@geastack/compiler 1.0.15

package/dist/targets/cpp/deferral-safety.d.ts

@@ -0,0 +1,82 @@
+import type { DeclarationId, IrValueId } from '../../identity/ids.js';
+import type { EmitContext } from './emit-context.js';
+/**
+ * What a WITHHELD value still reads, for the emitters that move where it lands.
+ *
+ * `ir/deferral.ts` withholds a value that has one use, in one block, from an
+ * operation with no effects, with every operation between the two also
+ * withheld. That last condition is the whole proof: nothing between the
+ * definition and the use emits a statement, so nothing can change what the
+ * withheld expression reads before it renders.
+ *
+ * It is a proof about the emission the census SAW. An emitter that rewrites its
+ * own output -- puts a statement into that window, or renders the value
+ * somewhere the census never placed it -- invalidates it retroactively, and the
+ * census has no way to know. Three do:
+ *
+ *  - `emit-json.ts`'s write-in-place fill emits `cell.clear()` and then renders
+ *    the argument, so a withheld read of that cell now renders against emptied
+ *    storage. `text = JSON.stringify(text.length)` served `0` for `"ee".length`
+ *    -- clean C++, wrong answer, no diagnostic.
+ *  - `emit-callable.ts`'s receiver argument passes a withheld cell read to a
+ *    body that takes its receiver BY REFERENCE, where the callee reassigning
+ *    that cell drops the last count and destroys the object the reference
+ *    names.
+ *  - `emit-arrays.ts`'s counted-push rewrite renders the loop bound on both
+ *    sides of the `bulkAppend` that changes the array's length.
+ *
+ * One hazard, found three times, cured three different ways -- which is how the
+ * first one shipped: nothing made the author of a rewrite think about deferral
+ * at all. So the QUESTION lives here, once. The cure stays with the emitter,
+ * because the three genuinely differ: the fill declines its fast path, the
+ * receiver takes a temporary back, the rewrite declines itself. What none of
+ * them may do any more is answer the question privately.
+ *
+ * ## Why there is a second guard, elsewhere, that this one does not replace
+ *
+ * A withheld read renders as the cell's own name only because
+ * `emit-bindings.ts` decided it may: a read becomes an ALIAS of the cell rather
+ * than a copy of it exactly when the body writes that cell at most once
+ * (`bindingWriteCounts <= 1`, emit-bindings.ts:233,255), and deferral inherits
+ * that decision, since a deferred value's text is captured from the statement
+ * emit-bindings had already rendered. So "the cell will name a DIFFERENT object
+ * by the time this renders" is answered once, upstream, and no site here needs
+ * to re-ask it.
+ *
+ * What that guard cannot see is the case this file exists for: the storage the
+ * cell names being mutated IN PLACE. `clear()`, an append, a subscript store --
+ * none of them writes the cell, so the write count does not move and the alias
+ * stays sound by its own rule while what it reads changes underneath it. Two
+ * different questions, two guards, and the emitter needs both.
+ *
+ * A sweep of all 59 files under `targets/cpp/` for "emits a mutation, then
+ * renders an operand" found twelve candidates: nine are mutually exclusive
+ * branches rather than a sequence, and three are sequential and sound -- the
+ * array builder's `appendRange` mutates an array freshly allocated in that same
+ * emission, which no operand can name yet, and the two `defineValueAlias` sites
+ * (emit-carrier-members.ts:779, emit-properties.ts:906) publish the receiver
+ * after a subscript store, where mutating one slot does not change which object
+ * the cell names. Relocation in the other direction -- a read hoisted EARLIER,
+ * into a loop preheader -- is `ir/hoist.ts`'s, and it guards on both cell
+ * writes and `mutatesArrayStorage`.
+ */
+/**
+ * Whether rendering `value` here would read `declaration` -- directly, or
+ * through anything it was computed from.
+ *
+ * The question every emitter above has to ask before it writes to that cell, or
+ * moves the render past something that does. Asking only whether the value IS a
+ * read of the cell is the narrower question, and it is the one that let
+ * `JSON.stringify(text.length)` past.
+ */
+export declare const readsCell: (ctx: EmitContext, value: IrValueId, declaration: DeclarationId) => boolean;
+/**
+ * The cell a value renders as the storage OF, rather than as a copy of, or
+ * `null` when it renders as a value of its own.
+ *
+ * A withheld `binding-read` spells the cell's own name, so what the use
+ * receives is that storage and not a copy of it. Whether that matters is the
+ * caller's question -- for a `const&` receiver it is a lifetime, for the fill
+ * it is staleness -- but which values are in that position is this one.
+ */
+export declare const withheldCellOf: (ctx: EmitContext, value: IrValueId) => DeclarationId | null;

