@tailor-platform/sdk 2.0.0-next.1 → 2.0.0-next.11

package/dist/configure/services/tailordb/types.d.mts

@@ -0,0 +1,198 @@
+import { DefinedFieldMetadata, FieldMetadata, TailorField, TailorFieldType } from "../../types/field.types.mjs";
+import { InferredAttributes, TailorPrincipal } from "../../../runtime/types.mjs";
+import { DeepReadonly, InferFieldsOutput, Prettify, output } from "../../../types/helpers.mjs";
+import { DBFieldMetadata as DBFieldMetadata$1, GqlOperationsInput, RawPermissions, TailorDBServiceConfigInput } from "../../../types/tailordb.generated.mjs";
+//#region src/configure/services/tailordb/types.d.ts
+type SerialConfig<T extends "string" | "integer" = "string" | "integer"> = Prettify<{
+  start: number;
+  maxValue?: number;
+} & (T extends "string" ? {
+  format?: string;
+} : object)>;
+interface DBFieldMetadata extends FieldMetadata {
+  index?: boolean;
+  unique?: boolean;
+  vector?: boolean;
+  foreignKey?: boolean;
+  foreignKeyType?: string;
+  foreignKeyField?: string;
+  /** Lifecycle hooks for the field */
+  hooks?: DBFieldMetadata$1["hooks"];
+  serial?: SerialConfig;
+  relation?: boolean;
+  scale?: number;
+  default?: unknown;
+}
+interface DefinedDBFieldMetadata extends DefinedFieldMetadata {
+  index?: boolean;
+  unique?: boolean;
+  vector?: boolean;
+  foreignKey?: boolean;
+  foreignKeyType?: boolean;
+  validate?: boolean;
+  hooks?: {
+    create: boolean;
+    update: boolean;
+  };
+  serial?: boolean;
+  relation?: boolean;
+  default?: boolean;
+}
+type GqlOperationsConfig = GqlOperationsInput;
+interface RawRelationConfig {
+  type: "1-1" | "n-1" | "keyOnly" | "oneToOne" | "manyToOne" | "N-1";
+  toward: {
+    type: string;
+    as?: string;
+    key?: string;
+  };
+  backward?: string;
+}
+interface TailorDBTypeMetadata {
+  name: string;
+  description?: string;
+  settings?: {
+    pluralForm?: string;
+    aggregation?: boolean;
+    bulkUpsert?: boolean;
+    gqlOperations?: GqlOperationsConfig;
+    publishEvents?: boolean;
+  };
+  permissions: RawPermissions;
+  files: Record<string, string>;
+  indexes?: Record<string, {
+    fields: string[];
+    unique?: boolean;
+  }>;
+  typeHook?: {
+    create?: Function;
+    update?: Function;
+  };
+  typeValidate?: Function;
+}
+/**
+ * Minimal structural interface for TailorDBField.
+ * Defines only the properties needed by parser, plugin, cli, and types layers.
+ * The full interface with builder methods (relation, index, unique, hooks, validate, etc.)
+ * is defined in configure/services/tailordb/schema.ts.
+ */
+interface TailorDBField<Defined extends DefinedDBFieldMetadata = DefinedDBFieldMetadata, Output = any> extends Omit<TailorField<Defined, Output, DBFieldMetadata, Defined["type"]>, "fields"> {
+  readonly fields: Record<string, TailorAnyDBField>;
+  readonly rawRelation: Readonly<RawRelationConfig> | undefined;
+}
+type TailorAnyDBField = TailorDBField<any, any>;
+/**
+ * Minimal structural interface for TailorDBType.
+ * Defines only the properties needed by parser, plugin, cli, and types layers.
+ * The full interface with builder methods (hooks, validate, features, permission, etc.)
+ * is defined in configure/services/tailordb/schema.ts.
+ */
+interface TailorDBType<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributes> {
+  readonly name: string;
+  readonly fields: Fields;
+  readonly _output: InferFieldsOutput<Fields>;
+  readonly metadata: TailorDBTypeMetadata;
+  readonly plugins: PluginAttachment[];
+}
+type TailorAnyDBType = TailorDBType<any, any>;
+type TailorDBInstance<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributes> = TailorDBType<Fields, User>;
+type HookArgs<TData> = TData extends Record<string, unknown> ? { readonly [K in keyof TData]?: DeepReadonly<TData[K]> | null | undefined; } : unknown;
+type CreateHookFn<TValue, TReturn> = (args: {
+  input: TValue;
+  invoker: TailorPrincipal | null;
+  now: Date;
+}) => TReturn;
+type UpdateHookFn<TValue, TReturn> = (args: {
+  input: TValue;
+  oldValue: TReturn;
+  invoker: TailorPrincipal | null;
+  now: Date;
+}) => TReturn;
+type Hook<TReturn, TCreateReturn = TReturn> = {
+  create?: CreateHookFn<TReturn | null, TCreateReturn>;
+  update?: UpdateHookFn<TReturn | null, TReturn>;
+};
+type DotJoin<A extends string, B extends string> = A extends "" ? B : `${A}.${B}`;
+type DottedPaths<T, Prefix extends string = ""> = string extends keyof T ? string : T extends readonly (infer E)[] ? E extends Record<string, unknown> ? { [K in keyof E & string]: `${Prefix}[${number}].${K}` | DottedPaths<NonNullable<E[K]>, `${Prefix}[${number}].${K}`>; }[keyof E & string] : never : T extends Record<string, unknown> ? { [K in keyof T & string]: DotJoin<Prefix, K> | DottedPaths<NonNullable<T[K]>, DotJoin<Prefix, K>>; }[keyof T & string] : never;
+type TypeValidateFn<F extends Record<string, TailorAnyDBField>, TData = { [K in keyof F]: output<F[K]>; }> = (args: {
+  newRecord: DeepReadonly<TData>;
+  oldRecord: DeepReadonly<TData> | null;
+  invoker: TailorPrincipal | null;
+}, issues: (field: DottedPaths<Omit<TData, "id">>, message: string) => void) => void;
+type TypeCreateHookFn<F extends Record<string, TailorAnyDBField>, TData = { [K in keyof F]: output<F[K]>; }> = (args: {
+  input: DeepReadonly<TData>;
+  invoker: TailorPrincipal | null;
+  now: Date;
+}) => { [K in Exclude<keyof TData & string, "id">]?: TData[K] | null; };
+type TypeUpdateHookFn<F extends Record<string, TailorAnyDBField>, TData = { [K in keyof F]: output<F[K]>; }> = (args: {
+  input: HookArgs<TData>;
+  oldRecord: DeepReadonly<TData>;
+  invoker: TailorPrincipal | null;
+  now: Date;
+}) => { [K in Exclude<keyof TData & string, "id">]?: TData[K] | null; };
+type TypeHook<F extends Record<string, TailorAnyDBField>> = {
+  create?: TypeCreateHookFn<F>;
+  update?: TypeUpdateHookFn<F>;
+};
+type ExcludeNestedDBFields<T extends Record<string, TailorAnyDBField>> = { [K in keyof T]: T[K] extends TailorDBField<{
+  type: "nested";
+  array: boolean;
+}, any> ? never : T[K]; };
+type ExcludeHookedDBFields<T extends Record<string, TailorAnyDBField>> = { [K in keyof T]: T[K] extends TailorDBField<{
+  type: TailorFieldType;
+  array: boolean;
+  hooks: {
+    create: true;
+    update: boolean;
+  };
+}, any> ? never : T[K] extends TailorDBField<{
+  type: TailorFieldType;
+  array: boolean;
+  hooks: {
+    create: boolean;
+    update: true;
+  };
+}, any> ? never : T[K]; };
+type ExcludeDefaultedDBFields<T extends Record<string, TailorAnyDBField>> = { [K in keyof T]: T[K] extends TailorDBField<{
+  type: TailorFieldType;
+  array: boolean;
+  default: true;
+}, any> ? never : T[K]; };
+interface TypeFeatures {
+  pluralForm?: string;
+  aggregation?: true;
+  bulkUpsert?: true;
+  /** Configure GraphQL operations for this type. Use "query" for read-only mode, or an object for granular control. */
+  gqlOperations?: GqlOperationsConfig;
+  /**
+   * Enable publishing events for this type.
+   * When enabled, record creation/update/deletion events are published.
+   * If not specified, this is automatically set to true when an executor uses this type
+   * with recordCreated/recordUpdated/recordDeleted triggers. If explicitly set to false
+   * while an executor uses this type, an error will be thrown during apply.
+   */
+  publishEvents?: boolean;
+}
+/**
+ * Plugin attachment stored on TailorAnyDBType instances.
+ */
+interface PluginAttachment {
+  pluginId: string;
+  config: unknown;
+}
+type IndexDef<T extends {
+  fields: Record<PropertyKey, unknown>;
+}> = {
+  fields: [keyof T["fields"], keyof T["fields"], ...(keyof T["fields"])[]];
+  unique?: boolean;
+  name?: string;
+};
+type RelationType = "1-1" | "oneToOne" | "n-1" | "manyToOne" | "N-1" | "keyOnly";
+type TailorDBExternalConfig = {
+  external: true;
+};
+type TailorDBServiceInput = {
+  [namespace: string]: TailorDBServiceConfigInput | TailorDBExternalConfig;
+};
+//#endregion
+export { DBFieldMetadata, DefinedDBFieldMetadata, ExcludeDefaultedDBFields, ExcludeHookedDBFields, ExcludeNestedDBFields, GqlOperationsConfig, Hook, IndexDef, PluginAttachment, RawRelationConfig, RelationType, SerialConfig, TailorAnyDBField, TailorAnyDBType, TailorDBExternalConfig, TailorDBField, TailorDBInstance, TailorDBServiceInput, TailorDBType, TailorDBTypeMetadata, TypeFeatures, TypeHook, TypeValidateFn };

