@w6w/embed 0.1.0 → 0.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"document-sources-C0grrtdq.js","sources":["../src/lib/code-rail.ts","../src/lib/error-handler-self.ts","../src/lib/document-sources.ts"],"sourcesContent":["/**\n * Pure decisions behind the right rail's Code tool (`src/ui/rail/CodeTool.tsx`).\n * Split out so `node --test` can gate them directly — mirrors\n * `src/lib/alias-rail.ts`'s own reason for existing: `node --test` throws\n * `ERR_UNKNOWN_FILE_EXTENSION` on any `@w6w/ui`-adjacent import, and\n * `src/ui/workspace.tsx` sits one hop from that barrel through `Layout.tsx`'s\n * import graph. So this module declares its own structural mirror of\n * `WorkspaceCallable` instead of importing it.\n */\nimport type { SnippetCallable, SnippetInput } from \"./sdk-snippets.ts\";\n\n/** Structural mirror of T2.1.2's widened `WorkspaceCallable` (`src/ui/workspace.tsx`). */\nexport type RailCallable =\n  | { kind: \"function\"; id: string; key?: string; inputs?: readonly SnippetInput[]; alias?: string }\n  | {\n      kind: \"endpoint\";\n      id: string;\n      key?: string;\n      invokeUrl?: string;\n      invokeUrlByKey?: string;\n      urlForm?: \"id\" | \"key\";\n      alias?: string;\n      inputs?: readonly SnippetInput[];\n    }\n  | { kind: \"workflow\"; id: string; label?: string; key?: string }\n  | { kind: \"connection\"; id: string }\n  | null;\n\n/**\n * Is a \"Call from code\" panel meaningful for this context? Mirrors\n * `alias-rail.ts`'s `targetForCallable` fail-closed shape exactly (its own\n * comment: *\"'connection' and no resource at all both fail closed to null —\n * house style\"*) — `\"connection\"` and `null` both answer `false`.\n */\nexport function isAvailable(ctx: RailCallable): boolean {\n  if (!ctx) return false;\n  switch (ctx.kind) {\n    case \"function\":\n    case \"endpoint\":\n    case \"workflow\":\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * The widened-union -> `SnippetCallable` conversion `CodeTool.Panel` hands to\n * `CallFromCodeBody`. `null` for a context this tool has no snippet for\n * (`\"connection\"`, or no resource at all) — defensive, since `isAvailable`\n * already keeps the tool off the strip for those.\n *\n * The one easy-to-miss field: `WorkspaceCallable`'s `label` maps to\n * `SnippetCallable`'s `workflow` arm's `displayName` — NOT the same field\n * name. A naive `{...ctx}` spread compiles (both optional) but silently\n * drops the label everywhere it matters, never caught by `tsc`.\n */\nexport function toSnippetCallable(ctx: RailCallable): SnippetCallable | null {\n  if (!ctx) return null;\n  switch (ctx.kind) {\n    case \"function\":\n      return { kind: \"function\", id: ctx.id, key: ctx.key, inputs: ctx.inputs, alias: ctx.alias };\n    case \"endpoint\":\n      return {\n        kind: \"endpoint\",\n        id: ctx.id,\n        key: ctx.key,\n        invokeUrl: ctx.invokeUrl,\n        invokeUrlByKey: ctx.invokeUrlByKey,\n        urlForm: ctx.urlForm,\n        alias: ctx.alias,\n        inputs: ctx.inputs,\n      };\n    case \"workflow\":\n      return { kind: \"workflow\", id: ctx.id, displayName: ctx.label, key: ctx.key };\n    default:\n      return null;\n  }\n}\n","/**\n * The authoring-time half of the error-handler recursion guard. The server\n * compares resolved values at dispatch time; this small, pure decision keeps\n * the rail from creating the known-identical no-adapter case in the first\n * place without losing an adapter imported or authored elsewhere.\n */\nexport type ErrorHandlerSelfDecision = \"allow\" | \"warn\" | \"block\";\n\nexport interface ErrorHandlerSelfInput {\n  resource: { kind: string; id: string };\n  target: { kind: string; id: string };\n  hasAdapter: boolean;\n}\n\n/**\n * Only Function and Workflow targets can re-enter the currently edited\n * resource. Actions are always allowed. A self-target with no adapter passes\n * the failed input through unchanged, so it is refused; an adapter is kept\n * and called out because only the runtime can determine its resolved values.\n */\nexport function errorHandlerSelfDecision({\n  resource,\n  target,\n  hasAdapter,\n}: ErrorHandlerSelfInput): ErrorHandlerSelfDecision {\n  const selfTarget =\n    (target.kind === \"function\" || target.kind === \"workflow\") &&\n    target.kind === resource.kind &&\n    target.id === resource.id;\n  if (!selfTarget) return \"allow\";\n  return hasAdapter ? \"warn\" : \"block\";\n}\n","/**\n * Pure `Doc[]` → `ExpressionOptions` projections for the ƒx picker's\n * Documents group — extracted out of `ExpressionScope.tsx` so studio's\n * Node-native `test:unit` runner (globbed to `src/lib/__tests__/`,\n * `src/api/__tests__/` and `src/repos/__tests__/` only — `.ai/PLANNER.md`\n * fact 10) can reach it. No React, no import from `src/ui/` — `@w6w/ui`'s\n * `ExpressionDocumentSource` interface is not imported either (it is not\n * exported from `@w6w/ui`'s barrel, D-P3): the object literals returned below\n * are structurally identical to it, so TypeScript carries the shape without a\n * type import.\n *\n * ## The gate — mirrors the engine's own, bit-for-bit\n *\n * A document contributes field data **iff**: `doc.format === \"json\"` AND\n * `JSON.parse(doc.content)` succeeds into a plain object, OR\n * `doc.format === \"yaml\"` AND npm `yaml`'s `parse(doc.content)` succeeds into\n * a plain object — where *plain object* means\n * `typeof v === \"object\" && v !== null && !Array.isArray(v)`. This mirrors\n * the engine's own gate (`documentsSeed` /\n * `packages/server/packages/api/run-seed.ts`, read-only, out of scope)\n * bit-for-bit for each format: `format === \"json\"` or `format === \"yaml\"`,\n * then a `try/catch` parse, falling back to the raw content string on either\n * a non-matching format or a throw. Reproduced here so the picker never\n * offers a ref the run scope itself would refuse to resolve\n * (`render_ref_unresolved`) — `text`/`markdown`/`html` documents, and a\n * `json`/`yaml` document whose parse throws or yields a non-plain-object, are\n * excluded.\n *\n * The two parsers are not identical for every input — `@std/yaml` (server,\n * `{ schema: \"core\" }`) and npm `yaml` (here) diverge on tab-indented content\n * and on an unresolvable custom tag (`!!js/function`), both accepted, tested\n * debt (D-3). Every other input, including a plain JSON object (JSON is a\n * subset of YAML), agrees between the two.\n *\n * Field keys are enumerated RAW and UNFILTERED by {@link projectDocumentSources}\n * — arbitrary user-authored JSON keys (which can contain `.`/`{`/`}`/\n * whitespace) reach the modal; `isRefSafeKey` filters them exactly once, at\n * the modal's render site (`ExpressionEditorModal.tsx`), never here\n * (`building-blocks.md`: \"enumerate raw at the source, filter once at the\n * single render site\").\n */\nimport type { Doc } from \"@w6w/sdk\";\nimport { parse as parseYaml } from \"yaml\";\n\n/** One document's contribution to `ExpressionOptions.documents` — structurally\n * identical to `@w6w/ui`'s (unexported) `ExpressionDocumentSource`. */\nexport interface DocumentSource {\n  key: string;\n  fields?: { key: string }[];\n}\n\n/**\n * `doc`'s parsed content when the gate holds, else `null`. The one place both\n * functions below apply the gate, so they cannot silently disagree on it.\n */\nfunction gatedFields(doc: Doc): Record<string, unknown> | null {\n  let parsed: unknown;\n  if (doc.format === \"json\") {\n    try {\n      parsed = JSON.parse(doc.content);\n    } catch {\n      return null;\n    }\n  } else if (doc.format === \"yaml\") {\n    try {\n      parsed = parseYaml(doc.content);\n    } catch {\n      return null;\n    }\n  } else {\n    return null;\n  }\n  if (typeof parsed !== \"object\" || parsed === null || Array.isArray(parsed)) return null;\n  return parsed as Record<string, unknown>;\n}\n\n/**\n * The `ExpressionOptions.documents` array: `{ key }` for every document, plus\n * `fields` (raw, unfiltered top-level keys) when the gate holds AND the\n * parsed object has at least one key. `fields` is OMITTED (not `[]`) both\n * when the gate fails and when it holds but yields zero keys — a consumer\n * must be able to tell \"nothing declared\" from \"declared none\".\n */\nexport function projectDocumentSources(docs: Doc[]): DocumentSource[] {\n  return docs.map((d) => {\n    const parsed = gatedFields(d);\n    if (!parsed) return { key: d.key };\n    const keys = Object.keys(parsed);\n    return keys.length > 0 ? { key: d.key, fields: keys.map((key) => ({ key })) } : { key: d.key };\n  });\n}\n\n/**\n * The `sampleValues` entries the ƒx Result preview substitutes for document\n * refs: `documents.<key>` → the document's raw content, for every document\n * (unconditional, exactly as before this project), PLUS `documents.<key>.<field>`\n * → the field's own parsed value, for the gated set only. Without the second\n * half, every field ref this project newly makes pickable would preview as\n * the empty string (`renderResult` does an exact flat-key lookup).\n */\nexport function documentSampleValues(docs: Doc[]): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  for (const d of docs) {\n    out[`documents.${d.key}`] = d.content;\n    const parsed = gatedFields(d);\n    if (!parsed) continue;\n    for (const [key, value] of Object.entries(parsed)) {\n      out[`documents.${d.key}.${key}`] = value;\n    }\n  }\n  return out;\n}\n"],"names":["isAvailable","ctx","toSnippetCallable","errorHandlerSelfDecision","resource","target","hasAdapter","gatedFields","doc","parsed","parseYaml","projectDocumentSources","docs","d","keys","key","documentSampleValues","out","value"],"mappings":";AAkCO,SAASA,EAAYC,GAA4B;AACtD,MAAI,CAACA,EAAK,QAAO;AACjB,UAAQA,EAAI,MAAA;AAAA,IACV,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO;AAAA,IACT;AACE,aAAO;AAAA,EAAA;AAEb;AAaO,SAASC,EAAkBD,GAA2C;AAC3E,MAAI,CAACA,EAAK,QAAO;AACjB,UAAQA,EAAI,MAAA;AAAA,IACV,KAAK;AACH,aAAO,EAAE,MAAM,YAAY,IAAIA,EAAI,IAAI,KAAKA,EAAI,KAAK,QAAQA,EAAI,QAAQ,OAAOA,EAAI,MAAA;AAAA,IACtF,KAAK;AACH,aAAO;AAAA,QACL,MAAM;AAAA,QACN,IAAIA,EAAI;AAAA,QACR,KAAKA,EAAI;AAAA,QACT,WAAWA,EAAI;AAAA,QACf,gBAAgBA,EAAI;AAAA,QACpB,SAASA,EAAI;AAAA,QACb,OAAOA,EAAI;AAAA,QACX,QAAQA,EAAI;AAAA,MAAA;AAAA,IAEhB,KAAK;AACH,aAAO,EAAE,MAAM,YAAY,IAAIA,EAAI,IAAI,aAAaA,EAAI,OAAO,KAAKA,EAAI,IAAA;AAAA,IAC1E;AACE,aAAO;AAAA,EAAA;AAEb;AC1DO,SAASE,EAAyB;AAAA,EACvC,UAAAC;AAAA,EACA,QAAAC;AAAA,EACA,YAAAC;AACF,GAAoD;AAKlD,UAHGD,EAAO,SAAS,cAAcA,EAAO,SAAS,eAC/CA,EAAO,SAASD,EAAS,QACzBC,EAAO,OAAOD,EAAS,KAElBE,IAAa,SAAS,UADL;AAE1B;ACwBA,SAASC,EAAYC,GAA0C;AAC7D,MAAIC;AACJ,MAAID,EAAI,WAAW;AACjB,QAAI;AACF,MAAAC,IAAS,KAAK,MAAMD,EAAI,OAAO;AAAA,IACjC,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,WACSA,EAAI,WAAW;AACxB,QAAI;AACF,MAAAC,IAASC,EAAUF,EAAI,OAAO;AAAA,IAChC,QAAQ;AACN,aAAO;AAAA,IACT;AAAA;AAEA,WAAO;AAET,SAAI,OAAOC,KAAW,YAAYA,MAAW,QAAQ,MAAM,QAAQA,CAAM,IAAU,OAC5EA;AACT;AASO,SAASE,EAAuBC,GAA+B;AACpE,SAAOA,EAAK,IAAI,CAACC,MAAM;AACrB,UAAMJ,IAASF,EAAYM,CAAC;AAC5B,QAAI,CAACJ,EAAQ,QAAO,EAAE,KAAKI,EAAE,IAAA;AAC7B,UAAMC,IAAO,OAAO,KAAKL,CAAM;AAC/B,WAAOK,EAAK,SAAS,IAAI,EAAE,KAAKD,EAAE,KAAK,QAAQC,EAAK,IAAI,CAACC,OAAS,EAAE,KAAAA,IAAM,EAAA,IAAM,EAAE,KAAKF,EAAE,IAAA;AAAA,EAC3F,CAAC;AACH;AAUO,SAASG,EAAqBJ,GAAsC;AACzE,QAAMK,IAA+B,CAAA;AACrC,aAAWJ,KAAKD,GAAM;AACpB,IAAAK,EAAI,aAAaJ,EAAE,GAAG,EAAE,IAAIA,EAAE;AAC9B,UAAMJ,IAASF,EAAYM,CAAC;AAC5B,QAAKJ;AACL,iBAAW,CAACM,GAAKG,CAAK,KAAK,OAAO,QAAQT,CAAM;AAC9C,QAAAQ,EAAI,aAAaJ,EAAE,GAAG,IAAIE,CAAG,EAAE,IAAIG;AAAA,EAEvC;AACA,SAAOD;AACT;"}

