cursedbelt-core 2.13.2 → 2.13.3

package/src/core/navigation/searchCatalogue.ts

@@ -1,5 +1,5 @@
 // Pure matcher + grouper for the instant client-side "pages" search layer. Ranks a
-// derived catalogue ({@link deriveSearchCatalogue}) against a query and buckets the
+// derived catalog ({@link deriveSearchCatalogue}) against a query and buckets the
 // hits by their owning domain. Kept pure + framework-free so it's unit-testable and
 // shared by HeaderSearch and (task 14) the command palette. The palette upgrades the
 // *ranking* to uFuzzy; this is the dependency-free baseline both can fall back to.
@@ -49,8 +49,8 @@ function scoreEntry(entry: SearchCatalogueEntry, q: string): number {
 }
 
 /**
- * Filter + rank a catalogue by `query`. Empty/blank query → `[]` (the instant layer
- * shows nothing until the user types). Stable: equal scores keep catalogue order.
+ * Filter + rank a catalog by `query`. Empty/blank query → `[]` (the instant layer
+ * shows nothing until the user types). Stable: equal scores keep catalog order.
  */
 export function rankCatalogue(catalogue: SearchCatalogueEntry[], query: string): CatalogueHit[] {
   const q = norm(query);
@@ -61,7 +61,7 @@ export function rankCatalogue(catalogue: SearchCatalogueEntry[], query: string):
     if (score > 0) scored.push({ ...entry, score });
   }
   // Stable sort by score desc — Array.prototype.sort is stable in modern engines, so
-  // equal scores retain catalogue (authoring) order.
+  // equal scores retain catalog (authoring) order.
   return scored.sort((a, b) => b.score - a.score);
 }
 

package/src/core/palette/fuzzyRank.ts

@@ -1,4 +1,4 @@
-// The command-palette ranking layer — uFuzzy over the nav catalogue. This is the
+// The command-palette ranking layer — uFuzzy over the nav catalog. This is the
 // *upgrade* HeaderSearch's `rankCatalogue` (a substring scorer) cannot match: uFuzzy
 // scores by contiguous-match proximity, so abbreviated/typeahead input ranks the
 // right page first. Pure + synchronous + React-free (uFuzzy is regex-based, no DOM),