package/dist/targets/cpp/deferral-safety.js

@@ -0,0 +1,86 @@
+/**
+ * What a WITHHELD value still reads, for the emitters that move where it lands.
+ *
+ * `ir/deferral.ts` withholds a value that has one use, in one block, from an
+ * operation with no effects, with every operation between the two also
+ * withheld. That last condition is the whole proof: nothing between the
+ * definition and the use emits a statement, so nothing can change what the
+ * withheld expression reads before it renders.
+ *
+ * It is a proof about the emission the census SAW. An emitter that rewrites its
+ * own output -- puts a statement into that window, or renders the value
+ * somewhere the census never placed it -- invalidates it retroactively, and the
+ * census has no way to know. Three do:
+ *
+ *  - `emit-json.ts`'s write-in-place fill emits `cell.clear()` and then renders
+ *    the argument, so a withheld read of that cell now renders against emptied
+ *    storage. `text = JSON.stringify(text.length)` served `0` for `"ee".length`
+ *    -- clean C++, wrong answer, no diagnostic.
+ *  - `emit-callable.ts`'s receiver argument passes a withheld cell read to a
+ *    body that takes its receiver BY REFERENCE, where the callee reassigning
+ *    that cell drops the last count and destroys the object the reference
+ *    names.
+ *  - `emit-arrays.ts`'s counted-push rewrite renders the loop bound on both
+ *    sides of the `bulkAppend` that changes the array's length.
+ *
+ * One hazard, found three times, cured three different ways -- which is how the
+ * first one shipped: nothing made the author of a rewrite think about deferral
+ * at all. So the QUESTION lives here, once. The cure stays with the emitter,
+ * because the three genuinely differ: the fill declines its fast path, the
+ * receiver takes a temporary back, the rewrite declines itself. What none of
+ * them may do any more is answer the question privately.
+ *
+ * ## Why there is a second guard, elsewhere, that this one does not replace
+ *
+ * A withheld read renders as the cell's own name only because
+ * `emit-bindings.ts` decided it may: a read becomes an ALIAS of the cell rather
+ * than a copy of it exactly when the body writes that cell at most once
+ * (`bindingWriteCounts <= 1`, emit-bindings.ts:233,255), and deferral inherits
+ * that decision, since a deferred value's text is captured from the statement
+ * emit-bindings had already rendered. So "the cell will name a DIFFERENT object
+ * by the time this renders" is answered once, upstream, and no site here needs
+ * to re-ask it.
+ *
+ * What that guard cannot see is the case this file exists for: the storage the
+ * cell names being mutated IN PLACE. `clear()`, an append, a subscript store --
+ * none of them writes the cell, so the write count does not move and the alias
+ * stays sound by its own rule while what it reads changes underneath it. Two
+ * different questions, two guards, and the emitter needs both.
+ *
+ * A sweep of all 59 files under `targets/cpp/` for "emits a mutation, then
+ * renders an operand" found twelve candidates: nine are mutually exclusive
+ * branches rather than a sequence, and three are sequential and sound -- the
+ * array builder's `appendRange` mutates an array freshly allocated in that same
+ * emission, which no operand can name yet, and the two `defineValueAlias` sites
+ * (emit-carrier-members.ts:779, emit-properties.ts:906) publish the receiver
+ * after a subscript store, where mutating one slot does not change which object
+ * the cell names. Relocation in the other direction -- a read hoisted EARLIER,
+ * into a loop preheader -- is `ir/hoist.ts`'s, and it guards on both cell
+ * writes and `mutatesArrayStorage`.
+ */
+// The fixed-point closure that used to live here (`collectValueCellReads`) is
+// purely a property of the operand graph, with no C++ in the answer -- moved
+// to `ir/facts.ts`'s `bodyValueOriginsOf` (
+// Phase 3, "the no-write-during-render rule"), computed once before this
+// body's `EmitContext` exists and read here as `ctx.valueCellReads`, now a
+// `ReadonlyMap` no renderer may write into.
+/**
+ * Whether rendering `value` here would read `declaration` -- directly, or
+ * through anything it was computed from.
+ *
+ * The question every emitter above has to ask before it writes to that cell, or
+ * moves the render past something that does. Asking only whether the value IS a
+ * read of the cell is the narrower question, and it is the one that let
+ * `JSON.stringify(text.length)` past.
+ */
+export const readsCell = (ctx, value, declaration) => ctx.valueCellReads.get(value)?.has(declaration) === true;
+/**
+ * The cell a value renders as the storage OF, rather than as a copy of, or
+ * `null` when it renders as a value of its own.
+ *
+ * A withheld `binding-read` spells the cell's own name, so what the use
+ * receives is that storage and not a copy of it. Whether that matters is the
+ * caller's question -- for a `const&` receiver it is a lifetime, for the fill
+ * it is staleness -- but which values are in that position is this one.
+ */
+export const withheldCellOf = (ctx, value) => ctx.deferrable.has(value) ? (ctx.bindingReadDeclarations.get(value) ?? null) : null;

