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

package/dist/runtime/iconv.d.mts

@@ -1,2 +1,73 @@
-import { a as convert, c as encode, i as TailorIconvAPI, l as encodings, n as IconvConstructor, o as convertBuffer, r as IconvInstance, s as decode, t as Iconv } from "../iconv-kwrmd1U_.mjs";
-export { Iconv, IconvConstructor, IconvInstance, TailorIconvAPI, convert, convertBuffer, decode, encode, encodings };
+//#region src/runtime/iconv.d.ts
+/**
+ * Character encoding conversion utilities.
+ *
+ * Thin typed wrapper around the platform-provided `tailor.iconv` runtime API.
+ * At runtime this delegates to `globalThis.tailor.iconv`, which is provided by
+ * the Tailor Platform Function runtime. Use `mockIconv` from
+ * `@tailor-platform/sdk/vitest` to mock these calls in unit tests.
+ * @example
+ * import { iconv } from "@tailor-platform/sdk/runtime";
+ *
+ * const utf8 = iconv.convert(sjisBuffer, "Shift_JIS", "UTF-8"); // string
+ * const sjis = iconv.convert("こんにちは", "UTF-8", "Shift_JIS"); // Uint8Array
+ *
+ * const conv = new iconv.Iconv("Shift_JIS", "UTF-8");
+ * const out = conv.convert(sjisBuffer);
+ */
+/** Instance methods exposed by `tailor.iconv.Iconv`. */
+interface IconvInstance {
+  convert(input: string | Uint8Array | ArrayBuffer): string | Uint8Array;
+}
+/** Constructor shape for `tailor.iconv.Iconv`. */
+interface IconvConstructor {
+  new (fromEncoding: string, toEncoding: string): IconvInstance;
+}
+/**
+ * Platform API surface for `tailor.iconv`. Describes the shape the platform
+ * runtime injects on `globalThis.tailor.iconv` so the wrapper and ambient
+ * globals stay in sync.
+ */
+interface TailorIconvAPI {
+  /**
+   * Convert a string or buffer between encodings.
+   * @param str - Input data to convert
+   * @param fromEncoding - Source encoding name
+   * @param toEncoding - Target encoding name
+   * @returns `string` when `toEncoding` is `"UTF8"` or `"UTF-8"`, otherwise `Uint8Array`.
+   */
+  convert<T extends string>(str: string | Uint8Array | ArrayBuffer, fromEncoding: string, toEncoding: T): T extends "UTF8" | "UTF-8" ? string : Uint8Array;
+  /**
+   * Convert a buffer between encodings.
+   * @param buffer - Input bytes to convert
+   * @param fromEncoding - Source encoding name
+   * @param toEncoding - Target encoding name
+   * @returns `string` when `toEncoding` is `"UTF8"` or `"UTF-8"`, otherwise `Uint8Array`.
+   */
+  convertBuffer<T extends string>(buffer: Uint8Array | ArrayBuffer, fromEncoding: string, toEncoding: T): T extends "UTF8" | "UTF-8" ? string : Uint8Array;
+  /**
+   * Decode a buffer to a UTF-8 string using the given source encoding.
+   * @param buffer - Input bytes
+   * @param encoding - Source encoding name
+   * @returns Decoded UTF-8 string
+   */
+  decode(buffer: Uint8Array | ArrayBuffer, encoding: string): string;
+  /**
+   * Encode a UTF-8 string into the given target encoding.
+   * @param str - Input string
+   * @param encoding - Target encoding name
+   * @returns `string` when `encoding` is `"UTF8"` or `"UTF-8"`, otherwise `Uint8Array`.
+   */
+  encode<T extends string>(str: string, encoding: T): T extends "UTF8" | "UTF-8" ? string : Uint8Array;
+  /**
+   * Returns the list of supported encoding names.
+   * @returns Array of encoding names supported by the platform iconv runtime
+   */
+  encodings(): string[];
+  /** Constructor for the stateful converter. */
+  Iconv: IconvConstructor;
+}
+/** Runtime API for `tailor.iconv`. */
+declare const iconv: TailorIconvAPI;
+//#endregion
+export { IconvConstructor, IconvInstance, TailorIconvAPI, iconv };

