@automaton-labs/aib 0.0.6 → 0.0.8

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

@@ -0,0 +1,993 @@
+"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.planObjectUnpackSemanticPreview = planObjectUnpackSemanticPreview;
+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");
+const object_pack_semantic_preview_1 = require("./object-pack-semantic-preview");
+function planObjectUnpackSemanticPreview(cwd, input) {
+    return (0, object_mutation_partition_1.planBestEffortObjectMutation)(input.rows, (rows) => planObjectUnpackSemanticPreviewStrict(cwd, { sourceFile: input.sourceFile, rows }), {
+        blocksWholeGroup: (issue) => !issue.selector || issue.code === "OBJECT_UNPACK_OBJECT_WRITE_UNSUPPORTED"
+    });
+}
+function planObjectUnpackSemanticPreviewStrict(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_UNPACK_SOURCE_KIND_UNSUPPORTED",
+            message: "object.unpack 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_UNPACK_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_UNPACK_MULTIPLE_OWNERS_UNSUPPORTED",
+            message: "object.unpack semantic preview requires exactly one owning source project",
+            file: displaySource,
+            details: sourceProjects.map((project) => toRepoPath(root, project.config.file))
+        });
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    const sourceProject = sourceProjects[0];
+    const source = sourceProject.program.getSourceFile(sourceFile);
+    if (!source || !isEsmSourceFile(sourceProject, source)) {
+        unsupported.push({
+            code: "OBJECT_UNPACK_ESM_REQUIRED",
+            message: "object.unpack semantic preview requires an actual ESM source in its owning project",
+            file: displaySource
+        });
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    const objects = resolveObjects(workspace, sourceProject, source, rows, unsupported);
+    for (const object of objects) {
+        object.usages = (0, semantic_workspace_1.findSemanticReferences)(workspace, object.symbol);
+        for (const member of object.members) {
+            member.usages = (0, semantic_workspace_1.findSemanticReferences)(workspace, member.symbol);
+        }
+    }
+    moduleScope = (0, semantic_workspace_1.scopeRelevantSemanticModuleEdges)(workspace, moduleCollection, {
+        sourceFiles: [displaySource],
+        affectedFiles: objects.flatMap((object) => [
+            ...object.usages.map((usage) => usage.file),
+            ...object.members.flatMap((member) => member.usages.map((usage) => usage.file))
+        ])
+    });
+    if (!moduleScope.coverage.complete) {
+        unsupported.push(...moduleScope.coverage.incompleteReasons.map(toCoverageEvidence));
+        unsupported.push({
+            code: "OBJECT_UNPACK_CYCLE_EVIDENCE_UNAVAILABLE",
+            message: "runtime cycle evidence is unavailable because relevant module resolution is incomplete",
+            file: displaySource
+        });
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    for (const edge of moduleScope.edges) {
+        if (edge.toFile !== displaySource) {
+            continue;
+        }
+        if (edge.kind === "dynamic") {
+            unsupported.push({ code: "OBJECT_UNPACK_DYNAMIC_IMPORT_UNSUPPORTED", message: "dynamic imports of the unpacked source are unsupported", file: edge.fromFile });
+        }
+        else if (edge.kind === "require") {
+            unsupported.push({ code: "OBJECT_UNPACK_REQUIRE_UNSUPPORTED", message: "CommonJS require of the unpacked source is unsupported", file: edge.fromFile });
+        }
+    }
+    validateRequireConsumers(workspace, sourceFile, unsupported);
+    const cycleEvidence = (0, runtime_cycle_query_1.queryRuntimeCycleEvidence)(moduleScope.edges, [displaySource]);
+    if (cycleEvidence.cycles.length > 0) {
+        unsupported.push({
+            code: "OBJECT_UNPACK_RUNTIME_CYCLE_UNSUPPORTED",
+            message: "unpacked source participates in a runtime import cycle; initialization order cannot be proven safe",
+            file: displaySource,
+            details: cycleEvidence.cycles
+        });
+    }
+    validateAffectedOwnership(workspace, sourceFile, objects, moduleScope.edges, unsupported);
+    validateMemberReferenceFlows(workspace, sourceFile, objects, unsupported);
+    validateReExports(workspace, sourceFile, objects, unsupported);
+    if (unsupported.length > 0) {
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    const sourceReplacements = [];
+    const consumers = new Map();
+    const remainingObjectUse = new Set();
+    const memberByObjectAndName = new Map();
+    for (const object of objects) {
+        for (const member of object.members) {
+            memberByObjectAndName.set(`${object.objectName}\0${member.selector}`, member);
+            addExportModifier(source, member, sourceReplacements);
+        }
+        planObjectReferences(workspace, sourceFile, object, consumers, sourceReplacements, remainingObjectUse, unsupported);
+    }
+    if (unsupported.length > 0) {
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    planConsumerImports(workspace, sourceFile, objects, memberByObjectAndName, consumers, remainingObjectUse, unsupported);
+    if (unsupported.length > 0) {
+        return failure(displaySource, rows, unsupported, moduleScope.coverage);
+    }
+    const sourceText = fs.readFileSync(sourceFile, "utf8");
+    for (const object of objects) {
+        if (object.full && !remainingObjectUse.has(`${displaySource}\0${object.objectName}`)) {
+            addReplacement(sourceReplacements, {
+                start: object.statement.getStart(source),
+                end: statementEndWithTrailingNewline(sourceText, object.statement.end),
+                text: "",
+                reason: `object.unpack remove ${object.objectName}`
+            });
+        }
+        else {
+            const remaining = object.literal.properties.filter((property) => !object.members.some((member) => member.property === property));
+            const printer = typescript_1.default.createPrinter({ newLine: typescript_1.default.NewLineKind.LineFeed });
+            const nextLiteral = typescript_1.default.factory.updateObjectLiteralExpression(object.literal, remaining);
+            addReplacement(sourceReplacements, {
+                start: object.literal.getStart(source),
+                end: object.literal.end,
+                text: printer.printNode(typescript_1.default.EmitHint.Expression, nextLiteral, source),
+                reason: `object.unpack retain ${object.objectName}`
+            });
+        }
+    }
+    const virtualTexts = new Map();
+    const sourceNext = applyReplacements(sourceText, sourceReplacements);
+    virtualTexts.set(displaySource, sourceNext);
+    const consumerSummaries = [];
+    for (const plan of [...consumers.values()].sort((left, right) => left.file.localeCompare(right.file))) {
+        const absolute = path.resolve(root, plan.file);
+        const original = fs.readFileSync(absolute, "utf8");
+        const rewritten = applyReplacements(original, plan.replacements);
+        const canonicalized = (0, targeted_import_canonicalizer_1.formatChangedNamedImports)(original, rewritten, absolute).text;
+        if (canonicalized === original) {
+            continue;
+        }
+        virtualTexts.set(plan.file, canonicalized);
+        consumerSummaries.push({
+            file: plan.file,
+            objectNames: [...plan.objectNames].sort(),
+            selectors: [...plan.selectors.keys()].sort(),
+            referenceCount: plan.referenceCount
+        });
+    }
+    if (!moduleShapesUnchanged(root, virtualTexts)) {
+        unsupported.push({
+            code: "OBJECT_UNPACK_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 = (0, object_pack_semantic_preview_1.validateVirtualProjectDiagnostics)(workspace, virtualTexts);
+    if (diagnostics.added.length > 0) {
+        unsupported.push({
+            code: "OBJECT_UNPACK_NEW_DIAGNOSTICS",
+            message: "virtual object.unpack 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.unpack source preview" : "object.unpack consumer preview"
+    })).sort((left, right) => left.file.localeCompare(right.file));
+    const beforeHashes = (0, concrete_edit_plan_1.createConcretePreconditions)(root, edits);
+    const symbols = uniqueSymbols(objects.flatMap((object) => [object.symbol, ...object.members.map((member) => member.symbol)]));
+    const usages = uniqueUsages(objects.flatMap((object) => [object.usages, ...object.members.map((member) => member.usages)]).flat());
+    const fingerprintEdges = collectFingerprintModuleEdges(moduleScope.edges, displaySource);
+    const rowFingerprints = objects.map((object) => (0, concrete_edit_plan_1.createSemanticFingerprint)({
+        intent: {
+            operation: "object.unpack",
+            sourceFile: displaySource,
+            objectName: object.objectName,
+            members: object.members.map((member) => member.selector),
+            exportMode: "named"
+        },
+        projects: moduleScope.coverage.projects,
+        symbols: [object.symbol, ...object.members.map((member) => member.symbol)],
+        references: uniqueUsages([object.usages, ...object.members.map((member) => member.usages)].flat()),
+        moduleEdges: fingerprintEdges
+    }));
+    return {
+        ok: true,
+        operation: "exports.object.unpack.preview",
+        applyAvailable: true,
+        sourceFile: displaySource,
+        objectCount: objects.length,
+        memberCount: objects.reduce((sum, object) => sum + object.members.length, 0),
+        importerCount: consumerSummaries.length,
+        referenceCount: consumerSummaries.reduce((sum, item) => sum + item.referenceCount, 0),
+        objects: objects.map((object) => ({
+            objectName: object.objectName,
+            selectors: object.members.map((member) => member.selector).sort(),
+            full: object.full
+        })),
+        importers: consumerSummaries,
+        filesTouched: edits.map((edit) => edit.file),
+        filesWritten: [],
+        semanticFingerprint: sha256(rowFingerprints.join("\0")),
+        rowFingerprints,
+        edits,
+        beforeHashes,
+        coverage: moduleScope.coverage,
+        symbols,
+        usages,
+        moduleEdges: fingerprintEdges,
+        cycleEvidence,
+        diagnostics,
+        unsupported: []
+    };
+}
+function resolveObjects(workspace, project, source, rows, unsupported) {
+    const result = [];
+    const seenObjects = new Set();
+    for (const row of rows) {
+        if (seenObjects.has(row.objectName)) {
+            unsupported.push({ code: "OBJECT_UNPACK_DUPLICATE_OBJECT", message: "object name is used by more than one row", objectName: row.objectName });
+            continue;
+        }
+        seenObjects.add(row.objectName);
+        const resolution = (0, semantic_workspace_1.resolveExportedSemanticSymbol)(workspace, source.fileName, row.objectName);
+        if (resolution.status !== "resolved" || !resolution.symbol) {
+            unsupported.push({
+                code: resolution.status === "ambiguous" ? "OBJECT_UNPACK_OBJECT_AMBIGUOUS" : "OBJECT_UNPACK_OBJECT_NOT_FOUND",
+                message: "named exported object could not be resolved uniquely",
+                objectName: row.objectName,
+                details: resolution.reason
+            });
+            continue;
+        }
+        const declarationNode = findDeclarationByIdentity(source, resolution.symbol);
+        const declaration = declarationNode && typescript_1.default.isVariableDeclaration(declarationNode) ? declarationNode : null;
+        if (!declaration || !typescript_1.default.isIdentifier(declaration.name) || !typescript_1.default.isVariableDeclarationList(declaration.parent)) {
+            unsupported.push({
+                code: "OBJECT_UNPACK_SOURCE_OBJECT_UNSUPPORTED",
+                message: "object.unpack requires one named exported immutable const object declaration",
+                objectName: row.objectName,
+                file: toRepoPath(workspace.root, source.fileName)
+            });
+            continue;
+        }
+        const list = declaration.parent;
+        const statement = list.parent;
+        if (!typescript_1.default.isVariableStatement(statement) || list.declarations.length !== 1 ||
+            (list.flags & typescript_1.default.NodeFlags.Const) === 0 || !hasExportModifier(statement) || hasDefaultModifier(statement) || !declaration.initializer) {
+            unsupported.push({
+                code: "OBJECT_UNPACK_SOURCE_OBJECT_UNSUPPORTED",
+                message: "object.unpack requires one named exported immutable const object declaration",
+                objectName: row.objectName,
+                file: toRepoPath(workspace.root, source.fileName)
+            });
+            continue;
+        }
+        const literal = unwrapObjectLiteral(declaration.initializer);
+        if (!literal) {
+            unsupported.push({
+                code: "OBJECT_UNPACK_OBJECT_LITERAL_REQUIRED",
+                message: "object.unpack requires a statically unwrap-able object literal initializer",
+                objectName: row.objectName
+            });
+            continue;
+        }
+        const shorthandByName = new Map();
+        for (const property of literal.properties) {
+            if (typescript_1.default.isShorthandPropertyAssignment(property)) {
+                if (shorthandByName.has(property.name.text)) {
+                    unsupported.push({ code: "OBJECT_UNPACK_DUPLICATE_PROPERTY", message: "object literal contains duplicate shorthand properties", objectName: row.objectName, selector: property.name.text });
+                }
+                shorthandByName.set(property.name.text, property);
+            }
+        }
+        const members = [];
+        for (const selector of row.selectors) {
+            const property = shorthandByName.get(selector);
+            if (!property) {
+                const propertyWithName = literal.properties.find((candidate) => propertyNameText(candidate.name) === selector ||
+                    candidate.name && typescript_1.default.isComputedPropertyName(candidate.name) &&
+                        typescript_1.default.isStringLiteralLike(candidate.name.expression) && candidate.name.expression.text === selector);
+                const obscuredBySpread = literal.properties.some(typescript_1.default.isSpreadAssignment);
+                unsupported.push({
+                    code: propertyWithName || obscuredBySpread ? "OBJECT_UNPACK_MEMBER_SHAPE_UNSUPPORTED" : "OBJECT_UNPACK_MEMBER_NOT_FOUND",
+                    message: propertyWithName || obscuredBySpread ? "selected member must be a plain shorthand property" : "selected object member was not found",
+                    objectName: row.objectName,
+                    selector
+                });
+                continue;
+            }
+            const memberSymbol = project.checker.getShorthandAssignmentValueSymbol(property);
+            const identity = memberSymbol ? (0, semantic_workspace_1.resolveSemanticSymbolIdentity)(workspace, project, memberSymbol) : null;
+            const memberDeclarationNode = identity ? findDeclarationByIdentity(source, identity) : null;
+            const validated = validateMemberDeclaration(memberDeclarationNode, row.objectName, selector, source, unsupported);
+            if (identity && validated) {
+                members.push({
+                    objectName: row.objectName,
+                    selector,
+                    symbol: identity,
+                    declaration: validated.declaration,
+                    statement: validated.statement,
+                    property,
+                    usages: []
+                });
+            }
+            else if (!identity) {
+                unsupported.push({ code: "OBJECT_UNPACK_MEMBER_SYMBOL_UNRESOLVED", message: "shorthand member symbol could not be resolved", objectName: row.objectName, selector });
+            }
+        }
+        result.push({
+            objectName: row.objectName,
+            symbol: resolution.symbol,
+            declaration,
+            statement,
+            literal,
+            members,
+            full: members.length === literal.properties.length && literal.properties.every(typescript_1.default.isShorthandPropertyAssignment),
+            usages: []
+        });
+    }
+    return result;
+}
+function validateMemberDeclaration(node, objectName, selector, source, unsupported) {
+    if (node && typescript_1.default.isFunctionDeclaration(node) && node.name && !hasDefaultModifier(node)) {
+        if (containsThisSensitiveSyntax(node)) {
+            unsupported.push({ code: "OBJECT_UNPACK_THIS_SENSITIVE", message: "selected function contains this/super-sensitive semantics", objectName, selector, file: source.fileName });
+            return null;
+        }
+        return { declaration: node, statement: node };
+    }
+    if (node && typescript_1.default.isVariableDeclaration(node) && typescript_1.default.isIdentifier(node.name)) {
+        const list = node.parent;
+        const statement = list.parent;
+        if (!typescript_1.default.isVariableDeclarationList(list) || !typescript_1.default.isVariableStatement(statement) || list.declarations.length !== 1 ||
+            (list.flags & typescript_1.default.NodeFlags.Const) === 0 || !node.initializer || hasDefaultModifier(statement)) {
+            unsupported.push({ code: "OBJECT_UNPACK_MEMBER_DECLARATION_UNSUPPORTED", message: "selected member must resolve to one initialized const declaration", objectName, selector });
+            return null;
+        }
+        if (containsThisSensitiveSyntax(node.initializer)) {
+            unsupported.push({ code: "OBJECT_UNPACK_THIS_SENSITIVE", message: "selected const initializer contains this/super-sensitive semantics", objectName, selector });
+            return null;
+        }
+        return { declaration: node, statement };
+    }
+    unsupported.push({
+        code: "OBJECT_UNPACK_MEMBER_DECLARATION_UNSUPPORTED",
+        message: "selected shorthand member must resolve to a local named function or initialized const",
+        objectName,
+        selector
+    });
+    return null;
+}
+function validateAffectedOwnership(workspace, sourceFile, objects, edges, unsupported) {
+    const sourceDisplay = toRepoPath(workspace.root, sourceFile);
+    const affected = new Set();
+    for (const object of objects) {
+        for (const usage of object.usages)
+            affected.add(usage.file);
+        for (const member of object.members)
+            for (const usage of member.usages)
+                affected.add(usage.file);
+    }
+    for (const edge of edges)
+        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) {
+            unsupported.push({
+                code: "OBJECT_UNPACK_MULTIPLE_OWNERS_UNSUPPORTED",
+                message: "affected object.unpack file belongs to multiple owning projects",
+                file,
+                details: owners.map((project) => toRepoPath(workspace.root, project.config.file))
+            });
+        }
+    }
+}
+function validateMemberReferenceFlows(workspace, sourceFile, objects, unsupported) {
+    for (const object of objects) {
+        for (const member of object.members) {
+            for (const usage of member.usages) {
+                const project = projectForUsage(workspace, usage);
+                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_UNPACK_REFERENCE_NODE_UNRESOLVED", message: "member reference could not be mapped back to syntax", objectName: object.objectName, selector: member.selector, file: usage.file });
+                    continue;
+                }
+                if (isDeclarationName(node) || node === member.property.name) {
+                    continue;
+                }
+                const rejected = usage.kinds.filter((kind) => [
+                    "property-write", "update/delete", "destructure", "namespace", "re-export",
+                    "type-position/type-query", "escape/identity", "dynamic/require"
+                ].includes(kind));
+                if (rejected.length > 0) {
+                    unsupported.push({
+                        code: "OBJECT_UNPACK_MEMBER_FLOW_UNSUPPORTED",
+                        message: "selected member has an unsupported reference flow",
+                        objectName: object.objectName,
+                        selector: member.selector,
+                        file: usage.file,
+                        usageKinds: [...new Set(rejected)].sort()
+                    });
+                }
+            }
+        }
+    }
+}
+function planObjectReferences(workspace, sourceFile, object, consumers, sourceReplacements, remainingObjectUse, unsupported) {
+    const sourceDisplay = toRepoPath(workspace.root, sourceFile);
+    const selected = new Map(object.members.map((member) => [member.selector, member]));
+    for (const usage of object.usages) {
+        const project = projectForUsage(workspace, usage);
+        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_UNPACK_REFERENCE_NODE_UNRESOLVED", message: "object reference could not be mapped back to syntax", objectName: object.objectName, file: usage.file });
+            continue;
+        }
+        if (node === object.declaration.name || findAncestor(node, typescript_1.default.isImportSpecifier)) {
+            continue;
+        }
+        if (findAncestor(node, typescript_1.default.isExportSpecifier)) {
+            unsupported.push({ code: "OBJECT_UNPACK_REEXPORT_UNSUPPORTED", message: "re-export of unpacked object is unsupported", objectName: object.objectName, file: usage.file });
+            continue;
+        }
+        const parent = node.parent;
+        if (parent && typescript_1.default.isPropertyAccessExpression(parent) && parent.expression === node) {
+            if (parent.questionDotToken || parent.parent && typescript_1.default.isCallExpression(parent.parent) &&
+                parent.parent.expression === parent && parent.parent.questionDotToken) {
+                unsupported.push({ code: "OBJECT_UNPACK_OPTIONAL_ACCESS_UNSUPPORTED", message: "optional object member access is unsupported", objectName: object.objectName, file: usage.file });
+                continue;
+            }
+            const member = selected.get(parent.name.text);
+            if (!member) {
+                remainingObjectUse.add(`${usage.file}\0${object.objectName}`);
+                continue;
+            }
+            if (isWriteOrUpdateTarget(parent)) {
+                unsupported.push({ code: "OBJECT_UNPACK_OBJECT_WRITE_UNSUPPORTED", message: "selected object member is written, updated, or deleted", objectName: object.objectName, selector: member.selector, file: usage.file });
+                continue;
+            }
+            if (parent.parent && typescript_1.default.isCallExpression(parent.parent) && parent.parent.expression === parent && !supportsDirectCall(member)) {
+                unsupported.push({ code: "OBJECT_UNPACK_CALL_BINDING_UNPROVEN", message: "selected member is not proven callable with preserved binding semantics", objectName: object.objectName, selector: member.selector, file: usage.file });
+                continue;
+            }
+            const targetName = usage.file === sourceDisplay
+                ? member.selector
+                : chooseConsumerBinding(workspace, project, source, sourceFile, object.objectName, member);
+            const replacement = {
+                start: parent.getStart(source),
+                end: parent.end,
+                text: targetName,
+                reason: `object.unpack reference ${object.objectName}.${member.selector}`
+            };
+            if (usage.file === sourceDisplay) {
+                addReplacement(sourceReplacements, replacement);
+            }
+            else {
+                const plan = consumerPlan(consumers, usage.file);
+                addReplacement(plan.replacements, replacement);
+                plan.objectNames.add(object.objectName);
+                plan.selectors.set(member.selector, targetName);
+                plan.referenceCount += 1;
+            }
+            continue;
+        }
+        if (parent && typescript_1.default.isElementAccessExpression(parent) && parent.expression === node) {
+            unsupported.push({ code: "OBJECT_UNPACK_COMPUTED_ACCESS_UNSUPPORTED", message: "computed object member access is unsupported", objectName: object.objectName, file: usage.file });
+            continue;
+        }
+        if (parent && typescript_1.default.isPropertyAccessExpression(parent) && parent.name === node) {
+            unsupported.push({ code: "OBJECT_UNPACK_NAMESPACE_USAGE_UNSUPPORTED", message: "namespace-qualified object usage is unsupported", objectName: object.objectName, file: usage.file });
+            continue;
+        }
+        unsupported.push({
+            code: objectUsageCode(usage.kinds),
+            message: "object value has an unsupported identity, enumeration, destructure, or escape flow",
+            objectName: object.objectName,
+            file: usage.file,
+            usageKinds: usage.kinds
+        });
+    }
+}
+function planConsumerImports(workspace, sourceFile, objects, memberByObjectAndName, consumers, remainingObjectUse, unsupported) {
+    const objectByKey = new Map(objects.map((object) => [object.symbol.key, object]));
+    seedConsumerPlansForUnusedFullObjectImports(workspace, sourceFile, objectByKey, consumers, remainingObjectUse);
+    for (const plan of consumers.values()) {
+        const owners = (0, semantic_workspace_1.ownersForSemanticFile)(workspace, plan.file);
+        const project = owners[0];
+        const source = project?.program.getSourceFile(path.resolve(workspace.root, plan.file));
+        if (!project || owners.length !== 1 || !source) {
+            unsupported.push({ code: "OBJECT_UNPACK_CONSUMER_PROJECT_UNRESOLVED", message: "consumer project could not be resolved uniquely", file: plan.file });
+            continue;
+        }
+        const imports = [];
+        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;
+            }
+            if (statement.attributes) {
+                unsupported.push({ code: "OBJECT_UNPACK_IMPORT_ATTRIBUTES_UNSUPPORTED", message: "imports with attributes are unsupported", file: plan.file });
+                continue;
+            }
+            const clause = statement.importClause;
+            if (!clause || clause.isTypeOnly || clause.namedBindings && typescript_1.default.isNamespaceImport(clause.namedBindings)) {
+                unsupported.push({ code: "OBJECT_UNPACK_NAMESPACE_IMPORT_UNSUPPORTED", message: "namespace/type-only import from unpacked source is unsupported", file: plan.file });
+                continue;
+            }
+            const bindings = clause.namedBindings;
+            const objectElements = [];
+            if (bindings && typescript_1.default.isNamedImports(bindings)) {
+                for (const element of bindings.elements) {
+                    const identity = (0, semantic_workspace_1.resolveSemanticNodeIdentity)(workspace, project, element.name);
+                    const object = identity ? objectByKey.get(identity.key) : undefined;
+                    if (object)
+                        objectElements.push({ element, object });
+                }
+            }
+            imports.push({ statement, objectElements });
+        }
+        const relevant = imports.filter((entry) => entry.objectElements.length > 0);
+        if (relevant.length === 0) {
+            unsupported.push({ code: "OBJECT_UNPACK_OBJECT_IMPORT_UNRESOLVED", message: "consumer object import could not be mapped to selected references", file: plan.file });
+            continue;
+        }
+        const additions = [...plan.selectors.entries()].map(([selector, localName]) => selector === localName ? selector : `${selector} as ${localName}`);
+        let added = false;
+        for (const entry of relevant) {
+            const bindings = entry.statement.importClause.namedBindings;
+            const remove = new Set(entry.objectElements.filter(({ object }) => !remainingObjectUse.has(`${plan.file}\0${object.objectName}`)).map(({ element }) => element));
+            const elements = bindings.elements.filter((element) => !remove.has(element)).map((element) => element.getText(source));
+            if (!added) {
+                elements.push(...additions);
+                added = true;
+            }
+            const rendered = renderImportDeclaration(source, entry.statement, [...new Set(elements)].sort(importElementCompare));
+            addReplacement(plan.replacements, {
+                start: entry.statement.getStart(source),
+                end: rendered ? entry.statement.end : statementEndWithTrailingNewline(source.text, entry.statement.end),
+                text: rendered,
+                reason: "object.unpack import rewrite"
+            });
+        }
+        for (const [selector] of plan.selectors) {
+            if (![...plan.objectNames].some((objectName) => memberByObjectAndName.has(`${objectName}\0${selector}`))) {
+                unsupported.push({ code: "OBJECT_UNPACK_IMPORT_MEMBER_UNRESOLVED", message: "direct member import could not be resolved", selector, file: plan.file });
+            }
+        }
+    }
+}
+function seedConsumerPlansForUnusedFullObjectImports(workspace, sourceFile, objectByKey, consumers, remainingObjectUse) {
+    const seen = 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) || seen.has((0, semantic_workspace_1.canonicalPathIdentity)(file)))
+                continue;
+            seen.add((0, semantic_workspace_1.canonicalPathIdentity)(file));
+            const source = project.program.getSourceFile(file);
+            if (!source)
+                continue;
+            const display = toRepoPath(workspace.root, file);
+            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 bindings = statement.importClause?.namedBindings;
+                if (!bindings || !typescript_1.default.isNamedImports(bindings))
+                    continue;
+                for (const element of bindings.elements) {
+                    const identity = (0, semantic_workspace_1.resolveSemanticNodeIdentity)(workspace, project, element.name);
+                    const object = identity ? objectByKey.get(identity.key) : undefined;
+                    if (object?.full && !remainingObjectUse.has(`${display}\0${object.objectName}`)) {
+                        consumerPlan(consumers, display).objectNames.add(object.objectName);
+                    }
+                }
+            }
+        }
+    }
+}
+function validateReExports(workspace, sourceFile, objects, unsupported) {
+    const objectKeys = new Set(objects.map((object) => object.symbol.key));
+    const seen = new Set();
+    for (const project of workspace.projects) {
+        for (const file of project.config.parsed.fileNames) {
+            const key = (0, semantic_workspace_1.canonicalPathIdentity)(file);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            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 || typescript_1.default.isNamespaceExport(statement.exportClause)) {
+                    unsupported.push({ code: "OBJECT_UNPACK_REEXPORT_UNSUPPORTED", message: "export-star/namespace re-export from unpacked source is unsupported", file: toRepoPath(workspace.root, file) });
+                    continue;
+                }
+                for (const element of statement.exportClause.elements) {
+                    const identity = (0, semantic_workspace_1.resolveSemanticNodeIdentity)(workspace, project, element.propertyName ?? element.name);
+                    if (identity && objectKeys.has(identity.key)) {
+                        unsupported.push({ code: "OBJECT_UNPACK_REEXPORT_UNSUPPORTED", message: "re-export of unpacked object is unsupported", file: toRepoPath(workspace.root, file) });
+                    }
+                }
+            }
+        }
+    }
+}
+function validateRequireConsumers(workspace, sourceFile, unsupported) {
+    const seen = new Set();
+    for (const project of workspace.projects) {
+        for (const file of project.config.parsed.fileNames) {
+            const key = (0, semantic_workspace_1.canonicalPathIdentity)(file);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            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 provenRequire = declarations.some((declaration) => declaration.getSourceFile().isDeclarationFile || modifiersOf(declaration).some((modifier) => modifier.kind === typescript_1.default.SyntaxKind.DeclareKeyword));
+                    if (!symbol) {
+                        unsupported.push({ code: "OBJECT_UNPACK_REQUIRE_EVIDENCE_UNAVAILABLE", message: "require-like call targets unpacked source but require identity is unavailable", file: toRepoPath(workspace.root, file) });
+                    }
+                    else if (provenRequire) {
+                        unsupported.push({ code: "OBJECT_UNPACK_REQUIRE_UNSUPPORTED", message: "CommonJS require of unpacked source is unsupported", file: toRepoPath(workspace.root, file) });
+                    }
+                }
+                typescript_1.default.forEachChild(node, visit);
+            };
+            visit(source);
+        }
+    }
+}
+function chooseConsumerBinding(workspace, project, source, sourceFile, objectName, member) {
+    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 bindings = statement.importClause?.namedBindings;
+        if (!bindings || !typescript_1.default.isNamedImports(bindings))
+            continue;
+        for (const element of bindings.elements) {
+            const identity = (0, semantic_workspace_1.resolveSemanticNodeIdentity)(workspace, project, element.name);
+            if (identity?.key === member.symbol.key)
+                return element.name.text;
+        }
+    }
+    if (!project.checker.resolveName(member.selector, source, typescript_1.default.SymbolFlags.Value, false)) {
+        return member.selector;
+    }
+    const base = `${objectName}${member.selector[0].toUpperCase()}${member.selector.slice(1)}`;
+    let candidate = base;
+    let suffix = 2;
+    while (project.checker.resolveName(candidate, source, typescript_1.default.SymbolFlags.Value, false)) {
+        candidate = `${base}${suffix}`;
+        suffix += 1;
+    }
+    return candidate;
+}
+function addExportModifier(source, member, replacements) {
+    if (hasExportModifier(member.statement))
+        return;
+    addReplacement(replacements, {
+        start: member.statement.getStart(source),
+        end: member.statement.getStart(source),
+        text: "export ",
+        reason: `object.unpack export ${member.selector}`
+    });
+}
+function unwrapObjectLiteral(initializer) {
+    let current = initializer;
+    while (true) {
+        if (typescript_1.default.isParenthesizedExpression(current) || typescript_1.default.isSatisfiesExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (typescript_1.default.isAsExpression(current) && current.type.getText() === "const") {
+            current = current.expression;
+            continue;
+        }
+        return typescript_1.default.isObjectLiteralExpression(current) ? current : null;
+    }
+}
+function projectForUsage(workspace, usage) {
+    return workspace.projects.find((project) => toRepoPath(workspace.root, project.config.file) === usage.project);
+}
+function consumerPlan(target, file) {
+    const current = target.get(file) ?? {
+        file,
+        replacements: [],
+        objectNames: new Set(),
+        selectors: new Map(),
+        referenceCount: 0
+    };
+    target.set(file, current);
+    return current;
+}
+function objectUsageCode(kinds) {
+    if (kinds.includes("property-write") || kinds.includes("update/delete"))
+        return "OBJECT_UNPACK_OBJECT_WRITE_UNSUPPORTED";
+    if (kinds.includes("destructure"))
+        return "OBJECT_UNPACK_DESTRUCTURE_UNSUPPORTED";
+    if (kinds.includes("type-position/type-query"))
+        return "OBJECT_UNPACK_TYPE_USAGE_UNSUPPORTED";
+    return "OBJECT_UNPACK_OBJECT_IDENTITY_UNSUPPORTED";
+}
+function isWriteOrUpdateTarget(node) {
+    const parent = node.parent;
+    return Boolean(parent && (typescript_1.default.isBinaryExpression(parent) && parent.left === node && parent.operatorToken.kind >= typescript_1.default.SyntaxKind.FirstAssignment && parent.operatorToken.kind <= typescript_1.default.SyntaxKind.LastAssignment ||
+        typescript_1.default.isPrefixUnaryExpression(parent) || typescript_1.default.isPostfixUnaryExpression(parent) || typescript_1.default.isDeleteExpression(parent)));
+}
+function supportsDirectCall(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 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 importElementCompare(left, right) {
+    return left.replace(/\s+as\s+.*/, "").localeCompare(right.replace(/\s+as\s+.*/, "")) || left.localeCompare(right);
+}
+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) {
+        if (sorted[index].end > sorted[index - 1].start) {
+            throw new Error(`Overlapping object.unpack replacements: ${sorted[index].start}-${sorted[index].end} and ${sorted[index - 1].start}-${sorted[index - 1].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, replacement) {
+    if (!target.some((item) => item.start === replacement.start && item.end === replacement.end && item.text === replacement.text)) {
+        target.push(replacement);
+    }
+}
+function moduleShapesUnchanged(root, virtualTexts) {
+    for (const [file, nextText] of virtualTexts) {
+        const absolute = path.resolve(root, file);
+        const before = new Set(moduleShape(fs.readFileSync(absolute, "utf8"), absolute));
+        const after = moduleShape(nextText, absolute);
+        if (after.some((edge) => !before.has(edge)))
+            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)) {
+            shape.push(`import:${node.importClause?.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 collectFingerprintModuleEdges(edges, sourceFile) {
+    return edges.filter((edge) => edge.fromFile === sourceFile || edge.toFile === sourceFile);
+}
+function failure(sourceFile, rows, unsupported, coverage) {
+    const ordered = [...unsupported].sort((left, right) => (left.file ?? "").localeCompare(right.file ?? "") || (left.objectName ?? "").localeCompare(right.objectName ?? "") ||
+        (left.selector ?? "").localeCompare(right.selector ?? "") || left.code.localeCompare(right.code));
+    return {
+        ok: false,
+        operation: "exports.object.unpack.preview",
+        applyAvailable: false,
+        code: "OBJECT_UNPACK_SEMANTIC_PREVIEW_REJECTED",
+        sourceFile,
+        objectCount: rows.length,
+        memberCount: rows.reduce((sum, row) => sum + row.selectors.length, 0),
+        filesTouched: [],
+        filesWritten: [],
+        ...(coverage ? { coverage } : {}),
+        unsupportedCount: ordered.length,
+        unsupported: ordered
+    };
+}
+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 Boolean(parent && (typescript_1.default.isVariableDeclaration(parent) && parent.name === node ||
+        typescript_1.default.isFunctionDeclaration(parent) && parent.name === node ||
+        typescript_1.default.isImportSpecifier(parent) && parent.name === node));
+}
+function propertyNameText(name) {
+    if (!name)
+        return null;
+    return typescript_1.default.isIdentifier(name) || typescript_1.default.isStringLiteralLike(name) || typescript_1.default.isNumericLiteral(name) ? name.text : null;
+}
+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 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 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;
+    return [typescript_1.default.ModuleKind.Node16, typescript_1.default.ModuleKind.NodeNext].includes(kind) ? source.impliedNodeFormat === typescript_1.default.ModuleKind.ESNext : 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 uniqueSymbols(symbols) {
+    return [...new Map(symbols.map((symbol) => [symbol.key, symbol])).values()].sort((left, right) => left.key.localeCompare(right.key));
+}
+function uniqueUsages(usages) {
+    return [...new Map(usages.map((usage) => [`${usage.symbol.key}\0${usage.file}\0${usage.start}\0${usage.end}`, usage])).values()]
+        .sort((left, right) => left.file.localeCompare(right.file) || left.start - right.start || left.end - right.end || left.symbol.key.localeCompare(right.symbol.key));
+}
+function toCoverageEvidence(reason) {
+    const record = reason;
+    return {
+        code: `OBJECT_UNPACK_COVERAGE_${reason.code}`,
+        message: "semantic reference coverage is incomplete",
+        ...(typeof record.file === "string" ? { file: record.file } : {}),
+        details: reason
+    };
+}
+function toRepoPath(root, file) {
+    return path.relative(root, path.resolve(file)).replace(/\\/g, "/") || ".";
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}