@stephen-netu/design-system 0.1.0 → 0.2.1

package/dist/n1-flow-canvas/graph-state.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { NodeLayout, LayoutResult, GraphStateApi } from './types.js';
+export declare class GraphState implements GraphStateApi {
+    positions: Map<string, NodeLayout>;
+    bfsOrder: readonly string[];
+    focusCenterId: string | null;
+    layoutRootId: string | null;
+    private _targets;
+    private _rafId;
+    private _frameCount;
+    onLayoutRootChange: ((nodeId: string) => void) | null;
+    applyLayout(result: LayoutResult): void;
+    setFocusCenter(nodeId: string): void;
+    setLayoutRoot(nodeId: string): void;
+    private _startAnimation;
+    private _tick;
+    destroy(): void;
+}
+//# sourceMappingURL=graph-state.svelte.d.ts.map

package/dist/n1-flow-canvas/graph-state.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-state.svelte.d.ts","sourceRoot":"","sources":["../../src/n1-flow-canvas/graph-state.svelte.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAM1E,qBAAa,UAAW,YAAW,aAAa;IAC9C,SAAS,0BAA8C;IACvD,QAAQ,oBAAsC;IAG9C,aAAa,gBAAgC;IAC7C,YAAY,gBAAiC;IAE7C,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,WAAW,CAAK;IAGxB,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;IAE7D,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAOvC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAKpC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAOnC,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,KAAK,CAqCX;IAEF,OAAO,IAAI,IAAI;CAMhB"}

package/dist/n1-flow-canvas/graph-state.svelte.js

@@ -0,0 +1,81 @@
+// N1 GraphState — Svelte 5 runes, Spring-animated node positions
+// S-02: positions lerped deterministically via rAF loop (no Math.random)
+// S-05: animation loop bounded by convergence threshold
+const LERP_FACTOR = 0.12; // per frame (bounded, S-05)
+const SETTLE_THRESH = 0.5; // pixels — stop animating below this delta
+const MAX_FRAMES = 240; // ~4s at 60fps hard cap (S-05 killability)
+export class GraphState {
+    positions = $state(new Map());
+    bfsOrder = $state([]);
+    // Focus semantics
+    focusCenterId = $state(null);
+    layoutRootId = $state(null);
+    _targets = new Map();
+    _rafId = null;
+    _frameCount = 0;
+    // Callback invoked by FlowCanvas when layoutRootId changes
+    onLayoutRootChange = null;
+    applyLayout(result) {
+        this._targets = new Map(result.positions);
+        this.bfsOrder = result.bfsOrder;
+        this._frameCount = 0;
+        this._startAnimation();
+    }
+    setFocusCenter(nodeId) {
+        // Re-centers Poincaré disk — does NOT trigger re-layout
+        this.focusCenterId = nodeId;
+    }
+    setLayoutRoot(nodeId) {
+        this.layoutRootId = nodeId;
+        this.onLayoutRootChange?.(nodeId);
+    }
+    // ── Animation ──────────────────────────────────────────────────────────────
+    _startAnimation() {
+        if (this._rafId !== null)
+            cancelAnimationFrame(this._rafId);
+        this._tick();
+    }
+    _tick = () => {
+        if (this._frameCount >= MAX_FRAMES) {
+            // Force-snap to targets on hard cap (S-05)
+            this.positions = new Map(this._targets);
+            this._rafId = null;
+            return;
+        }
+        let maxDelta = 0;
+        const next = new Map();
+        for (const [id, target] of this._targets) {
+            const current = this.positions.get(id);
+            if (!current) {
+                // First appearance — snap directly, no lerp
+                next.set(id, { ...target });
+                continue;
+            }
+            const nx = current.x + (target.x - current.x) * LERP_FACTOR;
+            const ny = current.y + (target.y - current.y) * LERP_FACTOR;
+            const dx = Math.abs(target.x - nx);
+            const dy = Math.abs(target.y - ny);
+            if (dx > maxDelta)
+                maxDelta = dx;
+            if (dy > maxDelta)
+                maxDelta = dy;
+            next.set(id, { id, x: nx, y: ny, width: target.width, height: target.height });
+        }
+        this.positions = next;
+        this._frameCount++;
+        if (maxDelta > SETTLE_THRESH) {
+            this._rafId = requestAnimationFrame(this._tick);
+        }
+        else {
+            // Settled — snap to exact targets
+            this.positions = new Map(this._targets);
+            this._rafId = null;
+        }
+    };
+    destroy() {
+        if (this._rafId !== null) {
+            cancelAnimationFrame(this._rafId);
+            this._rafId = null;
+        }
+    }
+}

