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

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

@@ -6,7 +6,7 @@ import { WaitPointInstance } from "../../configure/services/workflow/wait-point.
 import { Mock } from "vitest";
 //#region src/vitest/mocks/workflow.d.ts
 type JobHandler = (jobName: string, args: unknown, options?: StartJobFunctionOptions) => unknown;
-type TriggerHandlerFn = (workflowName: string, args: unknown, options?: StartWorkflowOptions) => string;
+type StartHandlerFn = (workflowName: string, args: unknown, options?: StartWorkflowOptions) => string;
 type ResumeHandlerFn = (executionId: string) => string;
 type WaitHandlerFn = (key: string, payload: unknown) => unknown;
 type ResolveHandler = (executionId: string, key: string, callback: (payload: unknown) => unknown) => unknown | Promise<unknown>;
@@ -14,7 +14,7 @@ type SetWaitHandler = {
   (handler: WaitHandlerFn): void;
   (handler: unknown): void;
 };
-interface TriggeredJob {
+interface StartedJob {
   jobName: string;
   args: unknown;
   options?: StartJobFunctionOptions;
@@ -23,17 +23,12 @@ type WaitPayload<Payload> = [Payload] extends [undefined] ? undefined : Payload;
 /**
  * Acquire a disposable mock for workflow operations (`tailor.workflow`).
  * Restored on dispose.
- *
- * Canonical names (`startWorkflow`, `startJobFunction`, `resumeWorkflowExecution`)
- * and their frozen aliases (`triggerWorkflow`, `triggerJobFunction`, `resumeWorkflow`)
- * share the same underlying `vi.fn`, so calls through either name are recorded
- * once and handlers configured on either name apply to both.
  * @returns Disposable workflow mock control object
  * @example
  * ```typescript
  * import { mockWorkflow } from "@tailor-platform/sdk/vitest";
  *
- * test("job trigger", async () => {
+ * test("job start", async () => {
  *   using wf = mockWorkflow();
  *   const job = wf.job(validateOrder);
  *   job.mockResolvedValue({ valid: true });
@@ -45,43 +40,28 @@ type WaitPayload<Payload> = [Payload] extends [undefined] ? undefined : Payload;
 declare function mockWorkflow(): {
   /** The `startJobFunction` `vi.fn`. */
   startJobFunction: Mock<(jobName: string, _args?: unknown, _options?: StartJobFunctionOptions) => unknown>;
-  /**
-   * Frozen alias of `startJobFunction` (same `vi.fn` reference).
-   * @deprecated Use `startJobFunction` instead.
-   */
-  triggerJobFunction: Mock<(jobName: string, _args?: unknown, _options?: StartJobFunctionOptions) => unknown>;
   /** The `startWorkflow` `vi.fn`. */
   startWorkflow: Mock<(_workflowName: string, _args?: unknown, _options?: StartWorkflowOptions) => Promise<string>>;
-  /**
-   * Frozen alias of `startWorkflow` (same `vi.fn` reference).
-   * @deprecated Use `startWorkflow` instead.
-   */
-  triggerWorkflow: Mock<(_workflowName: string, _args?: unknown, _options?: StartWorkflowOptions) => Promise<string>>;
   /** The `resumeWorkflowExecution` `vi.fn`. */
   resumeWorkflowExecution: Mock<(executionId: string) => Promise<string>>;
-  /**
-   * Frozen alias of `resumeWorkflowExecution` (same `vi.fn` reference).
-   * @deprecated Use `resumeWorkflowExecution` instead.
-   */
-  resumeWorkflow: Mock<(executionId: string) => Promise<string>>;
   /** The `wait` `vi.fn`. */
   wait: Mock<(_key: string, _payload?: unknown) => unknown>;
   /** The `resolve` `vi.fn`. */
   resolve: Mock<(_executionId: string, _key: string, _callback: (payload: unknown) => unknown) => Promise<void>>;
   /**
-   * Get a stable, typed mock for a workflow job's `trigger` method.
-   * The real trigger behavior is used until an implementation or result is configured.
+   * Get a stable, typed mock for a workflow job's `start` method.
+   * The real start behavior is used until an implementation or result is configured.
    * @param definition - Workflow job definition to mock
-   * @returns Typed `trigger` mock for the definition
+   * @returns Typed `start` mock for the definition
    */
-  job<Name extends string, Input, Output>(definition: WorkflowJob<Name, Input, Output>): Mock<WorkflowJob<Name, Input, Output>["trigger"]>;
+  job<Name extends string, Input, Output>(definition: WorkflowJob<Name, Input, Output>): Mock<WorkflowJob<Name, Input, Output>["start"]>;
   /**
-   * Get a stable, typed mock for a workflow definition's `trigger` method.
-   * The real trigger behavior is used until an implementation or result is configured.
+   * Get a stable, typed mock for a workflow definition's `start` method.
+   * The real start behavior is used until an implementation or result is configured.
    * @param definition - Workflow definition to mock
-   * @returns Typed `trigger` mock for the definition
+   * @returns Typed `start` mock for the definition
    */
-  workflow<Definition extends Workflow>(definition: Definition): Mock<Definition["trigger"]>;
+  workflow<Definition extends Workflow>(definition: Definition): Mock<Definition["start"]>;
   /**
    * Get stable, typed mocks for a wait point's `wait` and `resolve` methods.
    * @param definition - Wait point definition to mock
@@ -98,30 +78,30 @@ declare function mockWorkflow(): {
    */
   setJobHandler(handler: JobHandler): void;
   /**
-   * Enqueue a single result for the next `triggerJobFunction` call (FIFO;
+   * Enqueue a single result for the next `startJobFunction` call (FIFO;
    * takes priority over `setJobHandler`).
    * @param result - Result to return from the next call
    */
   enqueueResult(result: unknown): void;
   /**
-   * Enqueue results for multiple subsequent `triggerJobFunction` calls (FIFO).
+   * Enqueue results for multiple subsequent `startJobFunction` calls (FIFO).
    * @param results - Results to enqueue, one per upcoming call
    */
   enqueueResults(...results: unknown[]): void;
   /**
-   * All jobs triggered via `triggerJobFunction`, in order.
-   * @returns Triggered jobs array
+   * All jobs started via `startJobFunction`, in order.
+   * @returns Started jobs array
    */
-  readonly triggeredJobs: TriggeredJob[];
+  readonly startedJobs: StartedJob[];
   /**
-   * Configure what `triggerWorkflow` returns. Pass a string (same id every
+   * Configure what `startWorkflow` returns. Pass a string (same id every
    * call) or `(name, args, options) => string`. Default: a placeholder UUID.
    * @param handler - Static execution ID or a function returning one
    */
-  setTriggerHandler(handler: string | TriggerHandlerFn): void;
+  setStartHandler(handler: string | StartHandlerFn): void;
   /**
-   * Configure what `resumeWorkflow` returns. Pass a string (same id every
-   * call) or `(executionId) => string`. Default: echoes the input executionId.
+   * Configure what `resumeWorkflowExecution` returns. Pass a string (same id
+   * every call) or `(executionId) => string`. Default: echoes the input executionId.
    * @param handler - Static execution ID or a function returning one
    */
   setResumeHandler(handler: string | ResumeHandlerFn): void;
@@ -132,7 +112,7 @@ declare function mockWorkflow(): {
    */
   setWaitHandler: SetWaitHandler;
   /**
-   * Set the `env` passed to job bodies invoked via `createWorkflowJob().trigger()`.
+   * Set the `env` passed to job bodies invoked via `createWorkflowJob().start()`.
    * Cleared on dispose / reset.
    * @param env - Env passed to job bodies.
    */

package/dist/vitest/setup.mjs

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

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

@@ -12,9 +12,9 @@ interface RunWorkflowLocallyOptions {
   env?: TailorEnv;
 }
 /**
- * Run a workflow's main job and dependent job triggers locally with real job bodies.
+ * Run a workflow's main job and dependent job starts locally with real job bodies.
  *
- * Use this for local full-chain workflow tests. Regular `.trigger()` calls
+ * Use this for local full-chain workflow tests. Regular `.start()` calls
  * delegate to the platform workflow runtime and should be mocked with
  * `mockWorkflow()` when you are not intentionally running the local chain.
  * @param workflow - Workflow definition to run

package/dist/workflow-CsBvRE3g.mjs

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

package/dist/workflow-CsBvRE3g.mjs.map

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

package/docs/cli/application.md

@@ -130,6 +130,8 @@ tailor deploy --config apps/buyer/tailor.config.ts,apps/supplier/tailor.config.t
 
 When multiple configs are provided, `deploy` creates or updates all configured services first, then updates the applications. This lets one application reference resources owned by another config with `external: true` during the same deploy.
 
+Each config's `files` and `ignores` patterns (see [Service Configuration](../configuration.md#service-configuration)) resolve relative to that config's own directory, not the directory you ran `deploy` from. For example, `apps/buyer/tailor.config.ts` declaring `files: ["db/**/*.ts"]` loads files from `apps/buyer/db/`, independent of where `apps/supplier/tailor.config.ts`'s patterns resolve. If a config's relative patterns match nothing under its own directory, the SDK falls back to the invocation directory and logs a warning (see [Service Configuration](../configuration.md#service-configuration) for details).
+
 **Migration Handling:**
 
 When migrations are configured (`db.tailordb.migration` in config), the `deploy` command automatically:

package/docs/cli/function.md

@@ -178,5 +178,5 @@ You can pass either a source file (`.ts`) or a pre-bundled file (`.js`).
 When a `.js` file is provided, detection and bundling are skipped and the file is executed as-is.
 
 > [!WARNING]
-> Workflow job `.trigger()` calls do not work in test-run mode.
-> Triggered jobs are not executed; only the target job's `body` function runs in isolation.
+> Workflow job `.start()` calls do not work in test-run mode.
+> Started jobs are not executed; only the target job's `body` function runs in isolation.

package/docs/cli/tailordb.md

@@ -231,10 +231,10 @@ See [Global Options](../cli-reference.md#global-options) for options available t
 
 ### tailordb erd
 
-The `tailordb erd` commands (export, diff, serve, deploy) are provided by the `@tailor-platform/sdk-tailordb-erd-plugin` CLI plugin. Install it next to the SDK and keep running `tailor tailordb erd <command>` as before:
+The `tailordb erd` commands (export, diff, serve, deploy) are provided by the `@tailor-platform/sdk-plugin-tailordb-erd` CLI plugin. Install it next to the SDK and keep running `tailor tailordb erd <command>` as before:
 
 ```bash
-npm install -D @tailor-platform/sdk-tailordb-erd-plugin@next
+npm install -D @tailor-platform/sdk-plugin-tailordb-erd@next
 tailor tailordb erd export --namespace myNamespace
 ```
 

package/docs/cli-reference.md

@@ -121,7 +121,7 @@ tailor hello world --loud
 
 This also works under a built-in command group. The command path is joined with hyphens, so a plugin
 nested under `tailordb` is named `tailor-tailordb-erd`. This is how the
-`@tailor-platform/sdk-tailordb-erd-plugin`
+`@tailor-platform/sdk-plugin-tailordb-erd`
 package provides the `tailordb erd` commands:
 
 ```bash

package/docs/configuration.md

@@ -82,6 +82,8 @@ export default defineConfig({
 
 **ignores**: Glob patterns to exclude files. Optional. By default, `**/*.test.ts` and `**/*.spec.ts` are automatically ignored. If you explicitly specify `ignores`, the default patterns will not be applied. Use `ignores: []` to include all files including test files.
 
+**Pattern resolution**: `files` and `ignores` patterns are resolved relative to the directory of the `tailor.config.ts` file that declares them, not the directory you run the command from. This matters when deploying [multiple configs](./cli/application.md#deploy) together — each config's patterns only match files under its own directory. If a config's _relative_ patterns match nothing under its own directory, the SDK falls back to resolving them from the directory you ran the command from and logs a warning (this fallback doesn't apply to already-absolute patterns, since their resolution can't change). Update such patterns to be relative to the config's own directory — this fallback will be removed in v2.
+
 ### External Resources
 
 You can reference resources managed by Terraform or other SDK projects to include them in your application's subgraph. External resources are not deployed by this project but can be used for shared access across multiple applications.

package/docs/github-actions.md

@@ -73,11 +73,11 @@ tailor setup -n my-app-stg --erd-preview
 ```
 
 The generated workflow runs `tailor tailordb erd`, which is provided by the
-`@tailor-platform/sdk-tailordb-erd-plugin` CLI plugin — install it as a
+`@tailor-platform/sdk-plugin-tailordb-erd` CLI plugin — install it as a
 dev-dependency in your project:
 
 ```bash
-npm install -D @tailor-platform/sdk-tailordb-erd-plugin@next
+npm install -D @tailor-platform/sdk-plugin-tailordb-erd@next
 ```
 
 The generated workflow builds one self-contained ERD viewer HTML file for each

package/docs/migration/v2.md

@@ -350,7 +350,7 @@ Do not change behavior beyond the auth.invoker() removal.
 
 **Migration:** Partially automatic
 
-Rename statically identified SDK `authInvoker` options to `invoker`, replace `auth.invoker("name")` there with the bare `"name"` string, and drop the `auth` import when no other reference remains. Ambiguous workflow `.trigger()` calls are left for manual review. The `auth.invoker()` helper is removed in v2 because importing `auth` from `tailor.config.ts` into runtime files pulls Node-only modules into the bundle.
+Rename statically identified SDK `authInvoker` options to `invoker`, replace `auth.invoker("name")` there with the bare `"name"` string, and drop the `auth` import when no other reference remains. Ambiguous workflow `.start()` calls are left for manual review. The `auth.invoker()` helper is removed in v2 because importing `auth` from `tailor.config.ts` into runtime files pulls Node-only modules into the bundle.
 
 Before:
 
@@ -378,8 +378,8 @@ For each remaining auth.invoker(<expr>) call:
    machine user name string; platform/runtime authInvoker payloads still expect
    the object form.
 2. Rename remaining authInvoker option keys to invoker only for SDK resolver,
-   executor, workflow.trigger(), or startWorkflow() options. Keep platform/runtime
-   payload keys such as tailor.workflow.triggerWorkflow(..., { authInvoker: ... }).
+   executor, workflow.start(), or startWorkflow() options. Keep platform/runtime
+   payload keys such as tailor.workflow.startWorkflow(..., { authInvoker: ... }).
 3. After removing every auth.invoker usage in a file, delete the now-unused auth
    import (keeping it pulls Node-only config modules into runtime bundles); leave
    the import if auth is still referenced elsewhere.
@@ -694,6 +694,73 @@ export const { approval } = createWaitPoints((define) => ({
 }));
 ```
 
+## workflow.triggerWorkflow/triggerJobFunction/resumeWorkflow → startWorkflow/startJobFunction/resumeWorkflowExecution
+
+**Migration:** Partially automatic
+
+Rename tailor.workflow call sites from the pre-alignment triggerWorkflow/triggerJobFunction/resumeWorkflow names to the canonical startWorkflow/startJobFunction/resumeWorkflowExecution names, on both the ambient tailor.workflow global and a workflow value imported from @tailor-platform/sdk/runtime(/workflow). For a renamed triggerWorkflow call, also renames a literal `invoker` option key to `authInvoker` — startWorkflow's options expect the platform shape directly, unlike the removed triggerWorkflow wrapper, which converted invoker to authInvoker internally.
+
+Before:
+
+```ts
+import { workflow } from "@tailor-platform/sdk/runtime";
+
+await workflow.triggerWorkflow("myWorkflow", { data: "value" });
+```
+
+After:
+
+```ts
+import { workflow } from "@tailor-platform/sdk/runtime";
+
+await workflow.startWorkflow("myWorkflow", { data: "value" });
+```
+
+A literal invoker option is renamed to authInvoker:
+
+Before:
+
+```ts
+await workflow.triggerWorkflow("myWorkflow", { data: "value" }, { invoker: myInvoker });
+```
+
+After:
+
+```ts
+await workflow.startWorkflow("myWorkflow", { data: "value" }, { authInvoker: myInvoker });
+```
+
+<details>
+<summary>Prompt for an AI agent (to finish the cases the codemod could not migrate)</summary>
+
+```text
+The pre-alignment tailor.workflow names triggerWorkflow, triggerJobFunction, and
+resumeWorkflow are removed from the SDK's type surface in v2; use the canonical
+startWorkflow, startJobFunction, and resumeWorkflowExecution names instead. The
+codemod rewrites direct member-access call sites on the ambient tailor.workflow
+global and on a workflow value imported from @tailor-platform/sdk/runtime or
+@tailor-platform/sdk/runtime/workflow (including aliased imports). It skips a
+file entirely when a local declaration shadows the workflow import or the
+ambient tailor name, to avoid rewriting an unrelated same-named value — review
+those manually.
+
+For a renamed triggerWorkflow call, the codemod also renames a literal invoker
+option key (including shorthand { invoker }) to authInvoker, since startWorkflow
+expects the platform's authInvoker shape directly while triggerWorkflow's removed
+wrapper converted invoker to authInvoker internally.
+
+Also review, and migrate by hand:
+- Destructured references (e.g. const { triggerWorkflow } = workflow) — the
+  codemod only rewrites direct member-access calls.
+- Imported TriggerWorkflowOptions / TriggerJobFunctionOptions types — rename
+  them to StartWorkflowOptions / StartJobFunctionOptions.
+- An invoker option passed via a variable or spread (not a literal object) —
+  the codemod only inspects literal object arguments; rename the invoker key
+  to authInvoker in the options object's own definition.
+```
+
+</details>
+
 ## openDownloadStream → downloadStream
 
 **Migration:** Manual
@@ -787,18 +854,18 @@ string literals.
 
 </details>
 
-## Workflow .trigger() and trigger tests
+## Workflow job start() and start tests
 
 **Migration:** Manual
 
-Workflow job `.trigger()` now aligns with the platform runtime: it returns the job result directly instead of a Promise wrapper, and tests no longer run job bodies locally. Mock trigger responses with `mockWorkflow()` (`setJobHandler` / `enqueueResult`, assert via `triggeredJobs`), or use `runWorkflowLocally()` for a full-chain local run.
+Workflow job `.start()` (previously `.trigger()`) now aligns with the platform runtime: it returns the job result directly instead of a Promise wrapper, and tests no longer run job bodies locally. Mock start responses with `mockWorkflow()` (`setJobHandler` / `enqueueResult`, assert via `startedJobs`), or use `runWorkflowLocally()` for a full-chain local run.
 
 Tests must mock the workflow runtime instead of running bodies locally:
 
 Before:
 
 ```ts
-const result = await orderJob.trigger({ id });
+const result = await orderJob.start({ id });
 expect(result.status).toBe("done");
 ```
 
@@ -807,7 +874,7 @@ After:
 ```ts
 using wf = mockWorkflow();
 wf.setJobHandler((jobName) => (jobName === "order-job" ? { status: "done" } : null));
-const result = await orderJob.trigger({ id });
+const result = await orderJob.start({ id });
 expect(result.status).toBe("done");
 ```
 
@@ -815,11 +882,57 @@ expect(result.status).toBe("done");
 <summary>Prompt for an AI agent (to perform this migration)</summary>
 
 ```text
-Workflow job .trigger() now uses the platform workflow runtime instead of running
+Workflow job .start() now uses the platform workflow runtime instead of running
 the job body locally. In tests, acquire `using wf = mockWorkflow()` and provide
-trigger responses (setJobHandler / enqueueResult), or use runWorkflowLocally() for a
-full-chain local run; an unmocked trigger now throws. Outside tests, treat the
-trigger result as the job output directly (no Promise wrapper to unwrap).
+start responses (setJobHandler / enqueueResult), or use runWorkflowLocally() for a
+full-chain local run; an unmocked start now throws. Outside tests, treat the
+start result as the job output directly (no Promise wrapper to unwrap).
+```
+
+</details>
+
+## Workflow.trigger()/WorkflowJob.trigger() → .start()
+
+**Migration:** Manual
+
+Rename `Workflow.trigger()` (returned by `createWorkflow()`) and `WorkflowJob.trigger()` (returned by `createWorkflowJob()`) to `.start()`, aligning the SDK's ergonomic verb with the platform's `start*` RPC vocabulary. No codemod ships for this rename: distinguishing a workflow/job `.trigger()` call from an unrelated object's own `.trigger()` method requires resolving the receiver back to a `createWorkflow`/`createWorkflowJob` result across files, which the SDK's own CLI bundler already does for build-time rewriting. Reusing that logic in a standalone script is a nontrivial lift, and — unlike the bundler, which fails loudly when it cannot rewrite a call — a codemod false positive would silently rewrite an unrelated `.trigger()` call with no error. For the call-site volume this rename typically involves, manual review guided by the prompt below is the safer trade-off.
+
+Before:
+
+```ts
+const inventory = checkInventory.trigger({ orderId: input.orderId });
+const workflowRunId = await orderProcessingWorkflow.trigger(args, { invoker: "manager" });
+```
+
+After:
+
+```ts
+const inventory = checkInventory.start({ orderId: input.orderId });
+const workflowRunId = await orderProcessingWorkflow.start(args, { invoker: "manager" });
+```
+
+<details>
+<summary>Prompt for an AI agent (to perform this migration)</summary>
+
+```text
+In Tailor SDK v2, the ergonomic .trigger() method on a createWorkflow() or
+createWorkflowJob() result is renamed to .start(). This is unrelated to the
+separate tailor.workflow.triggerWorkflow/triggerJobFunction/resumeWorkflow removal
+(see the workflow-trigger-rename codemod) — this rename targets the SDK's own
+ergonomic wrapper, not the low-level platform call.
+
+For each flagged `.trigger(` call in these files:
+1. Confirm the receiver is a workflow or job object — typically a local const
+   assigned from createWorkflow(...)/createWorkflowJob(...), a named import of one,
+   or the default import of a workflow module. Skip receivers that are unrelated
+   objects with their own .trigger() method (state machines, event emitters, etc.).
+2. Rename the call from .trigger(...) to .start(...); the argument list is unchanged.
+3. Update any mock/test code that reads WorkflowJob['trigger'] / Workflow['trigger']
+   as a type, or that mocks the ergonomic method via a wrapper — for example,
+   `wf.job(definition)` / `wf.workflow(definition)` from mockWorkflow() now return a
+   mock of the `.start` method.
+4. Update prose/docs/comments that say "trigger the workflow/job" to "start" only
+   where they describe this SDK verb specifically, not unrelated event terminology.
 ```
 
 </details>
@@ -1091,3 +1204,7 @@ The CLI stores human users by their stable subject ID instead of email (email is
 ### Node.js minimum version raised to 22.15.0
 
 v2 requires Node.js **22.15.0** or later. This is the first version that includes `module.registerHooks()`, which the SDK uses to register its TypeScript loader hook synchronously in the main thread. No source change is required; ensure your environment runs Node.js 22.15.0+.
+
+### Legacy bundle artifact cleanup removed from deploy
+
+`tailor deploy` no longer deletes on-disk bundle artifacts (`.entry.js` files, workflow-job bundles, and the `hooks-validate-scripts/` directory) left in the SDK output directory (`.tailor` by default) by SDK versions that predate the current in-memory bundling approach. Current bundlers no longer write these files. No source change is required; if such stale files remain from a very old SDK version, delete only those specific files/directories manually — do not delete the output directory itself, since it also holds deploy state (e.g. `secrets-state/`, `*.context.json`) that existing secrets and Auth Connections depend on.

package/docs/runtime.md

@@ -81,7 +81,7 @@ The runtime entry re-exports the following namespaces. Detailed signatures, para
 - `secretmanager` — secret-vault access (`getSecret`, `getSecrets`)
 - `authconnection` — OAuth-style connection tokens (`getConnectionToken`)
 - `idp` — IdP user management (`new Client({ namespace })`)
-- `workflow` — workflow & job control (`startWorkflow`, `resumeWorkflowExecution`, `startJobFunction`, `wait`, `resolve`; the pre-alignment names `triggerWorkflow`, `resumeWorkflow`, `triggerJobFunction` are kept as frozen aliases)
+- `workflow` — workflow & job control (`startWorkflow`, `resumeWorkflowExecution`, `startJobFunction`, `wait`, `resolve`)
 - `context` — execution context (`getInvoker`)
 - `file` — `tailordb.file` BLOB API (`upload`, `download`, `downloadAsBase64`, `delete`, `getMetadata`, `downloadStream`, `uploadStream`)
 - `aigateway` — AI Gateway URL resolution (`get`)

package/docs/services/auth.md

@@ -107,7 +107,7 @@ userProfile: {
 
 **usernameField**: The field in the TailorDB type used as the username. This field must have a unique constraint (`.unique()`) since it is used to uniquely identify users.
 
-**attributes**: Specifies which fields from the TailorDB type are used as user attributes. Set to `true` to enable a field. Enabled attributes must be assigned values in all machine user definitions. Only fields with ValueOperand types (string, boolean, string[], boolean[]) can be used as attributes. The `id` field and datetime/date/time types are excluded.
+**attributes**: Specifies which fields from the TailorDB type are used as user attributes. Set to `true` to enable a field. Machine user definitions must assign values to attributes derived from required fields; attributes derived from optional fields may be omitted (see [Machine Users](#machine-users)). Only fields with ValueOperand types (string, boolean, string[], boolean[]) can be used as attributes. The `id` field and datetime/date/time types are excluded.
 
 ## Attribute List
 
@@ -200,7 +200,7 @@ machineUsers: {
 },
 ```
 
-**attributes**: Values for attributes enabled in `userProfile.attributes` (or all fields defined in `machineUserAttributes` when `userProfile` is omitted). All enabled fields must be set here. These values are accessible via the runtime principal's `attributes`:
+**attributes**: Values for attributes enabled in `userProfile.attributes` (or fields defined in `machineUserAttributes` when `userProfile` is omitted). Attribute keys mirror the field's optionality: attributes derived from required fields must be set, while attributes derived from optional fields may be omitted. Setting an attribute to `null` or `undefined` is equivalent to omitting it — the attribute is deployed as unset. These values are accessible via the runtime principal's `attributes`:
 
 ```typescript
 // In a resolver
@@ -269,7 +269,7 @@ tailor machineuser token <name>
 
 ### Specifying a machine user invoker
 
-Resolvers, executors, and `workflow.trigger()` accept an `invoker` option that chooses which machine user runs the operation. Pass the machine user name as a plain string — it is type-narrowed to the names you registered in `machineUsers`.
+Resolvers, executors, and `workflow.start()` accept an `invoker` option that chooses which machine user runs the operation. Pass the machine user name as a plain string — it is type-narrowed to the names you registered in `machineUsers`.
 
 ```typescript
 // tailor.config.ts
@@ -284,19 +284,19 @@ export const auth = defineAuth("my-auth", {
 ```
 
 ```typescript
-// resolvers/trigger-workflow.ts
+// resolvers/start-workflow.ts
 import { createResolver, t } from "@tailor-platform/sdk";
 import myWorkflow from "../workflows/my-workflow";
 
 export default createResolver({
-  name: "triggerMyWorkflow",
+  name: "startMyWorkflow",
   operation: "mutation",
   input: {
     id: t.string(),
   },
   body: async ({ input }) => {
-    // Trigger workflow with machine user permissions
-    const workflowRunId = await myWorkflow.trigger(
+    // Start workflow with machine user permissions
+    const workflowRunId = await myWorkflow.start(
       { id: input.id },
       { invoker: "admin-machine-user" },
     );