@worca/app 1.0.0 → 1.2.0-rc.1

package/src/shared/graph/template.mjs

@@ -0,0 +1,165 @@
+// src/shared/graph/template.mjs
+// The editable v2 template: normalize/serialize, the node/wire factory and the
+// drop-legality check the composer runs on the POINTER PATH (so it must stay a
+// Map lookup plus a type check — never a Tarjan walk).
+import { TEMPLATE_VERSION } from './constants.mjs';
+import { portsOf, findPort, resolveOrOutType, inboundWires } from './ports.mjs';
+
+const isObject = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
+const ARITY_SET = new Set(['and', 'or', 'combine']);
+
+/** Canonicalize an authored or fetched template: numeric coordinates, a
+ *  materialized `config` on every node, non-object nodes/wires dropped, `key`
+ *  kept only where V3 allows it. Unknown config keys are PRESERVED (V17 warns
+ *  and ignores them; it never strips them). */
+export function normalizeTemplate(raw) {
+  const t = isObject(raw) ? raw : {};
+  const template = {
+    id: String(t.id ?? ''),
+    name: String(t.name ?? ''),
+    version: TEMPLATE_VERSION,
+    domain: String(t.domain ?? ''),
+    nodes: (Array.isArray(t.nodes) ? t.nodes : []).filter(isObject).map(normalizeNode),
+    wires: (Array.isArray(t.wires) ? t.wires : []).filter(isObject).map(normalizeWire),
+  };
+  const canvas = normalizeCanvas(t.canvas);
+  if (canvas) template.canvas = canvas;     // view state, engine-ignored — but it round-trips
+  return template;
+}
+
+/** The POST body: normalized, stable key order, stripped of anything JSON cannot carry. */
+export function serializeTemplate(template) {
+  return JSON.parse(JSON.stringify(normalizeTemplate(template)));
+}
+
+function normalizeNode(node) {
+  const out = { id: String(node.id ?? ''), kind: String(node.kind ?? '') };
+  if (out.kind === 'agent' && node.key !== undefined) out.key = String(node.key);
+  out.x = Number(node.x);
+  out.y = Number(node.y);
+  out.config = isObject(node.config) ? { ...node.config } : {};
+  return out;
+}
+
+function normalizeWire(wire) {
+  const out = {
+    id: String(wire.id ?? ''),
+    from: { node: String(wire.from?.node ?? ''), port: String(wire.from?.port ?? '') },
+    to: { node: String(wire.to?.node ?? ''), port: String(wire.to?.port ?? '') },
+  };
+  if (isObject(wire.config) && Object.keys(wire.config).length) out.config = { ...wire.config };
+  return out;
+}
+
+/** All three fields or nothing — a half-written canvas is worse than none. */
+function normalizeCanvas(canvas) {
+  if (!isObject(canvas)) return null;
+  const { x, y, zoom } = canvas;
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(zoom)) return null;
+  return { x, y, zoom };
+}
+
+/** `n_`/`w_` + 8 base36 chars, re-drawn until it misses `taken` (a Set of ids). */
+export function mintId(prefix, taken) {
+  const used = taken instanceof Set ? taken : new Set(Array.isArray(taken) ? taken : []);
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    let body = '';
+    while (body.length < 8) body += Math.random().toString(36).slice(2);
+    const id = `${prefix}${body.slice(0, 8)}`;
+    if (!used.has(id)) return id;
+  }
+  return `${prefix}${Date.now().toString(36).slice(-8)}`;   // unreachable in practice
+}
+
+/** @param {'agent'|'task'|'end'|'and'|'or'|'combine'} kind @param {string|null} key */
+export function newNode(kind, key, x = 0, y = 0, taken) {
+  const node = { id: mintId('n_', taken), kind };
+  if (kind === 'agent' && key) node.key = String(key);      // V3: only agent nodes carry a key
+  node.x = Number(x) || 0;
+  node.y = Number(y) || 0;
+  node.config = ARITY_SET.has(kind) ? { arity: 2 } : {};
+  return node;
+}
+
+export function newWire(from, to, config, taken) {
+  const wire = {
+    id: mintId('w_', taken),
+    from: { node: from.node, port: from.port },
+    to: { node: to.node, port: to.port },
+  };
+  if (isObject(config) && Object.keys(config).length) wire.config = { ...config };
+  return wire;
+}
+
+/**
+ * Drop legality, derived entirely from the template — which is what lets it see
+ * or-homogeneity and existing wires at all. Reasons, in check order:
+ *   unknown port              — the endpoint does not resolve (V5)
+ *   same node                 — an output and an input of the SAME card, UNLESS
+ *                               the pair is the self-loop the engine runs: a
+ *                               `when:'blocking'` output into a `loop:true`
+ *                               input (the seeded refiner `revise → revise`).
+ *                               Any other same-card pair is refused here rather
+ *                               than left to V10/V11 after the drop. Checked
+ *                               after the ports resolve because it reads their
+ *                               meta; `V0` is the chip's code, not a validator
+ *                               rule.
+ *   already connected         — UNIFORM single-wire (V7): ANY wired input rejects,
+ *                               agent ports, or `inK`, `end.result` and `await`
+ *                               alike. A duplicate (from,to) pair is necessarily a
+ *                               second wire into a wired input, so it lands here
+ *                               too. Rewiring is remove-then-drop.
+ *   <out> → <in> type mismatch — per-wire legality (V8); `any` accepts everything
+ *   or inputs must match: <t>  — or homogeneity (V12), mirrored from the resolved
+ *                               payload type; an or accepts ANY type until one
+ *                               in-wire exists.
+ * @returns {{ok:true} | {ok:false, code:string, reason:string}}
+ */
+export function canWire({ tpl, portsFn, from, to }) {
+  const nodes = Array.isArray(tpl?.nodes) ? tpl.nodes : [];
+  const byId = new Map(nodes.filter(isObject).map((n) => [n.id, n]));
+  const source = byId.get(from?.node);
+  const target = byId.get(to?.node);
+  const outPort = source ? findPort(portsOf(portsFn, source), from.port, 'out') : null;
+  const inPort = target ? findPort(portsOf(portsFn, target), to.port, 'in') : null;
+  if (!outPort || !inPort) return deny('V5', 'unknown port');
+  const selfLoop = outPort.when === 'blocking' && inPort.loop === true;
+  if (source.id === target.id && !selfLoop) return deny('V0', 'same node');
+  if (inboundWires(tpl, to.node, to.port).length) return deny('V7', 'already connected');
+
+  const sourceType = outPort.type && outPort.type !== 'any'
+    ? outPort.type
+    : (source.kind === 'or' ? resolveOrOutType(tpl, portsFn, source.id) : outPort.type ?? null);
+  if (inPort.type !== 'any' && sourceType !== null && sourceType !== inPort.type) {
+    return deny('V8', `${sourceType} → ${inPort.type} type mismatch`);
+  }
+  if (target.kind === 'or') {
+    const resolved = resolveOrOutType(tpl, portsFn, target.id);
+    if (resolved !== null && sourceType !== null && sourceType !== resolved) {
+      return deny('V12', `or inputs must match: ${resolved}`);
+    }
+  }
+  return { ok: true };
+}
+
+const deny = (code, reason) => ({ ok: false, code, reason });
+
+/** Structural edits — always a NEW template; the input is never mutated. */
+export function removeNode(tpl, nodeId) {
+  const t = normalizeTemplate(tpl);
+  return { ...t, nodes: t.nodes.filter((n) => n.id !== nodeId),
+    wires: t.wires.filter((w) => w.from.node !== nodeId && w.to.node !== nodeId) };
+}
+
+export function removeWire(tpl, wireId) {
+  const t = normalizeTemplate(tpl);
+  return { ...t, wires: t.wires.filter((w) => w.id !== wireId) };
+}
+
+export function nodeById(tpl, id) {
+  return (Array.isArray(tpl?.nodes) ? tpl.nodes : []).find((n) => n?.id === id) || null;
+}
+
+export function wireById(tpl, id) {
+  return (Array.isArray(tpl?.wires) ? tpl.wires : []).find((w) => w?.id === id) || null;
+}

