@w6w/embed 0.2.1 → 0.2.19

package/dist/repos/credentials.d.ts

@@ -0,0 +1,83 @@
+import { QueryClient } from '@tanstack/react-query';
+import { W6WClient } from '@w6w/sdk';
+import { CredentialDependents, CredentialListFilter, CredentialSummary, CredentialTestResult } from '@w6w/sdk/console';
+export type { CredentialDependents, CredentialListFilter, CredentialSummary, CredentialTestResult, } from '@w6w/sdk/console';
+export declare const credentialsKey: readonly ["credentials"];
+export declare const credentialKey: (id: string) => readonly ["credential", string];
+export declare const credentialDependentsKey: (id: string) => readonly ["credential-dependents", string];
+/**
+ * A credential write (rotate, enable/disable, delete) changes what every connection on it
+ * reports, so the credential keys AND every cached connection (single and per-app) go stale.
+ */
+export declare function invalidateAfterCredentialWrite(qc: QueryClient, id: string): void;
+export declare function listCredentials(client: W6WClient, filter?: CredentialListFilter): Promise<CredentialSummary[]>;
+export declare function getCredential(client: W6WClient, id: string): Promise<CredentialSummary>;
+export declare function createCredential(client: W6WClient, body: {
+    name: string;
+    contract: string;
+    source: Record<string, unknown>;
+}): Promise<CredentialSummary>;
+/** Rename. */
+export declare function updateCredential(client: W6WClient, id: string, body: {
+    name: string;
+}): Promise<CredentialSummary>;
+export declare function rotateCredential(client: W6WClient, id: string, body: {
+    source: Record<string, unknown>;
+}): Promise<CredentialSummary>;
+export declare function setCredentialStatus(client: W6WClient, id: string, status: "active" | "disabled"): Promise<CredentialSummary>;
+export declare function testCredential(client: W6WClient, id: string): Promise<CredentialTestResult>;
+export declare function getCredentialDependents(client: W6WClient, id: string): Promise<CredentialDependents>;
+export type DeleteCredentialResult = {
+    ok: true;
+} | {
+    ok: false;
+    dependents: CredentialDependents;
+};
+/**
+ * Delete. A 409 `credential_in_use` is data — `{ ok: false, dependents }` — not a thrown error;
+ * every other failure rejects. There is no `force`: a credential in use is never deleted.
+ * Wire (RECONCILE R-11): `{ error: { code, message, dependents: { connections } } }`.
+ */
+export declare function deleteCredential(client: W6WClient, id: string): Promise<DeleteCredentialResult>;
+export declare function useCredentialsQuery(filter?: CredentialListFilter): import('@tanstack/react-query').UseQueryResult<NoInfer<CredentialSummary[]>, Error>;
+export declare function useCredentialQuery(id: string): import('@tanstack/react-query').UseQueryResult<NoInfer<CredentialSummary>, Error>;
+export declare function useCredentialDependentsQuery(id: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<CredentialDependents>, Error>;
+export declare function useCreateCredentialMutation(): import('@tanstack/react-query').UseMutationResult<CredentialSummary, Error, {
+    name: string;
+    contract: string;
+    source: Record<string, unknown>;
+}, unknown>;
+/** Rename touches only the credential keys: no connection's state changes. */
+export declare function useUpdateCredentialMutation(id: string): import('@tanstack/react-query').UseMutationResult<CredentialSummary, Error, {
+    name: string;
+}, unknown>;
+export declare function useRotateCredentialMutation(id: string): import('@tanstack/react-query').UseMutationResult<CredentialSummary, Error, {
+    source: Record<string, unknown>;
+}, unknown>;
+export declare function useSetCredentialStatusMutation(id: string): import('@tanstack/react-query').UseMutationResult<CredentialSummary, Error, "active" | "disabled", unknown>;
+export declare function useTestCredentialMutation(id: string): import('@tanstack/react-query').UseMutationResult<CredentialTestResult, Error, void, unknown>;
+export declare function useDeleteCredentialMutation(): import('@tanstack/react-query').UseMutationResult<DeleteCredentialResult, Error, string, unknown>;
+/**
+ * The eight optional `W6WApi` credential methods over `client` (this module may not import
+ * `@w6w/ui`, so the signatures are checked where they are spread into a `W6WApi`: Studio's
+ * facade, and `W6WEmbedProvider`'s bridge). `deleteCredential` rejects on a
+ * 409 with the response body attached as `.body` (as `withApiErrorBody` does in the react adapter).
+ */
+export declare function credentialUiMethods(client: W6WClient): {
+    listCredentials: (filter?: CredentialListFilter) => Promise<CredentialSummary[]>;
+    createCredential: (body: {
+        name: string;
+        contract: string;
+        source: Record<string, unknown>;
+    }) => Promise<CredentialSummary>;
+    getCredential: (id: string) => Promise<CredentialSummary>;
+    rotateCredential: (id: string, body: {
+        source: Record<string, unknown>;
+    }) => Promise<CredentialSummary>;
+    setCredentialStatus: (id: string, status: "active" | "disabled") => Promise<CredentialSummary>;
+    testCredential: (id: string) => Promise<CredentialTestResult>;
+    credentialDependents: (id: string) => Promise<CredentialDependents>;
+    deleteCredential: (id: string) => Promise<void>;
+};
+/** Fills ONLY the credential methods that are not functions on `adapter`; keeps the rest. */
+export declare function withCredentialMethods<T extends object>(adapter: T, client: W6WClient): T;

package/dist/repos/data-stores.d.ts

@@ -0,0 +1,84 @@
+import { DataStore, DataStoreCreateInput, DataStoreEntry, DataStoreEntryPage, DataStoreKind, W6WClient } from '@w6w/sdk';
+/** The most requests one "walk every page" read makes (200 stores a page). */
+export declare const DATA_STORE_MAX_PAGES = 10;
+/** Query key for a project's store list. */
+export declare function dataStoresKey(projectId?: string): readonly ["data-stores", string | undefined, "list"];
+/** Query key for one store. */
+export declare function dataStoreKey(id: string, projectId?: string): readonly ["data-stores", string | undefined, "detail", string];
+/** Query key for one store's entries under a key prefix (`""` = no filter). */
+export declare function dataStoreEntriesKey(id: string, projectId: string | undefined, prefix: string): readonly ["data-stores", string | undefined, "entries", string, string];
+/**
+ * The project's stores, walked page by page (at most {@link DATA_STORE_MAX_PAGES} requests),
+ * server order kept. Hook-less so the ui picker's `listDataStores` seam can call it too.
+ */
+export declare function listAllDataStores(client: W6WClient, project: string): Promise<DataStore[]>;
+/** The picker's shape: store names and kinds only. */
+export declare function listDataStores(client: W6WClient, project: string): Promise<{
+    name: string;
+    kind: DataStoreKind;
+}[]>;
+/**
+ * ONE page of the entries of the project's store named `store`, for the ui's `data-store-key`
+ * picker (`W6WApi.listDataStoreEntries`): the name is resolved to its id (remembered), then
+ * `prefix` is the host's server-side key search and `limit` caps the page. An unknown name is an
+ * empty page; a failed entries read forgets the id (renamed or archived) and rethrows.
+ */
+export declare function listDataStoreEntries(client: W6WClient, project: string, store: string, opts?: {
+    prefix?: string;
+    limit?: number;
+    signal?: AbortSignal;
+}): Promise<{
+    items: {
+        key: string;
+        value: unknown;
+        updatedAt: string;
+    }[];
+    more: boolean;
+}>;
+export declare function useDataStoresQuery(projectId?: string): import('@tanstack/react-query').UseQueryResult<NoInfer<DataStore[]>, Error>;
+export declare function useDataStoreQuery(id: string, projectId?: string): import('@tanstack/react-query').UseQueryResult<NoInfer<DataStore>, Error>;
+export declare function useEntriesQuery(id: string, projectId: string | undefined, prefix: string): import('@tanstack/react-query').UseInfiniteQueryResult<import('@tanstack/react-query').InfiniteData<DataStoreEntryPage, unknown>, Error>;
+/** One entry by key, read fresh (the conflict prompt's Reload). */
+export declare function getEntry(client: W6WClient, id: string, key: string, project: string): Promise<DataStoreEntry>;
+export declare function useCreateDataStoreMutation(): import('@tanstack/react-query').UseMutationResult<DataStore, Error, {
+    input: DataStoreCreateInput;
+    project: string;
+}, unknown>;
+export declare function useArchiveDataStoreMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, {
+    id: string;
+    project: string;
+}, unknown>;
+/** `PUT` one entry. `ifVersion` is the optimistic-concurrency guard; `ttlSeconds` keeps an expiry. */
+export declare function useSetEntryMutation(): import('@tanstack/react-query').UseMutationResult<DataStoreEntry, Error, {
+    id: string;
+    key: string;
+    value: unknown;
+    ifVersion?: number;
+    ttlSeconds?: number;
+    project: string;
+}, unknown>;
+/** `POST` one table row; the server generates the key. */
+export declare function useInsertRowMutation(): import('@tanstack/react-query').UseMutationResult<DataStoreEntry, Error, {
+    id: string;
+    row: Record<string, unknown>;
+    ttlSeconds?: number;
+    project: string;
+}, unknown>;
+export declare function useDeleteEntryMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, {
+    id: string;
+    key: string;
+    project: string;
+}, unknown>;
+/** Import CSV text verbatim (`text/csv`). Resolves `{imported}`; a refusal throws an `ApiError`. */
+export declare function useImportCsvMutation(): import('@tanstack/react-query').UseMutationResult<{
+    imported: number;
+}, Error, {
+    id: string;
+    csv: string;
+    project: string;
+}, unknown>;
+/** Export a table store as CSV text. Read-only: nothing is invalidated. */
+export declare function useExportCsvMutation(): import('@tanstack/react-query').UseMutationResult<string, Error, {
+    id: string;
+    project: string;
+}, unknown>;

package/dist/repos/endpoints.d.ts

@@ -1,5 +1,5 @@
 import { W6WClient } from '@w6w/sdk';
-import { EndpointDef as SdkEndpointDef, EndpointSummary as SdkEndpointSummary, EndpointTarget as SdkEndpointTarget } from '@w6w/sdk/console';
+import { EndpointInvokeResult, 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
@@ -108,8 +108,14 @@ export declare function useGuardedSaveEndpointMutation(): import('@tanstack/reac
     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, {
+/**
+ * `POST /endpoints/:id/invoke` through `client.request` (D2). Answers `{ kind, output }`, or a 202
+ * `{ kind: "workflow", runId }` (success). `allowUnpublished: true` only when the caller opts in.
+ */
+export declare function invokeEndpoint(client: W6WClient, id: string, input: Record<string, unknown>, opts?: {
+    allowUnpublished?: boolean;
+}): Promise<EndpointInvokeResult>;
+export declare function useInvokeEndpointMutation(): import('@tanstack/react-query').UseMutationResult<EndpointInvokeResult, Error, {
     id: string;
     input: Record<string, unknown>;
 }, unknown>;

package/dist/repos/fields.d.ts

@@ -0,0 +1,34 @@
+import { W6WClient } from '@w6w/sdk';
+/**
+ * Dynamic-field resolution — `POST /apps/:id/actions/:key/fields` over `client.request()`.
+ * A 424 (the vendor lookup failed) becomes a per-field error result so one bad lookup does not
+ * blank the form; every other failure (400/403/404/network/abort) rethrows for the ui to handle.
+ */
+/**
+ * Structural mirror of ui's `W6WApi.resolveActionFields` shapes (this barrel may not import
+ * `@w6w/ui`); the facade/UiBridge assignment typechecks against W6WApi structurally.
+ */
+export interface ResolveActionFieldsBody {
+    connectionId: string;
+    version?: string;
+    reason: "init" | "change";
+    form: Record<string, unknown>;
+    previous?: Record<string, unknown>;
+    changed?: string[];
+    fields: string[];
+    unresolved: string[];
+}
+export interface ResolveActionFieldsResult {
+    fields: Record<string, {
+        options?: {
+            value: string | number;
+            label: string;
+            description?: string;
+        }[];
+        error?: string;
+    }>;
+}
+export interface ResolveActionFieldsOpts {
+    signal?: AbortSignal;
+}
+export declare function resolveActionFields(client: W6WClient, appId: string, actionKey: string, body: ResolveActionFieldsBody, opts?: ResolveActionFieldsOpts): Promise<ResolveActionFieldsResult>;

package/dist/repos/functions.d.ts

@@ -58,12 +58,14 @@ export interface FunctionInvokeResult {
     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.
+ * `POST /functions/:id/invoke` through the `client.request` escape hatch (D2: no wrappers change).
+ * The route answers the invocation frame `{ kind: "function", output, invocationId, status,
+ * durationMs }`. `allowUnpublished: true` is sent ONLY when the caller opts in (the editor's Test
+ * invoke hook); every other caller keeps the publish gate, so the key is absent otherwise.
  */
-export declare function invokeFunction(client: W6WClient, id: string, inputs: Record<string, unknown>): Promise<FunctionInvokeResult>;
+export declare function invokeFunction(client: W6WClient, id: string, inputs: Record<string, unknown>, opts?: {
+    allowUnpublished?: boolean;
+}): Promise<FunctionInvokeResult>;
 export declare function useInvokeFunctionMutation(): import('@tanstack/react-query').UseMutationResult<FunctionInvokeResult, Error, {
     id: string;
     inputs: Record<string, unknown>;

package/dist/repos/history.d.ts

@@ -22,3 +22,12 @@ export declare function useHasExecutedQuery(callableId: string): {
 /** 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>;
+/** Run a listed execution again with the same input (`rerunExecution`),
+ *  resolving to the new execution's row (or `null` if not listed yet). Every
+ *  history list, stat and probe is invalidated once it settles — a failed
+ *  re-run is still a new execution — as is the workflow's own run list. */
+export declare function useRerunExecutionMutation(): import('@tanstack/react-query').UseMutationResult<ExecutionSummary | null, Error, ExecutionSummary, unknown>;
+/** Look one execution of a callable up by id (`findExecution`) — what opens the original from a
+ *  re-run's "Re-run of <id>". A plain function over the embed client, not a query: it runs once per
+ *  click, and the opened detail has its own query. */
+export declare function useFindExecution(): (callableId: string, id: string) => Promise<ExecutionSummary | null>;

package/dist/repos/index.d.ts

@@ -9,9 +9,11 @@ export * from './workflows.ts';
 export * from './versions.ts';
 export * from './step-tests.ts';
 export * from './history.ts';
+export * from './constants.ts';
 export * from './vars.ts';
 export * from './vault.ts';
 export * from './documents.ts';
+export * from './data-stores.ts';
 export * from '../lib/history-query.ts';
 export * from '../lib/workflow-live-run.ts';
 export * from '../lib/workflow-poll.ts';
@@ -26,7 +28,12 @@ export * from './endpoints.ts';
 export * from './spec-export.ts';
 export * from './apps.ts';
 export * from './connections.ts';
+export * from './credentials.ts';
 export * from './saved-tests.ts';
 export * from './reliability.ts';
 export * from './dashboard.ts';
 export * from './api-calls.ts';
+export * from './models.ts';
+export * from './agents-studio-agents.ts';
+export * from './agents-studio-assets.ts';
+export * from './fields.ts';

package/dist/repos/models.d.ts

@@ -0,0 +1,289 @@
+import { W6WClient } from '@w6w/sdk';
+export interface ModelRates {
+    input?: number;
+    output?: number;
+    cachedInput?: number;
+    cacheWrite?: number;
+    perRequest?: number;
+    currency?: string;
+}
+export interface ModelRate {
+    id: string;
+    modelId: string;
+    effectiveFrom: string;
+    rates: ModelRates;
+    source: "seed" | "tenant";
+}
+export interface Model {
+    id: string;
+    providerAppId: string;
+    provider: string;
+    nativeId: string;
+    displayName: string;
+    capabilities: unknown;
+    limits: {
+        maxInputTokens?: number;
+        maxOutputTokens?: number;
+    };
+    status: "active" | "deprecated" | "blocked";
+    source: "discovered" | "manual";
+    currentRate: ModelRate | null;
+    discoveredAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ModelFallback {
+    model: string;
+    connection: string;
+}
+export interface ModelRoute {
+    id: string;
+    name: string;
+    project: string;
+    modelId: string;
+    connectionId: string;
+    fallbacks: ModelFallback[];
+    defaults: Record<string, unknown>;
+    status: "active" | "broken";
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ModelRouteInput {
+    name: string;
+    model: string;
+    connection: string;
+    fallbacks?: ModelFallback[];
+    defaults?: Record<string, unknown>;
+}
+export type ModelRoutePatch = Partial<Omit<ModelRouteInput, "name">>;
+export interface ModelBudgetLimits {
+    requests?: number;
+    tokens?: number;
+    costMinor?: number;
+    currency?: string;
+}
+export interface ModelBudget {
+    id: string;
+    scopeKind: string;
+    scopeId: string | null;
+    window: string;
+    limits: ModelBudgetLimits;
+    onBreach: "block" | "warn";
+}
+export interface ModelBudgetInput {
+    scopeKind: string;
+    scopeId?: string;
+    window: string;
+    limits: ModelBudgetLimits;
+    onBreach: "block" | "warn";
+}
+export type ModelBudgetPatch = Partial<Omit<ModelBudgetInput, "scopeKind" | "scopeId">>;
+export interface ModelBudgetUsageCounts {
+    requests: number;
+    tokens: number;
+    costMinor: number;
+}
+export interface ModelBudgetUsage {
+    budgetId: string;
+    window: string;
+    windowStart: string;
+    limits: ModelBudgetLimits;
+    used: ModelBudgetUsageCounts;
+    reserved: ModelBudgetUsageCounts;
+}
+export interface ModelCost {
+    currency: string;
+    amountMinor: number;
+}
+export interface ModelUsageGroup {
+    key: string;
+    requests: number;
+    totalTokens: number;
+    cost: ModelCost[];
+}
+export interface ModelUsageTotals {
+    requests: number;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    cacheWriteTokens: number;
+    totalTokens: number;
+    cost: ModelCost[];
+    unpriced: number;
+}
+export interface ModelUsageItem {
+    id: string;
+    routeId: string | null;
+    modelId: string;
+    connectionId: string;
+    provider: string;
+    nativeId: string;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    cacheWriteTokens: number;
+    totalTokens: number;
+    costMinor: number | null;
+    currency: string | null;
+    rateVersion: string | null;
+    durationMs: number;
+    ok: boolean;
+    errorCode: string | null;
+    invocationId: string | null;
+    runId: string | null;
+    occurredAt: string;
+}
+export interface ModelUsageReport {
+    totals: ModelUsageTotals;
+    totalsTruncated?: boolean | null;
+    groups?: ModelUsageGroup[];
+    items: ModelUsageItem[];
+    nextCursor: string | null;
+}
+export interface ModelUsageFilter {
+    route?: string;
+    model?: string;
+    from?: string;
+    to?: string;
+    groupBy?: "route" | "model" | "day";
+    limit?: number;
+    cursor?: string;
+}
+export interface ModelCatalogFilter {
+    provider?: string;
+    status?: string;
+    limit?: number;
+    cursor?: string;
+}
+export interface ModelCatalogPage {
+    models: Model[];
+    nextCursor: string | null;
+}
+export declare const modelCatalogKey: (filter?: ModelCatalogFilter) => readonly ["model-catalog", ModelCatalogFilter];
+export declare const modelProvidersKey: readonly ["model-providers"];
+export declare const modelRoutesKey: (projectId?: string) => readonly ["model-routes", string | undefined];
+export declare const modelBudgetsKey: (projectId?: string) => readonly ["model-budgets", string | undefined];
+export declare const modelBudgetUsageKey: (id: string, projectId?: string) => readonly ["model-budget-usage", string, string | undefined];
+export declare const modelUsageKey: (projectId?: string, filter?: ModelUsageFilter) => readonly ["model-usage", string | undefined, ModelUsageFilter];
+export declare function listModelCatalog(client: W6WClient, filter?: ModelCatalogFilter): Promise<ModelCatalogPage>;
+/** One row of `GET /models/providers` — the descriptor the model pickers are driven by. */
+export interface ModelProviderRow {
+    appId: string;
+    provider: string | null;
+    installed: boolean;
+    designation?: {
+        modelTypes: string[];
+        modelFamilies?: string[];
+    } | null;
+    operations?: {
+        discover: {
+            supported: boolean;
+            reason?: string;
+        };
+        complete: {
+            supported: boolean;
+            reason?: string;
+            features?: Partial<Record<ModelFeature, ModelFeatureState>>;
+        };
+    };
+    /** A2 (optional): the bridge adapter serving this app; `null` = none. */
+    adapter?: {
+        provider: string;
+        contractVersion: number;
+    } | null;
+    /** A2 (optional): why this app cannot serve the caller right now. */
+    reasons?: ModelProviderReason[];
+}
+export type ModelFeature = "toolCalls" | "structuredOutput" | "streaming";
+export type ModelFeatureState = "supported" | "unsupported" | "unknown";
+export type ModelProviderReasonCode = "not_installed" | "no_adapter" | "not_entitled" | "no_connection";
+export interface ModelProviderReason {
+    code: ModelProviderReasonCode;
+    message: string;
+}
+export interface CompleteSupport {
+    supported: boolean;
+    features: Partial<Record<ModelFeature, ModelFeatureState>>;
+    reasons: ModelProviderReason[];
+}
+/**
+ * THE support policy for `operations.complete`. Unsupported when the descriptor says so or the
+ * row names no adapter (`adapter: null`); a pre-A2 row (no `adapter`/`features`/`reasons`) falls
+ * back to `operations.complete.supported`. Unsupported rows always carry a reason.
+ */
+export declare function completeSupport(row: ModelProviderRow): CompleteSupport;
+/** Follow `nextCursor` until null (or `maxPages`), concatenating `models`. */
+export declare function loadAllModelCatalogPages(fetchPage: (cursor?: string) => Promise<ModelCatalogPage>, opts?: {
+    maxPages?: number;
+}): Promise<{
+    models: Model[];
+    truncated: boolean;
+}>;
+export type ModelOperation = "discover" | "complete";
+export interface ConnectionChoice {
+    id: string;
+    appId: string;
+    displayName: string;
+    /** Present only when the descriptor says the operation is unsupported for this provider. */
+    disabledReason?: string;
+}
+export declare function listModelProviders(client: W6WClient): Promise<ModelProviderRow[]>;
+/**
+ * The connections a model picker may offer for `operation`, decided by the descriptor alone:
+ * a connection whose app has no designated provider row never appears (an `ai`-category app is
+ * not a provider); a designated row whose `discover` is unsupported appears disabled with the
+ * descriptor's reason; for `complete` the shared `completeSupport` policy decides (unsupported => disabled, never selectable).
+ */
+export declare function connectionChoices<C extends {
+    id: string;
+    appId: string;
+    displayName: string;
+}>(connections: C[], providers: ModelProviderRow[], operation: ModelOperation): ConnectionChoice[];
+/** The server answers fallbacks as `{modelId, connectionId}`; the editor works in `{model, connection}`. */
+export declare function normaliseRoute(r: ModelRoute): ModelRoute;
+export declare function listModelRoutes(client: W6WClient, project: string): Promise<ModelRoute[]>;
+export declare function createModelRoute(client: W6WClient, project: string, input: ModelRouteInput): Promise<ModelRoute>;
+export declare function updateModelRoute(client: W6WClient, project: string, name: string, patch: ModelRoutePatch): Promise<ModelRoute>;
+export declare function deleteModelRoute(client: W6WClient, project: string, name: string): Promise<void>;
+export declare function listModelBudgets(client: W6WClient, project: string): Promise<ModelBudget[]>;
+export declare function createModelBudget(client: W6WClient, project: string, input: ModelBudgetInput): Promise<ModelBudget>;
+export declare function updateModelBudget(client: W6WClient, project: string, id: string, patch: ModelBudgetPatch): Promise<ModelBudget>;
+export declare function deleteModelBudget(client: W6WClient, project: string, id: string): Promise<void>;
+export declare function getModelBudgetUsage(client: W6WClient, project: string, id: string): Promise<ModelBudgetUsage>;
+export declare function getModelUsage(client: W6WClient, project: string, filter?: ModelUsageFilter): Promise<ModelUsageReport>;
+export declare function useModelCatalogQuery(filter?: ModelCatalogFilter): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelCatalogPage>, Error>;
+export declare function useAllModelCatalogQuery(filter?: Omit<ModelCatalogFilter, "cursor">): import('@tanstack/react-query').UseQueryResult<NoInfer<{
+    models: Model[];
+    truncated: boolean;
+}>, Error>;
+export declare function useModelProvidersQuery(): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelProviderRow[]>, Error>;
+export declare function useModelRoutesQuery(projectId?: string): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelRoute[]>, Error>;
+export declare function useModelBudgetsQuery(projectId?: string): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelBudget[]>, Error>;
+export declare function useModelBudgetUsageQuery(id: string, projectId?: string): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelBudgetUsage>, Error>;
+export declare function useModelUsageQuery(projectId?: string, filter?: ModelUsageFilter): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelUsageReport>, Error>;
+export declare function useCreateModelRouteMutation(): import('@tanstack/react-query').UseMutationResult<ModelRoute, Error, {
+    project: string;
+    input: ModelRouteInput;
+}, unknown>;
+export declare function useUpdateModelRouteMutation(): import('@tanstack/react-query').UseMutationResult<ModelRoute, Error, {
+    project: string;
+    name: string;
+    patch: ModelRoutePatch;
+}, unknown>;
+export declare function useDeleteModelRouteMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, {
+    project: string;
+    name: string;
+}, unknown>;
+export declare function useCreateModelBudgetMutation(): import('@tanstack/react-query').UseMutationResult<ModelBudget, Error, {
+    project: string;
+    input: ModelBudgetInput;
+}, unknown>;
+export declare function useUpdateModelBudgetMutation(): import('@tanstack/react-query').UseMutationResult<ModelBudget, Error, {
+    project: string;
+    id: string;
+    patch: ModelBudgetPatch;
+}, unknown>;
+export declare function useDeleteModelBudgetMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, {
+    project: string;
+    id: string;
+}, unknown>;

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

@@ -1,6 +1,6 @@
 /** 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";
+export type SpecCollection = "functions" | "endpoints" | "workflows";
 /**
  * Mirrors T2.1.1's `SpecDocument`, also mirrored by `repos/spec-import.ts`'s
  * `SpecImportDocument` for the sibling import route: the portable document a
@@ -16,8 +16,8 @@ export interface SpecDocument {
 }
 /**
  * `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
+ * button never renders on (`specCollectionForKind`'s `connection`
+ * arm) — 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>;

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

@@ -1,3 +1,4 @@
+import { PreviewDependency, Selection, SpecDependency } from '../lib/import-bindings.ts';
 import { SpecImportListKeys } from '../lib/spec-import-invalidation.ts';
 /**
  * Mirrors `T2.1.1`'s `SpecDocument` (`T2.1.1.contract.md:134-141`): the
@@ -30,7 +31,32 @@ export interface SpecImportResult {
         name?: string;
     };
     references: SpecImportReferenceReport[];
+    dependencies?: ImportDependencyStatus[];
 }
+/** IF-1 `POST /spec/preview` result: one entry per dependency, with server options + suggestion. */
+export interface PreviewResult {
+    kind: "function" | "endpoint" | "workflow";
+    dependencies: PreviewDependency[];
+    references?: SpecImportReferenceReport[];
+}
+/** One dependency's outcome in the import result (IF-1 `dependencies` status[]). */
+export interface ImportDependencyStatus {
+    key: string;
+    kind?: SpecDependency["kind"];
+    name?: string;
+    status: "bound" | "created" | "unconfigured" | string;
+    boundTo?: string;
+    reason?: string;
+}
+/** The preview request body: the document plus the host project, sent explicitly. */
+export declare function buildPreviewBody(document: Record<string, unknown>, project: string | undefined): Record<string, unknown>;
+/** The import request body: the preview body plus the FULL selections map (`unconfigured` included). */
+export declare function buildImportBody(document: Record<string, unknown>, project: string | undefined, selections: Record<string, Selection>): Record<string, unknown>;
+/**
+ * `POST /spec/preview` (IF-1). Read-only on the server; a failure rejects the mutation and the
+ * caller blocks Create — there is NO fallback to posting the document verbatim to `/spec/import`.
+ */
+export declare function useSpecPreviewMutation(project: string | undefined): import('@tanstack/react-query').UseMutationResult<PreviewResult, Error, Record<string, unknown>, unknown>;
 /**
  * `POST /spec/import`. Success is always `201` — including a partially
  * resolved import (T2.1.2 §E: "report, never fail silently"). This mutation
@@ -41,4 +67,7 @@ export interface SpecImportResult {
  * (`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>;
+export declare function useImportSpecMutation(project: string | undefined, listKeys: SpecImportListKeys): import('@tanstack/react-query').UseMutationResult<SpecImportResult, Error, {
+    document: Record<string, unknown>;
+    selections: Record<string, Selection>;
+}, unknown>;

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

@@ -2,6 +2,8 @@ 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];
+/** The prefix of every {@link stepTestsKey} of one workflow — invalidates all its steps at once. */
+export declare const workflowStepTestsKey: (workflowId: string) => readonly ["stepTests", 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;