@@ -48,7 +48,7 @@ function haystackFor(item: NavItem): string {
 
 /**
  * The SECOND tier: what a destination holds rather than what it is called — its description,
- * and the group and place it sits under when the entry carries them (catalogue entries do).
+ * and the group and place it sits under when the entry carries them (catalog entries do).
  * Owner, 2026-10-09: *"I may not know where to go but typing something like 'api' brings up the
  * relevant page links quickly"* — a page found only by its exact name is not found by someone
  * who does not know the name.
@@ -70,7 +70,7 @@ function rankedIndexes(haystack: string[], q: string): number[] {
 
 /**
  * Rank `items` against `query`, best match first; non-matches dropped. Generic over the
- * item type (so callers can pass plain {@link NavItem}s *or* richer catalogue entries
+ * item type (so callers can pass plain {@link NavItem}s *or* richer catalog entries
  * that carry domain/group tags for grouping — the extra fields ride straight through).
  * An empty/blank query returns `[]` (the palette shows its cold state instead).
  *

package/src/core/tokens/registry.ts

@@ -40,7 +40,7 @@ export interface TokenDef<S extends z.ZodType = z.ZodType> {
   subtypeOf?: string;
   /** Canonical payload injected by the V7.4 wire smoke probe. Must satisfy `schema`. */
   sample: z.infer<S>;
-  /** True when this token receives third-party traffic — triggers the V3 marshaller gates. */
+  /** True when this token receives third-party traffic — triggers the V3 marshaler gates. */
   external?: boolean;
   deprecated?: TokenDeprecation;
   description: string;
@@ -493,7 +493,7 @@ export const BASE_TOKENS: readonly TokenDef[] = [
     id: 'knowledge:records',
     mode: 'value',
     external: true,
-    description: 'Imported record rows (CSV/sheet/webhook) — external traffic, marshaller-gated (02 §7.1).',
+    description: 'Imported record rows (CSV/sheet/webhook) — external traffic, marshaler-gated (02 §7.1).',
     schema: z.object({ rows: z.array(z.record(z.string(), z.unknown())) }),
     sample: { rows: [{ id: '1' }] },
   },

package/src/core/wire/__fixtures__/rowsMarshalWorker.ts

@@ -1,9 +1,9 @@
 /**
- * A REAL marshalling worker entry, used by `marshalWorker.spec.ts` to prove the
+ * A REAL marshaling worker entry, used by `marshalWorker.spec.ts` to prove the
  * round-trip over an actual OS thread rather than over an injected fake.
  *
  * This is also the shape every production entry has, so it doubles as the
- * reference an app author copies: construct the marshaller, hand it to
+ * reference an app author copies: construct the marshaler, hand it to
  * `serveMarshalWorker`, done. The host never imports this file — it names it,
  * and the worker imports it.
  */

package/src/core/wire/index.ts

@@ -3,7 +3,7 @@
  *
  * This entry exists because of Law #1, for the same reason `client/index.ts`
  * gives that reason for `createWireHub`: an ingress route has to be able to
- * IMPORT the marshalling seam, and a worker entry has to be able to import
+ * IMPORT the marshaling seam, and a worker entry has to be able to import
  * `serveMarshalWorker`. Until the Worker commit (05 §B1) neither symbol had any
  * export path at all — `marshalInbound` was reachable only from inside this
  * package, which is most of why it went three arcs with zero callers.

package/src/core/wire/ingress.spec.ts

@@ -35,7 +35,7 @@ const registryWith = (marshaller: CCWireMarshaller) => {
 };
 
 describe('createMarshalledIngress', () => {
-  it('marshals a payload through the token’s registered marshaller', async () => {
+  it('marshals a payload through the token’s registered marshaler', async () => {
     const ingress = createMarshalledIngress({ registry: registryWith(rowsMarshaller()) });
     await expect(ingress.ingest('knowledge:records', { rows: [{ id: 'a' }] })).resolves.toEqual({
       rows: [{ id: 'a' }],
@@ -45,7 +45,7 @@ describe('createMarshalledIngress', () => {
 
   it('is a 404 for an unregistered token, not a 400', async () => {
     const ingress = createMarshalledIngress({ registry: createMarshallerRegistry() });
-    // From outside, "no marshaller" and "no such token" are the same fact.
+    // From outside, "no marshaler" and "no such token" are the same fact.
     // Distinguishing them would make an ingress an enumeration oracle for the
     // app's whole wire surface.
     await expect(ingress.ingest('nope', {})).rejects.toMatchObject({
@@ -55,20 +55,20 @@ describe('createMarshalledIngress', () => {
     await ingress.dispose();
   });
 
-  it('carries the marshaller’s own typed refusals through unchanged', async () => {
+  it('carries the marshaler’s own typed refusals through unchanged', async () => {
     const ingress = createMarshalledIngress({
       registry: registryWith(rowsMarshaller({ maxPayloadBytes: 8 })),
     });
-    // 413, from the marshaller's declared ceiling — the ingress adds no policy
-    // of its own about size, because the marshaller is where that is declared.
+    // 413, from the marshaler's declared ceiling — the ingress adds no policy
+    // of its own about size, because the marshaler is where that is declared.
     await expect(ingress.ingest('knowledge:records', { rows: [{ id: 'a-very-long-id' }] })).rejects.toMatchObject({
       status: 413,
     });
     await ingress.dispose();
   });
 
-  it('preserves the marshalling tier’s status codes rather than flattening them', async () => {
-    // These codes are the marshalling tier's, unchanged, and the distinction is
+  it('preserves the marshaling tier’s status codes rather than flattening them', async () => {
+    // These codes are the marshaling tier's, unchanged, and the distinction is
     // load-bearing: a payload `validate` refuses is the CALLER's wrong shape
     // (400), while a transform whose OUTPUT violates the token schema means an
     // upstream provider changed shape under us (502 — not our error budget, and
@@ -114,10 +114,10 @@ describe('createMarshalledIngress', () => {
    * The reason this module exists at all. `createMarshalWorkerClient` spawns a
    * thread PER CALL, so a route handler that called it per request would leak one
    * OS thread per webhook — a server that gets slower for a week and then dies,
-   * with nothing in the marshalling API to warn you. Caching per entry is not an
+   * with nothing in the marshaling API to warn you. Caching per entry is not an
    * optimization here; it is the whole point of having one owner.
    */
-  it('reuses ONE thread for a marshaller that offloads, and disposes it once', async () => {
+  it('reuses ONE thread for a marshaler that offloads, and disposes it once', async () => {
     const disposed: string[] = [];
     const ingress = createMarshalledIngress({
       registry: registryWith(
@@ -156,7 +156,7 @@ describe('createMarshalledIngress', () => {
 
   /* --------------------------------------------------------- request bodies */
 
-  it('parses a JSON body and hands the marshaller a VALUE', async () => {
+  it('parses a JSON body and hands the marshaler a VALUE', async () => {
     const ingress = createMarshalledIngress({ registry: registryWith(rowsMarshaller()) });
     const request = new Request('http://x/hook', {
       method: 'POST',
@@ -235,7 +235,7 @@ describe('adding an ingress later is a ROUTE, not a refactor (E16/D8)', () => {
     expect(ok.status).toBe(202);
     expect(accepted).toEqual([{ rows: [{ id: 'from-the-wire' }] }]);
 
-    // And a CSV import is the SAME route with a different marshaller and a
+    // And a CSV import is the SAME route with a different marshaler and a
     // different service call — which is the claim the owner's condition asked
     // to be able to rely on.
     await ingress.dispose();
@@ -253,7 +253,7 @@ describe('adding an ingress later is a ROUTE, not a refactor (E16/D8)', () => {
       } catch (error) {
         // A real mount uses the app's error middleware; the point asserted here
         // is that the ingress hands up an error that already KNOWS its status,
-        // so a route never has to map marshalling failures itself.
+        // so a route never has to map marshaling failures itself.
         return c.json({ success: false }, (error as { status?: number }).status as 413);
       }
     });

package/src/core/wire/ingress.ts

@@ -13,25 +13,25 @@
  * webhook endpoint that no product asked for would create a new orphan seam of
  * exactly the kind Law #1 exists to prevent, and it would guess wrong about the
  * part that actually differs between a webhook and an import (authentication,
- * routing, what the marshalled value is handed to). What does NOT differ — and
+ * routing, what the marshaled value is handed to). What does NOT differ — and
  * what every ingress would otherwise re-derive, differently — is this:
  *
  *   1. reading the body as bytes without buffering a stream into RAM twice;
- *   2. finding the marshaller for the token being fed;
+ *   2. finding the marshaler for the token being fed;
  *   3. owning a worker per `workerEntry` — a live OS thread, so exactly one
  *      thing must own disposing of it — and resolving it lazily and cached;
  *   4. handing those failures up as errors that already KNOW their HTTP status,
- *      so no route re-derives the mapping. The marshalling tier's codes are
+ *      so no route re-derives the mapping. The marshaling tier's codes are
  *      unchanged and deliberately distinct: 413 over the declared ceiling, 400
  *      for a payload `validate` refuses (the caller's shape is wrong), 502 when
  *      the TRANSFORM OUTPUT violates the token's canonical schema (an upstream
  *      provider changed shape under us — not our error budget), 503 for a
- *      payload that needs offload from a marshaller with no worker.
+ *      payload that needs offload from a marshaler with no worker.
  *
  * Step 3 is the one that would go wrong. `createMarshalWorkerClient` spawns a
  * thread per call; a route handler that called it per request would leak one
  * OS thread per webhook, and the symptom would be a server that gets slower for
- * a week and then dies. Nothing about that is discoverable from the marshalling
+ * a week and then dies. Nothing about that is discoverable from the marshaling
  * API, which is precisely why it belongs here once instead of in each ingress.
  *
  * ## Adding an ingress later
@@ -47,7 +47,7 @@
  * });
  * ```
  *
- * A CSV import is the same three lines with a different marshaller and a
+ * A CSV import is the same three lines with a different marshaler and a
  * different service call. Neither needs to know that a worker exists.
  */
 import { AppError } from '../../shared/errors.js';
@@ -59,14 +59,14 @@ import {
   type MarshalWorker,
 } from './marshalling.js';
 
-/** No marshaller is registered for the token an ingress was asked to feed. */
+/** No marshaler is registered for the token an ingress was asked to feed. */
 export const INGRESS_TOKEN_UNKNOWN = 'INGRESS_TOKEN_UNKNOWN';
 
 export interface MarshalledIngressOptions {
   /** The registry the app's wire tokens were registered on. */
   readonly registry: MarshallerRegistry;
   /**
-   * Per-payload worker ceiling. A marshalling worker that hangs would otherwise
+   * Per-payload worker ceiling. A marshaling worker that hangs would otherwise
    * hold the request open for as long as the client is willing to wait.
    */
   readonly workerTimeoutMs?: number;
@@ -83,12 +83,12 @@ export interface MarshalledIngress {
    *
    * @throws {AppError} `INGRESS_TOKEN_UNKNOWN` (404) when nothing is registered;
    *   `MARSHALLER_PAYLOAD_TOO_LARGE` (413/503), `MARSHALLER_VALIDATION_FAILED`
-   *   (400) or `MARSHALLER_SCHEMA_VIOLATION` (502) from the marshaller itself.
+   *   (400) or `MARSHALLER_SCHEMA_VIOLATION` (502) from the marshaler itself.
    */
   ingest<Out = unknown>(tokenId: string, payload: unknown): Promise<Out>;
   /**
    * Read a `Request` body and marshal it for `tokenId`. JSON bodies are parsed;
-   * anything else is handed to the marshaller as bytes, because a marshaller for
+   * anything else is handed to the marshaler as bytes, because a marshaler for
    * a CSV or a binary feed wants the bytes and re-encoding them would be lossy.
    */
   ingestRequest<Out = unknown>(tokenId: string, request: Request): Promise<Out>;
@@ -113,7 +113,7 @@ export const createMarshalledIngress = (options: MarshalledIngressOptions): Mars
     const entry = marshaller.workerEntry;
     if (entry === undefined) return undefined;
     if (disposed)
-      throw new AppError('This ingress has been disposed and cannot spawn a marshalling worker.', {
+      throw new AppError('This ingress has been disposed and cannot spawn a marshaling worker.', {
         code: 'INGRESS_DISPOSED',
         status: 503,
         isOperational: false,
@@ -133,10 +133,10 @@ export const createMarshalledIngress = (options: MarshalledIngressOptions): Mars
   const marshallerFor = (tokenId: string): CCWireMarshaller => {
     const marshaller = options.registry.forToken(tokenId);
     if (!marshaller)
-      // 404, not 400: from outside, a token with no marshaller and a token that
+      // 404, not 400: from outside, a token with no marshaler and a token that
       // does not exist are the same fact, and distinguishing them would make
       // this endpoint an enumeration oracle for the app's wire surface.
-      throw new AppError(`No marshaller is registered for wire token '${tokenId}'.`, {
+      throw new AppError(`No marshaler is registered for wire token '${tokenId}'.`, {
         code: INGRESS_TOKEN_UNKNOWN,
         status: 404,
         context: { tokenId },
@@ -153,8 +153,8 @@ export const createMarshalledIngress = (options: MarshalledIngressOptions): Mars
 
     async ingestRequest<Out>(tokenId: string, request: Request): Promise<Out> {
       const contentType = request.headers.get('content-type') ?? '';
-      // JSON is parsed here so the marshaller sees a value rather than a string
-      // it would have to parse itself (and parse DIFFERENTLY per marshaller).
+      // JSON is parsed here so the marshaler sees a value rather than a string
+      // it would have to parse itself (and parse DIFFERENTLY per marshaler).
       // A malformed body is the CALLER's error — 400 — and must not read as a
       // validation failure of a payload we never managed to decode.
       const payload = contentType.includes('application/json')

package/src/core/wire/marshalWorker.spec.ts

@@ -1,5 +1,5 @@
 /**
- * The marshalling Worker (05 §B1) — proven over a REAL thread.
+ * The marshaling Worker (05 §B1) — proven over a REAL thread.
  *
  * The seam has had an injectable `MarshalWorker` since it was written, and the
  * old suite exercised that seam with a fake. What it could never show is the
@@ -33,7 +33,7 @@ const marshaller = (over: Partial<CCWireMarshaller<unknown, z.infer<typeof schem
     ...over,
   }) as CCWireMarshaller<unknown, z.infer<typeof schema>>;
 
-describe('a real marshalling worker', () => {
+describe('a real marshaling worker', () => {
   it('runs validate + transform off-thread and returns the result', async () => {
     const client = createMarshalWorkerClient({ entry: WORKER_ENTRY, timeoutMs: 20_000 });
     try {
@@ -87,7 +87,7 @@ describe('a real marshalling worker', () => {
     }
   }, 30_000);
 
-  it('is the DEFAULT path: marshalInbound resolves the marshaller’s own workerEntry', async () => {
+  it('is the DEFAULT path: marshalInbound resolves the marshaler’s own workerEntry', async () => {
     const client = createMarshalWorkerClient({ entry: WORKER_ENTRY, timeoutMs: 20_000 });
     try {
       let ranOnMainThread = false;
@@ -100,7 +100,7 @@ describe('a real marshalling worker', () => {
         }),
         { rows: [{ id: 'x' }] },
         // No `worker:` — the point of the commit is that an ingress route wires
-        // nothing per-marshaller; it supplies one resolver and offload happens.
+        // nothing per-marshaler; it supplies one resolver and offload happens.
         { offloadThresholdBytes: 4, resolveWorker: () => client },
       );
       expect(result).toEqual({ rows: [{ id: 'worker:x' }] });
@@ -162,17 +162,17 @@ describe('marshal worker lifecycle', () => {
 });
 
 describe('requiresWorkerOffload — a derived fact, not a declared one', () => {
-  it('is false for a marshaller that can never exceed the main-thread limit', () => {
+  it('is false for a marshaler that can never exceed the main-thread limit', () => {
     // 256KB ceiling: no payload it accepts can reach the 512KB boundary, so
     // demanding a worker of it would be noise.
     expect(requiresWorkerOffload({ maxPayloadBytes: 256 * 1024 })).toBe(false);
   });
 
-  it('is true for a marshaller whose ceiling is above it', () => {
+  it('is true for a marshaler whose ceiling is above it', () => {
     expect(requiresWorkerOffload({ maxPayloadBytes: 2 * 1024 * 1024 })).toBe(true);
   });
 
-  it('names the missing artifact when an offload-needing marshaller has no entry', async () => {
+  it('names the missing artifact when an offload-needing marshaler has no entry', async () => {
     // The 503 that D1 was about. It is still reachable in code — V3 is what makes
     // it unreachable in a verified app — and when it fires it must say what to
     // build, not merely that something is missing.

package/src/core/wire/marshalWorker.ts

@@ -1,5 +1,5 @@
 /**
- * The marshalling Worker (05 §B1, second half) — `validate` + `transform` for a
+ * The marshaling Worker (05 §B1, second half) — `validate` + `transform` for a
  * large inbound payload, off the thread that has to answer requests.
  *
  * `marshalling.ts` has always had the SIZE BOUNDARY and the injection seam; what
@@ -8,19 +8,19 @@
  * the missing half: a real, long-lived worker with a request/response protocol,
  * on both runtimes cursedbelt ships to.
  *
- * ## Why the marshaller names its own worker entry
+ * ## Why the marshaler names its own worker entry
  *
- * A marshaller is mostly FUNCTIONS (`validate`, `transform`, a Zod schema), and
+ * A marshaler is mostly FUNCTIONS (`validate`, `transform`, a Zod schema), and
  * functions do not survive structured clone — a worker cannot be handed one, it
  * has to `import` it. The obvious design (one shared worker that resolves any
- * marshaller by id from a registry module) needs the host to declare, register
- * and keep in sync a second module listing every marshaller, and it gives that
+ * marshaler by id from a registry module) needs the host to declare, register
+ * and keep in sync a second module listing every marshaler, and it gives that
  * one worker the authority to run all of them.
  *
- * Instead each marshaller declares `workerEntry`: the module that constructs
- * exactly that marshaller and calls {@link serveMarshalWorker}. The worker can
- * therefore only ever run the one marshaller it was built for, the host wires
- * nothing, and — the part that matters for the gate — "can this marshaller
+ * Instead each marshaler declares `workerEntry`: the module that constructs
+ * exactly that marshaler and calls {@link serveMarshalWorker}. The worker can
+ * therefore only ever run the one marshaler it was built for, the host wires
+ * nothing, and — the part that matters for the gate — "can this marshaler
  * offload?" stops being a boolean somebody remembered to set and becomes a
  * question about an artifact that either exists or does not. V3 checks it
  * statically (`marshaller-worker-offload-missing`), so the 503 path below is
@@ -133,7 +133,7 @@ export async function serveMarshalWorker<Inbound, Out>(
           id: request.id,
           ok: false,
           code: MARSHALLER_VALIDATION_FAILED,
-          message: `Inbound payload rejected by marshaller '${marshaller.id}'.`,
+          message: `Inbound payload rejected by marshaler '${marshaller.id}'.`,
         } satisfies MarshalWorkerResponse);
         return;
       }
@@ -249,7 +249,7 @@ function spawnHostWorker(entry: string | URL): HostWorker {
 }
 
 /**
- * A long-lived worker for ONE marshaller, multiplexing concurrent payloads.
+ * A long-lived worker for ONE marshaler, multiplexing concurrent payloads.
  *
  * Long-lived rather than one-worker-per-payload deliberately: thread startup
  * plus module load is tens of milliseconds, which on a burst of imports would
@@ -304,7 +304,7 @@ export function createMarshalWorkerClient(options: MarshalWorkerClientOptions):
     for (const id of [...pending.keys()])
       settle(id, (p) =>
         p.reject(
-          new AppError(`Marshalling worker failed: ${message}`, {
+          new AppError(`Marshaling worker failed: ${message}`, {
             code: MARSHALLER_WORKER_FAILED,
             status: 500,
             context: { worker: String(options.entry) },
@@ -317,7 +317,7 @@ export function createMarshalWorkerClient(options: MarshalWorkerClientOptions):
     run<Inbound, Out>(_marshallerId: string, payload: Inbound): Promise<Out> {
       if (disposed)
         return Promise.reject(
-          new AppError('Marshalling worker has been disposed.', {
+          new AppError('Marshaling worker has been disposed.', {
             code: MARSHALLER_WORKER_FAILED,
             status: 500,
             context: { worker: String(options.entry) },
@@ -328,7 +328,7 @@ export function createMarshalWorkerClient(options: MarshalWorkerClientOptions):
         const timer = setTimeout(() => {
           pending.delete(id);
           reject(
-            new AppError(`Marshalling worker did not answer within ${timeoutMs}ms.`, {
+            new AppError(`Marshaling worker did not answer within ${timeoutMs}ms.`, {
               code: MARSHALLER_WORKER_TIMEOUT,
               status: 504,
               context: { worker: String(options.entry), timeoutMs },
@@ -345,7 +345,7 @@ export function createMarshalWorkerClient(options: MarshalWorkerClientOptions):
       for (const id of [...pending.keys()])
         settle(id, (p) =>
           p.reject(
-            new AppError('Marshalling worker was disposed while a payload was in flight.', {
+            new AppError('Marshaling worker was disposed while a payload was in flight.', {
               code: MARSHALLER_WORKER_FAILED,
               status: 503,
               context: { worker: String(options.entry) },

package/src/core/wire/marshalling.spec.ts

@@ -1,5 +1,5 @@
 /**
- * Port marshalling + the 512KB worker gate (02 §7.1).
+ * Port marshaling + the 512KB worker gate (02 §7.1).
  */
 import { describe, expect, it } from 'bun:test';
 import { z } from 'zod';
@@ -44,7 +44,7 @@ describe('marshalInbound', () => {
     expect(result).toEqual({ rows: [{ id: '1' }] });
   });
 
-  it('rejects a payload over the marshaller’s own limit before scheduling any work', async () => {
+  it('rejects a payload over the marshaler’s own limit before scheduling any work', async () => {
     let transformed = false;
     await expect(
       marshalInbound(
@@ -122,7 +122,7 @@ describe('marshalInbound', () => {
 });
 
 describe('createMarshallerRegistry', () => {
-  it('refuses a marshaller with no declared payload ceiling', () => {
+  it('refuses a marshaler with no declared payload ceiling', () => {
     const registry = createMarshallerRegistry();
     expect(() => registry.register('knowledge:records', marshaller({ maxPayloadBytes: 0 }))).toThrow(
       /maxPayloadBytes/,

package/src/core/wire/marshalling.ts

@@ -1,8 +1,8 @@
 /**
- * Port marshalling + the 512KB worker gate (02 §7.1).
+ * Port marshaling + the 512KB worker gate (02 §7.1).
  *
  * External payloads — webhooks, third-party feeds, spreadsheet imports — never
- * touch component code. A marshaller registered on the token is the only entry,
+ * touch component code. A marshaler registered on the token is the only entry,
  * and its `transform` output is checked against the token's canonical Zod schema
  * (V3 asserts this statically; here it is enforced at runtime too, because a
  * provider can change its shape without anyone recompiling).
@@ -21,7 +21,7 @@ import { AppError } from '../../shared/errors.js';
 export const MARSHALLER_WORKER_OFFLOAD_BYTES = 512 * 1024;
 
 /**
- * The ONE marshaller contract (05 §B1, unified 2026-07-26).
+ * The ONE marshaler contract (05 §B1, unified 2026-07-26).
  *
  * There were TWO interfaces of this name in this package: this one, and a
  * divergent copy in `core/tokens/registry.ts` that additionally required
@@ -35,24 +35,24 @@ export const MARSHALLER_WORKER_OFFLOAD_BYTES = 512 * 1024;
  */
 export interface CCWireMarshaller<Inbound = unknown, Out = unknown> {
   id: string;
-  /** The wire token this marshaller feeds — V3 resolves it against the registry. */
+  /** The wire token this marshaler feeds — V3 resolves it against the registry. */
   tokenId: string;
   /** REQUIRED — V3 `marshaller-payload-unbounded` when absent or non-positive. */
   maxPayloadBytes: number;
   /**
-   * The module that runs this marshaller's `validate`+`transform` off the main
+   * The module that runs this marshaler's `validate`+`transform` off the main
    * thread — an entry calling `serveMarshalWorker` (`core/wire/marshalWorker.ts`).
    *
    * **This replaced a `workerOffload: boolean` in the Worker commit (05 §B1).**
    * That flag was authored by hand and asserted a capability the codebase did
-   * not have: every marshaller in the repo set it `true` while no worker
+   * not have: every marshaler in the repo set it `true` while no worker
    * existed anywhere, so the V3 gate it fed was checking that someone had
-   * remembered to type `true`. Whether a marshaller can offload is now a
+   * remembered to type `true`. Whether a marshaler can offload is now a
    * question about an ARTIFACT — this entry either exists or it does not — and
    * whether it NEEDS to is {@link requiresWorkerOffload}, derived from
    * `maxPayloadBytes`. Neither is a promise anyone can make by hand.
    *
-   * Optional because a marshaller whose `maxPayloadBytes` sits under the
+   * Optional because a marshaler whose `maxPayloadBytes` sits under the
    * main-thread limit can never reach the offload path; V3 requires it of
    * exactly those that can.
    */
@@ -64,9 +64,9 @@ export interface CCWireMarshaller<Inbound = unknown, Out = unknown> {
 }
 
 /**
- * Can this marshaller ever reach the offload path? A DERIVED fact (05 §B1).
+ * Can this marshaler ever reach the offload path? A DERIVED fact (05 §B1).
  *
- * A marshaller that refuses anything over 256KB can never produce a payload
+ * A marshaler that refuses anything over 256KB can never produce a payload
  * above the 512KB main-thread limit, so it needs no worker and demanding one
  * would be noise. One whose ceiling is 2MB certainly can, and without a
  * `workerEntry` its large payloads are a guaranteed 503 — which is why V3
@@ -111,13 +111,13 @@ export interface MarshalWorker {
 
 export interface MarshalOptions {
   /**
-   * Use THIS worker instead of the one the marshaller's `workerEntry` names.
+   * Use THIS worker instead of the one the marshaler's `workerEntry` names.
    * Left unset in production: offload is the default path, resolved from the
-   * marshaller itself, so an ingress route needs no worker wiring of its own.
+   * marshaler itself, so an ingress route needs no worker wiring of its own.
    */
   worker?: MarshalWorker;
   /**
-   * Resolves a worker for a marshaller that declares a `workerEntry`. The host
+   * Resolves a worker for a marshaler that declares a `workerEntry`. The host
    * supplies this once (`createMarshalWorkerClient`, cached per entry) — it is a
    * parameter rather than a module-level singleton because a worker is a live
    * OS thread, and something has to own disposing of it.
@@ -128,9 +128,9 @@ export interface MarshalOptions {
 }
 
 /**
- * Run a payload through its marshaller, offloading past the size gate.
+ * Run a payload through its marshaler, offloading past the size gate.
  *
- * Order matters: the marshaller's OWN `maxPayloadBytes` is checked first, so an
+ * Order matters: the marshaler's OWN `maxPayloadBytes` is checked first, so an
  * oversized payload is refused with a typed diagnostic before any work — worker
  * or otherwise — is scheduled for it.
  */
@@ -143,7 +143,7 @@ export async function marshalInbound<Inbound, Out>(
 
   if (bytes > marshaller.maxPayloadBytes)
     throw new AppError(
-      `Payload of ${bytes} bytes exceeds marshaller '${marshaller.id}' limit of ${marshaller.maxPayloadBytes}.`,
+      `Payload of ${bytes} bytes exceeds marshaler '${marshaller.id}' limit of ${marshaller.maxPayloadBytes}.`,
       {
         code: MARSHALLER_PAYLOAD_TOO_LARGE,
         status: 413,
@@ -155,15 +155,15 @@ export async function marshalInbound<Inbound, Out>(
 
   if (bytes > threshold) {
     // Offload is the DEFAULT path (05 §B1): an explicitly injected worker wins,
-    // otherwise the marshaller's own `workerEntry` is resolved through the host's
-    // resolver. Neither present means this marshaller has no offload path at all
+    // otherwise the marshaler's own `workerEntry` is resolved through the host's
+    // resolver. Neither present means this marshaler has no offload path at all
     // — which V3 refuses to verify, so a verified app never reaches this throw.
     const worker =
       options.worker ??
       (marshaller.workerEntry ? options.resolveWorker?.(marshaller as CCWireMarshaller<never, never>) : undefined);
     if (!worker)
       throw new AppError(
-        `Payload of ${bytes} bytes exceeds the ${threshold}-byte main-thread limit and marshaller '${marshaller.id}' has no marshalling worker.`,
+        `Payload of ${bytes} bytes exceeds the ${threshold}-byte main-thread limit and marshaler '${marshaller.id}' has no marshaling worker.`,
         {
           code: MARSHALLER_PAYLOAD_TOO_LARGE,
           status: 503,
@@ -173,8 +173,8 @@ export async function marshalInbound<Inbound, Out>(
             threshold,
             workerEntry: marshaller.workerEntry ?? null,
             hint: marshaller.workerEntry
-              ? 'The marshaller declares a workerEntry but no resolveWorker was supplied — pass createMarshalWorkerClient through MarshalOptions.resolveWorker.'
-              : 'Give the marshaller a workerEntry (a module calling serveMarshalWorker), or lower maxPayloadBytes below the main-thread limit.',
+              ? 'The marshaler declares a workerEntry but no resolveWorker was supplied — pass createMarshalWorkerClient through MarshalOptions.resolveWorker.'
+              : 'Give the marshaler a workerEntry (a module calling serveMarshalWorker), or lower maxPayloadBytes below the main-thread limit.',
           },
         },
       );
@@ -185,7 +185,7 @@ export async function marshalInbound<Inbound, Out>(
   }
 
   if (!marshaller.validate(payload))
-    throw new AppError(`Inbound payload rejected by marshaller '${marshaller.id}'.`, {
+    throw new AppError(`Inbound payload rejected by marshaler '${marshaller.id}'.`, {
       code: MARSHALLER_VALIDATION_FAILED,
       status: 400,
       context: { marshaller: marshaller.id },
@@ -202,7 +202,7 @@ export async function marshalInbound<Inbound, Out>(
 function assertSchema<Inbound, Out>(marshaller: CCWireMarshaller<Inbound, Out>, value: Out): Out {
   const parsed = marshaller.targetZodSchema.safeParse(value);
   if (!parsed.success)
-    throw new AppError(`Marshaller '${marshaller.id}' produced output that violates its token's schema.`, {
+    throw new AppError(`Marshaler '${marshaller.id}' produced output that violates its token's schema.`, {
       code: MARSHALLER_SCHEMA_VIOLATION,
       status: 502,
       context: {
@@ -213,7 +213,7 @@ function assertSchema<Inbound, Out>(marshaller: CCWireMarshaller<Inbound, Out>,
   return parsed.data;
 }
 
-/** The registry of marshallers, keyed by token id (02 §7.1: registered ON the token). */
+/** The registry of marshalers, keyed by token id (02 §7.1: registered ON the token). */
 export interface MarshallerRegistry {
   register(tokenId: string, marshaller: CCWireMarshaller): void;
   forToken(tokenId: string): CCWireMarshaller | undefined;
@@ -225,7 +225,7 @@ export function createMarshallerRegistry(): MarshallerRegistry {
   return {
     register(tokenId, marshaller) {
       if (marshaller.maxPayloadBytes === undefined || marshaller.maxPayloadBytes <= 0)
-        throw new AppError(`Marshaller '${marshaller.id}' must declare a positive maxPayloadBytes.`, {
+        throw new AppError(`Marshaler '${marshaller.id}' must declare a positive maxPayloadBytes.`, {
           code: 'marshaller-payload-unbounded',
           status: 500,
           context: { marshaller: marshaller.id, tokenId },

package/src/ctgrClient/convertRequest.ts

@@ -93,7 +93,7 @@ async function formDataToBody(formData: FormData): Promise<Record<string, unknow
  * The request body as a JS value: a JSON string is parsed, a plain string rides as itself.
  *
  * 🔴 Anything else is REFUSED. The tunnel carries a JSON value or a form's files; a `File`, a
- * `Blob`, bytes, a stream or `URLSearchParams` handed through here was JSON-serialised as `{}` —
+ * `Blob`, bytes, a stream or `URLSearchParams` handed through here was JSON-serialized as `{}` —
  * desk's import preview posted a 3.4 MB workbook and the server described "a JSON file" with `{}`
  * as its sample (forge task 3443). A loud error at the call is the bug; a silent `{}` is data loss.
  * Send an upload as `FormData`, which is carried whole.
@@ -101,7 +101,7 @@ async function formDataToBody(formData: FormData): Promise<Record<string, unknow
 function bodyFromInit(body: BodyInit | null | undefined, method: string, url: string): unknown {
   if (body === null || body === undefined) return undefined;
   if (typeof body !== 'string') {
-    // A plain object or array a caller cast to `BodyInit` serialises as itself — carried as before.
+    // A plain object or array a caller cast to `BodyInit` serializes as itself — carried as before.
     const proto = Object.getPrototypeOf(body);
     if (Array.isArray(body) || proto === Object.prototype || proto === null) return body;
     const shape = Object.prototype.toString.call(body).slice(8, -1);

package/src/namedSubpathsResolve.spec.ts

@@ -103,7 +103,7 @@ describe('subpaths named in this repo resolve', () => {
 	});
 
 	it('knows what the manifest exports', () => {
-		// If `exports` is ever read wrong, every offence below silently becomes one.
+		// If `exports` is ever read wrong, every offense below silently becomes one.
 		expect(exported.has('')).toBe(true); // the "." root entry
 		expect(exported.has('/master-lock')).toBe(true);
 		expect(exported.has('/react')).toBe(false); // the react tier stayed in `cursedbelt` at the 2026-09-15 split