@flighthq/layout 0.3.0-next.1728.26853f6

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createLayoutState, enableLayoutGuards, explainLayoutResolution, registerAnchorLayoutResolver, registerFlexLayoutResolver, registerGridLayoutResolver, registerLayoutResolver, resolveLayoutTree, } from './contract';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,uBAAuB,EACvB,4BAA4B,EAC5B,0BAA0B,EAC1B,0BAA0B,EAC1B,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createLayoutState, enableLayoutGuards, explainLayoutResolution, registerAnchorLayoutResolver, registerFlexLayoutResolver, registerGridLayoutResolver, registerLayoutResolver, resolveLayoutTree, } from './contract';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,uBAAuB,EACvB,4BAA4B,EAC5B,0BAA0B,EAC1B,0BAA0B,EAC1B,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/layoutState.d.ts

@@ -0,0 +1,4 @@
+import type { LayoutResolver, LayoutState } from '@flighthq/types/contract';
+export declare function createLayoutState(): LayoutState;
+export declare function registerLayoutResolver(state: Readonly<LayoutState>, kind: string, resolver: LayoutResolver | null): void;
+//# sourceMappingURL=layoutState.d.ts.map

package/dist/layoutState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layoutState.d.ts","sourceRoot":"","sources":["../src/layoutState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAI5E,wBAAgB,iBAAiB,IAAI,WAAW,CAW/C;AAID,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,QAAQ,CAAC,WAAW,CAAC,EAC5B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,cAAc,GAAG,IAAI,GAC9B,IAAI,CAGN"}

package/dist/layoutState.js

@@ -0,0 +1,23 @@
+// Allocates the operation state and its open, last-write-wins resolver registry. Built-in resolvers are
+// opt-in registrations, so creating the core state never links anchor, flex, or grid code.
+export function createLayoutState() {
+    return {
+        guard: null,
+        lastFailureActualLength: 0,
+        lastFailureKind: null,
+        lastFailureNodeIndex: -1,
+        lastFailureParentIndex: -1,
+        lastFailureRequiredLength: 0,
+        lastFailureResolverKind: null,
+        resolvers: new Map(),
+    };
+}
+// Registers or replaces one container-kind resolver. Passing null removes it. Bare built-in names are
+// reserved by the SDK; custom kinds use a vendor prefix such as `acme.Flow`.
+export function registerLayoutResolver(state, kind, resolver) {
+    if (resolver === null)
+        state.resolvers.delete(kind);
+    else
+        state.resolvers.set(kind, resolver);
+}
+//# sourceMappingURL=layoutState.js.map

package/dist/layoutState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layoutState.js","sourceRoot":"","sources":["../src/layoutState.ts"],"names":[],"mappings":"AAEA,wGAAwG;AACxG,2FAA2F;AAC3F,MAAM,UAAU,iBAAiB;IAC/B,OAAO;QACL,KAAK,EAAE,IAAI;QACX,uBAAuB,EAAE,CAAC;QAC1B,eAAe,EAAE,IAAI;QACrB,oBAAoB,EAAE,CAAC,CAAC;QACxB,sBAAsB,EAAE,CAAC,CAAC;QAC1B,yBAAyB,EAAE,CAAC;QAC5B,uBAAuB,EAAE,IAAI;QAC7B,SAAS,EAAE,IAAI,GAAG,EAAE;KACrB,CAAC;AACJ,CAAC;AAED,sGAAsG;AACtG,6EAA6E;AAC7E,MAAM,UAAU,sBAAsB,CACpC,KAA4B,EAC5B,IAAY,EACZ,QAA+B;IAE/B,IAAI,QAAQ,KAAK,IAAI;QAAE,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;;QAC/C,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AAC3C,CAAC"}

package/dist/resolveLayoutTree.d.ts

