@geastack/compiler 1.0.15

package/dist/representation/intersection.d.ts

@@ -0,0 +1,84 @@
+import type { DeclarationId, StructuralTypeId } from '../identity/ids.js';
+import type { StructuralShape } from '../semantics/model/structural-types.js';
+import type { Representation } from './model.js';
+/**
+ * The two rules an INTERSECTION needs that are about carriers rather than
+ * about types.
+ *
+ * `&` is associative and the checker owns what a key of `A & B` holds
+ * (`derive.ts`'s `resolved` branch reads that answer). What is left here is
+ * the part the checker does not answer: which members are structurally the
+ * same intersection, and -- for the self-referential retry, which has no
+ * reconciliation to read -- how two carriers for one key reduce to one.
+ */
+/**
+ * An intersection's members with any NESTED intersection spliced in.
+ *
+ * `&` is associative, so `A & (B & C)` and `A & B & C` are the same type and
+ * must reach the same carrier. They did not: a member that is itself an
+ * intersection -- almost always because a NAME stands for one, and
+ * `structural-declared-body.ts` interns a named intersection's body as an
+ * `intersection` shape rather than expanding it -- has no object shape of
+ * its own, so `intersectionMemberShape` answered `null` and the whole
+ * intersection refused for having a member that "is not a record shape".
+ * mongodb's `WithId<TSchema> = EnhancedOmit<TSchema, '_id'> & { _id:
+ * InferIdType<TSchema> }` is the case, and it is a member of nearly every
+ * collection type the driver declares.
+ *
+ * A member whose declaration a plugin binds to a NATIVE carrier is never
+ * spliced: `deriveIntersection`'s own first rule says a host's name outranks
+ * the structure it erases to, and splicing such a member would erase exactly
+ * the name that rule exists to keep.
+ *
+ * The `seen` set is what makes this terminate on a self-referential alias
+ * (`type Loop = Loop & { x: number }` is writable), and re-entering a member
+ * already spliced contributes nothing new in any case.
+ */
+export declare const createIntersectionFlattener: (shapeOf: (id: StructuralTypeId) => StructuralShape | null, isNativeBound: (declaration: DeclarationId) => boolean) => ((members: readonly StructuralTypeId[], seen?: Set<StructuralTypeId>) => readonly StructuralTypeId[]);
+/**
+ * The physical carrier for a property that TWO intersection members both
+ * constrain, computed the way the language itself computes `A & B` for a
+ * property present in both -- not by demanding the two members already
+ * derived to the identical carrier.
+ *
+ * `A & B` means a value is BOTH, so for a shared key the correct type is
+ * the intersection of the two members' property types, which TypeScript
+ * already reduces on its own: `false & (boolean | undefined)` is `false`,
+ * not a disagreement, because an intersection value has no `undefined`
+ * arm left for it to be absent through once one member requires it
+ * present. This deriver has no checker to ask
+ * `getTypeOfPropertyOfType` directly (see this file's own module
+ * comment: it reads nothing but the sealed structural table), so it
+ * recovers the same reduction structurally: an `optional` carrier peels
+ * to its `payload` exactly when that payload matches -- recursively --
+ * the other member's own carrier for the same key, which is the
+ * representation-level statement of "the other member proves this value
+ * present". The merge loop below already tracks presence independently,
+ * in the `RecordField`'s own `required` bit, so peeling never has to
+ * touch it. Two carriers that do not reduce to one this way still refuse
+ * by name below, exactly as before -- this recovers a real TypeScript
+ * reduction, it does not relax the guard.
+ */
+export declare const intersectPropertyRepresentations: (a: Representation, b: Representation) => Representation | null;
+/** Resolve a structural id to its shape; the deriver's own table lookup. */
+type ShapeLookup = (id: StructuralTypeId) => StructuralShape | null;
+/**
+ * What an intersection member that is not a record shape actually is.
+ *
+ * Purely diagnostic. The refusal names the member by id, which says nothing
+ * about WHY it is not a record, and an id is a table index that cannot be
+ * resolved back from a log. A declared name reports the kind of the body it
+ * stands for, because "declared" on its own is never the answer -- the
+ * interesting fact is what the declaration resolves to.
+ */
+export declare const intersectionMemberKindOf: (shapeOf: ShapeLookup, member: StructuralTypeId) => string;
+/**
+ * Whether a member is a PRIMITIVE VALUE -- one whose carrier is a scalar,
+ * including a literal type, which is a scalar pinned to one value.
+ *
+ * Asked through the declared wrapper for the same reason the deriver's
+ * nominal-class test is: an alias reaches the deriver as a `declared` shape
+ * over the body it names.
+ */
+export declare const isPrimitiveValueShape: (shapeOf: ShapeLookup, member: StructuralTypeId) => boolean;
+export {};

