@tailor-platform/sdk 2.0.0-next.0 → 2.0.0-next.10

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

@@ -0,0 +1,51 @@
+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: 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
+ * import { mockIconv } from "@tailor-platform/sdk/vitest";
+ *
+ * test("mock encoding conversion", () => {
+ *   using iconv = mockIconv();
+ *   iconv.decode.mockReturnValue("decoded-text");
+ *   // …
+ * });
+ * ```
+ */
+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 { MockIconvOptions, mockIconv };

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

@@ -0,0 +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("returns a user", async () => {
+ *   using idp = mockIdp();
+ *   idp.namespace("my-idp").user.mockResolvedValue({
+ *     id: "u-1",
+ *     name: "alice",
+ *     disabled: false,
+ *     mfaEnrolled: false,
+ *     mfaFactorIds: [],
+ *   });
+ *   // …
+ * });
+ * ```
+ */
+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.
+   * 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 { MockIdpOptions, mockIdp };

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

@@ -0,0 +1,45 @@
+import { LogAttributes } from "../../runtime/logger.mjs";
+//#region src/vitest/mocks/logger.d.ts
+type LogSeverity = "debug" | "info" | "warn" | "error";
+/** A recorded `debug`/`info`/`warn`/`error` call. */
+interface LogCall {
+  severity: LogSeverity;
+  message: string;
+  attributes?: LogAttributes;
+}
+/** Initial fixtures for a logger mock. */
+interface MockLoggerOptions {}
+/**
+ * Acquire a disposable mock for `tailor.logger`. Each method is a `vi.fn`, so
+ * calls can be asserted directly; `calls` returns the `debug`/`info`/`warn`/
+ * `error` entries in the order they were emitted. Restored on dispose.
+ * @param _options - Reserved for future initial fixtures
+ * @returns Disposable logger mock control object
+ * @example
+ * ```typescript
+ * import { mockLogger } from "@tailor-platform/sdk/vitest";
+ *
+ * test("logs the processed order", () => {
+ *   using logger = mockLogger();
+ *   // …run code that calls tailor.logger.info…
+ *   expect(logger.info).toHaveBeenCalledWith("order processed", { orderId: "o-1" });
+ * });
+ * ```
+ */
+declare function mockLogger(_options?: MockLoggerOptions): {
+  /** The `debug` `vi.fn`. */
+  debug: import("vitest").Mock<(_message: string, _attributes?: LogAttributes) => void>;
+  /** The `info` `vi.fn`. */
+  info: import("vitest").Mock<(_message: string, _attributes?: LogAttributes) => void>;
+  /** The `warn` `vi.fn`. */
+  warn: import("vitest").Mock<(_message: string, _attributes?: LogAttributes) => void>;
+  /** The `error` `vi.fn`. */
+  error: import("vitest").Mock<(_message: string, _attributes?: LogAttributes) => void>;
+  /** The `setAttributes` `vi.fn`. */
+  setAttributes: import("vitest").Mock<(_attributes: LogAttributes) => void>;
+  readonly calls: LogCall[];
+  clear(): void;
+  reset(): void;
+} & Disposable;
+//#endregion
+export { MockLoggerOptions, mockLogger };

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

