@w6w/embed 0.0.0-stage → 0.1.1

package/dist/rail/SettingsTool.d.ts

@@ -0,0 +1,27 @@
+import { RailTool } from '../chrome/RightRail.tsx';
+import { WorkspaceCallable } from '../chrome/workspace.tsx';
+import { RailNavigation } from './rail-env.tsx';
+/**
+ * The three open flags a Settings panel shows: the Name/Key/Tags modal, the history section, and
+ * the version list modal. They are OWNED BY THE CALLER (a stateful shell above every kind's arm),
+ * not by the arm: a rail that stays mounted across a kind change (function -> workflow ->
+ * endpoint) swaps arm component types, and state held in the arm would be remounted away,
+ * closing an open modal. Lifting them keeps the modal open exactly as the pre-split single
+ * component did.
+ */
+export type SettingsOpenState = {
+    editingSettings: boolean;
+    setEditingSettings: (v: boolean) => void;
+    historyOpen: boolean;
+    setHistoryOpen: (v: boolean) => void;
+    versionListOpen: boolean;
+    setVersionListOpen: (v: boolean) => void;
+};
+export declare function WorkflowSettingsPanel({ ctx, project, onNavigate, open, }: {
+    ctx: WorkspaceCallable;
+    project: string | null;
+    onNavigate: (to: RailNavigation) => void;
+    open: SettingsOpenState;
+}): import("react").JSX.Element;
+/** The package's Settings tool — workflow context only (Studio keeps its own for the other arms). */
+export declare const settingsTool: RailTool;

package/dist/rail/editor-tools.d.ts

@@ -0,0 +1,2 @@
+import { RailTool } from '../chrome/RightRail.tsx';
+export declare const editorRailTools: readonly RailTool[];

