docs: reword lingering ts-pattern references to the built-in matcher

The dependency is gone (beta.6 builds the matcher into unthrown); the
migration guide, worker errors JSDoc, and the agent dependency rules now
say 'exhaustive matcher' instead of naming ts-pattern, and the catalog
note no longer lists it.

Author: btravers

.agents/rules/dependencies.md

@@ -13,7 +13,7 @@
 | `zod`                   | Direct dep of `contract` (used internally for the `defineContract` runtime validation pass); user-side schema lib for the others |
 | `valibot` / `arktype`   | User-side schema libraries (Standard Schema)                                                                                     |
 
-`pino` and `ts-pattern` appear in the catalog and are used by `examples/` only — they're not imported from any published package's `src/`.
+`pino` appears in the catalog and is used by `examples/` only — it's not imported from any published package's `src/`.
 
 ## Tooling
 

docs/guide/migrating-to-unthrown.md

@@ -52,21 +52,21 @@ the same name but is now imported from `"unthrown"`.
 
 ## API mapping
 
-| neverthrow                                   | unthrown                                                                                                                                       |
-| -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
-| `import { ResultAsync } from "neverthrow"`   | `import { fromPromise } from "unthrown"`                                                                                                       |
-| type `ResultAsync<T, E>`                     | type `AsyncResult<T, E>`                                                                                                                       |
-| type `Result<T, E>`                          | `Result<T, E>` (now from `"unthrown"`)                                                                                                         |
-| `ok(v)` / `err(e)`                           | `Ok(v)` / `Err(e)` (from `"unthrown"`)                                                                                                         |
-| `okAsync(v)`                                 | `Ok(v).toAsync()` (no `okAsync`)                                                                                                               |
-| `errAsync(e)`                                | `Err(e).toAsync()` (no `errAsync`)                                                                                                             |
-| `ResultAsync.fromPromise(promise, errFn)`    | `fromPromise(promise, errFn)`                                                                                                                  |
-| `ResultAsync.fromSafePromise(promise)`       | `fromSafePromise(promise)`                                                                                                                     |
-| `.andThen(fn)`                               | `.flatMap(fn)`                                                                                                                                 |
-| `.map(fn)` / `.mapErr(fn)` / `.orElse(fn)`   | `.map(fn)` / `.mapErrCases(m)` / `.flatMapErrCases(m)` (the error combinators take an exhaustive ts-pattern matcher `m`, not a plain callback) |
-| `Result.combine([...])`                      | `all([...])`                                                                                                                                   |
-| `result.match(okFn, errFn)` (positional)     | `result.match({ ok, errCases, defect })` (object, 3 channels; `errCases` is an exhaustive matcher)                                             |
-| `result.isOk()` / `result.isErr()` to narrow | `result.isOk()` / `result.isErr()` / `result.isDefect()` (methods narrow; `isOk(result)` free functions also exist)                            |
+| neverthrow                                   | unthrown                                                                                                                            |
+| -------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `import { ResultAsync } from "neverthrow"`   | `import { fromPromise } from "unthrown"`                                                                                            |
+| type `ResultAsync<T, E>`                     | type `AsyncResult<T, E>`                                                                                                            |
+| type `Result<T, E>`                          | `Result<T, E>` (now from `"unthrown"`)                                                                                              |
+| `ok(v)` / `err(e)`                           | `Ok(v)` / `Err(e)` (from `"unthrown"`)                                                                                              |
+| `okAsync(v)`                                 | `Ok(v).toAsync()` (no `okAsync`)                                                                                                    |
+| `errAsync(e)`                                | `Err(e).toAsync()` (no `errAsync`)                                                                                                  |
+| `ResultAsync.fromPromise(promise, errFn)`    | `fromPromise(promise, errFn)`                                                                                                       |
+| `ResultAsync.fromSafePromise(promise)`       | `fromSafePromise(promise)`                                                                                                          |
+| `.andThen(fn)`                               | `.flatMap(fn)`                                                                                                                      |
+| `.map(fn)` / `.mapErr(fn)` / `.orElse(fn)`   | `.map(fn)` / `.mapErrCases(m)` / `.flatMapErrCases(m)` (the error combinators take an exhaustive matcher `m`, not a plain callback) |
+| `Result.combine([...])`                      | `all([...])`                                                                                                                        |
+| `result.match(okFn, errFn)` (positional)     | `result.match({ ok, errCases, defect })` (object, 3 channels; `errCases` is an exhaustive matcher)                                  |
+| `result.isOk()` / `result.isErr()` to narrow | `result.isOk()` / `result.isErr()` / `result.isDefect()` (methods narrow; `isOk(result)` free functions also exist)                 |
 
 ## `okAsync` / `errAsync` are gone
 

packages/worker/src/errors.ts

@@ -346,7 +346,7 @@ export class ChildWorkflowError extends TaggedError("@temporal-contract/ChildWor
  * distinct {@link TaggedError}s, so call sites discriminate on the `_tag`
  * (or `instanceof ChildWorkflowCancelledError`) instead of relying on an
  * `instanceof ChildWorkflowError` that also matches cancellation. A
- * `result.match` with the ts-pattern `errCases` matcher folds the
+ * `result.match` with the exhaustive `errCases` matcher folds the
  * `ChildWorkflowError | ChildWorkflowCancelledError` union exhaustively.
  */
 export class ChildWorkflowCancelledError extends TaggedError(