package/dist/n1-flow-canvas/index.d.ts

@@ -0,0 +1,6 @@
+export type { GraphNode, GraphEdge, GraphSnapshot, NodeLayout, LayoutResult, WorkerIn, WorkerOut, WorkerMessage, GraphStateApi, EdgeRevealState, } from './types.js';
+export { EDGE_REVEAL_STAGGER_MS } from './types.js';
+export { default as FlowCanvas } from './FlowCanvas.svelte';
+export { GraphState } from './graph-state.svelte';
+export { nodeHitTest, domEventToCanvasCoords, parseMentionEdges, parseGroupedSequenceEdges } from './utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/n1-flow-canvas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/n1-flow-canvas/index.ts"],"names":[],"mappings":"AAGA,YAAY,EACV,SAAS,EACT,SAAS,EACT,aAAa,EACb,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,aAAa,EACb,aAAa,EACb,eAAe,GAChB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEpD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC"}

package/{src/n1-flow-canvas/index.ts → dist/n1-flow-canvas/index.js}

@@ -1,21 +1,6 @@
 // N1 Flow Canvas — Canvas 2D graph with ELK layout + BFS edge reveal
 // Depends on: graphology, elkjs, perfect-arrows, svelte-canvas
-
-export type {
-  GraphNode,
-  GraphEdge,
-  GraphSnapshot,
-  NodeLayout,
-  LayoutResult,
-  WorkerIn,
-  WorkerOut,
-  WorkerMessage,
-  GraphStateApi,
-  EdgeRevealState,
-} from './types.js';
-
 export { EDGE_REVEAL_STAGGER_MS } from './types.js';
-
 export { default as FlowCanvas } from './FlowCanvas.svelte';
 export { GraphState } from './graph-state.svelte';
 export { nodeHitTest, domEventToCanvasCoords, parseMentionEdges, parseGroupedSequenceEdges } from './utils.js';

package/dist/n1-flow-canvas/layout.d.ts

@@ -0,0 +1,4 @@
+import type { LayoutResult } from './types.js';
+import type { GraphSnapshot } from './types.js';
+export declare function runLayout(snapshot: GraphSnapshot, _canvasWidth: number, _canvasHeight: number): Promise<LayoutResult>;
+//# sourceMappingURL=layout.d.ts.map

package/dist/n1-flow-canvas/layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../src/n1-flow-canvas/layout.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,YAAY,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,YAAY,CAAC;AAkDtE,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,aAAa,EACvB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,YAAY,CAAC,CAwDvB"}

package/dist/n1-flow-canvas/layout.js

