@w6w/embed 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { W6WEmbedProvider, type W6WEmbedProviderProps } from './W6WEmbedProvider.tsx';

package/dist/index.mjs

@@ -0,0 +1,67 @@
+"use client";
+import { jsx as r } from "react/jsx-runtime";
+import { QueryClientProvider as w, QueryClient as R } from "@tanstack/react-query";
+import { W6WProvider as j, useW6WClient as h, createW6WUiAdapter as S } from "@w6w/react";
+import { W6WUIProvider as U } from "@w6w/ui";
+import { useState as u, useRef as y, useEffect as C, useMemo as x } from "react";
+import { E as A } from "./client-context-CX61Bgw-.js";
+import { c as D, D as Q } from "./draft-registry-YF0tqNN0.js";
+import { E as B } from "./project-context-Dbk0Gr1K.js";
+function W() {
+  return new R({
+    defaultOptions: { queries: { retry: !1, refetchOnWindowFocus: !1 } }
+  });
+}
+function K({ children: t }) {
+  return /* @__PURE__ */ r(A, { client: h(), children: t });
+}
+function O({ theme: t, children: o }) {
+  const e = h(), s = x(() => S(e), [e]);
+  return /* @__PURE__ */ r(U, { api: s, theme: t, children: o });
+}
+function L({
+  apiOrigin: t,
+  getSession: o,
+  identityKey: e,
+  theme: s,
+  ready: g,
+  project: f,
+  fetch: v,
+  children: P
+}) {
+  const [c] = u(D), [i, E] = u(() => ({
+    identityKey: e,
+    queryClient: W()
+  })), b = e !== i.identityKey, d = y({ apiOrigin: t, project: f, getSession: o });
+  b || (d.current = { apiOrigin: t, project: f, getSession: o });
+  const n = d.current, a = y(n.getSession);
+  a.current = n.getSession;
+  const [q] = u(() => () => a.current());
+  C(() => {
+    if (e === i.identityKey) return;
+    let m = !1;
+    const p = () => {
+      m || E({ identityKey: e, queryClient: W() });
+    };
+    return c.flushAll().then(p, p), () => {
+      m = !0;
+    };
+  }, [e, i.identityKey, c]);
+  const l = i.queryClient;
+  return C(() => () => l.clear(), [l]), /* @__PURE__ */ r(Q, { registry: c, children: /* @__PURE__ */ r(w, { client: l, children: /* @__PURE__ */ r(
+    j,
+    {
+      baseUrl: n.apiOrigin,
+      getSession: q,
+      identityKey: i.identityKey,
+      ready: g,
+      project: n.project,
+      fetch: v,
+      children: /* @__PURE__ */ r(B.Provider, { value: n.project, children: /* @__PURE__ */ r(K, { children: /* @__PURE__ */ r(O, { theme: s, children: P }) }) })
+    }
+  ) }, i.identityKey) });
+}
+export {
+  L as W6WEmbedProvider
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../src/W6WEmbedProvider.tsx"],"sourcesContent":["import { QueryClient, QueryClientProvider } from \"@tanstack/react-query\";\n/**\n * `<W6WEmbedProvider>` — everything an embedded w6w surface needs from a host, behind one\n * element: an identity-scoped `QueryClient`, a `@w6w/react` `<W6WProvider>` (client, session\n * renewal, per-request token) and `@w6w/ui`'s `<W6WUIProvider>` fed by `createW6WUiAdapter`.\n * It composes the three public pieces exactly as `@w6w/react`'s README bridge does: it never\n * spreads or patches the adapter, never reaches into `client.console`, and keeps no session\n * store of its own (`getSession` goes straight to `<W6WProvider>`).\n *\n * **Identity cache.** The `QueryClient` is owned here, not borrowed from the host, and it is a\n * NEW instance whenever `identityKey` changes — so a query cached while signed in as account A\n * is unreachable once the host switches to B. A new client alone is NOT enough: a mounted\n * `useQuery` keeps the `QueryObserver` it was born with, and that observer is bound to the client\n * it was created against, so a child that survives the swap would keep rendering A's cache. The\n * subtree is therefore also re-mounted (`key`), which drops every observer and every piece of\n * child state from the previous identity. The client, the `key` and the tuple handed to\n * `<W6WProvider>` all change in ONE state update: there is no render in which B's tree reads A's\n * cache. The old client is cleared once it is no longer mounted.\n *\n * **Identity switch (flush first).** A draft with a pending save must be written into the account\n * that produced the edit. When `identityKey` changes this provider therefore HOLDS the applied\n * tuple — `identityKey`, `apiOrigin`, `project`, `getSession`, the client — and keeps handing the\n * OLD one to `<W6WProvider>`, awaits `registry.flushAll()` (bounded, never rejects), and only then\n * applies the new tuple in a single update. `<W6WProvider>` swaps its client synchronously on a\n * new `identityKey` and detaches the old session store, so the flush must finish first; and the\n * new `getSession` is NOT forwarded early: `<W6WProvider>` reaches it through the stable wrapper\n * below, whose target is swapped in the same update as the tuple (forwarded early, the new\n * account's token would be minted on the old client). A flush that fails or times out still lets\n * the switch proceed (Q6) and is never retried with the new identity. A token rotation under an\n * unchanged `identityKey` is not a switch: it is forwarded at once, no hold.\n */\nimport { W6WProvider, type W6WSession, createW6WUiAdapter, useW6WClient } from \"@w6w/react\";\nimport type { FetchLike } from \"@w6w/sdk\";\nimport { type ThemeMode, W6WUIProvider } from \"@w6w/ui\";\nimport { type ReactNode, useEffect, useMemo, useRef, useState } from \"react\";\nimport { DraftRegistryProvider, EmbedClientProvider, createDraftRegistry } from \"./draft/index.ts\";\nimport { EmbedProjectContext } from \"./project-context.ts\";\n\nexport interface W6WEmbedProviderProps {\n  /** The w6w API origin, e.g. `\"https://api.w6w.io\"`. */\n  apiOrigin: string;\n  /**\n   * Mints a session for the CURRENT host user (`{token, expiresAt, expiresIn?}`). Always the\n   * latest callback; the provider caches and renews the result.\n   */\n  getSession: () => Promise<W6WSession>;\n  /**\n   * Which signed-in identity this provider speaks for (e.g. `${userId}:${accountId}`). Changing it\n   * rebuilds the API client AND replaces the `QueryClient`, so nothing cached for the previous\n   * identity is ever shown under the new one.\n   */\n  identityKey: string;\n  /** Force the `@w6w/ui` theme to follow the host's. Omit to resolve it the library's default way. */\n  theme?: ThemeMode;\n  /** Gates every read hook while `false` (default `true`) — e.g. until the host has a user. */\n  ready?: boolean;\n  /** Default project id for project-scoped operations. */\n  project?: string;\n  /** Transport override (tests, request recording). Defaults to `globalThis.fetch`. */\n  fetch?: FetchLike;\n  children: ReactNode;\n}\n\nfunction makeQueryClient(): QueryClient {\n  // Same defaults as Studio's own client (`studio/src/main.tsx`).\n  return new QueryClient({\n    defaultOptions: { queries: { retry: false, refetchOnWindowFocus: false } },\n  });\n}\n\n/** The part of the tuple that changes only when a switch has been APPLIED (after the flush). */\ninterface Applied {\n  identityKey: string;\n  queryClient: QueryClient;\n}\n\n/** What `<W6WProvider>` is fed while no switch is in progress; frozen at the last such render. */\ninterface Forwarded {\n  apiOrigin: string;\n  project: string | undefined;\n  getSession: () => Promise<W6WSession>;\n}\n\n/** Hands the SDK client of the nearest `<W6WProvider>` to `useWorkflowDraft`. */\nfunction ClientBridge({ children }: { children: ReactNode }) {\n  return <EmbedClientProvider client={useW6WClient()}>{children}</EmbedClientProvider>;\n}\n\n/** The README bridge: `useW6WClient` -> `createW6WUiAdapter` -> `<W6WUIProvider>`. */\nfunction UiBridge({ theme, children }: { theme?: ThemeMode; children: ReactNode }) {\n  const client = useW6WClient();\n  const api = useMemo(() => createW6WUiAdapter(client), [client]);\n  return (\n    <W6WUIProvider api={api} theme={theme}>\n      {children}\n    </W6WUIProvider>\n  );\n}\n\nexport function W6WEmbedProvider({\n  apiOrigin,\n  getSession,\n  identityKey,\n  theme,\n  ready,\n  project,\n  fetch,\n  children,\n}: W6WEmbedProviderProps): ReactNode {\n  const [registry] = useState(createDraftRegistry);\n  const [applied, setApplied] = useState<Applied>(() => ({\n    identityKey,\n    queryClient: makeQueryClient(),\n  }));\n\n  // While `identityKey` differs from the applied one a switch is pending: everything below keeps\n  // using the values frozen at the last render that was not pending. Otherwise props flow straight\n  // through (project / origin changes, token rotation). Idempotent latest-value writes, the same\n  // pattern `<W6WProvider>` uses for its own refs.\n  const switching = identityKey !== applied.identityKey;\n  const forwardedRef = useRef<Forwarded>({ apiOrigin, project, getSession });\n  if (!switching) forwardedRef.current = { apiOrigin, project, getSession };\n  const forwarded = forwardedRef.current;\n\n  // The stable `getSession` handed to `<W6WProvider>`: reads whatever is applied RIGHT NOW. Its\n  // target changes in the same render that applies the new tuple, never before the flush settles.\n  const sessionRef = useRef(forwarded.getSession);\n  sessionRef.current = forwarded.getSession;\n  const [stableGetSession] = useState(() => () => sessionRef.current());\n\n  useEffect(() => {\n    if (identityKey === applied.identityKey) return;\n    let cancelled = false;\n    const apply = () => {\n      if (cancelled) return;\n      setApplied({ identityKey, queryClient: makeQueryClient() });\n    };\n    // `flushAll` never rejects and is bounded; the switch proceeds either way (Q6).\n    registry.flushAll().then(apply, apply);\n    return () => {\n      cancelled = true;\n    };\n  }, [identityKey, applied.identityKey, registry]);\n\n  // The replaced client is dropped once nothing mounted reads it.\n  const queryClient = applied.queryClient;\n  useEffect(() => () => queryClient.clear(), [queryClient]);\n\n  return (\n    <DraftRegistryProvider registry={registry}>\n      <QueryClientProvider key={applied.identityKey} client={queryClient}>\n        <W6WProvider\n          baseUrl={forwarded.apiOrigin}\n          getSession={stableGetSession}\n          identityKey={applied.identityKey}\n          ready={ready}\n          project={forwarded.project}\n          fetch={fetch}\n        >\n          <EmbedProjectContext.Provider value={forwarded.project}>\n            <ClientBridge>\n              <UiBridge theme={theme}>{children}</UiBridge>\n            </ClientBridge>\n          </EmbedProjectContext.Provider>\n        </W6WProvider>\n      </QueryClientProvider>\n    </DraftRegistryProvider>\n  );\n}\n"],"names":["makeQueryClient","QueryClient","ClientBridge","children","jsx","EmbedClientProvider","useW6WClient","UiBridge","theme","client","api","useMemo","createW6WUiAdapter","W6WUIProvider","W6WEmbedProvider","apiOrigin","getSession","identityKey","ready","project","fetch","registry","useState","createDraftRegistry","applied","setApplied","switching","forwardedRef","useRef","forwarded","sessionRef","stableGetSession","useEffect","cancelled","apply","queryClient","DraftRegistryProvider","QueryClientProvider","W6WProvider","EmbedProjectContext"],"mappings":";;;;;;;;;AA+DA,SAASA,IAA+B;AAEtC,SAAO,IAAIC,EAAY;AAAA,IACrB,gBAAgB,EAAE,SAAS,EAAE,OAAO,IAAO,sBAAsB,KAAM;AAAA,EAAE,CAC1E;AACH;AAgBA,SAASC,EAAa,EAAE,UAAAC,KAAqC;AAC3D,SAAO,gBAAAC,EAACC,GAAA,EAAoB,QAAQC,EAAA,GAAiB,UAAAH,GAAS;AAChE;AAGA,SAASI,EAAS,EAAE,OAAAC,GAAO,UAAAL,KAAwD;AACjF,QAAMM,IAASH,EAAA,GACTI,IAAMC,EAAQ,MAAMC,EAAmBH,CAAM,GAAG,CAACA,CAAM,CAAC;AAC9D,SACE,gBAAAL,EAACS,GAAA,EAAc,KAAAH,GAAU,OAAAF,GACtB,UAAAL,EAAA,CACH;AAEJ;AAEO,SAASW,EAAiB;AAAA,EAC/B,WAAAC;AAAA,EACA,YAAAC;AAAA,EACA,aAAAC;AAAA,EACA,OAAAT;AAAA,EACA,OAAAU;AAAA,EACA,SAAAC;AAAA,EACA,OAAAC;AAAA,EACA,UAAAjB;AACF,GAAqC;AACnC,QAAM,CAACkB,CAAQ,IAAIC,EAASC,CAAmB,GACzC,CAACC,GAASC,CAAU,IAAIH,EAAkB,OAAO;AAAA,IACrD,aAAAL;AAAA,IACA,aAAajB,EAAA;AAAA,EAAgB,EAC7B,GAMI0B,IAAYT,MAAgBO,EAAQ,aACpCG,IAAeC,EAAkB,EAAE,WAAAb,GAAW,SAAAI,GAAS,YAAAH,GAAY;AACzE,EAAKU,MAAWC,EAAa,UAAU,EAAE,WAAAZ,GAAW,SAAAI,GAAS,YAAAH,EAAA;AAC7D,QAAMa,IAAYF,EAAa,SAIzBG,IAAaF,EAAOC,EAAU,UAAU;AAC9C,EAAAC,EAAW,UAAUD,EAAU;AAC/B,QAAM,CAACE,CAAgB,IAAIT,EAAS,MAAM,MAAMQ,EAAW,SAAS;AAEpE,EAAAE,EAAU,MAAM;AACd,QAAIf,MAAgBO,EAAQ,YAAa;AACzC,QAAIS,IAAY;AAChB,UAAMC,IAAQ,MAAM;AAClB,MAAID,KACJR,EAAW,EAAE,aAAAR,GAAa,aAAajB,EAAA,GAAmB;AAAA,IAC5D;AAEA,WAAAqB,EAAS,SAAA,EAAW,KAAKa,GAAOA,CAAK,GAC9B,MAAM;AACX,MAAAD,IAAY;AAAA,IACd;AAAA,EACF,GAAG,CAAChB,GAAaO,EAAQ,aAAaH,CAAQ,CAAC;AAG/C,QAAMc,IAAcX,EAAQ;AAC5B,SAAAQ,EAAU,MAAM,MAAMG,EAAY,SAAS,CAACA,CAAW,CAAC,qBAGrDC,GAAA,EAAsB,UAAAf,GACrB,UAAA,gBAAAjB,EAACiC,GAAA,EAA8C,QAAQF,GACrD,UAAA,gBAAA/B;AAAA,IAACkC;AAAA,IAAA;AAAA,MACC,SAAST,EAAU;AAAA,MACnB,YAAYE;AAAA,MACZ,aAAaP,EAAQ;AAAA,MACrB,OAAAN;AAAA,MACA,SAASW,EAAU;AAAA,MACnB,OAAAT;AAAA,MAEA,UAAA,gBAAAhB,EAACmC,EAAoB,UAApB,EAA6B,OAAOV,EAAU,SAC7C,UAAA,gBAAAzB,EAACF,GAAA,EACC,UAAA,gBAAAE,EAACG,GAAA,EAAS,OAAAC,GAAe,UAAAL,EAAA,CAAS,GACpC,EAAA,CACF;AAAA,IAAA;AAAA,EAAA,KAbsBqB,EAAQ,WAelC,GACF;AAEJ;"}