package/dist/targets/cpp/direct-call-receivers.d.ts

@@ -0,0 +1,37 @@
+import type { IrBody, IrOperand } from '../../ir/model.js';
+import type { IrValueId } from '../../identity/ids.js';
+import type { EmitContext } from './emit-context.js';
+import type { CallableAbi } from '../../representation/model.js';
+/**
+ * The receiver every method-value read in one body has to keep, settled
+ * before the body renders a line.
+ *
+ * A method value carries its body's physical convention, receiver first, while
+ * the language's view of it declares none; the call that consumes it is handed
+ * the object the READ went through. Which reads publish such a value is a
+ * question about the projected class layout, not about any text, so it is
+ * asked here rather than recorded as a side effect of whichever resolver
+ * happened to spell the value -- there were four such sites, two of which
+ * (`settleDeadCalleeSideEffects` and `computedClassPrototypeMethodText`) only
+ * ran on some renders, which is exactly how a fact goes missing.
+ *
+ * This composes; it decides nothing. Both claims live with the resolver that
+ * owns the carrier, and the map is keyed by the read's own SSA result, so a
+ * detached method read reaches its call through a different value and cannot
+ * acquire a receiver from it.
+ */
+export declare const directCallReceiversOf: (ctx: EmitContext, body: IrBody) => ReadonlyMap<IrValueId, IrOperand>;
+/**
+ * Every method read in one body that has to be DISPATCHED through the object,
+ * settled before the body renders a line.
+ *
+ * The same walk as above over the same claims' home: which reads are virtual
+ * is a question about the projected class family and the dispatch members this
+ * unit emitted, both fixed long before a line is printed. `virtualCalleesUsed`
+ * stays where it is -- it is a proof buffer, filled as each call consumes an
+ * entry and checked once the body has finished, which is what a buffer is.
+ */
+export declare const virtualCalleesOf: (ctx: EmitContext, body: IrBody) => ReadonlyMap<IrValueId, {
+    readonly member: string;
+    readonly abi: CallableAbi;
+}>;

package/dist/targets/cpp/direct-call-receivers.js

