@viewscript/renderer 0.1.0-20260515014709 → 0.1.0-20260515015849

package/dist/compiler/chunk-splitter.d.ts

@@ -35,7 +35,7 @@
  * 5. Compute chunk dependency DAG
  * ```
  */
-import type { EntityId, ConstraintId, ChunkId, Chunk, Rational } from '../ast/types';
+import type { EntityId, ConstraintId, ChunkId, Chunk, Rational } from '../ast/types.js';
 interface IRConstraint {
     id: ConstraintId;
     target: EntityId;

package/dist/rasterizer/canvas-mapper.d.ts

@@ -28,7 +28,7 @@
  *    coordinates, ensuring seamless curve connections
  * 3. **Fill Rule Semantics**: SVG fill-rule (nonzero/evenodd) is preserved
  */
-import type { EntityId, Rational, PathCommand } from '../ast/types';
+import type { EntityId, Rational, PathCommand } from '../ast/types.js';
 /**
  * Control point with resolved rational coordinates.
  */

package/dist/rasterizer/error-distribution.d.ts

@@ -34,7 +34,7 @@
  *
  * LRM distributes exactly (T - Σ⌊rᵢ⌋) extra pixels to achieve Σ = T.
  */
-import type { EntityId } from '../ast/types';
+import type { EntityId } from '../ast/types.js';
 /**
  * A sibling group: children that must sum to parent's dimension.
  */

package/dist/rasterizer/gradient-mapper.d.ts

@@ -36,7 +36,7 @@
  * canvas.drawRect(bounds, paint);
  * ```
  */
