@stephen-netu/design-system 0.1.0 → 0.2.1

package/dist/spatial/ZoneTiler.svelte.d.ts

@@ -0,0 +1,27 @@
+import type { Snippet } from 'svelte';
+import type { BspNode, ZoneRect, ZoneTilerConfig, SplitDirection } from './zone-tiler-types.js';
+interface Props {
+    /** BSP tree defining the zone layout */
+    tree: BspNode;
+    /** Container width in px */
+    width: number;
+    /** Container height in px */
+    height: number;
+    /** Render callback for each zone — receives zone rect */
+    zoneContent: Snippet<[ZoneRect]>;
+    /** Configuration overrides */
+    config?: ZoneTilerConfig;
+    /** Currently focused zone id */
+    focusedZoneId?: string;
+    /** Fired when a divider is dragged and ratio changes */
+    onResize?: (tree: BspNode) => void;
+    /** Fired when focused zone changes (keyboard nav or click) */
+    onFocusChange?: (zoneId: string) => void;
+    /** Fired when user requests a zone split (Ctrl+Shift+H/V) */
+    onSplitRequest?: (zoneId: string, direction: SplitDirection) => void;
+}
+export type ZoneTilerProps = Props;
+declare const ZoneTiler: import("svelte").Component<Props, {}, "focusedZoneId">;
+type ZoneTiler = ReturnType<typeof ZoneTiler>;
+export default ZoneTiler;
+//# sourceMappingURL=ZoneTiler.svelte.d.ts.map

package/dist/spatial/ZoneTiler.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZoneTiler.svelte.d.ts","sourceRoot":"","sources":["../../src/spatial/ZoneTiler.svelte.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EACR,OAAO,EACP,QAAQ,EAER,eAAe,EAEf,cAAc,EACf,MAAM,uBAAuB,CAAC;AAM/B,UAAU,KAAK;IACb,wCAAwC;IACxC,IAAI,EAAE,OAAO,CAAC;IACd,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,WAAW,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjC,8BAA8B;IAC9B,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,gCAAgC;IAChC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,8DAA8D;IAC9D,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,6DAA6D;IAC7D,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,KAAK,IAAI,CAAC;CACtE;AAED,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC;AAsMrC,QAAA,MAAM,SAAS,wDAAwC,CAAC;AACxD,KAAK,SAAS,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC;AAC9C,eAAe,SAAS,CAAC"}

package/dist/spatial/camera-types.d.ts

@@ -0,0 +1,34 @@
+/** Camera state */
+export interface CameraState {
+    /** Current zoom factor (1.0 = default, higher = zoomed in) */
+    zoom: number;
+    /** Pan offset X in px */
+    panX: number;
+    /** Pan offset Y in px */
+    panY: number;
+}
+/** Snap-zoom target: center on a point at a specific zoom level */
+export interface SnapZoomTarget {
+    /** Target center X (in content coords, before zoom) */
+    x: number;
+    /** Target center Y (in content coords, before zoom) */
+    y: number;
+    /** Target zoom level */
+    zoom: number;
+    /** Easing duration in ms. Default 400. */
+    duration?: number;
+}
+/** Camera configuration */
+export interface CameraConfig {
+    /** Minimum zoom. Default 0.05. */
+    minZoom?: number;
+    /** Maximum zoom. Default 4.0. */
+    maxZoom?: number;
+    /** Zoom speed (scroll wheel multiplier). Default 0.001. */
+    zoomSpeed?: number;
+    /** Snap-zoom easing duration in ms. Default 400. */
+    snapDuration?: number;
+}
+/** Default camera config */
+export declare const DEFAULT_CAMERA_CONFIG: Required<CameraConfig>;
+//# sourceMappingURL=camera-types.d.ts.map