@@ -0,0 +1,79 @@
+import { allOperationsOf } from '../../ir/model.js';
+import { operandsOfIrOperation } from '../../ir/queries.js';
+import { classMethodValueReceiverClaim, virtualCalleeClaim } from './class-properties/emit-class-properties.js';
+import { unionClassMethodValueReceiverClaim } from './emit-union-properties.js';
+/**
+ * The receiver every method-value read in one body has to keep, settled
+ * before the body renders a line.
+ *
+ * A method value carries its body's physical convention, receiver first, while
+ * the language's view of it declares none; the call that consumes it is handed
+ * the object the READ went through. Which reads publish such a value is a
+ * question about the projected class layout, not about any text, so it is
+ * asked here rather than recorded as a side effect of whichever resolver
+ * happened to spell the value -- there were four such sites, two of which
+ * (`settleDeadCalleeSideEffects` and `computedClassPrototypeMethodText`) only
+ * ran on some renders, which is exactly how a fact goes missing.
+ *
+ * This composes; it decides nothing. Both claims live with the resolver that
+ * owns the carrier, and the map is keyed by the read's own SSA result, so a
+ * detached method read reaches its call through a different value and cannot
+ * acquire a receiver from it.
+ */
+export const directCallReceiversOf = (ctx, body) => {
+    const receivers = new Map();
+    for (const block of body.blocks.values()) {
+        for (const operation of allOperationsOf(block)) {
+            if (operation.kind !== 'get')
+                continue;
+            const receiver = classMethodValueReceiverClaim(ctx, operation) ?? unionClassMethodValueReceiverClaim(ctx, operation);
+            if (receiver !== null)
+                receivers.set(operation.result.id, receiver);
+        }
+    }
+    return receivers;
+};
+/**
+ * Every method read in one body that has to be DISPATCHED through the object,
+ * settled before the body renders a line.
+ *
+ * The same walk as above over the same claims' home: which reads are virtual
+ * is a question about the projected class family and the dispatch members this
+ * unit emitted, both fixed long before a line is printed. `virtualCalleesUsed`
+ * stays where it is -- it is a proof buffer, filled as each call consumes an
+ * entry and checked once the body has finished, which is what a buffer is.
+ */
+export const virtualCalleesOf = (ctx, body) => {
+    const callees = new Map();
+    const immediate = new Set();
+    const escaped = new Set();
+    for (const block of body.blocks.values()) {
+        for (const operation of allOperationsOf(block)) {
+            if (operation.kind === 'call')
+                immediate.add(operation.callee.value);
+            for (const operand of operandsOfIrOperation(operation)) {
+                if (operation.kind === 'call' &&
+                    operand.value === operation.callee.value &&
+                    operation.receiver?.value !== operand.value &&
+                    !operation.arguments.some((argument) => argument.value === operand.value))
+                    continue;
+                escaped.add(operand.value);
+            }
+        }
+    }
+    for (const block of body.blocks.values()) {
+        for (const operation of allOperationsOf(block)) {
+            if (operation.kind !== 'get')
+                continue;
+            // A method returned, stored, or inspected is selected at property-read
+            // time. Only a value consumed exclusively as an immediate callee may
+            // defer that selection to the receiver's virtual dispatch member.
+            if (!immediate.has(operation.result.id) || escaped.has(operation.result.id))
+                continue;
+            const claim = virtualCalleeClaim(ctx, operation);
+            if (claim !== null)
+                callees.set(operation.result.id, claim);
+        }
+    }
+    return callees;
+};

package/dist/targets/cpp/document.d.ts

