@cosmicdrift/kumiko-framework 0.333.0 → 0.335.0

package/dist/scripts/codemod/pii-personal-migration.js

@@ -1,615 +0,0 @@
-#!/usr/bin/env bun
-// Migrates create*Field(...) calls from the old flag-based PII API (pii,
-// userOwned, tenantOwned, subjectRef, allowPlaintext, lookupable,
-// searchable, sensitive) to the author-facing personal/find API
-// (kumiko-framework#2250). Idempotent — re-running is a no-op on already
-// migrated fields (skipped once a `personal` property is present).
-//
-// Mapping table (exact):
-//   pii: true                           -> personal: "self"
-//   userOwned: { ownerField: "x" }      -> personal: { of: "x" }
-//   tenantOwned: true                   -> personal: "tenant"
-//   subjectRef: true                    -> personal: "ref"
-//   allowPlaintext: "R"                 -> personal: false, reason: "<R, normalized to snake_case>"
-//   lookupable: true (alone)            -> find: "exact"
-//   lookupable: true + searchable: true -> find: "fuzzy"
-//   searchable: true (alone)            -> find: "fuzzy"
-//   sensitive: true                     -> find: "secret"
-//   none of the above                   -> find: "none"
-// `find` only applies to text/longText fields, and only when the subject
-// is neither "ref" nor `personal: false` (see PersonalAnnotations in
-// packages/types/src/fields.ts). Never guesses: anything outside this
-// table is reported (file:line) instead of transformed.
-//
-// Usage: bun scripts/codemod/pii-personal-migration.ts <targetDir> [--dry-run]
-import { readFileSync } from "node:fs";
-import { relative, resolve } from "node:path";
-import { PII_DIRECT_NAME_HINTS, PII_USER_OWNED_NAME_HINTS, PII_USER_REFERENCE_NAME_HINTS, } from "@cosmicdrift/kumiko-framework/engine";
-import { Glob } from "bun";
-import { Node, Project, SyntaxKind, } from "ts-morph";
-const SUBJECT_FLAG_NAMES = [
-    "pii",
-    "userOwned",
-    "tenantOwned",
-    "subjectRef",
-    "allowPlaintext",
-];
-// `create*Field` factories that accept `find` (text/longText) — see
-// packages/framework/src/engine/factories.ts.
-const TEXT_FIND_FACTORIES = new Set(["createTextField"]);
-const LONGTEXT_FIND_FACTORIES = new Set(["createLongTextField"]);
-// Accept `personal` but never `find` (PersonalAnnotationsNoFind).
-const NO_FIND_FACTORIES = new Set([
-    "createSelectField",
-    "createMultiSelectField",
-    "createNumberField",
-    "createBigIntField",
-    "createDecimalField",
-    "createEmbeddedField",
-    "createEmbeddedListField",
-    "createJsonbField",
-    "createDateField",
-    "createTimestampField",
-    "createTzField",
-    "createLocatedTimestampField",
-]);
-// No personal-annotation support at all — a subject flag here is a bug.
-const NO_PERSONAL_FACTORIES = new Set([
-    "createBooleanField",
-    "createMoneyField",
-    "createFileField",
-    "createImageField",
-    "createFilesField",
-    "createImagesField",
-    "createDerivedField",
-]);
-// Overrides live in argument position 1, not 0.
-const OVERRIDES_ARG_INDEX_1 = new Set(["createEmbeddedField", "createEmbeddedListField"]);
-const FIELD_FACTORY_RE = /^create\w*Field$/;
-const reports = [];
-const newLookupableSites = [];
-const counts = {
-    exact: 0,
-    fuzzy: 0,
-    none: 0,
-    secret: 0,
-    ref: 0,
-    "personal-false": 0,
-    "no-find": 0,
-};
-function report(node, note) {
-    reports.push({
-        file: node.getSourceFile().getFilePath(),
-        line: node.getStartLineNumber(),
-        note,
-    });
-}
-function isTrueLiteral(node) {
-    return !!node && node.getKind() === SyntaxKind.TrueKeyword;
-}
-function findProp(obj, name) {
-    const p = obj.getProperty(name);
-    return p && Node.isPropertyAssignment(p) ? p : undefined;
-}
-// Reason-string convention (infra/guards/guard-error-reasons.ts):
-// ^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$ — lowercase snake_case, optional
-// dot-namespacing. Old allowPlaintext values are free-form kebab-case.
-function normalizeReasonSlug(raw) {
-    const slug = raw
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9.]+/g, "_")
-        .replace(/_+/g, "_")
-        .replace(/^[._]+|[._]+$/g, "");
-    return /^[0-9]/.test(slug) ? `_${slug}` : slug;
-}
-function collectFieldCalls(sourceFile) {
-    const calls = [];
-    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-        const exprNode = call.getExpression();
-        if (!Node.isIdentifier(exprNode))
-            continue;
-        const name = exprNode.getText();
-        // `createTenantConfig`/`createUserConfig`/etc. never match — they
-        // don't end in "Field", so they're out of scope by construction.
-        if (!FIELD_FACTORY_RE.test(name))
-            continue;
-        const argIndex = OVERRIDES_ARG_INDEX_1.has(name) ? 1 : 0;
-        const objArg = call.getArguments()[argIndex];
-        if (objArg && Node.isObjectLiteralExpression(objArg)) {
-            calls.push({ name, objArg });
-        }
-    }
-    return calls;
-}
-function reportRawSubjectLiterals(sourceFile, handled) {
-    for (const objLit of sourceFile.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression)) {
-        if (handled.has(objLit))
-            continue;
-        const found = [...SUBJECT_FLAG_NAMES, "piiEncrypted"].filter((n) => objLit.getProperty(n));
-        if (found.length > 0) {
-            report(objLit, `subject flag(s) [${found.join(", ")}] on an object literal that is not a create*Field(...) call`);
-        }
-    }
-}
-// kumiko-lint-ignore complexity-budget migration codemod, one-time script — splitting would add risk without benefit
-function processObjectLiteral(obj, factoryName) {
-    // skip: field already carries `personal` — already migrated, idempotent no-op
-    if (obj.getProperty("personal"))
-        return;
-    const piiEncryptedProp = obj.getProperty("piiEncrypted");
-    if (piiEncryptedProp) {
-        report(piiEncryptedProp, "piiEncrypted: true on an entity field (removed from the type system) — needs a human decision, not a mechanical mapping");
-        // skip: reported above — piiEncrypted needs a human decision, not a mechanical mapping
-        return;
-    }
-    const subjectProps = SUBJECT_FLAG_NAMES.map((n) => ({ name: n, prop: findProp(obj, n) })).filter((x) => !!x.prop);
-    const lookupableProp = findProp(obj, "lookupable");
-    const searchableProp = findProp(obj, "searchable");
-    const sensitiveProp = findProp(obj, "sensitive");
-    const anonymizeProp = obj.getProperty("anonymize");
-    if (subjectProps.length === 0) {
-        // `searchable`/`sensitive` alone remain valid, unrelated FieldDef
-        // properties — left untouched. `lookupable` alone can never compile
-        // (always an excess property without a `personal` to attach `find`
-        // to). `anonymize` alone has no PersonalAnnotations arm to live on.
-        if (lookupableProp) {
-            report(lookupableProp, "lookupable without any subject annotation — no `personal` to attach `find` to");
-        }
-        if (anonymizeProp) {
-            report(anonymizeProp, "anonymize without any subject annotation — no PersonalAnnotations arm accepts anonymize alone");
-        }
-        // skip: no subject flag on this field — stray lookupable/anonymize already reported above if present
-        return;
-    }
-    if (subjectProps.length > 1) {
-        const first = subjectProps[0];
-        if (first) {
-            report(first.prop, `multiple subject annotations on one field (${subjectProps.map((s) => s.name).join(", ")}) — needs a human decision on which subject is correct`);
-        }
-        // skip: reported above — multiple subject annotations need a human call on which one wins
-        return;
-    }
-    const subject = subjectProps[0];
-    if (!subject) {
-        // skip: length===0 and length>1 already returned — empty [0] is unreachable
-        return;
-    }
-    if (NO_PERSONAL_FACTORIES.has(factoryName)) {
-        report(subject.prop, `${factoryName} has no personal-annotation support — subject flag "${subject.name}" cannot be expressed here`);
-        // skip: reported above — this factory has no personal-annotation support to migrate into
-        return;
-    }
-    const isTextFind = TEXT_FIND_FACTORIES.has(factoryName);
-    const isLongTextFind = LONGTEXT_FIND_FACTORIES.has(factoryName);
-    const isNoFind = NO_FIND_FACTORIES.has(factoryName);
-    if (!isTextFind && !isLongTextFind && !isNoFind) {
-        report(subject.prop, `unrecognized field factory "${factoryName}" — cannot verify its PersonalAnnotations shape`);
-        // skip: reported above — unknown factory shape, cannot verify safely
-        return;
-    }
-    let personalInit;
-    let reasonInit;
-    if (subject.name === "pii") {
-        if (!isTrueLiteral(subject.prop.getInitializer())) {
-            report(subject.prop, "pii is set to a non-`true` value — cannot infer intent");
-            // skip: reported above — non-`true` pii value, can't infer intent
-            return;
-        }
-        personalInit = `"self"`;
-    }
-    else if (subject.name === "tenantOwned") {
-        if (!isTrueLiteral(subject.prop.getInitializer())) {
-            report(subject.prop, "tenantOwned is set to a non-`true` value — cannot infer intent");
-            // skip: reported above — non-`true` tenantOwned value, can't infer intent
-            return;
-        }
-        personalInit = `"tenant"`;
-    }
-    else if (subject.name === "subjectRef") {
-        if (!isTrueLiteral(subject.prop.getInitializer())) {
-            report(subject.prop, "subjectRef is set to a non-`true` value — cannot infer intent");
-            // skip: reported above — non-`true` subjectRef value, can't infer intent
-            return;
-        }
-        personalInit = `"ref"`;
-    }
-    else if (subject.name === "allowPlaintext") {
-        const init = subject.prop.getInitializer();
-        if (!init) {
-            report(subject.prop, "allowPlaintext has no value");
-            // skip: reported above — allowPlaintext has no value to migrate
-            return;
-        }
-        personalInit = "false";
-        reasonInit = Node.isStringLiteral(init)
-            ? `"${normalizeReasonSlug(init.getLiteralText())}"`
-            : init.getText();
-    }
-    else {
-        const init = subject.prop.getInitializer();
-        if (!init || !Node.isObjectLiteralExpression(init)) {
-            report(subject.prop, "userOwned value is not an object literal — cannot extract ownerField");
-            // skip: reported above — userOwned value isn't an object literal, can't extract ownerField
-            return;
-        }
-        const ownerFieldProp = findProp(init, "ownerField");
-        const ownerFieldInit = ownerFieldProp?.getInitializer();
-        if (!ownerFieldInit) {
-            report(subject.prop, 'userOwned is missing an "ownerField" property');
-            // skip: reported above — userOwned is missing its ownerField property
-            return;
-        }
-        personalInit = `{ of: ${ownerFieldInit.getText()} }`;
-    }
-    const subjectIsRefOrPlaintext = subject.name === "subjectRef" || subject.name === "allowPlaintext";
-    if (subjectIsRefOrPlaintext) {
-        // These PersonalAnnotations arms carry no `find` field at all.
-        if (lookupableProp) {
-            report(lookupableProp, `lookupable combined with personal:${subject.name === "subjectRef" ? '"ref"' : "false"} — findability doesn't apply to this subject, table has no mapping`);
-            // skip: reported above — lookupable doesn't apply to this subject, no mapping to migrate
-            return;
-        }
-        applyTransform(obj, [subject.prop], {
-            personal: personalInit,
-            reason: reasonInit,
-            find: undefined,
-        });
-        counts[subject.name === "subjectRef" ? "ref" : "personal-false"]++;
-        // skip: already transformed above — nothing left to check for this subject
-        return;
-    }
-    if (isNoFind) {
-        const stray = lookupableProp ?? searchableProp ?? sensitiveProp;
-        if (stray) {
-            report(stray, `${factoryName} has no \`find\` in its PersonalAnnotations — findability flag present on a non-text field`);
-            // skip: reported above — findability flag on a non-text field, no valid find to attach
-            return;
-        }
-        applyTransform(obj, [subject.prop], {
-            personal: personalInit,
-            reason: undefined,
-            find: undefined,
-        });
-        counts["no-find"]++;
-        // skip: already transformed above — no-find factory has nothing further to check
-        return;
-    }
-    const hasLookupable = !!lookupableProp;
-    const hasSearchable = !!searchableProp;
-    const hasSensitive = !!sensitiveProp;
-    if (sensitiveProp && (hasLookupable || hasSearchable)) {
-        report(sensitiveProp, 'sensitive combined with lookupable/searchable — two find values ("secret" vs "exact"/"fuzzy"), needs a human decision');
-        // skip: reported above — sensitive plus lookupable/searchable is an ambiguous find value
-        return;
-    }
-    let find;
-    if (hasSensitive)
-        find = "secret";
-    else if (hasLookupable && hasSearchable)
-        find = "fuzzy";
-    else if (hasLookupable)
-        find = "exact";
-    else if (hasSearchable)
-        find = "fuzzy";
-    else
-        find = "none";
-    if (isLongTextFind && (find === "exact" || find === "fuzzy")) {
-        const findSite = lookupableProp ?? searchableProp;
-        if (findSite) {
-            report(findSite, 'lookupable/searchable on createLongTextField — only "none"/"secret" are valid find values on longText');
-        }
-        // skip: reported above — exact/fuzzy find isn't valid on createLongTextField
-        return;
-    }
-    // searchable-alone -> "fuzzy" makes expandPersonalAnnotations add
-    // `lookupable: true`, which the field didn't carry before — that's a
-    // new `_bidx` column (DDL migration), tracked separately for the report.
-    if (hasSearchable && !hasLookupable) {
-        newLookupableSites.push({
-            file: obj.getSourceFile().getFilePath(),
-            line: subject.prop.getStartLineNumber(),
-            // Guard keys on property name `reason`; this is console copy, not an error code.
-            note: "needs a `_bidx` column migration",
-        });
-    }
-    const removedProps = [subject.prop, lookupableProp, searchableProp, sensitiveProp].filter((p) => !!p);
-    applyTransform(obj, removedProps, { personal: personalInit, reason: undefined, find });
-    counts[find]++;
-}
-function applyTransform(obj, removedProps, next) {
-    const properties = obj.getProperties();
-    // Call sites always pass at least subject.prop; without an anchor there is nowhere to insert.
-    const anchor = removedProps[0];
-    if (!anchor) {
-        // skip: no removed prop to anchor inserts on — nothing to transform
-        return;
-    }
-    const anchorIndex = properties.indexOf(anchor);
-    const removedSet = new Set(removedProps);
-    let insertIndex = 0;
-    for (let i = 0; i < anchorIndex; i++) {
-        if (!removedSet.has(properties[i]))
-            insertIndex++;
-    }
-    for (const p of removedProps)
-        p.remove();
-    const newProps = [
-        { name: "personal", initializer: next.personal },
-    ];
-    if (next.find)
-        newProps.push({ name: "find", initializer: `"${next.find}"` });
-    if (next.reason !== undefined)
-        newProps.push({ name: "reason", initializer: next.reason });
-    obj.insertPropertyAssignments(insertIndex, newProps);
-}
-function findTargetFiles(rootDir) {
-    const glob = new Glob("**/*.{ts,tsx}");
-    // engine/factories.ts constructs raw ResolvedPiiFlags literals as the
-    // *implementation* of expandPersonalAnnotations (personal -> flags) —
-    // not an authored override, so it's not a migration target.
-    const EXCLUDE = ["/node_modules/", "/dist/", "/build/", "/engine/factories.ts"];
-    const files = [];
-    for (const file of glob.scanSync({ cwd: rootDir, dot: false })) {
-        const abs = resolve(rootDir, file);
-        if (EXCLUDE.some((p) => abs.includes(p)))
-            continue;
-        files.push(abs);
-    }
-    return files.sort();
-}
-const ALL_PII_NAME_HINTS = [
-    ...PII_DIRECT_NAME_HINTS,
-    ...PII_USER_OWNED_NAME_HINTS,
-    ...PII_USER_REFERENCE_NAME_HINTS,
-];
-const REPORT_STANCE_CALLEES = new Set(["createTextField", "createLongTextField"]);
-// Mirrors guard-text-field-stance.ts's hasPersonalStance exactly.
-function reportStanceHasPersonalStance(obj) {
-    const prop = obj.getProperty("personal");
-    if (!prop || !Node.isPropertyAssignment(prop))
-        return false;
-    const init = prop.getInitializer();
-    return (init !== undefined &&
-        init.getKind() !== SyntaxKind.UndefinedKeyword &&
-        !(Node.isIdentifier(init) && init.getText() === "undefined") &&
-        init.getKind() !== SyntaxKind.NullKeyword);
-}
-function reportStanceEnclosingFieldName(call) {
-    let node = call.getParent();
-    while (node) {
-        if (Node.isPropertyAssignment(node))
-            return node.getName();
-        node = node.getParent();
-    }
-    return undefined;
-}
-function reportStanceResolveEntity(call) {
-    let node = call.getParent();
-    let entityCall;
-    while (node) {
-        if (Node.isCallExpression(node)) {
-            const expr = node.getExpression();
-            if (Node.isIdentifier(expr) && expr.getText() === "createEntity") {
-                entityCall = node;
-                break;
-            }
-        }
-        node = node.getParent();
-    }
-    if (!entityCall)
-        return null;
-    const firstArg = entityCall.getArguments()[0];
-    if (firstArg && Node.isObjectLiteralExpression(firstArg)) {
-        const tableProp = firstArg.getProperty("table");
-        if (tableProp && Node.isPropertyAssignment(tableProp)) {
-            const init = tableProp.getInitializer();
-            if (init && Node.isStringLiteral(init))
-                return init.getLiteralText();
-        }
-    }
-    const varDecl = entityCall.getParentIfKind(SyntaxKind.VariableDeclaration);
-    return varDecl ? varDecl.getName() : null;
-}
-// A hint only counts at a segment boundary (index 0, an uppercase letter in
-// the original, or preceded by `_`) — otherwise a coincidental substring
-// like "text" inside "contextId" would false-positive.
-function hintOccursAtBoundary(fieldLower, fieldOriginal, hint) {
-    let searchFrom = 0;
-    for (;;) {
-        const index = fieldLower.indexOf(hint, searchFrom);
-        if (index === -1)
-            return false;
-        const atBoundary = index === 0 || /[A-Z]/.test(fieldOriginal[index] ?? "") || fieldOriginal[index - 1] === "_";
-        if (atBoundary)
-            return true;
-        searchFrom = index + 1;
-    }
-}
-function findLongestBoundaryHint(fieldLower, fieldOriginal) {
-    let best;
-    for (const hint of ALL_PII_NAME_HINTS) {
-        if (best && hint.length <= best.length)
-            continue;
-        if (hintOccursAtBoundary(fieldLower, fieldOriginal, hint))
-            best = hint;
-    }
-    return best;
-}
-function segmentAlignedSuffixes(fieldOriginal) {
-    const fieldLower = fieldOriginal.toLowerCase();
-    const suffixes = [];
-    for (let index = 0; index < fieldOriginal.length; index++) {
-        const atBoundary = index === 0 || /[A-Z]/.test(fieldOriginal[index] ?? "") || fieldOriginal[index - 1] === "_";
-        if (atBoundary)
-            suffixes.push(fieldLower.slice(index));
-    }
-    return suffixes;
-}
-// The hint sets only carry exact full names, so a suffix variant of one
-// (e.g. "...UserId" of "assigneeUserId") otherwise slips through undetected.
-function findShortestHintContainingSuffix(fieldOriginal) {
-    let best;
-    for (const suffix of segmentAlignedSuffixes(fieldOriginal)) {
-        if (suffix.length < 5)
-            continue;
-        for (const hint of ALL_PII_NAME_HINTS) {
-            if (!hint.includes(suffix))
-                continue;
-            if (!best || hint.length < best.length)
-                best = hint;
-        }
-    }
-    return best;
-}
-function classifyFieldStance(field) {
-    const fieldLower = field.toLowerCase();
-    if (PII_DIRECT_NAME_HINTS.has(fieldLower))
-        return { stance: "direct", hint: fieldLower };
-    if (PII_USER_OWNED_NAME_HINTS.has(fieldLower))
-        return { stance: "user-owned", hint: fieldLower };
-    if (PII_USER_REFERENCE_NAME_HINTS.has(fieldLower))
-        return { stance: "user-reference", hint: fieldLower };
-    const containmentHint = findLongestBoundaryHint(fieldLower, field);
-    if (containmentHint)
-        return { stance: "near-miss", hint: containmentHint };
-    const suffixHint = findShortestHintContainingSuffix(field);
-    if (suffixHint)
-        return { stance: "near-miss", hint: suffixHint };
-    return { stance: "unclassified", hint: undefined };
-}
-export function reportStanceForSource(source, filePath) {
-    const project = new Project({ useInMemoryFileSystem: true, skipFileDependencyResolution: true });
-    const sourceFile = project.createSourceFile(filePath, source);
-    const sites = [];
-    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-        const exprNode = call.getExpression();
-        if (!Node.isIdentifier(exprNode))
-            continue;
-        const callee = exprNode.getText();
-        if (!REPORT_STANCE_CALLEES.has(callee))
-            continue;
-        const args = call.getArguments();
-        if (args.length > 0) {
-            const options = args[0];
-            if (!options || !Node.isObjectLiteralExpression(options))
-                continue;
-            if (options.getProperties().some((p) => p.isKind(SyntaxKind.SpreadAssignment)))
-                continue;
-            if (reportStanceHasPersonalStance(options))
-                continue;
-        }
-        const enclosingField = reportStanceEnclosingFieldName(call);
-        // A call with no enclosing field (e.g. a bare createTextField() at top
-        // level) has no real name to classify — `createTextField(...)` would
-        // otherwise false-positive as a near-miss on its own "Text".
-        const { stance, hint } = enclosingField
-            ? classifyFieldStance(enclosingField)
-            : { stance: "unclassified", hint: undefined };
-        sites.push({
-            line: call.getStartLineNumber(),
-            field: enclosingField ?? `${callee}(...)`,
-            entity: reportStanceResolveEntity(call),
-            callee,
-            stance,
-            hint,
-        });
-    }
-    return sites;
-}
-function findReportStanceFiles(rootDir) {
-    const glob = new Glob("**/*.{ts,tsx}");
-    const EXCLUDE = ["/node_modules/", "/dist/", "/build/"];
-    const files = [];
-    for (const file of glob.scanSync({ cwd: rootDir, dot: false })) {
-        if (file.endsWith(".d.ts"))
-            continue;
-        const abs = resolve(rootDir, file);
-        if (EXCLUDE.some((p) => abs.includes(p)))
-            continue;
-        files.push(abs);
-    }
-    return files.sort();
-}
-function reportStance(rootDir) {
-    console.log(`Scanning every .ts/.tsx under ${rootDir} except node_modules/dist/build/*.d.ts — guard-text-field-stance scans packages/*/src/** only, so counts can differ outside that scope.`);
-    const totals = {
-        direct: 0,
-        "user-owned": 0,
-        "user-reference": 0,
-        "near-miss": 0,
-        unclassified: 0,
-    };
-    let total = 0;
-    for (const file of findReportStanceFiles(rootDir)) {
-        const sites = reportStanceForSource(readFileSync(file, "utf8"), file);
-        if (sites.length === 0)
-            continue;
-        console.log(`\n${relative(rootDir, file)}`);
-        for (const site of sites) {
-            totals[site.stance]++;
-            total++;
-            const entity = site.entity ?? "<unresolved>";
-            const hintSuffix = site.hint ? ` (hint: ${site.hint})` : "";
-            console.log(`  ${site.line}  ${site.field}  entity=${entity}  ${site.callee}  ${site.stance}${hintSuffix}`);
-        }
-    }
-    console.log("\nBy stance:");
-    for (const [stance, count] of Object.entries(totals)) {
-        if (count > 0)
-            console.log(`  ${stance}: ${count}`);
-    }
-    console.log(`Total: ${total}`);
-    if (totals["near-miss"] > 0) {
-        console.log("\nHint sets in entity-handler.ts are exact name matches — near-miss field names slip past the boot heuristic.");
-    }
-}
-async function main() {
-    const positional = process.argv.slice(2).filter((a) => !a.startsWith("--"));
-    const rootDir = resolve(positional[0] ?? process.cwd());
-    if (process.argv.includes("--report-stance")) {
-        reportStance(rootDir);
-        // skip: report mode never rewrites, so the transform path below must not run
-        return;
-    }
-    const dryRun = process.argv.includes("--dry-run");
-    const files = findTargetFiles(rootDir);
-    const project = new Project({
-        skipAddingFilesFromTsConfig: true,
-        skipFileDependencyResolution: true,
-    });
-    let touchedFiles = 0;
-    for (const file of files) {
-        const sourceFile = project.addSourceFileAtPath(file);
-        const calls = collectFieldCalls(sourceFile);
-        const handled = new Set(calls.map((c) => c.objArg));
-        reportRawSubjectLiterals(sourceFile, handled);
-        const countsBefore = { ...counts };
-        for (const { name, objArg } of calls)
-            processObjectLiteral(objArg, name);
-        const changed = Object.keys(counts).some((k) => counts[k] !== countsBefore[k]);
-        if (changed) {
-            touchedFiles++;
-            if (!dryRun)
-                sourceFile.saveSync();
-        }
-    }
-    console.log(`\nScanned ${files.length} files under ${rootDir}${dryRun ? " (dry-run)" : ""}.`);
-    console.log(`Touched ${touchedFiles} files.\n`);
-    console.log("Transformed, by find/personal bucket:");
-    for (const [bucket, n] of Object.entries(counts)) {
-        if (n > 0)
-            console.log(`  ${bucket}: ${n}`);
-    }
-    console.log(`\nNewly gains lookupable (needs a _bidx migration): ${newLookupableSites.length}`);
-    for (const r of newLookupableSites) {
-        console.log(`  ${relative(rootDir, r.file)}:${r.line} — ${r.note}`);
-    }
-    console.log(`\nReported (not transformed): ${reports.length}`);
-    for (const r of reports) {
-        console.log(`  ${relative(rootDir, r.file)}:${r.line} — ${r.note}`);
-    }
-}
-if (import.meta.main) {
-    await main();
-}

package/dist/scripts/codemod/unprocessable-error-details-reason.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-export {};