package/dist/spatial/camera-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-types.d.ts","sourceRoot":"","sources":["../../src/spatial/camera-types.ts"],"names":[],"mappings":"AAIA,mBAAmB;AACnB,MAAM,WAAW,WAAW;IAC1B,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,mEAAmE;AACnE,MAAM,WAAW,cAAc;IAC7B,uDAAuD;IACvD,CAAC,EAAE,MAAM,CAAC;IACV,uDAAuD;IACvD,CAAC,EAAE,MAAM,CAAC;IACV,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,2BAA2B;AAC3B,MAAM,WAAW,YAAY;IAC3B,kCAAkC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iCAAiC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,4BAA4B;AAC5B,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,YAAY,CAKxD,CAAC"}

package/dist/spatial/camera-types.js

@@ -0,0 +1,10 @@
+// SnapZoomCamera — viewport camera types
+// wt-903 implementation is Sonnet; types defined here for interface clarity.
+// S-02: No wall-clock for easing — use requestAnimationFrame tick count.
+/** Default camera config */
+export const DEFAULT_CAMERA_CONFIG = {
+    minZoom: 0.05,
+    maxZoom: 4.0,
+    zoomSpeed: 0.001,
+    snapDuration: 400,
+};

package/dist/spatial/content-proportional-bsp.d.ts

@@ -0,0 +1,46 @@
+import { type BlockMetrics } from '../x0-enchanted-blocks/core/block-layout.js';
+import type { BspNode, ZoneLeaf, SplitDirection, ZoneTilerConfig } from './zone-tiler-types.js';
+/** Content metadata attached to zones for proportional sizing */
+export interface ContentZone {
+    zone: ZoneLeaf;
+    content: string;
+    metrics?: BlockMetrics;
+    /** Effective area (width × height) for split ratio calculation */
+    contentArea: number;
+    /** When true, zone renders as compact indicator block */
+    isMinimized: boolean;
+}
+/** Configuration for content-proportional layout */
+export interface ProportionalBspConfig extends ZoneTilerConfig {
+    /** Minimum content area (px²) before zone becomes minimized block. Default: 10000 (100×100) */
+    minContentThreshold?: number;
+    /** Minimum zone dimension even for content-rich zones. Default: 80px */
+    absoluteMinZoneSize?: number;
+    /** Font for Pretext measurement. Default: system font */
+    measureFont?: string;
+    /** Max width constraint for content measurement. Default: 400px */
+    maxContentWidth?: number;
+}
+/** Build a BSP tree with splits proportional to content areas */
+export declare function buildProportionalBsp(zones: ContentZone[], direction?: SplitDirection, config?: ProportionalBspConfig): BspNode;
+/** Calculate zone sizing infographic data */
+export declare function generateSizingInfographic(zones: ContentZone[], containerWidth: number, containerHeight: number, config?: ProportionalBspConfig): SizingInfo[];
+/** Infographic data for each zone */
+export interface SizingInfo {
+    zoneId: string;
+    contentArea: number;
+    lines: number;
+    isMinimized: boolean;
+    fits: string[];
+    recommendedSize: string;
+}
+/**
+ * Predict proportional split ratio based on actual content areas
+ * Used to avoid static 50/50 splits
+ */
+export declare function calculateProportionalRatio(firstContent: string, secondContent: string, config?: ProportionalBspConfig): number;
+/**
+ * Split a leaf zone into two zones using text measurement to proportionalize the ratio
+ */
+export declare function splitZoneProportional(root: BspNode, targetId: string, direction: SplitDirection, newZone: ZoneLeaf, targetContent: string, newZoneContent: string, config?: ProportionalBspConfig): BspNode;
+//# sourceMappingURL=content-proportional-bsp.d.ts.map

