@wenathlan/extension 1.1.52 → 1.1.53

package/extension/dist/sidepanel.js

@@ -1,9 +1,324 @@
+// workflow.ts
+function nestedparamof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.name !== "string" || !/^[a-z][a-z0-9]*$/.test(candidate.name)) return void 0;
+  if (!variablekinds.includes(candidate.kind)) return void 0;
+  if (candidate.default !== void 0 && !["string", "number", "boolean"].includes(typeof candidate.default) && !Array.isArray(candidate.default)) return void 0;
+  return { name: candidate.name, kind: candidate.kind, ...candidate.default !== void 0 ? { default: candidate.default } : {} };
+}
+function workflowstepof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.id !== "string" || !candidate.id.trim()) return void 0;
+  if (typeof candidate.kind !== "string" || !/^[a-z]+$/.test(candidate.kind)) return void 0;
+  if (typeof candidate.label !== "string" || !candidate.label.trim()) return void 0;
+  if (candidate.target !== void 0 && (typeof candidate.target !== "string" || !candidate.target)) return void 0;
+  if (candidate.value !== void 0 && typeof candidate.value !== "string") return void 0;
+  if (candidate.options !== void 0 && typeof candidate.options !== "string") return void 0;
+  if (candidate.breakpoint !== void 0 && typeof candidate.breakpoint !== "boolean") return void 0;
+  const bindings = Array.isArray(candidate.bindings) ? candidate.bindings.flatMap((binding) => bindingof(binding) !== void 0 ? [bindingof(binding)] : []) : void 0;
+  if (candidate.bindings !== void 0 && bindings === void 0) return void 0;
+  if (Array.isArray(candidate.bindings) && bindings !== void 0 && bindings.length !== candidate.bindings.length) return void 0;
+  const expression = candidate.expression === void 0 ? void 0 : expressionof(candidate.expression);
+  if (candidate.expression !== void 0 && expression === void 0) return void 0;
+  const extract = candidate.extract === void 0 ? void 0 : regexruleof(candidate.extract);
+  if (candidate.extract !== void 0 && extract === void 0) return void 0;
+  const params = Array.isArray(candidate.params) ? candidate.params.flatMap((param) => nestedparamof(param) !== void 0 ? [nestedparamof(param)] : []) : void 0;
+  if (candidate.params !== void 0 && params === void 0) return void 0;
+  if (Array.isArray(candidate.params) && params !== void 0 && params.length !== candidate.params.length) return void 0;
+  return { id: candidate.id, kind: candidate.kind, label: candidate.label, ...candidate.target !== void 0 ? { target: candidate.target } : {}, ...candidate.value !== void 0 ? { value: candidate.value } : {}, ...candidate.options !== void 0 ? { options: candidate.options } : {}, ...bindings !== void 0 && bindings.length > 0 ? { bindings } : {}, ...expression !== void 0 ? { expression } : {}, ...extract !== void 0 ? { extract } : {}, ...candidate.breakpoint === true ? { breakpoint: true } : {}, ...params !== void 0 && params.length > 0 ? { params } : {} };
+}
+function bindingof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.variable !== "string" || !/^[a-z][a-z0-9]*$/.test(candidate.variable)) return void 0;
+  if (!variablekinds.includes(candidate.kind)) return void 0;
+  if (typeof candidate.stepid !== "string" || !candidate.stepid.trim()) return void 0;
+  if (candidate.path !== void 0 && (typeof candidate.path !== "string" || !candidate.path.trim())) return void 0;
+  return { variable: candidate.variable, kind: candidate.kind, stepid: candidate.stepid, ...candidate.path !== void 0 ? { path: candidate.path } : {} };
+}
+var variablekinds = ["string", "number", "boolean", "list", "element"];
+var expressionoperators = ["add", "subtract", "multiply", "divide", "modulo", "equal", "notequal", "less", "greater", "lessequal", "greaterequal", "and", "or", "not", "concat", "contains", "length"];
+function expressionof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  const left = operandof(candidate.left);
+  if (!left) return void 0;
+  const right = candidate.right === void 0 ? void 0 : operandof(candidate.right);
+  if (candidate.right !== void 0 && right === void 0) return void 0;
+  if (typeof candidate.operator !== "string" || !expressionoperators.includes(candidate.operator)) return void 0;
+  if (typeof candidate.result !== "string" || !/^[a-z][a-z0-9]*$/.test(candidate.result)) return void 0;
+  if (!variablekinds.includes(candidate.resultkind)) return void 0;
+  return { left, ...right !== void 0 ? { right } : {}, operator: candidate.operator, result: candidate.result, resultkind: candidate.resultkind };
+}
+function operandof(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return { literal: value };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.ref === "string" && /^[a-z][a-z0-9]*$/.test(candidate.ref)) return { ref: candidate.ref };
+  if (typeof candidate.literal === "string" || typeof candidate.literal === "number" || typeof candidate.literal === "boolean") return { literal: candidate.literal };
+  return void 0;
+}
+function regexruleof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.pattern !== "string" || !candidate.pattern.trim()) return void 0;
+  if (typeof candidate.flags !== "string" || !/^[dgimsuvy]*$/.test(candidate.flags)) return void 0;
+  const groups = Array.isArray(candidate.groups) ? candidate.groups.flatMap((group) => typeof group === "string" && /^[a-z][a-z0-9]*$/.test(group) ? [group] : []) : [];
+  if (candidate.groups !== void 0 && groups.length !== candidate.groups.length) return void 0;
+  return { pattern: candidate.pattern, flags: candidate.flags, groups };
+}
+
 // policy.ts
 var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts", "recordscreen", "captureaudio", "downloadimages", "callrest", "callgraphql", "sendmessage", "blockrequest", "mockresponse", "rewriteheaders", "setcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles", "attachcdp", "detachcdp", "cdpcmd", "overridescript", "heapshot", "profilecpu", "capturesourcemaps", "emulatedevice", "emulatenetwork", "emulatelocate", "setuseragent", "overridepermission", "restoresession", "exportsessions", "importsessions", "runworkflow", "visitrule", "urlrule", "menurule", "keyrule", "buttonrule", "cronrule", "intervalrule", "urllistrule", "webhookrule", "eventrule"]);
 var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction", "capturebodies", "setbreakpoint", "stepcode", "watchexpr", "loop", "repeatuntil", "whileloop", "foreach", "parallel", "trycatch"]);
 var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance", "verifydownload", "exportnetlog", "namecaptures", "shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet", "capturepdf", "captureframe", "readmedia", "readassets", "probestream", "timelapse", "shotcanvas", "convertimage", "makethumbs", "fetchurl", "parsejson", "parsehtml", "opensocket", "waitmessage", "watchrequests", "readheaders", "mapapi", "subscribesse", "longpoll", "extractapi", "readcookies", "watchconsole", "watcherrors", "watchtasks", "watchcdp", "measureflow", "trackmemory", "watchshifts", "traceload", "annotatetrace", "replaytrace", "blackboxscripts", "persiststate", "capturesession", "namedsessions", "diffsessions", "searchsessions", "composeworkflow", "savetemplate", "dryrun", "delay", "waitelement", "compute", "extractvars", "condition", "branch"]);
 var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
 