package/dist/draft/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * `@w6w/embed/draft` — the headless draft lifecycle (debounced autosave, flush-on-hide, the
- * workflow save precondition). No UI and no `@w6w/ui`: it imports only `react`,
+ * workflow / function / endpoint save precondition). No UI and no `@w6w/ui`: it imports only `react`,
  * `@tanstack/react-query` and type-only `@w6w/sdk`, so a host can use it without the editor.
  */
 export { AUTOSAVE_DEBOUNCE_MS, createAutoSaver } from './autosave.ts';
@@ -13,3 +13,5 @@ export { DraftRegistryProvider, createDraftRegistry, useDraftRegistry, } from '.
 export type { DraftRegistry } from './draft-registry.ts';
 export { useWorkflowDraft } from './use-workflow-draft.ts';
 export type { FlushOutcome, UseWorkflowDraftOptions, WorkflowDraft, } from './use-workflow-draft.ts';
+export { useCallableDraft, useEndpointDraft, useFunctionDraft } from './use-callable-draft.ts';
+export type { CallableDraft, CallableDraftKind, UseCallableDraftOptions, } from './use-callable-draft.ts';

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

@@ -0,0 +1,65 @@
+import { CallablePolicy } from '../lib/settings-rail.ts';
+import { FlushOutcome } from './use-workflow-draft.ts';
+export type CallableDraftKind = "function" | "endpoint";
+type Definition = Record<string, unknown>;
+export interface UseCallableDraftOptions {
+    /** `null` ⇒ idle (the hook stays mounted above an early return). */
+    id: string | null;
+    /** Default FALSE: nothing is sent until `saveNow()` / `flush()` / `commit()`. */
+    autoSave?: boolean;
+    /** Injected busy probe. Gates AUTOMATIC saves only. */
+    canAutoSave?: () => boolean;
+    /** Injected edit guard: a reason blocks saving. */
+    saveGuard?: (definition: Definition) => string | null;
+    /**
+     * Called once when a handover or an identity switch (`flushAll`) drops a dirty buffer it could
+     * not save. `blocked`: refused before a request; `failed`: the request failed or the row was
+     * stale. No UI here.
+     */
+    onDiscard?: (info: {
+        id: string;
+        definition: Definition;
+        reason: "blocked" | "failed";
+    }) => void;
+}
+export interface CallableDraft {
+    /** The editable definition (no `valid` / `updatedAt`); `null` until loaded. */
+    definition: Definition | null;
+    setDefinition(next: Definition | ((prev: Definition) => Definition)): void;
+    /** `{retry, onError, reroute}` read off the buffer. */
+    policy: CallablePolicy;
+    /** Referentially stable. Saves `definitionWithPolicy(buffer, next)` now. */
+    onPolicyChange(policy: CallablePolicy): void;
+    loading: boolean;
+    loadError: unknown | null;
+    dirty: boolean;
+    saving: boolean;
+    canSave: boolean;
+    saveBlockedReason: string | null;
+    /** The last save was refused as stale (`function_stale` / `endpoint_stale`). */
+    stale: boolean;
+    /** Another writer changed the resource while this buffer is dirty. Never merged. */
+    changedElsewhere: boolean;
+    error: unknown | null;
+    /** Push + fire now. */
+    saveNow(): void;
+    flush(): Promise<FlushOutcome>;
+    /** Flush, then run `action` only when the buffer is clean or just saved. */
+    flushThen<T>(action: () => Promise<T>): Promise<{
+        ok: true;
+        value: T;
+    } | {
+        ok: false;
+        outcome: FlushOutcome;
+    }>;
+    /** `setDefinition(def)` + an immediate save. */
+    commit(def: Definition): Promise<FlushOutcome>;
+    /** Refetch the shared query, replace the buffer and token, clear `stale` / `changedElsewhere`. */
+    reload(): Promise<void>;
+}
+export declare function useCallableDraft(kind: CallableDraftKind, o: UseCallableDraftOptions): CallableDraft;
+/** {@link useCallableDraft} bound to a Function. */
+export declare function useFunctionDraft(o: UseCallableDraftOptions): CallableDraft;
+/** {@link useCallableDraft} bound to an Endpoint. */
+export declare function useEndpointDraft(o: UseCallableDraftOptions): CallableDraft;
+export {};

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