package/dist/representation/intersection.js

@@ -0,0 +1,149 @@
+import { representationKey } from './model.js';
+/**
+ * The two rules an INTERSECTION needs that are about carriers rather than
+ * about types.
+ *
+ * `&` is associative and the checker owns what a key of `A & B` holds
+ * (`derive.ts`'s `resolved` branch reads that answer). What is left here is
+ * the part the checker does not answer: which members are structurally the
+ * same intersection, and -- for the self-referential retry, which has no
+ * reconciliation to read -- how two carriers for one key reduce to one.
+ */
+/**
+ * An intersection's members with any NESTED intersection spliced in.
+ *
+ * `&` is associative, so `A & (B & C)` and `A & B & C` are the same type and
+ * must reach the same carrier. They did not: a member that is itself an
+ * intersection -- almost always because a NAME stands for one, and
+ * `structural-declared-body.ts` interns a named intersection's body as an
+ * `intersection` shape rather than expanding it -- has no object shape of
+ * its own, so `intersectionMemberShape` answered `null` and the whole
+ * intersection refused for having a member that "is not a record shape".
+ * mongodb's `WithId<TSchema> = EnhancedOmit<TSchema, '_id'> & { _id:
+ * InferIdType<TSchema> }` is the case, and it is a member of nearly every
+ * collection type the driver declares.
+ *
+ * A member whose declaration a plugin binds to a NATIVE carrier is never
+ * spliced: `deriveIntersection`'s own first rule says a host's name outranks
+ * the structure it erases to, and splicing such a member would erase exactly
+ * the name that rule exists to keep.
+ *
+ * The `seen` set is what makes this terminate on a self-referential alias
+ * (`type Loop = Loop & { x: number }` is writable), and re-entering a member
+ * already spliced contributes nothing new in any case.
+ */
+export const createIntersectionFlattener = (shapeOf, isNativeBound) => {
+    const flattenedIntersectionMembers = (members, seen = new Set()) => members.flatMap((member) => {
+        if (seen.has(member))
+            return [];
+        const shape = shapeOf(member);
+        const declaration = shape?.kind === 'intersection' || shape?.kind === 'declared' ? shape.declaration : null;
+        if (declaration && isNativeBound(declaration))
+            return [member];
+        const nested = shape?.kind === 'intersection' ? shape : shape?.kind === 'declared' && shape.body !== null ? shapeOf(shape.body) : null;
+        if (nested?.kind !== 'intersection')
+            return [member];
+        seen.add(member);
+        return flattenedIntersectionMembers(nested.members, seen);
+    });
+    return flattenedIntersectionMembers;
+};
+/**
+ * The physical carrier for a property that TWO intersection members both
+ * constrain, computed the way the language itself computes `A & B` for a
+ * property present in both -- not by demanding the two members already
+ * derived to the identical carrier.
+ *
+ * `A & B` means a value is BOTH, so for a shared key the correct type is
+ * the intersection of the two members' property types, which TypeScript
+ * already reduces on its own: `false & (boolean | undefined)` is `false`,
+ * not a disagreement, because an intersection value has no `undefined`
+ * arm left for it to be absent through once one member requires it
+ * present. This deriver has no checker to ask
+ * `getTypeOfPropertyOfType` directly (see this file's own module
+ * comment: it reads nothing but the sealed structural table), so it
+ * recovers the same reduction structurally: an `optional` carrier peels
+ * to its `payload` exactly when that payload matches -- recursively --
+ * the other member's own carrier for the same key, which is the
+ * representation-level statement of "the other member proves this value
+ * present". The merge loop below already tracks presence independently,
+ * in the `RecordField`'s own `required` bit, so peeling never has to
+ * touch it. Two carriers that do not reduce to one this way still refuse
+ * by name below, exactly as before -- this recovers a real TypeScript
+ * reduction, it does not relax the guard.
+ */
+export const intersectPropertyRepresentations = (a, b) => {
+    if (representationKey(a) === representationKey(b))
+        return a;
+    if (a.kind === 'optional')
+        return intersectPropertyRepresentations(a.payload, b);
+    if (b.kind === 'optional')
+        return intersectPropertyRepresentations(a, b.payload);
+    // A `tagged-union` is the same reduction one level up: `derive.ts`'s
+    // `deriveUnion` builds one instead of an `optional` exactly when a
+    // union carries BOTH absent values alongside a present arm (`T | null
+    // | undefined`), per `model.ts`'s own comment on `optional`. Its arms
+    // are proven pairwise disjoint, so at most one can ever match the
+    // other member's own carrier -- peeling to that one arm is the same
+    // "the other member proves which case is live" reduction as the
+    // `optional` case above, just against more than one absent arm at
+    // once (`null: PixelFormat_Options.internalFormat` reducing `null &
+    // (PixelFormat | null | undefined)` to `null`).
+    if (a.kind === 'tagged-union') {
+        for (const arm of a.arms) {
+            const reconciled = intersectPropertyRepresentations(arm.value, b);
+            if (reconciled)
+                return reconciled;
+        }
+        return null;
+    }
+    if (b.kind === 'tagged-union') {
+        for (const arm of b.arms) {
+            const reconciled = intersectPropertyRepresentations(a, arm.value);
+            if (reconciled)
+                return reconciled;
+        }
+        return null;
+    }
+    return null;
+};
+/**
+ * What an intersection member that is not a record shape actually is.
+ *
+ * Purely diagnostic. The refusal names the member by id, which says nothing
+ * about WHY it is not a record, and an id is a table index that cannot be
+ * resolved back from a log. A declared name reports the kind of the body it
+ * stands for, because "declared" on its own is never the answer -- the
+ * interesting fact is what the declaration resolves to.
+ */
+export const intersectionMemberKindOf = (shapeOf, member) => {
+    const shape = shapeOf(member);
+    if (!shape)
+        return 'no shape';
+    if (shape.kind === 'literal')
+        return `literal ${shape.primitive} ${shape.text}`;
+    if (shape.kind !== 'declared')
+        return shape.kind;
+    if (!shape.body)
+        return 'declared, no body';
+    return `declared -> ${shapeOf(shape.body)?.kind ?? 'no shape'}`;
+};
+/**
+ * Whether a member is a PRIMITIVE VALUE -- one whose carrier is a scalar,
+ * including a literal type, which is a scalar pinned to one value.
+ *
+ * Asked through the declared wrapper for the same reason the deriver's
+ * nominal-class test is: an alias reaches the deriver as a `declared` shape
+ * over the body it names.
+ */
+export const isPrimitiveValueShape = (shapeOf, member) => {
+    const shape = shapeOf(member);
+    if (!shape)
+        return false;
+    if (shape.kind === 'primitive' || shape.kind === 'literal')
+        return true;
+    if (shape.kind !== 'declared' || shape.body === null)
+        return false;
+    const body = shapeOf(shape.body)?.kind;
+    return body === 'primitive' || body === 'literal';
+};