+// workfloweditor.ts
+var palettecategories = ["actions", "controlflow", "waits", "variables", "triggers"];
+var noderowheight = 96;
+var blockcolumnwidth = 280;
+var canvasoriginx = 40;
+function snapshotof(model) {
+  const { undo, redo, dirty, ...rest } = model;
+  void undo;
+  void redo;
+  void dirty;
+  return { ...rest, dirty: true };
+}
+function withundo(model, next) {
+  const undo = [...model.undo ?? [], snapshotof(model)];
+  const { redo, ...rest } = next;
+  void redo;
+  return { ...rest, dirty: true, undo };
+}
+function nodeidof(node) {
+  return node.id ?? (node.step !== void 0 ? node.step.id : node.invocation !== void 0 ? node.invocation.block : "");
+}
+function layoutsizeof(nodes) {
+  const width = Math.max(640, ...nodes.map((node) => node.x + blockcolumnwidth)) + 40;
+  const height = Math.max(480, ...nodes.map((node) => node.y + noderowheight)) + 40;
+  return { width, height };
+}
+function layouttypeof(nodes, layout) {
+  const size = layoutsizeof(nodes);
+  if (!layout) return { width: size.width, height: size.height, viewportx: 0, viewporty: 0, zoom: 1 };
+  return { width: Math.max(size.width, layout.width), height: Math.max(size.height, layout.height), viewportx: layout.viewportx, viewporty: layout.viewporty, zoom: layout.zoom };
+}
+function snapnode(model, nodeid, x, y, grid = 20) {
+  if (!Number.isFinite(grid) || grid <= 0) throw new Error("The snap grid must be a positive number.");
+  const index = model.nodes.findIndex((node2) => nodeidof(node2) === nodeid);
+  if (index < 0) throw new Error(`No canvas node matches ${nodeid}.`);
+  const node = model.nodes[index];
+  if (node.step === void 0) throw new Error("A block invocation node attaches through its own definition, not through snapping.");
+  const snappedx = Math.round(x / grid) * grid;
+  const snappedy = Math.round(y / grid) * grid;
+  let attached;
+  for (const [blockindex, block] of model.blocks.entries()) {
+    const columnx = canvasoriginx + (blockindex + 1) * blockcolumnwidth;
+    if (Math.abs(snappedx - columnx) <= blockcolumnwidth / 2) attached = block.name;
+  }
+  const { block: priorblock, ...rest } = node.step;
+  void priorblock;
+  const step = { ...rest, ...attached !== void 0 ? { block: attached } : {} };
+  const nodes = model.nodes.map((candidate, position) => position === index ? { step, x: snappedx, y: snappedy } : candidate);
+  const size = layouttypeof(nodes, model.layout);
+  const next = { ...model, nodes, layout: size };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function reordersteps(model, nodeid, index) {
+  const current = model.nodes.findIndex((node) => nodeidof(node) === nodeid);
+  if (current < 0) throw new Error(`No canvas node matches ${nodeid}.`);
+  if (!Number.isInteger(index) || index < 0 || index > model.nodes.length - 1) throw new Error("The reorder index must address an existing position of the canvas list.");
+  const nodes = [...model.nodes];
+  const [moved] = nodes.splice(current, 1);
+  if (!moved) throw new Error("The reordered canvas node vanished.");
+  nodes.splice(index, 0, moved);
+  const next = { ...model, nodes };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function groupselect(model, nodeids, blockname) {
+  if (!/^[a-z][a-z0-9]*$/.test(blockname)) throw new Error("The block name must be a unique lowercase word.");
+  if (model.blocks.some((block) => block.name === blockname)) throw new Error(`The block name ${blockname} already exists on the canvas.`);
+  const selected = nodeids.map((id) => {
+    const node = model.nodes.find((candidate) => nodeidof(candidate) === id);
+    if (!node || node.step === void 0) throw new Error(`The grouping selection must address step nodes; ${id} is not one.`);
+    return node;
+  });
+  if (selected.length === 0) throw new Error("The grouping selection needs at least one step node.");
+  const steps = selected.map((node) => node.step);
+  const blocks = [...model.blocks, { name: blockname, label: blockname, steps: steps.map((step) => ({ ...step })) }];
+  const firstindex = model.nodes.findIndex((node) => nodeidof(node) === nodeids[0]);
+  const invocationnode = { id: blockname, invocation: { block: blockname, label: blockname }, x: selected[0].x, y: selected[0].y };
+  const nodes = [];
+  model.nodes.forEach((node, index) => {
+    if (nodeids.includes(nodeidof(node))) {
+      if (index === firstindex) nodes.push(invocationnode);
+      return;
+    }
+    nodes.push(node);
+  });
+  const next = { ...model, nodes, blocks };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function addnode(model, step, index) {
+  const normalized = workflowstepof(step);
+  if (!normalized) throw new Error("The canvas insertion needs one reviewed workflow step.");
+  let id = normalized.id;
+  let suffix = 2;
+  const taken = new Set(model.nodes.map((node) => nodeidof(node)));
+  while (taken.has(id)) {
+    id = `${normalized.id}${suffix}`;
+    suffix += 1;
+  }
+  const position = index !== void 0 && Number.isInteger(index) && index >= 0 && index <= model.nodes.length ? index : model.nodes.length;
+  const nodes = [...model.nodes.slice(0, position), { step: { ...normalized, id }, x: canvasoriginx, y: 60 + position * noderowheight }, ...model.nodes.slice(position)];
+  const next = { ...model, nodes };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function editstep(model, step) {
+  const normalized = workflowstepof(step);
+  if (!normalized) throw new Error("The step inspector edit needs one reviewed workflow step.");
+  const index = model.nodes.findIndex((node2) => node2.step?.id === normalized.id);
+  if (index < 0) throw new Error(`No canvas step matches ${normalized.id}.`);
+  const node = model.nodes[index];
+  const nodes = model.nodes.map((candidate, position) => position === index ? { step: { ...normalized, ...node.step?.block !== void 0 ? { block: node.step.block } : {}, ...node.step?.breakpoint === true ? { breakpoint: true } : {} }, x: node.x, y: node.y } : candidate);
+  const next = { ...model, nodes };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function renderminimap(model, width = 160, height = 100) {
+  if (!Number.isFinite(width) || width <= 0 || !Number.isFinite(height) || height <= 0) throw new Error("The mini map size must be positive.");
+  const canvaswidth = Math.max(1, model.layout.width);
+  const canvasheight = Math.max(1, model.layout.height);
+  const scale = Math.min(width / canvaswidth, height / canvasheight);
+  const zoom = model.layout.zoom > 0 ? model.layout.zoom : 1;
+  const visiblewidth = canvaswidth / zoom;
+  const visibleheight = canvasheight / zoom;
+  const viewport = {
+    x: Math.max(0, Math.min(model.layout.viewportx, canvaswidth)) * scale,
+    y: Math.max(0, Math.min(model.layout.viewporty, canvasheight)) * scale,
+    width: visiblewidth * scale,
+    height: visibleheight * scale
+  };
+  const nodes = model.nodes.map((node) => ({ id: nodeidof(node), x: node.x * scale, y: node.y * scale }));
+  return { minimap: { width, height, scale, zoom, viewport }, nodes };
+}
+function minimapfocus(model, x, y, width = 160, height = 100) {
+  const projection = renderminimap(model, width, height);
+  if (projection.minimap.scale <= 0) return model;
+  const canvasx = x / projection.minimap.scale;
+  const canvasy = y / projection.minimap.scale;
+  const zoom = model.layout.zoom > 0 ? model.layout.zoom : 1;
+  const visiblewidth = model.layout.width / zoom;
+  const visibleheight = model.layout.height / zoom;
+  const viewportx = Math.max(0, Math.min(canvasx - visiblewidth / 2, Math.max(0, model.layout.width - visiblewidth)));
+  const viewporty = Math.max(0, Math.min(canvasy - visibleheight / 2, Math.max(0, model.layout.height - visibleheight)));
+  const next = { ...model, layout: { ...model.layout, viewportx, viewporty } };
+  return { ...next, minimap: renderminimap(next).minimap };
+}
+function zoomcanvas(model, zoom) {
+  if (!Number.isFinite(zoom) || zoom <= 0) throw new Error("The canvas zoom must be a positive number with no code ceiling.");
+  const next = { ...model, layout: { ...model.layout, zoom } };
+  const labelscale = zoom < 1 ? 1 / zoom : 1;
+  return { model: { ...next, minimap: renderminimap(next).minimap }, labelscale };
+}
+function searchsteps(model, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle) return [];
+  const results = [];
+  for (const node of model.nodes) {
+    if (node.step === void 0) continue;
+    const matched = [];
+    if (node.step.label.toLowerCase().includes(needle)) matched.push("label");
+    if (node.step.kind.toLowerCase().includes(needle)) matched.push("kind");
+    const variables = [
+      ...model.edges.filter((edge) => edge.to === node.step?.id || edge.from === node.step?.id).map((edge) => edge.variable),
+      ...node.step.expression !== void 0 ? [node.step.expression.result] : [],
+      ...node.step.extract !== void 0 ? node.step.extract.groups : []
+    ];
+    if (variables.some((name) => name.toLowerCase().includes(needle))) matched.push("variable");
+    if (matched.length > 0) results.push({ id: node.step.id, label: node.step.label, kind: node.step.kind, matched });
+  }
+  return results;
+}
+function markbreakpoint(model, stepid) {
+  const toggle = (step) => {
+    const { breakpoint, ...rest } = step;
+    void breakpoint;
+    return breakpoint === true ? rest : { ...rest, breakpoint: true };
+  };
+  const index = model.nodes.findIndex((node) => node.step?.id === stepid);
+  if (index >= 0) {
+    const node = model.nodes[index];
+    const step = node.step;
+    const nodes = model.nodes.map((candidate, position) => position === index ? { step: toggle(step), x: candidate.x, y: candidate.y } : candidate);
+    const next2 = { ...model, nodes };
+    return withundo(model, { ...next2, minimap: renderminimap(next2).minimap });
+  }
+  const blocks = model.blocks.map((block) => {
+    const stepindex = block.steps.findIndex((entry) => "kind" in entry && "label" in entry && !("block" in entry) && entry.id === stepid);
+    if (stepindex < 0) return block;
+    const steps = block.steps.map((entry, position) => position === stepindex ? toggle(entry) : entry);
+    return { ...block, steps };
+  });
+  if (blocks.every((block, position) => block === model.blocks[position])) throw new Error(`No canvas step matches ${stepid}.`);
+  const next = { ...model, blocks };
+  return withundo(model, next);
+}
+function bindparam(model, blockname, param) {
+  if (!/^[a-z][a-z0-9]*$/.test(param.name)) throw new Error("The nested parameter name must be a lowercase word.");
+  const index = model.nodes.findIndex((node2) => node2.invocation?.block === blockname);
+  if (index < 0) throw new Error(`No block invocation of ${blockname} sits on the canvas.`);
+  const node = model.nodes[index];
+  const invocation = node.invocation;
+  const params = [...(invocation.params ?? []).filter((existing) => existing.name !== param.name), { ...param }];
+  const nodes = model.nodes.map((candidate, position) => position === index ? { invocation: { ...invocation, params }, x: candidate.x, y: candidate.y } : candidate);
+  const next = { ...model, nodes };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function addedge(model, edge) {
+  const from = model.nodes.findIndex((node) => nodeidof(node) === edge.from);
+  const to = model.nodes.findIndex((node) => nodeidof(node) === edge.to);
+  if (from < 0) throw new Error(`The canvas edge references the unknown source step ${edge.from}.`);
+  if (to < 0) throw new Error(`The canvas edge references the unknown target step ${edge.to}.`);
+  if (from >= to) throw new Error(`The canvas edge of ${edge.variable} would run backwards from ${edge.from} into ${edge.to} and form a cycle.`);
+  if (!/^[a-z][a-z0-9]*$/.test(edge.variable)) throw new Error("The bound variable name must be a lowercase word.");
+  const edges = [...model.edges.filter((candidate) => !(candidate.from === edge.from && candidate.to === edge.to && candidate.variable === edge.variable)), { ...edge, ...edge.path !== void 0 ? { path: edge.path } : {} }];
+  const next = { ...model, edges };
+  return withundo(model, next);
+}
+function removeedge(model, from, to, variable) {
+  const edges = model.edges.filter((candidate) => !(candidate.from === from && candidate.to === to && candidate.variable === variable));
+  if (edges.length === model.edges.length) throw new Error(`No canvas edge of ${variable} links ${from} into ${to}.`);
+  const next = { ...model, edges };
+  return withundo(model, next);
+}
+function removenode(model, nodeid) {
+  const index = model.nodes.findIndex((node) => nodeidof(node) === nodeid);
+  if (index < 0) throw new Error(`No canvas node matches ${nodeid}.`);
+  const nodes = model.nodes.filter((_, position) => position !== index);
+  const edges = model.edges.filter((edge) => edge.from !== nodeid && edge.to !== nodeid);
+  const next = { ...model, nodes, edges };
+  return withundo(model, { ...next, minimap: renderminimap(next).minimap });
+}
+function undoedit(model) {
+  const undo = model.undo ?? [];
+  if (undo.length === 0) return model;
+  const previous = undo[undo.length - 1];
+  const current = snapshotof(model);
+  return { ...previous, undo: undo.slice(0, -1), redo: [...model.redo ?? [], current] };
+}
+function redoedit(model) {
+  const redo = model.redo ?? [];
+  if (redo.length === 0) return model;
+  const next = redo[redo.length - 1];
+  const current = snapshotof(model);
+  return { ...next, redo: redo.slice(0, -1), undo: [...model.undo ?? [], current] };
+}
+
 // extension/tabscommand.ts
 function switcherlist(tabs, recency, filter) {
   const needle = filter.trim().toLowerCase();
@@ -75,10 +390,26 @@ var emulationroot = document.querySelector("#emulation");
 var netviewroot = document.querySelector("#netview");
 var sessionsroot = document.querySelector("#sessions");
 var workflowsroot = document.querySelector("#workflows");
+var workfloweditorroot = document.querySelector("#workfloweditor");
 var triggersroot = document.querySelector("#triggers");
 var triggerview = { manual: void 0, history: void 0 };
 var sessionsview = { term: "", window: "all", diffselection: [], restorereview: void 0, importreview: void 0 };
 var workflowview = { review: void 0, selected: "" };
+var editorview = {
+  workflowid: "",
+  model: void 0,
+  selected: [],
+  inspector: "",
+  palettesearch: "",
+  librarysearch: "",
+  stepsearch: "",
+  historyfilter: { workflowid: "", outcome: "" },
+  history: void 0,
+  importreview: void 0,
+  diff: void 0,
+  library: void 0,
+  palette: void 0
+};
 var statusnode = document.querySelector("#status");
 var progressnode = document.querySelector("#planprogress");
 var capabilitiestext = document.querySelector("#capabilitiestext");
@@ -2541,6 +2872,7 @@ async function refresh() {
   renderemulation(context);
   rendersessions(context);
   renderworkflows(context);
+  renderworkfloweditor(context);
   rendertriggers(context);
   renderconsolediff();
   renderaudit(context.audit);
@@ -3202,6 +3534,957 @@ function renderworkflows(context) {
     }
   }
 }
+function savefile(filename, contents) {
+  const url = URL.createObjectURL(new Blob([contents], { type: "application/octet-stream" }));
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = filename;
+  anchor.click();
+  setTimeout(() => URL.revokeObjectURL(url), 1e4);
+}
+function renderworkfloweditor(context) {
+  if (!workfloweditorroot) return;
+  workfloweditorroot.replaceChildren();
+  const editor = context.editor;
+  const workflows = context.workflow?.workflows ?? [];
+  const title = document.createElement("p");
+  title.textContent = `${workflows.length} workflow${workflows.length === 1 ? "" : "s"} in the library \xB7 ${editor?.versions.length ?? 0} version${(editor?.versions.length ?? 0) === 1 ? "" : "s"} \xB7 ${editor?.history.length ?? 0} run history entr${(editor?.history.length ?? 0) === 1 ? "y" : "ies"} \xB7 ${editor?.imports.length ?? 0} pending import${(editor?.imports.length ?? 0) === 1 ? "" : "s"} \xB7 ${editor?.overrides.length ?? 0} site override${(editor?.overrides.length ?? 0) === 1 ? "" : "s"} \xB7 ${editor?.watchdog.events.length ?? 0} watchdog event${(editor?.watchdog.events.length ?? 0) === 1 ? "" : "s"}.`;
+  workfloweditorroot.append(title);
+  const openrow = document.createElement("div");
+  openrow.className = "actions";
+  for (const record of workflows) {
+    openrow.append(button(`${record.name} v${record.version}`, async () => {
+      const loaded = await request({ kind: "editormodel", workflowid: record.id });
+      editorview.workflowid = record.id;
+      editorview.model = loaded.model;
+      editorview.selected = [];
+      editorview.inspector = "";
+      status(`Opened ${record.name} v${record.version} on the canvas with ${loaded.model.nodes.length} nodes.`);
+      await refresh();
+    }), " ");
+  }
+  if (editorview.model !== void 0) openrow.append(button("Close canvas", async () => {
+    editorview.workflowid = "";
+    editorview.model = void 0;
+    editorview.selected = [];
+    editorview.inspector = "";
+    editorview.diff = void 0;
+    status("Canvas closed; the stored versions survive.");
+    await refresh();
+  }));
+  workfloweditorroot.append(openrow);
+  const model = editorview.model;
+  if (model !== void 0) {
+    const nodeelement = (node) => {
+      const element = document.createElement("div");
+      element.className = "editornode";
+      element.style.left = `${node.x}px`;
+      element.style.top = `${node.y}px`;
+      const id = node.id ?? node.step?.id ?? node.invocation?.block ?? "";
+      element.dataset.selected = editorview.selected.includes(id) ? "true" : "false";
+      element.dataset.breakpoint = node.step?.breakpoint === true ? "true" : "false";
+      element.dataset.invocation = node.invocation !== void 0 ? "true" : "false";
+      const kind = document.createElement("p");
+      kind.className = "nodekind";
+      kind.textContent = node.step !== void 0 ? node.step.kind : `block ${node.invocation?.block ?? ""}`;
+      element.append(kind);
+      const label = document.createElement("p");
+      label.textContent = node.step !== void 0 ? node.step.label : node.invocation?.label ?? "";
+      element.append(label);
+      if (node.invocation !== void 0) {
+        const nested = model.blocks.find((block) => block.name === node.invocation?.block);
+        for (const entry of nested?.steps ?? []) {
+          const child = document.createElement("p");
+          child.textContent = entry && "kind" in entry ? `\xB7 ${entry.label} (${entry.kind})` : `\xB7 block ${entry.block}`;
+          element.append(child);
+        }
+      }
+      const sockets = document.createElement("p");
+      const targets = node.invocation !== void 0 ? [id, ...(model.blocks.find((block) => block.name === node.invocation?.block)?.steps ?? []).flatMap((entry) => "id" in entry ? [entry.id] : [])] : [id];
+      for (const edge of model.edges.filter((candidate) => targets.includes(candidate.to))) {
+        const socket = document.createElement("span");
+        socket.className = "socket in";
+        socket.textContent = `${edge.variable} (${edge.kind})`;
+        sockets.append(socket, " ");
+      }
+      for (const edge of model.edges.filter((candidate) => candidate.from === id)) {
+        const socket = document.createElement("span");
+        socket.className = "socket out";
+        socket.textContent = `${edge.variable} \u2192`;
+        sockets.append(socket, " ");
+      }
+      if (node.invocation?.params !== void 0 && node.invocation.params.length > 0) {
+        for (const param of node.invocation.params) {
+          const socket = document.createElement("span");
+          socket.className = "socket";
+          socket.textContent = `${param.name}: ${param.kind}`;
+          sockets.append(socket, " ");
+        }
+      }
+      element.append(sockets);
+      element.addEventListener("click", () => {
+        editorview.selected = [id];
+        editorview.inspector = id;
+        void refresh();
+      });
+      if (node.step !== void 0) {
+        element.addEventListener("pointerdown", (event) => {
+          if (event.button !== 0) return;
+          const startx = event.clientX;
+          const starty = event.clientY;
+          const originx = node.x;
+          const originy = node.y;
+          element.setPointerCapture(event.pointerId);
+          const move = (moveevent) => {
+            element.style.left = `${originx + moveevent.clientX - startx}px`;
+            element.style.top = `${originy + moveevent.clientY - starty}px`;
+          };
+          const drop = (upevent) => {
+            element.removeEventListener("pointermove", move);
+            element.removeEventListener("pointerup", drop);
+            void (async () => {
+              if (editorview.model === void 0) return;
+              try {
+                editorview.model = snapnode(editorview.model, id, originx + upevent.clientX - startx, originy + upevent.clientY - starty);
+                status(`Snapped ${id} onto the block grid; drop it near a block column to attach.`);
+              } catch (error) {
+                status(error instanceof Error ? error.message : String(error), true);
+              }
+              await refresh();
+            })();
+          };
+          element.addEventListener("pointermove", move);
+          element.addEventListener("pointerup", drop);
+        });
+      }
+      return element;
+    };
+    const canvascard = document.createElement("div");
+    canvascard.className = "sessionrow";
+    const toolbar = document.createElement("div");
+    toolbar.className = "actions";
+    toolbar.append(button("Undo", async () => {
+      if (editorview.model === void 0) return;
+      editorview.model = undoedit(editorview.model);
+      status("Canvas edit undone; the redo stack keeps it.");
+      await refresh();
+    }, (model.undo ?? []).length === 0));
+    toolbar.append(" ", button("Redo", async () => {
+      if (editorview.model === void 0) return;
+      editorview.model = redoedit(editorview.model);
+      status("Canvas edit redone.");
+      await refresh();
+    }, (model.redo ?? []).length === 0));
+    toolbar.append(" ", button("Toggle breakpoint", async () => {
+      if (editorview.model === void 0 || editorview.inspector === "") {
+        status("Select a step node first.", true);
+        return;
+      }
+      editorview.model = markbreakpoint(editorview.model, editorview.inspector);
+      status(`Breakpoint toggled on ${editorview.inspector}; a debug run pauses before it.`);
+      await refresh();
+    }));
+    toolbar.append(" ", button("Remove selected", async () => {
+      if (editorview.model === void 0 || editorview.selected.length === 0) {
+        status("Select a node first.", true);
+        return;
+      }
+      try {
+        for (const id of editorview.selected) editorview.model = removenode(editorview.model, id);
+        editorview.selected = [];
+        editorview.inspector = "";
+        status("Node removed with its edges; undo brings it back.");
+      } catch (error) {
+        status(error instanceof Error ? error.message : String(error), true);
+      }
+      await refresh();
+    }));
+    toolbar.append(" ", button("Move up", async () => {
+      if (editorview.model === void 0 || editorview.inspector === "") return;
+      const index = editorview.model.nodes.findIndex((node) => (node.id ?? node.step?.id ?? node.invocation?.block ?? "") === editorview.inspector);
+      try {
+        if (index > 0) editorview.model = reordersteps(editorview.model, editorview.inspector, index - 1);
+      } catch (error) {
+        status(error instanceof Error ? error.message : String(error), true);
+      }
+      await refresh();
+    }));
+    toolbar.append(" ", button("Move down", async () => {
+      if (editorview.model === void 0 || editorview.inspector === "") return;
+      const index = editorview.model.nodes.findIndex((node) => (node.id ?? node.step?.id ?? node.invocation?.block ?? "") === editorview.inspector);
+      try {
+        if (index >= 0 && index < editorview.model.nodes.length - 1) editorview.model = reordersteps(editorview.model, editorview.inspector, index + 1);
+      } catch (error) {
+        status(error instanceof Error ? error.message : String(error), true);
+      }
+      await refresh();
+    }));
+    const grouprow = document.createElement("div");
+    grouprow.className = "actions";
+    const groupinput = document.createElement("input");
+    groupinput.type = "text";
+    groupinput.placeholder = "blockname";
+    grouprow.append(groupinput, " ", button("Group selection into block", async () => {
+      if (editorview.model === void 0 || editorview.selected.length === 0) {
+        status("Select step nodes first.", true);
+        return;
+      }
+      try {
+        editorview.model = groupselect(editorview.model, editorview.selected, groupinput.value.trim());
+        editorview.selected = [];
+        status(`Grouped the selection into the block ${groupinput.value.trim()}.`);
+      } catch (error) {
+        status(error instanceof Error ? error.message : String(error), true);
+      }
+      await refresh();
+    }));
+    canvascard.append(toolbar, grouprow);
+    const canvas = document.createElement("div");
+    canvas.className = "editorcanvas";
+    const layer = document.createElement("div");
+    layer.style.position = "absolute";
+    layer.style.transformOrigin = "0 0";
+    layer.style.left = "0";
+    layer.style.top = "0";
+    layer.style.width = `${model.layout.width}px`;
+    layer.style.height = `${model.layout.height}px`;
+    const zoom = model.layout.zoom > 0 ? model.layout.zoom : 1;
+    layer.style.transform = `translate(${-Math.max(0, model.layout.viewportx)}px, ${-Math.max(0, model.layout.viewporty)}px) scale(${zoom})`;
+    for (const block of model.blocks) {
+      const members = model.nodes.filter((node) => node.invocation?.block === block.name);
+      if (members.length === 0) continue;
+      const container = document.createElement("div");
+      container.className = "editorblock";
+      const left = Math.min(...members.map((node) => node.x)) - 14;
+      const top = Math.min(...members.map((node) => node.y)) - 14;
+      container.style.left = `${left}px`;
+      container.style.top = `${top}px`;
+      container.style.width = `${Math.max(...members.map((node) => node.x)) - left + 234}px`;
+      container.style.height = `${Math.max(...members.map((node) => node.y)) - top + 110}px`;
+      const name = document.createElement("span");
+      name.textContent = block.name;
+      container.append(name);
+      layer.append(container);
+    }
+    for (const node of model.nodes) layer.append(nodeelement(node));
+    canvas.append(layer);
+    canvascard.append(canvas);
+    const minimap = document.createElement("div");
+    minimap.className = "editorminimap";
+    const projection = renderminimap(model);
+    for (const dot of projection.nodes) {
+      const point = document.createElement("span");
+      point.className = "dot";
+      point.style.left = `${Math.min(dot.x, model.minimap.width - 5)}px`;
+      point.style.top = `${Math.min(dot.y, model.minimap.height - 5)}px`;
+      minimap.append(point);
+    }
+    const rect = document.createElement("span");
+    rect.className = "viewportrect";
+    rect.style.left = `${Math.max(0, model.minimap.viewport.x)}px`;
+    rect.style.top = `${Math.max(0, model.minimap.viewport.y)}px`;
+    rect.style.width = `${Math.max(8, model.minimap.viewport.width)}px`;
+    rect.style.height = `${Math.max(6, model.minimap.viewport.height)}px`;
+    minimap.append(rect);
+    minimap.addEventListener("click", (event) => {
+      void (async () => {
+        if (editorview.model === void 0) return;
+        const bounds = minimap.getBoundingClientRect();
+        try {
+          editorview.model = minimapfocus(editorview.model, event.clientX - bounds.left, event.clientY - bounds.top);
+          status("Canvas jumped to the mini map region.");
+        } catch (error) {
+          status(error instanceof Error ? error.message : String(error), true);
+        }
+        await refresh();
+      })();
+    });
+    canvascard.append(minimap);
+    const zoomrow = document.createElement("div");
+    zoomrow.className = "actions";
+    const zoominput = document.createElement("input");
+    zoominput.type = "number";
+    zoominput.min = "0.1";
+    zoominput.step = "0.1";
+    zoominput.value = String(zoom);
+    zoomrow.append(zoominput, " ", button("Apply zoom", async () => {
+      if (editorview.model === void 0) return;
+      try {
+        const applied = zoomcanvas(editorview.model, Number(zoominput.value));
+        editorview.model = applied.model;
+        status(`Canvas zoom ${Number(zoominput.value)} with label scale ${applied.labelscale.toFixed(2)} so every step label stays readable.`);
+      } catch (error) {
+        status(error instanceof Error ? error.message : String(error), true);
+      }
+      await refresh();
+    }));
+    const searchinput = document.createElement("input");
+    searchinput.type = "text";
+    searchinput.placeholder = "search steps by label, kind or variable";
+    searchinput.value = editorview.stepsearch;
+    searchinput.addEventListener("input", () => {
+      editorview.stepsearch = searchinput.value;
+    });
+    zoomrow.append(searchinput, " ", button("Search steps", async () => {
+      await refresh();
+    }));
+    canvascard.append(zoomrow);
+    const results = searchsteps(model, editorview.stepsearch);
+    if (results.length > 0) {
+      const list = document.createElement("ul");
+      for (const result of results) {
+        const line = document.createElement("li");
+        line.textContent = `${result.label} (${result.kind}) matched ${result.matched.join(", ")}`;
+        list.append(line);
+      }
+      canvascard.append(list);
+    }
+    workfloweditorroot.append(canvascard);
+    const inspector = model.nodes.find((node) => (node.id ?? node.step?.id ?? node.invocation?.block ?? "") === editorview.inspector);
+    if (inspector !== void 0) {
+      const card = document.createElement("div");
+      card.className = "sessionrow";
+      const headline = document.createElement("p");
+      headline.textContent = inspector.step !== void 0 ? `Step inspector of ${inspector.step.id}` : `Invocation inspector of block ${inspector.invocation?.block ?? ""}`;
+      card.append(headline);
+      if (inspector.step !== void 0) {
+        const inspectedstep = inspector.step;
+        const grid = document.createElement("div");
+        grid.className = "editorgrid";
+        const labelinput = document.createElement("input");
+        labelinput.type = "text";
+        labelinput.value = inspectedstep.label;
+        const targetinput = document.createElement("input");
+        targetinput.type = "text";
+        targetinput.placeholder = "css target";
+        targetinput.value = inspectedstep.target ?? "";
+        const valueinput = document.createElement("input");
+        valueinput.type = "text";
+        valueinput.placeholder = "value";
+        valueinput.value = inspectedstep.value ?? "";
+        const optionsinput = document.createElement("input");
+        optionsinput.type = "text";
+        optionsinput.placeholder = "json options";
+        optionsinput.value = inspectedstep.options ?? "";
+        for (const [labeltext, input] of [["label", labelinput], ["target", targetinput], ["value", valueinput], ["options json", optionsinput]]) {
+          const fieldlabel = document.createElement("label");
+          fieldlabel.textContent = labeltext;
+          fieldlabel.append(input);
+          grid.append(fieldlabel);
+        }
+        card.append(grid, button("Save step edits", async () => {
+          if (editorview.model === void 0 || inspectedstep === void 0) return;
+          const options2 = optionsinput.value.trim() === "" ? void 0 : optionsinput.value.trim();
+          try {
+            editorview.model = editstep(editorview.model, { ...inspectedstep, label: labelinput.value.trim(), ...targetinput.value.trim() !== "" ? { target: targetinput.value.trim() } : {}, ...valueinput.value.trim() !== "" ? { value: valueinput.value.trim() } : {}, ...options2 !== void 0 ? { options: options2 } : {} });
+            status(`Saved the edits of ${inspectedstep.id}; undo covers them.`);
+          } catch (error) {
+            status(error instanceof Error ? error.message : String(error), true);
+          }
+          await refresh();
+        }));
+        const bindings = document.createElement("details");
+        bindings.className = "sessiongroup";
+        const bindingssummary = document.createElement("summary");
+        bindingssummary.textContent = `Bindings and nested params (${model.edges.filter((edge) => edge.to === inspectedstep.id || edge.from === inspectedstep.id).length} edges)`;
+        bindings.append(bindingssummary);
+        for (const edge of model.edges.filter((candidate) => candidate.to === inspectedstep?.id)) {
+          const line = document.createElement("p");
+          line.textContent = `${edge.variable} (${edge.kind}) from ${edge.from}${edge.path !== void 0 ? ` path ${edge.path}` : ""}`;
+          line.append(" ", button("Remove binding", async () => {
+            if (editorview.model === void 0) return;
+            try {
+              editorview.model = removeedge(editorview.model, edge.from, edge.to, edge.variable);
+              status(`Removed the binding ${edge.variable}.`);
+            } catch (error) {
+              status(error instanceof Error ? error.message : String(error), true);
+            }
+            await refresh();
+          }));
+          bindings.append(line);
+        }
+        const source = document.createElement("select");
+        for (const node of model.nodes) {
+          if (node.step === void 0 || node.step.id === inspectedstep.id) continue;
+          const option = document.createElement("option");
+          option.value = node.step.id;
+          option.textContent = `${node.step.id} (${node.step.kind})`;
+          source.append(option);
+        }
+        const variableinput = document.createElement("input");
+        variableinput.type = "text";
+        variableinput.placeholder = "variable";
+        const kindselect = document.createElement("select");
+        for (const kind of ["string", "number", "boolean", "list", "element"]) {
+          const option = document.createElement("option");
+          option.value = kind;
+          option.textContent = kind;
+          kindselect.append(option);
+        }
+        const pathinput = document.createElement("input");
+        pathinput.type = "text";
+        pathinput.placeholder = "path into outcome details";
+        bindings.append(source, " ", variableinput, " ", kindselect, " ", pathinput, " ", button("Bind variable", async () => {
+          if (editorview.model === void 0) return;
+          try {
+            editorview.model = addedge(editorview.model, { from: source.value, to: inspectedstep?.id ?? "", variable: variableinput.value.trim(), kind: kindselect.value, ...pathinput.value.trim() !== "" ? { path: pathinput.value.trim() } : {} });
+            status(`Bound ${variableinput.value.trim()} from ${source.value}.`);
+          } catch (error) {
+            status(error instanceof Error ? error.message : String(error), true);
+          }
+          await refresh();
+        }));
+        card.append(bindings);
+      }
+      if (inspector.invocation !== void 0) {
+        const paramgrid = document.createElement("div");
+        paramgrid.className = "editorgrid";
+        const paramname = document.createElement("input");
+        paramname.type = "text";
+        paramname.placeholder = "param name";
+        const paramkind = document.createElement("select");
+        for (const kind of ["string", "number", "boolean", "list", "element"]) {
+          const option = document.createElement("option");
+          option.value = kind;
+          option.textContent = kind;
+          paramkind.append(option);
+        }
+        const paramdefault = document.createElement("input");
+        paramdefault.type = "text";
+        paramdefault.placeholder = "default value";
+        paramgrid.append(paramname, paramkind, paramdefault);
+        card.append(paramgrid, button("Bind nested param", async () => {
+          if (editorview.model === void 0) return;
+          try {
+            const parseddefault = paramdefault.value.trim() === "" ? void 0 : paramkind.value === "number" ? Number(paramdefault.value) : paramkind.value === "boolean" ? paramdefault.value === "true" : paramkind.value === "list" ? paramdefault.value.split(",").map((part) => part.trim()) : paramdefault.value;
+            editorview.model = bindparam(editorview.model, inspector.invocation?.block ?? "", { name: paramname.value.trim(), kind: paramkind.value, ...parseddefault !== void 0 ? { default: parseddefault } : {} });
+            status(`Bound the nested param ${paramname.value.trim()} into ${inspector.invocation?.block ?? ""}.`);
+          } catch (error) {
+            status(error instanceof Error ? error.message : String(error), true);
+          }
+          await refresh();
+        }));
+      }
+      workfloweditorroot.append(card);
+    }
+    const saverow = document.createElement("div");
+    saverow.className = "sessionrow";
+    const nameinput = document.createElement("input");
+    nameinput.type = "text";
+    nameinput.value = model.name;
+    const originsinput = document.createElement("input");
+    originsinput.type = "text";
+    originsinput.value = model.origins.join(", ");
+    const noteinput2 = document.createElement("input");
+    noteinput2.type = "text";
+    noteinput2.placeholder = "change note for the version timeline";
+    const versioninput = document.createElement("input");
+    versioninput.type = "number";
+    versioninput.min = "1";
+    versioninput.value = String(model.version + 1);
+    saverow.append(nameinput, " ", originsinput, " ", versioninput, " ", noteinput2, " ", button("Save canvas as new version", async () => {
+      if (editorview.model === void 0) return;
+      editorview.model = { ...editorview.model, name: nameinput.value.trim(), origins: originsinput.value.split(",").map((origin) => origin.trim()).filter((origin) => origin !== ""), version: Number(versioninput.value) };
+      try {
+        const saved = await request({ kind: "editorsave", model: editorview.model, note: noteinput2.value.trim() });
+        status(`Saved ${saved.workflowid} as version ${saved.version}: ${saved.steps} expanded steps graded ${saved.risk} through the full grammar.`);
+      } catch (error) {
+        status(error instanceof Error ? error.message : String(error), true);
+      }
+      await refresh();
+    }));
+    workfloweditorroot.append(saverow);
+  } else {
+    const empty = document.createElement("p");
+    empty.textContent = "No canvas open; open a composed workflow above or import a workflow file below.";
+    workfloweditorroot.append(empty);
+  }
+  const palettecard = document.createElement("details");
+  palettecard.className = "sessiongroup";
+  const palettesummary = document.createElement("summary");
+  palettesummary.textContent = "Block palette and step library";
+  palettecard.append(palettesummary);
+  const paletteactions = document.createElement("div");
+  paletteactions.className = "actions";
+  const paletteinput = document.createElement("input");
+  paletteinput.type = "text";
+  paletteinput.placeholder = "search the palette by block or category";
+  paletteinput.value = editorview.palettesearch;
+  paletteinput.addEventListener("input", () => {
+    editorview.palettesearch = paletteinput.value;
+  });
+  const libraryinput = document.createElement("input");
+  libraryinput.type = "text";
+  libraryinput.placeholder = "search the step library by kind or category";
+  libraryinput.value = editorview.librarysearch;
+  libraryinput.addEventListener("input", () => {
+    editorview.librarysearch = libraryinput.value;
+  });
+  paletteactions.append(paletteinput, " ", libraryinput, " ", button("Load palette and library", async () => {
+    const loaded = await request({ kind: "steplibrarystore" });
+    editorview.palette = loaded.palette;
+    editorview.library = loaded.library;
+    status(`Loaded ${loaded.palette.length} palette blocks and ${loaded.library.length} library kinds.`);
+    await refresh();
+  }));
+  palettecard.append(paletteactions);
+  const palettebody = document.createElement("div");
+  palettebody.className = "editorpalette";
+  if (editorview.palette === void 0) {
+    const hint = document.createElement("p");
+    hint.textContent = "Load the palette to browse the curated drop blocks and every reviewed action kind grouped by category.";
+    palettebody.append(hint);
+  } else {
+    for (const category of palettecategories) {
+      const blocks = editorview.palette.filter((node) => node.category === category && `${node.label} ${node.kind} ${node.category}`.toLowerCase().includes(editorview.palettesearch.toLowerCase()));
+      if (blocks.length === 0) continue;
+      const head = document.createElement("p");
+      head.className = "palettecategory";
+      head.textContent = category;
+      palettebody.append(head);
+      for (const block of blocks) {
+        palettebody.append(button(block.label, async () => {
+          if (editorview.model === void 0) {
+            status("Open a canvas first.", true);
+            return;
+          }
+          try {
+            editorview.model = addnode(editorview.model, { id: block.kind, kind: block.kind, label: block.label });
+            status(`Dropped ${block.label} onto the canvas; the step inspector edits its target and options.`);
+          } catch (error) {
+            status(error instanceof Error ? error.message : String(error), true);
+          }
+          await refresh();
+        }), " ");
+      }
+    }
+  }
+  if (editorview.library !== void 0) {
+    for (const category of palettecategories) {
+      const kinds = editorview.library.filter((entry) => entry.category === category && `${entry.kind} ${entry.category}`.toLowerCase().includes(editorview.librarysearch.toLowerCase()));
+      if (kinds.length === 0) continue;
+      const head = document.createElement("p");
+      head.className = "palettecategory";
+      head.textContent = `${category} library`;
+      palettebody.append(head);
+      const list = document.createElement("ul");
+      for (const entry of kinds) {
+        const line = document.createElement("li");
+        line.textContent = `${entry.kind}${entry.optionschema.length > 0 ? ` \xB7 options: ${entry.optionschema.map((option) => `${option.name} ${option.kind}${option.required === true ? " (required)" : ""}`).join(", ")}` : ""}`;
+        list.append(line);
+      }
+      palettebody.append(list);
+    }
+  }
+  palettecard.append(palettebody);
+  workfloweditorroot.append(palettecard);
+  if (model !== void 0 && editor !== void 0) {
+    const versioncard = document.createElement("details");
+    versioncard.className = "sessiongroup";
+    const versionopen = editorview.diff !== void 0;
+    if (versionopen) versioncard.open = true;
+    const versionsummary = document.createElement("summary");
+    versionsummary.textContent = `Version timeline (${editor.versions.filter((entry) => entry.workflowid === editorview.workflowid).length} versions of this workflow)`;
+    versioncard.append(versionsummary);
+    for (const version of editor.versions.filter((entry) => entry.workflowid === editorview.workflowid)) {
+      const line = document.createElement("p");
+      line.className = "diffrow";
+      line.textContent = `v${version.version} \xB7 ${new Date(version.createdat).toISOString()} \xB7 ${version.steps} steps \xB7 ${version.risk ?? "ungraded"}${version.rollback === true ? " \xB7 rollback" : ""} \xB7 ${version.note}`;
+      line.append(" ", button("Roll back here", async () => {
+        try {
+          const rolled = await request({ kind: "rollbackversion", workflowid: editorview.workflowid, version: version.version });
+          status(`Rolled back to v${version.version}; stored as v${rolled.version} and ${rolled.reviewstate} until the rollback review approves it.`);
+        } catch (error) {
+          status(error instanceof Error ? error.message : String(error), true);
+        }
+        await refresh();
+      }));
+      versioncard.append(line);
+    }
+    const diffrow = document.createElement("div");
+    diffrow.className = "actions";
+    const frominput = document.createElement("input");
+    frominput.type = "number";
+    frominput.min = "1";
+    frominput.placeholder = "from";
+    const toinput = document.createElement("input");
+    toinput.type = "number";
+    toinput.min = "1";
+    toinput.placeholder = "to";
+    diffrow.append(frominput, " ", toinput, " ", button("Diff versions", async () => {
+      try {
+        const diff = await request({ kind: "diffversions", workflowid: editorview.workflowid, from: Number(frominput.value), to: Number(toinput.value) });
+        editorview.diff = diff;
+        status(`Diffed v${diff.from} into v${diff.to}: ${diff.added.length} added, ${diff.removed.length} removed, ${diff.changed.length} changed.`);
+      } catch (error) {
+        status(error instanceof Error ? error.message : String(error), true);
+      }
+      await refresh();
+    }));
+    versioncard.append(diffrow);
+    if (editorview.diff !== void 0) {
+      const diff = editorview.diff;
+      const card = document.createElement("div");
+      card.className = "sessionrow";
+      const headline = document.createElement("p");
+      headline.textContent = `Version diff v${diff.from} \u2192 v${diff.to}`;
+      card.append(headline);
+      for (const added of diff.added) {
+        const line = document.createElement("p");
+        line.className = "diffrow";
+        line.dataset.class = "added";
+        line.textContent = `+ ${added.stepid} (${added.kind}) ${added.label}`;
+        card.append(line);
+      }
+      for (const removed of diff.removed) {
+        const line = document.createElement("p");
+        line.className = "diffrow";
+        line.dataset.class = "removed";
+        line.textContent = `- ${removed.stepid} (${removed.kind}) ${removed.label}`;
+        card.append(line);
+      }
+      for (const changed of diff.changed) {
+        const line = document.createElement("p");
+        line.className = "diffrow";
+        line.dataset.class = "changed";
+        line.textContent = `~ ${changed.stepid} (${changed.kind}) ${changed.label}: ${changed.changes.join(", ")}`;
+        card.append(line);
+      }
+      card.append(button("Close diff", async () => {
+        editorview.diff = void 0;
+        await refresh();
+      }));
+      versioncard.append(card);
+    }
+    workfloweditorroot.append(versioncard);
+    const backgroundrow = document.createElement("div");
+    backgroundrow.className = "actions";
+    const backgroundcheck = document.createElement("input");
+    backgroundcheck.type = "checkbox";
+    backgroundcheck.checked = editor.backgroundruns[editorview.workflowid] === true;
+    const backgroundlabel = document.createElement("label");
+    backgroundlabel.append(backgroundcheck, " keep runs of this workflow executing with the panel closed (checkpoints restore on every worker wake)");
+    backgroundrow.append(backgroundlabel);
+    backgroundrow.append(button("Apply background toggle", async () => {
+      const result = await request({ kind: "setbackgroundrun", workflowid: editorview.workflowid, enabled: backgroundcheck.checked });
+      status(result.enabled ? "Background runs stay alive with the panel closed; every step checkpoints." : "Background runs off; a closed panel pauses the next run at its last checkpoint.");
+      await refresh();
+    }));
+    workfloweditorroot.append(backgroundrow);
+  }
+  if (context.workflow !== void 0) {
+    const logcard = document.createElement("details");
+    logcard.className = "sessiongroup";
+    const logsummary = document.createElement("summary");
+    logsummary.textContent = `Run log and variable inspector of the newest run (${context.workflow.log.length} entries)`;
+    logcard.append(logsummary);
+    const breakpoints = /* @__PURE__ */ new Set([...editor?.breakpoints ?? [], ...context.workflow.workflows.find((record) => record.id === editorview.workflowid)?.steps.flatMap((step) => step.breakpoint === true ? [step.id] : []) ?? []]);
+    for (const entry of context.workflow.log) {
+      const line = document.createElement("p");
+      line.textContent = `${entry.state} \xB7 ${entry.label}${breakpoints.has(entry.stepid) ? " \xB7 breakpoint" : ""} \xB7 ${entry.duration} ms \xB7 ${entry.summary}`;
+      line.dataset.class = entry.state === "failed" || entry.state === "refused" ? "changed" : "added";
+      logcard.append(line);
+    }
+    if (context.workflow.log.length === 0) {
+      const empty = document.createElement("p");
+      empty.textContent = "No run log entry yet; run the workflow from the workflows view.";
+      logcard.append(empty);
+    }
+    for (const scope of context.workflow.scopes) {
+      const line = document.createElement("p");
+      line.textContent = `Scope ${scope.name}: ${scope.variables.length === 0 ? "no variable" : scope.variables.map((variable) => `${variable.name} = ${Array.isArray(variable.value) ? `[${variable.value.join(", ")}]` : String(variable.value)} (${variable.kind})`).join(" \xB7 ")}`;
+      logcard.append(line);
+    }
+    workfloweditorroot.append(logcard);
+  }
+  const historycard = document.createElement("details");
+  historycard.className = "sessiongroup";
+  if (editorview.history !== void 0) historycard.open = true;
+  const historysummary = document.createElement("summary");
+  historysummary.textContent = `Run history (${editorview.history?.length ?? editor?.history.length ?? 0} entries)`;
+  historycard.append(historysummary);
+  const historyfilters = document.createElement("div");
+  historyfilters.className = "actions";
+  const workflowselect = document.createElement("select");
+  const anyoption = document.createElement("option");
+  anyoption.value = "";
+  anyoption.textContent = "every workflow";
+  workflowselect.append(anyoption);
+  for (const record of workflows) {
+    const option = document.createElement("option");
+    option.value = record.id;
+    option.textContent = record.name;
+    workflowselect.append(option);
+  }
+  workflowselect.value = editorview.historyfilter.workflowid;
+  const outcomeinput = document.createElement("input");
+  outcomeinput.type = "text";
+  outcomeinput.placeholder = "outcome filter";
+  outcomeinput.value = editorview.historyfilter.outcome;
+  historyfilters.append(workflowselect, " ", outcomeinput, " ", button("Apply history filters", async () => {
+    editorview.historyfilter = { workflowid: workflowselect.value, outcome: outcomeinput.value.trim() };
+    try {
+      const report = await request({ kind: "runhistory", ...workflowselect.value !== "" ? { workflowid: workflowselect.value } : {}, ...outcomeinput.value.trim() !== "" ? { outcome: outcomeinput.value.trim() } : {} });
+      editorview.history = report.entries;
+      status(`Run history: ${report.entries.length} entries match the filters.`);
+    } catch (error) {
+      status(error instanceof Error ? error.message : String(error), true);
+    }
+    await refresh();
+  }));
+  historyfilters.append(button("Keep every entry", async () => {
+    await request({ kind: "setrunhistoryretention" });
+    status("Run history keeps every entry; no code ceiling applies.");
+    await refresh();
+  }));
+  historycard.append(historyfilters);
+  const historyentries = editorview.history ?? editor?.history ?? [];
+  for (const entry of historyentries.slice(0, 40)) {
+    const line = document.createElement("div");
+    line.className = "historyrow";
+    line.dataset.outcome = entry.outcome;
+    const detail = document.createElement("p");
+    detail.textContent = `${entry.outcome} \xB7 ${entry.steps}/${entry.total} steps \xB7 ${entry.duration} ms \xB7 ${entry.cause}${entry.dryrun === true ? " \xB7 dry run" : ""} \xB7 ${new Date(entry.startedat).toISOString()}`;
+    line.append(detail);
+    historycard.append(line);
+  }
+  workfloweditorroot.append(historycard);
+  const filecard = document.createElement("details");
+  filecard.className = "sessiongroup";
+  const filesummary = document.createElement("summary");
+  filesummary.textContent = "Import, export and template sharing";
+  filecard.append(filesummary);
+  const formatselect = document.createElement("select");
+  for (const format of ["json", "yaml"]) {
+    const option = document.createElement("option");
+    option.value = format;
+    option.textContent = format;
+    formatselect.append(option);
+  }
+  const contentsinput = document.createElement("textarea");
+  contentsinput.rows = 4;
+  contentsinput.placeholder = "paste a workflow file to import";
+  const filenameinput = document.createElement("input");
+  filenameinput.type = "text";
+  filenameinput.placeholder = "source filename";
+  const importactions = document.createElement("div");
+  importactions.className = "actions";
+  importactions.append(contentsinput, " ", filenameinput, " ", formatselect, " ", button("Import workflow file", async () => {
+    if (contentsinput.value.trim() === "") {
+      status("Paste the workflow file contents first.", true);
+      return;
+    }
+    try {
+      const imported = await request({ kind: "importworkflow", contents: contentsinput.value, format: formatselect.value, ...filenameinput.value.trim() !== "" ? { filename: filenameinput.value.trim() } : {} });
+      const review = await request({ kind: "workflowreview", workflowid: imported.workflowid });
+      editorview.importreview = { importid: imported.importid, workflowid: imported.workflowid, name: imported.name, version: imported.version, risk: imported.risk, steps: review.steps };
+      status(`Imported ${imported.name} v${imported.version} with ${imported.steps} steps and ${imported.templates} templates; review before activation.`);
+    } catch (error) {
+      status(error instanceof Error ? error.message : String(error), true);
+    }
+    await refresh();
+  }));
+  filecard.append(importactions);
+  if (editorview.importreview !== void 0) {
+    const review = document.createElement("div");
+    review.className = "sessionrow";
+    const headline = document.createElement("p");
+    headline.textContent = `Import review of ${editorview.importreview.name} v${editorview.importreview.version} (${editorview.importreview.risk} for review): every expanded step shows before activation and nothing runs until approval.`;
+    review.append(headline);
+    const list = document.createElement("ol");
+    for (const step of editorview.importreview.steps) {
+      const line = document.createElement("li");
+      line.textContent = `${step.label} (${step.kind}${step.block !== void 0 ? ` \xB7 block ${step.block}` : ""}${step.target !== void 0 ? ` \xB7 ${step.target}` : ""})`;
+      list.append(line);
+    }
+    review.append(list);
+    review.append(button("Approve import", async () => {
+      try {
+        const approved = await request({ kind: "approveimport", importid: editorview.importreview?.importid });
+        status(`Import approved: ${approved.reviewstate}; the workflow runs behind the same gates.`);
+        editorview.importreview = void 0;
+      } catch (error) {
+        status(error instanceof Error ? error.message : String(error), true);
+      }
+      await refresh();
+    }), " ", button("Reject import", async () => {
+      try {
+        await request({ kind: "rejectimport", importid: editorview.importreview?.importid });
+        status("Import rejected; the pending record left the library.");
+        editorview.importreview = void 0;
+      } catch (error) {
+        status(error instanceof Error ? error.message : String(error), true);
+      }
+      await refresh();
+    }));
+    filecard.append(review);
+  }
+  for (const pending of editor?.imports ?? []) {
+    const line = document.createElement("p");
+    line.textContent = `Pending import ${pending.name} v${pending.version} (${pending.steps} steps, ${pending.risk})${pending.filename !== void 0 ? ` from ${pending.filename}` : ""}`;
+    line.append(" ", button("Review steps", async () => {
+      try {
+        const steps = await request({ kind: "workflowreview", workflowid: pending.workflowid });
+        editorview.importreview = { importid: pending.id, workflowid: pending.workflowid, name: pending.name, version: pending.version, risk: pending.risk, steps: steps.steps };
+        status(`Import review of ${pending.name}: ${steps.steps.length} expanded steps.`);
+      } catch (error) {
+        status(error instanceof Error ? error.message : String(error), true);
+      }
+      await refresh();
+    }));
+    filecard.append(line);
+  }
+  const exportrow = document.createElement("div");
+  exportrow.className = "actions";
+  const noteinput = document.createElement("input");
+  noteinput.type = "text";
+  noteinput.placeholder = "change note inside the file";
+  exportrow.append(noteinput, " ", button("Export open workflow", async () => {
+    if (editorview.workflowid === "") {
+      status("Open a workflow on the canvas first.", true);
+      return;
+    }
+    try {
+      const exported = await request({ kind: "exportworkflow", workflowid: editorview.workflowid, format: formatselect.value, ...noteinput.value.trim() !== "" ? { note: noteinput.value.trim() } : {} });
+      savefile(exported.filename, exported.contents);
+      status(`Exported ${exported.filename} (${exported.contents.length} characters, ${exported.format}); the export review held every secret back.`);
+    } catch (error) {
+      status(error instanceof Error ? error.message : String(error), true);
+    }
+  }), " ", button("Share with templates", async () => {
+    if (editorview.workflowid === "") {
+      status("Open a workflow on the canvas first.", true);
+      return;
+    }
+    try {
+      const shared = await request({ kind: "shareworkflow", workflowid: editorview.workflowid, format: formatselect.value, ...noteinput.value.trim() !== "" ? { note: noteinput.value.trim() } : {} });
+      savefile(shared.filename, shared.contents);
+      status(`Packed the share bundle ${shared.filename}; templates travel with the workflow.`);
+    } catch (error) {
+      status(error instanceof Error ? error.message : String(error), true);
+    }
+  }));
+  filecard.append(exportrow);
+  workfloweditorroot.append(filecard);
+  const watchdogcard = document.createElement("details");
+  watchdogcard.className = "sessiongroup";
+  const watchdogsummary = document.createElement("summary");
+  const watchdogconfig = editor?.watchdog.config;
+  watchdogsummary.textContent = `Watchdog status (${editor?.watchdog.events.length ?? 0} events)`;
+  watchdogcard.append(watchdogsummary);
+  const watchdoggrid = document.createElement("div");
+  watchdoggrid.className = "editorgrid";
+  const enabledcheck = document.createElement("input");
+  enabledcheck.type = "checkbox";
+  enabledcheck.checked = watchdogconfig?.enabled === true;
+  const thresholdinput = document.createElement("input");
+  thresholdinput.type = "number";
+  thresholdinput.min = "1";
+  thresholdinput.placeholder = "stall threshold ms";
+  thresholdinput.value = watchdogconfig !== void 0 ? String(watchdogconfig.stallthreshold) : "";
+  const actionselect = document.createElement("select");
+  for (const action of ["retry", "pause", "cancel"]) {
+    const option = document.createElement("option");
+    option.value = action;
+    option.textContent = action;
+    actionselect.append(option);
+  }
+  actionselect.value = watchdogconfig?.action ?? "pause";
+  const zombieinput = document.createElement("input");
+  zombieinput.type = "number";
+  zombieinput.min = "1";
+  zombieinput.placeholder = "zombie window ms";
+  zombieinput.value = watchdogconfig?.zombiewindow !== void 0 ? String(watchdogconfig.zombiewindow) : "";
+  for (const [labeltext, control] of [["enabled", enabledcheck], ["stall threshold ms", thresholdinput], ["recovery action", actionselect], ["zombie window ms", zombieinput]]) {
+    const fieldlabel = document.createElement("label");
+    fieldlabel.textContent = labeltext;
+    fieldlabel.append(control);
+    watchdoggrid.append(fieldlabel);
+  }
+  watchdogcard.append(watchdoggrid);
+  const watchdogactions = document.createElement("div");
+  watchdogactions.className = "actions";
+  watchdogactions.append(button("Save watchdog config", async () => {
+    try {
+      await request({ kind: "setwatchdog", config: { enabled: enabledcheck.checked, stallthreshold: Number(thresholdinput.value), action: actionselect.value, ...zombieinput.value.trim() !== "" ? { zombiewindow: Number(zombieinput.value) } : {} } });
+      status("Watchdog saved; thresholds stay user values with no code ceiling.");
+    } catch (error) {
+      status(error instanceof Error ? error.message : String(error), true);
+    }
+    await refresh();
+  }), " ", button("Scan now", async () => {
+    try {
+      const scan = await request({ kind: "watchdogscan" });
+      status(`Watchdog scan: ${scan.events.length} stalled or zombie run${scan.events.length === 1 ? "" : "s"} recovered.`);
+    } catch (error) {
+      status(error instanceof Error ? error.message : String(error), true);
+    }
+    await refresh();
+  }));
+  watchdogcard.append(watchdogactions);
+  for (const event of (editor?.watchdog.events ?? []).slice(0, 15)) {
+    const line = document.createElement("p");
+    line.textContent = `${event.verdict} \xB7 ${event.action} \xB7 ${new Date(event.at).toISOString()} \xB7 ${event.outcome}`;
+    watchdogcard.append(line);
+  }
+  workfloweditorroot.append(watchdogcard);
+  const overridecard = document.createElement("details");
+  overridecard.className = "sessiongroup";
+  const overridesummary = document.createElement("summary");
+  overridesummary.textContent = `Per site policy overrides (${editor?.overrides.length ?? 0})`;
+  overridecard.append(overridesummary);
+  const overridegrid = document.createElement("div");
+  overridegrid.className = "editorgrid";
+  const patterninput = document.createElement("input");
+  patterninput.type = "text";
+  patterninput.placeholder = "https://origin or https://*.origin";
+  const knobinputs = [];
+  for (const knob of ["loopbound", "stepms", "runms", "waitms", "delaybase"]) {
+    const input = document.createElement("input");
+    input.type = "number";
+    input.min = "1";
+    input.placeholder = knob;
+    knobinputs.push([knob, input]);
+    const fieldlabel = document.createElement("label");
+    fieldlabel.textContent = knob;
+    fieldlabel.append(input);
+    overridegrid.append(fieldlabel);
+  }
+  const patternlabel = document.createElement("label");
+  patternlabel.textContent = "origin pattern";
+  patternlabel.append(patterninput);
+  overridegrid.prepend(patternlabel);
+  overridecard.append(overridegrid, button("Attach override", async () => {
+    if (editorview.workflowid === "") {
+      status("Open a workflow on the canvas first.", true);
+      return;
+    }
+    const deltas = {};
+    for (const [knob, input] of knobinputs) if (input.value.trim() !== "" && Number.isFinite(Number(input.value)) && Number(input.value) > 0) deltas[knob] = Number(input.value);
+    try {
+      await request({ kind: "setsiteoverride", workflowid: editorview.workflowid, pattern: patterninput.value.trim(), deltas });
+      status(`Attached the override ${patterninput.value.trim()} with ${Object.keys(deltas).length} knob delta${Object.keys(deltas).length === 1 ? "" : "s"}.`);
+    } catch (error) {
+      status(error instanceof Error ? error.message : String(error), true);
+    }
+    await refresh();
+  }));
+  for (const override of editor?.overrides ?? []) {
+    const line = document.createElement("p");
+    line.textContent = `${override.pattern} of ${override.workflowid}: ${Object.entries(override.deltas).map(([knob, delta]) => `${knob} ${delta}`).join(", ") || "no delta"}`;
+    line.append(" ", button("Remove override", async () => {
+      try {
+        await request({ kind: "removesiteoverride", id: override.id });
+        status(`Removed the override ${override.pattern}.`);
+      } catch (error) {
+        status(error instanceof Error ? error.message : String(error), true);
+      }
+      await refresh();
+    }));
+    overridecard.append(line);
+  }
+  workfloweditorroot.append(overridecard);
+}
 function rendertriggers(context) {
   if (!triggersroot) return;
   triggersroot.replaceChildren();