@@ -23,6 +23,9 @@
  * - `workflow_conflict` — another `(tenant, subject)` owns that workflow id.
  *   Reloading changes nothing; offering a reload here would be a dead end.
  *
+ * The same precondition guards Function and Endpoint saves, answered with `function_stale` /
+ * `endpoint_stale`; all three are the recoverable "your copy is out of date" verdict.
+ *
  * Anything that carries no `code` (a thrown `TypeError`, a string, `null`) is
  * not a server verdict at all, so it is not a stale write either.
  *

package/dist/draft.mjs

@@ -1,18 +1,22 @@
 "use client";
-import { A as s, c as a, i as t, n as i, r as o, u } from "./use-workflow-draft-oI02dsP-.js";
+import { A as a, c as s, i as t, n as o, r as i, u } from "./use-workflow-draft-DzAyUeA6.js";
 import { E as n, u as l } from "./client-context-CX61Bgw-.js";
 import { D as E, c, u as d } from "./draft-registry-YF0tqNN0.js";
+import { u as p, a as x, b as S } from "./use-callable-draft-zHLpcr-b.js";
 export {
-  s as AUTOSAVE_DEBOUNCE_MS,
+  a as AUTOSAVE_DEBOUNCE_MS,
   E as DraftRegistryProvider,
   n as EmbedClientProvider,
-  a as createAutoSaver,
+  s as createAutoSaver,
   c as createDraftRegistry,
   t as isStaleWrite,
-  i as nextSaveToken,
-  o as registerFlushOnHide,
+  o as nextSaveToken,
+  i as registerFlushOnHide,
+  p as useCallableDraft,
   d as useDraftRegistry,
   l as useEmbedClient,
+  x as useEndpointDraft,
+  S as useFunctionDraft,
   u as useWorkflowDraft
 };
 //# sourceMappingURL=draft.mjs.map