@@ -0,0 +1,4 @@
+import type { LayoutResolutionExplanation, LayoutState, LayoutTree } from '@flighthq/types/contract';
+export declare function explainLayoutResolution(state: Readonly<LayoutState>, tree: Readonly<LayoutTree>, nodeIndex: number): LayoutResolutionExplanation | null;
+export declare function resolveLayoutTree(out: Float32Array, state: LayoutState, tree: Readonly<LayoutTree>, intrinsicSizes: ArrayLike<number>, availableWidth: number, availableHeight: number): boolean;
+//# sourceMappingURL=resolveLayoutTree.d.ts.map

package/dist/resolveLayoutTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveLayoutTree.d.ts","sourceRoot":"","sources":["../src/resolveLayoutTree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAE3B,WAAW,EACX,UAAU,EACX,MAAM,0BAA0B,CAAC;AAKlC,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,WAAW,CAAC,EAC5B,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC1B,SAAS,EAAE,MAAM,GAChB,2BAA2B,GAAG,IAAI,CA2BpC;AAKD,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC1B,cAAc,EAAE,SAAS,CAAC,MAAM,CAAC,EACjC,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,GACtB,OAAO,CAkDT"}

package/dist/resolveLayoutTree.js

@@ -0,0 +1,98 @@
+import { LayoutResolutionFailureKind as Failure } from '@flighthq/types/contract';
+// Returns a detached explanation for the latest matching sentinel, or diagnoses hierarchy/registration at
+// `nodeIndex` without mutating state. Expectedly valid nodes return null.
+export function explainLayoutResolution(state, tree, nodeIndex) {
+    if (state.lastFailureKind !== null &&
+        (nodeIndex < 0 || state.lastFailureNodeIndex < 0 || nodeIndex === state.lastFailureNodeIndex)) {
+        return {
+            actualLength: state.lastFailureActualLength,
+            kind: state.lastFailureKind,
+            nodeIndex: state.lastFailureNodeIndex,
+            parentIndex: state.lastFailureParentIndex,
+            requiredLength: state.lastFailureRequiredLength,
+            resolverKind: state.lastFailureResolverKind,
+        };
+    }
+    const nodes = tree.nodes;
+    if (nodeIndex < 0 || nodeIndex >= nodes.length)
+        return null;
+    const node = nodes[nodeIndex];
+    if (node.parentIndex < -1 || node.parentIndex >= nodeIndex) {
+        return explanation(Failure.InvalidHierarchy, nodeIndex, node.parentIndex, node.kind);
+    }
+    for (let i = nodeIndex + 1; i < nodes.length; i++) {
+        if (nodes[i].parentIndex === nodeIndex && !state.resolvers.has(node.kind)) {
+            return explanation(Failure.UnregisteredKind, nodeIndex, -1, node.kind);
+        }
+    }
+    return null;
+}
+// Resolves a flat, parent-before-child tree into absolute rectangles. `intrinsicSizes` is two floats per
+// node (natural width, height); `out` is four floats per node (x, y, width, height). Both buffers belong to
+// the caller. The successful path performs no allocation, and an anchor-only tree is one forward pass.
+export function resolveLayoutTree(out, state, tree, intrinsicSizes, availableWidth, availableHeight) {
+    clearLayoutFailure(state);
+    const nodes = tree.nodes;
+    const requiredOutLength = nodes.length * 4;
+    if (out.length < requiredOutLength) {
+        return failLayoutResolution(state, tree, Failure.OutputTooSmall, -1, -1, requiredOutLength, out.length, null);
+    }
+    const requiredIntrinsicLength = nodes.length * 2;
+    if (intrinsicSizes.length < requiredIntrinsicLength) {
+        return failLayoutResolution(state, tree, Failure.IntrinsicSizesTooSmall, -1, -1, requiredIntrinsicLength, intrinsicSizes.length, null);
+    }
+    const rootWidth = finiteSize(availableWidth);
+    const rootHeight = finiteSize(availableHeight);
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const parentIndex = node.parentIndex;
+        if (parentIndex < -1 || parentIndex >= i) {
+            return failLayoutResolution(state, tree, Failure.InvalidHierarchy, i, parentIndex, 0, 0, node.kind);
+        }
+        const offset = i * 4;
+        if (parentIndex === -1) {
+            out[offset] = 0;
+            out[offset + 1] = 0;
+            out[offset + 2] = rootWidth;
+            out[offset + 3] = rootHeight;
+            continue;
+        }
+        const parentKind = nodes[parentIndex].kind;
+        const resolver = state.resolvers.get(parentKind);
+        if (resolver === undefined) {
+            return failLayoutResolution(state, tree, Failure.UnregisteredKind, parentIndex, -1, 0, 0, parentKind);
+        }
+        const failure = resolver(out, tree, intrinsicSizes, parentIndex, i);
+        if (failure !== null) {
+            const failureNodeIndex = failure === Failure.InvalidContainerStyle ? parentIndex : i;
+            return failLayoutResolution(state, tree, failure, failureNodeIndex, parentIndex, 0, 0, parentKind);
+        }
+    }
+    return true;
+}
+function explanation(kind, nodeIndex, parentIndex, resolverKind) {
+    return { actualLength: 0, kind, nodeIndex, parentIndex, requiredLength: 0, resolverKind };
+}
+function clearLayoutFailure(state) {
+    state.lastFailureActualLength = 0;
+    state.lastFailureKind = null;
+    state.lastFailureNodeIndex = -1;
+    state.lastFailureParentIndex = -1;
+    state.lastFailureRequiredLength = 0;
+    state.lastFailureResolverKind = null;
+}
+function failLayoutResolution(state, tree, kind, nodeIndex, parentIndex, requiredLength, actualLength, resolverKind) {
+    state.lastFailureActualLength = actualLength;
+    state.lastFailureKind = kind;
+    state.lastFailureNodeIndex = nodeIndex;
+    state.lastFailureParentIndex = parentIndex;
+    state.lastFailureRequiredLength = requiredLength;
+    state.lastFailureResolverKind = resolverKind;
+    if (state.guard !== null)
+        state.guard(explainLayoutResolution(state, tree, nodeIndex));
+    return false;
+}
+function finiteSize(value) {
+    return Number.isFinite(value) && value > 0 ? value : 0;
+}
+//# sourceMappingURL=resolveLayoutTree.js.map