package/dist/spatial/content-proportional-bsp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-proportional-bsp.d.ts","sourceRoot":"","sources":["../../src/spatial/content-proportional-bsp.ts"],"names":[],"mappings":"AAIA,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,6CAA6C,CAAC;AAC9F,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAEhG,iEAAiE;AACjE,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,oDAAoD;AACpD,MAAM,WAAW,qBAAsB,SAAQ,eAAe;IAC5D,+FAA+F;IAC/F,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,wEAAwE;IACxE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,iEAAiE;AACjE,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,WAAW,EAAE,EACpB,SAAS,GAAE,cAA6B,EACxC,MAAM,GAAE,qBAA0B,GACjC,OAAO,CA+CT;AA2FD,6CAA6C;AAC7C,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,WAAW,EAAE,EACpB,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,EACvB,MAAM,GAAE,qBAA0B,GACjC,UAAU,EAAE,CAwBd;AAED,qCAAqC;AACrC,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,OAAO,CAAC;IACrB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,MAAM,GAAE,qBAA0B,GACjC,MAAM,CAWR;AAID;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,cAAc,EACzB,OAAO,EAAE,QAAQ,EACjB,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,MAAM,EACtB,MAAM,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAGT"}

package/dist/spatial/content-proportional-bsp.js

@@ -0,0 +1,166 @@
+// Content-Proportional BSP — Zone sizing based on Pretext-measured content
+// Zones split proportionally to their content area, not equally
+// Tiny zones become "colored blocks" (indicators) when below minContentThreshold
+import { measureBlock } from '../x0-enchanted-blocks/core/block-layout.js';
+/** Build a BSP tree with splits proportional to content areas */
+export function buildProportionalBsp(zones, direction = 'horizontal', config = {}) {
+    const { minContentThreshold = 10000 } = config;
+    // Measure all content
+    const measured = zones.map(z => ({
+        ...z,
+        metrics: measureBlock(z.content, config.measureFont, config.maxContentWidth),
+    }));
+    // Calculate content areas
+    const withAreas = measured.map(z => {
+        const area = z.metrics ? z.metrics.idealWidth * z.metrics.height : 0;
+        return {
+            ...z,
+            contentArea: area,
+            isMinimized: area < minContentThreshold,
+        };
+    });
+    // Separate minimized blocks from full zones
+    const fullZones = withAreas.filter(z => !z.isMinimized);
+    const minimizedBlocks = withAreas.filter(z => z.isMinimized);
+    if (fullZones.length === 0) {
+        // All zones minimized — build equal BSP for colored blocks
+        return buildEqualBsp(minimizedBlocks.map(z => z.zone), direction);
+    }
+    // Build proportional tree for full zones
+    let tree = buildWeightedBsp(fullZones, direction);
+    // Add minimized blocks as a separate region if any exist
+    if (minimizedBlocks.length > 0) {
+        const minimizedTree = buildEqualBsp(minimizedBlocks.map(z => z.zone), direction === 'horizontal' ? 'vertical' : 'horizontal');
+        // Split to add minimized region (small portion)
+        tree = {
+            kind: 'split',
+            direction,
+            ratio: 0.85, // 85% to full zones, 15% to minimized
+            first: tree,
+            second: minimizedTree,
+        };
+    }
+    return tree;
+}
+/** Build BSP with splits weighted by content area */
+function buildWeightedBsp(zones, direction) {
+    if (zones.length === 0) {
+        throw new Error('Cannot build BSP from empty zones');
+    }
+    if (zones.length === 1) {
+        return zones[0].zone;
+    }
+    // Sort by content area descending
+    const sorted = [...zones].sort((a, b) => b.contentArea - a.contentArea);
+    const totalArea = sorted.reduce((sum, z) => sum + z.contentArea, 0);
+    // Find split point that balances area on each side
+    let accumulated = 0;
+    let splitIndex = 0;
+    const halfArea = totalArea / 2;
+    for (let i = 0; i < sorted.length; i++) {
+        accumulated += sorted[i].contentArea;
+        if (accumulated >= halfArea) {
+            splitIndex = i + 1;
+            break;
+        }
+    }
+    // Ensure at least one zone on each side
+    splitIndex = Math.max(1, Math.min(splitIndex, sorted.length - 1));
+    const firstGroup = sorted.slice(0, splitIndex);
+    const secondGroup = sorted.slice(splitIndex);
+    // Calculate split ratio based on area proportions
+    const firstArea = firstGroup.reduce((sum, z) => sum + z.contentArea, 0);
+    const ratio = firstArea / totalArea;
+    // Recursively build subtrees
+    const firstNode = firstGroup.length === 1
+        ? firstGroup[0].zone
+        : buildWeightedBsp(firstGroup, flipDirection(direction));
+    const secondNode = secondGroup.length === 1
+        ? secondGroup[0].zone
+        : buildWeightedBsp(secondGroup, flipDirection(direction));
+    return {
+        kind: 'split',
+        direction,
+        ratio: Math.max(0.1, Math.min(0.9, ratio)), // Clamp between 10-90%
+        first: firstNode,
+        second: secondNode,
+    };
+}
+/** Build equal-split BSP (for minimized blocks) */
+function buildEqualBsp(zones, direction) {
+    if (zones.length === 0) {
+        throw new Error('Cannot build BSP from empty zones');
+    }
+    if (zones.length === 1) {
+        return zones[0];
+    }
+    const mid = Math.floor(zones.length / 2);
+    const firstGroup = zones.slice(0, mid);
+    const secondGroup = zones.slice(mid);
+    const firstNode = firstGroup.length === 1
+        ? firstGroup[0]
+        : buildEqualBsp(firstGroup, flipDirection(direction));
+    const secondNode = secondGroup.length === 1
+        ? secondGroup[0]
+        : buildEqualBsp(secondGroup, flipDirection(direction));
+    return {
+        kind: 'split',
+        direction,
+        ratio: 0.5,
+        first: firstNode,
+        second: secondNode,
+    };
+}
+/** Alternate split direction */
+function flipDirection(d) {
+    return d === 'horizontal' ? 'vertical' : 'horizontal';
+}
+/** Calculate zone sizing infographic data */
+export function generateSizingInfographic(zones, containerWidth, containerHeight, config = {}) {
+    const { minContentThreshold = 10000 } = config;
+    return zones.map(z => {
+        const metrics = measureBlock(z.content, config.measureFont, config.maxContentWidth);
+        const area = metrics.idealWidth * metrics.height;
+        const isMinimized = area < minContentThreshold;
+        // Calculate what fits
+        const fits = [];
+        if (metrics.lineCount >= 1)
+            fits.push('Title');
+        if (metrics.lineCount >= 3)
+            fits.push('Preview');
+        if (metrics.lineCount >= 8)
+            fits.push('Full content');
+        if (area > minContentThreshold)
+            fits.push('Edit mode');
+        return {
+            zoneId: z.zone.id,
+            contentArea: area,
+            lines: metrics.lineCount,
+            isMinimized,
+            fits,
+            recommendedSize: isMinimized ? '40×40' : `${Math.round(metrics.idealWidth)}×${Math.round(metrics.height)}`,
+        };
+    });
+}
+/**
+ * Predict proportional split ratio based on actual content areas
+ * Used to avoid static 50/50 splits
+ */
+export function calculateProportionalRatio(firstContent, secondContent, config = {}) {
+    const m1 = measureBlock(firstContent, config.measureFont, config.maxContentWidth);
+    const m2 = measureBlock(secondContent, config.measureFont, config.maxContentWidth);
+    const area1 = m1.idealWidth * m1.height;
+    const area2 = m2.idealWidth * m2.height;
+    if (area1 + area2 === 0)
+        return 0.5;
+    const ratio = area1 / (area1 + area2);
+    return Math.max(0.1, Math.min(0.9, ratio));
+}
+import { splitZone } from './zone-tiler-types.js';
+/**
+ * Split a leaf zone into two zones using text measurement to proportionalize the ratio
+ */
+export function splitZoneProportional(root, targetId, direction, newZone, targetContent, newZoneContent, config) {
+    const ratio = calculateProportionalRatio(targetContent, newZoneContent, config);
+    return splitZone(root, targetId, direction, newZone, ratio);
+}