package/dist/lib/callable-descriptors.d.ts

@@ -0,0 +1,77 @@
+import { CallableKind } from './callable-kind.ts';
+export type { CallableKind };
+/** The Settings modal's own per-kind behaviour (T4.2.1's formalization of the
+ *  seven `kind ===` conditionals `CallableSettingsModal.tsx` used to carry). */
+export interface CallableSettingsDescriptor {
+    /** May the `key` be typed here at all? Function/Workflow yes, Endpoint no
+     *  (`rfcs/endpoint.md` — an Endpoint's address is its identity). */
+    canEditKey: boolean;
+    /** Does this kind store tags? Workflow only. */
+    hasTags: boolean;
+    /** Placeholder for the Name field. */
+    namePlaceholder: string;
+    /** Placeholder for the Key field (read only when {@link canEditKey}). */
+    keyPlaceholder: string;
+    /** Appended to the shared "Lowercase, kebab-case, 3–39 characters." hint —
+     *  `""` for a kind that cannot unset its key, the "Leave empty to unset."
+     *  sentence for the one that can. */
+    keyHintSuffix: string;
+}
+/** The editor chrome's own per-kind copy. */
+export interface CallableEditorDescriptor {
+    /** The back control's label, e.g. `"← Functions"`. */
+    backLabel: string;
+    /** Heading fallback while the definition is still hydrating. */
+    newTitle: string;
+    /** Rendered in place of the form when the hydration GET 404s. */
+    notFoundTitle: string;
+    /** The Save button's idle label. */
+    saveLabel: string;
+}
+export interface CallableDescriptor {
+    kind: CallableKind;
+    /** The list page's `<h2>`, and the editor document title's second segment. */
+    listTitle: string;
+    /** The list page's explanatory paragraph. */
+    listDescription: string;
+    /** The empty-state paragraph (verbatim, including its typographic quotes). */
+    emptyCopy: string;
+    /** The create button's label, e.g. `"+ New function"`. */
+    newLabel: string;
+    /** The synthetic id's own prefix — `fn_…`/`ep_…`/`wf_…`, never user-edited. */
+    newIdPrefix: string;
+    /** `data-testid` of the list's Import affordance. */
+    importOpenTestId: string;
+    /** `data-testid` of the list's "Show archived" checkbox. */
+    showArchivedTestId: string;
+    /** `data-testid` of a row's "archived" badge. */
+    archivedBadgeTestId: string;
+    /** The row button's `title` tooltip (T4.2.3 — replaces the shared template literal
+     *  `` `Open this ${kind} in the editor.` ``, since Workflow's own row opens the visual editor,
+     *  not "the editor"). */
+    openRowTitle: string;
+    editor: CallableEditorDescriptor;
+    settings: CallableSettingsDescriptor;
+}
+/**
+ * The three kinds, every arm named explicitly — a total `Record<CallableKind,
+ * …>`, so a fourth kind fails to compile here rather than silently rendering
+ * another kind's copy (the same reasoning `COLLECTION_PATH` gives in
+ * `src/repos/versions.ts`).
+ *
+ * Only the `function` arm is consumed today: Endpoints and Workflows keep their
+ * own pages until T4.2.2/T4.2.3. Their arms are filled from those pages'
+ * current literals so the later nodes are a deletion, not a re-derivation.
+ */
+export declare const CALLABLE_DESCRIPTORS: Record<CallableKind, CallableDescriptor>;
+/** Look a descriptor up by kind. A plain index, never a `switch`: the `Record`
+ *  above already made every arm total. */
+export declare function descriptorFor(kind: CallableKind): CallableDescriptor;
+/**
+ * A fresh synthetic id for a create-modal's first POST — `fn_<uuid>` for a
+ * Function (verbatim the `newFunctionId` `FunctionsPage.tsx` used to hold),
+ * `ep_`/`wf_` for the other two, whose pages mint the same shapes today. The
+ * prefix comes from the descriptor, so "which kind is this?" is answered by the
+ * same table that answers every other kind question.
+ */
+export declare function newCallableId(kind: CallableKind): string;

