@rexezuge/tooling 0.0.0-stage → 1.0.0

package/dist/scripts/wrangler-config/types.js

@@ -0,0 +1,49 @@
+/**
+ * Shared paths, placeholders and shape definitions for the wrangler config helpers.
+ *
+ * Provenance: ported from Edge-Sonic's `scripts/lib/wrangler-config/types.ts`.
+ * Every script that reads or writes `wrangler.jsonc` resolves it here, so the
+ * backup workflow cannot end up inspecting a different file than the deploy
+ * materialized.
+ *
+ * The paths default to `process.cwd()`, which is the repo root in every consumer:
+ * the scripts run as `pnpm exec tsx scripts/deploy/…` from there. `WRANGLER_CONFIG_PATH`
+ * / `WRANGLER_TEMPLATE_PATH` override them for a caller that is not in the repo
+ * root, which is the one case the cwd default gets wrong.
+ */
+import path from 'node:path';
+/** The config the deploy targets. */
+export const CONFIG_PATH = process.env['WRANGLER_CONFIG_PATH'] ?? path.join(process.cwd(), 'wrangler.jsonc');
+/** The committed template the config is materialized from. */
+export const TEMPLATE_PATH = process.env['WRANGLER_TEMPLATE_PATH'] ?? path.join(process.cwd(), 'apps/api/wrangler.template.jsonc');
+/**
+ * The id a template carries for a D1 database that does not exist yet.
+ *
+ * `provisionWranglerResources` replaces it with a real id; the backup scripts
+ * refuse to export while it is still in place, because a database that was just
+ * created holds no user data.
+ */
+export const DEFAULT_UUID = '00000000-0000-0000-0000-000000000000';
+/** The placeholder for a KV namespace id and for a Secrets Store id. */
+export const DEFAULT_HEX_ID = '00000000000000000000000000000000';
+/** The Secrets Store name a deployment uses. */
+export const DEFAULT_SECRET_STORE_NAME = 'default';
+/**
+ * Fallback when the config declares no `name`, used to derive resource names.
+ *
+ * Overridable per consumer with `WRANGLER_WORKER_NAME`, which keeps the default
+ * honest rather than baking one repo's name into the kit.
+ */
+export const DEFAULT_WORKER_NAME = process.env['WRANGLER_WORKER_NAME'] ?? 'my-worker';
+/**
+ * KV bindings a deployment always needs, and the namespace each maps to.
+ *
+ * A consumer whose worker has no cache binding passes an empty map; a consumer
+ * with one names it here or leaves the derived `<worker>-<BINDING>` convention.
+ */
+export const DEFAULT_KV_NAMESPACE_NAMES = {
+    CACHE: `${DEFAULT_WORKER_NAME}-cache`,
+};
+/** Dimensions of a Vectorize index this kit provisions. */
+export const VECTORIZE_DIMENSIONS = 1024;
+//# sourceMappingURL=types.js.map

package/dist/scripts/wrangler-config/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/scripts/wrangler-config/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,qCAAqC;AACrC,MAAM,CAAC,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,gBAAgB,CAAC,CAAC;AAE7G,8DAA8D;AAC9D,MAAM,CAAC,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,kCAAkC,CAAC,CAAC;AAEnI;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,sCAAsC,CAAC;AAEnE,wEAAwE;AACxE,MAAM,CAAC,MAAM,cAAc,GAAG,kCAAkC,CAAC;AAEjE,gDAAgD;AAChD,MAAM,CAAC,MAAM,yBAAyB,GAAG,SAAS,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,IAAI,WAAW,CAAC;AAEtF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAA2B;IAChE,KAAK,EAAE,GAAG,mBAAmB,QAAQ;CACtC,CAAC;AAEF,2DAA2D;AAC3D,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,CAAC"}