@@ -0,0 +1,95 @@
+// N1 layout — ELK-based graph layout + BFS order
+// Runs on the main thread (ELK is async/Promise-based; won't block UI).
+// Extracted from layout.worker.ts so FlowCanvas can call it directly,
+// avoiding nested Worker creation which fails in Tauri's WKWebView.
+import ELK from 'elkjs/lib/elk.bundled.js';
+const elk = new ELK();
+// ── BFS ───────────────────────────────────────────────────────────────────────
+function computeBfsOrder(nodes, edges, startId) {
+    const adj = new Map();
+    for (const n of nodes)
+        adj.set(n.id, []);
+    for (const e of edges) {
+        const neighbors = adj.get(e.sourceId);
+        if (neighbors)
+            neighbors.push(e.targetId);
+    }
+    const rootId = startId ?? nodes[0]?.id;
+    if (!rootId)
+        return [];
+    const visited = new Set();
+    const queue = [rootId];
+    const order = [];
+    visited.add(rootId);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        order.push(current);
+        const neighbors = (adj.get(current) ?? []).slice().sort(); // S-02: deterministic
+        for (const neighbor of neighbors) {
+            if (!visited.has(neighbor)) {
+                visited.add(neighbor);
+                queue.push(neighbor);
+            }
+        }
+    }
+    for (const n of nodes) {
+        if (!visited.has(n.id))
+            order.push(n.id);
+    }
+    return order;
+}
+// ── ELK layout ────────────────────────────────────────────────────────────────
+const NODE_WIDTH = 120;
+const NODE_HEIGHT = 60;
+export async function runLayout(snapshot, _canvasWidth, _canvasHeight) {
+    const elkGraph = {
+        id: 'root',
+        layoutOptions: {
+            'elk.algorithm': 'layered',
+            'elk.direction': 'RIGHT',
+            'elk.spacing.nodeNode': '30',
+            'elk.layered.spacing.nodeNodeBetweenLayers': '80',
+            'elk.padding': '[top=40,left=40,bottom=40,right=40]',
+            'elk.layered.nodePlacement.strategy': 'BRANDES_KOEPF',
+        },
+        children: snapshot.nodes.map(n => ({
+            id: n.id,
+            width: NODE_WIDTH,
+            height: NODE_HEIGHT,
+        })),
+        edges: snapshot.edges.map(e => ({
+            id: e.id,
+            sources: [e.sourceId],
+            targets: [e.targetId],
+        })),
+    };
+    const result = await elk.layout(elkGraph);
+    const positions = new Map();
+    for (const child of result.children ?? []) {
+        if (child.x !== undefined && child.y !== undefined) {
+            positions.set(child.id, {
+                id: child.id,
+                x: child.x,
+                y: child.y,
+                width: child.width ?? NODE_WIDTH,
+                height: child.height ?? NODE_HEIGHT,
+            });
+        }
+    }
+    // Grid fallback for nodes ELK dropped (should not happen)
+    let col = 0;
+    for (const n of snapshot.nodes) {
+        if (!positions.has(n.id)) {
+            positions.set(n.id, {
+                id: n.id,
+                x: 40 + col * (NODE_WIDTH + 40),
+                y: 40,
+                width: NODE_WIDTH,
+                height: NODE_HEIGHT,
+            });
+            col++;
+        }
+    }
+    const bfsOrder = computeBfsOrder(snapshot.nodes, snapshot.edges, snapshot.focusNodeId);
+    return { positions, bfsOrder };
+}

package/dist/n1-flow-canvas/layout.worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=layout.worker.d.ts.map

package/dist/n1-flow-canvas/layout.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.worker.d.ts","sourceRoot":"","sources":["../../src/n1-flow-canvas/layout.worker.ts"],"names":[],"mappings":""}

package/dist/n1-flow-canvas/layout.worker.js