package/dist/spatial/force-canvas-types.d.ts

@@ -0,0 +1,65 @@
+/** A cell in the force simulation */
+export interface ForceCell {
+    id: string;
+    label: string;
+    /** Content type for visual differentiation */
+    contentType: 'text' | 'code' | 'url' | 'image' | 'filepath';
+    /** Visual weight — controls rendered size. Integer permille (0–1000). */
+    weight: number;
+    /** Embedding vector for semantic distance computation. Null = no embedding yet. */
+    embedding: number[] | null;
+    /** Pinned position (user-placed). Set fx/fy to pin. */
+    fx?: number | null;
+    fy?: number | null;
+    /** Arbitrary data for rendering */
+    data?: Record<string, unknown>;
+    x?: number;
+    y?: number;
+    vx?: number;
+    vy?: number;
+    index?: number;
+}
+/** Semantic link between cells (derived from embedding distance) */
+export interface ForceLink {
+    source: string;
+    target: string;
+    /** Semantic distance (0 = identical, 1 = unrelated). Drives spring length. */
+    distance: number;
+}
+/** ForceCanvas configuration */
+export interface ForceCanvasConfig {
+    /** Charge strength (repulsion between cells). Default -80. */
+    chargeStrength?: number;
+    /** Collision radius padding in px. Default 4. */
+    collisionPadding?: number;
+    /** Wall force margin in px (repulsion from zone boundary). Default 20. */
+    wallMargin?: number;
+    /** Wall force strength. Default 0.3. */
+    wallStrength?: number;
+    /** Minimum spring length (px) for highly similar content. Default 30. */
+    minSpringLength?: number;
+    /** Maximum spring length (px) for unrelated content. Default 200. */
+    maxSpringLength?: number;
+    /** Maximum simulation iterations per tick. Default 300. S-05 bound. */
+    maxIterations?: number;
+    /** Velocity decay (0–1). Default 0.4. Higher = more friction. */
+    velocityDecay?: number;
+    /** Initial velocity for newly added cells. Default 0.1. */
+    entryVelocity?: number;
+}
+/** Computed cell position for rendering */
+export interface CellPosition {
+    cell: ForceCell;
+    x: number;
+    y: number;
+    radius: number;
+}
+/** Convert cosine similarity to spring length.
+ *  similarity 1.0 → minSpringLength, similarity 0.0 → maxSpringLength */
+export declare function semanticSpringLength(similarity: number, minLength: number, maxLength: number): number;
+/** Compute cosine similarity between two embedding vectors.
+ *  Returns 0 if either vector is null or empty. */
+export declare function cosineSimilarity(a: number[] | null, b: number[] | null): number;
+/** Weight permille → rendered radius in px */
+export declare function weightToRadius(permille: number, baseRadius?: number): number;
+//# sourceMappingURL=force-canvas-types.d.ts.map

