@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/inspect/standalone-inspect-worker.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const standalone_inspect_analysis_1 = require("./standalone-inspect-analysis");
+process.once("message", (raw) => {
+    if (!isRequest(raw)) {
+        process.exitCode = 2;
+        process.disconnect?.();
+        return;
+    }
+    void (0, standalone_inspect_analysis_1.runStandaloneInspectPayload)(raw.workspaceRoot, raw.payload).then((result) => send({ type: "standaloneInspectResult", id: raw.id, pid: process.pid, result }), (error) => send({ type: "standaloneInspectResult", id: raw.id, pid: process.pid, result: { ok: false, code: "STANDALONE_INSPECT_WORKER_FAILED", error: error instanceof Error ? error.message : String(error) } }));
+});
+function send(message) { process.send?.(message, () => process.disconnect?.()); }
+function isRequest(value) { return Boolean(value && typeof value === "object" && !Array.isArray(value) && value.type === "standaloneInspectRequest" && typeof value.id === "string" && typeof value.workspaceRoot === "string" && value.payload); }

package/dist/metrics/central-metrics.js

@@ -1,2 +1,101 @@
-"use strict";var s=exports&&exports.__importDefault||function(t){return t&&t.__esModule?t:{default:t}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.centralMetricsEnabled=c,exports.mutationImpactMetricsEnabled=p,exports.mutationImpactStreamEnabled=_,exports.startCentralMetricSpan=v,exports.recordCentralMetric=f,exports.resolveCentralMetricsDir=l;const a=s(require("node:fs")),o=s(require("node:path")),n=require("../config/env-vars"),d=require("../config/product-storage"),m=require("../observability/context"),u=require("../observability/config");function c(){const t=process.env[n.CLI_ENV.metrics]?.trim().toLowerCase();return t==="0"||t==="false"||t==="off"?!1:(0,u.resolveObservabilityConfig)().metrics==="on"}function p(){if(!c())return!1;const t=process.env[n.CLI_ENV.mutationImpactMetrics]?.trim().toLowerCase();return t==="0"||t==="false"||t==="off"?!1:t==="1"||t==="true"||t==="on"?!0:(0,u.resolveObservabilityConfig)().mutationImpactMetrics==="on"}function _(){return process.env[n.CLI_ENV.mutationImpactStream]==="1"}function v(t){const r=Date.now(),i=new Date(r).toISOString();return{end(e={}){f({...t,...e,startedAt:i,completedAt:new Date().toISOString(),durationMs:Date.now()-r})}}}function f(t){if(c())try{const r=l(),i=typeof t.cwd=="string"?(0,m.buildCorrelationContext)(t.cwd):{};a.default.mkdirSync(r,{recursive:!0});const e=C({version:1,recordedAt:new Date().toISOString(),pid:process.pid,platform:process.platform,...process.env[n.CLI_ENV.metricsTag]?{tag:process.env[n.CLI_ENV.metricsTag]}:{},...i,...t});a.default.appendFileSync(o.default.join(r,"metrics.jsonl"),`${JSON.stringify(e)}
-`,"utf8")}catch{}}function l(){const t=process.env[n.CLI_ENV.metricsDir];return t&&t.trim()?o.default.resolve(t):o.default.join((0,d.productStorageRoot)(),"metrics")}function C(t){const r={};for(const[i,e]of Object.entries(t))e!=null&&(Array.isArray(e)&&e.length===0||typeof e=="object"&&!Array.isArray(e)&&Object.keys(e).length===0||(r[i]=e));return r}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.centralMetricsEnabled = centralMetricsEnabled;
+exports.mutationImpactMetricsEnabled = mutationImpactMetricsEnabled;
+exports.mutationImpactStreamEnabled = mutationImpactStreamEnabled;
+exports.startCentralMetricSpan = startCentralMetricSpan;
+exports.recordCentralMetric = recordCentralMetric;
+exports.resolveCentralMetricsDir = resolveCentralMetricsDir;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const env_vars_1 = require("../config/env-vars");
+const product_storage_1 = require("../config/product-storage");
+const context_1 = require("../observability/context");
+const config_1 = require("../observability/config");
+function centralMetricsEnabled() {
+    const raw = process.env[env_vars_1.CLI_ENV.metrics]?.trim().toLowerCase();
+    if (raw === "0" || raw === "false" || raw === "off") {
+        return false;
+    }
+    return (0, config_1.resolveObservabilityConfig)().metrics === "on";
+}
+function mutationImpactMetricsEnabled() {
+    if (!centralMetricsEnabled()) {
+        return false;
+    }
+    const raw = process.env[env_vars_1.CLI_ENV.mutationImpactMetrics]?.trim().toLowerCase();
+    if (raw === "0" || raw === "false" || raw === "off") {
+        return false;
+    }
+    if (raw === "1" || raw === "true" || raw === "on") {
+        return true;
+    }
+    return (0, config_1.resolveObservabilityConfig)().mutationImpactMetrics === "on";
+}
+function mutationImpactStreamEnabled() {
+    return process.env[env_vars_1.CLI_ENV.mutationImpactStream] === "1";
+}
+function startCentralMetricSpan(event) {
+    const startedAtMs = Date.now();
+    const startedAt = new Date(startedAtMs).toISOString();
+    return {
+        end(extra = {}) {
+            recordCentralMetric({
+                ...event,
+                ...extra,
+                startedAt,
+                completedAt: new Date().toISOString(),
+                durationMs: Date.now() - startedAtMs
+            });
+        }
+    };
+}
+function recordCentralMetric(event, options = {}) {
+    if (options.explicitlyEnabled !== true && !centralMetricsEnabled()) {
+        return;
+    }
+    try {
+        const metricsDir = resolveCentralMetricsDir();
+        const context = typeof event.cwd === "string" ? (0, context_1.buildCorrelationContext)(event.cwd) : {};
+        node_fs_1.default.mkdirSync(metricsDir, { recursive: true });
+        const row = compactMetric({
+            version: 1,
+            recordedAt: new Date().toISOString(),
+            pid: process.pid,
+            platform: process.platform,
+            ...(process.env[env_vars_1.CLI_ENV.metricsTag] ? { tag: process.env[env_vars_1.CLI_ENV.metricsTag] } : {}),
+            ...context,
+            ...event
+        });
+        node_fs_1.default.appendFileSync(node_path_1.default.join(metricsDir, "metrics.jsonl"), `${JSON.stringify(row)}\n`, "utf8");
+    }
+    catch {
+        // Metrics must never change command behavior.
+    }
+}
+function resolveCentralMetricsDir() {
+    const override = process.env[env_vars_1.CLI_ENV.metricsDir];
+    if (override && override.trim()) {
+        return node_path_1.default.resolve(override);
+    }
+    return node_path_1.default.join((0, product_storage_1.productStorageRoot)(), "metrics");
+}
+function compactMetric(value) {
+    const output = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (item === undefined || item === null) {
+            continue;
+        }
+        if (Array.isArray(item) && item.length === 0) {
+            continue;
+        }
+        if (typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 0) {
+            continue;
+        }
+        output[key] = item;
+    }
+    return output;
+}