package/dist/representation/literal-destination.d.ts

@@ -0,0 +1,43 @@
+import type { SemanticResultId } from '../identity/ids.js';
+import type { SemanticGraph } from '../semantics/model/graph.js';
+import type { RepresentationDeriver } from './derive.js';
+import { type Representation } from './model.js';
+/**
+ * An object literal minted directly as the carrier of the one place it goes.
+ *
+ * `{ data, width, height }` initializing a cell declared
+ * `{data: TypedArray, width: number, height: number}` derives, from the
+ * literal's own checker type, an anonymous record whose `data` still admits
+ * the constructor's `null` default. Selecting that carrier and then
+ * converting it into the cell's record is a structural record rebuild
+ * (`view:structural-record`) of a value nobody else ever observes: the
+ * literal is fresh, so it has no identity to keep, and its only consumer is
+ * that one initializer. The plan is the authority for what the value
+ * physically is, so the literal is published here as the destination's
+ * record instead. Each member install then stores into the destination's own
+ * field (`projection/slots.ts`'s `storeSlot` -> `fieldSlot`) through the
+ * ordinary census node for that field pair. Only a member whose entry into
+ * that field is TOTAL is admitted (below), so the override never asks an
+ * install for a narrowing -- a presence test, a downcast -- it cannot prove.
+ *
+ * Admitted only when every one of these holds; otherwise the literal keeps
+ * its structural derivation and whatever conversion plan it had:
+ * - the literal's own members are plain data installs under constant keys
+ *   (no spread protocol, accessor, computed key or non-default attributes --
+ *   anything else citing the fresh object is a second consumer);
+ * - across the literal and its installs there is exactly ONE outside
+ *   citation, and it is a `binding` initialization's `initializer`;
+ * - both carriers are plain records (no accessors) with the same ownership
+ *   and the SAME key set, which is also the set of keys the installs write --
+ *   an extra key the destination cannot hold, or a destination field the
+ *   literal never writes, refuses;
+ * - every member's carrier enters the destination's field TOTALLY
+ *   (`nativeTotalSelectionStepOf`): a field the literal may hold `null` in
+ *   but the destination declares non-null would need a presence proof the
+ *   install does not have, so it refuses rather than certify `(*value)`.
+ *
+ * The answer is keyed by every result of the literal's own chain -- the
+ * allocation and each install, which all publish the literal's type -- so the
+ * whole chain commits one carrier.
+ */
+export declare const literalDestinationsOf: (graph: Pick<SemanticGraph, "operations">, deriver: Pick<RepresentationDeriver, "derive" | "deriveStored">) => ReadonlyMap<SemanticResultId, Representation>;