package/dist/draft.mjs.map

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

package/dist/editor/CallableEditorFrame.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from 'react';
+import { CallableKind } from '../lib/callable-kind.ts';
+import { CallableEditorNavigation, CallableEditorSlots } from './types.ts';
+export interface CallableEditorFrameProps {
+    /** Which kind's copy (back/save labels, not-found heading) the frame shows. */
+    kind: CallableKind;
+    /** The heading's text — the kind computes it from its own draft, because only it knows what
+     *  "empty" means for its definition. */
+    title: string;
+    /** Renders the `incomplete` badge beside the heading. */
+    incomplete: boolean;
+    canSave: boolean;
+    isSaving: boolean;
+    onSave: () => void;
+    error: string | null;
+    /** A 404 from the hydration GET: render the not-found card, never a blank editable form. */
+    notFound: boolean;
+    /** Where the host should take the user; back asks for `{ type: "list" }`. */
+    onNavigate: (to: CallableEditorNavigation) => void;
+    slots?: CallableEditorSlots;
+    /** Statements BETWEEN the error banner and the body — the save-gate explanation, "Saved.". */
+    banners?: ReactNode;
+    /** Rendered as the FIRST child of the header action row, before Save (e.g. a JSON toggle). */
+    headerActions?: ReactNode;
+    children: ReactNode;
+}
+/**
+ * The shared editor frame of the Function and Endpoint editors: back control, heading with the
+ * `incomplete` badge, Save, the error banner and the body (or the not-found card). Router-free —
+ * it asks the host to navigate through `onNavigate` and sets no document title. It publishes
+ * nothing to the rail workspace either: each editor body does that itself (`useWorkspace`).
+ */
+export declare function CallableEditorFrame(props: CallableEditorFrameProps): import("react").JSX.Element;