package/dist/resolveLayoutTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveLayoutTree.js","sourceRoot":"","sources":["../src/resolveLayoutTree.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@flighthq/layout",
+  "version": "0.3.0-next.1728.26853f6",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flighthq/flight.git",
+    "directory": "packages/layout"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./contract": {
+      "types": "./dist/contract.d.ts",
+      "default": "./dist/contract.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/types": "0.3.0-next.1728.26853f6"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Renderer-neutral anchor, flex, and grid rectangle layout over flat trees",
+  "sideEffects": false
+}

package/src/anchorLayout.test.ts

@@ -0,0 +1,53 @@
+import type { AnchorLayoutItemStyle, LayoutNode, LayoutTree } from '@flighthq/types/contract';
+import { AnchorLayoutKind } from '@flighthq/types/contract';
+
+import { registerAnchorLayoutResolver } from './anchorLayout';
+import { createLayoutState } from './layoutState';
+import { explainLayoutResolution, resolveLayoutTree } from './resolveLayoutTree';
+
+function node(parentIndex: number, itemStyle: AnchorLayoutItemStyle | null = null): LayoutNode {
+  return { containerStyle: null, itemStyle, kind: AnchorLayoutKind, parentIndex };
+}
+
+function resolve(nodes: LayoutNode[], intrinsicSizes: number[], width = 200, height = 100): Float32Array {
+  const out = new Float32Array(nodes.length * 4);
+  const state = createLayoutState();
+  registerAnchorLayoutResolver(state);
+  expect(resolveLayoutTree(out, state, { nodes }, intrinsicSizes, width, height)).toBe(true);
+  return out;
+}
+
+describe('registerAnchorLayoutResolver', () => {
+  it('aligns a natural-size child with the existing viewport vocabulary', () => {
+    const out = resolve([node(-1), node(0, { align: 'bottomright' })], [0, 0, 40, 20]);
+    expect([...out.slice(4)]).toEqual([160, 80, 40, 20]);
+  });
+
+  it('stretches between opposing pins as the available rect changes', () => {
+    const nodes = [node(-1), node(0, { bottom: 10, left: 20, right: 30, top: 5 })];
+    expect([...resolve(nodes, [0, 0, 1, 1], 200, 100).slice(4)]).toEqual([20, 5, 150, 85]);
+    expect([...resolve(nodes, [0, 0, 1, 1], 300, 160).slice(4)]).toEqual([20, 5, 250, 145]);
+  });
+
+  it('lets an edge pin override alignment on only that axis', () => {
+    const out = resolve([node(-1), node(0, { align: 'bottomright', left: 12 })], [0, 0, 30, 20]);
+    expect([...out.slice(4)]).toEqual([12, 80, 30, 20]);
+  });
+
+  it('propagates nested rectangles in one parent-before-child pass', () => {
+    const out = resolve(
+      [node(-1), node(0, { bottom: 10, left: 10, right: 10, top: 10 }), node(1, { align: 'bottomright' })],
+      [0, 0, 0, 0, 20, 15],
+    );
+    expect([...out.slice(4, 8)]).toEqual([10, 10, 180, 80]);
+    expect([...out.slice(8)]).toEqual([170, 75, 20, 15]);
+  });
+
+  it('rejects a style shape its parent resolver cannot interpret', () => {
+    const input: LayoutTree = { nodes: [node(-1), { ...node(0), itemStyle: { align: 'middle' } }] };
+    const state = createLayoutState();
+    registerAnchorLayoutResolver(state);
+    expect(resolveLayoutTree(new Float32Array(8), state, input, new Float32Array(4), 100, 100)).toBe(false);
+    expect(explainLayoutResolution(state, input, 1)?.kind).toBe('InvalidItemStyle');
+  });
+});

