@w6w/embed 0.2.1 → 0.2.19

package/dist/chrome/ConfirmModal.d.ts

@@ -1,6 +1,9 @@
+import { ReactNode } from 'react';
 interface ConfirmModalProps {
     title: string;
     message: string;
+    /** Optional content rendered under the message (e.g. a list of impacted items). */
+    children?: ReactNode;
     /** Fired when the user confirms. The caller clears its pending state via onClose. */
     onConfirm: () => void;
     /** Fired on Cancel, Esc, or outside-click — dismisses without confirming. */
@@ -16,5 +19,5 @@ interface ConfirmModalProps {
  * confirmation prompt for destructive actions: Confirm fires `onConfirm`;
  * Cancel/Esc/outside-click fires `onClose` only (no confirmation).
  */
-export declare function ConfirmModal({ title, message, onConfirm, onClose, confirmLabel, cancelLabel, destructive, }: ConfirmModalProps): import("react").JSX.Element;
+export declare function ConfirmModal({ title, message, children, onConfirm, onClose, confirmLabel, cancelLabel, destructive, }: ConfirmModalProps): import("react").JSX.Element;
 export {};

package/dist/chrome/DangerZone.d.ts

@@ -1,8 +1,9 @@
 export interface DangerZoneProps {
-    /** Whether the resource is archived yet. `true` renders Delete; `false`
-     *  renders Archive. Every kind has an archive-before-delete step as of
-     *  T4.1.1 (Function/Endpoint newly, Workflow already did). */
+    /** Archived resources offer Delete; other resources also offer Archive. */
     archived: boolean;
+    /** Offer Delete before archiving when the caller handles both lifecycle operations. */
+    allowDirectDelete?: boolean;
+    pending?: boolean;
     /** Accessible name for the Delete icon button — `title`/`aria-label` only
      *  (`IconButton.tsx`), e.g. "Delete this function". */
     deleteLabel: string;

package/dist/chrome/ExecutionProfileHeader.d.ts

@@ -57,11 +57,11 @@ export interface ExecutionProfileHeaderProps {
      *  `?edit=`; `CallableEditorChrome` navigates to the kind's listing). */
     onBack: () => void;
     /** The back control's visible text — host-owned copy (`"← Workflows"`,
-     *  `descriptor.editor.backLabel`). */
-    backLabel: string;
+     *  `descriptor.editor.backLabel`). `null`: no back control is rendered. */
+    backLabel: string | null;
     /** Editable (Workflow) or read-only (Function/Endpoint) title. */
     title: ExecutionProfileTitle;
-    /** Rendered immediately after a read-only title — the `incomplete` badge. */
+    /** Rendered immediately after the title, including an editable workflow name. */
     titleAdornment?: ReactNode;
     /** The host's action row (buttons only; this component owns the wrapper). */
     actions: ReactNode;

package/dist/chrome/JsonToggle.d.ts

@@ -1,4 +1,19 @@
-export type JsonToggleMode = "synced" | "disconnected";
+/**
+ * `apply`: the dialog edits its own copy of the text and hands it to the host only on Apply (the
+ * workflow editor, whose canvas re-reads it). `disconnected`: the host owns the text and saves it.
+ */
+export type JsonToggleMode = "apply" | "disconnected";
+/** What `prepareApply` makes of the dialog's text: the text to apply, or why it can't be. */
+export type JsonApplyCheck = {
+    ok: true;
+    /** The text `onApply` receives — the edited text with any protected field put back. */
+    text: string;
+    /** Top-level fields whose loaded value was restored; listed under the editor. */
+    restored: string[];
+} | {
+    ok: false;
+    error: string;
+};
 /** The header icon button: `IconButton` with the set's `json` glyph — the
  *  curly-brace icon, distinct from the `code` `</>` "Call from code" icon
  *  beside it, so the two stop reading as the same button. The local
@@ -14,17 +29,15 @@ export interface JsonToggleProps {
     /** Modal title. */
     title: string;
     mode: JsonToggleMode;
-    /** Parent-owned text; the component keeps NO copy of it. */
+    /** disconnected: parent-owned text, the component keeps NO copy of it. apply: the text the
+     *  dialog starts from each time it opens. */
     value: string;
-    /** Every JsonEditor change, both modes. */
-    onChange: (text: string) => void;
-    /** JsonEditor's, error ?? null. */
-    onValidityChange?: (v: {
-        valid: boolean;
-        error: string | null;
-    }) => void;
-    /** When non-null: "Invalid JSON — {invalidReason}" (Workflow's existing line). */
-    invalidReason?: string | null;
+    /** disconnected only: every JsonEditor change. */
+    onChange?: (text: string) => void;
+    /** apply only: validates the dialog's text on every edit; Apply is enabled only on `ok`. */
+    prepareApply?: (text: string) => JsonApplyCheck;
+    /** apply only: the checked text, on Apply. */
+    onApply?: (text: string) => void;
     /** Evaluated on `value` every render; non-null → shown in
      *  <p className="muted small" data-testid="json-toggle-reason">. */
     guard?: (text: string) => string | null;
@@ -38,14 +51,10 @@ export interface JsonToggleProps {
     editorLabel: string;
 }
 /**
- * The JSON⇄editor toggle's chrome — the header icon button's dialog, extracted
- * verbatim from `WorkflowsPage.tsx`'s raw-JSON modal (T2.1.1 D-2) so a second
- * host can reuse it in `mode="disconnected"` (T2.1.2). Wraps `@w6w/ui`'s
- * `JsonEditor` and studio's own `Modal` (not `@w6w/ui`'s) — both existing
- * JSON-toggle-shaped precedents in this repo use studio's `Modal`.
- *
- * The component holds NO copy of `value`: every render shows exactly what the
- * parent hands it, which is what keeps a reopened dialog free of a stale
- * snapshot from the previous time it was open.
+ * The JSON⇄editor toggle's chrome — the header icon button's dialog, extracted from
+ * `WorkflowsPage.tsx`'s raw-JSON modal (T2.1.1 D-2) and reused by the Function and Endpoint
+ * editors in `mode="disconnected"` (T2.1.2). Wraps `@w6w/ui`'s `JsonEditor` and studio's own
+ * `Modal`. The editor fills the dialog and scrolls inside itself (`.modal-json`), so the title,
+ * the description and the footer buttons stay in view on a long definition.
  */
 export declare function JsonToggle(props: JsonToggleProps): JSX.Element | null;

package/dist/chrome/Modal.d.ts

@@ -10,11 +10,13 @@ interface ModalProps {
      *  the title and this node share one `.modal-head` row; absent, the title
      *  renders as a direct child exactly as before. */
     headerRight?: React.ReactNode;
+    /** Extra class on the `<dialog>` (e.g. `modal-json`, the fill-and-scroll JSON layout). */
+    className?: string;
 }
 /**
  * Small dialog modal. Built on the native <dialog> element so it gets focus
  * trapping, Esc-dismiss, and accessibility semantics for free. A button
  * positioned over the backdrop catches outside-clicks to close.
  */
-export declare function Modal({ title, onClose, children, wide, xl, headerRight, }: ModalProps): import("react").JSX.Element;
+export declare function Modal({ title, onClose, children, wide, xl, headerRight, className, }: ModalProps): import("react").JSX.Element;
 export {};

package/dist/chrome/RightRail.d.ts

@@ -12,9 +12,14 @@ export interface RailTool {
     isAvailable(ctx: WorkspaceCallable): boolean;
     /** Panel renders its own heading when it includes section actions. */
     rendersHeading?: boolean;
-    Panel: ComponentType<{
+    /** Absent for an action tool: one with `onActivate` opens nothing in the rail. */
+    Panel?: ComponentType<{
         ctx: WorkspaceCallable;
     }>;
+    /** An action tool: the strip button calls this instead of toggling a panel (e.g. a modal). */
+    onActivate?(ctx: WorkspaceCallable): void;
+    /** A dot on the strip button: the tool has something set. */
+    hasIndicator?(ctx: WorkspaceCallable): boolean;
 }
 /** `storageKey === null`: no key to persist under yet (pin 12) — the strip renders closed and
  * nothing is written to localStorage. No available tool ⇒ no rail element at all (C/D-C3). */

package/dist/chrome/VersionHistoryModal.d.ts

@@ -35,4 +35,6 @@ export declare function VersionHistoryModal(props: {
     id: string;
     versionNumber: number;
     onClose: () => void;
+    /** Editor hosts serialize draft saves before restoring, then refresh their buffer. */
+    onRestore?: (versionNumber: number) => Promise<void>;
 }): import("react").JSX.Element;

package/dist/chrome/index.d.ts

@@ -33,6 +33,7 @@ export { codeTool } from '../rail/CodeTool.tsx';
 export { ErrorHandlerSection, errorHandlingTool } from '../rail/ErrorHandlingTool.tsx';
 export type { ErrorHandlerKind, ErrorHandlerSectionProps } from '../rail/ErrorHandlingTool.tsx';
 export { ProjectExpressionScope, useProjectExpressionOptions } from '../rail/ExpressionScope.tsx';
+export { startingStateTool } from '../rail/StartingStateTool.tsx';
 export { editorRailTools } from '../rail/editor-tools.ts';
 export { TargetSelector } from '../editor/TargetSelector.tsx';
 export type { TargetKind, TargetSelectorProps, TargetValue, } from '../editor/TargetSelector.types.ts';

package/dist/chrome/workspace.d.ts

@@ -1,4 +1,5 @@
-import { CallablePolicy, SnippetInput, TriggerPreview } from '@w6w/embed/lib';
+import { CallablePolicy, SnippetInput, TriggerPreview, WorkflowVariableRow } from '@w6w/embed/lib';
+import { WorkflowConnectionResources } from '@w6w/ui/flow';
 import { ReactNode } from 'react';
 /**
  * T2.1.2: widened to a discriminated union, one arm per kind — every new
@@ -46,10 +47,26 @@ export type WorkspaceCallable = {
     onPolicyChange?: (policy: CallablePolicy) => void;
 } | {
     kind: "workflow";
+    connectionResources?: WorkflowConnectionResources;
     id: string;
     label?: string;
     key?: string;
     triggers?: TriggerPreview[];
+    /** Stable editor-owned actions serialize pending draft saves and refresh its buffer. */
+    onRestoreVersion?: (versionNumber: number) => Promise<void>;
+    /** Whether the editor buffer matches the published snapshot; absent while loading. */
+    definitionStatus?: "published" | "draft" | "unpublished";
+    /** Use the editor's save/publish guard from the sidebar too. Must be stable. */
+    onPublish?: () => Promise<void>;
+    publishDisabled?: boolean;
+    authoringSettings?: {
+        autoSave: boolean;
+        savePosition: boolean;
+    };
+    onAuthoringSettingChange?: (key: "autoSave" | "savePosition", value: boolean) => void;
+    variables?: WorkflowVariableRow[];
+    onVariablesChange?: (variables: WorkflowVariableRow[]) => void;
+    onOpenHistory?: () => void;
     /**
      * The workflow's run-level error policy, and the writer that applies it
      * (core Workflow RFC — *Amendment — 2026-08-21: the run-level error
@@ -68,10 +85,28 @@ export type WorkspaceCallable = {
      */
     policy?: CallablePolicy;
     onPolicyChange?: (policy: CallablePolicy) => void;
+    /** `Workflow.initialState` is a non-empty object: the rail State tool's dot. */
+    hasStartingState?: boolean;
+    /** `Workflow.initialState` as the editor holds it: the State panel's starting state preview. */
+    startingState?: Record<string, unknown>;
+    /**
+     * Opens the canvas editor's starting state editor; the rail State tool shows only when it
+     * is set. Same ⚠️ as `onPolicyChange`: it MUST be referentially stable.
+     */
+    onOpenStartingState?: () => void;
+    /**
+     * Opens one of this workflow's runs on the canvas (the History "Open run" path): the State
+     * panel's link to the run its current state comes from. Same ⚠️: referentially stable.
+     */
+    onOpenRun?: (runId: string) => void;
 } | {
     kind: "connection";
     id: string;
     label?: string;
+    /** Set by the connection ACTION page: the Code tool needs an action to show a snippet. */
+    action?: string;
+    /** Declared param keys of `action` (plain data — the registry keys on JSON). */
+    params?: readonly SnippetInput[];
 } | null;
 /** Derived from {@link WorkspaceCallable}, never redeclared — the arm a
  * `RailTool.isAvailable`/route wrapper narrows on. */

package/dist/coerce-input-DFJ4n_wc.js

@@ -0,0 +1,150 @@
+import { effectiveParam as y, matchesParamCondition as k } from "@w6w/expr";
+function m(n) {
+  return n.kind === "action" ? "" : n.kind === "endpoint" ? n.endpoint : n.kind === "function" ? n.function : n.workflow;
+}
+function N(n) {
+  return n.kind === "action" ? !!(n.uses.app && n.uses.action) : !!m(n);
+}
+function j(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 b(n) {
+  return n.kind === "action" ? { uses: n.uses, with: n.with ?? {} } : { ...n, with: {} };
+}
+function P(n, e) {
+  const t = b(e);
+  if (!(n != null && n.outputMap)) return t;
+  const u = n.kind ?? "action";
+  let i = !1;
+  if (u === "action" && e.kind === "action") {
+    const o = n;
+    i = o.uses.app === e.uses.app && o.uses.action === e.uses.action;
+  } else u === "function" && e.kind === "function" ? i = n.function === e.function : u === "workflow" && e.kind === "workflow" && (i = n.workflow === e.workflow);
+  return i ? { ...t, outputMap: n.outputMap } : t;
+}
+function A(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), e.when !== void 0 && (t.when = e.when), t;
+  });
+}
+function M(n, e) {
+  var r, s;
+  const t = (n == null ? void 0 : n.nodes) ?? (n == null ? void 0 : n.steps), u = Array.isArray(t) ? t : [], i = /* @__PURE__ */ new Set(), o = [];
+  for (const f of u) {
+    const l = (r = f == null ? void 0 : f.uses) == null ? void 0 : r.app;
+    if (typeof l != "string" || !e.isTriggerApp(l)) continue;
+    const h = e.asFieldDefs((s = f == null ? void 0 : f.with) == null ? void 0 : s.fields);
+    for (const d of h) {
+      const c = d.key;
+      typeof c != "string" || c.trim() === "" || i.has(c) || (i.add(c), o.push({ key: c, label: c, type: d.type ?? "string", required: d.required }));
+    }
+  }
+  return o;
+}
+const w = ["string", "text", "number", "boolean", "json", "secret"];
+function R(n) {
+  return n.rows.length === 0 && !n.touched;
+}
+function F(n) {
+  return w.includes(n) ? n : "string";
+}
+function x(n, e) {
+  const t = new Set(n.map((i) => i.key)), u = [];
+  for (const i of e) {
+    const o = i.key;
+    typeof o != "string" || o.trim() === "" || t.has(o) || (t.add(o), u.push({
+      key: o,
+      label: i.label ?? o,
+      type: F(i.type),
+      required: !!i.required
+    }));
+  }
+  return u.length === 0 ? n : [...n, ...u];
+}
+function q(n, e) {
+  const t = n.showIf;
+  return t ? k(t, e) : !0;
+}
+function I(n) {
+  return n == null ? !1 : typeof n == "string" ? n.trim() !== "" : !0;
+}
+function a(n, e, t) {
+  const u = new Set(n.map((r) => r.key)), i = (r) => {
+    var s;
+    return (t == null ? void 0 : t[r]) !== void 0 ? t[r] : (s = e.find((f) => f.key === r)) == null ? void 0 : s.default;
+  }, o = [];
+  for (const r of e) {
+    if (!y(r, i).required) continue;
+    const s = r.key;
+    typeof s != "string" || s.trim() === "" || u.has(s) || o.includes(s) || q(r, i) && (I(r.default) || o.push(s));
+  }
+  return o;
+}
+function B(n, e) {
+  if (!(e.emptyMeansPassthrough && n.length === 0))
+    return n;
+}
+function S(n) {
+  return n == null ? !1 : typeof n == "string" ? n.trim() !== "" : typeof n == "object" && "type" in n && n.type === "expr" ? !0 : typeof n == "object";
+}
+function p(n) {
+  const e = [];
+  for (const t of Object.keys(n))
+    S(n[t]) && e.push({ key: t, label: t, type: "string" });
+  return e;
+}
+function g(n) {
+  const { target: e, rows: t, fields: u } = n;
+  return e.kind === "action" ? e.with === void 0 ? [] : a(p(e.with), u, e.with) : t.length === 0 ? [] : a(t, u);
+}
+function D(n) {
+  return n.impl ? a(
+    p(n.impl.with ?? {}),
+    n.fields,
+    n.impl.with ?? {}
+  ) : n.fields.filter((e) => e.required).map((e) => e.key);
+}
+function E(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 {
+  w as I,
+  B as a,
+  m as b,
+  E as c,
+  b as d,
+  D as e,
+  M as f,
+  a as g,
+  P as h,
+  j as i,
+  x as m,
+  A as p,
+  R as s,
+  N as t,
+  g as u
+};
+//# sourceMappingURL=coerce-input-DFJ4n_wc.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coerce-input-DFJ4n_wc.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\nimport type { ParamWhen } from \"@w6w/expr\";\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  when?: ParamWhen[];\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  nodes?: unknown;\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  when?: ParamWhen[];\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/**\n * The `impl` a re-pick produces. `outputMap` adapts ONE binding's vendor response, so it survives\n * only while the binding identity is unchanged: the same `uses.app` + `uses.action` (action arm),\n * or the same callable kind + id (ref arm). Connection and `with` edits keep it; a different\n * action or callee drops it (rfcs/function.md: switching provider replaces `impl` wholesale).\n */\nexport function implAfterRebind(\n  prev: FunctionImplLike | undefined,\n  target: ActionTargetLike | CallableTargetLike,\n): FunctionImplLike {\n  const next = targetToImpl(target);\n  if (!prev?.outputMap) return next;\n  const prevKind = prev.kind ?? \"action\";\n  let same = false;\n  if (prevKind === \"action\" && target.kind === \"action\") {\n    const p = prev as ActionImplLike;\n    same = p.uses.app === target.uses.app && p.uses.action === target.uses.action;\n  } else if (prevKind === \"function\" && target.kind === \"function\") {\n    same = (prev as { function: string }).function === target.function;\n  } else if (prevKind === \"workflow\" && target.kind === \"workflow\") {\n    same = (prev as { workflow: string }).workflow === target.workflow;\n  }\n  return same ? { ...next, outputMap: prev.outputMap } : next;\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    if (p.when !== undefined) {\n      field.when = p.when;\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 rawNodes = workflow?.nodes ?? workflow?.steps;\n  const steps = Array.isArray(rawNodes) ? (rawNodes 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 { effectiveParam, matchesParamCondition } from \"@w6w/expr\";\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 * Delegates to `@w6w/expr`'s `matchesParamCondition` (all four arms).\n */\nfunction isFieldVisible(field: TargetField, effective: (key: string) => unknown): boolean {\n  const c = field.showIf;\n  if (!c) return true;\n  return matchesParamCondition(c, effective);\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 (!effectiveParam(field, effective).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","implAfterRebind","prev","next","prevKind","same","p","paramsToFields","params","field","fieldsFromWorkflow","workflow","ctx","rawNodes","steps","seen","out","step","app","_a","defs","_b","def","key","INPUT_TYPES","shouldSeed","args","normalizeType","type","mergeSeed","rows","fields","r","appended","isFieldVisible","effective","c","matchesParamCondition","hasUsableDefault","d","uncoveredRequiredKeys","values","covered","effectiveParam","inputsForSave","opts","isFedValue","v","coveredRowsFromWith","withBlock","uncoveredForEndpoint","uncoveredForFunction","f","coerceInput","raw","n"],"mappings":"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"}

package/dist/connections-CzsCyIxY.js

@@ -0,0 +1,119 @@
+import { useQuery as u, useQueryClient as a, useMutation as l } from "@tanstack/react-query";
+import { u as o } from "./client-context-CX61Bgw-.js";
+const p = (n) => ["app-connections", n];
+function d(n, e) {
+  return n.console.connections.listForApp(e);
+}
+function w(n, e = !0) {
+  const t = o();
+  return u({
+    queryKey: p(n),
+    queryFn: () => d(t, n),
+    enabled: e
+  });
+}
+const r = ["connections"];
+function q(n) {
+  return n.connections.list();
+}
+function g() {
+  const n = o();
+  return u({ queryKey: r, queryFn: () => q(n) });
+}
+const y = (n) => ["connection", n];
+function C(n, e) {
+  return n.console.connections.get(e);
+}
+function A(n) {
+  const e = o();
+  return u({ queryKey: y(n), queryFn: () => C(e, n) });
+}
+function D(n, e, t) {
+  return n.console.connections.create(e, t);
+}
+function K(n, e, t) {
+  return n.console.connections.update(e, t);
+}
+function M(n) {
+  const e = o(), t = a();
+  return l({
+    mutationFn: (c) => K(e, n, c),
+    onSuccess: () => {
+      t.invalidateQueries({ queryKey: r }), t.invalidateQueries({ queryKey: y(n) });
+    }
+  });
+}
+function h(n) {
+  const e = o(), t = a();
+  return l({
+    mutationFn: () => e.console.connections.test(n),
+    onSuccess: () => {
+      t.invalidateQueries({ queryKey: y(n) }), t.invalidateQueries({ queryKey: r });
+    }
+  });
+}
+const f = (n) => ["connection-dependents", n];
+function Q(n, e) {
+  return n.console.connections.dependents(e);
+}
+function k(n, e = !0) {
+  const t = o();
+  return u({
+    queryKey: f(n),
+    queryFn: () => Q(t, n),
+    enabled: e,
+    // The answer must be fresh each time the confirm opens.
+    staleTime: 0,
+    gcTime: 0,
+    retry: !1
+  });
+}
+async function m(n, e) {
+  var t;
+  try {
+    return await n.console.connections.delete(e.id, { force: e.force === !0 }), { ok: !0 };
+  } catch (c) {
+    const i = c;
+    if ((i == null ? void 0 : i.status) === 409 && i.code === "connection_in_use") {
+      const s = (t = (i.raw ?? {}).error) == null ? void 0 : t.dependents;
+      return {
+        ok: !1,
+        dependents: {
+          callables: (s == null ? void 0 : s.callables) ?? [],
+          subscriptions: (s == null ? void 0 : s.subscriptions) ?? []
+        }
+      };
+    }
+    throw c;
+  }
+}
+function S() {
+  const n = o(), e = a();
+  return l({
+    mutationFn: (t) => m(n, t),
+    onSuccess: (t, { id: c }) => {
+      e.invalidateQueries({ queryKey: r }), e.invalidateQueries({ queryKey: f(c) });
+    }
+  });
+}
+export {
+  f as a,
+  y as b,
+  r as c,
+  p as d,
+  D as e,
+  m as f,
+  C as g,
+  Q as h,
+  d as i,
+  K as j,
+  k,
+  q as l,
+  A as m,
+  w as n,
+  S as o,
+  h as p,
+  M as q,
+  g as u
+};
+//# sourceMappingURL=connections-CzsCyIxY.js.map

package/dist/connections-CzsCyIxY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connections-CzsCyIxY.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 { ConnectionDependents, ConnectionTestResult } from \"@w6w/sdk/console\";\nimport { useEmbedClient } from \"../draft/client-context.ts\";\n\nexport type { ConnectionSummary } from \"@w6w/sdk\";\n\n// The bodies are the SDK's (this module may not import @w6w/ui, see repos-graph.test.ts); they are\n// forwarded verbatim and the ui adapter's `CreateConnectionBody` / `updateConnection` bodies must\n// stay assignable to them (the hosts' tsc enforces it).\nexport type CreateConnectionBody = Parameters<W6WClient[\"console\"][\"connections\"][\"create\"]>[1];\nexport type UpdateConnectionBody = Parameters<W6WClient[\"console\"][\"connections\"][\"update\"]>[1];\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: CreateConnectionBody,\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: UpdateConnectionBody,\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: UpdateConnectionBody) => 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\n// ── dependents / delete ──────────────────────────────────────────────\n\nexport type { ConnectionDependents } from \"@w6w/sdk/console\";\n\nexport const connectionDependentsKey = (id: string) => [\"connection-dependents\", id] as const;\n\nexport function getConnectionDependents(\n  client: W6WClient,\n  id: string,\n): Promise<ConnectionDependents> {\n  return client.console.connections.dependents(id);\n}\n\n/** What a delete would disable. `enabled` gates the fetch (the modal is closed → no request). */\nexport function useConnectionDependentsQuery(id: string, enabled = true) {\n  const client = useEmbedClient();\n  return useQuery({\n    queryKey: connectionDependentsKey(id),\n    queryFn: () => getConnectionDependents(client, id),\n    enabled,\n    // The answer must be fresh each time the confirm opens.\n    staleTime: 0,\n    gcTime: 0,\n    retry: false,\n  });\n}\n\nexport type DeleteConnectionResult = { ok: true } | { ok: false; dependents: ConnectionDependents };\n\n/**\n * Delete with an optional `force`. A 409 `connection_in_use` is data — `{ ok: false, dependents }`\n * — not a thrown error; every other failure rejects.\n */\nexport async function deleteConnection(\n  client: W6WClient,\n  args: { id: string; force?: boolean },\n): Promise<DeleteConnectionResult> {\n  try {\n    await client.console.connections.delete(args.id, { force: args.force === true });\n    return { ok: true };\n  } catch (e) {\n    const err = e as { status?: unknown; code?: unknown; raw?: unknown };\n    if (err?.status === 409 && err.code === \"connection_in_use\") {\n      // Wire: { error: { code, message, dependents } } — see wrappers/node/src/connections.ts.\n      const raw = (err.raw ?? {}) as { error?: { dependents?: Partial<ConnectionDependents> } };\n      const deps = raw.error?.dependents;\n      return {\n        ok: false,\n        dependents: {\n          callables: deps?.callables ?? [],\n          subscriptions: deps?.subscriptions ?? [],\n        },\n      };\n    }\n    throw e;\n  }\n}\n\nexport function useDeleteConnectionMutation() {\n  const client = useEmbedClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: (args: { id: string; force?: boolean }) => deleteConnection(client, args),\n    onSuccess: (_r, { id }) => {\n      qc.invalidateQueries({ queryKey: connectionsKey });\n      qc.invalidateQueries({ queryKey: connectionDependentsKey(id) });\n    },\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","connectionDependentsKey","getConnectionDependents","useConnectionDependentsQuery","deleteConnection","args","e","err","deps","_a","useDeleteConnectionMutation","_r"],"mappings":"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"}