tsc-ts 0.1.0 → 0.1.1

package/dist/api/compiler/shared-results.d.ts

@@ -1,11 +1,12 @@
 import { type Node, type SourceFile } from './ast.js';
 import type { Checker } from './checker.js';
-import { ConditionalType, LiteralType, ObjectType, TupleType, Type, TypeAlias, UnionType, Signature } from './checker-types.js';
+import { Type, Signature } from './checker-types.js';
 import { type Symbol } from './symbol.js';
+import { LinkTable } from './link-tables.js';
 declare const enum RecordKind {
-    /** A type the checker creates when it starts: `num` is its position in `initialTypes`. */
+    /** A type the checker creates when it starts: its position in `initialTypes`. */
     Initial = 0,
-    /** A regular literal type: `flags`, `text` or `num`. */
+    /** A regular literal type: its flags, then its value as a double or its text. */
     Literal = 1,
     /** The fresh type of the literal type `refs[0]`. */
     FreshLiteral = 2,
@@ -23,24 +24,24 @@ declare const enum RecordKind {
     NodeType = 8,
     /** A reference to the generic type `refs[0]` with the type arguments `refs[1..]`. */
     Reference = 9,
-    /** The tuple target with the element flags `nums`, labeled by `nodes`, readonly when `num` is 1. */
+    /** The tuple target: readonly, then the element flags and label nodes. */
     TupleTarget = 10,
     /**
-     * The instantiation of the anonymous, mapped or deferred reference type `refs[0]` with the `num` outer type arguments
-     * after it, then the return types its signatures had resolved (built after it).
+     * The instantiation of the anonymous, mapped or deferred reference type `refs[0]` with the outer type arguments
+     * after it, then the return types its signatures had resolved (built after it); the node declares it.
      */
     Instantiation = 11,
-    /** A union of `refs`, with the origin `num` (a record index, or -1). */
+    /** A union of `refs` with the origin record, or -1. */
     Union = 12,
     /** An intersection of `refs`. */
     Intersection = 13,
-    /** `keyof refs[0]` with the index flags `num`. */
+    /** `keyof refs[0]` with the index flags. */
     Index = 14,
-    /** `refs[0][refs[1]]` with the access flags `num`. */
+    /** `refs[0][refs[1]]` with the access flags. */
     IndexedAccess = 15,
-    /** The instantiation of the conditional type of `node` with outer type arguments `refs`, for constraints when `num` is 1. */
+    /** The instantiation of the conditional type of `node` with outer type arguments `refs`, for constraints when the tag is 1. */
     Conditional = 16,
-    /** A template literal type of `texts` and `refs`. */
+    /** A template literal type of its texts and `refs`. */
     Template = 17,
     /** The string mapping `symbol` of `refs[0]`. */
     StringMapping = 18,
@@ -50,57 +51,54 @@ declare const enum RecordKind {
     NoInfer = 20,
     /**
      * The member for the constituent `refs[last]` of the distribution of the conditional type of `node` instantiated
-     * with outer type arguments `refs[0..last)`, for constraints when `num` is 1.
+     * with outer type arguments `refs[0..last)`, for constraints when the tag is 1.
      */
     DistributedConditional = 21,
     /**
      * An anonymous object type of the object literal `symbol` with members resolved when it was created (an object
-     * literal type, or its regular, widened or spread form), with the object flags `flags`. Its members come with the
-     * `CompleteObject` record that follows them.
+     * literal type, or its regular, widened or spread form): its object flags, then the record of its members.
      */
     AnonymousObject = 22,
-    /** The members of the `AnonymousObject` record `num`: the properties `refs` and the index infos `indexInfos`. */
+    /** The members of the `AnonymousObject` record whose index is written first: the properties `refs` and index infos. */
     CompleteObject = 23,
     /**
-     * A property symbol a checker created (`text` its name, `flags` its symbol flags, `num` its check flags): its
-     * declarations `nodes`, value declaration `node`, type `refs[0]`, name type `refs[1]` (or -1), the symbol it was
-     * made from `refs[2]` (a property record, or -1 for `symbol`, a symbol of the program) and its parent `aliasSymbol`.
+     * A property symbol a checker created: its symbol flags, check flags and name, its declarations, its type
+     * `refs[0]`, name type `refs[1]` (or -1), the symbol it was made from `refs[2]` (a property record, or -1 for the
+     * symbol of the program written with it) and its parent (its alias).
      */
     Property = 24
 }
-/** An index signature of an `AnonymousObject` record. */
-export declare class PortableIndexInfo {
-    readonly keyType: number;
-    readonly valueType: number;
-    readonly isReadonly: boolean;
-    readonly declaration: Node | undefined;
-    readonly components: readonly Node[];
-    constructor(keyType: number, valueType: number, isReadonly: boolean, declaration: Node | undefined, components: readonly Node[]);
-}
-export declare class PortableRecord {
-    readonly kind: RecordKind;
-    readonly flags: number;
-    readonly num: number;
-    readonly text: string;
-    symbol: Symbol | undefined;
-    readonly node: Node | undefined;
-    readonly refs: readonly number[];
-    nums: readonly number[];
-    nodes: readonly (Node | undefined)[];
-    texts: readonly string[];
-    /** For a symbol a checker merged: the id of a symbol it merged, which keys every checker's merged symbol. */
-    mergedId: number;
-    /** The alias: its symbol and the records of its type arguments. */
-    aliasSymbol: Symbol | undefined;
-    aliasMergedId: number;
-    aliasRefs: readonly number[];
-    indexInfos: readonly PortableIndexInfo[];
-    /** The producer's type id, which keys the consumer's translations of the producer's types. */
-    readonly id: number;
-    constructor(kind: RecordKind, id: number, flags: number, num: number, text: string, symbol: Symbol | undefined, node: Node | undefined, refs: readonly number[]);
+/**
+ * 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 declare class StoreWriter {
+    readonly numbers: Int32Array;
+    readonly strings: Uint16Array;
+    readonly table: Int32Array;
+    readonly fileIndex: Map<SourceFile, number>;
+    /** The cursor in the number log, and in the string log. */
+    at: number;
+    unitAt: number;
+    /** Set when a record or a field didn't fit the store's configured capacity. */
+    full: boolean;
+    constructor(numbers: Int32Array, strings: Uint16Array, table: Int32Array, fileIndex: Map<SourceFile, number>);
+    /** Returns to the cursors `at` and `unitAt`. */
+    reset(at: number, unitAt: number): void;
+    /** Starts record `index` at the cursor: its header, and its offset in the record table. */
+    beginRecord(index: number, header: number): void;
+    word(value: number): void;
+    /** A double as the two int32 halves of its bits. */
+    double(value: number): void;
+    /** A string as its offset and length in the string log. */
+    text(value: string): void;
+    /** A node as its file, range and id, or -1 for none. The file must be one `fileIndex` has. */
+    node(node: Node | undefined): void;
 }
 /** The types every checker creates when it starts, in the same order; marker types are left out. */
 export declare function initialTypes(c: Checker): Type[];
+/** The reason an export stops at its budget (`Exporter.limit`), which `post` returns: the result is not posted. */
+export declare const budgetFailure = "export budget";
 /** A checker's `Exporter.mergedOrigins`, kept while its merged symbols stay the same. */
 export declare class MergedOrigins {
     origins: Map<Symbol, number>;
@@ -109,98 +107,144 @@ export declare class MergedOrigins {
 /** Writes a result as records; `failure` names the first part that has no record kind. */
 export declare class Exporter {
     readonly c: Checker;
-    records: PortableRecord[];
-    readonly indexes: Map<Type, number>;
+    readonly writer: StoreWriter;
     /**
-     * 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: number;
+    /** The number of records the export in progress wrote. */
+    count: number;
+    /** The record of each type, by type id, and of each property symbol, by symbol id. */
+    readonly indexes: Map<number, number>;
+    readonly properties: Map<number, number>;
     /** The types and properties the export in progress gave indexes, which a failed export forgets again. */
-    readonly addedTypes: Type[];
-    readonly addedProperties: Symbol[];
-    /** Appends `record`; its index. */
-    push(record: PortableRecord): number;
-    readonly initial: Map<Type, number>;
+    readonly addedTypes: number[];
+    readonly addedProperties: number[];
+    /**
+     * 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;
+    readonly initial: Map<number, number>;
     failure: string | undefined;
     /** The ids above which nodes and symbols are the checker thread's own (lazily parsed JSDoc), or Infinity. */
     nodeLimit: number;
     symbolLimit: number;
-    constructor(c: Checker, initial: Map<Type, number>);
-    /** Whether `node` is one every checker shares; fails if not. */
-    sharedNode(node: Node | undefined): boolean;
     /** The ids of the symbols each merged symbol merged (`getMergedSymbol`), built on first use. */
     mergedOrigins: Map<Symbol, number> | undefined;
     /** Where the checker keeps `mergedOrigins` between exports. */
     originsCache: MergedOrigins | undefined;
+    /** How the record in progress names its symbol and its alias, and the node it carries. */
+    private naming;
+    private namingMerged;
+    private namingNode;
+    private aliasNaming;
+    private aliasMerged;
+    private aliasNode;
+    private aliasRefs;
+    private node;
+    constructor(c: Checker, initial: Map<number, number>, writer: StoreWriter);
+    fail(reason: string): number;
+    /** Whether `node` is one every checker shares, and can name; fails if not. */
+    sharedNode(node: Node | undefined): boolean;
     /**
-     * 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: PortableRecord, symbol: Symbol, alias: boolean): boolean;
-    /** `new PortableRecord` with the symbol `symbol` (see `symbolOf`); undefined if it is the checker's own. */
-    withSymbol(kind: RecordKind, t: Type, symbol: Symbol, num: number, refs: readonly number[]): PortableRecord | undefined;
-    addWithSymbol(kind: RecordKind, t: Type, symbol: Symbol, num: number, refs: readonly number[]): number;
-    fail(reason: string): number;
-    add(t: Type, record: PortableRecord): number;
+    nextIndex(): number;
+    /** Records the type `t` at `index`. */
+    private memo;
+    /**
+     * 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: Symbol | undefined, alias: boolean): boolean;
+    /** The ids of the symbols each merged symbol merged, from the checker's `mergedSymbols`. */
+    private buildOrigins;
+    /**
+     * 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.
+     */
+    private aliasBits;
+    /**
+     * 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: RecordKind, index: number, refs: readonly number[], bits: number): void;
+    /** The record of `t` of `kind`, with `refs` and no fields of its own; its index. */
+    private plain;
+    /** The record of the initial type `t`, which is `num`th in `initialTypes`. */
+    private initialType;
+    /** The record of the type `t` of `kind` named by `symbol`, with `refs`; its index. */
+    private symbolType;
+    /** The record of the type `t` of the type node `node`; its index. */
+    private nodeType;
     types(list: readonly Type[]): number[];
-    aliasOf(record: PortableRecord, alias: TypeAlias | undefined): PortableRecord;
     type(t: Type): number;
-    literal(t: LiteralType): number;
-    union(t: UnionType): number;
-    object(t: ObjectType): number;
+    private literal;
+    /** The record of the constituents of a union's or intersection's origin, which is not a type: it has no alias. */
+    private originRecord;
+    private union;
+    private intersection;
+    private object;
     /** An object literal type, or one made from one, with its properties and index infos. */
-    anonymousObject(t: ObjectType): number;
-    /** The records of property symbols, by symbol. */
-    readonly properties: Map<Symbol, number>;
+    private anonymousObject;
     /** A property symbol of an object literal type: a checker's own, made from one of the program or from another. */
-    property(prop: Symbol): number;
-    tupleTarget(t: TupleType): number;
+    private property;
+    private tupleTarget;
     /** An instantiated anonymous or mapped type, or a deferred type reference: its target and outer type arguments. */
-    instantiation(t: ObjectType): number;
+    private instantiation;
     /**
      * Adds to `refs` the return types the checker resolved for the signatures of the instantiation `t`, exported after
      * it. The consumer then creates them right after `t` and before the types that contain it, as this checker did:
      * inference stops at references whose type ids grow along its stack (`isDeeplyNestedType`), so a consumer that
      * created them later, when it resolved them, could stop an inference this checker made.
      */
-    resolvedReturnTypes(t: ObjectType, refs: number[]): void;
+    private resolvedReturnTypes;
     /**
      * The record of `t`, or -1 if it can't be exported; that leaves the export in progress as it was. An export that
      * failed before stays failed.
      */
     optionalType(t: Type): number;
-    conditional(t: ConditionalType): number;
+    /**
+     * 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.
+     */
+    private conditional;
 }
-/** Translates records into a checker's own types; one translation per producer type. */
+/** Translates the records of another checker's store into this checker's types, reading them where they are. */
 export declare class Translator {
     readonly c: Checker;
-    readonly translated: Map<number, Type>;
+    readonly store: StoreReader;
     readonly initial: Type[];
     /** Set when a record has no counterpart here; the translation is then abandoned. */
     failed: boolean;
-    constructor(c: Checker);
-    /** A property symbol made as the producer made it. */
-    property(r: PortableRecord, types: Type[], symbols: (Symbol | undefined)[]): Symbol;
-    /** Sets the members of the `AnonymousObject` record a `CompleteObject` record completes. */
-    complete(r: PortableRecord, types: Type[], symbols: (Symbol | undefined)[]): void;
-    record(r: PortableRecord, types: Type[]): Type;
+    constructor(c: Checker, store: StoreReader);
+    /**
+     * 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.
+     */
+    private namedSymbol;
+    /** Abandons the record being read: the translation fails, and a later one starts afresh. */
+    private abandon;
+    /** A property symbol made as the producer made it; undefined if its record can't be read here. */
+    property(index: number): Symbol | undefined;
+    /** Sets the members of the `AnonymousObject` record a `CompleteObject` record completes; false if it can't read it. */
+    complete(index: number): boolean;
     /**
      * Resolves the declared type of the type alias whose declaration contains the type node `node`, as resolving its
      * nodes through the alias does: that records the alias's type parameters, which its variances are measured with.
      * Sets `failed` if the alias's declared type is being resolved here.
      */
     aliasOfNode(node: Node): void;
-    alias(r: PortableRecord, types: Type[]): TypeAlias | undefined;
-    symbol(r: PortableRecord): Symbol;
-    build(r: PortableRecord, types: Type[]): Type;
+    /** The type record `index`; undefined if it or a record it needs can't be translated here. */
+    record(index: number): Type | undefined;
 }
 /** Whether the type of `symbol` is shared: a variable or property declared in the program, other than parameters. */
 export declare function isSharedValueSymbol(symbol: Symbol): boolean;
 /** Whether the return type of `sig` is shared: the signature of a declaration, as `getSignatureFromDeclaration` makes it. */
 export declare function isSharedReturnSignature(c: Checker, sig: Signature): boolean;
-/** Whether checker threads share results (TSC_TS_SHARE=1). */
-export declare const shareThreads: boolean;
 /**
  * What a checker thread needs to share results with the others; posted in its `workerData` (a plain object: class
  * instances arrive without their class).
@@ -208,6 +252,11 @@ export declare const shareThreads: boolean;
 export interface ThreadSharingData {
     readonly index: number;
     readonly count: number;
+    /**
+     * Whether this run's posts are cost-bounded (`RunConfig.bounded`): it posts only results another checker demanded
+     * and its takes build a bounded number of records. A run with it off keeps Phase 1's rule.
+     */
+    readonly bounded: boolean;
     /**
      * For each file, by file index: -2 if no checker checks it, -1 if checkers check it in statement ranges, 0 until a
      * checker takes it, and 1 + k once checker k took it.
@@ -218,6 +267,12 @@ export interface ThreadSharingData {
      * checker took the file: they never check it, and hand its positions on (`handoff`).
      */
     readonly forbidden: SharedArrayBuffer;
+    /**
+     * For each file, by file index, the checkers (one bit each, the same shape as `forbidden`) that looked for a result
+     * for one of its declarations and found none. A checker posts a result only for a declaration whose file one of
+     * them reads (`ThreadSharing.demanded`).
+     */
+    readonly wanted: SharedArrayBuffer;
     /**
      * Positions of the order a checker handed on: a lock, their number, the number of checkers that may still hand
      * positions on, then the positions.
@@ -230,16 +285,43 @@ export interface ThreadSharingData {
     readonly symbolIds: number;
     /**
      * Each checker's store of the records of the results it shares, by checker index: their numbers, and the code units
-     * of their strings. `used` has two counters per checker, how much of each it wrote. (Results go through shared
-     * memory: a message a worker receives synchronously makes the native build store the number fields of classes as
-     * doubles.)
+     * of their strings. `used` has two counters per checker, `usedStride` int32s apart, how much of each it wrote; a
+     * checker keeps its cursors in its own writer and writes them there only for the summary. (Results go through
+     * shared memory: a message a worker receives synchronously makes the native build store the number fields of
+     * classes as doubles.)
      */
     readonly numberLogs: SharedArrayBuffer[];
     readonly stringLogs: SharedArrayBuffer[];
     readonly used: SharedArrayBuffer;
-    /** For each checker, where each record of its store is in its number log, and each object's completion. */
+    /** For each checker, where each record of its store is in its number log: a word per record. */
     readonly recordTables: SharedArrayBuffer[];
+    /**
+     * One int32, read by every checker before it posts or translates a result: 0 runs, 1 stops posting, 2
+     * stops posting and translating. The main thread sets it (`startParallelCheck`'s window) when the
+     * results are not worth what they cost; every switch keeps the diagnostics the same, because a
+     * checker that does not take a posted result computes it itself.
+     */
+    readonly control: SharedArrayBuffer;
+    /**
+     * One row of `shareStatColumns` doubles per checker, for the counters the main thread reads while
+     * checking runs (`ThreadSharing.writeStats`).
+     */
+    readonly stats: SharedArrayBuffer;
 }
+/**
+ * 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 declare const shareStatColumns = 10;
+export declare const shareStatKinds = 4;
+export declare const shareStatExport = 4;
+export declare const shareStatTranslation = 5;
+export declare const shareStatUnpack = 6;
+export declare const shareStatPosted = 7;
+export declare const shareStatTranslated = 8;
+export declare 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.
@@ -248,6 +330,8 @@ export declare const numberLogSize: number;
 export declare const stringLogSize: number;
 /** The number of records each checker's store can hold. */
 export declare const recordTableSize: number;
+/** The int32s each checker gets in `ThreadSharingData.used`, a cache line each, for two counters. */
+export declare const usedStride = 16;
 /** The number of entries of each result table: a power of two. */
 export declare const resultTableSize: number;
 /**
@@ -265,6 +349,8 @@ export declare function postedOffset(count: number, state: number): number;
 export declare function forbiddenWords(count: number): number;
 /** Whether checker `index` of `count` took results for declarations of file `file` before any checker took it. */
 export declare function isForbidden(forbidden: Int32Array, count: number, file: number, index: number): boolean;
+/** Whether checker `index` of `count` looked for a result for a declaration of file `file` and found none (`wanted`). */
+export declare function isWanted(wanted: Int32Array, count: number, file: number, index: number): boolean;
 /**
  * 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`.
@@ -280,6 +366,36 @@ export declare class ResultTable {
     /** Sets the state of `slot` to a posted result's unless one is there already. */
     publish(slot: number, state: number): void;
 }
+/**
+ * The rule that decides whether a checker posts a result it computed, and how much a consumer may build to take one.
+ * The conditions that keep a take exact (the result's diagnostics, `forbidsLast`, the resolution stack) are checked
+ * by the callers, as are the stop switch and the demand bits.
+ */
+export interface PostingRule {
+    /**
+     * Whether a checker that just computed the result keyed `key` of a declaration in file `fileIndex` may post it, in
+     * `ms`, with `diagnosticFiles` the files its diagnostics are in. The caller checks first that the computation met
+     * no resolution cycle, that the stop switch is off, that (when the run is cost-bounded) another checker demanded the
+     * file (`demanded`) and that no result for the key is posted.
+     */
+    posts(sharing: ThreadSharing, key: number, ms: number, diagnosticFiles: readonly number[], fileIndex: number): boolean;
+    /**
+     * The most records a consumer may build to take a posted result whose producer computed it in `ms` milliseconds: 0
+     * admits only takes that build nothing, because every record they need is in the consumer's caches already.
+     */
+    buildBudget(ms: number): number;
+}
+/**
+ * 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 declare class CostBoundedRule implements PostingRule {
+    readonly bounded: boolean;
+    /** `bounded` false is Phase 1's rule: the same floor, and a take that may build any number of records. */
+    constructor(bounded: boolean);
+    posts(sharing: ThreadSharing, _key: number, ms: number, _diagnosticFiles: readonly number[], _fileIndex: number): boolean;
+    buildBudget(ms: number): number;
+}
 /** Sets the sharing data of this checker thread; its first checker shares with the other threads. */
 export declare function setThreadSharingData(data: ThreadSharingData | undefined): void;
 /** Gives `c` the thread's sharing state, if the thread shares and no checker of it has it yet. */
@@ -293,13 +409,14 @@ export declare 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 declare class FilesByKey {
     private readonly files;
     private readonly keys;
-    get(key: number): readonly string[] | undefined;
-    set(key: number, files: readonly string[]): void;
+    get(key: number): readonly number[] | undefined;
+    set(key: number, files: readonly number[]): void;
 }
 export declare class ThreadSharing {
     readonly c: Checker;
@@ -308,7 +425,19 @@ export declare class ThreadSharing {
     readonly returns: ResultTable;
     /** TSC_TS_SHARE_MIN_MS: the shortest computation this checker posts. */
     readonly minMs: number;
-    readonly initialIndexes: Map<Type, number>;
+    /**
+     * 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.
+     */
+    readonly bounded: boolean;
+    /**
+     * 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`).
+     */
+    readonly rule: PostingRule;
+    readonly initialIndexes: Map<number, number>;
     readonly initial: Type[];
     readonly numberLogs: Int32Array[];
     readonly recordTables: Int32Array[];
@@ -316,15 +445,41 @@ export declare class ThreadSharing {
     readonly used: Int32Array;
     readonly takers: Int32Array;
     readonly forbidden: Int32Array;
+    /** The checkers that missed on a key in each file (`ThreadSharingData.wanted`). */
+    readonly wanted: Int32Array;
+    /** The files this checker noted a miss on, so that each is marked in `wanted` once. */
+    private readonly wantedFiles;
+    /** The stop switch of every checker (`ThreadSharingData.control`). */
+    readonly control: Int32Array;
+    /** This checker's row of the counters the main thread reads (`ThreadSharingData.stats`). */
+    readonly stats: Float64Array;
+    readonly row: number;
     /** The number of results this checker posted. */
     posted: number;
     translated: number;
+    /**
+     * 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: boolean;
+    /** Shared results a nested computation left to the checkers that compute them. */
+    nested: number;
     /** Outermost shared-kind computations: nesting depth, the kind of the current one, and the time by kind. */
     depth: number;
     kind: number;
     readonly kindMs: number[];
     /** Kinds: 0 owned, 1 computed here for a file another checker took, 2 translated, 3 other. */
     addOutermost(ms: number): void;
+    /**
+     * 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(): void;
+    /** Adds to the milliseconds this checker saved by translating results instead of computing them. */
+    addSaved(ms: number): void;
+    /** Whether the main thread stopped translating posted results (control 2): this checker computes them. */
+    stoppedTranslating(): boolean;
     notShareable: number;
     notShareableMs: number;
     /** Whether the outermost computations are timed by kind (TSC_TS_SHARE_SUMMARY). */
@@ -334,17 +489,26 @@ export declare class ThreadSharing {
     verifiedIdentity: number;
     belowMin: number;
     belowMinMs: number;
+    /** Results whose export passed the budget `kappa*T`, and translations that stopped at `lambda*T/c`. */
+    overBudget: number;
+    overBudgetMs: number;
+    stoppedTranslations: number;
+    /** Results not posted because no checker that may take one missed on a key in the declaration's file. */
+    notDemanded: number;
     exportFailed: number;
     exportFailedMs: number;
     readonly exportFailures: Map<string, number>;
-    packFailed: number;
-    /** 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: number;
+    storeFailed: number;
+    /** Of `storeFailed`, the results that didn't fit in this checker's logs. */
     logFull: number;
     computedPrivately: number;
+    /** Results this checker computed and kept because the main thread stopped sharing (control 1 or 2). */
+    stopped: number;
     /** How often a posted result couldn't be taken here; and results for declarations of the checker's own files. */
     sawDoneUnusable: number;
     owned: number;
-    unpackMs: number;
     /** The program's nodes results named, by id. */
     readonly nodesById: Map<number, Node>;
     readonly origins: MergedOrigins;
@@ -363,9 +527,9 @@ export declare class ThreadSharing {
     readonly typeFiles: FilesByKey;
     readonly returnFiles: FilesByKey;
     /** The files of the computations in progress, innermost last. */
-    readonly fileStack: (Set<string> | undefined)[];
+    readonly fileStack: (Set<number> | undefined)[];
     /** Adds `files` to those of the computation in progress. */
-    noteFiles(files: readonly string[] | undefined): void;
+    noteFiles(files: readonly number[] | undefined): void;
     /** The last `computeShared`: whether its result can be shared, and how long it took. */
     lastShareable: boolean;
     lastMs: number;
@@ -373,6 +537,13 @@ export declare class ThreadSharing {
     computeShared(files: FilesByKey, key: number, symbol: Symbol | undefined, sig: Signature | undefined): Type;
     /** Runs `compute`, keeping in `files` under `key` the files of its diagnostics and of the results it used. */
     tracked(files: FilesByKey, key: number, symbol: Symbol | undefined, sig: Signature | undefined): Type;
+    /**
+     * 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: string): number;
+    /** The index of each file by name, built on first use. */
+    private filesByIndex;
     constructor(c: Checker, data: ThreadSharingData);
     summary(): string;
     /**
@@ -381,18 +552,27 @@ export declare class ThreadSharing {
      * result for it (`forbid`).
      */
     owns(file: SourceFile): boolean;
+    /** Whether this checker checks file `index`, or may; -1 names a diagnostic without a file, which it has. */
+    ownsIndex(index: number): boolean;
+    /**
+     * 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: SourceFile): void;
+    /**
+     * 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: number): boolean;
     /** After taking a result for a declaration in `file`: if no checker took the file yet, this one never will. */
     forbid(file: SourceFile): void;
+    forbidIndex(index: number): void;
     /**
      * Whether taking a result would leave file `index` to no checker: no checker took it, and every other checker
      * took results for its declarations already. The main thread would check it, alone.
      */
     forbidsLast(index: number): boolean;
-    forbidsLastNamed(fileName: string): boolean;
-    forbidNamed(fileName: string): void;
-    filesByName: Map<string, SourceFile> | undefined;
-    ownsFileNamed(fileName: string): boolean;
-    /** 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: number, offset: number): StoredResult;
     /** The exporter of this checker's store: it exports each type once. */
     storeExporter: Exporter | undefined;
@@ -401,7 +581,7 @@ export declare 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: Type, diagnosticFiles: readonly string[]): number | string;
+    post(t: Type, diagnosticFiles: readonly number[], computeMs: number): number | string;
     /** The records this checker stored. */
     storedRecords: number;
     /** The readers of the other checkers' stores. */
@@ -412,52 +592,105 @@ export declare class ThreadSharing {
 /** A result in a checker's store: the record of its type, and the files of its diagnostics. */
 export declare class StoredResult {
     readonly root: number;
-    readonly files: string[];
-    constructor(root: number, files: string[]);
+    readonly files: number[];
+    /** How long computing the result took its producer, in milliseconds. */
+    readonly computeMs: number;
+    constructor(root: number, files: number[], computeMs?: number);
 }
 /** Shares the value type of `symbol` with the other checker threads, computing it with `compute` where needed. */
 export declare function threadTypeOfSymbol(c: Checker, symbol: Symbol): Type;
 /** Notes that the computation in progress used the cached return type of `sig` (see `ThreadSharing.typeFiles`). */
 export declare function noteReturnTypeUse(c: Checker, sig: Signature): void;
 export declare function threadReturnType(c: Checker, sig: Signature): Type;
-/** Reads records from a checker's store. */
-declare class RecordUnpacker {
-    readonly c: Checker;
-    readonly f: Int32Array;
-    readonly strings: Uint16Array;
-    at: number;
-    failed: boolean;
-    /** The nodes found so far, by id. */
+/** The nodes of the program records name, by id, found by descending from their file through the nodes that contain them. */
+export declare class NodeFinder {
+    readonly files: readonly SourceFile[];
     readonly nodesById: Map<number, Node>;
-    constructor(c: Checker, numbers: Int32Array, strings: Uint16Array, nodesById: Map<number, Node>);
-    next(): number;
-    double(): number;
-    text(): string;
-    list(): number[];
+    private visitor;
+    constructor(files: readonly SourceFile[], nodesById: Map<number, Node>);
+    /** The node of file `fileIndex` with the range `pos`-`end` and id `id`; undefined if the program hasn't it. */
+    find(fileIndex: number, pos: number, end: number, id: number): Node | undefined;
+}
+/**
+ * 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 declare class RecordReader {
+    readonly numbers: Int32Array;
+    readonly strings: Uint16Array;
+    readonly table: Int32Array;
+    readonly finder: NodeFinder;
+    /** The record in progress: its header and kind, and where its refs are. */
+    header: number;
+    kind: number;
+    refAt: number;
+    refCount: number;
+    /** Where its alias refs are, if it has an alias; -1 if none. */
+    aliasRefAt: number;
+    aliasRefCount: number;
+    /** How its alias is named: `SymbolNaming` and a merged symbol id, or a node at `aliasNodeStart`. */
+    aliasNaming: number;
+    aliasMergedId: number;
+    aliasNodeStart: number;
+    /** How its symbol is named: the kind of naming, a merged symbol id, or a node at `symbolNodeStart`. */
+    symbolNaming: number;
+    symbolMergedId: number;
+    symbolNodeStart: number;
+    /** Where its node is, if it has one; -1 if none. */
+    nodeStart: number;
+    /** The offset of its kind's own fields. */
+    fields: number;
+    /** The records a record names, filled by `scan`. */
+    readonly deps: number[];
+    constructor(numbers: Int32Array, strings: Uint16Array, table: Int32Array, files: readonly SourceFile[], nodesById: Map<number, Node>);
+    /** Starts the record at `index`; false if the store hasn't it. */
+    begin(index: number): boolean;
+    /** Finds the record's alias refs, its symbol and its node, and the fields that follow them. */
+    private locate;
+    /** The words a node at `p` takes: its file index, range and id, or one word for no node. */
+    nodeWords(p: number): number;
+    /** The node at `p`; undefined if it is none or the program hasn't it. */
+    readNode(p: number): Node | undefined;
+    /** The record's own node; undefined if it has none or the program hasn't it. */
     node(): Node | undefined;
-    nodes(): (Node | undefined)[];
-    symbol(): Symbol | undefined;
+    doubleAt(p: number): number;
+    textAt(p: number): string;
+    /**
+     * 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(): void;
 }
 /**
- * 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.
  */
 declare class StoreReader {
     readonly sharing: ThreadSharing;
     readonly producer: number;
     readonly translator: Translator;
-    readonly table: Int32Array;
-    readonly unpacker: RecordUnpacker;
-    /** By record: the record, its translation and whether it is translated. */
-    readonly records: (PortableRecord | undefined)[];
-    readonly types: Type[];
-    readonly symbols: (Symbol | undefined)[];
-    readonly built: number[];
+    readonly reader: RecordReader;
+    /** Whether the last `translate` stopped at its budget, having built nothing. */
+    stopped: boolean;
+    /** By record: the type it translated to, the symbol a property record makes, and whether a completion is done. */
+    readonly types: LinkTable<Type>;
+    readonly symbols: LinkTable<Symbol>;
+    readonly completed: LinkTable<boolean>;
     constructor(sharing: ThreadSharing, producer: number);
-    private ensure;
-    /** Record `index`, read on first use; undefined if a node or symbol in it isn't in this program. */
-    private record;
-    /** The translation of record `root` and the records it needs; undefined if one can't be translated here. */
-    translate(root: number): Type | undefined;
+    /**
+     * 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.
+     */
+    private isBuilt;
+    /** Whether the record in progress names only merged symbols this program has. */
+    private present;
+    /**
+     * 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: number, budget?: number): Type | undefined;
 }
 export {};