@geastack/compiler 1.0.15

package/dist/semantics/normalize/cells/policies/bag.d.ts

@@ -0,0 +1,44 @@
+import ts from 'typescript';
+import type { ObjectBagIdentity } from '../../object-bag-bindings.js';
+import type { CellEvidencePolicy } from '../policy.js';
+/**
+ * The BAG domain: `object-bag-bindings.ts`'s open-property-bag question,
+ * restated as evidence rules over the shared flow index's
+ * `property-assignment`/`index-assignment` edges, joined per MEMBER NAME
+ * (`write.member`) rather than per cell -- the same
+ * `CellEvidenceContribution` extension `collection.ts` introduced, applied to
+ * the obstacle `policies/index.ts`'s header used to call the harder one:
+ * the member-name join was never the blocker.
+ *
+ * What this policy does NOT do, and could not without duplicating
+ * `object-bag-bindings.ts`'s own fixpoint a second time: decide which
+ * declarations are the SAME bag. That is `identity`'s published answer
+ * (`ObjectBagIdentity` -- `bagOf`/`returnsBag`/`conflicted`/`ungrounded`,
+ * settled once by a whole-program worklist over assignments, exhaustive
+ * `return`s, and one layer of callee-alias unwrapping). This policy CONSUMES
+ * that settled fixpoint rather than re-deriving it: `candidatesOf` is not a
+ * per-node syntactic test over `files` at all (every other domain's is) --
+ * it is `identity.roots`, the set the fixpoint already found, handed to this
+ * policy at construction alongside the checker.
+ *
+ * `writesOf` reads `identity.bagOf`'s own entries to pool one root's aliases
+ * -- every declaration the fixpoint proved is the same storage -- exactly
+ * the way `collection.ts`'s `writesOverAliasClosure` widens WHERE evidence is
+ * gathered from, except the closure here is not walked again: it was already
+ * computed, so this is a lookup into the published map rather than a second
+ * BFS over `flow.flowsFromDeclaration`.
+ *
+ * What is left unported, matching `collection.ts`'s own posture toward its
+ * gaps: `conflicted`/`ungrounded` roots are NOT excluded from `candidatesOf`
+ * -- a root is a candidate here exactly as an unwritten field is still a
+ * `field` candidate, and `combine` answering `null` for it (no admissible
+ * evidence, or a disagreement) is the same "no override" this table gives
+ * every other domain's failed candidate. Excluding them would hide a
+ * genuine collision from `twoOwnerClaims` for no gain, since nothing
+ * downstream reads this domain's answer yet. The `delete`/`Object.assign`/
+ * spread refusal vocabulary `object-bag-bindings.ts` applies before binding a
+ * shape is not restated: an opaque use simply contributes no evidence here,
+ * the same "narrower, not wrong" trade `collection.ts`'s header already
+ * accepts for its own left-out refusals.
+ */
+export declare const createBagCellPolicy: (checker: ts.TypeChecker, identity: ObjectBagIdentity) => CellEvidencePolicy;

package/dist/semantics/normalize/cells/policies/bag.js

