@w6w/embed 0.1.1 → 0.2.0

package/dist/rail.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `@w6w/embed/rail` — place the editor's rail anywhere in a host layout. A curated surface:
+ * `<CallableWorkspace>` (the context an editor mounted with `rail={false}` publishes into) and
+ * `<CallableRail>` (reads it), plus the `RailTool` type for custom tool lists.
+ */
+export { CallableWorkspace } from './rail/CallableWorkspace.tsx';
+export type { CallableRailKind, CallableWorkspaceProps, } from './rail/CallableWorkspace.tsx';
+export { CallableRail } from './rail/CallableRail.tsx';
+export type { CallableRailProps } from './rail/CallableRail.tsx';
+export type { RailTool } from './chrome/RightRail.tsx';
+export type { RailNavigation } from './rail/rail-env.tsx';

package/dist/rail.mjs

@@ -0,0 +1,35 @@
+"use client";
+import { jsx as r } from "react/jsx-runtime";
+import { useMemo as u } from "react";
+import { W as d, R as p, P as m, u as b, a as f, e as v, b as h } from "./editor-tools-RxmY5iyi.js";
+import { r as P, b as j } from "./project-context-BiCjv_E3.js";
+const R = () => {
+};
+function y({
+  kind: l,
+  id: s,
+  project: a,
+  onNavigate: i = R,
+  children: e
+}) {
+  const o = P(a, j()), t = u(() => ({ kind: l, id: s }), [l, s]);
+  return /* @__PURE__ */ r(d, { base: t, children: /* @__PURE__ */ r(p, { project: o, onNavigate: i, children: /* @__PURE__ */ r(m, { project: o, children: e }) }) });
+}
+function E({
+  kind: l,
+  id: s,
+  tools: a = v,
+  storageKey: i
+}) {
+  const e = b(), { project: o } = f();
+  if (!e || e.kind !== l || e.id !== s) return null;
+  const t = a.filter((c) => c.isAvailable(e));
+  if (t.length === 0) return null;
+  const n = i ?? (o === null ? null : `w6w.rail.embed.${o}`);
+  return /* @__PURE__ */ r("div", { className: "w6w-embed-root", style: { display: "flex", height: "100%", minHeight: 0 }, children: /* @__PURE__ */ r(h, { tools: t, storageKey: n }) });
+}
+export {
+  E as CallableRail,
+  y as CallableWorkspace
+};
+//# sourceMappingURL=rail.mjs.map

