@graphrefly/graphrefly 0.9.0 → 0.10.0

package/dist/index.cjs

@@ -180,6 +180,7 @@ __export(index_exports, {
   gate: () => gate,
   globToRegExp: () => globToRegExp,
   graph: () => graph_exports,
+  graphspec: () => graphspec_exports,
   interval: () => interval,
   isBatching: () => isBatching,
   isKnownMessageType: () => isKnownMessageType,
@@ -12862,6 +12863,7 @@ __export(patterns_exports, {
   ai: () => ai_exports,
   cqrs: () => cqrs_exports,
   demoShell: () => demo_shell_exports,
+  graphspec: () => graphspec_exports,
   layout: () => reactive_layout_exports,
   memory: () => memory_exports,
   messaging: () => messaging_exports,
@@ -15417,1544 +15419,2390 @@ function demoShell(opts) {
   };
 }
 
-// src/patterns/messaging.ts
-var messaging_exports = {};
-__export(messaging_exports, {
-  JobFlowGraph: () => JobFlowGraph,
-  JobQueueGraph: () => JobQueueGraph,
-  SubscriptionGraph: () => SubscriptionGraph,
-  TopicBridgeGraph: () => TopicBridgeGraph,
-  TopicGraph: () => TopicGraph,
-  jobFlow: () => jobFlow,
-  jobQueue: () => jobQueue,
-  subscription: () => subscription,
-  topic: () => topic,
-  topicBridge: () => topicBridge
+// src/patterns/graphspec.ts
+var graphspec_exports = {};
+__export(graphspec_exports, {
+  compileSpec: () => compileSpec,
+  decompileGraph: () => decompileGraph,
+  llmCompose: () => llmCompose,
+  llmRefine: () => llmRefine,
+  specDiff: () => specDiff,
+  validateSpec: () => validateSpec
 });
-var DEFAULT_MAX_PER_PUMP = 2147483647;
-function requireNonNegativeInt(value, label) {
-  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
-    throw new Error(`${label} must be a non-negative integer`);
-  }
-  return value;
-}
-function keepalive4(n) {
-  return n.subscribe(() => {
-  });
-}
-function messagingMeta(kind, extra) {
+
+// src/patterns/reduction.ts
+var reduction_exports = {};
+__export(reduction_exports, {
+  budgetGate: () => budgetGate,
+  feedback: () => feedback,
+  funnel: () => funnel,
+  scorer: () => scorer,
+  stratify: () => stratify
+});
+function baseMeta(kind, meta) {
   return {
-    messaging: true,
-    messaging_type: kind,
-    ...extra ?? {}
+    reduction: true,
+    reduction_type: kind,
+    ...meta ?? {}
   };
 }
-var TopicGraph = class extends Graph {
-  _log;
-  _keepaliveDisposers = [];
-  events;
-  latest;
-  constructor(name, opts = {}) {
-    super(name, opts.graph);
-    this._log = reactiveLog([], { name: "events", maxSize: opts.retainedLimit });
-    this.events = this._log.entries;
-    this.add("events", this.events);
-    this.latest = derived(
-      [this.events],
-      ([snapshot]) => {
-        const entries = snapshot.value.entries;
-        return entries.length === 0 ? void 0 : entries[entries.length - 1];
-      },
-      {
-        name: "latest",
-        describeKind: "derived",
-        meta: messagingMeta("topic_latest"),
-        initial: void 0
-      }
-    );
-    this.add("latest", this.latest);
-    this.connect("events", "latest");
-    this._keepaliveDisposers.push(keepalive4(this.latest));
-  }
-  destroy() {
-    for (const dispose of this._keepaliveDisposers) dispose();
-    this._keepaliveDisposers.length = 0;
-    super.destroy();
-  }
-  publish(value) {
-    this._log.append(value);
-  }
-  retained() {
-    const snapshot = this.events.get();
-    return snapshot.value.entries;
+function stratify(name, source, rules, opts) {
+  const g = new Graph(name, opts);
+  g.add("source", source);
+  const rulesNode = state(rules, {
+    meta: baseMeta("stratify_rules")
+  });
+  g.add("rules", rulesNode);
+  for (const rule of rules) {
+    _addBranch(g, source, rulesNode, rule);
   }
-};
-var SubscriptionGraph = class extends Graph {
-  _keepaliveDisposers = [];
-  source;
-  cursor;
-  available;
-  constructor(name, topicGraph, opts = {}) {
-    super(name, opts.graph);
-    const initialCursor = requireNonNegativeInt(opts.cursor ?? 0, "subscription cursor");
-    this.mount("topic", topicGraph);
-    const topicEvents = topicGraph.events;
-    this.source = derived([topicEvents], ([snapshot]) => snapshot, {
-      name: "source",
-      describeKind: "derived",
-      meta: messagingMeta("subscription_source"),
-      initial: topicEvents.get()
-    });
-    this.add("source", this.source);
-    this.cursor = state(initialCursor, {
-      name: "cursor",
-      describeKind: "state",
-      meta: messagingMeta("subscription_cursor")
-    });
-    this.add("cursor", this.cursor);
-    this.available = derived(
-      [this.source, this.cursor],
-      ([sourceSnapshot, cursor]) => {
-        const entries = sourceSnapshot.value.entries;
-        const start = Math.max(0, Math.trunc(cursor ?? 0));
-        return entries.slice(start);
-      },
-      {
-        name: "available",
-        describeKind: "derived",
-        meta: messagingMeta("subscription_available"),
-        initial: []
+  return g;
+}
+function _addBranch(graph, source, rulesNode, rule) {
+  const branchName = `branch/${rule.name}`;
+  let pendingDirty = false;
+  const filterNode = node([source, rulesNode], () => void 0, {
+    describeKind: "operator",
+    meta: baseMeta("stratify_branch", { branch: rule.name }),
+    onMessage(msg, depIndex, actions) {
+      if (depIndex !== 0) return false;
+      const t = msg[0];
+      if (t === DATA) {
+        const value = msg[1];
+        const currentRules = rulesNode.get();
+        const currentRule = currentRules.find((r) => r.name === rule.name);
+        if (currentRule && currentRule.classify(value)) {
+          pendingDirty = false;
+          actions.emit(value);
+        } else {
+          if (pendingDirty) {
+            pendingDirty = false;
+            actions.down([[DIRTY], [RESOLVED]]);
+          }
+        }
+        return true;
       }
-    );
-    this.add("available", this.available);
-    this.connect("topic::events", "source");
-    this.connect("source", "available");
-    this.connect("cursor", "available");
-    this._keepaliveDisposers.push(keepalive4(this.source));
-    this._keepaliveDisposers.push(keepalive4(this.available));
-  }
-  destroy() {
-    for (const dispose of this._keepaliveDisposers) dispose();
-    this._keepaliveDisposers.length = 0;
-    super.destroy();
-  }
-  ack(count) {
-    const available = this.available.get();
-    const requested = count === void 0 ? available.length : requireNonNegativeInt(count, "subscription ack count");
-    const step = Math.min(requested, available.length);
-    if (step <= 0) return this.cursor.get();
-    const next = this.cursor.get() + step;
-    this.cursor.down([[DATA, next]]);
-    return next;
-  }
-  pull(limit, opts = {}) {
-    const available = this.available.get();
-    const max = limit === void 0 ? available.length : requireNonNegativeInt(limit, "subscription pull limit");
-    const out = available.slice(0, max);
-    if (opts.ack && out.length > 0) this.ack(out.length);
-    return out;
-  }
-};
-var JobQueueGraph = class extends Graph {
-  _pending;
-  _jobs;
-  _keepaliveDisposers = [];
-  _seq = 0;
-  pending;
-  jobs;
-  depth;
-  constructor(name, opts = {}) {
-    super(name, opts.graph);
-    this._pending = reactiveList([], { name: "pending" });
-    this._jobs = reactiveMap({ name: "jobs" });
-    this.pending = this._pending.items;
-    this.jobs = this._jobs.node;
-    this.add("pending", this.pending);
-    this.add("jobs", this.jobs);
-    this.depth = derived(
-      [this.pending],
-      ([snapshot]) => snapshot.value.items.length,
-      {
-        name: "depth",
-        describeKind: "derived",
-        meta: messagingMeta("queue_depth"),
-        initial: 0
+      if (t === DIRTY) {
+        pendingDirty = true;
+        return true;
       }
-    );
-    this.add("depth", this.depth);
-    this.connect("pending", "depth");
-    this._keepaliveDisposers.push(keepalive4(this.depth));
-  }
-  destroy() {
-    for (const dispose of this._keepaliveDisposers) dispose();
-    this._keepaliveDisposers.length = 0;
-    super.destroy();
-  }
-  enqueue(payload, opts = {}) {
-    const id = opts.id ?? `${this.name}-${++this._seq}`;
-    if (this._jobs.get(id) !== void 0) {
-      throw new Error(`jobQueue("${this.name}"): duplicate job id "${id}"`);
+      if (t === RESOLVED) {
+        if (pendingDirty) {
+          pendingDirty = false;
+          actions.down([[DIRTY], [RESOLVED]]);
+        } else {
+          actions.down([[RESOLVED]]);
+        }
+        return true;
+      }
+      if (t === COMPLETE || t === ERROR) {
+        pendingDirty = false;
+        actions.down([msg]);
+        return true;
+      }
+      return false;
     }
-    const job = {
-      id,
-      payload,
-      attempts: 0,
-      metadata: Object.freeze({ ...opts.metadata ?? {} }),
-      state: "queued"
-    };
-    this._jobs.set(id, job);
-    this._pending.append(id);
-    return id;
+  });
+  graph.add(branchName, filterNode);
+  graph.connect("source", branchName);
+  if (rule.ops) {
+    const transformed = rule.ops(filterNode);
+    const transformedName = `branch/${rule.name}/out`;
+    graph.add(transformedName, transformed);
+    graph.connect(branchName, transformedName);
   }
-  claim(limit = 1) {
-    const max = requireNonNegativeInt(limit, "job queue claim limit");
-    if (max === 0) return [];
-    const out = [];
-    while (out.length < max) {
-      const snapshot = this.pending.get();
-      const ids = snapshot.value.items;
-      if (ids.length === 0) break;
-      const id = this._pending.pop(0);
-      const job = this._jobs.get(id);
-      if (!job || job.state !== "queued") continue;
-      const inflight = {
-        ...job,
-        state: "inflight",
-        attempts: job.attempts + 1
-      };
-      this._jobs.set(id, inflight);
-      out.push(inflight);
+}
+function funnel(name, sources, stages, opts) {
+  if (sources.length === 0) throw new RangeError("funnel requires at least one source");
+  if (stages.length === 0) throw new RangeError("funnel requires at least one stage");
+  const g = new Graph(name, opts);
+  const merged = sources.length === 1 ? sources[0] : merge(...sources);
+  g.add("merged", merged);
+  let prevOutputPath = "merged";
+  for (let i = 0; i < stages.length; i++) {
+    const stage = stages[i];
+    const sub = new Graph(stage.name);
+    stage.build(sub);
+    try {
+      sub.resolve("input");
+    } catch {
+      throw new Error(`funnel stage "${stage.name}" must define an "input" node`);
     }
-    return out;
-  }
-  ack(id) {
-    const job = this._jobs.get(id);
-    if (!job || job.state !== "inflight") return false;
-    this._jobs.delete(id);
-    return true;
-  }
-  nack(id, opts = {}) {
-    const job = this._jobs.get(id);
-    if (!job || job.state !== "inflight") return false;
-    if (opts.requeue ?? true) {
-      this._jobs.set(id, { ...job, state: "queued" });
-      this._pending.append(id);
-      return true;
+    try {
+      sub.resolve("output");
+    } catch {
+      throw new Error(`funnel stage "${stage.name}" must define an "output" node`);
     }
-    this._jobs.delete(id);
-    return true;
+    g.mount(stage.name, sub);
+    const prevNode = g.resolve(prevOutputPath);
+    const stageInputPath = `${stage.name}::input`;
+    const stageInput = g.resolve(stageInputPath);
+    prevNode.subscribe((msgs) => {
+      for (const msg of msgs) {
+        const t = msg[0];
+        if (t === DATA) {
+          stageInput.down([[DATA, msg[1]]]);
+        } else if (t === DIRTY) {
+          stageInput.down([[DIRTY]]);
+        } else if (t === RESOLVED) {
+          stageInput.down([[RESOLVED]]);
+        } else if (t === COMPLETE || t === ERROR) {
+          stageInput.down([msg]);
+        }
+      }
+    });
+    prevOutputPath = `${stage.name}::output`;
   }
-};
-var JobFlowGraph = class extends Graph {
-  _stageNames;
-  _queues = /* @__PURE__ */ new Map();
-  _keepaliveDisposers = [];
-  _completed;
-  completed;
-  completedCount;
-  constructor(name, opts = {}) {
-    super(name, opts.graph);
-    const stages = (opts.stages ?? ["incoming", "processing", "done"]).map((v) => v.trim());
-    if (stages.length < 2) {
-      throw new Error(`jobFlow("${name}"): requires at least 2 stages`);
+  return g;
+}
+function feedback(graph, condition, reentry, opts) {
+  const maxIter = opts?.maxIterations ?? 10;
+  const counterName = `__feedback_${condition}`;
+  const counter = state(0, {
+    meta: baseMeta("feedback_counter", {
+      maxIterations: maxIter,
+      feedbackFrom: condition,
+      feedbackTo: reentry
+    })
+  });
+  graph.add(counterName, counter);
+  const condNode = graph.resolve(condition);
+  const reentryNode = graph.resolve(reentry);
+  let tornDown = false;
+  let unsubCounter = null;
+  const safeUnsub = () => {
+    if (tornDown) return;
+    tornDown = true;
+    unsub();
+    unsubCounter?.();
+  };
+  const unsub = condNode.subscribe((msgs) => {
+    for (const msg of msgs) {
+      if (msg[0] === DATA) {
+        const currentCount = counter.get();
+        if (currentCount >= maxIter) continue;
+        const condValue = msg[1];
+        if (condValue == null) continue;
+        counter.down([[DATA, currentCount + 1]]);
+        reentryNode.down([[DATA, condValue]]);
+      } else if (msg[0] === COMPLETE || msg[0] === ERROR) {
+        const terminal = msg[0] === ERROR && msg.length > 1 ? [ERROR, msg[1]] : [msg[0]];
+        counter.down([terminal]);
+        safeUnsub();
+      }
     }
-    const unique = new Set(stages);
-    if (unique.size !== stages.length) {
-      throw new Error(`jobFlow("${name}"): stage names must be unique`);
+  });
+  unsubCounter = counter.subscribe((msgs) => {
+    for (const msg of msgs) {
+      if (msg[0] === COMPLETE || msg[0] === ERROR) {
+        safeUnsub();
+        return;
+      }
     }
-    this._stageNames = Object.freeze([...stages]);
-    for (const stage of this._stageNames) {
-      const q = jobQueue(`${name}-${stage}`);
-      this._queues.set(stage, q);
-      this.mount(stage, q);
+  });
+  return graph;
+}
+function budgetGate(source, constraints, opts) {
+  if (constraints.length === 0) throw new RangeError("budgetGate requires at least one constraint");
+  const constraintNodes = constraints.map((c) => c.node);
+  const allDeps = [source, ...constraintNodes];
+  let buffer2 = [];
+  let paused = false;
+  let pendingResolved = false;
+  const lockId = /* @__PURE__ */ Symbol("budget-gate");
+  function checkBudget() {
+    return constraints.every((c) => c.check(c.node.get()));
+  }
+  function flushBuffer(actions) {
+    while (buffer2.length > 0 && checkBudget()) {
+      const item = buffer2.shift();
+      actions.emit(item);
     }
-    this._completed = reactiveLog([], { name: "completed" });
-    this.completed = this._completed.entries;
-    this.add("completed", this.completed);
-    this.completedCount = derived(
-      [this.completed],
-      ([snapshot]) => snapshot.value.entries.length,
-      {
-        name: "completedCount",
-        describeKind: "derived",
-        meta: messagingMeta("job_flow_completed_count"),
-        initial: 0
-      }
-    );
-    this.add("completedCount", this.completedCount);
-    this.connect("completed", "completedCount");
-    this._keepaliveDisposers.push(keepalive4(this.completedCount));
-    const maxPerPump = Math.max(
-      1,
-      requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "job flow maxPerPump")
-    );
-    for (let i = 0; i < this._stageNames.length; i += 1) {
-      const stage = this._stageNames[i];
-      const current = this.queue(stage);
-      const next = i + 1 < this._stageNames.length ? this.queue(this._stageNames[i + 1]) : null;
-      const pump = node(
-        [current.pending],
-        () => {
-          let moved = 0;
-          while (moved < maxPerPump) {
-            const claim = current.claim(1);
-            if (claim.length === 0) break;
-            const job = claim[0];
-            if (!job) break;
-            if (next) {
-              next.enqueue(job.payload, {
-                metadata: {
-                  ...job.metadata,
-                  job_flow_from: stage
-                }
-              });
-            } else {
-              this._completed.append(job);
+    if (buffer2.length === 0 && pendingResolved) {
+      pendingResolved = false;
+      actions.down([[RESOLVED]]);
+    }
+  }
+  return node(allDeps, () => void 0, {
+    ...opts,
+    describeKind: "operator",
+    meta: baseMeta("budget_gate", opts?.meta),
+    onMessage(msg, depIndex, actions) {
+      const t = msg[0];
+      if (depIndex === 0) {
+        if (t === DATA) {
+          if (checkBudget() && buffer2.length === 0) {
+            actions.emit(msg[1]);
+          } else {
+            buffer2.push(msg[1]);
+            if (!paused) {
+              paused = true;
+              actions.up([[PAUSE, lockId]]);
             }
-            current.ack(job.id);
-            moved += 1;
           }
-        },
-        {
-          name: `pump_${stage}`,
-          describeKind: "effect",
-          meta: messagingMeta("job_flow_pump")
+          return true;
         }
-      );
-      this.add(`pump_${stage}`, pump);
-      this.connect(`${stage}::pending`, `pump_${stage}`);
-      this._keepaliveDisposers.push(keepalive4(pump));
+        if (t === DIRTY) {
+          actions.down([[DIRTY]]);
+          return true;
+        }
+        if (t === RESOLVED) {
+          if (buffer2.length === 0) {
+            actions.down([[RESOLVED]]);
+          } else {
+            pendingResolved = true;
+          }
+          return true;
+        }
+        if (t === COMPLETE || t === ERROR) {
+          for (const item of buffer2) {
+            actions.emit(item);
+          }
+          buffer2 = [];
+          pendingResolved = false;
+          if (paused) {
+            paused = false;
+            actions.up([[RESUME, lockId]]);
+          }
+          actions.down([msg]);
+          return true;
+        }
+        return false;
+      }
+      if (t === DATA || t === RESOLVED) {
+        if (checkBudget() && buffer2.length > 0) {
+          flushBuffer(actions);
+          if (buffer2.length === 0 && paused) {
+            paused = false;
+            actions.up([[RESUME, lockId]]);
+          }
+        } else if (!checkBudget() && !paused && buffer2.length > 0) {
+          paused = true;
+          actions.up([[PAUSE, lockId]]);
+        }
+        return true;
+      }
+      if (t === DIRTY) {
+        return true;
+      }
+      if (t === ERROR) {
+        actions.down([msg]);
+        return true;
+      }
+      if (t === COMPLETE) {
+        return true;
+      }
+      return false;
     }
+  });
+}
+function scorer(sources, weights, opts) {
+  if (sources.length === 0) throw new RangeError("scorer requires at least one source");
+  if (sources.length !== weights.length) {
+    throw new RangeError("scorer requires the same number of sources and weights");
   }
-  destroy() {
-    for (const dispose of this._keepaliveDisposers) dispose();
-    this._keepaliveDisposers.length = 0;
-    super.destroy();
-  }
-  stages() {
-    return this._stageNames;
+  const allDeps = [...sources, ...weights];
+  const n = sources.length;
+  const scoreFns = opts?.scoreFns;
+  return derived(
+    allDeps,
+    (vals) => {
+      const signals = vals.slice(0, n);
+      const weightValues = vals.slice(n);
+      const breakdown = [];
+      let totalScore = 0;
+      for (let i = 0; i < n; i++) {
+        const sig = signals[i] ?? 0;
+        const wt = weightValues[i] ?? 0;
+        const rawScore = scoreFns?.[i] ? scoreFns[i](sig) : sig;
+        const weighted = rawScore * wt;
+        breakdown.push(weighted);
+        totalScore += weighted;
+      }
+      return {
+        value: signals,
+        score: totalScore,
+        breakdown
+      };
+    },
+    {
+      ...opts,
+      describeKind: "derived",
+      meta: baseMeta("scorer", opts?.meta)
+    }
+  );
+}
+
+// src/patterns/graphspec.ts
+var VALID_NODE_TYPES2 = /* @__PURE__ */ new Set([
+  "state",
+  "producer",
+  "derived",
+  "effect",
+  "operator",
+  "template"
+]);
+var INNER_NODE_TYPES = /* @__PURE__ */ new Set(["state", "producer", "derived", "effect", "operator"]);
+function validateSpec(spec) {
+  const errors = [];
+  if (spec == null || typeof spec !== "object") {
+    return { valid: false, errors: ["GraphSpec must be a non-null object"] };
   }
-  queue(stage) {
-    const q = this._queues.get(stage);
-    if (!q) throw new Error(`jobFlow("${this.name}"): unknown stage "${stage}"`);
-    return q;
+  const s = spec;
+  if (typeof s.name !== "string" || s.name.length === 0) {
+    errors.push("Missing or empty 'name' field");
   }
-  enqueue(payload, opts = {}) {
-    return this.queue(this._stageNames[0]).enqueue(payload, opts);
+  if (s.nodes == null || typeof s.nodes !== "object" || Array.isArray(s.nodes)) {
+    errors.push("Missing or invalid 'nodes' field (must be an object)");
+    return { valid: false, errors };
   }
-  retainedCompleted() {
-    const snapshot = this.completed.get();
-    return snapshot.value.entries;
+  const nodeNames = new Set(Object.keys(s.nodes));
+  const nodeTypes = /* @__PURE__ */ new Map();
+  const templateDefs = /* @__PURE__ */ new Map();
+  if (s.templates != null && typeof s.templates === "object" && !Array.isArray(s.templates)) {
+    for (const [tName, tRaw] of Object.entries(s.templates)) {
+      if (tRaw != null && typeof tRaw === "object") {
+        const t = tRaw;
+        templateDefs.set(tName, {
+          params: Array.isArray(t.params) ? t.params : []
+        });
+      }
+    }
   }
-};
-var TopicBridgeGraph = class extends Graph {
-  _sourceSub;
-  _target;
-  _keepaliveDisposers = [];
-  bridgedCount;
-  constructor(name, sourceTopic, targetTopic, opts = {}) {
-    super(name, opts.graph);
-    this._sourceSub = subscription(`${name}-subscription`, sourceTopic, {
-      cursor: opts.cursor
-    });
-    this._target = targetTopic;
-    this.mount("subscription", this._sourceSub);
-    this.bridgedCount = state(0, {
-      name: "bridgedCount",
-      describeKind: "state",
-      meta: messagingMeta("topic_bridge_count")
-    });
-    this.add("bridgedCount", this.bridgedCount);
-    const maxPerPump = Math.max(
-      1,
-      requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "topic bridge maxPerPump")
-    );
-    const mapValue = opts.map ?? ((value) => value);
-    const pump = node(
-      [this._sourceSub.available],
-      () => {
-        const available = this._sourceSub.pull(maxPerPump, { ack: true });
-        if (available.length === 0) return;
-        let bridged = 0;
-        for (const value of available) {
-          const mapped = mapValue(value);
-          if (mapped === void 0) continue;
-          this._target.publish(mapped);
-          bridged += 1;
+  if (s.templates != null) {
+    if (typeof s.templates !== "object" || Array.isArray(s.templates)) {
+      errors.push("'templates' must be an object");
+    } else {
+      for (const [tName, tRaw] of Object.entries(s.templates)) {
+        if (tRaw == null || typeof tRaw !== "object") {
+          errors.push(`Template "${tName}": must be an object`);
+          continue;
         }
-        if (bridged > 0) {
-          const current = this.bridgedCount.get();
-          this.bridgedCount.down([[DATA, current + bridged]]);
+        const t = tRaw;
+        if (!Array.isArray(t.params)) {
+          errors.push(`Template "${tName}": missing 'params' array`);
+        }
+        if (t.nodes == null || typeof t.nodes !== "object" || Array.isArray(t.nodes)) {
+          errors.push(`Template "${tName}": missing or invalid 'nodes' object`);
+        } else {
+          const paramSet = new Set(Array.isArray(t.params) ? t.params : []);
+          const innerNames = new Set(Object.keys(t.nodes));
+          for (const [nName, nRaw] of Object.entries(t.nodes)) {
+            if (nRaw == null || typeof nRaw !== "object") {
+              errors.push(`Template "${tName}" node "${nName}": must be an object`);
+              continue;
+            }
+            const n = nRaw;
+            if (typeof n.type !== "string" || !INNER_NODE_TYPES.has(n.type)) {
+              errors.push(`Template "${tName}" node "${nName}": invalid type`);
+            }
+            if (Array.isArray(n.deps)) {
+              for (const dep of n.deps) {
+                if (!innerNames.has(dep) && !paramSet.has(dep)) {
+                  errors.push(
+                    `Template "${tName}" node "${nName}": dep "${dep}" is not an inner node or param`
+                  );
+                }
+              }
+            }
+          }
+          if (typeof t.output !== "string") {
+            errors.push(`Template "${tName}": missing 'output' string`);
+          } else if (!t.nodes[t.output]) {
+            errors.push(`Template "${tName}": output "${t.output}" is not a declared node`);
+          }
         }
-      },
-      {
-        name: "pump",
-        describeKind: "effect",
-        meta: messagingMeta("topic_bridge_pump")
       }
-    );
-    this.add("pump", pump);
-    this.connect("subscription::available", "pump");
-    this._keepaliveDisposers.push(keepalive4(pump));
-  }
-  destroy() {
-    for (const dispose of this._keepaliveDisposers) dispose();
-    this._keepaliveDisposers.length = 0;
-    super.destroy();
+    }
   }
-};
-function topic(name, opts) {
-  return new TopicGraph(name, opts);
-}
-function subscription(name, topicGraph, opts) {
-  return new SubscriptionGraph(name, topicGraph, opts);
-}
-function jobQueue(name, opts) {
-  return new JobQueueGraph(name, opts);
-}
-function jobFlow(name, opts) {
-  return new JobFlowGraph(name, opts);
-}
-function topicBridge(name, sourceTopic, targetTopic, opts) {
-  return new TopicBridgeGraph(name, sourceTopic, targetTopic, opts);
-}
-
-// src/patterns/orchestration.ts
-var orchestration_exports = {};
-__export(orchestration_exports, {
-  approval: () => approval,
-  branch: () => branch,
-  forEach: () => forEach2,
-  gate: () => gate2,
-  join: () => join2,
-  loop: () => loop,
-  onFailure: () => onFailure,
-  pipeline: () => pipeline,
-  sensor: () => sensor,
-  subPipeline: () => subPipeline,
-  task: () => task,
-  wait: () => wait
-});
-function resolveDep(graph, dep) {
-  if (typeof dep === "string") {
-    return { node: graph.resolve(dep), path: dep };
+  for (const [name, raw] of Object.entries(s.nodes)) {
+    if (raw == null || typeof raw !== "object") {
+      errors.push(`Node "${name}": must be an object`);
+      continue;
+    }
+    const n = raw;
+    if (typeof n.type !== "string" || !VALID_NODE_TYPES2.has(n.type)) {
+      errors.push(
+        `Node "${name}": invalid type "${String(n.type)}" (expected: ${[...VALID_NODE_TYPES2].join(", ")})`
+      );
+      continue;
+    }
+    nodeTypes.set(name, n.type);
+    if (n.type === "template") {
+      if (typeof n.template !== "string" || !templateDefs.has(n.template)) {
+        errors.push(`Node "${name}": template "${String(n.template)}" not found in templates`);
+      } else {
+        if (n.bind == null || typeof n.bind !== "object" || Array.isArray(n.bind)) {
+          errors.push(`Node "${name}": template ref requires 'bind' object`);
+        } else {
+          const tmpl = templateDefs.get(n.template);
+          const bind = n.bind;
+          for (const param of tmpl.params) {
+            if (!(param in bind)) {
+              errors.push(
+                `Node "${name}": template param "${param}" is not bound (template "${n.template}")`
+              );
+            }
+          }
+          for (const [, target] of Object.entries(bind)) {
+            if (typeof target === "string" && !nodeNames.has(target)) {
+              errors.push(
+                `Node "${name}": bind target "${target}" does not reference an existing node`
+              );
+            }
+          }
+        }
+      }
+    } else {
+      if (Array.isArray(n.deps)) {
+        for (const dep of n.deps) {
+          if (dep === name) {
+            errors.push(`Node "${name}": self-referencing dep`);
+          } else if (!nodeNames.has(dep)) {
+            errors.push(`Node "${name}": dep "${dep}" does not reference an existing node`);
+          }
+        }
+      }
+      if ((n.type === "derived" || n.type === "effect" || n.type === "operator") && !Array.isArray(n.deps)) {
+        errors.push(`Node "${name}": ${n.type} node should have a 'deps' array`);
+      }
+    }
   }
-  const path = findRegisteredNodePath(graph, dep);
-  if (!path) {
-    throw new Error(
-      "orchestration dep node must already be registered in the graph so explicit edges can be recorded; pass a string path or register the node first"
-    );
+  if (s.feedback != null) {
+    if (!Array.isArray(s.feedback)) {
+      errors.push("'feedback' must be an array");
+    } else {
+      for (let i = 0; i < s.feedback.length; i++) {
+        const edge = s.feedback[i];
+        if (edge == null || typeof edge !== "object") {
+          errors.push(`Feedback [${i}]: must be an object`);
+          continue;
+        }
+        const e = edge;
+        if (typeof e.from !== "string" || !nodeNames.has(e.from)) {
+          errors.push(
+            `Feedback [${i}]: 'from' "${String(e.from)}" does not reference an existing node`
+          );
+        }
+        if (typeof e.from === "string" && e.from === e.to) {
+          errors.push(`Feedback [${i}]: 'from' and 'to' must be different nodes`);
+        }
+        if (typeof e.to !== "string" || !nodeNames.has(e.to)) {
+          errors.push(
+            `Feedback [${i}]: 'to' "${String(e.to)}" does not reference an existing node`
+          );
+        } else if (typeof e.to === "string" && nodeTypes.get(e.to) !== "state") {
+          errors.push(
+            `Feedback [${i}]: 'to' node "${e.to}" must be a state node (got "${nodeTypes.get(e.to) ?? "unknown"}")`
+          );
+        }
+      }
+    }
   }
-  return { node: dep, path };
+  return { valid: errors.length === 0, errors };
 }
-function findRegisteredNodePath(graph, target) {
-  const described = graph.describe();
-  const metaSegment = `::${GRAPH_META_SEGMENT}::`;
-  for (const path of Object.keys(described.nodes).sort()) {
-    if (path.includes(metaSegment)) continue;
+function compileSpec(spec, opts) {
+  const validation = validateSpec(spec);
+  if (!validation.valid) {
+    throw new Error(`compileSpec: invalid GraphSpec:
+${validation.errors.join("\n")}`);
+  }
+  const catalog = opts?.catalog ?? {};
+  const g = new Graph(spec.name);
+  const templates = spec.templates ?? {};
+  const created = /* @__PURE__ */ new Map();
+  const deferred = [];
+  for (const [name, raw] of Object.entries(spec.nodes)) {
+    if (raw.type === "template") continue;
+    const n = raw;
+    if (n.type === "state") {
+      const nd = state(n.initial, {
+        name,
+        meta: n.meta ? { ...n.meta } : void 0
+      });
+      g.add(name, nd);
+      created.set(name, nd);
+    } else if (n.type === "producer") {
+      const sourceFactory = n.source ? catalog.sources?.[n.source] : void 0;
+      const fnFactory = n.fn ? catalog.fns?.[n.fn] : void 0;
+      if (sourceFactory) {
+        const nd = sourceFactory(n.config ?? {});
+        g.add(name, nd);
+        created.set(name, nd);
+      } else if (fnFactory) {
+        const nd = fnFactory([], n.config ?? {});
+        g.add(name, nd);
+        created.set(name, nd);
+      } else {
+        const nd = producer(() => {
+        }, {
+          name,
+          meta: { ...n.meta, _specFn: n.fn, _specSource: n.source }
+        });
+        g.add(name, nd);
+        created.set(name, nd);
+      }
+    } else {
+      deferred.push([name, n]);
+    }
+  }
+  let progressed = true;
+  const pending = new Map(deferred);
+  while (pending.size > 0 && progressed) {
+    progressed = false;
+    for (const [name, n] of [...pending.entries()]) {
+      const deps = n.deps ?? [];
+      if (!deps.every((dep) => created.has(dep))) continue;
+      const resolvedDeps = deps.map((dep) => created.get(dep));
+      const fnFactory = n.fn ? catalog.fns?.[n.fn] : void 0;
+      let nd;
+      if (fnFactory) {
+        nd = fnFactory(resolvedDeps, n.config ?? {});
+      } else if (n.type === "effect") {
+        nd = effect(resolvedDeps, () => {
+        });
+      } else {
+        nd = derived(resolvedDeps, (vals) => vals[0]);
+      }
+      g.add(name, nd);
+      created.set(name, nd);
+      pending.delete(name);
+      progressed = true;
+    }
+  }
+  if (pending.size > 0) {
+    const unresolved = [...pending.keys()].sort().join(", ");
+    throw new Error(`compileSpec: unresolvable deps for nodes: ${unresolved}`);
+  }
+  for (const [name, raw] of Object.entries(spec.nodes)) {
+    if (raw.type !== "template") continue;
+    const ref = raw;
+    const tmpl = templates[ref.template];
+    const sub = new Graph(name);
+    const subCreated = /* @__PURE__ */ new Map();
+    const subDeferred = [];
+    for (const [nName, nSpec] of Object.entries(tmpl.nodes)) {
+      const resolvedDeps = (nSpec.deps ?? []).map((dep) => {
+        if (dep.startsWith("$") && ref.bind[dep]) {
+          return ref.bind[dep];
+        }
+        return dep;
+      });
+      const specWithResolvedDeps = { ...nSpec, deps: resolvedDeps };
+      if (nSpec.type === "state") {
+        const nd = state(nSpec.initial, {
+          name: nName,
+          meta: nSpec.meta ? { ...nSpec.meta } : void 0
+        });
+        sub.add(nName, nd);
+        subCreated.set(nName, nd);
+      } else if (nSpec.type === "producer") {
+        const sourceFactory = nSpec.source ? catalog.sources?.[nSpec.source] : void 0;
+        const fnFactory = nSpec.fn ? catalog.fns?.[nSpec.fn] : void 0;
+        if (sourceFactory) {
+          const nd = sourceFactory(nSpec.config ?? {});
+          sub.add(nName, nd);
+          subCreated.set(nName, nd);
+        } else if (fnFactory) {
+          const nd = fnFactory([], nSpec.config ?? {});
+          sub.add(nName, nd);
+          subCreated.set(nName, nd);
+        } else {
+          const nd = producer(() => {
+          }, {
+            name: nName,
+            meta: { ...nSpec.meta, _specFn: nSpec.fn, _specSource: nSpec.source }
+          });
+          sub.add(nName, nd);
+          subCreated.set(nName, nd);
+        }
+      } else {
+        subDeferred.push([nName, specWithResolvedDeps]);
+      }
+    }
+    let subProgressed = true;
+    const subPending = new Map(subDeferred);
+    while (subPending.size > 0 && subProgressed) {
+      subProgressed = false;
+      for (const [nName, nSpec] of [...subPending.entries()]) {
+        const deps = nSpec.deps ?? [];
+        const allReady = deps.every((dep) => subCreated.has(dep) || created.has(dep));
+        if (!allReady) continue;
+        const resolvedDeps = deps.map((dep) => subCreated.get(dep) ?? created.get(dep));
+        const fnFactory = nSpec.fn ? catalog.fns?.[nSpec.fn] : void 0;
+        let nd;
+        if (fnFactory) {
+          nd = fnFactory(resolvedDeps, nSpec.config ?? {});
+        } else if (nSpec.type === "effect") {
+          nd = effect(resolvedDeps, () => {
+          });
+        } else {
+          nd = derived(resolvedDeps, (vals) => vals[0]);
+        }
+        sub.add(nName, nd);
+        subCreated.set(nName, nd);
+        subPending.delete(nName);
+        subProgressed = true;
+      }
+    }
+    if (subPending.size > 0) {
+      const unresolved = [...subPending.keys()].sort().join(", ");
+      throw new Error(
+        `compileSpec: template "${ref.template}" has unresolvable deps: ${unresolved}`
+      );
+    }
+    g.mount(name, sub);
+    const outputPath = `${name}::${tmpl.output}`;
+    created.set(name, g.resolve(outputPath));
     try {
-      if (graph.resolve(path) === target) return path;
+      const outputNode = g.resolve(outputPath);
+      outputNode.meta._templateName?.down([[DATA, ref.template]]);
+      outputNode.meta._templateBind?.down([[DATA, ref.bind]]);
     } catch {
     }
   }
-  return void 0;
-}
-function registerStep(graph, name, step, depPaths) {
-  graph.add(name, step);
-  for (const path of depPaths) {
-    graph.connect(path, name);
+  for (const [name, raw] of Object.entries(spec.nodes)) {
+    if (raw.type === "template") continue;
+    const n = raw;
+    for (const dep of n.deps ?? []) {
+      try {
+        g.connect(dep, name);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "";
+        if (!msg.includes("constructor deps") && !msg.includes("already")) {
+          throw err;
+        }
+      }
+    }
   }
+  for (const fb of spec.feedback ?? []) {
+    feedback(g, fb.from, fb.to, {
+      maxIterations: fb.maxIterations
+    });
+  }
+  return g;
 }
-function baseMeta(kind, meta) {
-  return {
-    orchestration: true,
-    orchestration_type: kind,
-    ...meta ?? {}
-  };
-}
-function coerceLoopIterations(raw) {
-  const parseString = (value) => {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) return 0;
-    return Number(trimmed);
-  };
-  let parsed;
-  if (typeof raw === "string") {
-    parsed = parseString(raw);
-  } else if (raw === null) {
-    parsed = 0;
-  } else {
-    parsed = Number(raw);
+var INTERNAL_META_KEYS = /* @__PURE__ */ new Set([
+  "reduction",
+  "reduction_type",
+  "_specFn",
+  "_specSource",
+  "_templateName",
+  "_templateBind",
+  "feedbackFrom",
+  "feedbackTo"
+]);
+function decompileGraph(graph) {
+  const desc = graph.describe({ detail: "standard" });
+  const nodes = {};
+  const feedbackEdges = [];
+  const metaSegment = `::${GRAPH_META_SEGMENT}::`;
+  const feedbackCounterPattern = /^__feedback_(.+)$/;
+  const feedbackConditions = /* @__PURE__ */ new Set();
+  for (const path of Object.keys(desc.nodes)) {
+    if (path.includes(metaSegment)) continue;
+    const match = feedbackCounterPattern.exec(path);
+    if (match) {
+      feedbackConditions.add(match[1]);
+      const meta = desc.nodes[path]?.meta;
+      if (meta?.feedbackFrom && meta?.feedbackTo) {
+        feedbackEdges.push({
+          from: meta.feedbackFrom,
+          to: meta.feedbackTo,
+          ...meta.maxIterations ? { maxIterations: meta.maxIterations } : {}
+        });
+      }
+    }
   }
-  if (!Number.isFinite(parsed)) return 1;
-  return Math.max(0, Math.trunc(parsed));
-}
-function pipeline(name, opts) {
-  return new Graph(name, opts);
-}
-function task(graph, name, run, opts) {
-  const depRefs = opts?.deps ?? [];
-  const deps = depRefs.map((dep) => resolveDep(graph, dep));
-  const { deps: _deps, ...nodeOpts } = opts ?? {};
-  const step = node(
-    deps.map((d) => d.node),
-    run,
-    {
-      ...nodeOpts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("task", opts?.meta)
+  for (const [path, nodeDesc] of Object.entries(desc.nodes)) {
+    if (path.includes(metaSegment)) continue;
+    if (feedbackCounterPattern.test(path)) continue;
+    if (path.includes("::")) continue;
+    const specNode = {
+      type: nodeDesc.type
+    };
+    if (nodeDesc.deps.length > 0) {
+      specNode.deps = nodeDesc.deps.filter((d) => !d.includes("::"));
+    }
+    if (nodeDesc.type === "state" && nodeDesc.value !== void 0) {
+      specNode.initial = nodeDesc.value;
+    }
+    if (nodeDesc.meta && Object.keys(nodeDesc.meta).length > 0) {
+      const meta = {};
+      for (const [k, v] of Object.entries(nodeDesc.meta)) {
+        if (!INTERNAL_META_KEYS.has(k)) meta[k] = v;
+      }
+      if (Object.keys(meta).length > 0) {
+        specNode.meta = meta;
+      }
+    }
+    nodes[path] = specNode;
+  }
+  const templates = {};
+  const templateRefs = {};
+  const metaDetectedSubgraphs = /* @__PURE__ */ new Set();
+  for (const subName of desc.subgraphs) {
+    const prefix = `${subName}::`;
+    for (const [path, nodeDesc] of Object.entries(desc.nodes)) {
+      if (!path.startsWith(prefix)) continue;
+      if (path.includes(metaSegment)) continue;
+      const meta = nodeDesc.meta;
+      if (meta?._templateName && meta?._templateBind) {
+        const templateName = meta._templateName;
+        const bind = meta._templateBind;
+        if (!templates[templateName]) {
+          const tmplNodes = {};
+          const tmplInnerNames = /* @__PURE__ */ new Set();
+          const tmplPrefix = `${subName}::`;
+          for (const [p, nd] of Object.entries(desc.nodes)) {
+            if (!p.startsWith(tmplPrefix) || p.includes(metaSegment)) continue;
+            const localName = p.slice(tmplPrefix.length);
+            if (localName.includes("::")) continue;
+            tmplInnerNames.add(localName);
+            tmplNodes[localName] = {
+              type: nd.type,
+              ...nd.deps.length > 0 ? {
+                deps: nd.deps.map(
+                  (d) => d.startsWith(tmplPrefix) ? d.slice(tmplPrefix.length) : d
+                )
+              } : {}
+            };
+          }
+          const tmplParams = [];
+          const tmplParamMap = /* @__PURE__ */ new Map();
+          for (const n of Object.values(tmplNodes)) {
+            for (const dep of n.deps ?? []) {
+              if (!tmplInnerNames.has(dep) && !tmplParamMap.has(dep)) {
+                const param = `$${dep}`;
+                tmplParams.push(param);
+                tmplParamMap.set(dep, param);
+              }
+            }
+          }
+          for (const n of Object.values(tmplNodes)) {
+            if (n.deps) n.deps = n.deps.map((d) => tmplParamMap.get(d) ?? d);
+          }
+          const depended = /* @__PURE__ */ new Set();
+          for (const n of Object.values(tmplNodes)) {
+            for (const dep of n.deps ?? []) {
+              if (tmplInnerNames.has(dep)) depended.add(dep);
+            }
+          }
+          const outputCandidates = [...tmplInnerNames].filter((n) => !depended.has(n));
+          const tmplOutput = outputCandidates[0] ?? [...tmplInnerNames].pop();
+          templates[templateName] = { params: tmplParams, nodes: tmplNodes, output: tmplOutput };
+        }
+        delete nodes[subName];
+        templateRefs[subName] = { type: "template", template: templateName, bind };
+        metaDetectedSubgraphs.add(subName);
+        break;
+      }
     }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    deps.flatMap((d) => d.path ? [d.path] : [])
-  );
-  return step;
-}
-function branch(graph, name, source, predicate, opts) {
-  const src = resolveDep(graph, source);
-  const step = node(
-    [src.node],
-    ([value]) => ({
-      branch: predicate(value) ? "then" : "else",
-      value
-    }),
-    {
-      ...opts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("branch", opts?.meta)
+  }
+  const structureMap = /* @__PURE__ */ new Map();
+  for (const subName of desc.subgraphs) {
+    if (metaDetectedSubgraphs.has(subName)) continue;
+    const subNodes = {};
+    const prefix = `${subName}::`;
+    for (const [path, nodeDesc] of Object.entries(desc.nodes)) {
+      if (path.includes(metaSegment)) continue;
+      if (!path.startsWith(prefix)) continue;
+      const localName = path.slice(prefix.length);
+      if (localName.includes("::")) continue;
+      subNodes[localName] = {
+        type: nodeDesc.type,
+        ...nodeDesc.deps.length > 0 ? {
+          deps: nodeDesc.deps.map((d) => d.startsWith(prefix) ? d.slice(prefix.length) : d)
+        } : {}
+      };
     }
-  );
-  registerStep(graph, name, step, src.path ? [src.path] : []);
-  return step;
-}
-function gate2(graph, name, source, control, opts) {
-  const src = resolveDep(graph, source);
-  const ctrl = resolveDep(graph, control);
-  const step = node(
-    [src.node, ctrl.node],
-    (_deps, actions) => {
-      const opened = ctrl.node.get();
-      if (!opened) {
-        actions.down([[RESOLVED]]);
-        return void 0;
-      }
-      return src.node.get();
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "operator",
-      meta: baseMeta("gate", opts?.meta)
+    const fingerprint = JSON.stringify(
+      Object.fromEntries(
+        Object.entries(subNodes).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => [k, { type: v.type, deps: v.deps ?? [] }])
+      )
+    );
+    if (!structureMap.has(fingerprint)) {
+      structureMap.set(fingerprint, []);
+    }
+    structureMap.get(fingerprint).push({ name: subName, nodes: subNodes });
+  }
+  for (const [, group] of structureMap) {
+    if (group.length < 2) continue;
+    const templateName = `${group[0].name}_template`;
+    const refNodes = group[0].nodes;
+    const innerNames = new Set(Object.keys(refNodes));
+    const params = [];
+    const baseParamMap = /* @__PURE__ */ new Map();
+    for (const n of Object.values(refNodes)) {
+      for (const dep of n.deps ?? []) {
+        if (!innerNames.has(dep) && !baseParamMap.has(dep)) {
+          const param = `$${dep}`;
+          params.push(param);
+          baseParamMap.set(dep, param);
+        }
+      }
+    }
+    const depended = /* @__PURE__ */ new Set();
+    for (const n of Object.values(refNodes)) {
+      for (const dep of n.deps ?? []) {
+        if (innerNames.has(dep)) depended.add(dep);
+      }
+    }
+    const outputCandidates = [...innerNames].filter((n) => !depended.has(n));
+    const output = outputCandidates[0] ?? [...innerNames].pop();
+    const tmplNodes = {};
+    for (const [nName, nSpec] of Object.entries(refNodes)) {
+      tmplNodes[nName] = {
+        ...nSpec,
+        deps: nSpec.deps?.map((d) => baseParamMap.get(d) ?? d)
+      };
     }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    [src.path, ctrl.path].filter((v) => typeof v === "string")
-  );
-  return step;
-}
-function approval(graph, name, source, approver, opts) {
-  const src = resolveDep(graph, source);
-  const ctrl = resolveDep(graph, approver);
-  const isApproved = opts?.isApproved ?? ((value) => Boolean(value));
-  const step = node(
-    [src.node, ctrl.node],
-    (_deps, actions) => {
-      if (!isApproved(ctrl.node.get())) {
-        actions.down([[RESOLVED]]);
-        return void 0;
+    templates[templateName] = { params, nodes: tmplNodes, output };
+    for (const member of group) {
+      delete nodes[member.name];
+      const memberBind = {};
+      const memberInnerNames = new Set(Object.keys(member.nodes));
+      for (const n of Object.values(member.nodes)) {
+        for (const dep of n.deps ?? []) {
+          if (!memberInnerNames.has(dep)) {
+            const param = baseParamMap.get(dep) ?? `$${dep}`;
+            memberBind[param] = dep;
+          }
+        }
       }
-      return src.node.get();
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "operator",
-      meta: baseMeta("approval", opts?.meta)
+      templateRefs[member.name] = {
+        type: "template",
+        template: templateName,
+        bind: memberBind
+      };
     }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    [src.path, ctrl.path].filter((v) => typeof v === "string")
-  );
-  return step;
+  }
+  const allNodes = {
+    ...nodes,
+    ...templateRefs
+  };
+  const result = { name: desc.name, nodes: allNodes };
+  if (Object.keys(templates).length > 0) result.templates = templates;
+  if (feedbackEdges.length > 0) result.feedback = feedbackEdges;
+  return result;
 }
-function forEach2(graph, name, source, run, opts) {
-  const src = resolveDep(graph, source);
-  let terminated = false;
-  const step = node([src.node], () => void 0, {
-    ...opts,
-    name,
-    describeKind: "effect",
-    completeWhenDepsComplete: false,
-    meta: baseMeta("forEach", opts?.meta),
-    onMessage(msg, depIndex, actions) {
-      if (terminated) return true;
-      if (depIndex !== 0) {
-        actions.down([msg]);
-        if (msg[0] === COMPLETE || msg[0] === ERROR) terminated = true;
-        return true;
+function specDiff(specA, specB) {
+  const entries = [];
+  if (specA.name !== specB.name) {
+    entries.push({
+      type: "changed",
+      path: "name",
+      detail: `"${specA.name}" \u2192 "${specB.name}"`
+    });
+  }
+  const nodesA = new Set(Object.keys(specA.nodes));
+  const nodesB = new Set(Object.keys(specB.nodes));
+  for (const name of nodesB) {
+    if (!nodesA.has(name)) {
+      const n = specB.nodes[name];
+      entries.push({
+        type: "added",
+        path: `nodes.${name}`,
+        detail: `type: ${n.type}`
+      });
+    }
+  }
+  for (const name of nodesA) {
+    if (!nodesB.has(name)) {
+      entries.push({ type: "removed", path: `nodes.${name}` });
+    }
+  }
+  for (const name of nodesA) {
+    if (!nodesB.has(name)) continue;
+    const a = specA.nodes[name];
+    const b = specB.nodes[name];
+    if (JSON.stringify(a) !== JSON.stringify(b)) {
+      const details = [];
+      if (a.type !== b.type) details.push(`type: ${a.type} \u2192 ${b.type}`);
+      if (JSON.stringify(a.deps) !== JSON.stringify(b.deps)) {
+        details.push("deps changed");
       }
-      if (msg[0] === DATA) {
-        try {
-          run(msg[1], actions);
-          actions.down([msg]);
-        } catch (err) {
-          terminated = true;
-          actions.down([[ERROR, err]]);
-        }
-        return true;
+      if (a.fn !== b.fn) {
+        details.push(`fn: ${a.fn} \u2192 ${b.fn}`);
       }
-      actions.down([msg]);
-      if (msg[0] === COMPLETE || msg[0] === ERROR) terminated = true;
-      return true;
+      if (JSON.stringify(a.config) !== JSON.stringify(b.config)) {
+        details.push("config changed");
+      }
+      entries.push({
+        type: "changed",
+        path: `nodes.${name}`,
+        detail: details.join("; ") || "modified"
+      });
     }
-  });
-  registerStep(graph, name, step, src.path ? [src.path] : []);
-  return step;
-}
-function join2(graph, name, deps, opts) {
-  const resolved = deps.map((dep) => resolveDep(graph, dep));
-  const step = node(
-    resolved.map((d) => d.node),
-    (values) => values,
-    {
-      ...opts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("join", opts?.meta)
+  }
+  const tmplA = specA.templates ?? {};
+  const tmplB = specB.templates ?? {};
+  const tmplNamesA = new Set(Object.keys(tmplA));
+  const tmplNamesB = new Set(Object.keys(tmplB));
+  for (const name of tmplNamesB) {
+    if (!tmplNamesA.has(name)) {
+      entries.push({ type: "added", path: `templates.${name}` });
     }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    resolved.flatMap((d) => d.path ? [d.path] : [])
-  );
-  return step;
+  }
+  for (const name of tmplNamesA) {
+    if (!tmplNamesB.has(name)) {
+      entries.push({ type: "removed", path: `templates.${name}` });
+    }
+  }
+  for (const name of tmplNamesA) {
+    if (!tmplNamesB.has(name)) continue;
+    if (JSON.stringify(tmplA[name]) !== JSON.stringify(tmplB[name])) {
+      entries.push({
+        type: "changed",
+        path: `templates.${name}`,
+        detail: "template definition changed"
+      });
+    }
+  }
+  const fbA = specA.feedback ?? [];
+  const fbB = specB.feedback ?? [];
+  const fbKeyA = new Set(fbA.map((e) => `${e.from}->${e.to}`));
+  const fbKeyB = new Set(fbB.map((e) => `${e.from}->${e.to}`));
+  for (const fb of fbB) {
+    const key = `${fb.from}->${fb.to}`;
+    if (!fbKeyA.has(key)) {
+      entries.push({
+        type: "added",
+        path: `feedback.${key}`,
+        detail: `maxIterations: ${fb.maxIterations ?? 10}`
+      });
+    }
+  }
+  for (const fb of fbA) {
+    const key = `${fb.from}->${fb.to}`;
+    if (!fbKeyB.has(key)) {
+      entries.push({ type: "removed", path: `feedback.${key}` });
+    }
+  }
+  for (const fb of fbA) {
+    const key = `${fb.from}->${fb.to}`;
+    const counterpart = fbB.find((b) => b.from === fb.from && b.to === fb.to);
+    if (counterpart && JSON.stringify(fb) !== JSON.stringify(counterpart)) {
+      entries.push({
+        type: "changed",
+        path: `feedback.${key}`,
+        detail: `maxIterations: ${fb.maxIterations ?? 10} \u2192 ${counterpart.maxIterations ?? 10}`
+      });
+    }
+  }
+  const added = entries.filter((e) => e.type === "added").length;
+  const removed = entries.filter((e) => e.type === "removed").length;
+  const changed = entries.filter((e) => e.type === "changed").length;
+  const parts = [];
+  if (added) parts.push(`${added} added`);
+  if (removed) parts.push(`${removed} removed`);
+  if (changed) parts.push(`${changed} changed`);
+  const summary = parts.length > 0 ? parts.join(", ") : "no changes";
+  return { entries, summary };
 }
-function loop(graph, name, source, iterate, opts) {
-  const src = resolveDep(graph, source);
-  const iterRef = opts?.iterations;
-  const iterDep = typeof iterRef === "number" || iterRef === void 0 ? void 0 : resolveDep(graph, iterRef);
-  const staticIterations = typeof iterRef === "number" ? iterRef : void 0;
-  const step = node(
-    iterDep ? [src.node, iterDep.node] : [src.node],
-    (_deps, actions) => {
-      let current = src.node.get();
-      const rawCount = staticIterations ?? iterDep?.node.get() ?? 1;
-      const count = coerceLoopIterations(rawCount);
-      for (let i = 0; i < count; i += 1) {
-        current = iterate(current, i, actions);
-      }
-      return current;
+var LLM_COMPOSE_SYSTEM_PROMPT = `You are a graph architect for GraphReFly, a reactive graph protocol.
+
+Given a natural-language description, produce a JSON GraphSpec with this structure:
+
+{
+  "name": "<graph_name>",
+  "nodes": {
+    "<node_name>": {
+      "type": "state" | "derived" | "producer" | "effect" | "operator",
+      "deps": ["<dep_node_name>", ...],
+      "fn": "<catalog_function_name>",
+      "source": "<catalog_source_name>",
+      "config": { ... },
+      "initial": <value>,
+      "meta": { "description": "<purpose>" }
     },
-    {
-      ...opts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("loop", opts?.meta)
+    "<template_instance>": {
+      "type": "template",
+      "template": "<template_name>",
+      "bind": { "$param": "node_name" }
     }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    [src.path, iterDep?.path].filter((v) => typeof v === "string")
-  );
-  return step;
+  },
+  "templates": {
+    "<template_name>": {
+      "params": ["$param1", "$param2"],
+      "nodes": { ... },
+      "output": "<output_node>"
+    }
+  },
+  "feedback": [
+    { "from": "<condition_node>", "to": "<state_node>", "maxIterations": 10 }
+  ]
 }
-function subPipeline(graph, name, childOrBuild, opts) {
-  const child = childOrBuild instanceof Graph ? childOrBuild : pipeline(name, opts);
-  if (typeof childOrBuild === "function") {
-    childOrBuild(child);
-  }
-  graph.mount(name, child);
-  return child;
+
+Rules:
+- "state" nodes hold user/LLM-writable values (knobs). Use "initial" for default values.
+- "derived" nodes compute from deps using a named "fn".
+- "effect" nodes produce side effects from deps.
+- "producer" nodes generate values from a named "source".
+- Use "templates" when the same subgraph pattern repeats (e.g., per-source resilience).
+- Use "feedback" for bounded cycles where a derived value writes back to a state node.
+- meta.description is required for every node.
+- Return ONLY valid JSON, no markdown fences or commentary.`;
+function stripFences2(text) {
+  const match = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```[\s\S]*$/);
+  return match ? match[1] : text;
 }
-function sensor(graph, name, initial, opts) {
-  const source = node([], () => void 0, {
-    ...opts,
-    name,
-    initial,
-    describeKind: "producer",
-    meta: baseMeta("sensor", opts?.meta)
+async function llmCompose(problem, adapter, opts) {
+  let systemPrompt = LLM_COMPOSE_SYSTEM_PROMPT;
+  if (opts?.catalogDescription) {
+    systemPrompt += `
+
+Available catalog:
+${opts.catalogDescription}`;
+  }
+  if (opts?.systemPromptExtra) {
+    systemPrompt += `
+
+${opts.systemPromptExtra}`;
+  }
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: problem }
+  ];
+  const rawResult = adapter.invoke(messages, {
+    model: opts?.model,
+    temperature: opts?.temperature ?? 0,
+    maxTokens: opts?.maxTokens
   });
-  registerStep(graph, name, source, []);
-  return {
-    node: source,
-    push(value) {
-      source.down([[DATA, value]]);
-    },
-    error(err) {
-      source.down([[ERROR, err]]);
-    },
-    complete() {
-      source.down([[COMPLETE]]);
-    }
-  };
+  const response = await rawResult;
+  let content = response.content.trim();
+  if (content.startsWith("```")) {
+    content = stripFences2(content);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error(`llmCompose: LLM response is not valid JSON: ${content.slice(0, 200)}`);
+  }
+  const validation = validateSpec(parsed);
+  if (!validation.valid) {
+    throw new Error(`llmCompose: invalid GraphSpec:
+${validation.errors.join("\n")}`);
+  }
+  return parsed;
 }
-function wait(graph, name, source, ms, opts) {
-  const src = resolveDep(graph, source);
-  const timers = /* @__PURE__ */ new Set();
-  let terminated = false;
-  let completed = false;
-  const step = node(
-    [src.node],
-    () => {
-      for (const id of timers) clearTimeout(id);
-      timers.clear();
-      return () => {
-        for (const id of timers) clearTimeout(id);
-        timers.clear();
-        terminated = true;
-      };
-    },
+async function llmRefine(currentSpec, feedback2, adapter, opts) {
+  let systemPrompt = LLM_COMPOSE_SYSTEM_PROMPT;
+  if (opts?.catalogDescription) {
+    systemPrompt += `
+
+Available catalog:
+${opts.catalogDescription}`;
+  }
+  if (opts?.systemPromptExtra) {
+    systemPrompt += `
+
+${opts.systemPromptExtra}`;
+  }
+  const messages = [
+    { role: "system", content: systemPrompt },
     {
-      ...opts,
-      name,
-      initial: src.node.get(),
-      describeKind: "operator",
-      completeWhenDepsComplete: false,
-      meta: baseMeta("wait", opts?.meta),
-      onMessage(msg, depIndex, actions) {
-        if (terminated) return true;
-        if (depIndex !== 0) {
-          actions.down([msg]);
-          if (msg[0] === COMPLETE || msg[0] === ERROR) terminated = true;
-          return true;
-        }
-        if (msg[0] === DATA) {
-          const id = setTimeout(() => {
-            timers.delete(id);
-            actions.down([msg]);
-            if (completed && timers.size === 0) {
-              actions.down([[COMPLETE]]);
-            }
-          }, ms);
-          timers.add(id);
-          return true;
-        }
-        if (msg[0] === COMPLETE) {
-          terminated = true;
-          completed = true;
-          if (timers.size === 0) {
-            actions.down([[COMPLETE]]);
-          }
-          return true;
-        }
-        if (msg[0] === ERROR) {
-          terminated = true;
-          for (const id of timers) clearTimeout(id);
-          timers.clear();
-          actions.down([msg]);
-          return true;
-        }
-        actions.down([msg]);
-        return true;
-      }
-    }
-  );
-  registerStep(graph, name, step, src.path ? [src.path] : []);
-  return step;
-}
-function onFailure(graph, name, source, recover, opts) {
-  const src = resolveDep(graph, source);
-  let terminated = false;
-  const step = node([src.node], () => void 0, {
-    ...opts,
-    name,
-    describeKind: "operator",
-    completeWhenDepsComplete: false,
-    meta: baseMeta("onFailure", opts?.meta),
-    onMessage(msg, _depIndex, actions) {
-      if (terminated) return true;
-      if (msg[0] === ERROR) {
-        try {
-          actions.emit(recover(msg[1], actions));
-        } catch (err) {
-          terminated = true;
-          actions.down([[ERROR, err]]);
-        }
-        return true;
-      }
-      actions.down([msg]);
-      if (msg[0] === COMPLETE) terminated = true;
-      return true;
+      role: "user",
+      content: `Current GraphSpec:
+${JSON.stringify(currentSpec, null, 2)}
+
+Modification request: ${feedback2}
+
+Return the complete modified GraphSpec as JSON.`
     }
+  ];
+  const rawResult = adapter.invoke(messages, {
+    model: opts?.model,
+    temperature: opts?.temperature ?? 0,
+    maxTokens: opts?.maxTokens
   });
-  registerStep(graph, name, step, src.path ? [src.path] : []);
-  return step;
+  const response = await rawResult;
+  let content = response.content.trim();
+  if (content.startsWith("```")) {
+    content = stripFences2(content);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error(`llmRefine: LLM response is not valid JSON: ${content.slice(0, 200)}`);
+  }
+  const validation = validateSpec(parsed);
+  if (!validation.valid) {
+    throw new Error(`llmRefine: invalid GraphSpec:
+${validation.errors.join("\n")}`);
+  }
+  return parsed;
 }
 
-// src/patterns/reactive-layout/index.ts
-var reactive_layout_exports = {};
-__export(reactive_layout_exports, {
-  CanvasMeasureAdapter: () => CanvasMeasureAdapter,
-  CliMeasureAdapter: () => CliMeasureAdapter,
-  ImageSizeAdapter: () => ImageSizeAdapter,
-  NodeCanvasMeasureAdapter: () => NodeCanvasMeasureAdapter,
-  PrecomputedAdapter: () => PrecomputedAdapter,
-  SvgBoundsAdapter: () => SvgBoundsAdapter,
-  analyzeAndMeasure: () => analyzeAndMeasure,
-  computeBlockFlow: () => computeBlockFlow,
-  computeCharPositions: () => computeCharPositions,
-  computeLineBreaks: () => computeLineBreaks,
-  computeTotalHeight: () => computeTotalHeight,
-  measureBlock: () => measureBlock,
-  measureBlocks: () => measureBlocks,
-  reactiveBlockLayout: () => reactiveBlockLayout,
-  reactiveLayout: () => reactiveLayout
+// src/patterns/messaging.ts
+var messaging_exports = {};
+__export(messaging_exports, {
+  JobFlowGraph: () => JobFlowGraph,
+  JobQueueGraph: () => JobQueueGraph,
+  SubscriptionGraph: () => SubscriptionGraph,
+  TopicBridgeGraph: () => TopicBridgeGraph,
+  TopicGraph: () => TopicGraph,
+  jobFlow: () => jobFlow,
+  jobQueue: () => jobQueue,
+  subscription: () => subscription,
+  topic: () => topic,
+  topicBridge: () => topicBridge
 });
-
-// src/patterns/reactive-layout/measurement-adapters.ts
-function cellWidth(code) {
-  if (code >= 768 && code <= 879 || // Combining Diacritical Marks
-  code >= 1155 && code <= 1161 || // Cyrillic combining marks
-  code >= 1425 && code <= 1469 || // Hebrew combining marks
-  code >= 1552 && code <= 1562 || // Arabic combining marks
-  code >= 1611 && code <= 1631 || // Arabic combining marks
-  code >= 1648 && code === 1648 || // Arabic superscript alef
-  code >= 1750 && code <= 1756 || // Arabic combining marks
-  code >= 1759 && code <= 1764 || // Arabic combining marks
-  code >= 1767 && code <= 1768 || // Arabic combining marks
-  code >= 1770 && code <= 1773 || // Arabic combining marks
-  code >= 1840 && code <= 1866 || // Syriac combining marks
-  code >= 1958 && code <= 1968 || // Thaana combining marks
-  code >= 2304 && code <= 2307 || // Devanagari combining marks
-  code >= 2362 && code <= 2383 || // Devanagari combining marks
-  code >= 2385 && code <= 2391 || // Devanagari combining marks
-  code >= 2402 && code <= 2403 || // Devanagari combining marks
-  code >= 2433 && code <= 2435 || // Bengali combining marks
-  code >= 2492 && code <= 2509 || // Bengali combining marks
-  code >= 2561 && code <= 2563 || // Gurmukhi combining marks
-  code >= 2620 && code <= 2641 || // Gurmukhi combining marks
-  code >= 2672 && code <= 2673 || // Gurmukhi combining marks
-  code >= 2677 && code === 2677 || // Gurmukhi combining mark
-  code >= 3633 && code === 3633 || // Thai combining mark
-  code >= 3636 && code <= 3642 || // Thai combining marks
-  code >= 3655 && code <= 3662 || // Thai combining marks
-  code >= 3761 && code === 3761 || // Lao combining mark
-  code >= 3764 && code <= 3772 || // Lao combining marks
-  code >= 3784 && code <= 3790 || // Lao combining marks
-  code >= 7616 && code <= 7679 || // Combining Diacritical Marks Supplement
-  code >= 8400 && code <= 8447 || // Combining Diacritical Marks for Symbols
-  code >= 65024 && code <= 65039 || // Variation Selectors
-  code >= 65056 && code <= 65071 || // Combining Half Marks
-  code === 8205) {
-    return 0;
+var DEFAULT_MAX_PER_PUMP = 2147483647;
+function requireNonNegativeInt(value, label) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
   }
-  if (code >= 4352 && code <= 4447 || // Hangul Jamo
-  code >= 8986 && code <= 8987 || // Watch, Hourglass
-  code >= 9001 && code <= 9002 || // Angle brackets
-  code >= 9193 && code <= 9203 || // Media control symbols
-  code >= 9208 && code <= 9210 || // Media control symbols
-  code >= 9725 && code <= 9726 || // Medium squares
-  code >= 9748 && code <= 9749 || // Umbrella, Hot Beverage
-  code >= 9800 && code <= 9811 || // Zodiac symbols
-  code === 9855 || // Wheelchair
-  code === 9875 || // Anchor
-  code === 9889 || // High Voltage
-  code >= 9898 && code <= 9899 || // Medium circles
-  code >= 9917 && code <= 9918 || // Soccer, Baseball
-  code >= 9924 && code <= 9925 || // Snowman, Sun behind cloud
-  code === 9934 || // Ophiuchus
-  code === 9940 || // No Entry
-  code === 9962 || // Church
-  code >= 9970 && code <= 9971 || // Fountain, Golf
-  code === 9973 || // Sailboat
-  code === 9978 || // Tent
-  code === 9981 || // Fuel Pump
-  code === 9986 || // Scissors
-  code === 9989 || // Check Mark
-  code >= 9992 && code <= 9997 || // Airplane...Writing Hand
-  code === 9999 || // Pencil
-  code >= 10067 && code <= 10069 || // Question marks
-  code === 10071 || // Exclamation
-  code >= 10133 && code <= 10135 || // Plus, Minus, Divide
-  code === 10160 || // Curly Loop
-  code === 10175 || // Double Curly Loop
-  code >= 10548 && code <= 10549 || // Arrows
-  code >= 11013 && code <= 11015 || // Arrows
-  code >= 11035 && code <= 11036 || // Squares
-  code === 11088 || // Star
-  code === 11093 || // Circle
-  code >= 11904 && code <= 12350 || // CJK Radicals, Symbols, Punctuation
-  code >= 12352 && code <= 12447 || // Hiragana
-  code >= 12448 && code <= 12543 || // Katakana
-  code >= 12549 && code <= 12591 || // Bopomofo
-  code >= 12593 && code <= 12686 || // Hangul Compatibility Jamo
-  code >= 12688 && code <= 12771 || // Kanbun, CJK Strokes
-  code >= 12784 && code <= 12830 || // Katakana Phonetic Extensions
-  code >= 12832 && code <= 12871 || // Enclosed CJK
-  code >= 12880 && code <= 19903 || // CJK Extensions + Unified block
-  code >= 19968 && code <= 40959 || // CJK Unified Ideographs
-  code >= 43360 && code <= 43388 || // Hangul Jamo Extended-A
-  code >= 44032 && code <= 55203 || // Hangul Syllables
-  code >= 63744 && code <= 64255 || // CJK Compatibility Ideographs
-  code >= 65040 && code <= 65049 || // Vertical forms
-  code >= 65072 && code <= 65131 || // CJK Compatibility Forms
-  code >= 65281 && code <= 65376 || // Fullwidth Forms (excl. halfwidth)
-  code >= 65504 && code <= 65510 || // Fullwidth Signs
-  code >= 126980 && code === 126980 || // Mahjong Red Dragon
-  code === 127183 || // Joker
-  code >= 127344 && code <= 127345 || // A/B buttons
-  code === 127358 || // O button
-  code === 127359 || // P button
-  code === 127374 || // AB button
-  code >= 127377 && code <= 127386 || // Squared symbols
-  code >= 127456 && code <= 127487 || // Regional Indicator Symbols
-  code >= 127488 && code <= 127490 || // Enclosed ideographic
-  code === 127514 || // Squared CJK
-  code === 127535 || // Squared CJK
-  code >= 127538 && code <= 127546 || // Squared CJK
-  code >= 127568 && code <= 127569 || // Circled ideographic
-  code >= 127744 && code <= 129535 || // Misc Symbols / Emoticons / Emoji
-  code >= 129536 && code <= 129791 || // Chess, Symbols Extended-A
-  code >= 129792 && code <= 130047 || // Symbols for Legacy Computing
-  code >= 131072 && code <= 196605 || // CJK Extension B-F (excl. nonchars)
-  code >= 196608 && code <= 262141) {
-    return 2;
+  return value;
+}
+function keepalive4(n) {
+  return n.subscribe(() => {
+  });
+}
+function messagingMeta(kind, extra) {
+  return {
+    messaging: true,
+    messaging_type: kind,
+    ...extra ?? {}
+  };
+}
+var TopicGraph = class extends Graph {
+  _log;
+  _keepaliveDisposers = [];
+  events;
+  latest;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    this._log = reactiveLog([], { name: "events", maxSize: opts.retainedLimit });
+    this.events = this._log.entries;
+    this.add("events", this.events);
+    this.latest = derived(
+      [this.events],
+      ([snapshot]) => {
+        const entries = snapshot.value.entries;
+        return entries.length === 0 ? void 0 : entries[entries.length - 1];
+      },
+      {
+        name: "latest",
+        describeKind: "derived",
+        meta: messagingMeta("topic_latest"),
+        initial: void 0
+      }
+    );
+    this.add("latest", this.latest);
+    this.connect("events", "latest");
+    this._keepaliveDisposers.push(keepalive4(this.latest));
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
+  }
+  publish(value) {
+    this._log.append(value);
+  }
+  retained() {
+    const snapshot = this.events.get();
+    return snapshot.value.entries;
+  }
+};
+var SubscriptionGraph = class extends Graph {
+  _keepaliveDisposers = [];
+  source;
+  cursor;
+  available;
+  constructor(name, topicGraph, opts = {}) {
+    super(name, opts.graph);
+    const initialCursor = requireNonNegativeInt(opts.cursor ?? 0, "subscription cursor");
+    this.mount("topic", topicGraph);
+    const topicEvents = topicGraph.events;
+    this.source = derived([topicEvents], ([snapshot]) => snapshot, {
+      name: "source",
+      describeKind: "derived",
+      meta: messagingMeta("subscription_source"),
+      initial: topicEvents.get()
+    });
+    this.add("source", this.source);
+    this.cursor = state(initialCursor, {
+      name: "cursor",
+      describeKind: "state",
+      meta: messagingMeta("subscription_cursor")
+    });
+    this.add("cursor", this.cursor);
+    this.available = derived(
+      [this.source, this.cursor],
+      ([sourceSnapshot, cursor]) => {
+        const entries = sourceSnapshot.value.entries;
+        const start = Math.max(0, Math.trunc(cursor ?? 0));
+        return entries.slice(start);
+      },
+      {
+        name: "available",
+        describeKind: "derived",
+        meta: messagingMeta("subscription_available"),
+        initial: []
+      }
+    );
+    this.add("available", this.available);
+    this.connect("topic::events", "source");
+    this.connect("source", "available");
+    this.connect("cursor", "available");
+    this._keepaliveDisposers.push(keepalive4(this.source));
+    this._keepaliveDisposers.push(keepalive4(this.available));
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
+  }
+  ack(count) {
+    const available = this.available.get();
+    const requested = count === void 0 ? available.length : requireNonNegativeInt(count, "subscription ack count");
+    const step = Math.min(requested, available.length);
+    if (step <= 0) return this.cursor.get();
+    const next = this.cursor.get() + step;
+    this.cursor.down([[DATA, next]]);
+    return next;
+  }
+  pull(limit, opts = {}) {
+    const available = this.available.get();
+    const max = limit === void 0 ? available.length : requireNonNegativeInt(limit, "subscription pull limit");
+    const out = available.slice(0, max);
+    if (opts.ack && out.length > 0) this.ack(out.length);
+    return out;
+  }
+};
+var JobQueueGraph = class extends Graph {
+  _pending;
+  _jobs;
+  _keepaliveDisposers = [];
+  _seq = 0;
+  pending;
+  jobs;
+  depth;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    this._pending = reactiveList([], { name: "pending" });
+    this._jobs = reactiveMap({ name: "jobs" });
+    this.pending = this._pending.items;
+    this.jobs = this._jobs.node;
+    this.add("pending", this.pending);
+    this.add("jobs", this.jobs);
+    this.depth = derived(
+      [this.pending],
+      ([snapshot]) => snapshot.value.items.length,
+      {
+        name: "depth",
+        describeKind: "derived",
+        meta: messagingMeta("queue_depth"),
+        initial: 0
+      }
+    );
+    this.add("depth", this.depth);
+    this.connect("pending", "depth");
+    this._keepaliveDisposers.push(keepalive4(this.depth));
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
+  }
+  enqueue(payload, opts = {}) {
+    const id = opts.id ?? `${this.name}-${++this._seq}`;
+    if (this._jobs.get(id) !== void 0) {
+      throw new Error(`jobQueue("${this.name}"): duplicate job id "${id}"`);
+    }
+    const job = {
+      id,
+      payload,
+      attempts: 0,
+      metadata: Object.freeze({ ...opts.metadata ?? {} }),
+      state: "queued"
+    };
+    this._jobs.set(id, job);
+    this._pending.append(id);
+    return id;
   }
-  return 1;
-}
-function countCells(text) {
-  let cells = 0;
-  for (const ch of text) {
-    cells += cellWidth(ch.codePointAt(0));
+  claim(limit = 1) {
+    const max = requireNonNegativeInt(limit, "job queue claim limit");
+    if (max === 0) return [];
+    const out = [];
+    while (out.length < max) {
+      const snapshot = this.pending.get();
+      const ids = snapshot.value.items;
+      if (ids.length === 0) break;
+      const id = this._pending.pop(0);
+      const job = this._jobs.get(id);
+      if (!job || job.state !== "queued") continue;
+      const inflight = {
+        ...job,
+        state: "inflight",
+        attempts: job.attempts + 1
+      };
+      this._jobs.set(id, inflight);
+      out.push(inflight);
+    }
+    return out;
   }
-  return cells;
-}
-var CliMeasureAdapter = class {
-  cellPx;
-  constructor(opts) {
-    this.cellPx = opts?.cellPx ?? 8;
+  ack(id) {
+    const job = this._jobs.get(id);
+    if (!job || job.state !== "inflight") return false;
+    this._jobs.delete(id);
+    return true;
   }
-  measureSegment(text, _font) {
-    return { width: countCells(text) * this.cellPx };
+  nack(id, opts = {}) {
+    const job = this._jobs.get(id);
+    if (!job || job.state !== "inflight") return false;
+    if (opts.requeue ?? true) {
+      this._jobs.set(id, { ...job, state: "queued" });
+      this._pending.append(id);
+      return true;
+    }
+    this._jobs.delete(id);
+    return true;
   }
 };
-var PrecomputedAdapterKeyError = class extends Error {
-  name = "KeyError";
-};
-var PrecomputedAdapter = class {
-  metrics;
-  fallback;
-  constructor(opts) {
-    this.metrics = opts.metrics;
-    const fb = opts.fallback ?? "per-char";
-    if (fb !== "per-char" && fb !== "error") {
-      throw new Error(
-        `fallback must be 'per-char' or 'error', got ${JSON.stringify(opts.fallback)}`
-      );
+var JobFlowGraph = class extends Graph {
+  _stageNames;
+  _queues = /* @__PURE__ */ new Map();
+  _keepaliveDisposers = [];
+  _completed;
+  completed;
+  completedCount;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    const stages = (opts.stages ?? ["incoming", "processing", "done"]).map((v) => v.trim());
+    if (stages.length < 2) {
+      throw new Error(`jobFlow("${name}"): requires at least 2 stages`);
     }
-    this.fallback = fb;
-  }
-  measureSegment(text, font) {
-    const fontMap = this.metrics[font];
-    if (fontMap) {
-      const w = fontMap[text];
-      if (w !== void 0) return { width: w };
+    const unique = new Set(stages);
+    if (unique.size !== stages.length) {
+      throw new Error(`jobFlow("${name}"): stage names must be unique`);
     }
-    if (this.fallback === "error") {
-      throw new PrecomputedAdapterKeyError(
-        `PrecomputedAdapter: no metrics for segment ${JSON.stringify(text)} in font ${JSON.stringify(font)}`
-      );
+    this._stageNames = Object.freeze([...stages]);
+    for (const stage of this._stageNames) {
+      const q = jobQueue(`${name}-${stage}`);
+      this._queues.set(stage, q);
+      this.mount(stage, q);
     }
-    let total = 0;
-    if (fontMap) {
-      for (const ch of text) {
-        const cw = fontMap[ch];
-        if (cw !== void 0) {
-          total += cw;
-        }
+    this._completed = reactiveLog([], { name: "completed" });
+    this.completed = this._completed.entries;
+    this.add("completed", this.completed);
+    this.completedCount = derived(
+      [this.completed],
+      ([snapshot]) => snapshot.value.entries.length,
+      {
+        name: "completedCount",
+        describeKind: "derived",
+        meta: messagingMeta("job_flow_completed_count"),
+        initial: 0
       }
+    );
+    this.add("completedCount", this.completedCount);
+    this.connect("completed", "completedCount");
+    this._keepaliveDisposers.push(keepalive4(this.completedCount));
+    const maxPerPump = Math.max(
+      1,
+      requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "job flow maxPerPump")
+    );
+    for (let i = 0; i < this._stageNames.length; i += 1) {
+      const stage = this._stageNames[i];
+      const current = this.queue(stage);
+      const next = i + 1 < this._stageNames.length ? this.queue(this._stageNames[i + 1]) : null;
+      const pump = node(
+        [current.pending],
+        () => {
+          let moved = 0;
+          while (moved < maxPerPump) {
+            const claim = current.claim(1);
+            if (claim.length === 0) break;
+            const job = claim[0];
+            if (!job) break;
+            if (next) {
+              next.enqueue(job.payload, {
+                metadata: {
+                  ...job.metadata,
+                  job_flow_from: stage
+                }
+              });
+            } else {
+              this._completed.append(job);
+            }
+            current.ack(job.id);
+            moved += 1;
+          }
+        },
+        {
+          name: `pump_${stage}`,
+          describeKind: "effect",
+          meta: messagingMeta("job_flow_pump")
+        }
+      );
+      this.add(`pump_${stage}`, pump);
+      this.connect(`${stage}::pending`, `pump_${stage}`);
+      this._keepaliveDisposers.push(keepalive4(pump));
     }
-    return { width: total };
   }
-};
-var CanvasMeasureAdapter = class {
-  ctx = null;
-  currentFont = "";
-  emojiCorrection;
-  constructor(opts) {
-    this.emojiCorrection = opts?.emojiCorrection ?? 1;
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
   }
-  getContext() {
-    if (!this.ctx) {
-      if (typeof OffscreenCanvas === "undefined") {
-        throw new Error(
-          "CanvasMeasureAdapter requires a browser environment with OffscreenCanvas support. Use CliMeasureAdapter or NodeCanvasMeasureAdapter for Node.js."
-        );
-      }
-      const canvas = new OffscreenCanvas(0, 0);
-      const ctx = canvas.getContext("2d");
-      if (!ctx) throw new Error("CanvasMeasureAdapter: failed to get 2d context");
-      this.ctx = ctx;
-    }
-    return this.ctx;
+  stages() {
+    return this._stageNames;
   }
-  measureSegment(text, font) {
-    const ctx = this.getContext();
-    if (font !== this.currentFont) {
-      ctx.font = font;
-      this.currentFont = font;
-    }
-    let width = ctx.measureText(text).width;
-    if (this.emojiCorrection !== 1 && /\p{Emoji_Presentation}/u.test(text)) {
-      width *= this.emojiCorrection;
-    }
-    return { width };
+  queue(stage) {
+    const q = this._queues.get(stage);
+    if (!q) throw new Error(`jobFlow("${this.name}"): unknown stage "${stage}"`);
+    return q;
   }
-  clearCache() {
-    this.currentFont = "";
+  enqueue(payload, opts = {}) {
+    return this.queue(this._stageNames[0]).enqueue(payload, opts);
+  }
+  retainedCompleted() {
+    const snapshot = this.completed.get();
+    return snapshot.value.entries;
+  }
+};
+var TopicBridgeGraph = class extends Graph {
+  _sourceSub;
+  _target;
+  _keepaliveDisposers = [];
+  bridgedCount;
+  constructor(name, sourceTopic, targetTopic, opts = {}) {
+    super(name, opts.graph);
+    this._sourceSub = subscription(`${name}-subscription`, sourceTopic, {
+      cursor: opts.cursor
+    });
+    this._target = targetTopic;
+    this.mount("subscription", this._sourceSub);
+    this.bridgedCount = state(0, {
+      name: "bridgedCount",
+      describeKind: "state",
+      meta: messagingMeta("topic_bridge_count")
+    });
+    this.add("bridgedCount", this.bridgedCount);
+    const maxPerPump = Math.max(
+      1,
+      requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "topic bridge maxPerPump")
+    );
+    const mapValue = opts.map ?? ((value) => value);
+    const pump = node(
+      [this._sourceSub.available],
+      () => {
+        const available = this._sourceSub.pull(maxPerPump, { ack: true });
+        if (available.length === 0) return;
+        let bridged = 0;
+        for (const value of available) {
+          const mapped = mapValue(value);
+          if (mapped === void 0) continue;
+          this._target.publish(mapped);
+          bridged += 1;
+        }
+        if (bridged > 0) {
+          const current = this.bridgedCount.get();
+          this.bridgedCount.down([[DATA, current + bridged]]);
+        }
+      },
+      {
+        name: "pump",
+        describeKind: "effect",
+        meta: messagingMeta("topic_bridge_pump")
+      }
+    );
+    this.add("pump", pump);
+    this.connect("subscription::available", "pump");
+    this._keepaliveDisposers.push(keepalive4(pump));
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
   }
 };
-var NodeCanvasMeasureAdapter = class {
-  ctx = null;
-  currentFont = "";
-  canvasModule;
-  constructor(canvasModule) {
-    this.canvasModule = canvasModule;
+function topic(name, opts) {
+  return new TopicGraph(name, opts);
+}
+function subscription(name, topicGraph, opts) {
+  return new SubscriptionGraph(name, topicGraph, opts);
+}
+function jobQueue(name, opts) {
+  return new JobQueueGraph(name, opts);
+}
+function jobFlow(name, opts) {
+  return new JobFlowGraph(name, opts);
+}
+function topicBridge(name, sourceTopic, targetTopic, opts) {
+  return new TopicBridgeGraph(name, sourceTopic, targetTopic, opts);
+}
+
+// src/patterns/orchestration.ts
+var orchestration_exports = {};
+__export(orchestration_exports, {
+  approval: () => approval,
+  branch: () => branch,
+  forEach: () => forEach2,
+  gate: () => gate2,
+  join: () => join2,
+  loop: () => loop,
+  onFailure: () => onFailure,
+  pipeline: () => pipeline,
+  sensor: () => sensor,
+  subPipeline: () => subPipeline,
+  task: () => task,
+  wait: () => wait
+});
+function resolveDep(graph, dep) {
+  if (typeof dep === "string") {
+    return { node: graph.resolve(dep), path: dep };
   }
-  getContext() {
-    if (!this.ctx) {
-      const canvas = this.canvasModule.createCanvas(0, 0);
-      const ctx = canvas.getContext("2d");
-      if (!ctx) throw new Error("NodeCanvasMeasureAdapter: failed to get 2d context");
-      this.ctx = ctx;
-    }
-    return this.ctx;
+  const path = findRegisteredNodePath(graph, dep);
+  if (!path) {
+    throw new Error(
+      "orchestration dep node must already be registered in the graph so explicit edges can be recorded; pass a string path or register the node first"
+    );
   }
-  measureSegment(text, font) {
-    const ctx = this.getContext();
-    if (font !== this.currentFont) {
-      ctx.font = font;
-      this.currentFont = font;
+  return { node: dep, path };
+}
+function findRegisteredNodePath(graph, target) {
+  const described = graph.describe();
+  const metaSegment = `::${GRAPH_META_SEGMENT}::`;
+  for (const path of Object.keys(described.nodes).sort()) {
+    if (path.includes(metaSegment)) continue;
+    try {
+      if (graph.resolve(path) === target) return path;
+    } catch {
     }
-    return { width: ctx.measureText(text).width };
-  }
-  clearCache() {
-    this.currentFont = "";
   }
-};
-var SvgBoundsAdapter = class {
-  measureSvg(content) {
-    const viewBoxMatch = content.match(/viewBox\s*=\s*["']([^"']+)["']/);
-    if (viewBoxMatch) {
-      const parts = viewBoxMatch[1].trim().split(/[\s,]+/);
-      if (parts.length >= 4) {
-        const w = Number.parseFloat(parts[2]);
-        const h = Number.parseFloat(parts[3]);
-        if (Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0) {
-          return { width: w, height: h };
-        }
-        throw new Error(
-          "SvgBoundsAdapter: viewBox width/height are missing, non-finite, or not positive"
-        );
-      }
-    }
-    const widthMatch = content.match(/<svg[^>]*\bwidth\s*=\s*["']?([\d.]+)/);
-    const heightMatch = content.match(/<svg[^>]*\bheight\s*=\s*["']?([\d.]+)/);
-    if (widthMatch && heightMatch) {
-      const w = Number.parseFloat(widthMatch[1]);
-      const h = Number.parseFloat(heightMatch[1]);
-      if (Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0) {
-        return { width: w, height: h };
-      }
-      throw new Error(
-        "SvgBoundsAdapter: svg width/height attributes are non-finite or not positive"
-      );
-    }
-    throw new Error(
-      "SvgBoundsAdapter: cannot determine dimensions \u2014 SVG has no viewBox or width/height attributes"
-    );
+  return void 0;
+}
+function registerStep(graph, name, step, depPaths) {
+  graph.add(name, step);
+  for (const path of depPaths) {
+    graph.connect(path, name);
   }
-};
-var ImageSizeAdapter = class {
-  sizes;
-  constructor(sizes) {
-    this.sizes = new Map(Object.entries(sizes));
+}
+function baseMeta2(kind, meta) {
+  return {
+    orchestration: true,
+    orchestration_type: kind,
+    ...meta ?? {}
+  };
+}
+function coerceLoopIterations(raw) {
+  const parseString = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) return 0;
+    return Number(trimmed);
+  };
+  let parsed;
+  if (typeof raw === "string") {
+    parsed = parseString(raw);
+  } else if (raw === null) {
+    parsed = 0;
+  } else {
+    parsed = Number(raw);
   }
-  measureImage(src) {
-    const dims = this.sizes.get(src);
-    if (!dims) {
-      throw new Error(`ImageSizeAdapter: no dimensions registered for ${JSON.stringify(src)}`);
+  if (!Number.isFinite(parsed)) return 1;
+  return Math.max(0, Math.trunc(parsed));
+}
+function pipeline(name, opts) {
+  return new Graph(name, opts);
+}
+function task(graph, name, run, opts) {
+  const depRefs = opts?.deps ?? [];
+  const deps = depRefs.map((dep) => resolveDep(graph, dep));
+  const { deps: _deps, ...nodeOpts } = opts ?? {};
+  const step = node(
+    deps.map((d) => d.node),
+    run,
+    {
+      ...nodeOpts,
+      name,
+      describeKind: "derived",
+      meta: baseMeta2("task", opts?.meta)
     }
-    return { width: dims.width, height: dims.height };
-  }
-};
-
-// src/patterns/reactive-layout/reactive-block-layout.ts
-function measureBlock(block, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight, index) {
-  switch (block.type) {
-    case "text": {
-      const font = block.font ?? defaultFont;
-      const lineHeight = block.lineHeight ?? defaultLineHeight;
-      const segments = analyzeAndMeasure(block.text, font, adapters.text, measureCache);
-      const lineBreaks = computeLineBreaks(segments, maxWidth, adapters.text, font, measureCache);
-      const charPositions = computeCharPositions(lineBreaks, segments, lineHeight);
-      const height = lineBreaks.lineCount * lineHeight;
-      let width = 0;
-      for (const line of lineBreaks.lines) {
-        if (line.width > width) width = line.width;
-      }
-      return {
-        index,
-        type: "text",
-        width: Math.min(width, maxWidth),
-        height,
-        textSegments: segments,
-        textLineBreaks: lineBreaks,
-        textCharPositions: charPositions
-      };
+  );
+  registerStep(
+    graph,
+    name,
+    step,
+    deps.flatMap((d) => d.path ? [d.path] : [])
+  );
+  return step;
+}
+function branch(graph, name, source, predicate, opts) {
+  const src = resolveDep(graph, source);
+  const step = node(
+    [src.node],
+    ([value]) => ({
+      branch: predicate(value) ? "then" : "else",
+      value
+    }),
+    {
+      ...opts,
+      name,
+      describeKind: "derived",
+      meta: baseMeta2("branch", opts?.meta)
     }
-    case "image": {
-      let w;
-      let h;
-      if (block.naturalWidth != null && block.naturalHeight != null) {
-        w = block.naturalWidth;
-        h = block.naturalHeight;
-      } else if (adapters.image) {
-        const dims = adapters.image.measureImage(block.src);
-        w = dims.width;
-        h = dims.height;
-      } else {
-        throw new Error(
-          `Image block at index ${index} has no naturalWidth/naturalHeight and no ImageMeasurer adapter`
-        );
+  );
+  registerStep(graph, name, step, src.path ? [src.path] : []);
+  return step;
+}
+function gate2(graph, name, source, control, opts) {
+  const src = resolveDep(graph, source);
+  const ctrl = resolveDep(graph, control);
+  const step = node(
+    [src.node, ctrl.node],
+    (_deps, actions) => {
+      const opened = ctrl.node.get();
+      if (!opened) {
+        actions.down([[RESOLVED]]);
+        return void 0;
       }
-      if (w > maxWidth) {
-        h = h * maxWidth / w;
-        w = maxWidth;
+      return src.node.get();
+    },
+    {
+      ...opts,
+      name,
+      describeKind: "operator",
+      meta: baseMeta2("gate", opts?.meta)
+    }
+  );
+  registerStep(
+    graph,
+    name,
+    step,
+    [src.path, ctrl.path].filter((v) => typeof v === "string")
+  );
+  return step;
+}
+function approval(graph, name, source, approver, opts) {
+  const src = resolveDep(graph, source);
+  const ctrl = resolveDep(graph, approver);
+  const isApproved = opts?.isApproved ?? ((value) => Boolean(value));
+  const step = node(
+    [src.node, ctrl.node],
+    (_deps, actions) => {
+      if (!isApproved(ctrl.node.get())) {
+        actions.down([[RESOLVED]]);
+        return void 0;
       }
-      return { index, type: "image", width: w, height: h };
+      return src.node.get();
+    },
+    {
+      ...opts,
+      name,
+      describeKind: "operator",
+      meta: baseMeta2("approval", opts?.meta)
     }
-    case "svg": {
-      let w;
-      let h;
-      if (block.viewBox) {
-        w = block.viewBox.width;
-        h = block.viewBox.height;
-      } else if (adapters.svg) {
-        const dims = adapters.svg.measureSvg(block.content);
-        w = dims.width;
-        h = dims.height;
-      } else {
-        throw new Error(`SVG block at index ${index} has no viewBox and no SvgMeasurer adapter`);
+  );
+  registerStep(
+    graph,
+    name,
+    step,
+    [src.path, ctrl.path].filter((v) => typeof v === "string")
+  );
+  return step;
+}
+function forEach2(graph, name, source, run, opts) {
+  const src = resolveDep(graph, source);
+  let terminated = false;
+  const step = node([src.node], () => void 0, {
+    ...opts,
+    name,
+    describeKind: "effect",
+    completeWhenDepsComplete: false,
+    meta: baseMeta2("forEach", opts?.meta),
+    onMessage(msg, depIndex, actions) {
+      if (terminated) return true;
+      if (depIndex !== 0) {
+        actions.down([msg]);
+        if (msg[0] === COMPLETE || msg[0] === ERROR) terminated = true;
+        return true;
       }
-      if (w > maxWidth) {
-        h = h * maxWidth / w;
-        w = maxWidth;
+      if (msg[0] === DATA) {
+        try {
+          run(msg[1], actions);
+          actions.down([msg]);
+        } catch (err) {
+          terminated = true;
+          actions.down([[ERROR, err]]);
+        }
+        return true;
       }
-      return { index, type: "svg", width: w, height: h };
+      actions.down([msg]);
+      if (msg[0] === COMPLETE || msg[0] === ERROR) terminated = true;
+      return true;
     }
-  }
+  });
+  registerStep(graph, name, step, src.path ? [src.path] : []);
+  return step;
 }
-function measureBlocks(blocks, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight) {
-  return blocks.map(
-    (block, i) => measureBlock(block, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight, i)
+function join2(graph, name, deps, opts) {
+  const resolved = deps.map((dep) => resolveDep(graph, dep));
+  const step = node(
+    resolved.map((d) => d.node),
+    (values) => values,
+    {
+      ...opts,
+      name,
+      describeKind: "derived",
+      meta: baseMeta2("join", opts?.meta)
+    }
+  );
+  registerStep(
+    graph,
+    name,
+    step,
+    resolved.flatMap((d) => d.path ? [d.path] : [])
   );
+  return step;
 }
-function computeBlockFlow(measured, gap) {
-  const result = [];
-  let y = 0;
-  for (let i = 0; i < measured.length; i++) {
-    const m = measured[i];
-    result.push({ ...m, x: 0, y });
-    y += m.height + (i < measured.length - 1 ? gap : 0);
+function loop(graph, name, source, iterate, opts) {
+  const src = resolveDep(graph, source);
+  const iterRef = opts?.iterations;
+  const iterDep = typeof iterRef === "number" || iterRef === void 0 ? void 0 : resolveDep(graph, iterRef);
+  const staticIterations = typeof iterRef === "number" ? iterRef : void 0;
+  const step = node(
+    iterDep ? [src.node, iterDep.node] : [src.node],
+    (_deps, actions) => {
+      let current = src.node.get();
+      const rawCount = staticIterations ?? iterDep?.node.get() ?? 1;
+      const count = coerceLoopIterations(rawCount);
+      for (let i = 0; i < count; i += 1) {
+        current = iterate(current, i, actions);
+      }
+      return current;
+    },
+    {
+      ...opts,
+      name,
+      describeKind: "derived",
+      meta: baseMeta2("loop", opts?.meta)
+    }
+  );
+  registerStep(
+    graph,
+    name,
+    step,
+    [src.path, iterDep?.path].filter((v) => typeof v === "string")
+  );
+  return step;
+}
+function subPipeline(graph, name, childOrBuild, opts) {
+  const child = childOrBuild instanceof Graph ? childOrBuild : pipeline(name, opts);
+  if (typeof childOrBuild === "function") {
+    childOrBuild(child);
   }
-  return result;
+  graph.mount(name, child);
+  return child;
 }
-function computeTotalHeight(flow) {
-  if (flow.length === 0) return 0;
-  const last2 = flow[flow.length - 1];
-  return last2.y + last2.height;
+function sensor(graph, name, initial, opts) {
+  const source = node([], () => void 0, {
+    ...opts,
+    name,
+    initial,
+    describeKind: "producer",
+    meta: baseMeta2("sensor", opts?.meta)
+  });
+  registerStep(graph, name, source, []);
+  return {
+    node: source,
+    push(value) {
+      source.down([[DATA, value]]);
+    },
+    error(err) {
+      source.down([[ERROR, err]]);
+    },
+    complete() {
+      source.down([[COMPLETE]]);
+    }
+  };
 }
-function reactiveBlockLayout(opts) {
-  const {
-    adapters,
-    name = "reactive-block-layout",
-    defaultFont = "16px sans-serif",
-    defaultLineHeight = 20
-  } = opts;
-  const g = new Graph(name);
-  const measureCache = /* @__PURE__ */ new Map();
-  const blocksNode = state(opts.blocks ?? [], { name: "blocks" });
-  const maxWidthNode = state(Math.max(0, opts.maxWidth ?? 800), { name: "max-width" });
-  const gapNode = state(opts.gap ?? 0, { name: "gap" });
-  const measuredBlocksNode = derived(
-    [blocksNode, maxWidthNode],
-    ([blocksVal, mwVal]) => {
-      const t0 = monotonicNs();
-      const result = measureBlocks(
-        blocksVal,
-        mwVal,
-        adapters,
-        measureCache,
-        defaultFont,
-        defaultLineHeight
-      );
-      const elapsed = monotonicNs() - t0;
-      const meta = measuredBlocksNode.meta;
-      if (meta) {
-        emitWithBatch((msgs) => meta["block-count"]?.down(msgs), [[DATA, result.length]], 3);
-        emitWithBatch((msgs) => meta["layout-time-ns"]?.down(msgs), [[DATA, elapsed]], 3);
-      }
-      return result;
+function wait(graph, name, source, ms, opts) {
+  const src = resolveDep(graph, source);
+  const timers = /* @__PURE__ */ new Set();
+  let terminated = false;
+  let completed = false;
+  const step = node(
+    [src.node],
+    () => {
+      for (const id of timers) clearTimeout(id);
+      timers.clear();
+      return () => {
+        for (const id of timers) clearTimeout(id);
+        timers.clear();
+        terminated = true;
+      };
     },
     {
-      name: "measured-blocks",
-      meta: { "block-count": 0, "layout-time-ns": 0 },
-      onMessage(msg, _depIndex, _actions) {
-        if (msg[0] === INVALIDATE || msg[0] === TEARDOWN) {
-          measureCache.clear();
-          adapters.text.clearCache?.();
+      ...opts,
+      name,
+      initial: src.node.get(),
+      describeKind: "operator",
+      completeWhenDepsComplete: false,
+      meta: baseMeta2("wait", opts?.meta),
+      onMessage(msg, depIndex, actions) {
+        if (terminated) return true;
+        if (depIndex !== 0) {
+          actions.down([msg]);
+          if (msg[0] === COMPLETE || msg[0] === ERROR) terminated = true;
+          return true;
         }
-        return false;
-      },
-      equals: (a, b) => {
-        const ma = a;
-        const mb = b;
-        if (ma == null || mb == null) return ma === mb;
-        if (ma.length !== mb.length) return false;
-        for (let i = 0; i < ma.length; i++) {
-          const ba = ma[i];
-          const bb = mb[i];
-          if (ba.type !== bb.type || ba.width !== bb.width || ba.height !== bb.height || ba.index !== bb.index)
-            return false;
+        if (msg[0] === DATA) {
+          const id = setTimeout(() => {
+            timers.delete(id);
+            actions.down([msg]);
+            if (completed && timers.size === 0) {
+              actions.down([[COMPLETE]]);
+            }
+          }, ms);
+          timers.add(id);
+          return true;
+        }
+        if (msg[0] === COMPLETE) {
+          terminated = true;
+          completed = true;
+          if (timers.size === 0) {
+            actions.down([[COMPLETE]]);
+          }
+          return true;
+        }
+        if (msg[0] === ERROR) {
+          terminated = true;
+          for (const id of timers) clearTimeout(id);
+          timers.clear();
+          actions.down([msg]);
+          return true;
         }
+        actions.down([msg]);
         return true;
       }
     }
   );
-  const blockFlowNode = derived(
-    [measuredBlocksNode, gapNode],
-    ([measured, gapVal]) => {
-      return computeBlockFlow(measured, gapVal);
-    },
-    {
-      name: "block-flow",
-      equals: (a, b) => {
-        const fa = a;
-        const fb = b;
-        if (fa == null || fb == null) return fa === fb;
-        if (fa.length !== fb.length) return false;
-        for (let i = 0; i < fa.length; i++) {
-          const pa = fa[i];
-          const pb = fb[i];
-          if (pa.x !== pb.x || pa.y !== pb.y || pa.width !== pb.width || pa.height !== pb.height)
-            return false;
+  registerStep(graph, name, step, src.path ? [src.path] : []);
+  return step;
+}
+function onFailure(graph, name, source, recover, opts) {
+  const src = resolveDep(graph, source);
+  let terminated = false;
+  const step = node([src.node], () => void 0, {
+    ...opts,
+    name,
+    describeKind: "operator",
+    completeWhenDepsComplete: false,
+    meta: baseMeta2("onFailure", opts?.meta),
+    onMessage(msg, _depIndex, actions) {
+      if (terminated) return true;
+      if (msg[0] === ERROR) {
+        try {
+          actions.emit(recover(msg[1], actions));
+        } catch (err) {
+          terminated = true;
+          actions.down([[ERROR, err]]);
         }
         return true;
       }
+      actions.down([msg]);
+      if (msg[0] === COMPLETE) terminated = true;
+      return true;
     }
-  );
-  const totalHeightNode = derived(
-    [blockFlowNode],
-    ([flow]) => computeTotalHeight(flow),
-    { name: "total-height" }
-  );
-  g.add("blocks", blocksNode);
-  g.add("max-width", maxWidthNode);
-  g.add("gap", gapNode);
-  g.add("measured-blocks", measuredBlocksNode);
-  g.add("block-flow", blockFlowNode);
-  g.add("total-height", totalHeightNode);
-  g.connect("blocks", "measured-blocks");
-  g.connect("max-width", "measured-blocks");
-  g.connect("measured-blocks", "block-flow");
-  g.connect("gap", "block-flow");
-  g.connect("block-flow", "total-height");
-  return {
-    graph: g,
-    setBlocks: (blocks) => g.set("blocks", blocks),
-    setMaxWidth: (mw) => g.set("max-width", Math.max(0, mw)),
-    setGap: (gap) => g.set("gap", gap),
-    measuredBlocks: measuredBlocksNode,
-    blockFlow: blockFlowNode,
-    totalHeight: totalHeightNode
-  };
+  });
+  registerStep(graph, name, step, src.path ? [src.path] : []);
+  return step;
 }
 
-// src/patterns/reduction.ts
-var reduction_exports = {};
-__export(reduction_exports, {
-  budgetGate: () => budgetGate,
-  feedback: () => feedback,
-  funnel: () => funnel,
-  scorer: () => scorer,
-  stratify: () => stratify
+// src/patterns/reactive-layout/index.ts
+var reactive_layout_exports = {};
+__export(reactive_layout_exports, {
+  CanvasMeasureAdapter: () => CanvasMeasureAdapter,
+  CliMeasureAdapter: () => CliMeasureAdapter,
+  ImageSizeAdapter: () => ImageSizeAdapter,
+  NodeCanvasMeasureAdapter: () => NodeCanvasMeasureAdapter,
+  PrecomputedAdapter: () => PrecomputedAdapter,
+  SvgBoundsAdapter: () => SvgBoundsAdapter,
+  analyzeAndMeasure: () => analyzeAndMeasure,
+  computeBlockFlow: () => computeBlockFlow,
+  computeCharPositions: () => computeCharPositions,
+  computeLineBreaks: () => computeLineBreaks,
+  computeTotalHeight: () => computeTotalHeight,
+  measureBlock: () => measureBlock,
+  measureBlocks: () => measureBlocks,
+  reactiveBlockLayout: () => reactiveBlockLayout,
+  reactiveLayout: () => reactiveLayout
 });
-function baseMeta2(kind, meta) {
-  return {
-    reduction: true,
-    reduction_type: kind,
-    ...meta ?? {}
-  };
+
+// src/patterns/reactive-layout/measurement-adapters.ts
+function cellWidth(code) {
+  if (code >= 768 && code <= 879 || // Combining Diacritical Marks
+  code >= 1155 && code <= 1161 || // Cyrillic combining marks
+  code >= 1425 && code <= 1469 || // Hebrew combining marks
+  code >= 1552 && code <= 1562 || // Arabic combining marks
+  code >= 1611 && code <= 1631 || // Arabic combining marks
+  code >= 1648 && code === 1648 || // Arabic superscript alef
+  code >= 1750 && code <= 1756 || // Arabic combining marks
+  code >= 1759 && code <= 1764 || // Arabic combining marks
+  code >= 1767 && code <= 1768 || // Arabic combining marks
+  code >= 1770 && code <= 1773 || // Arabic combining marks
+  code >= 1840 && code <= 1866 || // Syriac combining marks
+  code >= 1958 && code <= 1968 || // Thaana combining marks
+  code >= 2304 && code <= 2307 || // Devanagari combining marks
+  code >= 2362 && code <= 2383 || // Devanagari combining marks
+  code >= 2385 && code <= 2391 || // Devanagari combining marks
+  code >= 2402 && code <= 2403 || // Devanagari combining marks
+  code >= 2433 && code <= 2435 || // Bengali combining marks
+  code >= 2492 && code <= 2509 || // Bengali combining marks
+  code >= 2561 && code <= 2563 || // Gurmukhi combining marks
+  code >= 2620 && code <= 2641 || // Gurmukhi combining marks
+  code >= 2672 && code <= 2673 || // Gurmukhi combining marks
+  code >= 2677 && code === 2677 || // Gurmukhi combining mark
+  code >= 3633 && code === 3633 || // Thai combining mark
+  code >= 3636 && code <= 3642 || // Thai combining marks
+  code >= 3655 && code <= 3662 || // Thai combining marks
+  code >= 3761 && code === 3761 || // Lao combining mark
+  code >= 3764 && code <= 3772 || // Lao combining marks
+  code >= 3784 && code <= 3790 || // Lao combining marks
+  code >= 7616 && code <= 7679 || // Combining Diacritical Marks Supplement
+  code >= 8400 && code <= 8447 || // Combining Diacritical Marks for Symbols
+  code >= 65024 && code <= 65039 || // Variation Selectors
+  code >= 65056 && code <= 65071 || // Combining Half Marks
+  code === 8205) {
+    return 0;
+  }
+  if (code >= 4352 && code <= 4447 || // Hangul Jamo
+  code >= 8986 && code <= 8987 || // Watch, Hourglass
+  code >= 9001 && code <= 9002 || // Angle brackets
+  code >= 9193 && code <= 9203 || // Media control symbols
+  code >= 9208 && code <= 9210 || // Media control symbols
+  code >= 9725 && code <= 9726 || // Medium squares
+  code >= 9748 && code <= 9749 || // Umbrella, Hot Beverage
+  code >= 9800 && code <= 9811 || // Zodiac symbols
+  code === 9855 || // Wheelchair
+  code === 9875 || // Anchor
+  code === 9889 || // High Voltage
+  code >= 9898 && code <= 9899 || // Medium circles
+  code >= 9917 && code <= 9918 || // Soccer, Baseball
+  code >= 9924 && code <= 9925 || // Snowman, Sun behind cloud
+  code === 9934 || // Ophiuchus
+  code === 9940 || // No Entry
+  code === 9962 || // Church
+  code >= 9970 && code <= 9971 || // Fountain, Golf
+  code === 9973 || // Sailboat
+  code === 9978 || // Tent
+  code === 9981 || // Fuel Pump
+  code === 9986 || // Scissors
+  code === 9989 || // Check Mark
+  code >= 9992 && code <= 9997 || // Airplane...Writing Hand
+  code === 9999 || // Pencil
+  code >= 10067 && code <= 10069 || // Question marks
+  code === 10071 || // Exclamation
+  code >= 10133 && code <= 10135 || // Plus, Minus, Divide
+  code === 10160 || // Curly Loop
+  code === 10175 || // Double Curly Loop
+  code >= 10548 && code <= 10549 || // Arrows
+  code >= 11013 && code <= 11015 || // Arrows
+  code >= 11035 && code <= 11036 || // Squares
+  code === 11088 || // Star
+  code === 11093 || // Circle
+  code >= 11904 && code <= 12350 || // CJK Radicals, Symbols, Punctuation
+  code >= 12352 && code <= 12447 || // Hiragana
+  code >= 12448 && code <= 12543 || // Katakana
+  code >= 12549 && code <= 12591 || // Bopomofo
+  code >= 12593 && code <= 12686 || // Hangul Compatibility Jamo
+  code >= 12688 && code <= 12771 || // Kanbun, CJK Strokes
+  code >= 12784 && code <= 12830 || // Katakana Phonetic Extensions
+  code >= 12832 && code <= 12871 || // Enclosed CJK
+  code >= 12880 && code <= 19903 || // CJK Extensions + Unified block
+  code >= 19968 && code <= 40959 || // CJK Unified Ideographs
+  code >= 43360 && code <= 43388 || // Hangul Jamo Extended-A
+  code >= 44032 && code <= 55203 || // Hangul Syllables
+  code >= 63744 && code <= 64255 || // CJK Compatibility Ideographs
+  code >= 65040 && code <= 65049 || // Vertical forms
+  code >= 65072 && code <= 65131 || // CJK Compatibility Forms
+  code >= 65281 && code <= 65376 || // Fullwidth Forms (excl. halfwidth)
+  code >= 65504 && code <= 65510 || // Fullwidth Signs
+  code >= 126980 && code === 126980 || // Mahjong Red Dragon
+  code === 127183 || // Joker
+  code >= 127344 && code <= 127345 || // A/B buttons
+  code === 127358 || // O button
+  code === 127359 || // P button
+  code === 127374 || // AB button
+  code >= 127377 && code <= 127386 || // Squared symbols
+  code >= 127456 && code <= 127487 || // Regional Indicator Symbols
+  code >= 127488 && code <= 127490 || // Enclosed ideographic
+  code === 127514 || // Squared CJK
+  code === 127535 || // Squared CJK
+  code >= 127538 && code <= 127546 || // Squared CJK
+  code >= 127568 && code <= 127569 || // Circled ideographic
+  code >= 127744 && code <= 129535 || // Misc Symbols / Emoticons / Emoji
+  code >= 129536 && code <= 129791 || // Chess, Symbols Extended-A
+  code >= 129792 && code <= 130047 || // Symbols for Legacy Computing
+  code >= 131072 && code <= 196605 || // CJK Extension B-F (excl. nonchars)
+  code >= 196608 && code <= 262141) {
+    return 2;
+  }
+  return 1;
 }
-function stratify(name, source, rules, opts) {
-  const g = new Graph(name, opts);
-  g.add("source", source);
-  const rulesNode = state(rules, {
-    meta: baseMeta2("stratify_rules")
-  });
-  g.add("rules", rulesNode);
-  for (const rule of rules) {
-    _addBranch(g, source, rulesNode, rule);
+function countCells(text) {
+  let cells = 0;
+  for (const ch of text) {
+    cells += cellWidth(ch.codePointAt(0));
   }
-  return g;
+  return cells;
 }
-function _addBranch(graph, source, rulesNode, rule) {
-  const branchName = `branch/${rule.name}`;
-  let pendingDirty = false;
-  const filterNode = node([source, rulesNode], () => void 0, {
-    describeKind: "operator",
-    meta: baseMeta2("stratify_branch", { branch: rule.name }),
-    onMessage(msg, depIndex, actions) {
-      if (depIndex !== 0) return false;
-      const t = msg[0];
-      if (t === DATA) {
-        const value = msg[1];
-        const currentRules = rulesNode.get();
-        const currentRule = currentRules.find((r) => r.name === rule.name);
-        if (currentRule && currentRule.classify(value)) {
-          pendingDirty = false;
-          actions.emit(value);
-        } else {
-          if (pendingDirty) {
-            pendingDirty = false;
-            actions.down([[DIRTY], [RESOLVED]]);
-          }
+var CliMeasureAdapter = class {
+  cellPx;
+  constructor(opts) {
+    this.cellPx = opts?.cellPx ?? 8;
+  }
+  measureSegment(text, _font) {
+    return { width: countCells(text) * this.cellPx };
+  }
+};
+var PrecomputedAdapterKeyError = class extends Error {
+  name = "KeyError";
+};
+var PrecomputedAdapter = class {
+  metrics;
+  fallback;
+  constructor(opts) {
+    this.metrics = opts.metrics;
+    const fb = opts.fallback ?? "per-char";
+    if (fb !== "per-char" && fb !== "error") {
+      throw new Error(
+        `fallback must be 'per-char' or 'error', got ${JSON.stringify(opts.fallback)}`
+      );
+    }
+    this.fallback = fb;
+  }
+  measureSegment(text, font) {
+    const fontMap = this.metrics[font];
+    if (fontMap) {
+      const w = fontMap[text];
+      if (w !== void 0) return { width: w };
+    }
+    if (this.fallback === "error") {
+      throw new PrecomputedAdapterKeyError(
+        `PrecomputedAdapter: no metrics for segment ${JSON.stringify(text)} in font ${JSON.stringify(font)}`
+      );
+    }
+    let total = 0;
+    if (fontMap) {
+      for (const ch of text) {
+        const cw = fontMap[ch];
+        if (cw !== void 0) {
+          total += cw;
         }
-        return true;
       }
-      if (t === DIRTY) {
-        pendingDirty = true;
-        return true;
+    }
+    return { width: total };
+  }
+};
+var CanvasMeasureAdapter = class {
+  ctx = null;
+  currentFont = "";
+  emojiCorrection;
+  constructor(opts) {
+    this.emojiCorrection = opts?.emojiCorrection ?? 1;
+  }
+  getContext() {
+    if (!this.ctx) {
+      if (typeof OffscreenCanvas === "undefined") {
+        throw new Error(
+          "CanvasMeasureAdapter requires a browser environment with OffscreenCanvas support. Use CliMeasureAdapter or NodeCanvasMeasureAdapter for Node.js."
+        );
       }
-      if (t === RESOLVED) {
-        if (pendingDirty) {
-          pendingDirty = false;
-          actions.down([[DIRTY], [RESOLVED]]);
-        } else {
-          actions.down([[RESOLVED]]);
+      const canvas = new OffscreenCanvas(0, 0);
+      const ctx = canvas.getContext("2d");
+      if (!ctx) throw new Error("CanvasMeasureAdapter: failed to get 2d context");
+      this.ctx = ctx;
+    }
+    return this.ctx;
+  }
+  measureSegment(text, font) {
+    const ctx = this.getContext();
+    if (font !== this.currentFont) {
+      ctx.font = font;
+      this.currentFont = font;
+    }
+    let width = ctx.measureText(text).width;
+    if (this.emojiCorrection !== 1 && /\p{Emoji_Presentation}/u.test(text)) {
+      width *= this.emojiCorrection;
+    }
+    return { width };
+  }
+  clearCache() {
+    this.currentFont = "";
+  }
+};
+var NodeCanvasMeasureAdapter = class {
+  ctx = null;
+  currentFont = "";
+  canvasModule;
+  constructor(canvasModule) {
+    this.canvasModule = canvasModule;
+  }
+  getContext() {
+    if (!this.ctx) {
+      const canvas = this.canvasModule.createCanvas(0, 0);
+      const ctx = canvas.getContext("2d");
+      if (!ctx) throw new Error("NodeCanvasMeasureAdapter: failed to get 2d context");
+      this.ctx = ctx;
+    }
+    return this.ctx;
+  }
+  measureSegment(text, font) {
+    const ctx = this.getContext();
+    if (font !== this.currentFont) {
+      ctx.font = font;
+      this.currentFont = font;
+    }
+    return { width: ctx.measureText(text).width };
+  }
+  clearCache() {
+    this.currentFont = "";
+  }
+};
+var SvgBoundsAdapter = class {
+  measureSvg(content) {
+    const viewBoxMatch = content.match(/viewBox\s*=\s*["']([^"']+)["']/);
+    if (viewBoxMatch) {
+      const parts = viewBoxMatch[1].trim().split(/[\s,]+/);
+      if (parts.length >= 4) {
+        const w = Number.parseFloat(parts[2]);
+        const h = Number.parseFloat(parts[3]);
+        if (Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0) {
+          return { width: w, height: h };
         }
-        return true;
+        throw new Error(
+          "SvgBoundsAdapter: viewBox width/height are missing, non-finite, or not positive"
+        );
       }
-      if (t === COMPLETE || t === ERROR) {
-        pendingDirty = false;
-        actions.down([msg]);
-        return true;
+    }
+    const widthMatch = content.match(/<svg[^>]*\bwidth\s*=\s*["']?([\d.]+)/);
+    const heightMatch = content.match(/<svg[^>]*\bheight\s*=\s*["']?([\d.]+)/);
+    if (widthMatch && heightMatch) {
+      const w = Number.parseFloat(widthMatch[1]);
+      const h = Number.parseFloat(heightMatch[1]);
+      if (Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0) {
+        return { width: w, height: h };
       }
-      return false;
+      throw new Error(
+        "SvgBoundsAdapter: svg width/height attributes are non-finite or not positive"
+      );
     }
-  });
-  graph.add(branchName, filterNode);
-  graph.connect("source", branchName);
-  if (rule.ops) {
-    const transformed = rule.ops(filterNode);
-    const transformedName = `branch/${rule.name}/out`;
-    graph.add(transformedName, transformed);
-    graph.connect(branchName, transformedName);
+    throw new Error(
+      "SvgBoundsAdapter: cannot determine dimensions \u2014 SVG has no viewBox or width/height attributes"
+    );
   }
-}
-function funnel(name, sources, stages, opts) {
-  if (sources.length === 0) throw new RangeError("funnel requires at least one source");
-  if (stages.length === 0) throw new RangeError("funnel requires at least one stage");
-  const g = new Graph(name, opts);
-  const merged = sources.length === 1 ? sources[0] : merge(...sources);
-  g.add("merged", merged);
-  let prevOutputPath = "merged";
-  for (let i = 0; i < stages.length; i++) {
-    const stage = stages[i];
-    const sub = new Graph(stage.name);
-    stage.build(sub);
-    try {
-      sub.resolve("input");
-    } catch {
-      throw new Error(`funnel stage "${stage.name}" must define an "input" node`);
+};
+var ImageSizeAdapter = class {
+  sizes;
+  constructor(sizes) {
+    this.sizes = new Map(Object.entries(sizes));
+  }
+  measureImage(src) {
+    const dims = this.sizes.get(src);
+    if (!dims) {
+      throw new Error(`ImageSizeAdapter: no dimensions registered for ${JSON.stringify(src)}`);
     }
-    try {
-      sub.resolve("output");
-    } catch {
-      throw new Error(`funnel stage "${stage.name}" must define an "output" node`);
+    return { width: dims.width, height: dims.height };
+  }
+};
+
+// src/patterns/reactive-layout/reactive-block-layout.ts
+function measureBlock(block, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight, index) {
+  switch (block.type) {
+    case "text": {
+      const font = block.font ?? defaultFont;
+      const lineHeight = block.lineHeight ?? defaultLineHeight;
+      const segments = analyzeAndMeasure(block.text, font, adapters.text, measureCache);
+      const lineBreaks = computeLineBreaks(segments, maxWidth, adapters.text, font, measureCache);
+      const charPositions = computeCharPositions(lineBreaks, segments, lineHeight);
+      const height = lineBreaks.lineCount * lineHeight;
+      let width = 0;
+      for (const line of lineBreaks.lines) {
+        if (line.width > width) width = line.width;
+      }
+      return {
+        index,
+        type: "text",
+        width: Math.min(width, maxWidth),
+        height,
+        textSegments: segments,
+        textLineBreaks: lineBreaks,
+        textCharPositions: charPositions
+      };
     }
-    g.mount(stage.name, sub);
-    const prevNode = g.resolve(prevOutputPath);
-    const stageInputPath = `${stage.name}::input`;
-    const stageInput = g.resolve(stageInputPath);
-    prevNode.subscribe((msgs) => {
-      for (const msg of msgs) {
-        const t = msg[0];
-        if (t === DATA) {
-          stageInput.down([[DATA, msg[1]]]);
-        } else if (t === DIRTY) {
-          stageInput.down([[DIRTY]]);
-        } else if (t === RESOLVED) {
-          stageInput.down([[RESOLVED]]);
-        } else if (t === COMPLETE || t === ERROR) {
-          stageInput.down([msg]);
-        }
+    case "image": {
+      let w;
+      let h;
+      if (block.naturalWidth != null && block.naturalHeight != null) {
+        w = block.naturalWidth;
+        h = block.naturalHeight;
+      } else if (adapters.image) {
+        const dims = adapters.image.measureImage(block.src);
+        w = dims.width;
+        h = dims.height;
+      } else {
+        throw new Error(
+          `Image block at index ${index} has no naturalWidth/naturalHeight and no ImageMeasurer adapter`
+        );
+      }
+      if (w > maxWidth) {
+        h = h * maxWidth / w;
+        w = maxWidth;
+      }
+      return { index, type: "image", width: w, height: h };
+    }
+    case "svg": {
+      let w;
+      let h;
+      if (block.viewBox) {
+        w = block.viewBox.width;
+        h = block.viewBox.height;
+      } else if (adapters.svg) {
+        const dims = adapters.svg.measureSvg(block.content);
+        w = dims.width;
+        h = dims.height;
+      } else {
+        throw new Error(`SVG block at index ${index} has no viewBox and no SvgMeasurer adapter`);
       }
-    });
-    prevOutputPath = `${stage.name}::output`;
-  }
-  return g;
-}
-function feedback(graph, condition, reentry, opts) {
-  const maxIter = opts?.maxIterations ?? 10;
-  const counterName = `__feedback_${condition}`;
-  const counter = state(0, {
-    meta: baseMeta2("feedback_counter", { maxIterations: maxIter })
-  });
-  graph.add(counterName, counter);
-  const condNode = graph.resolve(condition);
-  const reentryNode = graph.resolve(reentry);
-  condNode.subscribe((msgs) => {
-    for (const msg of msgs) {
-      if (msg[0] === DATA) {
-        const currentCount = counter.get();
-        if (currentCount >= maxIter) continue;
-        const condValue = msg[1];
-        if (condValue == null) continue;
-        counter.down([[DATA, currentCount + 1]]);
-        reentryNode.down([[DATA, condValue]]);
+      if (w > maxWidth) {
+        h = h * maxWidth / w;
+        w = maxWidth;
       }
+      return { index, type: "svg", width: w, height: h };
     }
-  });
-  return graph;
-}
-function budgetGate(source, constraints, opts) {
-  if (constraints.length === 0) throw new RangeError("budgetGate requires at least one constraint");
-  const constraintNodes = constraints.map((c) => c.node);
-  const allDeps = [source, ...constraintNodes];
-  let buffer2 = [];
-  let paused = false;
-  const lockId = /* @__PURE__ */ Symbol("budget-gate");
-  function checkBudget() {
-    return constraints.every((c) => c.check(c.node.get()));
   }
-  function flushBuffer(actions) {
-    while (buffer2.length > 0 && checkBudget()) {
-      const item = buffer2.shift();
-      actions.emit(item);
-    }
+}
+function measureBlocks(blocks, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight) {
+  return blocks.map(
+    (block, i) => measureBlock(block, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight, i)
+  );
+}
+function computeBlockFlow(measured, gap) {
+  const result = [];
+  let y = 0;
+  for (let i = 0; i < measured.length; i++) {
+    const m = measured[i];
+    result.push({ ...m, x: 0, y });
+    y += m.height + (i < measured.length - 1 ? gap : 0);
   }
-  return node(allDeps, () => void 0, {
-    ...opts,
-    describeKind: "operator",
-    meta: baseMeta2("budget_gate", opts?.meta),
-    onMessage(msg, depIndex, actions) {
-      const t = msg[0];
-      if (depIndex === 0) {
-        if (t === DATA) {
-          if (checkBudget() && buffer2.length === 0) {
-            actions.emit(msg[1]);
-          } else {
-            buffer2.push(msg[1]);
-            if (!paused) {
-              paused = true;
-              actions.up([[PAUSE, lockId]]);
-            }
-          }
-          return true;
-        }
-        if (t === DIRTY) {
-          actions.down([[DIRTY]]);
-          return true;
-        }
-        if (t === RESOLVED) {
-          if (buffer2.length === 0) {
-            actions.down([[RESOLVED]]);
-          }
-          return true;
-        }
-        if (t === COMPLETE || t === ERROR) {
-          for (const item of buffer2) {
-            actions.emit(item);
-          }
-          buffer2 = [];
-          if (paused) {
-            paused = false;
-            actions.up([[RESUME, lockId]]);
-          }
-          actions.down([msg]);
-          return true;
+  return result;
+}
+function computeTotalHeight(flow) {
+  if (flow.length === 0) return 0;
+  const last2 = flow[flow.length - 1];
+  return last2.y + last2.height;
+}
+function reactiveBlockLayout(opts) {
+  const {
+    adapters,
+    name = "reactive-block-layout",
+    defaultFont = "16px sans-serif",
+    defaultLineHeight = 20
+  } = opts;
+  const g = new Graph(name);
+  const measureCache = /* @__PURE__ */ new Map();
+  const blocksNode = state(opts.blocks ?? [], { name: "blocks" });
+  const maxWidthNode = state(Math.max(0, opts.maxWidth ?? 800), { name: "max-width" });
+  const gapNode = state(opts.gap ?? 0, { name: "gap" });
+  const measuredBlocksNode = derived(
+    [blocksNode, maxWidthNode],
+    ([blocksVal, mwVal]) => {
+      const t0 = monotonicNs();
+      const result = measureBlocks(
+        blocksVal,
+        mwVal,
+        adapters,
+        measureCache,
+        defaultFont,
+        defaultLineHeight
+      );
+      const elapsed = monotonicNs() - t0;
+      const meta = measuredBlocksNode.meta;
+      if (meta) {
+        emitWithBatch((msgs) => meta["block-count"]?.down(msgs), [[DATA, result.length]], 3);
+        emitWithBatch((msgs) => meta["layout-time-ns"]?.down(msgs), [[DATA, elapsed]], 3);
+      }
+      return result;
+    },
+    {
+      name: "measured-blocks",
+      meta: { "block-count": 0, "layout-time-ns": 0 },
+      onMessage(msg, _depIndex, _actions) {
+        if (msg[0] === INVALIDATE || msg[0] === TEARDOWN) {
+          measureCache.clear();
+          adapters.text.clearCache?.();
         }
         return false;
-      }
-      if (t === DATA || t === RESOLVED) {
-        if (checkBudget() && buffer2.length > 0) {
-          flushBuffer(actions);
-          if (buffer2.length === 0 && paused) {
-            paused = false;
-            actions.up([[RESUME, lockId]]);
-          }
-        } else if (!checkBudget() && !paused && buffer2.length > 0) {
-          paused = true;
-          actions.up([[PAUSE, lockId]]);
+      },
+      equals: (a, b) => {
+        const ma = a;
+        const mb = b;
+        if (ma == null || mb == null) return ma === mb;
+        if (ma.length !== mb.length) return false;
+        for (let i = 0; i < ma.length; i++) {
+          const ba = ma[i];
+          const bb = mb[i];
+          if (ba.type !== bb.type || ba.width !== bb.width || ba.height !== bb.height || ba.index !== bb.index)
+            return false;
         }
         return true;
       }
-      if (t === DIRTY) {
-        return true;
-      }
-      if (t === ERROR) {
-        actions.down([msg]);
-        return true;
-      }
-      if (t === COMPLETE) {
-        return true;
-      }
-      return false;
     }
-  });
-}
-function scorer(sources, weights, opts) {
-  if (sources.length === 0) throw new RangeError("scorer requires at least one source");
-  if (sources.length !== weights.length) {
-    throw new RangeError("scorer requires the same number of sources and weights");
-  }
-  const allDeps = [...sources, ...weights];
-  const n = sources.length;
-  const scoreFns = opts?.scoreFns;
-  return derived(
-    allDeps,
-    (vals) => {
-      const signals = vals.slice(0, n);
-      const weightValues = vals.slice(n);
-      const breakdown = [];
-      let totalScore = 0;
-      for (let i = 0; i < n; i++) {
-        const sig = signals[i] ?? 0;
-        const wt = weightValues[i] ?? 0;
-        const rawScore = scoreFns?.[i] ? scoreFns[i](sig) : sig;
-        const weighted = rawScore * wt;
-        breakdown.push(weighted);
-        totalScore += weighted;
-      }
-      return {
-        value: signals,
-        score: totalScore,
-        breakdown
-      };
+  );
+  const blockFlowNode = derived(
+    [measuredBlocksNode, gapNode],
+    ([measured, gapVal]) => {
+      return computeBlockFlow(measured, gapVal);
     },
     {
-      ...opts,
-      describeKind: "derived",
-      meta: baseMeta2("scorer", opts?.meta)
+      name: "block-flow",
+      equals: (a, b) => {
+        const fa = a;
+        const fb = b;
+        if (fa == null || fb == null) return fa === fb;
+        if (fa.length !== fb.length) return false;
+        for (let i = 0; i < fa.length; i++) {
+          const pa = fa[i];
+          const pb = fb[i];
+          if (pa.x !== pb.x || pa.y !== pb.y || pa.width !== pb.width || pa.height !== pb.height)
+            return false;
+        }
+        return true;
+      }
     }
   );
+  const totalHeightNode = derived(
+    [blockFlowNode],
+    ([flow]) => computeTotalHeight(flow),
+    { name: "total-height" }
+  );
+  g.add("blocks", blocksNode);
+  g.add("max-width", maxWidthNode);
+  g.add("gap", gapNode);
+  g.add("measured-blocks", measuredBlocksNode);
+  g.add("block-flow", blockFlowNode);
+  g.add("total-height", totalHeightNode);
+  g.connect("blocks", "measured-blocks");
+  g.connect("max-width", "measured-blocks");
+  g.connect("measured-blocks", "block-flow");
+  g.connect("gap", "block-flow");
+  g.connect("block-flow", "total-height");
+  return {
+    graph: g,
+    setBlocks: (blocks) => g.set("blocks", blocks),
+    setMaxWidth: (mw) => g.set("max-width", Math.max(0, mw)),
+    setGap: (gap) => g.set("gap", gap),
+    measuredBlocks: measuredBlocksNode,
+    blockFlow: blockFlowNode,
+    totalHeight: totalHeightNode
+  };
 }
 
 // src/index.ts
@@ -17076,6 +17924,7 @@ var version = "0.0.0";
   gate,
   globToRegExp,
   graph,
+  graphspec,
   interval,
   isBatching,
   isKnownMessageType,