@@ -0,0 +1,114 @@
+import { cellType } from '../model.js';
+import { rulesFor } from '../policy.js';
+import { joinCellTypeValues } from './shared.js';
+/**
+ * The BAG domain: `object-bag-bindings.ts`'s open-property-bag question,
+ * restated as evidence rules over the shared flow index's
+ * `property-assignment`/`index-assignment` edges, joined per MEMBER NAME
+ * (`write.member`) rather than per cell -- the same
+ * `CellEvidenceContribution` extension `collection.ts` introduced, applied to
+ * the obstacle `policies/index.ts`'s header used to call the harder one:
+ * the member-name join was never the blocker.
+ *
+ * What this policy does NOT do, and could not without duplicating
+ * `object-bag-bindings.ts`'s own fixpoint a second time: decide which
+ * declarations are the SAME bag. That is `identity`'s published answer
+ * (`ObjectBagIdentity` -- `bagOf`/`returnsBag`/`conflicted`/`ungrounded`,
+ * settled once by a whole-program worklist over assignments, exhaustive
+ * `return`s, and one layer of callee-alias unwrapping). This policy CONSUMES
+ * that settled fixpoint rather than re-deriving it: `candidatesOf` is not a
+ * per-node syntactic test over `files` at all (every other domain's is) --
+ * it is `identity.roots`, the set the fixpoint already found, handed to this
+ * policy at construction alongside the checker.
+ *
+ * `writesOf` reads `identity.bagOf`'s own entries to pool one root's aliases
+ * -- every declaration the fixpoint proved is the same storage -- exactly
+ * the way `collection.ts`'s `writesOverAliasClosure` widens WHERE evidence is
+ * gathered from, except the closure here is not walked again: it was already
+ * computed, so this is a lookup into the published map rather than a second
+ * BFS over `flow.flowsFromDeclaration`.
+ *
+ * What is left unported, matching `collection.ts`'s own posture toward its
+ * gaps: `conflicted`/`ungrounded` roots are NOT excluded from `candidatesOf`
+ * -- a root is a candidate here exactly as an unwritten field is still a
+ * `field` candidate, and `combine` answering `null` for it (no admissible
+ * evidence, or a disagreement) is the same "no override" this table gives
+ * every other domain's failed candidate. Excluding them would hide a
+ * genuine collision from `twoOwnerClaims` for no gain, since nothing
+ * downstream reads this domain's answer yet. The `delete`/`Object.assign`/
+ * spread refusal vocabulary `object-bag-bindings.ts` applies before binding a
+ * shape is not restated: an opaque use simply contributes no evidence here,
+ * the same "narrower, not wrong" trade `collection.ts`'s header already
+ * accepts for its own left-out refusals.
+ */
+export const createBagCellPolicy = (checker, identity) => {
+    const aliasesOfRoot = new Map();
+    for (const [declaration, root] of identity.bagOf) {
+        const bucket = aliasesOfRoot.get(root);
+        if (bucket)
+            bucket.push(declaration);
+        else
+            aliasesOfRoot.set(root, [declaration]);
+    }
+    const writesOverIdentity = (declaration, flow) => {
+        const aliases = aliasesOfRoot.get(declaration) ?? [declaration];
+        const writes = [];
+        for (const alias of aliases)
+            writes.push(...flow.writesToDeclaration(alias));
+        return writes;
+    };
+    const valueRule = (write) => (write.value ? cellType(checker.getTypeAtLocation(write.value)) : null);
+    return {
+        domain: 'bag',
+        // Not a `cellCandidatesOf` walk: the fixpoint already decided this set (see this
+        // module's own header), so `files` -- every other domain's input -- is not asked.
+        candidatesOf: () => [...identity.roots].map((root) => root),
+        // A root's own literal is admitted only when it declares no type of its own
+        // (`object-bag-bindings.ts`'s `declaresOwnType`), so every candidate here is
+        // unannotated by construction -- the same reason `local.ts`'s `statedAt` is
+        // a real read that always answers `null` rather than a shortcut.
+        statedAt: () => null,
+        checkerAt: (declaration) => cellType(checker.getTypeAtLocation(declaration)),
+        writesOf: writesOverIdentity,
+        rules: rulesFor([
+            ['property-assignment', valueRule],
+            ['index-assignment', valueRule]
+        ]),
+        // Per-MEMBER-NAME join, not per-cell: `write.slot === 'member'` groups by
+        // `write.member` into the bag's named members, and `write.slot === 'element'`
+        // (a computed key, `flow/value-flow.ts`'s own partition) is the index sidecar --
+        // exactly the two-question split `collection.ts` already makes for K/V, applied
+        // to a bag's members/index instead. Either half joining to `null` (no evidence,
+        // or a disagreement `joinCellTypeValues` refuses) contributes nothing to that
+        // half alone, matching `object-bag-bindings.ts`'s own per-slot degradation.
+        combine: (contributions) => {
+            const named = new Map();
+            const indexed = [];
+            for (const contribution of contributions) {
+                if (contribution.write.slot === 'member' && contribution.write.member !== null) {
+                    const bucket = named.get(contribution.write.member);
+                    if (bucket)
+                        bucket.push(contribution.value);
+                    else
+                        named.set(contribution.write.member, [contribution.value]);
+                }
+                else if (contribution.write.slot === 'element') {
+                    indexed.push(contribution.value);
+                }
+            }
+            if (named.size === 0 && indexed.length === 0)
+                return null;
+            const members = new Map();
+            for (const [key, values] of named) {
+                const joined = joinCellTypeValues(checker, values);
+                if (joined)
+                    members.set(key, joined);
+            }
+            const index = indexed.length > 0 ? joinCellTypeValues(checker, indexed) : null;
+            if (members.size === 0 && index === null)
+                return null;
+            const shape = { members, index };
+            return { kind: 'bag-shape', shape };
+        }
+    };
+};

package/dist/semantics/normalize/cells/policies/collection.d.ts