package/dist/lib/callable-kind.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The three callable kinds and the single-resource query key per kind.
+ *
+ * Moved verbatim out of Studio's `repos/callables.ts` (`CallableKind`, `callableKey` and the one
+ * pure table `callableKey` closes over, `RESOURCE_KEY`) so `repos/versions.ts` — which ships in
+ * this package for all three kind arms — can invalidate a definition by key without importing a
+ * Studio module. `repos/callables.ts` imports these from `@w6w/embed/repos` and does NOT re-export
+ * them. No React, no client: loadable by `node --test`.
+ */
+/** The three kinds the callable repos are total over. */
+export type CallableKind = "function" | "endpoint" | "workflow";
+/** `GET /<coll>/:id`'s own query key — the literal `lib/save-invalidation.ts` invalidates. */
+export declare function callableKey(kind: CallableKind, id: string): readonly unknown[];

package/dist/lib/code-rail.d.ts

@@ -0,0 +1,45 @@
+import { SnippetCallable, SnippetInput } from './sdk-snippets.ts';
+/** Structural mirror of T2.1.2's widened `WorkspaceCallable` (`src/ui/workspace.tsx`). */
+export type RailCallable = {
+    kind: "function";
+    id: string;
+    key?: string;
+    inputs?: readonly SnippetInput[];
+    alias?: string;
+} | {
+    kind: "endpoint";
+    id: string;
+    key?: string;
+    invokeUrl?: string;
+    invokeUrlByKey?: string;
+    urlForm?: "id" | "key";
+    alias?: string;
+    inputs?: readonly SnippetInput[];
+} | {
+    kind: "workflow";
+    id: string;
+    label?: string;
+    key?: string;
+} | {
+    kind: "connection";
+    id: string;
+} | null;
+/**
+ * Is a "Call from code" panel meaningful for this context? Mirrors
+ * `alias-rail.ts`'s `targetForCallable` fail-closed shape exactly (its own
+ * comment: *"'connection' and no resource at all both fail closed to null —
+ * house style"*) — `"connection"` and `null` both answer `false`.
+ */
+export declare function isAvailable(ctx: RailCallable): boolean;
+/**
+ * The widened-union -> `SnippetCallable` conversion `CodeTool.Panel` hands to
+ * `CallFromCodeBody`. `null` for a context this tool has no snippet for
+ * (`"connection"`, or no resource at all) — defensive, since `isAvailable`
+ * already keeps the tool off the strip for those.
+ *
+ * The one easy-to-miss field: `WorkspaceCallable`'s `label` maps to
+ * `SnippetCallable`'s `workflow` arm's `displayName` — NOT the same field
+ * name. A naive `{...ctx}` spread compiles (both optional) but silently
+ * drops the label everywhere it matters, never caught by `tsc`.
+ */
+export declare function toSnippetCallable(ctx: RailCallable): SnippetCallable | null;