package/dist/runtime/iconv.mjs

@@ -1,4 +1,3 @@
+import { t as iconv } from "../iconv-QWaZh0TT.mjs";
 
-import { a as encode, i as decode, n as convert, o as encodings, r as convertBuffer, t as Iconv } from "../iconv-DreIffeM.mjs";
-
-export { Iconv, convert, convertBuffer, decode, encode, encodings };
+export { iconv };

package/dist/runtime/idp.d.mts

@@ -1,2 +1,129 @@
-import { a as IdpClientInstance, c as SendPasswordResetEmailInput, d as User, f as UserQuery, i as IdpClientConstructor, l as TailorIdpAPI, n as ClientConfig, o as ListUsersOptions, r as CreateUserInput, s as ListUsersResponse, t as Client, u as UpdateUserInput } from "../idp-BlBPtXJ-.mjs";
-export { Client, ClientConfig, CreateUserInput, IdpClientConstructor, IdpClientInstance, ListUsersOptions, ListUsersResponse, SendPasswordResetEmailInput, TailorIdpAPI, UpdateUserInput, User, UserQuery };
+//#region src/runtime/idp.d.ts
+/**
+ * IDP (Identity Provider) utilities.
+ *
+ * Thin typed wrapper around the platform-provided `tailor.idp` runtime API.
+ * At runtime this delegates to `globalThis.tailor.idp`. Use `mockIdp` from
+ * `@tailor-platform/sdk/vitest` to mock these calls in unit tests.
+ * @example
+ * import { idp } from "@tailor-platform/sdk/runtime";
+ *
+ * const client = new idp.Client({ namespace: "my-namespace" });
+ * const { users } = await client.users({ first: 10 });
+ */
+/** Configuration object for `idp.Client`. */
+interface ClientConfig {
+  namespace: string;
+}
+/** User record returned by IDP operations. */
+interface User {
+  id: string;
+  name: string;
+  disabled: boolean;
+  createdAt?: string;
+  /**
+   * True when the user has at least one enrolled MFA second factor. False when
+   * the namespace has MFA disabled or the user has not enrolled a factor.
+   */
+  mfaEnrolled: boolean;
+  /**
+   * Enrolled MFA second factor IDs. Pass an entry into
+   * `idp.Client.unenrollMfa()` to remove that factor.
+   */
+  mfaFactorIds: string[];
+}
+/** Filter options for `idp.Client.users()`. */
+interface UserQuery {
+  /** Filter by user IDs */
+  ids?: string[];
+  /** Filter by user names */
+  names?: string[];
+}
+/** Pagination/filter options for `idp.Client.users()`. */
+interface ListUsersOptions {
+  /** Maximum number of users to return */
+  first?: number;
+  /** Page token for pagination */
+  after?: string;
+  /** Query filter for users */
+  query?: UserQuery;
+}
+/** Response shape for `idp.Client.users()`. */
+interface ListUsersResponse {
+  users: User[];
+  nextPageToken: string | null;
+  totalCount: number;
+}
+/** Input for `idp.Client.createUser()`. */
+interface CreateUserInput {
+  /** The user's name (typically email) */
+  name: string;
+  /** The user's password. If omitted, the user is created without a password (cannot log in with any password). */
+  password?: string;
+  /** Whether the user is disabled */
+  disabled?: boolean;
+}
+/** Input for `idp.Client.updateUser()`. */
+interface UpdateUserInput {
+  /** The user's ID */
+  id: string;
+  /** New name for the user */
+  name?: string;
+  /** New password for the user. Cannot be used with clearPassword. */
+  password?: string;
+  /** If true, remove the user's password. Cannot be used with password. */
+  clearPassword?: boolean;
+  /** New disabled status for the user */
+  disabled?: boolean;
+}
+/** Input for `idp.Client.sendPasswordResetEmail()`. */
+interface SendPasswordResetEmailInput {
+  /** The ID of the user */
+  userId: string;
+  /** The URI to redirect to after password reset */
+  redirectUri: string;
+  /** The sender display name. Defaults to 'Tailor Platform IdP'. */
+  fromName?: string;
+  /** The email subject line. Defaults to the localized default subject. */
+  subject?: string;
+}
+/** Input for `idp.Client.unenrollMfa()`. */
+interface UnenrollMfaInput {
+  /** The ID of the user whose factor will be unenrolled. */
+  userId: string;
+  /**
+   * The ID of the factor to unenroll. Factor IDs are exposed on the user
+   * record (see {@link User.mfaFactorIds}).
+   */
+  mfaFactorId: string;
+}
+/** Instance methods exposed by `tailor.idp.Client`. */
+interface IdpClientInstance {
+  users(options?: ListUsersOptions): Promise<ListUsersResponse>;
+  user(userId: string): Promise<User>;
+  userByName(name: string): Promise<User>;
+  createUser(input: CreateUserInput): Promise<User>;
+  updateUser(input: UpdateUserInput): Promise<User>;
+  deleteUser(userId: string): Promise<boolean>;
+  sendPasswordResetEmail(input: SendPasswordResetEmailInput): Promise<boolean>;
+  unenrollMfa(input: UnenrollMfaInput): Promise<boolean>;
+}
+/**
+ * Constructor shape for `tailor.idp.Client`.
+ * @internal
+ */
+interface IdpClientConstructor {
+  new (config: ClientConfig): IdpClientInstance;
+}
+/**
+ * Platform API surface for `tailor.idp`. Describes the shape the platform
+ * runtime injects on `globalThis.tailor.idp`.
+ * @internal
+ */
+interface TailorIdpAPI {
+  Client: IdpClientConstructor;
+}
+/** Runtime API for `tailor.idp`. */
+declare const idp: TailorIdpAPI;
+//#endregion
+export { ClientConfig, CreateUserInput, IdpClientConstructor, IdpClientInstance, ListUsersOptions, ListUsersResponse, SendPasswordResetEmailInput, TailorIdpAPI, UnenrollMfaInput, UpdateUserInput, User, UserQuery, idp };