package/dist/mutation/concrete-edit-plan.js

@@ -0,0 +1,157 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeConcreteEdits = normalizeConcreteEdits;
+exports.createSemanticFingerprint = createSemanticFingerprint;
+exports.createConcretePreconditions = createConcretePreconditions;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+function normalizeConcreteEdits(edits) {
+    const normalized = edits.map((edit) => {
+        validateEditRange(edit);
+        return {
+            ...edit,
+            file: normalizeEditFile(edit.file)
+        };
+    }).sort((left, right) => left.file.localeCompare(right.file) || left.start - right.start || left.end - right.end ||
+        left.text.localeCompare(right.text) || left.reason.localeCompare(right.reason));
+    for (let index = 1; index < normalized.length; index += 1) {
+        const previous = normalized[index - 1];
+        const current = normalized[index];
+        if (previous.file === current.file && previous.start === previous.end &&
+            current.start === current.end && previous.start === current.start) {
+            throw new Error(`Conflicting zero-length inserts in ${current.file} at ${current.start}.`);
+        }
+        if (previous.file === current.file && current.start < previous.end) {
+            throw new Error(`Overlapping concrete edits in ${current.file}: ${previous.start}-${previous.end} and ${current.start}-${current.end}.`);
+        }
+    }
+    return normalized;
+}
+function createSemanticFingerprint(input) {
+    const normalized = {
+        intent: {
+            ...input.intent,
+            sourceFile: normalizeFile(input.intent.sourceFile),
+            members: [...new Set(input.intent.members)].sort()
+        },
+        projects: input.projects.map((project) => ({
+            tsconfig: normalizeFile(project.tsconfig),
+            configFingerprint: project.configFingerprint,
+            packageRoot: project.packageRoot ? normalizeFile(project.packageRoot) : undefined,
+            packageName: project.packageName,
+            projectReferences: [...new Set(project.projectReferences.map(normalizeFile))].sort()
+        })).sort((left, right) => left.tsconfig.localeCompare(right.tsconfig)),
+        symbols: input.symbols.map((symbol) => ({ ...symbol, declarationFile: normalizeFile(symbol.declarationFile) }))
+            .sort((left, right) => left.key.localeCompare(right.key) || left.name.localeCompare(right.name) ||
+            left.declarationFile.localeCompare(right.declarationFile) || left.declarationStart - right.declarationStart ||
+            left.declarationEnd - right.declarationEnd || left.flags - right.flags),
+        references: input.references.map((reference) => ({
+            symbol: reference.symbol.key,
+            file: normalizeFile(reference.file),
+            start: reference.start,
+            end: reference.end,
+            text: reference.text,
+            kinds: [...new Set(reference.kinds)].sort(),
+            project: normalizeFile(reference.project)
+        })).sort((left, right) => left.file.localeCompare(right.file) || left.start - right.start ||
+            left.end - right.end || left.symbol.localeCompare(right.symbol) ||
+            left.kinds.join("\0").localeCompare(right.kinds.join("\0")) || left.project.localeCompare(right.project) ||
+            left.text.localeCompare(right.text)),
+        moduleEdges: input.moduleEdges.map((edge) => ({
+            ...edge,
+            fromFile: normalizeFile(edge.fromFile),
+            toFile: normalizeFile(edge.toFile)
+        })).sort((left, right) => left.fromFile.localeCompare(right.fromFile) || left.toFile.localeCompare(right.toFile) ||
+            left.specifier.localeCompare(right.specifier) || left.kind.localeCompare(right.kind))
+    };
+    return sha256(stableStringify(normalized));
+}
+function createConcretePreconditions(workspaceRoot, edits) {
+    const root = path.resolve(workspaceRoot);
+    const realRoot = fs.realpathSync(root);
+    const files = [...new Set(normalizeConcreteEdits(edits).map((edit) => edit.file))];
+    return files.map((file) => {
+        const absolute = path.resolve(root, file);
+        assertContained(root, absolute, file);
+        const realFile = fs.realpathSync(absolute);
+        assertContained(realRoot, realFile, file);
+        return { file, beforeHash: sha256(fs.readFileSync(absolute)) };
+    });
+}
+function validateEditRange(edit) {
+    if (!Number.isFinite(edit.start) || !Number.isFinite(edit.end) ||
+        !Number.isInteger(edit.start) || !Number.isInteger(edit.end) ||
+        edit.start < 0 || edit.end < edit.start) {
+        throw new Error(`Invalid concrete edit range for ${edit.file}: ${edit.start}-${edit.end}.`);
+    }
+}
+function normalizeEditFile(file) {
+    const slashed = file.replace(/\\/g, "/");
+    const segments = slashed.split("/");
+    if (!slashed || path.isAbsolute(file) || path.win32.isAbsolute(file) || path.posix.isAbsolute(slashed) ||
+        segments.includes("..")) {
+        throw new Error(`Concrete edit file must be a contained repo-relative path: ${file}.`);
+    }
+    const normalized = path.posix.normalize(slashed).replace(/^\.\//, "");
+    if (!normalized || normalized === ".") {
+        throw new Error(`Concrete edit file must identify a file: ${file}.`);
+    }
+    return normalized;
+}
+function assertContained(root, file, displayFile) {
+    const relative = path.relative(root, file);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`Concrete edit file escapes workspace: ${displayFile}.`);
+    }
+}
+function normalizeFile(file) {
+    return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).filter((key) => record[key] !== undefined).sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}

