@w6w/embed 0.1.0 → 0.2.0

package/dist/callables-3mFrMVG_.js

@@ -0,0 +1,151 @@
+import { useQueryClient as a, useMutation as l, useQuery as f } from "@tanstack/react-query";
+import { u as s } from "./client-context-CX61Bgw-.js";
+const y = {
+  function: (e) => ["function", e],
+  endpoint: (e) => ["endpoint", e],
+  workflow: (e) => ["workflow", e]
+};
+function w(e, n) {
+  return y[e](n);
+}
+function C(e, n, t) {
+  e.invalidateQueries({ queryKey: n }), e.invalidateQueries({ queryKey: t });
+}
+const c = {
+  function: "functions",
+  endpoint: "endpoints",
+  workflow: "workflows"
+}, d = {
+  function: () => ["functions"],
+  endpoint: () => ["endpoints"],
+  workflow: (e) => ["workflows", e]
+};
+function Q(e) {
+  return c[e];
+}
+function b(e, n) {
+  const t = c[e];
+  return n === void 0 ? t : `${t}/${n}`;
+}
+function p(e, n) {
+  return `/${c[e]}/${n}`;
+}
+function S(e, n) {
+  return `${b(e, n)}/history`;
+}
+function u(e, n) {
+  return d[e](n);
+}
+function h(e, n, t) {
+  switch (n) {
+    case "function":
+      return e.console.functions.list();
+    case "endpoint":
+      return e.console.endpoints.list();
+    case "workflow":
+      return e.workflows.list({ project: t });
+  }
+}
+function k(e, n, t) {
+  switch (n) {
+    case "function":
+      return e.console.functions.get(t);
+    case "endpoint":
+      return e.console.endpoints.get(t);
+    case "workflow":
+      return e.console.workflows.get(t);
+  }
+}
+function m(e, n, t, o) {
+  switch (n) {
+    case "function":
+      return e.console.functions.upsert(t).then((r) => ({ id: r.id, key: r.key }));
+    case "endpoint":
+      return e.console.endpoints.upsert(t).then((r) => ({ id: r.endpoint.id, key: r.endpoint.key }));
+    case "workflow": {
+      const r = o == null ? void 0 : o.project;
+      return r ? e.console.workflows.upsert(t, { project: r }).then((i) => ({
+        id: i.workflow.id,
+        key: i.workflow.key ?? ""
+      })) : Promise.reject(new Error("No project selected yet."));
+    }
+  }
+}
+function q(e, n, t) {
+  switch (n) {
+    case "function":
+    case "endpoint":
+      return e.request({
+        method: "POST",
+        path: `${p(n, encodeURIComponent(t))}/archive`
+      });
+    case "workflow":
+      return e.console.workflows.archive(t);
+  }
+}
+function v(e, n, t) {
+  switch (n) {
+    case "function":
+    case "endpoint":
+      return e.request({ method: "DELETE", path: p(n, encodeURIComponent(t)) });
+    case "workflow":
+      return e.console.workflows.delete(t);
+  }
+}
+function L(e, n = !0, t) {
+  const o = s();
+  return f({
+    queryKey: u(e, t),
+    queryFn: () => h(o, e, t),
+    enabled: n
+  });
+}
+function R(e, n, t = !0) {
+  const o = s();
+  return f({
+    queryKey: w(e, n),
+    queryFn: () => k(o, e, n),
+    enabled: t
+  });
+}
+function $(e, n) {
+  const t = s(), o = a();
+  return l({
+    mutationFn: (r) => m(t, e, r, n),
+    onSuccess: (r) => C(o, u(e), w(e, r.id))
+  });
+}
+function g(e) {
+  const n = s(), t = a();
+  return l({
+    mutationFn: (o) => q(n, e, o),
+    onSuccess: () => t.invalidateQueries({ queryKey: u(e) })
+  });
+}
+function F(e) {
+  const n = s(), t = a();
+  return l({
+    mutationFn: (o) => v(n, e, o),
+    onSuccess: () => t.invalidateQueries({ queryKey: u(e) })
+  });
+}
+export {
+  q as a,
+  S as b,
+  Q as c,
+  w as d,
+  u as e,
+  p as f,
+  b as g,
+  v as h,
+  k as i,
+  C as j,
+  L as k,
+  h as l,
+  R as m,
+  F as n,
+  $ as o,
+  m as s,
+  g as u
+};
+//# sourceMappingURL=callables-3mFrMVG_.js.map

