tsc-ts 0.1.0 → 0.1.1

package/dist/api/compiler/shared-results.js

@@ -1,5 +1,5 @@
-// Results one checker thread computed, as portable records other checker threads translate into their own types
-// (TSC_TS_SHARE=1).
+// Results one checker thread computed, as records in its number log that other checker threads translate into their
+// own types (TSC_TS_SHARE=1).
 //
 // A checker exports the result of a declaration-level computation (the value type of a variable or property, or the
 // return type of a declared signature) as records: each type the result reaches through its identity (constituents,
@@ -7,7 +7,7 @@
 // template, string mapping and substitution types), down to types every checker can get by itself (intrinsic types,
 // declared types of symbols, types of declarations and type nodes). Another checker translates the records through
 // its own interning caches, so each type still has one object in it.
-import { getSymbol, NodeVisitor } from './ast.js';
+import { getSymbol, getType, NodeVisitor } from './ast.js';
 import { getSourceFileOfNode } from './binder-utilities.js';
 import { getDeclaredTypeOfSymbol } from './checker-declared-types.js';
 import { TupleElementInfo, TypeAlias, getMappedType, IndexInfo, newTypeMapper, } from './checker-types.js';
@@ -22,69 +22,87 @@ import { findResolutionCycleStartIndex } from './checker-symbols.js';
 import { typeToString } from './type-printer.js';
 import { getTypeOfSymbol } from './checker-symbol-types.js';
 import { getReturnTypeOfSignature } from './checker-signatures.js';
+import { LinkTable } from './link-tables.js';
 // Functions, classes, enums and modules have anonymous types that are cheap to create; their members are not. (A
 // function: a top-level constant computed from an enum member of a module in an import cycle doesn't compile natively.)
 function sharedValueFlags() {
     return 3 /* SymbolFlags.Variable */ | 4 /* SymbolFlags.Property */;
 }
