feat(worker)!: remove deprecated createWorkerOrThrow

Completes the no-deprecated-aliases policy applied to the client's
createOrThrow: createWorker returns AsyncResult<Worker, never>, so
.get() provides the same throw-on-defect behavior with the original
cause. Migration guide, checklist, changeset, and handlers.md updated.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: btravers

.agents/rules/handlers.md

@@ -108,8 +108,8 @@ shape on the client: the connection-scoped `TypedClient.create({ client })`
 returns `AsyncResult<TypedClient, never>` (a `TechnicalError`-caused defect on
 setup failure); bind a contract with the synchronous, infallible
 `typedClient.for(contract)`, which returns a `ContractClient<TContract>` (the
-type to use in annotations). There is no `TypedClient.createOrThrow`; the
-deprecated `createWorkerOrThrow` still exists for migration.
+type to use in annotations). There is no `TypedClient.createOrThrow` and no
+`createWorkerOrThrow` — use `.get()` on the returned `AsyncResult`.
 
 ```typescript
 import { createWorker, workflowsPathFromURL } from "@temporal-contract/worker/worker";

.changeset/v8-review-remediation.md

@@ -28,7 +28,7 @@ v8 review remediation — the full-surface overhaul from the six-track 8.0 revie
 
 - Invalid signal payloads are dropped and logged (`log.warn`), never thrown — `SignalInputValidationError` is deleted; a stale client can no longer terminally kill a workflow execution.
 - Contract misuse inside workflow code (unknown signal/query/update or workflow name, async schema, uncovered activity options) now fails fast as a non-retryable `ContractMisuseError` `ApplicationFailure` instead of hanging executions in Workflow Task retries.
-- Exported `qualify` is renamed `qualifyFailure` (no alias).
+- Exported `qualify` is renamed `qualifyFailure` (no alias), and the deprecated `createWorkerOrThrow` is removed — use `createWorker(...).get()`.
 - `activities` is optional on `createWorker`, and activity-less workflows no longer need `{}` entries in the implementations map.
 - `TypedChildWorkflowHandle` gains a typed `signals` map and `firstExecutionRunId`.
 

docs/how-to/add-activity-middleware.md

@@ -64,13 +64,13 @@ export const activities = declareActivitiesHandler({
 ## Inject typed context
 
 The most useful thing middleware does is extend the typed context that flows to
-implementations. Use `defineActivityMiddleware` to pin the in and out types:
+implementations. Use `declareActivityMiddleware` to pin the in and out types:
 
 ```typescript
-import { defineActivityMiddleware, type EmptyContext } from "@temporal-contract/worker/activity";
+import { declareActivityMiddleware, type EmptyContext } from "@temporal-contract/worker/activity";
 import { Err } from "unthrown";
 
