@tailor-platform/sdk 2.0.0-next.4 → 2.0.0-next.6

package/dist/vitest/mocks/aigateway.d.mts

@@ -1,30 +1,40 @@
 import { AIGatewayName } from "@tailor-platform/sdk";
-
 //#region src/vitest/mocks/aigateway.d.ts
 interface AigatewayCall {
   name: AIGatewayName;
 }
+/** Initial fixtures for an AI Gateway mock. */
+interface MockAigatewayOptions {
+  /** AI Gateway URLs available when the mock is acquired. */
+  urls?: Partial<Record<AIGatewayName, string>>;
+}
 /**
  * Acquire a disposable mock for `tailor.aigateway`. Restored on dispose.
+ * @param options - Initial AI Gateway URL fixtures
  * @returns Disposable AI Gateway mock control object
  * @example
  * ```typescript
  * import { mockAigateway } from "@tailor-platform/sdk/vitest";
  *
  * test("resolves an AI Gateway URL", async () => {
- *   using aigateway = mockAigateway();
- *   aigateway.setUrls({ "my-aigateway": "https://my-aigateway.example.com" });
+ *   using aigateway = mockAigateway({
+ *     urls: { "my-aigateway": "https://my-aigateway.example.com" },
+ *   });
+ *   aigateway.setUrl("my-aigateway", "https://replacement.example.com");
  *   // …
  * });
  * ```
  */