package/dist/runtime/idp.mjs

@@ -1,4 +1,3 @@
+import { t as idp } from "../idp-RA_swu-h.mjs";
 
-import { t as Client } from "../idp-Ch95ag8h.mjs";
-
-export { Client };
+export { idp };

package/dist/runtime/index.d.mts

@@ -1,9 +1,48 @@
-import { n as authconnection_d_exports } from "../authconnection-BIYzEh2p.mjs";
-import { i as context_d_exports } from "../context-CUBwSBq4.mjs";
-import { b as file_d_exports } from "../file-BzK8z3X-.mjs";
-import { u as iconv_d_exports } from "../iconv-kwrmd1U_.mjs";
-import { p as idp_d_exports } from "../idp-BlBPtXJ-.mjs";
-import { i as secretmanager_d_exports } from "../secretmanager-CKLB3wAQ.mjs";
-import { c as workflow_d_exports } from "../workflow-CMamswkK.mjs";
-import { a as TailordbQueryResult, i as TailordbCommandType, n as TailordbClientConstructor, o as TailordbRuntime, r as TailordbClientInstance, t as TailorRuntime } from "../index-DRhMpdnA.mjs";
-export { TailorRuntime, TailordbClientConstructor, TailordbClientInstance, TailordbCommandType, TailordbQueryResult, TailordbRuntime, authconnection_d_exports as authconnection, context_d_exports as context, file_d_exports as file, iconv_d_exports as iconv, idp_d_exports as idp, secretmanager_d_exports as secretmanager, workflow_d_exports as workflow };
+import { PlatformWorkflowAPI, workflow } from "./workflow.mjs";
+import { TailorAigatewayAPI, aigateway } from "./aigateway.mjs";
+import { TailorAuthconnectionAPI, authconnection } from "./authconnection.mjs";
+import { PlatformContextAPI, context } from "./context.mjs";
+import { TailorDBFileAPI, file } from "./file.mjs";
+import { TailorIconvAPI, iconv } from "./iconv.mjs";
+import { TailorIdpAPI, idp } from "./idp.mjs";
+import { TailorLoggerAPI, logger } from "./logger.mjs";
+import { TailorSecretmanagerAPI, secretmanager } from "./secretmanager.mjs";
+//#region src/runtime/index.d.ts
+/** SQL command type recorded on a {@link TailordbQueryResult}. */
+type TailordbCommandType = "INSERT" | "DELETE" | "UPDATE" | "SELECT" | "MOVE" | "FETCH" | "COPY" | "CREATE";
+/** Result of a single `queryObject` call against the TailorDB driver. */
+interface TailordbQueryResult<T> {
+  rows: T[];
+  command: TailordbCommandType;
+  rowCount: number;
+}
+/** Instance methods exposed by `tailordb.Client`. */
+interface TailordbClientInstance {
+  connect(): Promise<void>;
+  end(): Promise<void>;
+  queryObject<O>(sql: string, args?: readonly unknown[]): Promise<TailordbQueryResult<O>>;
+}
+/** Constructor shape for `tailordb.Client`. */
+interface TailordbClientConstructor {
+  new (config: {
+    namespace: string;
+  }): TailordbClientInstance;
+}
+/** Top-level `tailor` runtime object. */
+interface TailorRuntime {
+  secretmanager: TailorSecretmanagerAPI;
+  authconnection: TailorAuthconnectionAPI;
+  iconv: TailorIconvAPI;
+  idp: TailorIdpAPI;
+  workflow: PlatformWorkflowAPI;
+  context: PlatformContextAPI;
+  aigateway: TailorAigatewayAPI;
+  logger: TailorLoggerAPI;
+}
+/** Top-level `tailordb` runtime object. */
+interface TailordbRuntime {
+  Client: TailordbClientConstructor;
+  file: TailorDBFileAPI;
+}
+//#endregion
+export { TailorRuntime, TailordbClientConstructor, TailordbClientInstance, TailordbCommandType, TailordbQueryResult, TailordbRuntime, aigateway, authconnection, context, file, iconv, idp, logger, secretmanager, workflow };

