@neoloopy/cld-canvas 0.1.4 → 0.1.8

package/dist/engine/noteCodec.js

@@ -206,6 +206,44 @@ export function emitExtra(lines, key, value, indent) {
         lines.push(`${pad}${key}: ${scalar(value)}`);
     }
 }
+function emitFlowExtra(lines, value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        emitExtra(lines, "flow", value, 0);
+        return;
+    }
+    const m = value;
+    lines.push("flow:");
+    if (m["from"] !== undefined)
+        lines.push(`  from: ${scalar(m["from"])}`);
+    if (m["to"] !== undefined)
+        lines.push(`  to: ${scalar(m["to"])}`);
+    for (const [k, v] of Object.entries(m)) {
+        if (k === "from" || k === "to")
+            continue;
+        emitExtra(lines, k, v, 1);
+    }
+}
+function emitSfdExtra(lines, value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        emitExtra(lines, "sfd", value, 0);
+        return;
+    }
+    const m = value;
+    lines.push("sfd:");
+    if (m["x"] !== undefined) {
+        const x = m["x"];
+        lines.push(`  x: ${typeof x === "number" ? numToYaml(x) : scalar(x)}`);
+    }
+    if (m["y"] !== undefined) {
+        const y = m["y"];
+        lines.push(`  y: ${typeof y === "number" ? numToYaml(y) : scalar(y)}`);
+    }
+    for (const [k, v] of Object.entries(m)) {
+        if (k === "x" || k === "y")
+            continue;
+        emitExtra(lines, k, v, 1);
+    }
+}
 export function serializeNote(v) {
     const lines = [FENCE];
     lines.push(`id: ${scalar(v.id)}`);
@@ -252,8 +290,14 @@ export function serializeNote(v) {
             }
         }
     }
-    for (const [k, val] of Object.entries(v.extra))
-        emitExtra(lines, k, val, 0);
+    for (const [k, val] of Object.entries(v.extra)) {
+        if (k === "flow")
+            emitFlowExtra(lines, val);
+        else if (k === "sfd")
+            emitSfdExtra(lines, val);
+        else
+            emitExtra(lines, k, val, 0);
+    }
     lines.push(FENCE);
     let out = lines.join("\n") + "\n";
     if (v.body.trim().length > 0)

package/dist/engine/quantCanvasLoops.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Conservative, renderer-facing resolution of qualitative and quantitative loops.
+ *
+ * This is deliberately not a simulation or dominance implementation. It only
+ * enriches a declared qualitative cycle independently when every authored leg
+ * maps to one exact visible connector or material pipe. It admits a synthesized
+ * static scalar cycle only when every equation dependency and material effect
+ * is equally exact. Incomplete quantitative analysis returns no synthesized
+ * prefix but never strips an independently resolved qualitative path.
+ */
+import { DetectedLoop, ModelManifest, VariableFile } from "./types";
+export interface CanvasLoopDiscoveryLimits {
+    readonly maxLoops: number;
+    readonly maxEdgeVisits: number;
+    readonly maxDepth: number;
+}
+export declare const USER_FACING_CANVAS_LOOP_LIMITS: CanvasLoopDiscoveryLimits;
+export interface CanvasLoopDiscoveryOptions {
+    readonly manifest?: ModelManifest;
+    readonly limits?: CanvasLoopDiscoveryLimits;
+}
+export interface CanvasLoopDiscoveryResult {
+    readonly loops: DetectedLoop[];
+    readonly analysisError: string | null;
+}
+/** Stable first-class SFD pipe-leg identity. */
+export declare function materialPipeLegId(flowId: string, stockId: string): string;
+/** Stable base id for a non-persistent CLD projection of a material effect. */
+export declare function materialProjectionEdgeId(flowId: string, stockId: string): string;
+/**
+ * Discover complete canvas-resolvable quantitative cycles and merge them with
+ * exact qualitative counterparts. Declared loops are first resolved from their
+ * own authored topology, so a quantitative error never suppresses their honest
+ * CLD/SFD representation.
+ */
+export declare function discoverCanvasLoops(nodes: readonly VariableFile[], qualitativeLoops: readonly DetectedLoop[], options?: CanvasLoopDiscoveryOptions): CanvasLoopDiscoveryResult;