@nage-api/compat 1.0.0-beta.2

package/dist/codemods/node-fs.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * The real filesystem behind `CodemodFileSystem`.
+ *
+ * Separated from the command layer so every test of the command runs against an
+ * in-memory map. The skip list is the same one the CLI's own scanner uses:
+ * walking `node_modules` of a legacy monorepo is minutes of work producing notes
+ * about somebody else's code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeCodemodFs = nodeCodemodFs;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const SKIP = new Set(['node_modules', 'dist', 'build', 'coverage', '.turbo', '.git', '.next']);
+async function walk(directory) {
+    const found = [];
+    for (const entry of await (0, promises_1.readdir)(directory, { withFileTypes: true })) {
+        if (SKIP.has(entry.name))
+            continue;
+        const path = (0, node_path_1.join)(directory, entry.name);
+        if (entry.isDirectory())
+            found.push(...(await walk(path)));
+        else if (entry.isFile())
+            found.push(path);
+    }
+    return found;
+}
+function nodeCodemodFs() {
+    return {
+        list: walk,
+        read: (path) => (0, promises_1.readFile)(path, 'utf8'),
+        write: (path, content) => (0, promises_1.writeFile)(path, content, 'utf8'),
+    };
+}
+//# sourceMappingURL=node-fs.js.map