-const withTenant = defineActivityMiddleware<EmptyContext, { tenantId: string }>(
+const withTenant = declareActivityMiddleware<EmptyContext, { tenantId: string }>(
   (invocation, next) => {
     const tenantId = (invocation.input as { tenantId?: string }).tenantId;
 
@@ -160,7 +160,7 @@ export const activities = declareActivitiesHandler({
 smuggle unvalidated data past the contract:
 
 ```typescript
-const normalizeEmail = defineActivityMiddleware((invocation, next) => {
+const normalizeEmail = declareActivityMiddleware((invocation, next) => {
   const input = invocation.input as { email?: string };
   if (typeof input.email !== "string") {
     return next();

docs/how-to/configure-a-worker.md

@@ -52,11 +52,6 @@ await result.value.run();
 `.get()` is the terse form — on a defect it rethrows the original cause with its
 stack intact, which is usually what you want at process startup.
 
-::: tip `createWorkerOrThrow` is deprecated
-It exists to ease migration from the pre-`AsyncResult` API and will be removed
-in a future major. Use `createWorker`.
-:::
-
 ## Resolve the workflows path
 
 Temporal bundles workflow code into an isolated sandbox, so it needs a _path_,

docs/how-to/upgrade-to-v8.md

@@ -169,7 +169,8 @@ Or, more concisely — `.get()` rethrows a defect's original cause:
 const typedClient = await TypedClient.create({ client }).get();
 ```
 
-The same applies to `createWorker`.
+The same applies to `createWorker`. The deprecated `createWorkerOrThrow`
+migration alias is removed in 8.0 — use `createWorker(...).get()`.
 
 ### Every other operation
 
@@ -412,6 +413,17 @@ A mechanical rename, no alias kept:
 +       fromPromise(gateway.charge(customerId, amount), qualifyFailure("CHARGE_FAILED"))
 ```
 
+### `createWorkerOrThrow` is removed
+
+The deprecated throwing alias goes the same way as the client's
+`createOrThrow`: `createWorker` returns `AsyncResult<Worker, never>`, so
+`.get()` gives the same throw-on-defect behavior with the original cause.
+
+```diff
+- const worker = await createWorkerOrThrow({ contract, connection, workflowsPath, activities });
++ const worker = await createWorker({ contract, connection, workflowsPath, activities }).get();
+```
+
 ### Contract misuse fails the execution instead of hanging it
 
 Binding a signal/query/update handler for a name the contract does not
@@ -592,6 +604,7 @@ New on the surface:
       (imports and `P.tag` arms)
 - [ ] `getHandle` calls drop their `await` (it returns a sync `Result`)
 - [ ] `qualify` → `qualifyFailure` in activity implementations
+- [ ] `createWorkerOrThrow(...)` → `createWorker(...).get()`
 - [ ] No `SignalInputValidationError` imports remain; alerting expects
       invalid signals to be dropped and logged, not to fail executions
 - [ ] `schedule.create` matchers handle `ScheduleAlreadyExistsError`;

docs/reference/worker-surface.md

@@ -305,7 +305,7 @@ Runs **inside** the validation boundary.
 Calling `next` more than once re-runs the rest of the chain (retry). Returning
 without calling it short-circuits.
 
-#### `defineActivityMiddleware(middleware)`
+#### `declareActivityMiddleware(middleware)`
 
 Identity helper that pins the context type parameters without a variable
 annotation.
@@ -350,15 +350,6 @@ technical faults on the **defect** channel with a `TechnicalError` cause.
 Inspect with `isDefect()` / `match({ defect })` / `recoverDefect`, or use
 `.get()` to rethrow the original cause.
 
-### `createWorkerOrThrow(options)`
-
-::: warning Deprecated
-Pre-`AsyncResult` behaviour, kept to ease migration. Removed in a future major.
-Use `createWorker`.
-:::
-
-Rethrows the original cause rather than the `TechnicalError` wrapper.
-
 ### `workflowsPathFromURL(baseURL, relativePath)`
 
 ```typescript

packages/testing/src/time-skipping.ts

@@ -78,7 +78,7 @@ export function createTimeSkippingEnvironment(
  */
 export function createTimeSkippingTest(options?: TimeSkippingTestWorkflowEnvironmentOptions) {
   return vitestIt.extend<{
-    $worker: { testEnv: TestWorkflowEnvironment };
+    testEnv: TestWorkflowEnvironment;
   }>({
     testEnv: [
       // oxlint-disable-next-line no-empty-pattern

packages/worker/src/__tests__/time-skipping.inprocess.spec.ts

@@ -24,7 +24,7 @@ import { describe, expect } from "vitest";
 import {
   composeActivityMiddleware,
   declareActivitiesHandler,
-  defineActivityMiddleware,
+  declareActivityMiddleware,
 } from "../activity.js";
 import { createWorker, TechnicalError } from "../worker.js";
 import { inprocessContract } from "./inprocess.contract.js";
@@ -35,7 +35,7 @@ const errAsync = <E>(error: E): AsyncResult<never, E> => Err(error).toAsync();
 const seenContexts: Record<string, unknown>[] = [];
 
 const tracing = composeActivityMiddleware(
-  defineActivityMiddleware<{ gateway: string }, { gateway: string; traceId: string }>(
+  declareActivityMiddleware<{ gateway: string }, { gateway: string; traceId: string }>(
     (invocation, next) => next({ context: { ...invocation.context, traceId: "trace-1" } }),
   ),
 );

packages/worker/src/activity-contract-errors.spec.ts

@@ -15,7 +15,7 @@ import {
   ApplicationFailure,
   composeActivityMiddleware,
   declareActivitiesHandler,
-  defineActivityMiddleware,
+  declareActivityMiddleware,
   type ActivityMiddleware,
 } from "./activity.js";
 import { ContractErrorDataValidationError } from "./errors.js";
@@ -379,10 +379,11 @@ describe("declareActivitiesHandler — middleware", () => {
     const seenByInner: unknown[] = [];
     const seenByImplementation: unknown[] = [];
 
-    const outer = defineActivityMiddleware<{ tenant: string }, { tenant: string; traceId: string }>(
-      (invocation, next) => next({ context: { ...invocation.context, traceId: "t-1" } }),
-    );
-    const inner = defineActivityMiddleware<
+    const outer = declareActivityMiddleware<
+      { tenant: string },
+      { tenant: string; traceId: string }
+    >((invocation, next) => next({ context: { ...invocation.context, traceId: "t-1" } }));
+    const inner = declareActivityMiddleware<
       { tenant: string; traceId: string },
       { tenant: string; traceId: string; attempt: number }
     >((invocation, next) => {

packages/worker/src/activity.ts

@@ -313,7 +313,7 @@ export type ActivityMiddlewareNext<
  * `next({ context })`. A middleware that only reads context leaves both
  * parameters equal and stays valid unchanged. Compose typed chains with
  * {@link composeActivityMiddleware}; pin a middleware's context types
- * without a variable annotation via {@link defineActivityMiddleware}.
+ * without a variable annotation via {@link declareActivityMiddleware}.
  *
  * @example Log every activity invocation and its outcome (read-only)
  * ```ts
@@ -334,7 +334,7 @@ export type ActivityMiddlewareNext<
  *
  * @example Guard-and-narrow: inject a tenant id for everything downstream
  * ```ts
- * const auth = defineActivityMiddleware<EmptyContext, { tenantId: string }>(
+ * const auth = declareActivityMiddleware<EmptyContext, { tenantId: string }>(
  *   (invocation, next) => {
  *     const tenantId = readTenant(invocation.input);
  *     if (!tenantId) {
@@ -370,7 +370,7 @@ export type AnyActivityMiddleware = ActivityMiddleware<
  * Identity helper that pins a middleware's context types without a variable
  * annotation. (Mirrors amqp-contract's `defineMiddleware`.)
  */
-export function defineActivityMiddleware<
+export function declareActivityMiddleware<
   TContextIn extends Record<string, unknown> | EmptyContext = EmptyContext,
   TContextOut extends TContextIn = TContextIn,
 >(