@@ -0,0 +1,74 @@
+import type { DeclarationId, FunctionId, RegionId, SemanticResultId } from '../../identity/ids.js';
+import { type Representation } from '../../representation/model.js';
+/**
+ * The sealed emission boundary (architecture.md, "Definition of done"). Every
+ * generated C++ section crosses this module exactly once, carrying enough
+ * authority for the fail-closed check in `render` to run without re-deriving
+ * anything from the rendered text.
+ */
+/**
+ * Whatever authored one section: a callable or class-lifecycle execution
+ * region for a function body, or the declaration a struct/global
+ * materializes. Always a checker-stable identity from `identity/ids.ts`,
+ * never a name, path, or generated spelling.
+ */
+export type CppSectionOwner = FunctionId | RegionId | DeclarationId;
+/**
+ * The semantic authority one section carries. `empty` is admitted only for a
+ * legacy string emitter mid-migration to structured facts (architecture.md);
+ * every other producer publishes the representation it materialized, who
+ * authored it, and the exact published semantic result the section answers.
+ */
+export type CppFacts = {
+    readonly kind: 'materialized';
+    readonly representation: Representation;
+    readonly owner: CppSectionOwner;
+    /**
+     * `null` only for a section that is synthesized structure with no
+     * semantic operation behind it -- the implicit close of a body that ends
+     * without a `return`. Naming some nearby result instead would attribute
+     * text to an operation that did not author it.
+     */
+    readonly lineage: SemanticResultId | null;
+} | {
+    readonly kind: 'empty';
+};
+/** The one legitimate `empty` value. Reach for this only for a legacy producer that has no structured facts yet. */
+export declare const emptyCppFacts: CppFacts;
+/** One generated section: its literal C++ text plus the facts that authorize it. */
+export interface CppArtifact {
+    readonly text: string;
+    readonly facts: CppFacts;
+}
+/** A sealed, ordered collection of artifacts. Order is significant: it is C++ declaration order. */
+export interface CppDocument {
+    readonly artifacts: readonly CppArtifact[];
+}
+export interface CppDocumentBuilder {
+    readonly append: (artifact: CppArtifact) => void;
+    readonly seal: () => CppDocument;
+}
+export declare const createCppDocumentBuilder: () => CppDocumentBuilder;
+declare const renderedCppSourceBrand: unique symbol;
+/**
+ * Terminal output. Rendering is the last step in the pipeline: this string may
+ * be written to disk or run through a formatter, but nothing downstream may
+ * parse, regex, or otherwise inspect it to recover a type, scope, ownership,
+ * or target decision -- every such decision already lives in the sealed plan
+ * and the facts that produced this text. No parse/inspect function for this
+ * type exists in this module, or anywhere else in `targets/cpp/`, on purpose.
+ */
+export type RenderedCppSource = string & {
+    readonly [renderedCppSourceBrand]: 'RenderedCppSource';
+};
+/** Fails closed before any artifact's text leaves the compiler if its facts are not safe to materialize. */
+export declare const render: (document: CppDocument) => RenderedCppSource;
+/**
+ * One marker line of a rendered document replaced by text known only after
+ * rendering -- the union alias block (`translation-unit.ts`), whose contents
+ * are the spellings the rendering itself recorded. The brand survives: the
+ * facts `render` checked are unchanged, and the spliced text is declarations
+ * that carry none.
+ */
+export declare const spliceRendered: (source: RenderedCppSource, marker: string, replacement: string) => RenderedCppSource;
+export {};

package/dist/targets/cpp/document.js

