@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/object-pack-semantic-preview.js

@@ -0,0 +1,984 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planObjectPackSemanticPreview = planObjectPackSemanticPreview;
+exports.validateVirtualProjectDiagnostics = validateVirtualProjectDiagnostics;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const targeted_import_canonicalizer_1 = require("./targeted-import-canonicalizer");
+const concrete_edit_plan_1 = require("./concrete-edit-plan");
+const object_mutation_partition_1 = require("./object-mutation-partition");
+const semantic_workspace_1 = require("./semantic-workspace");
+const runtime_cycle_query_1 = require("./runtime-cycle-query");
+function planObjectPackSemanticPreview(cwd, input) {
+    return (0, object_mutation_partition_1.planBestEffortObjectMutation)(input.rows, (rows) => planObjectPackSemanticPreviewStrict(cwd, { sourceFile: input.sourceFile, rows }), { blocksWholeGroup: (issue) => !issue.selector });
+}
+function planObjectPackSemanticPreviewStrict(cwd, input) {
+    const root = path.resolve(cwd);
+    const sourceFile = path.resolve(root, input.sourceFile);
+    const displaySource = toRepoPath(root, sourceFile);
+    const rows = input.rows.map((row) => ({
+        objectName: row.objectName,
+        selectors: [...new Set(row.selectors)].sort()
+    })).sort((left, right) => left.objectName.localeCompare(right.objectName));
+    const unsupported = [];
+    if (!isSupportedSourceExtension(sourceFile)) {
+        unsupported.push({
+            code: "OBJECT_PACK_SOURCE_KIND_UNSUPPORTED",
+            message: "object.pack semantic preview supports TS/TSX/MTS ESM sources only",
+            file: displaySource
+        });
+        return failure(displaySource, rows, unsupported);
+    }
+    const workspace = (0, semantic_workspace_1.createSemanticWorkspace)({ workspaceRoot: root, focusFiles: [sourceFile] });
+    const moduleCollection = (0, semantic_workspace_1.collectSemanticModuleEdges)(workspace);
+    let moduleScope = (0, semantic_workspace_1.scopeRelevantSemanticModuleEdges)(workspace, moduleCollection, {
+        sourceFiles: [displaySource]
+    });
+    if (!moduleScope.coverage.complete) {
+        unsupported.push(...moduleScope.coverage.incompleteReasons.map(toCoverageEvidence));
+        unsupported.push({
+            code: "OBJECT_PACK_CYCLE_EVIDENCE_UNAVAILABLE",
+            message: "runtime cycle evidence is unavailable because semantic coverage is incomplete",
+            file: displaySource
+        });
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    const sourceProjects = (0, semantic_workspace_1.ownersForSemanticFile)(workspace, sourceFile);
+    if (sourceProjects.length > 1) {
+        unsupported.push({
+            code: "OBJECT_PACK_MULTIPLE_OWNERS_UNSUPPORTED",
+            message: "object.pack semantic preview requires exactly one owning project in M2",
+            file: displaySource,
+            details: sourceProjects.map((project) => toRepoPath(root, project.config.file))
+        });
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    if (sourceProjects.length === 0 || sourceProjects.some((project) => {
+        const source = project.program.getSourceFile(sourceFile);
+        return !source || !isEsmSourceFile(project, source);
+    })) {
+        unsupported.push({
+            code: "OBJECT_PACK_ESM_REQUIRED",
+            message: "object.pack semantic preview requires an ESM source in its owning project",
+            file: displaySource
+        });
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    const sourceProject = sourceProjects[0];
+    const source = sourceProject.program.getSourceFile(sourceFile);
+    const selected = resolveSelectedMembers(workspace, sourceProject, source, rows, unsupported);
+    validateVariableStatements(selected, unsupported, displaySource);
+    if (unsupported.length > 0) {
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    const selectedByKey = new Map(selected.map((member) => [member.symbol.key, member]));
+    const usageReplacements = new Map();
+    const externalReferenceCounts = new Map();
+    for (const member of selected) {
+        member.usages = (0, semantic_workspace_1.findSemanticReferences)(workspace, member.symbol);
+    }
+    moduleScope = (0, semantic_workspace_1.scopeRelevantSemanticModuleEdges)(workspace, moduleCollection, {
+        sourceFiles: [displaySource],
+        affectedFiles: selected.flatMap((member) => member.usages.map((usage) => usage.file))
+    });
+    if (!moduleScope.coverage.complete) {
+        unsupported.push(...moduleScope.coverage.incompleteReasons.map(toCoverageEvidence));
+        unsupported.push({
+            code: "OBJECT_PACK_CYCLE_EVIDENCE_UNAVAILABLE",
+            message: "runtime cycle evidence is unavailable because relevant module resolution is incomplete",
+            file: displaySource
+        });
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    if (moduleScope.edges.some((edge) => edge.kind === "dynamic" && edge.toFile === displaySource)) {
+        unsupported.push({
+            code: "OBJECT_PACK_DYNAMIC_IMPORT_UNSUPPORTED",
+            message: "dynamic imports of the packed source are not supported",
+            file: displaySource
+        });
+    }
+    if (moduleScope.edges.some((edge) => edge.kind === "require" && edge.toFile === displaySource)) {
+        unsupported.push({
+            code: "OBJECT_PACK_REQUIRE_UNSUPPORTED",
+            message: "CommonJS require of the packed source is not supported",
+            file: displaySource
+        });
+    }
+    validateRequireConsumers(workspace, sourceFile, unsupported);
+    const cycleEvidence = (0, runtime_cycle_query_1.queryRuntimeCycleEvidence)(moduleScope.edges, [displaySource]);
+    if (cycleEvidence.cycles.length > 0) {
+        unsupported.push({
+            code: "OBJECT_PACK_RUNTIME_CYCLE_UNSUPPORTED",
+            message: "packed source participates in a runtime import cycle; initialization order cannot be preserved safely",
+            file: displaySource,
+            details: cycleEvidence.cycles
+        });
+    }
+    validateAffectedFileOwnership(workspace, sourceFile, selected, moduleScope.edges, unsupported);
+    if (unsupported.length > 0) {
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    for (const member of selected) {
+        validateAndPlanUsages(workspace, sourceFile, member, usageReplacements, externalReferenceCounts, unsupported);
+    }
+    const importTransforms = planConsumerImports(workspace, sourceFile, selectedByKey, unsupported);
+    validateReExports(workspace, sourceFile, selectedByKey, unsupported);
+    if (unsupported.length > 0) {
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    const sourceText = fs.readFileSync(sourceFile, "utf8");
+    const sourceNext = buildSourceText(source, sourceText, selected, rows);
+    const virtualTexts = new Map([[displaySource, sourceNext]]);
+    const consumerSummaries = [];
+    const consumerFiles = new Set([
+        ...usageReplacements.keys(),
+        ...importTransforms.keys()
+    ]);
+    for (const file of [...consumerFiles].sort()) {
+        if ((0, semantic_workspace_1.canonicalPathIdentity)(path.resolve(root, file)) === (0, semantic_workspace_1.canonicalPathIdentity)(sourceFile)) {
+            continue;
+        }
+        const absolute = path.resolve(root, file);
+        const original = fs.readFileSync(absolute, "utf8");
+        const replacements = [
+            ...(usageReplacements.get(file) ?? []),
+            ...(importTransforms.get(file)?.replacements ?? [])
+        ];
+        const rewritten = applyReplacements(original, replacements);
+        const canonicalized = (0, targeted_import_canonicalizer_1.formatChangedNamedImports)(original, rewritten, absolute).text;
+        if (canonicalized !== original) {
+            virtualTexts.set(file, canonicalized);
+            consumerSummaries.push({
+                file,
+                text: canonicalized,
+                objectNames: importTransforms.get(file)?.objectNames ?? [],
+                selectors: importTransforms.get(file)?.selectors ?? [],
+                referenceCount: externalReferenceCounts.get(file) ?? 0
+            });
+        }
+    }
+    if (!moduleShapesUnchanged(root, virtualTexts)) {
+        unsupported.push({
+            code: "OBJECT_PACK_MODULE_EDGE_CHANGE_UNSUPPORTED",
+            message: "planned edits change module edge shape; cycle evidence is no longer sufficient",
+            file: displaySource
+        });
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    const diagnostics = validateVirtualProjectDiagnostics(workspace, virtualTexts);
+    if (diagnostics.added.length > 0) {
+        unsupported.push({
+            code: "OBJECT_PACK_NEW_DIAGNOSTICS",
+            message: "virtual object.pack edits introduce new project diagnostics",
+            file: displaySource,
+            details: diagnostics.added
+        });
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    const edits = [...virtualTexts.entries()].map(([file, text]) => ({
+        file,
+        start: 0,
+        end: fs.readFileSync(path.resolve(root, file), "utf8").length,
+        text,
+        reason: file === displaySource ? "object.pack source preview" : "object.pack consumer preview"
+    })).sort((left, right) => left.file.localeCompare(right.file));
+    const beforeHashes = (0, concrete_edit_plan_1.createConcretePreconditions)(root, edits);
+    const symbols = selected.map((member) => member.symbol).sort((left, right) => left.key.localeCompare(right.key));
+    const usages = selected.flatMap((member) => member.usages).sort(compareUsages);
+    const fingerprintModuleEdges = collectFingerprintModuleEdges(moduleScope.edges, displaySource);
+    const rowFingerprints = rows.map((row) => {
+        const rowMembers = selected.filter((member) => member.objectName === row.objectName);
+        const rowKeys = new Set(rowMembers.map((member) => member.symbol.key));
+        return (0, concrete_edit_plan_1.createSemanticFingerprint)({
+            intent: {
+                operation: "object.pack",
+                sourceFile: displaySource,
+                objectName: row.objectName,
+                members: row.selectors,
+                exportMode: "named"
+            },
+            projects: moduleScope.coverage.projects,
+            symbols: rowMembers.map((member) => member.symbol),
+            references: usages.filter((usage) => rowKeys.has(usage.symbol.key)),
+            moduleEdges: fingerprintModuleEdges
+        });
+    });
+    const semanticFingerprint = sha256(rowFingerprints.join("\0"));
+    return {
+        ok: true,
+        operation: "exports.object.pack.preview",
+        sourceFile: displaySource,
+        objectCount: rows.length,
+        memberCount: selected.length,
+        importerCount: consumerSummaries.length,
+        referenceCount: consumerSummaries.reduce((sum, item) => sum + item.referenceCount, 0),
+        objects: rows,
+        importers: consumerSummaries.map((item) => ({
+            file: item.file,
+            objectNames: item.objectNames,
+            selectors: item.selectors,
+            referenceCount: item.referenceCount
+        })),
+        filesTouched: edits.map((edit) => edit.file),
+        filesWritten: [],
+        semanticFingerprint,
+        rowFingerprints,
+        edits,
+        beforeHashes,
+        coverage: moduleScope.coverage,
+        symbols,
+        usages,
+        moduleEdges: fingerprintModuleEdges,
+        cycleEvidence,
+        diagnostics,
+        unsupported: []
+    };
+}
+function validateVirtualProjectDiagnostics(workspace, virtualTexts) {
+    const overrides = new Map([...virtualTexts.entries()].map(([file, text]) => [
+        (0, semantic_workspace_1.canonicalPathIdentity)(path.resolve(workspace.root, file)),
+        text
+    ]));
+    const baseline = new Map();
+    const next = new Map();
+    for (const project of workspace.projects) {
+        for (const diagnostic of typescript_1.default.getPreEmitDiagnostics(project.program)) {
+            baseline.set(diagnosticKey(workspace.root, diagnostic), diagnostic);
+        }
+        const options = project.config.parsed.options;
+        const host = typescript_1.default.createCompilerHost(options);
+        const originalReadFile = host.readFile.bind(host);
+        host.readFile = (file) => overrides.get((0, semantic_workspace_1.canonicalPathIdentity)(file)) ?? originalReadFile(file);
+        host.getSourceFile = (file, languageVersion, onError) => {
+            const text = host.readFile(file);
+            if (text === undefined) {
+                onError?.(`Unable to read ${file}`);
+                return undefined;
+            }
+            return typescript_1.default.createSourceFile(file, text, languageVersion, true, scriptKindForFile(file));
+        };
+        const program = typescript_1.default.createProgram({
+            rootNames: project.program.getRootFileNames(),
+            options,
+            host
+        });
+        for (const diagnostic of typescript_1.default.getPreEmitDiagnostics(program)) {
+            next.set(diagnosticKey(workspace.root, diagnostic), diagnostic);
+        }
+    }
+    const added = [...next.entries()]
+        .filter(([key]) => !baseline.has(key))
+        .map(([, diagnostic]) => toObjectDiagnostic(workspace.root, diagnostic))
+        .sort((left, right) => (left.file ?? "").localeCompare(right.file ?? "") || left.code.localeCompare(right.code));
+    return { baselineCount: baseline.size, nextCount: next.size, added };
+}
+function resolveSelectedMembers(workspace, sourceProject, source, rows, unsupported) {
+    const selected = [];
+    const selectorOwners = new Map();
+    const objectNames = new Set();
+    for (const row of rows) {
+        if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(row.objectName)) {
+            unsupported.push({ code: "OBJECT_PACK_OBJECT_NAME_INVALID", message: "object name must be a valid identifier", objectName: row.objectName });
+            continue;
+        }
+        if (objectNames.has(row.objectName)) {
+            unsupported.push({ code: "OBJECT_PACK_DUPLICATE_OBJECT", message: "object name is used by more than one row", objectName: row.objectName });
+            continue;
+        }
+        objectNames.add(row.objectName);
+        if (sourceProject.checker.resolveName(row.objectName, source, typescript_1.default.SymbolFlags.Value | typescript_1.default.SymbolFlags.Type | typescript_1.default.SymbolFlags.Namespace, false)) {
+            unsupported.push({
+                code: "OBJECT_PACK_OBJECT_COLLISION",
+                message: "object name already resolves in source scope",
+                objectName: row.objectName,
+                file: toRepoPath(workspace.root, source.fileName)
+            });
+        }
+        for (const selector of row.selectors) {
+            if (selectorOwners.has(selector)) {
+                unsupported.push({
+                    code: "OBJECT_PACK_SELECTOR_OVERLAP",
+                    message: `selector is already assigned to ${selectorOwners.get(selector)}`,
+                    selector,
+                    objectName: row.objectName
+                });
+                continue;
+            }
+            selectorOwners.set(selector, row.objectName);
+            const resolution = (0, semantic_workspace_1.resolveExportedSemanticSymbol)(workspace, source.fileName, selector);
+            if (resolution.status !== "resolved" || !resolution.symbol) {
+                unsupported.push({
+                    code: resolution.status === "ambiguous" ? "OBJECT_PACK_SELECTOR_AMBIGUOUS" : "OBJECT_PACK_SELECTOR_NOT_FOUND",
+                    message: resolution.status === "ambiguous" ? "exported selector resolves differently across owning projects" : "exported selector was not found",
+                    selector,
+                    objectName: row.objectName,
+                    details: resolution.reason
+                });
+                continue;
+            }
+            if ((resolution.symbol.flags & (typescript_1.default.SymbolFlags.Class | typescript_1.default.SymbolFlags.Enum | typescript_1.default.SymbolFlags.NamespaceModule |
+                typescript_1.default.SymbolFlags.ValueModule | typescript_1.default.SymbolFlags.TypeAlias | typescript_1.default.SymbolFlags.Interface)) !== 0) {
+                unsupported.push({
+                    code: "OBJECT_PACK_DUAL_NAMESPACE_UNSUPPORTED",
+                    message: "selected export participates in a type, class, enum, or namespace merge",
+                    selector,
+                    objectName: row.objectName
+                });
+                continue;
+            }
+            const declaration = findDeclarationByIdentity(source, resolution.symbol);
+            if (declaration && typescript_1.default.isFunctionDeclaration(declaration) && source.statements.filter((statement) => typescript_1.default.isFunctionDeclaration(statement) && statement.name?.text === selector).length > 1) {
+                unsupported.push({
+                    code: "OBJECT_PACK_OVERLOAD_UNSUPPORTED",
+                    message: "overload declaration sets are not supported",
+                    selector,
+                    objectName: row.objectName
+                });
+                continue;
+            }
+            const validated = validateSelectedDeclaration(declaration, selector, row.objectName, unsupported, source);
+            if (validated) {
+                selected.push({
+                    objectName: row.objectName,
+                    selector,
+                    symbol: resolution.symbol,
+                    declaration: validated.declaration,
+                    statement: validated.statement,
+                    usages: []
+                });
+            }
+        }
+    }
+    return selected;
+}
+function validateSelectedDeclaration(declaration, selector, objectName, unsupported, source) {
+    if (declaration && typescript_1.default.isFunctionDeclaration(declaration) && declaration.name) {
+        if (!hasExportModifier(declaration) || hasDefaultModifier(declaration)) {
+            unsupported.push({ code: "OBJECT_PACK_NAMED_EXPORT_REQUIRED", message: "selected function must be a named export declaration", selector, objectName });
+            return null;
+        }
+        if (containsThisSensitiveSyntax(declaration)) {
+            unsupported.push({ code: "OBJECT_PACK_THIS_SENSITIVE", message: "selected function contains this/super-sensitive semantics", selector, objectName, file: source.fileName });
+            return null;
+        }
+        return { declaration, statement: declaration };
+    }
+    if (declaration && typescript_1.default.isVariableDeclaration(declaration) && typescript_1.default.isIdentifier(declaration.name)) {
+        const list = declaration.parent;
+        const statement = list.parent;
+        if (!typescript_1.default.isVariableDeclarationList(list) || !typescript_1.default.isVariableStatement(statement) ||
+            (list.flags & typescript_1.default.NodeFlags.Const) === 0 || !declaration.initializer || !hasExportModifier(statement) || hasDefaultModifier(statement)) {
+            unsupported.push({ code: "OBJECT_PACK_CONST_EXPORT_REQUIRED", message: "selected value must be an initialized exported const", selector, objectName });
+            return null;
+        }
+        if (containsThisSensitiveSyntax(declaration.initializer)) {
+            unsupported.push({ code: "OBJECT_PACK_THIS_SENSITIVE", message: "selected const initializer contains this/super-sensitive semantics", selector, objectName });
+            return null;
+        }
+        return { declaration, statement };
+    }
+    unsupported.push({
+        code: "OBJECT_PACK_DECLARATION_KIND_UNSUPPORTED",
+        message: "object.pack supports named function declarations and initialized const values only",
+        selector,
+        objectName
+    });
+    return null;
+}
+function validateVariableStatements(selected, unsupported, sourceFile) {
+    const selectedDeclarations = new Set(selected.map((member) => `${member.declaration.getStart()}\0${member.declaration.end}`));
+    const seen = new Set();
+    for (const member of selected) {
+        if (!typescript_1.default.isVariableStatement(member.statement) || seen.has(member.statement)) {
+            continue;
+        }
+        seen.add(member.statement);
+        const missing = member.statement.declarationList.declarations.filter((declaration) => !selectedDeclarations.has(`${declaration.getStart()}\0${declaration.end}`));
+        if (missing.length > 0) {
+            unsupported.push({
+                code: "OBJECT_PACK_PARTIAL_VARIABLE_STATEMENT_UNSUPPORTED",
+                message: "all declarations in an exported const statement must be selected",
+                file: sourceFile,
+                details: missing.map((declaration) => declaration.name.getText())
+            });
+        }
+    }
+}
+function validateAndPlanUsages(workspace, sourceFile, member, replacements, externalReferenceCounts, unsupported) {
+    for (const usage of member.usages) {
+        const project = workspace.projects.find((candidate) => toRepoPath(workspace.root, candidate.config.file) === usage.project);
+        const source = project?.program.getSourceFile(path.resolve(workspace.root, usage.file));
+        const node = source ? findIdentifierAt(source, usage.start, usage.end) : null;
+        if (!project || !source || !node) {
+            unsupported.push({ code: "OBJECT_PACK_REFERENCE_NODE_UNRESOLVED", message: "checker reference could not be mapped back to syntax", selector: member.selector, file: usage.file });
+            continue;
+        }
+        if (isDeclarationName(node) || findAncestor(node, typescript_1.default.isImportSpecifier)) {
+            continue;
+        }
+        if (findAncestor(node, typescript_1.default.isExportSpecifier)) {
+            unsupported.push({ code: "OBJECT_PACK_REEXPORT_UNSUPPORTED", message: "re-export of a selected symbol is unsupported", selector: member.selector, file: usage.file });
+            continue;
+        }
+        const sourceLocal = (0, semantic_workspace_1.canonicalPathIdentity)(source.fileName) === (0, semantic_workspace_1.canonicalPathIdentity)(sourceFile);
+        const rejectedKinds = usage.kinds.filter((kind) => [
+            "property-write",
+            "update/delete",
+            "destructure",
+            "namespace",
+            "re-export",
+            "type-position/type-query",
+            "escape/identity",
+            "dynamic/require"
+        ].includes(kind));
+        if (isNamespaceQualifiedReference(node, project.checker)) {
+            rejectedKinds.push("namespace");
+        }
+        if (rejectedKinds.length > 0) {
+            unsupported.push({
+                code: "OBJECT_PACK_USAGE_UNSUPPORTED",
+                message: "selected symbol has an unsupported reference flow",
+                selector: member.selector,
+                file: usage.file,
+                usageKinds: [...new Set(rejectedKinds)].sort()
+            });
+            continue;
+        }
+        if (usage.kinds.includes("direct-call") && !supportsPropertyCall(member)) {
+            unsupported.push({
+                code: "OBJECT_PACK_CALL_BINDING_UNPROVEN",
+                message: "callable const initializer is not proven safe when invoked as an object property",
+                selector: member.selector,
+                file: usage.file,
+                usageKinds: usage.kinds
+            });
+            continue;
+        }
+        if (sourceLocal) {
+            continue;
+        }
+        if (project.checker.resolveName(member.objectName, node, typescript_1.default.SymbolFlags.Value, false)) {
+            unsupported.push({
+                code: "OBJECT_PACK_SCOPED_OBJECT_COLLISION",
+                message: "object import name is shadowed at a selected reference site",
+                selector: member.selector,
+                objectName: member.objectName,
+                file: usage.file
+            });
+            continue;
+        }
+        const replacement = `${member.objectName}.${member.selector}`;
+        const shorthand = findAncestor(node, typescript_1.default.isShorthandPropertyAssignment);
+        if (shorthand) {
+            addReplacement(replacements, usage.file, {
+                start: shorthand.getStart(source),
+                end: shorthand.end,
+                text: `${node.text}: ${replacement}`,
+                reason: `object.pack shorthand ${member.selector}`
+            });
+        }
+        else if (usage.kinds.every((kind) => kind === "direct-call" || kind === "value-pass")) {
+            addReplacement(replacements, usage.file, {
+                start: node.getStart(source),
+                end: node.end,
+                text: replacement,
+                reason: `object.pack reference ${member.selector}`
+            });
+        }
+        else {
+            unsupported.push({
+                code: "OBJECT_PACK_USAGE_UNCLASSIFIED",
+                message: "reference flow was not classified as a supported concrete rewrite",
+                selector: member.selector,
+                file: usage.file,
+                usageKinds: usage.kinds
+            });
+            continue;
+        }
+        externalReferenceCounts.set(usage.file, (externalReferenceCounts.get(usage.file) ?? 0) + 1);
+    }
+}
+function validateRequireConsumers(workspace, sourceFile, unsupported) {
+    const seenFiles = new Set();
+    for (const project of workspace.projects) {
+        for (const file of project.config.parsed.fileNames) {
+            const fileKey = (0, semantic_workspace_1.canonicalPathIdentity)(file);
+            if (seenFiles.has(fileKey)) {
+                continue;
+            }
+            seenFiles.add(fileKey);
+            const source = project.program.getSourceFile(file);
+            if (!source) {
+                continue;
+            }
+            const visit = (node) => {
+                if (typescript_1.default.isCallExpression(node) && typescript_1.default.isIdentifier(node.expression) && node.expression.text === "require" &&
+                    node.arguments.length === 1 && typescript_1.default.isStringLiteralLike(node.arguments[0]) &&
+                    resolvesToFile(project, source.fileName, node.arguments[0].text, sourceFile)) {
+                    const symbol = project.checker.getSymbolAtLocation(node.expression);
+                    const declarations = symbol?.getDeclarations() ?? [];
+                    const provenModuleRequire = declarations.some((declaration) => declaration.getSourceFile().isDeclarationFile || modifiersOf(declaration).some((modifier) => modifier.kind === typescript_1.default.SyntaxKind.DeclareKeyword));
+                    if (!symbol) {
+                        unsupported.push({
+                            code: "OBJECT_PACK_REQUIRE_EVIDENCE_UNAVAILABLE",
+                            message: "require-like call resolves to packed source but global require identity is unavailable",
+                            file: toRepoPath(workspace.root, file)
+                        });
+                    }
+                    else if (provenModuleRequire) {
+                        unsupported.push({
+                            code: "OBJECT_PACK_REQUIRE_UNSUPPORTED",
+                            message: "CommonJS require of packed source is unsupported",
+                            file: toRepoPath(workspace.root, file)
+                        });
+                    }
+                }
+                typescript_1.default.forEachChild(node, visit);
+            };
+            visit(source);
+        }
+    }
+}
+function collectFingerprintModuleEdges(edges, sourceFile) {
+    return edges.filter((edge) => edge.fromFile === sourceFile || edge.toFile === sourceFile);
+}
+function validateAffectedFileOwnership(workspace, sourceFile, selected, moduleEdges, unsupported) {
+    const sourceDisplay = toRepoPath(workspace.root, sourceFile);
+    const affected = new Set();
+    for (const usage of selected.flatMap((member) => member.usages)) {
+        affected.add(usage.file);
+    }
+    for (const edge of moduleEdges) {
+        if (edge.toFile === sourceDisplay) {
+            affected.add(edge.fromFile);
+        }
+    }
+    affected.delete(sourceDisplay);
+    for (const file of [...affected].sort()) {
+        const owners = (0, semantic_workspace_1.ownersForSemanticFile)(workspace, file);
+        if (owners.length <= 1) {
+            continue;
+        }
+        unsupported.push({
+            code: "OBJECT_PACK_MULTIPLE_OWNERS_UNSUPPORTED",
+            message: "affected object.pack file belongs to multiple owning projects in M2",
+            file,
+            details: owners.map((project) => toRepoPath(workspace.root, project.config.file))
+        });
+    }
+}
+function supportsPropertyCall(member) {
+    if (typescript_1.default.isFunctionDeclaration(member.declaration)) {
+        return true;
+    }
+    const initializer = member.declaration.initializer;
+    return Boolean(initializer && (typescript_1.default.isArrowFunction(initializer) || typescript_1.default.isFunctionExpression(initializer)));
+}
+function planConsumerImports(workspace, sourceFile, selectedByKey, unsupported) {
+    const result = new Map();
+    const seenFiles = new Set();
+    for (const project of workspace.projects) {
+        for (const file of project.config.parsed.fileNames) {
+            if ((0, semantic_workspace_1.canonicalPathIdentity)(file) === (0, semantic_workspace_1.canonicalPathIdentity)(sourceFile) || seenFiles.has((0, semantic_workspace_1.canonicalPathIdentity)(file))) {
+                continue;
+            }
+            seenFiles.add((0, semantic_workspace_1.canonicalPathIdentity)(file));
+            const source = project.program.getSourceFile(file);
+            if (!source) {
+                continue;
+            }
+            const selectedImports = [];
+            for (const statement of source.statements) {
+                if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier) ||
+                    !resolvesToFile(project, source.fileName, statement.moduleSpecifier.text, sourceFile)) {
+                    continue;
+                }
+                const clause = statement.importClause;
+                const bindings = clause?.namedBindings;
+                if (!clause || !bindings || !typescript_1.default.isNamedImports(bindings)) {
+                    continue;
+                }
+                const selected = [];
+                for (const element of bindings.elements) {
+                    const identity = (0, semantic_workspace_1.resolveSemanticNodeIdentity)(workspace, project, element.name);
+                    const member = identity ? selectedByKey.get(identity.key) : undefined;
+                    if (member) {
+                        selected.push({ element, member });
+                    }
+                }
+                if (selected.length === 0) {
+                    continue;
+                }
+                if (clause.isTypeOnly || selected.some((item) => item.element.isTypeOnly)) {
+                    for (const item of selected) {
+                        unsupported.push({ code: "OBJECT_PACK_TYPE_IMPORT_UNSUPPORTED", message: "selected symbol is imported as type-only", selector: item.member.selector, file: toRepoPath(workspace.root, file) });
+                    }
+                    continue;
+                }
+                if (statement.attributes) {
+                    unsupported.push({ code: "OBJECT_PACK_IMPORT_ATTRIBUTES_UNSUPPORTED", message: "selected import uses import attributes", file: toRepoPath(workspace.root, file) });
+                    continue;
+                }
+                selectedImports.push({ statement, selected });
+            }
+            if (selectedImports.length === 0) {
+                continue;
+            }
+            const fileDisplay = toRepoPath(workspace.root, file);
+            const objectNames = [...new Set(selectedImports.flatMap((entry) => entry.selected.map((item) => item.member.objectName)))].sort();
+            for (const objectName of objectNames) {
+                if (project.checker.resolveName(objectName, source, typescript_1.default.SymbolFlags.Value, false)) {
+                    unsupported.push({ code: "OBJECT_PACK_CONSUMER_OBJECT_COLLISION", message: "object import name already resolves in consumer scope", objectName, file: fileDisplay });
+                }
+            }
+            const firstStatementByObject = new Map();
+            for (const objectName of objectNames) {
+                firstStatementByObject.set(objectName, selectedImports.find((entry) => entry.selected.some((item) => item.member.objectName === objectName)).statement);
+            }
+            const replacements = [];
+            for (const entry of selectedImports) {
+                const selectedElements = new Set(entry.selected.map((item) => item.element));
+                const remaining = entry.statement.importClause.namedBindings && typescript_1.default.isNamedImports(entry.statement.importClause.namedBindings)
+                    ? entry.statement.importClause.namedBindings.elements.filter((element) => !selectedElements.has(element)).map((element) => element.getText(source))
+                    : [];
+                const added = objectNames.filter((objectName) => firstStatementByObject.get(objectName) === entry.statement);
+                const replacementText = renderImportDeclaration(source, entry.statement, [...remaining, ...added].sort());
+                replacements.push({
+                    start: entry.statement.getStart(source),
+                    end: replacementText ? entry.statement.end : statementEndWithTrailingNewline(source.text, entry.statement.end),
+                    text: replacementText,
+                    reason: "object.pack import rewrite"
+                });
+            }
+            result.set(fileDisplay, {
+                replacements,
+                objectNames,
+                selectors: [...new Set(selectedImports.flatMap((entry) => entry.selected.map((item) => item.member.selector)))].sort()
+            });
+        }
+    }
+    return result;
+}
+function validateReExports(workspace, sourceFile, selectedByKey, unsupported) {
+    const seenFiles = new Set();
+    for (const project of workspace.projects) {
+        for (const file of project.config.parsed.fileNames) {
+            if (seenFiles.has((0, semantic_workspace_1.canonicalPathIdentity)(file))) {
+                continue;
+            }
+            seenFiles.add((0, semantic_workspace_1.canonicalPathIdentity)(file));
+            const source = project.program.getSourceFile(file);
+            if (!source) {
+                continue;
+            }
+            for (const statement of source.statements) {
+                if (!typescript_1.default.isExportDeclaration(statement) || !statement.moduleSpecifier || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier) ||
+                    !resolvesToFile(project, source.fileName, statement.moduleSpecifier.text, sourceFile)) {
+                    continue;
+                }
+                if (!statement.exportClause) {
+                    unsupported.push({ code: "OBJECT_PACK_EXPORT_STAR_UNSUPPORTED", message: "export-star from packed source is unsupported", file: toRepoPath(workspace.root, file) });
+                    continue;
+                }
+                if (typescript_1.default.isNamespaceExport(statement.exportClause)) {
+                    unsupported.push({ code: "OBJECT_PACK_NAMESPACE_REEXPORT_UNSUPPORTED", message: "namespace re-export from packed source is unsupported", file: toRepoPath(workspace.root, file) });
+                    continue;
+                }
+                if (typescript_1.default.isNamedExports(statement.exportClause)) {
+                    for (const element of statement.exportClause.elements) {
+                        const identity = (0, semantic_workspace_1.resolveSemanticNodeIdentity)(workspace, project, element.propertyName ?? element.name);
+                        const member = identity ? selectedByKey.get(identity.key) : undefined;
+                        if (member) {
+                            unsupported.push({ code: "OBJECT_PACK_REEXPORT_UNSUPPORTED", message: "re-export of selected symbol is unsupported", selector: member.selector, file: toRepoPath(workspace.root, file) });
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+function buildSourceText(source, text, selected, rows) {
+    const replacements = [];
+    const seenStatements = new Set();
+    for (const member of selected) {
+        if (seenStatements.has(member.statement)) {
+            continue;
+        }
+        seenStatements.add(member.statement);
+        const exportModifier = modifiersOf(member.statement).find((modifier) => modifier.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+        let end = exportModifier.end;
+        while (end < text.length && (text[end] === " " || text[end] === "\t")) {
+            end += 1;
+        }
+        replacements.push({ start: exportModifier.getStart(source), end, text: "", reason: "object.pack localize export" });
+    }
+    let next = applyReplacements(text, replacements);
+    const objectStatements = rows.map((row) => `export const ${row.objectName} = { ${row.selectors.join(", ")} };`).join("\n");
+    next = `${next}${next.endsWith("\n") ? "" : "\n"}${next.trim().length > 0 ? "\n" : ""}${objectStatements}\n`;
+    return next;
+}
+function renderImportDeclaration(source, statement, elements) {
+    const clause = statement.importClause;
+    const defaultName = clause.name?.getText(source);
+    if (elements.length === 0) {
+        return defaultName ? `import ${defaultName} from ${statement.moduleSpecifier.getText(source)};` : "";
+    }
+    return `import ${defaultName ? `${defaultName}, ` : ""}{ ${elements.join(", ")} } from ${statement.moduleSpecifier.getText(source)};`;
+}
+function moduleShapesUnchanged(root, virtualTexts) {
+    for (const [file, nextText] of virtualTexts) {
+        const absolute = path.resolve(root, file);
+        const before = moduleShape(fs.readFileSync(absolute, "utf8"), absolute);
+        const after = moduleShape(nextText, absolute);
+        if (before.join("\0") !== after.join("\0")) {
+            return false;
+        }
+    }
+    return true;
+}
+function moduleShape(text, file) {
+    const source = typescript_1.default.createSourceFile(file, text, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(file));
+    const shape = [];
+    const visit = (node) => {
+        if (typescript_1.default.isImportDeclaration(node) && typescript_1.default.isStringLiteralLike(node.moduleSpecifier)) {
+            const clause = node.importClause;
+            shape.push(`import:${clause?.isTypeOnly ? "type" : "runtime"}:${node.moduleSpecifier.text}`);
+        }
+        else if (typescript_1.default.isExportDeclaration(node) && node.moduleSpecifier && typescript_1.default.isStringLiteralLike(node.moduleSpecifier)) {
+            shape.push(`export:${node.isTypeOnly ? "type" : "runtime"}:${node.moduleSpecifier.text}`);
+        }
+        else if (typescript_1.default.isCallExpression(node) && node.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword &&
+            node.arguments.length === 1 && typescript_1.default.isStringLiteralLike(node.arguments[0])) {
+            shape.push(`dynamic:${node.arguments[0].text}`);
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return [...new Set(shape)].sort();
+}
+function failure(sourceFile, rows, unsupported, coverage) {
+    return {
+        ok: false,
+        operation: "exports.object.pack.preview",
+        code: "OBJECT_PACK_SEMANTIC_PREVIEW_REJECTED",
+        sourceFile,
+        objectCount: rows.length,
+        memberCount: rows.reduce((sum, row) => sum + row.selectors.length, 0),
+        filesTouched: [],
+        filesWritten: [],
+        ...(coverage ? { coverage } : {}),
+        unsupportedCount: unsupported.length,
+        unsupported: unsupported.sort(compareUnsupported)
+    };
+}
+function findDeclarationByIdentity(source, identity) {
+    let found = null;
+    const visit = (node) => {
+        if (found) {
+            return;
+        }
+        if (node.getStart(source) === identity.declarationStart && node.end === identity.declarationEnd) {
+            found = node;
+            return;
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return found;
+}
+function findIdentifierAt(source, start, end) {
+    let found = null;
+    const visit = (node) => {
+        if (found || node.end < start || node.getStart(source) > end) {
+            return;
+        }
+        if (typescript_1.default.isIdentifier(node) && node.getStart(source) === start && node.end === end) {
+            found = node;
+            return;
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return found;
+}
+function isDeclarationName(node) {
+    const parent = node.parent;
+    return typescript_1.default.isFunctionDeclaration(parent) && parent.name === node ||
+        typescript_1.default.isVariableDeclaration(parent) && parent.name === node;
+}
+function isNamespaceQualifiedReference(node, checker) {
+    const parent = node.parent;
+    if (!typescript_1.default.isPropertyAccessExpression(parent) || parent.name !== node) {
+        return false;
+    }
+    const receiver = checker.getSymbolAtLocation(parent.expression);
+    return Boolean(receiver?.getDeclarations()?.some(typescript_1.default.isNamespaceImport));
+}
+function resolvesToFile(project, fromFile, specifier, targetFile) {
+    const resolved = typescript_1.default.resolveModuleName(specifier, fromFile, project.config.parsed.options, typescript_1.default.sys).resolvedModule?.resolvedFileName;
+    return Boolean(resolved && (0, semantic_workspace_1.canonicalPathIdentity)(resolved) === (0, semantic_workspace_1.canonicalPathIdentity)(targetFile));
+}
+function containsThisSensitiveSyntax(node) {
+    let sensitive = false;
+    const visit = (current) => {
+        if (current.kind === typescript_1.default.SyntaxKind.ThisKeyword || current.kind === typescript_1.default.SyntaxKind.SuperKeyword) {
+            sensitive = true;
+            return;
+        }
+        typescript_1.default.forEachChild(current, visit);
+    };
+    visit(node);
+    return sensitive;
+}
+function hasExportModifier(node) {
+    return modifiersOf(node).some((modifier) => modifier.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+}
+function hasDefaultModifier(node) {
+    return modifiersOf(node).some((modifier) => modifier.kind === typescript_1.default.SyntaxKind.DefaultKeyword);
+}
+function modifiersOf(node) {
+    return typescript_1.default.canHaveModifiers(node) ? typescript_1.default.getModifiers(node) ?? [] : [];
+}
+function applyReplacements(text, replacements) {
+    const sorted = [...replacements].sort((left, right) => right.start - left.start || right.end - left.end || left.text.localeCompare(right.text));
+    for (let index = 1; index < sorted.length; index += 1) {
+        const right = sorted[index - 1];
+        const left = sorted[index];
+        if (left.end > right.start) {
+            throw new Error(`Overlapping object.pack replacements: ${left.start}-${left.end} and ${right.start}-${right.end}.`);
+        }
+    }
+    let next = text;
+    for (const replacement of sorted) {
+        next = `${next.slice(0, replacement.start)}${replacement.text}${next.slice(replacement.end)}`;
+    }
+    return next;
+}
+function addReplacement(target, file, replacement) {
+    const values = target.get(file) ?? [];
+    if (!values.some((item) => item.start === replacement.start && item.end === replacement.end && item.text === replacement.text)) {
+        values.push(replacement);
+    }
+    target.set(file, values);
+}
+function diagnosticKey(root, diagnostic) {
+    return [
+        diagnostic.code,
+        diagnostic.file ? toRepoPath(root, diagnostic.file.fileName) : "",
+        diagnostic.start ?? -1,
+        diagnostic.length ?? -1,
+        typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+    ].join("\0");
+}
+function toObjectDiagnostic(root, diagnostic) {
+    return {
+        code: `TS${diagnostic.code}`,
+        severity: diagnostic.category === typescript_1.default.DiagnosticCategory.Error ? "error" : "warning",
+        message: typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+        ...(diagnostic.file ? { file: toRepoPath(root, diagnostic.file.fileName) } : {})
+    };
+}
+function toCoverageEvidence(reason) {
+    const record = reason;
+    return {
+        code: `OBJECT_PACK_COVERAGE_${reason.code}`,
+        message: "semantic reference coverage is incomplete",
+        ...(typeof record.file === "string" ? { file: record.file } : {}),
+        details: reason
+    };
+}
+function isSupportedSourceExtension(file) {
+    return [".ts", ".tsx", ".mts"].includes(path.extname(file).toLowerCase());
+}
+function isEsmSourceFile(project, source) {
+    const kind = project.config.parsed.options.module;
+    if (kind === undefined || [
+        typescript_1.default.ModuleKind.None,
+        typescript_1.default.ModuleKind.CommonJS,
+        typescript_1.default.ModuleKind.AMD,
+        typescript_1.default.ModuleKind.UMD,
+        typescript_1.default.ModuleKind.System
+    ].includes(kind)) {
+        return false;
+    }
+    if ([typescript_1.default.ModuleKind.Node16, typescript_1.default.ModuleKind.NodeNext].includes(kind)) {
+        return source.impliedNodeFormat === typescript_1.default.ModuleKind.ESNext;
+    }
+    return true;
+}
+function statementEndWithTrailingNewline(text, end) {
+    if (text[end] === "\r" && text[end + 1] === "\n") {
+        return end + 2;
+    }
+    return text[end] === "\n" ? end + 1 : end;
+}
+function scriptKindForFile(file) {
+    const extension = path.extname(file).toLowerCase();
+    return extension === ".tsx" ? typescript_1.default.ScriptKind.TSX : extension === ".jsx" ? typescript_1.default.ScriptKind.JSX :
+        [".js", ".mjs", ".cjs"].includes(extension) ? typescript_1.default.ScriptKind.JS : typescript_1.default.ScriptKind.TS;
+}
+function findAncestor(node, predicate) {
+    let current = node.parent;
+    while (current) {
+        if (predicate(current)) {
+            return current;
+        }
+        if (typescript_1.default.isStatement(current)) {
+            break;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function toRepoPath(root, file) {
+    return path.relative(root, path.resolve(file)).replace(/\\/g, "/") || ".";
+}
+function compareUsages(left, right) {
+    return left.file.localeCompare(right.file) || left.start - right.start || left.end - right.end ||
+        left.symbol.key.localeCompare(right.symbol.key) || left.project.localeCompare(right.project);
+}
+function compareUnsupported(left, right) {
+    return (left.file ?? "").localeCompare(right.file ?? "") || (left.selector ?? "").localeCompare(right.selector ?? "") ||
+        (left.objectName ?? "").localeCompare(right.objectName ?? "") || left.code.localeCompare(right.code);
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}