@w6w/embed 0.2.11 → 0.2.19

package/dist/data-stores-UeQvwVCa.js

@@ -0,0 +1,170 @@
+import { useQueryClient as l, useMutation as u, useQuery as m, useInfiniteQuery as C } from "@tanstack/react-query";
+import { u as i } from "./client-context-CX61Bgw-.js";
+const f = 10, p = 200;
+function K(e) {
+  return ["data-stores", e, "list"];
+}
+function Q(e, n) {
+  return ["data-stores", n, "detail", e];
+}
+function x(e, n, t) {
+  return ["data-stores", n, "entries", e, t];
+}
+async function q(e, n) {
+  const t = [];
+  let s;
+  for (let r = 0; r < f; r++) {
+    const a = await e.dataStores.list({ project: n, cursor: s, limit: p });
+    if (t.push(...a.items), a.nextCursor === void 0) break;
+    s = a.nextCursor;
+  }
+  return t;
+}
+async function v(e, n) {
+  return (await q(e, n)).map((t) => ({ name: t.name, kind: t.kind }));
+}
+const y = /* @__PURE__ */ new Map();
+async function D(e, n, t, s = {}) {
+  var S;
+  const r = `${n}\0${t}`;
+  let a = y.get(r);
+  if (a === void 0) {
+    let o;
+    for (let c = 0; c < f && a === void 0; c++) {
+      const d = await e.dataStores.list({
+        project: n,
+        cursor: o,
+        limit: p,
+        signal: s.signal
+      });
+      if (a = (S = d.items.find((g) => g.name === t)) == null ? void 0 : S.id, d.nextCursor === void 0) break;
+      o = d.nextCursor;
+    }
+    if (a === void 0) return { items: [], more: !1 };
+    y.set(r, a);
+  }
+  try {
+    const o = await e.dataStores.entries.list(a, {
+      project: n,
+      prefix: s.prefix,
+      limit: s.limit,
+      signal: s.signal
+    });
+    return {
+      items: o.items.map((c) => ({ key: c.key, value: c.value, updatedAt: c.updatedAt })),
+      more: o.nextCursor !== void 0
+    };
+  } catch (o) {
+    throw y.delete(r), o;
+  }
+}
+function F(e) {
+  const n = i();
+  return m({
+    queryKey: K(e),
+    queryFn: () => q(n, e),
+    enabled: e != null
+  });
+}
+function j(e, n) {
+  const t = i();
+  return m({
+    queryKey: Q(e, n),
+    queryFn: () => t.dataStores.get(e, { project: n }),
+    enabled: n != null
+  });
+}
+function k(e, n, t) {
+  const s = i();
+  return C({
+    queryKey: x(e, n, t),
+    queryFn: ({ pageParam: r }) => s.dataStores.entries.list(e, {
+      project: n,
+      prefix: t === "" ? void 0 : t,
+      cursor: r
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (r) => r.nextCursor,
+    enabled: n != null
+  });
+}
+function A(e, n, t, s) {
+  return e.dataStores.entries.get(n, t, { project: s });
+}
+function w() {
+  const e = i(), n = l();
+  return u({
+    mutationFn: (t) => e.dataStores.create(t.input, { project: t.project }),
+    onSuccess: () => n.invalidateQueries({ queryKey: ["data-stores"] })
+  });
+}
+function b() {
+  const e = i(), n = l();
+  return u({
+    mutationFn: (t) => e.dataStores.archive(t.id, { project: t.project }),
+    onSuccess: () => n.invalidateQueries({ queryKey: ["data-stores"] })
+  });
+}
+function h() {
+  const e = i(), n = l();
+  return u({
+    mutationFn: (t) => e.dataStores.entries.set(
+      t.id,
+      t.key,
+      { value: t.value, ifVersion: t.ifVersion, ttlSeconds: t.ttlSeconds },
+      { project: t.project }
+    ),
+    onSuccess: () => n.invalidateQueries({ queryKey: ["data-stores"] })
+  });
+}
+function P() {
+  const e = i(), n = l();
+  return u({
+    mutationFn: (t) => e.dataStores.entries.insert(t.id, t.row, {
+      project: t.project,
+      ttlSeconds: t.ttlSeconds
+    }),
+    onSuccess: () => n.invalidateQueries({ queryKey: ["data-stores"] })
+  });
+}
+function _() {
+  const e = i(), n = l();
+  return u({
+    mutationFn: (t) => e.dataStores.entries.delete(t.id, t.key, { project: t.project }),
+    onSuccess: () => n.invalidateQueries({ queryKey: ["data-stores"] })
+  });
+}
+function T() {
+  const e = i(), n = l();
+  return u({
+    mutationFn: (t) => e.dataStores.importCsv(t.id, t.csv, { project: t.project }),
+    onSuccess: () => n.invalidateQueries({ queryKey: ["data-stores"] })
+  });
+}
+function G() {
+  const e = i();
+  return u({
+    mutationFn: (n) => e.dataStores.exportCsv(n.id, { project: n.project })
+  });
+}
+export {
+  f as D,
+  Q as a,
+  K as b,
+  D as c,
+  x as d,
+  v as e,
+  w as f,
+  A as g,
+  j as h,
+  F as i,
+  _ as j,
+  k,
+  q as l,
+  G as m,
+  T as n,
+  P as o,
+  h as p,
+  b as u
+};
+//# sourceMappingURL=data-stores-UeQvwVCa.js.map

package/dist/data-stores-UeQvwVCa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-stores-UeQvwVCa.js","sources":["../src/repos/data-stores.ts"],"sourcesContent":["/**\n * The `data-stores` domain repo — wraps `@w6w/sdk`'s `client.dataStores.*` in react-query. The\n * repo never builds a request itself (no `client.request`, no `fetch`): every call is one SDK op,\n * and `project` is passed on every one of them (an omitted project would silently fall to the\n * account's default project).\n *\n * Every key starts with the bare `[\"data-stores\"]` prefix and every mutation invalidates that\n * prefix, so a write refreshes the list and any open store in whatever project it was cached\n * under. Reads are `enabled: projectId != null` and carry `projectId` in the key, so a render\n * before the project resolves never queries (or caches) the wrong project.\n *\n * Parsing, row building and conflict logic are `@w6w/ui`'s data-store util (E-2); this file only\n * moves data.\n */\nimport { useInfiniteQuery, useMutation, useQuery, useQueryClient } from \"@tanstack/react-query\";\nimport type {\n  DataStore,\n  DataStoreCreateInput,\n  DataStoreEntry,\n  DataStoreEntryPage,\n  DataStoreKind,\n  W6WClient,\n} from \"@w6w/sdk\";\nimport { useEmbedClient } from \"../draft/client-context.ts\";\n\n/** The most requests one \"walk every page\" read makes (200 stores a page). */\nexport const DATA_STORE_MAX_PAGES = 10;\nconst PAGE_LIMIT = 200;\n\n/** Query key for a project's store list. */\nexport function dataStoresKey(projectId?: string) {\n  return [\"data-stores\", projectId, \"list\"] as const;\n}\n\n/** Query key for one store. */\nexport function dataStoreKey(id: string, projectId?: string) {\n  return [\"data-stores\", projectId, \"detail\", id] as const;\n}\n\n/** Query key for one store's entries under a key prefix (`\"\"` = no filter). */\nexport function dataStoreEntriesKey(id: string, projectId: string | undefined, prefix: string) {\n  return [\"data-stores\", projectId, \"entries\", id, prefix] as const;\n}\n\n/**\n * The project's stores, walked page by page (at most {@link DATA_STORE_MAX_PAGES} requests),\n * server order kept. Hook-less so the ui picker's `listDataStores` seam can call it too.\n */\nexport async function listAllDataStores(client: W6WClient, project: string): Promise<DataStore[]> {\n  const out: DataStore[] = [];\n  let cursor: string | undefined;\n  for (let i = 0; i < DATA_STORE_MAX_PAGES; i++) {\n    const page = await client.dataStores.list({ project, cursor, limit: PAGE_LIMIT });\n    out.push(...page.items);\n    if (page.nextCursor === undefined) break;\n    cursor = page.nextCursor;\n  }\n  return out;\n}\n\n/** The picker's shape: store names and kinds only. */\nexport async function listDataStores(\n  client: W6WClient,\n  project: string,\n): Promise<{ name: string; kind: DataStoreKind }[]> {\n  return (await listAllDataStores(client, project)).map((s) => ({ name: s.name, kind: s.kind }));\n}\n\n/** Store id by `project \\0 name`: a key picker's every keystroke must not re-walk the list. */\nconst storeIds = new Map<string, string>();\n\n/**\n * ONE page of the entries of the project's store named `store`, for the ui's `data-store-key`\n * picker (`W6WApi.listDataStoreEntries`): the name is resolved to its id (remembered), then\n * `prefix` is the host's server-side key search and `limit` caps the page. An unknown name is an\n * empty page; a failed entries read forgets the id (renamed or archived) and rethrows.\n */\nexport async function listDataStoreEntries(\n  client: W6WClient,\n  project: string,\n  store: string,\n  opts: { prefix?: string; limit?: number; signal?: AbortSignal } = {},\n): Promise<{ items: { key: string; value: unknown; updatedAt: string }[]; more: boolean }> {\n  const memo = `${project}\\0${store}`;\n  let id = storeIds.get(memo);\n  if (id === undefined) {\n    let cursor: string | undefined;\n    for (let i = 0; i < DATA_STORE_MAX_PAGES && id === undefined; i++) {\n      const page = await client.dataStores.list({\n        project,\n        cursor,\n        limit: PAGE_LIMIT,\n        signal: opts.signal,\n      });\n      id = page.items.find((s) => s.name === store)?.id;\n      if (page.nextCursor === undefined) break;\n      cursor = page.nextCursor;\n    }\n    if (id === undefined) return { items: [], more: false };\n    storeIds.set(memo, id);\n  }\n  try {\n    const page = await client.dataStores.entries.list(id, {\n      project,\n      prefix: opts.prefix,\n      limit: opts.limit,\n      signal: opts.signal,\n    });\n    return {\n      items: page.items.map((e) => ({ key: e.key, value: e.value, updatedAt: e.updatedAt })),\n      more: page.nextCursor !== undefined,\n    };\n  } catch (e) {\n    storeIds.delete(memo);\n    throw e;\n  }\n}\n\nexport function useDataStoresQuery(projectId?: string) {\n  const client = useEmbedClient();\n  return useQuery({\n    queryKey: dataStoresKey(projectId),\n    queryFn: () => listAllDataStores(client, projectId as string),\n    enabled: projectId != null,\n  });\n}\n\nexport function useDataStoreQuery(id: string, projectId?: string) {\n  const client = useEmbedClient();\n  return useQuery({\n    queryKey: dataStoreKey(id, projectId),\n    queryFn: () => client.dataStores.get(id, { project: projectId }),\n    enabled: projectId != null,\n  });\n}\n\nexport function useEntriesQuery(id: string, projectId: string | undefined, prefix: string) {\n  const client = useEmbedClient();\n  return useInfiniteQuery({\n    queryKey: dataStoreEntriesKey(id, projectId, prefix),\n    queryFn: ({ pageParam }): Promise<DataStoreEntryPage> =>\n      client.dataStores.entries.list(id, {\n        project: projectId,\n        prefix: prefix === \"\" ? undefined : prefix,\n        cursor: pageParam,\n      }),\n    initialPageParam: undefined as string | undefined,\n    getNextPageParam: (last) => last.nextCursor,\n    enabled: projectId != null,\n  });\n}\n\n/** One entry by key, read fresh (the conflict prompt's Reload). */\nexport function getEntry(\n  client: W6WClient,\n  id: string,\n  key: string,\n  project: string,\n): Promise<DataStoreEntry> {\n  return client.dataStores.entries.get(id, key, { project });\n}\n\nexport function useCreateDataStoreMutation() {\n  const client = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (vars: { input: DataStoreCreateInput; project: string }) =>\n      client.dataStores.create(vars.input, { project: vars.project }),\n    onSuccess: () => qc.invalidateQueries({ queryKey: [\"data-stores\"] }),\n  });\n}\n\nexport function useArchiveDataStoreMutation() {\n  const client = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (vars: { id: string; project: string }) =>\n      client.dataStores.archive(vars.id, { project: vars.project }),\n    onSuccess: () => qc.invalidateQueries({ queryKey: [\"data-stores\"] }),\n  });\n}\n\n/** `PUT` one entry. `ifVersion` is the optimistic-concurrency guard; `ttlSeconds` keeps an expiry. */\nexport function useSetEntryMutation() {\n  const client = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (vars: {\n      id: string;\n      key: string;\n      value: unknown;\n      ifVersion?: number;\n      ttlSeconds?: number;\n      project: string;\n    }) =>\n      client.dataStores.entries.set(\n        vars.id,\n        vars.key,\n        { value: vars.value, ifVersion: vars.ifVersion, ttlSeconds: vars.ttlSeconds },\n        { project: vars.project },\n      ),\n    onSuccess: () => qc.invalidateQueries({ queryKey: [\"data-stores\"] }),\n  });\n}\n\n/** `POST` one table row; the server generates the key. */\nexport function useInsertRowMutation() {\n  const client = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (vars: {\n      id: string;\n      row: Record<string, unknown>;\n      ttlSeconds?: number;\n      project: string;\n    }) =>\n      client.dataStores.entries.insert(vars.id, vars.row, {\n        project: vars.project,\n        ttlSeconds: vars.ttlSeconds,\n      }),\n    onSuccess: () => qc.invalidateQueries({ queryKey: [\"data-stores\"] }),\n  });\n}\n\nexport function useDeleteEntryMutation() {\n  const client = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (vars: { id: string; key: string; project: string }) =>\n      client.dataStores.entries.delete(vars.id, vars.key, { project: vars.project }),\n    onSuccess: () => qc.invalidateQueries({ queryKey: [\"data-stores\"] }),\n  });\n}\n\n/** Import CSV text verbatim (`text/csv`). Resolves `{imported}`; a refusal throws an `ApiError`. */\nexport function useImportCsvMutation() {\n  const client = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (vars: { id: string; csv: string; project: string }) =>\n      client.dataStores.importCsv(vars.id, vars.csv, { project: vars.project }),\n    onSuccess: () => qc.invalidateQueries({ queryKey: [\"data-stores\"] }),\n  });\n}\n\n/** Export a table store as CSV text. Read-only: nothing is invalidated. */\nexport function useExportCsvMutation() {\n  const client = useEmbedClient();\n  return useMutation({\n    mutationFn: (vars: { id: string; project: string }) =>\n      client.dataStores.exportCsv(vars.id, { project: vars.project }),\n  });\n}\n"],"names":["DATA_STORE_MAX_PAGES","PAGE_LIMIT","dataStoresKey","projectId","dataStoreKey","id","dataStoreEntriesKey","prefix","listAllDataStores","client","project","out","cursor","i","page","listDataStores","s","storeIds","listDataStoreEntries","store","opts","memo","_a","e","useDataStoresQuery","useEmbedClient","useQuery","useDataStoreQuery","useEntriesQuery","useInfiniteQuery","pageParam","last","getEntry","key","useCreateDataStoreMutation","qc","useQueryClient","useMutation","vars","useArchiveDataStoreMutation","useSetEntryMutation","useInsertRowMutation","useDeleteEntryMutation","useImportCsvMutation","useExportCsvMutation"],"mappings":"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"}