package/dist/representation/literal-destination.js

@@ -0,0 +1,133 @@
+import { representationKey } from './model.js';
+import { nativeTotalSelectionStepOf } from '../conversion/native-selection.js';
+/**
+ * An object literal minted directly as the carrier of the one place it goes.
+ *
+ * `{ data, width, height }` initializing a cell declared
+ * `{data: TypedArray, width: number, height: number}` derives, from the
+ * literal's own checker type, an anonymous record whose `data` still admits
+ * the constructor's `null` default. Selecting that carrier and then
+ * converting it into the cell's record is a structural record rebuild
+ * (`view:structural-record`) of a value nobody else ever observes: the
+ * literal is fresh, so it has no identity to keep, and its only consumer is
+ * that one initializer. The plan is the authority for what the value
+ * physically is, so the literal is published here as the destination's
+ * record instead. Each member install then stores into the destination's own
+ * field (`projection/slots.ts`'s `storeSlot` -> `fieldSlot`) through the
+ * ordinary census node for that field pair. Only a member whose entry into
+ * that field is TOTAL is admitted (below), so the override never asks an
+ * install for a narrowing -- a presence test, a downcast -- it cannot prove.
+ *
+ * Admitted only when every one of these holds; otherwise the literal keeps
+ * its structural derivation and whatever conversion plan it had:
+ * - the literal's own members are plain data installs under constant keys
+ *   (no spread protocol, accessor, computed key or non-default attributes --
+ *   anything else citing the fresh object is a second consumer);
+ * - across the literal and its installs there is exactly ONE outside
+ *   citation, and it is a `binding` initialization's `initializer`;
+ * - both carriers are plain records (no accessors) with the same ownership
+ *   and the SAME key set, which is also the set of keys the installs write --
+ *   an extra key the destination cannot hold, or a destination field the
+ *   literal never writes, refuses;
+ * - every member's carrier enters the destination's field TOTALLY
+ *   (`nativeTotalSelectionStepOf`): a field the literal may hold `null` in
+ *   but the destination declares non-null would need a presence proof the
+ *   install does not have, so it refuses rather than certify `(*value)`.
+ *
+ * The answer is keyed by every result of the literal's own chain -- the
+ * allocation and each install, which all publish the literal's type -- so the
+ * whole chain commits one carrier.
+ */
+export const literalDestinationsOf = (graph, deriver) => {
+    const citations = new Map();
+    for (const operation of graph.operations.values())
+        for (const operand of operation.operands) {
+            if (operand.source.kind !== 'result')
+                continue;
+            const cited = citations.get(operand.source.result) ?? [];
+            cited.push({ operation, operand });
+            citations.set(operand.source.result, cited);
+        }
+    const destinations = new Map();
+    for (const operation of graph.operations.values()) {
+        if (operation.family !== 'allocation' || operation.allocated !== 'object-literal')
+            continue;
+        const own = operation.results.length === 1 ? operation.results[0] : undefined;
+        if (!own || own.role !== 'value')
+            continue;
+        const installs = [];
+        const outside = [];
+        for (const citation of citations.get(own.id) ?? [])
+            if (isOwnInstall(citation.operation, citation.operand))
+                installs.push(citation.operation);
+            else
+                outside.push(citation);
+        for (const install of installs)
+            for (const result of install.results)
+                outside.push(...(citations.get(result.id) ?? []));
+        const sole = outside.length === 1 ? outside[0] : undefined;
+        if (!sole || !isInitializer(sole.operation, sole.operand))
+            continue;
+        const cell = sole.operation.results.length === 1 ? sole.operation.results[0] : undefined;
+        if (!cell)
+            continue;
+        const literal = deriver.derive(own.type);
+        const target = deriver.deriveStored(cell.type);
+        if (literal.kind !== 'record' || target.kind !== 'record')
+            continue;
+        if (literal.accessors.length > 0 || target.accessors.length > 0 || literal.ownership !== target.ownership)
+            continue;
+        if (representationKey(literal) === representationKey(target))
+            continue;
+        const targetKeys = new Set(target.fields.map((field) => field.key));
+        const sameKeys = (keys) => keys.size === targetKeys.size && [...keys].every((key) => targetKeys.has(key));
+        if (!sameKeys(new Set(literal.fields.map((field) => field.key))))
+            continue;
+        if (!sameKeys(new Set(installs.map(installedKeyOf))))
+            continue;
+        // Every member must enter its destination field TOTALLY. A partial entry --
+        // `data: ?Uint8Array` stored into `data: Uint8Array`, whose only recipe is
+        // the present-optional load `(*data)` -- needs a presence proof no install
+        // site has: the value the literal holds may still be `null`. Choosing the
+        // destination there would certify an unguarded unwrap, so the literal
+        // keeps its own carrier and whatever plan it had.
+        const held = new Map(literal.fields.map((field) => [field.key, field.value]));
+        if (!target.fields.every((field) => {
+            const value = held.get(field.key);
+            return (value !== undefined &&
+                (representationKey(value) === representationKey(field.value) || nativeTotalSelectionStepOf(value, field.value) !== null));
+        }))
+            continue;
+        destinations.set(own.id, target);
+        for (const install of installs)
+            for (const result of install.results)
+                destinations.set(result.id, target);
+    }
+    return destinations;
+};
+/** `CreateDataPropertyOrThrow` of one of the literal's own members onto the fresh object. */
+const isOwnInstall = (operation, operand) => {
+    if (operation.family !== 'property' || operation.internalMethod !== 'define-own-property' || operation.keyIsComputed)
+        return false;
+    if (operand.role !== 'receiver' || operand.evaluation.kind !== 'provenance')
+        return false;
+    const descriptor = operation.descriptor;
+    if (!descriptor || descriptor.writable !== true || descriptor.enumerable !== true || descriptor.configurable !== true)
+        return false;
+    if (operation.results.length !== 1)
+        return false;
+    return keyOperandOf(operation)?.source.kind === 'constant';
+};
+const keyOperandOf = (operation) => operation.operands.find((operand) => operand.role === 'key' && operand.ordinal === 0);
+const installedKeyOf = (install) => {
+    const source = keyOperandOf(install)?.source;
+    return source?.kind === 'constant' ? source.text : '';
+};
+/** A plain lexical cell initialized with the value, evaluated unconditionally. */
+const isInitializer = (operation, operand) => operation.family === 'binding' &&
+    operation.action === 'initialize' &&
+    operation.parameterInitialization !== true &&
+    operation.external === undefined &&
+    operation.commonJs === undefined &&
+    operand.role === 'initializer' &&
+    operand.evaluation.kind === 'runtime';