package/src/enableLayoutGuards.test.ts

@@ -0,0 +1,16 @@
+import type { LayoutNode } from '@flighthq/types/contract';
+
+import { enableLayoutGuards } from './enableLayoutGuards';
+import { createLayoutState } from './layoutState';
+import { resolveLayoutTree } from './resolveLayoutTree';
+
+describe('enableLayoutGuards', () => {
+  it('warns with the structured explanation for a silent sentinel', () => {
+    const warn = vi.fn();
+    const state = createLayoutState();
+    enableLayoutGuards(state, warn);
+    const root: LayoutNode = { containerStyle: null, itemStyle: null, kind: 'acme.Root', parentIndex: -1 };
+    resolveLayoutTree(new Float32Array(3), state, { nodes: [root] }, new Float32Array(2), 100, 100);
+    expect(warn).toHaveBeenCalledWith(expect.objectContaining({ kind: 'OutputTooSmall' }));
+  });
+});

package/src/flexLayout.test.ts

@@ -0,0 +1,104 @@
+import type { FlexLayoutContainerStyle, FlexLayoutItemStyle, LayoutNode } from '@flighthq/types/contract';
+import { FlexLayoutKind } from '@flighthq/types/contract';
+
+import { registerFlexLayoutResolver } from './flexLayout';
+import { createLayoutState } from './layoutState';
+import { explainLayoutResolution, resolveLayoutTree } from './resolveLayoutTree';
+
+function root(containerStyle: FlexLayoutContainerStyle | null = null): LayoutNode {
+  return { containerStyle, itemStyle: null, kind: FlexLayoutKind, parentIndex: -1 };
+}
+
+function child(itemStyle: FlexLayoutItemStyle | null = null): LayoutNode {
+  return { containerStyle: null, itemStyle, kind: FlexLayoutKind, parentIndex: 0 };
+}
+
+function resolve(nodes: LayoutNode[], intrinsicSizes: number[], width = 200, height = 100): Float32Array {
+  const out = new Float32Array(nodes.length * 4);
+  const state = createLayoutState();
+  registerFlexLayoutResolver(state);
+  expect(resolveLayoutTree(out, state, { nodes }, intrinsicSizes, width, height)).toBe(true);
+  return out;
+}
+
+describe('registerFlexLayoutResolver', () => {
+  it('uses intrinsic sizes for basis-auto and distributes growth', () => {
+    const out = resolve([root({ align: 'start' }), child({ grow: 1 }), child({ grow: 2 })], [0, 0, 20, 10, 20, 15]);
+    expect([...out.slice(4, 8)]).toEqual([0, 0, 73.33333587646484, 10]);
+    expect(out[8]).toBeCloseTo(73.3333);
+    expect(out[10]).toBeCloseTo(126.6667);
+  });
+
+  it('shrinks overflowing items in proportion to basis and shrink', () => {
+    const out = resolve(
+      [root({ align: 'start' }), child({ basis: 80, shrink: 1 }), child({ basis: 80, shrink: 1 })],
+      [0, 0, 0, 10, 0, 10],
+      100,
+    );
+    expect(out[6]).toBe(50);
+    expect(out[8]).toBe(50);
+    expect(out[10]).toBe(50);
+  });
+
+  it('applies padding, gap, justify, and cross-axis alignment', () => {
+    const out = resolve(
+      [
+        root({
+          align: 'center',
+          gap: 10,
+          justify: 'space-between',
+          paddingBottom: 10,
+          paddingLeft: 10,
+          paddingRight: 10,
+          paddingTop: 10,
+        }),
+        child(),
+        child({ alignSelf: 'end' }),
+      ],
+      [0, 0, 20, 10, 30, 20],
+      120,
+      80,
+    );
+    expect([...out.slice(4, 8)]).toEqual([10, 35, 20, 10]);
+    expect([...out.slice(8)]).toEqual([80, 50, 30, 20]);
+  });
+
+  it('supports column-reverse without changing item role semantics', () => {
+    const out = resolve(
+      [root({ align: 'start', direction: 'column-reverse', gap: 5 }), child(), child()],
+      [0, 0, 20, 10, 30, 15],
+      100,
+      60,
+    );
+    expect([...out.slice(4, 8)]).toEqual([0, 50, 20, 10]);
+    expect([...out.slice(8)]).toEqual([0, 30, 30, 15]);
+  });
+
+  it('wraps lines and supports wrap-reverse', () => {
+    const normal = resolve(
+      [root({ align: 'start', gap: 5, wrap: 'wrap' }), child({ basis: 60 }), child({ basis: 60 })],
+      [0, 0, 0, 10, 0, 20],
+      100,
+      80,
+    );
+    expect([...normal.slice(4, 8)]).toEqual([0, 0, 60, 10]);
+    expect([...normal.slice(8)]).toEqual([0, 15, 60, 20]);
+
+    const reversed = resolve(
+      [root({ align: 'start', gap: 5, wrap: 'wrap-reverse' }), child({ basis: 60 }), child({ basis: 60 })],
+      [0, 0, 0, 10, 0, 20],
+      100,
+      80,
+    );
+    expect(reversed[5]).toBe(45);
+    expect(reversed[9]).toBe(60);
+  });
+
+  it('returns a diagnosable sentinel for mismatched styles', () => {
+    const nodes = [root(), { ...child(), itemStyle: { grow: 'yes' } }];
+    const state = createLayoutState();
+    registerFlexLayoutResolver(state);
+    expect(resolveLayoutTree(new Float32Array(8), state, { nodes }, new Float32Array(4), 100, 100)).toBe(false);
+    expect(explainLayoutResolution(state, { nodes }, 1)?.kind).toBe('InvalidItemStyle');
+  });
+});