package/dist/runtime/index.mjs

@@ -1,10 +1,11 @@
+import { t as iconv } from "../iconv-QWaZh0TT.mjs";
+import { t as secretmanager } from "../secretmanager-CYlpffsz.mjs";
+import { t as authconnection } from "../authconnection-CZvi9ANm.mjs";
+import { t as idp } from "../idp-RA_swu-h.mjs";
+import { t as workflow } from "../workflow-CsaQ9qK-.mjs";
+import { t as context } from "../context-DYQVYWqZ.mjs";
+import { t as file } from "../file-BUcmVIH2.mjs";
+import { t as aigateway } from "../aigateway-DR4Kwuik.mjs";
+import { i as logger } from "../logger-BtX0suGY.mjs";
 
-import { s as iconv_exports } from "../iconv-DreIffeM.mjs";
-import { r as secretmanager_exports } from "../secretmanager-B9h-U_8U.mjs";
-import { t as authconnection_exports } from "../authconnection-D8SJGMpj.mjs";
-import { n as idp_exports } from "../idp-Ch95ag8h.mjs";
-import { a as workflow_exports } from "../workflow--aPbA8Uq.mjs";
-import { t as context_exports } from "../context-s0lxhu8_.mjs";
-import { a as file_exports } from "../file-B58Dm-2P.mjs";
-
-export { authconnection_exports as authconnection, context_exports as context, file_exports as file, iconv_exports as iconv, idp_exports as idp, secretmanager_exports as secretmanager, workflow_exports as workflow };
+export { aigateway, authconnection, context, file, iconv, idp, logger, secretmanager, workflow };