@@ -0,0 +1,42 @@
+import ts from 'typescript';
+import type { ProgramReachability } from '../../reachability.js';
+import type { CellEvidencePolicy } from '../policy.js';
+/**
+ * The COLLECTION domain: `collection-bindings.ts`'s Map/Set/WeakMap/WeakSet
+ * question (`CollectionTypeArguments`'s K/V), restated as two evidence rules
+ * (`collection-key`, `collection-value`) over `flow`'s edges of the same
+ * name, joined per SLOT rather than into one value -- see `combine` below.
+ *
+ * Deliberately NOT ported, and left for a later phase exactly as
+ * `parameter.ts`'s header leaves its own gap documented rather than silent:
+ *
+ * - The checker-only half of `argumentType`'s `known ?? resolve` rule.
+ *   `collection-bindings.ts` falls back to the COMPOSED PARAMETER CENSUS when
+ *   the checker's own answer for a key/value argument is unusable evidence --
+ *   the majority case in practice, since most of these sites are an untyped
+ *   local function parameter. This policy has no composed census to fall
+ *   back to (nothing wires one in for `defaultCellEvidencePolicies`, and
+ *   wiring one would be the exact kind of cross-domain coupling
+ *   `policies/index.ts`'s header calls out for the bag census's own
+ *   `valueEvidence` half), so it reads the checker alone. This makes the
+ *   policy narrower, not wrong: a slot this policy cannot bind still answers
+ *   `null` (no override), never a guess.
+ * - The `weak-key-not-reference` refusal (`collection-bindings.ts:485-511`):
+ *   a `WeakMap`/`WeakSet` key that resolves to a union is still published
+ *   here as `key`, where the existing census would refuse the whole owner
+ *   instead. Safe for this table's current, diagnostic-only readership
+ *   (nothing downstream consumes `cellFacts` yet -- see `facts.ts`'s own
+ *   header), and flagged here for whoever wires a consumer to close before
+ *   this table's `collection` domain becomes load-bearing.
+ * - The array-element half of `collection-bindings.ts` (an empty array
+ *   literal's inferred element type) is a DIFFERENT question that already
+ *   fits the four ported domains' plain `ts.Type` shape -- it is not part of
+ *   `CollectionTypeArguments`, and `CellDomain` names no domain for it. Out
+ *   of scope for "port the collection domain" as this table's own `CellValue`
+ *   union defines it.
+ * - `family-disagreement` (two `new X()` sites for one owner naming different
+ *   families) is not tracked; a mixed owner simply answers from whichever
+ *   evidence its writes admit rather than refusing outright. Diagnostic-only
+ *   readership again makes this safe rather than silently wrong.
+ */
+export declare const createCollectionCellPolicy: (checker: ts.TypeChecker, reachable: ProgramReachability) => CellEvidencePolicy;

package/dist/semantics/normalize/cells/policies/collection.js