package/dist/editor/EditorShell.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { RailTool } from '../chrome/RightRail.tsx';
+import { RailNavigation } from '../rail/rail-env.tsx';
+export interface EditorShellProps {
+    /** Resolved project (`null` = none; tools refuse to save). */
+    project: string | null;
+    onNavigate: (to: RailNavigation) => void;
+    /** Default `true`. `false`: render no rail; publish into the enclosing workspace if any. */
+    rail?: boolean;
+    /** Persisted-rail key; `null` = not yet persistable. */
+    storageKey: string | null;
+    /** Default {@link editorRailTools}. */
+    tools?: readonly RailTool[];
+    children: ReactNode;
+}
+export declare function EditorShell({ project, onNavigate, rail, storageKey, tools, children, }: EditorShellProps): ReactNode;

package/dist/editor/EndpointCards.d.ts

@@ -0,0 +1,56 @@
+import { UrlForm } from '../lib/endpoint-editor.ts';
+import { EndpointInput, EndpointSecurity, InvokeUrlOption } from '../repos/endpoints.ts';
+/**
+ * The Endpoint's callable URL — its own card, directly beneath Identity.
+ *
+ * **Every URL here comes from the SERVER, verbatim** (the `["endpoint", id]` envelope's
+ * `invokeUrl`, `invokeUrlByKey` and `invokeUrls[]`): this component picks between strings and
+ * renders one. It holds no hostname, no path grammar and no account slug. `entry.urlByKey` is
+ * absent until the server renders it; then the card is one URL line and one Copy button, no
+ * id/key toggle. `domainOptions` renders the domain `<select>` only when there is a second option
+ * (`lib/endpoint-editor.ts`'s `urlOptions` does that collapse).
+ */
+export declare function UrlCard(props: {
+    entry: {
+        url: string;
+        urlByKey?: string;
+        resolves: boolean;
+    };
+    domainOptions?: InvokeUrlOption[];
+    urlDomain: string | null;
+    onUrlDomain: (domain: string) => void;
+    urlForm: UrlForm;
+    onUrlForm: (form: UrlForm) => void;
+}): import("react").JSX.Element;
+/**
+ * Who may call the URL above.
+ *
+ * Every mode except `platform` runs the target as the Endpoint's owner (there is no platform
+ * identity on such a request), which is what the warning below says before an operator switches off
+ * platform auth. Secrets are write-only: the server returns a mask for a configured secret, and
+ * saving the mask back keeps the stored value.
+ */
+export declare function SecurityCard(props: {
+    security: EndpointSecurity;
+    onPatch: (next: Partial<EndpointSecurity>) => void;
+}): import("react").JSX.Element;
+/**
+ * A write-only secret input. A stored secret comes back as {@link SECRET_MASK}; the input renders
+ * EMPTY (the mask is never a DOM value) with the "stored — type to replace" hint, and the buffer
+ * keeps the mask until the operator types, so a save that never touches it preserves what is stored.
+ */
+export declare function SecretField(props: {
+    label: string;
+    value: string | undefined;
+    onChange: (v: string) => void;
+}): import("react").JSX.Element;
+/**
+ * Test-invoke panel: one field per declared input, POSTed to /endpoints/:id/invoke. The server
+ * invokes the STORED definition, so unsaved edits are not what runs. The result is the
+ * `kind`-tagged envelope: an Action or Function target answers with an inline `output`; a Workflow
+ * target answers with a `runId` to poll.
+ */
+export declare function EndpointTestInvoke(props: {
+    id: string;
+    inputs: EndpointInput[];
+}): import("react").JSX.Element;

package/dist/editor/EndpointEditor.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { EndpointEditorProps } from './types.ts';
+/**
+ * `<EndpointEditor endpointId>` — Studio's endpoint editor body (Identity, URL, Input, Target,
+ * Security, Test invoke, History, JSON toggle) as a published component. The outermost element is
+ * `.w6w-embed-root`; nothing goes through a portal.
+ *
+ * ## One cache, one draft
+ *
+ * Every field is the buffer of `useEndpointDraft` (seeded from, and refreshed by, the ONE
+ * `["endpoint", id]` query), and every write — the header Save, the bottom Save and the JSON
+ * toggle's Save — is that draft's `commit`, so each issues one POST carrying the stored
+ * `updatedAt` (`If-Unmodified-Since`). A 409 `endpoint_stale` is shown inline with a Reload and is
+ * never retried. The invoke URLs are read from the same query's envelope, never copied into state,
+ * so a rail save or an external change shows without a remount.
+ *
+ * A Save with nothing changed since the last read sends no request (the draft is clean).
+ *
+ * ## Rail
+ *
+ * `rail` omitted: the editor owns a rail. `rail={false}` inside a `<CallableWorkspace>` for the
+ * SAME endpoint id publishes into it; with `rail={false}` the rail saves use the WORKSPACE's
+ * `project`, not the `project` prop here. A workspace for a different id is silently overridden
+ * while this editor is mounted.
+ */
+export declare function EndpointEditor(props: EndpointEditorProps): ReactNode;