package/dist/lib/document-sources.d.ts

@@ -0,0 +1,26 @@
+import { Doc } from '@w6w/sdk';
+/** One document's contribution to `ExpressionOptions.documents` — structurally
+ * identical to `@w6w/ui`'s (unexported) `ExpressionDocumentSource`. */
+export interface DocumentSource {
+    key: string;
+    fields?: {
+        key: string;
+    }[];
+}
+/**
+ * The `ExpressionOptions.documents` array: `{ key }` for every document, plus
+ * `fields` (raw, unfiltered top-level keys) when the gate holds AND the
+ * parsed object has at least one key. `fields` is OMITTED (not `[]`) both
+ * when the gate fails and when it holds but yields zero keys — a consumer
+ * must be able to tell "nothing declared" from "declared none".
+ */
+export declare function projectDocumentSources(docs: Doc[]): DocumentSource[];
+/**
+ * The `sampleValues` entries the ƒx Result preview substitutes for document
+ * refs: `documents.<key>` → the document's raw content, for every document
+ * (unconditional, exactly as before this project), PLUS `documents.<key>.<field>`
+ * → the field's own parsed value, for the gated set only. Without the second
+ * half, every field ref this project newly makes pickable would preview as
+ * the empty string (`renderResult` does an exact flat-key lookup).
+ */
+export declare function documentSampleValues(docs: Doc[]): Record<string, unknown>;