@@ -0,0 +1,218 @@
+import ts from 'typescript';
+import { cellCandidatesOf } from '../candidates.js';
+import { cellType } from '../model.js';
+import { rulesFor } from '../policy.js';
+import { joinCellTypeValues, statedTypeOf } from './shared.js';
+/** The four standard collection constructors, exactly `collection-bindings.ts`'s own table -- core ECMAScript, not a host's to configure. */
+const CONSTRUCTOR_NAMES = new Map([
+    ['Map', 'map'],
+    ['Set', 'set'],
+    ['WeakMap', 'weak-map'],
+    ['WeakSet', 'weak-set']
+]);
+/** A symbol's first declaration node -- the stable key every owner-tracking census in this compiler uses (see `flow/targets.ts`'s own header on why). */
+const declNodeOf = (symbol) => symbol?.getDeclarations()?.[0] ?? null;
+/**
+ * The declaration a plain identifier or `x.prop` access names -- this
+ * policy's own restatement of `collection-bindings.ts`'s `ownerDeclOfExpr`.
+ * Restated rather than imported: every policy in this directory recognises
+ * its own candidates from scratch (`field.ts`'s `isUnannotatedUninitializedField`,
+ * `local.ts`'s sibling), and this phase's "stay in `cells/**`" boundary rules
+ * out reaching into `collection-bindings.ts` for a shared helper it does not
+ * export.
+ */
+const ownerDeclOfExpr = (checker, expr) => {
+    if (ts.isIdentifier(expr))
+        return declNodeOf(checker.getSymbolAtLocation(expr));
+    if (ts.isPropertyAccessExpression(expr))
+        return declNodeOf(checker.getSymbolAtLocation(expr.name));
+    return null;
+};
+/**
+ * The declaration a `new Map()`/`new Set()`/`new WeakMap()`/`new WeakSet()`
+ * is bound to -- a variable's own name, a class field's own initializer, or
+ * a plain `x = new WeakMap()` / `this.m = new WeakMap()` reassignment target.
+ * `null` for anything else (an inline argument, a destructuring target): this
+ * policy's CELL is the owner, not the allocation site, so a construction with
+ * no trackable owner is not a candidate at all -- the same rule
+ * `collection-bindings.ts` applies, restated (see `ownerDeclOfExpr`'s note).
+ */
+const ownerDeclOf = (checker, node) => {
+    const parent = node.parent;
+    if (ts.isVariableDeclaration(parent) && parent.initializer === node && ts.isIdentifier(parent.name)) {
+        return declNodeOf(checker.getSymbolAtLocation(parent.name));
+    }
+    if (ts.isPropertyDeclaration(parent) && parent.initializer === node && ts.isIdentifier(parent.name)) {
+        return declNodeOf(checker.getSymbolAtLocation(parent.name));
+    }
+    if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.right === node) {
+        return ownerDeclOfExpr(checker, parent.left);
+    }
+    return null;
+};
+/**
+ * Every declaration a `whole`-slot write carries this owner's identity INTO,
+ * transitively -- `collection-bindings.ts`'s `aliasClosureOf`, restated over
+ * the same `flow.flowsFromDeclaration` reverse edge. This is the answer to
+ * `policies/index.ts`'s stated obstacle: a candidate's OWN
+ * `flow.writesToDeclaration` sees only writes made directly through its own
+ * name, so `const helper = []; fill(helper)` (where `fill`'s body does
+ * `arr.push(x)` on its PARAMETER) or `this.cache.set(k, v)` reached only
+ * through a parameter the cache was passed to are both invisible to a
+ * single-declaration read. Rather than forcing this into the generic
+ * `flow.writesToDeclaration(declaration)` default every OTHER ported domain
+ * uses, this policy states its own `writesOf` (see `policy.ts`'s doc on that
+ * hook) and pools the writes of the whole closure -- an honest widening of
+ * WHERE evidence is gathered, not a rule about what counts as evidence.
+ */
+const ALIAS_EDGES = new Set([
+    'declaration-initializer',
+    'identifier-assignment',
+    'property-assignment',
+    'index-assignment',
+    'call-argument'
+]);
+const writesOverAliasClosure = (owner, flow) => {
+    const seen = new Set([owner]);
+    const queue = [owner];
+    const writes = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        writes.push(...flow.writesToDeclaration(current));
+        for (const write of flow.flowsFromDeclaration(current)) {
+            if (write.slot !== 'whole' || !ALIAS_EDGES.has(write.edge))
+                continue;
+            const target = write.target.declaration;
+            if (target && !seen.has(target)) {
+                seen.add(target);
+                queue.push(target);
+            }
+        }
+    }
+    return writes;
+};
+/**
+ * The owner's own type node, when its declaration shape carries one --
+ * `const m: Map<string, number> = new Map()` states its own answer, and this
+ * policy's `stated` must defer to it exactly as `field.ts`/`return.ts` do for
+ * theirs. `collection-bindings.ts` itself never asks this (its `bareConstruction`
+ * check only inspects the `new X()` expression's own type arguments, not the
+ * OWNER's annotation), so a program shaped this way binds here where the
+ * existing census is silent -- a real, deliberate difference, not a
+ * fidelity gap, and one every ported `ts.Type`-space policy already gets by
+ * asking `stated` at all.
+ */
+const ownerTypeNodeOf = (declaration) => {
+    if (ts.isVariableDeclaration(declaration) || ts.isPropertyDeclaration(declaration) || ts.isParameter(declaration)) {
+        return declaration.type;
+    }
+    return undefined;
+};
+/**
+ * The COLLECTION domain: `collection-bindings.ts`'s Map/Set/WeakMap/WeakSet
+ * question (`CollectionTypeArguments`'s K/V), restated as two evidence rules
+ * (`collection-key`, `collection-value`) over `flow`'s edges of the same
+ * name, joined per SLOT rather than into one value -- see `combine` below.
+ *
+ * Deliberately NOT ported, and left for a later phase exactly as
+ * `parameter.ts`'s header leaves its own gap documented rather than silent:
+ *
+ * - The checker-only half of `argumentType`'s `known ?? resolve` rule.
+ *   `collection-bindings.ts` falls back to the COMPOSED PARAMETER CENSUS when
+ *   the checker's own answer for a key/value argument is unusable evidence --
+ *   the majority case in practice, since most of these sites are an untyped
+ *   local function parameter. This policy has no composed census to fall
+ *   back to (nothing wires one in for `defaultCellEvidencePolicies`, and
+ *   wiring one would be the exact kind of cross-domain coupling
+ *   `policies/index.ts`'s header calls out for the bag census's own
+ *   `valueEvidence` half), so it reads the checker alone. This makes the
+ *   policy narrower, not wrong: a slot this policy cannot bind still answers
+ *   `null` (no override), never a guess.
+ * - The `weak-key-not-reference` refusal (`collection-bindings.ts:485-511`):
+ *   a `WeakMap`/`WeakSet` key that resolves to a union is still published
+ *   here as `key`, where the existing census would refuse the whole owner
+ *   instead. Safe for this table's current, diagnostic-only readership
+ *   (nothing downstream consumes `cellFacts` yet -- see `facts.ts`'s own
+ *   header), and flagged here for whoever wires a consumer to close before
+ *   this table's `collection` domain becomes load-bearing.
+ * - The array-element half of `collection-bindings.ts` (an empty array
+ *   literal's inferred element type) is a DIFFERENT question that already
+ *   fits the four ported domains' plain `ts.Type` shape -- it is not part of
+ *   `CollectionTypeArguments`, and `CellDomain` names no domain for it. Out
+ *   of scope for "port the collection domain" as this table's own `CellValue`
+ *   union defines it.
+ * - `family-disagreement` (two `new X()` sites for one owner naming different
+ *   families) is not tracked; a mixed owner simply answers from whichever
+ *   evidence its writes admit rather than refusing outright. Diagnostic-only
+ *   readership again makes this safe rather than silently wrong.
+ */
+export const createCollectionCellPolicy = (checker, reachable) => {
+    let constructorSymbols = null;
+    const constructorSymbolsFor = (anchor) => {
+        if (constructorSymbols)
+            return constructorSymbols;
+        const resolved = new Map();
+        for (const [name, family] of CONSTRUCTOR_NAMES) {
+            const symbol = checker.resolveName(name, anchor, ts.SymbolFlags.Value, false);
+            if (symbol)
+                resolved.set(family, symbol);
+        }
+        constructorSymbols = resolved;
+        return resolved;
+    };
+    /** The family this expression constructs, only when it is genuinely the standard-library constructor -- never a program's own `class WeakMap`. */
+    const realConstructorFamily = (anchor, node) => {
+        if (!ts.isIdentifier(node.expression))
+            return null;
+        const family = CONSTRUCTOR_NAMES.get(node.expression.text);
+        if (!family)
+            return null;
+        const expected = constructorSymbolsFor(anchor).get(family);
+        if (!expected)
+            return null;
+        return checker.getSymbolAtLocation(node.expression) === expected ? family : null;
+    };
+    const bareConstruction = (node) => (node.typeArguments === undefined || node.typeArguments.length === 0) && (node.arguments === undefined || node.arguments.length === 0);
+    return {
+        domain: 'collection',
+        candidatesOf: (files) => {
+            const anchor = files[0];
+            if (!anchor)
+                return [];
+            const isBareCollectionNew = (node) => ts.isNewExpression(node) && bareConstruction(node) && realConstructorFamily(anchor, node) !== null;
+            const owners = new Set();
+            for (const node of cellCandidatesOf(reachable, files, isBareCollectionNew)) {
+                const owner = ownerDeclOf(checker, node);
+                if (owner)
+                    owners.add(owner);
+            }
+            return owners;
+        },
+        statedAt: (declaration) => statedTypeOf(checker, ownerTypeNodeOf(declaration)),
+        checkerAt: (declaration) => cellType(checker.getTypeAtLocation(declaration)),
+        writesOf: writesOverAliasClosure,
+        rules: rulesFor([
+            ['collection-key', (write) => (write.value ? cellType(checker.getTypeAtLocation(write.value)) : null)],
+            ['collection-value', (write) => (write.value ? cellType(checker.getTypeAtLocation(write.value)) : null)]
+        ]),
+        // Per-SLOT join, not per-cell: K and V are independent questions about one
+        // storage (`collection-bindings.ts`'s own header, "K and V are INDEPENDENT
+        // questions"), so a `Map`'s key evidence and value evidence are grouped by
+        // `write.slot` and joined separately -- exactly the extension
+        // `policies/index.ts` asked for, now that `combine` receives the write
+        // alongside the value (`CellEvidenceContribution`). Either half joining to
+        // `null` (no evidence, or disagreement) is "no override" for that half
+        // alone, matching `collection-bindings.ts`'s own `boundArgumentsFor`,
+        // which folds "refused" and "never asked" into the same absent answer.
+        combine: (contributions) => {
+            const keys = contributions.filter((c) => c.write.slot === 'collection-key').map((c) => c.value);
+            const values = contributions.filter((c) => c.write.slot === 'collection-value').map((c) => c.value);
+            if (keys.length === 0 && values.length === 0)
+                return null;
+            const key = keys.length > 0 ? joinCellTypeValues(checker, keys) : null;
+            const value = values.length > 0 ? joinCellTypeValues(checker, values) : null;
+            const arguments_ = { key, value, valueEvidence: [] };
+            return { kind: 'collection-arguments', arguments: arguments_ };
+        }
+    };
+};