package/dist/editor/FunctionEditor.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { FunctionEditorProps } from './types.ts';
+/**
+ * The managed Function editor: Interface, Inputs, Implementation, Test invoke, History and a JSON
+ * toggle, on `EditorShell`. The outermost element is `.w6w-embed-root`; nothing goes through a
+ * portal.
+ *
+ * Every read and write goes through `useFunctionDraft` (one cache entry, `["function", id]`; one
+ * stale-write token). Save, the JSON toggle's Save and the rail's Error handling (`onPolicyChange`)
+ * all persist through the draft, so each carries `If-Unmodified-Since`; a 409 shows inline with a
+ * reload control and is never retried. `project` is not a save precondition (a Function is
+ * account-scoped): it scopes the expression rail and the rail's storage key only.
+ *
+ * `rail` defaults to `true`: the editor renders its own right rail. `rail={false}` renders none and
+ * publishes the Function (key, inputs, policy, `onPolicyChange`) into an enclosing
+ * `<CallableWorkspace kind="function" id>` for the SAME id; an editor whose id differs from its
+ * workspace's overrides it and the host's rail renders empty. With `rail={false}` inside a
+ * workspace, the rail's saves use that workspace's `project`, not this editor's `project` prop.
+ * Aliases are not part of this editor; a host adds its own through `tools`.
+ */
+export declare function FunctionEditor(props: FunctionEditorProps): ReactNode;

package/dist/editor/InputListEditor.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+import { InputRow } from '../lib/input-seeding.ts';
+/**
+ * One input-row card, shared by the Functions "Inputs" editor and the
+ * Endpoints "Input" editor (T3.2.1) — the two were byte-identical from
+ * `<li key={i}>` through `</li>` on the merged branch, apart from the map
+ * source variable (`draft.inputs` vs the `inputs` local alias for
+ * `draft.input ?? []`). Controlled: the page owns `rows` as its `draft`'s
+ * single source of truth and passes the next array back through `onChange`
+ * on every add/update/remove — this component never holds its own copy.
+ *
+ * `emptyMeansPassthrough` carries the one real divergence between the two
+ * forms: an Endpoint's declared `input` list absent/empty is a documented
+ * pass-through mode, a Function's empty `inputs` just means "no arguments" —
+ * so the empty-state copy (and nothing else) differs per page.
+ */
+export interface InputListEditorProps {
+    rows: InputRow[];
+    onChange: (next: InputRow[]) => void;
+    /** The card's `<h3>` — "Inputs" (Functions) or "Input" (Endpoints). */
+    title: string;
+    /** The card's descriptive copy, caller-owned so wording stays per-surface. */
+    description: ReactNode;
+    /** Endpoints: `true` (the empty-state copy talks about pass-through). Functions: `false`. */
+    emptyMeansPassthrough: boolean;
+    /** Required target-field keys the current rows don't cover (HITL-1's post-touch flag). */
+    uncoveredKeys?: string[];
+}
+export declare function InputListEditor(props: InputListEditorProps): import("react").JSX.Element;

package/dist/editor/TargetSelector.d.ts

@@ -0,0 +1,30 @@
+import { TargetKind, TargetSelectorProps } from './TargetSelector.types.ts';
+/**
+ * One `target` picker for both the Functions editor's Implementation card and
+ * the Endpoints editor's Target card (rfcs/endpoint.md:339-347,
+ * rfcs/function.md:61-62). `allowedKinds` is the type-level RFC guard (A1,
+ * see `TargetSelector.types.ts`) — Functions passes `["action"]`, which makes
+ * `{kind:"function"}`/`{kind:"workflow"}` unconstructable at that call site
+ * and renders no kind control at all (A2); Endpoints passes all three.
+ *
+ * Owns every fetch its three arms need (apps/actions/connections for `action`;
+ * the functions/workflows lists plus the picked one's own detail for the
+ * other two — A8, gated `useQuery`s, mirroring the pages' existing
+ * `actionsQuery` gating) and reuses `StepBuilderModal` verbatim for the
+ * `action` arm (A3) — this is the one remaining `<StepBuilderModal` call
+ * site; no second app/action picker.
+ *
+ * Resolves the picked target to a normalized `TargetField[]` (A5) and reports
+ * it via `onResolved` on every change, so a page's own `useEffect` can seed
+ * its input list from the same fields the mapping table below renders from
+ * (A7) — by the time that table can render, `inputs.*` already resolves.
+ *
+ * **Takes no `exprOptions`.** The ƒx rail its mapping rows and its picker modal
+ * offer is INHERITED — the app shell contributes the project's vars/secrets/
+ * documents, the page contributes its `inputs` — so every expression editor
+ * reachable from this card sees the same sources wherever it is opened. It used
+ * to take the scope as a prop and wrap only the picker modal in a provider,
+ * which is precisely how the mapping rows' `ƒx` toggles ended up offering an
+ * empty rail while the "Change" button offered the full one.
+ */
+export declare function TargetSelector<K extends TargetKind>(props: TargetSelectorProps<K>): import("react").JSX.Element;

package/dist/editor/TargetSelector.types.d.ts