package/dist/spatial/force-canvas-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"force-canvas-types.d.ts","sourceRoot":"","sources":["../../src/spatial/force-canvas-types.ts"],"names":[],"mappings":"AAIA,qCAAqC;AACrC,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,UAAU,CAAC;IAC5D,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;IACf,mFAAmF;IACnF,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC3B,uDAAuD;IACvD,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,mCAAmC;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE/B,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,oEAAoE;AACpE,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,gCAAgC;AAChC,MAAM,WAAW,iBAAiB;IAChC,8DAA8D;IAC9D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qEAAqE;IACrE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,2CAA2C;AAC3C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;CAChB;AAID;yEACyE;AACzE,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAGR;AAED;mDACmD;AACnD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,MAAM,CAc/E;AAED,8CAA8C;AAC9C,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAI,GAAG,MAAM,CAIvE"}

package/dist/spatial/force-canvas-types.js

@@ -0,0 +1,32 @@
+// ForceCanvas — d3-force simulation types for spatial content layout
+// S-02: Integer permille for weights. Monotonic counter for tick. No Math.random.
+// S-05: Simulation has bounded iteration count per tick.
+// ── Semantic distance → spring length ──────────────────────────────────────
+/** Convert cosine similarity to spring length.
+ *  similarity 1.0 → minSpringLength, similarity 0.0 → maxSpringLength */
+export function semanticSpringLength(similarity, minLength, maxLength) {
+    const clamped = Math.max(0, Math.min(1, similarity));
+    return maxLength - clamped * (maxLength - minLength);
+}
+/** Compute cosine similarity between two embedding vectors.
+ *  Returns 0 if either vector is null or empty. */
+export function cosineSimilarity(a, b) {
+    if (!a || !b || a.length === 0 || b.length === 0 || a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let magA = 0;
+    let magB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        magA += a[i] * a[i];
+        magB += b[i] * b[i];
+    }
+    const denom = Math.sqrt(magA) * Math.sqrt(magB);
+    return denom === 0 ? 0 : dot / denom;
+}
+/** Weight permille → rendered radius in px */
+export function weightToRadius(permille, baseRadius = 8) {
+    // weight 500 → baseRadius, scales sqrt for area proportionality
+    const normalized = Math.max(100, Math.min(1000, permille)) / 500;
+    return baseRadius * Math.sqrt(normalized);
+}