package/dist/representation/merge.d.ts

@@ -0,0 +1,18 @@
+import type { StructuralTypeId } from '../identity/ids.js';
+import type { SemanticOperand } from '../semantics/model/operands.js';
+import type { StructuralType } from '../semantics/model/structural-types.js';
+import type { RepresentationDeriver } from './derive.js';
+import { type Representation } from './model.js';
+/** The exact value retained by an object-shaped falsy `&&` operand.
+ * An explicitly tagged destination must preserve null versus undefined.
+ * This is branch-local materialization, never a general object conversion.
+ */
+export declare const mergeTaggedAbsence: (source: Representation, target: Representation) => "null" | "undefined" | null;
+export declare const mergeFalsyAbsence: (source: Representation, target: Representation) => "null" | "undefined" | null;
+/**
+ * A merge can construct these values in its own carrier without converting an
+ * incoming carrier. Preflight and lowering must ask the same question: a
+ * `never[]` arm contains no elements, whereas `void[]` and `undefined[]` may
+ * contain real entries even though their element types occupy no storage.
+ */
+export declare const mergeMaterialization: (types: ReadonlyMap<StructuralTypeId, StructuralType>, deriver: RepresentationDeriver, operand: SemanticOperand, target: Representation) => "constant" | "empty-array" | "absence" | "unreachable" | null;