package/dist/codemods/registry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The codemods §23.4 names, and the one it names that is not here.
+ *
+ * §23.4 lists five: entity/schema introspection → migration, `Result(res, x)` →
+ * `return x`, import-path rewrites, an env-var rename map, and config blob →
+ * `defineConfig`. Four are below. **Entity/schema introspection is not**, and
+ * not because it is hard:
+ *
+ *   - it is a generator, not a source transform — its input is a live database's
+ *     `information_schema`, which is the one thing none of the others need;
+ *   - its output is a migration in @nage-api/data-sql's format, and `nage db
+ *     migrate` is not a command yet (`docs/migration.md` → "What has no
+ *     equivalent yet"), so nothing could apply what it wrote;
+ *   - nothing in this repository could test it. Every codemod here has a
+ *     before/after fixture; that one would have a fixture of a schema dump
+ *     somebody typed, which proves the code runs and nothing about whether the
+ *     migration it emits matches a real database.
+ *
+ * Writing it against a guess would produce the most dangerous artefact in the
+ * set: a plausible schema migration for a production database.
+ */
+import type { Codemod } from './types.js';
+/** Rewrites first: a report is more useful once the certain edits have landed. */
+export declare const CODEMODS: readonly Codemod[];
+export declare function findCodemod(name: string): Codemod | undefined;
+//# sourceMappingURL=registry.d.ts.map

package/dist/codemods/registry.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * The codemods §23.4 names, and the one it names that is not here.
+ *
+ * §23.4 lists five: entity/schema introspection → migration, `Result(res, x)` →
+ * `return x`, import-path rewrites, an env-var rename map, and config blob →
+ * `defineConfig`. Four are below. **Entity/schema introspection is not**, and
+ * not because it is hard:
+ *
+ *   - it is a generator, not a source transform — its input is a live database's
+ *     `information_schema`, which is the one thing none of the others need;
+ *   - its output is a migration in @nage-api/data-sql's format, and `nage db
+ *     migrate` is not a command yet (`docs/migration.md` → "What has no
+ *     equivalent yet"), so nothing could apply what it wrote;
+ *   - nothing in this repository could test it. Every codemod here has a
+ *     before/after fixture; that one would have a fixture of a schema dump
+ *     somebody typed, which proves the code runs and nothing about whether the
+ *     migration it emits matches a real database.
+ *
+ * Writing it against a guess would produce the most dangerous artefact in the
+ * set: a plausible schema migration for a production database.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEMODS = void 0;
+exports.findCodemod = findCodemod;
+const config_inventory_js_1 = require("./config-inventory.js");
+const env_rename_js_1 = require("./env-rename.js");
+const import_paths_js_1 = require("./import-paths.js");
+const job_generics_js_1 = require("./job-generics.js");
+const res_envelope_js_1 = require("./res-envelope.js");
+/** Rewrites first: a report is more useful once the certain edits have landed. */
+exports.CODEMODS = [
+    import_paths_js_1.importPathsCodemod,
+    env_rename_js_1.envRenameCodemod,
+    res_envelope_js_1.resEnvelopeCodemod,
+    config_inventory_js_1.configInventoryCodemod,
+    job_generics_js_1.jobGenericsCodemod,
+];
+function findCodemod(name) {
+    return exports.CODEMODS.find((codemod) => codemod.name === name);
+}
+//# sourceMappingURL=registry.js.map

package/dist/codemods/res-envelope.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `Result(res, x)` → `return x` (PLAN.md §23.4) — as a report, not a rewrite.
+ *
+ * §23.4 lists this as automatable and it is the transform everybody wants,
+ * because eighteen legacy controllers do it. It is not applied here, for one
+ * decisive reason and two supporting ones.
+ *
+ * The decisive one: rewriting the body without removing the `@Res()` parameter
+ * produces a route that **hangs**. Nest switches a handler to library-specific
+ * mode the moment `@Res()` appears in its signature and stops doing anything
+ * with the returned value, so `return data` writes nothing and the request times
+ * out. The two edits have to land together or not at all — and removing a
+ * parameter changes the method signature, every direct caller and every test
+ * that constructs a fake response, none of which is decidable from the line
+ * being rewritten.
+ *
+ * The supporting ones: `Result(res, { data, message })` has no home for
+ * `message` in the new envelope (§16.1 has no such field), so an automatic
+ * rewrite either drops a string the UI renders or invents a field; and a
+ * paginated payload changes shape rather than moving, `{ records, offset, limit,
+ * count }` becoming `{ records, pagination: { … } }`.
+ *
+ * So each site gets a note saying which of those it is. `@nage-api/compat` covers
+ * the interim: repoint the import (the `import-paths` codemod does that), and
+ * the controller compiles and behaves while you work through this list.
+ */
+import { type Codemod } from './types.js';
+export declare const resEnvelopeCodemod: Codemod;
+//# sourceMappingURL=res-envelope.d.ts.map

package/dist/codemods/res-envelope.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * `Result(res, x)` → `return x` (PLAN.md §23.4) — as a report, not a rewrite.
+ *
+ * §23.4 lists this as automatable and it is the transform everybody wants,
+ * because eighteen legacy controllers do it. It is not applied here, for one
+ * decisive reason and two supporting ones.
+ *
+ * The decisive one: rewriting the body without removing the `@Res()` parameter
+ * produces a route that **hangs**. Nest switches a handler to library-specific
+ * mode the moment `@Res()` appears in its signature and stops doing anything
+ * with the returned value, so `return data` writes nothing and the request times
+ * out. The two edits have to land together or not at all — and removing a
+ * parameter changes the method signature, every direct caller and every test
+ * that constructs a fake response, none of which is decidable from the line
+ * being rewritten.
+ *
+ * The supporting ones: `Result(res, { data, message })` has no home for
+ * `message` in the new envelope (§16.1 has no such field), so an automatic
+ * rewrite either drops a string the UI renders or invents a field; and a
+ * paginated payload changes shape rather than moving, `{ records, offset, limit,
+ * count }` becoming `{ records, pagination: { … } }`.
+ *
+ * So each site gets a note saying which of those it is. `@nage-api/compat` covers
+ * the interim: repoint the import (the `import-paths` codemod does that), and
+ * the controller compiles and behaves while you work through this list.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resEnvelopeCodemod = void 0;
+const types_js_1 = require("./types.js");
+/** `Result(` / `Created(` but not `this.Result(`, `fooResult(`. */
+const BUILDER_CALL = /(?<![\w$.])(Result|Created)\s*\(/;
+const ERROR_BUILDER_CALL = /(?<![\w$.])ErrorResponse\s*\(/;
+const RES_PARAMETER = /@Res\s*\(\s*\)/;
+const DIRECT_WRITE = /\bres\s*\.\s*(?:json|send|status|end|render|redirect)\s*\(/;
+/**
+ * Payload keys that tell us which of the three shapes this call site is.
+ *
+ * Read from the call's own line only. A payload spread over several lines falls
+ * through to the generic message, which is the right way for a *report* to be
+ * wrong: it still names the line and still says to delete the `@Res()`
+ * parameter, and the developer reads the payload themselves.
+ */
+const PAGE_KEYS = /\b(?:records|count|offset|limit)\s*:/;
+const MESSAGE_KEY = /\bmessage\s*:/;
+function describePayload(line) {
+    if (PAGE_KEYS.test(line)) {
+        return {
+            message: 'This builds the legacy list body: `records` and the three counters at the top level.',
+            action: 'Return `Paginated<T>` — `{ records, pagination: { offset, limit, count } }` — and let `ResponseInterceptor` lift it into `data` + `meta.pagination` (§16.1). `parseQuery` from @nage-api/data produces the query that page answers.',
+        };
+    }
+    if (MESSAGE_KEY.test(line)) {
+        return {
+            message: 'This call carries a `message`, and the success envelope has no field for one (§16.1).',
+            action: 'Decide where it goes: into the resource if a client renders it, or nowhere if it was for a developer. Do not invent a `meta.message` — one application doing that is how the envelope stopped being a contract last time.',
+        };
+    }
+    return {
+        message: 'This builds the response body by hand.',
+        action: 'Return the value and delete the `@Res()` parameter in the same edit. Until then, `@nage-api/compat` supplies `Result`/`Created` so the controller compiles unchanged.',
+    };
+}
+exports.resEnvelopeCodemod = {
+    name: 'res-envelope',
+    kind: 'report',
+    section: '§23.4, §16.1',
+    summary: 'Locates every manual response build and `@Res()` handler, and says which of the three ports each one is.',
+    run(files) {
+        const notes = [];
+        for (const file of files) {
+            if (!(0, types_js_1.isSourceFile)(file.path))
+                continue;
+            file.content.split('\n').forEach((line, index) => {
+                if ((0, types_js_1.isCommented)(line))
+                    return;
+                const at = { path: file.path, line: index + 1 };
+                if (RES_PARAMETER.test(line)) {
+                    notes.push({
+                        ...at,
+                        rule: 'res-parameter',
+                        message: '`@Res()` puts the handler in library-specific mode: its return value is ignored, `ResponseInterceptor` never sees it and `AllExceptionsFilter` never sees its errors.',
+                        action: 'Remove the parameter in the same commit as the `return`. If the route genuinely owns its bytes — a download, a webhook callback — use `@NoEnvelope()` from @nage-api/core, which keeps the exception filter.',
+                    });
+                }
+                if (BUILDER_CALL.test(line)) {
+                    const described = describePayload(line);
+                    notes.push({ ...at, rule: 'manual-envelope', ...described });
+                }
+                if (ERROR_BUILDER_CALL.test(line)) {
+                    notes.push({
+                        ...at,
+                        rule: 'error-envelope',
+                        message: 'The legacy `ErrorResponse` echoed `error.message || error` to the client, so SQL text and upstream bodies reached callers (§5.2).',
+                        action: 'Throw a `@nage-api/core` error instead and let `AllExceptionsFilter` answer. Check what this site was echoing before you decide the replacement is equivalent.',
+                    });
+                }
+                if (DIRECT_WRITE.test(line)) {
+                    notes.push({
+                        ...at,
+                        rule: 'direct-write',
+                        message: 'The response object is written to directly.',
+                        action: 'Nothing downstream of this line is in the envelope or the filter. Port it with the handler, not separately.',
+                    });
+                }
+            });
+        }
+        return { changes: [], notes };
+    },
+};
+//# sourceMappingURL=res-envelope.js.map

package/dist/codemods/runner.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Runs codemods over a set of files, in order, threading the rewrites through.
+ *
+ * Sequential rather than parallel because a later rewrite has to see an earlier
+ * one's output: two codemods touching the same import line would otherwise both
+ * produce a "new" version of the file from the original text, and whichever was
+ * written last would win silently.
+ *
+ * The `kind` declaration is enforced here rather than trusted. A codemod that
+ * calls itself a report and returns a change is a bug that would otherwise
+ * appear as an unexplained edit in somebody's repository, so it fails loudly at
+ * the point the contract is broken.
+ */
+import type { CodemodEdit, CodemodNote, SourceFile } from './types.js';
+export interface AppliedEdit extends CodemodEdit {
+    readonly codemod: string;
+    readonly path: string;
+}
+export interface AttributedNote extends CodemodNote {
+    readonly codemod: string;
+}
+export interface CodemodRunReport {
+    /** Every file, with rewrites applied — unchanged files included. */
+    readonly files: readonly SourceFile[];
+    /** Paths whose content differs from the input. */
+    readonly changed: readonly string[];
+    readonly edits: readonly AppliedEdit[];
+    readonly notes: readonly AttributedNote[];
+}
+export interface CodemodRunOptions {
+    readonly files: readonly SourceFile[];
+    /** Names to run; defaults to all of `CODEMODS`, in registry order. */
+    readonly only?: readonly string[];
+}
+export declare function runCodemods(options: CodemodRunOptions): CodemodRunReport;
+//# sourceMappingURL=runner.d.ts.map

package/dist/codemods/runner.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Runs codemods over a set of files, in order, threading the rewrites through.
+ *
+ * Sequential rather than parallel because a later rewrite has to see an earlier
+ * one's output: two codemods touching the same import line would otherwise both
+ * produce a "new" version of the file from the original text, and whichever was
+ * written last would win silently.
+ *
+ * The `kind` declaration is enforced here rather than trusted. A codemod that
+ * calls itself a report and returns a change is a bug that would otherwise
+ * appear as an unexplained edit in somebody's repository, so it fails loudly at
+ * the point the contract is broken.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCodemods = runCodemods;
+const registry_js_1 = require("./registry.js");
+function runCodemods(options) {
+    const selected = options.only === undefined
+        ? registry_js_1.CODEMODS
+        : registry_js_1.CODEMODS.filter((codemod) => options.only?.includes(codemod.name) === true);
+    const working = new Map(options.files.map((file) => [file.path, file.content]));
+    const edits = [];
+    const notes = [];
+    for (const codemod of selected) {
+        const input = [...working].map(([path, content]) => ({ path, content }));
+        const result = codemod.run(input);
+        if (codemod.kind === 'report' && result.changes.length > 0) {
+            throw new Error(`codemod "${codemod.name}" is declared as a report but returned ${String(result.changes.length)} file change(s)`);
+        }
+        for (const change of result.changes) {
+            working.set(change.path, change.content);
+            edits.push(...change.edits.map((edit) => ({ ...edit, codemod: codemod.name, path: change.path })));
+        }
+        notes.push(...result.notes.map((note) => ({ ...note, codemod: codemod.name })));
+    }
+    const files = [...working].map(([path, content]) => ({ path, content }));
+    const original = new Map(options.files.map((file) => [file.path, file.content]));
+    const changed = files
+        .filter((file) => original.get(file.path) !== file.content)
+        .map((file) => file.path);
+    return { files, changed, edits, notes };
+}
+//# sourceMappingURL=runner.js.map

package/dist/codemods/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The codemod contract (PLAN.md §23.4).
+ *
+ * Every codemod declares a `kind`, and the distinction is the point of this
+ * whole surface:
+ *
+ *   - **rewrite** — the transform is decidable from the text alone and the
+ *     result is what a careful developer would have typed. Applied to the file.
+ *   - **report** — the change needs a fact the source does not carry (which
+ *     entity a `Job<any>` is about; whether a dropped `message` mattered; what a
+ *     variable's type is). A note is emitted naming the file, the line and what
+ *     to do, and nothing is edited.
+ *
+ * The split exists because a codemod that is right most of the time is worse
+ * than no codemod: it produces a large, plausible diff that a reviewer approves
+ * by scrolling. `report` is what the uncertain cases get instead of a guess, and
+ * `runCodemods` enforces that a `report` codemod returns no changes.
+ */
+/** One file, read into memory by the runner. */
+export interface SourceFile {
+    readonly path: string;
+    readonly content: string;
+}
+export type CodemodKind = 'rewrite' | 'report';
+/** One line a rewrite changed, kept so the runner can print a diff. */
+export interface CodemodEdit {
+    /** 1-based, as an editor counts. */
+    readonly line: number;
+    readonly before: string;
+    readonly after: string;
+}
+export interface CodemodChange {
+    readonly path: string;
+    readonly content: string;
+    readonly edits: readonly CodemodEdit[];
+}
+/** A place a developer has to look, and what to do when they get there. */
+export interface CodemodNote {
+    readonly path: string;
+    readonly line: number;
+    /** Stable identifier for the rule that fired, so notes can be triaged. */
+    readonly rule: string;
+    readonly message: string;
+    readonly action: string;
+}
+export interface CodemodResult {
+    readonly changes: readonly CodemodChange[];
+    readonly notes: readonly CodemodNote[];
+}
+export interface Codemod {
+    readonly name: string;
+    readonly kind: CodemodKind;
+    /** The PLAN.md section this implements, quoted in `--help` and the report. */
+    readonly section: string;
+    readonly summary: string;
+    run(files: readonly SourceFile[]): CodemodResult;
+}
+/** Files a source-level codemod looks at. */
+export declare const SOURCE_EXTENSIONS: readonly [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+export declare function isSourceFile(path: string): boolean;
+/**
+ * Whether a line is commented out.
+ *
+ * Deliberately the same cheap test `scanForLegacyPatterns` uses: a line-oriented
+ * scanner that tried to track block comments properly would need a lexer, and a
+ * lexer that is nearly right is how a codemod edits a line inside a comment.
+ */
+export declare function isCommented(line: string): boolean;
+//# sourceMappingURL=types.d.ts.map

package/dist/codemods/types.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * The codemod contract (PLAN.md §23.4).
+ *
+ * Every codemod declares a `kind`, and the distinction is the point of this
+ * whole surface:
+ *
+ *   - **rewrite** — the transform is decidable from the text alone and the
+ *     result is what a careful developer would have typed. Applied to the file.
+ *   - **report** — the change needs a fact the source does not carry (which
+ *     entity a `Job<any>` is about; whether a dropped `message` mattered; what a
+ *     variable's type is). A note is emitted naming the file, the line and what
+ *     to do, and nothing is edited.
+ *
+ * The split exists because a codemod that is right most of the time is worse
+ * than no codemod: it produces a large, plausible diff that a reviewer approves
+ * by scrolling. `report` is what the uncertain cases get instead of a guess, and
+ * `runCodemods` enforces that a `report` codemod returns no changes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOURCE_EXTENSIONS = void 0;
+exports.isSourceFile = isSourceFile;
+exports.isCommented = isCommented;
+/** Files a source-level codemod looks at. */
+exports.SOURCE_EXTENSIONS = ['.ts', '.mts', '.cts', '.js', '.mjs', '.cjs'];
+function isSourceFile(path) {
+    return exports.SOURCE_EXTENSIONS.some((extension) => path.endsWith(extension));
+}
+/**
+ * Whether a line is commented out.
+ *
+ * Deliberately the same cheap test `scanForLegacyPatterns` uses: a line-oriented
+ * scanner that tried to track block comments properly would need a lexer, and a
+ * lexer that is nearly right is how a codemod edits a line inside a comment.
+ */
+function isCommented(line) {
+    const trimmed = line.trimStart();
+    return trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*');
+}
+//# sourceMappingURL=types.js.map

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `@nage-api/compat` — the shim and the codemods for moving a `nest-core-v2`
+ * application onto `@nage-api` (PLAN.md §23, §25 P1).
+ *
+ * Two halves that do not depend on each other:
+ *
+ *   - the **runtime shim**, which lets a ported controller keep answering old
+ *     clients in the old shape while the rest of the migration happens;
+ *   - the **codemods**, which are a build-time tool and never loaded by an
+ *     application.
+ *
+ * This package is temporary by design. When no route carries `@LegacyEnvelope()`
+ * any more, remove the import and the dependency; nothing else is holding it.
+ */
+export { defaultLegacyBody, legacyErrorBody, type LegacyBodyBuilder, type LegacyBodyInput, type LegacyListBody, } from './legacy/envelope.js';
+export { Created, ErrorResponse, Result, type LegacyResponse, type LegacyResponseOptions, } from './legacy/responses.js';
+export { LegacyEnvelope, LEGACY_ENVELOPE_METADATA } from './legacy/legacy-envelope.decorator.js';
+export { LegacyEnvelopeInterceptor } from './legacy/legacy-envelope.interceptor.js';
+export { NageCompatModule } from './legacy/compat.module.js';
+export { NAGE_COMPAT_OPTIONS, type CompatOptions } from './legacy/options.js';
+export { CODEMODS, findCodemod } from './codemods/registry.js';
+export { runCodemods, type AppliedEdit, type AttributedNote, type CodemodRunOptions, type CodemodRunReport, } from './codemods/runner.js';
+export { isCommented, isSourceFile, SOURCE_EXTENSIONS, type Codemod, type CodemodChange, type CodemodEdit, type CodemodKind, type CodemodNote, type CodemodResult, type SourceFile, } from './codemods/types.js';
+export { runCodemodCli, type CodemodCliOptions, type CodemodFileSystem, type CodemodIo, } from './codemods/cli-main.js';
+export { nodeCodemodFs } from './codemods/node-fs.js';
+export { importPathsCodemod, REPORT_RULES, REWRITE_RULES } from './codemods/import-paths.js';
+export { envRenameCodemod, ENV_NOTES, ENV_RENAMES } from './codemods/env-rename.js';
+export { resEnvelopeCodemod } from './codemods/res-envelope.js';
+export { configInventoryCodemod } from './codemods/config-inventory.js';
+export { jobGenericsCodemod } from './codemods/job-generics.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * `@nage-api/compat` — the shim and the codemods for moving a `nest-core-v2`
+ * application onto `@nage-api` (PLAN.md §23, §25 P1).
+ *
+ * Two halves that do not depend on each other:
+ *
+ *   - the **runtime shim**, which lets a ported controller keep answering old
+ *     clients in the old shape while the rest of the migration happens;
+ *   - the **codemods**, which are a build-time tool and never loaded by an
+ *     application.
+ *
+ * This package is temporary by design. When no route carries `@LegacyEnvelope()`
+ * any more, remove the import and the dependency; nothing else is holding it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobGenericsCodemod = exports.configInventoryCodemod = exports.resEnvelopeCodemod = exports.ENV_RENAMES = exports.ENV_NOTES = exports.envRenameCodemod = exports.REWRITE_RULES = exports.REPORT_RULES = exports.importPathsCodemod = exports.nodeCodemodFs = exports.runCodemodCli = exports.SOURCE_EXTENSIONS = exports.isSourceFile = exports.isCommented = exports.runCodemods = exports.findCodemod = exports.CODEMODS = exports.NAGE_COMPAT_OPTIONS = exports.NageCompatModule = exports.LegacyEnvelopeInterceptor = exports.LEGACY_ENVELOPE_METADATA = exports.LegacyEnvelope = exports.Result = exports.ErrorResponse = exports.Created = exports.legacyErrorBody = exports.defaultLegacyBody = void 0;
+// ── Runtime shim (§23.1) ────────────────────────────────────────────────────
+var envelope_js_1 = require("./legacy/envelope.js");
+Object.defineProperty(exports, "defaultLegacyBody", { enumerable: true, get: function () { return envelope_js_1.defaultLegacyBody; } });
+Object.defineProperty(exports, "legacyErrorBody", { enumerable: true, get: function () { return envelope_js_1.legacyErrorBody; } });
+var responses_js_1 = require("./legacy/responses.js");
+Object.defineProperty(exports, "Created", { enumerable: true, get: function () { return responses_js_1.Created; } });
+Object.defineProperty(exports, "ErrorResponse", { enumerable: true, get: function () { return responses_js_1.ErrorResponse; } });
+Object.defineProperty(exports, "Result", { enumerable: true, get: function () { return responses_js_1.Result; } });
+var legacy_envelope_decorator_js_1 = require("./legacy/legacy-envelope.decorator.js");
+Object.defineProperty(exports, "LegacyEnvelope", { enumerable: true, get: function () { return legacy_envelope_decorator_js_1.LegacyEnvelope; } });
+Object.defineProperty(exports, "LEGACY_ENVELOPE_METADATA", { enumerable: true, get: function () { return legacy_envelope_decorator_js_1.LEGACY_ENVELOPE_METADATA; } });
+var legacy_envelope_interceptor_js_1 = require("./legacy/legacy-envelope.interceptor.js");
+Object.defineProperty(exports, "LegacyEnvelopeInterceptor", { enumerable: true, get: function () { return legacy_envelope_interceptor_js_1.LegacyEnvelopeInterceptor; } });
+var compat_module_js_1 = require("./legacy/compat.module.js");
+Object.defineProperty(exports, "NageCompatModule", { enumerable: true, get: function () { return compat_module_js_1.NageCompatModule; } });
+var options_js_1 = require("./legacy/options.js");
+Object.defineProperty(exports, "NAGE_COMPAT_OPTIONS", { enumerable: true, get: function () { return options_js_1.NAGE_COMPAT_OPTIONS; } });
+// ── Codemods (§23.4) ────────────────────────────────────────────────────────
+var registry_js_1 = require("./codemods/registry.js");
+Object.defineProperty(exports, "CODEMODS", { enumerable: true, get: function () { return registry_js_1.CODEMODS; } });
+Object.defineProperty(exports, "findCodemod", { enumerable: true, get: function () { return registry_js_1.findCodemod; } });
+var runner_js_1 = require("./codemods/runner.js");
+Object.defineProperty(exports, "runCodemods", { enumerable: true, get: function () { return runner_js_1.runCodemods; } });
+var types_js_1 = require("./codemods/types.js");
+Object.defineProperty(exports, "isCommented", { enumerable: true, get: function () { return types_js_1.isCommented; } });
+Object.defineProperty(exports, "isSourceFile", { enumerable: true, get: function () { return types_js_1.isSourceFile; } });
+Object.defineProperty(exports, "SOURCE_EXTENSIONS", { enumerable: true, get: function () { return types_js_1.SOURCE_EXTENSIONS; } });
+var cli_main_js_1 = require("./codemods/cli-main.js");
+Object.defineProperty(exports, "runCodemodCli", { enumerable: true, get: function () { return cli_main_js_1.runCodemodCli; } });
+var node_fs_js_1 = require("./codemods/node-fs.js");
+Object.defineProperty(exports, "nodeCodemodFs", { enumerable: true, get: function () { return node_fs_js_1.nodeCodemodFs; } });
+var import_paths_js_1 = require("./codemods/import-paths.js");
+Object.defineProperty(exports, "importPathsCodemod", { enumerable: true, get: function () { return import_paths_js_1.importPathsCodemod; } });
+Object.defineProperty(exports, "REPORT_RULES", { enumerable: true, get: function () { return import_paths_js_1.REPORT_RULES; } });
+Object.defineProperty(exports, "REWRITE_RULES", { enumerable: true, get: function () { return import_paths_js_1.REWRITE_RULES; } });
+var env_rename_js_1 = require("./codemods/env-rename.js");
+Object.defineProperty(exports, "envRenameCodemod", { enumerable: true, get: function () { return env_rename_js_1.envRenameCodemod; } });
+Object.defineProperty(exports, "ENV_NOTES", { enumerable: true, get: function () { return env_rename_js_1.ENV_NOTES; } });
+Object.defineProperty(exports, "ENV_RENAMES", { enumerable: true, get: function () { return env_rename_js_1.ENV_RENAMES; } });
+var res_envelope_js_1 = require("./codemods/res-envelope.js");
+Object.defineProperty(exports, "resEnvelopeCodemod", { enumerable: true, get: function () { return res_envelope_js_1.resEnvelopeCodemod; } });
+var config_inventory_js_1 = require("./codemods/config-inventory.js");
+Object.defineProperty(exports, "configInventoryCodemod", { enumerable: true, get: function () { return config_inventory_js_1.configInventoryCodemod; } });
+var job_generics_js_1 = require("./codemods/job-generics.js");
+Object.defineProperty(exports, "jobGenericsCodemod", { enumerable: true, get: function () { return job_generics_js_1.jobGenericsCodemod; } });
+//# sourceMappingURL=index.js.map

package/dist/legacy/compat.module.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `NageCompatModule.forRoot()` — registers the legacy envelope interceptor.
+ *
+ * Importing it changes nothing on its own: the interceptor only acts on routes
+ * carrying `@LegacyEnvelope()`. That is what makes it safe to leave imported for
+ * the whole of a migration and remove in one commit at the end, once no route
+ * carries the decorator any more.
+ */
+import { type DynamicModule } from '@nestjs/common';
+import { type CompatOptions } from './options.js';
+export declare class NageCompatModule {
+    static forRoot(options?: CompatOptions): DynamicModule;
+}
+//# sourceMappingURL=compat.module.d.ts.map

package/dist/legacy/compat.module.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * `NageCompatModule.forRoot()` — registers the legacy envelope interceptor.
+ *
+ * Importing it changes nothing on its own: the interceptor only acts on routes
+ * carrying `@LegacyEnvelope()`. That is what makes it safe to leave imported for
+ * the whole of a migration and remove in one commit at the end, once no route
+ * carries the decorator any more.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var NageCompatModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NageCompatModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const legacy_envelope_interceptor_js_1 = require("./legacy-envelope.interceptor.js");
+const options_js_1 = require("./options.js");
+let NageCompatModule = NageCompatModule_1 = class NageCompatModule {
+    static forRoot(options = {}) {
+        return {
+            module: NageCompatModule_1,
+            providers: [
+                { provide: options_js_1.NAGE_COMPAT_OPTIONS, useValue: options },
+                { provide: core_1.APP_INTERCEPTOR, useClass: legacy_envelope_interceptor_js_1.LegacyEnvelopeInterceptor },
+            ],
+            exports: [options_js_1.NAGE_COMPAT_OPTIONS],
+        };
+    }
+};
+exports.NageCompatModule = NageCompatModule;
+exports.NageCompatModule = NageCompatModule = NageCompatModule_1 = __decorate([
+    (0, common_1.Module)({})
+], NageCompatModule);
+//# sourceMappingURL=compat.module.js.map