package/dist/configure/services/workflow/execution-policy.d.mts

@@ -0,0 +1,70 @@
+import { ExecutionPolicyConcurrency, ExecutionPolicyDefInput, ExecutionPolicyExactInstance, ExecutionPolicyGroupOptions, ExecutionPolicyInstance, ExecutionPolicyWildcardInstance, ResolvedExecutionPolicyInstance } from "./execution-policy.types.mjs";
+//#region src/configure/services/workflow/execution-policy.d.ts
+type ResolveKey<Def, Fallback extends string> = Def extends {
+  key: infer K extends string;
+} ? K : Fallback;
+type ResolveMatchType<Def> = Def extends {
+  matchType: infer M extends "exact" | "prefix";
+} ? M : "exact";
+/**
+ * Define a single workflow job function execution policy.
+ *
+ * Use this when declaring a policy outside the
+ * {@link defineWorkflowExecutionPolicies} builder — for example, when the
+ * runtime key prefix needs to differ from the corresponding workspace-unique
+ * name.
+ *
+ * When `matchType: "prefix"` is set, the returned instance has `keyFor(suffix)`
+ * instead of a directly-usable `key` (see {@link ExecutionPolicyWildcardInstance}).
+ * @param name - Workspace-unique name. Must match `^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$`.
+ * @param def - Optional overrides for `key` (defaults to `name`), `matchType`, `separator` (the `keyFor` join character, defaults to `.`), and concurrency
+ * @returns An execution policy instance
+ * @example
+ * export const perTenant = defineWorkflowExecutionPolicy("tenant-api", {
+ *   matchType: "prefix",
+ *   concurrencyPolicy: { maxConcurrentExecutions: 3 },
+ * });
+ *
+ * perTenant.keyFor(tenantId); // "tenant-api.<tenantId>"
+ */
+declare function defineWorkflowExecutionPolicy<const N extends string, const D extends (Omit<ExecutionPolicyDefInput, "name"> & {
+  separator?: string;
+}) | undefined = undefined>(name: N, def?: D): ResolvedExecutionPolicyInstance<ResolveKey<D, N>, ResolveMatchType<D>>;
+/**
+ * Define a group of workflow job function execution policies. Property names
+ * become the workspace-unique `name` and default `key` verbatim, matching the
+ * mental model of {@link createWaitPoints}. Provide `name` / `key` explicitly
+ * to override the property-name default (for example, when the property name
+ * is not valid for the execution policy grammar or when the runtime key
+ * prefix needs to differ).
+ *
+ * When `matchType: "prefix"` is set, the returned instance has `keyFor(suffix)`
+ * instead of a directly-usable `key` (see {@link ExecutionPolicyWildcardInstance}).
+ * `matchType` can be combined with an explicit `key`, or left to apply to
+ * the property-name-derived prefix.
+ *
+ * The return type mirrors the builder's return type so JSDoc on each property
+ * is preserved in IDE autocompletion.
+ * @param builder - Callback that receives a `define` factory and returns a record of policies
+ * @param options - Group-wide options; `separator` overrides the `.` `keyFor` uses to join the prefix and suffix for every prefix policy in the group
+ * @returns The same object returned by the builder (with `name` / `key` resolved on each instance)
+ * @example
+ * export const executionPolicies = defineWorkflowExecutionPolicies((define) => ({
+ *   premium: define({ concurrencyPolicy: { maxConcurrentExecutions: 5 } }),
+ *   "tenant-api": define({
+ *     matchType: "prefix",
+ *     concurrencyPolicy: { maxConcurrentExecutions: 3 },
+ *   }),
+ * }));
+ *
+ * // In a workflow job function:
+ * await tailor.workflow.execJobFunction("worker", args, {
+ *   executionPolicyKey: executionPolicies.premium.key,
+ * });
+ * await tailor.workflow.execJobFunction("worker", args, {
+ *   executionPolicyKey: executionPolicies["tenant-api"].keyFor(input.tenantId),
+ * });
+ */
+declare function defineWorkflowExecutionPolicies<T extends Record<string, ExecutionPolicyInstance>>(builder: (define: <const D extends ExecutionPolicyDefInput | undefined = undefined>(def?: D) => ResolvedExecutionPolicyInstance<ResolveKey<D, string>, ResolveMatchType<D>>) => T, options?: ExecutionPolicyGroupOptions): T;
+//#endregion
+export { type ExecutionPolicyConcurrency, type ExecutionPolicyDefInput, type ExecutionPolicyExactInstance, type ExecutionPolicyGroupOptions, type ExecutionPolicyInstance, type ExecutionPolicyWildcardInstance, type ResolvedExecutionPolicyInstance, defineWorkflowExecutionPolicies, defineWorkflowExecutionPolicy };