package/src/shared/graph/thumbnail.mjs

@@ -0,0 +1,67 @@
+// src/shared/graph/thumbnail.mjs
+// A v2 template -> a mini-SVG string for the saved-pipeline rows. Pure and
+// deterministic, and the markup carries NUMBERS ONLY (no ids, no names, no
+// author text), so the result is safe to hand to innerHTML without escaping.
+// The whole scene is drawn in WORLD space inside one <g transform>, which is
+// what lets it reuse the real router instead of a second wire geometry.
+import { graphBounds, fitBounds, nodeSize, portAnchor } from './geometry.mjs';
+import { routeAll, routePathD } from './route.mjs';
+import { portsOf, findPort } from './ports.mjs';
+
+const DEFAULTS = { width: 120, height: 64, pad: 8, radius: 3 };
+const round = (v) => Math.round(v * 100) / 100;
+/** A drawable node: an object with a string id. A truthy non-object survived
+ *  `filter(Boolean)` and indexed under `undefined`, which is what let a
+ *  non-object wire find a `from` and throw on `w.from.port` below. */
+const isNode = (n) => Boolean(n) && typeof n === 'object' && !Array.isArray(n) && typeof n.id === 'string';
+
+export function thumbnailSvg(tpl, portsFn, opts = {}) {
+  const { width, height, pad, radius } = { ...DEFAULTS, ...opts };
+  const nodes = (Array.isArray(tpl?.nodes) ? tpl.nodes : []).filter(isNode);
+  const open = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" `
+    + `viewBox="0 0 ${width} ${height}" role="img" aria-hidden="true">`;
+  if (!nodes.length) return `${open}</svg>`;
+
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  // The cards are the router's obstacles, so the tile shows the same shapes the
+  // live canvas does — one wire, one <path>, no arrow markers, no split legs.
+  const obstacles = nodes.map((n) => ({ x: Number(n.x) || 0, y: Number(n.y) || 0, ...nodeSize(n, portsOf(portsFn, n)) }));
+  const wireList = [];
+  for (const w of (Array.isArray(tpl?.wires) ? tpl.wires : [])) {
+    const from = byId.get(w?.from?.node);
+    const to = byId.get(w?.to?.node);
+    if (!from || !to) continue;                                    // dangling (V5) — never draw NaN
+    const fromPorts = portsOf(portsFn, from);
+    const toPorts = portsOf(portsFn, to);
+    if (!findPort(fromPorts, w.from.port, 'out') || !findPort(toPorts, w.to.port, 'in')) continue;
+    const a = portAnchor(from, fromPorts, w.from.port, 'out');
+    const b = portAnchor(to, toPorts, w.to.port, 'in');
+    if (a && b) wireList.push({ id: String(w.id), a, b });          // ids stay INTERNAL: route keys only
+  }
+  const { routes } = routeAll(wireList, obstacles);
+
+  // Measured over the DRAWN set, never the raw one: a junk entry the loop above
+  // skips must not stretch the fit that positions the cards it does draw. The
+  // routed vertices join the union so a detour is never clipped out of the tile.
+  const base = graphBounds({ ...tpl, nodes }, portsFn, { pad: 0 });
+  let x0 = base.x; let y0 = base.y; let x1 = base.x + base.w; let y1 = base.y + base.h;
+  for (const pts of routes.values()) {
+    for (const p of pts) { x0 = Math.min(x0, p.x); y0 = Math.min(y0, p.y); x1 = Math.max(x1, p.x); y1 = Math.max(y1, p.y); }
+  }
+  const bounds = { x: x0 - pad, y: y0 - pad, w: x1 - x0 + 2 * pad, h: y1 - y0 + 2 * pad };
+  const { z, tx, ty } = fitBounds(bounds, { width, height }, { zoomMin: 0, zoomMax: 1 });
+  const stroke = round(1 / (z || 1));
+
+  // Wires first so the cards sit on top, exactly like the live canvas.
+  const paths = [...routes.values()].map((pts) =>
+    `<path d="${routePathD(pts)}" fill="none" stroke="#B7B7BC" stroke-width="${stroke}" stroke-linejoin="round"/>`).join('');
+
+  const rects = nodes.map((node) => {
+    const size = nodeSize(node, portsOf(portsFn, node));
+    return `<rect x="${round(Number(node.x) || 0)}" y="${round(Number(node.y) || 0)}" `
+      + `width="${round(size.w)}" height="${round(size.h)}" rx="${radius}" `
+      + `fill="#FFFFFF" stroke="#C9C9CE" stroke-width="${stroke}"/>`;
+  }).join('');
+
+  return `${open}<g transform="translate(${round(tx)} ${round(ty)}) scale(${round(z)})">${paths}${rects}</g></svg>`;
+}