-/** An index signature of an `AnonymousObject` record. */
-export class PortableIndexInfo {
-    keyType;
-    valueType;
-    isReadonly;
-    declaration;
-    components;
-    constructor(keyType, valueType, isReadonly, declaration, components) {
-        this.keyType = keyType;
-        this.valueType = valueType;
-        this.isReadonly = isReadonly;
-        this.declaration = declaration;
-        this.components = components;
+const noRefs = [];
+/**
+ * Writes records into a checker's store: int32 words at a cursor, strings into its string log, and each record's
+ * offset in its record table. The cursor is the writer's alone until it publishes a result.
+ */
+export class StoreWriter {
+    numbers;
+    strings;
+    table;
+    fileIndex;
+    /** The cursor in the number log, and in the string log. */
+    at = 0;
+    unitAt = 0;
+    /** Set when a record or a field didn't fit the store's configured capacity. */
+    full = false;
+    constructor(numbers, strings, table, fileIndex) {
+        this.numbers = numbers;
+        this.strings = strings;
+        this.table = table;
+        this.fileIndex = fileIndex;
     }
-}
-export class PortableRecord {
-    kind;
-    flags;
-    num;
-    text;
-    symbol;
-    node;
-    refs;
-    nums;
-    nodes;
-    texts;
-    /** For a symbol a checker merged: the id of a symbol it merged, which keys every checker's merged symbol. */
-    mergedId;
-    /** The alias: its symbol and the records of its type arguments. */
-    aliasSymbol;
-    aliasMergedId;
-    aliasRefs;
-    indexInfos;
-    /** The producer's type id, which keys the consumer's translations of the producer's types. */
-    id;
-    constructor(kind, id, flags, num, text, symbol, node, refs) {
-        this.kind = kind;
-        this.id = id;
-        this.flags = flags;
-        this.num = num;
-        this.text = text;
-        this.symbol = symbol;
-        this.node = node;
-        this.refs = refs;
-        this.nums = noNumbers;
-        this.nodes = noNodes;
-        this.texts = noTexts;
-        this.mergedId = -1;
-        this.aliasSymbol = undefined;
-        this.aliasMergedId = -1;
-        this.aliasRefs = noNumbers;
-        this.indexInfos = noIndexInfos;
+    /** Returns to the cursors `at` and `unitAt`. */
+    reset(at, unitAt) {
+        this.at = at;
+        this.unitAt = unitAt;
+        this.full = false;
+    }
+    /** Starts record `index` at the cursor: its header, and its offset in the record table. */
+    beginRecord(index, header) {
+        if (index < this.table.length)
+            this.table[index] = this.at + 1;
+        else
+            this.full = true;
+        this.word(header);
+    }
+    word(value) {
+        if (this.at < this.numbers.length)
+            this.numbers[this.at] = value;
+        else
+            this.full = true;
+        this.at++;
+    }
+    /** A double as the two int32 halves of its bits. */
+    double(value) {
+        const words = doubleWords();
+        words.f[0] = value;
+        this.word(words.i[0]);
+        this.word(words.i[1]);
+    }
+    /** A string as its offset and length in the string log. */
+    text(value) {
+        const length = value.length;
+        if (this.unitAt + length <= this.strings.length) {
+            this.word(this.unitAt);
+            this.word(length);
+            for (let j = 0; j < length; j++)
+                this.strings[this.unitAt++] = value.charCodeAt(j);
+            return;
+        }
+        this.full = true;
+        this.word(0);
+        this.word(0);
+    }
+    /** A node as its file, range and id, or -1 for none. The file must be one `fileIndex` has. */
+    node(node) {
+        if (node === undefined) {
+            this.word(-1);
+            return;
+        }
+        this.word(this.fileIndex.get(getSourceFileOfNode(node)));
+        this.word(node.pos);
+        this.word(node.end);
+        this.word(node.id);
     }
 }
-const noNumbers = [];
-const noNodes = [];
-const noTexts = [];
-const noIndexInfos = [];
 /** The types every checker creates when it starts, in the same order; marker types are left out. */
 export function initialTypes(c) {
     return [
@@ -142,127 +160,266 @@ export function initialTypes(c) {
         c.typeofType,
     ];
 }
+/** The reason an export stops at its budget (`Exporter.limit`), which `post` returns: the result is not posted. */
+export const budgetFailure = 'export budget';
 /** A checker's `Exporter.mergedOrigins`, kept while its merged symbols stay the same. */
 export class MergedOrigins {
     origins = new Map();
     size = -1;
 }
+/** An index signature of an `AnonymousObject` record, waiting for the words of its `CompleteObject`. */
+class IndexInfoWords {
+    keyType;
+    valueType;
+    isReadonly;
+    declaration;
+    components;
+    constructor(keyType, valueType, isReadonly, declaration, components) {
+        this.keyType = keyType;
+        this.valueType = valueType;
+        this.isReadonly = isReadonly;
+        this.declaration = declaration;
+        this.components = components;
+    }
+}
 /** Writes a result as records; `failure` names the first part that has no record kind. */
 export class Exporter {
     c;
-    records = [];
-    indexes = new Map();
+    writer;
     /**
-     * The index of `records[0]`. A checker's exporter keeps the indexes of the types it exported before
-     * (`ThreadSharing.post`): their records are in its store already, and a result's records are only the new ones.
+     * The index of the first record of the export in progress. A checker's exporter keeps the records of the types it
+     * exported before (`ThreadSharing.post`): its store has them already, and a result's records are only the new ones.
      */
     base = 0;
+    /** The number of records the export in progress wrote. */
+    count = 0;
+    /** The record of each type, by type id, and of each property symbol, by symbol id. */
+    indexes = new Map();
+    properties = new Map();
     /** The types and properties the export in progress gave indexes, which a failed export forgets again. */
     addedTypes = [];
     addedProperties = [];
-    /** Appends `record`; its index. */
-    push(record) {
-        const index = this.base + this.records.length;
-        this.records.push(record);
-        return index;
-    }
+    /**
+     * The most records the export in progress may add (`ThreadSharing.post` prices it with `kappa`); past it the export
+     * fails and the result is not posted.
+     */
+    limit = Number.POSITIVE_INFINITY;
     initial;
     failure = undefined;
     /** The ids above which nodes and symbols are the checker thread's own (lazily parsed JSDoc), or Infinity. */
     nodeLimit = Infinity;
     symbolLimit = Infinity;
-    constructor(c, initial) {
+    /** The ids of the symbols each merged symbol merged (`getMergedSymbol`), built on first use. */
+    mergedOrigins = undefined;
+    /** Where the checker keeps `mergedOrigins` between exports. */
+    originsCache = undefined;
+    /** How the record in progress names its symbol and its alias, and the node it carries. */
+    naming = 0 /* SymbolNaming.None */;
+    namingMerged = -1;
+    namingNode = undefined;
+    aliasNaming = 0 /* SymbolNaming.None */;
+    aliasMerged = -1;
+    aliasNode = undefined;
+    aliasRefs = noRefs;
+    node = undefined;
+    constructor(c, initial, writer) {
         this.c = c;
         this.initial = initial;
+        this.writer = writer;
     }
-    /** Whether `node` is one every checker shares; fails if not. */
+    fail(reason) {
+        if (this.failure === undefined)
+            this.failure = reason;
+        return -1;
+    }
+    /** Whether `node` is one every checker shares, and can name; fails if not. */
     sharedNode(node) {
-        if (node === undefined || node.id <= this.nodeLimit)
+        if (node === undefined)
             return true;
-        this.fail('node of the thread');
-        return false;
+        if (node.id > this.nodeLimit) {
+            this.fail('node of the thread');
+            return false;
+        }
+        if (!this.writer.fileIndex.has(getSourceFileOfNode(node))) {
+            this.fail('node outside the program');
+            return false;
+        }
+        return true;
     }
-    /** The ids of the symbols each merged symbol merged (`getMergedSymbol`), built on first use. */
-    mergedOrigins = undefined;
-    /** Where the checker keeps `mergedOrigins` between exports. */
-    originsCache = undefined;
     /**
-     * Sets the symbol of `record`: a symbol of the program, which every checker shares, or a symbol the checker merged,
-     * by the id of a symbol it merged. Other symbols are the checker's own.
+     * The index of the next record of the store, or -1 if the result is over its export budget; the store's table must
+     * have room for it.
      */
-    symbolOf(record, symbol, alias) {
-        let mergedId = -1;
-        let shared = symbol;
-        if ((symbol.flags & 33554432 /* SymbolFlags.Transient */) === 0 && getSymbolId(symbol) > this.symbolLimit) {
-            this.fail('symbol of the thread');
-            return false;
-        }
-        if ((symbol.flags & 33554432 /* SymbolFlags.Transient */) !== 0) {
-            let origins = this.mergedOrigins;
-            if (origins === undefined) {
-                const cache = this.originsCache;
-                if (cache !== undefined && cache.size === this.c.mergedSymbols.size)
-                    origins = cache.origins;
+    nextIndex() {
+        const index = this.base + this.count;
+        if (index >= this.limit)
+            return this.fail(budgetFailure);
+        this.count++;
+        if (index >= this.writer.table.length)
+            this.writer.full = true;
+        return index;
+    }
+    /** Records the type `t` at `index`. */
+    memo(t, index) {
+        // A consumer's memo is by record index, so a type has one record: VERIFY runs check that it does.
+        if (shareVerifyValue !== undefined && this.indexes.has(t.id))
+            process.stderr.write('share-verify: type ' + t.id + ' has a record already\n');
+        this.indexes.set(t.id, index);
+        this.addedTypes.push(t.id);
+    }
+    /**
+     * Sets how the record in progress names `symbol`: a symbol of the program by the node it is the symbol of, or a
+     * symbol the checker merged by the id of a symbol it merged. Fails for a symbol of the thread.
+     */
+    nameSymbol(symbol, alias) {
+        let naming = 0 /* SymbolNaming.None */;
+        let merged = -1;
+        let node = undefined;
+        if (symbol !== undefined) {
+            if ((symbol.flags & 33554432 /* SymbolFlags.Transient */) === 0) {
+                if (getSymbolId(symbol) > this.symbolLimit) {
+                    this.fail('symbol of the thread');
+                    return false;
+                }
+                const declaration = symbol.declaration;
+                if (declaration === undefined) {
+                    this.fail('symbol without a declaration');
+                    return false;
+                }
+                const local = getSymbol(declaration);
+                if (local === symbol)
+                    naming = 1 /* SymbolNaming.Node */;
+                else if (local !== undefined && local.exportSymbol === symbol)
+                    naming = 2 /* SymbolNaming.Export */;
                 else {
-                    origins = new Map();
-                    for (const [id, target] of this.c.mergedSymbols)
-                        if (!origins.has(target))
-                            origins.set(target, id);
-                    if (cache !== undefined) {
-                        cache.origins = origins;
-                        cache.size = this.c.mergedSymbols.size;
-                    }
+                    this.fail('symbol not named by its declaration');
+                    return false;
                 }
-                this.mergedOrigins = origins;
+                node = declaration;
             }
-            const origin = origins.get(symbol);
-            if (origin === undefined) {
-                this.fail('checker symbol ' + symbol.name);
-                return false;
+            else {
+                let origins = this.mergedOrigins;
+                if (origins === undefined)
+                    origins = this.buildOrigins();
+                const origin = origins.get(symbol);
+                if (origin === undefined) {
+                    this.fail('checker symbol ' + symbol.name);
+                    return false;
+                }
+                naming = 3 /* SymbolNaming.Merged */;
+                merged = origin;
             }
-            mergedId = origin;
-            shared = undefined;
         }
         if (alias) {
-            record.aliasSymbol = shared;
-            record.aliasMergedId = mergedId;
+            this.aliasNaming = naming;
+            this.aliasMerged = merged;
+            this.aliasNode = node;
+            // The alias's type arguments are recorded after it is named (`aliasBits`). A record that names an alias which
+            // has none, such as a property naming its parent, keeps none of the last alias's.
+            this.aliasRefs = noRefs;
         }
         else {
-            record.symbol = shared;
-            record.mergedId = mergedId;
+            this.naming = naming;
+            this.namingMerged = merged;
+            this.namingNode = node;
         }
         return true;
     }
-    /** `new PortableRecord` with the symbol `symbol` (see `symbolOf`); undefined if it is the checker's own. */
-    withSymbol(kind, t, symbol, num, refs) {
-        const record = new PortableRecord(kind, t.id, 0, num, '', undefined, undefined, refs);
-        return this.symbolOf(record, symbol, false) ? record : undefined;
+    /** The ids of the symbols each merged symbol merged, from the checker's `mergedSymbols`. */
+    buildOrigins() {
+        const cache = this.originsCache;
+        let origins;
+        if (cache !== undefined && cache.size === this.c.mergedSymbols.size)
+            origins = cache.origins;
+        else {
+            origins = new Map();
+            for (const [id, target] of this.c.mergedSymbols)
+                if (!origins.has(target))
+                    origins.set(target, id);
+            if (cache !== undefined) {
+                cache.origins = origins;
+                cache.size = this.c.mergedSymbols.size;
+            }
+        }
+        this.mergedOrigins = origins;
+        return origins;
     }
-    addWithSymbol(kind, t, symbol, num, refs) {
-        const record = this.withSymbol(kind, t, symbol, num, refs);
-        return record === undefined ? -1 : this.add(t, record);
+    /**
+     * Names the alias of the record in progress, after its type arguments are exported, and returns the header bits that
+     * name it; -1 if it can't be named.
+     */
+    aliasBits(alias, refs) {
+        if (alias === undefined)
+            return 0;
+        if (!this.nameSymbol(alias.symbol, true))
+            return -1;
+        this.aliasRefs = refs;
+        return 32 /* RecordHeader.HasAlias */ | (this.aliasNaming === 3 /* SymbolNaming.Merged */ ? 1024 /* RecordHeader.AliasMerged */ : 0);
     }
-    fail(reason) {
-        if (this.failure === undefined)
-            this.failure = reason;
-        return -1;
+    /**
+     * Starts the record at `index`: its header, its refs, its alias, its symbol and its node, all decided by `bits` and
+     * the fields set just before. A kind's own fields follow.
+     */
+    begin(kind, index, refs, bits) {
+        const w = this.writer;
+        const n = refs.length;
+        w.beginRecord(index, kind | bits | (n < 65535 /* RecordHeader.RefEscape */ ? n << 16 : 65535 /* RecordHeader.RefEscape */ << 16));
+        if (n >= 65535 /* RecordHeader.RefEscape */)
+            w.word(n);
+        for (let i = 0; i < n; i++)
+            w.word(refs[i]);
+        if ((bits & 32 /* RecordHeader.HasAlias */) !== 0) {
+            if ((bits & 1024 /* RecordHeader.AliasMerged */) !== 0)
+                w.word(this.aliasMerged);
+            else {
+                w.word(this.aliasNaming === 2 /* SymbolNaming.Export */ ? 1 : 0);
+                w.node(this.aliasNode);
+            }
+            const aliasRefs = this.aliasRefs;
+            w.word(aliasRefs.length);
+            for (let i = 0; i < aliasRefs.length; i++)
+                w.word(aliasRefs[i]);
+        }
+        const naming = bits & 192 /* RecordHeader.NamingMask */;
+        if (naming === 3 /* SymbolNaming.Merged */ << 6 /* RecordHeader.NamingShift */)
+            w.word(this.namingMerged);
+        else if (naming !== 0)
+            w.node(this.namingNode);
+        if ((bits & 256 /* RecordHeader.HasNode */) !== 0)
+            w.node(this.node);
+    }
+    /** The record of `t` of `kind`, with `refs` and no fields of its own; its index. */
+    plain(kind, t, refs) {
+        const index = this.nextIndex();
+        this.memo(t, index);
+        this.begin(kind, index, refs, 0);
+        return index;
     }
-    add(t, record) {
-        if (!this.sharedNode(record.node))
+    /** The record of the initial type `t`, which is `num`th in `initialTypes`. */
+    initialType(t, num) {
+        const index = this.nextIndex();
+        this.memo(t, index);
+        this.begin(0 /* RecordKind.Initial */, index, noRefs, 0);
+        this.writer.word(num);
+        return index;
+    }
+    /** The record of the type `t` of `kind` named by `symbol`, with `refs`; its index. */
+    symbolType(kind, t, symbol, refs) {
+        if (!this.nameSymbol(symbol, false))
             return -1;
-        for (const node of record.nodes)
-            if (!this.sharedNode(node))
-                return -1;
-        for (const info of record.indexInfos) {
-            if (!this.sharedNode(info.declaration))
-                return -1;
-            for (const node of info.components)
-                if (!this.sharedNode(node))
-                    return -1;
-        }
-        const index = this.push(record);
-        this.indexes.set(t, index);
-        this.addedTypes.push(t);
+        const index = this.nextIndex();
+        this.memo(t, index);
+        this.begin(kind, index, refs, this.naming << 6 /* RecordHeader.NamingShift */);
+        return index;
+    }
+    /** The record of the type `t` of the type node `node`; its index. */
+    nodeType(t, node) {
+        if (!this.sharedNode(node))
+            return -1;
+        this.node = node;
+        const index = this.nextIndex();
+        this.memo(t, index);
+        this.begin(8 /* RecordKind.NodeType */, index, noRefs, 256 /* RecordHeader.HasNode */);
         return index;
     }
     types(list) {
@@ -274,23 +431,15 @@ export class Exporter {
         }
         return refs;
     }
-    aliasOf(record, alias) {
-        if (alias === undefined)
-            return record;
-        const refs = this.types(alias.typeArguments);
-        this.symbolOf(record, alias.symbol, true);
-        record.aliasRefs = refs;
-        return record;
-    }
     type(t) {
         if (this.failure !== undefined)
             return -1;
-        const known = this.indexes.get(t);
+        const known = this.indexes.get(t.id);
         if (known !== undefined)
             return known;
-        const initial = this.initial.get(t);
+        const initial = this.initial.get(t.id);
         if (initial !== undefined)
-            return this.add(t, new PortableRecord(0 /* RecordKind.Initial */, t.id, 0, initial, '', undefined, undefined, noNumbers));
+            return this.initialType(t, initial);
         const c = this.c;
         const flags = t.flags;
         if ((flags & 15360 /* TypeFlags.Literal */) !== 0 && (flags & 256 /* TypeFlags.Boolean */) === 0)
@@ -298,7 +447,7 @@ export class Exporter {
         if ((flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0) {
             if (c.uniqueESSymbolTypes.get(t.symbol) !== t)
                 return this.fail('unique symbol');
-            return this.addWithSymbol(4 /* RecordKind.UniqueSymbol */, t, t.symbol, 0, noNumbers);
+            return this.symbolType(4 /* RecordKind.UniqueSymbol */, t, t.symbol, noRefs);
         }
         if ((flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
             const symbol = t.symbol;
@@ -306,41 +455,50 @@ export class Exporter {
                 return this.fail('type parameter without a symbol');
             const declared = getDeclaredTypeOfSymbol(c, symbol);
             if (declared === t)
-                return this.addWithSymbol(5 /* RecordKind.Declared */, t, symbol, 0, noNumbers);
+                return this.symbolType(5 /* RecordKind.Declared */, t, symbol, noRefs);
             if ((declared.objectFlags & 3 /* ObjectFlags.ClassOrInterface */) !== 0 && declared.thisType === t)
-                return this.addWithSymbol(6 /* RecordKind.ThisType */, t, symbol, 0, noNumbers);
+                return this.symbolType(6 /* RecordKind.ThisType */, t, symbol, noRefs);
             return this.fail('fresh type parameter');
         }
         if (t.symbol !== undefined && (flags & (134217728 /* TypeFlags.Union */ | 65536 /* TypeFlags.Enum */)) !== 0) {
             // An enum type: the declared type of its symbol.
             if (getDeclaredTypeOfSymbol(c, t.symbol) !== t)
                 return this.fail('enum type');
-            return this.addWithSymbol(5 /* RecordKind.Declared */, t, t.symbol, 0, noNumbers);
+            return this.symbolType(5 /* RecordKind.Declared */, t, t.symbol, noRefs);
         }
         if ((flags & 134217728 /* TypeFlags.Union */) !== 0)
             return this.union(t);
-        if ((flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
-            const refs = this.types(t.types);
-            if (this.failure !== undefined)
-                return -1;
-            const record = new PortableRecord(13 /* RecordKind.Intersection */, t.id, t.objectFlags, 0, '', undefined, undefined, refs);
-            return this.add(t, this.aliasOf(record, t.alias));
-        }
+        if ((flags & 268435456 /* TypeFlags.Intersection */) !== 0)
+            return this.intersection(t);
         if ((flags & 1048576 /* TypeFlags.Object */) !== 0)
             return this.object(t);
         if ((flags & 2097152 /* TypeFlags.Index */) !== 0) {
             const target = this.type(t.target);
             if (this.failure !== undefined)
                 return -1;
-            return this.add(t, new PortableRecord(14 /* RecordKind.Index */, t.id, 0, t.indexFlags, '', undefined, undefined, [target]));
+            const index = this.nextIndex();
+            this.memo(t, index);
+            this.begin(14 /* RecordKind.Index */, index, [target], 0);
+            this.writer.word(t.indexFlags);
+            return index;
         }
         if ((flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0) {
             const access = t;
             const refs = this.types([access.objectType, access.indexType]);
             if (this.failure !== undefined)
                 return -1;
-            const record = new PortableRecord(15 /* RecordKind.IndexedAccess */, t.id, 0, this.c.indexedAccessKeyFlags.get(t) ?? access.accessFlags, '', undefined, undefined, refs);
-            return this.add(t, this.aliasOf(record, t.alias));
+            const alias = t.alias;
+            const aliasRefs = alias === undefined ? noRefs : this.types(alias.typeArguments);
+            if (this.failure !== undefined)
+                return -1;
+            const bits = this.aliasBits(alias, aliasRefs);
+            if (bits < 0)
+                return -1;
+            const index = this.nextIndex();
+            this.memo(t, index);
+            this.begin(15 /* RecordKind.IndexedAccess */, index, refs, bits);
+            this.writer.word(this.c.indexedAccessKeyFlags.get(t) ?? access.accessFlags);
+            return index;
         }
         if ((flags & 67108864 /* TypeFlags.Conditional */) !== 0)
             return this.conditional(t);
@@ -349,15 +507,20 @@ export class Exporter {
             const refs = this.types(template.types);
             if (this.failure !== undefined)
                 return -1;
-            const record = new PortableRecord(17 /* RecordKind.Template */, t.id, 0, 0, '', undefined, undefined, refs);
-            record.texts = template.texts.slice();
-            return this.add(t, record);
+            const index = this.nextIndex();
+            this.memo(t, index);
+            this.begin(17 /* RecordKind.Template */, index, refs, 0);
+            const texts = template.texts;
+            this.writer.word(texts.length);
+            for (let i = 0; i < texts.length; i++)
+                this.writer.text(texts[i]);
+            return index;
         }
         if ((flags & 8388608 /* TypeFlags.StringMapping */) !== 0) {
             const target = this.type(t.target);
             if (this.failure !== undefined)
                 return -1;
-            return this.addWithSymbol(18 /* RecordKind.StringMapping */, t, t.symbol, 0, [target]);
+            return this.symbolType(18 /* RecordKind.StringMapping */, t, t.symbol, [target]);
         }
         if ((flags & 16777216 /* TypeFlags.Substitution */) !== 0) {
             const substitution = t;
@@ -365,12 +528,12 @@ export class Exporter {
                 const base = this.type(substitution.baseType);
                 if (this.failure !== undefined)
                     return -1;
-                return this.add(t, new PortableRecord(20 /* RecordKind.NoInfer */, t.id, 0, 0, '', undefined, undefined, [base]));
+                return this.plain(20 /* RecordKind.NoInfer */, t, [base]);
             }
             const refs = this.types([substitution.baseType, substitution.constraint]);
             if (this.failure !== undefined)
                 return -1;
-            return this.add(t, new PortableRecord(19 /* RecordKind.Substitution */, t.id, 0, 0, '', undefined, undefined, refs));
+            return this.plain(19 /* RecordKind.Substitution */, t, refs);
         }
         return this.fail('type flags ' + flags);
     }
@@ -382,35 +545,86 @@ export class Exporter {
             const index = this.type(regular);
             if (this.failure !== undefined)
                 return -1;
-            return this.add(t, new PortableRecord(2 /* RecordKind.FreshLiteral */, t.id, 0, 0, '', undefined, undefined, [index]));
+            return this.plain(2 /* RecordKind.FreshLiteral */, t, [index]);
         }
         if (t.symbol !== undefined) {
             if (getDeclaredTypeOfSymbol(this.c, t.symbol) !== t)
                 return this.fail('enum literal');
-            return this.addWithSymbol(3 /* RecordKind.EnumLiteral */, t, t.symbol, 0, noNumbers);
+            return this.symbolType(3 /* RecordKind.EnumLiteral */, t, t.symbol, noRefs);
         }
-        return this.add(t, new PortableRecord(1 /* RecordKind.Literal */, t.id, t.flags, t.numberValue, t.stringValue, undefined, undefined, noNumbers));
+        const index = this.nextIndex();
+        this.memo(t, index);
+        this.begin(1 /* RecordKind.Literal */, index, noRefs, 0);
+        const w = this.writer;
+        w.word(t.flags);
+        if ((t.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0)
+            w.double(t.numberValue);
+        else
+            w.text(t.stringValue);
+        return index;
+    }
+    /** The record of the constituents of a union's or intersection's origin, which is not a type: it has no alias. */
+    originRecord(kind, flags, refs) {
+        const index = this.nextIndex();
+        this.begin(kind, index, refs, 2048 /* RecordHeader.Constituent */);
+        this.writer.word(flags);
+        // A union's origin field is -1 here, as it is for a union with no origin: the constituents are refs, and the
+        // reader scans the field for records this record depends on.
+        if (kind === 12 /* RecordKind.Union */)
+            this.writer.word(-1);
+        return index;
     }
     union(t) {
         const refs = this.types(t.types);
+        if (this.failure !== undefined)
+            return -1;
         let origin = -1;
-        if (t.origin !== undefined) {
-            const o = t.origin;
+        const o = t.origin;
+        if (o !== undefined) {
             if ((o.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
                 // Origins are not interned: a union key spells their constituents.
                 const parts = this.types(o.types);
                 if (this.failure !== undefined)
                     return -1;
                 const kind = (o.flags & 134217728 /* TypeFlags.Union */) !== 0 ? 12 /* RecordKind.Union */ : 13 /* RecordKind.Intersection */;
-                origin = this.push(new PortableRecord(kind, -1, o.objectFlags, -2, '', undefined, undefined, parts));
+                origin = this.originRecord(kind, o.objectFlags, parts);
             }
-            else
+            else {
                 origin = this.type(o);
+                if (this.failure !== undefined)
+                    return -1;
+            }
         }
+        const alias = t.alias;
+        const aliasRefs = alias === undefined ? noRefs : this.types(alias.typeArguments);
         if (this.failure !== undefined)
             return -1;
-        const record = new PortableRecord(12 /* RecordKind.Union */, t.id, t.objectFlags, origin, '', undefined, undefined, refs);
-        return this.add(t, this.aliasOf(record, t.alias));
+        const bits = this.aliasBits(alias, aliasRefs);
+        if (bits < 0)
+            return -1;
+        const index = this.nextIndex();
+        this.memo(t, index);
+        this.begin(12 /* RecordKind.Union */, index, refs, bits);
+        this.writer.word(t.objectFlags);
+        this.writer.word(origin);
+        return index;
+    }
+    intersection(t) {
+        const refs = this.types(t.types);
+        if (this.failure !== undefined)
+            return -1;
+        const alias = t.alias;
+        const aliasRefs = alias === undefined ? noRefs : this.types(alias.typeArguments);
+        if (this.failure !== undefined)
+            return -1;
+        const bits = this.aliasBits(alias, aliasRefs);
+        if (bits < 0)
+            return -1;
+        const index = this.nextIndex();
+        this.memo(t, index);
+        this.begin(13 /* RecordKind.Intersection */, index, refs, bits);
+        this.writer.word(t.objectFlags);
+        return index;
     }
     object(t) {
         const c = this.c;
@@ -426,17 +640,17 @@ export class Exporter {
                     return this.tupleTarget(t);
                 if (symbol === undefined || getDeclaredTypeOfSymbol(c, symbol) !== t)
                     return this.fail('generic target');
-                return this.addWithSymbol(5 /* RecordKind.Declared */, t, symbol, 0, noNumbers);
+                return this.symbolType(5 /* RecordKind.Declared */, t, symbol, noRefs);
             }
             const refs = [this.type(target), ...this.types(reference.resolvedTypeArguments ?? [])];
             if (this.failure !== undefined)
                 return -1;
-            return this.add(t, new PortableRecord(9 /* RecordKind.Reference */, t.id, 0, 0, '', undefined, undefined, refs));
+            return this.plain(9 /* RecordKind.Reference */, t, refs);
         }
         if ((objectFlags & 3 /* ObjectFlags.ClassOrInterface */) !== 0) {
             if (symbol === undefined || getDeclaredTypeOfSymbol(c, symbol) !== t)
                 return this.fail('declared type');
-            return this.addWithSymbol(5 /* RecordKind.Declared */, t, symbol, 0, noNumbers);
+            return this.symbolType(5 /* RecordKind.Declared */, t, symbol, noRefs);
         }
         if ((objectFlags & (1024 /* ObjectFlags.ReverseMapped */ | 256 /* ObjectFlags.EvolvingArray */)) !== 0)
             return this.fail('object kind');
@@ -446,10 +660,10 @@ export class Exporter {
             return this.fail('object without a declaration, object flags ' + objectFlags);
         // The anonymous type of a function, class, enum or module; a variable's own type is what is being shared.
         if ((symbol.flags & sharedValueFlags()) === 0 && c.symbolTypes.get(getSymbolId(symbol)) === t)
-            return this.addWithSymbol(7 /* RecordKind.SymbolType */, t, symbol, 0, noNumbers);
+            return this.symbolType(7 /* RecordKind.SymbolType */, t, symbol, noRefs);
         const declaration = (objectFlags & 32 /* ObjectFlags.Mapped */) !== 0 ? t.declaration : symbol.declaration;
         if (declaration !== undefined && c.resolvedTypes.get(declaration.id) === t)
-            return this.add(t, new PortableRecord(8 /* RecordKind.NodeType */, t.id, 0, 0, '', undefined, declaration, noNumbers));
+            return this.nodeType(t, declaration);
         if ((symbol.flags & 4096 /* SymbolFlags.ObjectLiteral */) !== 0 &&
             (objectFlags & (16 /* ObjectFlags.Anonymous */ | 2097152 /* ObjectFlags.MembersResolved */)) ===
                 (16 /* ObjectFlags.Anonymous */ | 2097152 /* ObjectFlags.MembersResolved */))
@@ -471,10 +685,8 @@ export class Exporter {
         const resolved = t;
         if (resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0)
             return this.fail('object literal signatures');
-        const shell = new PortableRecord(22 /* RecordKind.AnonymousObject */, t.id, t.objectFlags & ~lazyObjectFlags(), 0, '', undefined, undefined, noNumbers);
-        if (!this.symbolOf(shell, t.symbol, false))
-            return -1;
-        const index = this.add(t, shell);
+        const shell = this.nextIndex();
+        this.memo(t, shell);
         const members = [];
         for (const prop of resolved.properties) {
             members.push(this.property(prop));
@@ -487,18 +699,38 @@ export class Exporter {
             const value = this.type(info.valueType);
             if (this.failure !== undefined)
                 return -1;
-            infos.push(new PortableIndexInfo(key, value, info.isReadonly, info.declaration, info.components.slice()));
+            if (!this.sharedNode(info.declaration))
+                return -1;
+            for (const node of info.components)
+                if (!this.sharedNode(node))
+                    return -1;
+            infos.push(new IndexInfoWords(key, value, info.isReadonly, info.declaration, info.components));
         }
-        const complete = new PortableRecord(23 /* RecordKind.CompleteObject */, -1, 0, index, '', undefined, undefined, members);
-        complete.indexInfos = infos;
-        this.push(complete);
-        return index;
+        const complete = this.nextIndex();
+        if (!this.nameSymbol(t.symbol, false))
+            return -1;
+        this.begin(22 /* RecordKind.AnonymousObject */, shell, noRefs, this.naming << 6 /* RecordHeader.NamingShift */);
+        const w = this.writer;
+        w.word(t.objectFlags & ~lazyObjectFlags());
+        w.word(complete);
+        this.begin(23 /* RecordKind.CompleteObject */, complete, members, 0);
+        w.word(shell);
+        w.word(infos.length);
+        for (const info of infos) {
+            w.word(info.keyType);
+            w.word(info.valueType);
+            w.word(info.isReadonly ? 1 : 0);
+            w.node(info.declaration);
+            w.word(info.components.length);
+            for (const node of info.components)
+                w.node(node);
+        }
+        return shell;
     }
-    /** The records of property symbols, by symbol. */
-    properties = new Map();
     /** A property symbol of an object literal type: a checker's own, made from one of the program or from another. */
     property(prop) {
-        const known = this.properties.get(prop);
+        const id = getSymbolId(prop);
+        const known = this.properties.get(id);
         if (known !== undefined)
             return known;
         const c = this.c;
@@ -506,7 +738,6 @@ export class Exporter {
             return this.fail('property of the program');
         if ((prop.checkFlags & ~(8 /* CheckFlags.Readonly */ | 32768 /* CheckFlags.Late */)) !== 0)
             return this.fail('property check flags ' + prop.checkFlags);
-        const id = getSymbolId(prop);
         const t = c.symbolTypes.get(id);
         if (t === undefined)
             return this.fail('property without a type');
@@ -527,33 +758,52 @@ export class Exporter {
             else
                 program = source;
         }
-        const record = new PortableRecord(24 /* RecordKind.Property */, -1, prop.flags, prop.checkFlags, prop.name, program, prop.valueDeclaration, [type, name, target]);
-        record.nodes = getDeclarations(prop).slice();
-        if (prop.parent !== undefined && !this.symbolOf(record, prop.parent, true))
-            return -1;
-        if (program !== undefined && getSymbolId(program) > this.symbolLimit)
-            return this.fail('symbol of the thread');
+        const declarations = getDeclarations(prop);
         if (!this.sharedNode(prop.valueDeclaration))
             return -1;
-        for (const node of record.nodes)
+        for (const node of declarations)
             if (!this.sharedNode(node))
                 return -1;
-        const index = this.push(record);
-        this.properties.set(prop, index);
-        this.addedProperties.push(prop);
+        const index = this.nextIndex();
+        this.properties.set(id, index);
+        this.addedProperties.push(id);
+        if (!this.nameSymbol(program, false))
+            return -1;
+        const value = prop.valueDeclaration;
+        const valueIsFirst = value !== undefined && declarations.length !== 0 && declarations[0] === value;
+        this.node = value;
+        let bits = (this.naming << 6 /* RecordHeader.NamingShift */) |
+            (valueIsFirst ? 512 /* RecordHeader.ValueIsFirst */ : value !== undefined ? 256 /* RecordHeader.HasNode */ : 0);
+        if (prop.parent !== undefined) {
+            if (!this.nameSymbol(prop.parent, true))
+                return -1;
+            bits |= 32 /* RecordHeader.HasAlias */ | (this.aliasMerged >= 0 ? 1024 /* RecordHeader.AliasMerged */ : 0);
+        }
+        this.begin(24 /* RecordKind.Property */, index, [type, name, target], bits);
+        const w = this.writer;
+        w.word(prop.flags);
+        w.word(prop.checkFlags);
+        w.text(prop.name);
+        w.word(declarations.length);
+        for (const node of declarations)
+            w.node(node);
         return index;
     }
     tupleTarget(t) {
-        const record = new PortableRecord(10 /* RecordKind.TupleTarget */, t.id, 0, t.readonly ? 1 : 0, '', undefined, undefined, noNumbers);
-        const nums = [];
-        const nodes = [];
-        for (const info of t.elementInfos) {
-            nums.push(info.flags);
-            nodes.push(info.labeledDeclaration);
+        const index = this.nextIndex();
+        this.memo(t, index);
+        this.begin(10 /* RecordKind.TupleTarget */, index, noRefs, 0);
+        const w = this.writer;
+        w.word(t.readonly ? 1 : 0);
+        const infos = t.elementInfos;
+        w.word(infos.length);
+        for (const info of infos) {
+            if (!this.sharedNode(info.labeledDeclaration))
+                return -1;
+            w.word(info.flags);
+            w.node(info.labeledDeclaration);
         }
-        record.nums = nums;
-        record.nodes = nodes;
-        return this.add(t, record);
+        return index;
     }
     /** An instantiated anonymous or mapped type, or a deferred type reference: its target and outer type arguments. */
     instantiation(t) {
@@ -576,7 +826,7 @@ export class Exporter {
             target = t.target;
         }
         if (declaration !== undefined && t.mapper === undefined && c.resolvedTypes.get(declaration.id) === t)
-            return this.add(t, new PortableRecord(8 /* RecordKind.NodeType */, t.id, 0, 0, '', undefined, declaration, noNumbers));
+            return this.nodeType(t, declaration);
         if (declaration === undefined || target === undefined || t.mapper === undefined)
             return this.fail('instantiation, declaration ' + (declaration?.kind ?? -1) + ' target ' + (target !== undefined));
         const typeParameters = c.nodeLinks(declaration).outerTypeParameters;
@@ -591,11 +841,29 @@ export class Exporter {
         const refs = [this.type(target), ...this.types(args)];
         if (this.failure !== undefined)
             return -1;
-        const record = new PortableRecord(11 /* RecordKind.Instantiation */, t.id, 0, args.length, '', undefined, declaration, refs);
-        const index = this.add(t, this.aliasOf(record, t.alias));
+        // The alias and its type arguments are exported before the record, as the record names them: a consumer builds
+        // records in index order, and would find them unbuilt after it.
+        const alias = t.alias;
+        const aliasRefs = alias === undefined ? noRefs : this.types(alias.typeArguments);
+        if (this.failure !== undefined)
+            return -1;
+        if (!this.sharedNode(declaration))
+            return -1;
+        // The record is written after the return types of its signatures, which are built right after it: its index is
+        // lower than theirs.
+        const index = this.nextIndex();
+        this.memo(t, index);
         // Only for an export that hasn't failed (its alias may have): optionalType would forget that failure.
-        if (index >= 0 && this.failure === undefined)
+        if (this.failure === undefined)
             this.resolvedReturnTypes(t, refs);
+        if (this.failure !== undefined)
+            return -1;
+        const bits = this.aliasBits(alias, aliasRefs);
+        if (bits < 0)
+            return -1;
+        this.node = declaration;
+        this.begin(11 /* RecordKind.Instantiation */, index, refs, bits | 256 /* RecordHeader.HasNode */);
+        this.writer.word(args.length);
         return index;
     }
     /**
@@ -624,7 +892,10 @@ export class Exporter {
     optionalType(t) {
         if (this.failure !== undefined)
             return -1;
-        const records = this.records.length;
+        const w = this.writer;
+        const at = w.at;
+        const unitAt = w.unitAt;
+        const count = this.count;
         const types = this.addedTypes.length;
         const properties = this.addedProperties.length;
         const index = this.type(t);
@@ -636,16 +907,23 @@ export class Exporter {
             this.properties.delete(this.addedProperties[i]);
         this.addedTypes.length = types;
         this.addedProperties.length = properties;
-        this.records.length = records;
+        this.count = count;
+        w.at = at;
+        w.unitAt = unitAt;
+        // A store that ran out stays out: the export can't be posted.
         this.failure = undefined;
         return -1;
     }
+    /**
+     * The record of the conditional type `t`: the conditional type of a type node, or the instantiation of one with
+     * outer type arguments; -1 if it can't be exported.
+     */
     conditional(t) {
         const root = t.root;
         if (t.mapper === undefined) {
             if (this.c.resolvedTypes.get(root.node.id) !== t)
                 return this.fail('conditional type');
-            return this.add(t, new PortableRecord(8 /* RecordKind.NodeType */, t.id, 0, 0, '', undefined, root.node, noNumbers));
+            return this.nodeType(t, root.node);
         }
         const args = [];
         for (const tp of root.outerTypeParameters)
@@ -660,8 +938,21 @@ export class Exporter {
                 const refs = this.types(keyed.typeArguments);
                 if (this.failure !== undefined)
                     return -1;
-                const record = new PortableRecord(16 /* RecordKind.Conditional */, t.id, 0, keyed.tag, '', undefined, keyed.root.node, refs);
-                return this.add(t, this.aliasOf(record, keyed.alias));
+                const alias = keyed.alias;
+                const aliasRefs = alias === undefined ? noRefs : this.types(alias.typeArguments);
+                if (this.failure !== undefined)
+                    return -1;
+                const bits = this.aliasBits(alias, aliasRefs);
+                if (bits < 0)
+                    return -1;
+                if (!this.sharedNode(keyed.root.node))
+                    return -1;
+                this.node = keyed.root.node;
+                const index = this.nextIndex();
+                this.memo(t, index);
+                this.begin(16 /* RecordKind.Conditional */, index, refs, bits | 256 /* RecordHeader.HasNode */);
+                this.writer.word(keyed.tag);
+                return index;
             }
             const distributed = this.c.distributedConditionals?.get(t);
             if (distributed === undefined)
@@ -669,14 +960,40 @@ export class Exporter {
             const refs = this.types([...distributed.typeArguments, distributed.constituent]);
             if (this.failure !== undefined)
                 return -1;
-            const record = new PortableRecord(21 /* RecordKind.DistributedConditional */, t.id, 0, distributed.tag, '', undefined, root.node, refs);
-            return this.add(t, this.aliasOf(record, distributed.alias));
+            const alias = distributed.alias;
+            const aliasRefs = alias === undefined ? noRefs : this.types(alias.typeArguments);
+            if (this.failure !== undefined)
+                return -1;
+            const bits = this.aliasBits(alias, aliasRefs);
+            if (bits < 0)
+                return -1;
+            if (!this.sharedNode(root.node))
+                return -1;
+            this.node = root.node;
+            const index = this.nextIndex();
+            this.memo(t, index);
+            this.begin(21 /* RecordKind.DistributedConditional */, index, refs, bits | 256 /* RecordHeader.HasNode */);
+            this.writer.word(distributed.tag);
+            return index;
         }
         const refs = this.types(args);
         if (this.failure !== undefined)
             return -1;
-        const record = new PortableRecord(16 /* RecordKind.Conditional */, t.id, 0, tag, '', undefined, root.node, refs);
-        return this.add(t, this.aliasOf(record, t.alias));
+        const alias = t.alias;
+        const aliasRefs = alias === undefined ? noRefs : this.types(alias.typeArguments);
+        if (this.failure !== undefined)
+            return -1;
+        const bits = this.aliasBits(alias, aliasRefs);
+        if (bits < 0)
+            return -1;
+        if (!this.sharedNode(root.node))
+            return -1;
+        this.node = root.node;
+        const index = this.nextIndex();
+        this.memo(t, index);
+        this.begin(16 /* RecordKind.Conditional */, index, refs, bits | 256 /* RecordHeader.HasNode */);
+        this.writer.word(tag);
+        return index;
     }
 }
 /** Object flags that checkers compute after creating a type (a function: see `sharedValueFlags`). */
@@ -689,58 +1006,162 @@ function lazyObjectFlags() {
         268435456 /* ObjectFlags.IdenticalBaseTypeExists */);
 }
 /** Translates records into a checker's own types; one translation per producer type. */
+const noTypes = [];
+/** A type alias whose symbol and type arguments are read: its declared type first, as instantiating it does. */
+function typeAliasOf(c, symbol, refs) {
+    // An instantiation of an alias follows its declared type, which records the alias's type parameters.
+    getDeclaredTypeOfSymbol(c, symbol);
+    return new TypeAlias(symbol, refs);
+}
+/** Translates the records of another checker's store into this checker's types, reading them where they are. */
 export class Translator {
     c;
-    translated = new Map();
+    store;
     initial;
     /** Set when a record has no counterpart here; the translation is then abandoned. */
     failed = false;
-    constructor(c) {
+    constructor(c, store) {
         this.c = c;
+        this.store = store;
         this.initial = initialTypes(c);
     }
-    /** A property symbol made as the producer made it. */
-    property(r, types, symbols) {
+    /**
+     * The symbol of `node`, named by `how`: the symbol of the node itself, or its export symbol. The record names
+     * symbols of the program this way, and a consumer that hasn't the symbol fails the translation.
+     */
+    namedSymbol(node, how) {
+        const local = getSymbol(node);
+        return how === 2 /* SymbolNaming.Export */ ? local?.exportSymbol : local;
+    }
+    /** Abandons the record being read: the translation fails, and a later one starts afresh. */
+    abandon() {
+        this.failed = true;
+        return undefined;
+    }
+    /** A property symbol made as the producer made it; undefined if its record can't be read here. */
+    property(index) {
         const c = this.c;
-        const prop = c.newSymbolWithCheckFlags(r.flags & ~33554432 /* SymbolFlags.Transient */, r.text, r.num);
-        setDeclarations(prop, r.nodes);
-        prop.valueDeclaration = r.node;
-        if (r.aliasSymbol !== undefined || r.aliasMergedId >= 0)
-            prop.parent = r.aliasMergedId >= 0 ? c.mergedSymbols.get(r.aliasMergedId) : r.aliasSymbol;
+        const store = this.store;
+        const reader = store.reader;
+        if (!reader.begin(index))
+            return this.abandon();
+        const f = reader.numbers;
+        const type = store.types.get(f[reader.refAt]);
+        if (type === undefined)
+            return this.abandon();
+        const nameAt = f[reader.refAt + 1];
+        const targetAt = f[reader.refAt + 2];
+        let parent = undefined;
+        if (reader.aliasNaming >= 0) {
+            if (reader.aliasNaming === 3 /* SymbolNaming.Merged */)
+                parent = c.mergedSymbols.get(reader.aliasMergedId);
+            else {
+                const node = reader.readNode(reader.aliasNodeStart);
+                if (node === undefined)
+                    return this.abandon();
+                parent = this.namedSymbol(node, reader.aliasNaming);
+            }
+            if (parent === undefined)
+                return this.abandon();
+        }
+        let source = undefined;
+        if (reader.symbolNaming === 3 /* SymbolNaming.Merged */)
+            source = c.mergedSymbols.get(reader.symbolMergedId);
+        else if (reader.symbolNaming !== 0 /* SymbolNaming.None */) {
+            const node = reader.readNode(reader.symbolNodeStart);
+            if (node === undefined)
+                return this.abandon();
+            source = this.namedSymbol(node, reader.symbolNaming);
+        }
+        if (reader.symbolNaming !== 0 /* SymbolNaming.None */ && source === undefined)
+            return this.abandon();
+        let value = undefined;
+        if (reader.nodeStart >= 0) {
+            value = reader.readNode(reader.nodeStart);
+            if (value === undefined)
+                return this.abandon();
+        }
+        let p = reader.fields;
+        const flags = f[p++];
+        const checkFlags = f[p++];
+        const text = reader.textAt(p);
+        p += 2;
+        const count = f[p++];
+        const declarations = [];
+        for (let i = 0; i < count; i++) {
+            const node = reader.readNode(p);
+            p += reader.nodeWords(p);
+            if (node === undefined)
+                return this.abandon();
+            declarations.push(node);
+        }
+        if ((reader.header & 512 /* RecordHeader.ValueIsFirst */) !== 0)
+            value = declarations[0];
+        const prop = c.newSymbolWithCheckFlags(flags & ~33554432 /* SymbolFlags.Transient */, text, checkFlags);
+        setDeclarations(prop, declarations);
+        prop.valueDeclaration = value;
+        if (parent !== undefined)
+            prop.parent = parent;
         const id = getSymbolId(prop);
-        c.symbolTypes.set(id, types[r.refs[0]]);
-        if (r.refs[1] >= 0)
-            c.symbolNameTypes.set(id, types[r.refs[1]]);
-        const target = r.refs[2] >= 0 ? symbols[r.refs[2]] : r.symbol;
+        c.symbolTypes.set(id, type);
+        if (nameAt >= 0) {
+            const nameType = store.types.get(nameAt);
+            if (nameType === undefined)
+                return this.abandon();
+            c.symbolNameTypes.set(id, nameType);
+        }
+        const target = targetAt >= 0 ? store.symbols.get(targetAt) : source;
         if (target !== undefined)
             c.symbolTargets.set(id, target);
         return prop;
     }
-    /** Sets the members of the `AnonymousObject` record a `CompleteObject` record completes. */
-    complete(r, types, symbols) {
+    /** Sets the members of the `AnonymousObject` record a `CompleteObject` record completes; false if it can't read it. */
+    complete(index) {
         const c = this.c;
-        const t = types[r.num];
-        if ((t.objectFlags & 2097152 /* ObjectFlags.MembersResolved */) !== 0)
-            return;
+        const store = this.store;
+        const reader = store.reader;
+        if (!reader.begin(index))
+            return false;
+        const f = reader.numbers;
+        const refAt = reader.refAt;
+        let p = reader.fields;
+        const shell = store.types.get(f[p++]);
+        if (shell === undefined)
+            return false;
+        if ((shell.objectFlags & 2097152 /* ObjectFlags.MembersResolved */) !== 0)
+            return true;
         const members = new Map();
-        for (const i of r.refs) {
-            const prop = symbols[i];
+        for (let i = 0; i < reader.refCount; i++) {
+            const prop = store.symbols.get(f[refAt + i]);
+            if (prop === undefined)
+                return false;
             members.set(prop.name, prop);
         }
-        const infos = r.indexInfos.map((info) => new IndexInfo(types[info.keyType], types[info.valueType], info.isReadonly, info.declaration, info.components));
-        setStructuredTypeMembers(c, t, members, [], [], infos);
-        keepPropertiesOnly(c, t, members, scannedLiteralPropertiesLimit);
-    }
-    record(r, types) {
-        if (r.id >= 0) {
-            const known = this.translated.get(r.id);
-            if (known !== undefined)
-                return known;
+        const count = f[p++];
+        const infos = [];
+        for (let i = 0; i < count; i++) {
+            const keyType = store.types.get(f[p]);
+            const valueType = store.types.get(f[p + 1]);
+            const isReadonly = f[p + 2] === 1;
+            p += 3;
+            const declaration = reader.readNode(p);
+            p += reader.nodeWords(p);
+            const components = [];
+            const componentCount = f[p++];
+            for (let j = 0; j < componentCount; j++) {
+                const node = reader.readNode(p);
+                p += reader.nodeWords(p);
+                if (node === undefined)
+                    return false;
+                components.push(node);
+            }
+            if (keyType === undefined || valueType === undefined)
+                return false;
+            infos.push(new IndexInfo(keyType, valueType, isReadonly, declaration, components));
         }
-        const t = this.build(r, types);
-        if (r.id >= 0 && !this.failed)
-            this.translated.set(r.id, t);
-        return t;
+        setStructuredTypeMembers(c, shell, members, [], [], infos);
+        keepPropertiesOnly(c, shell, members, scannedLiteralPropertiesLimit);
+        return true;
     }
     /**
      * Resolves the declared type of the type alias whose declaration contains the type node `node`, as resolving its
@@ -762,128 +1183,202 @@ export class Translator {
             return;
         }
     }
-    alias(r, types) {
-        if (r.aliasSymbol === undefined && r.aliasMergedId < 0)
-            return undefined;
-        const symbol = r.aliasMergedId >= 0 ? this.c.mergedSymbols.get(r.aliasMergedId) : r.aliasSymbol;
-        // An instantiation of an alias follows its declared type, which records the alias's type parameters.
-        getDeclaredTypeOfSymbol(this.c, symbol);
-        return new TypeAlias(symbol, r.aliasRefs.map((i) => types[i]));
-    }
-    symbol(r) {
-        return r.mergedId >= 0 ? this.c.mergedSymbols.get(r.mergedId) : r.symbol;
-    }
-    build(r, types) {
+    /** The type record `index`; undefined if it or a record it needs can't be translated here. */
+    record(index) {
         const c = this.c;
+        const store = this.store;
+        const reader = store.reader;
+        if (!reader.begin(index))
+            return this.abandon();
+        const f = reader.numbers;
+        const header = reader.header;
+        const kind = reader.kind;
+        const n = reader.refCount;
         // An instantiation's refs end with the return types of its signatures, which are built after it.
-        const own = r.kind === 11 /* RecordKind.Instantiation */ ? r.refs.slice(0, 1 + r.num) : r.refs;
-        const refs = own.map((i) => types[i]);
-        switch (r.kind) {
+        const count = kind === 11 /* RecordKind.Instantiation */ ? Math.min(n, 1 + f[reader.fields]) : n;
+        const refs = new Array(count);
+        for (let i = 0; i < count; i++) {
+            const t = store.types.get(f[reader.refAt + i]);
+            if (t === undefined)
+                return this.abandon();
+            refs[i] = t;
+        }
+        let aliasSymbol = undefined;
+        let aliasRefs = noTypes;
+        if (reader.aliasNaming >= 0) {
+            if (reader.aliasNaming === 3 /* SymbolNaming.Merged */) {
+                aliasSymbol = c.mergedSymbols.get(reader.aliasMergedId);
+                if (aliasSymbol === undefined)
+                    return this.abandon();
+            }
+            else {
+                const aliasNode = reader.readNode(reader.aliasNodeStart);
+                if (aliasNode === undefined)
+                    return this.abandon();
+                aliasSymbol = this.namedSymbol(aliasNode, reader.aliasNaming);
+                if (aliasSymbol === undefined)
+                    return this.abandon();
+            }
+            const aliasCount = reader.aliasRefCount;
+            const types = new Array(aliasCount);
+            for (let i = 0; i < aliasCount; i++) {
+                const t = store.types.get(f[reader.aliasRefAt + i]);
+                if (t === undefined)
+                    return this.abandon();
+                types[i] = t;
+            }
+            aliasRefs = types;
+        }
+        let symbol = undefined;
+        if (reader.symbolNaming === 3 /* SymbolNaming.Merged */) {
+            symbol = c.mergedSymbols.get(reader.symbolMergedId);
+            if (symbol === undefined)
+                return this.abandon();
+        }
+        else if (reader.symbolNaming !== 0 /* SymbolNaming.None */) {
+            const symbolNode = reader.readNode(reader.symbolNodeStart);
+            if (symbolNode === undefined)
+                return this.abandon();
+            symbol = this.namedSymbol(symbolNode, reader.symbolNaming);
+            if (symbol === undefined)
+                return this.abandon();
+        }
+        let node = undefined;
+        if (reader.nodeStart >= 0) {
+            node = reader.readNode(reader.nodeStart);
+            if (node === undefined)
+                return this.abandon();
+        }
+        let p = reader.fields;
+        switch (kind) {
             case 0 /* RecordKind.Initial */:
-                return this.initial[r.num];
-            case 1 /* RecordKind.Literal */:
-                if ((r.flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
-                    return getStringLiteralType(c, r.text);
-                if ((r.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0)
-                    return getNumberLiteralType(c, r.num);
-                return getBigIntLiteralType(c, r.text);
+                return this.initial[f[p]];
+            case 1 /* RecordKind.Literal */: {
+                const flags = f[p++];
+                if ((flags & 2048 /* TypeFlags.NumberLiteral */) !== 0)
+                    return getNumberLiteralType(c, reader.doubleAt(p));
+                const text = reader.textAt(p);
+                return (flags & 1024 /* TypeFlags.StringLiteral */) !== 0 ? getStringLiteralType(c, text) : getBigIntLiteralType(c, text);
+            }
             case 2 /* RecordKind.FreshLiteral */:
                 return getFreshTypeOfLiteralType(c, refs[0]);
             case 3 /* RecordKind.EnumLiteral */:
             case 5 /* RecordKind.Declared */:
-                return getDeclaredTypeOfSymbol(c, this.symbol(r));
+                return getDeclaredTypeOfSymbol(c, symbol);
             case 6 /* RecordKind.ThisType */:
-                return getDeclaredTypeOfSymbol(c, this.symbol(r)).thisType;
+                return getDeclaredTypeOfSymbol(c, symbol).thisType;
             case 4 /* RecordKind.UniqueSymbol */:
-                return getESSymbolLikeTypeForNode(c, this.symbol(r).valueDeclaration);
+                return getESSymbolLikeTypeForNode(c, symbol.valueDeclaration);
             case 7 /* RecordKind.SymbolType */:
-                return getTypeOfSymbol(c, this.symbol(r));
+                return getTypeOfSymbol(c, symbol);
             case 8 /* RecordKind.NodeType */: {
-                const node = r.node;
                 const cached = c.resolvedTypes.get(node.id);
                 if (cached !== undefined)
                     return cached;
                 this.aliasOfNode(node);
                 if (this.failed)
-                    return c.errorType;
+                    return undefined;
                 const t = getTypeFromTypeNode(c, node);
                 return c.resolvedTypes.get(node.id) ?? t;
             }
             case 9 /* RecordKind.Reference */:
                 return createTypeReference(c, refs[0], refs.slice(1));
             case 10 /* RecordKind.TupleTarget */: {
+                const readonly = f[p++] === 1;
+                const infosCount = f[p++];
                 const infos = [];
-                for (let i = 0; i < r.nums.length; i++)
-                    infos.push(new TupleElementInfo(r.nums[i], r.nodes[i]));
-                return getTupleTargetType(c, infos, r.num === 1);
+                for (let i = 0; i < infosCount; i++) {
+                    const flags = f[p++];
+                    const label = reader.readNode(p);
+                    p += reader.nodeWords(p);
+                    infos.push(new TupleElementInfo(flags, label));
+                }
+                return getTupleTargetType(c, infos, readonly);
             }
             case 11 /* RecordKind.Instantiation */: {
+                const args = f[p++];
                 const target = refs[0];
-                const typeParameters = outerTypeParametersOf(c, r.node, target);
-                return instantiateTypeWithAlias(c, target, newTypeMapper(typeParameters, refs.slice(1, 1 + r.num)), this.alias(r, types));
+                const typeParameters = outerTypeParametersOf(c, node, target);
+                return instantiateTypeWithAlias(c, target, newTypeMapper(typeParameters, refs.slice(1, 1 + args)), aliasSymbol === undefined ? undefined : typeAliasOf(c, aliasSymbol, aliasRefs));
             }
             case 12 /* RecordKind.Union */: {
-                if (r.num === -2)
-                    return newUnionType(c, r.flags & 0 /* ObjectFlags.None */, refs);
-                const origin = r.num >= 0 ? types[r.num] : undefined;
-                return getUnionTypeFromSortedList(c, refs, r.flags & (32768 /* ObjectFlags.PrimitiveUnion */ | 33554432 /* ObjectFlags.ContainsIntersections */), this.alias(r, types), origin);
+                const flags = f[p++];
+                const originAt = f[p++];
+                if ((header & 2048 /* RecordHeader.Constituent */) !== 0)
+                    return newUnionType(c, flags & 0 /* ObjectFlags.None */, refs);
+                return getUnionTypeFromSortedList(c, refs, flags & (32768 /* ObjectFlags.PrimitiveUnion */ | 33554432 /* ObjectFlags.ContainsIntersections */), aliasSymbol === undefined ? undefined : typeAliasOf(c, aliasSymbol, aliasRefs), originAt >= 0 ? store.types.get(originAt) : undefined);
             }
             case 13 /* RecordKind.Intersection */: {
-                if (r.num === -2)
+                const flags = f[p++];
+                if ((header & 2048 /* RecordHeader.Constituent */) !== 0)
                     return newIntersectionType(c, 0 /* ObjectFlags.None */, refs);
-                const alias = this.alias(r, types);
+                const alias = aliasSymbol === undefined ? undefined : typeAliasOf(c, aliasSymbol, aliasRefs);
                 const hash = typeListHash(refs, alias, 0);
                 const existing = c.intersectionTypes.get(hash, refs, alias, 0);
                 if (existing !== undefined)
                     return existing;
-                const result = newIntersectionType(c, (r.flags & 134217728 /* ObjectFlags.IsConstrainedTypeVariable */) | getPropagatingFlagsOfTypes(refs, 12 /* TypeFlags.Nullable */), refs);
+                const result = newIntersectionType(c, (flags & 134217728 /* ObjectFlags.IsConstrainedTypeVariable */) | getPropagatingFlagsOfTypes(refs, 12 /* TypeFlags.Nullable */), refs);
                 result.alias = alias;
                 c.intersectionTypes.set(hash, refs, alias, 0, result);
                 return result;
             }
             case 14 /* RecordKind.Index */:
-                return getIndexTypeEx(c, refs[0], r.num);
+                return getIndexTypeEx(c, refs[0], f[p]);
             case 15 /* RecordKind.IndexedAccess */:
-                return getIndexedAccessTypeEx(c, refs[0], refs[1], r.num, undefined, this.alias(r, types));
+                return getIndexedAccessTypeEx(c, refs[0], refs[1], f[p], undefined, aliasSymbol === undefined ? undefined : typeAliasOf(c, aliasSymbol, aliasRefs));
             case 16 /* RecordKind.Conditional */: {
-                this.aliasOfNode(r.node);
+                const tag = f[p++];
+                this.aliasOfNode(node);
                 if (this.failed)
-                    return c.errorType;
-                const declared = c.resolvedTypes.get(r.node.id) ?? getTypeFromTypeNode(c, r.node);
+                    return undefined;
+                const declared = c.resolvedTypes.get(node.id) ?? getTypeFromTypeNode(c, node);
                 const root = declared.root;
-                return getConditionalTypeInstantiation(c, declared, newTypeMapper(root.outerTypeParameters, refs), r.num === 1, this.alias(r, types));
+                return getConditionalTypeInstantiation(c, declared, newTypeMapper(root.outerTypeParameters, refs), tag === 1, aliasSymbol === undefined ? undefined : typeAliasOf(c, aliasSymbol, aliasRefs));
             }
             case 21 /* RecordKind.DistributedConditional */: {
-                this.aliasOfNode(r.node);
+                const tag = f[p++];
+                this.aliasOfNode(node);
                 if (this.failed)
-                    return c.errorType;
-                const declared = (c.resolvedTypes.get(r.node.id) ?? getTypeFromTypeNode(c, r.node));
+                    return undefined;
+                const declared = (c.resolvedTypes.get(node.id) ?? getTypeFromTypeNode(c, node));
                 const root = declared.root;
                 const args = refs.slice(0, refs.length - 1);
-                const alias = this.alias(r, types);
-                getConditionalTypeInstantiation(c, declared, newTypeMapper(root.outerTypeParameters, args), r.num === 1, alias);
-                const member = c.distributedByKey?.get(distributedKey(root.node.id, args, alias, r.num, refs[refs.length - 1]));
+                const alias = aliasSymbol === undefined ? undefined : typeAliasOf(c, aliasSymbol, aliasRefs);
+                getConditionalTypeInstantiation(c, declared, newTypeMapper(root.outerTypeParameters, args), tag === 1, alias);
+                const member = c.distributedByKey?.get(distributedKey(root.node.id, args, alias, tag, refs[refs.length - 1]));
                 if (member === undefined)
-                    this.failed = true;
-                return member ?? c.errorType;
+                    return this.abandon();
+                return member;
+            }
+            case 17 /* RecordKind.Template */: {
+                const textsCount = f[p++];
+                const texts = [];
+                for (let i = 0; i < textsCount; i++) {
+                    texts.push(reader.textAt(p));
+                    p += 2;
+                }
+                return getTemplateLiteralType(c, texts, refs);
             }
-            case 17 /* RecordKind.Template */:
-                return getTemplateLiteralType(c, r.texts.slice(), refs);
             case 18 /* RecordKind.StringMapping */:
-                return getStringMappingType(c, this.symbol(r), refs[0]);
+                return getStringMappingType(c, symbol, refs[0]);
             case 19 /* RecordKind.Substitution */:
                 return getSubstitutionType(c, refs[0], refs[1]);
             case 20 /* RecordKind.NoInfer */:
                 return getNoInferType(c, refs[0]);
-            case 22 /* RecordKind.AnonymousObject */:
-                return newObjectType(c, r.flags | 16 /* ObjectFlags.Anonymous */, this.symbol(r));
+            case 22 /* RecordKind.AnonymousObject */: {
+                // A translation that failed after this record opened the type still made it, and a record built then may name
+                // it: the completion must fill that type, not a new one beside it.
+                const known = store.types.get(index);
+                if (known !== undefined)
+                    return known;
+                return newObjectType(c, f[p] | 16 /* ObjectFlags.Anonymous */, symbol);
+            }
             case 23 /* RecordKind.CompleteObject */:
             case 24 /* RecordKind.Property */:
-                return c.errorType;
+                return this.abandon();
         }
     }
 }
-/** The outer type parameters an instantiation of `target` (declared at `declaration`) maps, as instantiation computes them. */
 function outerTypeParametersOf(c, declaration, target) {
     const known = c.nodeLinks(declaration).outerTypeParameters;
     if (known !== undefined)
@@ -913,19 +1408,20 @@ export function isSharedReturnSignature(c, sig) {
         (sig.flags & (16 /* SignatureFlags.IsInnerCallChain */ | 32 /* SignatureFlags.IsOuterCallChain */)) === 0 &&
         c.resolvedSignatures.get(declaration.id) === sig);
 }
-// ---- Sharing between checker threads (TSC_TS_SHARE=1)
-//
-// Checker threads take files from the shared queue as without sharing, and record which checker took each file
-// (`ThreadSharingData.takers`). When a checker needs the value type of a variable or property, or the return type of a
-// declared signature, declared in a file another checker took, it looks the declaration up in a table all threads
-// share (`ResultTable`): a result another checker posted is translated, unless that checker's computation reported
-// diagnostics in a file this one checks or may check; otherwise the checker computes the result itself. After
-// computing a result that took long enough and met no resolution cycle, a checker exports it into its store (each type
-// once) and posts it. A checker that took results for declarations of a file no checker took yet never checks that
-// file: it hands the file on to another checker (`forbidden`, `handoff`), which then computes them itself, as the
-// checker of a file always does.
-/** Whether checker threads share results (TSC_TS_SHARE=1). */
-export const shareThreads = process.env.TSC_TS_SHARE === '1';
+/**
+ * The columns of a checker's row of `ThreadSharingData.stats`: the milliseconds of its outermost
+ * computations by kind (0 owned, 1 computed here for a file another checker took, 2 translated, 3
+ * other), of exporting, translating and unpacking results, the results it posted and translated, and
+ * the milliseconds it saved by translating a result instead of computing it.
+ */
+export const shareStatColumns = 10;
+export const shareStatKinds = 4;
+export const shareStatExport = 4;
+export const shareStatTranslation = 5;
+export const shareStatUnpack = 6;
+export const shareStatPosted = 7;
+export const shareStatTranslated = 8;
+export const shareStatSaved = 9;
 /**
  * The size of each checker's logs: numbers (int32s) and string code units (2 bytes each), 8 MB and 2 MB. Only the
  * pages a checker writes take memory.
@@ -934,6 +1430,8 @@ export const numberLogSize = 1 << 21;
 export const stringLogSize = 1 << 20;
 /** The number of records each checker's store can hold. */
 export const recordTableSize = 1 << 20;
+/** The int32s each checker gets in `ThreadSharingData.used`, a cache line each, for two counters. */
+export const usedStride = 16;
 /** The number of entries of each result table: a power of two. */
 export const resultTableSize = 1 << 20;
 /**
@@ -961,6 +1459,10 @@ export function forbiddenWords(count) {
 export function isForbidden(forbidden, count, file, index) {
     return (Atomics.load(forbidden, file * forbiddenWords(count) + (index >>> 5)) & (1 << (index & 31))) !== 0;
 }
+/** Whether checker `index` of `count` looked for a result for a declaration of file `file` and found none (`wanted`). */
+export function isWanted(wanted, count, file, index) {
+    return (Atomics.load(wanted, file * forbiddenWords(count) + (index >>> 5)) & (1 << (index & 31))) !== 0;
+}
 /**
  * An open-addressing table in a SharedArrayBuffer, from a key (a symbol or node id) to a result's state: 0 until a
  * checker posts it, then `postedState`.
@@ -1011,8 +1513,73 @@ export class ResultTable {
         Atomics.compareExchange(this.words, 2 * slot + 1, 0, state);
     }
 }
-/** TSC_TS_SHARE_MIN_MS: the shortest computation a checker posts, in milliseconds (32 divided by the checkers by default). */
+/** TSC_TS_SHARE_MIN_MS: the shortest computation a checker posts, in milliseconds (`shareFloorTotalMs` split by the checkers by default). */
 const shareMinValue = process.env.TSC_TS_SHARE_MIN_MS;
+/**
+ * The floor, in milliseconds of checker time split over the checkers that share: 1 ms with 4 checkers, 0.25 ms with
+ * 16.
+ */
+const shareFloorTotalMs = 4;
+/** `TSC_TS_SHARE_<name>` as a number, or `fallback`. */
+function shareNumber(name, fallback) {
+    const value = process.env[name];
+    if (value === undefined)
+        return fallback;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+/**
+ * The posting rule's cost model: a post appends at most `(kappa*T - p0)/e` records (`T` the computation's time), a
+ * take builds at most `lambda*T/c`, `p0` is what a post costs itself, `e` each record a post adds and `c` each record
+ * a take builds, all in microseconds. The price instrumentation's replay (`TSC_TS_SHARE_PRICE`) fits them; the
+ * `TSC_TS_SHARE_*` variables override them for measurement.
+ *
+ * Read where they are used, not once at module evaluation: this module is in an import cycle (it imports
+ * `checker-symbols.js`, which imports `checker.js`, which imports this module), and scriptc rejects code that runs at
+ * module evaluation there (SC1016: a class the cycle reaches can be accessed before its declaration runs), so a
+ * `const kappa = shareNumber(...)` at the top level does not build.
+ */
+function shareKappa() {
+    return shareNumber('TSC_TS_SHARE_KAPPA', 0.25);
+}
+function shareLambda() {
+    return shareNumber('TSC_TS_SHARE_LAMBDA', 0.3);
+}
+function sharePostUs() {
+    return shareNumber('TSC_TS_SHARE_P0_US', 0.3);
+}
+function shareExportRecordUs() {
+    return shareNumber('TSC_TS_SHARE_E_US', 1.2);
+}
+function shareBuildRecordUs() {
+    return shareNumber('TSC_TS_SHARE_C_US', 6.59);
+}
+/**
+ * Whether a run posts cost-bounded is its configuration's choice (`RunConfig.bounded`), not a rule here: off by
+ * default, because a bounded post costs a run that gains nothing by it (T3 server's c16 check was 8-9% slower),
+ * and turned on where the project's own runs measured it faster (`run-config.ts`). A bounded run keeps the 2-8 ms
+ * floor's sharing gate, posts only results another checker demanded, and budgets both the records a post adds and
+ * the records a take builds; an unbounded run keeps Phase 1's rule and posts every result over the floor.
+ */
+/** The floor's total in milliseconds before the cost-bounded rule (`shareFloorTotalMs`): 2 ms at 16, 8 ms at 4. */
+const shareFloorTotalMsPhase1 = 32;
+/**
+ * The rule of the design's Phase 2: a result is posted when it took at least the floor (`ThreadSharing.minMs`), and a
+ * consumer builds at most `lambda*T/c` records to take one, where `T` is the producer's time for it.
+ */
+export class CostBoundedRule {
+    bounded;
+    /** `bounded` false is Phase 1's rule: the same floor, and a take that may build any number of records. */
+    constructor(bounded) {
+        this.bounded = bounded;
+    }
+    posts(sharing, _key, ms, _diagnosticFiles, _fileIndex) {
+        return ms >= sharing.minMs;
+    }
+    buildBudget(ms) {
+        return this.bounded ? Math.floor((shareLambda() * ms * 1000) / shareBuildRecordUs()) : Number.POSITIVE_INFINITY;
+    }
+}
 // Debugging: TSC_TS_SHARE_BLOCK and TSC_TS_SHARE_ALLOW name parts of file names (comma-separated, each optionally with
 // a range of declaration positions, `name@start-end`) whose results are never or only translated, and
 // TSC_TS_SHARE_TRACE=1 prints each translation.
@@ -1020,7 +1587,8 @@ const shareBlockValue = process.env.TSC_TS_SHARE_BLOCK;
 const shareAllowValue = process.env.TSC_TS_SHARE_ALLOW;
 const shareTraceValue = process.env.TSC_TS_SHARE_TRACE;
 // Debugging: TSC_TS_SHARE_VERIFY=1 computes each result a checker could translate, translates it after, and prints
-// the results whose translation prints differently.
+// the results whose translation prints differently; =2 checks that a translation creates types record by record, in
+// the order the producer created them.
 const shareVerifyValue = process.env.TSC_TS_SHARE_VERIFY;
 /** Checks a translation against the computation it replaces (TSC_TS_SHARE_VERIFY). */
 function verifyTranslation(c, kind, node, own, translated) {
@@ -1131,7 +1699,8 @@ export class IdBits {
 }
 /**
  * The files of the diagnostics of results, by key (a symbol or declaration id), with a bit per key: most results have
- * none, and the bit answers that without a lookup.
+ * none, and the bit answers that without a lookup. A file is its index in the program (`Checker.fileIndex`), and -1
+ * a diagnostic without a file.
  */
 export class FilesByKey {
     files = new Map();
@@ -1151,6 +1720,18 @@ export class ThreadSharing {
     returns;
     /** TSC_TS_SHARE_MIN_MS: the shortest computation this checker posts. */
     minMs;
+    /**
+     * Whether this run is cost-bounded, which the run's configuration chose (`RunConfig.bounded`, off by default and
+     * learned from the project's records). Without it the run keeps Phase 1's behavior: no demand bits, no export or
+     * take budget, the 2-8 ms floor.
+     */
+    bounded;
+    /**
+     * The rule that decides which of this checker's results are posted, and how much a take may build. A small-result
+     * tier stacks on it by constructing its own rule here. Built per checker, not once at module evaluation, for the
+     * reason the cost model's functions give (`shareKappa`).
+     */
+    rule;
     initialIndexes = new Map();
     initial;
     numberLogs = [];
@@ -1159,9 +1740,26 @@ export class ThreadSharing {
     used;
     takers;
     forbidden;
+    /** The checkers that missed on a key in each file (`ThreadSharingData.wanted`). */
+    wanted;
+    /** The files this checker noted a miss on, so that each is marked in `wanted` once. */
+    wantedFiles = new IdBits();
+    /** The stop switch of every checker (`ThreadSharingData.control`). */
+    control;
+    /** This checker's row of the counters the main thread reads (`ThreadSharingData.stats`). */
+    stats;
+    row;
     /** The number of results this checker posted. */
     posted = 0;
     translated = 0;
+    /**
+     * Set while this checker exports a result into its store. A computation nested in the export walk can reach
+     * another shared result: posting it would write its records in the middle of the record being exported, and an
+     * export that failed would rewind over the posted result's words.
+     */
+    exporting = false;
+    /** Shared results a nested computation left to the checkers that compute them. */
+    nested = 0;
     /** Outermost shared-kind computations: nesting depth, the kind of the current one, and the time by kind. */
     depth = 0;
     kind = 0;
@@ -1170,6 +1768,31 @@ export class ThreadSharing {
     addOutermost(ms) {
         this.kindMs[this.kind] += ms;
         this.kind = 3;
+        this.writeStats();
+    }
+    /**
+     * Copies this checker's counters into its row of `stats`, the memory the main thread reads them from
+     * while checking runs. Called where a counter changes, a few times per result at most.
+     */
+    writeStats() {
+        const s = this.stats;
+        const row = this.row;
+        for (let k = 0; k < shareStatKinds; k++)
+            s[row + k] = this.kindMs[k];
+        s[row + shareStatExport] = this.exportMs;
+        s[row + shareStatTranslation] = this.translationMs;
+        // A translation reads its records in place, so there is no separate unpacking time: shareStatUnpack stays 0.
+        s[row + shareStatPosted] = this.posted;
+        s[row + shareStatTranslated] = this.translated;
+    }
+    /** Adds to the milliseconds this checker saved by translating results instead of computing them. */
+    addSaved(ms) {
+        const at = this.row + shareStatSaved;
+        this.stats[at] = this.stats[at] + ms;
+    }
+    /** Whether the main thread stopped translating posted results (control 2): this checker computes them. */
+    stoppedTranslating() {
+        return Atomics.load(this.control, 0) === 2;
     }
     notShareable = 0;
     notShareableMs = 0;
@@ -1180,17 +1803,26 @@ export class ThreadSharing {
     verifiedIdentity = 0;
     belowMin = 0;
     belowMinMs = 0;
+    /** Results whose export passed the budget `kappa*T`, and translations that stopped at `lambda*T/c`. */
+    overBudget = 0;
+    overBudgetMs = 0;
+    stoppedTranslations = 0;
+    /** Results not posted because no checker that may take one missed on a key in the declaration's file. */
+    notDemanded = 0;
     exportFailed = 0;
     exportFailedMs = 0;
     exportFailures = new Map();
-    packFailed = 0;
-    /** Of `packFailed`, the results that didn't fit in this checker's logs. */
+    /** TSC_TS_SHARE_VERIFY=2: records whose translation created types before an earlier record's. */
+    orderViolations = 0;
+    storeFailed = 0;
+    /** Of `storeFailed`, the results that didn't fit in this checker's logs. */
     logFull = 0;
     computedPrivately = 0;
+    /** Results this checker computed and kept because the main thread stopped sharing (control 1 or 2). */
+    stopped = 0;
     /** How often a posted result couldn't be taken here; and results for declarations of the checker's own files. */
     sawDoneUnusable = 0;
     owned = 0;
-    unpackMs = 0;
     /** The program's nodes results named, by id. */
     nodesById = new Map();
     origins = new MergedOrigins();
@@ -1262,13 +1894,13 @@ export class ThreadSharing {
                 if (own === undefined)
                     own = new Set();
                 const file = diagnostics[i].file;
-                own.add(file === undefined ? '' : file.fileName);
+                own.add(file === undefined ? -1 : this.fileIndexOfName(file.fileName));
             }
             for (let i = suggestionsBefore; i < suggestions.length; i++) {
                 if (own === undefined)
                     own = new Set();
                 const file = suggestions[i].file;
-                own.add(file === undefined ? '' : file.fileName);
+                own.add(file === undefined ? -1 : this.fileIndexOfName(file.fileName));
             }
             // A deferred diagnostic is reported where its file is checked, as the diagnostics it reported are.
             for (let i = deferredBefore; i < deferred.length; i++) {
@@ -1283,6 +1915,22 @@ export class ThreadSharing {
             }
         }
     }
+    /**
+     * The index of the program file named `fileName`, or -1: a diagnostic in a file this checker hasn't is one every
+     * checker would report, like a diagnostic without a file.
+     */
+    fileIndexOfName(fileName) {
+        let files = this.filesByIndex;
+        if (files === undefined) {
+            files = new Map();
+            for (const [file, index] of this.c.fileIndex)
+                files.set(file.fileName, index);
+            this.filesByIndex = files;
+        }
+        return files.get(fileName) ?? -1;
+    }
+    /** The index of each file by name, built on first use. */
+    filesByIndex = undefined;
     constructor(c, data) {
         this.c = c;
         // `tracked` reads the diagnostics a computation added, and deferred, from these lists.
@@ -1290,17 +1938,27 @@ export class ThreadSharing {
         c.suggestionDiagnostics.added = [];
         c.deferredDiagnosticFiles = [];
         this.data = data;
+        this.bounded = data.bounded;
+        this.rule = new CostBoundedRule(this.bounded);
         this.used = new Int32Array(data.used);
         this.takers = new Int32Array(data.takers);
         this.forbidden = new Int32Array(data.forbidden);
+        this.wanted = new Int32Array(data.wanted);
+        this.control = new Int32Array(data.control);
+        this.stats = new Float64Array(data.stats);
+        this.row = data.index * shareStatColumns;
         this.types = new ResultTable(data.typeTable);
         this.returns = new ResultTable(data.returnTable);
-        // A posted result pays when enough checkers need it, so the threshold falls as checkers are added: 8 ms with 4
-        // checkers, 2 ms with 16.
-        this.minMs = shareMinValue === undefined ? 32 / data.count : Number(shareMinValue);
+        // The floor, lowered with the rest of the 2-8 ms threshold band when posting is cost-bounded: a posted result pays
+        // when enough checkers need it, so it falls as checkers are added, to 0.25 ms with 16. Below the bounded count the
+        // run keeps the 2-8 ms band, where the posts the extra floor would add are what the c4 gate measured as a cost.
+        this.minMs =
+            shareMinValue === undefined
+                ? (this.bounded ? shareFloorTotalMs : shareFloorTotalMsPhase1) / data.count
+                : Number(shareMinValue);
         this.initial = initialTypes(c);
         for (let i = 0; i < this.initial.length; i++)
-            this.initialIndexes.set(this.initial[i], i);
+            this.initialIndexes.set(this.initial[i].id, i);
         for (let k = 0; k < data.count; k++) {
             this.numberLogs.push(new Int32Array(data.numberLogs[k]));
             this.recordTables.push(new Int32Array(data.recordTables[k]));
@@ -1310,8 +1968,15 @@ export class ThreadSharing {
             process.on('exit', () => process.stderr.write(this.summary() + '\n'));
     }
     summary() {
+        // The stores are written through a local cursor; the shared counters are only for this summary.
+        const writer = this.storeExporter?.writer;
+        const me = this.data.index;
+        if (writer !== undefined) {
+            this.used[usedStride * me] = writer.at;
+            this.used[usedStride * me + 1] = writer.unitAt;
+        }
         return ('checker ' +
-            this.data.index +
+            me +
             ': outermost ms owned/computed here/translated/other ' +
             this.kindMs.map((v) => v.toFixed(0)).join('/') +
             '; posted ' +
@@ -1322,15 +1987,15 @@ export class ThreadSharing {
             this.translated +
             ' (' +
             this.translationMs.toFixed(0) +
-            ' ms, unpacking ' +
-            this.unpackMs.toFixed(0) +
             ' ms), export ' +
             this.exportMs.toFixed(0) +
             ' ms, computed here ' +
             this.computedPrivately +
             ' (' +
             this.sawDoneUnusable +
-            ' posted but not taken), owned ' +
+            ' posted but not taken, ' +
+            this.stopped +
+            ' after the stop switch), owned ' +
             this.owned +
             '; not posted: cycles ' +
             this.notShareable +
@@ -1340,7 +2005,15 @@ export class ThreadSharing {
             this.belowMin +
             ' (' +
             this.belowMinMs.toFixed(0) +
-            ' ms), not exported ' +
+            ' ms), not demanded ' +
+            this.notDemanded +
+            ', over the export budget ' +
+            this.overBudget +
+            ' (' +
+            this.overBudgetMs.toFixed(0) +
+            ' ms), takes stopped at their budget ' +
+            this.stoppedTranslations +
+            ', not exported ' +
             this.exportFailed +
             ' (' +
             this.exportFailedMs.toFixed(0) +
@@ -1350,16 +2023,21 @@ export class ThreadSharing {
                 .slice(0, 4)
                 .map(([k, v]) => k + ' ' + v.toFixed(0))
                 .join('; ') +
-            '), not packed ' +
-            this.packFailed +
+            '), in an export ' +
+            this.nested +
+            ', not stored ' +
+            this.storeFailed +
             ' (logs full ' +
             this.logFull +
             ', used ' +
-            this.used[2 * this.data.index] +
+            this.used[usedStride * me] +
             ' numbers, ' +
-            this.used[2 * this.data.index + 1] +
+            this.used[usedStride * me + 1] +
             ' code units)' +
-            (shareVerifyValue === '1' ? '; verified ' + this.verified + ' (' + this.verifiedIdentity + ' equal as text)' : ''));
+            (shareVerifyValue === '1'
+                ? '; verified ' + this.verified + ' (' + this.verifiedIdentity + ' equal as text)'
+                : '') +
+            (shareVerifyValue === '2' ? '; order violations ' + this.orderViolations : ''));
     }
     /**
      * Whether this checker checks `file`, or may: a result computed for a declaration in it is never taken here. That is
@@ -1368,17 +2046,60 @@ export class ThreadSharing {
      */
     owns(file) {
         const index = this.c.fileIndex.get(file);
-        if (index === undefined)
+        return index === undefined || this.ownsIndex(index);
+    }
+    /** Whether this checker checks file `index`, or may; -1 names a diagnostic without a file, which it has. */
+    ownsIndex(index) {
+        if (index < 0)
             return true;
         const taker = Atomics.load(this.takers, index);
         if (taker === 0)
             return false;
         return taker !== -2 && (taker < 0 || taker === this.data.index + 1);
     }
+    /**
+     * Notes that this checker looked for a result for a declaration in `file` and found none: a checker posts results
+     * for that file only then (`demanded`). One `Atomics.or` per file and checker.
+     */
+    want(file) {
+        if (!this.bounded)
+            return;
+        const index = this.c.fileIndex.get(file);
+        if (index === undefined || this.wantedFiles.has(index))
+            return;
+        this.wantedFiles.add(index);
+        const me = this.data.index;
+        Atomics.or(this.wanted, index * forbiddenWords(this.data.count) + (me >>> 5), 1 << (me & 31));
+    }
+    /**
+     * Whether a checker other than this one and the file's taker missed on a key in file `index`: someone other than
+     * the checkers that already compute its declarations would take a result for one of them.
+     */
+    demanded(index) {
+        const count = this.data.count;
+        const me = this.data.index;
+        const words = forbiddenWords(count);
+        const taker = Atomics.load(this.takers, index);
+        const base = index * words;
+        for (let w = 0; w < words; w++) {
+            let bits = Atomics.load(this.wanted, base + w);
+            if (w === me >>> 5)
+                bits &= ~(1 << (me & 31));
+            if (taker > 0 && w === (taker - 1) >>> 5)
+                bits &= ~(1 << ((taker - 1) & 31));
+            if (bits !== 0)
+                return true;
+        }
+        return false;
+    }
     /** After taking a result for a declaration in `file`: if no checker took the file yet, this one never will. */
     forbid(file) {
         const index = this.c.fileIndex.get(file);
-        if (index === undefined)
+        if (index !== undefined)
+            this.forbidIndex(index);
+    }
+    forbidIndex(index) {
+        if (index < 0)
             return;
         const me = this.data.index;
         if (Atomics.load(this.takers, index) === 0)
@@ -1404,40 +2125,16 @@ export class ThreadSharing {
         }
         return true;
     }
-    forbidsLastNamed(fileName) {
-        this.ownsFileNamed(fileName);
-        const file = this.filesByName.get(fileName);
-        const index = file === undefined ? undefined : this.c.fileIndex.get(file);
-        return index !== undefined && this.forbidsLast(index);
-    }
-    forbidNamed(fileName) {
-        this.ownsFileNamed(fileName);
-        const file = this.filesByName.get(fileName);
-        if (file !== undefined)
-            this.forbid(file);
-    }
-    filesByName = undefined;
-    ownsFileNamed(fileName) {
-        let files = this.filesByName;
-        if (files === undefined) {
-            files = new Map();
-            for (const file of this.c.files)
-                files.set(file.fileName, file);
-            this.filesByName = files;
-        }
-        const file = files.get(fileName);
-        return file === undefined || this.owns(file);
-    }
-    /** The result checker `k` posted at `offset` in its number log. */
+    /** The result checker `k` posted at `offset` in its number log: the record of its type, and the files it named. */
     result(k, offset) {
         const numbers = this.numberLogs[k];
-        const strings = this.stringLogs[k];
         const root = numbers[offset];
-        const count = numbers[offset + 1];
+        const computeMs = numbers[offset + 1] / 1000;
+        const count = numbers[offset + 2];
         const files = [];
         for (let i = 0; i < count; i++)
-            files.push(readText(strings, numbers[offset + 2 + 2 * i], numbers[offset + 3 + 2 * i]));
-        return new StoredResult(root, files);
+            files.push(numbers[offset + 3 + i]);
+        return new StoredResult(root, files, computeMs);
     }
     /** The exporter of this checker's store: it exports each type once. */
     storeExporter = undefined;
@@ -1446,71 +2143,71 @@ export class ThreadSharing {
      * tables, -1 if it doesn't fit in the logs or a node or symbol in it can't be named across threads, or why it can't
      * be exported.
      */
-    post(t, diagnosticFiles) {
+    post(t, diagnosticFiles, computeMs) {
         const c = this.c;
+        const me = this.data.index;
         let exporter = this.storeExporter;
         if (exporter === undefined) {
-            exporter = new Exporter(c, this.initialIndexes);
+            const writer = new StoreWriter(this.numberLogs[me], this.stringLogs[me], this.recordTables[me], c.fileIndex);
+            exporter = new Exporter(c, this.initialIndexes, writer);
             exporter.nodeLimit = this.data.nodeIds;
             exporter.symbolLimit = this.data.symbolIds;
             exporter.originsCache = this.origins;
             this.storeExporter = exporter;
         }
+        // The export budget: a post appends at most `(kappa*T - p0)/e` records, so it costs at most `kappa*T` even when
+        // the result is over it, and an over-budget result is not posted.
+        if (this.bounded) {
+            const maxRecords = Math.floor((shareKappa() * computeMs * 1000 - sharePostUs()) / shareExportRecordUs());
+            if (maxRecords < 0)
+                return budgetFailure;
+            exporter.limit = exporter.base + maxRecords;
+        }
+        else
+            exporter.limit = Number.POSITIVE_INFINITY;
+        const writer = exporter.writer;
         exporter.failure = undefined;
         exporter.mergedOrigins = undefined;
-        const root = exporter.type(t);
-        if (exporter.failure !== undefined) {
-            const failure = exporter.failure;
-            forgetExport(exporter);
-            return failure;
-        }
-        const me = this.data.index;
-        const numbers = this.numberLogs[me];
-        const strings = this.stringLogs[me];
-        const table = this.recordTables[me];
-        const offset = this.used[2 * me];
-        const p = new RecordPacker(c.fileIndex, strings, this.used[2 * me + 1]);
-        const starts = [];
-        for (const r of exporter.records) {
-            starts.push(p.f.length);
-            if (!packRecord(p, r)) {
-                forgetExport(exporter);
+        exporter.base = this.storedRecords;
+        exporter.count = 0;
+        const at = writer.at;
+        const unitAt = writer.unitAt;
+        this.exporting = true;
+        try {
+            const root = exporter.type(t);
+            if (exporter.failure !== undefined) {
+                const failure = exporter.failure;
+                forgetExport(exporter, at, unitAt);
+                return failure;
+            }
+            // The result's own words, at the cursor after the records it added: its root record, how long the result
+            // took to compute (microseconds: a checker that translates it saved that much), and the files its
+            // diagnostics are in.
+            const header = writer.at;
+            writer.word(root);
+            writer.word(Math.round(computeMs * 1000));
+            writer.word(diagnosticFiles.length);
+            for (const index of diagnosticFiles)
+                writer.word(index);
+            if (writer.full) {
+                this.logFull++;
+                forgetExport(exporter, at, unitAt);
                 return -1;
             }
+            const count = exporter.count;
+            exporter.base += count;
+            exporter.count = 0;
+            exporter.addedTypes.length = 0;
+            exporter.addedProperties.length = 0;
+            this.posted++;
+            this.storedRecords += count;
+            this.writeStats();
+            // Only this checker writes its logs and store; the result table's state publishes what it wrote.
+            return postedState(this.data.count, me, header);
         }
-        const header = p.f.length;
-        p.f.push(root, diagnosticFiles.length);
-        for (const fileName of diagnosticFiles)
-            p.text(fileName);
-        const count = exporter.records.length;
-        let fits = !p.full && offset + p.f.length <= numbers.length && exporter.base + count <= recordTableSize;
-        for (const v of p.f)
-            if ((v | 0) !== v)
-                fits = false;
-        if (!fits) {
-            this.logFull++;
-            forgetExport(exporter);
-            return -1;
+        finally {
+            this.exporting = false;
         }
-        for (let i = 0; i < p.f.length; i++)
-            numbers[offset + i] = p.f[i];
-        for (let i = 0; i < count; i++) {
-            const index = exporter.base + i;
-            table[2 * index] = offset + starts[i] + 1;
-            const r = exporter.records[i];
-            if (r.kind === 23 /* RecordKind.CompleteObject */)
-                table[2 * r.num + 1] = index + 1;
-        }
-        // Only this checker writes its logs and store; the result table's state publishes what it wrote.
-        this.used[2 * me] = offset + p.f.length;
-        this.used[2 * me + 1] = p.unitAt;
-        exporter.base += count;
-        exporter.records = [];
-        exporter.addedTypes.length = 0;
-        exporter.addedProperties.length = 0;
-        this.posted++;
-        this.storedRecords += count;
-        return postedState(this.data.count, me, offset + header);
     }
     /** The records this checker stored. */
     storedRecords = 0;
@@ -1518,8 +2215,8 @@ export class ThreadSharing {
     readers = [];
     /** The translation of `posted` into this checker, or undefined if it can't be taken here. */
     translatePosted(producer, posted, files, key, declarationFile) {
-        for (const fileName of posted.files)
-            if (fileName === '' || this.ownsFileNamed(fileName) || this.forbidsLastNamed(fileName))
+        for (const index of posted.files)
+            if (this.ownsIndex(index) || this.forbidsLast(index))
                 return undefined;
         const declarationIndex = this.c.fileIndex.get(declarationFile);
         if (declarationIndex !== undefined && this.forbidsLast(declarationIndex))
@@ -1530,17 +2227,25 @@ export class ThreadSharing {
             reader = new StoreReader(this, producer);
             this.readers[producer] = reader;
         }
-        const t = reader.translate(posted.root);
+        // The translation budget: building more records than the rule allows costs more than computing the result again,
+        // where `T` is the time the producer's computation took (`StoredResult.computeMs`). The walk stops at the bound
+        // before anything is built.
+        const t = reader.translate(posted.root, this.rule.buildBudget(posted.computeMs));
+        if (t === undefined && reader.stopped)
+            this.stoppedTranslations++;
         this.translationMs += performance.now() - start;
         if (t !== undefined) {
             this.translated++;
-            for (const fileName of posted.files)
-                this.forbidNamed(fileName);
+            // Translating the result saved the time its producer's computation took (`post`'s header).
+            this.addSaved(posted.computeMs);
+            for (const index of posted.files)
+                this.forbidIndex(index);
             if (posted.files.length > 0) {
                 files.set(key, posted.files);
                 this.noteFiles(posted.files);
             }
         }
+        this.writeStats();
         return t;
     }
 }
@@ -1548,9 +2253,12 @@ export class ThreadSharing {
 export class StoredResult {
     root;
     files;
-    constructor(root, files) {
+    /** How long computing the result took its producer, in milliseconds. */
+    computeMs;
+    constructor(root, files, computeMs = 0) {
         this.root = root;
         this.files = files;
+        this.computeMs = computeMs;
     }
 }
 function readText(strings, start, length) {
@@ -1559,23 +2267,25 @@ function readText(strings, start, length) {
         text += String.fromCharCode(strings[start + j]);
     return text;
 }
-/** Forgets the types and properties a failed export of a store gave indexes. */
-function forgetExport(exporter) {
+/** Forgets the types and properties a failed export of a store gave indexes, and its words. */
+function forgetExport(exporter, at, unitAt) {
     for (const t of exporter.addedTypes)
         exporter.indexes.delete(t);
     for (const prop of exporter.addedProperties)
         exporter.properties.delete(prop);
     exporter.addedTypes.length = 0;
     exporter.addedProperties.length = 0;
-    exporter.records = [];
+    exporter.count = 0;
     exporter.failure = undefined;
+    exporter.writer.at = at;
+    exporter.writer.unitAt = unitAt;
 }
 /**
  * Runs `compute` for the result keyed `key` in `table`, then exports and posts it if it can be shared and took long
  * enough, unless another checker posted it meanwhile. Nothing is written for the others before: a checker that finds
  * no result computes its own.
  */
-function computeAndPost(sharing, table, files, key, symbol, sig) {
+function computeAndPost(sharing, table, files, key, symbol, sig, declarationFile) {
     const t = sharing.computeShared(files, key, symbol, sig);
     const ms = sharing.lastMs;
     if (!sharing.lastShareable) {
@@ -1583,10 +2293,48 @@ function computeAndPost(sharing, table, files, key, symbol, sig) {
         sharing.notShareableMs += ms;
         return t;
     }
-    // A quick computation is cheaper to repeat than to export, post and translate.
-    if (ms < sharing.minMs) {
-        sharing.belowMin++;
-        sharing.belowMinMs += ms;
+    let diagnosticFiles;
+    if (sharing.bounded) {
+        // The main thread stopped sharing at its window (control 1 or 2): this result is the checker's own,
+        // and the others compute theirs, as they do when they find none posted.
+        if (Atomics.load(sharing.control, 0) !== 0) {
+            sharing.stopped++;
+            return t;
+        }
+        const index = sharing.c.fileIndex.get(declarationFile);
+        if (index === undefined)
+            return t;
+        // The rule priced this result: a quick computation is cheaper to repeat than to export, post and translate.
+        diagnosticFiles = files.get(key) ?? [];
+        if (!sharing.rule.posts(sharing, key, ms, diagnosticFiles, index)) {
+            sharing.belowMin++;
+            sharing.belowMinMs += ms;
+            return t;
+        }
+        // A result is posted only for a declaration whose file another checker that may take it missed on: a file only
+        // its own checkers read has nobody to take it.
+        if (!sharing.demanded(index)) {
+            sharing.notDemanded++;
+            return t;
+        }
+    }
+    else {
+        // Below the bounded count the run is Phase 1's, and takes the same path: the floor first, then the stop switch,
+        // and none of the bounded path's lookups (the file index and the diagnostics) is made.
+        if (ms < sharing.minMs) {
+            sharing.belowMin++;
+            sharing.belowMinMs += ms;
+            return t;
+        }
+        if (Atomics.load(sharing.control, 0) !== 0) {
+            sharing.stopped++;
+            return t;
+        }
+    }
+    // A result computed inside this checker's export walk doesn't have the store to itself: the walk would write over
+    // its records, so it stays with the checkers that compute it.
+    if (sharing.exporting) {
+        sharing.nested++;
         return t;
     }
     const slot = table.slot(key);
@@ -1594,17 +2342,22 @@ function computeAndPost(sharing, table, files, key, symbol, sig) {
         return t;
     const start = performance.now();
     // Diagnostics stay with this checker; the others only learn which files they are in.
-    const state = sharing.post(t, files.get(key) ?? []);
-    if (typeof state === 'string') {
+    const state = sharing.post(t, diagnosticFiles ?? files.get(key) ?? [], ms);
+    if (state === budgetFailure) {
+        sharing.overBudget++;
+        sharing.overBudgetMs += ms;
+    }
+    else if (typeof state === 'string') {
         sharing.exportFailed++;
         sharing.exportFailedMs += ms;
         sharing.exportFailures.set(state, (sharing.exportFailures.get(state) ?? 0) + ms);
     }
     else if (state === -1)
-        sharing.packFailed++;
+        sharing.storeFailed++;
     else
         table.publish(slot, state);
     sharing.exportMs += performance.now() - start;
+    sharing.writeStats();
     return t;
 }
 /** Shares the value type of `symbol` with the other checker threads, computing it with `compute` where needed. */
@@ -1635,27 +2388,34 @@ function threadTypeOfSymbolWorker(c, symbol) {
     }
     if (id > sharing.data.symbolIds)
         return sharing.tracked(sharing.typeFiles, id, symbol, undefined);
+    const declaration = symbol.valueDeclaration;
+    const file = getSourceFileOfNode(declaration);
+    // A declaration with a type annotation: computing its type resolves the annotation, and translating the records
+    // does too (`NodeType` resolves the node), so sharing saves nothing on it and costs a lookup. Below the bounded
+    // count the exclusion is off, as it is in Phase 1.
+    if (sharing.bounded && getType(declaration) !== undefined)
+        return sharing.tracked(sharing.typeFiles, id, symbol, undefined);
     const table = sharing.types;
-    if (!sharing.owns(getSourceFileOfNode(symbol.valueDeclaration))) {
-        const slot = table.find(id);
+    if (!sharing.owns(file)) {
+        // The stop switch is read before the table: a checker that stops translating computes the result itself.
+        const slot = sharing.stoppedTranslating() ? -1 : table.find(id);
         const state = slot < 0 ? 0 : table.state(slot);
         if (state <= -2 &&
             findResolutionCycleStartIndex(c, symbol, 0 /* TypeSystemPropertyName.Type */) < 0 &&
-            !translationBlocked(symbol.valueDeclaration)) {
+            !translationBlocked(declaration)) {
             const producer = postedProducer(sharing.data.count, state);
             const posted = sharing.result(producer, postedOffset(sharing.data.count, state));
-            const file = getSourceFileOfNode(symbol.valueDeclaration);
             if (shareVerifyValue === '1') {
                 const own = sharing.tracked(sharing.typeFiles, id, symbol, undefined);
-                verifyTranslation(c, 'types', symbol.valueDeclaration, own, sharing.translatePosted(producer, posted, sharing.typeFiles, id, file));
+                verifyTranslation(c, 'types', declaration, own, sharing.translatePosted(producer, posted, sharing.typeFiles, id, file));
                 return own;
             }
             const t = sharing.translatePosted(producer, posted, sharing.typeFiles, id, file);
             if (t !== undefined) {
-                traceTranslation(c, 'types', symbol.valueDeclaration, producer);
+                traceTranslation(c, 'types', declaration, producer);
                 if (sharing.depth === 1)
                     sharing.kind = 2;
-                sharing.forbid(getSourceFileOfNode(symbol.valueDeclaration));
+                sharing.forbid(file);
                 const again = c.symbolTypes.get(id);
                 if (again !== undefined)
                     return again;
@@ -1664,6 +2424,9 @@ function threadTypeOfSymbolWorker(c, symbol) {
             }
             sharing.sawDoneUnusable++;
         }
+        // This checker needed a result for one of the file's declarations and has none: the others post its results only
+        // then.
+        sharing.want(file);
         sharing.computedPrivately++;
         if (sharing.depth === 1)
             sharing.kind = 1;
@@ -1673,7 +2436,7 @@ function threadTypeOfSymbolWorker(c, symbol) {
         if (sharing.depth === 1)
             sharing.kind = 0;
     }
-    return computeAndPost(sharing, table, sharing.typeFiles, id, symbol, undefined);
+    return computeAndPost(sharing, table, sharing.typeFiles, id, symbol, undefined, file);
 }
 /** Notes that the computation in progress used the cached return type of `sig` (see `ThreadSharing.typeFiles`). */
 export function noteReturnTypeUse(c, sig) {
@@ -1703,16 +2466,21 @@ function threadReturnTypeWorker(c, sig) {
     const key = declaration.id;
     if (key > sharing.data.nodeIds)
         return sharing.tracked(sharing.returnFiles, key, undefined, sig);
+    const file = getSourceFileOfNode(declaration);
+    // A declaration with a return type annotation: computing the return type resolves the annotation, and translating
+    // the records does too, so sharing saves nothing on it and costs a lookup. Below the bounded count the exclusion is
+    // off, as it is in Phase 1.
+    if (sharing.bounded && getType(declaration) !== undefined)
+        return sharing.tracked(sharing.returnFiles, key, undefined, sig);
     const table = sharing.returns;
-    if (!sharing.owns(getSourceFileOfNode(declaration))) {
-        const slot = table.find(key);
+    if (!sharing.owns(file)) {
+        const slot = sharing.stoppedTranslating() ? -1 : table.find(key);
         const state = slot < 0 ? 0 : table.state(slot);
         if (state <= -2 &&
             findResolutionCycleStartIndex(c, sig, 3 /* TypeSystemPropertyName.ResolvedReturnType */) < 0 &&
             !translationBlocked(declaration)) {
             const producer = postedProducer(sharing.data.count, state);
             const posted = sharing.result(producer, postedOffset(sharing.data.count, state));
-            const file = getSourceFileOfNode(declaration);
             if (shareVerifyValue === '1') {
                 const own = sharing.tracked(sharing.returnFiles, key, undefined, sig);
                 verifyTranslation(c, 'returns', declaration, own, sharing.translatePosted(producer, posted, sharing.returnFiles, key, file));
@@ -1723,11 +2491,12 @@ function threadReturnTypeWorker(c, sig) {
                 traceTranslation(c, 'returns', declaration, producer);
                 if (sharing.depth === 1)
                     sharing.kind = 2;
-                sharing.forbid(getSourceFileOfNode(declaration));
+                sharing.forbid(file);
                 return t;
             }
             sharing.sawDoneUnusable++;
         }
+        sharing.want(file);
         sharing.computedPrivately++;
         if (sharing.depth === 1)
             sharing.kind = 1;
@@ -1737,7 +2506,7 @@ function threadReturnTypeWorker(c, sig) {
         if (sharing.depth === 1)
             sharing.kind = 0;
     }
-    return computeAndPost(sharing, table, sharing.returnFiles, key, undefined, sig);
+    return computeAndPost(sharing, table, sharing.returnFiles, key, undefined, sig, file);
 }
 // ---- Records in a checker's store
 //
@@ -1759,333 +2528,305 @@ function doubleWords() {
         doubleWordsValue = new DoubleWords();
     return doubleWordsValue;
 }
-/** Packs records into a checker's store: their numbers into `f`, their strings into its string log from `unitAt`. */
-class RecordPacker {
-    f = [];
-    fileIndex;
-    strings;
-    unitAt;
-    /** Set when the string log is full. */
-    full = false;
-    constructor(fileIndex, strings, unitAt) {
-        this.fileIndex = fileIndex;
-        this.strings = strings;
-        this.unitAt = unitAt;
+/** Collects the children of a node (`forEachChild`). */
+class ChildVisitor extends NodeVisitor {
+    children = [];
+    visitNode(node) {
+        this.children.push(node);
+        return false;
     }
-    text(t) {
-        if (this.unitAt + t.length > this.strings.length) {
-            this.full = true;
-            this.f.push(0, 0);
-            return;
-        }
-        this.f.push(this.unitAt, t.length);
-        for (let j = 0; j < t.length; j++)
-            this.strings[this.unitAt++] = t.charCodeAt(j);
+}
+/** The nodes of the program records name, by id, found by descending from their file through the nodes that contain them. */
+export class NodeFinder {
+    files;
+    nodesById;
+    visitor = undefined;
+    constructor(files, nodesById) {
+        this.files = files;
+        this.nodesById = nodesById;
     }
-    list(values) {
-        this.f.push(values.length);
-        for (const v of values)
-            this.f.push(v);
+    /** The node of file `fileIndex` with the range `pos`-`end` and id `id`; undefined if the program hasn't it. */
+    find(fileIndex, pos, end, id) {
+        const known = this.nodesById.get(id);
+        if (known !== undefined)
+            return known;
+        const file = this.files[fileIndex];
+        if (file === undefined)
+            return undefined;
+        let visitor = this.visitor;
+        if (visitor === undefined)
+            visitor = this.visitor = new ChildVisitor();
+        let node = file;
+        for (;;) {
+            if (node.id === id) {
+                if (node.pos !== pos || node.end !== end)
+                    return undefined;
+                this.nodesById.set(id, node);
+                return node;
+            }
+            visitor.children.length = 0;
+            node.forEachChild(visitor);
+            let next = undefined;
+            for (const child of visitor.children)
+                if (child.pos <= pos && end <= child.end) {
+                    // The innermost of nested nodes with one range is found by its id further down.
+                    if (child.id === id) {
+                        if (child.pos !== pos || child.end !== end)
+                            return undefined;
+                        this.nodesById.set(id, child);
+                        return child;
+                    }
+                    if (next === undefined)
+                        next = child;
+                }
+            if (next === undefined)
+                return undefined;
+            node = next;
+        }
     }
-    /** A double as the two int32 halves of its bits. */
-    double(v) {
-        const words = doubleWords();
-        words.f[0] = v;
-        this.f.push(words.i[0], words.i[1]);
+}
+/**
+ * Reads the records of a checker's store where it wrote them. `begin` starts a record at its offset in the number log
+ * and finds its parts without decoding its kind's fields: its refs, its alias, its symbol, its node, then the fields
+ * at `fields`.
+ */
+export class RecordReader {
+    numbers;
+    strings;
+    table;
+    finder;
+    /** The record in progress: its header and kind, and where its refs are. */
+    header = 0;
+    kind = 0;
+    refAt = 0;
+    refCount = 0;
+    /** Where its alias refs are, if it has an alias; -1 if none. */
+    aliasRefAt = -1;
+    aliasRefCount = 0;
+    /** How its alias is named: `SymbolNaming` and a merged symbol id, or a node at `aliasNodeStart`. */
+    aliasNaming = -1;
+    aliasMergedId = -1;
+    aliasNodeStart = -1;
+    /** How its symbol is named: the kind of naming, a merged symbol id, or a node at `symbolNodeStart`. */
+    symbolNaming = 0;
+    symbolMergedId = -1;
+    symbolNodeStart = -1;
+    /** Where its node is, if it has one; -1 if none. */
+    nodeStart = -1;
+    /** The offset of its kind's own fields. */
+    fields = 0;
+    /** The records a record names, filled by `scan`. */
+    deps = [];
+    constructor(numbers, strings, table, files, nodesById) {
+        this.numbers = numbers;
+        this.strings = strings;
+        this.table = table;
+        this.finder = new NodeFinder(files, nodesById);
     }
-    node(node) {
-        if (node === undefined) {
-            this.f.push(-1);
-            return true;
-        }
-        const file = getSourceFileOfNode(node);
-        const index = this.fileIndex.get(file);
-        if (index === undefined)
+    /** Starts the record at `index`; false if the store hasn't it. */
+    begin(index) {
+        if (index < 0 || index >= this.table.length)
             return false;
-        this.f.push(index, node.pos, node.end, node.kind, node.id);
-        return true;
-    }
-    nodes(list) {
-        this.f.push(list.length);
-        for (const node of list)
-            if (!this.node(node))
-                return false;
+        const start = this.table[index];
+        if (start <= 0)
+            return false;
+        const numbers = this.numbers;
+        const at = start - 1;
+        const header = numbers[at];
+        this.header = header;
+        this.kind = header & 31 /* RecordHeader.KindMask */;
+        let count = (header >>> 16) & RefCountMask;
+        this.refAt = at + 1;
+        if (count === 65535 /* RecordHeader.RefEscape */) {
+            count = numbers[this.refAt];
+            this.refAt++;
+        }
+        this.refCount = count;
+        this.locate();
         return true;
     }
-    /** A symbol of the program (by the node it is the symbol of, or the export symbol of), or none. */
-    symbol(symbol) {
-        if (symbol === undefined) {
-            this.f.push(-1);
-            return true;
+    /** Finds the record's alias refs, its symbol and its node, and the fields that follow them. */
+    locate() {
+        const numbers = this.numbers;
+        const header = this.header;
+        let p = this.refAt + this.refCount;
+        this.aliasNaming = -1;
+        this.aliasMergedId = -1;
+        this.aliasNodeStart = -1;
+        this.aliasRefAt = -1;
+        this.aliasRefCount = 0;
+        if ((header & 32 /* RecordHeader.HasAlias */) !== 0) {
+            if ((header & 1024 /* RecordHeader.AliasMerged */) !== 0) {
+                this.aliasNaming = 3 /* SymbolNaming.Merged */;
+                this.aliasMergedId = numbers[p++];
+            }
+            else {
+                this.aliasNaming = numbers[p] === 1 ? 2 /* SymbolNaming.Export */ : 1 /* SymbolNaming.Node */;
+                this.aliasNodeStart = p + 1;
+                p = this.aliasNodeStart + this.nodeWords(this.aliasNodeStart);
+            }
+            this.aliasRefCount = numbers[p];
+            this.aliasRefAt = p + 1;
+            p = this.aliasRefAt + this.aliasRefCount;
         }
-        const declaration = symbol.declaration;
-        if (declaration === undefined)
-            return false;
-        const local = getSymbol(declaration);
-        if (local === symbol)
-            this.f.push(0);
-        else if (local !== undefined && local.exportSymbol === symbol)
-            this.f.push(1);
-        else
-            return false;
-        return this.node(declaration);
+        const naming = (header & 192 /* RecordHeader.NamingMask */) >>> 6 /* RecordHeader.NamingShift */;
+        this.symbolNaming = naming;
+        this.symbolMergedId = -1;
+        this.symbolNodeStart = -1;
+        if (naming === 3 /* SymbolNaming.Merged */)
+            this.symbolMergedId = numbers[p++];
+        else if (naming !== 0 /* SymbolNaming.None */) {
+            this.symbolNodeStart = p;
+            p += this.nodeWords(p);
+        }
+        this.nodeStart = -1;
+        if ((header & 256 /* RecordHeader.HasNode */) !== 0) {
+            this.nodeStart = p;
+            p += this.nodeWords(p);
+        }
+        this.fields = p;
     }
-}
-/** Writes `r`; false if a node or symbol in it can't be named across threads. */
-function packRecord(p, r) {
-    p.f.push(r.kind, r.id, r.flags);
-    // A number literal's value is any double, written as its two halves.
-    if (r.kind === 1 /* RecordKind.Literal */)
-        p.double(r.num);
-    else
-        p.f.push(r.num);
-    p.f.push(r.mergedId, r.aliasMergedId);
-    p.text(r.text);
-    if (!p.symbol(r.symbol) || !p.node(r.node) || !p.symbol(r.aliasSymbol))
-        return false;
-    p.list(r.refs);
-    p.list(r.nums);
-    if (!p.nodes(r.nodes))
-        return false;
-    p.f.push(r.texts.length);
-    for (const t of r.texts)
-        p.text(t);
-    p.list(r.aliasRefs);
-    p.f.push(r.indexInfos.length);
-    for (const info of r.indexInfos) {
-        p.f.push(info.keyType, info.valueType, info.isReadonly ? 1 : 0);
-        if (!p.node(info.declaration) || !p.nodes(info.components))
-            return false;
+    /** The words a node at `p` takes: its file index, range and id, or one word for no node. */
+    nodeWords(p) {
+        return this.numbers[p] < 0 ? 1 : 4;
     }
-    return true;
-}
-/** Reads records from a checker's store. */
-class RecordUnpacker {
-    c;
-    f;
-    strings;
-    at = 0;
-    failed = false;
-    /** The nodes found so far, by id. */
-    nodesById;
-    constructor(c, numbers, strings, nodesById) {
-        this.c = c;
-        this.f = numbers;
-        this.strings = strings;
-        this.nodesById = nodesById;
+    /** The node at `p`; undefined if it is none or the program hasn't it. */
+    readNode(p) {
+        if (p < 0 || this.numbers[p] < 0)
+            return undefined;
+        const numbers = this.numbers;
+        return this.finder.find(numbers[p], numbers[p + 1], numbers[p + 2], numbers[p + 3]);
     }
-    next() {
-        return this.f[this.at++];
+    /** The record's own node; undefined if it has none or the program hasn't it. */
+    node() {
+        return this.readNode(this.nodeStart);
     }
-    double() {
+    doubleAt(p) {
         const words = doubleWords();
-        words.i[0] = this.next();
-        words.i[1] = this.next();
+        words.i[0] = this.numbers[p];
+        words.i[1] = this.numbers[p + 1];
         return words.f[0];
     }
-    text() {
-        const start = this.next();
-        const length = this.next();
-        return readText(this.strings, start, length);
+    textAt(p) {
+        return readText(this.strings, this.numbers[p], this.numbers[p + 1]);
     }
-    list() {
-        const n = this.next();
-        const values = [];
-        for (let i = 0; i < n; i++)
-            values.push(this.next());
-        return values;
-    }
-    node() {
-        const fileIndex = this.next();
-        if (fileIndex < 0)
-            return undefined;
-        const pos = this.next();
-        const end = this.next();
-        const kind = this.next();
-        const id = this.next();
-        let node = this.nodesById.get(id);
-        if (node === undefined) {
-            const file = this.c.files[fileIndex];
-            node = file === undefined ? undefined : findNode(file, pos, end, kind, id);
-            if (node === undefined) {
-                this.failed = true;
-                return undefined;
+    /**
+     * Collects in `deps` the indexes of the records the record in progress needs: its refs, its alias refs, and the
+     * types of its own fields that are records (a union's origin, an object literal's completion, a completed object's
+     * members' types). A record is written before the records it needs.
+     */
+    scan() {
+        const numbers = this.numbers;
+        const deps = this.deps;
+        deps.length = 0;
+        for (let i = 0; i < this.refCount; i++)
+            deps.push(numbers[this.refAt + i]);
+        for (let i = 0; i < this.aliasRefCount; i++)
+            deps.push(numbers[this.aliasRefAt + i]);
+        let p = this.fields;
+        switch (this.kind) {
+            case 12 /* RecordKind.Union */:
+            case 22 /* RecordKind.AnonymousObject */:
+                // The origin of a union, and the completion of an object literal.
+                deps.push(numbers[p + 1]);
+                break;
+            case 23 /* RecordKind.CompleteObject */: {
+                // The object literal completed, then each index signature's key and value types.
+                deps.push(numbers[p]);
+                const count = numbers[p + 1];
+                let q = p + 2;
+                for (let i = 0; i < count; i++) {
+                    deps.push(numbers[q], numbers[q + 1]);
+                    q += 3;
+                    q += this.nodeWords(q);
+                    const components = numbers[q++];
+                    for (let j = 0; j < components; j++)
+                        q += this.nodeWords(q);
+                }
+                break;
             }
-            this.nodesById.set(id, node);
         }
-        return node;
-    }
-    nodes() {
-        const n = this.next();
-        const list = [];
-        for (let i = 0; i < n; i++)
-            list.push(this.node());
-        return list;
-    }
-    symbol() {
-        const how = this.next();
-        if (how < 0)
-            return undefined;
-        const node = this.node();
-        if (node === undefined)
-            return undefined;
-        const local = getSymbol(node);
-        const symbol = how === 0 ? local : local?.exportSymbol;
-        if (symbol === undefined)
-            this.failed = true;
-        return symbol;
-    }
-}
-/** Reads a record; undefined if a node or symbol in it isn't in `u`'s program. */
-function unpackRecord(u) {
-    const kind = u.next();
-    const id = u.next();
-    const flags = u.next();
-    const num = kind === 1 /* RecordKind.Literal */ ? u.double() : u.next();
-    const mergedId = u.next();
-    const aliasMergedId = u.next();
-    const text = u.text();
-    const symbol = u.symbol();
-    const node = u.node();
-    const aliasSymbol = u.symbol();
-    const refs = u.list();
-    const record = new PortableRecord(kind, id, flags, num, text, symbol, node, refs);
-    record.mergedId = mergedId;
-    record.aliasMergedId = aliasMergedId;
-    record.aliasSymbol = aliasSymbol;
-    record.nums = u.list();
-    record.nodes = u.nodes();
-    const textCount = u.next();
-    const texts = [];
-    for (let k = 0; k < textCount; k++)
-        texts.push(u.text());
-    record.texts = texts;
-    record.aliasRefs = u.list();
-    const infoCount = u.next();
-    const infos = [];
-    for (let k = 0; k < infoCount; k++) {
-        const keyType = u.next();
-        const valueType = u.next();
-        const isReadonly = u.next() === 1;
-        const declaration = u.node();
-        const components = u.nodes();
-        infos.push(new PortableIndexInfo(keyType, valueType, isReadonly, declaration, components));
-    }
-    record.indexInfos = infos;
-    return u.failed ? undefined : record;
-}
-/** Collects the children of a node (`forEachChild`). */
-class ChildCollector extends NodeVisitor {
-    children = [];
-    visitNode(node) {
-        this.children.push(node);
-        return false;
-    }
-}
-/** The node of `file` with the range, kind and id given, found by descending through the nodes that contain it. */
-function findNode(file, pos, end, kind, id) {
-    let node = file;
-    for (;;) {
-        if (node.id === id)
-            return node.kind === kind && node.pos === pos && node.end === end ? node : undefined;
-        const collector = new ChildCollector();
-        node.forEachChild(collector);
-        let next = undefined;
-        for (const child of collector.children)
-            if (child.pos <= pos && end <= child.end) {
-                // The innermost of nested nodes with one range is found by its id further down.
-                if (child.id === id)
-                    return child.kind === kind && child.pos === pos && child.end === end ? child : undefined;
-                if (next === undefined)
-                    next = child;
-            }
-        if (next === undefined)
-            return undefined;
-        node = next;
     }
 }
+/** The bits of a record header that hold the number of refs, or `RefEscape` if the number is a word of its own. */
+const RefCountMask = 0xffff;
 /**
- * A consumer's translations of another checker's store: each record is read and translated once, when a result
- * first needs it, in the order of the store, which is the order the producer exported them in.
+ * A consumer's translations of another checker's store: each record is read where it is, and translated once, when a
+ * result first needs it, in the order of the store, which is the order the producer exported them in.
  */
 class StoreReader {
     sharing;
     producer;
     translator;
-    table;
-    unpacker;
-    /** By record: the record, its translation and whether it is translated. */
-    records = [];
-    types = [];
-    symbols = [];
-    built = [];
+    reader;
+    /** Whether the last `translate` stopped at its budget, having built nothing. */
+    stopped = false;
+    /** By record: the type it translated to, the symbol a property record makes, and whether a completion is done. */
+    types = new LinkTable();
+    symbols = new LinkTable();
+    completed = new LinkTable();
     constructor(sharing, producer) {
         this.sharing = sharing;
         this.producer = producer;
-        this.translator = new Translator(sharing.c);
-        this.table = sharing.recordTables[producer];
-        this.unpacker = new RecordUnpacker(sharing.c, sharing.numberLogs[producer], sharing.stringLogs[producer], sharing.nodesById);
+        this.translator = new Translator(sharing.c, this);
+        this.reader = new RecordReader(sharing.numberLogs[producer], sharing.stringLogs[producer], sharing.recordTables[producer], sharing.c.files, sharing.nodesById);
     }
-    ensure(index) {
-        const placeholder = this.sharing.c.errorType;
-        while (this.types.length <= index) {
-            this.types.push(placeholder);
-            this.symbols.push(undefined);
-            this.records.push(undefined);
-            this.built.push(0);
-        }
+    /**
+     * Whether record `index` is translated: a property record made its symbol, an object literal got its members, a
+     * shell whose members come later only counts with them. A translation that fails after it built a shell leaves
+     * the empty type behind, and a later translation of the shell alone would take it for the object.
+     */
+    isBuilt(index) {
+        if (!this.reader.begin(index))
+            return false;
+        const kind = this.reader.kind;
+        if (kind === 24 /* RecordKind.Property */)
+            return this.symbols.get(index) !== undefined;
+        if (kind === 23 /* RecordKind.CompleteObject */)
+            return this.completed.get(index) !== undefined;
+        if (this.types.get(index) === undefined)
+            return false;
+        if (kind !== 22 /* RecordKind.AnonymousObject */)
+            return true;
+        const completion = this.reader.numbers[this.reader.fields + 1];
+        return completion < 0 || this.completed.get(completion) !== undefined;
     }
-    /** Record `index`, read on first use; undefined if a node or symbol in it isn't in this program. */
-    record(index) {
-        this.ensure(index);
-        const known = this.records[index];
-        if (known !== undefined)
-            return known;
-        const u = this.unpacker;
-        u.at = this.table[2 * index] - 1;
-        u.failed = false;
-        const start = performance.now();
-        const record = unpackRecord(u);
-        this.sharing.unpackMs += performance.now() - start;
-        if (record !== undefined)
-            this.records[index] = record;
-        return record;
-    }
-    /** The translation of record `root` and the records it needs; undefined if one can't be translated here. */
-    translate(root) {
+    /** Whether the record in progress names only merged symbols this program has. */
+    present(reader) {
+        const merged = this.sharing.c.mergedSymbols;
+        if (reader.aliasNaming === 3 /* SymbolNaming.Merged */ && !merged.has(reader.aliasMergedId))
+            return false;
+        return reader.symbolNaming !== 3 /* SymbolNaming.Merged */ || merged.has(reader.symbolMergedId);
+    }
+    /**
+     * The translation of record `root` and the records it needs; undefined if one can't be translated here, or if the
+     * records it would build pass `budget`.
+     */
+    translate(root, budget = Number.POSITIVE_INFINITY) {
         const c = this.sharing.c;
         const translator = this.translator;
+        const reader = this.reader;
+        translator.failed = false;
         const needed = new Set();
         const stack = [root];
+        this.stopped = false;
         while (stack.length > 0) {
             const i = stack.pop();
-            if (needed.has(i))
-                continue;
-            this.ensure(i);
-            if (this.built[i] === 1)
+            if (needed.has(i) || this.isBuilt(i))
                 continue;
-            const r = this.record(i);
-            if (r === undefined)
+            if (needed.size >= budget) {
+                this.stopped = true;
                 return undefined;
-            if ((r.mergedId >= 0 && !c.mergedSymbols.has(r.mergedId)) ||
-                (r.aliasMergedId >= 0 && !c.mergedSymbols.has(r.aliasMergedId)))
+            }
+            if (!reader.begin(i) || !this.present(reader))
                 return undefined;
             needed.add(i);
-            for (const j of r.refs)
+            reader.scan();
+            const deps = reader.deps;
+            for (let k = 0; k < deps.length; k++) {
+                const j = deps[k];
                 if (j >= 0)
                     stack.push(j);
-            for (const j of r.aliasRefs)
-                stack.push(j);
-            if (r.kind === 23 /* RecordKind.CompleteObject */ || (r.kind === 12 /* RecordKind.Union */ && r.num >= 0))
-                stack.push(r.num);
-            for (const info of r.indexInfos) {
-                stack.push(info.keyType);
-                stack.push(info.valueType);
-            }
-            if (r.kind === 22 /* RecordKind.AnonymousObject */) {
-                const completion = this.table[2 * i + 1] - 1;
-                if (completion >= 0)
-                    stack.push(completion);
             }
         }
         const order = [...needed].sort((a, b) => a - b);
@@ -2093,36 +2834,72 @@ class StoreReader {
         // record is translated. A translation can start translations of this store again (resolving a type alias, or
         // a type of a symbol), which translate some of these records first.
         for (const i of order) {
-            if (this.built[i] === 1)
+            if (this.isBuilt(i))
                 continue;
-            const r = this.records[i];
-            if (r.kind === 8 /* RecordKind.NodeType */ ||
-                r.kind === 16 /* RecordKind.Conditional */ ||
-                r.kind === 21 /* RecordKind.DistributedConditional */)
-                translator.aliasOfNode(r.node);
+            reader.begin(i);
+            const kind = reader.kind;
+            if (kind !== 8 /* RecordKind.NodeType */ && kind !== 16 /* RecordKind.Conditional */ && kind !== 21 /* RecordKind.DistributedConditional */)
+                continue;
+            const node = reader.node();
+            if (node === undefined)
+                return undefined;
+            translator.aliasOfNode(node);
         }
         if (translator.failed) {
             translator.failed = false;
             return undefined;
         }
+        const verifyOrder = shareVerifyValue === '2';
+        let lastNew = -1;
         for (const i of order) {
-            if (this.built[i] === 1)
+            if (this.isBuilt(i))
                 continue;
-            const r = this.records[i];
-            if (r.kind === 24 /* RecordKind.Property */)
-                this.symbols[i] = translator.property(r, this.types, this.symbols);
-            else if (r.kind === 23 /* RecordKind.CompleteObject */)
-                translator.complete(r, this.types, this.symbols);
-            else
-                this.types[i] = translator.record(r, this.types);
-            if (translator.failed) {
-                translator.failed = false;
-                return undefined;
+            reader.begin(i);
+            const before = verifyOrder ? c.typeCount : 0;
+            switch (reader.kind) {
+                case 24 /* RecordKind.Property */: {
+                    const symbol = translator.property(i);
+                    if (symbol === undefined) {
+                        translator.failed = false;
+                        return undefined;
+                    }
+                    this.symbols.set(i, symbol);
+                    continue;
+                }
+                case 23 /* RecordKind.CompleteObject */:
+                    if (!translator.complete(i)) {
+                        translator.failed = false;
+                        return undefined;
+                    }
+                    this.completed.set(i, true);
+                    continue;
+                default: {
+                    const t = translator.record(i);
+                    if (t === undefined) {
+                        translator.failed = false;
+                        return undefined;
+                    }
+                    this.types.set(i, t);
+                    // The types a translation creates, record by record, are created in the order the producer created them.
+                    if (verifyOrder && c.typeCount > before) {
+                        if (before < lastNew) {
+                            const violations = ++this.sharing.orderViolations;
+                            if (violations <= 20)
+                                process.stderr.write('share-verify: checker ' +
+                                    this.sharing.data.index +
+                                    ' record ' +
+                                    i +
+                                    ' created type ' +
+                                    c.typeCount +
+                                    ' after ' +
+                                    lastNew +
+                                    '\n');
+                        }
+                        lastNew = c.typeCount;
+                    }
+                }
             }
-            this.built[i] = 1;
-            // A translated record is not read again.
-            this.records[i] = undefined;
         }
-        return this.types[root];
+        return this.types.get(root);
     }
 }