@cplieger/deadset-ts 5.0.0 → 5.1.0

package/dist/src/analysis.js

@@ -14,10 +14,12 @@ import { decorator } from "./decorator.js";
 import { dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
 import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "./discover.js";
-import { conventionFailuresFor, readConventions, } from "./conventions.js";
+import { conventionFailuresFor, generatedFiles, readConventions, } from "./conventions.js";
 import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
-import { computeExemptions, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
+import { generatedFile } from "./generated-file.js";
+import { sourceFilesOf } from "./source-files.js";
+import { detectExemptions, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
 import { heldByInclusion, sourceTree } from "./file-facts.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { NO_SELF_CHECK, unmatchedRootFindings, } from "./findings/self-check.js";
@@ -110,6 +112,7 @@ function readProjects(engine, host, scope, config, stage) {
         entryFiles: config.ts.entryFiles,
         conventions,
         testFiles: config.ts.testFiles,
+        parse: (fileName, text) => engine.parseSourceFile(fileName, text),
         publishedAPI: config.targetKind === "library",
     };
     const notBuilt = [...discovered.notBuilt];
@@ -225,6 +228,7 @@ function readProjects(engine, host, scope, config, stage) {
                     .ownSourceFiles()
                     .filter((file) => referenceOnly(file.fileName))
                     .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
+                generated: generatedFiles(conventions, sourceFilesOf(project, targetRoot)),
             };
         };
         return stage(project, { configuration, read });
@@ -321,6 +325,7 @@ export function runRoots(engine, host, scope, config, provenance) {
 const DETECTORS = new Map([
     ["interface-satisfaction", interfaceSatisfaction],
     ["enum-group", enumGroup],
+    ["generated-file", generatedFile],
     ["template-field", templateField],
     ["reflective-lookup", reflectiveLookup],
     ["decorator", decorator],
@@ -347,11 +352,27 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             testFiles: config.ts.testFiles,
         });
         const support = testSupportFiles(projectRead.held.symbols, resolved.references, projectRead.rooted.liveUnderReachability, resolved.testFilePaths);
+        const detected = detectExemptions({
+            project,
+            held: projectRead.held,
+            targetRoot,
+            templates,
+            ts: config.ts,
+            consumers,
+            ...(config.analysis.generatedFiles === "include"
+                ? {}
+                : { generated: projectRead.generated }),
+        }, detectors, {
+            disabled,
+            mode,
+            testFiles: new Set([...resolved.testFilePaths, ...support]),
+        });
+        const exempt = detected.records;
         const made = supportReferences(resolved.references, support);
         const configured = {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
-            references: made,
+            references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
             roots: projectRead.rooted.liveUnderReachability,
             testFiles: resolved.testFilePaths,
             ...(support.size === 0 ? {} : { supportFiles: [...support].sort() }),
@@ -359,11 +380,6 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                 ? {}
                 : { referenceOnly: projectRead.referenceOnly }),
         };
-        const exempt = computeExemptions({ project, held: projectRead.held, targetRoot, templates, ts: config.ts, consumers }, detectors, {
-            disabled,
-            mode,
-            testFiles: new Set([...resolved.testFilePaths, ...support]),
-        });
         const unanswered = [
             ...projectRead.held.unanswered,
             ...projectRead.rooted.unanswered,
@@ -440,6 +456,55 @@ function holdingSweep(read, input) {
         live = next;
     }
 }
+/**
+ * The test references exemption evidence written in a test file makes: each is a read of
+ * the declaration it would retain, made by the test file at the evidence's site.
+ */
+function evidenceReferences(symbols, inTestFiles) {
+    if (inTestFiles.length === 0) {
+        return [];
+    }
+    const files = new Map(symbols
+        .filter((symbol) => symbol.kind === "file")
+        .map((symbol) => [symbol.position.path, symbol.id]));
+    return inTestFiles.flatMap((record) => {
+        const from = files.get(record.site.path);
+        return from === undefined
+            ? []
+            : [
+                {
+                    from,
+                    to: record.id,
+                    position: record.site,
+                    use: "read",
+                    resolution: "syntax",
+                    test: true,
+                },
+            ];
+    });
+}
+/**
+ * The declarations every reference the mode counts stores into, a loaded consumer's
+ * reference counting as a read: what the write-only kind would report but for a record.
+ */
+function writtenOnly(read, mode) {
+    const written = new Set();
+    const readSome = new Set();
+    for (const { configured } of read.projects) {
+        for (const reference of configured.references) {
+            if (mode.production && reference.test) {
+                continue;
+            }
+            if (reference.use === "write" && reference.consumer === undefined) {
+                written.add(reference.to);
+            }
+            else {
+                readSome.add(reference.to);
+            }
+        }
+    }
+    return new Set([...written].filter((id) => !readSome.has(id)));
+}
 /**
  * The sweep of a run read once, under one set of marks. Where a question went unanswered,
  * the run is swept once more without what that question could have kept live and without
@@ -483,7 +548,7 @@ function sweptOf(read, input) {
         matrix: read.matrix,
         sweep: result,
         exempt,
-        retained: retainedIn(read.matrix, swept),
+        retained: retainedIn(read.matrix, swept, writtenOnly(read, input.mode)),
         notBuilt: read.notBuilt,
         unanswered: read.unanswered,
         heldByUnanswered: [...held],
@@ -510,9 +575,10 @@ function readEmitterRun(engine, host, scope, config, mode, detectors) {
     const run = readRun(engine, host, scope, config, mode, detectors, (project, read, references) => ({
         deprecation: deprecatedDeclarations(project, read.held),
         accessors: accessorsOf(project, read.held),
-        needs: projectNeeds(project, read.held, host, targetRoot),
+        needs: projectNeeds(project, read.held, host, targetRoot, (fileName, text) => engine.parseSourceFile(fileName, text)),
         implementations: implementations(project, read.held),
         heldByInclusion: heldByInclusion(project, targetRoot),
+        generated: [...read.generated.keys()],
         rooted: read.rooted,
         directives: inlineDirectives(project, read.held, targetRoot).filter((directive) => !read.referenceOnly.includes(directive.site.path)),
         declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
@@ -546,6 +612,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
         files: {
             tree: sourceTree(host, targetRoot),
             heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
+            generated: new Set(projects.flatMap((one) => one.extra.generated)),
         },
         boundary: {
             consumers: {

package/dist/src/configuration-files.js

@@ -6,7 +6,7 @@
  * 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 { isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { isExportDeclaration, isImportDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/unstable/ast";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 const MANIFEST = "package.json";
 /** A configuration module's name, each form with the spelling a root reports it by. */
@@ -29,6 +29,15 @@ const DEPENDENCY_MEMBERS = [
 ];
 /** 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. */
+const COUNTERPARTS = [
+    [".js", [".ts", ".tsx"]],
+    [".jsx", [".tsx", ".ts"]],
+    [".mjs", [".mts"]],
+    [".cjs", [".cts"]],
+];
+/** The extensions appended to a relative specifier from a configuration file, in order. */
+const APPENDED = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 /** The extensions the program's module resolution appends to a specifier written without one. */
 const RESOLVED_EXTENSIONS = [
     ".ts",
@@ -85,7 +94,7 @@ export function moduleStrings(file) {
  * in a directory that holds a manifest. A document that cannot be read or parsed as
  * JSON holds no string.
  */
-export function configurationFiles(host, targetRoot, files) {
+export function configurationFiles(host, targetRoot, files, parse) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const manifests = new Map();
     const holdsManifest = (dir) => {
@@ -135,7 +144,102 @@ export function configurationFiles(host, targetRoot, files) {
             documents.push({ path, strings: documentStrings(value) });
         }
     }
-    return { modules, documents };
+    return {
+        modules,
+        documents,
+        outside: parse === undefined ? [] : outsideModules(host, [...dirs], files, holdsManifest, parse),
+    };
+}
+/** 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)
+            ? statement.moduleSpecifier
+            : undefined;
+        return specifier !== undefined &&
+            isStringLiteral(specifier) &&
+            RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))
+            ? [specifier.text]
+            : [];
+    });
+}
+/**
+ * The module one relative specifier from a configuration file reaches: the path it names,
+ * that path with its JavaScript extension replaced by the TypeScript counterparts, that
+ * path with an extension appended, and a directory's `index` with one appended.
+ */
+function reachedBy(host, dir, specifier) {
+    const path = resolvePath(dir, specifier);
+    const isFile = (candidate) => host.kindOf(candidate) === "file";
+    // A data file such as `./package.json` is no module, so its strings use no dependency.
+    if (isFile(path) && APPENDED.some((extension) => path.endsWith(extension))) {
+        return path;
+    }
+    for (const [extension, counterparts] of COUNTERPARTS) {
+        if (path.endsWith(extension)) {
+            const stem = path.slice(0, -extension.length);
+            const found = counterparts.map((one) => stem + one).find(isFile);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+    }
+    const appended = APPENDED.map((extension) => path + extension).find(isFile);
+    if (appended !== undefined) {
+        return appended;
+    }
+    return host.kindOf(path) === "directory"
+        ? APPENDED.map((extension) => joinPath(path, `index${extension}`)).find(isFile)
+        : undefined;
+}
+/**
+ * The configuration modules of the directories that hold a manifest which the program
+ * does not hold, and the files they import by a relative specifier, until no further
+ * file joins. A file that cannot be read is skipped.
+ */
+function outsideModules(host, dirs, files, holdsManifest, parse) {
+    const pending = [];
+    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 {
+            continue;
+        }
+        pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
+    }
+    const found = [];
+    const seen = new Set();
+    for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+        if (seen.has(next.path) || files.byName.has(next.path)) {
+            continue;
+        }
+        seen.add(next.path);
+        let text;
+        try {
+            text = host.readFile(next.path);
+        }
+        catch {
+            continue;
+        }
+        const file = parse(next.path, text);
+        found.push({ file, manifestDir: next.manifestDir });
+        for (const specifier of relativeSpecifiers(file)) {
+            const reached = reachedBy(host, dirnamePath(next.path), specifier);
+            if (reached !== undefined) {
+                pending.push({ path: reached, manifestDir: next.manifestDir });
+            }
+        }
+    }
+    return found;
 }
 /** Every dependency the manifest in one directory declares, or none where it holds none to read. */
 export function declaredIn(host, dir) {

package/dist/src/conformance-record.js

@@ -2,15 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "2.1.1",
+        corpusVersion: "2.2.0",
         result: "pass",
-        digest: "sha256:e5e456bf3a706f1fa9f906ae71e10ea98a78da52d7d99a5ed59dca8a72bbe927",
+        digest: "sha256:ce7c9087ed7b2baf3de9fa2df436b500706f4f9e94fd9e0fed633054305f06a4",
     },
-    gaps: [
-        {
-            fixture: "private-member-unread",
-            capability: "reflective-lookup",
-            reason: "The reference pass resolves a string-literal element access to the member it names, so the member is live by that reference and the retained listing names no class for it.",
-        },
-    ],
+    gaps: [],
 };

package/dist/src/contextual-uses.js

@@ -0,0 +1,240 @@
+/**
+ * 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
+ * function parameters and results too; a class instance there is the
+ * interface-satisfaction class's evidence instead.
+ */
+import { isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { SignatureKind } from "@typescript/native/unstable/sync";
+import { isAnswered } from "./query.js";
+/** The member kinds a contextual type writes and reads: data members and the members of object types. */
+const MEMBER_KINDS = new Set(["type-member", "class-member"]);
+/** The name one literal property is written under, where the name is literal text. */
+function propertyName(property) {
+    if (!isPropertyAssignment(property) &&
+        !isShorthandPropertyAssignment(property) &&
+        !isMethodDeclaration(property) &&
+        !isGetAccessorDeclaration(property) &&
+        !isSetAccessorDeclaration(property)) {
+        return undefined;
+    }
+    const name = property.name;
+    if (isIdentifier(name) || isStringLiteral(name) || isNumericLiteral(name)) {
+        return { node: name, text: name.text };
+    }
+    if (isComputedPropertyName(name)) {
+        const key = name.expression;
+        if (isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key)) {
+            return { node: name, text: key.text };
+        }
+    }
+    return undefined;
+}
+/** How many element and signature steps the structural walk takes below a value's own type. */
+const MAX_DEPTH = 3;
+/**
+ * The contextual uses of one project's literals and values, asked in batches: one
+ * contextual type per literal and per value whose type carries a member of the target,
+ * one type per value, and each distinct type's properties once.
+ */
+export function contextualUses(project, held, chains, literals, flows, cap, properties) {
+    const queries = project.queries;
+    const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
+    let batches = 0;
+    let lookups = 0;
+    const batchesOf = (count) => Math.ceil(count / cap);
+    const parts = new Map();
+    /** The object types one type is: itself, or its constituents at any depth. */
+    const partsOf = (type) => {
+        const known = parts.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        let found = [];
+        if (type.isUnionType() || type.isIntersectionType()) {
+            lookups += 1;
+            const constituents = queries.constituents(type);
+            found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
+        }
+        else if (type.isObjectType()) {
+            found = [type];
+        }
+        parts.set(type.id, found);
+        return found;
+    };
+    const tables = new Map();
+    /** The members one object type has, by name. */
+    const membersOf = (type) => {
+        const known = tables.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const table = new Map();
+        const read = properties.of(type);
+        lookups += read.asked ? 1 : 0;
+        for (const property of isAnswered(read.properties) ? read.properties : []) {
+            table.set(property.name, {
+                ids: chains
+                    .declarationsOf(property)
+                    .filter((id) => MEMBER_KINDS.has(kinds.get(id) ?? "file")),
+                handles: new Set(property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`)),
+            });
+        }
+        tables.set(type.id, table);
+        return table;
+    };
+    const writes = [];
+    batches += batchesOf(literals.length);
+    const contexts = queries.contextualTypes(literals.map((one) => one.literal), cap);
+    literals.forEach(({ literal, from }, index) => {
+        const context = contexts[index];
+        if (context === undefined || !isAnswered(context)) {
+            return;
+        }
+        const tablesOf = partsOf(context).map(membersOf);
+        for (const property of literal.properties) {
+            const name = propertyName(property);
+            if (name === undefined) {
+                continue;
+            }
+            const ids = [...new Set(tablesOf.flatMap((table) => table.get(name.text)?.ids ?? []))];
+            if (ids.length > 0) {
+                writes.push({ at: name.node, from, ids });
+            }
+        }
+    });
+    const carried = flows.filter((flow) => !isObjectLiteralExpression(flow.value));
+    batches += batchesOf(carried.length);
+    const types = queries.typesAt(carried.map((flow) => flow.value), cap);
+    /** The members a position may read structurally: those of object types, not of classes. */
+    const readable = (member) => member.ids.filter((id) => kinds.get(id) === "type-member");
+    const carries = (part) => [...membersOf(part).values()].some((member) => readable(member).length > 0);
+    const elements = new Map();
+    /** The element type of an array type, read once per type. */
+    const elementOf = (type) => {
+        if (elements.has(type.id)) {
+            return elements.get(type.id);
+        }
+        lookups += 1;
+        const isArray = queries.isArray(type);
+        let element;
+        if (isAnswered(isArray) && isArray) {
+            lookups += 1;
+            const held = queries.typeArguments(type);
+            element = isAnswered(held) ? held[0] : undefined;
+        }
+        elements.set(type.id, element);
+        return element;
+    };
+    const calls = new Map();
+    /** The parameter and return types of a type's one call signature, read once per type. */
+    const callOf = (type) => {
+        if (calls.has(type.id)) {
+            return calls.get(type.id);
+        }
+        lookups += 1;
+        const signatures = queries.signaturesOf(type, SignatureKind.Call);
+        let called;
+        const [signature, ...more] = isAnswered(signatures) ? signatures : [];
+        if (signature !== undefined && more.length === 0) {
+            const parameters = signature.parameters.map((_parameter, index) => queries.parameterType(signature, index));
+            const result = queries.returnTypeOf(signature);
+            lookups += parameters.length + 1;
+            called = {
+                parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
+                result: isAnswered(result) ? result : undefined,
+            };
+        }
+        calls.set(type.id, called);
+        return called;
+    };
+    /**
+     * Each object type a value of `source` is checked as against the object types of
+     * `target`: the value's own, and through array elements and through a function's
+     * parameters, checked the other way, and its result. A source that is one of the
+     * target's own object types matches it as it stands.
+     */
+    const compared = (source, target, depth, into, seen) => {
+        const key = `${String(source?.id)}>${String(target?.id)}`;
+        if (source === undefined || target === undefined || source.id === target.id) {
+            return;
+        }
+        if (depth > MAX_DEPTH || seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        const targets = partsOf(target);
+        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 });
+            }
+            const element = elementOf(one);
+            const called = element === undefined ? callOf(one) : undefined;
+            for (const part of targets) {
+                if (element !== undefined) {
+                    compared(element, elementOf(part), depth + 1, into, seen);
+                    continue;
+                }
+                const other = called === undefined ? undefined : callOf(part);
+                if (called === undefined || other === undefined) {
+                    continue;
+                }
+                other.parameters.forEach((parameter, index) => {
+                    compared(parameter, called.parameters[index], depth + 1, into, seen);
+                });
+                compared(called.result, other.result, depth + 1, into, seen);
+            }
+        }
+    };
+    /** Whether a value of one type may carry a member a position reads, at any depth the walk takes. */
+    const mayCarry = (type, depth) => depth <= MAX_DEPTH &&
+        partsOf(type).some((part) => {
+            if (carries(part)) {
+                return true;
+            }
+            const element = elementOf(part);
+            if (element !== undefined) {
+                return mayCarry(element, depth + 1);
+            }
+            return callOf(part) !== undefined;
+        });
+    const sourced = carried.flatMap((flow, index) => {
+        const type = types[index];
+        return type === undefined || !isAnswered(type) || !mayCarry(type, 0) ? [] : [{ flow, type }];
+    });
+    batches += batchesOf(sourced.length);
+    const positions = queries.contextualTypes(sourced.map((one) => one.flow.value), cap);
+    const reads = [];
+    sourced.forEach(({ flow, type }, index) => {
+        const position = positions[index];
+        if (position === undefined || !isAnswered(position)) {
+            return;
+        }
+        const checked = [];
+        compared(type, position, 0, checked, new Set());
+        const ids = new Set();
+        for (const { source, targets } of checked) {
+            const tables = targets.map(membersOf);
+            for (const [name, member] of membersOf(source)) {
+                const read = tables.some((table) => {
+                    const declared = table.get(name);
+                    return (declared !== undefined &&
+                        declared.handles.size > 0 &&
+                        ![...declared.handles].some((handle) => member.handles.has(handle)));
+                });
+                if (read) {
+                    for (const id of readable(member)) {
+                        ids.add(id);
+                    }
+                }
+            }
+        }
+        if (ids.size > 0) {
+            reads.push({ at: flow.value, from: flow.from, ids: [...ids] });
+        }
+    });
+    return { writes, reads, batches, lookups };
+}

package/dist/src/convention-rows.js

@@ -45,6 +45,7 @@ export const CONVENTION_ROWS = [
             `<src>/content/config.${MODULE}`,
         ],
         excludes: ["<src>/pages/**/_*", "<src>/pages/**/_*/**"],
+        generated: [".astro"],
         moves: [
             {
                 id: "src",
@@ -71,6 +72,7 @@ export const CONVENTION_ROWS = [
         name: "next",
         package: "next",
         range: ">=13.4.0 <17.0.0",
+        generated: [".next"],
         entries: [
             `{,src/}app/**/{layout,page,loading,not-found,error,route,template,default,forbidden,unauthorized}.${SCRIPT}`,
             `{,src/}app/global-{error,not-found}.${SCRIPT}`,
@@ -87,6 +89,7 @@ export const CONVENTION_ROWS = [
         name: "nuxt",
         package: "nuxt",
         range: ">=3.0.0 <5.0.0",
+        generated: [".nuxt"],
         entries: [
             "<srcDir>/{app,error}.{vue,jsx,tsx}",
             `<srcDir>/app.config.${MODULE}`,
@@ -181,6 +184,7 @@ export const CONVENTION_ROWS = [
         package: "@react-router/dev",
         range: ">=7.0.0 <9.0.0",
         entries: APP_DIRECTORY_ENTRIES,
+        generated: [".react-router"],
         moves: [
             {
                 id: "app",
@@ -259,6 +263,7 @@ export const CONVENTION_ROWS = [
         package: "@sveltejs/kit",
         range: ">=2.0.0 <3.0.0",
         entries: [...SVELTEKIT_ENTRIES, "<params>/*.{js,ts}"],
+        generated: [".svelte-kit"],
         moves: [
             {
                 id: "src",
@@ -323,6 +328,7 @@ export const CONVENTION_ROWS = [
         package: "@sveltejs/kit",
         range: ">=3.0.0 <4.0.0",
         entries: [...SVELTEKIT_ENTRIES, "<params>.{js,ts}"],
+        generated: [".svelte-kit"],
         moves: [
             {
                 id: "src",