package/dist/semantics/normalize/cells/policies/field.d.ts

@@ -0,0 +1,28 @@
+import ts from 'typescript';
+import type { ProgramReachability } from '../../reachability.js';
+import type { CellEvidencePolicy } from '../policy.js';
+/**
+ * The FIELD domain: `field-bindings.ts`'s question, restated over the shared
+ * flow index's `property-assignment` edge.
+ *
+ * Scoped to an explicit `PropertyDeclaration` with no initializer -- the
+ * the shape called note 16 ("a `PropertyDeclaration` WITH an
+ * initializer is not a candidate at all"). What is NOT ported: a field TypeScript
+ * infers purely from a JS constructor's `this.x = v` with no
+ * `PropertyDeclaration` node at all ("TS JS-class
+ * inference decl"). `field-bindings.ts` keys that case by SYMBOL because there
+ * is no declaration node to key it by, and this policy interface keys every
+ * candidate by a `ts.Declaration` for `identities.declarationIdOf` -- the same
+ * "one answer language" constraint this whole table exists to hold everyone
+ * to. Closing that gap needs either a synthetic per-symbol identity or
+ * widening `CellEvidencePolicy.candidatesOf` to a symbol-keyed variant; left
+ * for a later step rather than forced here. See the report for the exact
+ * count this leaves unproven.
+ *
+ * `flow/model.ts` already resolves `this.x = v` (and a subclass's write, and
+ * `this.a.b = v`'s outer member) to THIS declaration by symbol identity
+ * (`FlowTarget.symbol`/`.declaration`, `flow/model.ts`'s own header), so no
+ * receiver-walk of this policy's own is needed -- exactly the property
+ * `parameter.ts` and `return.ts` already lean on for their own edges.
+ */
+export declare const createFieldCellPolicy: (checker: ts.TypeChecker, reachable: ProgramReachability) => CellEvidencePolicy;