package/dist/configure/services/workflow/execution-policy.types.d.mts

@@ -0,0 +1,103 @@
+import { ExecutionPolicyKey } from "../../../runtime/workflow.mjs";
+//#region src/configure/services/workflow/execution-policy.types.d.ts
+/**
+ * Optional per-key concurrency cap applied to job function dispatches that
+ * resolve to a policy's `executionPolicyKey`.
+ */
+interface ExecutionPolicyConcurrency {
+  /** Maximum number of concurrent executions allowed per resolved key. */
+  maxConcurrentExecutions: number;
+}
+/** Fields shared by both {@link ExecutionPolicyExactInstance} and {@link ExecutionPolicyWildcardInstance}. */
+interface ExecutionPolicyBase {
+  /** Workspace-unique name for this policy. */
+  readonly name: string;
+  /** Optional per-key concurrency cap. */
+  readonly concurrencyPolicy?: ExecutionPolicyConcurrency;
+}
+/**
+ * An execution policy declared with `matchType: "exact"` (the default).
+ * `key` is branded as {@link ExecutionPolicyKey}, so it can be passed
+ * directly as the `executionPolicyKey` option.
+ */
+interface ExecutionPolicyExactInstance<Key extends string = string> extends ExecutionPolicyBase {
+  /** Declared key; the platform registers it verbatim. */
+  readonly key: Key & ExecutionPolicyKey;
+  readonly matchType: "exact";
+}
+/**
+ * An execution policy declared with `matchType: "prefix"`. The platform
+ * registers the declared key prefix with a trailing `*`, and matches every
+ * dispatch whose runtime key begins with that prefix. There is no
+ * directly-usable `key` — use `keyFor` to build a concrete, branded runtime
+ * key at the call site instead of hand-concatenating the prefix and a
+ * suffix.
+ */
+interface ExecutionPolicyWildcardInstance extends ExecutionPolicyBase {
+  readonly matchType: "prefix";
+  /**
+   * Build a concrete runtime key by appending `suffix` after this policy's
+   * declared key prefix, separated by `.` unless a different separator was
+   * configured where this policy was declared.
+   * @param suffix - Value appended after the wildcard prefix
+   * @returns The concrete key to pass as `executionPolicyKey`
+   * @throws If the resulting key does not match the execution policy key
+   * grammar (for example, an empty `suffix`)
+   * @example
+   * // key: "tenant-api", matchType: "prefix"
+   * tenantApi.keyFor(tenantId); // "tenant-api.<tenantId>"
+   */
+  keyFor(suffix: string): ExecutionPolicyKey;
+}
+/**
+ * A declared workflow job function execution policy — either
+ * {@link ExecutionPolicyExactInstance} or {@link ExecutionPolicyWildcardInstance}.
+ */
+type ExecutionPolicyInstance<Key extends string = string> = ExecutionPolicyExactInstance<Key> | ExecutionPolicyWildcardInstance;
+/**
+ * Resolves to {@link ExecutionPolicyWildcardInstance} when `MatchType` is
+ * known at the type level to be `"prefix"`, to {@link ExecutionPolicyExactInstance}
+ * when it's known to be `"exact"`, or to their union when `MatchType` is the
+ * unnarrowed `"exact" | "prefix"` (e.g. a caller passed a non-literal
+ * `matchType`) — narrowing to one branch in that case would claim a `key` or
+ * `keyFor` that may not exist on the actual runtime instance.
+ */
+type ResolvedExecutionPolicyInstance<Key extends string, MatchType extends "exact" | "prefix"> = "exact" | "prefix" extends MatchType ? ExecutionPolicyExactInstance<Key> | ExecutionPolicyWildcardInstance : MatchType extends "prefix" ? ExecutionPolicyWildcardInstance : ExecutionPolicyExactInstance<Key>;
+/**
+ * Body of an execution policy declaration.
+ *
+ * When both `name` and `key` are omitted in the `defineWorkflowExecutionPolicies`
+ * builder, the property name is used verbatim for both (like
+ * `createWaitPoints`). Provide `name` when the property identifier is not
+ * valid execution policy grammar, and provide `key` when the runtime key
+ * prefix needs to differ from `name` (e.g. it needs `:` or `.`).
+ */
+interface ExecutionPolicyDefInput {
+  /** Overrides the property-name-derived `name`. 3-63 characters from `[a-z0-9-]`; must start and end with `[a-z0-9]`. */
+  name?: string;
+  /** Overrides the property-name-derived `key` prefix. Independent of `matchType` — both may be set together. */
+  key?: string;
+  /**
+   * `"exact"` (the default) matches a dispatch whose runtime key equals
+   * `key` (or the resolved `name`, if `key` is omitted). `"prefix"`
+   * registers `key` as a wildcard prefix — the platform appends a trailing
+   * `*`, and the resulting instance exposes `keyFor(suffix)` to build
+   * concrete dispatch keys instead of a directly-usable `key`.
+   */
+  matchType?: "exact" | "prefix";
+  /** Optional per-key concurrency cap. */
+  concurrencyPolicy?: ExecutionPolicyConcurrency;
+}
+/**
+ * Options for {@link defineWorkflowExecutionPolicies}, applying to every
+ * policy declared by the builder (not settable per policy).
+ */
+interface ExecutionPolicyGroupOptions {
+  /**
+   * Separator `keyFor(suffix)` inserts between a wildcard policy's declared
+   * `key` prefix and `suffix`. Defaults to `.`.
+   */
+  separator?: string;
+}
+//#endregion
+export { ExecutionPolicyConcurrency, ExecutionPolicyDefInput, ExecutionPolicyExactInstance, ExecutionPolicyGroupOptions, ExecutionPolicyInstance, ExecutionPolicyWildcardInstance, ResolvedExecutionPolicyInstance };