package/dist/mutation/exports-star-collapse-preview.js

@@ -0,0 +1,361 @@
+"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.ExportsStarCollapsePreviewSession = void 0;
+exports.planExportsStarCollapsePreview = planExportsStarCollapsePreview;
+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 semantic_context_provider_1 = require("../semantic/semantic-context-provider");
+const workspace_project_index_1 = require("../topology/workspace-project-index");
+const semantic_export_index_1 = require("./semantic-export-index");
+function planExportsStarCollapsePreview(cwd, input) {
+    const session = new ExportsStarCollapsePreviewSession(cwd);
+    try {
+        return session.plan(input);
+    }
+    finally {
+        session.dispose();
+    }
+}
+class ExportsStarCollapsePreviewSession {
+    pool;
+    root;
+    projectIndex;
+    semanticProvider;
+    leases = new Map();
+    structuralIndexMs;
+    programsBuilt = 0;
+    overlaysBuilt = 0;
+    poolHits = 0;
+    poolMisses = 0;
+    poolFallbacks = 0;
+    disposed = false;
+    constructor(cwd, pool) {
+        this.pool = pool;
+        this.root = path.resolve(cwd);
+        const started = performance.now();
+        this.projectIndex = new workspace_project_index_1.WorkspaceProjectIndex(this.root);
+        this.structuralIndexMs = roundMs(performance.now() - started);
+        this.semanticProvider = new semantic_context_provider_1.SemanticContextProvider(this.root, this.projectIndex);
+    }
+    get resources() {
+        return { structuralIndexesBuilt: 1, semanticProvidersCreated: 1, distinctContextsAcquired: this.leases.size, programsBuilt: this.programsBuilt, overlaysBuilt: this.overlaysBuilt, poolHits: this.poolHits, poolMisses: this.poolMisses, poolFallbacks: this.poolFallbacks };
+    }
+    plan(input) {
+        if (this.disposed)
+            throw new Error("ExportsStarCollapsePreviewSession is disposed.");
+        const totalStarted = performance.now();
+        const absolute = path.resolve(this.root, input.sourceFile);
+        const sourceFile = repoPath(this.root, absolute);
+        const timings = { structuralIndexMs: this.structuralIndexMs };
+        if (!inside(this.root, absolute) || !fs.existsSync(absolute))
+            return empty(sourceFile, "sourceNotFound", "The requested barrel is not an existing workspace file.", timings, this.resources, totalStarted);
+        if (!/\.(?:ts|tsx|mts|cts)$/i.test(sourceFile) || /\.d\.ts$/i.test(sourceFile))
+            return empty(sourceFile, "sourceKindUnsupported", "exports.star.collapse preview supports TypeScript source modules only.", timings, this.resources, totalStarted);
+        const semanticStarted = performance.now();
+        const owners = this.projectIndex.exactOwnersForFile(sourceFile);
+        if (owners.length === 0)
+            return empty(sourceFile, "barrelNotOwned", "No exact TypeScript project owns the barrel.", timings, this.resources, totalStarted);
+        for (const owner of owners)
+            this.acquire(sourceFile, owner);
+        const records = owners.map((owner) => this.leases.get(owner.identity.key));
+        const source = records[0]?.lease.program.getSourceFile(absolute);
+        if (!source)
+            return empty(sourceFile, "barrelMissingFromProgram", "The barrel is missing from its owning TypeScript program.", timings, this.resources, totalStarted);
+        timings.semanticContextsMs = roundMs(performance.now() - semanticStarted);
+        const ownerNames = owners.map((owner) => repoPath(this.root, owner.identity.lexicalPath)).sort();
+        const exportStarted = performance.now();
+        const provider = exportProvider(this.root, records);
+        const baselineBarrel = (0, semantic_export_index_1.buildSemanticExportIndexFromProvider)(provider, { barrelFiles: [sourceFile] }).barrels[0];
+        timings.exportIndexMs = roundMs(performance.now() - exportStarted);
+        const selected = selectGroups(baselineBarrel, input.selectors, sourceFile);
+        if (isCommonJsSource(source, records[0].lease.program.getCompilerOptions())) {
+            return retainedPreview(sourceFile, selected.requestedCount, ownerNames, selected.groups.map((group) => retained(sourceFile, group.selector, "commonJsObservableShapeUnproven", "TS-to-CJS export-star namespace descriptors/order are not proven equivalent.")), selected.retained, timings, this.resources, totalStarted);
+        }
+        const baselineSignature = surfaceSignature(baselineBarrel);
+        const baselineDiagnostics = diagnosticSet(this.root, records, sourceFile);
+        const accepted = [];
+        const retainedRows = [...selected.retained];
+        const surfaces = [];
+        let currentText = source.text;
+        const proofStarted = performance.now();
+        for (const group of selected.groups) {
+            const local = validateGroup(source, group, sourceFile);
+            if (local) {
+                retainedRows.push(local);
+                continue;
+            }
+            const candidate = renderGroup(source, group);
+            if (!candidate) {
+                retainedRows.push(retained(sourceFile, group.selector, "rendererUnsupported", "The selected named re-export group cannot be rendered without losing trivia."));
+                continue;
+            }
+            const nextText = applyReplacements(source.text, [...accepted, ...candidate]);
+            const proof = this.proveOverlay(sourceFile, owners, nextText, baselineSignature, baselineDiagnostics);
+            if (!proof.ok) {
+                retainedRows.push(retained(sourceFile, group.selector, proof.code, proof.reason));
+                continue;
+            }
+            accepted.push(...candidate);
+            currentText = nextText;
+            surfaces.push({ selector: group.selector, specifier: group.specifier, mode: group.mode === "named-type" ? "type-star" : "runtime-star", names: unique(group.edges.flatMap((edge) => edge.bindings.map((binding) => binding.publicName))).sort(), explicitEdgeCount: group.edges.length });
+        }
+        timings.proofMs = roundMs(performance.now() - proofStarted);
+        timings.totalMs = roundMs(this.structuralIndexMs + performance.now() - totalStarted);
+        const plannedCount = surfaces.length;
+        const dedupedRetained = dedupeRetained(retainedRows);
+        const edits = plannedCount ? [{ file: sourceFile, start: 0, end: source.text.length, text: currentText, reason: "exports.star.collapse preview" }] : [];
+        const beforeHashes = plannedCount ? [{ file: sourceFile, beforeHash: sha256(source.text) }] : [];
+        const evidence = { sourceFile, owners: ownerNames, selectors: input.selectors ?? [], surfaces, retained: dedupedRetained, beforeHashes, afterSurface: baselineSignature };
+        return {
+            ok: true,
+            operation: "exports.star.collapse.preview",
+            applyAvailable: false,
+            partial: plannedCount > 0 && dedupedRetained.length > 0,
+            sourceFile,
+            requestedCount: selected.requestedCount,
+            plannedCount,
+            retainedCount: dedupedRetained.length,
+            filesTouched: plannedCount ? [sourceFile] : [],
+            filesWritten: [],
+            retained: dedupedRetained,
+            rows: [{ ok: true, sourceFile, requestedCount: selected.requestedCount, plannedCount, retainedCount: dedupedRetained.length }],
+            edits,
+            beforeHashes,
+            owners: ownerNames,
+            surfaces,
+            diagnostics: { added: [] },
+            cycleEvidence: { status: "available", runtimeEdgesChanged: false, cyclesAdded: [] },
+            futureLeakage: surfaces.map((item) => ({ specifier: item.specifier, policy: "star-follows-target", note: "Future non-default exports added by the target will become public through this barrel." })),
+            timings,
+            resources: this.resources,
+            semanticFingerprint: sha256(stableStringify(evidence)),
+            next: "Review exports.star.collapse view evidence; apply/execute is not available yet."
+        };
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const item of this.leases.values())
+            item.lease.release();
+        this.leases.clear();
+        this.semanticProvider.dispose();
+        this.projectIndex.dispose();
+    }
+    acquire(focusFile, owner) {
+        const found = this.leases.get(owner.identity.key);
+        if (found)
+            return found;
+        let lease;
+        if (this.pool) {
+            try {
+                const pooled = this.pool.acquireProgram({ focusFile, ownerConfig: owner.identity.lexicalPath, projectScope: "owner-with-forward-references" });
+                lease = pooled;
+                if (pooled.cache.status === "hit")
+                    this.poolHits += 1;
+                else {
+                    this.poolMisses += 1;
+                    this.programsBuilt += 1;
+                }
+            }
+            catch {
+                this.poolFallbacks += 1;
+                this.programsBuilt += 1;
+                lease = this.semanticProvider.acquireProgram({ focusFile, ownerConfig: owner.identity.lexicalPath, projectScope: "owner-with-forward-references" });
+            }
+        }
+        else {
+            this.programsBuilt += 1;
+            lease = this.semanticProvider.acquireProgram({ focusFile, ownerConfig: owner.identity.lexicalPath, projectScope: "owner-with-forward-references" });
+        }
+        const handle = makeHandle(this.root, owner, lease);
+        const record = { owner, lease, handle };
+        this.leases.set(owner.identity.key, record);
+        return record;
+    }
+    proveOverlay(sourceFile, owners, text, expectedSurface, baselineDiagnostics) {
+        const overlayRecords = [];
+        try {
+            for (const owner of owners) {
+                const lease = this.semanticProvider.acquireProgram({ focusFile: sourceFile, ownerConfig: owner.identity.lexicalPath, projectScope: "owner-with-forward-references", overlays: [{ file: sourceFile, text }] });
+                this.overlaysBuilt += 1;
+                overlayRecords.push({ owner, lease, handle: makeHandle(this.root, owner, lease) });
+            }
+            const barrel = (0, semantic_export_index_1.buildSemanticExportIndexFromProvider)(exportProvider(this.root, overlayRecords), { barrelFiles: [sourceFile] }).barrels[0];
+            if (surfaceSignature(barrel) !== expectedSurface)
+                return { ok: false, code: "observableSurfaceChanged", reason: "Replacing the named re-exports with a star changes the current public export surface or symbol identity." };
+            const added = [...diagnosticSet(this.root, overlayRecords, sourceFile)].find((item) => !baselineDiagnostics.has(item));
+            if (added)
+                return { ok: false, code: "virtualDiagnosticsAdded", reason: "The collapsed barrel adds a TypeScript diagnostic." };
+            return { ok: true };
+        }
+        finally {
+            for (const item of overlayRecords)
+                item.lease.release();
+        }
+    }
+}
+exports.ExportsStarCollapsePreviewSession = ExportsStarCollapsePreviewSession;
+function selectGroups(barrel, selectors, sourceFile) {
+    const named = barrel.edges.filter((edge) => edge.mode === "named-runtime" || edge.mode === "named-type");
+    const groups = [...new Set(named.map((edge) => edge.specifier))].map((specifier) => {
+        const edges = named.filter((edge) => edge.specifier === specifier);
+        const hasRuntimeBinding = edges.some((edge) => edge.bindings.some((binding) => binding.exposure === "runtime"));
+        return { selector: specifier, specifier, mode: hasRuntimeBinding ? "named-runtime" : "named-type", edges };
+    });
+    if (!selectors?.length)
+        return { groups, retained: groups.length ? [] : [retained(sourceFile, "*", "namedReexportNotFound", "The barrel has no named re-export groups to collapse.")], requestedCount: groups.length };
+    const selected = [];
+    const retainedRows = [];
+    const requested = unique(selectors.map((item) => item.trim()).filter(Boolean));
+    for (const selector of requested) {
+        const exact = groups.filter((group) => group.specifier === selector);
+        const matches = exact.length ? exact : groups.filter((group) => (0, semantic_export_index_1.normalizeExportEdgeSelector)(group.specifier) === (0, semantic_export_index_1.normalizeExportEdgeSelector)(selector));
+        if (matches.length === 1)
+            selected.push({ ...matches[0], selector });
+        else if (matches.length > 1)
+            retainedRows.push({ ...retained(sourceFile, selector, "selectorAmbiguous", "Selector matches multiple named re-export groups."), candidates: unique(matches.map((item) => item.specifier)).sort() });
+        else
+            retainedRows.push(retained(sourceFile, selector, "selectorNotFound", "No existing named re-export group matches this selector."));
+    }
+    return { groups: selected, retained: retainedRows, requestedCount: requested.length };
+}
+function validateGroup(source, group, sourceFile) {
+    if (group.edges.some((edge) => /\.(?:jsx?|mjs|cjs)$/i.test(edge.resolvedFile ?? "")))
+        return retained(sourceFile, group.selector, "targetKindUnsupported", "Raw JavaScript/CommonJS export targets are unsupported.");
+    if (group.edges.some((edge) => edge.resolution !== "resolved" || !edge.resolvedFile || edge.issues.length > 0))
+        return retained(sourceFile, group.selector, "edgeEvidenceIncomplete", "The selected named re-export group does not resolve equivalently for every owner.");
+    const bindings = group.edges.flatMap((edge) => edge.bindings);
+    if (bindings.some((binding) => binding.isDefault || binding.publicName !== binding.targetName))
+        return retained(sourceFile, group.selector, "aliasOrDefaultUnsupported", "Aliases and default re-exports cannot be represented by export star.");
+    if (group.mode === "named-runtime" && !bindings.some((binding) => binding.exposure === "runtime"))
+        return retained(sourceFile, group.selector, "runtimeEvaluationChangeUnproven", "A runtime star would add evaluation to a type-only named re-export group.");
+    for (const edge of group.edges) {
+        const statement = source.statements.find((item) => item.getStart(source) === edge.start && item.end === edge.end);
+        if (!statement || !typescript_1.default.isExportDeclaration(statement) || !statement.moduleSpecifier)
+            return retained(sourceFile, group.selector, "statementShapeUnsupported", "The selected export declaration shape is unsupported.");
+        const clauseText = source.text.slice(statement.getStart(source), statement.moduleSpecifier.getStart(source));
+        if (/\/\*|\/\//.test(clauseText))
+            return retained(sourceFile, group.selector, "inlineCommentUnsupported", "Inline comments inside the named export clause must be preserved manually.");
+    }
+    return null;
+}
+function renderGroup(source, group) {
+    const statements = group.edges.map((edge) => ({ edge, statement: source.statements.find((item) => item.getStart(source) === edge.start && item.end === edge.end) })).sort((a, b) => a.edge.start - b.edge.start);
+    const first = statements[0];
+    if (!first?.statement || !typescript_1.default.isExportDeclaration(first.statement) || !first.statement.moduleSpecifier)
+        return null;
+    const moduleText = source.text.slice(first.statement.moduleSpecifier.getStart(source), first.statement.moduleSpecifier.end);
+    const tail = source.text.slice(first.statement.moduleSpecifier.end, first.statement.end);
+    const replacement = `${group.mode === "named-type" ? "export type *" : "export *"} from ${moduleText}${tail}`;
+    return statements.map((item, index) => ({ start: item.edge.start, end: item.edge.end, text: index === 0 ? replacement : "" }));
+}
+function makeHandle(root, owner, lease) {
+    return {
+        id: repoPath(root, owner.identity.lexicalPath), checker: lease.checker,
+        getSourceFile: (file) => lease.program.getSourceFile(path.resolve(file)),
+        resolveModule: (fromFile, specifier) => typescript_1.default.resolveModuleName(specifier, fromFile, lease.program.getCompilerOptions(), typescript_1.default.sys).resolvedModule?.resolvedFileName ?? null,
+        symbolIdentity: (symbol) => symbolIdentity(root, lease.checker, symbol),
+        diagnosticsForFile: (file) => { const source = lease.program.getSourceFile(path.resolve(file)); return source ? lease.program.getSemanticDiagnostics(source) : []; }
+    };
+}
+function exportProvider(root, records) {
+    return { root, projectsForFile: (file) => records.filter((record) => Boolean(record.lease.program.getSourceFile(path.resolve(file)))).map((record) => record.handle) };
+}
+function symbolIdentity(root, checker, symbol) {
+    let target = symbol;
+    if ((target.flags & typescript_1.default.SymbolFlags.Alias) !== 0) {
+        try {
+            target = checker.getAliasedSymbol(target);
+        }
+        catch { /* retain */ }
+    }
+    const declaration = target.valueDeclaration ?? target.declarations?.[0];
+    if (!declaration)
+        return null;
+    return { key: `${canonical(declaration.getSourceFile().fileName)}:${declaration.getStart()}:${declaration.end}:${target.flags}`, name: target.getName(), declarationFile: repoPath(root, declaration.getSourceFile().fileName), declarationStart: declaration.getStart(), declarationEnd: declaration.end, flags: target.flags };
+}
+function surfaceSignature(barrel) {
+    return stableStringify(barrel.bindings.map((binding) => ({ name: binding.publicName, key: binding.symbol.key, facets: binding.facets, exposure: binding.exposure, default: binding.isDefault })).sort((a, b) => a.name.localeCompare(b.name)));
+}
+function diagnosticSet(root, records, sourceFile) {
+    return new Set(records.flatMap((record) => {
+        const source = record.lease.program.getSourceFile(path.resolve(root, sourceFile));
+        return source ? [...record.lease.program.getSyntacticDiagnostics(source), ...record.lease.program.getSemanticDiagnostics(source)].map((item) => `${repoPath(root, item.file?.fileName ?? sourceFile)}:${item.start ?? -1}:${item.code}:${typescript_1.default.flattenDiagnosticMessageText(item.messageText, " ")}`) : [];
+    }));
+}
+function isCommonJsSource(source, options) {
+    if (source.fileName.toLowerCase().endsWith(".cts"))
+        return true;
+    if (source.fileName.toLowerCase().endsWith(".mts"))
+        return false;
+    if (options.module === typescript_1.default.ModuleKind.CommonJS)
+        return true;
+    return source.impliedNodeFormat === typescript_1.default.ModuleKind.CommonJS;
+}
+function applyReplacements(text, replacements) {
+    let result = text;
+    for (const item of [...replacements].sort((a, b) => b.start - a.start))
+        result = result.slice(0, item.start) + item.text + result.slice(item.end);
+    return result;
+}
+function empty(sourceFile, code, reason, timings, resources, started) {
+    return retainedPreview(sourceFile, 0, [], [], [retained(sourceFile, "*", code, reason)], timings, resources, started);
+}
+function retainedPreview(sourceFile, requestedCount, owners, groupRetained, initial, timings, resources, started) {
+    const retainedRows = dedupeRetained([...initial, ...groupRetained]);
+    timings.totalMs = roundMs((timings.structuralIndexMs ?? 0) + performance.now() - started);
+    return { ok: true, operation: "exports.star.collapse.preview", applyAvailable: false, partial: false, sourceFile, requestedCount, plannedCount: 0, retainedCount: retainedRows.length, filesTouched: [], filesWritten: [], retained: retainedRows, rows: [{ ok: true, sourceFile, requestedCount, plannedCount: 0, retainedCount: retainedRows.length }], edits: [], beforeHashes: [], owners, surfaces: [], diagnostics: { added: [] }, cycleEvidence: { status: "available", runtimeEdgesChanged: false, cyclesAdded: [] }, futureLeakage: [], timings, resources, semanticFingerprint: sha256(stableStringify({ sourceFile, owners, retained: retainedRows })), next: "Review retained exports.star.collapse evidence; apply/execute is not available yet." };
+}
+function retained(sourceFile, selector, code, reason) { return { sourceFile, selector, code, reason }; }
+function dedupeRetained(items) { return [...new Map(items.map((item) => [`${item.selector}:${item.code}:${item.reason}`, item])).values()]; }
+function unique(items) { return [...new Set(items)]; }
+function inside(root, file) { const relative = path.relative(path.resolve(root), path.resolve(file)); return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative)); }
+function repoPath(root, file) {
+    const absolute = path.isAbsolute(file) ? file : path.resolve(root, file);
+    return path.relative(root, absolute).replace(/\\/g, "/");
+}
+function canonical(file) { const value = path.resolve(file); return process.platform === "win32" ? value.toLowerCase() : value; }
+function sha256(value) { return crypto.createHash("sha256").update(value).digest("hex"); }
+function stableStringify(value) { if (value === null || typeof value !== "object")
+    return JSON.stringify(value); if (Array.isArray(value))
+    return `[${value.map(stableStringify).join(",")}]`; return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`; }
+function roundMs(value) { return Math.round(value * 100) / 100; }