package/dist/document-sources-DNmBojx6.js

@@ -0,0 +1,169 @@
+import { STATE_LIMITS as l } from "@w6w/expr";
+import { parse as f } from "yaml";
+const y = /* @__PURE__ */ new Set(["string", "number", "boolean", "object", "array"]);
+function p(e) {
+  if (!Array.isArray(e)) return [];
+  const n = [];
+  for (const t of e) {
+    if (typeof t != "object" || t === null || Array.isArray(t)) continue;
+    const r = t, o = { key: typeof r.key == "string" ? r.key : "" };
+    typeof r.type == "string" && y.has(r.type) && (o.type = r.type), typeof r.required == "boolean" && (o.required = r.required), r.default !== void 0 && (o.default = r.default), n.push(o);
+  }
+  return n;
+}
+function m(e) {
+  if (e.length !== 0)
+    return e.map((n) => {
+      const t = { key: n.key };
+      return n.type !== void 0 && (t.type = n.type), n.required && (t.required = !0), n.default !== void 0 && (t.default = n.default), t;
+    });
+}
+function h(e) {
+  const n = /* @__PURE__ */ new Set(), t = [];
+  return e.forEach((r, o) => {
+    n.has(r.key) ? t.push(o) : n.add(r.key);
+  }), t;
+}
+function b(e, n, t) {
+  const r = /* @__PURE__ */ new Set(), o = [];
+  for (const i of [...e.slice(0, n).map((s) => s.key), ...t])
+    i === "" || r.has(i) || (r.add(i), o.push(i));
+  return o;
+}
+function c(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e) && e.type === "expr" && Array.isArray(e.parts);
+}
+function v(e) {
+  const n = [], t = [];
+  for (const r of e)
+    if (r.key.trim() !== "") {
+      if (c(r.default)) {
+        n.push({ key: r.key, type: r.type, required: !1 }), t.push(r.key);
+        continue;
+      }
+      n.push({ key: r.key, type: r.type, default: r.default, required: r.required });
+    }
+  return { fields: n, computed: t };
+}
+function a(e) {
+  return e !== null && typeof e == "object" && !Array.isArray(e);
+}
+function A(e) {
+  return a(e) ? e : void 0;
+}
+function S(e) {
+  if (e.trim() === "") return { ok: !0, value: void 0 };
+  let n;
+  try {
+    n = JSON.parse(e);
+  } catch {
+    return { ok: !1, reason: "invalid_json" };
+  }
+  return a(n) ? JSON.stringify(n).length > l.initialChars ? { ok: !1, reason: "too_large" } : Object.keys(n).length === 0 ? { ok: !0, value: void 0 } : { ok: !0, value: n } : { ok: !1, reason: "not_object" };
+}
+function j(e, n) {
+  if (!e) return [];
+  const t = [];
+  for (const r of n)
+    r.key === "" || t.includes(r.key) || Object.hasOwn(e, r.key) && t.push(r.key);
+  return t;
+}
+function w(e) {
+  if (!e) return !1;
+  switch (e.kind) {
+    case "function":
+    case "endpoint":
+    case "workflow":
+      return !0;
+    // A bare connection has no snippet; only the action page (which names one) does.
+    case "connection":
+      return !!e.action;
+    default:
+      return !1;
+  }
+}
+function g(e) {
+  if (!e) return null;
+  switch (e.kind) {
+    case "function":
+      return { kind: "function", id: e.id, key: e.key, inputs: e.inputs, alias: e.alias };
+    case "endpoint":
+      return {
+        kind: "endpoint",
+        id: e.id,
+        key: e.key,
+        invokeUrl: e.invokeUrl,
+        invokeUrlByKey: e.invokeUrlByKey,
+        urlForm: e.urlForm,
+        alias: e.alias,
+        inputs: e.inputs
+      };
+    case "workflow":
+      return { kind: "workflow", id: e.id, displayName: e.label, key: e.key };
+    case "connection":
+      return e.action ? { kind: "connection", id: e.id, action: e.action, params: e.params } : null;
+    default:
+      return null;
+  }
+}
+function O({
+  resource: e,
+  target: n,
+  hasAdapter: t
+}) {
+  return (n.kind === "function" || n.kind === "workflow") && n.kind === e.kind && n.id === e.id ? t ? "warn" : "block" : "allow";
+}
+function u(e) {
+  let n;
+  if (e.format === "json")
+    try {
+      n = JSON.parse(e.content);
+    } catch {
+      return null;
+    }
+  else if (e.format === "yaml")
+    try {
+      n = f(e.content);
+    } catch {
+      return null;
+    }
+  else
+    return null;
+  return typeof n != "object" || n === null || Array.isArray(n) ? null : n;
+}
+function q(e) {
+  return e.map((n) => {
+    const t = u(n);
+    if (!t) return { key: n.key };
+    const r = Object.keys(t);
+    return r.length > 0 ? { key: n.key, fields: r.map((o) => ({ key: o })) } : { key: n.key };
+  });
+}
+function F(e) {
+  const n = {};
+  for (const t of e) {
+    n[`documents.${t.key}`] = t.content;
+    const r = u(t);
+    if (r)
+      for (const [o, i] of Object.entries(r))
+        n[`documents.${t.key}.${o}`] = i;
+  }
+  return n;
+}
+export {
+  h as a,
+  c as b,
+  p as c,
+  F as d,
+  O as e,
+  v as f,
+  S as g,
+  b as h,
+  w as i,
+  q as p,
+  A as r,
+  j as s,
+  g as t,
+  m as v
+};
+//# sourceMappingURL=document-sources-DNmBojx6.js.map

