@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/dist/src/configuration-files.js

@@ -6,9 +6,13 @@
  * every string either holds as it likes, so each one that spells a declared dependency
  * uses it and each relative one that names a source file of the program roots the file.
  */
-import { isExportDeclaration, isImportDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/ast";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
-const MANIFEST = "package.json";
+import { isCallExpression, isExportDeclaration, isIdentifier, isImportDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { bytewise } from "./text/compare.js";
+import { isRecord } from "./json-document.js";
+import { filesIn } from "./fs/tree.js";
+import { DEPENDENCY_SECTIONS, holdsManifest, inInstalledPackages, manifestAt, readJSON, } from "./fs/manifest.js";
+import { shellWords } from "./text/shell.js";
 /** A configuration module's name, each form with the spelling a root reports it by. */
 const MODULE_FORMS = [
     { name: /^[\w-]+\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u, form: "<stem>.config.<ext>" },
@@ -20,13 +24,6 @@ const MODULE_FORMS = [
 ];
 /** A JSON configuration file's name. */
 const DOCUMENT_NAME = /^(?:[\w-]+(?:\.[\w-]+)?\.config\.json|\.[\w-]+rc(?:\.json)?)$/u;
-/** The manifest members a dependency is declared in. */
-const DEPENDENCY_MEMBERS = [
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies",
-];
 /** The prefixes a string names a file with, relative to the file that writes it. */
 const RELATIVE_PREFIXES = ["./", "../"];
 /** The JavaScript extensions a relative specifier from a configuration file stands for TypeScript under. */
@@ -50,18 +47,14 @@ export const RESOLVED_EXTENSIONS = [
     ".mjs",
     ".cjs",
 ];
-/** The directory a package manager installs packages into, whose files are no project's own. */
-const MODULES_DIR = "node_modules";
 /** The file's name, the last segment of its path. */
 function basename(path) {
     return path.slice(path.lastIndexOf("/") + 1);
 }
 /** Whether one path is the project's own: below the target root and in no `node_modules`. */
 function isProjectPath(root, path) {
-    return relativePath(root, path)?.split("/").includes(MODULES_DIR) === false;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+    const below = relativePath(root, path);
+    return below !== undefined && !inInstalledPackages(below);
 }
 /** The form one file name is as a configuration module, or undefined where it is none. */
 export function configurationModuleForm(name) {
@@ -75,122 +68,13 @@ export function isConfigurationDocumentName(name) {
 const CONFIG_FLAGS = new Set(["--config", "-c"]);
 /** The extensions of a module a configuration flag may name. */
 const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
-/** The characters that end a word outside quotes and separate nothing: blanks. */
-// Stryker disable next-line Regex: its \v to \V mutant is no valid escape under the u flag, so the whole module fails to parse
-const BLANK = /[ \t\r\f\v]/u;
-/** The characters that end a word outside quotes and begin an operator: newline included. */
-const OPERATOR = /[\n;&|()<>]/u;
-/** The characters a backslash escapes inside double quotes; before any other it stands for itself. */
-const DOUBLE_QUOTE_ESCAPES = new Set(["$", "`", '"', "\\"]);
-/**
- * The words of one command line, as POSIX token recognition reads quotes, backslashes,
- * line continuations, comments and operators. A word an expansion may change (an unquoted
- * `$`, backquote, glob character or leading `~`, or a `$` or backquote in double quotes)
- * is computed, and so is the rest of a line whose quote is never closed. A computed word
- * and each operator are undefined, so a flag's file is never read across them.
- */
-function shellWords(command) {
-    const words = [];
-    let word;
-    let computed = false;
-    const end = () => {
-        if (word !== undefined) {
-            words.push(computed ? undefined : word);
-        }
-        word = undefined;
-        computed = false;
-    };
-    for (let at = 0; at < command.length; at += 1) {
-        const char = command.charAt(at);
-        if (char === "\\" && command.charAt(at + 1) === "\n") {
-            at += 1;
-        }
-        else if (BLANK.test(char)) {
-            end();
-        }
-        else if (OPERATOR.test(char)) {
-            end();
-            words.push(undefined);
-        }
-        else if (char === "#" && word === undefined) {
-            const newline = command.indexOf("\n", at);
-            at = newline < 0 ? command.length : newline - 1;
-        }
-        else if (char === "\\") {
-            at += 1;
-            word = (word ?? "") + command.charAt(at);
-        }
-        else if (char === "'" || char === '"') {
-            const close = closingQuote(command, at);
-            if (close < 0) {
-                word ??= "";
-                computed = true;
-                break;
-            }
-            const quoted = char === "'"
-                ? { text: command.slice(at + 1, close), computed: false }
-                : doubleQuoted(command.slice(at + 1, close));
-            word = (word ?? "") + quoted.text;
-            computed ||= quoted.computed;
-            at = close;
-        }
-        else {
-            computed ||= /[$`*?[]/u.test(char) || (char === "~" && word === undefined);
-            word = (word ?? "") + char;
-        }
-    }
-    end();
-    return words;
-}
-/** The text between one pair of double quotes, unescaped, and whether an expansion may change it. */
-function doubleQuoted(inner) {
-    let text = "";
-    let computed = false;
-    for (let at = 0; at < inner.length; at += 1) {
-        const char = inner.charAt(at);
-        const next = inner.charAt(at + 1);
-        if (char === "\\" && next === "\n") {
-            at += 1;
-        }
-        else if (char === "\\" && DOUBLE_QUOTE_ESCAPES.has(next)) {
-            text += next;
-            at += 1;
-        }
-        else {
-            computed ||= char === "$" || char === "`";
-            text += char;
-        }
-    }
-    return { text, computed };
-}
-/** The index of the quote that closes the one at `open`, or -1 where none does. */
-function closingQuote(command, open) {
-    const quote = command.charAt(open);
-    for (let at = open + 1; at < command.length; at += 1) {
-        const char = command.charAt(at);
-        if (char === quote) {
-            return at;
-        }
-        if (quote === '"' && char === "\\") {
-            at += 1;
-        }
-    }
-    return -1;
-}
 /**
  * The files the scripts of the manifest in one directory name after a configuration flag,
  * `--config <file>`, `-c <file>` or `--config=<file>`, each a JSON file or a module below
  * the target root and in no `node_modules`.
  */
 function scriptConfigurations(host, root, dir) {
-    let scripts;
-    try {
-        const manifest = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
-        scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
-    }
-    catch {
-        return [];
-    }
+    const scripts = manifestAt(host, dir)?.["scripts"];
     if (!isRecord(scripts)) {
         return [];
     }
@@ -217,15 +101,6 @@ function scriptConfigurations(host, root, dir) {
     }
     return found;
 }
-/** The decoded value of one JSON file, or undefined where it cannot be read or parsed. */
-function readDocument(host, path) {
-    try {
-        return JSON.parse(host.readFile(path));
-    }
-    catch {
-        return undefined;
-    }
-}
 /** Every string value one decoded JSON value holds at any depth. */
 export function documentStrings(value) {
     if (typeof value === "string") {
@@ -258,10 +133,10 @@ export function moduleStrings(file) {
 export function configurationFiles(host, targetRoot, files, parse) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const manifests = new Map();
-    const holdsManifest = (dir) => {
+    const manifestHeld = (dir) => {
         let held = manifests.get(dir);
         if (held === undefined) {
-            held = host.kindOf(joinPath(dir, MANIFEST)) === "file";
+            held = holdsManifest(host, dir);
             manifests.set(dir, held);
         }
         return held;
@@ -271,30 +146,23 @@ export function configurationFiles(host, targetRoot, files, parse) {
     for (const file of files.byPath.values()) {
         const form = configurationModuleForm(basename(file.fileName));
         const fileDir = dirnamePath(file.fileName);
-        if (form !== undefined && holdsManifest(fileDir)) {
+        if (form !== undefined && manifestHeld(fileDir)) {
             modules.push({ file, form, manifestDir: fileDir });
         }
-        for (let dir = dirnamePath(file.fileName); relativePath(root, dir) !== undefined && !dirs.has(dir); dir = dirnamePath(dir)) {
+        for (const dir of ancestors(dirnamePath(file.fileName), root)) {
+            if (dirs.has(dir)) {
+                break;
+            }
             dirs.add(dir);
         }
     }
     const pending = [];
     const named = [];
-    for (const dir of [...dirs].sort()) {
-        if (!holdsManifest(dir)) {
+    for (const dir of [...dirs].sort(bytewise)) {
+        if (!manifestHeld(dir)) {
             continue;
         }
-        let names;
-        try {
-            names = host
-                .readDirectory(dir)
-                .filter((entry) => !entry.directory && isConfigurationDocumentName(entry.name))
-                .map((entry) => entry.name)
-                .sort();
-        }
-        catch {
-            names = [];
-        }
+        const names = filesIn(host, dir, isConfigurationDocumentName);
         pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
         for (const path of scriptConfigurations(host, root, dir)) {
             const held = files.byName.get(path);
@@ -318,7 +186,7 @@ export function configurationFiles(host, targetRoot, files, parse) {
             continue;
         }
         if (document === undefined) {
-            const value = readDocument(host, next.path);
+            const value = readJSON(host, next.path);
             if (value === undefined) {
                 unreadable.add(next.path);
                 continue;
@@ -343,21 +211,59 @@ export function configurationFiles(host, targetRoot, files, parse) {
         documents: [...documents.values()],
         outside: parse === undefined
             ? []
-            : outsideModules(host, root, [...dirs], files, holdsManifest, parse, named),
+            : outsideModules(host, root, [...dirs], files, manifestHeld, parse, named),
     };
 }
-/** The relative specifiers one file's imports and re-exports name. */
-function relativeSpecifiers(file) {
-    return file.statements.flatMap((statement) => {
-        const specifier = isImportDeclaration(statement) || isExportDeclaration(statement)
+/** The literal module specifier one `require(...)` or `import(...)` call names, if any. */
+function calledSpecifier(node) {
+    if (!isCallExpression(node) || node.arguments.length !== 1) {
+        return undefined;
+    }
+    const callee = node.expression;
+    const loads = callee.kind === SyntaxKind.ImportKeyword || (isIdentifier(callee) && callee.text === "require");
+    return loads ? node.arguments[0] : undefined;
+}
+/**
+ * The relative specifiers one file's imports and re-exports name, and those its
+ * `require(...)` and `import(...)` calls name by a literal.
+ */
+export function relativeSpecifiers(file) {
+    const known = specifiersOf.get(file);
+    if (known !== undefined) {
+        return known;
+    }
+    const found = [];
+    const named = (specifier) => {
+        if (specifier !== undefined &&
+            (isStringLiteral(specifier) || isNoSubstitutionTemplateLiteral(specifier)) &&
+            RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))) {
+            found.push(specifier.text);
+        }
+    };
+    const visit = (node) => {
+        named(calledSpecifier(node));
+        node.forEachChild(visit);
+    };
+    for (const statement of file.statements) {
+        named(isImportDeclaration(statement) || isExportDeclaration(statement)
             ? statement.moduleSpecifier
-            : undefined;
-        return specifier !== undefined &&
-            isStringLiteral(specifier) &&
-            RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))
-            ? [specifier.text]
-            : [];
-    });
+            : undefined);
+        visit(statement);
+    }
+    specifiersOf.set(file, found);
+    return found;
+}
+/** What {@link relativeSpecifiers} found in each file, which every project of a run reads alike. */
+const specifiersOf = new WeakMap();
+/**
+ * The files no program holds that a chain from `seeds` reads: each seed, and each file
+ * below the target root one imports, re-exports or loads by a relative specifier that no
+ * program holds either, until no further file joins, each read against the manifest
+ * directory its seed names. A file that cannot be read is skipped.
+ */
+export function outsideChain(host, targetRoot, files, parse, seeds) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    return outsideModules(host, root, [], files, () => false, parse, seeds);
 }
 /**
  * The paths one relative specifier from a configuration file may reach, in the order they
@@ -391,23 +297,13 @@ export function resolveRelativeSpecifier(host, dir, specifier) {
  * does not hold, and the project files below `root` they import by a relative specifier,
  * until no further file joins. A file that cannot be read is skipped.
  */
-function outsideModules(host, root, dirs, files, holdsManifest, parse, named) {
+function outsideModules(host, root, dirs, files, manifestHeld, parse, named) {
     const pending = [...named];
-    for (const dir of [...dirs].sort()) {
-        if (!holdsManifest(dir)) {
-            continue;
-        }
-        let names;
-        try {
-            names = host
-                .readDirectory(dir)
-                .filter((entry) => !entry.directory && configurationModuleForm(entry.name) !== undefined)
-                .map((entry) => entry.name)
-                .sort();
-        }
-        catch {
+    for (const dir of [...dirs].sort(bytewise)) {
+        if (!manifestHeld(dir)) {
             continue;
         }
+        const names = filesIn(host, dir, (name) => configurationModuleForm(name) !== undefined);
         pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
     }
     const found = new Map();
@@ -443,18 +339,12 @@ function outsideModules(host, root, dirs, files, holdsManifest, parse, named) {
 }
 /** Every dependency the manifest in one directory declares, or none where it holds none to read. */
 export function declaredIn(host, dir) {
-    let value;
-    try {
-        value = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
-    }
-    catch {
-        return [];
-    }
-    if (!isRecord(value)) {
+    const value = manifestAt(host, dir);
+    if (value === undefined) {
         return [];
     }
     const names = new Set();
-    for (const member of DEPENDENCY_MEMBERS) {
+    for (const member of DEPENDENCY_SECTIONS) {
         const section = value[member];
         if (isRecord(section)) {
             Object.keys(section).forEach((name) => names.add(name));

package/dist/src/configured-declarations.js

@@ -179,19 +179,19 @@ export function resolveEntries(project, held, entries) {
     for (const symbol of held.symbols) {
         byRef.set(symbol.ref, [...(byRef.get(symbol.ref) ?? []), symbol.id]);
     }
-    const modules = modulesNamed(project, new Set(entries.flatMap((entry) => (entry.shape === "module" ? [entry.module] : []))));
+    const modules = modulesNamed(project, new Set(entries.flatMap((entry) => ("module" in entry ? [entry.module] : []))));
     return entries.map((entry) => {
-        if (entry.shape === "symbol") {
+        if ("symbol" in entry) {
             return { entry, handles: new Set(), ids: new Set(byRef.get(entry.symbol) ?? []) };
         }
-        const { components, static: isStatic } = componentsOf(entry.shape === "module" ? entry.name : entry.global);
+        const { components, static: isStatic } = componentsOf("module" in entry ? entry.name : entry.global);
         const [first = "", ...rest] = components;
         let start;
         if (isStatic && rest.length === 0) {
             // Only a member is static, and a path of one component names no member.
             start = undefined;
         }
-        else if (entry.shape === "module") {
+        else if ("module" in entry) {
             const module = modules.get(entry.module);
             start = module === undefined ? undefined : memberOf(project, module, first, false);
         }
@@ -246,14 +246,10 @@ export function entriesAt(project, chains, nodes, resolved) {
  * program the display name the inventory gives it.
  */
 export function spelledEntry(entry, held) {
-    switch (entry.shape) {
-        case "symbol":
-            return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
-        case "module":
-            return entry.name;
-        case "global":
-            return entry.global;
+    if ("symbol" in entry) {
+        return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
     }
+    return "module" in entry ? entry.name : entry.global;
 }
 /** The key under which a lifecycle contract's declarations are configured. */
 const LIFECYCLE_KEY = "ts.lifecycle_contracts";
@@ -264,11 +260,14 @@ const LIFECYCLE_KEY = "ts.lifecycle_contracts";
  */
 export function configuredDeclarations(config) {
     return [
-        ...config.ts.injectionRegistrations.map((entry) => ({
+        ...config.ts.injection_registrations.map((entry) => ({
             key: "ts.injection_registrations",
             entry,
         })),
-        ...config.ts.lifecycleContracts.flatMap((contract) => [...contract.components, ...contract.bases].map((entry) => ({ key: LIFECYCLE_KEY, entry }))),
+        ...config.ts.lifecycle_contracts.flatMap((contract) => [...(contract.components ?? []), ...(contract.bases ?? [])].map((entry) => ({
+            key: LIFECYCLE_KEY,
+            entry,
+        }))),
         ...config.ts.serializers.map((entry) => ({ key: "ts.serializers", entry })),
     ];
 }
@@ -294,12 +293,8 @@ export function declarationsNamed(project, held, configured) {
  * sign and its name, and a global entry's path after a number sign.
  */
 export function configuredRef(entry) {
-    switch (entry.shape) {
-        case "symbol":
-            return entry.symbol;
-        case "module":
-            return `${entry.module}#${entry.name}`;
-        case "global":
-            return `#${entry.global}`;
+    if ("symbol" in entry) {
+        return entry.symbol;
     }
+    return "module" in entry ? `${entry.module}#${entry.name}` : `#${entry.global}`;
 }

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "5.2.0",
+        corpusVersion: "6.0.0",
         result: "pass",
-        digest: "sha256:012872542679539ec105f49b5ee502b0a9fa35c6bbd9ef3983b5f6e53af83d8e",
+        digest: "sha256:0d33564807a356fd3e2760ddaa0645d758bdb9a96ee74a392675e444343bbf20",
     },
     gaps: [],
 };

package/dist/src/consumers.js

@@ -1,34 +1,7 @@
-/**
- * The consumers a scope declares, loaded beside the target: each a directory on the
- * local filesystem whose compiler configurations open as projects of the run's one
- * snapshot, and whose references to the target's declarations count against them.
- */
-import { consumerProjects } from "./discover.js";
-import { inventory, packageScope } from "./inventory.js";
+import { inventory } from "./inventory.js";
 import { relativePath } from "./paths.js";
 import { references } from "./references.js";
 import { narrowedTo } from "./session.js";
-/** The name one module publishes itself under: the scope's, else its manifest's. */
-export function moduleIdentity(host, module) {
-    return module.id === "" ? packageScope(host, module.path)("index.ts").package : module.id;
-}
-/**
- * Every consumer the scope declares, in its order, with the projects it opens as. A
- * configuration that is also one of the target's projects, or an earlier consumer's, is
- * that project's alone. A consumer whose directory is absent, is no directory or holds
- * no configuration ends the run naming it, before any project opens.
- */
-export function consumerLoads(engine, host, scope, targetConfigFiles) {
-    const opened = new Set(targetConfigFiles);
-    return scope.consumers.map((module) => {
-        const configFiles = consumerProjects(engine, host, module.path).filter((configFile) => {
-            const fresh = !opened.has(configFile);
-            opened.add(configFile);
-            return fresh;
-        });
-        return { consumer: { id: moduleIdentity(host, module), path: module.path }, configFiles };
-    });
-}
 /**
  * Every reference one consumer project's own files make to a declaration of the target.
  * The target's declarations are enumerated over the target's files the consumer's
@@ -39,10 +12,10 @@ export function consumerLoads(engine, host, scope, targetConfigFiles) {
 export function consumerReferences(project, host, targetRoot, consumer, config) {
     const held = inventory(narrowedTo(project, (file) => relativePath(targetRoot, file.fileName) !== undefined), host, targetRoot);
     const found = references(project, held, targetRoot, {
-        testFiles: config.ts.testFiles,
+        testFiles: config.ts.test_files,
         consumer,
     }).references;
-    if (config.analysis.consumerTests !== "production") {
+    if (config.analysis.consumer_tests !== "production") {
         return found;
     }
     return found.map((reference) => (reference.test ? { ...reference, test: false } : reference));

package/dist/src/contextual-uses.js

@@ -1,10 +1,11 @@
 /**
  * The uses contextual types make of the target's members, which no name node resolves to.
  * An object-literal property writes the member of its name on each constituent of the
- * literal's contextual type that declares one. A value reaching a position typed by another
- * object type reads each of its members that type declares, through array elements and
- * the parameters and results of functions and constructors too; a class instance there is
- * the interface-satisfaction class's evidence instead.
+ * literal's contextual type that declares one, and so does a property of a literal whose
+ * type is inferred, where a value of that type reaches such a position. A value reaching a
+ * position typed by another object type reads each of its members that type declares,
+ * through array elements and the parameters and results of functions and constructors
+ * too; a class instance there is the interface-satisfaction class's evidence instead.
  */
 import { isClassDeclaration, isClassExpression, isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isMethodSignatureDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, } from "@typescript/native/ast";
 import { SignatureKind } from "@typescript/native/sync";
@@ -164,6 +165,33 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const members = [...membersOf(part).values()];
         return members.length > 0 && members.every((member) => !member.own);
     };
+    const literalTypes = new Map();
+    /**
+     * Whether an object type is an object literal's own, inferred where no contextual type
+     * names it: every member a property an object literal of the target writes.
+     */
+    const literalTyped = (part) => {
+        let known = literalTypes.get(part.id);
+        if (known === undefined) {
+            const members = [...membersOf(part).values()];
+            known =
+                members.length > 0 &&
+                    members.every((member) => member.ids.length === 0 &&
+                        member.declarations.length > 0 &&
+                        member.declarations.every((handle) => literalProperty(handle) !== undefined));
+            literalTypes.set(part.id, known);
+        }
+        return known;
+    };
+    /** The name node of the object literal property one declaration handle names, if it is one. */
+    const literalProperty = (handle) => {
+        const node = project.declarationAt(handle)?.node;
+        return node !== undefined &&
+            (isPropertyAssignment(node) || isShorthandPropertyAssignment(node)) &&
+            isObjectLiteralExpression(node.parent)
+            ? node.name
+            : undefined;
+    };
     const elements = new Map();
     /** The element type of an array type, read once per type. */
     const elementOf = (type) => {
@@ -246,10 +274,13 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const sources = partsOf(source).filter((one) => !targets.some((part) => part.id === one.id));
         for (const one of sources) {
             if (carries(one)) {
-                into.push({ source: one, targets, outside: false });
+                into.push({ source: one, targets, sourceKind: "members" });
             }
             else if (outside(one)) {
-                into.push({ source: one, targets, outside: true });
+                into.push({ source: one, targets, sourceKind: "outside" });
+            }
+            else if (literalTyped(one)) {
+                into.push({ source: one, targets, sourceKind: "literal" });
             }
             const element = elementOf(one);
             const called = element === undefined ? callsOf(one) : [];
@@ -290,7 +321,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
         seen.add(type.id);
         return partsOf(type).some((part) => {
-            if (carries(part) || outside(part)) {
+            if (carries(part) || outside(part) || literalTyped(part)) {
                 return true;
             }
             const element = elementOf(part);
@@ -307,6 +338,8 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     batches += batchesOf(sourced.length);
     const positions = queries.contextualTypes(sourced.map((one) => one.flow.value), cap);
     const reads = [];
+    // A literal property writes a position's members once, however many values carry it there.
+    const carriedWrites = new Set();
     sourced.forEach(({ flow, type }, index) => {
         const position = positions[index];
         if (position === undefined || !isAnswered(position)) {
@@ -315,10 +348,24 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const checked = [];
         compared(type, position, checked, new Set());
         const ids = new Set();
-        for (const { source, targets, outside: held } of checked) {
+        for (const { source, targets, sourceKind } of checked) {
             const tables = targets.map(membersOf);
             const sourceMembers = membersOf(source);
-            if (held) {
+            if (sourceKind === "literal") {
+                for (const [name, member] of sourceMembers) {
+                    const written = [...new Set(tables.flatMap((table) => table.get(name)?.ids ?? []))];
+                    for (const at of written.length === 0 ? [] : member.declarations) {
+                        const node = literalProperty(at);
+                        const key = `${at.path}#${String(at.index)}>${written.join(",")}`;
+                        if (node !== undefined && !carriedWrites.has(key)) {
+                            carriedWrites.add(key);
+                            writes.push({ at: node, from: flow.from, ids: written });
+                        }
+                    }
+                }
+                continue;
+            }
+            if (sourceKind === "outside") {
                 for (const table of tables) {
                     for (const [name, member] of table) {
                         if (sourceMembers.has(name)) {