-import type { Rational, RasterBounds } from '../ast/types';
+import type { Rational, RasterBounds } from '../ast/types.js';
 /** GPU shader backend interface (minimal subset needed for gradients) */
 export interface GpuShaderBackend {
     Shader: {

package/dist/rasterizer/topology-rounding.d.ts

@@ -61,7 +61,7 @@
  *   Assert all topological constraints are satisfied
  * ```
  */
-import type { EntityId, Rational, RasterBounds, PVectorBounds } from '../ast/types';
+import type { EntityId, Rational, RasterBounds, PVectorBounds } from '../ast/types.js';
 /**
  * A coordinate in the pre-rasterization space.
  */

package/dist/runtime/event-backpressure.d.ts

@@ -23,7 +23,7 @@
  * 3. Configurable throttle strategies
  * 4. Priority queues for critical events (click > mousemove)
  */
-import type { EntityId } from '../ast/types';
+import type { EntityId } from '../ast/types.js';
 /**
  * Semantic T-vector state keys.
  *

package/dist/runtime/render-loop.d.ts

@@ -34,7 +34,7 @@
  *
  * We NEVER touch: width, height, top, left, margin, padding (reflow triggers)
  */
-import type { EntityId, RenderableEntity, RasterBounds, PVectorBounds } from '../ast/types';
+import type { EntityId, RenderableEntity, RasterBounds, PVectorBounds } from '../ast/types.js';
 import type { FfiDispatcher, PendingFfiCall } from './ffi-dispatcher.js';
 import type { WasmSolverBridge } from './wasm-solver-bridge.js';
 /**

package/dist/semantic/semantic-translator.d.ts

@@ -34,7 +34,7 @@
  * const diff = translator.compareSolutions(solution1, solution2);
  * ```
  */
-import type { EntityId } from '../ast/types';
+import type { EntityId } from '../ast/types.js';
 /**
  * Raw solution from solver: "entity_id:component" -> "numerator/denominator"
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viewscript/renderer",
-  "version": "0.1.0-20260515014709",
+  "version": "0.1.0-20260515015849",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/compiler/chunk-splitter.ts

@@ -45,7 +45,7 @@ import type {
   RenderableEntity,
   Rational,
   PVectorBounds,
-} from '../ast/types';
+} from '../ast/types.js';
 
 // =============================================================================
 // Input Types (from IR)

package/src/rasterizer/__tests__/error-distribution.test.ts

@@ -11,7 +11,7 @@ import {
   applyErrorDistribution,
   type SiblingGroup,
   type ContainmentConstraint,
-} from '../error-distribution';
+} from '../error-distribution.js';
 
 describe('Largest Remainder Method', () => {
   /**
@@ -44,17 +44,17 @@ describe('Largest Remainder Method', () => {
     expect(result.isExact).toBe(true);
 
     // Assert: Each child gets 33 or 34 pixels
-    const pixels = result.dimensions.map(d => d.pixels);
-    expect(pixels.every(p => p === 33 || p === 34)).toBe(true);
+    const pixels = result.dimensions.map((d: { pixels: number }) => d.pixels);
+    expect(pixels.every((p: number) => p === 33 || p === 34)).toBe(true);
 
     // Assert: Exactly one child gets the extra pixel
-    const count34 = pixels.filter(p => p === 34).length;
-    const count33 = pixels.filter(p => p === 33).length;
+    const count34 = pixels.filter((p: number) => p === 34).length;
+    const count33 = pixels.filter((p: number) => p === 33).length;
     expect(count34).toBe(1);
     expect(count33).toBe(2);
 
     // Assert: Sum is exactly 100 (33 + 33 + 34 = 100)
-    expect(pixels.reduce((a, b) => a + b, 0)).toBe(100);
+    expect(pixels.reduce((a: number, b: number) => a + b, 0)).toBe(100);
 
     // Assert: Distribution is [34, 33, 33] (leftmost gets extra due to tie-break)
     expect(pixels).toEqual([34, 33, 33]);
@@ -81,7 +81,7 @@ describe('Largest Remainder Method', () => {
     // Assert
     expect(result.totalPixels).toBe(100);
     expect(result.isExact).toBe(true);
-    expect(result.dimensions.map(d => d.pixels)).toEqual([25, 25, 25, 25]);
+    expect(result.dimensions.map((d: { pixels: number }) => d.pixels)).toEqual([25, 25, 25, 25]);
   });
 
   it('distributes multiple extra pixels by remainder priority', () => {
@@ -108,7 +108,7 @@ describe('Largest Remainder Method', () => {
     // Assert
     expect(result.totalPixels).toBe(100);
     expect(result.isExact).toBe(true);
-    expect(result.dimensions.map(d => d.pixels)).toEqual([41, 31, 28]);
+    expect(result.dimensions.map((d: { pixels: number }) => d.pixels)).toEqual([41, 31, 28]);
   });
 
   it('handles single child (trivial case)', () => {
@@ -164,7 +164,7 @@ describe('Largest Remainder Method', () => {
 
     // Assert: shortfall is 1, so first element (leftmost) gets it
     expect(result.totalPixels).toBe(7);
-    expect(result.dimensions.map(d => d.pixels)).toEqual([4, 3]);
+    expect(result.dimensions.map((d: { pixels: number }) => d.pixels)).toEqual([4, 3]);
   });
 
   it('handles vertical axis', () => {
@@ -302,8 +302,8 @@ describe('Edge Cases', () => {
 
     // 7 * 14 = 98, shortfall = 2
     // Two elements get 15px, five get 14px
-    const fifteens = result.dimensions.filter(d => d.pixels === 15).length;
-    const fourteens = result.dimensions.filter(d => d.pixels === 14).length;
+    const fifteens = result.dimensions.filter((d: { pixels: number }) => d.pixels === 15).length;
+    const fourteens = result.dimensions.filter((d: { pixels: number }) => d.pixels === 14).length;
     expect(fifteens).toBe(2);
     expect(fourteens).toBe(5);
   });

package/src/rasterizer/canvas-mapper.ts

@@ -29,7 +29,7 @@
  * 3. **Fill Rule Semantics**: SVG fill-rule (nonzero/evenodd) is preserved
  */
 
-import type { EntityId, Rational, PathCommand, FillStyle, StrokeStyle } from '../ast/types';
+import type { EntityId, Rational, PathCommand, FillStyle, StrokeStyle } from '../ast/types.js';
 
 // =============================================================================
 // Input Types (from P-Dimension Solver)

package/src/rasterizer/error-distribution.ts

@@ -35,7 +35,7 @@
  * LRM distributes exactly (T - Σ⌊rᵢ⌋) extra pixels to achieve Σ = T.
  */
 
-import type { EntityId, Rational } from '../ast/types';
+import type { EntityId, Rational } from '../ast/types.js';
 
 // =============================================================================
 // Types

package/src/rasterizer/gradient-mapper.ts

@@ -37,7 +37,7 @@
  * ```
  */
 
-import type { Rational, RasterBounds } from '../ast/types';
+import type { Rational, RasterBounds } from '../ast/types.js';
 
 // =============================================================================
 // Types

package/src/rasterizer/topology-rounding.ts

@@ -62,7 +62,7 @@
  * ```
  */
 
-import type { EntityId, Rational, RasterBounds, PVectorBounds } from '../ast/types';
+import type { EntityId, Rational, RasterBounds, PVectorBounds } from '../ast/types.js';
 
 // =============================================================================
 // Types

package/src/runtime/__tests__/event-backpressure.test.ts

@@ -14,7 +14,7 @@ import {
   EventPriority,
   type QDimensionEvent,
   type TStateKey,
-} from '../event-backpressure';
+} from '../event-backpressure.js';
 
 describe('EventBuffer', () => {
   let buffer: EventBuffer;
@@ -187,8 +187,8 @@ describe('EventBuffer', () => {
 
       expect(flushed).toHaveLength(2);
       // Both events should be present
-      expect(flushed.some(e => e.entityId === 1)).toBe(true);
-      expect(flushed.some(e => e.entityId === 2)).toBe(true);
+      expect(flushed.some((e: QDimensionEvent) => e.entityId === 1)).toBe(true);
+      expect(flushed.some((e: QDimensionEvent) => e.entityId === 2)).toBe(true);
     });
   });
 

package/src/runtime/__tests__/ffi-integration.test.ts

@@ -127,6 +127,10 @@ function createBindManifestContext(bindings: {
       line: i + 2,
     })),
     triggers: [],