package/dist/document-sources-DNmBojx6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-sources-DNmBojx6.js","sources":["../src/lib/workflow-variables.ts","../src/lib/starting-data.ts","../src/lib/code-rail.ts","../src/lib/error-handler-self.ts","../src/lib/document-sources.ts"],"sourcesContent":["/**\n * The pure decisions behind a workflow's `variables` list (T1.1.5) — the\n * Variables tab's authoring surface and the run page's generated-form\n * projection. `variables` rides inside the workflow **definition**\n * (`w6w-workflow/packages/types/mod.ts:170`), the same JSON document that\n * already carries `steps`, so there is no column, no migration and no server\n * change behind it.\n *\n * Pure, React-free, `.ts`, **no value import of `@w6w/ui`** — studio's\n * `test:unit` is a bare `node --test` with no jsx loader\n * (`studio/package.json:17`), so a value import of the barrel (which\n * re-exports `.tsx`) kills the test. Same shape as `workflow-settings.ts`'s\n * reader/writer discipline and `input-seeding.ts`'s pure-module docstring\n * rule.\n *\n * The row type is defined **locally**, structurally identical to\n * `WorkflowVariable` (`w6w-workflow/packages/types/mod.ts:40-45`: `key`,\n * `type?`, `required?`, `default?`), so no cast is needed at the `.tsx`\n * boundary in either direction.\n */\n\n/** One row of a workflow's declared `variables` list. */\nexport interface WorkflowVariableRow {\n  key: string;\n  type?: \"string\" | \"number\" | \"boolean\" | \"object\" | \"array\";\n  required?: boolean;\n  default?: unknown;\n}\n\n/** The declared type union `WorkflowVariable.type` accepts. */\nconst VARIABLE_TYPES = new Set([\"string\", \"number\", \"boolean\", \"object\", \"array\"]);\n\n/**\n * Read a workflow definition's `variables` field as an array of rows.\n *\n * Takes `unknown` because the source is `JSON.parse`d and the `</>` editor\n * lets an author type anything: a non-array reads as no variables, and a\n * non-object array entry is dropped rather than crashing the tab. **Never\n * sorts, never de-dups, never re-orders** — declaration order *is*\n * resolution order (D-5) and `resolveVariables` iterates the array in order\n * (`w6w-workflow/packages/engine/src/run.ts:70-83`), so two rows sharing a\n * key both survive, in the order they were declared.\n */\nexport function readVariables(raw: unknown): WorkflowVariableRow[] {\n  if (!Array.isArray(raw)) return [];\n  const out: WorkflowVariableRow[] = [];\n  for (const entry of raw) {\n    if (typeof entry !== \"object\" || entry === null || Array.isArray(entry)) continue;\n    const e = entry as Record<string, unknown>;\n    const row: WorkflowVariableRow = { key: typeof e.key === \"string\" ? e.key : \"\" };\n    if (typeof e.type === \"string\" && VARIABLE_TYPES.has(e.type)) {\n      row.type = e.type as WorkflowVariableRow[\"type\"];\n    }\n    if (typeof e.required === \"boolean\") row.required = e.required;\n    if (e.default !== undefined) row.default = e.default;\n    out.push(row);\n  }\n  return out;\n}\n\n/**\n * The rows ready to write back into the definition's `variables` field.\n *\n * Mirrors `workflow-settings.ts`'s \"default written as absent\" rule, but here\n * it applies to a row's **optional flags, not the value**: `required` is\n * omitted when `false` and `type` is omitted when unset, so opening the tab\n * and touching nothing does not rewrite a legacy definition into\n * `{required:false,type:undefined}` rows. `default` is user data and is kept\n * **verbatim** — including `false`, `0`, `\"\"` and `null` — never dropped as\n * an optimisation (a \"drop falsy\" implementation would lose a `false`\n * default, which is exactly the case the tests pin).\n *\n * Returns `undefined` for an empty array (never `[]`) so the caller\n * (`patchMeta`, via `JSON.stringify`) drops the key entirely — which matters\n * beyond hygiene here: `draftFromWorkflowVariables`\n * (`server/packages/api/mcp/tool-schema.ts:310-326`) treats `undefined` and\n * `length === 0` identically (pass-through), so `[]` and absent already agree\n * on the wire; this just keeps the definition itself from growing an empty\n * `\"variables\": []` on the first open of the tab.\n */\nexport function variablesForSave(rows: WorkflowVariableRow[]): WorkflowVariableRow[] | undefined {\n  if (rows.length === 0) return undefined;\n  return rows.map((r) => {\n    const out: WorkflowVariableRow = { key: r.key };\n    if (r.type !== undefined) out.type = r.type;\n    if (r.required) out.required = true;\n    if (r.default !== undefined) out.default = r.default;\n    return out;\n  });\n}\n\n/**\n * Every index whose `key` repeats an earlier row's key. `resolveVariables`\n * writes `vars[v.key]` in a loop with no duplicate check (`run.ts:74-80`), so\n * a later row silently wins — this is informational only (the tab marks the\n * row; nothing here blocks a save), never de-duping or rejecting.\n */\nexport function duplicateKeyIndexes(rows: WorkflowVariableRow[]): number[] {\n  const seen = new Set<string>();\n  const out: number[] = [];\n  rows.forEach((r, i) => {\n    if (seen.has(r.key)) out.push(i);\n    else seen.add(r.key);\n  });\n  return out;\n}\n\n/**\n * The `var.*` names to offer row `index`'s expression rail: the keys of\n * rows **strictly above** it, then `projectVars`, deduped, with blanks\n * dropped. Declaration order is resolution order (D-5), so a row can only\n * reference a variable declared earlier than itself — offering a row at or\n * below `index` would suggest a forward reference the engine rejects\n * (T2.1.1). This is the offered rail only; it is not validation.\n */\nexport function varsRailFor(\n  rows: WorkflowVariableRow[],\n  index: number,\n  projectVars: string[],\n): string[] {\n  const seen = new Set<string>();\n  const out: string[] = [];\n  for (const k of [...rows.slice(0, index).map((r) => r.key), ...projectVars]) {\n    if (k === \"\" || seen.has(k)) continue;\n    seen.add(k);\n    out.push(k);\n  }\n  return out;\n}\n\n/** `true` if `v` is an `ExprValue` envelope — the two-key check `@w6w/ui`'s\n *  `isExprValue` (`ui/src/types.ts:301-309`) makes, re-implemented locally\n *  because this module cannot import `@w6w/ui` at value level (see the\n *  module docstring). Mirrors `trigger-preview.ts:102-119`'s sanctioned\n *  pattern for the same constraint — this is not duplication. */\nexport function isExprDefault(v: unknown): boolean {\n  return (\n    typeof v === \"object\" &&\n    v !== null &&\n    !Array.isArray(v) &&\n    (v as { type?: unknown }).type === \"expr\" &&\n    Array.isArray((v as { parts?: unknown }).parts)\n  );\n}\n\n/** One field the run page's generated form fills — structurally assignable\n *  to `@w6w/ui/flow`'s `TriggerFieldDef` (all fields optional) with no cast. */\nexport interface RunFormField {\n  key: string;\n  type?: WorkflowVariableRow[\"type\"];\n  default?: unknown;\n  required?: boolean;\n}\n\n/**\n * Project a workflow's declared variables into the run page's form fields.\n *\n * A row whose `default` is an `ExprValue` envelope is a server-side\n * computation (its value is resolved at run time, not authored on the\n * client), so it is emitted with **`default` dropped and `required: false`**\n * — never as a value `ui`'s `seedValues` would `String(...)` the envelope\n * into — and its key is listed in `computed` so the host can label the field\n * \"computed at run time\" and post nothing for it. A row with a blank/missing\n * key is dropped, mirroring `@w6w/ui`'s `fieldsToParams`, which does the same\n * before turning field definitions into a fillable form.\n */\nexport function runFormFields(rows: WorkflowVariableRow[]): {\n  fields: RunFormField[];\n  computed: string[];\n} {\n  const fields: RunFormField[] = [];\n  const computed: string[] = [];\n  for (const r of rows) {\n    if (r.key.trim() === \"\") continue;\n    if (isExprDefault(r.default)) {\n      fields.push({ key: r.key, type: r.type, required: false });\n      computed.push(r.key);\n      continue;\n    }\n    fields.push({ key: r.key, type: r.type, default: r.default, required: r.required });\n  }\n  return { fields, computed };\n}\n","/**\n * The pure decisions behind a workflow's **Starting data** (`Workflow.initialState`,\n * core/rfcs/workflow.md; ruling R8): a literal JSON object that seeds the run's\n * state tree. It rides inside the workflow definition as a top-level key, the\n * same way `variables` does, so the Settings tab only reads and writes that key.\n *\n * Seed layering (R2', later wins): project variables → starting data → the\n * workflow's own / the caller's variables.\n *\n * Pure, React-free, `.ts`, **no value import of `@w6w/ui`** — the same header\n * rule as `workflow-variables.ts` (studio's `test:unit` has no jsx loader).\n */\nimport { STATE_LIMITS } from \"@w6w/expr\";\nimport type { WorkflowVariableRow } from \"./workflow-variables.ts\";\n\n/** Why a Starting data draft cannot be saved. */\nexport type StartingDataProblem = \"invalid_json\" | \"not_object\" | \"too_large\";\n\n/** The outcome of reading a Starting data draft for save. `value: undefined` drops the key. */\nexport type StartingDataForSave =\n  | { ok: true; value: Record<string, unknown> | undefined }\n  | { ok: false; reason: StartingDataProblem };\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return v !== null && typeof v === \"object\" && !Array.isArray(v);\n}\n\n/**\n * Read a definition's `initialState` field. Takes `unknown` because the source is\n * `JSON.parse`d and the `</>` editor lets an author type anything: only a plain\n * object counts; anything else reads as \"no starting data\".\n */\nexport function readStartingData(raw: unknown): Record<string, unknown> | undefined {\n  return isPlainObject(raw) ? raw : undefined;\n}\n\n/**\n * Turn the tab's JSON text into the value `patchMeta({ initialState })` saves.\n * Blank text and `{}` both mean \"no starting data\" (`value: undefined`, so the\n * key is dropped from the definition). Anything but a plain object is refused,\n * as is an object whose serialised form exceeds `STATE_LIMITS.initialChars`\n * (measured exactly as the server measures it: `JSON.stringify(v).length`).\n */\nexport function startingDataForSave(text: string): StartingDataForSave {\n  if (text.trim() === \"\") return { ok: true, value: undefined };\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(text);\n  } catch {\n    return { ok: false, reason: \"invalid_json\" };\n  }\n  if (!isPlainObject(parsed)) return { ok: false, reason: \"not_object\" };\n  if (JSON.stringify(parsed).length > STATE_LIMITS.initialChars) {\n    return { ok: false, reason: \"too_large\" };\n  }\n  if (Object.keys(parsed).length === 0) return { ok: true, value: undefined };\n  return { ok: true, value: parsed };\n}\n\n/**\n * The declared variable keys that are also top-level keys of the starting data —\n * on those keys the variable's value wins (R2'). Variable declaration order, no\n * duplicates, no empty keys.\n */\nexport function startingDataCollisions(\n  initial: Record<string, unknown> | undefined,\n  variables: readonly WorkflowVariableRow[],\n): string[] {\n  if (!initial) return [];\n  const out: string[] = [];\n  for (const v of variables) {\n    if (v.key === \"\" || out.includes(v.key)) continue;\n    if (Object.hasOwn(initial, v.key)) out.push(v.key);\n  }\n  return out;\n}\n","/**\n * Pure decisions behind the right rail's Code tool (`src/ui/rail/CodeTool.tsx`).\n * Split out so `node --test` can gate them directly — mirrors\n * `src/lib/alias-rail.ts`'s own reason for existing: `node --test` throws\n * `ERR_UNKNOWN_FILE_EXTENSION` on any `@w6w/ui`-adjacent import, and\n * `src/ui/workspace.tsx` sits one hop from that barrel through `Layout.tsx`'s\n * import graph. So this module declares its own structural mirror of\n * `WorkspaceCallable` instead of importing it.\n */\nimport type { SnippetCallable, SnippetInput } from \"./sdk-snippets.ts\";\n\n/** Structural mirror of T2.1.2's widened `WorkspaceCallable` (`src/ui/workspace.tsx`). */\nexport type RailCallable =\n  | { kind: \"function\"; id: string; key?: string; inputs?: readonly SnippetInput[]; alias?: string }\n  | {\n      kind: \"endpoint\";\n      id: string;\n      key?: string;\n      invokeUrl?: string;\n      invokeUrlByKey?: string;\n      urlForm?: \"id\" | \"key\";\n      alias?: string;\n      inputs?: readonly SnippetInput[];\n    }\n  | { kind: \"workflow\"; id: string; label?: string; key?: string }\n  | { kind: \"connection\"; id: string; action?: string; params?: readonly SnippetInput[] }\n  | null;\n\n/**\n * Is a \"Call from code\" panel meaningful for this context? Mirrors\n * `alias-rail.ts`'s `targetForCallable` fail-closed shape exactly (its own\n * comment: *\"'connection' and no resource at all both fail closed to null —\n * house style\"*) — a bare `\"connection\"` (no `action`) and `null` both answer `false`.\n */\nexport function isAvailable(ctx: RailCallable): boolean {\n  if (!ctx) return false;\n  switch (ctx.kind) {\n    case \"function\":\n    case \"endpoint\":\n    case \"workflow\":\n      return true;\n    // A bare connection has no snippet; only the action page (which names one) does.\n    case \"connection\":\n      return !!ctx.action;\n    default:\n      return false;\n  }\n}\n\n/**\n * The widened-union -> `SnippetCallable` conversion `CodeTool.Panel` hands to\n * `CallFromCodeBody`. `null` for a context this tool has no snippet for\n * (a connection without an `action`, or no resource at all) — defensive, since `isAvailable`\n * already keeps the tool off the strip for those.\n *\n * The one easy-to-miss field: `WorkspaceCallable`'s `label` maps to\n * `SnippetCallable`'s `workflow` arm's `displayName` — NOT the same field\n * name. A naive `{...ctx}` spread compiles (both optional) but silently\n * drops the label everywhere it matters, never caught by `tsc`.\n */\nexport function toSnippetCallable(ctx: RailCallable): SnippetCallable | null {\n  if (!ctx) return null;\n  switch (ctx.kind) {\n    case \"function\":\n      return { kind: \"function\", id: ctx.id, key: ctx.key, inputs: ctx.inputs, alias: ctx.alias };\n    case \"endpoint\":\n      return {\n        kind: \"endpoint\",\n        id: ctx.id,\n        key: ctx.key,\n        invokeUrl: ctx.invokeUrl,\n        invokeUrlByKey: ctx.invokeUrlByKey,\n        urlForm: ctx.urlForm,\n        alias: ctx.alias,\n        inputs: ctx.inputs,\n      };\n    case \"workflow\":\n      return { kind: \"workflow\", id: ctx.id, displayName: ctx.label, key: ctx.key };\n    case \"connection\":\n      return ctx.action\n        ? { kind: \"connection\", id: ctx.id, action: ctx.action, params: ctx.params }\n        : null;\n    default:\n      return null;\n  }\n}\n","/**\n * The authoring-time half of the error-handler recursion guard. The server\n * compares resolved values at dispatch time; this small, pure decision keeps\n * the rail from creating the known-identical no-adapter case in the first\n * place without losing an adapter imported or authored elsewhere.\n */\nexport type ErrorHandlerSelfDecision = \"allow\" | \"warn\" | \"block\";\n\nexport interface ErrorHandlerSelfInput {\n  resource: { kind: string; id: string };\n  target: { kind: string; id: string };\n  hasAdapter: boolean;\n}\n\n/**\n * Only Function and Workflow targets can re-enter the currently edited\n * resource. Actions are always allowed. A self-target with no adapter passes\n * the failed input through unchanged, so it is refused; an adapter is kept\n * and called out because only the runtime can determine its resolved values.\n */\nexport function errorHandlerSelfDecision({\n  resource,\n  target,\n  hasAdapter,\n}: ErrorHandlerSelfInput): ErrorHandlerSelfDecision {\n  const selfTarget =\n    (target.kind === \"function\" || target.kind === \"workflow\") &&\n    target.kind === resource.kind &&\n    target.id === resource.id;\n  if (!selfTarget) return \"allow\";\n  return hasAdapter ? \"warn\" : \"block\";\n}\n","/**\n * Pure `Doc[]` → `ExpressionOptions` projections for the ƒx picker's\n * Documents group — extracted out of `ExpressionScope.tsx` so studio's\n * Node-native `test:unit` runner (globbed to `src/lib/__tests__/`,\n * `src/api/__tests__/` and `src/repos/__tests__/` only — `.ai/PLANNER.md`\n * fact 10) can reach it. No React, no import from `src/ui/` — `@w6w/ui`'s\n * `ExpressionDocumentSource` interface is not imported either (it is not\n * exported from `@w6w/ui`'s barrel, D-P3): the object literals returned below\n * are structurally identical to it, so TypeScript carries the shape without a\n * type import.\n *\n * ## The gate — mirrors the engine's own, bit-for-bit\n *\n * A document contributes field data **iff**: `doc.format === \"json\"` AND\n * `JSON.parse(doc.content)` succeeds into a plain object, OR\n * `doc.format === \"yaml\"` AND npm `yaml`'s `parse(doc.content)` succeeds into\n * a plain object — where *plain object* means\n * `typeof v === \"object\" && v !== null && !Array.isArray(v)`. This mirrors\n * the engine's own gate (`documentsSeed` /\n * `packages/server/packages/api/run-seed.ts`, read-only, out of scope)\n * bit-for-bit for each format: `format === \"json\"` or `format === \"yaml\"`,\n * then a `try/catch` parse, falling back to the raw content string on either\n * a non-matching format or a throw. Reproduced here so the picker never\n * offers a ref the run scope itself would refuse to resolve\n * (`render_ref_unresolved`) — `text`/`markdown`/`html` documents, and a\n * `json`/`yaml` document whose parse throws or yields a non-plain-object, are\n * excluded.\n *\n * The two parsers are not identical for every input — `@std/yaml` (server,\n * `{ schema: \"core\" }`) and npm `yaml` (here) diverge on tab-indented content\n * and on an unresolvable custom tag (`!!js/function`), both accepted, tested\n * debt (D-3). Every other input, including a plain JSON object (JSON is a\n * subset of YAML), agrees between the two.\n *\n * Field keys are enumerated RAW and UNFILTERED by {@link projectDocumentSources}\n * — arbitrary user-authored JSON keys (which can contain `.`/`{`/`}`/\n * whitespace) reach the modal; `isRefSafeKey` filters them exactly once, at\n * the modal's render site (`ExpressionEditorModal.tsx`), never here\n * (`building-blocks.md`: \"enumerate raw at the source, filter once at the\n * single render site\").\n */\nimport type { Doc } from \"@w6w/sdk\";\nimport { parse as parseYaml } from \"yaml\";\n\n/** One document's contribution to `ExpressionOptions.documents` — structurally\n * identical to `@w6w/ui`'s (unexported) `ExpressionDocumentSource`. */\nexport interface DocumentSource {\n  key: string;\n  fields?: { key: string }[];\n}\n\n/**\n * `doc`'s parsed content when the gate holds, else `null`. The one place both\n * functions below apply the gate, so they cannot silently disagree on it.\n */\nfunction gatedFields(doc: Doc): Record<string, unknown> | null {\n  let parsed: unknown;\n  if (doc.format === \"json\") {\n    try {\n      parsed = JSON.parse(doc.content);\n    } catch {\n      return null;\n    }\n  } else if (doc.format === \"yaml\") {\n    try {\n      parsed = parseYaml(doc.content);\n    } catch {\n      return null;\n    }\n  } else {\n    return null;\n  }\n  if (typeof parsed !== \"object\" || parsed === null || Array.isArray(parsed)) return null;\n  return parsed as Record<string, unknown>;\n}\n\n/**\n * The `ExpressionOptions.documents` array: `{ key }` for every document, plus\n * `fields` (raw, unfiltered top-level keys) when the gate holds AND the\n * parsed object has at least one key. `fields` is OMITTED (not `[]`) both\n * when the gate fails and when it holds but yields zero keys — a consumer\n * must be able to tell \"nothing declared\" from \"declared none\".\n */\nexport function projectDocumentSources(docs: Doc[]): DocumentSource[] {\n  return docs.map((d) => {\n    const parsed = gatedFields(d);\n    if (!parsed) return { key: d.key };\n    const keys = Object.keys(parsed);\n    return keys.length > 0 ? { key: d.key, fields: keys.map((key) => ({ key })) } : { key: d.key };\n  });\n}\n\n/**\n * The `sampleValues` entries the ƒx Result preview substitutes for document\n * refs: `documents.<key>` → the document's raw content, for every document\n * (unconditional, exactly as before this project), PLUS `documents.<key>.<field>`\n * → the field's own parsed value, for the gated set only. Without the second\n * half, every field ref this project newly makes pickable would preview as\n * the empty string (`renderResult` does an exact flat-key lookup).\n */\nexport function documentSampleValues(docs: Doc[]): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  for (const d of docs) {\n    out[`documents.${d.key}`] = d.content;\n    const parsed = gatedFields(d);\n    if (!parsed) continue;\n    for (const [key, value] of Object.entries(parsed)) {\n      out[`documents.${d.key}.${key}`] = value;\n    }\n  }\n  return out;\n}\n"],"names":["VARIABLE_TYPES","readVariables","raw","out","entry","e","row","variablesForSave","rows","r","duplicateKeyIndexes","seen","i","varsRailFor","index","projectVars","k","isExprDefault","v","runFormFields","fields","computed","isPlainObject","readStartingData","startingDataForSave","text","parsed","STATE_LIMITS","startingDataCollisions","initial","variables","isAvailable","ctx","toSnippetCallable","errorHandlerSelfDecision","resource","target","hasAdapter","gatedFields","doc","parseYaml","projectDocumentSources","docs","d","keys","key","documentSampleValues","value"],"mappings":"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"}

