@w6w/embed 0.1.1 → 0.2.1

package/dist/repos/workflows.d.ts

@@ -0,0 +1,138 @@
+import { UseMutationResult } from '@tanstack/react-query';
+import { W6WClient, WorkflowRunResult } from '@w6w/sdk';
+import { RunState } from '@w6w/sdk/console';
+export type { RunState, RunSummary } from '@w6w/sdk/console';
+export type { WorkflowStatus, WorkflowSummary } from '@w6w/sdk';
+export declare const workflowsKey: (project?: string) => readonly ["workflows", string | undefined];
+export declare function listWorkflows(client: W6WClient, project?: string): Promise<import('@w6w/sdk').WorkflowSummary[]>;
+export declare function useWorkflowsQuery(project?: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<import('@w6w/sdk').WorkflowSummary[]>, Error>;
+export declare const workflowKey: (id: string) => readonly ["workflow", string];
+export declare function getWorkflow(client: W6WClient, id: string): Promise<import('@w6w/sdk').WorkflowDetail>;
+export declare function useWorkflowQuery(id: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<import('@w6w/sdk').WorkflowDetail>, Error>;
+/**
+ * A missing `project` here is not "unscoped" the way a read can legitimately
+ * be — the write would silently land in the account's default project
+ * instead of the one the caller is looking at. Both mutations refuse rather
+ * than risk that; `WorkflowsPage.tsx`'s own `projectId != null` gate on
+ * `useWorkflowsQuery` should mean `project` is always set by the time either
+ * of these can actually be invoked from the UI, but the guard costs nothing.
+ */
+export declare function useCreateWorkflowMutation(project?: string): UseMutationResult<{
+    workflow: {
+        id: string;
+        name: string;
+        key: string | null;
+    };
+    scheduled: boolean;
+    updatedAt: string;
+}, Error, unknown, unknown>;
+export declare function useSaveWorkflowMutation(project?: string): UseMutationResult<{
+    workflow: {
+        id: string;
+        name: string;
+        key: string | null;
+    };
+    scheduled: boolean;
+    updatedAt: string;
+}, Error, {
+    definition: unknown;
+    ifUnmodifiedSince: string | null;
+}, unknown>;
+export declare function useArchiveWorkflowMutation(): UseMutationResult<import('@w6w/sdk').WorkflowDefinition, Error, string, unknown>;
+export declare function useDeleteWorkflowMutation(): UseMutationResult<void, Error, string, unknown>;
+export declare const runsKey: (workflowId: string) => readonly ["runs", string];
+export declare function useRunsQuery(workflowId: string): import('@tanstack/react-query').UseQueryResult<NoInfer<import('@w6w/sdk/console').RunSummary[]>, Error>;
+/**
+ * Start a run and poll it to a terminal state.
+ *
+ * `input` is the run's START PAYLOAD, and it is a different thing from
+ * `variables`: the server hands it to the entry `@w6w/trigger` node as that
+ * node's own output, which is what makes `{{ steps.<trigger>.output.<field> }}`
+ * resolve in a real run. Omitted, that node outputs `{}` and every reference to
+ * a trigger field resolves to the empty string — the failure mode filed as
+ * `.ai/projects/backlog/26-07-29-01-trigger-run-payload.md`, where a step tests
+ * green and then does nothing in production. `variables` seeds `vars.*` and
+ * reaches the trigger node not at all.
+ *
+ * Goes through the typed `client.workflows.run()` with
+ * `allowUnpublished: true`: this call site always runs the STORED draft, and
+ * the server exempts a caller that sets the flag from the publish gate
+ * (`packages/api/run-workflow.ts`'s `enqueueRun`). The SDK's result is the flat
+ * run body, so the `runId` used to poll comes off `res.runId`.
+ */
+export declare function runWorkflow(client: W6WClient, id: string, variables: Record<string, unknown>, input?: Record<string, unknown>): Promise<RunState>;
+export declare function useRunWorkflowMutation(): UseMutationResult<RunState, Error, {
+    id: string;
+    variables: Record<string, unknown>;
+    input?: Record<string, unknown>;
+}, unknown>;
+/**
+ * Run a Workflow SYNCHRONOUSLY — the `W6WApi.runWorkflow` facade member's
+ * backing function (the Workflows tab's Test stage, D-11/D-15(c)). A sibling
+ * of {@link runWorkflow}, NOT a replacement: that function's enqueue-then-poll
+ * shape is the studio-wide "Run this workflow" action and stays exactly as it
+ * is. This one instead sends `wait: true` on the SAME base `client.workflows
+ * .run` call already published (`?wait=true` — the server polls internally,
+ * up to its own timeout) — zero new server code, and no second poll loop:
+ * there is no `pollRunToTerminal` here at all. `terminal`/`httpStatus` on the
+ * result distinguish "finished in time" (`200`) from "still going when the
+ * server's own wait timed out" (`202`, a legitimate outcome, not an error).
+ */
+export declare function runWorkflowSync(client: W6WClient, id: string, variables: Record<string, unknown>, input?: Record<string, unknown>): Promise<WorkflowRunResult>;
+/**
+ * T2.1.1 — the ENQUEUE half only: starts a run and returns its handle
+ * immediately, without polling it to terminal. A genuine sibling of
+ * {@link runWorkflow}, NOT a replacement — that function's "enqueue, then
+ * block to a terminal result" shape is what `WorkflowDetailPage.tsx`'s "Run
+ * now" panel is built on and stays exactly as it is. This one is for a host
+ * that wants the `runId` right away so it can poll it live itself (the
+ * visual editor's canvas + execution log panel) — see {@link useLiveRunQuery}.
+ *
+ * Like {@link runWorkflow}, this calls `client.workflows.run()` with
+ * `allowUnpublished: true` unconditionally. Only `{ runId }` is returned, so
+ * callers keep reading `runId` off the resolved value exactly as before.
+ */
+export declare function startWorkflowRun(client: W6WClient, id: string, variables: Record<string, unknown>, input?: Record<string, unknown>): Promise<{
+    runId: string;
+}>;
+export declare function useStartRunMutation(): UseMutationResult<{
+    runId: string;
+}, Error, {
+    id: string;
+    variables: Record<string, unknown>;
+    input?: Record<string, unknown>;
+}, unknown>;
+/** What `client.workflows.cancel` resolves to. Named here because the SDK's root entry does not
+ *  export its `WorkflowCancelResult`: an inferred return type would name it and `vite-plugin-dts`
+ *  would skip this whole file (TS2742), leaving every `./repos` declaration out of the tarball. */
+export type WorkflowCancelResult = Awaited<ReturnType<W6WClient["workflows"]["cancel"]>>;
+/**
+ * T2.1.1/A6 — cancel a queued or running run. `client.workflows.cancel`
+ * itself never claims the run has stopped (its own doc comment: a `202`
+ * means the request was RECORDED, not that the run finished) — the caller
+ * keeps polling {@link useLiveRunQuery} until the run actually reaches a
+ * terminal status. See `../lib/workflow-live-run.ts`'s `classifyCancelError`
+ * for how a `409 run_not_cancelable` (the run beat the cancel to the finish
+ * line) is told apart from a real failure.
+ */
+export declare function cancelWorkflowRun(client: W6WClient, runId: string): Promise<WorkflowCancelResult>;
+export declare function useCancelRunMutation(): UseMutationResult<WorkflowCancelResult, Error, string>;
+/** The single-shot half of {@link useLiveRunQuery} — a thin, directly
+ *  testable wrapper around `client.console.workflows.getRun`, so the polling
+ *  config below can be pinned without needing to render a hook. */
+export declare function getRunState(client: W6WClient, runId: string): Promise<RunState>;
+/** Query key for one run's live state — distinct from {@link runsKey}, which
+ *  is the workflow's run LIST. */
+export declare const runStateKey: (runId: string) => readonly ["run", string];
+/**
+ * T2.1.1/A2/A3 — poll one run's live state at a fixed 500ms interval,
+ * stopping once it reaches a terminal status ({@link shouldContinuePolling},
+ * `../lib/workflow-live-run.ts`). A genuine sibling of `pollRunToTerminal`
+ * (`../lib/workflow-poll.ts`) using the SAME underlying SDK call
+ * (`client.console.workflows.getRun`), but publishing every intermediate
+ * `RunState` to its caller via TanStack Query's own `data` — unlike
+ * `pollRunToTerminal`, which discards every non-terminal result and hands
+ * back only the last one. `runId === null` disables the query entirely (no
+ * run started yet, or the page navigated to a different workflow).
+ */
+export declare function useLiveRunQuery(runId: string | null): import('@tanstack/react-query').UseQueryResult<NoInfer<RunState>, Error>;

package/dist/repos.mjs

@@ -1,94 +1,180 @@
 "use client";
-import { C as s, E as t, H as u, I as o, R as r, S as n, c as i, a as l, b as y, d as c, e as S, f as M, g as R, h as f, i as w, j as E, k as d, l as k, m as p, n as D, o as m, p as v, q as I, r as Q, s as T, t as K, u as W, v as L, w as _, x as C, y as g, z as A, A as h, B as H, D as P, F as b, G as F, J as O, K as V, L as x, M as N, N as U, O as B, P as Y, Q as q, T as j, U as G, V as Z, W as z, X as J, Y as X, Z as $, _ as aa, $ as ea, a0 as sa, a1 as ta, a2 as ua, a3 as oa, a4 as ra, a5 as na, a6 as ia, a7 as la, a8 as ya, a9 as ca, aa as Sa, ab as Ma, ac as Ra, ad as fa, ae as wa, af as Ea, ag as da, ah as ka, ai as pa, aj as Da, ak as ma, al as va, am as Ia, an as Qa, ao as Ta, ap as Ka, aq as Wa, ar as La, as as _a, at as Ca, au as ga, av as Aa, aw as ha, ax as Ha, ay as Pa } from "./spec-import-HgO7ZkLZ.js";
+import { E as a, H as t, R as u, S as o, c as n, a as r, d as i, b as l, e as c, f as y, g as p, h as S, i as d, j as M, k as f, l as v, m as C, n as E, o as R, p as Q, q as b, r as T, s as A, t as m, u as K, v as F, w as I, x as k, y as D, z as g, A as h, B as w, C as _, D as x, F as L, G as N, I as W, J as O, K as P, L as H, M as V, N as U, O as j, P as B, Q as G, T as Y, U as q, V as z, W as Z, X as J, Y as X, Z as $, _ as ee } from "./spec-import-CjmxyZDR.js";
+import { u as ae, a as te, b as ue, c as oe, d as ne, e as re, f as ie, v as le, g as ce } from "./spec-export-Cf3VQSQS.js";
+import { l as pe, r as Se, s as de, a as Me } from "./step-tests-CivICmTq.js";
+import { a as ve, b as Ce, g as Ee, c as Re, u as Qe, d as be, e as Te, f as Ae, h as me, i as Ke } from "./apps-1FNUwbGv.js";
+import { l as Ie, s as ke, a as De, u as ge, b as he, c as we, d as _e, e as xe, f as Le, g as Ne, h as We, i as Oe, v as Pe } from "./vault-BSEWhMYC.js";
+import { a as Ve, c as Ue, b as je, d as Be, e as Ge, f as Ye, g as qe, h as ze, i as Ze, j as Je, l as Xe, s as $e, u as es, k as ss, m as as, n as ts, o as us } from "./callables-3mFrMVG_.js";
+import { C as ns, E as rs, F as is, I as ls, d as cs, e as ys, a as ps, f as Ss, b as ds, g as Ms, c as fs, i as vs, h as Cs, j as Es, l as Rs, n as Qs, k as bs, u as Ts, m as As, o as ms, p as Ks, q as Fs, r as Is, s as ks, t as Ds, v as gs, w as hs, x as ws, y as _s, z as xs, A as Ls } from "./endpoints-B2ynbZo-.js";
+import { c as Ws, a as Os, b as Ps, d as Hs, g as Vs, l as Us, e as js, u as Bs, f as Gs, h as Ys, i as qs, j as zs, k as Zs, m as Js } from "./connections-CjjYeRqb.js";
+import { c as $s, d as ea, l as sa, a as aa, r as ta, s as ua, t as oa, u as na, b as ra, e as ia, f as la, g as ca, h as ya, i as pa } from "./api-calls--JHyif6a.js";
+import { SECRET_MASK as da } from "@w6w/sdk/console";
 export {
-  s as CALLABLE_DESCRIPTORS,
-  t as EMPTY_HISTORY_FILTERS,
-  u as HISTORY_PAGE_SIZE,
-  o as ID_ALPHABET,
-  r as RUN_FAILED_NO_REASON,
-  n as STEP_FAILED_NO_REASON,
-  i as callableKey,
-  l as cancelWorkflowRun,
-  y as classifyCancelError,
-  c as descriptorFor,
-  S as documentKey,
-  M as documentProvenanceState,
-  R as documentsKey,
-  f as filtersFromSearch,
-  w as filtersToSearch,
-  E as getExecutionDetail,
+  ns as CALLABLE_DESCRIPTORS,
+  a as EMPTY_HISTORY_FILTERS,
+  rs as ENDPOINT_MANIFEST_VERSION,
+  is as FUNCTION_MANIFEST_VERSION,
+  t as HISTORY_PAGE_SIZE,
+  ls as ID_ALPHABET,
+  u as RUN_FAILED_NO_REASON,
+  da as SECRET_MASK,
+  o as STEP_FAILED_NO_REASON,
+  ve as appActionsKey,
+  Ce as appKey,
+  Ve as archiveCallable,
+  Ue as callableCollection,
+  je as callableHistoryRoute,
+  Be as callableKey,
+  Ge as callableListKey,
+  Ye as callablePath,
+  qe as callableRoute,
+  n as cancelWorkflowRun,
+  r as classifyCancelError,
+  Ws as connectionKey,
+  Os as connectionsForAppKey,
+  Ps as connectionsKey,
+  Hs as createConnection,
+  $s as createSavedTest,
+  ze as deleteCallable,
+  ea as deleteSavedTest,
+  cs as descriptorFor,
+  i as documentKey,
+  l as documentProvenanceState,
+  c as documentsKey,
+  ys as endpointKey,
+  ps as endpointsKey,
+  y as filtersFromSearch,
+  p as filtersToSearch,
+  Ss as functionKey,
+  ds as functionsKey,
+  Ee as getApp,
+  Re as getAppActions,
+  Ze as getCallable,
+  Vs as getConnection,
+  Ms as getEndpoint,
+  S as getExecutionDetail,
+  fs as getFunction,
   d as getHistory,
-  k as getHistoryStats,
-  p as getRunState,
-  D as getWorkflow,
-  m as historyKeys,
-  v as historyRequestQuery,
-  I as invalidateSavedCallable,
-  Q as isRunInFlight,
-  T as latestFixtureInput,
-  K as listSecrets,
-  W as listStepTests,
-  L as listWorkflows,
-  _ as mapRunStateToLogSteps,
-  C as newCallableId,
-  g as newId,
+  M as getHistoryStats,
+  f as getRunState,
+  v as getWorkflow,
+  C as historyKeys,
+  E as historyRequestQuery,
+  Je as invalidateSavedCallable,
+  vs as invokeEndpoint,
+  Cs as invokeFunction,
+  Es as isEndpointDraft,
+  R as isRunInFlight,
+  Q as latestFixtureInput,
+  Xe as listCallables,
+  Us as listConnections,
+  js as listConnectionsForApp,
+  Rs as listFunctions,
+  sa as listSavedTests,
+  Ie as listSecrets,
+  pe as listStepTests,
+  aa as listTestRuns,
+  b as listWorkflows,
+  T as mapRunStateToLogSteps,
+  Qs as newCallableId,
+  bs as newId,
   A as pollRunToTerminal,
-  h as recordStepTestRun,
-  H as resolveHeaderRunInput,
-  P as runButtonLabel,
-  b as runLevelErrors,
-  F as runStateKey,
-  O as runWorkflow,
-  V as runWorkflowSync,
-  x as runsKey,
-  N as saveStepTest,
-  U as sealSecret,
-  B as secretsKey,
-  Y as shouldContinuePolling,
-  q as startWorkflowRun,
-  j as stepTestsKey,
-  G as toLogError,
-  Z as useArchiveWorkflowMutation,
-  z as useCancelRunMutation,
-  J as useCreateDocumentMutation,
-  X as useCreateSecretMutation,
-  $ as useCreateVarMutation,
-  aa as useCreateWorkflowMutation,
-  ea as useDeleteDocumentMutation,
-  sa as useDeleteSecretMutation,
-  ta as useDeleteVarMutation,
-  ua as useDeleteWorkflowMutation,
-  oa as useDocumentQuery,
-  ra as useDocumentsQuery,
-  na as useExecutionDetailQuery,
-  ia as useHasExecutedQuery,
-  la as useHistoryQuery,
-  ya as useHistoryStatsQuery,
-  ca as useImportSpecMutation,
-  Sa as useInvokeVersionMutation,
-  Ma as useLiveRunQuery,
-  Ra as usePublishMutation,
-  fa as useRevertMutation,
-  wa as useRunWorkflowMutation,
-  Ea as useRunsQuery,
-  da as useSaveWorkflowMutation,
-  ka as useSealSecret,
-  pa as useSecretsQuery,
-  Da as useSetEnabledMutation,
-  ma as useStartRunMutation,
-  va as useSyncDocumentMutation,
-  Ia as useUpdateDocumentMutation,
-  Qa as useUpdateSecretMutation,
-  Ta as useUpdateVarMutation,
-  Ka as useVarsQuery,
-  Wa as useVersionQuery,
-  La as useVersionsQuery,
-  _a as useWorkflowQuery,
-  Ca as useWorkflowsQuery,
-  ga as varsKey,
-  Aa as versionKey,
-  ha as versionsKey,
-  Ha as workflowKey,
-  Pa as workflowsKey
+  Se as recordStepTestRun,
+  ta as recordTestRun,
+  m as resolveHeaderRunInput,
+  K as runButtonLabel,
+  F as runLevelErrors,
+  I as runStateKey,
+  k as runWorkflow,
+  D as runWorkflowSync,
+  g as runsKey,
+  $e as saveCallable,
+  de as saveStepTest,
+  ua as savedTestsKey,
+  ke as sealSecret,
+  De as secretsKey,
+  h as shouldContinuePolling,
+  w as startWorkflowRun,
+  Me as stepTestsKey,
+  oa as testRunsKey,
+  _ as toLogError,
+  Bs as updateConnection,
+  na as updateSavedTest,
+  ra as useApiCallsQuery,
+  Qe as useAppActionsQuery,
+  be as useAppQuery,
+  es as useArchiveCallableMutation,
+  Ts as useArchiveEndpointMutation,
+  As as useArchiveFunctionMutation,
+  x as useArchiveWorkflowMutation,
+  ss as useCallableListQuery,
+  as as useCallableQuery,
+  L as useCancelRunMutation,
+  Gs as useConnectionQuery,
+  Ys as useConnectionsForAppQuery,
+  qs as useConnectionsQuery,
+  N as useCreateDocumentMutation,
+  ge as useCreateSecretMutation,
+  he as useCreateVarMutation,
+  W as useCreateWorkflowMutation,
+  ia as useDashboardStatsQuery,
+  ts as useDeleteCallableMutation,
+  zs as useDeleteConnectionMutation,
+  O as useDeleteDocumentMutation,
+  ms as useDeleteEndpointMutation,
+  Ks as useDeleteFunctionMutation,
+  we as useDeleteSecretMutation,
+  _e as useDeleteVarMutation,
+  P as useDeleteWorkflowMutation,
+  H as useDocumentQuery,
+  V as useDocumentsQuery,
+  Fs as useEndpointQuery,
+  Is as useEndpointsQuery,
+  Te as useExecutionDetailQuery,
+  ks as useFunctionQuery,
+  Ds as useFunctionsQuery,
+  gs as useGuardedSaveEndpointMutation,
+  hs as useGuardedSaveFunctionMutation,
+  Ae as useHasExecutedQuery,
+  me as useHistoryQuery,
+  Ke as useHistoryStatsQuery,
+  U as useImportSpecMutation,
+  ws as useInvokeEndpointMutation,
+  _s as useInvokeFunctionMutation,
+  ae as useInvokeVersionMutation,
+  j as useLiveRunQuery,
+  la as useProjectReliabilityQuery,
+  te as usePublishMutation,
+  ca as useReliabilityQuery,
+  ue as useRevertMutation,
+  B as useRunWorkflowMutation,
+  G as useRunsQuery,
+  us as useSaveCallableMutation,
+  xs as useSaveEndpointMutation,
+  Ls as useSaveFunctionMutation,
+  Y as useSaveWorkflowMutation,
+  ya as useSavedTestsQuery,
+  xe as useSealSecret,
+  Le as useSecretsQuery,
+  oe as useSetEnabledMutation,
+  ne as useSpecQuery,
+  q as useStartRunMutation,
+  z as useSyncDocumentMutation,
+  Zs as useTestConnectionMutation,
+  pa as useTestRunsQuery,
+  Js as useUpdateConnectionMutation,
+  Z as useUpdateDocumentMutation,
+  Ne as useUpdateSecretMutation,
+  We as useUpdateVarMutation,
+  Oe as useVarsQuery,
+  re as useVersionQuery,
+  ie as useVersionsQuery,
+  J as useWorkflowQuery,
+  X as useWorkflowsQuery,
+  Pe as varsKey,
+  le as versionKey,
+  ce as versionsKey,
+  $ as workflowKey,
+  ee as workflowsKey
 };
 //# sourceMappingURL=repos.mjs.map

package/dist/repos.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"repos.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}
+{"version":3,"file":"repos.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/dist/settings-rail--GdRMusb.js

@@ -0,0 +1,33 @@
+function l(r, n) {
+  if (typeof n != "object" || n === null || Array.isArray(n)) return null;
+  const t = n, e = typeof t.updatedAt == "string" ? t.updatedAt : null;
+  if (r === "function") {
+    const { valid: i, updatedAt: f, ...u } = t;
+    return { definition: u, updatedAt: e };
+  }
+  const o = t.endpoint;
+  return typeof o != "object" || o === null || Array.isArray(o) ? null : { definition: o, updatedAt: e };
+}
+function a(r) {
+  return r ? r.kind === "function" || r.kind === "endpoint" ? !0 : r.kind === "workflow" && typeof r.onPolicyChange == "function" : !1;
+}
+function s(r) {
+  const n = {};
+  return r.retry && (n.retry = r.retry), r.onError && r.onError !== "fail" && (n.onError = r.onError), r.reroute && (n.reroute = r.reroute), n;
+}
+function d(r, n) {
+  const { retry: t, onError: e, reroute: o, ...i } = r;
+  return {
+    ...i,
+    ...n.retry ? { retry: n.retry } : {},
+    ...n.onError && n.onError !== "fail" ? { onError: n.onError } : {},
+    ...n.reroute ? { reroute: n.reroute } : {}
+  };
+}
+export {
+  l as c,
+  d,
+  a as i,
+  s as p
+};
+//# sourceMappingURL=settings-rail--GdRMusb.js.map

package/dist/settings-rail--GdRMusb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-rail--GdRMusb.js","sources":["../src/lib/callable-record.ts","../src/lib/settings-rail.ts"],"sourcesContent":["/**\n * The ONE split of a Function's / Endpoint's `get` response into the editable definition and the\n * stale-write token. `useCallableDraft` (seed, external-change detection, the posted body) and the\n * rail's write paths (B-4) both read through it, so \"what do we post, and which `updatedAt` do we\n * guard it with\" has one answer.\n *\n * - **function** — the `console.functions.get` result is `FunctionDef & {valid, updatedAt}` with the\n *   top-level values spread LAST. The definition is that object minus `valid` and `updatedAt`\n *   (both read-only splices that must never ride back in a save body); the token is its top-level\n *   `updatedAt`, so a stale `updatedAt` stored INSIDE a definition never wins.\n * - **endpoint** — the response is the verbatim envelope `{endpoint, invokeUrl, …, updatedAt}`.\n *   The definition is `data.endpoint` as-is; the token is the TOP-LEVEL `data.updatedAt`, never\n *   `data.endpoint.updatedAt`.\n *\n * `null` when `data` is absent or is not the shape the kind answers with. Pure, no imports:\n * loadable by `node --test`.\n */\nexport function callableRecord(\n  kind: \"function\" | \"endpoint\",\n  data: unknown,\n): { definition: Record<string, unknown>; updatedAt: string | null } | null {\n  if (typeof data !== \"object\" || data === null || Array.isArray(data)) return null;\n  const top = data as Record<string, unknown>;\n  const updatedAt = typeof top.updatedAt === \"string\" ? top.updatedAt : null;\n  if (kind === \"function\") {\n    const { valid: _valid, updatedAt: _updatedAt, ...definition } = top;\n    return { definition, updatedAt };\n  }\n  const endpoint = top.endpoint;\n  if (typeof endpoint !== \"object\" || endpoint === null || Array.isArray(endpoint)) return null;\n  return { definition: endpoint as Record<string, unknown>, updatedAt };\n}\n","/**\n * Pure decisions behind the right rail's Error handling tool\n * (`src/ui/rail/SettingsTool.tsx`, D-10) — the third `railTools` entry,\n * rendering `@w6w/ui`'s `NodeConfigForm` for a Function or an Endpoint and\n * persisting `retry` / `onError` / `reroute` onto that resource's own\n * definition. Split out so `node --test` can gate them directly — mirrors\n * `code-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 — `import type … from\n * \"@w6w/sdk/console\"` is safe and precedented (`src/lib/workflow-poll.ts:15`,\n * `src/lib/tenant-oauth-patch.ts:69`, both unit-tested today).\n */\nimport type { CallableOnError, ErrorReroute, RetryPolicy } from \"@w6w/sdk/console\";\n\n/** Structural mirror of `WorkspaceCallable` (`src/ui/workspace.tsx`) — only\n *  the fields this module reads. `onPolicyChange` is the WORKFLOW arm's\n *  injected writer (see {@link isAvailable}); the two callable arms have no\n *  such member and never read it. */\nexport type SettingsCallable = {\n  kind: string;\n  id: string;\n  onPolicyChange?: (policy: CallablePolicy) => void;\n} | null;\n\n/** The three fields this tool owns on a Function/Endpoint definition —\n *  TC2's pinned shape, shared by both `Fn` and `Endpoint`. */\nexport interface CallablePolicy {\n  retry?: RetryPolicy;\n  onError?: CallableOnError;\n  reroute?: ErrorReroute;\n}\n\n/** A definition carrying (at least) the three fields above, plus whatever\n *  else `Fn`/`Endpoint` declares — `definitionWithPolicy` preserves every\n *  field this type doesn't name. */\nexport type CallableDefinition = CallablePolicy;\n\n/**\n * Is the Error handling tool meaningful for this context?\n *\n * A Function and an Endpoint: always — the panel owns their whole\n * read-modify-write, because nothing else on the page is editing the same\n * definition at the same time.\n *\n * A Workflow: only when the publishing page injects `onPolicyChange` (core\n * Workflow RFC — *Amendment — 2026-08-21: the run-level error handler*). This\n * is not fussiness. The workflow canvas holds the definition as JSON TEXT it\n * owns, and auto-saves it (`settings.autoSave` defaults to ON), so a rail\n * panel doing its own read-modify-write against the server would be racing the\n * editor: whichever wrote last would silently drop the other's edit, and the\n * loser would most often be the rail, since the canvas re-sends its whole\n * buffer on the next keystroke. Injecting the writer instead means the rail\n * edits the SAME buffer the canvas is about to save. A page that does not own\n * that buffer (the run-detail page) publishes no writer, and the tool simply\n * does not appear there.\n *\n * A Connection has no run-level policy at all. `null` (no resource published)\n * fails closed, house style (mirrors `code-rail.ts`'s `isAvailable`).\n */\nexport function isAvailable(ctx: SettingsCallable): boolean {\n  if (!ctx) return false;\n  if (ctx.kind === \"function\" || ctx.kind === \"endpoint\") return true;\n  return ctx.kind === \"workflow\" && typeof ctx.onPolicyChange === \"function\";\n}\n\n/**\n * Read a definition's `{retry, onError, reroute}` into the shape the panel's\n * local editing state starts from. Normalizes the same way\n * `definitionWithPolicy` writes: a stored `onError: \"fail\"` (never written by\n * this tool, but defensive against a hand-edited or older definition) reads\n * back as absent, matching how `NodeConfigForm` already treats `\"fail\"` as\n * its own default.\n */\nexport function policyFromDefinition(def: CallableDefinition): CallablePolicy {\n  const policy: CallablePolicy = {};\n  if (def.retry) policy.retry = def.retry;\n  if (def.onError && def.onError !== \"fail\") policy.onError = def.onError;\n  if (def.reroute) policy.reroute = def.reroute;\n  return policy;\n}\n\n/**\n * Read-modify-write: apply `policy`'s `{retry, onError, reroute}` onto `def`,\n * preserving every OTHER field untouched (`impl`/`inputs`/`key` on a\n * Function, `target`/`input`/`key` on an Endpoint, …) — the save this tool\n * issues is never a bare `{retry, onError, reroute}` object. A field whose\n * value is the default is OMITTED entirely, not written as `undefined`:\n * `policy.onError === \"fail\"` (or absent) drops the key, matching\n * `NodeConfigForm`'s own \"fail\" -> absent convention for the field it edits\n * in place. Built by destructuring the three fields OUT of `def` and\n * conditionally re-spreading them, rather than `delete`, so the key is\n * genuinely absent from the returned object, not merely `undefined`-valued —\n * `node:assert/strict`'s deep-equal distinguishes the two (this module's own\n * test pins it).\n */\nexport function definitionWithPolicy<T extends CallableDefinition>(\n  def: T,\n  policy: CallablePolicy,\n): T {\n  const { retry: _retry, onError: _onError, reroute: _reroute, ...rest } = def;\n  return {\n    ...rest,\n    ...(policy.retry ? { retry: policy.retry } : {}),\n    ...(policy.onError && policy.onError !== \"fail\" ? { onError: policy.onError } : {}),\n    ...(policy.reroute ? { reroute: policy.reroute } : {}),\n  } as T;\n}\n"],"names":["callableRecord","kind","data","top","updatedAt","_valid","_updatedAt","definition","endpoint","isAvailable","ctx","policyFromDefinition","def","policy","definitionWithPolicy","_retry","_onError","_reroute","rest"],"mappings":"AAiBO,SAASA,EACdC,GACAC,GAC0E;AAC1E,MAAI,OAAOA,KAAS,YAAYA,MAAS,QAAQ,MAAM,QAAQA,CAAI,EAAG,QAAO;AAC7E,QAAMC,IAAMD,GACNE,IAAY,OAAOD,EAAI,aAAc,WAAWA,EAAI,YAAY;AACtE,MAAIF,MAAS,YAAY;AACvB,UAAM,EAAE,OAAOI,GAAQ,WAAWC,GAAY,GAAGC,MAAeJ;AAChE,WAAO,EAAE,YAAAI,GAAY,WAAAH,EAAA;AAAA,EACvB;AACA,QAAMI,IAAWL,EAAI;AACrB,SAAI,OAAOK,KAAa,YAAYA,MAAa,QAAQ,MAAM,QAAQA,CAAQ,IAAU,OAClF,EAAE,YAAYA,GAAqC,WAAAJ,EAAA;AAC5D;AC8BO,SAASK,EAAYC,GAAgC;AAC1D,SAAKA,IACDA,EAAI,SAAS,cAAcA,EAAI,SAAS,aAAmB,KACxDA,EAAI,SAAS,cAAc,OAAOA,EAAI,kBAAmB,aAF/C;AAGnB;AAUO,SAASC,EAAqBC,GAAyC;AAC5E,QAAMC,IAAyB,CAAA;AAC/B,SAAID,EAAI,UAAOC,EAAO,QAAQD,EAAI,QAC9BA,EAAI,WAAWA,EAAI,YAAY,WAAQC,EAAO,UAAUD,EAAI,UAC5DA,EAAI,YAASC,EAAO,UAAUD,EAAI,UAC/BC;AACT;AAgBO,SAASC,EACdF,GACAC,GACG;AACH,QAAM,EAAE,OAAOE,GAAQ,SAASC,GAAU,SAASC,GAAU,GAAGC,EAAA,IAASN;AACzE,SAAO;AAAA,IACL,GAAGM;AAAA,IACH,GAAIL,EAAO,QAAQ,EAAE,OAAOA,EAAO,MAAA,IAAU,CAAA;AAAA,IAC7C,GAAIA,EAAO,WAAWA,EAAO,YAAY,SAAS,EAAE,SAASA,EAAO,QAAA,IAAY,CAAA;AAAA,IAChF,GAAIA,EAAO,UAAU,EAAE,SAASA,EAAO,QAAA,IAAY,CAAA;AAAA,EAAC;AAExD;"}