package/dist/spatial/index.d.ts

@@ -0,0 +1,9 @@
+export * from './zone-tiler-types.js';
+export * from './force-canvas-types.js';
+export * from './lod-types.js';
+export * from './camera-types.js';
+export * from './content-proportional-bsp.js';
+export { ForceSimulation } from './ForceSimulation.svelte.js';
+export { BspTilingSimulation } from './BspTilingSimulation.svelte.js';
+export { CameraController } from './CameraController.svelte.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/spatial/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spatial/index.ts"],"names":[],"mappings":"AAGA,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,+BAA+B,CAAC;AAG9C,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC"}

package/{src/spatial/index.ts → dist/spatial/index.js}

@@ -1,12 +1,14 @@
 // Spatial primitives — BSP zone tiling, force-directed layout, LOD rendering, snap-zoom camera
 // Consumed by Loge first; available to Atelier and future apps.
-
 export * from './zone-tiler-types.js';
 export * from './force-canvas-types.js';
 export * from './lod-types.js';
 export * from './camera-types.js';
 export * from './content-proportional-bsp.js';
-
+// S0-lifecycle store implementations
+export { ForceSimulation } from './ForceSimulation.svelte.js';
+export { BspTilingSimulation } from './BspTilingSimulation.svelte.js';
+export { CameraController } from './CameraController.svelte.js';
 // Components are imported directly:
 //   import ZoneTiler from '@kos/design-system/spatial/ZoneTiler.svelte';
 //   import ForceCanvas from '@kos/design-system/spatial/ForceCanvas.svelte';

package/dist/spatial/lod-types.d.ts

@@ -0,0 +1,39 @@
+/** Discrete LOD levels */
+export type LodLevel = 0 | 1 | 2 | 3;
+/** Zoom thresholds for LOD transitions */
+export interface LodThresholds {
+    /** Zoom >= l0 → L0 (full). Default 0.8. */
+    l0: number;
+    /** Zoom >= l1 → L1 (compact). Default 0.4. */
+    l1: number;
+    /** Zoom >= l2 → L2 (dot/chip). Default 0.15. */
+    l2: number;
+}
+/** Default LOD thresholds matching ADR spec */
+export declare const DEFAULT_LOD_THRESHOLDS: LodThresholds;
+/** LOD renderer configuration */
+export interface LodRendererConfig {
+    /** Zoom thresholds */
+    thresholds?: LodThresholds;
+    /** Cross-fade transition duration in ms. Default 300. */
+    crossFadeDuration?: number;
+}
+/** Per-cell LOD state tracked by the renderer */
+export interface CellLodState {
+    cellId: string;
+    /** Current active LOD level */
+    currentLevel: LodLevel;
+    /** Previous LOD level (for cross-fade) */
+    previousLevel: LodLevel | null;
+    /** Transition progress: 0 = showing previous, 1 = showing current. Null if not transitioning. */
+    transitionProgress: number | null;
+    /** Timestamp when transition started */
+    transitionStart: number | null;
+}
+/** Resolve zoom factor to LOD level */
+export declare function zoomToLod(zoom: number, thresholds?: LodThresholds): LodLevel;
+/** LOD level descriptions for accessibility */
+export declare const LOD_DESCRIPTIONS: Record<LodLevel, string>;
+/** L2 chip: 2-letter abbreviation from label */
+export declare function chipAbbrev(label: string): string;
+//# sourceMappingURL=lod-types.d.ts.map