@@ -0,0 +1,106 @@
+// N1 Layout Worker — ELK.js layout + BFS traversal order
+// Runs in a dedicated Web Worker (mandatory at mount, never on main thread)
+// S-02: BFS neighbors sorted before enqueue for deterministic order
+import ELK from 'elkjs/lib/elk.bundled.js';
+const elk = new ELK();
+// ── BFS ───────────────────────────────────────────────────────────────────────
+function computeBfsOrder(nodes, edges, startId) {
+    // Build adjacency with Map (S-02: no object spread iteration)
+    const adj = new Map();
+    for (const n of nodes)
+        adj.set(n.id, []);
+    for (const e of edges) {
+        const neighbors = adj.get(e.sourceId);
+        if (neighbors)
+            neighbors.push(e.targetId);
+    }
+    // Root: prefer explicit startId, fall back to first node in declaration order
+    const rootId = startId ?? nodes[0]?.id;
+    if (!rootId)
+        return [];
+    const visited = new Set();
+    const queue = [rootId];
+    const order = [];
+    visited.add(rootId);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        order.push(current);
+        // Sort neighbors for determinism (S-02)
+        const neighbors = (adj.get(current) ?? []).slice().sort();
+        for (const neighbor of neighbors) {
+            if (!visited.has(neighbor)) {
+                visited.add(neighbor);
+                queue.push(neighbor);
+            }
+        }
+    }
+    // Append any unreachable nodes in declaration order (disconnected subgraphs)
+    for (const n of nodes) {
+        if (!visited.has(n.id))
+            order.push(n.id);
+    }
+    return order;
+}
+// ── ELK layout ────────────────────────────────────────────────────────────────
+const NODE_WIDTH = 120;
+const NODE_HEIGHT = 60;
+async function runLayout(snapshot, canvasWidth, canvasHeight) {
+    const elkGraph = {
+        id: 'root',
+        layoutOptions: {
+            'elk.algorithm': 'layered',
+            'elk.direction': 'DOWN',
+            'elk.spacing.nodeNode': '40',
+            'elk.layered.spacing.nodeNodeBetweenLayers': '60',
+            'elk.padding': '[top=40,left=40,bottom=40,right=40]',
+        },
+        children: snapshot.nodes.map(n => ({
+            id: n.id,
+            width: NODE_WIDTH,
+            height: NODE_HEIGHT,
+        })),
+        edges: snapshot.edges.map(e => ({
+            id: e.id,
+            sources: [e.sourceId],
+            targets: [e.targetId],
+        })),
+    };
+    const result = await elk.layout(elkGraph);
+    const positions = new Map();
+    for (const child of result.children ?? []) {
+        if (child.x !== undefined && child.y !== undefined) {
+            positions.set(child.id, {
+                id: child.id,
+                x: child.x,
+                y: child.y,
+                width: child.width ?? NODE_WIDTH,
+                height: child.height ?? NODE_HEIGHT,
+            });
+        }
+    }
+    // Fall back: place unmapped nodes in a grid (ELK dropped them — shouldn't happen)
+    let col = 0;
+    for (const n of snapshot.nodes) {
+        if (!positions.has(n.id)) {
+            positions.set(n.id, {
+                id: n.id,
+                x: 40 + col * (NODE_WIDTH + 40),
+                y: 40,
+                width: NODE_WIDTH,
+                height: NODE_HEIGHT,
+            });
+            col++;
+        }
+    }
+    const bfsOrder = computeBfsOrder(snapshot.nodes, snapshot.edges, snapshot.focusNodeId);
+    return { positions, bfsOrder };
+}
+// ── Worker message loop ───────────────────────────────────────────────────────
+self.onmessage = async (event) => {
+    const msg = event.data;
+    if (msg.type !== 'layout')
+        return;
+    const result = await runLayout(msg.snapshot, msg.canvasWidth, msg.canvasHeight);
+    const out = { type: 'layout_result', result };
+    self.postMessage(out);
+};

package/dist/n1-flow-canvas/types.d.ts

