;;; ebox-dsl-tests.el --- Ebox DSL tests -*- lexical-binding: t; -*-

(require 'ert)

(load-file (expand-file-name "../ebox.el" (file-name-directory (or load-file-name buffer-file-name))))

(defun ebox-dsl-test--plain (node)
  "Render NODE and strip text properties."
  (substring-no-properties (ebox-render node)))

(defun ebox-dsl-test--line-widths (node)
  "Return rendered pixel widths for NODE line by line."
  (mapcar #'ebox--string-pixel-width (ebox-string-lines (ebox-render node))))

(defun ebox-dsl-test--display-line-widths (node)
  "Return rendered display pixel widths for NODE line by line."
  (mapcar #'ebox--string-pixel-width (ebox-string-lines (ebox-render node))))

(defun ebox-dsl-test--tree-count (node predicate)
  "Count nodes below NODE for which PREDICATE returns non-nil."
  (if (or (stringp node) (not (listp node)))
      0
    (+ (if (funcall predicate node) 1 0)
       (cl-loop for child in (ebox-tree-node-children node)
                sum (ebox-dsl-test--tree-count child predicate)))))

(ert-deftest ebox-style-expands-ebox-aliases-to-canonical-longhands ()
  "Existing Ebox aliases should normalize to CSS-like longhand properties."
  (let ((style (ebox-style-compute
                (list :bgcolor "#ffffff"
                      :padding '(1 2)
                      :margin-left 3
                      :border "#333333"))))
    (should (equal (plist-get style :background-color) "#ffffff"))
    (should (= (plist-get style :padding-block-start) 1))
    (should (= (plist-get style :padding-inline-end) 2))
    (should (= (plist-get style :padding-block-end) 1))
    (should (= (plist-get style :padding-inline-start) 2))
    (should (= (plist-get style :margin-inline-start) 3))
    (should (equal (plist-get style :border-color) "#333333"))))

(ert-deftest ebox-style-classifies-incremental-effects ()
  "Style metadata should classify paint and layout effects."
  (should (eq (ebox-style-dirty-kind :background-color) 'paint))
  (should (eq (ebox-style-dirty-kind :border-color) 'paint))
  (should (eq (ebox-style-dirty-kind :padding-inline-start) 'geometry))
  (should (eq (ebox-style-dirty-kind :width) 'geometry))
  (should (eq (ebox-style-dirty-kind :outer) 'structure))
  (should (eq (ebox-style-dirty-kind :layout) 'structure))
  (should (eq (ebox-style-dirty-kind :display) 'structure)))

(ert-deftest ebox-style-projects-public-box-axes-to-internal-display ()
  "Computed outer/layout properties should project to one display pair."
  (let* ((style
          (ebox-style-compute-subject
           (ecss-subject-create :type "box")
           (ebox-style-compile-declarations
            '(:outer inline :layout flex))))
         (node (ebox-build '(box "A"))))
    (ebox-style-apply-computed node style)
    (should (equal (ebox--computed-display node) '(inline flex)))))

(ert-deftest ebox-style-strict-cache-does-not-hide-unknown-properties ()
  "Strict declaration validation should remain exact after an empty cache hit."
  (ebox-style-compile-declarations nil t)
  (should-error
   (ebox-style-compile-declarations '(:not-an-ebox-property 1) t)
   :type 'error))

(ert-deftest ebox-style-aliases-share-one-canonical-property-id ()
  "A concise alias should disappear before canonical declarations."
  (should
   (equal (ebox-style-compile-declarations '(:bgcolor "red") t)
          (ebox-style-compile-declarations '(:background-color "red") t))))

(ert-deftest ebox-style-rejects-canonical-and-alias-duplicates ()
  "One declaration source should not spell one property twice."
  (should-error
   (ebox-style-compile-declarations
    '(:bgcolor "red" :background-color "blue") t)
   :type 'error)
  (should-error
   (ebox-style-compile-declarations
    '(:background-color "red" :bgcolor "blue") t)
   :type 'error))

(ert-deftest ebox-style-property-registry-rejects-alias-collisions ()
  "An alias should never shadow another canonical property."
  (let ((ebox-style--property-table nil)
        (ebox-style--property-definitions
         '((:name :first :id ebox/first :aliases (:second))
           (:name :second :id ebox/second))))
    (should-error (ebox-style--ensure-property-table) :type 'error)))

(ert-deftest ebox-style-border-present-is-a-typed-shorthand-not-an-alias ()
  "The concise border boolean should expand to canonical width and style."
  (should
   (equal (ebox-style-compile-declarations '(:border-top-p t) t)
          '(ebox/border-top-width 1 ebox/border-top-style solid)))
  (should
   (equal (ebox-style-compile-declarations '(:border-top-p nil) t)
          '(ebox/border-top-width 0 ebox/border-top-style none)))
  (should (eq (ebox-style-canonical-name :border-top-p) :border-top-p)))

(ert-deftest ebox-style-exclusive-check-does-not-reexpand-ordinary-shorthands ()
  "Conflict validation should leave the declaration cache effective."
  (let ((calls 0)
        (original (symbol-function 'ebox-style--padding-shorthand)))
    (clrhash ebox-style--declaration-cache)
    (cl-letf (((symbol-function 'ebox-style--padding-shorthand)
               (lambda (value)
                 (cl-incf calls)
                 (funcall original value))))
      (ebox-style-compile-declarations '(:padding 1) t)
      (ebox-style-compile-declarations '(:padding 1) t))
    (should (= calls 1))))

(ert-deftest ebox-style-border-present-rejects-owned-longhand-conflicts ()
  "One source should not mix the boolean border shorthand with its outputs."
  (should-error
   (ebox-style-compile-declarations
    '(:border-top-p t :border-top-width 2) t)
   :type 'error)
  (should-error
   (ebox-style-compile-declarations
    '(:border-top-style dashed :border-top-p t) t)
   :type 'error)
  (should-error
   (ebox-style-compile-declarations
    '(:border-top-p t :border-top (2 dashed "red")) t)
   :type 'error)
  (should-error
   (ebox-style-compile-declarations
    '(:border-top-p t :border-width 2) t)
   :type 'error)
  (should-error
   (ebox-style-compile-declarations
    '(:border-style dashed :border-top-p t) t)
   :type 'error)
  (should-error
   (ebox-style-compile-declarations
    '(:border-bottom-p t :border (1 solid "red")) t)
   :type 'error))

(ert-deftest ebox-canonical-text-constructor-is-renderable-and-typed ()
  "A canonical TextNode should retain its kind, source, and string value."
  (let ((node (ebox-text-create :value "Hello" :source-handle 'source-text)))
    (should (ebox-text-node-p node))
    (should-not (ebox-box-node-p node))
    (should (eq (ebox-node-source-handle node) 'source-text))
    (should (string= (ebox-text-node-value node) "Hello"))
    (should (string= (ebox-dsl-test--plain node) "Hello"))))

(ert-deftest ebox-canonical-text-constructor-rejects-non-text-shapes ()
  "A canonical TextNode should have exactly one string payload."
  (should-error (ebox-text-create :value 7) :type 'error)
  (should-error (ebox-text-create :value "A" :content "B") :type 'error)
  (should-error (ebox-text-create :value "A" :children nil) :type 'error)
  (should-error (ebox-text-create :value "A" :color "red") :type 'error)
  (should-error
   (ebox-text-create :value "A" :value "B")
   :type 'error)
  (should-error
   (ebox-text-create :value "A" :source-handle 'a :source-handle 'b)
   :type 'error))

(ert-deftest ebox-canonical-normal-box-renders-inline-runs-and-blocks ()
  "Normal should retain typed children and honor inline/block boundaries."
  (let* ((text (ebox-text-create :value "A" :source-handle 'source-text))
         (second-text (ebox-text-create :value "B"))
         (inline
          (ebox-box-create
           :layout (ebox-normal-layout-create) :outer 'inline
           :width '(100)
           :children (list (ebox-text-create :value "A B"))))
         (block
          (ebox-box-create
           :layout (ebox-normal-layout-create)
           :children (list (ebox-text-create :value "C"))))
         (tail (ebox-text-create :value "D"))
         (layout (ebox-normal-layout-create))
         (box (ebox-box-create :layout layout
                               :children (list text second-text inline block tail)
                               :source-handle 'source-box
                               :width '(50) :overflow 'visible))
         (rendered (ebox-render box))
         (rendered-lines (ebox-string-lines rendered))
         (lines (mapcar (lambda (line)
                          (string-trim-right
                           (substring-no-properties line)))
                        rendered-lines)))
    (should (ebox-box-node-p box))
    (should-not (ebox-text-node-p box))
    (should (eq (ebox-node-source-handle box) 'source-box))
    (should (eq (ebox-layout-config-kind
                 (ebox-box-node-layout box))
                'normal))
    (should (equal (ebox-box-node-children box)
                   (list text second-text inline block tail)))
    (should (equal (ebox--computed-display text) '(inline flow)))
    (should (equal lines '("AB" "A B" "C" "D")))
    (should (>= (ebox--string-pixel-width (nth 1 rendered-lines)) 100))
    (let ((ebox-style-stylesheet (ecss-stylesheet-create)))
      (plist-put text :class "fixed-inline-text")
      (ebox-style-add-rule ".fixed-inline-text" (list :outer 'block))
      (should-error (ebox-render box) :type 'error))
    (cl-labels
        ((normal-lines
          (value &optional width)
          (mapcar #'substring-no-properties
                  (ebox-string-lines
                   (ebox-render
                    (apply #'ebox-box-create
                           :layout (ebox-normal-layout-create)
                           :children (list (ebox-text-create :value value))
                           (when width
                             (list :width (list width)
                                   :overflow 'visible))))))))
      (dolist (case '(("A\n\nB" ("A" "" "B"))
                      ("\nA" ("" "A"))
                      ("A\n" ("A" ""))
                      ("\n" ("" ""))))
        (should (equal (mapcar #'string-trim-right
                               (normal-lines (car case)))
                       (cadr case))))
      (should (equal (normal-lines "  A") '("  A")))
      (should (equal (normal-lines " ") '(" ")))
      (should
       (equal (mapcar #'string-trim-right
                      (normal-lines
                       "abcdef x" (* 5 (ebox--string-pixel-width "a"))))
              '("abcde" "f x")))
      (should
       (= (length
           (normal-lines
            (make-string 10 ?\s)
            (* 5 (ebox--string-pixel-width " "))))
          2))
      (should (= (length (normal-lines "word" 0)) 1))
      (should (= (length (normal-lines " " 0)) 1))
      (let* ((inline-zero
              (ebox-box-create
               :layout (ebox-normal-layout-create) :outer 'inline
               :width '(10)
               :children (list (ebox-text-create :value "I"))))
             (zero-parent
              (ebox-box-create
               :layout (ebox-normal-layout-create) :width '(0)
               :overflow 'visible :children (list inline-zero))))
        (should (= (ebox-string-height (ebox-render zero-parent)) 1))))))

(ert-deftest ebox-canonical-row-box-retains-and-renders-typed-children ()
  "A Row Box should retain one Box identity around all typed children."
  (let* ((left (ebox-text-create :value "A" :source-handle 'left))
         (right (ebox-text-create :value "B\nB\nB" :source-handle 'right))
         (box (ebox-box-create :layout (ebox-row-layout-create
                                        :item-gap 5 :cross-align 'center)
                               :children (list left right)
                               :source-handle 'row)))
    (should (ebox-box-node-p box))
    (should (eq (ebox-node-source-handle box) 'row))
    (should (eq (ebox-layout-config-kind (ebox-box-node-layout box)) 'row))
    (should (equal (ebox-layout-config-props (ebox-box-node-layout box))
                   '(:item-gap 5 :cross-align center)))
    (should (equal (ebox-box-node-children box) (list left right)))
    (should (eq (ebox-tree-node-children box)
                (ebox-box-node-children box)))
    (should (= (ebox-dsl-test--tree-count box (lambda (_node) t)) 3))
    (should (= (ebox-dsl-test--tree-count box #'ebox-node-kind) 3))
    (should-not (plist-member box :ebox-content-node))
    (should (equal (ebox--computed-display box) '(block row)))
    (let* ((rendered (ebox-render box))
           (lines (ebox-string-lines rendered))
           (middle (nth 1 lines)))
      (should-not (string-match-p "A" (substring-no-properties (car lines))))
      (should (string-match-p "A.*B" (substring-no-properties middle)))
      (should (= (ebox--string-pixel-width middle)
                 (+ (ebox--string-pixel-width "A") 5
                    (ebox--string-pixel-width "B")))))))

(ert-deftest ebox-canonical-column-box-retains-and-renders-typed-children ()
  "A Column Box should retain one Box identity around all typed children."
  (let* ((top (ebox-text-create :value "A"))
         (bottom (ebox-text-create :value "BBB"))
         (box (ebox-box-create :layout (ebox-column-layout-create
                                        :item-gap 1 :cross-align 'end)
                               :children (list top bottom))))
    (should (ebox-box-node-p box))
    (should (eq (ebox-layout-config-kind (ebox-box-node-layout box)) 'column))
    (should (equal (ebox-layout-config-props (ebox-box-node-layout box))
                   '(:item-gap 1 :cross-align end)))
    (should (equal (ebox-box-node-children box) (list top bottom)))
    (should (eq (ebox-tree-node-children box)
                (ebox-box-node-children box)))
    (should (= (ebox-dsl-test--tree-count box (lambda (_node) t)) 3))
    (should (= (ebox-dsl-test--tree-count box #'ebox-node-kind) 3))
    (should-not (plist-member box :ebox-content-node))
    (should (equal (ebox--computed-display box) '(block column)))
    (should (= (ebox-string-height (ebox-render box)) 3))
    (let ((lines (ebox-string-lines (ebox-render box))))
      (should (string-prefix-p " " (substring-no-properties (car lines))))
      (should (= (ebox--string-pixel-width (car lines))
                 (ebox--string-pixel-width (nth 2 lines)))))))

(ert-deftest ebox-canonical-simple-axis-config-validates-closed-schema ()
  "Row/Column configs should distinguish defaults from invalid explicit values."
  (dolist (constructor '(ebox-row-layout-create ebox-column-layout-create))
    (should (equal (ebox-layout-config-props (funcall constructor))
                   '(:item-gap 0 :cross-align stretch)))
    (dolist (plist '((:item-gap nil) (:item-gap -1)
                     (:cross-align nil) (:cross-align bogus)
                     (:gap 1) (:item-gap 1 :item-gap 2)))
      (should-error (apply constructor plist) :type 'error))))

(ert-deftest ebox-canonical-flex-box-uses-one-box-identity-and-child-list ()
  "A FlexConfig should select the Box algorithm without a Flex runtime node."
  (let* ((left (ebox-text-create :value "A"))
         (right (ebox-text-create :value "B"))
         (layout (ebox-flex-layout-create))
         (box (ebox-box-create :layout layout
                               :children (list left right)
                               :width '(120)))
         (rendered (ebox-render box)))
    (should
     (equal (ebox-layout-config-props layout)
            '(:flex-direction row :flex-wrap nowrap
              :justify-content flex-start :align-items stretch
              :align-content stretch :row-gap 0 :column-gap 0)))
    (should-not (plist-member (ebox-layout-config-props layout) :width))
    (should-not (plist-member (ebox-layout-config-props layout) :height))
    (should (ebox-box-node-p box))
    (should (eq (ebox-layout-config-kind (ebox-box-node-layout box)) 'flex))
    (should (eq (ebox-tree-node-children box)
                (ebox-box-node-children box)))
    (should (= (ebox-dsl-test--tree-count box (lambda (_node) t)) 3))
    (should (= (ebox-dsl-test--tree-count box #'ebox-node-kind) 3))
    (should
     (= (ebox-dsl-test--tree-count
         box (lambda (node) (eq (plist-get node :ebox-type) 'flex)))
        0))
    (should-not (plist-member box :ebox-content-node))
    (should (equal (ebox--computed-display box) '(block flex)))
    (should (string= (string-trim-right
                      (substring-no-properties rendered))
                     "AB"))
    (should (= (ebox--string-pixel-width rendered) 120))))

(ert-deftest ebox-canonical-flex-revalidates-the-typed-config-boundary ()
  "Mutated or extra FlexConfig properties should fail before rendering."
  (let ((invalid-direction (ebox-flex-layout-create))
        (extra-frame-prop (ebox-flex-layout-create))
        (cross-kind-props (ebox-flex-layout-create)))
    (setf (ebox-layout-config-props invalid-direction)
          '(:flex-direction bogus :flex-wrap nowrap
            :justify-content flex-start :align-items stretch
            :align-content stretch :row-gap 0 :column-gap 0))
    (setf (ebox-layout-config-props extra-frame-prop)
          (append (ebox-layout-config-props extra-frame-prop)
                  '(:width 999)))
    (setf (ebox-layout-config-kind cross-kind-props) 'row)
    (should-error
     (ebox-box-create :layout invalid-direction :children nil)
     :type 'error)
    (should-error
     (ebox-box-create :layout extra-frame-prop :children nil)
     :type 'error)
    (should-error
     (ebox-box-create :layout cross-kind-props :children nil)
     :type 'error)))

(ert-deftest ebox-canonical-box-detaches-validated-layout-config ()
  "Caller and accessor mutations should not alter a constructed Box."
  (let* ((source-layout (ebox-flex-layout-create))
         (box (ebox-box-create
               :layout source-layout
               :children (list (ebox-text-create :value "A")
                               (ebox-text-create :value "B"))))
         (exposed-layout (ebox-box-node-layout box)))
    (should-not (fboundp 'ebox-layout-config-validator))
    (setf (ebox-layout-config-props source-layout) '(:flex-direction bogus))
    (setf (ebox-layout-config-props exposed-layout) '(:width 999))
    (should (string= (string-trim-right
                      (substring-no-properties (ebox-render box)))
                     "AB"))
    (should (equal (ebox-layout-config-props (ebox-box-node-layout box))
                   ebox--flex-default-config-props))))

(ert-deftest ebox-flex-layout-create-normalizes-the-complete-config-schema ()
  "The typed Flex constructor should emit one canonical closed property set."
  (let ((layout
         (ebox-flex-layout-create
          :flex-direction 'column-reverse
          :flex-wrap 'wrap
          :justify-content 'space-between
          :align-items 'center
          :align-content 'end
          :row-gap '(2)
          :column-gap '(8))))
    (should
     (equal (ebox-layout-config-props layout)
            '(:flex-direction column-reverse :flex-wrap wrap
              :justify-content space-between :align-items center
              :align-content end :row-gap 2 :column-gap 8)))
    (should (ebox-flex-layout-config-props-p
             (ebox-layout-config-props layout)))
    (should (ebox-box-node-p
             (ebox-box-create :layout layout :children nil)))))

(ert-deftest ebox-flex-layout-create-validates-values-and-rejects-author-sugar ()
  "FlexConfig should accept its value domain and reject sugar or foreign props."
  (dolist (direction ebox--flex-direction-values)
    (should (ebox-flex-layout-create :flex-direction direction)))
  (dolist (wrap ebox--flex-wrap-values)
    (should (ebox-flex-layout-create :flex-wrap wrap)))
  (dolist (justify ebox--flex-justify-content-values)
    (should (ebox-flex-layout-create :justify-content justify)))
  (dolist (align ebox--flex-align-items-values)
    (should (ebox-flex-layout-create :align-items align)))
  (dolist (align ebox--flex-align-content-values)
    (should (ebox-flex-layout-create :align-content align)))
  (dolist (plist '((:flex-direction bogus)
                   (:flex-wrap reverse)
                   (:justify-content bogus)
                   (:align-items bogus)
                   (:align-content bogus)
                   (:row-gap -1)
                   (:column-gap (-1))
                   (:flex-flow (row wrap))
                   (:gap 1)
                   (:width 100)
                   (:flex-direction row :flex-direction column)))
    (should-error (apply #'ebox-flex-layout-create plist) :type 'error)))

(ert-deftest ebox-flex-config-validation-does-not-reparse-canonical-pixels ()
  "Boundary validation should preserve physical pixels under non-unit fonts."
  (cl-letf (((symbol-function 'ebox--space-pixel-width) (lambda () 8)))
    (let* ((layout (ebox-flex-layout-create :column-gap '(8)))
           (box (ebox-box-create :layout layout :children nil)))
      (should (= (plist-get (ebox-layout-config-props layout) :column-gap) 8))
      (should (= (plist-get
                  (ebox-layout-config-props (ebox-box-node-layout box))
                  :column-gap)
                 8)))))

(ert-deftest ebox-canonical-flex-projects-one-box-frame-constraint ()
  "Typed and legacy Flex should derive the same content size from BoxFrame."
  (dolist (sizing '(border-box content-box))
    (let* ((typed
            (ebox-box-create
             :layout (ebox-flex-layout-create)
             :children (list (ebox-text-create :value "A")
                             (ebox-text-create :value "B"))
             :width '(140) :padding '(0 (10)) :box-sizing sizing))
           (legacy
            (ebox-flex
             :width '(140) :padding '(0 (10)) :box-sizing sizing
             (ebox-text-create :value "A")
             (ebox-text-create :value "B")))
           (typed-rendered (ebox-render typed))
           (legacy-rendered (ebox-render legacy)))
      (should
       (string=
        (string-trim-right (substring-no-properties typed-rendered))
        (string-trim-right (substring-no-properties legacy-rendered))))
      (should (= (ebox--string-pixel-width typed-rendered)
                 (ebox--string-pixel-width legacy-rendered))))))

(ert-deftest ebox-canonical-grid-box-uses-one-box-identity-and-child-list ()
  "A GridConfig should select the Box algorithm without a Grid runtime node."
  (let* ((layout (ebox-grid-layout-create))
         (box (ebox-box-create
               :layout layout
               :children (list (ebox-text-create :value "A")
                               (ebox-text-create :value "B"))
               :width '(120)))
         (rendered (ebox-render box)))
    (should (equal (ebox-layout-config-props layout)
                   ebox--grid-default-config-props))
    (should-not (plist-member (ebox-layout-config-props layout) :width))
    (should-not (plist-member (ebox-layout-config-props layout) :height))
    (should (ebox-box-node-p box))
    (should (eq (ebox-layout-config-kind (ebox-box-node-layout box)) 'grid))
    (should (eq (ebox-tree-node-children box)
                (ebox-box-node-children box)))
    (should (= (ebox-dsl-test--tree-count box (lambda (_node) t)) 3))
    (should (= (ebox-dsl-test--tree-count box #'ebox-node-kind) 3))
    (should
     (= (ebox-dsl-test--tree-count
         box (lambda (node) (eq (plist-get node :ebox-type) 'grid)))
        0))
    (should-not (plist-member box :ebox-content-node))
    (should (equal (ebox--computed-display box) '(block grid)))
    (should (string=
             (replace-regexp-in-string
              "[[:space:]]" "" (substring-no-properties rendered))
             "AB"))
    (should (equal (mapcar #'ebox--string-pixel-width
                           (ebox-string-lines rendered))
                   '(120 120 120)))))

(ert-deftest ebox-canonical-grid-consumes-direct-child-placement ()
  "Grid placement should stay on child Boxes without grid-item wrappers."
  (let* ((later
          (ebox-box-create :layout (ebox-normal-layout-create)
                           :children (list (ebox-text-create :value "A"))
                           :grid-row 2))
         (earlier
          (ebox-box-create :layout (ebox-normal-layout-create)
                           :children (list (ebox-text-create :value "B"))
                           :grid-row 1))
         (box (ebox-box-create :layout (ebox-grid-layout-create)
                               :children (list later earlier)))
         (rendered (substring-no-properties (ebox-render box))))
    (should (string=
             (replace-regexp-in-string "[[:space:]]" "" rendered)
             "BA"))
    (should (= (ebox-dsl-test--tree-count box (lambda (_node) t)) 5))
    (should (= (ebox-dsl-test--tree-count box #'ebox-node-kind) 5))))

(ert-deftest ebox-canonical-participation-validates-the-final-parent-context ()
  "Participation should be legal only under its matching direct parent layout."
  (cl-labels
      ((child (&rest props)
         (apply #'ebox-box-create
                :layout (ebox-normal-layout-create)
                :children (list (ebox-text-create :value "A"))
                props))
       (parent (layout child)
         (ebox-box-create :layout layout :children (list child))))
    (should (stringp
             (ebox-render
              (parent (ebox-flex-layout-create) (child :flex-grow 1)))))
    (should (stringp
             (ebox-render
              (parent (ebox-grid-layout-create) (child :grid-row 1)))))
    (should-error
     (ebox-render (child :flex-grow 1)) :type 'error)
    (should-error
     (ebox-render
      (parent (ebox-normal-layout-create) (child :flex-grow 1)))
     :type 'error)
    (should-error
     (ebox-render
      (parent (ebox-flex-layout-create) (child :grid-row 1)))
     :type 'error)
    (should-error
     (ebox-render
      (parent (ebox-grid-layout-create) (child :flex-grow 1)))
     :type 'error)
    (let ((text (ebox-text-create :value "A")))
      (plist-put text :flex-grow 1)
      (should-error
       (ebox-render (parent (ebox-flex-layout-create) text)) :type 'error))
    ;; The final candidate is authoritative after ECSS projection too.
    (let ((ebox-style-stylesheet (ecss-stylesheet-create)))
      (ebox-style-add-rule "box" (list :flex-grow 1))
      (should-error
       (ebox-render
        (parent (ebox-normal-layout-create) (child)))
       :type 'error))
    ;; Detached Flex geometry retains its final parent during computed style.
    (let ((ebox-style-stylesheet (ecss-stylesheet-create))
          (detached (child)))
      (plist-put detached :class "detached-flex-item")
      (ebox-style-add-rule ".detached-flex-item" (list :flex-grow 1))
      (let ((ebox--render-root-parent-kind 'flex))
        (should (stringp (ebox-render detached))))
      ;; The dynamic context is exact and cannot authorize a later root.
      (should-error (ebox-render detached) :type 'error))
    (let ((ebox-style-stylesheet (ecss-stylesheet-create))
          (detached (child)))
      (plist-put detached :class "detached-flex-item")
      (ebox-style-add-rule ".detached-flex-item" (list :grid-row 1))
      (let ((ebox--render-root-parent-kind 'flex))
        (should-error (ebox-render detached) :type 'error)))
    ;; A real legacy adapter exempts only its two exact duplicate nodes.
    (let* ((illegal-grandchild (child :flex-grow 1))
           (nested (parent (ebox-normal-layout-create) illegal-grandchild))
           (adapter (ebox-flex-item nested :flex-grow 1 :padding 1)))
      ;; The obsolete mutable depth field must have no authority.
      (plist-put adapter :ebox-flex-item-adapter-depth 99)
      (should-error
       (ebox-render (ebox-flex :width '(100) adapter))
       :type 'error))
    ;; Provenance binds the exact constructor-time source identities.
    (let* ((adapter (ebox-flex-item (ebox-create :content "original")))
           (replacement (ebox-create :content "replacement")))
      (plist-put replacement :flex-grow 1)
      (plist-put adapter :node replacement)
      (should-error
       (ebox-render (ebox-column adapter)) :type 'error))
    (let* ((adapter (ebox-flex-item (ebox-create :content "original")))
           (source (plist-get adapter :node))
           (replacement (ebox-create :content "replacement")))
      (plist-put replacement :flex-grow 1)
      (setq adapter
            (ebox-tree-copy-with-direct-child-replacements
             adapter (list (cons source replacement))))
      (should-error
       (ebox-render (ebox-column adapter)) :type 'error))
    (let* ((adapter
            (ebox-flex-item (ebox-create :content "original") :padding 1))
           (wrapper (plist-get adapter :node))
           (replacement (ebox-create :content "replacement")))
      (plist-put replacement :flex-grow 1)
      (plist-put wrapper :ebox-content-node replacement)
      (should-error
       (ebox-render (ebox-column adapter)) :type 'error))
    ;; Internal layout and parent participation are orthogonal facts.
    (should
     (stringp
      (ebox-render
       (parent
        (ebox-grid-layout-create)
        (ebox-box-create
         :layout (ebox-flex-layout-create)
         :children (list (ebox-text-create :value "A"))
         :grid-row 1)))))))

(ert-deftest ebox-canonical-grid-revalidates-the-typed-config-boundary ()
  "GridConfig must reject frame properties and cross-kind property sets."
  (let ((extra-frame-prop (ebox-grid-layout-create))
        (cross-kind-props (ebox-grid-layout-create)))
    (setf (ebox-layout-config-props extra-frame-prop)
          (append (ebox-layout-config-props extra-frame-prop)
                  '(:width 999)))
    (setf (ebox-layout-config-kind cross-kind-props) 'column)
    (should-error
     (ebox-box-create :layout extra-frame-prop :children nil)
     :type 'error)
    (should-error
     (ebox-box-create :layout cross-kind-props :children nil)
     :type 'error)))

(ert-deftest ebox-canonical-grid-projects-one-box-frame-constraint ()
  "Typed and legacy Grid should derive the same content size from BoxFrame."
  (dolist (sizing '(border-box content-box))
    (let* ((typed
            (ebox-box-create
             :layout (ebox-grid-layout-create)
             :children (list (ebox-text-create :value "A")
                             (ebox-text-create :value "B"))
             :width '(140) :padding '(0 (10)) :box-sizing sizing))
           (legacy
            (ebox-grid
             :width '(140) :padding '(0 (10)) :box-sizing sizing
             (ebox-text-create :value "A")
             (ebox-text-create :value "B")))
           (typed-rendered (ebox-render typed))
           (legacy-rendered (ebox-render legacy)))
      (should (string= (substring-no-properties typed-rendered)
                       (substring-no-properties legacy-rendered)))
      (should
       (equal (mapcar #'ebox--string-pixel-width
                      (ebox-string-lines typed-rendered))
              (mapcar #'ebox--string-pixel-width
                      (ebox-string-lines legacy-rendered)))))))

(ert-deftest ebox-grid-layout-create-normalizes-the-complete-config-schema ()
  "The typed Grid constructor should emit one canonical closed property set."
  (let* ((layout
          (ebox-grid-layout-create
           :grid-template-columns '((20) 1fr)
           :grid-template-rows '(1 auto)
           :grid-auto-columns '((30))
           :grid-auto-rows '(2)
           :grid-auto-flow 'column
           :row-gap '(2) :column-gap '(8)
           :justify-items 'center :align-items 'end
           :justify-content 'space-between :align-content 'center))
         (props (ebox-layout-config-props layout)))
    (should (equal (plist-get props :grid-template-columns)
                   '((:kind fixed :size 20) (:kind fr :factor 1))))
    (should (equal (plist-get props :grid-template-rows)
                   '((:kind fixed :size 1) (:kind auto :factor 0))))
    (should (equal (plist-get props :grid-auto-columns)
                   '(:kind fixed :size 30)))
    (should (equal (plist-get props :grid-auto-rows)
                   '(:kind fixed :size 2)))
    (should (= (plist-get props :row-gap) 2))
    (should (= (plist-get props :column-gap) 8))
    (should (ebox-grid-layout-config-props-p props))
    (should (ebox-box-node-p
             (ebox-box-create :layout layout :children nil)))))

(ert-deftest ebox-grid-layout-create-validates-values-and-rejects-author-sugar ()
  "GridConfig should accept its value domain and reject sugar or foreign props."
  (dolist (flow '(row column))
    (should (ebox-grid-layout-create :grid-auto-flow flow)))
  (dolist (value ebox--grid-justify-items-values)
    (should (ebox-grid-layout-create :justify-items value)))
  (dolist (value ebox--grid-align-items-values)
    (should (ebox-grid-layout-create :align-items value)))
  (dolist (value ebox--grid-content-alignment-values)
    (should (ebox-grid-layout-create :justify-content value))
    (should (ebox-grid-layout-create :align-content value)))
  (dolist (plist '((:grid-auto-flow diagonal)
                   (:grid-template-columns (bogus))
                   (:grid-template-rows (bogus))
                   (:grid-template-columns (0fr))
                   (:grid-template-columns (0.0fr))
                   (:grid-template-columns ((fr 0)))
                   (:grid-template-columns ((minmax (fr 1) auto)))
                   (:grid-template-columns
                    ((minmax (minmax (10) (20)) auto)))
                   (:grid-auto-columns ((10) (20)))
                   (:row-gap -1)
                   (:column-gap (-1))
                   (:gap 1)
                   (:grid-row-gap 1)
                   (:width 100)
                   (:align-items bogus)
                   (:grid-auto-flow row :grid-auto-flow column)))
    (should-error (apply #'ebox-grid-layout-create plist) :type 'error)))

(ert-deftest ebox-grid-config-validation-does-not-reparse-canonical-pixels ()
  "Grid boundary validation should preserve physical pixels under GUI fonts."
  (cl-letf (((symbol-function 'ebox--space-pixel-width) (lambda () 8)))
    (let* ((layout
            (ebox-grid-layout-create
             :grid-template-columns '((20)) :column-gap '(8)))
           (box (ebox-box-create :layout layout :children nil))
           (props (ebox-layout-config-props (ebox-box-node-layout box))))
      (should (= (plist-get props :column-gap) 8))
      (should (= (plist-get (car (plist-get props :grid-template-columns))
                            :size)
                 20)))))

(ert-deftest ebox-grid-config-boundary-rejects-forged-minmax-roles ()
  "Trusted Grid validation should enforce minmax roles after mutation."
  (let ((fr-minimum (ebox-grid-layout-create))
        (nested-minimum (ebox-grid-layout-create)))
    (setf (ebox-layout-config-props fr-minimum)
          (plist-put (ebox-layout-config-props fr-minimum)
                     :grid-template-columns
                     '((:kind minmax
                        :min (:kind fr :factor 1)
                        :max (:kind auto :factor 0)))))
    (setf (ebox-layout-config-props nested-minimum)
          (plist-put (ebox-layout-config-props nested-minimum)
                     :grid-template-columns
                     '((:kind minmax
                        :min (:kind minmax
                              :min (:kind fixed :size 1)
                              :max (:kind fixed :size 2))
                        :max (:kind auto :factor 0)))))
    (should-error
     (ebox-box-create :layout fr-minimum :children nil) :type 'error)
    (should-error
     (ebox-box-create :layout nested-minimum :children nil) :type 'error)))

(ert-deftest ebox-canonical-flex-consumes-direct-child-participation ()
  "Flex participation should stay on child Boxes without item wrappers."
  (let* ((left-text (ebox-text-create :value "A"))
         (right-text (ebox-text-create :value "B"))
         (left (ebox-box-create :layout (ebox-normal-layout-create)
                                :children (list left-text)
                                :order 2))
         (right (ebox-box-create :layout (ebox-normal-layout-create)
                                 :children (list right-text)
                                 :order 1))
         (box (ebox-box-create :layout (ebox-flex-layout-create)
                               :children (list left right)))
         (rendered (substring-no-properties (ebox-render box))))
    (should (string= (string-trim-right rendered) "BA"))
    (should (= (ebox-dsl-test--tree-count box (lambda (_node) t)) 5))
    (should (= (ebox-dsl-test--tree-count box #'ebox-node-kind) 5))
    (should
     (= (ebox-dsl-test--tree-count
         box (lambda (node) (eq (plist-get node :ebox-type) 'flex-item)))
        0))))

(ert-deftest ebox-canonical-row-and-column-never-collapse-single-child-boxes ()
  "A one-child Row or Column should preserve its canonical Box boundary."
  (let* ((child (ebox-text-create :value "A"))
         (row (ebox-box-create :layout (ebox-row-layout-create)
                               :children (list child)))
         (column (ebox-box-create :layout (ebox-column-layout-create)
                                  :children (list child))))
    (should (ebox-box-node-p row))
    (should (ebox-box-node-p column))
    (should-not (eq row child))
    (should-not (eq column child))
    (should (equal (ebox-tree-node-children row) (list child)))
    (should (equal (ebox-tree-node-children column) (list child)))
    (should (= (ebox-dsl-test--tree-count row (lambda (_node) t)) 2))
    (should (= (ebox-dsl-test--tree-count column (lambda (_node) t)) 2))
    (should (string= (ebox-dsl-test--plain row) "A"))
    (should (string= (ebox-dsl-test--plain column) "A"))))

(ert-deftest ebox-canonical-empty-layout-boxes-have-no-runtime-child ()
  "Empty layout Boxes should not synthesize layout identities."
  (dolist (layout (list (ebox-row-layout-create)
                        (ebox-column-layout-create)
                        (ebox-flex-layout-create)
                        (ebox-grid-layout-create)))
    (let ((box (ebox-box-create :layout layout :children nil)))
      (should (ebox-box-node-p box))
      (should-not (ebox-tree-node-children box))
      (should (= (ebox-dsl-test--tree-count box (lambda (_node) t)) 1))
      (should (= (ebox-dsl-test--tree-count box #'ebox-node-kind) 1))
      (should (string= (ebox-dsl-test--plain box) "")))))

(ert-deftest ebox-canonical-box-copy-keeps-one-authoritative-child-list ()
  "A copied Box should expose exactly its copied runtime children."
  (let* ((left (ebox-text-create :value "A"))
         (right (ebox-text-create :value "B"))
         (source (ebox-box-create :layout (ebox-row-layout-create)
                                  :children (list left right)))
         (copy (ebox-tree-copy-node-structure source))
         (copied-children (ebox-tree-node-children copy)))
    (should (eq copied-children (ebox-box-node-children copy)))
    (should-not (eq copied-children (ebox-box-node-children source)))
    (should-not (eq (car copied-children) left))
    (should-not (eq (cadr copied-children) right))
    (should (= (ebox-dsl-test--tree-count copy (lambda (_node) t)) 3))
    (should (= (ebox-dsl-test--tree-count copy #'ebox-node-kind) 3))))

(ert-deftest ebox-canonical-box-rejects-paint-only-properties ()
  "Canonical Box geometry should not duplicate paint-only state."
  (should-error
   (ebox-box-create :layout (ebox-normal-layout-create)
                    :bgcolor "red")
   :type 'error))

(ert-deftest ebox-canonical-box-requires-unique-reserved-fields ()
  "Typed Box reserved fields should never be missing or duplicated."
  (let ((normal (ebox-normal-layout-create)))
    (should-error (ebox-box-create :children nil) :type 'error)
    (should-error
     (ebox-box-create :layout normal :layout normal :children nil)
     :type 'error)
    (should-error
     (ebox-box-create :layout normal :children nil :children nil)
     :type 'error)
    (should-error
     (ebox-box-create :layout normal :outer nil :children nil)
     :type 'error)))

(ert-deftest ebox-build-normalizes-text-author-forms ()
  "The Ebox DSL should normalize explicit and bare Text forms."
  (let ((text (ebox-build '(text "A")))
        (bare (ebox-build "B")))
    (should (ebox-text-node-p text))
    (should (ebox-text-node-p bare))
    (should (string= (ebox-dsl-test--plain text) "A"))
    (should (string= (ebox-dsl-test--plain bare) "B"))))

(ert-deftest ebox-build-text-requires-one-string-payload ()
  "The Ebox Text form should reject empty, multiple, and nested payloads."
  (should-error (ebox-build '(text)) :type 'error)
  (should-error (ebox-build '(text "A" "B")) :type 'error)
  (should-error (ebox-build '(text (text "A"))) :type 'error)
  (should-error (ebox-build '(text :color "red" "A")) :type 'error)
  (should-error (ebox-build '(text :wrap-mode garbage "A")) :type 'error))

(ert-deftest ebox-dsl-module-preserves-public-build-syntax ()
  "Extracted DSL compiler should preserve existing ebox-build syntax."
  (let ((node (ebox-build
               '(column :padding 1 :bgcolor "linen"
                 (row
                  (box :content "A" :width (40))
                  (box :content "B" :width (40)))))))
    (should (eq (plist-get node :ebox-type) 'box))
    (should (string-match-p "A" (ebox-render node)))
    (should (string-match-p "B" (ebox-render node)))))

(ert-deftest ebox-build-creates-box-from-keyword-plist ()
  "A `(box ...)' form should compile to a normal Ebox box node."
  (let ((node (ebox-build '(box :content "Hello" :width (120) :border t))))
    (should (eq (plist-get node :ebox-type) 'box))
    (should (string-match-p "Hello" (ebox-dsl-test--plain node)))))

(ert-deftest ebox-build-uses-string-child-as-box-content ()
  "A simple string child should be shorthand for box content."
  (let ((node (ebox-build '(box :width (120) "Hello"))))
    (should (eq (plist-get node :ebox-type) 'box))
    (should (string-match-p "Hello" (ebox-dsl-test--plain node)))))

(ert-deftest ebox-build-resolves-viewport-width-from-dynamic-binding ()
  "The DSL should allow box widths to follow the current render viewport."
  (let* ((ebox-viewport-width 320)
         (node (ebox-build
                '(box :content "Viewport"
                  :width (viewport)
                  :box-sizing border-box
                  :border t))))
    (should (= (car (ebox-dsl-test--line-widths node)) 320))))

(ert-deftest ebox-build-resolves-viewport-height-from-dynamic-binding ()
  "The DSL should allow box heights to follow the current render viewport."
  (let* ((ebox-viewport-height 3)
         (node (ebox-build
                '(box :content "One\nTwo\nThree\nFour"
                  :height (viewport-height)
                  :overflow scroll))))
    (should (= (length (ebox-string-lines (ebox-render node))) 3))))

(ert-deftest ebox-build-resolves-viewport-height-arithmetic-expression ()
  "The DSL should allow viewport-relative height expressions."
  (let* ((ebox-viewport-height 6)
         (node (ebox-build
                '(box :content "One\nTwo\nThree\nFour"
                  :height (- (viewport-height) 2)
                  :overflow scroll))))
    (should (= (length (ebox-string-lines (ebox-render node))) 4))))

(ert-deftest ebox-build-unquotes-static-list-property-values ()
  "The DSL should accept quoted list values used by `etaf-view' forms."
  (let* ((node (ebox-build
                '(grid :width '(120)
                   :grid-template-columns '((40) 1fr)
                   :gap '(0 (4))
                   (box :content "A")
                   (box :content "B"))))
         (props (plist-get node :raw-props))
         (line (car (ebox-string-lines (ebox-render node)))))
    (should (equal (plist-get props :width) '(120)))
    (should (equal (plist-get props :grid-template-columns)
                   '((40) 1fr)))
    (should (= (ebox--string-pixel-width line) 120))))

(ert-deftest ebox-build-composes-fixed-viewport-shell-around-scrollbox ()
  "A fixed viewport shell can reserve chrome while an inner box scrolls."
  (let* ((ebox-viewport-height 6)
         (node (ebox-build
                '(column :height (viewport-height)
                  (box :content "top" :height 1)
                  (box :id "root" :height (- (viewport-height) 2)
                   :overflow scroll
                   (column
                    (box :content "A" :height 1)
                    (box :content "B" :height 1)
                    (box :content "C" :height 1)
                    (box :content "D" :height 1)
                    (box :content "E" :height 1)))
                  (box :content "bottom" :height 1)))))
    (should (= (length (ebox-string-lines (ebox-render node))) 6))))

(ert-deftest ebox-build-composes-row-and-column-layouts ()
  "Row and column forms should compose existing lazy layout nodes."
  (let* ((node (ebox-build
                '(column
                  (box :content "Header" :width (180))
                  (row
                   (box :content "Left" :width (80))
                   (spacer :width (20))
                   (box :content "Right" :width (80))))))
         (plain (ebox-dsl-test--plain node)))
    (should (eq (plist-get node :ebox-type) 'stack))
    (should (string-match-p "Header" plain))
    (should (string-match-p "Left.*Right" plain))
    (should (= (length (ebox-region-ids node)) 4))))

(ert-deftest ebox-build-wraps-child-layout-with-box-properties ()
  "A node with child layout may still apply box properties to the wrapper."
  (let* ((node (ebox-build
                '(box :width (240) :box-sizing border-box
                  :padding (1 20) :border t :bgcolor "#222222"
                  (row
                   (box :content "A" :width (80))
                   (box :content "B" :width (80))))))
         (plain (ebox-dsl-test--plain node)))
    (should (eq (plist-get node :ebox-type) 'box))
    (should (equal (ebox-get node :bgcolor) "#222222"))
    (should (string-match-p "A.*B" plain))
    (dolist (width (ebox-dsl-test--line-widths node))
      (should (= width 240)))))

(ert-deftest ebox-build-box-wrapper-preserves-preformatted-child-layout ()
  "A box wrapping child layout should not rewrap rendered children."
  (cl-letf (((symbol-function 'require)
             (lambda (feature &optional _filename _noerror)
               (when (eq feature 'ekp) t)))
            ((symbol-function 'ekp-pixel-justify)
             (lambda (text _width)
               (if (string-match-p "\n" text)
                   "REWRAPPED"
                 text))))
    (let* ((node (ebox-build
                  '(box :width (220) :box-sizing border-box
                    (row
                     (box :content "Left" :width (80) :height 2)
                     (box :content "Right" :width (80) :height 2)))))
           (plain (ebox-dsl-test--plain node)))
      (should-not (string-match-p "REWRAPPED" plain))
      (should (string-match-p "Left.*Right" plain))
      (dolist (width (ebox-dsl-test--line-widths node))
        (should (= width 220))))))

(ert-deftest ebox-build-row-wrapper-preserves-preformatted-layout ()
  "Row box properties should not rewrap the rendered child layout."
  (cl-letf (((symbol-function 'require)
             (lambda (feature &optional _filename _noerror)
               (when (eq feature 'ekp) t)))
            ((symbol-function 'ekp-pixel-justify)
             (lambda (text _width)
               (if (string-match-p "\n" text)
                   "REWRAPPED"
                 text))))
    (let* ((node (ebox-build
                  '(row :width (220) :box-sizing border-box
                    (box :content "Left" :width (80) :height 2)
                    (box :content "Right" :width (80) :height 2))))
           (plain (ebox-dsl-test--plain node)))
      (should-not (string-match-p "REWRAPPED" plain))
      (should (string-match-p "Left.*Right" plain))
      (dolist (width (ebox-dsl-test--line-widths node))
        (should (= width 220))))))

(ert-deftest ebox-build-column-wrapper-preserves-preformatted-layout ()
  "Column box properties should not rewrap the rendered child layout."
  (cl-letf (((symbol-function 'require)
             (lambda (feature &optional _filename _noerror)
               (when (eq feature 'ekp) t)))
            ((symbol-function 'ekp-pixel-justify)
             (lambda (text _width)
               (if (string-match-p "\n" text)
                   "REWRAPPED"
                 text))))
    (let* ((node (ebox-build
                  '(column :width (180) :box-sizing border-box
                    (box :content "Top" :width (120))
                    (box :content "Bottom" :width (120)))))
           (plain (ebox-dsl-test--plain node)))
      (should-not (string-match-p "REWRAPPED" plain))
      (should (string-match-p "Top" plain))
      (should (string-match-p "Bottom" plain))
      (dolist (width (ebox-dsl-test--line-widths node))
        (should (= width 180))))))

(ert-deftest ebox-build-padded-column-wrapper-stays-inside-viewport ()
  "A padded layout wrapper should not let preformatted children overflow."
  (let* ((ebox-viewport-width 320)
         (node (ebox-build
                '(column :padding 1
                  (box :content "Child width follows the viewport"
                       :wrap-mode word))))
         (widths (ebox-dsl-test--display-line-widths node)))
    (should (cl-every (lambda (width)
                        (<= width ebox-viewport-width))
                      widths))))

(ert-deftest ebox-build-wrapper-explicit-width-bounds-child-layout-viewport ()
  "A wrapper's explicit width should be the containing block for child layouts."
  (let* ((ebox-viewport-width 360)
         (node (ebox-build
                '(column :width (180)
                  (box :content "alpha beta gamma delta epsilon zeta eta theta"
                       :wrap-mode word))))
         (widths (ebox-dsl-test--line-widths node)))
    (dolist (width widths)
      (should (<= width 180)))))

(ert-deftest ebox-build-column-contains-auto-row-children ()
  "A column wrapper must not let an auto-width row child duplicate its viewport."
  (let* ((node (ebox-build
                '(column :width (120)
                  (row
                   (box :content "Left" :border t)
                   (box :content "Right" :border t))
                  (box :content "Body" :border t))))
         (widths (ebox-dsl-test--line-widths node)))
    (should (cl-every (lambda (width) (<= width 120)) widths))))

(ert-deftest ebox-row-keeps-explicit-viewport-widths-intrinsic-context ()
  "Row intrinsic sizing must not change explicit viewport-sized children."
  (let* ((ebox-viewport-width 120)
         (node (ebox-row
                (ebox-create :content "Left" :width 'viewport)
                (ebox-create :content "Right" :width 'stretch)))
         (widths (ebox-dsl-test--line-widths node)))
    (should (equal widths '(240)))))

(ert-deftest ebox-row-keeps-composite-column-intrinsic-width ()
  "A composite column child must not consume the row viewport as auto width."
  (let* ((ebox-viewport-width 120)
         (node (ebox-row
                (ebox-column
                 (ebox-create :content "Top")
                 (ebox-create :content "Bottom"))
                (ebox-create :content "Tail")))
         (widths (ebox-dsl-test--line-widths node)))
    (should (cl-every (lambda (width) (<= width 120)) widths))))

(ert-deftest ebox-build-lazy-column-contains-auto-row-children ()
  "Lazy column windows must apply the same intrinsic row sizing rule."
  (let* ((ebox-viewport-width 120)
         (ebox-viewport-height 4)
         (node (ebox-build
                '(box :width (viewport)
                  :height (viewport-height)
                  :overflow scroll
                  (column
                   (row
                    (box :content "Left" :border t)
                    (box :content "Right" :border t))
                   (box :content "Body" :border t)))))
         (widths (ebox-dsl-test--line-widths node)))
    (should (cl-every (lambda (width) (<= width 120)) widths))))

(ert-deftest ebox-build-wrapper-viewport-width-bounds-child-layout-viewport ()
  "A wrapper's `(viewport)' width should pass its content box to child layouts."
  (let ((cases
         '((box :width (viewport)
            :padding-inline (20)
            :border-left (10)
            :border-right (10)
            (box :content "alpha beta gamma delta epsilon zeta eta theta"
                 :wrap-mode word))
           (column :width (viewport)
            :padding-inline (20)
            :border-left (10)
            :border-right (10)
            (box :content "alpha beta gamma delta epsilon zeta eta theta"
                 :wrap-mode word))
           (row :width (viewport)
            :padding-inline (20)
            :border-left (10)
            :border-right (10)
            (box :content "alpha beta gamma delta epsilon zeta eta theta"
                 :wrap-mode word)
            (spacer :width (0) :height 1)))))
    (dolist (dsl cases)
      (let* ((ebox-viewport-width 240)
             (node (ebox-build dsl))
             (widths (ebox-dsl-test--line-widths node)))
        (dolist (width widths)
          (should (<= width ebox-viewport-width)))))))

(ert-deftest ebox-build-lazy-scroll-prefix-bounds-wrapper-child-viewport ()
  "Lazy scroll prefix rendering should preserve wrapper content viewport."
  (let* ((ebox-viewport-width 320)
         (ebox-viewport-height 5)
         (node (ebox-build
                '(box :id "root"
                  :width (viewport)
                  :height (- (viewport-height) 1)
                  :box-sizing border-box
                  :overflow scroll
                  (column :width (viewport)
                   :box-sizing border-box
                   :padding (1 (18))
                   (box :content "One"
                        :width (viewport)
                        :box-sizing border-box
                        :border t)
                   (box :content "Two"
                        :width (viewport)
                        :box-sizing border-box
                        :border t)
                   (box :content "Three"
                        :width (viewport)
                        :box-sizing border-box
                        :border t)
                   (box :content "Four"
                        :width (viewport)
                        :box-sizing border-box
                        :border t)))))
         (widths (ebox-dsl-test--line-widths node)))
    (dolist (width widths)
      (should (<= width ebox-viewport-width)))))

(ert-deftest ebox-build-tags-map-to-css-like-display ()
  "DSL container tags should expose CSS-like outer/inner display values."
  (let ((box-node (ebox-build '(box :content "A")))
        (row-node (ebox-build '(row (box :content "A") (box :content "B"))))
        (column-node (ebox-build
                      '(column (box :content "A") (box :content "B"))))
        (flex-node (ebox-build '(flex (box :content "A") (box :content "B")))))
    (should (equal (ebox--computed-display box-node) '(block flow)))
    (should (equal (ebox--computed-display row-node) '(block row)))
    (should (equal (ebox--computed-display column-node) '(block column)))
    (should (equal (ebox--computed-display flex-node) '(block flex)))))

(ert-deftest ebox-build-box-uses-orthogonal-outer-and-layout-axes ()
  "Canonical Box DSL should select outer participation and child layout."
  (let ((normal (ebox-build '(box :outer inline :layout normal "A")))
        (row (ebox-build
              '(box :outer inline :layout row
                (box "A")
                (box "B"))))
        (column (ebox-build
                 '(box :outer block :layout column
                   (box "A")
                   (box "B")))))
    (should (equal (ebox--computed-display normal) '(inline flow)))
    (should (equal (ebox--computed-display row) '(inline row)))
    (should (equal (ebox--computed-display column) '(block column)))
    (should (string= (ebox-dsl-test--plain row) "AB"))
    (should (string= (ebox-dsl-test--plain column) "A\nB"))))

(ert-deftest ebox-build-box-rejects-invalid-axis-values ()
  "Canonical Box DSL should reject unknown outer and layout values."
  (should-error (ebox-build '(box :outer floating "A")) :type 'error)
  (should-error (ebox-build '(box :layout masonry "A")) :type 'error))

(ert-deftest ebox-build-box-layout-consumes-direct-flex-item-properties ()
  "Canonical Flex Box should consume participation props from child Boxes."
  (let* ((node (ebox-build
                '(box :layout flex :width (300)
                  (box :flex-grow 1 :flex-basis (80) "A")
                  (box :flex-grow 2 :flex-basis (80) "B"))))
         (children (plist-get node :children)))
    (should (equal (ebox--computed-display node) '(block flex)))
    (should (= (plist-get (car children) :flex-grow) 1))
    (should (= (plist-get (cadr children) :flex-grow) 2))
    (should (string-match-p "A" (ebox-dsl-test--plain node)))
    (should (string-match-p "B" (ebox-dsl-test--plain node)))))

(ert-deftest ebox-build-box-layout-consumes-direct-grid-item-properties ()
  "Canonical Grid Box should consume placement props from child Boxes."
  (let* ((node (ebox-build
                '(box :layout grid :grid-template-columns ((20) (20))
                  (box :grid-column (1 :span 2) "Header"))))
         (child (car (plist-get node :children))))
    (should (equal (ebox--computed-display node) '(block grid)))
    (should (equal (plist-get child :grid-column) '(1 :span 2)))
    (should (string-match-p "Header" (ebox-dsl-test--plain node)))))

(ert-deftest ebox-build-wrapper-child-layout-rerenders-on-runtime-viewport-change ()
  "A DSL wrapper box should rerender child layout content on viewport resize."
  (let ((node (let ((ebox-viewport-width 96))
                (ebox-build
                 '(column :padding 1 :bgcolor "linen"
                   (box :content "This child text should wrap again when the preview becomes narrow."
                        :wrap-mode word)))))
        buffer)
    (unwind-protect
        (progn
          (setq buffer
                (let ((ebox-viewport-width 96))
                  (ebox-render-to-buffer
                   (generate-new-buffer-name " *ebox-dsl-test*")
                   node)))
          (let ((wide-text (with-current-buffer buffer
                             (buffer-substring-no-properties
                              (point-min) (point-max))))
                (wide-height (with-current-buffer buffer
                               (count-lines (point-min) (point-max)))))
            (ebox-rerender-buffer-with-context buffer 36)
            (let ((narrow-text (with-current-buffer buffer
                                 (buffer-substring-no-properties
                                  (point-min) (point-max))))
                  (narrow-height (with-current-buffer buffer
                                   (count-lines (point-min) (point-max)))))
              (should-not (string= wide-text narrow-text))
              (should (> narrow-height wide-height)))))
      (when (and buffer (buffer-live-p buffer))
        (kill-buffer buffer)))))

(ert-deftest ebox-build-item-is-flex-participation-sugar ()
  "DSL item should attach flex participation to its child semantics."
  (let* ((node (ebox-build
                '(flex :width (300)
                  (item :flex 1 (box :content "A"))
                  (box :content "B" :flex 1))))
         (rendered (let ((ebox-viewport-width 300))
                     (ebox-render node))))
    (should (string-match-p "A" (substring-no-properties rendered)))
    (should (string-match-p "B" (substring-no-properties rendered)))))

(ert-deftest ebox-build-keeps-pre-render-region-ids-available ()
  "The DSL should not break the pre-render region-id workflow."
  (let* ((node (ebox-build
                '(row
                  (box :content "One" :width (80))
                  (box :content "Two" :width (80)))))
         (ids (ebox-region-ids node)))
    (should (= (length ids) 2))
    (should (cl-every #'identity ids))))

(ert-deftest ebox-build-wrapper-region-ids-include-child-layout ()
  "A wrapper box should keep both its own region id and child layout ids."
  (let* ((node (ebox-build
                '(column :padding 1
                  (box :content "One")
                  (box :content "Two"))))
         (ids (ebox-region-ids node)))
    (should (= (length ids) 3))
    (should (cl-every #'identity ids))))

(ert-deftest ebox-build-rejects-invalid-dsl ()
  "Bad forms should fail loudly instead of producing surprising nodes."
  (should-error (ebox-build '(unknown :content "Nope")) :type 'error)
  (should-error (ebox-build '(box :content)) :type 'error)
  (should-error (ebox-build '(spacer :width (20) (box :content "bad"))) :type 'error))

(provide 'ebox-dsl-tests)
;;; ebox-dsl-tests.el ends here