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

package/dist/configure/index.mjs

@@ -1,18 +1,199 @@
-import { t as t$1 } from "../types-B2RpYyA_.mjs";
+import { i as parseInternal, n as mapAllowedValues, t as db } from "../schema--xYWRGfe.mjs";
 import { t as brandValue } from "../brand-Eo4pLXPJ.mjs";
-import { t as db } from "../schema-BhkpP5Hw.mjs";
-import { r as dispatchTriggerWorkflow } from "../registry-DdsYlL_P.mjs";
-import { t as WORKFLOW_TEST_ENV_KEY } from "../test-env-key-D9kM6ETE.mjs";
-import { t as createWorkflowJob } from "../job-fuc3j1Ma.mjs";
+import { a as registerJob, n as dispatchStartJob, r as dispatchStartWorkflow } from "../registry-BIGVUrMB.mjs";
+import { i as withWorkflowTestInvoker } from "../test-env-key-D7UkZp99.mjs";
 
-//#region src/configure/user.ts
-/** Represents an unauthenticated user in the Tailor platform. */
-const unauthenticatedTailorUser = {
-	id: "00000000-0000-0000-0000-000000000000",
-	type: "",
-	workspaceId: "00000000-0000-0000-0000-000000000000",
-	attributes: null,
-	attributeList: []
+//#region src/configure/types/type.ts
+function createTailorField(type, options, fields, values, metadata) {
+	const _metadata = metadata ? {
+		...metadata,
+		...metadata.allowedValues && { allowedValues: metadata.allowedValues.map((v) => ({ ...v })) },
+		...metadata.validate && { validate: metadata.validate.map((v) => Array.isArray(v) ? [...v] : v) }
+	} : { required: true };
+	if (!metadata) {
+		if (options) {
+			if (options.optional === true) _metadata.required = false;
+			if (options.array === true) _metadata.array = true;
+		}
+		if (values) _metadata.allowedValues = mapAllowedValues(values);
+	}
+	function parseInternal$1(args) {
+		return parseInternal({
+			...args,
+			field
+		});
+	}
+	/**
+	* Clone the field and apply metadata updates to the clone.
+	* The original instance is never mutated, so a field shared across places
+	* cannot leak metadata between them.
+	* @param metadataUpdates - Metadata properties to overwrite on the clone
+	* @returns A new field with the updated metadata
+	*/
+	function cloneWith(metadataUpdates) {
+		const cloned = field.clone();
+		Object.assign(cloned._metadata, metadataUpdates);
+		return cloned;
+	}
+	const field = {
+		type,
+		fields: fields ?? {},
+		_defined: void 0,
+		_output: void 0,
+		_metadata,
+		get metadata() {
+			return { ...this._metadata };
+		},
+		description(description) {
+			return cloneWith({ description });
+		},
+		typeName(typeName) {
+			return cloneWith({ typeName });
+		},
+		validate(...validateInputs) {
+			return cloneWith({ validate: validateInputs });
+		},
+		parse(args) {
+			return parseInternal$1({
+				value: args.value,
+				data: args.data,
+				invoker: args.invoker,
+				pathArray: []
+			});
+		},
+		clone() {
+			let clonedFields = fields;
+			if (fields) {
+				const cloned = {};
+				for (const [key, nestedField] of Object.entries(fields)) cloned[key] = nestedField.clone();
+				clonedFields = cloned;
+			}
+			return createTailorField(type, options, clonedFields, values, this._metadata);
+		}
+	};
+	return field;
+}
+/**
+* Create a UUID field for resolver input/output.
+* @param options - Field configuration options
+* @returns A UUID field
+* @example t.uuid()
+*/
+function uuid(options) {
+	return createTailorField("uuid", options);
+}
+/**
+* Create a string field for resolver input/output.
+* @param options - Field configuration options
+* @returns A string field
+* @example t.string()
+* @example t.string({ optional: true })
+* @example t.string({ array: true })
+*/
+function string(options) {
+	return createTailorField("string", options);
+}
+/**
+* Create a boolean field for resolver input/output.
+* @param options - Field configuration options
+* @returns A boolean field
+* @example t.bool()
+*/
+function bool(options) {
+	return createTailorField("boolean", options);
+}
+/**
+* Create an integer field for resolver input/output.
+* @param options - Field configuration options
+* @returns An integer field
+* @example t.int()
+*/
+function int(options) {
+	return createTailorField("integer", options);
+}
+/**
+* Create a float field for resolver input/output.
+* @param options - Field configuration options
+* @returns A float field
+* @example t.float()
+*/
+function float(options) {
+	return createTailorField("float", options);
+}
+/**
+* Create a decimal field for resolver input/output (stored as string for precision).
+* @param options - Field configuration options
+* @returns A decimal field
+* @example t.decimal()
+* @example t.decimal({ optional: true })
+*/
+function decimal(options) {
+	return createTailorField("decimal", options);
+}
+/**
+* Create a date field for resolver input/output.
+* @param options - Field configuration options
+* @returns A date field
+* @example t.date()
+*/
+function date(options) {
+	return createTailorField("date", options);
+}
+/**
+* Create a datetime field for resolver input/output.
+* @param options - Field configuration options
+* @returns A datetime field
+* @example t.datetime()
+*/
+function datetime(options) {
+	return createTailorField("datetime", options);
+}
+/**
+* Create a time field for resolver input/output.
+* @param options - Field configuration options
+* @returns A time field
+* @example t.time()
+*/
+function time(options) {
+	return createTailorField("time", options);
+}
+/**
+* Create an enum field for resolver input/output.
+* @param values - Array of allowed string values
+* @param options - Field configuration options
+* @returns An enum field
+* @example t.enum(["active", "inactive"])
+*/
+function _enum(values, options) {
+	return createTailorField("enum", options, void 0, values);
+}
+/**
+* Create a nested object field for resolver input/output.
+* @param fields - Record of field definitions
+* @param options - Field options (optional, array)
+* @returns A nested object field
+* @example
+* // Single object:
+* output: t.object({ name: t.string(), email: t.string() })
+* @example
+* // Array of objects:
+* items: t.object({ name: t.string() }, { array: true })
+*/
+function object(fields, options) {
+	return createTailorField("nested", options, fields);
+}
+const t$1 = {
+	uuid,
+	string,
+	bool,
+	int,
+	float,
+	decimal,
+	date,
+	datetime,
+	time,
+	enum: _enum,
+	object
 };
 
 //#endregion
@@ -21,10 +202,7 @@ const unauthenticatedTailorUser = {
 function defineAuth(name, config) {
 	return {
 		...config,
-		name,
-		getConnectionToken(connectionName) {
-			return tailor.authconnection.getConnectionToken(connectionName);
-		}
+		name
 	};
 }
 
@@ -74,7 +252,7 @@ const unsafeAllowAllGqlPermission = [{
 * Create a resolver definition for the Tailor SDK.
 *
 * The `body` function receives a context with `input` (typed from `config.input`),
-* `user`, `invoker` (reflects `authInvoker` delegation), and `env`.
+* `caller`, `invoker` (reflects configured machine-user delegation), and `env`.
 * The return value of `body` must match the `output` type.
 *
 * `output` accepts either a single TailorField (e.g. `t.string()`) or a
@@ -84,6 +262,14 @@ const unsafeAllowAllGqlPermission = [{
 * If not specified, this is automatically set to true when an executor uses this resolver
 * with `resolverExecutedTrigger`. If explicitly set to false while an executor uses this
 * resolver, an error will be thrown during apply.
+*
+* `permission` declares the resolver's access requirement, checked against `context.user` (the
+* original caller, unaffected by `authInvoker`) before `body` runs. Omitted (default):
+* unchanged, anonymous callers can reach the resolver. `"allowAnonymous"`: explicitly documents
+* that anonymous callers are allowed. An array of `{ conditions, permit }` policies (in the same
+* style as TailorDB's `.permission()`) rejects non-matching callers: at least one `permit: true`
+* policy is required (denied unless it matches), and a matching `permit: false` policy always
+* overrides that grant.
 * @template Input
 * @template Output
 * @param config - Resolver configuration
@@ -94,10 +280,11 @@ const unsafeAllowAllGqlPermission = [{
 * export default createResolver({
 *   name: "getUser",
 *   operation: "query",
+*   permission: [{ conditions: [[{ user: "_loggedIn" }, "=", true]], permit: true }],
 *   input: {
 *     id: t.string(),
 *   },
-*   body: async ({ input, user }) => {
+*   body: async ({ input, caller }) => {
 *     const db = getDB("tailordb");
 *     const result = await db.selectFrom("User").selectAll().where("id", "=", input.id).executeTakeFirst();
 *     return { name: result?.name ?? "", email: result?.email ?? "" };
@@ -328,6 +515,173 @@ function authAccessTokenTrigger(options) {
 		__args: {}
 	};
 }
+const workflowExecutionEventMap = {
+	started: "workflow.workflow_execution.started",
+	completed: "workflow.workflow_execution.completed",
+	retried: "workflow.workflow_execution.retried",
+	resumed: "workflow.workflow_execution.resumed",
+	wait_started: "workflow.workflow_execution.wait_started",
+	wait_resolved: "workflow.workflow_execution.wait_resolved"
+};
+function workflowExecutionTriggerConfig(events, options) {
+	return {
+		kind: "workflowExecution",
+		events,
+		workflowName: options.workflow.name,
+		condition: options.condition,
+		__args: {}
+	};
+}
+/**
+* Create a trigger that fires when a workflow execution starts running.
+* @param options - Trigger options
+* @param options.workflow - Workflow to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow execution started trigger
+*/
+function workflowExecutionStartedTrigger(options) {
+	return workflowExecutionTriggerConfig(["workflow.workflow_execution.started"], options);
+}
+/**
+* Create a trigger that fires when a workflow execution succeeds or fails.
+* @param options - Trigger options
+* @param options.workflow - Workflow to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow execution completed trigger
+*/
+function workflowExecutionCompletedTrigger(options) {
+	return workflowExecutionTriggerConfig(["workflow.workflow_execution.completed"], options);
+}
+/**
+* Create a trigger that fires when a workflow execution is retried by its retry policy.
+* @param options - Trigger options
+* @param options.workflow - Workflow to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow execution retried trigger
+*/
+function workflowExecutionRetriedTrigger(options) {
+	return workflowExecutionTriggerConfig(["workflow.workflow_execution.retried"], options);
+}
+/**
+* Create a trigger that fires when a failed workflow execution is manually resumed.
+* @param options - Trigger options
+* @param options.workflow - Workflow to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow execution resumed trigger
+*/
+function workflowExecutionResumedTrigger(options) {
+	return workflowExecutionTriggerConfig(["workflow.workflow_execution.resumed"], options);
+}
+/**
+* Create a trigger that fires when a workflow execution starts waiting on a wait point.
+* @param options - Trigger options
+* @param options.workflow - Workflow to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow execution wait started trigger
+*/
+function workflowExecutionWaitStartedTrigger(options) {
+	return workflowExecutionTriggerConfig(["workflow.workflow_execution.wait_started"], options);
+}
+/**
+* Create a trigger that fires when a waiting workflow execution is released.
+* @param options - Trigger options
+* @param options.workflow - Workflow to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow execution wait resolved trigger
+*/
+function workflowExecutionWaitResolvedTrigger(options) {
+	return workflowExecutionTriggerConfig(["workflow.workflow_execution.wait_resolved"], options);
+}
+/**
+* Create a trigger that fires on multiple workflow execution event types.
+* @template K
+* @param options - Trigger options with events array
+* @param options.events - Workflow execution event kinds to subscribe to
+* @param options.workflow - Workflow to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow execution trigger
+*/
+function workflowExecutionTrigger(options) {
+	const { events, workflow, condition } = options;
+	return workflowExecutionTriggerConfig(events.map((k) => workflowExecutionEventMap[k]), {
+		workflow,
+		condition
+	});
+}
+const workflowJobExecutionEventMap = {
+	started: "workflow.workflow_execution.job_execution.started",
+	completed: "workflow.workflow_execution.job_execution.completed",
+	wait_started: "workflow.workflow_execution.job_execution.wait_started",
+	wait_resolved: "workflow.workflow_execution.job_execution.wait_resolved"
+};
+function workflowJobExecutionTriggerConfig(events, options) {
+	return {
+		kind: "workflowJobExecution",
+		events,
+		workflowName: options.workflow.name,
+		condition: options.condition,
+		__args: {}
+	};
+}
+/**
+* Create a trigger that fires when a job inside a workflow starts running.
+* @param options - Trigger options
+* @param options.workflow - Workflow whose job executions to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow job execution started trigger
+*/
+function workflowJobExecutionStartedTrigger(options) {
+	return workflowJobExecutionTriggerConfig(["workflow.workflow_execution.job_execution.started"], options);
+}
+/**
+* Create a trigger that fires when a job inside a workflow succeeds or fails.
+*
+* A job released from a wait point reports `wait_resolved` instead of
+* `completed`; subscribe to both to observe every way a job can end.
+* @param options - Trigger options
+* @param options.workflow - Workflow whose job executions to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow job execution completed trigger
+*/
+function workflowJobExecutionCompletedTrigger(options) {
+	return workflowJobExecutionTriggerConfig(["workflow.workflow_execution.job_execution.completed"], options);
+}
+/**
+* Create a trigger that fires when a job inside a workflow starts waiting on a wait point.
+* @param options - Trigger options
+* @param options.workflow - Workflow whose job executions to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow job execution wait started trigger
+*/
+function workflowJobExecutionWaitStartedTrigger(options) {
+	return workflowJobExecutionTriggerConfig(["workflow.workflow_execution.job_execution.wait_started"], options);
+}
+/**
+* Create a trigger that fires when a waiting job inside a workflow is released.
+* @param options - Trigger options
+* @param options.workflow - Workflow whose job executions to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow job execution wait resolved trigger
+*/
+function workflowJobExecutionWaitResolvedTrigger(options) {
+	return workflowJobExecutionTriggerConfig(["workflow.workflow_execution.job_execution.wait_resolved"], options);
+}
+/**
+* Create a trigger that fires on multiple workflow job execution event types.
+* @template K
+* @param options - Trigger options with events array
+* @param options.events - Workflow job execution event kinds to subscribe to
+* @param options.workflow - Workflow whose job executions to subscribe to
+* @param options.condition - Condition function to filter events
+* @returns Workflow job execution trigger
+*/
+function workflowJobExecutionTrigger(options) {
+	const { events, workflow, condition } = options;
+	return workflowJobExecutionTriggerConfig(events.map((k) => workflowJobExecutionEventMap[k]), {
+		workflow,
+		condition
+	});
+}
 
 //#endregion
 //#region src/configure/services/executor/trigger/schedule.ts
@@ -364,6 +718,166 @@ function incomingWebhookTrigger(options) {
 	};
 }
 
+//#endregion
+//#region src/configure/services/workflow/execution-policy.ts
+const EXECUTION_POLICY_EXACT_KEY_REGEX = /^[a-z0-9][a-z0-9_:.-]{0,62}[a-z0-9]$/;
+function createExecutionPolicyInstance(initialName, initialKey, concurrencyPolicy, matchType, separator, allowNameSetter, allowKeySetter) {
+	const isPrefix = matchType === "prefix";
+	const raw = {
+		name: initialName,
+		key: initialKey,
+		matchType,
+		...concurrencyPolicy && { concurrencyPolicy },
+		...isPrefix && { keyFor: (suffix) => {
+			const key = `${raw.key}${separator}${suffix}`;
+			if (!EXECUTION_POLICY_EXACT_KEY_REGEX.test(key)) throw new Error(`Invalid execution policy key "${key}" built by keyFor("${suffix}"): must match [a-z0-9_:.-] (2-64 chars; must start and end with [a-z0-9]).`);
+			return key;
+		} }
+	};
+	return {
+		instance: brandValue(raw, "execution-policy"),
+		setName: allowNameSetter ? (n) => {
+			raw.name = n;
+		} : void 0,
+		setKey: allowKeySetter ? (k) => {
+			raw.key = k;
+		} : void 0
+	};
+}
+/**
+* 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>"
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function defineWorkflowExecutionPolicy(name, def) {
+	return createExecutionPolicyInstance(name, def?.key ?? name, def?.concurrencyPolicy, def?.matchType ?? "exact", def?.separator ?? ".", false, false).instance;
+}
+/**
+* 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),
+* });
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function defineWorkflowExecutionPolicies(builder, options) {
+	const separator = options?.separator ?? ".";
+	const nameSetters = /* @__PURE__ */ new Map();
+	const keySetters = /* @__PURE__ */ new Map();
+	const define = (def) => {
+		const explicitName = def?.name;
+		const explicitKey = def?.key;
+		const { instance, setName, setKey } = createExecutionPolicyInstance(explicitName ?? "__pending__", explicitKey ?? explicitName ?? "__pending__", def?.concurrencyPolicy, def?.matchType ?? "exact", separator, explicitName === void 0, explicitKey === void 0 && explicitName === void 0);
+		if (setName) nameSetters.set(instance, setName);
+		if (setKey) keySetters.set(instance, setKey);
+		return instance;
+	};
+	const result = builder(define);
+	for (const propName of Object.keys(result)) {
+		const instance = result[propName];
+		nameSetters.get(instance)?.(propName);
+		keySetters.get(instance)?.(propName);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/configure/services/workflow/job.ts
+/**
+* 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 };
+*   },
+* });
+*/
+function createWorkflowJob(config) {
+	const userBody = config.body;
+	const body = process.env.__TAILOR_PLATFORM_BUNDLE ? userBody : (input, context) => withWorkflowTestInvoker(context.invoker, () => userBody(input, context));
+	if (!process.env.__TAILOR_PLATFORM_BUNDLE) registerJob(config.name, body);
+	const start = process.env.__TAILOR_PLATFORM_BUNDLE ? () => {
+		throw new Error("This workflow job's .start() is rewritten at build time and is unavailable in the bundle");
+	} : function start(args, options) {
+		return arguments.length >= 2 ? dispatchStartJob(config.name, args, options) : dispatchStartJob(config.name, args);
+	};
+	return brandValue({
+		name: config.name,
+		start,
+		body,
+		...config.publishEvents !== void 0 ? { publishEvents: config.publishEvents } : {}
+	}, "workflow-job");
+}
+
 //#endregion
 //#region src/configure/services/workflow/wait-point.ts
 function getPlatformWorkflow() {
@@ -395,7 +909,7 @@ function createWaitPointInstance(initialKey) {
 	};
 }
 /**
-* Define a single typed wait point with an explicit key.
+* 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;
@@ -403,16 +917,16 @@ function createWaitPointInstance(initialKey) {
 * @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 = defineWaitPoint<{ message: string }, { approved: boolean }>("approval");
+* export const approval = createWaitPoint<{ message: string }, { approved: boolean }>("approval");
 *
 * await approval.wait({ message: "Please approve" });
 */
 /* @__NO_SIDE_EFFECTS__ */
-function defineWaitPoint(key) {
+function createWaitPoint(key) {
 	return createWaitPointInstance(key).instance;
 }
 /**
-* Define a group of typed wait points for human-in-the-loop workflows.
+* 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
@@ -424,7 +938,7 @@ function defineWaitPoint(key) {
 * @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 = defineWaitPoints(define => ({
+* export const waitPoints = createWaitPoints(define => ({
 *   // Preceding JSDoc on this property is shown in IDE autocompletion
 *   approval: define<{ message: string }, { approved: boolean }>(),
 * }));
@@ -435,7 +949,7 @@ function defineWaitPoint(key) {
 * // For 2-level access, use destructured export with JSDoc attached to the export itself.
 */
 /* @__NO_SIDE_EFFECTS__ */
-function defineWaitPoints(builder) {
+function createWaitPoints(builder) {
 	const setters = /* @__PURE__ */ new Map();
 	const define = (() => {
 		const { instance, setKey } = createWaitPointInstance("__pending__");
@@ -450,8 +964,8 @@ function defineWaitPoints(builder) {
 //#endregion
 //#region src/configure/services/workflow/workflow.ts
 /**
-* Create a workflow definition that can be triggered via the Tailor SDK.
-* In production, bundler transforms .trigger() calls to tailor.workflow.triggerWorkflow().
+* 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.
@@ -463,7 +977,7 @@ function defineWaitPoints(builder) {
 * export const processData = createWorkflowJob({
 *   name: "process-data",
 *   body: (input: { id: string }) => {
-*     const data = fetchData.trigger({ id: input.id });
+*     const data = fetchData.start({ id: input.id });
 *     return { data };
 *   },
 * });
@@ -477,9 +991,11 @@ function defineWaitPoints(builder) {
 function createWorkflow(config) {
 	return brandValue({
 		...config,
-		trigger: process.env.TAILOR_PLATFORM_BUNDLE ? async () => {
-			throw new Error("workflow.trigger() is rewritten at build time and unavailable in the bundle");
-		} : async (args, options) => await dispatchTriggerWorkflow(config.name, args, options)
+		start: process.env.__TAILOR_PLATFORM_BUNDLE ? async () => {
+			throw new Error("workflow.start() is rewritten at build time and unavailable in the bundle");
+		} : async function start(args, options) {
+			return arguments.length >= 2 ? await dispatchStartWorkflow(config.name, args, options) : await dispatchStartWorkflow(config.name, args);
+		}
 	}, "workflow");
 }
 
@@ -547,6 +1063,10 @@ const unsafeAllowAllIdPPermission = {
 	sendPasswordResetEmail: [{
 		conditions: [],
 		permit: true
+	}],
+	unenrollMfa: [{
+		conditions: [],
+		permit: true
 	}]
 };
 
@@ -609,12 +1129,14 @@ function defineSecretManager(config, options) {
 * Files are discovered via the `httpAdapter.files` glob in `defineConfig()`.
 *
 * `input` is an object keyed by lowercase HTTP method (`get`, `post`, `put`,
-* `patch`, `delete`). At least one method must be declared; the methods the
+* `patch`, `delete`). Each handler can return a GraphQL query string or a
+* typed document node. At least one method must be declared; the methods the
 * adapter serves are derived from these keys.
 *
-* `output` is optional and shared across all methods. If you need different
-* response shapes per method, discriminate inside `output` based on the
-* GraphQL response shape.
+* `output` is optional and shared across all methods. If `input` returns typed
+* document nodes, `output` receives the corresponding result type as
+* `resp.data`. If you need different response shapes per method, discriminate
+* inside `output` based on the GraphQL response shape.
 *
 * Each handler runs server-side and must be synchronous: Node APIs, `fetch`,
 * `async`/`await`, Promises, and top-level `await` are not available.
@@ -675,5 +1197,5 @@ function definePlugins(...configs) {
 const t = t$1;
 
 //#endregion
-export { WORKFLOW_TEST_ENV_KEY, authAccessTokenIssuedTrigger, authAccessTokenRefreshedTrigger, authAccessTokenRevokedTrigger, authAccessTokenTrigger, createExecutor, createHttpAdapter, createResolver, createWorkflow, createWorkflowJob, db, defineAIGateway, defineAuth, defineConfig, defineIdp, definePlugins, defineSecretManager, defineStaticWebSite, defineWaitPoint, defineWaitPoints, idpUserCreatedTrigger, idpUserDeletedTrigger, idpUserTrigger, idpUserUpdatedTrigger, incomingWebhookTrigger, recordCreatedTrigger, recordDeletedTrigger, recordTrigger, recordUpdatedTrigger, resolverExecutedTrigger, scheduleTrigger, t, unauthenticatedTailorUser, unsafeAllowAllGqlPermission, unsafeAllowAllIdPPermission, unsafeAllowAllTypePermission };
+export { authAccessTokenIssuedTrigger, authAccessTokenRefreshedTrigger, authAccessTokenRevokedTrigger, authAccessTokenTrigger, createExecutor, createHttpAdapter, createResolver, createWaitPoint, createWaitPoints, createWorkflow, createWorkflowJob, db, defineAIGateway, defineAuth, defineConfig, defineIdp, definePlugins, defineSecretManager, defineStaticWebSite, defineWorkflowExecutionPolicies, defineWorkflowExecutionPolicy, idpUserCreatedTrigger, idpUserDeletedTrigger, idpUserTrigger, idpUserUpdatedTrigger, incomingWebhookTrigger, recordCreatedTrigger, recordDeletedTrigger, recordTrigger, recordUpdatedTrigger, resolverExecutedTrigger, scheduleTrigger, t, unsafeAllowAllGqlPermission, unsafeAllowAllIdPPermission, unsafeAllowAllTypePermission, workflowExecutionCompletedTrigger, workflowExecutionResumedTrigger, workflowExecutionRetriedTrigger, workflowExecutionStartedTrigger, workflowExecutionTrigger, workflowExecutionWaitResolvedTrigger, workflowExecutionWaitStartedTrigger, workflowJobExecutionCompletedTrigger, workflowJobExecutionStartedTrigger, workflowJobExecutionTrigger, workflowJobExecutionWaitResolvedTrigger, workflowJobExecutionWaitStartedTrigger };
 //# sourceMappingURL=index.mjs.map