package/dist/spatial/lod-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lod-types.d.ts","sourceRoot":"","sources":["../../src/spatial/lod-types.ts"],"names":[],"mappings":"AAIA,0BAA0B;AAC1B,MAAM,MAAM,QAAQ,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAErC,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,8CAA8C;IAC9C,EAAE,EAAE,MAAM,CAAC;IACX,gDAAgD;IAChD,EAAE,EAAE,MAAM,CAAC;CAEZ;AAED,+CAA+C;AAC/C,eAAO,MAAM,sBAAsB,EAAE,aAIpC,CAAC;AAEF,iCAAiC;AACjC,MAAM,WAAW,iBAAiB;IAChC,sBAAsB;IACtB,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,yDAAyD;IACzD,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,iDAAiD;AACjD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,YAAY,EAAE,QAAQ,CAAC;IACvB,0CAA0C;IAC1C,aAAa,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC/B,iGAAiG;IACjG,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,wCAAwC;IACxC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,uCAAuC;AACvC,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,GAAE,aAAsC,GAAG,QAAQ,CAKpG;AAED,+CAA+C;AAC/C,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAKrD,CAAC;AAEF,gDAAgD;AAChD,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMhD"}

package/dist/spatial/lod-types.js

@@ -0,0 +1,34 @@
+// LodRenderer — Level of Detail types
+// S-02: Integer permille for health/weight. Deterministic tick counter for animation.
+// Pure TypeScript — no Svelte, no DOM.
+/** Default LOD thresholds matching ADR spec */
+export const DEFAULT_LOD_THRESHOLDS = {
+    l0: 0.8,
+    l1: 0.4,
+    l2: 0.15,
+};
+/** Resolve zoom factor to LOD level */
+export function zoomToLod(zoom, thresholds = DEFAULT_LOD_THRESHOLDS) {
+    if (zoom >= thresholds.l0)
+        return 0;
+    if (zoom >= thresholds.l1)
+        return 1;
+    if (zoom >= thresholds.l2)
+        return 2;
+    return 3;
+}
+/** LOD level descriptions for accessibility */
+export const LOD_DESCRIPTIONS = {
+    0: 'Full: editable cell with titlebar and resize handles',
+    1: 'Compact: title, type icon, first-line preview',
+    2: 'Chip: colored circle with abbreviation',
+    3: 'Pixel field: heat-mapped color mosaic',
+};
+/** L2 chip: 2-letter abbreviation from label */
+export function chipAbbrev(label) {
+    const words = label.trim().split(/\s+/);
+    if (words.length >= 2) {
+        return (words[0][0] + words[1][0]).toUpperCase();
+    }
+    return label.slice(0, 2).toUpperCase();
+}

package/dist/spatial/zone-tiler-types.d.ts