package/dist/runtime/logger.d.mts

@@ -0,0 +1,98 @@
+//#region src/runtime/logger.d.ts
+/**
+ * Structured logging utilities.
+ *
+ * Thin typed wrapper around the platform-provided `tailor.logger` runtime API.
+ * At runtime this delegates to `globalThis.tailor.logger`. Use `mockLogger`
+ * from `@tailor-platform/sdk/vitest` to mock these calls in unit tests.
+ *
+ * Unlike `console.*`, each call carries a severity and structured attributes.
+ * The message is written to standard output, and the full entry with its
+ * attributes is exported over OpenTelemetry, where the attributes are queryable.
+ * @example
+ * import { logger } from "@tailor-platform/sdk/runtime";
+ *
+ * logger.setAttributes({ requestId: "r-123" });
+ * logger.info("order processed", { orderId: "o-1", total: 99.5 });
+ */
+/**
+ * A single log attribute value. Values outside this union (`null`, nested
+ * objects, mixed-type arrays) are silently dropped by the platform.
+ */
+type LogAttributeValue = string | number | boolean | readonly string[] | readonly number[] | readonly boolean[];
+/**
+ * Structured attributes attached to a log entry. The platform keeps at most 32
+ * entries, drops any entry whose key exceeds 128 bytes, and truncates string
+ * values over 4096 bytes and arrays over 64 elements.
+ */
+type LogAttributes = Record<string, LogAttributeValue>;
+/**
+ * Platform API surface for `tailor.logger`. Describes the shape the platform
+ * runtime injects on `globalThis.tailor.logger`.
+ *
+ * Each method below is also re-exported as a top-level named export from this
+ * module so callers can either `import * as logger from
+ * "@tailor-platform/sdk/runtime/logger"` or pick individual methods.
+ */
+interface TailorLoggerAPI {
+  /**
+   * Emits a `debug`-severity log entry.
+   * @param message - The log message
+   * @param attributes - Structured attributes to attach to this entry
+   */
+  debug(message: string, attributes?: LogAttributes): void;
+  /**
+   * Emits an `info`-severity log entry.
+   * @param message - The log message
+   * @param attributes - Structured attributes to attach to this entry
+   */
+  info(message: string, attributes?: LogAttributes): void;
+  /**
+   * Emits a `warn`-severity log entry.
+   * @param message - The log message
+   * @param attributes - Structured attributes to attach to this entry
+   */
+  warn(message: string, attributes?: LogAttributes): void;
+  /**
+   * Emits an `error`-severity log entry.
+   * @param message - The log message
+   * @param attributes - Structured attributes to attach to this entry
+   */
+  error(message: string, attributes?: LogAttributes): void;
+  /**
+   * Merges attributes into every subsequent log entry from the current
+   * execution. Later keys overwrite earlier ones; per-call attributes passed to
+   * `debug`/`info`/`warn`/`error` take precedence.
+   * @param attributes - Attributes to attach to subsequent entries
+   */
+  setAttributes(attributes: LogAttributes): void;
+}
+/**
+ * See {@link TailorLoggerAPI.debug}.
+ * @param args - Forwarded to {@link TailorLoggerAPI.debug}
+ */
+declare const debug: TailorLoggerAPI["debug"];
+/**
+ * See {@link TailorLoggerAPI.info}.
+ * @param args - Forwarded to {@link TailorLoggerAPI.info}
+ */
+declare const info: TailorLoggerAPI["info"];
+/**
+ * See {@link TailorLoggerAPI.warn}.
+ * @param args - Forwarded to {@link TailorLoggerAPI.warn}
+ */
+declare const warn: TailorLoggerAPI["warn"];
+/**
+ * See {@link TailorLoggerAPI.error}.
+ * @param args - Forwarded to {@link TailorLoggerAPI.error}
+ */
+declare const error: TailorLoggerAPI["error"];
+/**
+ * See {@link TailorLoggerAPI.setAttributes}.
+ * @param args - Forwarded to {@link TailorLoggerAPI.setAttributes}
+ */
+declare const setAttributes: TailorLoggerAPI["setAttributes"];
+/** `tailor.logger` API object. See {@link TailorLoggerAPI} for method docs. */
+declare const logger: TailorLoggerAPI;
+//#endregion
+export { LogAttributeValue, LogAttributes, TailorLoggerAPI, debug, error, info, logger, setAttributes, warn };