package/dist/configure/services/workflow/index.d.mts

@@ -0,0 +1,9 @@
+import { ExecutionPolicyConcurrency, ExecutionPolicyDefInput, ExecutionPolicyExactInstance, ExecutionPolicyGroupOptions, ExecutionPolicyInstance, ExecutionPolicyWildcardInstance, ResolvedExecutionPolicyInstance } from "./execution-policy.types.mjs";
+import { WorkflowServiceConfig, WorkflowServiceInput } from "../../config/types.mjs";
+import { ConcurrencyPolicy, RetryPolicy } from "../../../types/workflow.generated.mjs";
+import { WorkflowJob, WorkflowJobContext, createWorkflowJob } from "./job.mjs";
+import { Workflow, WorkflowConfig, createWorkflow } from "./workflow.mjs";
+import { defineWorkflowExecutionPolicies, defineWorkflowExecutionPolicy } from "./execution-policy.mjs";
+import { WaitPointInstance, createWaitPoint, createWaitPoints } from "./wait-point.mjs";
+import "./types.mjs";
+export { type ConcurrencyPolicy, type ExecutionPolicyConcurrency, type ExecutionPolicyDefInput, type ExecutionPolicyExactInstance, type ExecutionPolicyGroupOptions, type ExecutionPolicyInstance, type ExecutionPolicyWildcardInstance, type ResolvedExecutionPolicyInstance, type RetryPolicy, WaitPointInstance, Workflow, WorkflowConfig, WorkflowJob, WorkflowJobContext, type WorkflowServiceConfig, type WorkflowServiceInput, createWaitPoint, createWaitPoints, createWorkflow, createWorkflowJob, defineWorkflowExecutionPolicies, defineWorkflowExecutionPolicy };