package/dist/callables-3mFrMVG_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"callables-3mFrMVG_.js","sources":["../src/lib/callable-kind.ts","../src/lib/save-invalidation.ts","../src/repos/callables.ts"],"sourcesContent":["/**\n * The three callable kinds and the single-resource query key per kind.\n *\n * Moved verbatim out of Studio's `repos/callables.ts` (`CallableKind`, `callableKey` and the one\n * pure table `callableKey` closes over, `RESOURCE_KEY`) so `repos/versions.ts` — which ships in\n * this package for all three kind arms — can invalidate a definition by key without importing a\n * Studio module. `repos/callables.ts` imports these from `@w6w/embed/repos` and does NOT re-export\n * them. No React, no client: loadable by `node --test`.\n */\n\n/** The three kinds the callable repos are total over. */\nexport type CallableKind = \"function\" | \"endpoint\" | \"workflow\";\n\n/** The single-resource key's own prefix — byte-identical to `functionKey`/`endpointKey`/\n *  `workflowKey`. */\nconst RESOURCE_KEY: Record<CallableKind, (id: string) => readonly unknown[]> = {\n  function: (id) => [\"function\", id],\n  endpoint: (id) => [\"endpoint\", id],\n  workflow: (id) => [\"workflow\", id],\n};\n\n/** `GET /<coll>/:id`'s own query key — the literal `lib/save-invalidation.ts` invalidates. */\nexport function callableKey(kind: CallableKind, id: string): readonly unknown[] {\n  return RESOURCE_KEY[kind](id);\n}\n","/**\n * Shared invalidation for a whole-definition save (T3.1.1). `useSaveFunctionMutation` and\n * `useSaveEndpointMutation` (`src/repos/functions.ts`, `src/repos/endpoints.ts`) both route their\n * `onSuccess` through this one helper rather than inlining the two `invalidateQueries` calls at\n * each site — so a save invalidates the LIST key (both list pages and the editor depend on it)\n * *and* the saved resource's own single-resource key (`functionKey(id)` / `endpointKey(id)`),\n * never just the list.\n *\n * No value imports on purpose: `node --test` throws `ERR_UNKNOWN_FILE_EXTENSION` on anything that\n * reaches the `@w6w/ui` / `Layout.tsx` import graph, and `src/repos/*.ts` reaches it through\n * `../api/apiClient.tsx` (JSX). This module has none of that, so it is loadable by `node --test`\n * directly — see `src/lib/alias-rail.ts`'s docstring for the same reasoning.\n */\n\nexport interface QueryInvalidator {\n  invalidateQueries(filters: { queryKey: readonly unknown[] }): unknown;\n}\n\n/**\n * Invalidate the list key, then the saved resource's own key. List first: both keys are\n * invalidated regardless of order, but the order is asserted (see the unit test) so a future edit\n * that drops one call is a diff a reviewer can spot in a single line.\n */\nexport function invalidateSavedCallable(\n  qc: QueryInvalidator,\n  listKey: readonly unknown[],\n  callableKey: readonly unknown[],\n): void {\n  qc.invalidateQueries({ queryKey: listKey });\n  qc.invalidateQueries({ queryKey: callableKey });\n}\n","import { useMutation, useQuery, useQueryClient } from \"@tanstack/react-query\";\nimport type { W6WClient } from \"@w6w/sdk\";\nimport { useEmbedClient } from \"../draft/client-context.ts\";\n/**\n * The kind-parametrised resource repo (T4.2.1, `building-blocks.F3.md` §F-3) — ONE module\n * answering \"list / get / save / archive / delete a resource of kind K\" for all three kinds,\n * instead of `functions.ts`/`endpoints.ts`/`workflows.ts` each restating the same five shapes with\n * their own key builder.\n *\n * **Mirrors `src/repos/versions.ts`'s `COLLECTION_PATH: Record<VersionsKind, …>` idiom**: every\n * per-kind fact is a TOTAL `Record` whose arms are all named explicitly, never a string\n * pluralisation rule — a typo'd suffix would silently send one kind's requests at another kind's\n * collection (that module's own docblock gives the reasoning in full). The two tables that are\n * genuinely per-kind *data* — the collection segment and the two query-key shapes — are `Record`s;\n * the three calls whose SIGNATURE differs per kind (get's return shape, save's envelope key,\n * archive/delete's SDK-vs-escape-hatch split) are `switch`es with every arm named and no\n * `default:`, so a fourth kind is a compile error rather than a silent fall-through.\n *\n * **Query keys are byte-identical to the ones this repo replaces** — `[\"functions\"]`,\n * `[\"function\", id]`, `[\"endpoints\"]`, `[\"endpoint\", id]`, `[\"workflows\", project]`,\n * `[\"workflow\", id]` — because `lib/save-invalidation.ts`, `lib/spec-import-invalidation.ts` and\n * `repos/versions.ts`'s revert arm all invalidate those literals through helpers that take a key,\n * not a hook. A renamed key here would leave a saved resource's page showing its pre-save draft,\n * invisible to `tsc` and to every page guard (this is `spec-import-invalidation.ts`'s own\n * argument, restated for the whole family).\n *\n * `repos/functions.ts` stays as the Function-bound facade over this module — every existing\n * importer (`ui/rail/SettingsTool.tsx`, `ui/rail/AliasesTool.tsx`, `ui/rail/ErrorHandlingTool.tsx`,\n * `components/TargetSelector.tsx`, `components/FunctionIdentityModal.tsx`, `api/w6wApiFacade.tsx`)\n * keeps its import and its call shape; only where the code lives changed.\n */\nimport { type CallableKind, callableKey } from \"../lib/callable-kind.ts\";\nimport { invalidateSavedCallable } from \"../lib/save-invalidation.ts\";\n\n/** `<coll>` — the wire contract's own path segment per kind, every arm named explicitly\n *  (never derived by string pluralisation), mirroring `versions.ts`'s `COLLECTION_PATH`. */\nconst COLLECTION_PATH: Record<CallableKind, \"functions\" | \"endpoints\" | \"workflows\"> = {\n  function: \"functions\",\n  endpoint: \"endpoints\",\n  workflow: \"workflows\",\n};\n\n/**\n * The LIST query key per kind — byte-identical to `functionsKey`, `endpointsKey` and\n * `workflowsKey(project)`. A function per kind, not a literal, because the Workflow arm is\n * genuinely project-scoped (`repos/workflows.ts`'s own note: `[\"workflows\", undefined]` and\n * `[\"workflows\", \"prj_x\"]` are DIFFERENT cache entries, deliberately).\n */\nconst LIST_KEY: Record<CallableKind, (project?: string) => readonly unknown[]> = {\n  function: () => [\"functions\"],\n  endpoint: () => [\"endpoints\"],\n  workflow: (project) => [\"workflows\", project],\n};\n\n/**\n * The structural minimum every list row of every kind satisfies — what the shared list chrome\n * (`pages/CallablePage.tsx`) renders and the Settings rail reads by id. Kind-specific widening\n * (`archivedAt`, an Endpoint's `status`/`incomplete`) stays in the kind's own facade, which is\n * where the comment explaining \"the SDK does not know this column yet\" belongs.\n */\nexport interface CallableRow {\n  id: string;\n  /** `null` for a Workflow that has no key of its own yet (`WorkflowSummary`'s own\n   *  type) — never coerced to `\"\"` here, so the list renders exactly what the server sent. */\n  key: string | null;\n  displayName?: string | null;\n  description?: string | null;\n  archivedAt?: string | null;\n}\n\n/** `<coll>` for a kind — the wire segment AND (studio mirrors the wire) the route segment. */\nexport function callableCollection(kind: CallableKind): string {\n  return COLLECTION_PATH[kind];\n}\n\n/** The studio route for a kind, or for one of its resources: `\"functions\"`, `\"functions/fn_x\"`. */\nexport function callableRoute(kind: CallableKind, id?: string): string {\n  const collection = COLLECTION_PATH[kind];\n  return id === undefined ? collection : `${collection}/${id}`;\n}\n\n/** The wire path for one resource: `/functions/fn_x`. */\nexport function callablePath(kind: CallableKind, id: string): string {\n  return `/${COLLECTION_PATH[kind]}/${id}`;\n}\n\n/** The studio route for one resource's History tab/page (T2.3.1/T2.4.1):\n *  `\"functions/fn_x/history\"`. A sibling of {@link callableRoute}, not a\n *  hand-written string per call site. */\nexport function callableHistoryRoute(kind: CallableKind, id: string): string {\n  return `${callableRoute(kind, id)}/history`;\n}\n\n/** `GET /<coll>`'s own query key — the literal `lib/spec-import-invalidation.ts` invalidates. */\nexport function callableListKey(kind: CallableKind, project?: string): readonly unknown[] {\n  return LIST_KEY[kind](project);\n}\n\n/**\n * `GET /<coll>`. A `switch`, not a table: the three SDK calls return three different summary\n * types, and the union is what the shared chrome consumes structurally.\n */\nexport function listCallables(\n  client: W6WClient,\n  kind: CallableKind,\n  project?: string,\n): Promise<CallableRow[]> {\n  switch (kind) {\n    case \"function\":\n      return client.console.functions.list();\n    case \"endpoint\":\n      return client.console.endpoints.list();\n    case \"workflow\":\n      return client.workflows.list({ project });\n  }\n}\n\n/**\n * `GET /<coll>/:id`, each arm returning exactly what that kind's existing repo function returns —\n * Function's `{...function, valid}` splice, Endpoint's `{endpoint, invokeUrl, …}` envelope,\n * Workflow's three-field body — never re-shaped here. The return type is the honest `unknown`:\n * the per-kind reader in the kind's own facade is what narrows it.\n */\nexport function getCallable(client: W6WClient, kind: CallableKind, id: string): Promise<unknown> {\n  switch (kind) {\n    case \"function\":\n      return client.console.functions.get(id);\n    case \"endpoint\":\n      return client.console.endpoints.get(id);\n    case \"workflow\":\n      return client.console.workflows.get(id);\n  }\n}\n\n/**\n * `POST /<coll>`, normalised to the one thing EVERY caller of a save needs — the saved resource's\n * id and key, for the invalidation below and for a create modal's own \"created\" callback. The two\n * envelopes (`{endpoint: {id, key}}`, `{workflow: {id, key}}`) and the flat one (`{id, key}`) are\n * unwrapped in the arm that knows its own shape, so no caller outside this module ever has to.\n *\n * Workflow refuses without a `project` for the same reason `repos/workflows.ts`'s own save does:\n * a missing project on a WRITE lands the definition in the account's default project instead of\n * the one the operator is looking at.\n */\nexport function saveCallable(\n  client: W6WClient,\n  kind: CallableKind,\n  definition: unknown,\n  options?: { project?: string },\n): Promise<{ id: string; key: string }> {\n  switch (kind) {\n    case \"function\":\n      return client.console.functions\n        .upsert(definition as never)\n        .then((saved) => ({ id: saved.id, key: saved.key }));\n    case \"endpoint\":\n      return client.console.endpoints\n        .upsert(definition as never)\n        .then((saved) => ({ id: saved.endpoint.id, key: saved.endpoint.key }));\n    case \"workflow\": {\n      const project = options?.project;\n      if (!project) return Promise.reject(new Error(\"No project selected yet.\"));\n      return client.console.workflows.upsert(definition, { project }).then((saved) => ({\n        id: saved.workflow.id,\n        key: saved.workflow.key ?? \"\",\n      }));\n    }\n  }\n}\n\n/**\n * `POST /<coll>/:id/archive`. Function and Endpoint go through the plain `apiClient.request()`\n * escape hatch (T4.1.1/A7/D-I0-7: no typed `@w6w/sdk` method exists, and adding one would drag\n * `packages/wrappers` into this task's scope for an internal route); Workflow keeps the typed\n * `console.workflows.archive` it has had since the rail's DangerZone landed.\n */\nexport function archiveCallable(\n  client: W6WClient,\n  kind: CallableKind,\n  id: string,\n): Promise<unknown> {\n  switch (kind) {\n    case \"function\":\n    case \"endpoint\":\n      return client.request({\n        method: \"POST\",\n        path: `${callablePath(kind, encodeURIComponent(id))}/archive`,\n      });\n    case \"workflow\":\n      return client.console.workflows.archive(id);\n  }\n}\n\n/** `DELETE /<coll>/:id` — same split, and the same reasoning, as {@link archiveCallable}. */\nexport function deleteCallable(\n  client: W6WClient,\n  kind: CallableKind,\n  id: string,\n): Promise<unknown> {\n  switch (kind) {\n    case \"function\":\n    case \"endpoint\":\n      return client.request({ method: \"DELETE\", path: callablePath(kind, encodeURIComponent(id)) });\n    case \"workflow\":\n      return client.console.workflows.delete(id);\n  }\n}\n\n/**\n * `useQuery` over {@link listCallables}, keyed by {@link callableListKey}. Generic over the row\n * type so a kind's own facade can narrow it to that kind's widened summary (Function's\n * `archivedAt`, Endpoint's `status`/`incomplete`) without a cast at the call site.\n */\nexport function useCallableListQuery<Row extends CallableRow = CallableRow>(\n  kind: CallableKind,\n  enabled = true,\n  project?: string,\n) {\n  const apiClient = useEmbedClient();\n  return useQuery<Row[]>({\n    queryKey: callableListKey(kind, project),\n    queryFn: () => listCallables(apiClient, kind, project) as Promise<Row[]>,\n    enabled,\n  });\n}\n\n/** `useQuery` over {@link getCallable}, keyed by {@link callableKey}. */\nexport function useCallableQuery<Def = unknown>(kind: CallableKind, id: string, enabled = true) {\n  const apiClient = useEmbedClient();\n  return useQuery<Def>({\n    queryKey: callableKey(kind, id),\n    queryFn: () => getCallable(apiClient, kind, id) as Promise<Def>,\n    enabled,\n  });\n}\n\n/**\n * `useMutation` over {@link saveCallable}. `onSuccess` routes through the SAME\n * `invalidateSavedCallable` helper every save in studio already uses, with the SAME two keys —\n * the list AND the saved resource — so the Function arm's invalidation is the one\n * `repos/functions.ts` performs today, byte for byte.\n */\nexport function useSaveCallableMutation(kind: CallableKind, options?: { project?: string }) {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (definition: unknown) => saveCallable(apiClient, kind, definition, options),\n    onSuccess: (saved) =>\n      invalidateSavedCallable(qc, callableListKey(kind), callableKey(kind, saved.id)),\n  });\n}\n\n/** `useMutation` over {@link archiveCallable} — the list key, so the row's archived badge\n *  refreshes and the rail's Delete control appears in Archive's place. */\nexport function useArchiveCallableMutation(kind: CallableKind) {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (id: string) => archiveCallable(apiClient, kind, id),\n    onSuccess: () => qc.invalidateQueries({ queryKey: callableListKey(kind) }),\n  });\n}\n\n/** `useMutation` over {@link deleteCallable}. */\nexport function useDeleteCallableMutation(kind: CallableKind) {\n  const apiClient = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (id: string) => deleteCallable(apiClient, kind, id),\n    onSuccess: () => qc.invalidateQueries({ queryKey: callableListKey(kind) }),\n  });\n}\n"],"names":["RESOURCE_KEY","id","callableKey","kind","invalidateSavedCallable","qc","listKey","COLLECTION_PATH","LIST_KEY","project","callableCollection","callableRoute","collection","callablePath","callableHistoryRoute","callableListKey","listCallables","client","getCallable","saveCallable","definition","options","saved","archiveCallable","deleteCallable","useCallableListQuery","enabled","apiClient","useEmbedClient","useQuery","useCallableQuery","useSaveCallableMutation","useQueryClient","useMutation","useArchiveCallableMutation","useDeleteCallableMutation"],"mappings":"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"}