package/dist/runtime/logger.mjs

@@ -0,0 +1,3 @@
+import { a as setAttributes, i as logger, n as error, o as warn, r as info, t as debug } from "../logger-BtX0suGY.mjs";
+
+export { debug, error, info, logger, setAttributes, warn };

package/dist/runtime/secretmanager.d.mts

@@ -1,2 +1,41 @@
-import { n as getSecret, r as getSecrets, t as TailorSecretmanagerAPI } from "../secretmanager-CKLB3wAQ.mjs";
-export { TailorSecretmanagerAPI, getSecret, getSecrets };
+//#region src/runtime/secretmanager.d.ts
+/**
+ * Secret manager utilities.
+ *
+ * Thin typed wrapper around the platform-provided `tailor.secretmanager` runtime API.
+ * At runtime this delegates to `globalThis.tailor.secretmanager`. Use
+ * `mockSecretmanager` from `@tailor-platform/sdk/vitest` to mock these calls
+ * in unit tests.
+ * @example
+ * import { secretmanager } from "@tailor-platform/sdk/runtime";
+ *
+ * const apiKey = await secretmanager.getSecret("my-vault", "API_KEY");
+ * const all = await secretmanager.getSecrets("my-vault", ["A", "B"] as const);
+ */
+/**
+ * Platform API surface for `tailor.secretmanager`. Describes the shape the
+ * platform runtime injects on `globalThis.tailor.secretmanager`.
+ */
+interface TailorSecretmanagerAPI {
+  /**
+   * Returns multiple secrets from a vault. Missing names are omitted from the result.
+   * @param vault - Vault name
+   * @param names - Secret names to fetch (use `as const` to narrow the result key)
+   * @returns Partial record keyed by the requested names
+   */
+  getSecrets<const T extends readonly string[]>(vault: string, names: T): Promise<Partial<Record<T[number], string>>>;
+  /**
+   * Returns a single secret from a vault, or `undefined` when missing.
+   * @param vault - Vault name
+   * @param name - Secret name
+   * @returns The secret value, or `undefined` if not present
+   */
+  getSecret(vault: string, name: string): Promise<string | undefined>;
+}
+/** Runtime wrapper namespace for `tailor.secretmanager`. */
+declare const secretmanager: {
+  readonly getSecrets: <const T extends readonly string[]>(vault: string, names: T) => Promise<Partial<Record<T[number], string>>>;
+  readonly getSecret: (vault: string, name: string) => Promise<string | undefined>;
+};
+//#endregion
+export { TailorSecretmanagerAPI, secretmanager };

package/dist/runtime/secretmanager.mjs

@@ -1,4 +1,3 @@
+import { t as secretmanager } from "../secretmanager-CYlpffsz.mjs";
 
-import { n as getSecrets, t as getSecret } from "../secretmanager-B9h-U_8U.mjs";
-
-export { getSecret, getSecrets };
+export { secretmanager };

package/dist/runtime/types.d.mts

