@w6w/embed 0.2.11 → 0.2.20

package/dist/{spec-export-CBbloO_n.js → spec-export-DGy5ijps.js}

@@ -1,8 +1,8 @@
-import { useQueryClient as c, useMutation as l, useQuery as f } from "@tanstack/react-query";
-import { path as i } from "@w6w/sdk";
-import { u } from "./client-context-CX61Bgw-.js";
-import { i as p, a as d } from "./callables-tOlflvbl.js";
-import { o as y, _ as b } from "./spec-import-CW6R_Wk1.js";
+import { useQueryClient as c, useMutation as l, useQuery as w } from "@tanstack/react-query";
+import { path as u } from "@w6w/sdk";
+import { u as i } from "./client-context-CX61Bgw-.js";
+import { i as y, a as d } from "./callables-tOlflvbl.js";
+import { o as p, a2 as b } from "./workflows-BZN4Hyz1.js";
 const h = (t) => d("endpoint", t), m = (t) => d("function", t), a = {
   function: "functions",
   workflow: "workflows",
@@ -12,16 +12,16 @@ const h = (t) => d("endpoint", t), m = (t) => d("function", t), a = {
   endpoint: "invoke",
   workflow: "run"
 };
-function w(t, n) {
+function f(t, n) {
   return ["versions", t, n];
 }
-function $(t, n, s) {
-  return ["version", t, n, s];
+function $(t, n, o) {
+  return ["version", t, n, o];
 }
-function T(t, n, s) {
-  const e = u();
-  return f({
-    queryKey: w(t, n),
+function Q(t, n, o) {
+  const e = i();
+  return w({
+    queryKey: f(t, n),
     queryFn: async () => {
       switch (t) {
         case "workflow":
@@ -31,36 +31,36 @@ function T(t, n, s) {
         case "endpoint":
           return (await e.request({
             method: "GET",
-            path: i`/${a.endpoint}/${n}/versions`
+            path: u`/${a.endpoint}/${n}/versions`
           })).body;
       }
     },
-    enabled: s && t !== null && n !== ""
+    enabled: o && t !== null && n !== ""
   });
 }
-function O(t, n, s, e) {
-  const o = u();
-  return f({
-    queryKey: $(t, n, s),
+function F(t, n, o, e) {
+  const s = i();
+  return w({
+    queryKey: $(t, n, o),
     queryFn: async () => {
-      const r = s;
+      const r = o;
       switch (t) {
         case "workflow":
-          return await o.workflows.getVersion(n, r);
+          return await s.workflows.getVersion(n, r);
         case "function":
-          return await o.functions.getVersion(n, r);
+          return await s.functions.getVersion(n, r);
         case "endpoint":
-          return (await o.request({
+          return (await s.request({
             method: "GET",
-            path: i`/${a.endpoint}/${n}/versions/${String(r)}`
+            path: u`/${a.endpoint}/${n}/versions/${String(r)}`
           })).body.version;
       }
     },
-    enabled: e && t !== null && n !== "" && s !== null
+    enabled: e && t !== null && n !== "" && o !== null
   });
 }
-function Q(t) {
-  const n = u(), s = c();
+function O(t) {
+  const n = i(), o = c();
   return l({
     mutationFn: async (e) => {
       switch (t) {
@@ -71,17 +71,15 @@ function Q(t) {
         case "endpoint":
           return (await n.request({
             method: "POST",
-            path: i`/${a.endpoint}/${e}/publish`
+            path: u`/${a.endpoint}/${e}/publish`
           })).body;
       }
     },
-    onSuccess: (e, o) => {
-      s.invalidateQueries({ queryKey: w(t, o) });
-    }
+    onSuccess: (e, s) => o.invalidateQueries({ queryKey: f(t, s) })
   });
 }
 function v(t) {
-  const n = u(), s = c();
+  const n = i(), o = c();
   return l({
     mutationFn: async (e) => {
       switch (t) {
@@ -92,17 +90,17 @@ function v(t) {
         case "endpoint":
           return (await n.request({
             method: "POST",
-            path: i`/${a.endpoint}/${e.id}/${e.enabled ? "enable" : "disable"}`
+            path: u`/${a.endpoint}/${e.id}/${e.enabled ? "enable" : "disable"}`
           })).body;
       }
     },
-    onSuccess: (e, o) => {
-      s.invalidateQueries({ queryKey: w(t, o.id) });
+    onSuccess: (e, s) => {
+      o.invalidateQueries({ queryKey: f(t, s.id) });
     }
   });
 }
-function F(t) {
-  const n = u(), s = c();
+function g(t) {
+  const n = i(), o = c();
   return l({
     mutationFn: async (e) => {
       switch (t) {
@@ -113,29 +111,29 @@ function F(t) {
         case "endpoint":
           return (await n.request({
             method: "POST",
-            path: i`/${a.endpoint}/${e.id}/versions/${String(e.versionNumber)}/revert`
+            path: u`/${a.endpoint}/${e.id}/versions/${String(e.versionNumber)}/revert`
           })).body;
       }
     },
-    onSuccess: (e, o) => {
+    onSuccess: (e, s) => {
       let r;
       switch (t) {
         case "function":
-          r = m(o.id);
+          r = m(s.id);
           break;
         case "workflow":
-          r = b(o.id);
+          r = b(s.id);
           break;
         case "endpoint":
-          r = h(o.id);
+          r = h(s.id);
           break;
       }
-      p(s, w(t, o.id), r);
+      y(o, f(t, s.id), r);
     }
   });
 }
-function _(t) {
-  const n = u(), s = c();
+function I(t) {
+  const n = i(), o = c();
   return l({
     mutationFn: async (e) => {
       if (t === "workflow") {
@@ -144,33 +142,48 @@ function _(t) {
       }
       return (await n.request({
         method: "POST",
-        path: i`/${a[t]}/${e.id}/versions/${String(e.versionNumber)}/${q[t]}`,
+        path: u`/${a[t]}/${e.id}/versions/${String(e.versionNumber)}/${q[t]}`,
         body: {}
       })).body;
     },
-    onSettled: () => s.invalidateQueries({ queryKey: y.root })
+    onSettled: () => o.invalidateQueries({ queryKey: p.root })
+  });
+}
+function K() {
+  return ["constants"];
+}
+function N() {
+  const t = i();
+  return w({
+    queryKey: K(),
+    queryFn: async () => (await t.request({
+      method: "GET",
+      path: "/constants"
+    })).body.constants
   });
 }
-function g(t, n, s) {
-  const e = u();
-  return f({
+function P(t, n, o) {
+  const e = i();
+  return w({
     queryKey: ["spec", t, n],
     queryFn: async () => (await e.request({
       method: "GET",
-      path: i`/${t}/${n}/spec`
+      path: u`/${t}/${n}/spec`
     })).body.spec,
-    enabled: s && t !== null
+    enabled: o && t !== null
   });
 }
 export {
-  Q as a,
-  F as b,
-  v as c,
+  I as a,
+  O as b,
+  K as c,
   g as d,
-  O as e,
-  T as f,
-  w as g,
-  _ as u,
+  v as e,
+  P as f,
+  F as g,
+  Q as h,
+  f as i,
+  N as u,
   $ as v
 };
-//# sourceMappingURL=spec-export-CBbloO_n.js.map
+//# sourceMappingURL=spec-export-DGy5ijps.js.map

package/dist/spec-export-DGy5ijps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-export-DGy5ijps.js","sources":["../src/repos/versions.ts","../src/repos/constants.ts","../src/repos/spec-export.ts"],"sourcesContent":["/**\n * The `/<collection>/:id/{publish,versions,enable,disable}` repo (T3.1.1) — the Settings rail's\n * read-only version-history browser plus Publish and Enable/Disable. A NEW file, mirroring\n * `src/repos/spec-export.ts` in full: kept out of `repos/functions.ts` / `repos/workflows.ts` /\n * `repos/endpoints.ts` so this node never collides with any of them on the same file, exactly the\n * reason `spec-export.ts`'s own docblock gives for the sibling `/spec` route.\n *\n * **Workflow and Function arms go through the public `@w6w/sdk` methods** (`listVersions`,\n * `getVersion`, `publish`, `revert`, `enable`, `disable`, and `workflows.runVersion`), never\n * `apiClient.console.*`. Each hook dispatches with an explicit per-kind `switch` over LITERAL\n * receivers (`apiClient.workflows.publish(id)`, `apiClient.functions.publish(id)`) and no `default:`\n * — the same reasoning `COLLECTION_PATH` and `useRevertMutation` give against derived dispatch.\n *\n * **Two arms deliberately stay on `W6WClient.request<T>()`:** the ENDPOINT arm of every hook\n * (R-5: endpoint versions have no SDK method — intentionally excluded from the public surface),\n * and the FUNCTION arm of {@link useInvokeVersionMutation} (F-P4: `VersionHistoryModal` renders the\n * raw invocation frame, but `functions.runVersion` unwraps the output like `functions.run`, so the\n * SDK method would drop the frame; follow-up F-6).\n *\n * Every query below is gated on the CALLER'S OWN `enabled` flag, ANDed with `kind !== null` and\n * `id !== \"\"` — never on mount alone (`packages/studio/.ai/PLANNER.md` fact 11): a hook that fires\n * unconditionally against an unresolved `null`/`\"\"` argument 404s once and, because `main.tsx`\n * sets `retry: false` and an unchanged query key never re-fetches, never self-corrects. Opening\n * the Settings panel must issue ZERO `/versions` requests; only opening its History section (or\n * `WorkflowsPage.tsx`'s own editor, a separate call site with its own gate) flips `enabled`.\n *\n * T5.3.1 (project.md Phase 2, Amendments #5/#6): a version can now be reverted to and invoked\n * directly, superseding the earlier \"read-only history, restore out of scope\" pin. `useRevertMutation`\n * overwrites the LIVE resource's `definition` with the archived version's content — never its\n * `key`/address (HITL-4's pinned default) — and does post a `definition` back, by design.\n * `useInvokeVersionMutation` runs that ARCHIVED version's own definition, not the live one, which is\n * exactly why it exists as a separate call from the live invoke/run routes `functions.ts`/\n * `endpoints.ts`/`workflows.ts` already expose.\n */\nimport { useMutation, useQuery, useQueryClient } from \"@tanstack/react-query\";\nimport { path } from \"@w6w/sdk\";\nimport { useEmbedClient } from \"../draft/client-context.ts\";\nimport { callableKey } from \"../lib/callable-kind.ts\";\nimport { historyKeys } from \"../lib/history-query.ts\";\nimport { invalidateSavedCallable } from \"../lib/save-invalidation.ts\";\nimport { workflowKey } from \"./workflows.ts\";\n\n/** The Endpoint / Function single-resource keys the revert arm invalidates: the same\n *  `callableKey(\"<kind>\", id)` Studio's `repos/endpoints.ts` / `repos/functions.ts` export as\n *  `endpointKey` / `functionKey` (byte-identical `[\"endpoint\", id]` / `[\"function\", id]`). */\nconst endpointKey = (id: string) => callableKey(\"endpoint\", id);\nconst functionKey = (id: string) => callableKey(\"function\", id);\n\n/** The three kinds the wire contract's version-history routes exist for — `connection` has none\n *  (see `hasVersionHistory`, `../lib/rail-settings.ts`). */\nexport type VersionsKind = \"function\" | \"workflow\" | \"endpoint\";\n\n/** `<coll>` — the wire contract's own path segment for each kind, every one of the three arms\n *  named explicitly (never derived by string pluralization), mirroring `specCollectionForKind`'s\n *  own reasoning (`../lib/rail-settings.ts:69`): a typo'd suffix rule would silently send one\n *  kind's requests at another kind's collection. */\nconst COLLECTION_PATH: Record<VersionsKind, \"functions\" | \"workflows\" | \"endpoints\"> = {\n  function: \"functions\",\n  workflow: \"workflows\",\n  endpoint: \"endpoints\",\n};\n\n/** One row of `GET /<coll>/:id/versions`'s `versions` array — newest first, per the wire contract. */\nexport interface VersionSummary {\n  versionNumber: number;\n  createdAt: string;\n  createdBy: string | null;\n  isCurrentPublished: boolean;\n}\n\n/** `GET /<coll>/:id/versions`'s full 200 body. */\nexport interface VersionsEnvelope {\n  enabled: boolean;\n  currentPublishedVersion: number | null;\n  versions: VersionSummary[];\n}\n\n/** `GET /<coll>/:id/versions/:n`'s `version` field — `definition` is the redacted stored\n *  definition for THIS query; {@link useRevertMutation} is what posts a version's definition\n *  back onto the live resource, and {@link useInvokeVersionMutation} is what runs it. */\nexport interface VersionDetail {\n  versionNumber: number;\n  createdAt: string;\n  createdBy: string | null;\n  isCurrentPublished: boolean;\n  definition: Record<string, unknown>;\n}\n\n/** `POST /<coll>/:id/publish`'s 200 body. */\nexport interface PublishResult {\n  version: {\n    kind: string;\n    callableId: string;\n    versionNumber: number;\n    createdAt: string;\n    createdBy: string | null;\n  };\n  currentPublishedVersion: number;\n}\n\n/** `POST /<coll>/:id/versions/:n/revert`'s 200 body. */\nexport interface RevertResult {\n  reverted: {\n    kind: string;\n    callableId: string;\n    versionNumber: number;\n  };\n}\n\n/** `<coll>` per kind ends its live invoke/run route in `/invoke` (Function, Endpoint) or `/run`\n *  (Workflow, matching that kind's existing unversioned route) — every arm named explicitly\n *  (never derived by suffix rule), mirroring `COLLECTION_PATH`'s own reasoning above: a derived\n *  rule would silently send one kind's requests at the wrong verb. */\nconst VERSION_INVOKE_VERB: Record<VersionsKind, \"invoke\" | \"run\"> = {\n  function: \"invoke\",\n  endpoint: \"invoke\",\n  workflow: \"run\",\n};\n\nexport function versionsKey(kind: VersionsKind | null, id: string) {\n  return [\"versions\", kind, id] as const;\n}\n\nexport function versionKey(kind: VersionsKind | null, id: string, versionNumber: number | null) {\n  return [\"version\", kind, id, versionNumber] as const;\n}\n\n/**\n * `GET /<collection>/:id/versions`. Never fires on mount — `enabled` is the caller's own flag\n * (the Settings panel's History-open state, or `WorkflowsPage.tsx`'s own editor-open gate), ANDed\n * with `kind !== null` and `id !== \"\"`, exactly `useSpecQuery`'s shape (`spec-export.ts:45-57`).\n */\nexport function useVersionsQuery(kind: VersionsKind | null, id: string, enabled: boolean) {\n  const apiClient = useEmbedClient();\n  return useQuery({\n    queryKey: versionsKey(kind, id),\n    queryFn: async (): Promise<VersionsEnvelope> => {\n      switch (kind as VersionsKind) {\n        case \"workflow\":\n          return await apiClient.workflows.listVersions(id);\n        case \"function\":\n          return await apiClient.functions.listVersions(id);\n        case \"endpoint\": {\n          // R-5: no SDK method for endpoint versions.\n          const res = await apiClient.request<VersionsEnvelope>({\n            method: \"GET\",\n            path: path`/${COLLECTION_PATH.endpoint}/${id}/versions`,\n          });\n          return res.body;\n        }\n      }\n    },\n    enabled: enabled && kind !== null && id !== \"\",\n  });\n}\n\n/**\n * `GET /<collection>/:id/versions/:n`. Same gating shape as {@link useVersionsQuery}, plus\n * `versionNumber !== null` — the modal opens this only once a row has been clicked.\n */\nexport function useVersionQuery(\n  kind: VersionsKind | null,\n  id: string,\n  versionNumber: number | null,\n  enabled: boolean,\n) {\n  const apiClient = useEmbedClient();\n  return useQuery({\n    queryKey: versionKey(kind, id, versionNumber),\n    queryFn: async (): Promise<VersionDetail> => {\n      // The SDK's `getVersion` already unwraps the `{ version }` envelope.\n      const n = versionNumber as number;\n      switch (kind as VersionsKind) {\n        case \"workflow\":\n          return (await apiClient.workflows.getVersion(id, n)) as VersionDetail;\n        case \"function\":\n          return (await apiClient.functions.getVersion(id, n)) as VersionDetail;\n        case \"endpoint\": {\n          // R-5: no SDK method for endpoint versions.\n          const res = await apiClient.request<{ version: VersionDetail }>({\n            method: \"GET\",\n            path: path`/${COLLECTION_PATH.endpoint}/${id}/versions/${String(n)}`,\n          });\n          return res.body.version;\n        }\n      }\n    },\n    enabled: enabled && kind !== null && id !== \"\" && versionNumber !== null,\n  });\n}\n\n/**\n * `POST /<collection>/:id/publish`. `kind` is fixed per hook instance — the caller already knows\n * which kind it is publishing (the rail's `ctx.kind`, or `WorkflowsPage.tsx`'s hardcoded\n * `\"workflow\"`) — and `mutate(id)` supplies the resource. `onSuccess` invalidates the SAME\n * `[\"versions\", kind, id]` key {@link useVersionsQuery} reads, so the panel's published pointer\n * and version list are fresh without a reload (A3), mirroring `useSaveFunctionMutation`'s\n * `onSuccess` shape (`./functions.ts`).\n */\nexport function usePublishMutation(kind: VersionsKind) {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: async (id: string): Promise<PublishResult> => {\n      switch (kind) {\n        case \"workflow\":\n          return await apiClient.workflows.publish(id);\n        case \"function\":\n          return await apiClient.functions.publish(id);\n        case \"endpoint\": {\n          // R-5: no SDK method for endpoint versions.\n          const res = await apiClient.request<PublishResult>({\n            method: \"POST\",\n            path: path`/${COLLECTION_PATH.endpoint}/${id}/publish`,\n          });\n          return res.body;\n        }\n      }\n    },\n    onSuccess: (_result, id) => {\n      return qc.invalidateQueries({ queryKey: versionsKey(kind, id) });\n    },\n  });\n}\n\n/**\n * `POST /<collection>/:id/{enable,disable}`. One mutation for both — the wire contract is two\n * routes distinguished only by which one is called, so `vars.enabled` picks the path segment\n * rather than this module carrying two near-identical mutations. `onSuccess` invalidates the same\n * key {@link usePublishMutation} does, for the same reason.\n */\nexport function useSetEnabledMutation(kind: VersionsKind) {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: async (vars: { id: string; enabled: boolean }): Promise<{ enabled: boolean }> => {\n      // The SDK's `enable`/`disable` return void; the hook's result stays `{ enabled }`.\n      switch (kind) {\n        case \"workflow\":\n          if (vars.enabled) await apiClient.workflows.enable(vars.id);\n          else await apiClient.workflows.disable(vars.id);\n          return { enabled: vars.enabled };\n        case \"function\":\n          if (vars.enabled) await apiClient.functions.enable(vars.id);\n          else await apiClient.functions.disable(vars.id);\n          return { enabled: vars.enabled };\n        case \"endpoint\": {\n          // R-5: no SDK method for endpoint versions.\n          const res = await apiClient.request<{ enabled: boolean }>({\n            method: \"POST\",\n            path: path`/${COLLECTION_PATH.endpoint}/${vars.id}/${vars.enabled ? \"enable\" : \"disable\"}`,\n          });\n          return res.body;\n        }\n      }\n    },\n    onSuccess: (_result, vars) => {\n      qc.invalidateQueries({ queryKey: versionsKey(kind, vars.id) });\n    },\n  });\n}\n\n/**\n * `POST /<collection>/:id/versions/:n/revert`, no body — overwrites the LIVE resource's\n * `definition` with the archived version's content, preserving its `key`/address (HITL-4's\n * pinned default; see the module docblock). This is the first mutation in this family that\n * changes `definition` rather than merely appending to or flipping a flag on the version history\n * (`usePublishMutation`/`useSetEnabledMutation` above do neither), so `onSuccess` invalidates\n * BOTH `versionsKey(kind, id)` (the same key those two invalidate) AND the kind's own\n * definition-edit key — via the shared `invalidateSavedCallable` helper\n * `useSaveFunctionMutation`/`useSaveEndpointMutation` already route through\n * (`../lib/save-invalidation.ts`) — or the page a user reverted FROM keeps showing the\n * pre-revert draft until a manual reload. The definition key is picked by a `switch` naming all\n * three arms explicitly, with no `default:` — the same reasoning `COLLECTION_PATH`'s own docblock\n * gives: a derived rule would silently send one kind at another kind's key.\n */\nexport function useRevertMutation(kind: VersionsKind) {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: async (vars: { id: string; versionNumber: number }): Promise<RevertResult> => {\n      // The SDK's `revert` unwraps `{ reverted }`; the hook re-wraps it to keep its result shape.\n      switch (kind) {\n        case \"workflow\":\n          return { reverted: await apiClient.workflows.revert(vars.id, vars.versionNumber) };\n        case \"function\":\n          return { reverted: await apiClient.functions.revert(vars.id, vars.versionNumber) };\n        case \"endpoint\": {\n          // R-5: no SDK method for endpoint versions.\n          const res = await apiClient.request<RevertResult>({\n            method: \"POST\",\n            path: path`/${COLLECTION_PATH.endpoint}/${vars.id}/versions/${String(vars.versionNumber)}/revert`,\n          });\n          return res.body;\n        }\n      }\n    },\n    onSuccess: (_result, vars) => {\n      let definitionKey: readonly unknown[];\n      switch (kind) {\n        case \"function\":\n          definitionKey = functionKey(vars.id);\n          break;\n        case \"workflow\":\n          definitionKey = workflowKey(vars.id);\n          break;\n        case \"endpoint\":\n          definitionKey = endpointKey(vars.id);\n          break;\n      }\n      invalidateSavedCallable(qc, versionsKey(kind, vars.id), definitionKey);\n    },\n  });\n}\n\n/**\n * `POST /<collection>/:id/versions/:n/{invoke,run}`, an EMPTY JSON body — identical to that\n * kind's unversioned invoke/run route's success body, except the requested version's OWN\n * `impl`/definition runs instead of the live one (T5.3.1's wire contract table). Unlike\n * {@link useRevertMutation}, invoking changes no resource state, so it invalidates History ONLY\n * (`onSettled`, `historyKeys.root` — a version run is a run, failed ones included, like every other\n * run path) and no resource query — the caller (`VersionHistoryModal`) renders the mutation's own `data`/`error` state\n * directly, and that state is naturally cleared whenever the modal remounts for a different\n * version (`SettingsTool.tsx`'s `openVersion` gate fully unmounts/remounts it, never leaves it\n * mounted across a prop change).\n */\nexport function useInvokeVersionMutation(kind: VersionsKind) {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: async (vars: {\n      id: string;\n      versionNumber: number;\n    }): Promise<Record<string, unknown>> => {\n      // The workflow arm moves to `workflows.runVersion`. The FUNCTION arm (F-P4 / F-6) and the\n      // ENDPOINT arm (R-5) stay on `request()`: this hook's caller renders the raw invocation\n      // frame, and `functions.runVersion` unwraps the output like `functions.run` — it would drop\n      // the frame. The workflow arm returns only `{ runId, status }`, as the raw body did.\n      if (kind === \"workflow\") {\n        const run = await apiClient.workflows.runVersion(vars.id, vars.versionNumber, {});\n        // Project back to the server's own run-start body: the SDK adds `steps`/`terminal`/\n        // `httpStatus`, and `VersionHistoryModal` prints this value verbatim as JSON.\n        return { runId: run.runId, status: run.status };\n      }\n      const res = await apiClient.request<Record<string, unknown>>({\n        method: \"POST\",\n        path: path`/${COLLECTION_PATH[kind]}/${vars.id}/versions/${String(vars.versionNumber)}/${VERSION_INVOKE_VERB[kind]}`,\n        body: {},\n      });\n      return res.body;\n    },\n    onSettled: () => qc.invalidateQueries({ queryKey: historyKeys.root }),\n  });\n}\n","/**\n * The `constants` domain repo — account-level, read-only values set by an\n * administrator and referenced as `{{ const.<name> }}`. There is no write\n * route; the server derives the account from the token.\n */\nimport { useQuery } from \"@tanstack/react-query\";\nimport { useEmbedClient } from \"../draft/client-context.ts\";\n\nexport interface Constant {\n  name: string;\n  type: \"string\" | \"number\" | \"boolean\" | \"json\";\n  value: unknown;\n  description: string;\n  /** Computed by the server (e.g. `account_id`), not stored. */\n  derived: boolean;\n}\n\n/** Query key for the constants list. */\nexport function constantsKey() {\n  return [\"constants\"] as const;\n}\n\n/** The account's constants (read-only). */\nexport function useConstantsQuery() {\n  const apiClient = useEmbedClient();\n  return useQuery({\n    queryKey: constantsKey(),\n    queryFn: async () => {\n      const res = await apiClient.request<{ constants: Constant[] }>({\n        method: \"GET\",\n        path: \"/constants\",\n      });\n      return res.body.constants;\n    },\n  });\n}\n","/**\n * The `/<collection>/:id/spec` export repo (T3.3.1) — the Settings rail's Export\n * button. A NEW file, deliberately kept out of `repos/functions.ts` /\n * `repos/endpoints.ts` (T3.1.1 owns both), exactly as T3.2.1 put `/spec/import` in\n * its own `repos/spec-import.ts` for the same reason — the two nodes never\n * collide on the same file.\n *\n * **Goes through `W6WClient.request<T>()`, never `apiClient.console.*`.** There\n * is no SDK method for this route, exactly as `repos/spec-import.ts`'s own\n * docblock records for the sibling `/spec/import` route.\n *\n * `useSpecQuery` is gated on the caller's `enabled` flag (the export modal's own\n * open state) AND `collection !== null` — never on `ctx.kind` alone, and never\n * on mount: the contract pins that opening the Settings panel must issue ZERO\n * `/spec` requests, and exactly one fires per Export click.\n */\nimport { useQuery } from \"@tanstack/react-query\";\nimport { path } from \"@w6w/sdk\";\nimport { useEmbedClient } from \"../draft/client-context.ts\";\n\n/** The collections that carry a `/spec` export route — `specCollectionForKind`\n *  (`../lib/rail-settings.ts`) is the sole producer of this type's values. */\nexport type SpecCollection = \"functions\" | \"endpoints\" | \"workflows\";\n\n/**\n * Mirrors T2.1.1's `SpecDocument`, also mirrored by `repos/spec-import.ts`'s\n * `SpecImportDocument` for the sibling import route: the portable document a\n * `GET /<kind>/:id/spec` export produces. Not a bare `FunctionDef`/`EndpointDef`\n * — `id` is deleted server-side (`admin/spec.ts:96-108`) and connection/var\n * references ride as re-bindable `rebind` entries, never live ids.\n */\nexport interface SpecDocument {\n  specVersion: string;\n  kind: \"function\" | \"endpoint\" | \"workflow\";\n  callable: Record<string, unknown>;\n  rebind: unknown[];\n}\n\n/**\n * `GET /<collection>/:id/spec`. `collection` is `null` for a kind the Export\n * button never renders on (`specCollectionForKind`'s `connection`\n * arm) — passing `null` disables the query regardless of `enabled`, so a\n * caller need not re-derive that guard itself.\n */\nexport function useSpecQuery(collection: SpecCollection | null, id: string, enabled: boolean) {\n  const apiClient = useEmbedClient();\n  return useQuery({\n    queryKey: [\"spec\", collection, id],\n    queryFn: async () => {\n      const res = await apiClient.request<{ spec: SpecDocument }>({\n        method: \"GET\",\n        path: path`/${collection as SpecCollection}/${id}/spec`,\n      });\n      return res.body.spec;\n    },\n    enabled: enabled && collection !== null,\n  });\n}\n"],"names":["endpointKey","id","callableKey","functionKey","COLLECTION_PATH","VERSION_INVOKE_VERB","versionsKey","kind","versionKey","versionNumber","useVersionsQuery","enabled","apiClient","useEmbedClient","useQuery","path","useVersionQuery","n","usePublishMutation","qc","useQueryClient","useMutation","_result","useSetEnabledMutation","vars","useRevertMutation","definitionKey","workflowKey","invalidateSavedCallable","useInvokeVersionMutation","run","historyKeys","constantsKey","useConstantsQuery","useSpecQuery","collection"],"mappings":"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"}

package/dist/spec-import-SWOonsNr.js

@@ -0,0 +1,116 @@
+import { useQueryClient as c, useMutation as o, useQuery as r } from "@tanstack/react-query";
+import { path as m } from "@w6w/sdk";
+import { u } from "./client-context-CX61Bgw-.js";
+import { i as d } from "./spec-import-invalidation-D3retX4Q.js";
+function b(e) {
+  return e.shared ? e.sourceRepo == null ? "pending" : "synced" : "private";
+}
+function p(e) {
+  return ["documents", e];
+}
+function y(e, t) {
+  return ["documents", "detail", e, t];
+}
+function j(e, t, n = !0) {
+  const s = u();
+  return r({
+    queryKey: y(e, t),
+    queryFn: async () => await s.documents.get(e, { project: t }),
+    enabled: n
+  });
+}
+function F(e, t = !0) {
+  const n = u();
+  return r({
+    queryKey: p(e),
+    // Cast to DocWithProvenance[], same as useDocumentQuery above: the wire
+    // response already carries `shared`/`source*`/`syncedAt` (repo.list()
+    // serializes every document the same way repo.get() does), but the SDK's
+    // own `Doc` type doesn't declare them yet (D-5). Without this cast,
+    // DocumentsPage.tsx's list rows have no type-visible way to branch on
+    // `d.shared` the way DocumentDetailPage.tsx already does.
+    queryFn: async () => await n.documents.list({ project: e }),
+    enabled: t
+  });
+}
+function K() {
+  const e = u(), t = c();
+  return o({
+    mutationFn: (n) => e.documents.create(n.input, { project: n.project }),
+    onSuccess: () => t.invalidateQueries({ queryKey: ["documents"] })
+  });
+}
+function Q() {
+  const e = u(), t = c();
+  return o({
+    mutationFn: (n) => e.documents.update(n.id, n.patch, { project: n.project }),
+    onSuccess: () => t.invalidateQueries({ queryKey: ["documents"] })
+  });
+}
+function w() {
+  const e = u(), t = c();
+  return o({
+    mutationFn: (n) => e.documents.delete(n.id, { project: n.project }),
+    onSuccess: () => t.invalidateQueries({ queryKey: ["documents"] })
+  });
+}
+function D() {
+  const e = u(), t = c();
+  return o({
+    mutationFn: (n) => e.request({
+      method: "POST",
+      path: m`/documents/${n.id}/sync`,
+      query: { project: n.project }
+    }),
+    onSuccess: () => t.invalidateQueries({ queryKey: ["documents"] })
+  });
+}
+function a(e, t) {
+  return { ...e, project: t };
+}
+function l(e, t, n) {
+  return { ...a(e, t), selections: n };
+}
+function M(e) {
+  const t = u();
+  return o({
+    mutationFn: async (n) => (await t.request({
+      method: "POST",
+      path: "/spec/preview",
+      body: a(n, e)
+    })).body
+  });
+}
+function P(e, t) {
+  const n = u(), s = c();
+  return o({
+    mutationFn: async (i) => (await n.request({
+      method: "POST",
+      path: "/spec/import",
+      body: l(i.document, e, i.selections)
+    })).body,
+    // A row exists in every `201` outcome (T2.1.2 §E creates it even when
+    // some references stayed unresolved), so the list is stale either way —
+    // but ONLY the list the imported kind actually belongs to (AC-3): the
+    // unconditional `functionsKey` this used to invalidate left an imported
+    // Endpoint or Workflow's own list stale while pointlessly invalidating
+    // Functions.
+    onSuccess: (i) => d(s, i.kind, t, e)
+  });
+}
+export {
+  Q as a,
+  P as b,
+  M as c,
+  l as d,
+  a as e,
+  y as f,
+  b as g,
+  p as h,
+  w as i,
+  j,
+  F as k,
+  D as l,
+  K as u
+};
+//# sourceMappingURL=spec-import-SWOonsNr.js.map

package/dist/spec-import-SWOonsNr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-import-SWOonsNr.js","sources":["../src/repos/documents.ts","../src/repos/spec-import.ts"],"sourcesContent":["/**\n * The `documents` domain repo — wraps `@w6w/sdk`'s `client.documents.*` in\n * react-query (HITL-6). `QueryClientProvider` (`main.tsx`) stays the actual\n * cache; this module only centralizes the query-key factory and the\n * `queryFn`/`mutationFn` pairs so every page reads documents the same way.\n *\n * Documents are project-scoped (`documents.ts`'s `DocumentOptions.project`);\n * every mutation here invalidates the unscoped `[\"documents\"]` key, which\n * prefix-matches every project-scoped query key produced by\n * {@linkcode documentsKey} — the same invalidation shape `DocumentsPage.tsx`\n * used before this migration.\n */\nimport { useMutation, useQuery, useQueryClient } from \"@tanstack/react-query\";\nimport { path, type Doc, type DocumentCreateInput, type DocumentPatch } from \"@w6w/sdk\";\nimport { useEmbedClient } from \"../draft/client-context.ts\";\n\n/**\n * T1.1.1's wire shape for one document, pinned here ahead of that node\n * merging (this node is dispatched speculatively against it — see this\n * task's contract). `shared` and the six `source*`/`syncedAt` fields are all\n * additive over the SDK's own `Doc`, so a locally-created document simply\n * carries them as `null` (or `false` for `shared`) rather than omitting\n * them. Do not rename a field — the server produces these names verbatim.\n */\nexport interface DocWithProvenance extends Doc {\n  shared: boolean;\n  /** \"owner/name\" of the bound repository this document was pulled from. */\n  sourceRepo: string | null;\n  /** Repo-relative file path the document was pulled from. */\n  sourcePath: string | null;\n  /** The pulled file's content hash — NOT a commit SHA. */\n  sourceSha: string | null;\n  /** The repository's HEAD commit SHA at pull time — NOT a content hash. */\n  sourceRefSha: string | null;\n  /** Web link to the file; may be absent even when the rest of provenance is set. */\n  sourceUrl: string | null;\n  /** ISO-8601. Stamped at the document's last actual change, not at every sync. */\n  syncedAt: string | null;\n}\n\n/**\n * Which provenance state `DocumentDetailPage.tsx`'s \"Source\" card should\n * render for `doc`. `shared` (not `sourceRepo`) is the gate: a shared\n * document whose provenance columns haven't been stamped yet (any document\n * synced before this feature shipped, until its next real-content sync —\n * tier-1 \"unchanged\" syncs never restamp provenance) is still shared, and\n * must say so, distinct from a genuinely private document.\n *\n * - `\"private\"` — `doc.shared` is false. No card.\n * - `\"pending\"` — shared, but `sourceRepo` hasn't been stamped yet.\n * - `\"synced\"` — shared, with full provenance available.\n */\nexport function documentProvenanceState(doc: DocWithProvenance): \"private\" | \"pending\" | \"synced\" {\n  if (!doc.shared) return \"private\";\n  return doc.sourceRepo == null ? \"pending\" : \"synced\";\n}\n\n/** Query key for a documents list, optionally scoped to a project. */\nexport function documentsKey(projectId?: string) {\n  return [\"documents\", projectId] as const;\n}\n\n/**\n * Query key for a single document, scoped to a project (mirrors\n * {@linkcode useDocumentsQuery}'s fix at :72-79/:80-87 below — `projectId`\n * belongs in the key itself, not just the `queryFn`, so a render where the\n * key was cached under `projectId === undefined` genuinely changes key once\n * `ProjectContext` resolves the real one, instead of reusing the same cache\n * entry — and its `retry: false` wrong-project 404 — forever). Still sits\n * under the bare `[\"documents\"]` prefix every mutation below invalidates, so\n * an edit/delete refreshes this page too — `\"detail\"` keeps it from\n * colliding with {@linkcode documentsKey}'s own `[\"documents\", projectId]`\n * shape.\n */\nexport function documentKey(id: string, projectId?: string) {\n  return [\"documents\", \"detail\", id, projectId] as const;\n}\n\n/**\n * A single document by id, cast to {@link DocWithProvenance} (D-5): the SDK's\n * `Doc` doesn't model T1.1.1's provenance fields yet, and this repo is not\n * the place to fork or extend `@w6w/sdk` (D-4). The `project` option is\n * passed exactly as {@linkcode useDocumentsQuery} passes it — a document in a\n * non-default project 404s without it. `enabled` defaults `true` to preserve\n * that unscoped fallback for a caller that genuinely wants it — same as\n * {@linkcode useDocumentsQuery}'s own `enabled` doc comment below — a\n * project-scoped page should instead pass `enabled: projectId != null` so it\n * never queries (and never renders) against the wrong project while\n * `ProjectContext`'s own project list is still resolving.\n */\nexport function useDocumentQuery(id: string, projectId?: string, enabled = true) {\n  const apiClient = useEmbedClient();\n  return useQuery({\n    queryKey: documentKey(id, projectId),\n    queryFn: async () =>\n      (await apiClient.documents.get(id, { project: projectId })) as DocWithProvenance,\n    enabled,\n  });\n}\n\n/**\n * The current project's documents (or the tenant default when unscoped).\n * `enabled` defaults `true` to preserve that unscoped fallback for a caller\n * that genuinely wants it — a project-scoped page should instead pass\n * `enabled: projectId != null` so it never queries (and never renders)\n * against the wrong project while `ProjectContext`'s own project list is\n * still resolving.\n */\nexport function useDocumentsQuery(projectId?: string, enabled = true) {\n  const apiClient = useEmbedClient();\n  return useQuery({\n    queryKey: documentsKey(projectId),\n    // Cast to DocWithProvenance[], same as useDocumentQuery above: the wire\n    // response already carries `shared`/`source*`/`syncedAt` (repo.list()\n    // serializes every document the same way repo.get() does), but the SDK's\n    // own `Doc` type doesn't declare them yet (D-5). Without this cast,\n    // DocumentsPage.tsx's list rows have no type-visible way to branch on\n    // `d.shared` the way DocumentDetailPage.tsx already does.\n    queryFn: async () =>\n      (await apiClient.documents.list({ project: projectId })) as DocWithProvenance[],\n    enabled,\n  });\n}\n\nexport function useCreateDocumentMutation() {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (vars: { input: DocumentCreateInput; project?: string }) =>\n      apiClient.documents.create(vars.input, { project: vars.project }),\n    onSuccess: () => qc.invalidateQueries({ queryKey: [\"documents\"] }),\n  });\n}\n\nexport function useUpdateDocumentMutation() {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (vars: { id: string; patch: DocumentPatch; project?: string }) =>\n      apiClient.documents.update(vars.id, vars.patch, { project: vars.project }),\n    onSuccess: () => qc.invalidateQueries({ queryKey: [\"documents\"] }),\n  });\n}\n\nexport function useDeleteDocumentMutation() {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (vars: { id: string; project?: string }) =>\n      apiClient.documents.delete(vars.id, { project: vars.project }),\n    onSuccess: () => qc.invalidateQueries({ queryKey: [\"documents\"] }),\n  });\n}\n\n/**\n * Re-pulls a shared document from its bound repository (\"Sync\" button, T2.1.4)\n * — `POST /documents/:id/sync` (T3.1.1). No SDK method exists for this route\n * yet (D-4/D-5), so this goes through `apiClient.request()` directly, same\n * escape hatch `repo-sync.ts`'s `useSyncRepoNowMutation` uses. The document\n * routes are project-scoped by QUERY param, not a path segment (unlike\n * `repo-binding`'s `/projects/:id/...` shape), so `project` travels in\n * `query`, mirroring {@linkcode useDocumentQuery}'s own `{ project: … }` use.\n */\nexport function useSyncDocumentMutation() {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (vars: { id: string; project?: string }) =>\n      apiClient.request<{ document: DocWithProvenance }>({\n        method: \"POST\",\n        path: path`/documents/${vars.id}/sync`,\n        query: { project: vars.project },\n      }),\n    onSuccess: () => qc.invalidateQueries({ queryKey: [\"documents\"] }),\n  });\n}\n","/**\n * The `/spec/import` repo (T3.2.1). A NEW file, deliberately kept out of\n * `repos/functions.ts` / `repos/endpoints.ts` (T3.1.1 owns both) so the two\n * nodes never collide on the same file.\n *\n * **Every operation here goes through `W6WClient.request<T>()`, never\n * `apiClient.console.*`.** `T2.1.2`'s `inputs.touch` has no\n * `packages/wrappers` entry — there is no SDK method for this route — so\n * `request()` is the client's public escape hatch, exactly as\n * `repos/vars.ts`'s own docblock explains for the same reason.\n *\n * The posted `document` is forwarded to the server as-is (spread, never edited):\n * this module adds only `project` (and, on import, `selections`) beside it, validates nothing, and — this is the mechanism pin note 1\n * of the contract states from the side a wrong implementation must break —\n * never falls back to the sibling whole-definition save mutation\n * `FunctionIdentityModal.tsx` uses, on any response. `/spec/import` is where\n * the server-side sealed-secret walker lives (T2.1.2 §B runs\n * `assertNoSecretEnvelopes` over the WHOLE supplied body before any write);\n * a \"helpful\" fallback to that other write path would route a pasted\n * document straight around that check.\n *\n * T1.2.1 generalizes this over all three kinds: `onSuccess` invalidates the\n * ONE list key the imported document's own kind reads (`result.kind`, which\n * the server always echoes), never an unconditional `functionsKey`. The\n * decision of which key that is lives in `../lib/spec-import-invalidation.ts`\n * (a pure, `node --test`-loadable module). The three list keys are INJECTED by the host\n * (`listKeys`): Studio's `functionsKey`/`endpointsKey` live in its own `repos/callables`.\n */\nimport { useMutation, useQueryClient } from \"@tanstack/react-query\";\nimport { useEmbedClient } from \"../draft/client-context.ts\";\nimport type { PreviewDependency, Selection, SpecDependency } from \"../lib/import-bindings.ts\";\nimport {\n  type SpecImportListKeys,\n  invalidateImportedCallable,\n} from \"../lib/spec-import-invalidation.ts\";\n\n/**\n * Mirrors `T2.1.1`'s `SpecDocument` (`T2.1.1.contract.md:134-141`): the\n * portable document a `GET /<kind>/:id/spec` export produces and this\n * route consumes. Not a bare `FunctionDef` — connection/var references ride\n * as re-bindable `rebind` entries, never live ids.\n */\nexport interface SpecImportDocument {\n  specVersion: string;\n  kind: \"function\" | \"endpoint\" | \"workflow\";\n  callable: Record<string, unknown>;\n  rebind: unknown[];\n}\n\n/** One reference site's outcome (T2.1.2 §E's `SpecImportReferenceReport`). */\nexport interface SpecImportReferenceReport {\n  path: string;\n  kind: string;\n  resolved: boolean;\n  /** Present only when `resolved` is `true`. */\n  boundTo?: string;\n  /** Present only when `resolved` is `false`. */\n  reason?: string;\n}\n\n/** The `201` body `POST /spec/import` returns (T2.1.2 §E). */\nexport interface SpecImportResult {\n  kind: \"function\" | \"endpoint\" | \"workflow\";\n  callable: { id: string; key?: string; name?: string };\n  references: SpecImportReferenceReport[];\n  dependencies?: ImportDependencyStatus[];\n}\n\n/** IF-1 `POST /spec/preview` result: one entry per dependency, with server options + suggestion. */\nexport interface PreviewResult {\n  kind: \"function\" | \"endpoint\" | \"workflow\";\n  dependencies: PreviewDependency[];\n  references?: SpecImportReferenceReport[];\n}\n\n/** One dependency's outcome in the import result (IF-1 `dependencies` status[]). */\nexport interface ImportDependencyStatus {\n  key: string;\n  kind?: SpecDependency[\"kind\"];\n  name?: string;\n  status: \"bound\" | \"created\" | \"unconfigured\" | string;\n  boundTo?: string;\n  reason?: string;\n}\n\n/** The preview request body: the document plus the host project, sent explicitly. */\nexport function buildPreviewBody(\n  document: Record<string, unknown>,\n  project: string | undefined,\n): Record<string, unknown> {\n  return { ...document, project };\n}\n\n/** The import request body: the preview body plus the FULL selections map (`unconfigured` included). */\nexport function buildImportBody(\n  document: Record<string, unknown>,\n  project: string | undefined,\n  selections: Record<string, Selection>,\n): Record<string, unknown> {\n  return { ...buildPreviewBody(document, project), selections };\n}\n\n/**\n * `POST /spec/preview` (IF-1). Read-only on the server; a failure rejects the mutation and the\n * caller blocks Create — there is NO fallback to posting the document verbatim to `/spec/import`.\n */\nexport function useSpecPreviewMutation(project: string | undefined) {\n  const apiClient = useEmbedClient();\n  return useMutation({\n    mutationFn: async (document: Record<string, unknown>) => {\n      const res = await apiClient.request<PreviewResult>({\n        method: \"POST\",\n        path: \"/spec/preview\",\n        body: buildPreviewBody(document, project),\n      });\n      return res.body;\n    },\n  });\n}\n\n/**\n * `POST /spec/import`. Success is always `201` — including a partially\n * resolved import (T2.1.2 §E: \"report, never fail silently\"). This mutation\n * resolves on ANY `201`; branching on `references.every(r => r.resolved)` is\n * the caller's job (A5), never this repo's.\n *\n * `project` is the caller's current project — only the workflow arm reads it\n * (`listKeys.workflowsKey(project)`), but every caller passes it uniformly rather than branching on kind itself; see\n * `../lib/spec-import-invalidation.ts` for why the key differs by kind.\n */\nexport function useImportSpecMutation(project: string | undefined, listKeys: SpecImportListKeys) {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: async (input: {\n      document: Record<string, unknown>;\n      selections: Record<string, Selection>;\n    }) => {\n      const res = await apiClient.request<SpecImportResult>({\n        method: \"POST\",\n        path: \"/spec/import\",\n        body: buildImportBody(input.document, project, input.selections),\n      });\n      return res.body;\n    },\n    // A row exists in every `201` outcome (T2.1.2 §E creates it even when\n    // some references stayed unresolved), so the list is stale either way —\n    // but ONLY the list the imported kind actually belongs to (AC-3): the\n    // unconditional `functionsKey` this used to invalidate left an imported\n    // Endpoint or Workflow's own list stale while pointlessly invalidating\n    // Functions.\n    onSuccess: (result) => invalidateImportedCallable(qc, result.kind, listKeys, project),\n  });\n}\n"],"names":["documentProvenanceState","doc","documentsKey","projectId","documentKey","id","useDocumentQuery","enabled","apiClient","useEmbedClient","useQuery","useDocumentsQuery","useCreateDocumentMutation","qc","useQueryClient","useMutation","vars","useUpdateDocumentMutation","useDeleteDocumentMutation","useSyncDocumentMutation","path","buildPreviewBody","document","project","buildImportBody","selections","useSpecPreviewMutation","useImportSpecMutation","listKeys","input","result","invalidateImportedCallable"],"mappings":"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"}

package/dist/{step-tests-CivICmTq.js → step-tests-B4E4W3ly.js}

@@ -1,18 +1,19 @@
-const o = (s, e) => ["stepTests", s, e];
-function r(s, e, t) {
+const o = (s, e) => ["stepTests", s, e], r = (s) => ["stepTests", s];
+function p(s, e, t) {
   return s.console.stepTests.list(e, t);
 }
 function c(s, e, t, n) {
   return s.console.stepTests.save(e, t, n);
 }
-function p(s, e, t, n) {
+function T(s, e, t, n) {
   return s.console.stepTests.recordRun(e, t, n).then(() => {
   });
 }
 export {
   o as a,
-  r as l,
-  p as r,
-  c as s
+  p as l,
+  T as r,
+  c as s,
+  r as w
 };
-//# sourceMappingURL=step-tests-CivICmTq.js.map
+//# sourceMappingURL=step-tests-B4E4W3ly.js.map

package/dist/step-tests-B4E4W3ly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-tests-B4E4W3ly.js","sources":["../src/repos/step-tests.ts"],"sourcesContent":["/**\n * The `step tests` domain repo — wraps `@w6w/sdk`'s `client.console.stepTests.*`\n * (T2.6.1). Unlike every other domain migrated so far, its one read\n * (`listStepTests`) exports ONLY a query-key factory + a plain, explicit-client\n * fetcher — no hook. `WorkflowsPage.tsx`'s `stepTestsQueries` (`useQueries`\n * looping over `testGatedSteps`) is the sole read call site and cannot call a\n * hook inside `.map(...)` (Rules of Hooks); no other studio call site needs a\n * hook form. Mirrors `repos/apps.ts`'s \"build what's needed\" discipline,\n * applied to a query for the first time (every prior no-hook export in this\n * project was a mutation).\n *\n * None of these methods take a `project` scoping parameter — step tests are\n * scoped by workflow/tenant server-side, mirroring `console.connections`'s\n * own host shape.\n */\nimport type { W6WClient } from \"@w6w/sdk\";\nimport type { StepTest } from \"@w6w/sdk/console\";\n\nexport type { StepTest } from \"@w6w/sdk/console\";\n\n// ── step tests (list) — key + plain fetcher ONLY, no hook. See header. ────\n\nexport const stepTestsKey = (workflowId: string, stepId: string) =>\n  [\"stepTests\", workflowId, stepId] as const;\n\n/** The prefix of every {@link stepTestsKey} of one workflow — invalidates all its steps at once. */\nexport const workflowStepTestsKey = (workflowId: string) => [\"stepTests\", workflowId] as const;\n\nexport function listStepTests(\n  client: W6WClient,\n  workflowId: string,\n  stepId: string,\n): Promise<StepTest[]> {\n  return client.console.stepTests.list(workflowId, stepId);\n}\n\n// ── mutations (facade-only) ─────────────────────────────────────────────\n\nexport function saveStepTest(\n  client: W6WClient,\n  workflowId: string,\n  stepId: string,\n  body: { name?: string; input: Record<string, unknown>; with: Record<string, unknown> },\n): Promise<StepTest> {\n  return client.console.stepTests.save(workflowId, stepId, body);\n}\n\n/** Same void-discard reasoning as `recordTestRun` above — see that function's doc comment. */\nexport function recordStepTestRun(\n  client: W6WClient,\n  workflowId: string,\n  stepId: string,\n  body: {\n    stepTestId?: string | null;\n    status: string;\n    input?: unknown;\n    output?: unknown;\n    error?: unknown;\n    meta?: unknown;\n  },\n): Promise<void> {\n  return client.console.stepTests.recordRun(workflowId, stepId, body).then(() => undefined);\n}\n"],"names":["stepTestsKey","workflowId","stepId","workflowStepTestsKey","listStepTests","client","saveStepTest","body","recordStepTestRun"],"mappings":"AAsBO,MAAMA,IAAe,CAACC,GAAoBC,MAC/C,CAAC,aAAaD,GAAYC,CAAM,GAGrBC,IAAuB,CAACF,MAAuB,CAAC,aAAaA,CAAU;AAE7E,SAASG,EACdC,GACAJ,GACAC,GACqB;AACrB,SAAOG,EAAO,QAAQ,UAAU,KAAKJ,GAAYC,CAAM;AACzD;AAIO,SAASI,EACdD,GACAJ,GACAC,GACAK,GACmB;AACnB,SAAOF,EAAO,QAAQ,UAAU,KAAKJ,GAAYC,GAAQK,CAAI;AAC/D;AAGO,SAASC,EACdH,GACAJ,GACAC,GACAK,GAQe;AACf,SAAOF,EAAO,QAAQ,UAAU,UAAUJ,GAAYC,GAAQK,CAAI,EAAE,KAAK,MAAA;AAAA,GAAe;AAC1F;"}

package/dist/{use-callable-draft-DsALnSfF.js → use-callable-draft-DCauHt5o.js}

@@ -2,7 +2,7 @@ import { useQueryClient as be } from "@tanstack/react-query";
 import { useState as b, useRef as p, useCallback as f, useEffect as T, useMemo as Y } from "react";
 import { u as Ee, i as Re, c as De, a as Te } from "./callables-tOlflvbl.js";
 import { c as Z, p as Ce, d as Ae } from "./settings-rail--GdRMusb.js";
-import { c as Oe, r as xe, n as Ne, i as Pe } from "./use-workflow-draft-DzAyUeA6.js";
+import { c as Oe, r as xe, n as Ne, i as Pe } from "./use-workflow-draft-l3P5KZzw.js";
 import { u as Je } from "./client-context-CX61Bgw-.js";
 import { u as qe } from "./draft-registry-YF0tqNN0.js";
 function le(s, E, h) {
@@ -268,4 +268,4 @@ export {
   Me as b,
   ie as u
 };
-//# sourceMappingURL=use-callable-draft-DsALnSfF.js.map
+//# sourceMappingURL=use-callable-draft-DCauHt5o.js.map