package/dist/configure/services/workflow/job.d.mts

@@ -0,0 +1,92 @@
+import { TailorEnv, TailorPrincipal } from "../../../runtime/types.mjs";
+import { JsonCompatible, TypeLevelError } from "../../../types/helpers.mjs";
+import { ExecJobFunctionOptions } from "../../../runtime/workflow.mjs";
+//#region src/configure/services/workflow/job.d.ts
+/**
+ * Context object passed as the second argument to workflow job body functions.
+ */
+type WorkflowJobContext = {
+  env: TailorEnv;
+  invoker: TailorPrincipal | null;
+};
+/**
+ * The body function type for a workflow job.
+ * Resolves to the callable signature when `I` / `O` are JsonValue-compatible,
+ * or to a type-level error that surfaces at the `body:` property.
+ */
+type JobBody<I, O> = [null] extends [I] ? TypeLevelError<"Input cannot be null at the top level"> : [I] extends [undefined] ? [O] extends [JsonCompatible<O> | undefined | void] ? (input: I, context: WorkflowJobContext) => O | Promise<O> : TypeLevelError<"Output must be JsonValue-compatible (plain objects/arrays; no class instances or functions)"> : [undefined] extends [I] ? TypeLevelError<"Input cannot include undefined at the top level"> : [I] extends [JsonCompatible<I>] ? [O] extends [JsonCompatible<O> | undefined | void] ? (input: I, context: WorkflowJobContext) => O | Promise<O> : TypeLevelError<"Output must be JsonValue-compatible (plain objects/arrays; no class instances or functions)"> : TypeLevelError<"Input must be JsonValue-compatible (plain objects/arrays; no class instances or functions)">;
+/**
+ * WorkflowJob represents a job that can be started from a workflow.
+ *
+ * Type constraints:
+ * - Input: Must be JsonValue-compatible (plain objects/arrays; no class instances or functions) or undefined.
+ * - Output: Must be JsonValue-compatible (plain objects/arrays; no class instances or functions), undefined, or void.
+ * - Start returns `Awaited<Output>` as-is (no Promise or Jsonify transformation).
+ */
+interface WorkflowJob<Name extends string = string, Input = undefined, Output = undefined> {
+  name: Name;
+  /**
+   * Start this job with the given input and return the job's output value.
+   * Accepts an optional second argument to pass `executionPolicyKey` for
+   * platform-side concurrency enforcement.
+   * @example
+   * body: async (input) => {
+   *   const a = jobA.start({ id: input.id });
+   *   const b = jobB.start({ id: input.id }, {
+   *     executionPolicyKey: `tenant-api.${input.tenantId}`,
+   *   });
+   *   return { a, b };
+   * }
+   */
+  start: [Input] extends [undefined] ? (input?: undefined, options?: ExecJobFunctionOptions) => Awaited<Output> : (input: Input, options?: ExecJobFunctionOptions) => Awaited<Output>;
+  body: (input: Input, context: WorkflowJobContext) => Output | Promise<Output>;
+  publishEvents?: boolean;
+}
+interface CreateWorkflowJobConfig<Name extends string, I, O> {
+  readonly name: Name;
+  readonly body: JobBody<I, O>;
+  /**
+   * Enable publishing this job's execution events, letting executors with a
+   * `workflowJobExecution*` trigger observe them.
+   *
+   * Left unset, it is enabled automatically when an executor in the project
+   * subscribes to the job execution events of a workflow that runs this job.
+   */
+  readonly publishEvents?: boolean;
+}
+/**
+ * Create a workflow job definition.
+ *
+ * All jobs must be named exports from the workflow file.
+ * Job names must be unique across the entire project.
+ *
+ * Input and output must be JsonValue-compatible (primitives, plain objects, arrays).
+ * Functions and objects with a `toJSON` method are rejected at the type level;
+ * class instances exposing methods are rejected via the property walk.
+ * @param config - Job configuration with name and body function.
+ * @param config.name - Unique job name across the project.
+ * @param config.body - Function that processes the job input.
+ * @returns A WorkflowJob that can be started from other jobs.
+ * @example
+ * // Simple job with async body:
+ * export const fetchData = createWorkflowJob({
+ *   name: "fetch-data",
+ *   body: async (input: { id: string }) => {
+ *     const db = getDB("tailordb");
+ *     return await db.selectFrom("Table").selectAll().where("id", "=", input.id).executeTakeFirst();
+ *   },
+ * });
+ * @example
+ * // Orchestrator job that fans out to other jobs.
+ * export const orchestrate = createWorkflowJob({
+ *   name: "orchestrate",
+ *   body: (input: { orderId: string }) => {
+ *     const inventory = checkInventory.start({ orderId: input.orderId });
+ *     const payment = processPayment.start({ orderId: input.orderId });
+ *     return { inventory, payment };
+ *   },
+ * });
+ */
+declare function createWorkflowJob<const Name extends string, I = undefined, O = undefined>(config: CreateWorkflowJobConfig<Name, I, O>): WorkflowJob<Name, I, Awaited<O>>;
+//#endregion
+export { WorkflowJob, WorkflowJobContext, createWorkflowJob };