package/dist/representation/merge.js

@@ -0,0 +1,83 @@
+import { carriesMergeAbsence, carriesUndefined, contributesOnlyAbsence } from './model.js';
+/** The exact value retained by an object-shaped falsy `&&` operand.
+ * An explicitly tagged destination must preserve null versus undefined.
+ * This is branch-local materialization, never a general object conversion.
+ */
+export const mergeTaggedAbsence = (source, target) => {
+    if (target.kind !== 'tagged-union')
+        return null;
+    const absence = source.kind === 'optional'
+        ? source.absence
+        : source.kind === 'native-handle' || (source.kind === 'class-ref' && source.ownership === 'shared-refcount')
+            ? 'null'
+            : null;
+    return absence && target.arms.some((arm) => arm.value.kind === absence) ? absence : null;
+};
+export const mergeFalsyAbsence = (source, target) => contributesOnlyAbsence(source) ? mergeTaggedAbsence(source, target) : null;
+/**
+ * A merge can construct these values in its own carrier without converting an
+ * incoming carrier. Preflight and lowering must ask the same question: a
+ * `never[]` arm contains no elements, whereas `void[]` and `undefined[]` may
+ * contain real entries even though their element types occupy no storage.
+ */
+export const mergeMaterialization = (types, deriver, operand, target) => {
+    if (operand.source.kind === 'constant' && deriver.derive(operand.type).kind === 'void')
+        return 'constant';
+    const shape = types.get(operand.type)?.shape;
+    // A non-constant expression typed `never` cannot complete normally, so its
+    // branch contributes no runtime value to the phi. When the destination has
+    // an absence state, materialize that state solely to give C++ a typed
+    // incoming expression for the unreachable edge. Otherwise the edge gets an
+    // unreachable value of the merge's own carrier: `k === 0 ? a : k === 1 ? b
+    // : Debug.fail()` is tsc's standing idiom (17 rows on the self-compile),
+    // and its last arm never delivers anything to convert. Both are
+    // branch-local: neither installs a general `void -> object` conversion.
+    if (shape?.kind === 'primitive' && shape.primitive === 'never')
+        return carriesMergeAbsence(target) ? 'absence' : 'unreachable';
+    // A `void` call as a default (`[w = counter()]`) publishes no value at all;
+    // what the merge receives from that arm is `undefined`, spelled in the
+    // target's own absence -- the call itself still runs in the arm.
+    if (shape?.kind === 'primitive' && (shape.primitive === 'void' || shape.primitive === 'undefined') && carriesUndefined(target))
+        return 'absence';
+    if (holdsEmptyArray(types, target) && isEmptyArrayLiteralType(deriver, shape))
+        return 'empty-array';
+    return null;
+};
+/**
+ * The type of an array literal with no elements, in the two spellings the
+ * checker gives one.
+ *
+ * This is the same pair `semantics/normalize/structural.ts` recognizes when it
+ * DROPS an empty-array arm out of a union -- "13.2.4.2 gives an ArrayLiteral
+ * with no elements an Array of length 0, and a value with no element cannot
+ * disagree with any element type, so it is already a value of the arm beside
+ * it". That drop is what makes `path.match(re) || []` publish the surviving
+ * arm's carrier alone, so the two have to admit the identical set: an arm the
+ * join removes and this does not recognize is a merge with no incoming value
+ * at all.
+ *
+ * Both spellings really occur, decided by what contextually types the literal:
+ * `input || []` against a `string[]` gets the array shape, while `path.match(re)
+ * || []` gets the empty TUPLE, because `RegExpMatchArray` is an array-LIKE with
+ * members of its own rather than an `Array<T>`. Only the array-of-never
+ * spelling was admitted, so the tuple one refused.
+ */
+const isEmptyArrayLiteralType = (deriver, shape) => shape?.kind === 'tuple' ? shape.elements.length === 0 : shape?.kind === 'array' && deriver.isNeverType(shape.element);
+/**
+ * A carrier an empty array can be BUILT in, rather than converted into.
+ *
+ * `array-object` is the obvious one. The other is a stated-native record whose
+ * structural shape is an array: `RegExpMatchArray` is `gea::runtime::regex::
+ * MatchResult`, which IS a `gea::ArrayObject<std::string>` carrying the members
+ * 22.1.3.13 adds beside it, all of them default-initialized. An empty one is
+ * therefore constructible and is exactly the `[]` the program wrote -- the same
+ * `[]` TypeScript itself already accepts here, `RegExpMatchArray`'s required
+ * `[0]` notwithstanding, because an empty array disagrees with no element type.
+ *
+ * Asked of the target's own shape rather than of a list of native names: the
+ * fact that licenses the construction is "this carrier holds an array", and a
+ * name list would be a second authority over the same question that drifts the
+ * first time a host states another array-like type.
+ */
+const holdsEmptyArray = (types, target) => target.kind === 'array-object' ||
+    (target.kind === 'native-record-ref' && types.get(target.shapeId)?.shape.kind === 'array');