package/dist/test/integration-migrations.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Applying the migration directory to a D1 binding — as a factory.
+ *
+ * Provenance: converged from `test/integration/helpers/migrations.ts` in six repos
+ * (AWS-AccessBridge, ChordDHT-Tracker, Durable-DAV, Durable-DAV-Router, Edge-Git,
+ * Mail-Meow) and `test/helpers/migrations.ts` in two more (CalDAV-Bridge,
+ * Edge-Sonic). All eight are the same file: a SQL splitter plus a range-addressed
+ * `applyMigrations`.
+ *
+ * ### Why it is a factory and not a module
+ *
+ * Every source file hardcodes where the migrations live, either as a
+ * `__INTEGRATION_MIGRATION_FILES__` binding injected by the Vitest config's
+ * `define`, or as a path derived from `import.meta.url`. The kit cannot know
+ * either, so the directory is an argument and the injection stays available as an
+ * option. One call to `createMigrationHelper({ migrationsDir })` gives the consumer
+ * the same helper their repo already has.
+ *
+ * ### What each source contributes
+ *
+ * - **Durable-DAV** — the trigger-aware splitter. `CREATE TRIGGER … BEGIN … END;`
+ *   bodies contain semicolons that must not split, and a naive splitter produces
+ *   statements SQLite rejects mid-migration. The BEGIN/END depth is tracked only
+ *   outside strings and comments, and the word *before* `TRIGGER` disambiguates
+ *   `CREATE TRIGGER` from a table called `trigger`. Durable-DAV also applies one
+ *   file per `batch()` and names the offending statement in the error, which is
+ *   the difference between "0007 failed" and a line number.
+ * - **AWS-AccessBridge** — the once-per-database guard. D1 records which
+ *   migrations have run; this helper does the same, because `ALTER TABLE … ADD
+ *   COLUMN` is not idempotent in SQLite and re-running the bundle fails with
+ *   "duplicate column name". A `WeakMap` keyed on the binding is the right scope
+ *   because each test file gets its own database. AWS also keeps `next` out of the
+ *   line-comment branch, which never reads it, and preserves newlines inside block
+ *   comments so an error's line numbers still point at the file.
+ * - **Edge-Sonic** — reading the directory off disk rather than a `define`
+ *   binding, because a test that names one hardcoded file cannot tell **a new
+ *   migration** from **an edit to an old one**, so it goes on passing through a
+ *   schema change that never reached production.
+ *
+ * ### The splitter is not here
+ *
+ * The statement splitter — with all of Durable-DAV's trigger-aware rules and its
+ * comment-level history — lives once, in `@rexezuge/d1`. `@rexezuge/identity`'s
+ * migration applier delegates to the same module, so the splitter cannot drift
+ * between the suite helper and the production applier. The re-exports below keep
+ * this file's public surface identical to the source repos'.
+ *
+ * ### The lock is asserted, not reimplemented
+ *
+ * D1 records applied migrations by *filename*, so an applied migration is immutable
+ * in fact while being an ordinary text file in appearance. That fact lives in
+ * `migrations/migrations.lock.json`, and the rules that check it live once, in
+ * `scripts/verify-migrations.ts` — the same module the CI gate runs. This helper
+ * deliberately does not parse the lock itself: a second implementation of a thing
+ * already written is free to disagree with the first, and the two disagreeing would
+ * leave a suite green against a lock CI rejects.
+ *
+ * ### Generic over the binding
+ *
+ * `D1DatabaseLike` is structural — `prepare`, and `batch` when the runtime has it
+ * — so a fake D1 in a unit test, a real D1 in the workerd integration suite, and
+ * Miniflare's D1 all satisfy it without an import of `@cloudflare/workers-types`.
+ * `batch` is used when present (Durable-DAV's shape: one round trip per file, and
+ * the failure names the file) and a sequential `prepare().run()` loop otherwise
+ * (AWS's shape: works on a binding with no batch support).
+ */
+import { executableStatements, splitSql } from '@rexezuge/d1';
+/**
+ * One migration file, as it is read.
+ */
+export interface MigrationFile {
+    /** Bare filename, e.g. `0007_replication.sql`. */
+    name: string;
+    /** The file's full text. */
+    sql: string;
+}
+/**
+ * The subset of a D1 prepared statement this helper uses.
+ */
+export interface D1PreparedStatementLike {
+    run(): Promise<unknown>;
+}
+/**
+ * The subset of a D1 binding this helper uses.
+ *
+ * `batch` is optional because not every binding that can prepare a statement can
+ * batch one; where it exists it is the better path, and where it does not the
+ * sequential loop is equivalent for a migration whose statements are independent.
+ */
+export interface D1DatabaseLike {
+    prepare(sql: string): D1PreparedStatementLike;
+    batch?(statements: readonly D1PreparedStatementLike[]): Promise<unknown>;
+}
+/**
+ * A closed range of migration files, by filename.
+ *
+ * Both ends inclusive, because "up to and including 0006" is the natural way to
+ * seed a pre-migration database and then apply the migration under test.
+ */
+export interface MigrationRange {
+    from?: string;
+    to?: string;
+}
+/**
+ * What `createMigrationHelper` accepts.
+ */
+export interface MigrationHelperOptions {
+    /**
+     * Directory holding the `.sql` files. Read top-level only, matching wrangler's
+     * default `${migrationsDir}/*.sql`, so the helper describes exactly the set
+     * wrangler will run.
+     */
+    readonly migrationsDir: string;
+    /**
+     * Migration files to use instead of reading `migrationsDir`.
+     *
+     * The escape hatch for a harness that embeds the SQL at build time. Same shape
+     * as the `__INTEGRATION_MIGRATION_FILES__` binding the source repos inject.
+     */
+    readonly files?: readonly MigrationFile[];
+}
+/**
+ * A bound migration helper.
+ */
+export interface MigrationHelper {
+    /** Every migration, in apply order. */
+    migrationFiles(): MigrationFile[];
+    /** The filenames, in apply order. */
+    migrationFileNames(): string[];
+    /** The concatenation of every file, in apply order — what a fresh database becomes. */
+    migrationSql(): string;
+    /** One file's SQL, by name. "What does *this* file say", not "what does the set say". */
+    migrationSqlOf(name: string): string;
+    /** Split one file into statements, comments included. */
+    splitSql(sql: string): string[];
+    /** The statements of one file that SQLite will actually execute. */
+    executableStatements(sql: string): string[];
+    /**
+     * Apply a range of migrations, at most once per database and range.
+     *
+     * Per file rather than one batch for everything, so a test can stop between
+     * files: the identity-upgrade test needs to seed the *pre-0004* shape and then
+     * apply 0004 to it.
+     */
+    applyMigrations(db: D1DatabaseLike, range?: MigrationRange): Promise<void>;
+}
+/**
+ * Reads every `.sql` file in `dir`, in apply order.
+ *
+ * Sort is the filename sort D1 itself uses, rather than a numeric parse of the
+ * prefix: wrangler hands the directory to SQLite in lexicographic order, so a
+ * suite that reads it numerically disagrees with production on any prefix wider
+ * than four digits.
+ */
+export declare function readMigrationFiles(dir: string): MigrationFile[];
+/** Re-exported for surface parity with the source repos — the rules live in @rexezuge/d1. */
+export { executableStatements, splitSql };
+/**
+ * Bind a migration directory into a helper.
+ *
+ * ```ts
+ * const migrations = createMigrationHelper({ migrationsDir: path.join(REPO_ROOT, 'migrations') });
+ * await migrations.applyMigrations(env.DB);
+ * ```
+ */
+export declare function createMigrationHelper(options: MigrationHelperOptions): MigrationHelper;
+//# sourceMappingURL=integration-migrations.d.ts.map

package/dist/test/integration-migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-migrations.d.ts","sourceRoot":"","sources":["../../src/test/integration-migrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAEH,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAI9D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,uBAAuB,CAAC;IAC9C,KAAK,CAAC,CAAC,UAAU,EAAE,SAAS,uBAAuB,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1E;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,uCAAuC;IACvC,cAAc,IAAI,aAAa,EAAE,CAAC;IAClC,qCAAqC;IACrC,kBAAkB,IAAI,MAAM,EAAE,CAAC;IAC/B,uFAAuF;IACvF,YAAY,IAAI,MAAM,CAAC;IACvB,yFAAyF;IACzF,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACrC,yDAAyD;IACzD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAChC,oEAAoE;IACpE,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5C;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5E;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,EAAE,CAM/D;AAeD,6FAA6F;AAC7F,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,CAAC;AAE1C;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,GAAG,eAAe,CAsEtF"}

package/dist/test/integration-migrations.js

@@ -0,0 +1,171 @@
+/**
+ * Applying the migration directory to a D1 binding — as a factory.
+ *
+ * Provenance: converged from `test/integration/helpers/migrations.ts` in six repos
+ * (AWS-AccessBridge, ChordDHT-Tracker, Durable-DAV, Durable-DAV-Router, Edge-Git,
+ * Mail-Meow) and `test/helpers/migrations.ts` in two more (CalDAV-Bridge,
+ * Edge-Sonic). All eight are the same file: a SQL splitter plus a range-addressed
+ * `applyMigrations`.
+ *
+ * ### Why it is a factory and not a module
+ *
+ * Every source file hardcodes where the migrations live, either as a
+ * `__INTEGRATION_MIGRATION_FILES__` binding injected by the Vitest config's
+ * `define`, or as a path derived from `import.meta.url`. The kit cannot know
+ * either, so the directory is an argument and the injection stays available as an
+ * option. One call to `createMigrationHelper({ migrationsDir })` gives the consumer
+ * the same helper their repo already has.
+ *
+ * ### What each source contributes
+ *
+ * - **Durable-DAV** — the trigger-aware splitter. `CREATE TRIGGER … BEGIN … END;`
+ *   bodies contain semicolons that must not split, and a naive splitter produces
+ *   statements SQLite rejects mid-migration. The BEGIN/END depth is tracked only
+ *   outside strings and comments, and the word *before* `TRIGGER` disambiguates
+ *   `CREATE TRIGGER` from a table called `trigger`. Durable-DAV also applies one
+ *   file per `batch()` and names the offending statement in the error, which is
+ *   the difference between "0007 failed" and a line number.
+ * - **AWS-AccessBridge** — the once-per-database guard. D1 records which
+ *   migrations have run; this helper does the same, because `ALTER TABLE … ADD
+ *   COLUMN` is not idempotent in SQLite and re-running the bundle fails with
+ *   "duplicate column name". A `WeakMap` keyed on the binding is the right scope
+ *   because each test file gets its own database. AWS also keeps `next` out of the
+ *   line-comment branch, which never reads it, and preserves newlines inside block
+ *   comments so an error's line numbers still point at the file.
+ * - **Edge-Sonic** — reading the directory off disk rather than a `define`
+ *   binding, because a test that names one hardcoded file cannot tell **a new
+ *   migration** from **an edit to an old one**, so it goes on passing through a
+ *   schema change that never reached production.
+ *
+ * ### The splitter is not here
+ *
+ * The statement splitter — with all of Durable-DAV's trigger-aware rules and its
+ * comment-level history — lives once, in `@rexezuge/d1`. `@rexezuge/identity`'s
+ * migration applier delegates to the same module, so the splitter cannot drift
+ * between the suite helper and the production applier. The re-exports below keep
+ * this file's public surface identical to the source repos'.
+ *
+ * ### The lock is asserted, not reimplemented
+ *
+ * D1 records applied migrations by *filename*, so an applied migration is immutable
+ * in fact while being an ordinary text file in appearance. That fact lives in
+ * `migrations/migrations.lock.json`, and the rules that check it live once, in
+ * `scripts/verify-migrations.ts` — the same module the CI gate runs. This helper
+ * deliberately does not parse the lock itself: a second implementation of a thing
+ * already written is free to disagree with the first, and the two disagreeing would
+ * leave a suite green against a lock CI rejects.
+ *
+ * ### Generic over the binding
+ *
+ * `D1DatabaseLike` is structural — `prepare`, and `batch` when the runtime has it
+ * — so a fake D1 in a unit test, a real D1 in the workerd integration suite, and
+ * Miniflare's D1 all satisfy it without an import of `@cloudflare/workers-types`.
+ * `batch` is used when present (Durable-DAV's shape: one round trip per file, and
+ * the failure names the file) and a sequential `prepare().run()` loop otherwise
+ * (AWS's shape: works on a binding with no batch support).
+ */
+import { executableStatements, splitSql } from '@rexezuge/d1';
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Reads every `.sql` file in `dir`, in apply order.
+ *
+ * Sort is the filename sort D1 itself uses, rather than a numeric parse of the
+ * prefix: wrangler hands the directory to SQLite in lexicographic order, so a
+ * suite that reads it numerically disagrees with production on any prefix wider
+ * than four digits.
+ */
+export function readMigrationFiles(dir) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.sql'))
+        .map((entry) => ({ name: entry.name, sql: readFileSync(join(dir, entry.name), 'utf8') }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+/**
+ * Strip leading `--` and block comments, which the splitter folds into the
+ * statement it then reports on.
+ */
+function stripLeadingComments(statement) {
+    let out = statement;
+    for (;;) {
+        const next = out.replace(/^\s*(?:--[^\n]*\n|\/\*[\s\S]*?\*\/)\s*/, '');
+        if (next === out)
+            return out.trim();
+        out = next;
+    }
+}
+/** Re-exported for surface parity with the source repos — the rules live in @rexezuge/d1. */
+export { executableStatements, splitSql };
+/**
+ * Bind a migration directory into a helper.
+ *
+ * ```ts
+ * const migrations = createMigrationHelper({ migrationsDir: path.join(REPO_ROOT, 'migrations') });
+ * await migrations.applyMigrations(env.DB);
+ * ```
+ */
+export function createMigrationHelper(options) {
+    const files = options.files !== undefined ? [...options.files] : readMigrationFiles(options.migrationsDir);
+    /**
+     * Databases this helper has already migrated, keyed by the range applied.
+     *
+     * A `WeakMap` rather than a module-level `Set`, because the guard is per
+     * binding: two databases in one suite each need the bundle applied once, and a
+     * module-level set would silently skip the second.
+     */
+    const applied = new WeakMap();
+    const indexOf = (name, fallback) => {
+        if (name === undefined)
+            return fallback;
+        const found = files.findIndex((file) => file.name === name);
+        if (found === -1) {
+            throw new Error(`Unknown migration file: ${name}. Available: ${files.map((file) => file.name).join(', ')}`);
+        }
+        return found;
+    };
+    return {
+        migrationFiles: () => files.map((file) => ({ ...file })),
+        migrationFileNames: () => files.map((file) => file.name),
+        migrationSql: () => files.map((file) => file.sql).join('\n'),
+        migrationSqlOf: (name) => {
+            const file = files.find((candidate) => candidate.name === name);
+            if (file === undefined) {
+                throw new Error(`Unknown migration file: ${name}. Available: ${files.map((candidate) => candidate.name).join(', ')}`);
+            }
+            return file.sql;
+        },
+        splitSql,
+        executableStatements,
+        applyMigrations: async (db, range) => {
+            const start = indexOf(range?.from, 0);
+            const end = indexOf(range?.to, files.length - 1);
+            const key = `${start}:${end}`;
+            if (applied.get(db) === key)
+                return;
+            const applicable = files.slice(start, end + 1);
+            for (const file of applicable) {
+                const statements = executableStatements(file.sql);
+                if (statements.length === 0)
+                    continue;
+                if (typeof db.batch === 'function') {
+                    try {
+                        await db.batch(statements.map((sql) => db.prepare(sql)));
+                    }
+                    catch (error) {
+                        // A batch reports only the file's single failure, so name the statement:
+                        // a migration error that says nothing about which of its nine statements
+                        // broke is a migration error nobody fixes.
+                        throw new Error(`${file.name}: batch of ${statements.length} statements failed at ${stripLeadingComments(statements.at(-1) ?? '').slice(0, 200)}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+                    }
+                    continue;
+                }
+                for (const sql of statements) {
+                    await db.prepare(sql).run();
+                }
+            }
+            applied.set(db, key);
+        },
+    };
+}
+//# sourceMappingURL=integration-migrations.js.map

package/dist/test/integration-migrations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-migrations.js","sourceRoot":"","sources":["../../src/test/integration-migrations.ts"],"names":[],"mappings":"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"}

package/dist/test/mocks/cloudflare-workers.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Stand-in for the `cloudflare:workers` module, which has no Node equivalent.
+ *
+ * Provenance: converged from the eight copies at `test/mocks/cloudflare-workers.ts`
+ * (AWS-AccessBridge, CalDAV-Bridge, ChordDHT-Tracker, Durable-DAV, Edge-Git,
+ * Edge-Sonic, Mail-Meow, Mail-Otter). All eight are the same twenty lines; the
+ * union is three base classes and the union exists because each repo discovered a
+ * missing one the hard way.
+ *
+ * ### What each source contributes
+ *
+ * - **DurableObject** — every copy. Stores `ctx` and `env` so a real DO class can
+ *   be constructed and its lifecycle RPCs driven directly, without Miniflare.
+ * - **`RpcTarget`** — Durable-DAV's, and the reason is load-bearing rather than
+ *   tidy: `dofs`' `Fs` class `extends RpcTarget`, so the module fails to evaluate
+ *   with *"Class extends value undefined"* when the base is missing. That is a
+ *   module-load error, not a test failure, so it surfaces as an unimportable
+ *   `dav-store` barrel and no unit test can reach `DavRepository`. Deliberately
+ *   empty: on the platform it marks which methods are callable across an RPC
+ *   boundary, and nothing in a Node suite calls those through RPC. An empty base
+ *   keeps the fake honest instead of pretending to implement dispatch.
+ * - **`WorkflowEntrypoint`** — Edge-Git, Edge-Sonic, Mail-Meow, Mail-Otter. A
+ *   Workflow class extends it, so the mock must provide it or the module fails the
+ *   same way — a **startup** error, which therefore takes down every suite that
+ *   reaches `apps/background` for an unrelated reason. Edge-Sonic's is the shape
+ *   kept: it stores `ctx` as well as `env`, because the failure policy under test
+ *   in `runWorkflow` lives in a plain function precisely so it can be exercised
+ *   without workerd, and that policy reads the execution context.
+ *
+ * ### Why the ambient types are declared here rather than imported
+ *
+ * The source repos name `DurableObjectState`, `ExecutionContext` and `Env`
+ * unqualified, which resolves only because `worker-configuration.d.ts` and
+ * `@cloudflare/workers-types` are ambient inside a Wrangler project. This copy is
+ * imported by the kit's own typecheck, where neither exists, so the two state
+ * shapes are declared locally and `TEnv` defaults to `unknown` instead of `Env`
+ * (Edge-Sonic's form). A local declaration shadows the ambient one inside this
+ * file only, so a consumer's copy typechecks against their generated types
+ * exactly as the original did.
+ *
+ * ### Usage in a consumer
+ *
+ * Copy this file to `<repo>/test/mocks/cloudflare-workers.ts` and alias the
+ * specifier in the Vitest config — `defineUnitVitestConfig()` already does:
+ *
+ * ```jsonc
+ * // wrangler.jsonc / vitest alias
+ * "cloudflare:workers": "test/mocks/cloudflare-workers.ts"
+ * ```
+ *
+ * Only what a test actually imports is exported. A symbol here that nothing
+ * imports is not a safety net; it is a claim that something depends on it.
+ */
+/**
+ * The subset of `DurableObjectState` a Node test reaches.
+ *
+ * Declared structurally rather than imported: `id`, `storage` and `waitUntil` are
+ * the three a hand-driven lifecycle touches, and nothing here needs the rest.
+ */
+export interface DurableObjectState {
+    readonly id: {
+        toString(): string;
+        readonly name?: string;
+    };
+}
+/**
+ * The subset of `ExecutionContext` a Node test reaches.
+ *
+ * `waitUntil` is present because a Workflow's `run()` is driven through it, and
+ * `passThroughOnException` is absent on purpose — nothing in a Node suite wires a
+ * request through it.
+ */
+export interface ExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+}
+/**
+ * The base class every Durable Object extends.
+ *
+ * `protected`, exactly as on the platform: a DO subclass reads `this.env` and
+ * `this.ctx`, and nothing outside it may.
+ */
+declare class DurableObject<TEnv = unknown> {
+    protected ctx: DurableObjectState;
+    protected env: TEnv;
+    constructor(ctx: DurableObjectState, env: TEnv);
+}
+/**
+ * The base class `dofs`' `Fs` extends. See the header: an empty body is the
+ * whole point, and a missing class is a module-load failure.
+ */
+declare class RpcTarget {
+}
+/**
+ * The base class every Workflow extends.
+ *
+ * `ctx` is `ExecutionContext` rather than `unknown` (Mail-Meow/Mail-Otter's
+ * form) because a Workflow's step code reads it; `void ctx` to silence the unused
+ * warning would be a lie about which of the two a subclass uses.
+ */
+declare class WorkflowEntrypoint<TEnv = unknown> {
+    protected ctx: ExecutionContext;
+    protected env: TEnv;
+    constructor(ctx: ExecutionContext, env: TEnv);
+}
+export { DurableObject, RpcTarget, WorkflowEntrypoint };
+//# sourceMappingURL=cloudflare-workers.d.ts.map

package/dist/test/mocks/cloudflare-workers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-workers.d.ts","sourceRoot":"","sources":["../../../src/test/mocks/cloudflare-workers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE;QAAE,QAAQ,IAAI,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7D;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;CAC5C;AAED;;;;;GAKG;AACH,cAAM,aAAa,CAAC,IAAI,GAAG,OAAO;IAChC,SAAS,CAAC,GAAG,EAAE,kBAAkB,CAAC;IAClC,SAAS,CAAC,GAAG,EAAE,IAAI,CAAC;gBAER,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,IAAI;CAI/C;AAED;;;GAGG;AACH,cAAM,SAAS;CAAG;AAElB;;;;;;GAMG;AACH,cAAM,kBAAkB,CAAC,IAAI,GAAG,OAAO;IACrC,SAAS,CAAC,GAAG,EAAE,gBAAgB,CAAC;IAChC,SAAS,CAAC,GAAG,EAAE,IAAI,CAAC;gBAER,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,IAAI;CAI7C;AAED,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/test/mocks/cloudflare-workers.js

@@ -0,0 +1,90 @@
+/**
+ * Stand-in for the `cloudflare:workers` module, which has no Node equivalent.
+ *
+ * Provenance: converged from the eight copies at `test/mocks/cloudflare-workers.ts`
+ * (AWS-AccessBridge, CalDAV-Bridge, ChordDHT-Tracker, Durable-DAV, Edge-Git,
+ * Edge-Sonic, Mail-Meow, Mail-Otter). All eight are the same twenty lines; the
+ * union is three base classes and the union exists because each repo discovered a
+ * missing one the hard way.
+ *
+ * ### What each source contributes
+ *
+ * - **DurableObject** — every copy. Stores `ctx` and `env` so a real DO class can
+ *   be constructed and its lifecycle RPCs driven directly, without Miniflare.
+ * - **`RpcTarget`** — Durable-DAV's, and the reason is load-bearing rather than
+ *   tidy: `dofs`' `Fs` class `extends RpcTarget`, so the module fails to evaluate
+ *   with *"Class extends value undefined"* when the base is missing. That is a
+ *   module-load error, not a test failure, so it surfaces as an unimportable
+ *   `dav-store` barrel and no unit test can reach `DavRepository`. Deliberately
+ *   empty: on the platform it marks which methods are callable across an RPC
+ *   boundary, and nothing in a Node suite calls those through RPC. An empty base
+ *   keeps the fake honest instead of pretending to implement dispatch.
+ * - **`WorkflowEntrypoint`** — Edge-Git, Edge-Sonic, Mail-Meow, Mail-Otter. A
+ *   Workflow class extends it, so the mock must provide it or the module fails the
+ *   same way — a **startup** error, which therefore takes down every suite that
+ *   reaches `apps/background` for an unrelated reason. Edge-Sonic's is the shape
+ *   kept: it stores `ctx` as well as `env`, because the failure policy under test
+ *   in `runWorkflow` lives in a plain function precisely so it can be exercised
+ *   without workerd, and that policy reads the execution context.
+ *
+ * ### Why the ambient types are declared here rather than imported
+ *
+ * The source repos name `DurableObjectState`, `ExecutionContext` and `Env`
+ * unqualified, which resolves only because `worker-configuration.d.ts` and
+ * `@cloudflare/workers-types` are ambient inside a Wrangler project. This copy is
+ * imported by the kit's own typecheck, where neither exists, so the two state
+ * shapes are declared locally and `TEnv` defaults to `unknown` instead of `Env`
+ * (Edge-Sonic's form). A local declaration shadows the ambient one inside this
+ * file only, so a consumer's copy typechecks against their generated types
+ * exactly as the original did.
+ *
+ * ### Usage in a consumer
+ *
+ * Copy this file to `<repo>/test/mocks/cloudflare-workers.ts` and alias the
+ * specifier in the Vitest config — `defineUnitVitestConfig()` already does:
+ *
+ * ```jsonc
+ * // wrangler.jsonc / vitest alias
+ * "cloudflare:workers": "test/mocks/cloudflare-workers.ts"
+ * ```
+ *
+ * Only what a test actually imports is exported. A symbol here that nothing
+ * imports is not a safety net; it is a claim that something depends on it.
+ */
+/**
+ * The base class every Durable Object extends.
+ *
+ * `protected`, exactly as on the platform: a DO subclass reads `this.env` and
+ * `this.ctx`, and nothing outside it may.
+ */
+class DurableObject {
+    ctx;
+    env;
+    constructor(ctx, env) {
+        this.ctx = ctx;
+        this.env = env;
+    }
+}
+/**
+ * The base class `dofs`' `Fs` extends. See the header: an empty body is the
+ * whole point, and a missing class is a module-load failure.
+ */
+class RpcTarget {
+}
+/**
+ * The base class every Workflow extends.
+ *
+ * `ctx` is `ExecutionContext` rather than `unknown` (Mail-Meow/Mail-Otter's
+ * form) because a Workflow's step code reads it; `void ctx` to silence the unused
+ * warning would be a lie about which of the two a subclass uses.
+ */
+class WorkflowEntrypoint {
+    ctx;
+    env;
+    constructor(ctx, env) {
+        this.ctx = ctx;
+        this.env = env;
+    }
+}
+export { DurableObject, RpcTarget, WorkflowEntrypoint };
+//# sourceMappingURL=cloudflare-workers.js.map

package/dist/test/mocks/cloudflare-workers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-workers.js","sourceRoot":"","sources":["../../../src/test/mocks/cloudflare-workers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAuBH;;;;;GAKG;AACH,MAAM,aAAa;IACP,GAAG,CAAqB;IACxB,GAAG,CAAO;IAEpB,YAAY,GAAuB,EAAE,GAAS;QAC5C,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,SAAS;CAAG;AAElB;;;;;;GAMG;AACH,MAAM,kBAAkB;IACZ,GAAG,CAAmB;IACtB,GAAG,CAAO;IAEpB,YAAY,GAAqB,EAAE,GAAS;QAC1C,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;CACF;AAED,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,kBAAkB,EAAE,CAAC"}