package/dist/configure/services/workflow/types.d.mts

@@ -0,0 +1,2 @@
+import { WorkflowServiceConfig, WorkflowServiceInput } from "../../config/types.mjs";
+export type { WorkflowServiceConfig, WorkflowServiceInput };

package/dist/configure/services/workflow/wait-point.d.mts

@@ -0,0 +1,72 @@
+import { JsonCompatible, TypeLevelError } from "../../../types/helpers.mjs";
+//#region src/configure/services/workflow/wait-point.d.ts
+/**
+ * A single wait point instance with typed `.wait()` and `.resolve()` methods.
+ *
+ * - `.wait(payload?)` suspends execution until resolved. Returns the result from `.resolve()`.
+ * - `.resolve(executionId, callback)` resumes a suspended execution.
+ *
+ * Both `Payload` and `Result` must be JsonValue-compatible (primitives, plain objects, arrays).
+ * Functions and objects with a `toJSON` method are rejected at the type level.
+ */
+interface WaitPointInstance<Payload = undefined, Result = undefined> {
+  wait: [Payload] extends [undefined] ? () => Promise<Result> : (payload: Payload) => Promise<Result>;
+  resolve: (executionId: string, callback: (payload: [Payload] extends [undefined] ? undefined : Payload) => Result | Promise<Result>) => Promise<void>;
+}
+/**
+ * The type produced by `define<Payload, Result>()` / `createWaitPoint<Payload, Result>(key)`.
+ * Resolves to `WaitPointInstance<Payload, Result>` when both types are JsonValue-compatible,
+ * or to a type-level error that surfaces at the call site.
+ */
+type WaitPointDef<Payload, Result> = [null] extends [Payload] ? TypeLevelError<"Payload cannot be null at the top level"> : [undefined] extends [Result] ? TypeLevelError<"Result cannot be (or include) undefined (resolve callback must return a value)"> : [Payload] extends [undefined] ? [Result] extends [JsonCompatible<Result>] ? WaitPointInstance<Payload, Result> : TypeLevelError<"Result must be JsonValue-compatible (plain objects/arrays; no class instances or functions)"> : [undefined] extends [Payload] ? TypeLevelError<"Payload cannot include undefined at the top level"> : [Payload] extends [JsonCompatible<Payload>] ? [Result] extends [JsonCompatible<Result>] ? WaitPointInstance<Payload, Result> : TypeLevelError<"Result must be JsonValue-compatible (plain objects/arrays; no class instances or functions)"> : TypeLevelError<"Payload must be JsonValue-compatible (plain objects/arrays; no class instances or functions)">;
+/**
+ * The `define` function passed to the `createWaitPoints` builder callback.
+ * Returns an actual WaitPointInstance (not a phantom marker) so that the
+ * builder's return type can flow through as-is, preserving JSDoc comments
+ * on each property for IDE autocompletion.
+ *
+ * JSON validation is encoded in the return type rather than in type-parameter
+ * constraints, because tsgo rejects self-referential constraints like
+ * `Payload extends JsonCompatible<Payload>` as circular.
+ */
+type DefineFn = <Payload = undefined, Result = undefined>() => WaitPointDef<Payload, Result>;
+/**
+ * Create a single typed wait point with an explicit key.
+ *
+ * `Payload` and `Result` must be JsonValue-compatible.
+ * Functions and objects with a `toJSON` method are rejected at the type level;
+ * class instances exposing methods are rejected via the property walk.
+ * @param key - The wait point key used to match wait and resolve calls
+ * @returns A WaitPointInstance with typed `.wait()` and `.resolve()` methods
+ * @example
+ * export const approval = createWaitPoint<{ message: string }, { approved: boolean }>("approval");
+ *
+ * await approval.wait({ message: "Please approve" });
+ */
+declare function createWaitPoint<Payload = undefined, Result = undefined>(key: string): WaitPointDef<Payload, Result>;
+/**
+ * Create a group of typed wait points for human-in-the-loop workflows.
+ * Property names become the wait point keys.
+ *
+ * The return type is the same as the builder's return type, so JSDoc on each
+ * property is preserved and visible in IDE autocompletion.
+ *
+ * `Payload` and `Result` must be JsonValue-compatible.
+ * Functions and objects with a `toJSON` method are rejected at the type level;
+ * class instances exposing methods are rejected via the property walk.
+ * @param builder - Callback that receives a `define` factory and returns an object of wait points
+ * @returns The same object returned by the builder (with correct keys set on each instance)
+ * @example
+ * export const waitPoints = createWaitPoints(define => ({
+ *   // Preceding JSDoc on this property is shown in IDE autocompletion
+ *   approval: define<{ message: string }, { approved: boolean }>(),
+ * }));
+ *
+ * // IDE shows the JSDoc when typing `waitPoints.`
+ * await waitPoints.approval.wait({ message: "Please approve" });
+ *
+ * // For 2-level access, use destructured export with JSDoc attached to the export itself.
+ */
+declare function createWaitPoints<T extends Record<string, WaitPointInstance<any, any>>>(builder: (define: DefineFn) => T): T;
+//#endregion
+export { WaitPointInstance, createWaitPoint, createWaitPoints };

