cursedbelt-core 2.13.2 → 2.13.3

package/dist/core/analytics/range.d.ts

@@ -94,8 +94,8 @@ export declare const startOfBucket: (t: number, unit: BucketUnit) => number;
  * duplicated or missing bar exactly once every spring and autumn — the kind of
  * bug nobody reproduces.
  *
- * The time-of-day is carried through rather than normalised to midnight: every
- * caller here passes an already-aligned value, so normalising would be
+ * The time-of-day is carried through rather than normalized to midnight: every
+ * caller here passes an already-aligned value, so normalizing would be
  * invisible in this file and a trap for the first caller that does not.
  */
 export declare const addDays: (t: number, n: number) => number;

package/dist/core/analytics/range.js

@@ -102,8 +102,8 @@ export const startOfBucket = (t, unit) => unit === 'hour' ? startOfHour(t) : sta
  * duplicated or missing bar exactly once every spring and autumn — the kind of
  * bug nobody reproduces.
  *
- * The time-of-day is carried through rather than normalised to midnight: every
- * caller here passes an already-aligned value, so normalising would be
+ * The time-of-day is carried through rather than normalized to midnight: every
+ * caller here passes an already-aligned value, so normalizing would be
  * invisible in this file and a trap for the first caller that does not.
  */
 export const addDays = (t, n) => {

package/dist/core/analytics/schedule.d.ts

@@ -11,7 +11,7 @@
  * Three separate claims hide in that, and a `remaining / rate` division answers
  * none of them:
  *
- * 1. **Work does not parallelise freely.** Two tasks that write the same files
+ * 1. **Work does not parallelize freely.** Two tasks that write the same files
  *    may not run together whatever the fleet size — that is the orchestrator's
  *    own scope rule, and it is why a queue of ten tasks all scoped to one app
  *    drains at exactly the same speed with eight workers as with one.

package/dist/core/analytics/schedule.js

@@ -11,7 +11,7 @@
  * Three separate claims hide in that, and a `remaining / rate` division answers
  * none of them:
  *
- * 1. **Work does not parallelise freely.** Two tasks that write the same files
+ * 1. **Work does not parallelize freely.** Two tasks that write the same files
  *    may not run together whatever the fleet size — that is the orchestrator's
  *    own scope rule, and it is why a queue of ten tasks all scoped to one app
  *    drains at exactly the same speed with eight workers as with one.
@@ -179,10 +179,10 @@ function blocks(candidate, other) {
 /**
  * A best-effort reason an item started late — for the table behind the chart.
  *
- * Deliberately approximate and labelled as such: the precise answer would need
+ * Deliberately approximate and labeled as such: the precise answer would need
  * the admission loop to record every refusal at every event, which is a lot of
  * bookkeeping for a column. "Was it waiting on a dependency, on a conflicting
- * neighbour, or simply for a free worker" is the distinction a reader acts on,
+ * neighbor, or simply for a free worker" is the distinction a reader acts on,
  * and that is decidable from the item alone.
  */
 function whyWaited(item, _timeline, known) {

package/dist/core/duplicates/index.d.ts

@@ -17,7 +17,7 @@
  *
  * ── What is NOT here, deliberately ──────────────────────────────────────────────────────
  * Anything that needs a database, a filesystem, a fetch or a picture decoder. This module is
- * pure so both consumers can prove their behaviour with `bun test` instead of against a live
+ * pure so both consumers can prove their behavior with `bun test` instead of against a live
  * store, and so a browser bundle may import it (music renders the pair side by side).
  */
 /**
@@ -93,7 +93,7 @@ export declare function durationsClose(a: number | null | undefined, b: number |
 /** One file, reduced to what this module can reason about. Units are the caller's — pass
  *  both durations in the same unit or not at all. */
 export interface NamedFileFacts {
-    /** The name a person would recognise: a display title, else the last path segment. */
+    /** The name a person would recognize: a display title, else the last path segment. */
     name: string | null | undefined;
     sizeBytes: number;
     /** Playing time, in whatever unit the caller uses consistently. Null = never measured. */

package/dist/core/duplicates/index.js

@@ -17,7 +17,7 @@
  *
  * ── What is NOT here, deliberately ──────────────────────────────────────────────────────
  * Anything that needs a database, a filesystem, a fetch or a picture decoder. This module is
- * pure so both consumers can prove their behaviour with `bun test` instead of against a live
+ * pure so both consumers can prove their behavior with `bun test` instead of against a live
  * store, and so a browser bundle may import it (music renders the pair side by side).
  */
 /**

package/dist/core/file-tree/fileTreeModel.d.ts

@@ -22,7 +22,7 @@
 /** What a row IS. `folder` may hold children and accept drops; `file` is a leaf. */
 export type FileTreeNodeKind = 'folder' | 'file';
 /**
- * How visible a node is, generalised from collections' private/locked folders.
+ * How visible a node is, generalized from collections' private/locked folders.
  *
  * 🔴 It is a LABEL, never an enforcement. The server decides what a session may see, and a
  * tree that hides a row the server sent (or shows one it did not) is a second, weaker
@@ -114,7 +114,7 @@ export interface FileTreeNode {
      *
      * For a consumer that narrows the tree itself (by content, not only by name) and keeps
      * the folders on the way to each hit: the hits are what the eye is scanning for, and the
-     * folders kept around them are context. Omit it and nothing is emphasised.
+     * folders kept around them are context. Omit it and nothing is emphasized.
      */
     matched?: boolean;
     /**
@@ -280,7 +280,7 @@ export interface KeyboardMoveOptions {
  * without asking which of several folders was meant — and **← promotes out to the folder its
  * own folder is in**, which is `root` at depth 1.
  *
- * 🔴 Every refusal the DRAG honours is honoured here, from the same fields: `acceptsDrop`,
+ * 🔴 Every refusal the DRAG honors is honored here, from the same fields: `acceptsDrop`,
  * the consumer's `canDrop`, and the descendant rule. A keyboard route that can reach a
  * destination the pointer refuses is a second, weaker opinion about what is legal — and it
  * is the one nobody looks at, because the pointer is what gets tested by hand.

package/dist/core/file-tree/fileTreeModel.js

@@ -68,7 +68,7 @@ export function flattenFileTree(nodes, collapsed) {
              * "A row that claims to open onto nothing is its own small lie" was the old reasoning
              * and it is answered by what VS Code does: the chevron says *folder*, not *occupied*,
              * and opening an empty one onto nothing is the honest answer, not a broken promise.
-             * `node.expandable === false` is still honoured for a row that can never hold anything.
+             * `node.expandable === false` is still honored for a row that can never hold anything.
              */
             const expandable = node.kind === 'folder' && (node.expandable ?? true);
             const expanded = expandable && !shut.has(node.id);
@@ -210,7 +210,7 @@ export function resolveDrop({ nodes, row, offsetRatio, dragId, allowReorder = fa
  * without asking which of several folders was meant — and **← promotes out to the folder its
  * own folder is in**, which is `root` at depth 1.
  *
- * 🔴 Every refusal the DRAG honours is honoured here, from the same fields: `acceptsDrop`,
+ * 🔴 Every refusal the DRAG honors is honored here, from the same fields: `acceptsDrop`,
  * the consumer's `canDrop`, and the descendant rule. A keyboard route that can reach a
  * destination the pointer refuses is a second, weaker opinion about what is legal — and it
  * is the one nobody looks at, because the pointer is what gets tested by hand.

package/dist/core/folder-tree/actions.d.ts

@@ -25,7 +25,7 @@
  * applies, with nothing destroyed. Deleting the CONTENTS destroys items, and this module
  * has never seen an item; it only ever sees the paths they carry. So `purge` is a mode the
  * menu offers and the CONSUMER implements against its own store, which is also the only
- * place that can count what is about to be lost or refuse the operation. Modelling it here
+ * place that can count what is about to be lost or refuse the operation. Modeling it here
  * would mean inventing an item, and an item this model cannot see is one it cannot protect.
  */
 import type { FolderNode, FolderRemap } from "./tree.js";

package/dist/core/folder-tree/actions.js

@@ -25,7 +25,7 @@
  * applies, with nothing destroyed. Deleting the CONTENTS destroys items, and this module
  * has never seen an item; it only ever sees the paths they carry. So `purge` is a mode the
  * menu offers and the CONSUMER implements against its own store, which is also the only
- * place that can count what is about to be lost or refuse the operation. Modelling it here
+ * place that can count what is about to be lost or refuse the operation. Modeling it here
  * would mean inventing an item, and an item this model cannot see is one it cannot protect.
  */
 import { folderPathKey, isFolderPathUnder, parseFolderPath, serializeFolderPath, } from "./path.js";

package/dist/core/master-lock/kdf.js

@@ -70,7 +70,7 @@ export async function deriveMasterLockVerifier(masterPassword, params) {
     }
     const salt = unb64u(params.salt);
     const kek = await pbkdf2(utf8(masterPassword), salt, params.iter);
-    // Same salt as the KEK, by design: it individualises the verifier without a second
+    // Same salt as the KEK, by design: it individualizes the verifier without a second
     // stored value. One round, over KEK ‖ password.
     const verifier = await pbkdf2(concat(kek, utf8(masterPassword)), salt, 1);
     return b64u(verifier);

package/dist/core/master-lock/presence.d.ts

@@ -23,7 +23,7 @@
  * ── 🔴 Why a decorative loop is NOT presence ────────────────────────────────
  * The failure mode that would make this a security hole is an ambient background clip
  * — muted, looping, autoplaying, running forever with nobody in the building. That is
- * a recognisable signature (`muted` AND `loop`) and it is refused. A film the owner is
+ * a recognizable signature (`muted` AND `loop`) and it is refused. A film the owner is
  * actually watching is not both at once; a muted film that loops is not something this
  * fleet renders. Where a component knows better than the heuristic, it says so:
  * `data-master-lock-presence="watch"` counts unconditionally, `"ignore"` never does.

package/dist/core/master-lock/presence.js

@@ -23,7 +23,7 @@
  * ── 🔴 Why a decorative loop is NOT presence ────────────────────────────────
  * The failure mode that would make this a security hole is an ambient background clip
  * — muted, looping, autoplaying, running forever with nobody in the building. That is
- * a recognisable signature (`muted` AND `loop`) and it is refused. A film the owner is
+ * a recognizable signature (`muted` AND `loop`) and it is refused. A film the owner is
  * actually watching is not both at once; a muted film that loops is not something this
  * fleet renders. Where a component knows better than the heuristic, it says so:
  * `data-master-lock-presence="watch"` counts unconditionally, `"ignore"` never does.

package/dist/core/master-lock/wire.d.ts

@@ -112,7 +112,7 @@ export declare const MASTER_LOCK_STATE_HEADER = "x-master-lock-state";
  *  nothing in the fleet constructs one. So adding a required field to it is
  *  additive, and without this annotation it is the residual false MAJOR that
  *  Phase −1's M-B measured and had no cheap fix for (F4). `release/surface.ts`
- *  records the annotation; `release/classify.ts` honours it. */
+ *  records the annotation; `release/classify.ts` honors it. */
 export interface MasterLockStatus {
     /** Is a master password set at all? False only on an app that was never seeded,
      *  or — in per-person mode — for a person who has not chosen one yet. */

package/dist/core/media/mediaItem.js

@@ -1,5 +1,5 @@
 // Pure MediaItem helpers — kind predicates + dimension/aspect resolution. The React
-// catalogue maps items to layout photos through these, so the "what size is this
+// catalog maps items to layout photos through these, so the "what size is this
 // thumbnail" logic is tested here, not buried in a component.
 export const isImageItem = (item) => item.type === 'image';
 export const isVideoItem = (item) => item.type === 'video';

package/dist/core/media/types.d.ts

@@ -71,10 +71,10 @@ export type VideoProgressEvent = {
     progressPercent?: number;
     error?: string;
 };
-/** The three media kinds the catalogue + lightbox understand. */
+/** The three media kinds the catalog + lightbox understand. */
 export type MediaKind = 'image' | 'video' | 'audio';
 /**
- * A URL-only catalogue item — the unit the `<MediaCatalogueViewer>` renders. It
+ * A URL-only catalog item — the unit the `<MediaCatalogueViewer>` renders. It
  * holds NO storage identity (no FsNode, no binary id): the app maps its own records
  * to this and pre-resolves `url`/`thumbnailUrl` (signing private files as needed).
  */
@@ -95,7 +95,7 @@ export type MediaItem = {
     durationSeconds?: number;
 };
 /**
- * A gallery photo — a {@link MediaItem} specialized to images, plus the catalogue affordances a
+ * A gallery photo — a {@link MediaItem} specialized to images, plus the catalog affordances a
  * photo grid renders (tags for the filter strip, createdAt for ordering, favorite for the ♥).
  * Like every media-core unit it carries only resolved URLs — no storage identity.
  */
@@ -124,7 +124,7 @@ export type ProcessingStatus = 'pending' | 'processing' | 'ready' | 'failed';
 /**
  * A surface-agnostic description of a playable video with every URL already resolved —
  * the unit the `<VideoPlayer>` primitive consumes (distinct from {@link MediaItem}, which
- * is the lightbox catalogue unit). It carries NO storage identity: a source pre-resolves
+ * is the lightbox catalog unit). It carries NO storage identity: a source pre-resolves
  * the streaming URLs (signing/tokenising private ones), so the player couples to nothing.
  * Richer than `MediaItem`: an HLS master + scrub-preview track for a real player HUD.
  */

package/dist/core/media/videoCuts.d.ts

@@ -43,7 +43,7 @@ export interface VideoCut {
  * The shortest span worth cutting, in seconds.
  *
  * 🔴 Not zero, and not "whatever the person dragged". Below roughly a frame the request is
- * indistinguishable from a mis-click, and it is a request ffmpeg cannot honour anyway — a
+ * indistinguishable from a mis-click, and it is a request ffmpeg cannot honor anyway — a
  * cut has to land on a frame boundary, so a 4 ms span asks the encoder to remove nothing and
  * charges a full re-encode of the file for it. 40 ms is one frame at 25fps, the slowest rate
  * anything in this library was shot at.

package/dist/core/media/videoCuts.js

@@ -38,7 +38,7 @@
  * The shortest span worth cutting, in seconds.
  *
  * 🔴 Not zero, and not "whatever the person dragged". Below roughly a frame the request is
- * indistinguishable from a mis-click, and it is a request ffmpeg cannot honour anyway — a
+ * indistinguishable from a mis-click, and it is a request ffmpeg cannot honor anyway — a
  * cut has to land on a frame boundary, so a 4 ms span asks the encoder to remove nothing and
  * charges a full re-encode of the file for it. 40 ms is one frame at 25fps, the slowest rate
  * anything in this library was shot at.
@@ -252,7 +252,7 @@ export function toggleSegment(plan, segment, duration) {
             splits: plan.splits,
             // Drop every removal this segment sits inside, then put back the parts of a WIDER
             // removal that are still meant to go — un-marking one piece of a span that was marked
-            // before it was split must not resurrect its neighbours.
+            // before it was split must not resurrect its neighbors.
             removed: plan.removed.flatMap((cut) => {
                 if (!(cut.start <= current.start + 1e-6 && cut.end >= current.end - 1e-6))
                     return [cut];

package/dist/core/navigation/index.js

@@ -1,6 +1,6 @@
 // `cursedbelt-core/navigation` — the navigation contract + pure selectors. React-free and
 // routing-free: the single source of truth (the IA tree) plus every derivation off
-// it (side nav, hub tiles, breadcrumbs, search catalogue, coverage test, prefs
+// it (side nav, hub tiles, breadcrumbs, search catalog, coverage test, prefs
 // migration). The React components in `cursedbelt/react` consume exactly this.
 export { buildBreadcrumbTrail, } from './breadcrumbCompat.js';
 export { createCoverageTest, findCoverageGaps, } from './coverageTest.js';

package/dist/core/navigation/navigationModel.d.ts

@@ -118,7 +118,7 @@ export interface NavDomain {
      * again the same as on a {@link NavItem}.
      *
      * Both of these exist because a domain IS a destination: `deriveSearchCatalogue`
-     * emits one catalogue entry per domain, so a rail of leaf-shaped domains (an app
+     * emits one catalog entry per domain, so a rail of leaf-shaped domains (an app
      * whose places have no sub-items) had no way to be found by synonym while an
      * otherwise identical rail of items did. That asymmetry was in the data model,
      * not in the ranker.

package/dist/core/navigation/navigationModel.js

@@ -1,6 +1,6 @@
 // The single navigation source of truth — a declarative Information-Architecture
 // tree (Domain → Group → Item) every nav surface derives from: the side nav, hub
-// landing tiles, breadcrumbs, the universal-search catalogue, and the command
+// landing tiles, breadcrumbs, the universal-search catalog, and the command
 // palette. Authoring a feature into the model is the *only* way to surface it, so
 // the historical "four hand-maintained lists drift out of sync → features get
 // buried" bug is structurally impossible (the coverage test enforces it in CI).

package/dist/core/navigation/navigationSelectors.d.ts

@@ -12,7 +12,7 @@ import { type GateFn, type NavDomain, type NavGroup, type NavItem, type Navigati
  * stands before it and it starts with `/` — `/tools#tab=curl` is still `/tools`.
  */
 export declare function normalizeNavPath(path: string): string;
-/** A flattened, gated catalogue entry — a leaf plus where it lives (for grouping). */
+/** A flattened, gated catalog entry — a leaf plus where it lives (for grouping). */
 export interface SearchCatalogueEntry extends NavItem {
     /** Owning domain id (absent for ungrouped items). */
     domainId?: string;
@@ -57,7 +57,7 @@ export declare function deriveBreadcrumbTrail(model: NavigationModel, path: stri
  * The flat list of searchable destinations — every visible (gated,
  * non-`deepLinkOnly`) domain landing + item, `searchOnly` ones included, each tagged with its domain/group so
  * results can be grouped. Drives HeaderSearch's instant pages layer *and* the
- * command palette; replaces every hand-listed search catalogue (so a feature is
+ * command palette; replaces every hand-listed search catalog (so a feature is
  * findable the moment it's registered).
  */
 export declare function deriveSearchCatalogue(model: NavigationModel, gate?: GateFn): SearchCatalogueEntry[];

package/dist/core/navigation/navigationSelectors.js

@@ -1,5 +1,5 @@
 // Pure derivations off the {@link NavigationModel}. Every nav surface (side nav,
-// hub tiles, breadcrumbs, search catalogue, palette, the coverage test) reads the
+// hub tiles, breadcrumbs, search catalog, palette, the coverage test) reads the
 // model exclusively through these — there is no second list to keep in sync. They
 // import nothing from React, so they run identically in the client, in a server
 // test, and in the CI coverage check.
@@ -118,7 +118,7 @@ export function deriveBreadcrumbTrail(model, path, gate = allowAllGate) {
  * The flat list of searchable destinations — every visible (gated,
  * non-`deepLinkOnly`) domain landing + item, `searchOnly` ones included, each tagged with its domain/group so
  * results can be grouped. Drives HeaderSearch's instant pages layer *and* the
- * command palette; replaces every hand-listed search catalogue (so a feature is
+ * command palette; replaces every hand-listed search catalog (so a feature is
  * findable the moment it's registered).
  */
 export function deriveSearchCatalogue(model, gate = allowAllGate) {

package/dist/core/navigation/searchCatalogue.d.ts

@@ -12,8 +12,8 @@ export interface CatalogueResultGroup {
     items: CatalogueHit[];
 }
 /**
- * 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 declare function rankCatalogue(catalogue: SearchCatalogueEntry[], query: string): CatalogueHit[];
 /**

package/dist/core/navigation/searchCatalogue.js

@@ -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.
@@ -39,8 +39,8 @@ function scoreEntry(entry, q) {
     return 0;
 }
 /**
- * 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, query) {
     const q = norm(query);
@@ -53,7 +53,7 @@ export function rankCatalogue(catalogue, query) {
             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/dist/core/palette/fuzzyRank.d.ts

@@ -7,7 +7,7 @@ import type { NavItem } from '../navigation/index.js';
 export declare function searchInitials(label: string): string;
 /**
  * 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/dist/core/palette/fuzzyRank.js

@@ -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),
@@ -42,7 +42,7 @@ function haystackFor(item) {
 }
 /**
  * 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.
@@ -63,7 +63,7 @@ function rankedIndexes(haystack, q) {
 }
 /**
  * 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/dist/core/tokens/registry.d.ts

@@ -36,7 +36,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;

package/dist/core/tokens/registry.js

@@ -405,7 +405,7 @@ export const BASE_TOKENS = [
         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/dist/core/wire/__fixtures__/rowsMarshalWorker.js

@@ -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/dist/core/wire/index.d.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/dist/core/wire/index.js

@@ -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/dist/core/wire/ingress.d.ts

@@ -1,11 +1,11 @@
 import { type MarshallerRegistry } 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 declare 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;
@@ -21,12 +21,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>;

package/dist/core/wire/ingress.js

@@ -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,13 +47,13 @@
  * });
  * ```
  *
- * 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';
 import { createMarshalWorkerClient } from './marshalWorker.js';
 import { marshalInbound, } 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';
 /**
  * Build the ingress. One per app — it caches a worker per `workerEntry`, and two
@@ -68,7 +68,7 @@ export const createMarshalledIngress = (options) => {
         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,
@@ -88,10 +88,10 @@ export const createMarshalledIngress = (options) => {
     const marshallerFor = (tokenId) => {
         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 },
@@ -106,8 +106,8 @@ export const createMarshalledIngress = (options) => {
         },
         async ingestRequest(tokenId, request) {
             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/dist/core/wire/marshalWorker.d.ts

@@ -58,7 +58,7 @@ export interface MarshalWorkerClient extends MarshalWorker {
     dispose(): Promise<void>;
 }
 /**
- * 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