@@ -0,0 +1,106 @@
+import { dynamicReasons } from '../../representation/model.js';
+/** The one legitimate `empty` value. Reach for this only for a legacy producer that has no structured facts yet. */
+export const emptyCppFacts = { kind: 'empty' };
+export const createCppDocumentBuilder = () => {
+    const artifacts = [];
+    let sealed = false;
+    const append = (artifact) => {
+        if (sealed)
+            throw new Error('cpp document is sealed; cannot append an artifact after freeze');
+        artifacts.push(artifact);
+    };
+    const seal = () => {
+        sealed = true;
+        return Object.freeze({ artifacts: Object.freeze([...artifacts]) });
+    };
+    return { append, seal };
+};
+const abiIsRenderable = (abi) => abi.parameters.every((parameter) => representationIsRenderable(parameter.value)) &&
+    representationIsRenderable(abi.result) &&
+    (abi.receiver === null || representationIsRenderable(abi.receiver));
+/**
+ * `unresolved` is lattice bottom, not an answer, and a `dynamic` carrier is
+ * legitimate only for one of the four declared reasons in
+ * `representation/model.ts`. Both are checked recursively: a record field, an
+ * array element, an ABI parameter, or a union arm can bury either one under
+ * an otherwise ordinary carrier, and a shallow `kind` check would miss it.
+ */
+const representationIsRenderable = (representation) => {
+    switch (representation.kind) {
+        case 'unresolved':
+            return false;
+        case 'dynamic':
+            return dynamicReasons.includes(representation.reason);
+        case 'void':
+        case 'string':
+        case 'symbol':
+        case 'null':
+        case 'undefined':
+        case 'scalar':
+        case 'class-ref':
+        case 'native-handle':
+        case 'native-record-ref':
+        case 'typed-array':
+        case 'array-buffer':
+        case 'shared-array-buffer':
+        case 'data-view':
+        // A function identity is one refcounted handle with no nested carrier.
+        case 'callable-identity':
+            return true;
+        case 'record':
+            return representation.fields.every((field) => representationIsRenderable(field.value));
+        case 'record-with-index':
+            return (representation.fields.every((field) => representationIsRenderable(field.value)) &&
+                representation.indexes.every((index) => representationIsRenderable(index.value)));
+        case 'proxy-object':
+            return representationIsRenderable(representation.target) && representationIsRenderable(representation.handler);
+        case 'borrowed-ref':
+            return representationIsRenderable(representation.referent);
+        case 'array-object':
+        case 'dense-buffer':
+        case 'native-sequence':
+        case 'iterator':
+            return representationIsRenderable(representation.element);
+        case 'promise':
+            return representationIsRenderable(representation.value);
+        case 'keyed-collection':
+            return representationIsRenderable(representation.key) && (!representation.value || representationIsRenderable(representation.value));
+        case 'dictionary':
+            return representationIsRenderable(representation.value);
+        case 'function':
+        case 'function-family':
+        case 'constructor-family':
+        case 'constructor-value-dispatch':
+        case 'function-value-family':
+        case 'function-value-dispatch':
+            return abiIsRenderable(representation.abi);
+        case 'generic-function-set':
+            return true;
+        case 'function-and-constructor':
+            return abiIsRenderable(representation.call) && abiIsRenderable(representation.construct);
+        case 'optional':
+            return representationIsRenderable(representation.payload);
+        case 'tagged-union':
+            return representation.arms.every((arm) => representationIsRenderable(arm.value));
+    }
+};
+/** Fails closed before any artifact's text leaves the compiler if its facts are not safe to materialize. */
+export const render = (document) => {
+    for (const artifact of document.artifacts) {
+        if (artifact.facts.kind === 'empty')
+            continue;
+        if (!representationIsRenderable(artifact.facts.representation)) {
+            throw new Error(`cpp artifact for owner ${artifact.facts.owner} (result ${artifact.facts.lineage}) carries an unresolved or ` +
+                `undeclared-dynamic representation and cannot render`);
+        }
+    }
+    return document.artifacts.map((artifact) => artifact.text).join('\n');
+};
+/**
+ * One marker line of a rendered document replaced by text known only after
+ * rendering -- the union alias block (`translation-unit.ts`), whose contents
+ * are the spellings the rendering itself recorded. The brand survives: the
+ * facts `render` checked are unchanged, and the spliced text is declarations
+ * that carry none.
+ */
+export const spliceRendered = (source, marker, replacement) => source.replace(marker, replacement);

package/dist/targets/cpp/emit-allocation.d.ts