-declare function mockAigateway(): {
-  /** The `get` `vi.fn`. */get: import("vitest").Mock<(name: AIGatewayName) => Promise<{
+declare function mockAigateway(options?: MockAigatewayOptions): {
+  /** The `get` `vi.fn`. */
+  get: import("vitest").Mock<(name: AIGatewayName) => Promise<{
     url: string;
   }>>;
   setUrls(value: Partial<Record<AIGatewayName, string>>): void;
+  setUrl(name: AIGatewayName, url: string): void;
   readonly calls: AigatewayCall[];
+  clear(): void;
   reset(): void;
 } & Disposable;
 //#endregion
-export { mockAigateway };
+export { MockAigatewayOptions, mockAigateway };

package/dist/vitest/mocks/authconnection.d.mts

@@ -1,28 +1,38 @@
 import { AuthConnectionTokenResult, ConnectionName } from "@tailor-platform/sdk";
-
 //#region src/vitest/mocks/authconnection.d.ts
 interface AuthConnectionCall {
   connectionName: ConnectionName;
 }
+/** Initial fixtures and fallback behavior for an AuthConnection mock. */
+interface MockAuthconnectionOptions {
+  /** Tokens available when the mock is acquired. */
+  tokens?: Partial<Record<ConnectionName, AuthConnectionTokenResult>>;
+  /** Return a placeholder token or throw when a connection has no configured token. */
+  onUnhandled?: "fallback" | "error";
+}
 /**
  * Acquire a disposable mock for `tailor.authconnection`. Restored on dispose.
+ * @param options - Initial token fixtures and fallback behavior
  * @returns Disposable AuthConnection mock control object
  * @example
  * ```typescript
  * import { mockAuthconnection } from "@tailor-platform/sdk/vitest";
  *
  * test("returns configured token", async () => {
- *   using ac = mockAuthconnection();
- *   ac.setTokens({ google: { access_token: "ya29.xxx" } });
+ *   using ac = mockAuthconnection({ tokens: { google: { access_token: "ya29.xxx" } } });
+ *   ac.setToken("google", { access_token: "replacement" });
  *   // …
  * });
  * ```
  */
-declare function mockAuthconnection(): {
-  /** The `getConnectionToken` `vi.fn`. */getConnectionToken: import("vitest").Mock<(connectionName: ConnectionName) => Promise<AuthConnectionTokenResult>>;
+declare function mockAuthconnection(options?: MockAuthconnectionOptions): {
+  /** The `getConnectionToken` `vi.fn`. */
+  getConnectionToken: import("vitest").Mock<(connectionName: ConnectionName) => Promise<AuthConnectionTokenResult>>;
   setTokens(value: Partial<Record<ConnectionName, AuthConnectionTokenResult>>): void;
+  setToken(connectionName: ConnectionName, token: AuthConnectionTokenResult): void;
   readonly calls: AuthConnectionCall[];
+  clear(): void;
   reset(): void;
 } & Disposable;
 //#endregion
-export { mockAuthconnection };
+export { MockAuthconnectionOptions, mockAuthconnection };

package/dist/vitest/mocks/file.d.mts

@@ -1,3 +1,5 @@
+import { FileDownloadAsBase64Response, FileDownloadResponse, FileDownloadStreamResponse, FileMetadata, FileUploadOptions, FileUploadResponse, FileUploadStreamOptions } from "../../runtime/file.mjs";
+import { Mock } from "vitest";
 //#region src/vitest/mocks/file.d.ts
 type FileResolver = (method: string, call: FileCall) => unknown;
 interface FileCall {
@@ -7,8 +9,14 @@ interface FileCall {
   fieldName: string;
   recordId: string;
 }
+/** Controls fallback behavior for File calls without a configured result. */
+interface MockFileOptions {
+  /** Return a type-compatible fixture or throw when no behavior is configured. */
+  onUnhandled?: "fallback" | "error";
+}
 /**
  * Acquire a disposable mock for `tailordb.file`. Restored on dispose.
+ * @param options - Controls behavior for calls without a configured result
  * @returns Disposable File mock control object
  * @example
  * ```typescript
@@ -16,26 +24,35 @@ interface FileCall {
  *
  * test("mock file download", async () => {
  *   using file = mockFile();
- *   file.enqueueResult({ data: new Uint8Array([1, 2, 3]), metadata: { ... } });
+ *   file.download.mockResolvedValue({ data: new Uint8Array(), metadata: { ... } });
  *   // …
  * });
  * ```
  */
-declare function mockFile(): {
+declare function mockFile(options?: MockFileOptions): {
   setResolver(value: FileResolver): void;
   /**
-   * Enqueue a single result for the next `tailordb.file` call (FIFO; falls
-   * back to `setResolver` when exhausted).
+   * Enqueue a single result for the next `tailordb.file` call.
+   * The queue is shared across all methods and namespaces.
    * @param result - Result to return from the next file call
    */
   enqueueResult(result: unknown): void;
   /**
    * Enqueue results for multiple subsequent `tailordb.file` calls.
+   * The queue is shared across all methods and namespaces.
    * @param results - Results to enqueue, one per upcoming call
    */
   enqueueResults(...results: unknown[]): void;
-  readonly calls: FileCall[];
+  calls: FileCall[];
+  clear(): void;
   reset(): void;
+  delete: Mock<(namespace: string, typeName: string, fieldName: string, recordId: string) => Promise<void>>;
+  upload: Mock<(namespace: string, typeName: string, fieldName: string, recordId: string, data: string | ArrayBuffer | Uint8Array | number[], options?: FileUploadOptions) => Promise<FileUploadResponse>>;
+  download: Mock<(namespace: string, typeName: string, fieldName: string, recordId: string) => Promise<FileDownloadResponse>>;
+  downloadAsBase64: Mock<(namespace: string, typeName: string, fieldName: string, recordId: string) => Promise<FileDownloadAsBase64Response>>;
+  getMetadata: Mock<(namespace: string, typeName: string, fieldName: string, recordId: string) => Promise<FileMetadata>>;
+  downloadStream: Mock<(namespace: string, typeName: string, fieldName: string, recordId: string) => Promise<FileDownloadStreamResponse>>;
+  uploadStream: Mock<(namespace: string, typeName: string, fieldName: string, recordId: string, readableStream: ReadableStream<Uint8Array | ArrayBuffer>, options?: FileUploadStreamOptions) => Promise<FileUploadResponse>>;
 } & Disposable;
 //#endregion
-export { mockFile };
+export { MockFileOptions, mockFile };

package/dist/vitest/mocks/iconv.d.mts

@@ -1,11 +1,24 @@
+import { MockInstance } from "vitest";
 //#region src/vitest/mocks/iconv.d.ts
 type IconvResolver = (method: string, args: unknown[]) => unknown;
+type IconvMethod = "convert" | "convertBuffer" | "decode" | "encode" | "encodings";
 interface IconvCall {
-  method: string;
+  method: IconvMethod;
   args: unknown[];
 }
+type ConversionResult = string | Uint8Array;
+type ConvertMockProcedure = (input: string | Uint8Array | ArrayBuffer, fromEncoding: string, toEncoding: string) => ConversionResult;
+type ConvertBufferMockProcedure = (input: Uint8Array | ArrayBuffer, fromEncoding: string, toEncoding: string) => ConversionResult;
+type EncodeMockProcedure = (input: string, encoding: string) => ConversionResult;
+type TypedOperationMock<RuntimeProcedure, MockProcedure extends (...args: never[]) => unknown> = RuntimeProcedure & MockInstance<MockProcedure>;
+/** Controls how unconfigured Iconv operations are handled. */
+interface MockIconvOptions {
+  /** Return an empty type-compatible value or throw when no behavior is configured. */
+  onUnhandled?: "fallback" | "error";
+}
 /**
  * Acquire a disposable mock for `tailor.iconv`. Restored on dispose.
+ * @param options - Fallback behavior for unconfigured operations
  * @returns Disposable Iconv mock control object
  * @example
  * ```typescript
@@ -13,15 +26,26 @@ interface IconvCall {
  *
  * test("mock encoding conversion", () => {
  *   using iconv = mockIconv();
- *   iconv.setResolver((method) => (method === "decode" ? "decoded-text" : null));
+ *   iconv.decode.mockReturnValue("decoded-text");
  *   // …
  * });
  * ```
  */
-declare function mockIconv(): {
+declare function mockIconv(options?: MockIconvOptions): {
+  /** The `convert` `vi.fn`. */
+  convert: TypedOperationMock<(<T extends string>(str: string | Uint8Array | ArrayBuffer, fromEncoding: string, toEncoding: T) => T extends "UTF8" | "UTF-8" ? string : Uint8Array), ConvertMockProcedure>;
+  /** The `convertBuffer` `vi.fn`. */
+  convertBuffer: TypedOperationMock<(<T extends string>(buffer: Uint8Array | ArrayBuffer, fromEncoding: string, toEncoding: T) => T extends "UTF8" | "UTF-8" ? string : Uint8Array), ConvertBufferMockProcedure>;
+  /** The `decode` `vi.fn`. */
+  decode: import("vitest").Mock<(input: Uint8Array | ArrayBuffer, encoding: string) => string>;
+  /** The `encode` `vi.fn`. */
+  encode: TypedOperationMock<(<T extends string>(str: string, encoding: T) => T extends "UTF8" | "UTF-8" ? string : Uint8Array), EncodeMockProcedure>;
+  /** The `encodings` `vi.fn`. */
+  encodings: import("vitest").Mock<() => string[]>;
   setResolver(value: IconvResolver): void;
   readonly calls: IconvCall[];
+  clear: () => void;
   reset(): void;
 } & Disposable;
 //#endregion
-export { mockIconv };
+export { MockIconvOptions, mockIconv };

package/dist/vitest/mocks/idp.d.mts

@@ -1,44 +1,60 @@
+import { IdpClientConstructor, IdpClientInstance } from "../../runtime/idp.mjs";
 import { Mock } from "vitest";
-
 //#region src/vitest/mocks/idp.d.ts
+type IdpMethod = keyof IdpClientInstance;
 type IdpResolver = (method: string, args: unknown[], namespace: string) => unknown;
 interface IdpCall {
   method: string;
   args: unknown[];
   namespace: string;
 }
+/** Controls fallback behavior for IdP calls without a configured result. */
+interface MockIdpOptions {
+  /** Return a type-compatible fixture or throw when no behavior is configured. */
+  onUnhandled?: "fallback" | "error";
+}
+type IdpNamespaceMocks = { [Method in IdpMethod]: Mock<IdpClientInstance[Method]>; };
 /**
  * Acquire a disposable mock for `tailor.idp`. Restored on dispose.
+ * @param options - Controls behavior for calls without a configured result
  * @returns Disposable IDP mock control object
  * @example
  * ```typescript
  * import { mockIdp } from "@tailor-platform/sdk/vitest";
  *
- * test("resolver-based", async () => {
+ * test("returns a user", async () => {
  *   using idp = mockIdp();
- *   idp.setResolver((method) =>
- *     method === "user" ? { id: "u-1", name: "alice", disabled: false } : null,
- *   );
+ *   idp.namespace("my-idp").user.mockResolvedValue({
+ *     id: "u-1",
+ *     name: "alice",
+ *     disabled: false,
+ *     mfaEnrolled: false,
+ *     mfaFactorIds: [],
+ *   });
  *   // …
  * });
  * ```
  */
-declare function mockIdp(): {
-  /** The mock IDP `Client` constructor (`vi.fn`). */Client: Mock;
+declare function mockIdp(options?: MockIdpOptions): {
+  /** The mock IDP `Client` constructor (`vi.fn`). */
+  Client: Mock<IdpClientConstructor>;
+  namespace: (name: string) => IdpNamespaceMocks;
   setResolver(value: IdpResolver): void;
   /**
-   * Enqueue a single result for the next IDP call (FIFO; falls back to
-   * `setResolver` when exhausted).
+   * Enqueue a single result for the next IDP call.
+   * The queue is shared across all methods and namespaces.
    * @param result - Result to return from the next IDP call
    */
   enqueueResult(result: unknown): void;
   /**
    * Enqueue results for multiple subsequent IDP calls.
+   * The queue is shared across all methods and namespaces.
    * @param results - Results to enqueue, one per upcoming call
    */
   enqueueResults(...results: unknown[]): void;
   readonly calls: IdpCall[];
+  clear(): void;
   reset(): void;
 } & Disposable;
 //#endregion
-export { mockIdp };
+export { MockIdpOptions, mockIdp };

package/dist/vitest/mocks/secretmanager.d.mts

@@ -5,29 +5,40 @@ interface SecretCall {
   name?: string;
   names?: readonly string[];
 }
+/** Initial fixtures for a Secret Manager mock. */
+interface MockSecretmanagerOptions {
+  /** Secrets to merge over fixtures inherited from the currently installed mock. */
+  secrets?: Record<string, Record<string, string>>;
+}
 /**
  * Acquire a disposable mock for `tailor.secretmanager`. The secret store is
  * inherited (cloned) from the currently-installed mock on acquisition and
  * restored on dispose, so secrets seeded outside the test survive across
  * `using` scopes while per-test `setSecrets()` overrides stay isolated.
+ * @param options - Initial Secret Manager fixtures
  * @returns Disposable SecretManager mock control object
  * @example
  * ```typescript
  * import { mockSecretmanager } from "@tailor-platform/sdk/vitest";
  *
  * test("reads secrets from vault", async () => {
- *   using sm = mockSecretmanager();
- *   sm.setSecrets({ "my-vault": { API_KEY: "sk-123" } });
+ *   using sm = mockSecretmanager({ secrets: { "my-vault": { API_KEY: "sk-123" } } });
+ *   sm.setSecret("my-vault", "API_KEY", "replacement");
  *   // …
  * });
  * ```
  */
-declare function mockSecretmanager(): {
-  /** The `getSecret` `vi.fn`. */getSecret: import("vitest").Mock<(vault: string, name: string) => Promise<string | undefined>>; /** The `getSecrets` `vi.fn`. */
+declare function mockSecretmanager(options?: MockSecretmanagerOptions): {
+  /** The `getSecret` `vi.fn`. */
+  getSecret: import("vitest").Mock<(vault: string, name: string) => Promise<string | undefined>>;
+  /** The `getSecrets` `vi.fn`. */
   getSecrets: import("vitest").Mock<(<const T extends readonly string[]>(vault: string, names: T) => Promise<Partial<Record<T[number], string>>>)>;
   setSecrets(secrets: Record<string, Record<string, string>>): void;
+  setSecret(vault: string, name: string, value: string): void;
+  mergeSecrets(vault: string, secrets: Record<string, string>): void;
   readonly calls: SecretCall[];
+  clear(): void;
   reset(): void;
 } & Disposable;
 //#endregion
-export { mockSecretmanager };
+export { MockSecretmanagerOptions, mockSecretmanager };

package/dist/vitest/mocks/tailordb.d.mts

@@ -1,5 +1,30 @@
 //#region src/vitest/mocks/tailordb.d.ts
-type QueryResolver = (query: string, params: unknown[]) => unknown[];
+type QueryResolver = (query: string, params: unknown[]) => unknown[] | undefined;
+/** Controls how unmatched TailorDB queries are handled. */
+interface MockTailordbOptions {
+  /** Return an empty result or throw when no configured query behavior matches. */
+  onUnhandled?: "fallback" | "error";
+}
+/** Matches a TailorDB query by SQL text and optionally by parameters. */
+interface QueryMatch {
+  /** Exact SQL text or regular expression to match. */
+  sql: string | RegExp;
+  /** Exact parameters or a predicate for parameter matching. */
+  params?: readonly unknown[] | ((params: unknown[]) => boolean);
+}
+/** Selects TailorDB queries that receive a configured response. */
+type QueryMatcher = string | RegExp | QueryMatch | ((query: string, params: unknown[]) => boolean);
+/** Configures persistent and one-time responses for matched queries. */
+interface QueryBehavior<Row> {
+  /** Return these rows for every matching query after one-time responses are consumed. */
+  returnsRows(rows: Row[]): QueryBehavior<Row>;
+  /** Return these rows for the next matching query. */
+  returnsRowsOnce(rows: Row[]): QueryBehavior<Row>;
+  /** Reject every matching query after one-time responses are consumed. */
+  rejects(error: unknown): QueryBehavior<Row>;
+  /** Reject the next matching query. */
+  rejectsOnce(error: unknown): QueryBehavior<Row>;
+}
 interface ExecutedQuery {
   query: string;
   params: unknown[];
@@ -19,30 +44,41 @@ declare class MockQueryResult {
  * `tailordb.Client` whose `queryObject` is a shared `vi.fn()` (so query
  * responses can be staged before the client is constructed). Restored on
  * dispose.
+ * @param options - Query fallback behavior
  * @returns Disposable TailorDB mock control object
  * @example
  * ```typescript
  * import { mockTailordb } from "@tailor-platform/sdk/vitest";
  *
- * test("order-based", async () => {
+ * test("query-based", async () => {
  *   using db = mockTailordb();
- *   db.enqueueResults([], [{ age: 30 }], []); // BEGIN / SELECT / COMMIT
+ *   db.onQuery({ sql: /FROM users/, params: ["u-1"] }).returnsRows([{ age: 30 }]);
  *   // …
- *   expect(db.queryObject).toHaveBeenCalledTimes(3);
+ *   expect(db.queryObject).toHaveBeenCalled();
  *   expect(db.Client).toHaveBeenCalledWith({ namespace: "tailordb" });
  * });
  * ```
  */
-declare function mockTailordb(): {
-  /** The mock `tailordb.Client` constructor (`vi.fn`). */Client: import("vitest").Mock<(this: any, config?: {
+declare function mockTailordb(options?: MockTailordbOptions): {
+  /** The mock `tailordb.Client` constructor (`vi.fn`). */
+  Client: import("vitest").Mock<(this: any, config?: {
     namespace?: string;
-  }) => void>; /** The shared `queryObject` `vi.fn` used by every client and transaction. */
-  queryObject: import("vitest").Mock<(_query: string, _params?: unknown[]) => Promise<MockQueryResult>>;
+  }) => void>;
+  /** The shared `queryObject` `vi.fn` used by every client and transaction. */
+  queryObject: import("vitest").Mock<(query: string, params?: unknown[]) => Promise<MockQueryResult>>;
   /**
    * Set a fallback query resolver. Called when the enqueue queue is empty.
    * @param resolver - Function that returns rows for a given query and params
    */
   setQueryResolver(resolver: QueryResolver): void;
+  /**
+   * Configure responses for queries matching SQL text, parameters, or a predicate.
+   * More recently registered matchers take precedence.
+   * Do not combine matchers with a direct `queryObject.mockImplementation()` override.
+   * @param matcher - Query matcher
+   * @returns Chainable query behavior
+   */
+  onQuery<Row = unknown>(matcher: QueryMatcher): QueryBehavior<Row>;
   /**
    * Enqueue rows for the next `queryObject` call (FIFO; takes priority over
    * `setQueryResolver`). Call with no arguments for an empty result.
@@ -54,6 +90,11 @@ declare function mockTailordb(): {
    * @param rowsList - Rows arrays, one per upcoming query
    */
   enqueueResults(...rowsList: unknown[][]): void;
+  /**
+   * Enqueue row arrays for subsequent queries whose exact order is under test.
+   * @param rowsList - Rows arrays, one per upcoming query
+   */
+  enqueueRows(...rowsList: unknown[][]): void;
   /**
    * All queries executed via `queryObject`, in order, derived from the vi.fn
    * call records.
@@ -64,8 +105,11 @@ declare function mockTailordb(): {
    * All TailorDB clients created, with their namespace and end state.
    * @returns Created clients array
    */
-  readonly createdClients: CreatedClient[]; /** Reset query responses and recorded calls (keeps the mock installed). */
+  readonly createdClients: CreatedClient[];
+  /** Clear recorded calls while preserving configured query behavior. */
+  clear(): void;
+  /** Reset query responses and recorded calls (keeps the mock installed). */
   reset(): void;
 } & Disposable;
 //#endregion
-export { mockTailordb };
+export { MockTailordbOptions, QueryBehavior, QueryMatch, QueryMatcher, mockTailordb };

package/dist/vitest/mocks/workflow.d.mts

@@ -1,15 +1,12 @@
 import { TailorEnv } from "../../runtime/types.mjs";
-import { TriggerJobFunctionOptions } from "../../runtime/workflow.mjs";
-
+import { StartJobFunctionOptions, StartWorkflowOptions } from "../../runtime/workflow.mjs";
+import { WorkflowJob } from "../../configure/services/workflow/job.mjs";
+import { Workflow } from "../../configure/services/workflow/workflow.mjs";
+import { WaitPointInstance } from "../../configure/services/workflow/wait-point.mjs";
+import { Mock } from "vitest";
 //#region src/vitest/mocks/workflow.d.ts
-type JobHandler = (jobName: string, args: unknown, options?: TriggerJobFunctionOptions) => unknown;
-type TriggerWorkflowOptions = {
-  authInvoker?: {
-    namespace: string;
-    machineUserName: string;
-  };
-};
-type TriggerHandlerFn = (workflowName: string, args: unknown, options?: TriggerWorkflowOptions) => string;
+type JobHandler = (jobName: string, args: unknown, options?: StartJobFunctionOptions) => unknown;
+type TriggerHandlerFn = (workflowName: string, args: unknown, options?: StartWorkflowOptions) => string;
 type ResumeHandlerFn = (executionId: string) => string;
 type WaitHandlerFn = (key: string, payload: unknown) => unknown;
 type ResolveHandler = (executionId: string, key: string, callback: (payload: unknown) => unknown) => unknown | Promise<unknown>;
@@ -20,30 +17,81 @@ type SetWaitHandler = {
 interface TriggeredJob {
   jobName: string;
   args: unknown;
-  options?: TriggerJobFunctionOptions;
+  options?: StartJobFunctionOptions;
 }
+type WaitPayload<Payload> = [Payload] extends [undefined] ? undefined : Payload;
 /**
  * Acquire a disposable mock for workflow operations (`tailor.workflow`).
  * Restored on dispose.
+ *
+ * Canonical names (`startWorkflow`, `startJobFunction`, `resumeWorkflowExecution`)
+ * and their frozen aliases (`triggerWorkflow`, `triggerJobFunction`, `resumeWorkflow`)
+ * share the same underlying `vi.fn`, so calls through either name are recorded
+ * once and handlers configured on either name apply to both.
  * @returns Disposable workflow mock control object
  * @example
  * ```typescript
  * import { mockWorkflow } from "@tailor-platform/sdk/vitest";
  *
- * test("job handler", async () => {
+ * test("job trigger", async () => {
  *   using wf = mockWorkflow();
- *   wf.setJobHandler((name) => (name === "validate" ? { valid: true } : null));
- *   await runWorkflowUnderTest(); // calls tailor.workflow.triggerJobFunction("validate", {})
- *   expect(wf.triggerJobFunction).toHaveBeenCalledWith("validate", {});
+ *   const job = wf.job(validateOrder);
+ *   job.mockResolvedValue({ valid: true });
+ *   await runWorkflowUnderTest();
+ *   expect(job).toHaveBeenCalled();
  * });
  * ```
  */
 declare function mockWorkflow(): {
-  /** The `triggerJobFunction` `vi.fn`. */triggerJobFunction: import("vitest").Mock<(jobName: string, _args?: unknown, _options?: TriggerJobFunctionOptions) => unknown>; /** The `triggerWorkflow` `vi.fn`. */
-  triggerWorkflow: import("vitest").Mock<(_workflowName: string, _args?: unknown, _options?: TriggerWorkflowOptions) => Promise<string>>; /** The `resumeWorkflow` `vi.fn`. */
-  resumeWorkflow: import("vitest").Mock<(executionId: string) => Promise<string>>; /** The `wait` `vi.fn`. */
-  wait: import("vitest").Mock<(_key: string, _payload?: unknown) => unknown>; /** The `resolve` `vi.fn`. */
-  resolve: import("vitest").Mock<(_executionId: string, _key: string, _callback: (payload: unknown) => unknown) => Promise<void>>;
+  /** The `startJobFunction` `vi.fn`. */
+  startJobFunction: Mock<(jobName: string, _args?: unknown, _options?: StartJobFunctionOptions) => unknown>;
+  /**
+   * Frozen alias of `startJobFunction` (same `vi.fn` reference).
+   * @deprecated Use `startJobFunction` instead.
+   */
+  triggerJobFunction: Mock<(jobName: string, _args?: unknown, _options?: StartJobFunctionOptions) => unknown>;
+  /** The `startWorkflow` `vi.fn`. */
+  startWorkflow: Mock<(_workflowName: string, _args?: unknown, _options?: StartWorkflowOptions) => Promise<string>>;
+  /**
+   * Frozen alias of `startWorkflow` (same `vi.fn` reference).
+   * @deprecated Use `startWorkflow` instead.
+   */
+  triggerWorkflow: Mock<(_workflowName: string, _args?: unknown, _options?: StartWorkflowOptions) => Promise<string>>;
+  /** The `resumeWorkflowExecution` `vi.fn`. */
+  resumeWorkflowExecution: Mock<(executionId: string) => Promise<string>>;
+  /**
+   * Frozen alias of `resumeWorkflowExecution` (same `vi.fn` reference).
+   * @deprecated Use `resumeWorkflowExecution` instead.
+   */
+  resumeWorkflow: Mock<(executionId: string) => Promise<string>>;
+  /** The `wait` `vi.fn`. */
+  wait: Mock<(_key: string, _payload?: unknown) => unknown>;
+  /** The `resolve` `vi.fn`. */
+  resolve: Mock<(_executionId: string, _key: string, _callback: (payload: unknown) => unknown) => Promise<void>>;
+  /**
+   * Get a stable, typed mock for a workflow job's `trigger` method.
+   * The real trigger behavior is used until an implementation or result is configured.
+   * @param definition - Workflow job definition to mock
+   * @returns Typed `trigger` mock for the definition
+   */
+  job<Name extends string, Input, Output>(definition: WorkflowJob<Name, Input, Output>): Mock<WorkflowJob<Name, Input, Output>["trigger"]>;
+  /**
+   * Get a stable, typed mock for a workflow definition's `trigger` method.
+   * The real trigger behavior is used until an implementation or result is configured.
+   * @param definition - Workflow definition to mock
+   * @returns Typed `trigger` mock for the definition
+   */
+  workflow<Definition extends Workflow>(definition: Definition): Mock<Definition["trigger"]>;
+  /**
+   * Get stable, typed mocks for a wait point's `wait` and `resolve` methods.
+   * @param definition - Wait point definition to mock
+   * @returns Typed wait point mock control object
+   */
+  waitPoint<Payload, Result>(definition: WaitPointInstance<Payload, Result>): {
+    wait: Mock<WaitPointInstance<Payload, Result>["wait"]>;
+    resolve: Mock<WaitPointInstance<Payload, Result>["resolve"]>;
+    setResolvePayload(payload: WaitPayload<Payload>): void;
+  };
   /**
    * Set a fallback job handler. Called when the enqueue queue is empty.
    * @param handler - Function returning a result for a job name, args, and options
@@ -110,7 +158,10 @@ declare function mockWorkflow(): {
   readonly resolveCalls: {
     executionId: string;
     key: string;
-  }[]; /** Reset all workflow responses and recorded calls (keeps the mock installed). */
+  }[];
+  /** Clear recorded calls while preserving configured responses. */
+  clear(): void;
+  /** Reset all workflow responses and recorded calls (keeps the mock installed). */
   reset(): void;
 } & Disposable;
 //#endregion

package/dist/vitest/setup.mjs

@@ -1,5 +1,5 @@
-import { t as RUNTIME_FLAG_KEY } from "../globals-BjhJJ2dN.mjs";
-import { t as mockSecretmanager } from "../secretmanager-Bd45j7an.mjs";
+import { t as RUNTIME_FLAG_KEY } from "../globals-D-YbJKW-.mjs";
+import { t as mockSecretmanager } from "../secretmanager-IY4UvinW.mjs";
 import { pathToFileURL } from "node:url";
 import { afterEach, beforeAll, beforeEach } from "vitest";
 

package/dist/vitest/workflow-local.d.mts

@@ -1,6 +1,7 @@
 import { TailorEnv } from "../runtime/types.mjs";
 import { WorkflowJob } from "../configure/services/workflow/job.mjs";
 import { Workflow } from "../configure/services/workflow/workflow.mjs";
+import "../configure/services/workflow/index.mjs";
 //#region src/vitest/workflow-local.d.ts
 type AnyWorkflowJob = WorkflowJob<string, any, any>;
 type AnyWorkflow = Workflow<AnyWorkflowJob>;

package/dist/workflow-9kHGKxF2.mjs

@@ -0,0 +1,64 @@
+//#region src/runtime/workflow.ts
+const api = () => globalThis.tailor.workflow;
+/**
+* See {@link TailorWorkflowAPI.startWorkflow}.
+* @param args - Forwarded to {@link TailorWorkflowAPI.startWorkflow}
+* @returns The execution ID of the started workflow
+*/
+const startWorkflow = (...args) => api().startWorkflow(...args);
+/**
+* Frozen alias for {@link startWorkflow}. Kept for backward compatibility.
+* Converts the SDK-facing `invoker` option to the platform's `authInvoker`.
+* @param workflowName - Workflow name as defined in tailor.config
+* @param args - Arguments forwarded to the workflow's main job
+* @param options - Optional SDK trigger options
+* @returns The execution ID of the triggered workflow
+* @deprecated Use {@link startWorkflow} instead.
+*/
+function triggerWorkflow(workflowName, args, options) {
+	if (options?.invoker === void 0) return api().triggerWorkflow(workflowName, args);
+	return api().triggerWorkflow(workflowName, args, { authInvoker: options.invoker });
+}
+/**
+* See {@link TailorWorkflowAPI.resumeWorkflowExecution}.
+* @param args - Forwarded to {@link TailorWorkflowAPI.resumeWorkflowExecution}
+* @returns The execution ID of the resumed workflow
+*/
+const resumeWorkflowExecution = (...args) => api().resumeWorkflowExecution(...args);
+/**
+* Frozen alias for {@link resumeWorkflowExecution}. Kept for backward compatibility.
+* @param args - Forwarded to {@link resumeWorkflowExecution}
+* @returns The execution ID of the resumed workflow
+* @deprecated Use {@link resumeWorkflowExecution} instead.
+*/
+const resumeWorkflow = (...args) => api().resumeWorkflow(...args);
+/**
+* See {@link TailorWorkflowAPI.startJobFunction}.
+* @param args - Forwarded to {@link TailorWorkflowAPI.startJobFunction}
+* @returns The job's return value
+*/
+const startJobFunction = (...args) => api().startJobFunction(...args);
+/**
+* Frozen alias for {@link startJobFunction}. Kept for backward compatibility.
+* @param args - Forwarded to {@link startJobFunction}
+* @returns The job's return value
+* @deprecated Use {@link startJobFunction} instead.
+*/
+const triggerJobFunction = (...args) => api().triggerJobFunction(...args);
+const wait = (...args) => api().wait(...args);
+const resolve = (...args) => api().resolve(...args);
+/** Runtime wrapper namespace for `tailor.workflow`. */
+const workflow = {
+	startWorkflow,
+	triggerWorkflow,
+	resumeWorkflowExecution,
+	resumeWorkflow,
+	startJobFunction,
+	triggerJobFunction,
+	wait,
+	resolve
+};
+
+//#endregion
+export { workflow as t };
+//# sourceMappingURL=workflow-9kHGKxF2.mjs.map