+    componentDecls: [],
+    components: [],
+    scene: null,
+    consts: [],
     errors: [],
   };
 
@@ -168,6 +172,10 @@ function createTriggerManifestContext(triggers: {
       functionArgs: t.functionArgs,
       line: i + 2,
     })),
+    componentDecls: [],
+    components: [],
+    scene: null,
+    consts: [],
     errors: [],
   };
 

package/src/runtime/event-backpressure.ts

@@ -24,7 +24,7 @@
  * 4. Priority queues for critical events (click > mousemove)
  */
 
-import type { EntityId } from '../ast/types';
+import type { EntityId } from '../ast/types.js';
 
 // =============================================================================
 // Types

package/src/runtime/render-loop.ts

@@ -41,7 +41,7 @@ import type {
   RasterBounds,
   PVectorBounds,
   ChunkId,
-} from '../ast/types';
+} from '../ast/types.js';
 import type { FfiDispatcher, PendingFfiCall } from './ffi-dispatcher.js';
 import type { WasmSolverBridge } from './wasm-solver-bridge.js';
 

package/src/semantic/__tests__/semantic-translator.test.ts

@@ -9,7 +9,7 @@ import {
   createEmptyRegistry,
   type EntityMetadata,
   type RawSolution,
-} from '../semantic-translator';
+} from '../semantic-translator.js';
 
 describe('SemanticTranslator', () => {
   describe('parseVarId', () => {
@@ -162,7 +162,7 @@ describe('SemanticTranslator', () => {
       const result = translator.translateSolution(rawSolution, 0);
 
       expect(result.relationships.length).toBeGreaterThan(0);
-      const alignment = result.relationships.find(r => r.type === 'alignment');
+      const alignment = result.relationships.find((r: { type: string }) => r.type === 'alignment');
       expect(alignment).toBeDefined();
       expect(alignment?.description).toContain('horizontally aligned');
     });

package/src/semantic/semantic-translator.ts

@@ -35,7 +35,7 @@
  * ```
  */
 
-import type { EntityId, Rational } from '../ast/types';
+import type { EntityId, Rational } from '../ast/types.js';
 
 // =============================================================================
 // Types for Raw Solver Output

package/tsconfig.json

@@ -8,5 +8,6 @@
     "outDir": "dist",
     "rootDir": "src"
   },
-  "include": ["src"]
+  "include": ["src"],
+  "exclude": ["src/**/__tests__"]
 }

package/dist/rasterizer/__tests__/error-distribution.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Unit Tests for Subpixel Error Distribution
- *
- * These tests verify the Largest Remainder Method implementation
- * guarantees spatial closure (no gaps, no overflow).
- */
-export {};

package/dist/rasterizer/__tests__/error-distribution.test.js

@@ -1,322 +0,0 @@
-/**
- * Unit Tests for Subpixel Error Distribution
- *
- * These tests verify the Largest Remainder Method implementation
- * guarantees spatial closure (no gaps, no overflow).
- */
-import { describe, it, expect } from 'vitest';
-import { distributeWithLargestRemainder, applyErrorDistribution, } from '../error-distribution';
-describe('Largest Remainder Method', () => {
-    /**
-     * CRITICAL TEST: Architect's Decision #2
-     *
-     * "幅100pxのコンテナ内に、幅33.333...pxの要素が3つ、
-     *  隙間なく隣接して配置される"
-     *
-     * This is the canonical case that motivated error distribution.
-     */
-    it('distributes 100px among 3 equal children (33.333...px each) without gaps', () => {
-        // Arrange
-        const group = {
-            parentId: 1,
-            childIds: [10, 11, 12],
-            axis: 'horizontal',
-            parentDimension: 100,
-            childDimensions: new Map([
-                [10, 100 / 3], // 33.333...
-                [11, 100 / 3], // 33.333...
-                [12, 100 / 3], // 33.333...
-            ]),
-        };
-        // Act
-        const result = distributeWithLargestRemainder(group);
-        // Assert: Sum must equal parent exactly
-        expect(result.totalPixels).toBe(100);
-        expect(result.isExact).toBe(true);
-        // Assert: Each child gets 33 or 34 pixels
-        const pixels = result.dimensions.map(d => d.pixels);
-        expect(pixels.every(p => p === 33 || p === 34)).toBe(true);
-        // Assert: Exactly one child gets the extra pixel
-        const count34 = pixels.filter(p => p === 34).length;
-        const count33 = pixels.filter(p => p === 33).length;
-        expect(count34).toBe(1);
-        expect(count33).toBe(2);
-        // Assert: Sum is exactly 100 (33 + 33 + 34 = 100)
-        expect(pixels.reduce((a, b) => a + b, 0)).toBe(100);
-        // Assert: Distribution is [34, 33, 33] (leftmost gets extra due to tie-break)
-        expect(pixels).toEqual([34, 33, 33]);
-    });
-    it('handles exact division (no remainder)', () => {
-        // Arrange: 100px / 4 = 25px exactly
-        const group = {
-            parentId: 1,
-            childIds: [10, 11, 12, 13],
-            axis: 'horizontal',
-            parentDimension: 100,
-            childDimensions: new Map([
-                [10, 25],
-                [11, 25],
-                [12, 25],
-                [13, 25],
-            ]),
-        };
-        // Act
-        const result = distributeWithLargestRemainder(group);
-        // Assert
-        expect(result.totalPixels).toBe(100);
-        expect(result.isExact).toBe(true);
-        expect(result.dimensions.map(d => d.pixels)).toEqual([25, 25, 25, 25]);
-    });
-    it('distributes multiple extra pixels by remainder priority', () => {
-        // Arrange: 100px for [40.9, 30.8, 28.3]
-        // floors: [40, 30, 28] = 98
-        // remainders: [0.9, 0.8, 0.3]
-        // shortfall: 2px
-        // Extra pixels go to: 40.9 → 41, 30.8 → 31
-        const group = {
-            parentId: 1,
-            childIds: [10, 11, 12],
-            axis: 'horizontal',
-            parentDimension: 100,
-            childDimensions: new Map([
-                [10, 40.9],
-                [11, 30.8],
-                [12, 28.3],
-            ]),
-        };
-        // Act
-        const result = distributeWithLargestRemainder(group);
-        // Assert
-        expect(result.totalPixels).toBe(100);
-        expect(result.isExact).toBe(true);
-        expect(result.dimensions.map(d => d.pixels)).toEqual([41, 31, 28]);
-    });
-    it('handles single child (trivial case)', () => {
-        const group = {
-            parentId: 1,
-            childIds: [10],
-            axis: 'horizontal',
-            parentDimension: 100,
-            childDimensions: new Map([[10, 100]]),
-        };
-        const result = distributeWithLargestRemainder(group);
-        expect(result.totalPixels).toBe(100);
-        expect(result.dimensions[0].pixels).toBe(100);
-    });
-    it('handles empty children', () => {
-        const group = {
-            parentId: 1,
-            childIds: [],
-            axis: 'horizontal',
-            parentDimension: 100,
-            childDimensions: new Map(),
-        };
-        const result = distributeWithLargestRemainder(group);
-        expect(result.totalPixels).toBe(0);
-        expect(result.dimensions).toEqual([]);
-    });
-    it('ties are broken by layout order (leftmost first)', () => {
-        // Arrange: 10px for [3.5, 3.5] - equal remainders
-        // floors: [3, 3] = 6
-        // remainders: [0.5, 0.5] - TIE!
-        // shortfall: 4px (wait, that's wrong)
-        // Actually: 10 - 6 = 4... no, 3.5 + 3.5 = 7, not 10
-        // Let me fix: 7px for [3.5, 3.5]
-        const group = {
-            parentId: 1,
-            childIds: [10, 11],
-            axis: 'horizontal',
-            parentDimension: 7,
-            childDimensions: new Map([
-                [10, 3.5],
-                [11, 3.5],
-            ]),
-        };
-        // Act
-        const result = distributeWithLargestRemainder(group);
-        // Assert: shortfall is 1, so first element (leftmost) gets it
-        expect(result.totalPixels).toBe(7);
-        expect(result.dimensions.map(d => d.pixels)).toEqual([4, 3]);
-    });
-    it('handles vertical axis', () => {
-        const group = {
-            parentId: 1,
-            childIds: [10, 11, 12],
-            axis: 'vertical',
-            parentDimension: 100,
-            childDimensions: new Map([
-                [10, 100 / 3],
-                [11, 100 / 3],
-                [12, 100 / 3],
-            ]),
-        };
-        const result = distributeWithLargestRemainder(group);
-        expect(result.totalPixels).toBe(100);
-        expect(result.isExact).toBe(true);
-    });
-    it('records error for each element', () => {
-        const group = {
-            parentId: 1,
-            childIds: [10, 11, 12],
-            axis: 'horizontal',
-            parentDimension: 100,
-            childDimensions: new Map([
-                [10, 100 / 3], // ~33.333
-                [11, 100 / 3],
-                [12, 100 / 3],
-            ]),
-        };
-        const result = distributeWithLargestRemainder(group);
-        // First element: 34 - 33.333... = +0.666...
-        expect(result.dimensions[0].error).toBeCloseTo(0.6667, 3);
-        // Other elements: 33 - 33.333... = -0.333...
-        expect(result.dimensions[1].error).toBeCloseTo(-0.3333, 3);
-        expect(result.dimensions[2].error).toBeCloseTo(-0.3333, 3);
-    });
-});
-describe('applyErrorDistribution (Integration)', () => {
-    it('adjusts child bounds to fit parent exactly', () => {
-        // Arrange
-        const roundedBounds = new Map([
-            [1, { x: 0, y: 0, width: 100, height: 50 }], // Parent
-            [10, { x: 0, y: 0, width: 33, height: 50 }], // Child 1 (naive)
-            [11, { x: 33, y: 0, width: 33, height: 50 }], // Child 2
-            [12, { x: 66, y: 0, width: 33, height: 50 }], // Child 3
-            // Sum: 33 + 33 + 33 = 99 ← GAP!
-        ]);
-        const containments = [
-            {
-                parentId: 1,
-                childIds: [10, 11, 12],
-                axis: 'horizontal',
-            },
-        ];
-        // Act
-        const result = applyErrorDistribution(roundedBounds, containments);
-        // Assert: Children sum to parent width exactly
-        const child1 = result.get(10);
-        const child2 = result.get(11);
-        const child3 = result.get(12);
-        const totalWidth = child1.width + child2.width + child3.width;
-        expect(totalWidth).toBe(100);
-        // Assert: Children are contiguous (no gaps)
-        expect(child2.x).toBe(child1.x + child1.width);
-        expect(child3.x).toBe(child2.x + child2.width);
-    });
-    it('handles multiple containment constraints', () => {
-        const roundedBounds = new Map([
-            // Horizontal container
-            [1, { x: 0, y: 0, width: 100, height: 50 }],
-            [10, { x: 0, y: 0, width: 33, height: 50 }],
-            [11, { x: 33, y: 0, width: 33, height: 50 }],
-            [12, { x: 66, y: 0, width: 33, height: 50 }],
-            // Vertical container
-            [2, { x: 0, y: 50, width: 100, height: 100 }],
-            [20, { x: 0, y: 50, width: 100, height: 33 }],
-            [21, { x: 0, y: 83, width: 100, height: 33 }],
-            [22, { x: 0, y: 116, width: 100, height: 33 }],
-        ]);
-        const containments = [
-            { parentId: 1, childIds: [10, 11, 12], axis: 'horizontal' },
-            { parentId: 2, childIds: [20, 21, 22], axis: 'vertical' },
-        ];
-        const result = applyErrorDistribution(roundedBounds, containments);
-        // Horizontal container
-        const hTotal = result.get(10).width + result.get(11).width + result.get(12).width;
-        expect(hTotal).toBe(100);
-        // Vertical container
-        const vTotal = result.get(20).height + result.get(21).height + result.get(22).height;
-        expect(vTotal).toBe(100);
-    });
-});
-describe('Edge Cases', () => {
-    it('handles very small fractional differences', () => {
-        // 100px / 7 = 14.285714...
-        const group = {
-            parentId: 1,
-            childIds: [1, 2, 3, 4, 5, 6, 7],
-            axis: 'horizontal',
-            parentDimension: 100,
-            childDimensions: new Map([
-                [1, 100 / 7],
-                [2, 100 / 7],
-                [3, 100 / 7],
-                [4, 100 / 7],
-                [5, 100 / 7],
-                [6, 100 / 7],
-                [7, 100 / 7],
-            ]),
-        };
-        const result = distributeWithLargestRemainder(group);
-        expect(result.totalPixels).toBe(100);
-        expect(result.isExact).toBe(true);
-        // 7 * 14 = 98, shortfall = 2
-        // Two elements get 15px, five get 14px
-        const fifteens = result.dimensions.filter(d => d.pixels === 15).length;
-        const fourteens = result.dimensions.filter(d => d.pixels === 14).length;
-        expect(fifteens).toBe(2);
-        expect(fourteens).toBe(5);
-    });
-    it('handles zero-width children', () => {
-        const group = {
-            parentId: 1,
-            childIds: [10, 11],
-            axis: 'horizontal',
-            parentDimension: 100,
-            childDimensions: new Map([
-                [10, 100],
-                [11, 0],
-            ]),
-        };
-        const result = distributeWithLargestRemainder(group);
-        expect(result.totalPixels).toBe(100);
-        expect(result.dimensions[0].pixels).toBe(100);
-        expect(result.dimensions[1].pixels).toBe(0);
-    });
-    it('uses proportional scaling when children exceed parent', () => {
-        // Children sum to 150, but parent is only 100
-        const group = {
-            parentId: 1,
-            childIds: [10, 11, 12],
-            axis: 'horizontal',
-            parentDimension: 100,
-            childDimensions: new Map([
-                [10, 50],
-                [11, 50],
-                [12, 50],
-            ]),
-        };
-        const result = distributeWithLargestRemainder(group);
-        // Falls back to proportional: each gets ~33.33
-        expect(result.totalPixels).toBe(100);
-        expect(result.method).toBe('first-fit');
-    });
-});
-describe('Proof: No Gaps or Overflow', () => {
-    /**
-     * Property test: For ANY valid input, sum(children) === parent
-     */
-    it('maintains invariant for random inputs', () => {
-        const testCases = [
-            { parent: 100, children: [100 / 3, 100 / 3, 100 / 3] },
-            { parent: 1000, children: [1000 / 7, 1000 / 7, 1000 / 7, 1000 / 7, 1000 / 7, 1000 / 7, 1000 / 7] },
-            { parent: 50, children: [12.5, 12.5, 12.5, 12.5] },
-            { parent: 99, children: [33, 33, 33] },
-            { parent: 101, children: [50.5, 50.5] },
-            { parent: 1, children: [0.5, 0.5] },
-            { parent: 2, children: [0.6, 0.7, 0.7] },
-        ];
-        for (const tc of testCases) {
-            const group = {
-                parentId: 1,
-                childIds: tc.children.map((_, i) => i + 10),
-                axis: 'horizontal',
-                parentDimension: tc.parent,
-                childDimensions: new Map(tc.children.map((c, i) => [i + 10, c])),
-            };
-            const result = distributeWithLargestRemainder(group);
-            expect(result.totalPixels).toBe(tc.parent);
-            expect(result.isExact).toBe(true);
-        }
-    });
-});

package/dist/runtime/__tests__/event-backpressure.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Tests for Q-Dimension Event Backpressure Control
- *
- * Validates:
- * 1. Event coalescing (latest-only sampling)
- * 2. Priority queue handling (critical events)
- * 3. Async event isolation and merging
- * 4. P/Q boundary enforcement (T-state keys only)
- */
-export {};