package/src/gridLayout.test.ts

@@ -0,0 +1,123 @@
+import type { GridLayoutContainerStyle, GridLayoutItemStyle, LayoutNode } from '@flighthq/types/contract';
+import { GridLayoutKind } from '@flighthq/types/contract';
+
+import { registerGridLayoutResolver } from './gridLayout';
+import { createLayoutState } from './layoutState';
+import { explainLayoutResolution, resolveLayoutTree } from './resolveLayoutTree';
+
+function root(containerStyle: GridLayoutContainerStyle): LayoutNode {
+  return { containerStyle, itemStyle: null, kind: GridLayoutKind, parentIndex: -1 };
+}
+
+function child(itemStyle: GridLayoutItemStyle | null = null): LayoutNode {
+  return { containerStyle: null, itemStyle, kind: GridLayoutKind, parentIndex: 0 };
+}
+
+function resolve(nodes: LayoutNode[], intrinsicSizes: number[], width = 200, height = 100): Float32Array {
+  const out = new Float32Array(nodes.length * 4);
+  const state = createLayoutState();
+  registerGridLayoutResolver(state);
+  expect(resolveLayoutTree(out, state, { nodes }, intrinsicSizes, width, height)).toBe(true);
+  return out;
+}
+
+describe('registerGridLayoutResolver', () => {
+  it('sizes fixed, fractional, and intrinsic tracks', () => {
+    const out = resolve(
+      [
+        root({
+          columnGap: 10,
+          columns: [{ kind: 'fixed', size: 40 }, { kind: 'auto' }, { fraction: 1, kind: 'fraction' }],
+          rows: [{ kind: 'auto' }],
+        }),
+        child({ column: 0, row: 0 }),
+        child({ column: 1, row: 0 }),
+        child({ column: 2, row: 0 }),
+      ],
+      [0, 0, 20, 10, 30, 25, 15, 20],
+    );
+    expect([...out.slice(4, 8)]).toEqual([0, 0, 40, 25]);
+    expect([...out.slice(8, 12)]).toEqual([50, 0, 30, 25]);
+    expect([...out.slice(12)]).toEqual([90, 0, 110, 25]);
+  });
+
+  it('assigns omitted placement row-major', () => {
+    const out = resolve(
+      [
+        root({
+          columnGap: 5,
+          columns: [
+            { kind: 'fixed', size: 20 },
+            { kind: 'fixed', size: 30 },
+          ],
+          rowGap: 4,
+          rows: [
+            { kind: 'fixed', size: 10 },
+            { kind: 'fixed', size: 15 },
+          ],
+        }),
+        child(),
+        child(),
+        child(),
+      ],
+      new Array(8).fill(0),
+    );
+    expect([...out.slice(4, 8)]).toEqual([0, 0, 20, 10]);
+    expect([...out.slice(8, 12)]).toEqual([25, 0, 30, 10]);
+    expect([...out.slice(12)]).toEqual([0, 14, 20, 15]);
+  });
+
+  it('supports spans, padding, and independent gaps', () => {
+    const out = resolve(
+      [
+        root({
+          columnGap: 5,
+          columns: [
+            { kind: 'fixed', size: 20 },
+            { kind: 'fixed', size: 30 },
+          ],
+          paddingLeft: 7,
+          paddingTop: 11,
+          rowGap: 3,
+          rows: [
+            { kind: 'fixed', size: 10 },
+            { kind: 'fixed', size: 15 },
+          ],
+        }),
+        child({ column: 0, columnSpan: 2, row: 0, rowSpan: 2 }),
+      ],
+      [0, 0, 0, 0],
+    );
+    expect([...out.slice(4)]).toEqual([7, 11, 55, 28]);
+  });
+
+  it('shares intrinsic size across auto tracks in a span', () => {
+    const out = resolve(
+      [
+        root({ columns: [{ kind: 'auto' }, { kind: 'auto' }], rows: [{ kind: 'auto' }] }),
+        child({ column: 0, columnSpan: 2, row: 0 }),
+      ],
+      [0, 0, 80, 20],
+    );
+    expect([...out.slice(4)]).toEqual([0, 0, 80, 20]);
+  });
+
+  it('returns diagnosable sentinels for mismatched container and item styles', () => {
+    const invalidContainerNodes = [
+      { ...root({ columns: [{ kind: 'auto' }], rows: [{ kind: 'auto' }] }), containerStyle: { columns: [] } },
+      child(),
+    ];
+    const state = createLayoutState();
+    registerGridLayoutResolver(state);
+    expect(
+      resolveLayoutTree(new Float32Array(8), state, { nodes: invalidContainerNodes }, new Float32Array(4), 10, 10),
+    ).toBe(false);
+    expect(explainLayoutResolution(state, { nodes: invalidContainerNodes }, 0)?.kind).toBe('InvalidContainerStyle');
+
+    const invalidItemNodes = [root({ columns: [{ kind: 'auto' }], rows: [{ kind: 'auto' }] }), child({ column: 0 })];
+    expect(
+      resolveLayoutTree(new Float32Array(8), state, { nodes: invalidItemNodes }, new Float32Array(4), 10, 10),
+    ).toBe(false);
+    expect(explainLayoutResolution(state, { nodes: invalidItemNodes }, 1)?.kind).toBe('InvalidItemStyle');
+  });
+});