@@ -0,0 +1,60 @@
+import type { AllocateRecordOperation, AllocateRegExpOperation, AllocateTemplateObjectOperation, SpreadCopyOperation } from '../../ir/model.js';
+import { type EmitContext } from './emit-context.js';
+export declare const emitAllocateRecord: (ctx: EmitContext, lines: string[], operation: AllocateRecordOperation) => void;
+/**
+ * `` tag`a${b}c` ``'s first argument: the template object, built once per site.
+ *
+ * The per-site `static` IS the semantics. ECMA-262 13.2.8.3 caches
+ * `GetTemplateObject` per Parse Node, so the tag must be handed the same object
+ * on every evaluation -- that is what makes a `WeakMap`-keyed tag cache (the
+ * dominant real use of tagged templates) work at all. A fresh object per
+ * evaluation would compile, run, and be quietly wrong.
+ *
+ * Only the native Array exotic carrier is admitted. A record-with-index can
+ * resemble the checker's structural declaration, but it cannot implement
+ * Array index/length descriptors, frozen integrity, or the exact `raw` own
+ * property. Treating that resemblance as a carrier was therefore a silent
+ * semantic downgrade, not another valid lowering.
+ */
+export declare const emitAllocateTemplateObject: (ctx: EmitContext, lines: string[], operation: AllocateTemplateObjectOperation) => void;
+export declare const emitAllocateRegExp: (ctx: EmitContext, lines: string[], operation: AllocateRegExpOperation) => void;
+export { emitToNumericCoercion } from './emit-tonumber.js';
+/**
+ * Object spread's `CopyDataProperties` for a source whose own-property set is
+ * not known until this runs -- `SpreadCopyOperation` (ir/model.ts), lowered
+ * from `producers/protocol.ts`'s `protocol: 'spread'` operation by
+ * `ir/lower-protocol.ts`. Lives here, not in a file of its own: it is one
+ * more way an object's own storage gets written -- the same subject this
+ * file's `emitAllocateDictionary` (above) already owns for a literal's own
+ * keys -- and `targets/cpp` sits at the architecture gate's per-directory
+ * file-count cap, so a new top-level file for one function is not free here.
+ *
+ * This backend renders two deliberately narrow receiver/source pairs:
+ * `dynamic` into `dynamic`, with the full CopyDataProperties key,
+ * descriptor, Get, and CreateDataProperty sequence; and a plain
+ * `dictionary` receiver with the statically selected structural source
+ * carriers below. A dynamic source does not certify the dictionary path: it
+ * may contain symbol keys that the dictionary's string-key insertion loop
+ * cannot preserve.
+ *
+ * The SOURCE may be a plain `dictionary`, a `tagged-union` whose arms are
+ * each a `dictionary` or a `record`, or an `optional` wrapping either of
+ * those -- `HeaderRecord`'s own three arms (`Record<'Content-Type',
+ * BaseMime> | Record<ResponseHeader, string | string[]> | Record<string,
+ * string | string[]>`) are exactly one `record`, one `record` and one
+ * `dictionary`, and `setDefaultContentType`'s `headers?: HeaderRecord`
+ * parameter wraps that same union `optional`. A `dictionary` arm's copy is a
+ * runtime walk (`gea::Dictionary::copyInto`, gea_runtime.h); a `record` arm's
+ * copy is a static per-FIELD unroll, since its keys are known at compile
+ * time; an `optional` source is `CopyDataProperties(obj, source)` itself --
+ * spreading `null`/`undefined` is a no-op per that abstract operation, so an
+ * absent optional renders no copy at all, and a present one recurses into
+ * whichever of the two shapes its payload is. Any other kind -- `record-
+ * with-index`, `native-record-ref`, `class-ref`, ... -- refuses by name:
+ * unrolling those needs a field list this file does not have a uniform way
+ * to read yet, and a record arm with an accessor member refuses for the same
+ * reason `producers/shared.ts`'s `staticSpreadMembersOf` already refuses one
+ * on the static-copy path -- an accessor must be CALLED, which is not
+ * modelled here.
+ */
+export declare const emitSpreadCopy: (ctx: EmitContext, lines: string[], operation: SpreadCopyOperation) => void;