@aventara/client 0.1.0-pilot.1 → 0.1.0-pilot.2

package/dist/emit/client-tree.emitter.d.ts

@@ -1,17 +1,14 @@
 import type { ClientContract } from "@aventara/core";
 import type { ClientEntrypoint } from "../config/client-config.interface.js";
 import { type ClientEmission } from "./emitted-tree.interface.js";
+import { type ClientModuleStyle } from "./module-style.interface.js";
 /**
- * §15.3's emit steps over an accepted ClientContract, as one value (plan §7).
- *
  * The banner, the encoding and the file order are applied HERE, once, over every
- * module — so no emitter can forget the banner, and byte-equality is a property
- * of this function rather than of each emitter's care (C-843):
+ * module — so no emitter can forget the banner, and byte-equality is a property of
+ * this function rather than of each emitter's care:
  *
- * - every module opens with the generated banner (M17);
+ * - every module opens with the generated banner;
  * - every file is UTF-8;
- * - the layout is the architect's (2026-10-04): `AvClient.ts` at the root of
- *   `generateAt`, every other module under `generated/`;
  * - files come in UTF-16 code-unit order of their path, each path once.
  *
  * The name derivation's rename warnings ride on the result beside the tree; this
@@ -19,19 +16,13 @@ import { type ClientEmission } from "./emitted-tree.interface.js";
  *
  * The names and enums read the enum registry, registry NAMES and `protocol`.
  * Core's derivation is copied under `generated/derivation/` as its published
- * declarations (Q1 = A, `derivation.emitter.ts`): read from the installed
- * `@aventara/core`, never from the Contract. The contract itself reaches the
- * tree as three projections of the one accepted contract (plan §6): the carrier
- * `generated/contract.ts` (Q4), the runtime's decode table and advertised
- * operations `generated/runtime/descriptor.ts` (P1, P4), and `metadata.ts`'s
- * hash, version and default entrypoint (Q5) — the entrypoint being the run's
- * other input.
- *
- * The runtime (`generated/runtime/codec.ts`, `decimal.ts`, `errors.ts`,
- * `transport.ts`) reads nothing of the Contract at all: §6.2's codecs and
- * §13's codes are fixed by protocol version (M10, Q3), and the transport sends
- * the operation its caller names.
+ * declarations: read from the installed `@aventara/core`, never from the Contract.
+ * The contract itself reaches the tree as three projections of the one accepted
+ * contract: the carrier `generated/contract.ts`, the runtime's decode table and
+ * advertised operations `generated/runtime/descriptor.ts`, and `metadata.ts`'s
+ * hash, version and default entrypoint — the entrypoint being the run's other
+ * input.
  *
  * @throws GeneratedNameError when a name cannot be emitted, even renamed.
  */
-export declare function emitClientTree(contract: ClientContract, entrypoint: ClientEntrypoint): ClientEmission;
+export declare function emitClientTree(contract: ClientContract, entrypoint: ClientEntrypoint, style: ClientModuleStyle): ClientEmission;

package/dist/emit/client-tree.emitter.js

@@ -5,65 +5,32 @@ import { emitDerivationModules } from "./derivation.emitter.js";
 import { emitDescriptorModule } from "./descriptor.emitter.js";
 import { CLIENT_ENTRY_FILE, GENERATED_DIRECTORY, } from "./emitted-tree.interface.js";
 import { emitEnumsModule } from "./enum.emitter.js";
+import { moduleSpecifierWriter, } from "./module-style.interface.js";
 import { deriveEmittedNames } from "./name.deriver.js";
 import { emitNamedTypesModule } from "./named-type.emitter.js";
 import { emitDecimalModule, emitErrorsModule, emitMetadataModule, emitTransportModule, errorsModuleExports, } from "./runtime.emitter.js";
 import { emitScalarCodecModule } from "./scalar.codec.js";
 import { emitTransactionModules } from "./transaction.emitter.js";