package/dist/semantics/normalize/cells/policies/field.js

@@ -0,0 +1,40 @@
+import ts from 'typescript';
+import { cellCandidatesOf } from '../candidates.js';
+import { cellType } from '../model.js';
+import { rulesFor } from '../policy.js';
+import { combineTypesByJoin, statedTypeOf } from './shared.js';
+const isUnannotatedUninitializedField = (node) => ts.isPropertyDeclaration(node) && node.type === undefined && node.initializer === undefined;
+/**
+ * The FIELD domain: `field-bindings.ts`'s question, restated over the shared
+ * flow index's `property-assignment` edge.
+ *
+ * Scoped to an explicit `PropertyDeclaration` with no initializer -- the
+ * the shape called note 16 ("a `PropertyDeclaration` WITH an
+ * initializer is not a candidate at all"). What is NOT ported: a field TypeScript
+ * infers purely from a JS constructor's `this.x = v` with no
+ * `PropertyDeclaration` node at all ("TS JS-class
+ * inference decl"). `field-bindings.ts` keys that case by SYMBOL because there
+ * is no declaration node to key it by, and this policy interface keys every
+ * candidate by a `ts.Declaration` for `identities.declarationIdOf` -- the same
+ * "one answer language" constraint this whole table exists to hold everyone
+ * to. Closing that gap needs either a synthetic per-symbol identity or
+ * widening `CellEvidencePolicy.candidatesOf` to a symbol-keyed variant; left
+ * for a later step rather than forced here. See the report for the exact
+ * count this leaves unproven.
+ *
+ * `flow/model.ts` already resolves `this.x = v` (and a subclass's write, and
+ * `this.a.b = v`'s outer member) to THIS declaration by symbol identity
+ * (`FlowTarget.symbol`/`.declaration`, `flow/model.ts`'s own header), so no
+ * receiver-walk of this policy's own is needed -- exactly the property
+ * `parameter.ts` and `return.ts` already lean on for their own edges.
+ */
+export const createFieldCellPolicy = (checker, reachable) => ({
+    domain: 'field',
+    candidatesOf: (files) => cellCandidatesOf(reachable, files, isUnannotatedUninitializedField),
+    statedAt: (declaration) => statedTypeOf(checker, declaration.type),
+    checkerAt: (declaration) => cellType(checker.getTypeAtLocation(declaration)),
+    rules: rulesFor([
+        ['property-assignment', (write) => (write.value ? cellType(checker.getTypeAtLocation(write.value)) : null)]
+    ]),
+    combine: combineTypesByJoin(checker)
+});