@@ -0,0 +1,70 @@
+/** Privacy state matching Rust SealState enum */
+export type PrivacyState = 'ouvert' | 'scelle';
+/** Leaf node — a visible zone */
+export interface ZoneLeaf {
+    kind: 'leaf';
+    id: string;
+    label: string;
+    /** Optional tint for zone background. Ouvert zones derive color from content; Scelle uses fixed hazard treatment. */
+    colorTint?: string;
+    privacyState: PrivacyState;
+}
+/** Split direction */
+export type SplitDirection = 'horizontal' | 'vertical';
+/** Internal split node — divides space into two children */
+export interface ZoneSplit {
+    kind: 'split';
+    direction: SplitDirection;
+    /** Divider position as fraction (0–1) of parent dimension */
+    ratio: number;
+    first: BspNode;
+    second: BspNode;
+}
+/** A BSP tree node: either a leaf zone or a split */
+export type BspNode = ZoneLeaf | ZoneSplit;
+/** Computed zone rectangle (absolute pixel coords within container) */
+export interface ZoneRect {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    zone: ZoneLeaf;
+}
+/** Computed divider rectangle for hit-testing and rendering */
+export interface DividerRect {
+    /** Path from root to this split (for identity) */
+    path: string;
+    direction: SplitDirection;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Reference to parent split for ratio mutation */
+    splitRef: ZoneSplit;
+}
+/** ZoneTiler configuration */
+export interface ZoneTilerConfig {
+    /** Minimum zone dimension in px. Default 120. */
+    minZoneSize?: number;
+    /** Divider thickness in px. Default 6. */
+    dividerThickness?: number;
+    /** Divider hit-area expansion in px (each side). Default 4. */
+    dividerHitExpand?: number;
+}
+/** Flatten a BSP tree into leaf zones with computed rectangles */
+export declare function flattenBsp(node: BspNode, x: number, y: number, w: number, h: number, dividerThickness: number): {
+    zones: ZoneRect[];
+    dividers: DividerRect[];
+};
+/** Find a zone leaf by id in the BSP tree */
+export declare function findZone(node: BspNode, id: string): ZoneLeaf | null;
+/** Create a default single-zone BSP tree */
+export declare function createDefaultBsp(id?: string, label?: string): ZoneLeaf;
+/** Split a leaf zone into two zones. Returns a new BSP tree (immutable). */
+export declare function splitZone(root: BspNode, targetId: string, direction: SplitDirection, newZone: ZoneLeaf, ratio?: number): BspNode;
+/** Serialize BSP tree to JSON (for desk persistence) */
+export declare function serializeBsp(node: BspNode): string;
+/** Deserialize BSP tree from JSON */
+export declare function deserializeBsp(json: string): BspNode;
+//# sourceMappingURL=zone-tiler-types.d.ts.map

package/dist/spatial/zone-tiler-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone-tiler-types.d.ts","sourceRoot":"","sources":["../../src/spatial/zone-tiler-types.ts"],"names":[],"mappings":"AAIA,iDAAiD;AACjD,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE/C,iCAAiC;AACjC,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,qHAAqH;IACrH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED,sBAAsB;AACtB,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,UAAU,CAAC;AAEvD,4DAA4D;AAC5D,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,cAAc,CAAC;IAC1B,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,qDAAqD;AACrD,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE3C,uEAAuE;AACvE,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,+DAA+D;AAC/D,MAAM,WAAW,WAAW;IAC1B,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,cAAc,CAAC;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,8BAA8B;AAC9B,MAAM,WAAW,eAAe;IAC9B,iDAAiD;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,+DAA+D;IAC/D,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID,kEAAkE;AAClE,wBAAgB,UAAU,CACxB,IAAI,EAAE,OAAO,EACb,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,gBAAgB,EAAE,MAAM,GACvB;IAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IAAC,QAAQ,EAAE,WAAW,EAAE,CAAA;CAAE,CAoDhD;AAED,6CAA6C;AAC7C,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAGnE;AAED,4CAA4C;AAC5C,wBAAgB,gBAAgB,CAAC,EAAE,SAAS,EAAE,KAAK,SAAS,GAAG,QAAQ,CAEtE;AAED,4EAA4E;AAC5E,wBAAgB,SAAS,CACvB,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,cAAc,EACzB,OAAO,EAAE,QAAQ,EACjB,KAAK,SAAM,GACV,OAAO,CAkBT;AAED,wDAAwD;AACxD,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAElD;AAED,qCAAqC;AACrC,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD"}