@@ -0,0 +1,44 @@
+//#region src/vitest/mocks/secretmanager.d.ts
+interface SecretCall {
+  method: "getSecret" | "getSecrets";
+  vault: string;
+  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({ secrets: { "my-vault": { API_KEY: "sk-123" } } });
+ *   sm.setSecret("my-vault", "API_KEY", "replacement");
+ *   // …
+ * });
+ * ```
+ */
+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 { MockSecretmanagerOptions, mockSecretmanager };

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

@@ -0,0 +1,115 @@
+//#region src/vitest/mocks/tailordb.d.ts
+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[];
+}
+interface CreatedClient {
+  namespace: string | undefined;
+  ended: boolean;
+}
+declare class MockQueryResult {
+  command: string;
+  rowCount: number;
+  rows: unknown[];
+  constructor(rows: unknown[]);
+}
+/**
+ * Acquire a disposable mock for TailorDB operations. Installs a mock
+ * `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("query-based", async () => {
+ *   using db = mockTailordb();
+ *   db.onQuery({ sql: /FROM users/, params: ["u-1"] }).returnsRows([{ age: 30 }]);
+ *   // …
+ *   expect(db.queryObject).toHaveBeenCalled();
+ *   expect(db.Client).toHaveBeenCalledWith({ namespace: "tailordb" });
+ * });
+ * ```
+ */
+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>>;
+  /**
+   * 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.
+   * @param rows - Row objects to return from the next `queryObject` call
+   */
+  enqueueResult(...rows: unknown[]): void;
+  /**
+   * Enqueue rows for multiple subsequent `queryObject` calls (FIFO).
+   * @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.
+   * @returns Executed queries array
+   */
+  readonly executedQueries: ExecutedQuery[];
+  /**
+   * All TailorDB clients created, with their namespace and end state.
+   * @returns Created clients array
+   */
+  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 { MockTailordbOptions, QueryBehavior, QueryMatch, QueryMatcher, mockTailordb };

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

@@ -0,0 +1,157 @@
+import { TailorEnv } from "../../runtime/types.mjs";
+import { ExecJobFunctionOptions, 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?: ExecJobFunctionOptions) => unknown;
+type StartHandlerFn = (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>;
+type SetWaitHandler = {
+  (handler: WaitHandlerFn): void;
+  (handler: unknown): void;
+};
+interface StartedJob {
+  jobName: string;
+  args: unknown;
+  options?: ExecJobFunctionOptions;
+}
+type WaitPayload<Payload> = [Payload] extends [undefined] ? undefined : Payload;
+/**
+ * Acquire a disposable mock for workflow operations (`tailor.workflow`).
+ * Restored on dispose.
+ *
+ * The canonical `execJobFunction` and its `startJobFunction` alias 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 start", async () => {
+ *   using wf = mockWorkflow();
+ *   const job = wf.job(validateOrder);
+ *   job.mockResolvedValue({ valid: true });
+ *   await runWorkflowUnderTest();
+ *   expect(job).toHaveBeenCalled();
+ * });
+ * ```
+ */
+declare function mockWorkflow(): {
+  /** The `execJobFunction` `vi.fn`. */
+  execJobFunction: Mock<(jobName: string, _args?: unknown, _options?: ExecJobFunctionOptions) => unknown>;
+  /**
+   * Alias of `execJobFunction` (same `vi.fn` reference).
+   * @deprecated Use `execJobFunction` instead.
+   */
+  startJobFunction: Mock<(jobName: string, _args?: unknown, _options?: ExecJobFunctionOptions) => unknown>;
+  /** The `startWorkflow` `vi.fn`. */
+  startWorkflow: Mock<(_workflowName: string, _args?: unknown, _options?: StartWorkflowOptions) => Promise<string>>;
+  /** The `resumeWorkflowExecution` `vi.fn`. */
+  resumeWorkflowExecution: 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 `start` method.
+   * The real start behavior is used until an implementation or result is configured.
+   * @param definition - Workflow job definition to mock
+   * @returns Typed `start` mock for the definition
+   */
+  job<Name extends string, Input, Output>(definition: WorkflowJob<Name, Input, Output>): Mock<WorkflowJob<Name, Input, Output>["start"]>;
+  /**
+   * Get a stable, typed mock for a workflow definition's `start` method.
+   * The real start behavior is used until an implementation or result is configured.
+   * @param definition - Workflow definition to mock
+   * @returns Typed `start` mock for the definition
+   */
+  workflow<Definition extends Workflow>(definition: Definition): Mock<Definition["start"]>;
+  /**
+   * 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
+   */
+  setJobHandler(handler: JobHandler): void;
+  /**
+   * Enqueue a single result for the next `execJobFunction` call (FIFO;
+   * takes priority over `setJobHandler`).
+   * @param result - Result to return from the next call
+   */
+  enqueueResult(result: unknown): void;
+  /**
+   * Enqueue results for multiple subsequent `execJobFunction` calls (FIFO).
+   * @param results - Results to enqueue, one per upcoming call
+   */
+  enqueueResults(...results: unknown[]): void;
+  /**
+   * All jobs executed via `execJobFunction`, in order.
+   * @returns Started jobs array
+   */
+  readonly startedJobs: StartedJob[];
+  /**
+   * Configure what `startWorkflow` returns. Pass a string (same id every
+   * call) or `(name, args, options) => string`. Default: a placeholder UUID.
+   * @param handler - Static execution ID or a function returning one
+   */
+  setStartHandler(handler: string | StartHandlerFn): void;
+  /**
+   * Configure what `resumeWorkflowExecution` returns. Pass a string (same id
+   * every call) or `(executionId) => string`. Default: echoes the input executionId.
+   * @param handler - Static execution ID or a function returning one
+   */
+  setResumeHandler(handler: string | ResumeHandlerFn): void;
+  /**
+   * Configure what `wait` returns. Pass `(key, payload) => unknown` or any
+   * other value to return it for every call. Default: `null`.
+   * @param handler - Static value or a function returning one
+   */
+  setWaitHandler: SetWaitHandler;
+  /**
+   * Set the `env` passed to job bodies invoked via `createWorkflowJob().start()`.
+   * Cleared on dispose / reset.
+   * @param env - Env passed to job bodies.
+   */
+  setEnv(env: TailorEnv): void;
+  /**
+   * Configure how `resolve` runs the user-supplied callback. Default: callback
+   * is not invoked (records the call only).
+   * @param handler - Function invoked per `resolve` call
+   */
+  setResolveHandler(handler: ResolveHandler): void;
+  /**
+   * `wait` calls reshaped as `{ key, payload }` for assertions.
+   * @returns Wait call records
+   */
+  readonly waitCalls: {
+    key: string;
+    payload: unknown;
+  }[];
+  /**
+   * `resolve` calls reshaped as `{ executionId, key }` for assertions.
+   * @returns Resolve call records
+   */
+  readonly resolveCalls: {
+    executionId: string;
+    key: string;
+  }[];
+  /** Clear recorded calls while preserving configured responses. */
+  clear(): void;
+  /** Reset all workflow responses and recorded calls (keeps the mock installed). */
+  reset(): void;
+} & Disposable;
+//#endregion
+export { mockWorkflow };

package/dist/vitest/setup.d.mts