package/dist/semantics/normalize/cells/policies/index.d.ts

@@ -0,0 +1,49 @@
+import type ts from 'typescript';
+import type { ProgramReachability } from '../../reachability.js';
+import type { ObjectBagIdentity } from '../../object-bag-bindings.js';
+import type { CellEvidencePolicy } from '../policy.js';
+export { createParameterCellPolicy } from './parameter.js';
+export { createReturnCellPolicy } from './return.js';
+export { createLocalCellPolicy } from './local.js';
+export { createFieldCellPolicy } from './field.js';
+export { createCollectionCellPolicy } from './collection.js';
+export { createBagCellPolicy } from './bag.js';
+/**
+ * Five of the six domains are ported to an evidence policy as of this phase:
+ * parameter, return, local, field (already `ts.Type`-space censuses), and now
+ * collection (`CollectionTypeArguments`'s independent key/value pair -- see
+ * `collection.ts`'s own header for what was and was not carried over).
+ *
+ * Porting `collection` needed a real extension to the shape, not a policy
+ * bent to fit the existing one: `combine` used to receive a flat
+ * `CellValue[]`, discarding which write and which slot produced each one, so
+ * nothing could join K and V independently. `CellEvidenceContribution`
+ * (`policy.ts`) pairs the value back with its `ValueWrite`, and `writesOf`
+ * (also `policy.ts`) lets a policy widen WHERE evidence is gathered from
+ * (`collection.ts`'s alias-closure walk) without forcing every other domain
+ * to pay for a closure it never needed. Both are honest widenings of the
+ * question `CellEvidencePolicy` can state, not a narrower reading of
+ * `collection-bindings.ts`'s own question -- see `collection.ts` for the
+ * three pieces of that census deliberately left unported and why each is
+ * safe for this table's current, diagnostic-only readership.
+ *
+ * BAG is now here too, and the obstacle that kept it out was never "needs a
+ * slot-aware rule" -- the frontend's evidence-policy tables
+ * records the full history. `object-bag-bindings.ts`'s identity (which
+ * declarations name the SAME bag) is not decided per write or even per
+ * declaration -- it is the fixed point of a whole-program worklist
+ * (`bagOf`/`returnsBag`, propagated through assignments, provably-exhaustive
+ * `return`s, and one layer of callee-alias unwrapping, with `conflicted`/
+ * `ungrounded` bookkeeping deciding which candidates survive), and a
+ * `candidatesOf` that enumerates nodes by a per-node syntactic test --
+ * everything this table's `cellCandidatesOf` walk assumes -- cannot state
+ * "one candidate becomes known to be one cell only once a closure over the
+ * WHOLE program has converged." The fix taken was the second of the two
+ * choices this header used to weigh: `object-bag-bindings.ts` now publishes
+ * that fixpoint as `ObjectBagCensus.identity` (`ObjectBagIdentity`), and
+ * `bag.ts`'s policy consumes it rather than reimplementing it -- `bagIdentity`
+ * is threaded in as a construction-time argument, not discovered via `files`,
+ * because the fixpoint needs the whole program already settled before any
+ * single node can be called a candidate.
+ */
+export declare const defaultCellEvidencePolicies: (checker: ts.TypeChecker, reachable: ProgramReachability, bagIdentity: ObjectBagIdentity) => readonly CellEvidencePolicy[];

package/dist/semantics/normalize/cells/policies/index.js