@@ -0,0 +1,65 @@
+import type { Point, Size } from '../p0-primitives/types/geometry';
+export type { Point, Size };
+export interface GraphNode {
+    id: string;
+    label: string;
+    /** Optional semantic data (task status, flow phase, etc.) */
+    data: Record<string, unknown>;
+}
+export interface GraphEdge {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    /** Optional: task wt-NNN dependency references */
+    label?: string;
+}
+export interface GraphSnapshot {
+    readonly nodes: ReadonlyArray<GraphNode>;
+    readonly edges: ReadonlyArray<GraphEdge>;
+    /** Node id used as layout/BFS root */
+    readonly focusNodeId: string | null;
+}
+export interface NodeLayout {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface LayoutResult {
+    /** Euclidean positions from ELK, keyed by node id */
+    positions: Map<string, NodeLayout>;
+    /** BFS traversal order starting from focusNodeId (or arbitrary root if null) */
+    bfsOrder: ReadonlyArray<string>;
+}
+export interface WorkerIn {
+    type: 'layout';
+    snapshot: GraphSnapshot;
+    /** Canvas dimensions for ELK bounds */
+    canvasWidth: number;
+    canvasHeight: number;
+}
+export interface WorkerOut {
+    type: 'layout_result';
+    result: LayoutResult;
+}
+export type WorkerMessage = WorkerIn | WorkerOut;
+export interface GraphStateApi {
+    /** Current node positions (Spring targets). Read these for rendering. */
+    readonly positions: Map<string, NodeLayout>;
+    /** Current BFS order for edge reveal animation */
+    readonly bfsOrder: ReadonlyArray<string>;
+    /** Update Spring targets from a completed layout. Does NOT reset current positions. */
+    applyLayout(result: LayoutResult): void;
+    /** Re-center Poincaré disk on this node. Does NOT trigger re-layout. */
+    setFocusCenter(nodeId: string): void;
+    /** Mark ELK layout root. Triggers worker re-compute. */
+    setLayoutRoot(nodeId: string): void;
+}
+export interface EdgeRevealState {
+    /** Edge id → current lineDashOffset (0.0 = fully drawn, 1.0 = hidden) */
+    offsets: Map<string, number>;
+}
+/** Stagger delay per BFS wave step (ms). Deterministic — no Math.random. */
+export declare const EDGE_REVEAL_STAGGER_MS = 30;
+//# sourceMappingURL=types.d.ts.map

package/dist/n1-flow-canvas/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/n1-flow-canvas/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,iCAAiC,CAAC;AAEnE,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAI5B,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAID,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IACzC,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAID,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,qDAAqD;IACrD,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,gFAAgF;IAChF,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACjC;AAID,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,aAAa,CAAC;IACxB,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,eAAe,CAAC;IACtB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,SAAS,CAAC;AAMjD,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC5C,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC,uFAAuF;IACvF,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IACxC,wEAAwE;IACxE,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,wDAAwD;IACxD,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAID,MAAM,WAAW,eAAe;IAC9B,yEAAyE;IACzE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED,4EAA4E;AAC5E,eAAO,MAAM,sBAAsB,KAAK,CAAC"}

package/dist/n1-flow-canvas/types.js

@@ -0,0 +1,6 @@
+// N1 Flow Canvas — Shared Types
+// Pure TypeScript — no Svelte, no DOM dependencies
+// S-02: all collections use Map/Array with deterministic ordering (no Set/Object spread iteration)
+/** Stagger delay per BFS wave step (ms). Deterministic — no Math.random. */
+export const EDGE_REVEAL_STAGGER_MS = 30;
+// === Geometry (imported from p0-primitives, re-exported for convenience) ===

package/dist/n1-flow-canvas/utils.d.ts

@@ -0,0 +1,50 @@
+import type { GraphEdge, NodeLayout } from './types.js';
+/**
+ * Returns the id of the first node whose layout rect contains (x, y), or null.
+ *
+ * When the canvas element is scaled (CSS width ≠ canvas pixel width), pass
+ * scaleX/scaleY to convert event coordinates before testing.
+ *
+ * @param x       - click x in canvas pixel space
+ * @param y       - click y in canvas pixel space
+ * @param positions - GraphState.positions map
+ */
+export declare function nodeHitTest(x: number, y: number, positions: Map<string, NodeLayout>): string | null;
+/**
+ * Convert a DOM click event on a container element to canvas pixel coordinates,
+ * accounting for CSS scaling between container size and canvas resolution.
+ */
+export declare function domEventToCanvasCoords(event: MouseEvent, canvasWidth: number, canvasHeight: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Parse directed dependency edges by scanning each item's description for
+ * regex matches that reference another item's id.
+ *
+ * Generic — works for any item type. Apps supply:
+ * - `idFn`   — extract the item's own id
+ * - `descFn` — extract the text to scan (description, notes, etc.)
+ * - `mentionRegex` — must have one capture group yielding the referenced id
+ * - `mentionToId`  — convert regex capture to a canonical id (e.g. `m => 'wt-' + m`)
+ *
+ * @example KOS usage:
+ *   parseMentionEdges(tasks, t => t.id, t => t.description ?? '', /wt-(\d+)/g, m => `wt-${m}`)
+ */
+export declare function parseMentionEdges<T>(items: T[], idFn: (item: T) => string, descFn: (item: T) => string, mentionRegex: RegExp, mentionToId: (capture: string) => string, edgesMap?: Map<string, GraphEdge>): Map<string, GraphEdge>;
+/**
+ * Create sequential "related" edges between items that share the same group key,
+ * ordered by a sort key. Produces a chain: group[0]→group[1]→group[2]…
+ *
+ * Generic — apps supply:
+ * - `idFn`       — extract item id
+ * - `groupKeyFn` — items with the same key become a chain (e.g. domain+workspace)
+ * - `sortKeyFn`  — ordering within each group (e.g. createdAt string, or id)
+ *
+ * @example KOS usage:
+ *   parseGroupedSequenceEdges(tasks, t => t.id,
+ *     t => `${t.domain ?? ''}:${t.workspace ?? ''}`,
+ *     t => t.createdAt ?? t.id)
+ */
+export declare function parseGroupedSequenceEdges<T>(items: T[], idFn: (item: T) => string, groupKeyFn: (item: T) => string, sortKeyFn: (item: T) => string, edgesMap?: Map<string, GraphEdge>): Map<string, GraphEdge>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/n1-flow-canvas/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/n1-flow-canvas/utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAIxD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GACjC,MAAM,GAAG,IAAI,CAYf;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,UAAU,EACjB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GACnB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAQ1B;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,CAAC,EAAE,EACV,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EACzB,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC3B,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,EACxC,QAAQ,GAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAa,GAC3C,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAyBxB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EACzC,KAAK,EAAE,CAAC,EAAE,EACV,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EACzB,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC/B,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC9B,QAAQ,GAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAa,GAC3C,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAsBxB"}

package/dist/n1-flow-canvas/utils.js

@@ -0,0 +1,113 @@
+// N1 Flow Canvas — Generic graph adapter utilities
+// These are the reusable algorithms; apps supply their own domain types + config.
+// S-02: all collections use Map/Array — no Set iteration order assumptions
+// ── Hit testing ───────────────────────────────────────────────────────────────
+/**
+ * Returns the id of the first node whose layout rect contains (x, y), or null.
+ *
+ * When the canvas element is scaled (CSS width ≠ canvas pixel width), pass
+ * scaleX/scaleY to convert event coordinates before testing.
+ *
+ * @param x       - click x in canvas pixel space
+ * @param y       - click y in canvas pixel space
+ * @param positions - GraphState.positions map
+ */
+export function nodeHitTest(x, y, positions) {
+    for (const [id, layout] of positions) {
+        if (x >= layout.x &&
+            x <= layout.x + layout.width &&
+            y >= layout.y &&
+            y <= layout.y + layout.height) {
+            return id;
+        }
+    }
+    return null;
+}
+/**
+ * Convert a DOM click event on a container element to canvas pixel coordinates,
+ * accounting for CSS scaling between container size and canvas resolution.
+ */
+export function domEventToCanvasCoords(event, canvasWidth, canvasHeight) {
+    const rect = event.currentTarget.getBoundingClientRect();
+    const scaleX = canvasWidth / rect.width;
+    const scaleY = canvasHeight / rect.height;
+    return {
+        x: (event.clientX - rect.left) * scaleX,
+        y: (event.clientY - rect.top) * scaleY,
+    };
+}
+// ── Edge inference ────────────────────────────────────────────────────────────
+/**
+ * Parse directed dependency edges by scanning each item's description for
+ * regex matches that reference another item's id.
+ *
+ * Generic — works for any item type. Apps supply:
+ * - `idFn`   — extract the item's own id
+ * - `descFn` — extract the text to scan (description, notes, etc.)
+ * - `mentionRegex` — must have one capture group yielding the referenced id
+ * - `mentionToId`  — convert regex capture to a canonical id (e.g. `m => 'wt-' + m`)
+ *
+ * @example KOS usage:
+ *   parseMentionEdges(tasks, t => t.id, t => t.description ?? '', /wt-(\d+)/g, m => `wt-${m}`)
+ */
+export function parseMentionEdges(items, idFn, descFn, mentionRegex, mentionToId, edgesMap = new Map()) {
+    const knownIds = new Set(items.map(idFn));
+    for (const item of items) {
+        const sourceId = idFn(item);
+        const text = descFn(item);
+        if (!text)
+            continue;
+        for (const match of text.matchAll(mentionRegex)) {
+            const targetId = mentionToId(match[1]);
+            if (!knownIds.has(targetId))
+                continue;
+            const edgeId = `${sourceId}->${targetId}`;
+            if (edgesMap.has(edgeId))
+                continue;
+            edgesMap.set(edgeId, {
+                id: edgeId,
+                sourceId,
+                targetId,
+                label: 'depends_on',
+            });
+        }
+    }
+    return edgesMap;
+}
+/**
+ * Create sequential "related" edges between items that share the same group key,
+ * ordered by a sort key. Produces a chain: group[0]→group[1]→group[2]…
+ *
+ * Generic — apps supply:
+ * - `idFn`       — extract item id
+ * - `groupKeyFn` — items with the same key become a chain (e.g. domain+workspace)
+ * - `sortKeyFn`  — ordering within each group (e.g. createdAt string, or id)
+ *
+ * @example KOS usage:
+ *   parseGroupedSequenceEdges(tasks, t => t.id,
+ *     t => `${t.domain ?? ''}:${t.workspace ?? ''}`,
+ *     t => t.createdAt ?? t.id)
+ */
+export function parseGroupedSequenceEdges(items, idFn, groupKeyFn, sortKeyFn, edgesMap = new Map()) {
+    const sorted = [...items].sort((a, b) => sortKeyFn(a).localeCompare(sortKeyFn(b)));
+    const groups = new Map();
+    for (const item of sorted) {
+        const key = groupKeyFn(item);
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(item);
+    }
+    for (const groupItems of groups.values()) {
+        if (groupItems.length < 2)
+            continue;
+        for (let i = 0; i < groupItems.length - 1; i++) {
+            const sourceId = idFn(groupItems[i]);
+            const targetId = idFn(groupItems[i + 1]);
+            const edgeId = `${sourceId}->${targetId}`;
+            if (edgesMap.has(edgeId))
+                continue;
+            edgesMap.set(edgeId, { id: edgeId, sourceId, targetId, label: 'related' });
+        }
+    }
+    return edgesMap;
+}

package/dist/n2-manifold-disk/ManifoldDisk.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { GraphSnapshot } from '../n1-flow-canvas/types.js';
+import { GraphState } from '../n1-flow-canvas/graph-state.svelte.js';
+/** Raw inhabitant wire type — mirrors InhabitantView from ryu/src/stores/manifoldStore. */
+interface InhabitantView {
+    id: string;
+    orientation: [number, number, number, number];
+    allay: number;
+}
+interface Props {
+    snapshot: GraphSnapshot;
+    state: GraphState;
+    width?: number;
+    height?: number;
+    selectedId?: string | null;
+    /** Raw S³ inhabitant orientations from the manifold store. Projected here at render time. */
+    inhabitants?: InhabitantView[];
+}
+declare const ManifoldDisk: import("svelte").Component<Props, {}, "">;
+type ManifoldDisk = ReturnType<typeof ManifoldDisk>;
+export default ManifoldDisk;
+//# sourceMappingURL=ManifoldDisk.svelte.d.ts.map

package/dist/n2-manifold-disk/ManifoldDisk.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManifoldDisk.svelte.d.ts","sourceRoot":"","sources":["../../src/n2-manifold-disk/ManifoldDisk.svelte.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAOnE,2FAA2F;AAC3F,UAAU,cAAc;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,KAAK,EAAE,MAAM,CAAC;CACf;AAED,UAAU,KAAK;IACb,QAAQ,EAAE,aAAa,CAAC;IACxB,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,6FAA6F;IAC7F,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;CAChC;AA6SH,QAAA,MAAM,YAAY,2CAAwC,CAAC;AAC3D,KAAK,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AACpD,eAAe,YAAY,CAAC"}

package/dist/n2-manifold-disk/index.d.ts

@@ -0,0 +1,4 @@
+export { default as ManifoldDisk } from './ManifoldDisk.svelte';
+export { mobiusTransform, projectToDisk, poincareDistance, quaternionToDisk } from './poincare.js';
+export type { GraphStateApi, GraphSnapshot } from '../n1-flow-canvas/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/n2-manifold-disk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/n2-manifold-disk/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACnG,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC"}

package/{src/n2-manifold-disk/index.ts → dist/n2-manifold-disk/index.js}

@@ -1,6 +1,4 @@
 // N2 Manifold Disk — Poincaré disk projection wrapping n1-flow-canvas
 // κ = 1.0 fixed (standard Poincaré disk, no prop)
-
 export { default as ManifoldDisk } from './ManifoldDisk.svelte';
 export { mobiusTransform, projectToDisk, poincareDistance, quaternionToDisk } from './poincare.js';
-export type { GraphStateApi, GraphSnapshot } from '../n1-flow-canvas/types.js';