@@ -59,5 +59,4 @@ declare function removeBlockedGlobals(globalObj: Record<string, unknown>, keys:
  */
 declare function restoreBlockedGlobals(globalObj: Record<string, unknown>, saved: SavedGlobals): void;
 //#endregion
-export { createBlockedGlobalsLifecycle, extractVaultStore, loadSecretsFromConfig, removeBlockedGlobals, restoreBlockedGlobals };
-//# sourceMappingURL=setup.d.mts.map
+export { createBlockedGlobalsLifecycle, extractVaultStore, loadSecretsFromConfig, removeBlockedGlobals, restoreBlockedGlobals };

package/dist/vitest/setup.mjs

@@ -1,6 +1,5 @@
-
-import { t as RUNTIME_FLAG_KEY } from "../globals-ByrCoDip.mjs";
-import { a as mockSecretmanager } from "../mock-DMgIygjE.mjs";
+import { t as RUNTIME_FLAG_KEY } from "../globals-DQotNuwK.mjs";
+import { t as mockSecretmanager } from "../secretmanager-IY4UvinW.mjs";
 import { pathToFileURL } from "node:url";
 import { afterEach, beforeAll, beforeEach } from "vitest";
 

package/dist/vitest/setup.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"setup.mjs","names":[],"sources":["../../src/vitest/setup.ts"],"sourcesContent":["/**\n * Vitest setup file that removes Node.js globals which Vitest depends on\n * but are not available in the Tailor Platform runtime.\n *\n * These globals cannot be removed in the environment's setup() because\n * Vitest's runner needs them during initialization. By using beforeEach/afterEach,\n * they are only removed during user test code execution.\n *\n * This file is auto-injected by tailorRuntime() but only activates when\n * the tailor-runtime environment is active (detected via __tailorRuntimeActive,\n * a flag set by injectMocks() during environment setup).\n */\nimport { pathToFileURL } from \"node:url\";\nimport { afterEach, beforeAll, beforeEach } from \"vitest\";\nimport { RUNTIME_FLAG_KEY, mockSecretmanager } from \"./mock\";\n\n// Globals that Vitest internals depend on but don't exist in the platform runtime.\n// Removed before each test, restored after.\nconst BLOCKED_GLOBALS = [\"performance\"] as const;\n\ntype SavedGlobals = Record<string, PropertyDescriptor | undefined>;\n\n/**\n * Reference-counted lifecycle for blocked globals.\n *\n * Concurrent tests in the same Vitest worker (`test.concurrent`) interleave\n * their beforeEach/afterEach hooks: a naive `let saved` shared across hooks\n * would let one test's `afterEach` restore `performance` mid-execution of\n * another test. Reference counting keeps the globals removed for the union\n * of all overlapping test scopes — the property is removed on first entry\n * and restored only when the last test exits.\n * @returns Lifecycle hooks\n */\nexport function createBlockedGlobalsLifecycle(): {\n  enter: (globalObj: Record<string, unknown>, keys: readonly string[]) => void;\n  exit: (globalObj: Record<string, unknown>) => void;\n  readonly active: number;\n} {\n  let active = 0;\n  let saved: SavedGlobals = {};\n  return {\n    get active() {\n      return active;\n    },\n    enter(globalObj, keys) {\n      if (active === 0) saved = removeBlockedGlobals(globalObj, keys);\n      active++;\n    },\n    exit(globalObj) {\n      // Defensive guard — in practice every `enter` is paired with `exit`,\n      // but a hook crash could desync the counter.\n      if (active === 0) return;\n      active--;\n      if (active === 0) {\n        restoreBlockedGlobals(globalObj, saved);\n        saved = {};\n      }\n    },\n  };\n}\n\nconst lifecycle = createBlockedGlobalsLifecycle();\n\nfunction isTailorRuntime(): boolean {\n  return RUNTIME_FLAG_KEY in globalThis;\n}\n\n/**\n * Extract a vault store from a secrets-shaped value.\n *\n * `defineSecretManager()` returns `{ vaults, options, get, getAll }` (get/getAll\n * are non-enumerable). When that shape is present, the actual vaults live\n * under `.vaults`. Otherwise fall back to treating the object itself as the\n * vault map (for plain object configs).\n * @param secrets - Value from `appConfig.secrets` or `config.secrets`\n * @returns Vault store, or null if the value is unusable\n */\nexport function extractVaultStore(secrets: unknown): Record<string, Record<string, string>> | null {\n  if (!secrets || typeof secrets !== \"object\") return null;\n\n  const source =\n    \"vaults\" in secrets &&\n    typeof (secrets as { vaults?: unknown }).vaults === \"object\" &&\n    (secrets as { vaults?: unknown }).vaults !== null\n      ? ((secrets as { vaults: Record<string, unknown> }).vaults as Record<string, unknown>)\n      : (secrets as Record<string, unknown>);\n\n  const store: Record<string, Record<string, string>> = {};\n  for (const [vaultName, vaultData] of Object.entries(source)) {\n    if (typeof vaultData === \"object\" && vaultData !== null) {\n      store[vaultName] = { ...(vaultData as Record<string, string>) };\n    }\n  }\n  return Object.keys(store).length > 0 ? store : null;\n}\n\n/**\n * Load and parse secrets from a tailor.config.ts file.\n *\n * Returns a vault store on success, or `null` on any failure (missing config,\n * import failure, missing/invalid secrets shape). Errors are swallowed so a\n * misconfigured project still boots — the user can set secrets manually via\n * `mockSecretmanager().setSecrets()`.\n * @param configPath - Absolute path to tailor.config.ts\n * @returns Vault store keyed by vault name, or null if unavailable\n */\nexport async function loadSecretsFromConfig(\n  configPath: string,\n): Promise<Record<string, Record<string, string>> | null> {\n  try {\n    // Convert to file URL so absolute Windows paths (e.g. \"C:\\...\") parse as\n    // valid ESM specifiers.\n    const config = await import(pathToFileURL(configPath).href);\n    const appConfig = config.default;\n    const secrets = appConfig?.secrets ?? config.secrets;\n    return extractVaultStore(secrets);\n  } catch {\n    return null;\n  }\n}\n\n// Load secrets from tailor.config.ts if config path is provided via env var\nbeforeAll(async () => {\n  if (!isTailorRuntime()) return;\n  const configPath = process.env.__TAILOR_RUNTIME_CONFIG;\n  if (!configPath) return;\n\n  const store = await loadSecretsFromConfig(configPath);\n  if (store) {\n    // Acquire without `using`: this is a one-time global seed that must persist\n    // across tests, so we deliberately do not dispose (which would reset it).\n    mockSecretmanager().setSecrets(store);\n  }\n});\n\n/**\n * Remove the given globals from `globalObj`, returning the descriptors that\n * were actually deleted so `restoreBlockedGlobals` can put them back.\n *\n * Mirrors environment.ts: non-configurable properties are skipped instead of\n * deleted, so `delete` never throws in strict-mode runtimes that lock them\n * down. Only properties whose deletion actually happened are returned, so the\n * caller restores nothing for the skipped case.\n * @param globalObj - Target object (typically `globalThis`)\n * @param keys - Property names to remove\n * @returns Map of removed descriptors keyed by property name\n */\nexport function removeBlockedGlobals(\n  globalObj: Record<string, unknown>,\n  keys: readonly string[],\n): SavedGlobals {\n  const removed: SavedGlobals = {};\n  for (const key of keys) {\n    const descriptor = Object.getOwnPropertyDescriptor(globalObj, key);\n    if (descriptor?.configurable) {\n      removed[key] = descriptor;\n      delete globalObj[key];\n    }\n  }\n  return removed;\n}\n\n/**\n * Restore previously-removed globals onto `globalObj` from a `SavedGlobals`\n * map produced by `removeBlockedGlobals`.\n * @param globalObj - Target object (typically `globalThis`)\n * @param saved - Descriptors to re-define\n */\nexport function restoreBlockedGlobals(\n  globalObj: Record<string, unknown>,\n  saved: SavedGlobals,\n): void {\n  for (const [key, descriptor] of Object.entries(saved)) {\n    if (descriptor) {\n      Object.defineProperty(globalObj, key, descriptor);\n    }\n  }\n}\n\nbeforeEach(() => {\n  if (!isTailorRuntime()) return;\n  lifecycle.enter(globalThis as Record<string, unknown>, BLOCKED_GLOBALS);\n});\n\nafterEach(() => {\n  if (!isTailorRuntime()) return;\n  lifecycle.exit(globalThis as Record<string, unknown>);\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,MAAM,kBAAkB,CAAC,aAAa;;;;;;;;;;;;AAetC,SAAgB,gCAId;CACA,IAAI,SAAS;CACb,IAAI,QAAsB,CAAC;CAC3B,OAAO;EACL,IAAI,SAAS;GACX,OAAO;EACT;EACA,MAAM,WAAW,MAAM;GACrB,IAAI,WAAW,GAAG,QAAQ,qBAAqB,WAAW,IAAI;GAC9D;EACF;EACA,KAAK,WAAW;GAGd,IAAI,WAAW,GAAG;GAClB;GACA,IAAI,WAAW,GAAG;IAChB,sBAAsB,WAAW,KAAK;IACtC,QAAQ,CAAC;GACX;EACF;CACF;AACF;AAEA,MAAM,YAAY,8BAA8B;AAEhD,SAAS,kBAA2B;CAClC,OAAO,oBAAoB;AAC7B;;;;;;;;;;;AAYA,SAAgB,kBAAkB,SAAiE;CACjG,IAAI,CAAC,WAAW,OAAO,YAAY,UAAU,OAAO;CAEpD,MAAM,SACJ,YAAY,WACZ,OAAQ,QAAiC,WAAW,YACnD,QAAiC,WAAW,OACvC,QAAgD,SACjD;CAEP,MAAM,QAAgD,CAAC;CACvD,KAAK,MAAM,CAAC,WAAW,cAAc,OAAO,QAAQ,MAAM,GACxD,IAAI,OAAO,cAAc,YAAY,cAAc,MACjD,MAAM,aAAa,EAAE,GAAI,UAAqC;CAGlE,OAAO,OAAO,KAAK,KAAK,CAAC,CAAC,SAAS,IAAI,QAAQ;AACjD;;;;;;;;;;;AAYA,eAAsB,sBACpB,YACwD;CACxD,IAAI;EAGF,MAAM,SAAS,MAAM,OAAO,cAAc,UAAU,CAAC,CAAC;EAGtD,OAAO,kBAFW,OAAO,SACE,WAAW,OAAO,OACb;CAClC,QAAQ;EACN,OAAO;CACT;AACF;AAGA,UAAU,YAAY;CACpB,IAAI,CAAC,gBAAgB,GAAG;CACxB,MAAM,aAAa,QAAQ,IAAI;CAC/B,IAAI,CAAC,YAAY;CAEjB,MAAM,QAAQ,MAAM,sBAAsB,UAAU;CACpD,IAAI,OAGF,kBAAkB,CAAC,CAAC,WAAW,KAAK;AAExC,CAAC;;;;;;;;;;;;;AAcD,SAAgB,qBACd,WACA,MACc;CACd,MAAM,UAAwB,CAAC;CAC/B,KAAK,MAAM,OAAO,MAAM;EACtB,MAAM,aAAa,OAAO,yBAAyB,WAAW,GAAG;EACjE,IAAI,YAAY,cAAc;GAC5B,QAAQ,OAAO;GACf,OAAO,UAAU;EACnB;CACF;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,sBACd,WACA,OACM;CACN,KAAK,MAAM,CAAC,KAAK,eAAe,OAAO,QAAQ,KAAK,GAClD,IAAI,YACF,OAAO,eAAe,WAAW,KAAK,UAAU;AAGtD;AAEA,iBAAiB;CACf,IAAI,CAAC,gBAAgB,GAAG;CACxB,UAAU,MAAM,YAAuC,eAAe;AACxE,CAAC;AAED,gBAAgB;CACd,IAAI,CAAC,gBAAgB,GAAG;CACxB,UAAU,KAAK,UAAqC;AACtD,CAAC"}
+{"version":3,"file":"setup.mjs","names":[],"sources":["../../src/vitest/setup.ts"],"sourcesContent":["/**\n * Vitest setup file that removes Node.js globals which Vitest depends on\n * but are not available in the Tailor Platform runtime.\n *\n * These globals cannot be removed in the environment's setup() because\n * Vitest's runner needs them during initialization. By using beforeEach/afterEach,\n * they are only removed during user test code execution.\n *\n * This file is auto-injected by tailorRuntime() but only activates when\n * the tailor-runtime environment is active (detected via __tailorRuntimeActive,\n * a flag set by injectMocks() during environment setup).\n */\nimport { pathToFileURL } from \"node:url\";\nimport { afterEach, beforeAll, beforeEach } from \"vitest\";\nimport { RUNTIME_FLAG_KEY, mockSecretmanager } from \"./mock\";\n\n// Globals that Vitest internals depend on but don't exist in the platform runtime.\n// Removed before each test, restored after.\nconst BLOCKED_GLOBALS = [\"performance\"] as const;\n\ntype SavedGlobals = Record<string, PropertyDescriptor | undefined>;\n\n/**\n * Reference-counted lifecycle for blocked globals.\n *\n * Concurrent tests in the same Vitest worker (`test.concurrent`) interleave\n * their beforeEach/afterEach hooks: a naive `let saved` shared across hooks\n * would let one test's `afterEach` restore `performance` mid-execution of\n * another test. Reference counting keeps the globals removed for the union\n * of all overlapping test scopes — the property is removed on first entry\n * and restored only when the last test exits.\n * @returns Lifecycle hooks\n */\nexport function createBlockedGlobalsLifecycle(): {\n  enter: (globalObj: Record<string, unknown>, keys: readonly string[]) => void;\n  exit: (globalObj: Record<string, unknown>) => void;\n  readonly active: number;\n} {\n  let active = 0;\n  let saved: SavedGlobals = {};\n  return {\n    get active() {\n      return active;\n    },\n    enter(globalObj, keys) {\n      if (active === 0) saved = removeBlockedGlobals(globalObj, keys);\n      active++;\n    },\n    exit(globalObj) {\n      // Defensive guard — in practice every `enter` is paired with `exit`,\n      // but a hook crash could desync the counter.\n      if (active === 0) return;\n      active--;\n      if (active === 0) {\n        restoreBlockedGlobals(globalObj, saved);\n        saved = {};\n      }\n    },\n  };\n}\n\nconst lifecycle = createBlockedGlobalsLifecycle();\n\nfunction isTailorRuntime(): boolean {\n  return RUNTIME_FLAG_KEY in globalThis;\n}\n\n/**\n * Extract a vault store from a secrets-shaped value.\n *\n * `defineSecretManager()` returns `{ vaults, options, get, getAll }` (get/getAll\n * are non-enumerable). When that shape is present, the actual vaults live\n * under `.vaults`. Otherwise fall back to treating the object itself as the\n * vault map (for plain object configs).\n * @param secrets - Value from `appConfig.secrets` or `config.secrets`\n * @returns Vault store, or null if the value is unusable\n */\nexport function extractVaultStore(secrets: unknown): Record<string, Record<string, string>> | null {\n  if (!secrets || typeof secrets !== \"object\") return null;\n\n  const source =\n    \"vaults\" in secrets &&\n    typeof (secrets as { vaults?: unknown }).vaults === \"object\" &&\n    (secrets as { vaults?: unknown }).vaults !== null\n      ? ((secrets as { vaults: Record<string, unknown> }).vaults as Record<string, unknown>)\n      : (secrets as Record<string, unknown>);\n\n  const store: Record<string, Record<string, string>> = {};\n  for (const [vaultName, vaultData] of Object.entries(source)) {\n    if (typeof vaultData === \"object\" && vaultData !== null) {\n      store[vaultName] = { ...(vaultData as Record<string, string>) };\n    }\n  }\n  return Object.keys(store).length > 0 ? store : null;\n}\n\n/**\n * Load and parse secrets from a tailor.config.ts file.\n *\n * Returns a vault store on success, or `null` on any failure (missing config,\n * import failure, missing/invalid secrets shape). Errors are swallowed so a\n * misconfigured project still boots — the user can set secrets manually via\n * `mockSecretmanager().setSecrets()`.\n * @param configPath - Absolute path to tailor.config.ts\n * @returns Vault store keyed by vault name, or null if unavailable\n */\nexport async function loadSecretsFromConfig(\n  configPath: string,\n): Promise<Record<string, Record<string, string>> | null> {\n  try {\n    // Convert to file URL so absolute Windows paths (e.g. \"C:\\...\") parse as\n    // valid ESM specifiers.\n    const config = await import(pathToFileURL(configPath).href);\n    const appConfig = config.default;\n    const secrets = appConfig?.secrets ?? config.secrets;\n    return extractVaultStore(secrets);\n  } catch {\n    return null;\n  }\n}\n\n// Load secrets from tailor.config.ts if config path is provided via env var\nbeforeAll(async () => {\n  if (!isTailorRuntime()) return;\n  const configPath = process.env.__TAILOR_RUNTIME_CONFIG;\n  if (!configPath) return;\n\n  const store = await loadSecretsFromConfig(configPath);\n  if (store) {\n    // Acquire without `using`: this is a one-time global seed that must persist\n    // across tests, so we deliberately do not dispose (which would reset it).\n    mockSecretmanager().setSecrets(store);\n  }\n});\n\n/**\n * Remove the given globals from `globalObj`, returning the descriptors that\n * were actually deleted so `restoreBlockedGlobals` can put them back.\n *\n * Mirrors environment.ts: non-configurable properties are skipped instead of\n * deleted, so `delete` never throws in strict-mode runtimes that lock them\n * down. Only properties whose deletion actually happened are returned, so the\n * caller restores nothing for the skipped case.\n * @param globalObj - Target object (typically `globalThis`)\n * @param keys - Property names to remove\n * @returns Map of removed descriptors keyed by property name\n */\nexport function removeBlockedGlobals(\n  globalObj: Record<string, unknown>,\n  keys: readonly string[],\n): SavedGlobals {\n  const removed: SavedGlobals = {};\n  for (const key of keys) {\n    const descriptor = Object.getOwnPropertyDescriptor(globalObj, key);\n    if (descriptor?.configurable) {\n      removed[key] = descriptor;\n      delete globalObj[key];\n    }\n  }\n  return removed;\n}\n\n/**\n * Restore previously-removed globals onto `globalObj` from a `SavedGlobals`\n * map produced by `removeBlockedGlobals`.\n * @param globalObj - Target object (typically `globalThis`)\n * @param saved - Descriptors to re-define\n */\nexport function restoreBlockedGlobals(\n  globalObj: Record<string, unknown>,\n  saved: SavedGlobals,\n): void {\n  for (const [key, descriptor] of Object.entries(saved)) {\n    if (descriptor) {\n      Object.defineProperty(globalObj, key, descriptor);\n    }\n  }\n}\n\nbeforeEach(() => {\n  if (!isTailorRuntime()) return;\n  lifecycle.enter(globalThis as Record<string, unknown>, BLOCKED_GLOBALS);\n});\n\nafterEach(() => {\n  if (!isTailorRuntime()) return;\n  lifecycle.exit(globalThis as Record<string, unknown>);\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,MAAM,kBAAkB,CAAC,aAAa;;;;;;;;;;;;AAetC,SAAgB,gCAId;CACA,IAAI,SAAS;CACb,IAAI,QAAsB,CAAC;CAC3B,OAAO;EACL,IAAI,SAAS;GACX,OAAO;EACT;EACA,MAAM,WAAW,MAAM;GACrB,IAAI,WAAW,GAAG,QAAQ,qBAAqB,WAAW,IAAI;GAC9D;EACF;EACA,KAAK,WAAW;GAGd,IAAI,WAAW,GAAG;GAClB;GACA,IAAI,WAAW,GAAG;IAChB,sBAAsB,WAAW,KAAK;IACtC,QAAQ,CAAC;GACX;EACF;CACF;AACF;AAEA,MAAM,YAAY,8BAA8B;AAEhD,SAAS,kBAA2B;CAClC,OAAO,oBAAoB;AAC7B;;;;;;;;;;;AAYA,SAAgB,kBAAkB,SAAiE;CACjG,IAAI,CAAC,WAAW,OAAO,YAAY,UAAU,OAAO;CAEpD,MAAM,SACJ,YAAY,WACZ,OAAQ,QAAiC,WAAW,YACnD,QAAiC,WAAW,OACvC,QAAgD,SACjD;CAEP,MAAM,QAAgD,CAAC;CACvD,KAAK,MAAM,CAAC,WAAW,cAAc,OAAO,QAAQ,MAAM,GACxD,IAAI,OAAO,cAAc,YAAY,cAAc,MACjD,MAAM,aAAa,EAAE,GAAI,UAAqC;CAGlE,OAAO,OAAO,KAAK,KAAK,CAAC,CAAC,SAAS,IAAI,QAAQ;AACjD;;;;;;;;;;;AAYA,eAAsB,sBACpB,YACwD;CACxD,IAAI;EAGF,MAAM,SAAS,MAAM,OAAO,cAAc,UAAU,CAAC,CAAC;EAGtD,OAAO,kBAFW,OAAO,SACE,WAAW,OAAO,OACb;CAClC,QAAQ;EACN,OAAO;CACT;AACF;AAGA,UAAU,YAAY;CACpB,IAAI,CAAC,gBAAgB,GAAG;CACxB,MAAM,aAAa,QAAQ,IAAI;CAC/B,IAAI,CAAC,YAAY;CAEjB,MAAM,QAAQ,MAAM,sBAAsB,UAAU;CACpD,IAAI,OAGF,kBAAkB,CAAC,CAAC,WAAW,KAAK;AAExC,CAAC;;;;;;;;;;;;;AAcD,SAAgB,qBACd,WACA,MACc;CACd,MAAM,UAAwB,CAAC;CAC/B,KAAK,MAAM,OAAO,MAAM;EACtB,MAAM,aAAa,OAAO,yBAAyB,WAAW,GAAG;EACjE,IAAI,YAAY,cAAc;GAC5B,QAAQ,OAAO;GACf,OAAO,UAAU;EACnB;CACF;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,sBACd,WACA,OACM;CACN,KAAK,MAAM,CAAC,KAAK,eAAe,OAAO,QAAQ,KAAK,GAClD,IAAI,YACF,OAAO,eAAe,WAAW,KAAK,UAAU;AAGtD;AAEA,iBAAiB;CACf,IAAI,CAAC,gBAAgB,GAAG;CACxB,UAAU,MAAM,YAAuC,eAAe;AACxE,CAAC;AAED,gBAAgB;CACd,IAAI,CAAC,gBAAgB,GAAG;CACxB,UAAU,KAAK,UAAqC;AACtD,CAAC"}

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

@@ -0,0 +1,41 @@
+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>;
+type WorkflowInput<W extends AnyWorkflow> = W["mainJob"] extends WorkflowJob<string, infer I, any> ? I : never;
+type WorkflowOutput<W extends AnyWorkflow> = W["mainJob"] extends WorkflowJob<string, any, infer O> ? Awaited<O> : never;
+interface RunWorkflowLocallyOptions {
+  /** Env passed to workflow job bodies during this local run. */
+  env?: TailorEnv;
+}
+/**
+ * Run a workflow's main job and dependent job starts locally with real job bodies.
+ *
+ * Use this for local full-chain workflow tests. Regular `.start()` calls
+ * delegate to the platform workflow runtime and should be mocked with
+ * `mockWorkflow()` when you are not intentionally running the local chain.
+ * @param workflow - Workflow definition to run
+ * @returns The main job output
+ */
+declare function runWorkflowLocally<W extends Workflow<WorkflowJob<string, undefined, any>>>(workflow: W): Promise<WorkflowOutput<W>>;
+/**
+ * Run a no-input workflow locally with optional runner settings.
+ * @param workflow - Workflow definition to run
+ * @param args - Must be `undefined` for no-input workflows
+ * @param options - Local runner options
+ * @returns The main job output
+ */
+declare function runWorkflowLocally<W extends Workflow<WorkflowJob<string, undefined, any>>>(workflow: W, args: undefined, options?: RunWorkflowLocallyOptions): Promise<WorkflowOutput<W>>;
+/**
+ * Run a workflow locally with real job bodies.
+ * @param workflow - Workflow definition to run
+ * @param args - Arguments passed to the workflow's main job
+ * @param options - Local runner options
+ * @returns The main job output
+ */
+declare function runWorkflowLocally<W extends AnyWorkflow>(workflow: W, args: WorkflowInput<W>, options?: RunWorkflowLocallyOptions): Promise<WorkflowOutput<W>>;
+//#endregion
+export { RunWorkflowLocallyOptions, runWorkflowLocally };

package/dist/workflow-CsaQ9qK-.mjs

@@ -0,0 +1,42 @@
+//#region src/runtime/workflow.ts
+const api = () => globalThis.tailor.workflow;
+/**
+* See {@link PlatformWorkflowAPI.startWorkflow}.
+* @param args - Forwarded to {@link PlatformWorkflowAPI.startWorkflow}
+* @returns The execution ID of the started workflow
+*/
+const startWorkflow = (...args) => api().startWorkflow(...args);
+/**
+* See {@link PlatformWorkflowAPI.resumeWorkflowExecution}.
+* @param args - Forwarded to {@link PlatformWorkflowAPI.resumeWorkflowExecution}
+* @returns The execution ID of the resumed workflow
+*/
+const resumeWorkflowExecution = (...args) => api().resumeWorkflowExecution(...args);
+/**
+* See {@link PlatformWorkflowAPI.execJobFunction}.
+* @param args - Forwarded to {@link PlatformWorkflowAPI.execJobFunction}
+* @returns The job's return value
+*/
+const execJobFunction = (...args) => api().execJobFunction(...args);
+/**
+* Alias for {@link execJobFunction}. Kept for backward compatibility.
+* @deprecated Use {@link execJobFunction} instead.
+* @param args - Forwarded to {@link PlatformWorkflowAPI.execJobFunction}
+* @returns The job's return value
+*/
+const startJobFunction = (...args) => api().execJobFunction(...args);
+const wait = (...args) => api().wait(...args);
+const resolve = (...args) => api().resolve(...args);
+/** Runtime wrapper namespace for `tailor.workflow`. */
+const workflow = {
+	startWorkflow,
+	resumeWorkflowExecution,
+	execJobFunction,
+	startJobFunction,
+	wait,
+	resolve
+};
+
+//#endregion
+export { workflow as t };
+//# sourceMappingURL=workflow-CsaQ9qK-.mjs.map

package/dist/workflow-CsaQ9qK-.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-CsaQ9qK-.mjs","names":[],"sources":["../src/runtime/workflow.ts"],"sourcesContent":["/**\n * Workflow utilities.\n *\n * Thin typed wrapper around the platform-provided `tailor.workflow` runtime API.\n * At runtime this delegates to `globalThis.tailor.workflow`. Use `mockWorkflow`\n * from `@tailor-platform/sdk/vitest` to mock these calls in unit tests.\n *\n * The canonical names (`startWorkflow`, `execJobFunction`,\n * `resumeWorkflowExecution`) mirror the public `tailor.v1` RPC vocabulary:\n * `Exec*` is a blocking call that returns the job's result, while `Start*`\n * returns only an execution ID. `startJobFunction` is kept as an alias of\n * `execJobFunction` for code written against earlier v2 prereleases.\n * @example\n * import { workflow } from \"@tailor-platform/sdk/runtime\";\n *\n * const executionId = await workflow.startWorkflow(\"myWorkflow\", { data: \"value\" });\n */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * Specifies the machine user that should be used to execute the workflow.\n * This allows workflows to run with specific authentication context.\n */\nexport interface Invoker {\n  /** The namespace where the machine user is defined */\n  namespace: string;\n  /** The name of the machine user to use for workflow execution */\n  machineUserName: string;\n}\n\n/** Options for {@link startWorkflow}. */\nexport interface StartWorkflowOptions {\n  /** Optional authentication invoker to specify which machine user should execute the workflow */\n  authInvoker?: Invoker;\n}\n\ndeclare const executionPolicyKeyBrand: unique symbol;\n\n/**\n * A concrete runtime key produced by an execution policy instance — either an\n * exact-match policy's `.key`, or a wildcard policy's `.keyFor(suffix)` (see\n * `defineWorkflowExecutionPolicies`). Branded so an arbitrary string that\n * wasn't derived from a declared policy can't be passed as `executionPolicyKey`.\n */\nexport type ExecutionPolicyKey = string & { readonly [executionPolicyKeyBrand]: never };\n\n/** Options for {@link execJobFunction}. */\nexport interface ExecJobFunctionOptions {\n  /**\n   * Execution policy key matched by the platform against the policies\n   * declared with `defineWorkflowExecutionPolicies` in `tailor.config.ts`.\n   */\n  executionPolicyKey?: ExecutionPolicyKey;\n}\n\n/**\n * Alias for {@link ExecJobFunctionOptions}. Kept for backward compatibility.\n * @deprecated Use {@link ExecJobFunctionOptions} instead.\n */\nexport type StartJobFunctionOptions = ExecJobFunctionOptions;\n\n/**\n * Platform API surface for `tailor.workflow`. Describes the shape the platform\n * runtime injects on `globalThis.tailor.workflow`.\n */\nexport interface PlatformWorkflowAPI {\n  /**\n   * Starts a workflow and returns its execution ID.\n   * @param workflowName - Workflow name as defined in tailor.config\n   * @param args - Arguments forwarded to the workflow's main job\n   * @param options - Optional start options (e.g. `authInvoker`)\n   * @returns The execution ID of the started workflow\n   */\n  startWorkflow(workflowName: string, args?: any, options?: StartWorkflowOptions): Promise<string>;\n\n  /**\n   * Resumes a failed or pending-retry workflow execution and returns its execution ID.\n   * @param executionId - The execution to resume\n   * @returns The execution ID of the resumed workflow\n   */\n  resumeWorkflowExecution(executionId: string): Promise<string>;\n\n  /**\n   * Executes a job function and returns its result via durable suspend/replay.\n   *\n   * Canonical name under the platform verb convention: `Exec*` blocks and\n   * returns the job's result, while `Start*` returns only an execution ID.\n   * {@link startJobFunction} is an alias that resolves to the same platform\n   * implementation.\n   * @param jobName - Job name as defined in the workflow\n   * @param args - Arguments forwarded to the job\n   * @param options - Optional execution options (e.g. `executionPolicyKey`)\n   * @returns The job's return value\n   */\n  execJobFunction(jobName: string, args?: any, options?: ExecJobFunctionOptions): any;\n\n  /**\n   * Alias for {@link execJobFunction}. Kept for backward compatibility.\n   * @deprecated Use {@link execJobFunction} instead.\n   * @param jobName - Job name as defined in the workflow\n   * @param args - Arguments forwarded to the job\n   * @param options - Optional execution options (e.g. `executionPolicyKey`)\n   * @returns The job's return value\n   */\n  startJobFunction(jobName: string, args?: any, options?: StartJobFunctionOptions): any;\n\n  /**\n   * Suspends the current workflow execution and waits for an external signal to resume.\n   * @param key - Wait point key\n   * @param payload - Optional payload to record with the wait point\n   * @returns The payload supplied by the corresponding `resolve` call\n   */\n  wait(key: string, payload?: any): any;\n\n  /**\n   * Resolves a waiting workflow execution, causing it to resume.\n   * @param executionId - The execution to resume\n   * @param key - Wait point key to resolve\n   * @param callback - Callback receiving the wait payload; its return value is forwarded to `wait`\n   * @returns A promise that resolves once the resolve has been recorded\n   */\n  resolve(executionId: string, key: string, callback: (waitPayload: any) => any): Promise<void>;\n}\n\nconst api = (): PlatformWorkflowAPI =>\n  (globalThis as unknown as { tailor: { workflow: PlatformWorkflowAPI } }).tailor.workflow;\n\n/**\n * See {@link PlatformWorkflowAPI.startWorkflow}.\n * @param args - Forwarded to {@link PlatformWorkflowAPI.startWorkflow}\n * @returns The execution ID of the started workflow\n */\nconst startWorkflow: PlatformWorkflowAPI[\"startWorkflow\"] = (...args) =>\n  api().startWorkflow(...args);\n\n/**\n * See {@link PlatformWorkflowAPI.resumeWorkflowExecution}.\n * @param args - Forwarded to {@link PlatformWorkflowAPI.resumeWorkflowExecution}\n * @returns The execution ID of the resumed workflow\n */\nconst resumeWorkflowExecution: PlatformWorkflowAPI[\"resumeWorkflowExecution\"] = (...args) =>\n  api().resumeWorkflowExecution(...args);\n\n/**\n * See {@link PlatformWorkflowAPI.execJobFunction}.\n * @param args - Forwarded to {@link PlatformWorkflowAPI.execJobFunction}\n * @returns The job's return value\n */\nconst execJobFunction: PlatformWorkflowAPI[\"execJobFunction\"] = (...args) =>\n  api().execJobFunction(...args);\n\n/**\n * Alias for {@link execJobFunction}. Kept for backward compatibility.\n * @deprecated Use {@link execJobFunction} instead.\n * @param args - Forwarded to {@link PlatformWorkflowAPI.execJobFunction}\n * @returns The job's return value\n */\nconst startJobFunction: PlatformWorkflowAPI[\"startJobFunction\"] = (...args) =>\n  api().execJobFunction(...args);\n\nconst wait: PlatformWorkflowAPI[\"wait\"] = (...args) => api().wait(...args);\n\nconst resolve: PlatformWorkflowAPI[\"resolve\"] = (...args) => api().resolve(...args);\n\n/** Runtime wrapper namespace for `tailor.workflow`. */\nexport const workflow = {\n  startWorkflow,\n  resumeWorkflowExecution,\n  execJobFunction,\n  startJobFunction,\n  wait,\n  resolve,\n} as const satisfies PlatformWorkflowAPI;\n"],"mappings":";AA6HA,MAAM,YACH,WAAwE,OAAO;;;;;;AAOlF,MAAM,iBAAuD,GAAG,SAC9D,IAAI,CAAC,CAAC,cAAc,GAAG,IAAI;;;;;;AAO7B,MAAM,2BAA2E,GAAG,SAClF,IAAI,CAAC,CAAC,wBAAwB,GAAG,IAAI;;;;;;AAOvC,MAAM,mBAA2D,GAAG,SAClE,IAAI,CAAC,CAAC,gBAAgB,GAAG,IAAI;;;;;;;AAQ/B,MAAM,oBAA6D,GAAG,SACpE,IAAI,CAAC,CAAC,gBAAgB,GAAG,IAAI;AAE/B,MAAM,QAAqC,GAAG,SAAS,IAAI,CAAC,CAAC,KAAK,GAAG,IAAI;AAEzE,MAAM,WAA2C,GAAG,SAAS,IAAI,CAAC,CAAC,QAAQ,GAAG,IAAI;;AAGlF,MAAa,WAAW;CACtB;CACA;CACA;CACA;CACA;CACA;AACF"}