@@ -0,0 +1,62 @@
+import { ReactNode } from 'react';
+import { TargetField } from '../lib/target-fields.ts';
+import { EndpointTarget } from '../repos/endpoints.ts';
+/** The three arms an Endpoint's `target` can take (`EndpointTarget["kind"]`). */
+export type TargetKind = EndpointTarget["kind"];
+/** Narrow `EndpointTarget` to exactly the arm(s) named by `K`. */
+export type TargetValue<K extends TargetKind> = Extract<EndpointTarget, {
+    kind: K;
+}>;
+/** Metadata resolved for the picked target, common across all three arms. */
+export interface TargetMeta {
+    kind: TargetKind;
+    /** The app id for `action`; the function/workflow id for the other two arms. */
+    ref: string;
+}
+export interface TargetSelectorProps<K extends TargetKind> {
+    /** Which kinds the caller may construct. A single-element array offers no kind control at all (A2). */
+    allowedKinds: readonly K[];
+    value: TargetValue<NoInfer<K>>;
+    onChange: (next: TargetValue<NoInfer<K>>) => void;
+    /** Fired whenever the picked target resolves to a normalized field list (A5/A7). */
+    onResolved?: (t: {
+        meta: TargetMeta;
+        kind: K;
+        fields: TargetField[];
+    }) => void;
+    /** The card's `<h3>` — exactly "Implementation" (Functions) or "Target" (Endpoints), A11. */
+    title: string;
+    /** The card's descriptive copy, above the kind control — caller-owned so wording stays per-surface. */
+    description: ReactNode;
+    /** Endpoints only: renders the pass-through sentence in the action arm's mapping sub-panel (A11). */
+    passthroughHint?: boolean;
+}
+/**
+ * Compile-time proof of the generic narrowing described above. Never called —
+ * its only job is to fail `tsc` with `TS2578: Unused '@ts-expect-error'
+ * directive` the moment `TargetValue<K>` is ever widened from a type-level
+ * constraint to something an invalid kind could pass through undetected (e.g.
+ * a runtime `if` with no compile-time teeth). `allowedKinds={["action"]}`
+ * must make a `{kind:"function"}` (or `{kind:"workflow"}`) value literally
+ * unconstructable as `TargetValue<K>` — no shipped call site is single-kind
+ * today, but every one of them (`EndpointsPage`, `AliasesPage`) depends on
+ * the SAME generic holding at its own, wider `allowedKinds`.
+ */
+export declare function _actionOnlyGuardProof(): void;
+/**
+ * Call-site-shaped companion to `_actionOnlyGuardProof`. That proof only
+ * exercises `TargetValue<"action">` with an EXPLICIT type argument — the one
+ * form that already errored before `NoInfer` — while every real call site
+ * (`FunctionsPage.tsx`, `EndpointsPage.tsx`, `AliasesPage.tsx`) supplies none;
+ * `K` is INFERRED from the props object, exactly like JSX calling a generic
+ * component. This proof mirrors that inference site: no explicit `<...>`
+ * anywhere, `allowedKinds` narrowed via `as const` (as every call site does),
+ * `value`/`onChange` passed as plain object/arrow-function literals. Before
+ * `NoInfer`, `K` inferred to `"action" | "function"` here and this compiled
+ * clean — the exact vacuous-guard failure mode this file now proves closed.
+ * `["action"]` is used as the tightest, single-kind shape of `allowedKinds`
+ * for the same reason `_actionOnlyGuardProof` does — no shipped call site
+ * is single-kind post-D-8, but the inference mechanism this exercises is the
+ * one every wider `allowedKinds` array (every real call site's) still needs.
+ */
+export declare function _actionOnlyGuardCallSiteProof(): void;

package/dist/editor/editor-apps.d.ts

@@ -1,7 +1,13 @@
 import { AppSummary } from '@w6w/ui';
-/** The per-app actions query key — byte-identical to Studio's `repos/apps.ts#appActionsKey`. */
-export declare const appActionsKey: (id: string) => readonly ["app-actions", string];
+/** The per-app actions query key — the repos export itself (one declaration, no copy). */
+export { appActionsKey } from '../repos/apps.ts';
 /** A bounded set of app records by id. Empty when the host's API has no `listAppsByIds`. */
 export declare function useEditorApps(ids: readonly string[]): {
     byId: ReadonlyMap<string, AppSummary>;
 };
+/**
+ * One app record by id, over {@link useEditorApps} (same `/apps` request, same cache entry as the
+ * canvas's batch lookup). `undefined` while loading, for an empty id (which issues no request),
+ * or when the host's API cannot look apps up by id.
+ */
+export declare function useEditorApp(id: string): AppSummary | undefined;

package/dist/editor/types.d.ts

@@ -1,4 +1,6 @@
 import { ReactNode } from 'react';