package/dist/rail/rail-env.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { SpecImportKind } from '../lib/spec-import-invalidation.ts';
+/** Where the host should go after a rail action. */
+export type RailNavigation = {
+    type: "list";
+} | {
+    type: "imported";
+    kind: SpecImportKind;
+    id: string;
+};
+export interface RailEnv {
+    project: string | null;
+    onNavigate(to: RailNavigation): void;
+}
+export declare function RailEnvProvider({ project, onNavigate, children, }: RailEnv & {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useRailEnv(): RailEnv;

package/dist/rail/settings-sections.d.ts

@@ -0,0 +1,93 @@
+import { ReactNode } from 'react';
+import { RailSettingsKind } from '../lib/rail-settings.ts';
+import { VersionSummary, VersionsEnvelope } from '../repos/versions.ts';
+/** The three kinds the Settings panel renders for. */
+export type SettingsKind = Extract<RailSettingsKind, "function" | "endpoint" | "workflow">;
+/** Heading row: the title and the "Edit settings" trigger for the unified settings modal. */
+export declare function SettingsHeading(props: {
+    onEdit: () => void;
+}): import("react").JSX.Element;
+/**
+ * id + key + updated (+ tags, workflow only) — and nothing else. No createdAt, ever. A two-column
+ * label/value GRID (`dl`/`dt`/`dd`); `.rail-meta-list` is the rail-scoped grid and there is
+ * deliberately no global `dl`/`dt`/`dd` rule.
+ */
+export declare function MetadataSection(props: {
+    id: string;
+    displayName: string;
+    /** `metadataFieldsForKind(kind)`. */
+    fields: ReadonlyArray<"id" | "key" | "updatedAt">;
+    /** The already-cached list row (carries key/updatedAt); `undefined` until the list loads. */
+    row: {
+        key?: string | null;
+        updatedAt: string;
+    } | undefined;
+    /** Workflow only: the tag chips. `undefined` hides the row (function/endpoint). */
+    tags?: readonly string[];
+}): import("react").JSX.Element;
+/**
+ * A5: one icon opens the combined Export/Edit JSON/Import chooser. Nothing here grows with the
+ * size of the resource's definition — the definition renders in neither vessel here, only inside
+ * a modal.
+ */
+export declare function SpecActionsTrigger(props: {
+    onOpen: () => void;
+}): import("react").JSX.Element;
+/**
+ * The chooser shell: Import always (it creates a NEW resource and navigates to it, never an
+ * in-place replacement), plus a slot the host fills with extra definition actions (Studio adds
+ * Export + Edit JSON for function/endpoint). Picking an item closes THIS modal and opens that
+ * item's own — nothing is ever nested inside this one's body.
+ */
+export declare function SpecChooserModal(props: {
+    kind: SettingsKind;
+    /** Extra definition actions, rendered above the Import row. */
+    children?: ReactNode;
+    onImport: () => void;
+    onClose: () => void;
+}): import("react").JSX.Element;
+/**
+ * Version history (A4): a link-styled icon, ALWAYS enabled ("no earlier versions" is an empty
+ * state INSIDE the list modal, never a disabled control). Once opened (`open`), the un-carded
+ * "Published: vN" line and Publish / Enable-Disable stay in the main panel.
+ */
+export declare function VersionSection(props: {
+    open: boolean;
+    versions: VersionsEnvelope | undefined;
+    publishing: boolean;
+    togglingEnabled: boolean;
+    publishError: string | null;
+    enableError: string | null;
+    onShow: () => void;
+    onPublish: () => void;
+    onToggleEnabled: () => void;
+}): import("react").JSX.Element;
+/**
+ * The "All versions" list modal — deliberately NOT titled "Version history" (which would share
+ * the `Version …` aria-label prefix the per-version detail viewer's own dialogs use).
+ */
+export declare function VersionListModal(props: {
+    loading: boolean;
+    versions: readonly VersionSummary[] | undefined;
+    onSelect: (versionNumber: number) => void;
+    onClose: () => void;
+}): import("react").JSX.Element;
+/**
+ * The bottom "danger zone": Archive (until archived) then Delete, with the two confirm modals.
+ * Per-kind variance (copy, test ids) is the table above; the caller owns the mutations and the
+ * confirm/error state, and renders this only when `hasDelete(kind)`.
+ */
+export declare function SettingsDangerZone(props: {
+    kind: SettingsKind;
+    archived: boolean;
+    deleteConfirming: boolean;
+    archiveConfirming: boolean;
+    deleteError: string | null;
+    archiveError: string | null;
+    onRequestDelete: () => void;
+    onRequestArchive: () => void;
+    onConfirmDelete: () => void;
+    onConfirmArchive: () => void;
+    onCloseDelete: () => void;
+    onCloseArchive: () => void;
+}): import("react").JSX.Element;

package/dist/repos/documents.d.ts

@@ -0,0 +1,102 @@
+import { Doc, DocumentCreateInput, DocumentPatch } from '@w6w/sdk';
+/**
+ * T1.1.1's wire shape for one document, pinned here ahead of that node
+ * merging (this node is dispatched speculatively against it — see this
+ * task's contract). `shared` and the six `source*`/`syncedAt` fields are all
+ * additive over the SDK's own `Doc`, so a locally-created document simply
+ * carries them as `null` (or `false` for `shared`) rather than omitting
+ * them. Do not rename a field — the server produces these names verbatim.
+ */
+export interface DocWithProvenance extends Doc {
+    shared: boolean;
+    /** "owner/name" of the bound repository this document was pulled from. */
+    sourceRepo: string | null;
+    /** Repo-relative file path the document was pulled from. */
+    sourcePath: string | null;
+    /** The pulled file's content hash — NOT a commit SHA. */
+    sourceSha: string | null;
+    /** The repository's HEAD commit SHA at pull time — NOT a content hash. */
+    sourceRefSha: string | null;
+    /** Web link to the file; may be absent even when the rest of provenance is set. */
+    sourceUrl: string | null;
+    /** ISO-8601. Stamped at the document's last actual change, not at every sync. */
+    syncedAt: string | null;
+}
+/**
+ * Which provenance state `DocumentDetailPage.tsx`'s "Source" card should
+ * render for `doc`. `shared` (not `sourceRepo`) is the gate: a shared
+ * document whose provenance columns haven't been stamped yet (any document
+ * synced before this feature shipped, until its next real-content sync —
+ * tier-1 "unchanged" syncs never restamp provenance) is still shared, and
+ * must say so, distinct from a genuinely private document.
+ *
+ * - `"private"` — `doc.shared` is false. No card.
+ * - `"pending"` — shared, but `sourceRepo` hasn't been stamped yet.
+ * - `"synced"` — shared, with full provenance available.
+ */
+export declare function documentProvenanceState(doc: DocWithProvenance): "private" | "pending" | "synced";
+/** Query key for a documents list, optionally scoped to a project. */
+export declare function documentsKey(projectId?: string): readonly ["documents", string | undefined];
+/**
+ * Query key for a single document, scoped to a project (mirrors
+ * {@linkcode useDocumentsQuery}'s fix at :72-79/:80-87 below — `projectId`
+ * belongs in the key itself, not just the `queryFn`, so a render where the
+ * key was cached under `projectId === undefined` genuinely changes key once
+ * `ProjectContext` resolves the real one, instead of reusing the same cache
+ * entry — and its `retry: false` wrong-project 404 — forever). Still sits
+ * under the bare `["documents"]` prefix every mutation below invalidates, so
+ * an edit/delete refreshes this page too — `"detail"` keeps it from
+ * colliding with {@linkcode documentsKey}'s own `["documents", projectId]`
+ * shape.
+ */
+export declare function documentKey(id: string, projectId?: string): readonly ["documents", "detail", string, string | undefined];
+/**
+ * A single document by id, cast to {@link DocWithProvenance} (D-5): the SDK's
+ * `Doc` doesn't model T1.1.1's provenance fields yet, and this repo is not
+ * the place to fork or extend `@w6w/sdk` (D-4). The `project` option is
+ * passed exactly as {@linkcode useDocumentsQuery} passes it — a document in a
+ * non-default project 404s without it. `enabled` defaults `true` to preserve
+ * that unscoped fallback for a caller that genuinely wants it — same as
+ * {@linkcode useDocumentsQuery}'s own `enabled` doc comment below — a
+ * project-scoped page should instead pass `enabled: projectId != null` so it
+ * never queries (and never renders) against the wrong project while
+ * `ProjectContext`'s own project list is still resolving.
+ */
+export declare function useDocumentQuery(id: string, projectId?: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<DocWithProvenance>, Error>;
+/**
+ * The current project's documents (or the tenant default when unscoped).
+ * `enabled` defaults `true` to preserve that unscoped fallback for a caller
+ * that genuinely wants it — a project-scoped page should instead pass
+ * `enabled: projectId != null` so it never queries (and never renders)
+ * against the wrong project while `ProjectContext`'s own project list is
+ * still resolving.
+ */
+export declare function useDocumentsQuery(projectId?: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<DocWithProvenance[]>, Error>;
+export declare function useCreateDocumentMutation(): import('@tanstack/react-query').UseMutationResult<Doc, Error, {
+    input: DocumentCreateInput;
+    project?: string;
+}, unknown>;
+export declare function useUpdateDocumentMutation(): import('@tanstack/react-query').UseMutationResult<Doc, Error, {
+    id: string;
+    patch: DocumentPatch;
+    project?: string;
+}, unknown>;
+export declare function useDeleteDocumentMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, {
+    id: string;
+    project?: string;
+}, unknown>;
+/**
+ * Re-pulls a shared document from its bound repository ("Sync" button, T2.1.4)
+ * — `POST /documents/:id/sync` (T3.1.1). No SDK method exists for this route
+ * yet (D-4/D-5), so this goes through `apiClient.request()` directly, same
+ * escape hatch `repo-sync.ts`'s `useSyncRepoNowMutation` uses. The document
+ * routes are project-scoped by QUERY param, not a path segment (unlike
+ * `repo-binding`'s `/projects/:id/...` shape), so `project` travels in
+ * `query`, mirroring {@linkcode useDocumentQuery}'s own `{ project: … }` use.
+ */
+export declare function useSyncDocumentMutation(): import('@tanstack/react-query').UseMutationResult<import('@w6w/sdk').HttpResponse<{
+    document: DocWithProvenance;
+}>, Error, {
+    id: string;
+    project?: string;
+}, unknown>;

package/dist/repos/history.d.ts

@@ -0,0 +1,24 @@
+import { ExecutionSummary, HistoryFilters, HistoryScope } from '../lib/history-query.ts';
+/** The project-wide or per-callable execution list, one page at a time.
+ *  Disabled while `scope` is `null` (no project/callable selected yet).
+ *  `placeholderData: keepPreviousData` keeps the previous page's rows on
+ *  screen while a filter/page change is in flight, instead of flashing to
+ *  an empty list. */
+export declare function useHistoryQuery(scope: HistoryScope | null, f: HistoryFilters, limit?: number): import('@tanstack/react-query').UseQueryResult<NoInfer<{
+    executions: ExecutionSummary[];
+    hasMore: boolean;
+}>, Error>;
+/** The aggregate stats card above the list — same scope/filters, no paging.
+ *  Disabled while `scope` is `null`. */
+export declare function useHistoryStatsQuery(scope: HistoryScope | null, f: HistoryFilters): import('@tanstack/react-query').UseQueryResult<NoInfer<import('./index.ts').ExecutionStats>, Error>;
+/** "Has this callable ever been executed?" — the cheap existence probe the
+ *  header's History button uses to decide its disabled state (one row,
+ *  every filter at its default). `hasExecuted` reads `false` while loading
+ *  or on error — never a false "yes". */
+export declare function useHasExecutedQuery(callableId: string): {
+    hasExecuted: boolean;
+    isLoading: boolean;
+};
+/** One execution's full detail, opened from a list row. Disabled while
+ *  `summary` is `null` (no row selected). */
+export declare function useExecutionDetailQuery(summary: ExecutionSummary | null): import('@tanstack/react-query').UseQueryResult<NoInfer<import('./index.ts').ExecutionDetailData>, Error>;

package/dist/repos/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `@w6w/embed/repos` — the client-backed lib modules and the editor's data repos.
+ *
+ * Every hook reads its SDK client from `useEmbedClient()` (`../draft/client-context.ts`), so a
+ * host mounts one `EmbedClientProvider` (Studio and `W6WEmbedProvider` both do) and the same
+ * code serves both. Query keys are byte-identical to the Studio copies they replace.
+ */
+export * from './workflows.ts';
+export * from './versions.ts';
+export * from './step-tests.ts';
+export * from './history.ts';
+export * from './vars.ts';
+export * from './vault.ts';
+export * from './documents.ts';
+export * from '../lib/history-query.ts';
+export * from '../lib/workflow-live-run.ts';
+export * from '../lib/workflow-poll.ts';
+export * from '../lib/save-invalidation.ts';
+export * from '../lib/new-id.ts';
+export * from '../lib/callable-descriptors.ts';
+export * from '../lib/callable-kind.ts';
+export * from './spec-import.ts';

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

@@ -0,0 +1,44 @@
+import { SpecImportListKeys } from '../lib/spec-import-invalidation.ts';
+/**
+ * Mirrors `T2.1.1`'s `SpecDocument` (`T2.1.1.contract.md:134-141`): the
+ * portable document a `GET /<kind>/:id/spec` export produces and this
+ * route consumes. Not a bare `FunctionDef` — connection/var references ride
+ * as re-bindable `rebind` entries, never live ids.
+ */
+export interface SpecImportDocument {
+    specVersion: string;
+    kind: "function" | "endpoint" | "workflow";
+    callable: Record<string, unknown>;
+    rebind: unknown[];
+}
+/** One reference site's outcome (T2.1.2 §E's `SpecImportReferenceReport`). */
+export interface SpecImportReferenceReport {
+    path: string;
+    kind: string;
+    resolved: boolean;
+    /** Present only when `resolved` is `true`. */
+    boundTo?: string;
+    /** Present only when `resolved` is `false`. */
+    reason?: string;
+}
+/** The `201` body `POST /spec/import` returns (T2.1.2 §E). */
+export interface SpecImportResult {
+    kind: "function" | "endpoint" | "workflow";
+    callable: {
+        id: string;
+        key?: string;
+        name?: string;
+    };
+    references: SpecImportReferenceReport[];
+}
+/**
+ * `POST /spec/import`. Success is always `201` — including a partially
+ * resolved import (T2.1.2 §E: "report, never fail silently"). This mutation
+ * resolves on ANY `201`; branching on `references.every(r => r.resolved)` is
+ * the caller's job (A5), never this repo's.
+ *
+ * `project` is the caller's current project — only the workflow arm reads it
+ * (`listKeys.workflowsKey(project)`), but every caller passes it uniformly rather than branching on kind itself; see
+ * `../lib/spec-import-invalidation.ts` for why the key differs by kind.
+ */
+export declare function useImportSpecMutation(project: string | undefined, listKeys: SpecImportListKeys): import('@tanstack/react-query').UseMutationResult<SpecImportResult, Error, Record<string, unknown>, unknown>;

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

@@ -0,0 +1,19 @@
+import { W6WClient } from '@w6w/sdk';
+import { StepTest } from '@w6w/sdk/console';
+export type { StepTest } from '@w6w/sdk/console';
+export declare const stepTestsKey: (workflowId: string, stepId: string) => readonly ["stepTests", string, string];
+export declare function listStepTests(client: W6WClient, workflowId: string, stepId: string): Promise<StepTest[]>;
+export declare function saveStepTest(client: W6WClient, workflowId: string, stepId: string, body: {
+    name?: string;
+    input: Record<string, unknown>;
+    with: Record<string, unknown>;
+}): Promise<StepTest>;
+/** Same void-discard reasoning as `recordTestRun` above — see that function's doc comment. */
+export declare function recordStepTestRun(client: W6WClient, workflowId: string, stepId: string, body: {
+    stepTestId?: string | null;
+    status: string;
+    input?: unknown;
+    output?: unknown;
+    error?: unknown;
+    meta?: unknown;
+}): Promise<void>;

package/dist/repos/vars.d.ts

@@ -0,0 +1,25 @@
+import { Var, VarCreateInput, VarPatch } from '@w6w/sdk';
+/** Query key for the vars list, optionally scoped to a project. */
+export declare function varsKey(projectId?: string): readonly ["vars", string | undefined];
+/**
+ * The current project's variables (or the tenant default when unscoped).
+ * `enabled` defaults `true` to preserve that unscoped fallback for a caller
+ * that genuinely wants it — a project-scoped page should instead pass
+ * `enabled: projectId != null` so it never queries (and never renders)
+ * against the wrong project while `ProjectContext`'s own project list is
+ * still resolving. Same fix as `documents.ts`'s `useDocumentsQuery`.
+ */
+export declare function useVarsQuery(projectId?: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<Var[]>, Error>;
+export declare function useCreateVarMutation(): import('@tanstack/react-query').UseMutationResult<Var, Error, {
+    input: VarCreateInput;
+    project?: string;
+}, unknown>;
+export declare function useUpdateVarMutation(): import('@tanstack/react-query').UseMutationResult<Var, Error, {
+    id: string;
+    patch: VarPatch;
+    project?: string;
+}, unknown>;
+export declare function useDeleteVarMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, {
+    id: string;
+    project?: string;
+}, unknown>;

package/dist/repos/vault.d.ts

@@ -0,0 +1,24 @@
+import { W6WClient } from '@w6w/sdk';
+import { SecretValue, VaultSecretSummary } from '@w6w/sdk/console';
+export type { SecretValue, VaultSecretSummary } from '@w6w/sdk/console';
+export declare const secretsKey: readonly ["secrets"];
+export declare function listSecrets(client: W6WClient): Promise<VaultSecretSummary[]>;
+export declare function useSecretsQuery(): import('@tanstack/react-query').UseQueryResult<NoInfer<VaultSecretSummary[]>, Error>;
+export declare function sealSecret(client: W6WClient, value: string): Promise<SecretValue>;
+/**
+ * A stable, bound `(value: string) => Promise<SecretValue>` closing over
+ * the ambient apiClient — drop straight into `ExpressionOptions.sealSecret`.
+ * Rebuilds only when `apiClient` itself changes identity (HITL-2's own
+ * token-rotation `useMemo`, one layer up).
+ */
+export declare function useSealSecret(): (value: string) => Promise<SecretValue>;
+export declare function useCreateSecretMutation(): import('@tanstack/react-query').UseMutationResult<VaultSecretSummary, Error, {
+    name: string;
+    value: string;
+    description?: string;
+}, unknown>;
+export declare function useUpdateSecretMutation(id: string): import('@tanstack/react-query').UseMutationResult<VaultSecretSummary, Error, {
+    value?: string;
+    description?: string;
+}, unknown>;
+export declare function useDeleteSecretMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;

package/dist/repos/versions.d.ts

@@ -0,0 +1,112 @@
+/** The three kinds the wire contract's version-history routes exist for — `connection` has none
+ *  (see `hasVersionHistory`, `../lib/rail-settings.ts`). */
+export type VersionsKind = "function" | "workflow" | "endpoint";
+/** One row of `GET /<coll>/:id/versions`'s `versions` array — newest first, per the wire contract. */
+export interface VersionSummary {
+    versionNumber: number;
+    createdAt: string;
+    createdBy: string | null;
+    isCurrentPublished: boolean;
+}
+/** `GET /<coll>/:id/versions`'s full 200 body. */
+export interface VersionsEnvelope {
+    enabled: boolean;
+    currentPublishedVersion: number | null;
+    versions: VersionSummary[];
+}
+/** `GET /<coll>/:id/versions/:n`'s `version` field — `definition` is the redacted stored
+ *  definition for THIS query; {@link useRevertMutation} is what posts a version's definition
+ *  back onto the live resource, and {@link useInvokeVersionMutation} is what runs it. */
+export interface VersionDetail {
+    versionNumber: number;
+    createdAt: string;
+    createdBy: string | null;
+    isCurrentPublished: boolean;
+    definition: Record<string, unknown>;
+}
+/** `POST /<coll>/:id/publish`'s 200 body. */
+export interface PublishResult {
+    version: {
+        kind: string;
+        callableId: string;
+        versionNumber: number;
+        createdAt: string;
+        createdBy: string | null;
+    };
+    currentPublishedVersion: number;
+}
+/** `POST /<coll>/:id/versions/:n/revert`'s 200 body. */
+export interface RevertResult {
+    reverted: {
+        kind: string;
+        callableId: string;
+        versionNumber: number;
+    };
+}
+export declare function versionsKey(kind: VersionsKind | null, id: string): readonly ["versions", VersionsKind | null, string];
+export declare function versionKey(kind: VersionsKind | null, id: string, versionNumber: number | null): readonly ["version", VersionsKind | null, string, number | null];
+/**
+ * `GET /<collection>/:id/versions`. Never fires on mount — `enabled` is the caller's own flag
+ * (the Settings panel's History-open state, or `WorkflowsPage.tsx`'s own editor-open gate), ANDed
+ * with `kind !== null` and `id !== ""`, exactly `useSpecQuery`'s shape (`spec-export.ts:45-57`).
+ */
+export declare function useVersionsQuery(kind: VersionsKind | null, id: string, enabled: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<VersionsEnvelope>, Error>;
+/**
+ * `GET /<collection>/:id/versions/:n`. Same gating shape as {@link useVersionsQuery}, plus
+ * `versionNumber !== null` — the modal opens this only once a row has been clicked.
+ */
+export declare function useVersionQuery(kind: VersionsKind | null, id: string, versionNumber: number | null, enabled: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<VersionDetail>, Error>;
+/**
+ * `POST /<collection>/:id/publish`. `kind` is fixed per hook instance — the caller already knows
+ * which kind it is publishing (the rail's `ctx.kind`, or `WorkflowsPage.tsx`'s hardcoded
+ * `"workflow"`) — and `mutate(id)` supplies the resource. `onSuccess` invalidates the SAME
+ * `["versions", kind, id]` key {@link useVersionsQuery} reads, so the panel's published pointer
+ * and version list are fresh without a reload (A3), mirroring `useSaveFunctionMutation`'s
+ * `onSuccess` shape (`./functions.ts`).
+ */
+export declare function usePublishMutation(kind: VersionsKind): import('@tanstack/react-query').UseMutationResult<PublishResult, Error, string, unknown>;
+/**
+ * `POST /<collection>/:id/{enable,disable}`. One mutation for both — the wire contract is two
+ * routes distinguished only by which one is called, so `vars.enabled` picks the path segment
+ * rather than this module carrying two near-identical mutations. `onSuccess` invalidates the same
+ * key {@link usePublishMutation} does, for the same reason.
+ */
+export declare function useSetEnabledMutation(kind: VersionsKind): import('@tanstack/react-query').UseMutationResult<{
+    enabled: boolean;
+}, Error, {
+    id: string;
+    enabled: boolean;
+}, unknown>;
+/**
+ * `POST /<collection>/:id/versions/:n/revert`, no body — overwrites the LIVE resource's
+ * `definition` with the archived version's content, preserving its `key`/address (HITL-4's
+ * pinned default; see the module docblock). This is the first mutation in this family that
+ * changes `definition` rather than merely appending to or flipping a flag on the version history
+ * (`usePublishMutation`/`useSetEnabledMutation` above do neither), so `onSuccess` invalidates
+ * BOTH `versionsKey(kind, id)` (the same key those two invalidate) AND the kind's own
+ * definition-edit key — via the shared `invalidateSavedCallable` helper
+ * `useSaveFunctionMutation`/`useSaveEndpointMutation` already route through
+ * (`../lib/save-invalidation.ts`) — or the page a user reverted FROM keeps showing the
+ * pre-revert draft until a manual reload. The definition key is picked by a `switch` naming all
+ * three arms explicitly, with no `default:` — the same reasoning `COLLECTION_PATH`'s own docblock
+ * gives: a derived rule would silently send one kind at another kind's key.
+ */
+export declare function useRevertMutation(kind: VersionsKind): import('@tanstack/react-query').UseMutationResult<RevertResult, Error, {
+    id: string;
+    versionNumber: number;
+}, unknown>;
+/**
+ * `POST /<collection>/:id/versions/:n/{invoke,run}`, an EMPTY JSON body — identical to that
+ * kind's unversioned invoke/run route's success body, except the requested version's OWN
+ * `impl`/definition runs instead of the live one (T5.3.1's wire contract table). Unlike
+ * {@link useRevertMutation}, invoking changes no resource state, so it invalidates History ONLY
+ * (`onSettled`, `historyKeys.root` — a version run is a run, failed ones included, like every other
+ * run path) and no resource query — the caller (`VersionHistoryModal`) renders the mutation's own `data`/`error` state
+ * directly, and that state is naturally cleared whenever the modal remounts for a different
+ * version (`SettingsTool.tsx`'s `openVersion` gate fully unmounts/remounts it, never leaves it
+ * mounted across a prop change).
+ */
+export declare function useInvokeVersionMutation(kind: VersionsKind): import('@tanstack/react-query').UseMutationResult<Record<string, unknown>, Error, {
+    id: string;
+    versionNumber: number;
+}, unknown>;

package/dist/repos.d.ts

@@ -0,0 +1,2 @@
+export * from './repos/index'
+export {}

package/dist/repos.mjs

@@ -0,0 +1,94 @@
+"use client";
+import { C as s, E as t, H as u, I as o, R as r, S as n, c as i, a as l, b as y, d as c, e as S, f as M, g as R, h as f, i as w, j as E, k as d, l as k, m as p, n as D, o as m, p as v, q as I, r as Q, s as T, t as K, u as W, v as L, w as _, x as C, y as g, z as A, A as h, B as H, D as P, F as b, G as F, J as O, K as V, L as x, M as N, N as U, O as B, P as Y, Q as q, T as j, U as G, V as Z, W as z, X as J, Y as X, Z as $, _ as aa, $ as ea, a0 as sa, a1 as ta, a2 as ua, a3 as oa, a4 as ra, a5 as na, a6 as ia, a7 as la, a8 as ya, a9 as ca, aa as Sa, ab as Ma, ac as Ra, ad as fa, ae as wa, af as Ea, ag as da, ah as ka, ai as pa, aj as Da, ak as ma, al as va, am as Ia, an as Qa, ao as Ta, ap as Ka, aq as Wa, ar as La, as as _a, at as Ca, au as ga, av as Aa, aw as ha, ax as Ha, ay as Pa } from "./spec-import-HgO7ZkLZ.js";
+export {
+  s as CALLABLE_DESCRIPTORS,
+  t as EMPTY_HISTORY_FILTERS,
+  u as HISTORY_PAGE_SIZE,
+  o as ID_ALPHABET,
+  r as RUN_FAILED_NO_REASON,
+  n as STEP_FAILED_NO_REASON,
+  i as callableKey,
+  l as cancelWorkflowRun,
+  y as classifyCancelError,
+  c as descriptorFor,
+  S as documentKey,
+  M as documentProvenanceState,
+  R as documentsKey,
+  f as filtersFromSearch,
+  w as filtersToSearch,
+  E as getExecutionDetail,
+  d as getHistory,
+  k as getHistoryStats,
+  p as getRunState,
+  D as getWorkflow,
+  m as historyKeys,
+  v as historyRequestQuery,
+  I as invalidateSavedCallable,
+  Q as isRunInFlight,
+  T as latestFixtureInput,
+  K as listSecrets,
+  W as listStepTests,
+  L as listWorkflows,
+  _ as mapRunStateToLogSteps,
+  C as newCallableId,
+  g as newId,
+  A as pollRunToTerminal,
+  h as recordStepTestRun,
+  H as resolveHeaderRunInput,
+  P as runButtonLabel,
+  b as runLevelErrors,
+  F as runStateKey,
+  O as runWorkflow,
+  V as runWorkflowSync,
+  x as runsKey,
+  N as saveStepTest,
+  U as sealSecret,
+  B as secretsKey,
+  Y as shouldContinuePolling,
+  q as startWorkflowRun,
+  j as stepTestsKey,
+  G as toLogError,
+  Z as useArchiveWorkflowMutation,
+  z as useCancelRunMutation,
+  J as useCreateDocumentMutation,
+  X as useCreateSecretMutation,
+  $ as useCreateVarMutation,
+  aa as useCreateWorkflowMutation,
+  ea as useDeleteDocumentMutation,
+  sa as useDeleteSecretMutation,
+  ta as useDeleteVarMutation,
+  ua as useDeleteWorkflowMutation,
+  oa as useDocumentQuery,
+  ra as useDocumentsQuery,
+  na as useExecutionDetailQuery,
+  ia as useHasExecutedQuery,
+  la as useHistoryQuery,
+  ya as useHistoryStatsQuery,
+  ca as useImportSpecMutation,
+  Sa as useInvokeVersionMutation,
+  Ma as useLiveRunQuery,
+  Ra as usePublishMutation,
+  fa as useRevertMutation,
+  wa as useRunWorkflowMutation,
+  Ea as useRunsQuery,
+  da as useSaveWorkflowMutation,
+  ka as useSealSecret,
+  pa as useSecretsQuery,
+  Da as useSetEnabledMutation,
+  ma as useStartRunMutation,
+  va as useSyncDocumentMutation,
+  Ia as useUpdateDocumentMutation,
+  Qa as useUpdateSecretMutation,
+  Ta as useUpdateVarMutation,
+  Ka as useVarsQuery,
+  Wa as useVersionQuery,
+  La as useVersionsQuery,
+  _a as useWorkflowQuery,
+  Ca as useWorkflowsQuery,
+  ga as varsKey,
+  Aa as versionKey,
+  ha as versionsKey,
+  Ha as workflowKey,
+  Pa as workflowsKey
+};
+//# sourceMappingURL=repos.mjs.map

package/dist/repos.mjs.map

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