package/dist/lib/error-handler-self.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The authoring-time half of the error-handler recursion guard. The server
+ * compares resolved values at dispatch time; this small, pure decision keeps
+ * the rail from creating the known-identical no-adapter case in the first
+ * place without losing an adapter imported or authored elsewhere.
+ */
+export type ErrorHandlerSelfDecision = "allow" | "warn" | "block";
+export interface ErrorHandlerSelfInput {
+    resource: {
+        kind: string;
+        id: string;
+    };
+    target: {
+        kind: string;
+        id: string;
+    };
+    hasAdapter: boolean;
+}
+/**
+ * Only Function and Workflow targets can re-enter the currently edited
+ * resource. Actions are always allowed. A self-target with no adapter passes
+ * the failed input through unchanged, so it is refused; an adapter is kept
+ * and called out because only the runtime can determine its resolved values.
+ */
+export declare function errorHandlerSelfDecision({ resource, target, hasAdapter, }: ErrorHandlerSelfInput): ErrorHandlerSelfDecision;

package/dist/lib/history-query.d.ts

@@ -0,0 +1,135 @@
+import { W6WClient } from '@w6w/sdk';
+export type ExecutionKind = "function" | "endpoint" | "workflow";
+export type ExecutionStatus = "queued" | "running" | "succeeded" | "failed" | "canceled";
+export interface ExecutionSummary {
+    id: string;
+    kind: ExecutionKind;
+    callableId: string;
+    callableName: string;
+    status: ExecutionStatus;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number | null;
+    workflowRunId: string | null;
+}
+export interface ExecutionStats {
+    total: number;
+    succeeded: number;
+    failed: number;
+    canceled: number;
+    inFlight: number;
+    successRate: number | null;
+    avgDurationMs: number | null;
+}
+/** Either the project-wide view or one callable's own history — mutually
+ *  exclusive, never both, mirroring the wire's own `project`|`callable`
+ *  params (exactly one). */
+export type HistoryScope = {
+    project: string;
+} | {
+    callable: string;
+};
+/** Everything the History page's filter chrome can set, already parsed out
+ *  of the URL. `status`/`kind` are `""` for "any"; `from`/`to` are the
+ *  `YYYY-MM-DD` the date pickers hand back, or `""` for unset; `offset` is
+ *  always a non-negative integer (0 for "first page"). */
+export interface HistoryFilters {
+    status: ExecutionStatus | "";
+    kind: ExecutionKind | "";
+    from: string;
+    to: string;
+    q: string;
+    offset: number;
+}
+export declare const EMPTY_HISTORY_FILTERS: HistoryFilters;
+export declare const HISTORY_PAGE_SIZE = 25;
+/**
+ * URL search string → `HistoryFilters`. An unrecognised `status`/`kind`, a
+ * `from`/`to` not matching `YYYY-MM-DD`, or a non-integer/negative `offset`
+ * all fall back to their empty/zero default rather than carrying a bogus
+ * value forward into a request — a stale or hand-edited URL degrades to "no
+ * filter" instead of erroring.
+ */
+export declare function filtersFromSearch(search: string): HistoryFilters;
+/**
+ * `HistoryFilters` → URL search string. `""` when every field is at its
+ * default, else a leading-`?` string with only the non-default fields, in
+ * the pinned key order `status,kind,from,to,q,offset` (so two renders of the
+ * same filters always produce byte-identical URLs — stable for bookmarking
+ * and for `filtersFromSearch` round-tripping).
+ */
+export declare function filtersToSearch(f: HistoryFilters): string;
+/**
+ * `HistoryFilters` + a scope → the wire's own query params (D3/pinned rules).
+ * `kind` is sent only for a project scope with a non-empty kind — a
+ * per-callable view already knows its one kind, and the server's `kind`
+ * param is project-mode-only. `from`/`to` are expanded from the picked
+ * calendar day into the half-open `[from, to)` ISO instant range the wire
+ * wants — `to` is the NEXT day's midnight so the picked day itself is fully
+ * inclusive. `q` is trimmed and omitted when blank (server-side id/name
+ * search, D3 — never a payload scan). Paging params are added only when
+ * `opts.paged`: `limit` always (defaulting to `HISTORY_PAGE_SIZE`), `offset`
+ * only when it would change anything (`> 0`).
+ */
+export declare function historyRequestQuery(scope: HistoryScope, f: HistoryFilters, opts: {
+    paged: boolean;
+    limit?: number;
+}): Record<string, string>;
+/**
+ * Every key this domain reads or invalidates. `list`/`stats` carry the full
+ * scope and filters object so two distinct filter sets never collide on the
+ * same cache entry (and the identical pair always do) — react-query's own
+ * structural key hashing does the rest.
+ */
+export declare const historyKeys: {
+    root: readonly ["history"];
+    list(scope: HistoryScope, f: HistoryFilters, limit: number): readonly unknown[];
+    stats(scope: HistoryScope, f: HistoryFilters): readonly unknown[];
+    exists(callableId: string): readonly ["history", "exists", string];
+    detail(kind: ExecutionKind, id: string): readonly ["history", "detail", ExecutionKind, string];
+};
+/** `GET /history` — paged. */
+export declare function getHistory(client: W6WClient, scope: HistoryScope, f: HistoryFilters, limit?: number): Promise<{
+    executions: ExecutionSummary[];
+    hasMore: boolean;
+}>;
+/** `GET /history/stats` — unpaged (no `limit`/`offset`). */
+export declare function getHistoryStats(client: W6WClient, scope: HistoryScope, f: HistoryFilters): Promise<ExecutionStats>;
+/** One execution's full detail — the shape `ExecutionDetail` (`@w6w/ui`,
+ *  T2.2.2) renders. `steps` is present only for a workflow run; a
+ *  function/endpoint invocation has none. */
+export interface ExecutionDetailData {
+    id: string;
+    kind: ExecutionKind;
+    callableName: string;
+    status: ExecutionStatus;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number | null;
+    input?: unknown;
+    output?: unknown;
+    error?: unknown;
+    steps?: Array<{
+        id: string;
+        status: "pending" | "running" | "succeeded" | "failed" | "skipped";
+        startedAt?: string;
+        finishedAt?: string;
+        input?: unknown;
+        output?: unknown;
+    }>;
+}
+/**
+ * Expand a list row into its full detail. Function/Endpoint invocations are
+ * synchronous calls recorded one row per call (`.claude/docs/invocations.md`)
+ * — `GET /invocations/:id` by the escape-hatch `client.request` (no typed SDK
+ * method exists for this internal route, same reasoning as
+ * `repos/callables.ts`'s `archiveCallable`/`deleteCallable` split; A1: no
+ * other runtime import needed). A workflow run instead reuses
+ * `client.console.workflows.getRun` (`repos/workflows.ts`'s own
+ * `getRunState`) — its `variables` become the detail's `input`, and its
+ * opaque `steps` map through the SAME `mapRunStateToLogSteps` the live-run
+ * overlay uses, so a historical run's step list renders identically to a
+ * live one. `callableName` always comes from the summary — neither read
+ * carries a human-readable callable name of its own.
+ */
+export declare function getExecutionDetail(client: W6WClient, summary: ExecutionSummary): Promise<ExecutionDetailData>;