+import { RailTool } from '../chrome/RightRail.tsx';
+import { RailNavigation } from '../rail/rail-env.tsx';
 /** Where the host should take the user. The editor never touches a router: it asks. */
 export type WorkflowEditorNavigation = {
     type: "list";
@@ -31,4 +33,59 @@ export interface WorkflowEditorProps {
     /** Optional (a Next.js server component cannot pass a function); default is a no-op. */
     onNavigate?: (to: WorkflowEditorNavigation) => void;
     slots?: WorkflowEditorSlots;
+    /**
+     * Default `true`: the editor renders its own right rail. `false`: no rail is rendered; the editor
+     * publishes its policy/triggers into an enclosing `<CallableWorkspace>` (from `@w6w/embed/rail`)
+     * so a `<CallableRail>` placed elsewhere shows them. With no enclosing workspace it simply has no
+     * rail.
+     */
+    rail?: boolean;
+}
+/**
+ * Where a Function/Endpoint editor asks the host to go: back to the list, or (after a spec import
+ * from the rail) to the imported resource. The rail's own union, re-exported — no second one.
+ */
+export type CallableEditorNavigation = RailNavigation;
+/** The Function/Endpoint editors' slots — the same shape as the workflow editor's. */
+export type CallableEditorSlots = WorkflowEditorSlots;
+/** Props of `<EndpointEditor>` (`@w6w/embed/editors`). */
+export interface EndpointEditorProps {
+    /** The Endpoint to edit (`ep_…`). */
+    endpointId: string;
+    /**
+     * The project the editor's expression scope and rail tools belong to. Omitted: the
+     * `<W6WEmbedProvider project>`. `null` or `""`: no project — rail tools refuse to save. An
+     * Endpoint's own save carries no project.
+     */
+    project?: string | null;
+    /** Optional (a Next.js server component cannot pass a function); default is a no-op. */
+    onNavigate?: (to: CallableEditorNavigation) => void;
+    slots?: CallableEditorSlots;
+    /**
+     * Default `true`: the editor renders its own right rail. `false`: no rail; the editor publishes
+     * its resource (invoke URL, inputs, policy and its writer) into an enclosing `<CallableWorkspace>`
+     * for the SAME endpoint id. Rail saves then use the WORKSPACE's `project`, not this `project`
+     * prop. With no enclosing workspace it simply has no rail.
+     */
+    rail?: boolean;
+    /** Replaces the rail's tool list (default: the editor rail tools). */
+    tools?: readonly RailTool[];
+}
+export interface FunctionEditorProps {
+    functionId: string;
+    /**
+     * Scopes the expression rail and the rail's storage key (a Function is account-scoped, so it is
+     * never a save precondition). Omitted: the `<W6WEmbedProvider project>`. `null` or `""`: none.
+     */
+    project?: string | null;
+    /** Optional (a Next.js server component cannot pass a function); default is a no-op. */
+    onNavigate?: (to: CallableEditorNavigation) => void;
+    slots?: CallableEditorSlots;
+    /**
+     * Default `true`: the editor renders its own right rail. `false`: none; the editor publishes into
+     * an enclosing `<CallableWorkspace kind="function" id>` for the SAME id.
+     */
+    rail?: boolean;
+    /** Replaces the rail's tools (default: the editor tools; no Aliases tool). */
+    tools?: readonly RailTool[];
 }

package/dist/editor-apps-BdenSV1o.js

@@ -0,0 +1,95 @@
+import { jsxs as F, Fragment as N, jsx as f } from "react/jsx-runtime";
+import { h as O, i as _, e as R } from "./apps-1FNUwbGv.js";
+import { H as g } from "./spec-import-CjmxyZDR.js";
+import { ExecutionStats as j, ExecutionFilters as D, ExecutionList as L, ExecutionDetail as B, useW6WApi as K } from "@w6w/ui";
+import { useRef as I, useState as S, useEffect as b, useCallback as V, useMemo as W } from "react";
+import { useQuery as G } from "@tanstack/react-query";
+const U = 300;
+function ot(e) {
+  var x, q;
+  const { scope: n, showKind: a, filters: t, onFiltersChange: l, onOpenInEditor: u } = e, p = I(t);
+  p.current = t;
+  const [r, i] = S(t.q), c = I(null), [o, h] = S(null);
+  b(() => {
+    i(t.q);
+  }, [t.q]), b(
+    () => () => {
+      c.current && clearTimeout(c.current);
+    },
+    []
+  );
+  const d = O(n, t), v = _(n, t), m = R(o), y = ((x = d.data) == null ? void 0 : x.executions) ?? [], E = t.offset, C = ((q = d.data) == null ? void 0 : q.hasMore) ?? !1, M = (s) => {
+    l({ ...s, offset: 0 });
+  }, Q = (s) => {
+    if (s.q === r) {
+      M(s);
+      return;
+    }
+    i(s.q), c.current && clearTimeout(c.current), c.current = setTimeout(() => {
+      c.current = null, l({ ...p.current, q: s.q, offset: 0 });
+    }, U);
+  }, w = () => l({ ...t, q: r, offset: Math.max(0, E - g) }), A = () => l({ ...t, q: r, offset: E + g }), H = V(
+    (s) => {
+      h(y.find((T) => T.id === s) ?? null);
+    },
+    [y]
+  ), k = {
+    status: t.status,
+    kind: t.kind,
+    from: t.from,
+    to: t.to,
+    q: r
+  }, P = (o == null ? void 0 : o.kind) === "workflow" && u ? () => u(o) : void 0;
+  return /* @__PURE__ */ F(N, { children: [
+    /* @__PURE__ */ f(j, { stats: v.data ?? null }),
+    /* @__PURE__ */ f(D, { showKind: a, value: k, onChange: Q }),
+    d.isError && /* @__PURE__ */ f("p", { className: "error", "data-testid": "history-error", children: "Couldn't load execution history." }),
+    /* @__PURE__ */ f(
+      L,
+      {
+        items: y,
+        showCallable: a,
+        loading: d.isLoading,
+        selectedId: (o == null ? void 0 : o.id) ?? null,
+        hasPrev: E > 0,
+        hasNext: C,
+        onPrev: w,
+        onNext: A,
+        onSelect: H
+      }
+    ),
+    o && /* @__PURE__ */ f(
+      B,
+      {
+        execution: m.data ?? null,
+        loading: m.isLoading,
+        errorMessage: m.isError ? "This execution is no longer available." : void 0,
+        onClose: () => h(null),
+        onOpenInEditor: P
+      }
+    )
+  ] });
+}
+const Y = /* @__PURE__ */ new Map();
+function Z(e) {
+  var r;
+  const n = K(), a = (r = n.listAppsByIds) == null ? void 0 : r.bind(n), t = [...e].sort().join(","), u = G({
+    queryKey: ["editor-apps", t],
+    queryFn: ({ signal: i }) => a ? a(e, { signal: i }) : Promise.resolve([]),
+    enabled: e.length > 0 && typeof a == "function"
+  }).data;
+  return { byId: W(
+    () => u ? new Map(u.map((i) => [i.id, i])) : Y,
+    [u]
+  ) };
+}
+function st(e) {
+  const { byId: n } = Z(e ? [e] : []);
+  return e ? n.get(e) : void 0;
+}
+export {
+  ot as H,
+  Z as a,
+  st as u
+};
+//# sourceMappingURL=editor-apps-BdenSV1o.js.map