@@ -0,0 +1,25 @@
+//#region src/runtime/types.d.ts
+interface Attributes {}
+interface AttributeList {
+  __tuple?: [];
+}
+type InferredAttributes = keyof Attributes extends never ? Record<string, string | string[] | boolean | boolean[] | undefined> : Attributes;
+type InferredAttributeList = AttributeList["__tuple"] extends [] ? string[] : AttributeList["__tuple"];
+/** Represents a user or machine user principal in the Tailor Platform. */
+type TailorPrincipal = {
+  /** The ID of the principal. */
+  id: string;
+  /** The type of the principal. */
+  type: "user" | "machine_user";
+  /** The ID of the workspace the principal belongs to. */
+  workspaceId: string;
+  /** A map of the principal's attributes. */
+  attributes: InferredAttributes;
+  /** A list of the principal's attribute IDs. */
+  attributeList: InferredAttributeList;
+};
+interface Env {}
+/** Represents environment variables in the Tailor platform. */
+type TailorEnv = keyof Env extends never ? Record<string, string | number | boolean> : Env;
+//#endregion
+export { AttributeList, Attributes, Env, InferredAttributeList, InferredAttributes, TailorEnv, TailorPrincipal };

package/dist/runtime/workflow.d.mts

@@ -1,2 +1,124 @@
-import { a as triggerJobFunction, i as resolve, n as TailorWorkflowAPI, o as triggerWorkflow, r as TriggerWorkflowOptions, s as wait, t as AuthInvoker } from "../workflow-CMamswkK.mjs";
-export { AuthInvoker, TailorWorkflowAPI, TriggerWorkflowOptions, resolve, triggerJobFunction, triggerWorkflow, wait };
+//#region src/runtime/workflow.d.ts
+/**
+ * Workflow utilities.
+ *
+ * Thin typed wrapper around the platform-provided `tailor.workflow` runtime API.
+ * At runtime this delegates to `globalThis.tailor.workflow`. Use `mockWorkflow`
+ * from `@tailor-platform/sdk/vitest` to mock these calls in unit tests.
+ *
+ * The canonical names (`startWorkflow`, `execJobFunction`,
+ * `resumeWorkflowExecution`) mirror the public `tailor.v1` RPC vocabulary:
+ * `Exec*` is a blocking call that returns the job's result, while `Start*`
+ * returns only an execution ID. `startJobFunction` is kept as an alias of
+ * `execJobFunction` for code written against earlier v2 prereleases.
+ * @example
+ * import { workflow } from "@tailor-platform/sdk/runtime";
+ *
+ * const executionId = await workflow.startWorkflow("myWorkflow", { data: "value" });
+ */
+/**
+ * Specifies the machine user that should be used to execute the workflow.
+ * This allows workflows to run with specific authentication context.
+ */
+interface Invoker {
+  /** The namespace where the machine user is defined */
+  namespace: string;
+  /** The name of the machine user to use for workflow execution */
+  machineUserName: string;
+}
+/** Options for {@link startWorkflow}. */
+interface StartWorkflowOptions {
+  /** Optional authentication invoker to specify which machine user should execute the workflow */
+  authInvoker?: Invoker;
+}
+declare const executionPolicyKeyBrand: unique symbol;
+/**
+ * A concrete runtime key produced by an execution policy instance — either an
+ * exact-match policy's `.key`, or a wildcard policy's `.keyFor(suffix)` (see
+ * `defineWorkflowExecutionPolicies`). Branded so an arbitrary string that
+ * wasn't derived from a declared policy can't be passed as `executionPolicyKey`.
+ */
+type ExecutionPolicyKey = string & {
+  readonly [executionPolicyKeyBrand]: never;
+};
+/** Options for {@link execJobFunction}. */
+interface ExecJobFunctionOptions {
+  /**
+   * Execution policy key matched by the platform against the policies
+   * declared with `defineWorkflowExecutionPolicies` in `tailor.config.ts`.
+   */
+  executionPolicyKey?: ExecutionPolicyKey;
+}
+/**
+ * Alias for {@link ExecJobFunctionOptions}. Kept for backward compatibility.
+ * @deprecated Use {@link ExecJobFunctionOptions} instead.
+ */
+type StartJobFunctionOptions = ExecJobFunctionOptions;
+/**
+ * Platform API surface for `tailor.workflow`. Describes the shape the platform
+ * runtime injects on `globalThis.tailor.workflow`.
+ */
+interface PlatformWorkflowAPI {
+  /**
+   * Starts a workflow and returns its execution ID.
+   * @param workflowName - Workflow name as defined in tailor.config
+   * @param args - Arguments forwarded to the workflow's main job
+   * @param options - Optional start options (e.g. `authInvoker`)
+   * @returns The execution ID of the started workflow
+   */
+  startWorkflow(workflowName: string, args?: any, options?: StartWorkflowOptions): Promise<string>;
+  /**
+   * Resumes a failed or pending-retry workflow execution and returns its execution ID.
+   * @param executionId - The execution to resume
+   * @returns The execution ID of the resumed workflow
+   */
+  resumeWorkflowExecution(executionId: string): Promise<string>;
+  /**
+   * Executes a job function and returns its result via durable suspend/replay.
+   *
+   * Canonical name under the platform verb convention: `Exec*` blocks and
+   * returns the job's result, while `Start*` returns only an execution ID.
+   * {@link startJobFunction} is an alias that resolves to the same platform
+   * implementation.
+   * @param jobName - Job name as defined in the workflow
+   * @param args - Arguments forwarded to the job
+   * @param options - Optional execution options (e.g. `executionPolicyKey`)
+   * @returns The job's return value
+   */
+  execJobFunction(jobName: string, args?: any, options?: ExecJobFunctionOptions): any;
+  /**
+   * Alias for {@link execJobFunction}. Kept for backward compatibility.
+   * @deprecated Use {@link execJobFunction} instead.
+   * @param jobName - Job name as defined in the workflow
+   * @param args - Arguments forwarded to the job
+   * @param options - Optional execution options (e.g. `executionPolicyKey`)
+   * @returns The job's return value
+   */
+  startJobFunction(jobName: string, args?: any, options?: StartJobFunctionOptions): any;
+  /**
+   * Suspends the current workflow execution and waits for an external signal to resume.
+   * @param key - Wait point key
+   * @param payload - Optional payload to record with the wait point
+   * @returns The payload supplied by the corresponding `resolve` call
+   */
+  wait(key: string, payload?: any): any;
+  /**
+   * Resolves a waiting workflow execution, causing it to resume.
+   * @param executionId - The execution to resume
+   * @param key - Wait point key to resolve
+   * @param callback - Callback receiving the wait payload; its return value is forwarded to `wait`
+   * @returns A promise that resolves once the resolve has been recorded
+   */
+  resolve(executionId: string, key: string, callback: (waitPayload: any) => any): Promise<void>;
+}
+/** Runtime wrapper namespace for `tailor.workflow`. */
+declare const workflow: {
+  readonly startWorkflow: (workflowName: string, args?: any, options?: StartWorkflowOptions) => Promise<string>;
+  readonly resumeWorkflowExecution: (executionId: string) => Promise<string>;
+  readonly execJobFunction: (jobName: string, args?: any, options?: ExecJobFunctionOptions) => any;
+  readonly startJobFunction: (jobName: string, args?: any, options?: StartJobFunctionOptions) => any;
+  readonly wait: (key: string, payload?: any) => any;
+  readonly resolve: (executionId: string, key: string, callback: (waitPayload: any) => any) => Promise<void>;
+};
+//#endregion
+export { ExecJobFunctionOptions, ExecutionPolicyKey, Invoker, PlatformWorkflowAPI, StartJobFunctionOptions, StartWorkflowOptions, workflow };

package/dist/runtime/workflow.mjs

@@ -1,4 +1,3 @@
+import { t as workflow } from "../workflow-CsaQ9qK-.mjs";
 
-import { i as wait, n as triggerJobFunction, r as triggerWorkflow, t as resolve } from "../workflow--aPbA8Uq.mjs";
-
-export { resolve, triggerJobFunction, triggerWorkflow, wait };
+export { workflow };