package/dist/configure/services/workflow/workflow.d.mts

@@ -0,0 +1,66 @@
+import { MachineUserName } from "../auth/types.mjs";
+import { ConcurrencyPolicy, RetryPolicy } from "../../../types/workflow.generated.mjs";
+import "../../types/machine-user.mjs";
+import { WorkflowJob } from "./job.mjs";
+//#region src/configure/services/workflow/workflow.d.ts
+interface WorkflowConfig<Job extends WorkflowJob<any, any, any> = WorkflowJob<any, any, any>> {
+  name: string;
+  mainJob: Job;
+  retryPolicy?: RetryPolicy;
+  concurrencyPolicy?: ConcurrencyPolicy;
+  publishEvents?: boolean;
+}
+interface Workflow<Job extends WorkflowJob<any, any, any> = WorkflowJob<any, any, any>> {
+  name: string;
+  mainJob: Job;
+  retryPolicy?: RetryPolicy;
+  concurrencyPolicy?: ConcurrencyPolicy;
+  publishEvents?: boolean;
+  start: [Parameters<Job["start"]>[0]] extends [undefined] ? (args?: undefined, options?: {
+    invoker: MachineUserName;
+  }) => Promise<string> : (args: Parameters<Job["start"]>[0], options?: {
+    invoker: MachineUserName;
+  }) => Promise<string>;
+}
+interface WorkflowDefinition<Job extends WorkflowJob<any, any, any>> {
+  name: string;
+  mainJob: Job;
+  retryPolicy?: RetryPolicy;
+  concurrencyPolicy?: ConcurrencyPolicy;
+  /**
+   * Enable publishing this workflow's execution events, letting executors with
+   * a `workflowExecution*` trigger observe them.
+   *
+   * Left unset, it is enabled automatically when an executor in the project
+   * subscribes to this workflow's execution events.
+   */
+  publishEvents?: boolean;
+}
+/**
+ * Create a workflow definition that can be started via the Tailor SDK.
+ * In production, the bundler rewrites `.start()` calls into direct platform workflow calls.
+ *
+ * The workflow MUST be the default export of the file.
+ * All jobs referenced by the workflow MUST be named exports.
+ * @template Job
+ * @param config - Workflow configuration
+ * @returns Defined workflow
+ * @example
+ * export const fetchData = createWorkflowJob({ name: "fetch-data", body: async (input: { id: string }) => ({ id: input.id }) });
+ * export const processData = createWorkflowJob({
+ *   name: "process-data",
+ *   body: (input: { id: string }) => {
+ *     const data = fetchData.start({ id: input.id });
+ *     return { data };
+ *   },
+ * });
+ *
+ * // Workflow must be default export; mainJob is the entry point
+ * export default createWorkflow({
+ *   name: "data-processing",
+ *   mainJob: processData,
+ * });
+ */
+declare function createWorkflow<Job extends WorkflowJob<any, any, any>>(config: WorkflowDefinition<Job>): Workflow<Job>;
+//#endregion
+export { type ConcurrencyPolicy, type RetryPolicy, Workflow, WorkflowConfig, createWorkflow };