package/dist/lib/import-paste.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pure decision behind `ImportSpecModal`'s Submit gate (T1.2.1, generalizing T3.2.1's A3 over all
+ * three spec kinds).
+ *
+ * `/spec/import` accepts all three spec kinds at one route (T2.1.2 §B), and this affordance is now
+ * mounted on the Functions, Endpoints and Workflows lists alike — each instance passing its own
+ * `expectedKind`. Pasting a document of the WRONG kind onto a given list would still create a row
+ * server-side and then send the operator to e.g. `functions/<ep_…>`, which 404s in the target
+ * page's editor. So this module refuses, client-side, before any request is ever sent: (1) text
+ * that isn't JSON, (2) a parse result that isn't a plain object, (3) a parsed `kind` that doesn't
+ * match `expectedKind`.
+ *
+ * Nothing beyond that is checked here — `specVersion`, `callable`'s shape,
+ * connection/reference resolvability, all of it is the SERVER's job
+ * (T2.1.2 §B); duplicating any of it here would drift from what the route
+ * actually enforces.
+ *
+ * `node --test` throws `ERR_UNKNOWN_FILE_EXTENSION` on anything reaching the
+ * `@w6w/ui` import graph (`src/lib/alias-rail.ts`'s docblock), so this module
+ * takes no value import at all — it has no dependency to avoid in the first
+ * place.
+ */
+/** The parsed paste, once it is confirmed to be a plain JSON object. */
+export type ParsedSpecDocument = Record<string, unknown>;
+/** The one kind a given mount of the Import affordance expects — see `ImportSpecModal`'s `kind` prop. */
+export type ExpectedSpecKind = "function" | "endpoint" | "workflow";
+export interface ImportPasteResult {
+    /**
+     * The parsed JSON when it is a plain object — populated even when
+     * `blockedReason` names a wrong `kind`, so a caller could still inspect
+     * what was found. `null` when the text didn't even parse to an object.
+     */
+    parsed: ParsedSpecDocument | null;
+    /** `null` exactly when the paste is a plausible spec document of `expectedKind`. */
+    blockedReason: string | null;
+}
+/**
+ * Total: never throws, always returns. `JSON.parse` is the only thing here
+ * that can throw, and it is caught.
+ */
+export declare function parseImportPaste(text: string, expectedKind: ExpectedSpecKind): ImportPasteResult;

package/dist/lib/index.d.ts

@@ -0,0 +1,17 @@
+export * from './workflow-validity.ts';
+export * from './workflow-variables.ts';
+export * from './workflow-settings.ts';
+export * from './workflow-route.ts';
+export type { RailCallable } from './code-rail.ts';
+export { isAvailable as isCodeRailAvailable, toSnippetCallable } from './code-rail.ts';
+export * from './import-paste.ts';
+export * from './error-handler-self.ts';
+export * from './document-sources.ts';
+export * from './rail-settings.ts';
+export type { CallableDefinition, CallablePolicy, SettingsCallable, } from './settings-rail.ts';
+export { definitionWithPolicy, isAvailable as isSettingsRailAvailable, policyFromDefinition, } from './settings-rail.ts';
+export type { TriggerPreview, TriggerPreviewContext, TriggerPreviewFieldDef, } from './trigger-preview.ts';
+export { triggerInputSeed, triggerPreviews } from './trigger-preview.ts';
+export * from './sdk-snippets.ts';
+export * from './slug.ts';
+export * from './spec-import-invalidation.ts';

package/dist/lib/new-id.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Platform id minter (studio copy). Algorithm is byte-identical to the server's
+ * `packages/ids/ids.ts`: alphabet base62, drop byte b >= 248 (largest multiple of 62
+ * that fits a byte), keep ALPHABET[b % 62]. No modulo bias.
+ */
+export declare const ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+/** Byte source seam; defaults to `crypto.getRandomValues`. */
+export type ByteSource = (n: number) => Uint8Array;
+/** `<prefix>_<len chars of base62>`. */
+export declare function newId(prefix: string, len?: number, bytes?: ByteSource): string;