package/dist/draft/use-workflow-draft.d.ts

@@ -63,5 +63,7 @@ export interface WorkflowDraft {
     commit(next: string): Promise<FlushOutcome>;
     /** 409 recovery: GET, replace the buffer and token, clear `stale`. */
     reload(): Promise<void>;
+    /** Stop pending saves, drain an in-flight save, replace the server draft, then reload. */
+    discardThen(action: () => Promise<unknown>): Promise<void>;
 }
 export declare function useWorkflowDraft(o: UseWorkflowDraftOptions): WorkflowDraft;

package/dist/draft.mjs

@@ -1,8 +1,8 @@
 "use client";
-import { A as a, c as s, i as t, n as o, r as i, u } from "./use-workflow-draft-DzAyUeA6.js";
+import { A as a, c as s, i as t, n as o, r as i, u } from "./use-workflow-draft-l3P5KZzw.js";
 import { E as n, u as l } from "./client-context-CX61Bgw-.js";
 import { D as E, c, u as d } from "./draft-registry-YF0tqNN0.js";
-import { u as p, a as x, b as S } from "./use-callable-draft-DsALnSfF.js";
+import { u as p, a as x, b as S } from "./use-callable-draft-DCauHt5o.js";
 export {
   a as AUTOSAVE_DEBOUNCE_MS,
   E as DraftRegistryProvider,

package/dist/editor/PublishTooltip.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+/** Immediate, keyboard-accessible publish help; no native title delay. */
+export declare function PublishTooltip({ message, disabled, children, }: {
+    message: string;
+    disabled?: boolean;
+    children: (descriptionId: string) => ReactNode;
+}): import("react").JSX.Element;

package/dist/editor/SetupIncompleteBanner.d.ts

@@ -0,0 +1,12 @@
+export interface SetupIncompleteBannerProps {
+    /** Node id -> what is missing there (the detector's output). */
+    problems: Record<string, string[]>;
+    /** Node id -> display label; falls back to the id. */
+    nodeLabel?: (nodeId: string) => string;
+}
+/** Non-blocking "Setup incomplete" banner; renders nothing when no node has a problem. */
+export declare function SetupIncompleteBanner(props: SetupIncompleteBannerProps): import('react').DetailedReactHTMLElement<{
+    role: "status";
+    className: string;
+    "data-testid": string;
+}, HTMLElement> | null;

package/dist/editor/StartingStateModal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The one editor for a workflow's starting state (`Workflow.initialState`), opened from the
+ * rail's State tool (`rail/StartingStateTool.tsx`) and from Settings → Starting data: the expression manager in its
+ * starting-state mode. Its `{{ }}` references are resolved once when a run starts, before any
+ * step, so the rail has no Previous steps or State section, and no Secrets (a secret never
+ * enters state). A click inserts a reference or, with "Value", the source's current value. Save
+ * goes through `startingDataForSave` and `validateInitialState` (the server's own check); `{}`
+ * or empty drops the key.
+ */
+export declare function StartingStateModal(props: {
+    initialState: Record<string, unknown> | undefined;
+    onChange: (next: Record<string, unknown> | undefined) => void;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/editor/WorkflowSettingsModal.d.ts

@@ -5,13 +5,18 @@ import { WorkflowVariableRow } from '../lib/index.ts';
  * Both General flags are on unless the workflow says otherwise and persist
  * immediately (`saveMeta`, via `onChange`); every Variables edit instead goes
  * through the auto-saver (`onVariablesChange` → `patchMeta`, never an
- * immediate save — see the module docstring's Save path decision).
+ * immediate save — see the module docstring's Save path decision). The
+ * Starting data tab (`Workflow.initialState`, the state tree's seed) shows what
+ * is set and how it layers with variables; its editor is the one the rail's
+ * State tool opens (`StartingStateModal`), reached through `onEditStartingData`.
  */
 export declare function WorkflowSettingsModal(props: {
     autoSave: boolean;
     savePosition: boolean;
     variables: WorkflowVariableRow[];
+    initialState: Record<string, unknown> | undefined;
     onClose: () => void;
     onChange: (key: "autoSave" | "savePosition", value: boolean) => void;
     onVariablesChange: (next: WorkflowVariableRow[]) => void;
+    onEditStartingData: () => void;
 }): import("react").JSX.Element;

package/dist/editor/WorkflowVariablesEditor.d.ts

@@ -0,0 +1,6 @@
+import { WorkflowVariableRow } from '../lib/index.ts';
+/** Shared workflow input editor, used in the Data rail and the legacy settings dialog. */
+export declare function WorkflowVariablesEditor({ variables, onVariablesChange, }: {
+    variables: WorkflowVariableRow[];
+    onVariablesChange: (next: WorkflowVariableRow[]) => void;
+}): import("react").JSX.Element;

package/dist/editor/definition.d.ts

@@ -9,6 +9,10 @@ export type Parsed = Record<string, unknown> & {
      *  this is ever ASSIGNED; this page only ever reads it back. */
     key?: string | null;
     nodes?: unknown[];
+    connections?: Record<string, {
+        app: string;
+        connection: string | null;
+    }>;
     /** Legacy name for `nodes`; read via `workflowNodes`. */
     steps?: unknown[];
     status?: WorkflowStatus;

package/dist/editor/json-apply.d.ts

@@ -0,0 +1,29 @@
+import { JsonApplyCheck } from '../chrome/JsonToggle.tsx';
+import { Parsed } from './definition.ts';
+/**
+ * The top-level fields the raw-JSON dialog may not change: `id` names the row the save writes to,
+ * `key` is assigned only by the rail's Settings → Key control (`workflowKeyEditAllowed`), and
+ * `manifestVersion` is the one value the server's `parseWorkflowDefinition` accepts. An edit that
+ * alters or deletes one is not refused: Apply puts the loaded value back and says so.
+ */
+export declare const PROTECTED_WORKFLOW_FIELDS: readonly ["id", "key", "manifestVersion"];
+/**
+ * The offset of the first character that makes `text` invalid JSON, or `null` when it is valid.
+ * Engines disagree on whether `JSON.parse` reports a position at all (current V8 quotes a snippet
+ * instead), so the dialog finds it itself with this small strict scanner.
+ */
+export declare function jsonErrorOffset(text: string): number | null;
+/** `JSON.parse`'s message, prefixed with the 1-based line and column of the first bad character. */
+export declare function jsonSyntaxError(text: string, e: unknown): string;
+/**
+ * The save-time shape rules the server applies (`parseWorkflowDefinition` + the step-id gate),
+ * restated for the fields the canvas reads, plus the one the canvas needs on top: every edge names
+ * a node that exists, or React Flow drops it silently and the next canvas edit deletes it.
+ */
+export declare function workflowShapeError(def: Record<string, unknown>): string | null;
+/**
+ * Everything Apply checks, in order: the text parses, it is an object, the protected fields carry
+ * the loaded values (restored when not), and the result has a shape the canvas and the save accept.
+ * `ok` hands back the text to apply — re-serialized when a field was restored, verbatim otherwise.
+ */
+export declare function prepareWorkflowJsonApply(text: string, loaded: Parsed | null): JsonApplyCheck;

package/dist/editor/step-problems-feed.d.ts

@@ -0,0 +1,5 @@
+import { StepProblems } from '@w6w/ui/flow';
+import { BindingProblem } from '../lib/binding-problems.ts';
+/** Per step: its connection problem first, then its loop problems, then its state
+ *  problems, then its setup-incomplete problem; all kept, empty lists skipped. */
+export declare function mergeStepProblems(bindingProblems: readonly BindingProblem[], loopProblems: StepProblems | undefined, stateProblems?: StepProblems, setupProblems?: StepProblems): StepProblems;

package/dist/editor/types.d.ts

@@ -17,8 +17,8 @@ export interface WorkflowEditorSlots {
     header?: ReactNode;
     /** Rendered after the built-in header actions. Ignored when `header` replaces the header. */
     headerActions?: ReactNode;
-    /** Label of the back control. Default `"← Workflows"`. */
-    backLabel?: string;
+    /** Label of the back control. Default `"← Workflows"`. `null` hides the back control. */
+    backLabel?: string | null;
 }
 export interface WorkflowEditorProps {
     workflowId: string;