package/dist/rail.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rail.mjs","sources":["../src/rail/CallableWorkspace.tsx","../src/rail/CallableRail.tsx"],"sourcesContent":["/**\n * `<CallableWorkspace kind id>` — the host-placed workspace a `<CallableRail>` reads. A thin\n * composition of the trio `<WorkflowEditor>` mounts for itself (`WorkspaceProvider`,\n * `RailEnvProvider`, `ProjectExpressionScope`), so there is exactly one workspace context.\n *\n * It publishes the BASE resource `{kind, id}`. An editor mounted inside it with `rail={false}`\n * publishes its richer resource (policy, triggers, `onPolicyChange`), which wins while mounted;\n * when that editor unmounts the base is restored, never cleared (see `WorkspaceProvider`).\n * Renders no DOM of its own.\n */\nimport { type ReactNode, useMemo } from \"react\";\nimport { WorkspaceProvider } from \"../chrome/workspace.tsx\";\nimport { resolveEditorProject, useProvidedProject } from \"../project-context.ts\";\nimport { ProjectExpressionScope } from \"./ExpressionScope.tsx\";\nimport { RailEnvProvider, type RailNavigation } from \"./rail-env.tsx\";\n\nexport type CallableRailKind = \"workflow\" | \"function\" | \"endpoint\";\n\nexport interface CallableWorkspaceProps {\n  kind: CallableRailKind;\n  id: string;\n  /**\n   * The project rail tools save into. Omitted: the `<W6WEmbedProvider project>`. `null` or `\"\"`:\n   * no project — tools refuse to save (never a fallback to the account default).\n   */\n  project?: string | null;\n  /** Where the host goes after a rail action (archive/delete -> list, import -> imported row). */\n  onNavigate?: (to: RailNavigation) => void;\n  children?: ReactNode;\n}\n\nconst NOOP = (): void => {};\n\nexport function CallableWorkspace({\n  kind,\n  id,\n  project,\n  onNavigate = NOOP,\n  children,\n}: CallableWorkspaceProps): ReactNode {\n  const resolved = resolveEditorProject(project, useProvidedProject());\n  const base = useMemo(() => ({ kind, id }), [kind, id]);\n  return (\n    <WorkspaceProvider base={base}>\n      <RailEnvProvider project={resolved} onNavigate={onNavigate}>\n        <ProjectExpressionScope project={resolved}>{children}</ProjectExpressionScope>\n      </RailEnvProvider>\n    </WorkspaceProvider>\n  );\n}\n","/**\n * `<CallableRail kind id>` — the editor's right rail, placeable anywhere inside a\n * `<CallableWorkspace>` (a host drawer, a sidebar). It reads the nearest workspace, renders nothing\n * when the workspace's `{kind, id}` differs or no tool is available for it, and throws outside any\n * workspace (as `useWorkspaceCallable` does).\n *\n * Settings, Code and Error handling all serve workflow, function and endpoint. Error handling on a\n * workflow shows only when an editor published its policy writer (`ctx.onPolicyChange`); on a\n * function/endpoint it is always there (it saves from the cached record when no writer is\n * published). The rail shows exactly what `isAvailable` accepts.\n */\nimport type { ReactNode } from \"react\";\nimport { type RailTool, RightRail } from \"../chrome/RightRail.tsx\";\nimport { useWorkspaceCallable } from \"../chrome/workspace.tsx\";\nimport type { CallableRailKind } from \"./CallableWorkspace.tsx\";\nimport { editorRailTools } from \"./editor-tools.ts\";\nimport { useRailEnv } from \"./rail-env.tsx\";\n\nexport interface CallableRailProps {\n  kind: CallableRailKind;\n  id: string;\n  /** Default {@link editorRailTools}. */\n  tools?: readonly RailTool[];\n  /** localStorage key for the open tool. Default `w6w.rail.embed.<project>`. */\n  storageKey?: string;\n}\n\nexport function CallableRail({\n  kind,\n  id,\n  tools = editorRailTools,\n  storageKey,\n}: CallableRailProps): ReactNode {\n  const ctx = useWorkspaceCallable();\n  const { project } = useRailEnv();\n  if (!ctx || ctx.kind !== kind || ctx.id !== id) return null;\n  const available = tools.filter((t) => t.isAvailable(ctx));\n  if (available.length === 0) return null;\n  const key = storageKey ?? (project === null ? null : `w6w.rail.embed.${project}`);\n  return (\n    <div className=\"w6w-embed-root\" style={{ display: \"flex\", height: \"100%\", minHeight: 0 }}>\n      <RightRail tools={available} storageKey={key} />\n    </div>\n  );\n}\n"],"names":["NOOP","CallableWorkspace","kind","id","project","onNavigate","children","resolved","resolveEditorProject","useProvidedProject","base","useMemo","jsx","WorkspaceProvider","RailEnvProvider","ProjectExpressionScope","CallableRail","tools","editorRailTools","storageKey","ctx","useWorkspaceCallable","useRailEnv","available","t","key","RightRail"],"mappings":";;;;;AA+BA,MAAMA,IAAO,MAAY;AAAC;AAEnB,SAASC,EAAkB;AAAA,EAChC,MAAAC;AAAA,EACA,IAAAC;AAAA,EACA,SAAAC;AAAA,EACA,YAAAC,IAAaL;AAAA,EACb,UAAAM;AACF,GAAsC;AACpC,QAAMC,IAAWC,EAAqBJ,GAASK,EAAA,CAAoB,GAC7DC,IAAOC,EAAQ,OAAO,EAAE,MAAAT,GAAM,IAAAC,MAAO,CAACD,GAAMC,CAAE,CAAC;AACrD,SACE,gBAAAS,EAACC,GAAA,EAAkB,MAAAH,GACjB,UAAA,gBAAAE,EAACE,KAAgB,SAASP,GAAU,YAAAF,GAClC,UAAA,gBAAAO,EAACG,GAAA,EAAuB,SAASR,GAAW,UAAAD,EAAA,CAAS,GACvD,GACF;AAEJ;ACtBO,SAASU,EAAa;AAAA,EAC3B,MAAAd;AAAA,EACA,IAAAC;AAAA,EACA,OAAAc,IAAQC;AAAA,EACR,YAAAC;AACF,GAAiC;AAC/B,QAAMC,IAAMC,EAAA,GACN,EAAE,SAAAjB,EAAA,IAAYkB,EAAA;AACpB,MAAI,CAACF,KAAOA,EAAI,SAASlB,KAAQkB,EAAI,OAAOjB,EAAI,QAAO;AACvD,QAAMoB,IAAYN,EAAM,OAAO,CAACO,MAAMA,EAAE,YAAYJ,CAAG,CAAC;AACxD,MAAIG,EAAU,WAAW,EAAG,QAAO;AACnC,QAAME,IAAMN,MAAef,MAAY,OAAO,OAAO,kBAAkBA,CAAO;AAC9E,2BACG,OAAA,EAAI,WAAU,kBAAiB,OAAO,EAAE,SAAS,QAAQ,QAAQ,QAAQ,WAAW,KACnF,UAAA,gBAAAQ,EAACc,GAAA,EAAU,OAAOH,GAAW,YAAYE,GAAK,GAChD;AAEJ;"}

package/dist/repos/api-calls.d.ts

@@ -0,0 +1,4 @@
+export type { ApiCallRecord } from '@w6w/sdk/console';
+export declare function useApiCallsQuery(project: string | undefined, appId: string, opts?: {
+    limit?: number;
+}): import('@tanstack/react-query').UseQueryResult<NoInfer<import('@w6w/sdk/console').ApiCallRecord[]>, Error>;