package/dist/chrome/index.d.ts

@@ -34,3 +34,9 @@ export { ErrorHandlerSection, errorHandlingTool } from '../rail/ErrorHandlingToo
 export type { ErrorHandlerKind, ErrorHandlerSectionProps } from '../rail/ErrorHandlingTool.tsx';
 export { ProjectExpressionScope, useProjectExpressionOptions } from '../rail/ExpressionScope.tsx';
 export { editorRailTools } from '../rail/editor-tools.ts';
+export { TargetSelector } from '../editor/TargetSelector.tsx';
+export type { TargetKind, TargetSelectorProps, TargetValue, } from '../editor/TargetSelector.types.ts';
+export { InputListEditor } from '../editor/InputListEditor.tsx';
+export type { InputListEditorProps } from '../editor/InputListEditor.tsx';
+export { CallableEditorFrame } from '../editor/CallableEditorFrame.tsx';
+export type { CallableEditorFrameProps } from '../editor/CallableEditorFrame.tsx';

package/dist/chrome/workspace.d.ts

@@ -16,6 +16,15 @@ export type WorkspaceCallable = {
     key?: string;
     inputs?: readonly SnippetInput[];
     alias?: string;
+    /**
+     * The Function's / Endpoint's run-level error policy and its writer, published by an
+     * editor that owns the definition buffer (`useCallableDraft`) so the rail's Error handling
+     * tool edits and saves THAT buffer (pending edits ride along) instead of racing it. Same
+     * ⚠️ as the workflow arm: `onPolicyChange` MUST be referentially stable
+     * (`useCallableDraft`'s is).
+     */
+    policy?: CallablePolicy;
+    onPolicyChange?: (policy: CallablePolicy) => void;
 } | {
     kind: "endpoint";
     id: string;
@@ -26,6 +35,15 @@ export type WorkspaceCallable = {
     urlForm?: "id" | "key";
     alias?: string;
     inputs?: readonly SnippetInput[];
+    /**
+     * The Function's / Endpoint's run-level error policy and its writer, published by an
+     * editor that owns the definition buffer (`useCallableDraft`) so the rail's Error handling
+     * tool edits and saves THAT buffer (pending edits ride along) instead of racing it. Same
+     * ⚠️ as the workflow arm: `onPolicyChange` MUST be referentially stable
+     * (`useCallableDraft`'s is).
+     */
+    policy?: CallablePolicy;
+    onPolicyChange?: (policy: CallablePolicy) => void;
 } | {
     kind: "workflow";
     id: string;
@@ -58,9 +76,19 @@ export type WorkspaceCallable = {
 /** Derived from {@link WorkspaceCallable}, never redeclared — the arm a
  * `RailTool.isAvailable`/route wrapper narrows on. */
 export type WorkspaceKind = Exclude<WorkspaceCallable, null>["kind"];
-export declare function WorkspaceProvider({ children }: {
+/**
+ * Two layers: `base` (a prop — the host-owned `{kind, id}` a `<CallableWorkspace>` publishes) and
+ * an override (what a mounted page publishes with `useWorkspace`). The override wins while it is
+ * set; when its publisher unmounts it is cleared and the base is shown again — never empty. With no
+ * `base` (Studio's layout, the editor's own nested provider) the behaviour is exactly the old
+ * single-slot one: override or `null`.
+ */
+export declare function WorkspaceProvider({ children, base, }: {
     children: ReactNode;
+    base?: WorkspaceCallable;
 }): import("react").JSX.Element;
+/** Non-throwing probe: is there an enclosing {@link WorkspaceProvider}? */
+export declare function useHasWorkspace(): boolean;
 /** Publisher. Compute during render, effect-write, clear on unmount. */
 export declare function useWorkspace(resource: WorkspaceCallable): void;
 /** Reader — used by the rail and by every tool `Panel`. Throws outside the provider. */

package/dist/coerce-input-BicYr7nc.js

@@ -0,0 +1,139 @@
+function y(n) {
+  return n.kind === "action" ? "" : n.kind === "endpoint" ? n.endpoint : n.kind === "function" ? n.function : n.workflow;
+}
+function q(n) {
+  return n.kind === "action" ? !!(n.uses.app && n.uses.action) : !!y(n);
+}
+function I(n) {
+  return n ? n.kind === "function" ? { kind: "function", function: n.function } : n.kind === "workflow" ? { kind: "workflow", workflow: n.workflow } : { kind: "action", uses: n.uses, with: n.with } : { kind: "action", uses: { app: "", action: "", connection: null }, with: {} };
+}
+function F(n) {
+  return n.kind === "action" ? { uses: n.uses, with: n.with ?? {} } : { ...n, with: {} };
+}
+function g(n) {
+  return n.map((e) => {
+    const t = {
+      key: e.key,
+      label: e.label ?? e.key,
+      type: e.type ?? "string",
+      required: e.required,
+      default: e.default
+    };
+    return e.showIf !== void 0 && (t.showIf = e.showIf), t;
+  });
+}
+function S(n, e) {
+  var u, s;
+  const t = Array.isArray(n == null ? void 0 : n.steps) ? n.steps : [], i = /* @__PURE__ */ new Set(), r = [];
+  for (const o of t) {
+    const c = (u = o == null ? void 0 : o.uses) == null ? void 0 : u.app;
+    if (typeof c != "string" || !e.isTriggerApp(c)) continue;
+    const p = e.asFieldDefs((s = o == null ? void 0 : o.with) == null ? void 0 : s.fields);
+    for (const d of p) {
+      const f = d.key;
+      typeof f != "string" || f.trim() === "" || i.has(f) || (i.add(f), r.push({ key: f, label: f, type: d.type ?? "string", required: d.required }));
+    }
+  }
+  return r;
+}
+const h = ["string", "text", "number", "boolean", "json", "secret"];
+function T(n) {
+  return n.rows.length === 0 && !n.touched;
+}
+function k(n) {
+  return h.includes(n) ? n : "string";
+}
+function N(n, e) {
+  const t = new Set(n.map((r) => r.key)), i = [];
+  for (const r of e) {
+    const u = r.key;
+    typeof u != "string" || u.trim() === "" || t.has(u) || (t.add(u), i.push({
+      key: u,
+      label: r.label ?? u,
+      type: k(r.type),
+      required: !!r.required
+    }));
+  }
+  return i.length === 0 ? n : [...n, ...i];
+}
+function m(n, e) {
+  const t = n.showIf;
+  if (!t) return !0;
+  const i = e(t.field);
+  return t.equals !== void 0 ? i === t.equals : t.in ? t.in.some((r) => r === i) : t.notIn ? !t.notIn.some((r) => r === i) : t.truthy !== void 0 ? t.truthy ? !!i : !i : !0;
+}
+function b(n) {
+  return n == null ? !1 : typeof n == "string" ? n.trim() !== "" : !0;
+}
+function a(n, e, t) {
+  const i = new Set(n.map((s) => s.key)), r = (s) => {
+    var o;
+    return (t == null ? void 0 : t[s]) !== void 0 ? t[s] : (o = e.find((c) => c.key === s)) == null ? void 0 : o.default;
+  }, u = [];
+  for (const s of e) {
+    if (!s.required) continue;
+    const o = s.key;
+    typeof o != "string" || o.trim() === "" || i.has(o) || u.includes(o) || m(s, r) && (b(s.default) || u.push(o));
+  }
+  return u;
+}
+function j(n, e) {
+  if (!(e.emptyMeansPassthrough && n.length === 0))
+    return n;
+}
+function w(n) {
+  return n == null ? !1 : typeof n == "string" ? n.trim() !== "" : typeof n == "object" && "type" in n && n.type === "expr" ? !0 : typeof n == "object";
+}
+function l(n) {
+  const e = [];
+  for (const t of Object.keys(n))
+    w(n[t]) && e.push({ key: t, label: t, type: "string" });
+  return e;
+}
+function v(n) {
+  const { target: e, rows: t, fields: i } = n;
+  return e.kind === "action" ? e.with === void 0 ? [] : a(l(e.with), i, e.with) : t.length === 0 ? [] : a(t, i);
+}
+function A(n) {
+  return n.impl ? a(
+    l(n.impl.with ?? {}),
+    n.fields,
+    n.impl.with ?? {}
+  ) : n.fields.filter((e) => e.required).map((e) => e.key);
+}
+function B(n, e) {
+  if (e !== "")
+    switch (n) {
+      case "number": {
+        const t = Number(e);
+        return Number.isNaN(t) ? e : t;
+      }
+      case "boolean":
+        return e === "true";
+      case "json":
+        try {
+          return JSON.parse(e);
+        } catch {
+          return e;
+        }
+      default:
+        return e;
+    }
+}
+export {
+  h as I,
+  j as a,
+  y as b,
+  B as c,
+  F as d,
+  A as e,
+  S as f,
+  a as g,
+  I as i,
+  N as m,
+  g as p,
+  T as s,
+  q as t,
+  v as u
+};
+//# sourceMappingURL=coerce-input-BicYr7nc.js.map

package/dist/coerce-input-BicYr7nc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coerce-input-BicYr7nc.js","sources":["../src/lib/target-fields.ts","../src/lib/input-seeding.ts","../src/lib/input-coverage.ts","../src/lib/coerce-input.ts"],"sourcesContent":["/**\n * Pure helpers shared by `TargetSelector`'s three arms (rfcs/endpoint.md\n * :339-347 — `EndpointTarget = CallableRef | ActionTarget`) and by\n * `EndpointsPage`'s save gate.\n *\n * Pure and testable by design, mirroring `workflow-validity.ts`'s shape:\n * `@w6w/ui`'s `package.json` `exports[\".\"]` resolves to raw `./src/index.ts`,\n * which re-exports `.tsx` files, so `node --test` throws\n * `ERR_UNKNOWN_FILE_EXTENSION` the moment anything here imports `@w6w/ui` or\n * `@w6w/ui/flow` — even type-only. So this module declares its own local\n * structural (`*Like`) types instead of importing the real ones from\n * `../api/types.ts`, and `isTriggerApp`/`asFieldDefs` (the workflow arm's only\n * dependency on `@w6w/ui/flow`) are **caller-injected** — `TargetSelector.tsx`\n * (unaffected by the JSX constraint) imports the real ones and passes them in.\n */\n\n/** The four arms `EndpointTarget` can take; a Function's `impl` takes the\n *  first three (D-8) — `\"endpoint\"` is alias-only, never legal for `Fn.impl`. */\nexport type TargetKind = \"action\" | \"function\" | \"workflow\" | \"endpoint\";\n\n/** The `action` arm — same `{ uses, with }` shape a Function's `impl` carries. */\nexport interface ActionTargetLike {\n  kind: \"action\";\n  uses: { app: string; action: string; connection?: string | null };\n  with?: Record<string, unknown>;\n}\n\n/** The `function`/`workflow` arms — a bare ref, one hop to a CallableRef. */\nexport type CallableTargetLike =\n  | { kind: \"function\"; function: string }\n  | { kind: \"workflow\"; workflow: string };\n\n/** The `endpoint` arm — a bare ref to another Endpoint. Alias-only (plan.md\n *  §2a): legal for `AliasDef.target`, never for an Endpoint's own `target`\n *  (the server refuses it — `admin/endpoints.ts`'s `validateDefinition`). */\nexport interface EndpointRefTargetLike {\n  kind: \"endpoint\";\n  endpoint: string;\n}\n\n/** The full local mirror of `EndpointTarget` this module operates on. */\nexport type TargetLike = ActionTargetLike | CallableTargetLike | EndpointRefTargetLike;\n\n/**\n * The action arm of a Function's `impl` — today's `FunctionImplLike` shape,\n * plus the two fields D-8 adds: `kind?: \"action\"` (absent means \"action\",\n * unchanged for every Function stored before the union existed) and\n * `outputMap?` (mirrors the action arm's own adapter-out pass, already on\n * `FnActionImpl`/`FunctionActionImpl`).\n */\nexport interface ActionImplLike {\n  kind?: \"action\";\n  uses: { app: string; action: string; connection?: string | null };\n  with?: Record<string, unknown>;\n  outputMap?: Record<string, unknown>;\n}\n\n/**\n * A Function's `impl` (D-8, `rfcs/function.md` as amended by TC2) — bound to\n * one app Action, or to another Function/Workflow via `CallableTargetLike`\n * (reused verbatim, never a fourth local mirror), intersected with the same\n * `with`/`outputMap` adapter pair the action arm carries — field-for-field\n * `FnCallableImpl = CallableRef & {with?; outputMap?}` (TC2's pinned type).\n */\nexport type FunctionImplLike =\n  | ActionImplLike\n  | (CallableTargetLike & { with?: Record<string, unknown>; outputMap?: Record<string, unknown> });\n\n/** A declared action/function param, just enough of it for the projector. */\nexport interface ParamLike {\n  key: string;\n  label?: string;\n  type?: string;\n  required?: boolean;\n  default?: unknown;\n  showIf?: ShowIfPredicate;\n}\n\n/** Visibility predicate — mirroring ActionParam.showIf from @w6w/ui. */\nexport interface ShowIfPredicate {\n  field: string;\n  equals?: unknown;\n  in?: unknown[];\n  notIn?: unknown[];\n  truthy?: boolean;\n}\n\n/** One field of a manual/webhook trigger's `with.fields` (`@w6w/ui/flow`'s `TriggerFieldDef`). */\nexport interface TriggerFieldDefLike {\n  key?: string;\n  type?: string;\n  default?: unknown;\n  required?: boolean;\n}\n\n/** A workflow graph step, just enough of it for the trigger-field union (A6). */\nexport interface WorkflowStepLike {\n  uses?: { app?: string };\n  with?: Record<string, unknown>;\n}\n\n/** A workflow definition, just enough of it for the trigger-field union. */\nexport interface WorkflowLike {\n  steps?: unknown;\n}\n\n/** Everything `fieldsFromWorkflow` needs from `@w6w/ui/flow` but cannot import itself. */\nexport interface WorkflowFieldCtx {\n  /** `@w6w/ui/flow`'s `isTriggerApp`, injected by the JSX caller. */\n  isTriggerApp: (app: string) => boolean;\n  /** `@w6w/ui/flow`'s `asFieldDefs`, injected by the JSX caller. */\n  asFieldDefs: (fields: unknown) => TriggerFieldDefLike[];\n}\n\n/** One field of the normalized list `TargetSelector` resolves to (A5). */\nexport interface TargetField {\n  key: string;\n  label: string;\n  type: string;\n  required?: boolean;\n  default?: unknown;\n  showIf?: ShowIfPredicate;\n}\n\n/** One row of an input-contract list (`FunctionInput`/`EndpointInput`'s common shape). */\nexport interface InputRowLike {\n  key: string;\n  label: string;\n  type: string;\n  required?: boolean;\n}\n\n/** The concrete ref (`fn_…` / `wf_…` / `ep_…`) a CallableRef/endpoint target\n *  currently points at, `\"\"` for `action`. */\nexport function targetRef(target: TargetLike): string {\n  if (target.kind === \"action\") return \"\";\n  if (target.kind === \"endpoint\") return target.endpoint;\n  return target.kind === \"function\" ? target.function : target.workflow;\n}\n\n/** Is the target fully chosen? An action needs both halves of its `uses` pair (A9). */\nexport function targetIsBound(target: TargetLike): boolean {\n  if (target.kind === \"action\") return Boolean(target.uses.app && target.uses.action);\n  return Boolean(targetRef(target));\n}\n\n/**\n * Adapt a Function's `impl` into the shape `TargetSelector` consumes (D-8):\n * an action impl to the `action` arm exactly as before; a CallableRef impl maps\n * its `kind`/`function`|`workflow` across UNCHANGED — deliberately dropping\n * `with`/`outputMap`, which `TargetLike`'s CallableRef arm has no slot for (they\n * survive on `draft.impl` itself; `targetToImpl` restores a default `with` on\n * the way back, so `implToTarget(targetToImpl(x))` round-trips `x`). An\n * absent impl still yields the empty action target.\n */\nexport function implToTarget(\n  impl: FunctionImplLike | undefined,\n): ActionTargetLike | CallableTargetLike {\n  // Draft functions have no impl yet; return an empty target\n  if (!impl) {\n    return { kind: \"action\", uses: { app: \"\", action: \"\", connection: null }, with: {} };\n  }\n  if (impl.kind === \"function\") return { kind: \"function\", function: impl.function };\n  if (impl.kind === \"workflow\") return { kind: \"workflow\", workflow: impl.workflow };\n  return { kind: \"action\", uses: impl.uses, with: impl.with };\n}\n\n/**\n * Inverse of {@link implToTarget}, over the widened D-8 domain. Never yields\n * `with: undefined` on EITHER arm — A10: `invoke-function.ts`'s\n * `resolveWith(impl.with, …)` call is unconditional and shared by both arms\n * (the CallableRef arm has its own `with` adapter pass onto the callee's inputs,\n * unlike `uncoveredForEndpoint`'s P3), so an unmapped `with` must still be\n * `{}`, not absent, on a CallableRef impl too.\n */\nexport function targetToImpl(target: ActionTargetLike | CallableTargetLike): FunctionImplLike {\n  if (target.kind === \"action\") {\n    return { uses: target.uses, with: target.with ?? {} };\n  }\n  return { ...target, with: {} };\n}\n\n/** Project a list of action/function params into the normalized `TargetField[]` (A5). */\nexport function paramsToFields(params: ParamLike[]): TargetField[] {\n  return params.map((p) => {\n    const field: TargetField = {\n      key: p.key,\n      label: p.label ?? p.key,\n      type: p.type ?? \"string\",\n      required: p.required,\n      default: p.default,\n    };\n    if (p.showIf !== undefined) {\n      field.showIf = p.showIf;\n    }\n    return field;\n  });\n}\n\n/**\n * A6: project every manual/webhook-trigger step's `with.fields` from a raw\n * workflow graph into the union of `TargetField`s, keyed by `key`, first\n * occurrence wins, order stable (planner D-2: the server broadcasts one\n * `input` object to every trigger identically). A webhook/scheduler step that\n * declares `methods`/`auth` but no `fields` contributes nothing — by reading\n * `with.fields`, not a special case. Unnamed/blank keys are skipped. `default`\n * is not carried for this arm (A5). A missing/garbage graph, or one whose\n * `isTriggerApp` predicate matches nothing, yields `[]` — never a throw.\n */\nexport function fieldsFromWorkflow(\n  workflow: WorkflowLike | null | undefined,\n  ctx: WorkflowFieldCtx,\n): TargetField[] {\n  const steps = Array.isArray(workflow?.steps) ? (workflow.steps as WorkflowStepLike[]) : [];\n  const seen = new Set<string>();\n  const out: TargetField[] = [];\n  for (const step of steps) {\n    const app = step?.uses?.app;\n    if (typeof app !== \"string\" || !ctx.isTriggerApp(app)) continue;\n    const defs = ctx.asFieldDefs(step?.with?.fields);\n    for (const def of defs) {\n      const key = def.key;\n      if (typeof key !== \"string\" || key.trim() === \"\" || seen.has(key)) continue;\n      seen.add(key);\n      out.push({ key, label: key, type: def.type ?? \"string\", required: def.required });\n    }\n  }\n  return out;\n}\n","/**\n * The seeding/coverage logic behind the shared `InputListEditor` (T3.2.1):\n * filling a Function/Endpoint's declared input list from the picked target's\n * resolved fields (`TargetSelector`'s A5/A7, `target-fields.ts`), and\n * flagging what a later target change no longer covers.\n *\n * **The policy (HITL-1, pinned).** Seed only when the input list is empty\n * AND the user has not touched it; once touched (any add/update/remove via\n * the row editor), a later target change never rewrites the list — it only\n * flags the required keys the new target no longer covers. This is the only\n * policy that cannot destroy typed work, and the flag is what T3.2.2's save\n * gate consumes.\n *\n * **Supersedes `target-fields.ts`'s `seedRowsFromFields`** — T3.1.1's\n * declared v1 stopgap (seed-a-wholly-empty-list-once, no touched/merge\n * concept). That symbol is deleted from `target-fields.ts`, not duplicated;\n * this module is its one home.\n *\n * **The pass-through guard** (the finding most likely to cause a silent\n * regression): the server dispatches an Endpoint's `action` arm on\n * `target.with === undefined` (`invoke-endpoint.ts:136-143`) — `{}` is\n * truthy, so an empty `with` does NOT pass through. `EndpointDef.input` (the\n * declared list this module seeds) is a SEPARATE field the server never\n * reads for dispatch at all, but the round-trip must still agree:\n * {@link inputsForSave} returns `undefined` (never `[]`) for an empty,\n * pass-through-mode list, so a previously authored pass-through Endpoint\n * opens and re-saves unchanged. A Function has no pass-through mode —\n * `emptyMeansPassthrough: false` never returns `undefined`, matching\n * `FunctionDef.inputs`'s non-nullable wire type (`draft.inputs.map` would\n * throw on `undefined`).\n *\n * Pure, React-free, `.ts`, no value import of `@w6w/ui` — mirrors\n * `workflow-validity.ts`/`target-fields.ts`'s shape so `node --test` can\n * load it directly (`@w6w/ui`'s barrel re-exports `.tsx`, which Node's\n * type-stripping cannot parse). `INPUT_TYPES` lives here rather than in\n * `InputListEditor.tsx` because this module's own seeding logic needs it.\n */\n\nimport type { TargetField } from \"./target-fields.ts\";\n\n/** The input-row types the two builders offer (`ActionParam`'s subset). */\nexport const INPUT_TYPES = [\"string\", \"text\", \"number\", \"boolean\", \"json\", \"secret\"] as const;\n\n/**\n * One row of an input-contract list — `FunctionInput`/`EndpointInput`'s\n * common shape (`../api/types.ts`), mirrored locally so this pure module\n * never imports a value from a `.tsx`-reexporting barrel. Structurally\n * identical to both wire types, so a page's `draft.inputs`/`draft.input`\n * needs no cast at the `InputListEditor` boundary in either direction.\n */\nexport interface InputRow {\n  key: string;\n  label: string;\n  type: string;\n  required?: boolean;\n  default?: unknown;\n  hint?: string;\n}\n\n/**\n * Is there a wholly empty, still-untouched list to seed? Any manual edit —\n * add, update or remove, via the row editor's own `onChange` — makes the\n * list the user's forever after (HITL-1); the seeding effect itself must\n * never be what sets `touched`.\n */\nexport function shouldSeed(args: { rows: InputRow[]; touched: boolean }): boolean {\n  return args.rows.length === 0 && !args.touched;\n}\n\n/**\n * `type` is the field's own type when {@link INPUT_TYPES} declares it,\n * otherwise `\"string\"` — an unlisted type (`section`, `select`, …) would\n * otherwise render a `<select>` with no matching `<option>` and silently\n * change the value.\n */\nfunction normalizeType(type: string): string {\n  return (INPUT_TYPES as readonly string[]).includes(type) ? type : \"string\";\n}\n\n/**\n * `rows` plus one appended row per `fields` key not already present, in\n * field order. **Never modifies or removes an existing row, never\n * re-orders.** A seeded row is\n * `{ key, label: field.label ?? field.key, type, required: Boolean(field.required) }`\n * and nothing else — `default`/`hint` are deliberately not copied, because\n * the row editor cannot show or remove them and they would become invisible\n * state on the saved definition. Fields with a missing/blank key are\n * skipped; a duplicate key (in `fields`, or already present in `rows`)\n * seeds once.\n */\nexport function mergeSeed(rows: InputRow[], fields: TargetField[]): InputRow[] {\n  const seen = new Set(rows.map((r) => r.key));\n  const appended: InputRow[] = [];\n  for (const field of fields) {\n    const key = field.key;\n    if (typeof key !== \"string\" || key.trim() === \"\" || seen.has(key)) continue;\n    seen.add(key);\n    appended.push({\n      key,\n      label: field.label ?? key,\n      type: normalizeType(field.type),\n      required: Boolean(field.required),\n    });\n  }\n  return appended.length === 0 ? rows : [...rows, ...appended];\n}\n\n/**\n * Is `field` visible under the given effective-value lookup?\n * Implements `packages/ui/src/ParamsForm.tsx:20-29`'s `isParamVisible`\n * predicate, honouring all four arms (`equals`, `in`, `notIn`, `truthy`).\n */\nfunction isFieldVisible(field: TargetField, effective: (key: string) => unknown): boolean {\n  const c = field.showIf;\n  if (!c) return true;\n  const v = effective(c.field);\n  if (c.equals !== undefined) return v === c.equals;\n  if (c.in) return c.in.some((x) => x === v);\n  if (c.notIn) return !c.notIn.some((x) => x === v);\n  if (c.truthy !== undefined) return c.truthy ? !!v : !v;\n  return true;\n}\n\n/**\n * Does `default` satisfy \"usable\"? A usable default can stand in for an\n * explicitly mapped value — `false` and `0` are usable, `undefined`/`null`\n * and whitespace-only strings are not.\n * Implements the `v === undefined || v === null` / `v.trim() !== \"\"`\n * rejection from `packages/ui/src/StepBuilderModal.tsx:706-707`.\n */\nfunction hasUsableDefault(d: unknown): boolean {\n  if (d === undefined || d === null) return false;\n  if (typeof d === \"string\") return d.trim() !== \"\";\n  return true;\n}\n\n/**\n * The required field keys `fields` declares that no row in `rows` covers,\n * in field order — what a target change leaves for the operator to notice\n * once the list is the user's (HITL-1) and can no longer be auto-filled.\n * Informational here: T3.2.2's save gate is what turns this into a block,\n * and imports this same predicate rather than forking a second copy of it.\n *\n * Skips a required field that is currently hidden by its own `showIf` or\n * that declares a usable `default` — mirroring\n * `packages/ui/src/StepBuilderModal.tsx:686-711`'s `requiredParamsFilled`.\n * `values` is the `with` mapping; omitting it leaves existing callers'\n * behaviour unchanged apart from the two new skips.\n */\nexport function uncoveredRequiredKeys(\n  rows: InputRow[],\n  fields: TargetField[],\n  values?: Record<string, unknown>,\n): string[] {\n  const covered = new Set(rows.map((r) => r.key));\n  const effective = (key: string) =>\n    values?.[key] !== undefined ? values[key] : fields.find((f) => f.key === key)?.default;\n  const out: string[] = [];\n  for (const field of fields) {\n    if (!field.required) continue;\n    const key = field.key;\n    if (typeof key !== \"string\" || key.trim() === \"\" || covered.has(key) || out.includes(key)) {\n      continue;\n    }\n    if (!isFieldVisible(field, effective)) continue;\n    if (hasUsableDefault(field.default)) continue;\n    out.push(key);\n  }\n  return out;\n}\n\n/**\n * The write-back both pages route their input list through (see the module\n * docstring's pass-through guard). The overloads let a call site that\n * passes the literal `emptyMeansPassthrough: false` (every Function save)\n * keep a non-nullable return type at compile time, matching\n * `FunctionDef.inputs`'s wire shape without a cast.\n */\nexport function inputsForSave(rows: InputRow[], opts: { emptyMeansPassthrough: false }): InputRow[];\nexport function inputsForSave(\n  rows: InputRow[],\n  opts: { emptyMeansPassthrough: boolean },\n): InputRow[] | undefined;\nexport function inputsForSave(\n  rows: InputRow[],\n  opts: { emptyMeansPassthrough: boolean },\n): InputRow[] | undefined {\n  if (opts.emptyMeansPassthrough && rows.length === 0) return undefined;\n  return rows;\n}\n","/**\n * The **save gate**'s arm dispatch (T3.2.2): given a picked target, decide\n * *which* key set counts as \"feeding\" its required fields — and when the\n * question does not apply at all — then hand the actual set difference to\n * {@link uncoveredRequiredKeys}.\n *\n * **This module deliberately owns no coverage rule of its own.**\n * `uncoveredRequiredKeys` lives in `./input-seeding.ts` because T3.2.1's\n * `InputListEditor` *renders* the uncovered-required flag from it. Two copies\n * of one coverage rule would drift, and the user would see a flag with no\n * block or a block with no flag. Everything below is dispatch: pick the\n * covered set, or skip.\n *\n * ## The five cases, each anchored to the line that decides it at runtime\n *\n * | # | case | gate |\n * |---|---|---|\n * | P1 | Endpoint, `action` arm, `target.with === undefined` | **skipped** — pass-through |\n * | P2 | Endpoint, `action` arm, `target.with` is an object (**incl. `{}`**) | required params must be non-blank cells of `with` |\n * | P3 | Endpoint, `function`/`workflow` arm, declared `input` list empty | **skipped** — no `with` mechanism exists on these arms |\n * | P4 | Endpoint, `function`/`workflow` arm, declared list non-empty | required target keys must appear as declared row keys |\n * | P5 | **Function**, always | required params must be non-blank cells of `impl.with` |\n *\n * P1 is `=== undefined` **only**. `bll/invoke-endpoint.ts:136-143` dispatches\n * `target.with ? resolveWith(…) : input.input`, and `{}` is truthy — so an\n * empty object does **not** pass through, and treating it as if it did would\n * ship exactly the unfed-required-field bug this gate exists to block. The\n * consequence, stated rather than fixed: `EndpointsPage`'s picker writes\n * `with: built.with ?? {}`, so an action-arm **pass-through Endpoint can no\n * longer be authored through the UI at all** — it can only be opened and\n * re-saved. That was already true server-side before this gate existed\n * (`FOLLOWUPS.md`).\n *\n * P1/P2 key on `target.with` and **never** on the declared list. That matters\n * because T3.2.1 made a deliberately emptied Endpoint list save `input`\n * *absent* rather than `[]` — so \"emptied\" and \"never declared\" are\n * indistinguishable on the wire, and a gate that read pass-through off the\n * list's emptiness would misread one for the other. P3's skip is justified by\n * the *absence of a `with` mechanism* on the callable arms, where the payload\n * always passes through by key identity, not by the list being empty.\n *\n * P5 has no skip: `bll/invoke-function.ts:101-107` calls\n * `resolveWith(impl.with, …)` unconditionally, so a Function has no\n * pass-through mode. With **no action chosen** the field list is empty and\n * coverage is vacuously satisfied, which is what preserves the deliberate\n * save-gate asymmetry — `FunctionsPage` stays saveable incomplete (its\n * `valid`/incomplete badge is the signal), while `EndpointsPage` keeps its\n * separate `targetIsBound` term.\n *\n * ## Known limitation — this gate is CLIENT-SIDE ONLY\n *\n * A determined API caller can still `POST /functions` or `POST /endpoints`\n * with a malformed definition. Both server `validateDefinition`s are\n * structural only (`api/functions.ts:26-37` checks the *types* of\n * `impl.uses.app`/`action`; `api/endpoints.ts:109-154` checks `target.kind`\n * plus its ref/uses fields and the `exposure.security` shape) — neither\n * invokes anything nor looks at coverage, so a dangling ref or an unmapped\n * required param stores fine and fails only at invoke time. Closing that is a\n * server-side write, a boundary expansion out of scope for this node; it is\n * stated here rather than papered over.\n *\n * Pure, React-free, `.ts`, no import of `@w6w/ui` — directly or transitively.\n * `./target-fields.ts`, `./input-seeding.ts` and `./with-mapping.ts` are all\n * `@w6w/ui`-free by the same design (`workflow-validity.ts`'s header explains\n * the wall: the barrel re-exports `.tsx`, which `node --test` cannot parse).\n * The normalized field list therefore arrives as a plain array parameter,\n * resolved by the caller — `TargetSelector`'s `onResolved` — exactly as\n * `workflow-validity.ts:69`'s injected `ValidityContext` does.\n */\n\nimport { type InputRow, uncoveredRequiredKeys } from \"./input-seeding.ts\";\nimport type { FunctionImplLike, TargetField, TargetLike } from \"./target-fields.ts\";\n\n/**\n * Check if a `with` mapping value is considered \"fed\" (non-empty).\n * A cell is \"fed\" when it contains a non-empty value:\n * - ExprValue objects are always considered fed (they have meaningful content)\n * - Strings are fed if non-blank after trimming\n * - Everything else (null, undefined, empty string) is not fed\n */\nfunction isFedValue(v: unknown): boolean {\n  if (v == null) return false;\n  if (typeof v === \"string\") return v.trim() !== \"\";\n  if (typeof v === \"object\" && \"type\" in v && v.type === \"expr\") return true;\n  // Legacy `{ \"$\": path }` format or any other object is considered fed\n  return typeof v === \"object\";\n}\n\n/**\n * The mapping cells that actually feed something, shaped as the covered rows\n * {@link uncoveredRequiredKeys} diffs against. A cell is \"fed\" when it\n * contains a non-empty value — a whitespace-only literal maps nothing, and\n * `updateWith` deletes a cleared key outright.\n */\nfunction coveredRowsFromWith(withBlock: Record<string, unknown>): InputRow[] {\n  const rows: InputRow[] = [];\n  for (const key of Object.keys(withBlock)) {\n    if (!isFedValue(withBlock[key])) continue;\n    rows.push({ key, label: key, type: \"string\" });\n  }\n  return rows;\n}\n\n/**\n * The required target-field keys an Endpoint does **not** feed — P1–P4 above.\n * Empty means saveable as far as coverage is concerned; `EndpointsPage`'s own\n * `targetIsBound`/`key` terms are separate and survive unchanged.\n *\n * `fields` is the target's normalized field list as `TargetSelector` resolved\n * it. While a target's detail is still loading it is `[]`, so the gate is\n * vacuous until the fields arrive — this fails **open**, deliberately: an\n * unresolvable target (a deleted app, a failed fetch) must never trap an\n * author in a form they cannot save.\n */\nexport function uncoveredForEndpoint(args: {\n  target: TargetLike;\n  rows: InputRow[];\n  fields: TargetField[];\n}): string[] {\n  const { target, rows, fields } = args;\n  if (target.kind === \"action\") {\n    if (target.with === undefined) return []; // P1 — pass-through, nothing to check\n    return uncoveredRequiredKeys(coveredRowsFromWith(target.with), fields, target.with); // P2\n  }\n  if (rows.length === 0) return []; // P3 — the callable arms have no `with` mechanism\n  return uncoveredRequiredKeys(rows, fields); // P4 — key-name identity\n}\n\n/**\n * The required action-param keys a Function's `impl.with` does not map — P5.\n * No skip arm: a Function has no pass-through mode. An unbound Function\n * resolves to an empty `fields`, so this returns `[]` and the Functions save\n * gate keeps allowing a deliberately incomplete save.\n */\nexport function uncoveredForFunction(args: {\n  impl: FunctionImplLike | undefined;\n  fields: TargetField[];\n}): string[] {\n  // Draft functions have no impl yet; no fields are covered\n  if (!args.impl) {\n    return args.fields.filter((f) => f.required).map((f) => f.key);\n  }\n  return uncoveredRequiredKeys(\n    coveredRowsFromWith(args.impl.with ?? {}),\n    args.fields,\n    args.impl.with ?? {},\n  );\n}\n","/**\n * Coerce a text field's value to the canonical input's declared type, for a callable's test-invoke\n * form. Empty ⇒ undefined (the field is omitted from the payload). Unparseable `number`/`json` text\n * is passed through raw, so the server's own validation names the problem.\n */\nexport function coerceInput(type: string, raw: string): unknown {\n  if (raw === \"\") return undefined;\n  switch (type) {\n    case \"number\": {\n      const n = Number(raw);\n      return Number.isNaN(n) ? raw : n;\n    }\n    case \"boolean\":\n      return raw === \"true\";\n    case \"json\":\n      try {\n        return JSON.parse(raw);\n      } catch {\n        return raw;\n      }\n    default:\n      return raw;\n  }\n}\n"],"names":["targetRef","target","targetIsBound","implToTarget","impl","targetToImpl","paramsToFields","params","p","field","fieldsFromWorkflow","workflow","ctx","_a","_b","steps","seen","out","step","app","defs","def","key","INPUT_TYPES","shouldSeed","args","normalizeType","type","mergeSeed","rows","fields","appended","isFieldVisible","effective","c","v","x","hasUsableDefault","d","uncoveredRequiredKeys","values","covered","r","f","inputsForSave","opts","isFedValue","coveredRowsFromWith","withBlock","uncoveredForEndpoint","uncoveredForFunction","coerceInput","raw","n"],"mappings":"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"}

package/dist/connections-CjjYeRqb.js

@@ -0,0 +1,78 @@
+import { useQuery as s, useQueryClient as i, useMutation as u } from "@tanstack/react-query";
+import { u as o } from "./client-context-CX61Bgw-.js";
+const y = (n) => ["app-connections", n];
+function l(n, e) {
+  return n.console.connections.listForApp(e);
+}
+function F(n, e = !0) {
+  const t = o();
+  return s({
+    queryKey: y(n),
+    queryFn: () => l(t, n),
+    enabled: e
+  });
+}
+const c = ["connections"];
+function f(n) {
+  return n.connections.list();
+}
+function Q() {
+  const n = o();
+  return s({ queryKey: c, queryFn: () => f(n) });
+}
+const r = (n) => ["connection", n];
+function p(n, e) {
+  return n.console.connections.get(e);
+}
+function m(n) {
+  const e = o();
+  return s({ queryKey: r(n), queryFn: () => p(e, n) });
+}
+function d(n, e, t) {
+  return n.console.connections.create(e, t);
+}
+function q(n, e, t) {
+  return n.console.connections.update(e, t);
+}
+function v(n) {
+  const e = o(), t = i();
+  return u({
+    mutationFn: (a) => q(e, n, a),
+    onSuccess: () => {
+      t.invalidateQueries({ queryKey: c }), t.invalidateQueries({ queryKey: r(n) });
+    }
+  });
+}
+function A(n) {
+  const e = o(), t = i();
+  return u({
+    mutationFn: () => e.console.connections.test(n),
+    onSuccess: () => {
+      t.invalidateQueries({ queryKey: r(n) }), t.invalidateQueries({ queryKey: c });
+    }
+  });
+}
+function M() {
+  const n = o(), e = i();
+  return u({
+    mutationFn: (t) => n.console.connections.delete(t),
+    onSuccess: () => e.invalidateQueries({ queryKey: c })
+  });
+}
+export {
+  y as a,
+  c as b,
+  r as c,
+  d,
+  l as e,
+  m as f,
+  p as g,
+  F as h,
+  Q as i,
+  M as j,
+  A as k,
+  f as l,
+  v as m,
+  q as u
+};
+//# sourceMappingURL=connections-CjjYeRqb.js.map

package/dist/connections-CjjYeRqb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connections-CjjYeRqb.js","sources":["../src/repos/connections.ts"],"sourcesContent":["/**\n * The connections-for-one-app repo — the Target selector's connection picker.\n *\n * Moved from Studio's `repos/connections.ts` (B-3a); the Studio file re-exports these names. The\n * client comes from `useEmbedClient()`. D-12e moved the rest of the file here (list, single,\n * create, update, test, delete); Studio's `repos/connections.ts` is now a pure re-export shim.\n */\nimport { useMutation, useQuery, useQueryClient } from \"@tanstack/react-query\";\nimport type { ConnectionSummary, W6WClient } from \"@w6w/sdk\";\nimport type { ConnectionTestResult } from \"@w6w/sdk/console\";\nimport { useEmbedClient } from \"../draft/client-context.ts\";\n\nexport type { ConnectionSummary } from \"@w6w/sdk\";\n\nexport const connectionsForAppKey = (appId: string) => [\"app-connections\", appId] as const;\n\nexport function listConnectionsForApp(\n  client: W6WClient,\n  appId: string,\n): Promise<ConnectionSummary[]> {\n  return client.console.connections.listForApp(appId);\n}\n\n/**\n * `enabled` defaults to `true`. `TargetSelector` passes `app !== \"\"` — its original\n * pre-migration guard, preserved exactly.\n */\nexport function useConnectionsForAppQuery(appId: string, enabled = true) {\n  const client = useEmbedClient();\n  return useQuery({\n    queryKey: connectionsForAppKey(appId),\n    queryFn: () => listConnectionsForApp(client, appId),\n    enabled,\n  });\n}\n\n// ── connections (list, all apps) ──────────────────────────────────────\n// BASE partner surface — client.connections.list() already exists. There is no\n// console.connections.list(); do NOT route this one through client.console.connections.\n\nexport const connectionsKey = [\"connections\"] as const;\n\nexport function listConnections(client: W6WClient): Promise<ConnectionSummary[]> {\n  return client.connections.list();\n}\n\nexport function useConnectionsQuery() {\n  const client = useEmbedClient();\n  return useQuery({ queryKey: connectionsKey, queryFn: () => listConnections(client) });\n}\n\n// ── connection (single) ───────────────────────────────────────────────\n\nexport const connectionKey = (id: string) => [\"connection\", id] as const;\n\nexport function getConnection(client: W6WClient, id: string): Promise<ConnectionSummary> {\n  return client.console.connections.get(id);\n}\n\nexport function useConnectionQuery(id: string) {\n  const client = useEmbedClient();\n  return useQuery({ queryKey: connectionKey(id), queryFn: () => getConnection(client, id) });\n}\n\n// ── create / update (plain fetchers) ──────────────────────────────────\n\nexport function createConnection(\n  client: W6WClient,\n  appId: string,\n  body: {\n    authKey: string;\n    credential: Record<string, unknown>;\n    displayName?: string;\n    profile?: Record<string, unknown>;\n  },\n): Promise<ConnectionSummary> {\n  return client.console.connections.create(appId, body);\n}\n\n/** The write `W6WEmbedProvider` hands the ui adapter as `updateConnection` (the SDK adapter has none). */\nexport function updateConnection(\n  client: W6WClient,\n  id: string,\n  body: { displayName?: string; credential?: Record<string, unknown> },\n): Promise<ConnectionSummary> {\n  return client.console.connections.update(id, body);\n}\n\n// ── mutations ────────────────────────────────────────────────────────\n\nexport function useUpdateConnectionMutation(connectionId: string) {\n  const client = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (body: { displayName?: string; credential?: Record<string, unknown> }) =>\n      updateConnection(client, connectionId, body),\n    onSuccess: () => {\n      qc.invalidateQueries({ queryKey: connectionsKey });\n      qc.invalidateQueries({ queryKey: connectionKey(connectionId) });\n    },\n  });\n}\n\nexport function useTestConnectionMutation(connectionId: string) {\n  const client = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (): Promise<ConnectionTestResult> => client.console.connections.test(connectionId),\n    onSuccess: () => {\n      qc.invalidateQueries({ queryKey: connectionKey(connectionId) });\n      qc.invalidateQueries({ queryKey: connectionsKey });\n    },\n  });\n}\n\nexport function useDeleteConnectionMutation() {\n  const client = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (id: string) => client.console.connections.delete(id),\n    onSuccess: () => qc.invalidateQueries({ queryKey: connectionsKey }),\n  });\n}\n"],"names":["connectionsForAppKey","appId","listConnectionsForApp","client","useConnectionsForAppQuery","enabled","useEmbedClient","useQuery","connectionsKey","listConnections","useConnectionsQuery","connectionKey","id","getConnection","useConnectionQuery","createConnection","body","updateConnection","useUpdateConnectionMutation","connectionId","qc","useQueryClient","useMutation","useTestConnectionMutation","useDeleteConnectionMutation"],"mappings":";;AAcO,MAAMA,IAAuB,CAACC,MAAkB,CAAC,mBAAmBA,CAAK;AAEzE,SAASC,EACdC,GACAF,GAC8B;AAC9B,SAAOE,EAAO,QAAQ,YAAY,WAAWF,CAAK;AACpD;AAMO,SAASG,EAA0BH,GAAeI,IAAU,IAAM;AACvE,QAAMF,IAASG,EAAA;AACf,SAAOC,EAAS;AAAA,IACd,UAAUP,EAAqBC,CAAK;AAAA,IACpC,SAAS,MAAMC,EAAsBC,GAAQF,CAAK;AAAA,IAClD,SAAAI;AAAA,EAAA,CACD;AACH;AAMO,MAAMG,IAAiB,CAAC,aAAa;AAErC,SAASC,EAAgBN,GAAiD;AAC/E,SAAOA,EAAO,YAAY,KAAA;AAC5B;AAEO,SAASO,IAAsB;AACpC,QAAMP,IAASG,EAAA;AACf,SAAOC,EAAS,EAAE,UAAUC,GAAgB,SAAS,MAAMC,EAAgBN,CAAM,GAAG;AACtF;AAIO,MAAMQ,IAAgB,CAACC,MAAe,CAAC,cAAcA,CAAE;AAEvD,SAASC,EAAcV,GAAmBS,GAAwC;AACvF,SAAOT,EAAO,QAAQ,YAAY,IAAIS,CAAE;AAC1C;AAEO,SAASE,EAAmBF,GAAY;AAC7C,QAAMT,IAASG,EAAA;AACf,SAAOC,EAAS,EAAE,UAAUI,EAAcC,CAAE,GAAG,SAAS,MAAMC,EAAcV,GAAQS,CAAE,EAAA,CAAG;AAC3F;AAIO,SAASG,EACdZ,GACAF,GACAe,GAM4B;AAC5B,SAAOb,EAAO,QAAQ,YAAY,OAAOF,GAAOe,CAAI;AACtD;AAGO,SAASC,EACdd,GACAS,GACAI,GAC4B;AAC5B,SAAOb,EAAO,QAAQ,YAAY,OAAOS,GAAII,CAAI;AACnD;AAIO,SAASE,EAA4BC,GAAsB;AAChE,QAAMhB,IAASG,EAAA,GACTc,IAAKC,EAAA;AACX,SAAOC,EAAY;AAAA,IACjB,YAAY,CAACN,MACXC,EAAiBd,GAAQgB,GAAcH,CAAI;AAAA,IAC7C,WAAW,MAAM;AACf,MAAAI,EAAG,kBAAkB,EAAE,UAAUZ,EAAA,CAAgB,GACjDY,EAAG,kBAAkB,EAAE,UAAUT,EAAcQ,CAAY,GAAG;AAAA,IAChE;AAAA,EAAA,CACD;AACH;AAEO,SAASI,EAA0BJ,GAAsB;AAC9D,QAAMhB,IAASG,EAAA,GACTc,IAAKC,EAAA;AACX,SAAOC,EAAY;AAAA,IACjB,YAAY,MAAqCnB,EAAO,QAAQ,YAAY,KAAKgB,CAAY;AAAA,IAC7F,WAAW,MAAM;AACf,MAAAC,EAAG,kBAAkB,EAAE,UAAUT,EAAcQ,CAAY,GAAG,GAC9DC,EAAG,kBAAkB,EAAE,UAAUZ,EAAA,CAAgB;AAAA,IACnD;AAAA,EAAA,CACD;AACH;AAEO,SAASgB,IAA8B;AAC5C,QAAMrB,IAASG,EAAA,GACTc,IAAKC,EAAA;AACX,SAAOC,EAAY;AAAA,IACjB,YAAY,CAACV,MAAeT,EAAO,QAAQ,YAAY,OAAOS,CAAE;AAAA,IAChE,WAAW,MAAMQ,EAAG,kBAAkB,EAAE,UAAUZ,GAAgB;AAAA,EAAA,CACnE;AACH;"}

package/dist/document-sources-C0grrtdq.js

@@ -0,0 +1,86 @@
+import { parse as u } from "yaml";
+function a(e) {
+  if (!e) return !1;
+  switch (e.kind) {
+    case "function":
+    case "endpoint":
+    case "workflow":
+      return !0;
+    default:
+      return !1;
+  }
+}
+function f(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 };
+    default:
+      return null;
+  }
+}
+function k({
+  resource: e,
+  target: n,
+  hasAdapter: r
+}) {
+  return (n.kind === "function" || n.kind === "workflow") && n.kind === e.kind && n.id === e.id ? r ? "warn" : "block" : "allow";
+}
+function o(e) {
+  let n;
+  if (e.format === "json")
+    try {
+      n = JSON.parse(e.content);
+    } catch {
+      return null;
+    }
+  else if (e.format === "yaml")
+    try {
+      n = u(e.content);
+    } catch {
+      return null;
+    }
+  else
+    return null;
+  return typeof n != "object" || n === null || Array.isArray(n) ? null : n;
+}
+function d(e) {
+  return e.map((n) => {
+    const r = o(n);
+    if (!r) return { key: n.key };
+    const i = Object.keys(r);
+    return i.length > 0 ? { key: n.key, fields: i.map((t) => ({ key: t })) } : { key: n.key };
+  });
+}
+function y(e) {
+  const n = {};
+  for (const r of e) {
+    n[`documents.${r.key}`] = r.content;
+    const i = o(r);
+    if (i)
+      for (const [t, l] of Object.entries(i))
+        n[`documents.${r.key}.${t}`] = l;
+  }
+  return n;
+}
+export {
+  y as d,
+  k as e,
+  a as i,
+  d as p,
+  f as t
+};
+//# sourceMappingURL=document-sources-C0grrtdq.js.map