@@ -0,0 +1,58 @@
+import { createBagCellPolicy } from './bag.js';
+import { createCollectionCellPolicy } from './collection.js';
+import { createFieldCellPolicy } from './field.js';
+import { createLocalCellPolicy } from './local.js';
+import { createParameterCellPolicy } from './parameter.js';
+import { createReturnCellPolicy } from './return.js';
+export { createParameterCellPolicy } from './parameter.js';
+export { createReturnCellPolicy } from './return.js';
+export { createLocalCellPolicy } from './local.js';
+export { createFieldCellPolicy } from './field.js';
+export { createCollectionCellPolicy } from './collection.js';
+export { createBagCellPolicy } from './bag.js';
+/**
+ * Five of the six domains are ported to an evidence policy as of this phase:
+ * parameter, return, local, field (already `ts.Type`-space censuses), and now
+ * collection (`CollectionTypeArguments`'s independent key/value pair -- see
+ * `collection.ts`'s own header for what was and was not carried over).
+ *
+ * Porting `collection` needed a real extension to the shape, not a policy
+ * bent to fit the existing one: `combine` used to receive a flat
+ * `CellValue[]`, discarding which write and which slot produced each one, so
+ * nothing could join K and V independently. `CellEvidenceContribution`
+ * (`policy.ts`) pairs the value back with its `ValueWrite`, and `writesOf`
+ * (also `policy.ts`) lets a policy widen WHERE evidence is gathered from
+ * (`collection.ts`'s alias-closure walk) without forcing every other domain
+ * to pay for a closure it never needed. Both are honest widenings of the
+ * question `CellEvidencePolicy` can state, not a narrower reading of
+ * `collection-bindings.ts`'s own question -- see `collection.ts` for the
+ * three pieces of that census deliberately left unported and why each is
+ * safe for this table's current, diagnostic-only readership.
+ *
+ * BAG is now here too, and the obstacle that kept it out was never "needs a
+ * slot-aware rule" -- the frontend's evidence-policy tables
+ * records the full history. `object-bag-bindings.ts`'s identity (which
+ * declarations name the SAME bag) is not decided per write or even per
+ * declaration -- it is the fixed point of a whole-program worklist
+ * (`bagOf`/`returnsBag`, propagated through assignments, provably-exhaustive
+ * `return`s, and one layer of callee-alias unwrapping, with `conflicted`/
+ * `ungrounded` bookkeeping deciding which candidates survive), and a
+ * `candidatesOf` that enumerates nodes by a per-node syntactic test --
+ * everything this table's `cellCandidatesOf` walk assumes -- cannot state
+ * "one candidate becomes known to be one cell only once a closure over the
+ * WHOLE program has converged." The fix taken was the second of the two
+ * choices this header used to weigh: `object-bag-bindings.ts` now publishes
+ * that fixpoint as `ObjectBagCensus.identity` (`ObjectBagIdentity`), and
+ * `bag.ts`'s policy consumes it rather than reimplementing it -- `bagIdentity`
+ * is threaded in as a construction-time argument, not discovered via `files`,
+ * because the fixpoint needs the whole program already settled before any
+ * single node can be called a candidate.
+ */
+export const defaultCellEvidencePolicies = (checker, reachable, bagIdentity) => [
+    createParameterCellPolicy(checker, reachable),
+    createReturnCellPolicy(checker, reachable),
+    createLocalCellPolicy(checker, reachable),
+    createFieldCellPolicy(checker, reachable),
+    createCollectionCellPolicy(checker, reachable),
+    createBagCellPolicy(checker, bagIdentity)
+];

package/dist/semantics/normalize/cells/policies/local.d.ts

@@ -0,0 +1,18 @@
+import ts from 'typescript';
+import type { ProgramReachability } from '../../reachability.js';
+import type { CellEvidencePolicy } from '../policy.js';
+/**
+ * The LOCAL domain: `local-bindings.ts`'s question ("an unannotated
+ * `let`/`var` cell with no initializer, filled in by exactly the writes the
+ * program makes to it"), restated over the shared flow index's
+ * `identifier-assignment` and `logical-assignment` edges.
+ *
+ * `compound-assignment` (`x += 1`) is deliberately given no rule: per
+ * `flow/model.ts`'s own doc, that edge states existence and a DERIVED value,
+ * never a fresh one, so admitting it here would join the cell's own prior
+ * (unknown) contents into its write-join. `rulesFor` skipping an edge is the
+ * correct, sound default -- soundness cuts one way here:
+ * missing evidence is a box, joining the wrong evidence is a silent
+ * miscompile, and this domain refuses the second, never the first.
+ */
+export declare const createLocalCellPolicy: (checker: ts.TypeChecker, reachable: ProgramReachability) => CellEvidencePolicy;