@cplieger/deadset-ts 8.0.0-dev.16 → 8.0.0-dev.18

package/dist/src/entries/html-entries.js

@@ -5,7 +5,7 @@
  */
 import { isExportDeclaration, isImportDeclaration, isStringLiteral, } from "@typescript/native/ast";
 import { resolveRelativeSpecifier } from "./configuration-files.js";
-import { ancestors, dirnamePath, joinPath, resolvePath } from "../paths.js";
+import { ancestors, dirnamePath, hasURLScheme, isAbsolutePath, isExplicitPath, joinPath, resolvePath, } from "../paths.js";
 import { filesBelow } from "../fs/tree.js";
 import { holdsManifest } from "../fs/manifest.js";
 /** A `<script` start tag, its attribute text captured. */
@@ -14,12 +14,8 @@ const SCRIPT_TAG = /<script(?=[\s>/])([^>]*)>/giu;
 const SCRIPT_END = /<\/script\s*>/iu;
 /** One attribute: a name, then a double-quoted, single-quoted or unquoted value. */
 const ATTRIBUTE = /([^\s"'=<>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/gu;
-/** A value that names a resource on another origin, or by another scheme. */
-const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
 /** The `type` values a classic script carries, compared in lowercase. */
 const CLASSIC_TYPES = new Set(["text/javascript", "application/javascript"]);
-/** The prefixes an inline script's specifier names a file of the target with. */
-const FILE_PREFIXES = ["/", "./", "../"];
 /** Each attribute of one start tag's attribute text, by its lowercase name. */
 function attributes(text) {
     const found = new Map();
@@ -69,7 +65,7 @@ function scriptValues(parse, path, text) {
         const rest = text.slice(start);
         const end = rest.search(SCRIPT_END);
         const content = end === -1 ? rest : rest.slice(0, end);
-        values.push(...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter((specifier) => FILE_PREFIXES.some((prefix) => specifier.startsWith(prefix))));
+        values.push(...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter(isExplicitPath));
     }
     return values;
 }
@@ -98,18 +94,19 @@ export function htmlEntries(host, targetRoot, files, parse) {
         }
         const dir = dirnamePath(path);
         for (const value of scriptValues(parse, path, text)) {
-            if (ELSEWHERE.test(value)) {
+            // A value with a scheme, or one starting `//`, names a resource on another origin.
+            if (value.startsWith("//") || hasURLScheme(value)) {
                 continue;
             }
-            const base = value.startsWith("/") ? manifestDirectory(host, root, dir) : dir;
-            const relative = value.startsWith("/") ? `.${value}` : value;
+            const base = isAbsolutePath(value) ? manifestDirectory(host, root, dir) : dir;
+            const relative = isAbsolutePath(value) ? `.${value}` : value;
             const reached = resolveRelativeSpecifier(host, base, relative);
             const file = reached === undefined ? undefined : files.byName.get(reached);
             if (file !== undefined) {
                 found.push({ file, source: value });
                 continue;
             }
-            const served = value.startsWith("/")
+            const served = isAbsolutePath(value)
                 ? files.outputDirs.filter((outDir) => outDir === dir)
                 : [];
             const emitting = [base, ...served].flatMap((against) => files.named(resolvePath(against, relative)));

package/dist/src/entries/mdx-entries.js

@@ -4,7 +4,7 @@
  * is an import declaration, which an MDX compiler hoists into the module it builds.
  */
 import { resolveRelativeSpecifier } from "./configuration-files.js";
-import { dirnamePath, joinPath, resolvePath } from "../paths.js";
+import { dirnamePath, joinPath, resolvePath, startsRelativePath } from "../paths.js";
 import { filesBelow } from "../fs/tree.js";
 /** The extensions of a document whose imports an MDX compiler reads. */
 const DOCUMENT = /\.mdx?$/u;
@@ -122,7 +122,7 @@ function importedBy(text) {
         }
         const matched = open === undefined ? IMPORT_LINE.exec(line) : null;
         const specifier = matched?.[2];
-        if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+        if (specifier !== undefined && startsRelativePath(specifier)) {
             found.push({ specifier, names: clauseNames(matched?.[1] ?? "") });
         }
     }

package/dist/src/entries/static-module.js

@@ -7,6 +7,7 @@
 import { isArrayLiteralExpression, isBindingElement, isExternalModuleReference, isImportClause, isImportEqualsDeclaration, isImportSpecifier, isStringLiteralLikeNode, isCallExpression, isClassDeclaration, isClassExpression, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableDeclaration, isVariableStatement, isSourceFile, isBlock, isModuleBlock, isCaseBlock, isCatchClause, isForStatement, isForInStatement, isForOfStatement, isVariableDeclarationList, isMetaProperty, isAssignmentOperator, isBinaryExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isShorthandPropertyAssignment, isSpreadElement, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { commonJSModuleValue } from "../inventory/commonjs.js";
 import { callsPlatformBy, lexicalBinding, writtenName } from "../platform-calls.js";
+import { startsRelativePath } from "../paths.js";
 import { unwrapped } from "../unwrap.js";
 /** A JSON or YAML document's value, which carries no positions. */
 export function documentValue(value) {
@@ -443,7 +444,7 @@ export function relativeSpecifiers(file) {
     }
     const found = [];
     const named = (specifier) => {
-        if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+        if (specifier !== undefined && startsRelativePath(specifier)) {
             found.push(specifier);
         }
     };

package/dist/src/exempt.js

@@ -10,7 +10,6 @@ import { EXEMPTION_CLASSES } from "./contract/contract.generated.js";
 import { TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
 import { byPosition, positionKey } from "./position.js";
 import { Unanswerable } from "./query.js";
-import { sweep } from "./sweep.js";
 import { bytewise } from "./text/compare.js";
 /**
  * The classes `exemptions.disabled` switches off. A class that runs on another language
@@ -130,13 +129,6 @@ export function exemptionsOf(found) {
         return true;
     });
 }
-/**
- * The records that hold while the component files at `live` are live: every record that
- * holds whatever is live, and each one a live file's markup holds, as a record of the run.
- */
-export function holdingWhile(records, live) {
-    return exemptionsOf(records.flatMap(({ whileLive, ...record }) => whileLive === undefined || live.has(whileLive) ? [record] : []));
-}
 /** The records per declaration, each declaration's in the order given. */
 function byDeclaration(records) {
     const grouped = new Map();
@@ -151,24 +143,6 @@ function byDeclaration(records) {
     }
     return grouped;
 }
-/**
- * The records that held back a declaration: one some configuration's graph, swept
- * again with no exemption and its marks, judges a candidate, whatever another
- * configuration answers, or one in `writeOnly`, which the run would report as written
- * and never read without the record's read. A declaration a relation or a mark holds
- * live in every configuration is held back by no record. The order is the
- * declarations' site order, and for one declaration the input's.
- */
-export function retainedIn(matrix, input, writeOnly = new Set()) {
-    const exempt = input.exempt ?? [];
-    if (exempt.length === 0) {
-        return [];
-    }
-    const bare = { marked: input.marked, mode: input.mode };
-    const dead = new Set(matrix.graphs.flatMap((graph) => sweep(graph, bare).candidates.map((candidate) => candidate.id)));
-    const held = byDeclaration(exempt.filter((record) => dead.has(record.id) || writeOnly.has(record.id)));
-    return matrix.union.symbols.flatMap((symbol) => held.get(symbol.id) ?? []);
-}
 /**
  * One line per held-back declaration, in site order: its reference and position, then
  * each record's class, site and detail, all separated by tabs.

package/dist/src/exposure.js

@@ -0,0 +1,400 @@
+/**
+ * Which types of the target each of its declarations hands to code outside the package:
+ * the types each declaration a reference from outside reaches names, as written or as the
+ * checker reads it, as the precondition of `DS1501` in the Contract's kinds reads that
+ * reach.
+ */
+import { SignatureKind, SymbolFlags, } from "@typescript/native/sync";
+import { isArrowFunction, isAsExpression, isBindingElement, isCallSignatureDeclaration, isClassExpression, isConstructorTypeNode, isConstructSignatureDeclaration, isDecorator, isEnumMember, isFunctionExpression, isFunctionTypeNode, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isMethodSignatureDeclaration, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAssignment, isPropertyDeclaration, isPropertySignatureDeclaration, isSatisfiesExpression, isSetAccessorDeclaration, isSpreadAssignment, isTypeAssertion, isTypeReferenceNode, } from "@typescript/native/ast";
+import { aliasChains } from "./alias-chain.js";
+import { OUTSIDE } from "./liveness/graph.js";
+import { nodeKey } from "./inventory.js";
+import { isAnswered } from "./query.js";
+import { typeNamesOf } from "./roots/published-reach.js";
+/** The declarations whose values a reference holds without naming them. */
+const TYPES = new Set(["class", "interface", "type", "enum"]);
+/** The symbol flags of a type the source spells as a literal, whose members are its own. */
+const LITERAL = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
+/** The members a type's definition names other types through, where exported. */
+const MEMBERS = new Set([
+    "method",
+    "class-member",
+    "interface-method",
+    "type-member",
+]);
+/** The declarations of a module or a namespace whose signature or type hands values on. */
+const CARRYING = new Set(["function", "variable", ...TYPES]);
+/** The containers whose own declarations a reference from outside can reach. */
+const SCOPES = new Set(["file", "namespace"]);
+/** What a project whose carriers no rule reads carries: nothing. */
+export const NO_CARRIERS = { named: new Map(), unread: new Set() };
+/** Whether a member is named from outside its type: neither `private` nor a private name. */
+function exportedMember(symbol) {
+    return symbol.visibility === "public" || symbol.visibility === "protected";
+}
+/**
+ * The declarations of one project that carry values out: a function, a variable or a type
+ * a module or a namespace declares, and an exported member of a class, an interface or a
+ * type. Neither is filtered by its export: only a declaration the reach meets passes it
+ * on, and an unexported type an exported function returns passes it to what it names.
+ */
+function carrying(held) {
+    const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+    return held.symbols.filter((symbol) => {
+        const parent = byId.get(symbol.parent);
+        if (MEMBERS.has(symbol.kind)) {
+            return parent !== undefined && TYPES.has(parent.kind) && exportedMember(symbol);
+        }
+        return CARRYING.has(symbol.kind) && parent !== undefined && SCOPES.has(parent.kind);
+    });
+}
+/** The node a declaration's symbol is resolved at: its name, or itself where it has none. */
+function nameNode(node) {
+    return node.name ?? node;
+}
+/** Whether a value expression is one whose type the declaration output prints as written. */
+function printedAsWritten(node) {
+    return (isParenthesizedExpression(node) ||
+        isAsExpression(node) ||
+        isTypeAssertion(node) ||
+        isSatisfiesExpression(node) ||
+        isObjectLiteralExpression(node) ||
+        isArrowFunction(node) ||
+        isFunctionExpression(node) ||
+        isClassExpression(node));
+}
+/** Whether a type node is the `const` of a const assertion, which names no type. */
+function isConstName(node) {
+    return isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.text === "const";
+}
+/**
+ * Whether the declaration output prints a type or a member it meets by this declaration's
+ * written types: a function type's, a signature's, a member's, or an expression's that
+ * {@link printedAsWritten} holds. A type literal or a mapped type it prints from the
+ * checker's members, so only each member's own declaration is read.
+ */
+function reused(node) {
+    return (isFunctionTypeNode(node) ||
+        isConstructorTypeNode(node) ||
+        isPropertySignatureDeclaration(node) ||
+        isMethodSignatureDeclaration(node) ||
+        isCallSignatureDeclaration(node) ||
+        isConstructSignatureDeclaration(node) ||
+        isPropertyAssignment(node) ||
+        isPropertyDeclaration(node) ||
+        isMethodDeclaration(node) ||
+        isGetAccessorDeclaration(node) ||
+        isSetAccessorDeclaration(node) ||
+        printedAsWritten(node));
+}
+/**
+ * Whether the declaration output leaves out the types one node of a declaration writes.
+ * It prints an initializer only where its declaration has no annotation, and then as the
+ * checker types it, except through what {@link printedAsWritten} holds: an assertion's
+ * type in place of its operand, a function's or a class's signatures, an object literal's
+ * properties, and the operand of a `satisfies`. A decorator and an enum member's or a
+ * binding element's initializer are not printed.
+ */
+function unprinted(node) {
+    const parent = node.parent;
+    if (parent === undefined) {
+        return false;
+    }
+    if (isDecorator(node)) {
+        return true;
+    }
+    const held = parent;
+    if (held.initializer === node) {
+        return (isEnumMember(parent) ||
+            isBindingElement(parent) ||
+            held.type !== undefined ||
+            !printedAsWritten(node));
+    }
+    if (isAsExpression(parent) || isTypeAssertion(parent)) {
+        return isConstName(parent.type)
+            ? node === parent.type || !printedAsWritten(node)
+            : node === parent.expression;
+    }
+    if (isSatisfiesExpression(parent)) {
+        return node === parent.type || !printedAsWritten(node);
+    }
+    if (isParenthesizedExpression(parent) || isSpreadAssignment(parent)) {
+        return !printedAsWritten(node);
+    }
+    return false;
+}
+/**
+ * The declarations of the target each declaration of one project carries: those it names
+ * as written, and those its type names as the checker reads it, so an inferred result names
+ * its type as an annotation does. The walk reads a type's constituents, type arguments,
+ * alias arguments, `partsOf`, literal members and index signatures, and each signature's
+ * parameters, result and `signaturePartsOf`. A type of the target ends the walk, since its
+ * own definition is read as its own.
+ */
+export function carriersOf(project, held) {
+    const { queries } = project;
+    const chains = aliasChains(project, held);
+    const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
+    const parents = new Map(held.symbols.map((symbol) => [symbol.id, symbol.parent]));
+    const wanted = new Set(carrying(held).map((symbol) => symbol.id));
+    const declared = [];
+    // A nested carrier and any other member of a type are read on that member, not on the
+    // declaration that holds it; a type parameter is part of its declaration.
+    const readAloneIn = (file) => (nested) => {
+        const id = held.declarations.get(nodeKey(file, nested));
+        const kind = id === undefined ? undefined : kinds.get(id);
+        return (unprinted(nested) ||
+            (id !== undefined &&
+                kind !== "type-parameter" &&
+                (wanted.has(id) || TYPES.has(kinds.get(parents.get(id) ?? "") ?? "file"))));
+    };
+    for (const file of project.ownSourceFiles()) {
+        const readAlone = readAloneIn(file);
+        const visit = (node) => {
+            const id = held.declarations.get(nodeKey(file, node));
+            if (id !== undefined && wanted.has(id)) {
+                declared.push({
+                    id,
+                    handle: project.handle(nameNode(node)),
+                    written: typeNamesOf(node, readAlone).map((name) => project.handle(name)),
+                });
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    const unread = new Set();
+    let reading = "";
+    const answer = (found, otherwise) => {
+        if (isAnswered(found)) {
+            return found;
+        }
+        unread.add(reading);
+        return otherwise;
+    };
+    const typesOf = (symbol) => chains.declarationsOf(symbol).filter((id) => TYPES.has(kinds.get(id) ?? "file"));
+    // The declaration output prints an anonymous type or a literal's member by its own
+    // declaration's written types where it has them, which name an alias the checker erases,
+    // so the walk of one declaration keeps the target's own declarations of those it meets.
+    const own = project.ownPaths();
+    let meeting = new Map();
+    const meet = (symbol) => {
+        for (const handle of symbol.declarations) {
+            if (own.has(handle.path)) {
+                meeting.set(`${handle.path}#${String(handle.index)}`, handle);
+            }
+        }
+    };
+    const signatures = (type, into, seen) => {
+        for (const kind of [SignatureKind.Call, SignatureKind.Construct]) {
+            for (const signature of answer(queries.signaturesOf(type, kind), [])) {
+                signature.parameters.forEach((_parameter, index) => {
+                    walk(answer(queries.parameterType(signature, index), undefined), into, seen);
+                });
+                walk(answer(queries.returnTypeOf(signature), undefined), into, seen);
+                for (const part of answer(queries.signaturePartsOf(signature), [])) {
+                    walk(part, into, seen);
+                }
+            }
+        }
+    };
+    // The parts of a type that spell other types, not counting the type itself.
+    const structure = (type, into, seen) => {
+        for (const part of answer(queries.constituents(type), [])) {
+            if (part.id !== type.id) {
+                walk(part, into, seen);
+            }
+        }
+        for (const argument of answer(queries.typeArguments(type), [])) {
+            walk(argument, into, seen);
+        }
+        for (const part of answer(queries.partsOf(type), [])) {
+            walk(part, into, seen);
+        }
+        const symbol = answer(queries.symbolOfType(type), undefined);
+        if (symbol !== undefined && (symbol.flags & LITERAL) !== 0) {
+            for (const property of answer(queries.propertiesOf(type), [])) {
+                meet(property);
+                walk(answer(queries.typeOfSymbol(property), undefined), into, seen);
+            }
+            for (const info of answer(queries.indexInfosOf(type), [])) {
+                walk(info.valueType, into, seen);
+            }
+        }
+        signatures(type, into, seen);
+    };
+    const walk = (type, into, seen) => {
+        if (type === undefined || seen.has(type.id)) {
+            return;
+        }
+        seen.add(type.id);
+        const alias = answer(queries.aliasSymbolOf(type), undefined);
+        if (alias !== undefined) {
+            for (const id of typesOf(alias)) {
+                into.add(id);
+            }
+            for (const argument of answer(queries.aliasArgumentsOf(type), [])) {
+                walk(argument, into, seen);
+            }
+            if (typesOf(alias).length > 0) {
+                return;
+            }
+        }
+        const symbol = answer(queries.symbolOfType(type), undefined);
+        const named = symbol === undefined ? [] : typesOf(symbol);
+        if (named.length > 0) {
+            for (const id of named) {
+                into.add(id);
+            }
+            for (const argument of answer(queries.typeArguments(type), [])) {
+                walk(argument, into, seen);
+            }
+            return;
+        }
+        if (symbol !== undefined) {
+            meet(symbol);
+        }
+        structure(type, into, seen);
+    };
+    // What one declaration's checker type names, by its kind.
+    const definition = (symbol, kind, into) => {
+        const seen = new Set();
+        // A class's or an interface's own definition: its properties are members, which carry
+        // on their own, so only its bases, signatures and index signatures are read here.
+        const own = (type) => {
+            for (const info of answer(queries.indexInfosOf(type), [])) {
+                walk(info.valueType, into, seen);
+            }
+            signatures(type, into, seen);
+        };
+        if (kind === "class" || kind === "interface") {
+            const instance = answer(queries.declaredTypeOf(symbol), undefined);
+            const statics = kind === "class" ? answer(queries.typeOfSymbol(symbol), undefined) : undefined;
+            const sides = [instance, statics].filter((side) => side !== undefined);
+            for (const side of sides) {
+                seen.add(side.id);
+            }
+            for (const base of instance === undefined ? [] : answer(queries.baseTypes(instance), [])) {
+                walk(base, into, seen);
+            }
+            sides.forEach(own);
+        }
+        else if (kind === "type") {
+            const aliased = answer(queries.declaredTypeOf(symbol), undefined);
+            if (aliased !== undefined) {
+                seen.add(aliased.id);
+                structure(aliased, into, seen);
+            }
+        }
+        else if (kind !== "enum") {
+            walk(answer(queries.typeOfSymbol(symbol), undefined), into, seen);
+        }
+    };
+    const symbols = project.symbolsAt(declared.map((one) => one.handle));
+    const spelled = project.symbolsAt(declared.flatMap((one) => one.written));
+    const reached = [];
+    const add = (answered, into) => {
+        const name = answer(answered, undefined);
+        for (const target of name === undefined ? [] : chains.chainOf(name)) {
+            if (TYPES.has(kinds.get(target.id) ?? "file")) {
+                into.add(target.id);
+            }
+        }
+    };
+    let from = 0;
+    declared.forEach(({ id, written }, index) => {
+        reading = id;
+        const into = new Set();
+        for (const answered of spelled.slice(from, from + written.length)) {
+            add(answered, into);
+        }
+        from += written.length;
+        meeting = new Map();
+        const symbol = answer(symbols[index], undefined);
+        if (symbol !== undefined) {
+            definition(symbol, kinds.get(id), into);
+        }
+        reached.push({ id, into, met: [...meeting.values()] });
+    });
+    const namesAt = new Map();
+    const writtenAt = (handle) => {
+        const key = `${handle.path}#${String(handle.index)}`;
+        let names = namesAt.get(key);
+        if (names === undefined) {
+            const node = project.declarationAt(handle)?.node;
+            names =
+                node === undefined || !reused(node)
+                    ? []
+                    : typeNamesOf(node, readAloneIn(node.getSourceFile())).map((name) => project.handle(name));
+            namesAt.set(key, names);
+        }
+        return names;
+    };
+    const metNames = reached.map((one) => one.met.flatMap(writtenAt));
+    const metSpelled = project.symbolsAt(metNames.flat());
+    const named = new Map();
+    from = 0;
+    reached.forEach(({ id, into }, index) => {
+        reading = id;
+        const count = metNames[index]?.length ?? 0;
+        for (const answered of metSpelled.slice(from, from + count)) {
+            add(answered, into);
+        }
+        from += count;
+        into.delete(id);
+        named.set(id, [...into]);
+    });
+    return { named, unread };
+}
+/**
+ * The types whose values a reference from outside the package reaches through the
+ * package's own declarations, or every type where such a reference reaches a declaration
+ * whose surface the checker left unread. `outside` flags each declaration of the graph a
+ * reference from outside names; each passes the reach on to what it carries, a type to
+ * each member it exports, a namespace to each declaration it exports and a member to its
+ * type, until no declaration joins.
+ */
+export function exposedTypes(graph, outside, carriers) {
+    const { symbols, parent } = graph;
+    const members = symbols.map(() => []);
+    symbols.forEach((symbol, at) => {
+        const container = parent[at] ?? OUTSIDE;
+        const holder = symbols[container];
+        if (holder !== undefined &&
+            ((TYPES.has(holder.kind) && MEMBERS.has(symbol.kind) && exportedMember(symbol)) ||
+                (holder.kind === "namespace" && symbol.exported))) {
+            members[container]?.push(at);
+        }
+    });
+    const reached = symbols.map((_symbol, at) => outside[at] === true);
+    const queue = reached.flatMap((one, at) => (one ? [at] : []));
+    const join = (at) => {
+        if (at !== OUTSIDE && reached[at] !== true) {
+            reached[at] = true;
+            queue.push(at);
+        }
+    };
+    for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
+        const symbol = symbols[at];
+        if (symbol === undefined) {
+            continue;
+        }
+        if (carriers?.unread.has(symbol.id) === true) {
+            return "every";
+        }
+        for (const id of carriers?.named.get(symbol.id) ?? []) {
+            join(graph.at(id));
+        }
+        for (const member of members[at] ?? []) {
+            join(member);
+        }
+        if (MEMBERS.has(symbol.kind)) {
+            join(parent[at] ?? OUTSIDE);
+        }
+    }
+    return new Set(symbols.flatMap((symbol, at) => reached[at] === true && TYPES.has(symbol.kind) ? [symbol.id] : []));
+}
+/** Whether code outside the package holds values of a type through the package's declarations. */
+export function exposes(exposed, symbol) {
+    return TYPES.has(symbol.kind) && (exposed === "every" || exposed.has(symbol.id));
+}

package/dist/src/facts.js

@@ -1,13 +1,13 @@
 /**
  * The facts document `--facts` writes, `bindings.1` and `bindings.2`: the run's generated
- * files under the one decision the generated-file class reads. It carries no binding
- * record, so it states `evaluated: false`.
+ * files under the one decision the generated-file class reads, and the binding identities
+ * they publish. No binding state is computed, so it states `evaluated: false` (`bindings.10`).
  */
 import { FACTS_VERSION } from "./contract/contract.generated.js";
 import { LANGUAGE, PRODUCT } from "./product.js";
 import { bytewise } from "./text/compare.js";
 /** The facts document of one run, as the text written to the path `--facts` names. */
-export function factsDocument(version, generated) {
+export function factsDocument(version, generated, bindings) {
     const document = {
         facts_version: FACTS_VERSION,
         analyzer: { name: PRODUCT, version },
@@ -32,7 +32,7 @@ export function factsDocument(version, generated) {
                     schema_files: fact.generator.schemaFiles,
                 }),
         })),
-        bindings: [],
+        bindings,
     };
     return `${JSON.stringify(document, null, 2)}\n`;
 }