package/src/layoutState.test.ts

@@ -0,0 +1,26 @@
+import type { LayoutResolver } from '@flighthq/types/contract';
+
+import { createLayoutState, registerLayoutResolver } from './layoutState';
+
+const resolver: LayoutResolver = () => null;
+
+describe('createLayoutState', () => {
+  it('starts with an empty resolver registry and no retained failure', () => {
+    const state = createLayoutState();
+    expect(state.resolvers.size).toBe(0);
+    expect(state.lastFailureKind).toBeNull();
+    expect(state.guard).toBeNull();
+  });
+});
+
+describe('registerLayoutResolver', () => {
+  it('is open, last-write-wins, and accepts null to unregister', () => {
+    const state = createLayoutState();
+    const replacement: LayoutResolver = () => 'InvalidItemStyle';
+    registerLayoutResolver(state, 'acme.Flow', resolver);
+    registerLayoutResolver(state, 'acme.Flow', replacement);
+    expect(state.resolvers.get('acme.Flow')).toBe(replacement);
+    registerLayoutResolver(state, 'acme.Flow', null);
+    expect(state.resolvers.has('acme.Flow')).toBe(false);
+  });
+});

package/src/layoutTreeShaking.test.ts

@@ -0,0 +1,52 @@
+// @vitest-environment node
+
+import { build } from 'esbuild';
+
+const resolveDir = getFileUrlDirectory(import.meta.url);
+
+async function bundleLayoutExports(names: readonly string[]): Promise<string> {
+  const result = await build({
+    bundle: true,
+    format: 'esm',
+    logLevel: 'silent',
+    minify: true,
+    packages: 'external',
+    stdin: {
+      contents: `export { ${names.join(', ')} } from './contract.ts';`,
+      resolveDir,
+      sourcefile: `tree-shake-${names.join('-')}.ts`,
+    },
+    treeShaking: true,
+    write: false,
+  });
+  return result.outputFiles[0].text;
+}
+
+describe('layout resolver tree shaking', () => {
+  it('keeps anchor-only assembly independent of flex and grid', async () => {
+    const output = await bundleLayoutExports([
+      'createLayoutState',
+      'registerAnchorLayoutResolver',
+      'resolveLayoutTree',
+    ]);
+    expect(output).toContain('AnchorLayout');
+    expect(output).not.toContain('space-evenly');
+    expect(output).not.toContain('columnGap');
+  });
+
+  it('includes each optional resolver only through its named registrar', async () => {
+    const flex = await bundleLayoutExports(['registerFlexLayoutResolver']);
+    const grid = await bundleLayoutExports(['registerGridLayoutResolver']);
+    expect(flex).toContain('space-evenly');
+    expect(flex).not.toContain('columnGap');
+    expect(grid).toContain('columnGap');
+    expect(grid).not.toContain('space-evenly');
+  });
+});
+
+function getFileUrlDirectory(url: string): string {
+  const directory = new URL('.', url);
+  const pathname = decodeURIComponent(directory.pathname);
+  if (directory.hostname !== '') return `//${directory.hostname}${pathname}`;
+  return /^\/[A-Za-z]:\//.test(pathname) ? pathname.slice(1) : pathname;
+}