-/**
- * §15.3's emit steps over an accepted ClientContract, as one value (plan §7).
- *
- * The banner, the encoding and the file order are applied HERE, once, over every
- * module — so no emitter can forget the banner, and byte-equality is a property
- * of this function rather than of each emitter's care (C-843):
- *
- * - every module opens with the generated banner (M17);
- * - every file is UTF-8;
- * - the layout is the architect's (2026-10-04): `AvClient.ts` at the root of
- *   `generateAt`, every other module under `generated/`;
- * - files come in UTF-16 code-unit order of their path, each path once.
- *
- * The name derivation's rename warnings ride on the result beside the tree; this
- * function prints nothing.
- *
- * The names and enums read the enum registry, registry NAMES and `protocol`.
- * Core's derivation is copied under `generated/derivation/` as its published
- * declarations (Q1 = A, `derivation.emitter.ts`): read from the installed
- * `@aventara/core`, never from the Contract. The contract itself reaches the
- * tree as three projections of the one accepted contract (plan §6): the carrier
- * `generated/contract.ts` (Q4), the runtime's decode table and advertised
- * operations `generated/runtime/descriptor.ts` (P1, P4), and `metadata.ts`'s
- * hash, version and default entrypoint (Q5) — the entrypoint being the run's
- * other input.
- *
- * The runtime (`generated/runtime/codec.ts`, `decimal.ts`, `errors.ts`,
- * `transport.ts`) reads nothing of the Contract at all: §6.2's codecs and
- * §13's codes are fixed by protocol version (M10, Q3), and the transport sends
- * the operation its caller names.
- *
- * @throws GeneratedNameError when a name cannot be emitted, even renamed.
- */
-export function emitClientTree(contract, entrypoint) {
+export function emitClientTree(contract, entrypoint, style) {
     const names = deriveEmittedNames(contract);
     const generated = [
         ...emitDerivationModules(),
-        emitClientSurfaceModule(contract, names),
+        emitClientSurfaceModule(contract, names, style),
         emitContractCarrierModule(contract),
         emitDescriptorModule(contract),
         emitEnumsModule(contract, names),
         emitMetadataModule(contract.protocol, entrypoint),
-        emitScalarCodecModule(),
+        emitScalarCodecModule(style),
         emitDecimalModule(),
         emitErrorsModule(),
-        emitTransportModule(),
-        emitNamedTypesModule(contract, names),
-        // P3: the builder and runner exist iff transactions are interactive.
+        emitTransportModule(style),
+        emitNamedTypesModule(contract, names, style),
         ...(contract.transactions === "interactive"
-            ? emitTransactionModules()
+            ? emitTransactionModules(style)
             : []),
     ];
     const files = [
-        { path: CLIENT_ENTRY_FILE, source: clientEntrySource() },
+        { path: CLIENT_ENTRY_FILE, source: clientEntrySource(style) },
         ...generated.map((module) => ({
             path: `${GENERATED_DIRECTORY}/${module.path}`,
             source: module.source,
@@ -76,20 +43,11 @@ export function emitClientTree(contract, entrypoint) {
         path: file.path,
         bytes: encoder.encode(withGeneratedBanner(file.source)),
     }));
-    return { tree, warnings: names.warnings };
+    return { tree, style, warnings: names.warnings };
 }
-/**
- * `AvClient.ts`, the entry point a consumer imports (§15.4; Phase 12-rest Q7):
- * the ready client `avClient` as the DEFAULT export, and as named exports the
- * class `AvClient`, `AvClientOptions`, `CallOptions`, `Fetch`, `Operation<T>`,
- * the named Resource types, the enums, `Decimal`, the errors and the code unions —
- * re-exported from `generated/`. Never the transport's primitive (Q1 = B), never
- * the derived forms map (Q3: internal).
- *
- *     import avClient, { AvClient, User, UserWhere } from "./AvClient";
- */
-function clientEntrySource() {
-    const from = (module) => JSON.stringify(`./${GENERATED_DIRECTORY}/${module.replace(/\.d\.ts$|\.ts$/, ".js")}`);
+function clientEntrySource(style) {
+    const specifier = moduleSpecifierWriter(style);
+    const from = (module) => specifier(`./${GENERATED_DIRECTORY}/${module.replace(/\.d\.ts$|\.ts$/, "")}`);
     return (`export { default } from ${from("client.ts")};\n` +
         `export {\n\tAvClient,\n\ttype AvClientOptions,\n\ttype CallOptions,\n} from ${from("client.ts")};\n` +
         `export type { Fetch } from ${from("runtime/transport.ts")};\n` +

package/dist/emit/contract-carrier.emitter.d.ts

@@ -3,11 +3,10 @@ import type { EmittedModule } from "./emitted-tree.interface.js";
 /** `generated/contract.ts`, before the banner. */
 export declare function emitContractCarrierModule(contract: ClientContract): EmittedModule;
 /**
- * The ClientContract a carrier file holds — its whole text, banner included —
- * or `undefined` when it is not one this generator wrote over a contract that
- * still verifies: a foreign prefix or suffix, bytes that are not JSON, a body
- * that is not a ClientContract or whose hash does not re-verify, or bytes that
- * are not that contract's canonical form. Never trusted otherwise (Q6: a carrier
- * that does not re-hash is treated as absent).
+ * The ClientContract a carrier file holds — its whole text, banner included — or
+ * `undefined` when it is not one this generator wrote over a contract that still
+ * verifies: a foreign prefix or suffix, bytes that are not JSON, a body that is
+ * not a ClientContract or whose hash does not re-verify, or bytes that are not
+ * that contract's canonical form. Never trusted otherwise.
  */
 export declare function parseContractCarrier(text: string): Promise<ClientContract | undefined>;

package/dist/emit/contract-carrier.emitter.js

@@ -1,42 +1,14 @@
 import { canonicalizeContract } from "@aventara/core";
 import { acceptClientContract } from "../contract/contract.acceptance.js";
 import { withGeneratedBanner } from "./banner.emitter.js";
-/**
- * The carrier (Q4 = A): `generated/contract.ts` holds the ClientContract the
- * client was generated against, as its served canonical bytes (RFC 8785, §19.2)
- * verbatim — which are a valid TypeScript type literal (plan M4):
- *
- * ```ts
- * export type ClientContractShape = {"enums":{},…};
- * ```
- *
- * One artefact, three readers: the derivation's `C` (S4); the generator on a
- * `304` (Q6, S7), which parses it back with {@link parseContractCarrier}; and a
- * person auditing what the client was generated against. It costs no runtime
- * byte — nothing imports it as a value.
- *
- * The bytes are `canonicalizeContract`'s over the ACCEPTED contract: the body a
- * deployment serves is those bytes (`_contract` serves `canonicalizeContract`'s
- * output, and acceptance verified the hash over the same canonical form), and a
- * contract that arrives in another key order still emits them (C-843).
- */
 const CARRIER_PREFIX = "export type ClientContractShape = ";
 const CARRIER_SUFFIX = ";\n";
-/** `generated/contract.ts`, before the banner. */
 export function emitContractCarrierModule(contract) {
     return {
         path: "contract.ts",
         source: `${CARRIER_PREFIX}${canonicalizeContract(contract)}${CARRIER_SUFFIX}`,
     };
 }
-/**
- * The ClientContract a carrier file holds — its whole text, banner included —
- * or `undefined` when it is not one this generator wrote over a contract that
- * still verifies: a foreign prefix or suffix, bytes that are not JSON, a body
- * that is not a ClientContract or whose hash does not re-verify, or bytes that
- * are not that contract's canonical form. Never trusted otherwise (Q6: a carrier
- * that does not re-hash is treated as absent).
- */
 export async function parseContractCarrier(text) {
     const opening = withGeneratedBanner(CARRIER_PREFIX);
     if (!text.startsWith(opening) || !text.endsWith(CARRIER_SUFFIX)) {

package/dist/emit/derivation.emitter.d.ts

@@ -1,14 +1,14 @@
 import type { EmittedModule } from "./emitted-tree.interface.js";
 /**
- * The derivation, transported (Phase 12-rest S2, Q1 = A). A generated client's
- * argument and result types are core's own `OperationArgumentsFor`,
- * `OperationResultFor` and the call grammar (`OperationCall`, …) — never a second
- * spelling. They reach the emitted tree as core's PUBLISHED DECLARATIONS, copied
- * under `generated/derivation/` at their path relative to core's `dist`:
+ * The derivation, transported. A generated client's argument and result types are
+ * core's own `OperationArgumentsFor`, `OperationResultFor` and the call grammar
+ * (`OperationCall`, …) — never a second spelling. They reach the emitted tree as
+ * core's PUBLISHED DECLARATIONS, copied under `generated/derivation/` at their
+ * path relative to core's `dist`:
  *
  * - declarations, not sources: the sources' closure carries value imports (the
- *   canonicaliser, the wire grammars), the declarations' carries none (plan M1);
- *   a `.d.ts` cannot carry runtime, so a bundler never sees one;
+ *   canonicaliser, the wire grammars), the declarations' carries none; a `.d.ts`
+ *   cannot carry runtime, so a bundler never sees one;
  * - under their own directory, so core's `runtime/decimal.d.ts` cannot shadow the
  *   emitted `generated/runtime/decimal.ts`;
  * - byte for byte, except the trailing `//# sourceMappingURL=…` line, which names

package/dist/emit/derivation.emitter.js

@@ -1,34 +1,7 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-/**
- * The derivation, transported (Phase 12-rest S2, Q1 = A). A generated client's
- * argument and result types are core's own `OperationArgumentsFor`,
- * `OperationResultFor` and the call grammar (`OperationCall`, …) — never a second
- * spelling. They reach the emitted tree as core's PUBLISHED DECLARATIONS, copied
- * under `generated/derivation/` at their path relative to core's `dist`:
- *
- * - declarations, not sources: the sources' closure carries value imports (the
- *   canonicaliser, the wire grammars), the declarations' carries none (plan M1);
- *   a `.d.ts` cannot carry runtime, so a bundler never sees one;
- * - under their own directory, so core's `runtime/decimal.d.ts` cannot shadow the
- *   emitted `generated/runtime/decimal.ts`;
- * - byte for byte, except the trailing `//# sourceMappingURL=…` line, which names
- *   a map the tree does not hold.
- *
- * The closure is walked here, at generation time, from {@link DERIVATION_ROOTS}
- * over whichever `@aventara/core` this package resolves — so the output is a
- * function of the core version the generator depends on, as the rest of it is a
- * function of the generator. A closure that names a package, carries a
- * triple-slash reference, or leaves core's declarations is refused: it cannot be
- * transported, and core's own gate (`emittable-closure.gate.spec.ts`) exists so
- * that it never is.
- */
-/**
- * The modules whose declarations the generated client copies — the roots of core's
- * `emittable-closure.gate.spec.ts`, mirrored (core cannot export a test constant,
- * and this package cannot read core's tests).
- */
+import { scanModuleSpecifiers } from "./module-specifier.scanner.js";
 export const DERIVATION_ROOTS = [
     "contracts/contract",
     "contracts/scalar-value-type",
@@ -39,7 +12,6 @@ export const DERIVATION_ROOTS = [
     "transactions/deferred-operation",
     "transactions/transaction-reference",
 ];
-/** The published declarations of the `@aventara/core` this package resolves. */
 export function publishedCoreDeclarations() {
     const dist = path.dirname(fileURLToPath(import.meta.resolve("@aventara/core")));
     return (relative) => {
@@ -54,13 +26,6 @@ export function publishedCoreDeclarations() {
         }
     };
 }
-/**
- * Core's declaration closure from {@link DERIVATION_ROOTS}, as modules under
- * `derivation/`, in UTF-16 code-unit order of their path.
- *
- * @throws Error when the closure cannot be transported — a defect of the
- *   installed `@aventara/core`, never of the consumer's input.
- */
 export function emitDerivationModules(read = publishedCoreDeclarations()) {
     const copied = new Map();
     const queue = DERIVATION_ROOTS.map((root) => `${root}.d.ts`);
@@ -73,7 +38,7 @@ export function emitDerivationModules(read = publishedCoreDeclarations()) {
         if (text === undefined) {
             throw new Error(`@aventara/core's declaration closure names ${file}, which it does not publish.`);
         }
-        const scanned = scanDeclaration(text);
+        const scanned = scanModuleSpecifiers(text);
         if (scanned.references) {
             throw untransportable(`${file} carries a triple-slash reference, which the emitted tree cannot satisfy`);
         }
@@ -92,10 +57,6 @@ export function emitDerivationModules(read = publishedCoreDeclarations()) {
 function untransportable(reason) {
     return new Error(`@aventara/core's declarations cannot be copied into the generated client: ${reason}.`);
 }
-/**
- * The declaration file a specifier names, relative to core's `dist`: a relative
- * `.js` specifier inside it, as NodeNext resolves an emitted declaration's import.
- */
 function declarationTarget(file, specifier) {
     const leaves = () => untransportable(`${file} names ${JSON.stringify(specifier)}, which is not a declaration file beside it`);
     if (!(specifier.startsWith("./") || specifier.startsWith("../")) ||
@@ -108,126 +69,6 @@ function declarationTarget(file, specifier) {
     }
     return target.replace(/\.js$/, ".d.ts");
 }
-/** `text` without its final `//# sourceMappingURL=…` line, when it ends with one. */
 function withoutSourceMapTrailer(text) {
     return text.replace(/(^|\n)\/\/# sourceMappingURL=[^\n]*\n?$/, "$1");
 }
-/**
- * A word followed directly by a string literal names a module. A pattern, not two
- * string comparisons: the packaging gate reads shipped JavaScript lexically, and
- * a keyword spelled as a quoted literal would read to it as an import.
- */
-const SPECIFIER_KEYWORD = /^(?:from|import)$/;
-/**
- * The specifiers one declaration file names, read by a small lexer rather than
- * by `typescript` (an optional peer, absent from a consumer's install): comments,
- * string literals and template literals are skipped as units, so text inside them
- * is never mistaken for an import. Agrees with TypeScript's own pre-processor
- * over core's closure (`derivation.emitter.spec.ts`).
- */
-function scanDeclaration(text) {
-    const tokens = [];
-    let references = false;
-    let index = 0;
-    const readQuoted = (quote) => {
-        let value = "";
-        index += 1;
-        while (index < text.length && text[index] !== quote) {
-            if (text[index] === "\\") {
-                value += text[index + 1] ?? "";
-                index += 2;
-                continue;
-            }
-            value += text[index];
-            index += 1;
-        }
-        index += 1;
-        return value;
-    };
-    /** Scans code until the end, or until the `}` closing a `${` when `inPlaceholder`. */
-    const scanCode = (inPlaceholder) => {
-        let depth = 0;
-        while (index < text.length) {
-            const character = text[index];
-            const next = text[index + 1];
-            if (character === "/" && next === "/") {
-                const end = text.indexOf("\n", index);
-                const line = text.slice(index, end === -1 ? text.length : end);
-                if (/^\/\/\/\s*<reference\b/.test(line)) {
-                    references = true;
-                }
-                index = end === -1 ? text.length : end + 1;
-            }
-            else if (character === "/" && next === "*") {
-                const end = text.indexOf("*/", index + 2);
-                index = end === -1 ? text.length : end + 2;
-            }
-            else if (character === '"' || character === "'") {
-                tokens.push({ kind: "string", value: readQuoted(character) });
-            }
-            else if (character === "`") {
-                scanTemplate();
-            }
-            else if (/[A-Za-z_$]/.test(character)) {
-                const start = index;
-                while (index < text.length && /[\w$]/.test(text[index])) {
-                    index += 1;
-                }
-                tokens.push({ kind: "word", value: text.slice(start, index) });
-            }
-            else if (/\s/.test(character)) {
-                index += 1;
-            }
-            else {
-                if (inPlaceholder && character === "{") {
-                    depth += 1;
-                }
-                else if (inPlaceholder && character === "}") {
-                    if (depth === 0) {
-                        index += 1;
-                        return;
-                    }
-                    depth -= 1;
-                }
-                tokens.push({ kind: "punctuation", value: character });
-                index += 1;
-            }
-        }
-    };
-    const scanTemplate = () => {
-        index += 1;
-        while (index < text.length && text[index] !== "`") {
-            if (text[index] === "\\") {
-                index += 2;
-            }
-            else if (text[index] === "$" && text[index + 1] === "{") {
-                index += 2;
-                scanCode(true);
-            }
-            else {
-                index += 1;
-            }
-        }
-        index += 1;
-        // A template is one opaque token: nothing before it pairs with it.
-        tokens.push({ kind: "punctuation", value: "`" });
-    };
-    scanCode(false);
-    const specifiers = [];
-    tokens.forEach((token, at) => {
-        const following = tokens[at + 1];
-        if (token.kind !== "word") {
-            return;
-        }
-        if (SPECIFIER_KEYWORD.test(token.value) && following?.kind === "string") {
-            specifiers.push(following.value);
-        }
-        else if (token.value === "import" &&
-            following?.kind === "punctuation" &&
-            following.value === "(" &&
-            tokens[at + 2]?.kind === "string") {
-            specifiers.push(tokens[at + 2].value);
-        }
-    });
-    return { specifiers, references };
-}

package/dist/emit/descriptor.emitter.js

@@ -1,36 +1,11 @@
 import { isOperationVariantAvailable, } from "@aventara/core";
 import { ownPropertyKey } from "./name.deriver.js";
-/**
- * `generated/runtime/descriptor.ts` — what the RUNTIME needs of the ClientContract,
- * as data (P1, P4). A projection of the same accepted contract the carrier
- * (`generated/contract.ts`) holds, derived in the same run, so it is not a second
- * source: `descriptor.emitter.spec.ts` regenerates it from the parsed carrier and
- * compares.
- *
- * - **The decode table (P1).** Encoding is decidable by a value's runtime class;
- *   decoding is not — a wire `"12"` is a `string`, a `bigint` or a `decimal`
- *   depending only on the field (M13). So per Resource the table names each
- *   result field whose wire string is revived (`bigint`, `decimal`, `datetime`,
- *   `bytes`, §6.2) and each relation with its target and whether it is to-many,
- *   which the decode walk recurses into (S5 added `many`: a to-one record may
- *   itself hold a `data` and a `count` field, so the shape alone cannot say). Every other key passes through untouched; `json` is never
- *   revived.
- * - **The advertised operations (P4).** Read here through core's
- *   `isOperationVariantAvailable`, emitted as `[resource, family, variant]`; the
- *   type grammar reads the carrier's `operations` keys. They agree while present
- *   ⇔ advertised (Phase 10 A3), and a gate asserts it over both pilots.
- *
- * Every registry is walked in UTF-16 code-unit order, so the key order a
- * contract arrives in never reaches the bytes (C-843).
- */
-/** The scalars whose wire form a decoder revives into another runtime class (§6.2). */
 const REVIVED_SCALARS = new Set([
     "bigint",
     "bytes",
     "datetime",
     "decimal",
 ]);
-/** `generated/runtime/descriptor.ts`, before the banner. */
 export function emitDescriptorModule(contract) {
     const resources = codeUnitOrder(Object.keys(contract.resources));
     const table = resources.map((name) => {
@@ -55,9 +30,9 @@ export function emitDescriptorModule(contract) {
     return {
         path: "runtime/descriptor.ts",
         source: "/**\n" +
-            " * A result field the decoder revives from its wire string (§6.2), or a relation\n" +
+            " * A result field the decoder revives from its wire string, or a relation\n" +
             " * it recurses into, read as the relation's target Resource — `many` saying the\n" +
-            " * value is a list, `{ data, count }` or `{ count }` rather than one record (P1).\n" +
+            " * value is a list, `{ data, count }` or `{ count }` rather than one record.\n" +
             " */\n" +
             "export type FieldDecoding =\n" +
             '\t| "bigint"\n' +
@@ -79,7 +54,6 @@ export function emitDescriptorModule(contract) {
             `])[] = [${advertised.length === 0 ? "" : `\n${advertised.join("")}`}];\n`,
     };
 }
-/** The table entry a field needs, as source, or `undefined` when it passes through. */
 function decodingOf(field) {
     if (field === undefined) {
         return undefined;

package/dist/emit/emitted-tree.interface.d.ts

@@ -1,37 +1,58 @@
 /**
- * The generator's output as a VALUE before it is a filesystem effect (plan §7,
- * group 3). Byte-equality is therefore testable without touching disk, and
- * temp → validate → replace (S7) is a property of the writer alone rather than of
- * every emitter.
+ * The generator's output as a VALUE before it is a filesystem effect.
+ * Byte-equality is therefore testable without touching disk, and temp → validate →
+ * replace is a property of the writer alone rather than of every emitter.
  */
+import type { ClientModuleStyle } from "./module-style.interface.js";
 /**
- * The output layout (architect, 2026-10-04): the consumer names a directory,
- * `generateAt`, which is SHARED — they may keep their own files there. The
- * generator owns exactly two entries in it:
+ * The output layout: the consumer names a directory, `generateAt`, which is SHARED
+ * — they may keep their own files there. The generator owns exactly two entries in
+ * it:
  *
  * - `AvClient.ts`, the entry point a consumer imports;
  * - `generated/`, every other module, owned and replaced whole.
+ *
+ * The tree is TypeScript source that the developer's own toolchain compiles like
+ * their own files — `tsc`, Next.js (Turbopack or webpack), Vite, `tsx`, Node's
+ * type stripping. pilot.1's tree always spelled its internal imports NodeNext's
+ * way (`./generated/client.js`), which a bundler that does not map `.js` back to
+ * `.ts` (Turbopack) and plain Node could not follow. Now those specifiers are the
+ * project's: extensionless, `.js` or `.ts`, as its `tsconfig.json` decides
+ * (`module-style.interface.ts`, Prisma 7's rules). A consumer imports the entry as
+ * they import their own files — `./api/AvClient`, `./api/AvClient.js` or
+ * `./api/AvClient.ts`.
  */
 /** The entry point, at the root of `generateAt`. */
 export declare const CLIENT_ENTRY_FILE = "AvClient.ts";
+/** The files the generator owns at the root of `generateAt`. */
+export declare const CLIENT_ENTRY_FILES: readonly ["AvClient.ts"];
+/** One of the entry point's files. */
+export type ClientEntryFile = (typeof CLIENT_ENTRY_FILES)[number];
+/**
+ * Entry files an unreleased build of this generator wrote — JavaScript beside
+ * declarations, never published. Each is the generator's only while it carries
+ * the ownership line: a generation removes it then, so no stale `AvClient.mjs`
+ * is left beside the `AvClient.ts` it was replaced by. One without the line is
+ * the developer's file, and nothing reads, refuses on or removes it. (pilot.0's
+ * and pilot.1's entry is `AvClient.ts` itself, replaced in place.)
+ */
+export declare const LEGACY_CLIENT_ENTRY_FILES: readonly string[];
 /** The directory holding every other emitted module, under `generateAt`. */
 export declare const GENERATED_DIRECTORY = "generated";
 /**
  * One of core's published declaration files, copied under `generated/derivation/`
- * at its path relative to core's `dist` (Q1 = A, `derivation.emitter.ts`).
+ * at its path relative to core's `dist`.
  */
 export type DerivationModulePath = `derivation/${string}.d.ts`;
 /**
- * The modules under `generated/`: the emitted sources, the carrier
- * (`contract.ts`, Q4), the typed surface (`client.ts`) and named types
- * (`types.d.ts`, S4 — a declaration file, architect 2026-10-05), and core's declarations under `derivation/`. §15.4's
- * `runtime/transaction.ts` and `runtime/fingerprint.ts` exist iff transactions
- * are interactive (S6, P3); `resources/` and `runtime/projection.ts` are not
- * emitted (plan §7).
- *
  * Relative to `generated/`, POSIX-separated.
  */
 export type GeneratedModulePath = DerivationModulePath | "client.ts" | "contract.ts" | "enums.ts" | "metadata.ts" | "runtime/codec.ts" | "runtime/decimal.ts" | "runtime/descriptor.ts" | "runtime/errors.ts" | "runtime/fingerprint.ts" | "runtime/transaction.ts" | "runtime/transport.ts" | "types.d.ts";
+/**
+ * The carrier: the ClientContract the tree was generated against, under
+ * `generated/` — the module a rerun reads back to ask for a `304`.
+ */
+export declare const CONTRACT_CARRIER_MODULE = "contract.ts";
 /** A path in the emitted tree: relative to `generateAt`, POSIX-separated. */
 export type EmittedFilePath = typeof CLIENT_ENTRY_FILE | `${typeof GENERATED_DIRECTORY}/${GeneratedModulePath}`;
 /** One module's TypeScript source under `generated/`, before the banner and before encoding. */
@@ -46,8 +67,8 @@ export interface EmittedFile {
 }
 /**
  * Every file one generation emits, in UTF-16 code-unit order of `path`, each path
- * once — `AvClient.ts` first, then `generated/**`. Replaced, never merged
- * (§15.3): `generated/` whole, `AvClient.ts` as one file.
+ * once — `AvClient.ts` first, then `generated/**`. Replaced, never merged:
+ * `generated/` whole, `AvClient.ts` as one file.
  */
 export type EmittedTree = readonly EmittedFile[];
 /**
@@ -57,5 +78,7 @@ export type EmittedTree = readonly EmittedFile[];
  */
 export interface ClientEmission {
     readonly tree: EmittedTree;
+    /** The project's spelling the tree was emitted in, and is validated in. */
+    readonly style: ClientModuleStyle;
     readonly warnings: readonly string[];
 }

package/dist/emit/emitted-tree.interface.js

@@ -1,18 +1,8 @@
-/**
- * The generator's output as a VALUE before it is a filesystem effect (plan §7,
- * group 3). Byte-equality is therefore testable without touching disk, and
- * temp → validate → replace (S7) is a property of the writer alone rather than of
- * every emitter.
- */
-/**
- * The output layout (architect, 2026-10-04): the consumer names a directory,
- * `generateAt`, which is SHARED — they may keep their own files there. The
- * generator owns exactly two entries in it:
- *
- * - `AvClient.ts`, the entry point a consumer imports;
- * - `generated/`, every other module, owned and replaced whole.
- */
-/** The entry point, at the root of `generateAt`. */
 export const CLIENT_ENTRY_FILE = "AvClient.ts";
-/** The directory holding every other emitted module, under `generateAt`. */
+export const CLIENT_ENTRY_FILES = [CLIENT_ENTRY_FILE];
+export const LEGACY_CLIENT_ENTRY_FILES = [
+    "AvClient.d.mts",
+    "AvClient.mjs",
+];
 export const GENERATED_DIRECTORY = "generated";
+export const CONTRACT_CARRIER_MODULE = "contract.ts";

package/dist/emit/enum.emitter.d.ts

@@ -3,7 +3,7 @@ import type { EmittedModule } from "./emitted-tree.interface.js";
 import { type EmittedNames } from "./name.deriver.js";
 /**
  * `enums.ts`: per enum, a string-literal union type and a same-named `as const`
- * object (§15.4's "enum types"; architect decision, 2026-10-04):
+ * object:
  *
  * ```ts
  * export type Role = "ADMIN" | "USER";
@@ -17,8 +17,8 @@ import { type EmittedNames } from "./name.deriver.js";
  * renamed.
  *
  * Enums come in the order `names` gives them — UTF-16 code units of the contract
- * name — so the key order a contract arrives in never reaches the bytes (C-843).
- * An enum's VALUES keep their declared order, in the type and in the object: that
- * order is meaning, and canonical form keeps it too.
+ * name — so the key order a contract arrives in never reaches the bytes. An enum's
+ * VALUES keep their declared order, in the type and in the object: that order is
+ * meaning, and canonical form keeps it too.
  */
 export declare function emitEnumsModule(contract: Pick<ClientContract, "enums">, names: EmittedNames): EmittedModule;