package/dist/repos/apps.d.ts

@@ -0,0 +1,14 @@
+import { W6WClient } from '@w6w/sdk';
+import { ActionDef, AppDetail } from '@w6w/sdk/console';
+export declare const appActionsKey: (id: string) => readonly ["app-actions", string];
+export declare function getAppActions(client: W6WClient, id: string): Promise<ActionDef[]>;
+/** `enabled` defaults to `true`; a selector passes `app !== ""` so an empty app issues nothing. */
+export declare function useAppActionsQuery(id: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<ActionDef[]>, Error>;
+export declare const appKey: (id: string) => readonly ["app", string];
+export declare function getApp(client: W6WClient, id: string): Promise<AppDetail>;
+/**
+ * `id` accepts `string | undefined`: a detail view's app id is `undefined` until its own
+ * connection query resolves, so the caller passes `enabled` (its `!!id` guard) instead of
+ * `!`-asserting.
+ */
+export declare function useAppQuery(id: string | undefined, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<AppDetail>, Error>;

package/dist/repos/callables.d.ts

@@ -0,0 +1,91 @@
+import { W6WClient } from '@w6w/sdk';
+import { CallableKind } from '../lib/callable-kind.ts';
+/**
+ * The structural minimum every list row of every kind satisfies — what the shared list chrome
+ * (`pages/CallablePage.tsx`) renders and the Settings rail reads by id. Kind-specific widening
+ * (`archivedAt`, an Endpoint's `status`/`incomplete`) stays in the kind's own facade, which is
+ * where the comment explaining "the SDK does not know this column yet" belongs.
+ */
+export interface CallableRow {
+    id: string;
+    /** `null` for a Workflow that has no key of its own yet (`WorkflowSummary`'s own
+     *  type) — never coerced to `""` here, so the list renders exactly what the server sent. */
+    key: string | null;
+    displayName?: string | null;
+    description?: string | null;
+    archivedAt?: string | null;
+}
+/** `<coll>` for a kind — the wire segment AND (studio mirrors the wire) the route segment. */
+export declare function callableCollection(kind: CallableKind): string;
+/** The studio route for a kind, or for one of its resources: `"functions"`, `"functions/fn_x"`. */
+export declare function callableRoute(kind: CallableKind, id?: string): string;
+/** The wire path for one resource: `/functions/fn_x`. */
+export declare function callablePath(kind: CallableKind, id: string): string;
+/** The studio route for one resource's History tab/page (T2.3.1/T2.4.1):
+ *  `"functions/fn_x/history"`. A sibling of {@link callableRoute}, not a
+ *  hand-written string per call site. */
+export declare function callableHistoryRoute(kind: CallableKind, id: string): string;
+/** `GET /<coll>`'s own query key — the literal `lib/spec-import-invalidation.ts` invalidates. */
+export declare function callableListKey(kind: CallableKind, project?: string): readonly unknown[];
+/**
+ * `GET /<coll>`. A `switch`, not a table: the three SDK calls return three different summary
+ * types, and the union is what the shared chrome consumes structurally.
+ */
+export declare function listCallables(client: W6WClient, kind: CallableKind, project?: string): Promise<CallableRow[]>;
+/**
+ * `GET /<coll>/:id`, each arm returning exactly what that kind's existing repo function returns —
+ * Function's `{...function, valid}` splice, Endpoint's `{endpoint, invokeUrl, …}` envelope,
+ * Workflow's three-field body — never re-shaped here. The return type is the honest `unknown`:
+ * the per-kind reader in the kind's own facade is what narrows it.
+ */
+export declare function getCallable(client: W6WClient, kind: CallableKind, id: string): Promise<unknown>;
+/**
+ * `POST /<coll>`, normalised to the one thing EVERY caller of a save needs — the saved resource's
+ * id and key, for the invalidation below and for a create modal's own "created" callback. The two
+ * envelopes (`{endpoint: {id, key}}`, `{workflow: {id, key}}`) and the flat one (`{id, key}`) are
+ * unwrapped in the arm that knows its own shape, so no caller outside this module ever has to.
+ *
+ * Workflow refuses without a `project` for the same reason `repos/workflows.ts`'s own save does:
+ * a missing project on a WRITE lands the definition in the account's default project instead of
+ * the one the operator is looking at.
+ */
+export declare function saveCallable(client: W6WClient, kind: CallableKind, definition: unknown, options?: {
+    project?: string;
+}): Promise<{
+    id: string;
+    key: string;
+}>;
+/**
+ * `POST /<coll>/:id/archive`. Function and Endpoint go through the plain `apiClient.request()`
+ * escape hatch (T4.1.1/A7/D-I0-7: no typed `@w6w/sdk` method exists, and adding one would drag
+ * `packages/wrappers` into this task's scope for an internal route); Workflow keeps the typed
+ * `console.workflows.archive` it has had since the rail's DangerZone landed.
+ */
+export declare function archiveCallable(client: W6WClient, kind: CallableKind, id: string): Promise<unknown>;
+/** `DELETE /<coll>/:id` — same split, and the same reasoning, as {@link archiveCallable}. */
+export declare function deleteCallable(client: W6WClient, kind: CallableKind, id: string): Promise<unknown>;
+/**
+ * `useQuery` over {@link listCallables}, keyed by {@link callableListKey}. Generic over the row
+ * type so a kind's own facade can narrow it to that kind's widened summary (Function's
+ * `archivedAt`, Endpoint's `status`/`incomplete`) without a cast at the call site.
+ */
+export declare function useCallableListQuery<Row extends CallableRow = CallableRow>(kind: CallableKind, enabled?: boolean, project?: string): import('@tanstack/react-query').UseQueryResult<NoInfer<Row[]>, Error>;
+/** `useQuery` over {@link getCallable}, keyed by {@link callableKey}. */
+export declare function useCallableQuery<Def = unknown>(kind: CallableKind, id: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<Def>, Error>;
+/**
+ * `useMutation` over {@link saveCallable}. `onSuccess` routes through the SAME
+ * `invalidateSavedCallable` helper every save in studio already uses, with the SAME two keys —
+ * the list AND the saved resource — so the Function arm's invalidation is the one
+ * `repos/functions.ts` performs today, byte for byte.
+ */
+export declare function useSaveCallableMutation(kind: CallableKind, options?: {
+    project?: string;
+}): import('@tanstack/react-query').UseMutationResult<{
+    id: string;
+    key: string;
+}, Error, unknown, unknown>;
+/** `useMutation` over {@link archiveCallable} — the list key, so the row's archived badge
+ *  refreshes and the rail's Delete control appears in Archive's place. */
+export declare function useArchiveCallableMutation(kind: CallableKind): import('@tanstack/react-query').UseMutationResult<unknown, Error, string, unknown>;
+/** `useMutation` over {@link deleteCallable}. */
+export declare function useDeleteCallableMutation(kind: CallableKind): import('@tanstack/react-query').UseMutationResult<unknown, Error, string, unknown>;

package/dist/repos/connections.d.ts

@@ -0,0 +1,33 @@
+import { ConnectionSummary, W6WClient } from '@w6w/sdk';
+import { ConnectionTestResult } from '@w6w/sdk/console';
+export type { ConnectionSummary } from '@w6w/sdk';
+export declare const connectionsForAppKey: (appId: string) => readonly ["app-connections", string];
+export declare function listConnectionsForApp(client: W6WClient, appId: string): Promise<ConnectionSummary[]>;
+/**
+ * `enabled` defaults to `true`. `TargetSelector` passes `app !== ""` — its original
+ * pre-migration guard, preserved exactly.
+ */
+export declare function useConnectionsForAppQuery(appId: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<ConnectionSummary[]>, Error>;
+export declare const connectionsKey: readonly ["connections"];
+export declare function listConnections(client: W6WClient): Promise<ConnectionSummary[]>;
+export declare function useConnectionsQuery(): import('@tanstack/react-query').UseQueryResult<NoInfer<ConnectionSummary[]>, Error>;
+export declare const connectionKey: (id: string) => readonly ["connection", string];
+export declare function getConnection(client: W6WClient, id: string): Promise<ConnectionSummary>;
+export declare function useConnectionQuery(id: string): import('@tanstack/react-query').UseQueryResult<NoInfer<ConnectionSummary>, Error>;
+export declare function createConnection(client: W6WClient, appId: string, body: {
+    authKey: string;
+    credential: Record<string, unknown>;
+    displayName?: string;
+    profile?: Record<string, unknown>;
+}): Promise<ConnectionSummary>;
+/** The write `W6WEmbedProvider` hands the ui adapter as `updateConnection` (the SDK adapter has none). */
+export declare function updateConnection(client: W6WClient, id: string, body: {
+    displayName?: string;
+    credential?: Record<string, unknown>;
+}): Promise<ConnectionSummary>;
+export declare function useUpdateConnectionMutation(connectionId: string): import('@tanstack/react-query').UseMutationResult<ConnectionSummary, Error, {
+    displayName?: string;
+    credential?: Record<string, unknown>;
+}, unknown>;
+export declare function useTestConnectionMutation(connectionId: string): import('@tanstack/react-query').UseMutationResult<ConnectionTestResult, Error, void, unknown>;
+export declare function useDeleteConnectionMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;

package/dist/repos/dashboard.d.ts

@@ -0,0 +1,4 @@
+import { DashboardStatsParams } from '@w6w/sdk/console';
+export type { DashboardStats, DashboardStatsParams } from '@w6w/sdk/console';
+/** One of the two account-scoped dashboard windows `<ActivitySummary>` renders. */
+export declare function useDashboardStatsQuery(key: "today" | "week", params: DashboardStatsParams): import('@tanstack/react-query').UseQueryResult<NoInfer<import('@w6w/sdk').DashboardStats>, Error>;

package/dist/repos/endpoints.d.ts

@@ -0,0 +1,125 @@
+import { W6WClient } from '@w6w/sdk';
+import { EndpointDef as SdkEndpointDef, EndpointSummary as SdkEndpointSummary, EndpointTarget as SdkEndpointTarget } from '@w6w/sdk/console';
+export type { ActionTarget, CallableRef, CallableOnError, ErrorHandlerTarget, EndpointAuthMode, EndpointInput, EndpointInvokeResult, EndpointSecurity, EndpointTarget, ErrorReroute, Exposure, RetryPolicy, } from '@w6w/sdk/console';
+export { SECRET_MASK } from '@w6w/sdk/console';
+/** An Endpoint's OWN target: the alias-only `endpoint` arm excluded, mirroring the
+ *  server fence in admin/endpoints.ts's validateDefinition. Aliases use the full union
+ *  (`EndpointTarget`, re-exported above verbatim). */
+export type EndpointOwnTarget = Exclude<SdkEndpointTarget, {
+    kind: "endpoint";
+}>;
+export type EndpointDef = Omit<SdkEndpointDef, "target"> & {
+    target: EndpointOwnTarget;
+};
+/**
+ * One entry of the `invokeUrls[]` array the server renders on `GET
+ * /endpoints/:id` and the `POST /endpoints` 201 (T3.4.1, `admin/endpoints.ts`'s
+ * `InvokeUrlEntry` — the shapes are kept in sync by hand, not shared, because
+ * `@w6w/sdk` does not type this field yet: it is server-fresh and
+ * `packages/wrappers` publishes in lockstep at one `VERSION` across four
+ * languages, outside this project's boundary (HITL-10). `entries[0]` is always
+ * the platform entry; every entry after it is one of the tenant's domains.
+ * `default` mirrors the tenant's stored default domain and, since D-S1
+ * (intake T-0.2), it is what CHOOSES the open-on entry: absent an
+ * in-session pick, the URL card opens on whichever entry carries it,
+ * falling back to `entries[0]` only when no entry does. `resolves` is a
+ * static host comparison the server already made; the client never
+ * re-derives it.
+ */
+export interface InvokeUrlOption {
+    domain: string;
+    default: boolean;
+    url: string;
+    urlByKey?: string;
+    resolves: boolean;
+}
+/** The two SDK-typed URL fields, widened with the untyped `invokeUrls[]`
+ *  array — the ONE seam `getEndpoint`, the save mutation and the editor's own
+ *  201 read all widen through, so `EndpointsPage.tsx` never casts. */
+type WithInvokeUrls = {
+    invokeUrl: string;
+    invokeUrlByKey?: string;
+    invokeUrls?: InvokeUrlOption[];
+};
+/** An Endpoint list row — the SDK's own summary (`status`, `incomplete` and `archivedAt` are
+ *  on it since W-12), read for draft-ness only through {@link isEndpointDraft}. */
+export type EndpointSummary = SdkEndpointSummary;
+/** Is this row a draft — not authorised to dispatch (HITL-7/HITL-8,
+ *  `rfcs/endpoint.md` § Amendment — 2026-08-14b)? Prefers the server's `status`
+ *  field (`!== "ready"`), falling back to the older `incomplete` boolean only
+ *  when `status` is absent (a server that has not shipped it yet). The sole
+ *  reader of both fields in studio; every "unfinished" UI decision (the
+ *  list's tag, and any future one) calls this rather than reading either
+ *  field inline. */
+export declare function isEndpointDraft(ep: Pick<EndpointSummary, "status" | "incomplete">): boolean;
+/** Endpoint definitions carry `manifestVersion: "2"` — the one literal, shared
+ *  by the editor's blank draft and the create modal's first POST. */
+export declare const ENDPOINT_MANIFEST_VERSION = "2";
+/** The list key {@link useEndpointsQuery} reads — `callables.ts`'s own
+ *  `callableListKey("endpoint")` (byte-identical `["endpoints"]`), kept as a named export because
+ *  `repos/spec-import.ts` invalidates it by value. */
+export declare const endpointsKey: readonly unknown[];
+export declare function useEndpointsQuery(enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<SdkEndpointSummary[]>, Error>;
+/** Fetch one Endpoint. Widens the SDK's return once — the server sends
+ *  `invokeUrls[]` (T3.4.1) that `@w6w/sdk`'s typed `get()` does not know about
+ *  yet; see {@link WithInvokeUrls}. */
+export declare function getEndpoint(client: W6WClient, id: string): Promise<{
+    endpoint: EndpointDef;
+} & WithInvokeUrls>;
+/** The single-resource key — `callables.ts`'s own `callableKey("endpoint", id)` (byte-identical
+ *  `["endpoint", id]`), kept as a named export because `repos/versions.ts`'s revert arm invalidates
+ *  it by value. */
+export declare const endpointKey: (id: string) => readonly unknown[];
+/** `TargetSelector`'s `endpoint` arm needs one Endpoint's own `input` contract
+ *  to project into fields — mirrors `useFunctionQuery`/`useWorkflowQuery`
+ *  (`repos/functions.ts`/`repos/workflows.ts`) exactly. */
+export declare function useEndpointQuery(id: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<{
+    endpoint: EndpointDef;
+} & WithInvokeUrls>, Error>;
+/**
+ * The Endpoint arm's SAVE — the one delegated name whose `mutationFn` is NOT `callables.ts`'s
+ * `saveCallable`: that helper normalises every kind's success envelope down to `{id, key}` for the
+ * invalidation below, while this kind's 201 also carries the fresh server-rendered `invokeUrl`/
+ * `invokeUrlByKey`/`invokeUrls[]` the editor's URL card renders from (`onSaveSuccess` in
+ * `EndpointsPage.tsx`). Its KEYS and its invalidation, though, are the generic pair's — so the
+ * "which keys does an Endpoint save refresh" answer still has one home.
+ */
+export declare function useSaveEndpointMutation(): import('@tanstack/react-query').UseMutationResult<{
+    endpoint: {
+        id: string;
+        key: string;
+    };
+} & WithInvokeUrls, Error, unknown, unknown>;
+/**
+ * The GUARDED Endpoint save: `console.endpoints.upsert(definition, {ifUnmodifiedSince})`, so a
+ * save from a stale copy answers `409 endpoint_stale`. Variables and invalidation as
+ * {@link useSaveEndpointMutation}'s, plus the required token (`null` opts out explicitly; it is
+ * `callableRecord("endpoint", …).updatedAt`, the envelope's TOP-LEVEL `updatedAt`). Resolves the
+ * verbatim upsert body (`{endpoint:{id,key}, invokeUrl, …, updatedAt}`). Additive: the unguarded
+ * hook's `mutate(definition)` shape is unchanged.
+ */
+export declare function useGuardedSaveEndpointMutation(): import('@tanstack/react-query').UseMutationResult<{
+    endpoint: {
+        id: string;
+        key: string;
+    };
+    updatedAt: string;
+} & WithInvokeUrls, Error, {
+    definition: unknown;
+    ifUnmodifiedSince: string | null;
+}, unknown>;
+export declare function invokeEndpoint(client: W6WClient, id: string, input: Record<string, unknown>): Promise<import('@w6w/sdk/console').EndpointInvokeResult>;
+export declare function useInvokeEndpointMutation(): import('@tanstack/react-query').UseMutationResult<import('@w6w/sdk/console').EndpointInvokeResult, Error, {
+    id: string;
+    input: Record<string, unknown>;
+}, unknown>;
+/**
+ * T4.1.1/A7/D-I0-7: `POST /endpoints/:id/archive` — the Endpoint arm of `callables.ts`'s generic
+ * pair (the plain `apiClient.request()` escape hatch, NOT a typed `@w6w/sdk` method, which would
+ * drag `packages/wrappers` into this task's scope for one internal route). Invalidates
+ * `endpointsKey`, so the list's `archivedAt` refreshes and the rail's Delete control appears in
+ * Archive's place.
+ */
+export declare function useArchiveEndpointMutation(): import('@tanstack/react-query').UseMutationResult<unknown, Error, string, unknown>;
+/** `DELETE /endpoints/:id` — the Endpoint arm of the same generic pair. */
+export declare function useDeleteEndpointMutation(): import('@tanstack/react-query').UseMutationResult<unknown, Error, string, unknown>;

package/dist/repos/functions.d.ts

@@ -0,0 +1,79 @@
+import { W6WClient } from '@w6w/sdk';
+import { FunctionSummary as SdkFunctionSummary } from '@w6w/sdk/console';
+export type { FunctionDef, FunctionImpl, FunctionInput, FunctionOutputField, } from '@w6w/sdk/console';
+/** A Function list row — the SDK's own summary (it carries `archivedAt` since W-12). */
+export type FunctionSummary = SdkFunctionSummary;
+/** The list key {@link useFunctionsQuery} reads — `callables.ts`'s own
+ *  `callableListKey("function")`, kept as a named export because
+ *  `lib/spec-import-invalidation.ts` invalidates it by value. */
+export declare const functionsKey: readonly unknown[];
+/** Function definitions carry `manifestVersion: "2"` - the one literal, shared
+ *  by the editor's blank draft and the create modal's first POST. */
+export declare const FUNCTION_MANIFEST_VERSION = "2";
+export declare function listFunctions(client: W6WClient): Promise<SdkFunctionSummary[]>;
+export declare function useFunctionsQuery(enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<SdkFunctionSummary[]>, Error>;
+export declare const functionKey: (id: string) => readonly unknown[];
+/** The Function arm's own reader: the SDK's typed `get`, whose `{...function, valid}` splice is
+ *  what `FunctionEditor` hydrates its draft from (pin 5 — the server computes `valid`; studio
+ *  never reimplements the check). */
+export declare function getFunction(client: W6WClient, id: string): Promise<import('@w6w/sdk/console').FunctionRead>;
+export declare function useFunctionQuery(id: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<import('@w6w/sdk/console').FunctionDef & {
+    updatedAt: string;
+}>, Error>;
+export declare function useSaveFunctionMutation(): import('@tanstack/react-query').UseMutationResult<{
+    id: string;
+    key: string;
+}, Error, unknown, unknown>;
+/**
+ * The GUARDED Function save: `console.functions.upsert(definition, {ifUnmodifiedSince})`, so a
+ * save made from a stale copy answers `409 function_stale` instead of overwriting the newer one.
+ * `ifUnmodifiedSince` is REQUIRED in the variables (pass `null` to opt out explicitly) so a call
+ * site cannot forget the token; it is the `updatedAt` of the copy the definition was edited from
+ * (`callableRecord("function", …).updatedAt`). Same invalidation as {@link useSaveFunctionMutation}
+ * (list + the saved resource's key); resolves `{id, key, updatedAt}`. Additive: the unguarded
+ * hook's `mutate(definition)` shape is unchanged.
+ */
+export declare function useGuardedSaveFunctionMutation(): import('@tanstack/react-query').UseMutationResult<{
+    id: string;
+    key: string;
+    updatedAt: string;
+}, Error, {
+    definition: unknown;
+    ifUnmodifiedSince: string | null;
+}, unknown>;
+/**
+ * One test invoke's result: the Function's own output, plus the platform's
+ * record of the attempt.
+ *
+ * The two are kept apart rather than merged because they answer different
+ * questions, and merging them is what the invocation envelope exists to stop:
+ * a vendor payload reading `{"statusCode": 202}` is SendGrid describing its own
+ * request, while `status` here is whether w6w considered the call a success.
+ * The frame fields are optional — an older server sends only the output.
+ */
+export interface FunctionInvokeResult {
+    output: unknown;
+    invocationId?: string;
+    status?: string;
+    durationMs?: number;
+}
+/**
+ * `fn_…` ids are already URN-shaped, so the base dispatcher resolves them
+ * directly — no id translation. `isFunctionRun` narrows the open
+ * `RunEnvelope`; a `fn_…` URN can only ever resolve to the `function` arm
+ * server-side, so the `else` branch is defensive, not a real code path.
+ */
+export declare function invokeFunction(client: W6WClient, id: string, inputs: Record<string, unknown>): Promise<FunctionInvokeResult>;
+export declare function useInvokeFunctionMutation(): import('@tanstack/react-query').UseMutationResult<FunctionInvokeResult, Error, {
+    id: string;
+    inputs: Record<string, unknown>;
+}, unknown>;
+/**
+ * T4.1.1/A7/D-I0-7: `POST /functions/:id/archive`, `DELETE /functions/:id` — the Function arm of
+ * `callables.ts`'s generic pair (the plain `apiClient.request()` escape hatch, NOT a typed
+ * `@w6w/sdk` method, which would drag `packages/wrappers` into this task's scope for two internal
+ * routes). Both invalidate `functionsKey`, so the list's `archivedAt` refreshes and the rail's
+ * Delete control appears in Archive's place.
+ */
+export declare function useArchiveFunctionMutation(): import('@tanstack/react-query').UseMutationResult<unknown, Error, string, unknown>;
+export declare function useDeleteFunctionMutation(): import('@tanstack/react-query').UseMutationResult<unknown, Error, string, unknown>;

package/dist/repos/index.d.ts

@@ -20,3 +20,13 @@ export * from '../lib/new-id.ts';
 export * from '../lib/callable-descriptors.ts';
 export * from '../lib/callable-kind.ts';
 export * from './spec-import.ts';
+export * from './callables.ts';
+export * from './functions.ts';
+export * from './endpoints.ts';
+export * from './spec-export.ts';
+export * from './apps.ts';
+export * from './connections.ts';
+export * from './saved-tests.ts';
+export * from './reliability.ts';
+export * from './dashboard.ts';
+export * from './api-calls.ts';

package/dist/repos/reliability.d.ts

@@ -0,0 +1,42 @@
+import { ReliabilityComponentReport, ReliabilityErrorMix, ReliabilityService, ReliabilityServiceMembers, ReliabilityServices, ReliabilityTimelineEntry } from '@w6w/sdk/console';
+export type { ReliabilityComponentReport, ReliabilityErrorMix, ReliabilityService, ReliabilityServiceMembers, ReliabilityServices, ReliabilityTimelineEntry, };
+/** A single bounded status request. Callers must pass at most ten app ids. */
+export declare function useReliabilityQuery(project: string | undefined, appIds: readonly string[], days?: number, limit?: number): import('@tanstack/react-query').UseQueryResult<NoInfer<ReliabilityServices>, Error>;
+/**
+ * Discover a project's service ids, then request their status in batches of at most ten.
+ * Membership discovery is identifier-only; every status request names the app ids it may inspect.
+ */
+export declare function useProjectReliabilityQuery(project: string | undefined, days?: number): {
+    data: {
+        services: never[];
+        account: string;
+        window: {
+            from: string;
+            to: string;
+            days: number;
+        };
+        uptimeMeans: string;
+        definition: {
+            id: string;
+            version: string;
+            source: string;
+        };
+        appIds: string[];
+    } | {
+        services: ReliabilityService[];
+        account: string;
+        window: {
+            from: string;
+            to: string;
+            days: number;
+        };
+        uptimeMeans: string;
+        definition: {
+            id: string;
+            version: string;
+            source: string;
+        };
+    } | undefined;
+    error: Error | null;
+    isLoading: boolean;
+};

package/dist/repos/saved-tests.d.ts

@@ -0,0 +1,46 @@
+import { W6WClient } from '@w6w/sdk';
+import { SavedTest, TestRunSummary } from '@w6w/sdk/console';
+export type { SavedTest, TestRunSummary } from '@w6w/sdk/console';
+export declare const savedTestsKey: (connId: string) => readonly ["saved-tests", string];
+export declare function listSavedTests(client: W6WClient, connId: string): Promise<SavedTest[]>;
+/**
+ * Shared by BOTH `ConnectionDetailPage.tsx` and `ConnectionActionPage.tsx` —
+ * the action page deliberately "just subscribes" to the SAME cache entry
+ * the list page already populates (no `getSavedTest` method exists). Both call
+ * sites MUST go through this hook (or `savedTestsKey` directly) so the key
+ * is byte-identical; a hand-spelled second key here would silently defeat
+ * the sharing and either double-fetch or leave the tester reading a cold,
+ * empty cache.
+ */
+export declare function useSavedTestsQuery(connId: string): import('@tanstack/react-query').UseQueryResult<NoInfer<SavedTest[]>, Error>;
+export declare const testRunsKey: (connId: string) => readonly ["test-runs", string];
+export declare function listTestRuns(client: W6WClient, connId: string): Promise<TestRunSummary[]>;
+/** `retry: false` baked in — matches the sole pre-migration caller's original option
+ * (`ConnectionDetailPage.tsx`'s comment: a load failure must not retry-storm the page). */
+export declare function useTestRunsQuery(connId: string): import('@tanstack/react-query').UseQueryResult<NoInfer<TestRunSummary[]>, Error>;
+export declare function createSavedTest(client: W6WClient, connId: string, body: {
+    actionKey: string;
+    name: string;
+    values: Record<string, unknown>;
+}): Promise<SavedTest>;
+export declare function updateSavedTest(client: W6WClient, connId: string, id: string, patch: {
+    name?: string;
+    values?: Record<string, unknown>;
+}): Promise<SavedTest>;
+export declare function deleteSavedTest(client: W6WClient, connId: string, id: string): Promise<void>;
+/**
+ * The SDK returns the REAL created `SavedTestRun` (T2.6.1's design). `@w6w/ui`'s
+ * `W6WApi.recordTestRun` is pinned `Promise<void>` (`provider.tsx:168-177`) —
+ * discard here, in the repo/adaptation layer, not in the SDK. Verified this
+ * discard is load-bearing, not decorative: a scratch `tsc --strict` check
+ * confirms `Promise<SavedTestRun>` does NOT structurally satisfy
+ * `Promise<void>` (TS's void-return leniency does not extend through a
+ * `Promise<T>` wrapper).
+ */
+export declare function recordTestRun(client: W6WClient, connId: string, body: {
+    savedTestId?: string | null;
+    actionKey: string;
+    ok: boolean;
+    summary?: string;
+    result?: unknown;
+}): Promise<void>;

package/dist/repos/spec-export.d.ts

@@ -0,0 +1,23 @@
+/** The collections that carry a `/spec` export route — `specCollectionForKind`
+ *  (`../lib/rail-settings.ts`) is the sole producer of this type's values. */
+export type SpecCollection = "functions" | "endpoints";
+/**
+ * Mirrors T2.1.1's `SpecDocument`, also mirrored by `repos/spec-import.ts`'s
+ * `SpecImportDocument` for the sibling import route: the portable document a
+ * `GET /<kind>/:id/spec` export produces. Not a bare `FunctionDef`/`EndpointDef`
+ * — `id` is deleted server-side (`admin/spec.ts:96-108`) and connection/var
+ * references ride as re-bindable `rebind` entries, never live ids.
+ */
+export interface SpecDocument {
+    specVersion: string;
+    kind: "function" | "endpoint" | "workflow";
+    callable: Record<string, unknown>;
+    rebind: unknown[];
+}
+/**
+ * `GET /<collection>/:id/spec`. `collection` is `null` for a kind the Export
+ * button never renders on (`specCollectionForKind`'s `workflow`/`connection`
+ * arms) — passing `null` disables the query regardless of `enabled`, so a
+ * caller need not re-derive that guard itself.
+ */
+export declare function useSpecQuery(collection: SpecCollection | null, id: string, enabled: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<SpecDocument>, Error>;