package/dist/configure/types/aigateway-name.d.mts

@@ -0,0 +1,12 @@
+//#region src/configure/types/aigateway-name.d.ts
+interface AIGatewayNameRegistry {}
+/**
+ * AI Gateway name.
+ *
+ * When `tailor.d.ts` is generated (via `tailor deploy`/`generate`), this is narrowed
+ * to the union of AI Gateway names defined via `defineAIGateway()`. Falls back to
+ * `string` before the first generate run.
+ */
+type AIGatewayName = keyof AIGatewayNameRegistry extends never ? string : keyof AIGatewayNameRegistry & string;
+//#endregion
+export { AIGatewayName, AIGatewayNameRegistry };

package/dist/configure/types/connection-name.d.mts

@@ -0,0 +1,12 @@
+//#region src/configure/types/connection-name.d.ts
+interface ConnectionNameRegistry {}
+/**
+ * Auth connection name.
+ *
+ * When `tailor.d.ts` is generated (via `tailor deploy`/`generate`), this is narrowed
+ * to the union of connection names defined in `defineAuth()`'s `connections`. Falls back
+ * to `string` before the first generate run.
+ */
+type ConnectionName = keyof ConnectionNameRegistry extends never ? string : keyof ConnectionNameRegistry & string;
+//#endregion
+export { ConnectionName, ConnectionNameRegistry };

package/dist/configure/types/field.d.mts

@@ -0,0 +1,8 @@
+import { EnumValue } from "./field.types.mjs";
+//#region src/configure/types/field.d.ts
+type AllowedValues = readonly [string | EnumValue, ...(string | EnumValue)[]];
+type AllowedValuesOutput<V extends AllowedValues> = V[number] extends (infer T) ? T extends string ? T : T extends {
+  value: infer K;
+} ? K : never : never;
+//#endregion
+export { AllowedValues, AllowedValuesOutput };