@danceiny/gotry 0.0.1-rc.21 → 0.0.1-rc.24

package/dist/scripts/ledger-workflow-crash.js

@@ -1,3 +1,8 @@
+/**
+ * 崩溃注入探针(ledger-tests 的子进程):创建 durable 工单 → 求解(step done 落账)
+ * → 在 settle 之前 kill 自身(exit 9)——模拟「一小时后」回收进程中途崩溃。
+ * 用法:npx tsx scripts/ledger-workflow-crash.ts <stateRoot> <ticketId> <countFile>
+ */
 import { appendFileSync } from 'node:fs';
 import { collectDeepPlanning, makeJournaledSolvePort, persistAsyncTicket } from '../src/loop.js';
 import { openLedgerIfExists } from '../src/state-ledger.js';
@@ -10,33 +15,18 @@ const ticket = {
     id,
     objective: '崩溃注入:已求解未交付(settle 前被杀)',
     requestedAt: new Date().toISOString(),
-    etaLabel: '秒级'
+    etaLabel: '秒级',
 };
 const state = {
-    calendar: {
-        year: 2026,
-        assertedWeekdays: {}
-    },
+    calendar: { year: 2026, assertedWeekdays: {} },
     profile: {},
     gates: [],
     wishes: [],
-    spec: {
-        segments: []
-    }
+    spec: { segments: [] },
 };
 await persistAsyncTicket(ticket, state, root);
 const ledger = openLedgerIfExists(root);
-const solve = makeJournaledSolvePort(ledger, id, async ()=>({
-        feasible: false,
-        unsat_core: [
-            'crash-probe'
-        ],
-        suggestions: []
-    }), {
-    onRealSolve: ()=>appendFileSync(countFile, 'solve\n')
-});
+const solve = makeJournaledSolvePort(ledger, id, async () => ({ feasible: false, unsat_core: ['crash-probe'], suggestions: [] }), { onRealSolve: () => appendFileSync(countFile, 'solve\n') });
 await collectDeepPlanning(state, ticket, solve);
+// solve 步骤已 done 落账,交付未落——此刻崩掉
 process.exit(9);
-
-
-//# sourceURL=ts/scripts/ledger-workflow-crash.ts

package/dist/scripts/map-tools-vendor-package-proof.js

@@ -1,14 +1,24 @@
+/**
+ * Package proof for issue #202.
+ *
+ * The full suite passes the executable from its clean tarball install; focused
+ * runs pack/unpack locally and attach the already-installed root closure. Both
+ * paths load the plugin from the artifact, never from the checkout vendor path.
+ * No map provider or paid endpoint is contacted; inline-coordinate geocoding is
+ * asserted with fetch disabled.
+ */
 import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync } from 'node:fs';
+import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import assert from 'node:assert/strict';
 const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
 const upstreamLicenseSha256 = 'b6bbb0c73a02cf8d2c304e9f208b41c32f0a810fabe366986e2b14ac3338f618';
 const upstreamVendorFileCount = 32;
-const upstreamVendorAggregateSha256 = 'd82a38adace8bfe574dcecb4222da5c994a1b9e8792f78dc2dad3a7f50c9925a';
+const adaptedVendorAggregateSha256 = '65ac7b76a62c07bda771c476fff6b4c5e4220b013ce74ad3c54e6b95e5b34063';
 const expectedTools = [
     'map_bicycling_route',
     'map_driving_route',
@@ -16,72 +26,112 @@ const expectedTools = [
     'map_poi_search',
     'map_reverse_geocode',
     'map_transit_route',
-    'map_walking_route'
+    'map_walking_route',
 ];
 function sha256(path) {
     return createHash('sha256').update(readFileSync(path)).digest('hex');
 }
 function vendorAggregate(root) {
     const files = [];
-    const walk = (directory)=>{
-        for (const entry of readdirSync(directory, {
-            withFileTypes: true
-        })){
+    const walk = (directory) => {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
             const path = join(directory, entry.name);
-            if (entry.isDirectory()) walk(path);
-            else files.push(path.slice(root.length + 1).replaceAll('\\', '/'));
+            if (entry.isDirectory())
+                walk(path);
+            else
+                files.push(path.slice(root.length + 1).replaceAll('\\', '/'));
         }
     };
     walk(root);
     files.sort();
     const digest = createHash('sha256');
-    for (const relative of files){
+    for (const relative of files) {
         digest.update(relative);
         digest.update('\0');
         digest.update(readFileSync(join(root, relative)));
         digest.update('\0');
     }
-    return {
-        count: files.length,
-        sha256: digest.digest('hex')
-    };
+    return { count: files.length, sha256: digest.digest('hex') };
 }
-function assertAlpha3LockClosure() {
+function assertPackagingExcludesNodeModules() {
+    const tempRoot = mkdtempSync(join(tmpdir(), 'gotry-pack-excl-'));
+    try {
+        const archiveTar = join(tempRoot, 'head.tar');
+        execFileSync('git', ['archive', '--format=tar', '--output', archiveTar, 'HEAD'], { cwd: repoRoot });
+        const checkoutDir = join(tempRoot, 'checkout');
+        mkdirSync(checkoutDir);
+        execFileSync('tar', ['-xf', archiveTar, '-C', checkoutDir]);
+        copyFileSync(join(repoRoot, 'package.json'), join(checkoutDir, 'package.json'));
+        const vendorBinDir = join(checkoutDir, 'ts/dsh-runtime/vendor/dsh-map-tools/node_modules/.bin');
+        mkdirSync(vendorBinDir, { recursive: true });
+        for (const name of ['cordis', 'tsc', 'tsserver', 'vitest']) {
+            const binPath = join(vendorBinDir, name);
+            writeFileSync(binPath, '#!/usr/bin/env node\n');
+            chmodSync(binPath, 0o755);
+        }
+        const packDir = join(tempRoot, 'pack');
+        mkdirSync(packDir);
+        const packOutput = execFileSync('npm', [
+            'pack', '--ignore-scripts', '--json', '--pack-destination', packDir,
+        ], { cwd: checkoutDir, encoding: 'utf8' });
+        const packInfo = JSON.parse(packOutput);
+        assert.equal(packInfo.length, 1, 'temp npm pack must produce one artifact');
+        const tarball = join(packDir, packInfo[0].filename);
+        assert.ok(existsSync(tarball), `temp packed artifact missing: ${tarball}`);
+        const entries = execFileSync('tar', ['-tzf', tarball], { encoding: 'utf8' }).trimEnd().split('\n');
+        const nodeModulesEntries = entries.filter(path => path.startsWith('package/ts/dsh-runtime/vendor/dsh-map-tools/node_modules'));
+        assert.equal(nodeModulesEntries.length, 0, `npm pack must exclude vendor node_modules: found ${nodeModulesEntries.join(', ')}`);
+        const extractDir = join(tempRoot, 'extracted');
+        mkdirSync(extractDir);
+        execFileSync('tar', ['-xzf', tarball, '-C', extractDir]);
+        const packedVendorRoot = join(extractDir, 'package/ts/dsh-runtime/vendor/dsh-map-tools');
+        const packedAggregate = vendorAggregate(packedVendorRoot);
+        assert.equal(packedAggregate.count, upstreamVendorFileCount, 'packed vendor file count drifted');
+        assert.equal(packedAggregate.sha256, adaptedVendorAggregateSha256, 'packed vendor aggregate drifted');
+    }
+    finally {
+        rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function assertTargetLockClosure() {
     const manifest = JSON.parse(readFileSync(join(repoRoot, 'ts/package.json'), 'utf8'));
     assert.equal(manifest.dependencies?.['dsh-map-tools'], undefined, 'external map-tools dependency must stay removed');
     const lock = JSON.parse(readFileSync(join(repoRoot, 'ts/package-lock.json'), 'utf8'));
     assert.equal(lock.packages?.['']?.dependencies?.['dsh-map-tools'], undefined, 'lock root must not resolve external map-tools');
     assert.equal(lock.packages?.['node_modules/dsh-map-tools'], undefined, 'lock must not carry external map-tools');
-    const dshEntries = Object.entries(lock.packages ?? {}).filter(([path])=>/(?:^|\/)node_modules\/@deepseek-ai\/(?:dsh|dsh-[^/]+)$/.test(path));
+    const dshEntries = Object.entries(lock.packages ?? {}).filter(([path]) => /(?:^|\/)node_modules\/@deepseek-ai\/(?:dsh|dsh-[^/]+)$/.test(path));
     assert.ok(dshEntries.length >= 10, 'expected dsh-tools peer closure in the ts lock');
-    for (const [path, entry] of dshEntries){
-        assert.equal(entry.version, '0.1.2-alpha.3', `${path} drifted outside the alpha.3 closure`);
+    for (const [path, entry] of dshEntries) {
+        assert.equal(entry.version, '0.1.5-rc.1', `${path} drifted outside the 0.1.5-rc.1 closure`);
     }
-    return {
-        packages: dshEntries.length,
-        version: '0.1.2-alpha.3'
-    };
+    return { packages: dshEntries.length, version: '0.1.5-rc.1' };
 }
 function findPackageRoot(entry) {
     let cursor = dirname(entry);
-    for(;;){
+    for (;;) {
         const manifestPath = join(cursor, 'package.json');
         if (existsSync(manifestPath)) {
             const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-            if (manifest.name === '@danceiny/gotry') return cursor;
+            if (manifest.name === '@danceiny/gotry')
+                return cursor;
         }
         const parent = dirname(cursor);
-        if (parent === cursor) throw new Error(`cannot locate @danceiny/gotry package root from ${entry}`);
+        if (parent === cursor)
+            throw new Error(`cannot locate @danceiny/gotry package root from ${entry}`);
         cursor = parent;
     }
 }
 function assertBinTargetsPackage(binPath, expectedTarget) {
     const resolvedExpectedTarget = realpathSync(expectedTarget);
-    if (realpathSync(binPath) === resolvedExpectedTarget) return;
+    if (realpathSync(binPath) === resolvedExpectedTarget)
+        return;
+    // pnpm writes an executable shell shim instead of a symlink. Its final
+    // machine-readable marker is safer to verify than accepting any occurrence
+    // of the package path in an otherwise unrelated executable.
     const shim = readFileSync(binPath, 'utf8');
     assert.ok(Buffer.byteLength(shim, 'utf8') <= 32_768, 'clean-install gotry shim is unexpectedly large');
     const lines = shim.trimEnd().split(/\r?\n/);
-    const markers = lines.filter((line)=>line.startsWith('# cmd-shim-target='));
+    const markers = lines.filter(line => line.startsWith('# cmd-shim-target='));
     assert.equal(markers.length, 1, 'pnpm gotry shim must contain exactly one target marker');
     assert.equal(lines.at(-1), markers[0], 'pnpm gotry shim target marker must be the final line');
     const markerTarget = markers[0].slice('# cmd-shim-target='.length);
@@ -99,55 +149,39 @@ function prepareProofPackage(cleanInstalledBin) {
         const packageRoot = findPackageRoot(packageMain);
         const installedManifest = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
         assert.equal(installedManifest.name, '@danceiny/gotry', 'clean-install executable must belong to GoTry');
-        const declaredBin = typeof installedManifest.bin === 'string' ? installedManifest.bin : installedManifest.bin?.gotry;
+        const declaredBin = typeof installedManifest.bin === 'string'
+            ? installedManifest.bin
+            : installedManifest.bin?.gotry;
         assert.equal(declaredBin, 'bin/gotry-inner.js', 'installed package must declare the production gotry bin');
         assertBinTargetsPackage(binPath, join(packageRoot, declaredBin));
-        return {
-            packageRoot
-        };
+        return { packageRoot };
     }
     const proofRoot = mkdtempSync(join(repoRoot, '.tmp-map-tools-proof-'));
     try {
         const packOutput = execFileSync('npm', [
-            'pack',
-            '--ignore-scripts',
-            '--json',
-            '--pack-destination',
-            proofRoot
-        ], {
-            cwd: repoRoot,
-            encoding: 'utf8'
-        });
+            'pack', '--ignore-scripts', '--json', '--pack-destination', proofRoot,
+        ], { cwd: repoRoot, encoding: 'utf8' });
         const packInfo = JSON.parse(packOutput);
         assert.equal(packInfo.length, 1, 'npm pack must produce one artifact');
         const tarball = join(proofRoot, packInfo[0].filename);
         assert.ok(existsSync(tarball), `packed artifact missing: ${tarball}`);
         const unpackRoot = join(proofRoot, 'unpacked');
         mkdirSync(unpackRoot);
-        execFileSync('tar', [
-            '-xzf',
-            tarball,
-            '-C',
-            unpackRoot
-        ]);
+        execFileSync('tar', ['-xzf', tarball, '-C', unpackRoot]);
         const packageRoot = join(unpackRoot, 'package');
         symlinkSync(join(repoRoot, 'node_modules'), join(packageRoot, 'node_modules'), process.platform === 'win32' ? 'junction' : 'dir');
-        return {
-            packageRoot,
-            proofRoot
-        };
-    } catch (error) {
-        rmSync(proofRoot, {
-            recursive: true,
-            force: true
-        });
+        return { packageRoot, proofRoot };
+    }
+    catch (error) {
+        rmSync(proofRoot, { recursive: true, force: true });
         throw error;
     }
 }
 const cleanInstalledBin = process.env.GOTRY_MAP_TOOLS_E2E_BIN;
 const { packageRoot, proofRoot } = prepareProofPackage(cleanInstalledBin);
 try {
-    const lockedDsh = assertAlpha3LockClosure();
+    assertPackagingExcludesNodeModules();
+    const lockedDsh = assertTargetLockClosure();
     const vendorRoot = join(packageRoot, 'ts/dsh-runtime/vendor/dsh-map-tools');
     const requiredFiles = [
         'LICENSE',
@@ -158,119 +192,157 @@ try {
         'lib/config.js',
         'lib/tools/geocode.js',
         'lib/tools/routes.js',
-        'lib/tools/poi.js'
+        'lib/tools/poi.js',
     ];
-    for (const relative of requiredFiles){
+    for (const relative of requiredFiles) {
         assert.ok(existsSync(join(vendorRoot, relative)), `required vendor file missing: ${relative}`);
     }
     const vendorTree = vendorAggregate(vendorRoot);
     assert.equal(vendorTree.count, upstreamVendorFileCount, 'vendored payload file count drifted');
-    assert.equal(vendorTree.sha256, upstreamVendorAggregateSha256, 'vendored payload aggregate drifted');
+    assert.equal(vendorTree.sha256, adaptedVendorAggregateSha256, 'vendored payload aggregate drifted');
     const vendorPackage = JSON.parse(readFileSync(join(vendorRoot, 'package.json'), 'utf8'));
     assert.equal(vendorPackage.name, 'dsh-map-tools');
     assert.equal(vendorPackage.version, '0.5.1');
     assert.equal(vendorPackage.license, 'MIT');
     assert.equal(sha256(join(vendorRoot, 'LICENSE')), upstreamLicenseSha256, 'upstream MIT license changed');
     const packageRequire = createRequire(join(packageRoot, 'package.json'));
-    const dshTools = JSON.parse(readFileSync(packageRequire.resolve('@deepseek-ai/dsh-tools/package.json'), 'utf8'));
-    const dshSettings = JSON.parse(readFileSync(packageRequire.resolve('@deepseek-ai/dsh-settings/package.json'), 'utf8'));
-    assert.equal(dshTools.version, '0.1.2-alpha.3');
-    assert.equal(dshSettings.version, '0.1.2-alpha.3');
-    const settingsApi = await import(pathToFileURL(packageRequire.resolve('@deepseek-ai/dsh-settings')).href);
-    assert.equal(typeof settingsApi.SettingsProvider?.prototype?.installSection, 'function', 'real alpha.3 SettingsProvider.installSection API must be present');
+    const dshToolsPackageJson = packageRequire.resolve('@deepseek-ai/dsh-tools/package.json');
+    const dshSettingsPackageJson = packageRequire.resolve('@deepseek-ai/dsh-settings/package.json');
+    const dshTools = JSON.parse(readFileSync(dshToolsPackageJson, 'utf8'));
+    const dshSettings = JSON.parse(readFileSync(dshSettingsPackageJson, 'utf8'));
+    assert.equal(dshTools.version, '0.1.5-rc.1');
+    assert.equal(dshSettings.version, '0.1.5-rc.1');
+    const settingsApi = await import(pathToFileURL(join(dirname(dshSettingsPackageJson), 'lib/index.js')).href);
+    const installSection = settingsApi.SettingsProvider?.prototype?.installSection;
+    assert.equal(typeof installSection, 'function', 'real 0.1.5-rc.1 SettingsProvider.prototype.installSection must be present');
     const plugin = await import(pathToFileURL(join(vendorRoot, 'lib/index.js')).href);
-    const registered = [];
-    const settingsCalls = [];
+    const registered = new Map();
+    const registerEvents = [];
+    const toolDisposeEvents = [];
+    const settingsRegistrations = [];
+    const settingsWatchers = [];
+    const settingsProviderDisposers = [];
+    const contextDisposers = [];
+    const settingsNamespaceValue = 'dsh-map-tools';
+    const activeToolNames = () => [...registered.keys()].sort();
+    const settingsProvider = {
+        ctx: {
+            effect(effect) {
+                const disposer = effect();
+                if (typeof disposer === 'function')
+                    settingsProviderDisposers.push(disposer);
+                return disposer;
+            },
+        },
+        register: (...args) => {
+            settingsRegistrations.push(args);
+            return {
+                get: () => args[2] && typeof args[2] === 'object' ? args[2].base : undefined,
+                watch: (callback) => {
+                    settingsWatchers.push(callback);
+                    return () => {
+                        const index = settingsWatchers.indexOf(callback);
+                        if (index >= 0)
+                            settingsWatchers.splice(index, 1);
+                    };
+                },
+                update: async () => undefined,
+                replace: async () => undefined,
+            };
+        },
+        installSection: (...args) => installSection.apply(settingsProvider, args),
+    };
     const context = {
-        tools: {
-            register (tool) {
-                registered.push(tool);
-                return ()=>undefined;
-            }
+        fiber: { state: 'active' },
+        effect(effect) {
+            const disposer = effect();
+            if (typeof disposer === 'function')
+                contextDisposers.push(disposer);
+            return disposer;
         },
-        effect (effect) {
-            effect();
+        tools: {
+            register(tool) {
+                assert.ok(tool.name.startsWith('map_'), `unexpected map tool name: ${tool.name}`);
+                registered.set(tool.name, tool);
+                registerEvents.push(tool.name);
+                return () => {
+                    registered.delete(tool.name);
+                    toolDisposeEvents.push(tool.name);
+                };
+            },
         },
-        inject (dependencies, callback) {
+        inject(dependencies, callback) {
             if (dependencies.includes('settings')) {
-                callback({
-                    settings: {
-                        installSection: (...args)=>{
-                            settingsCalls.push(args);
-                        }
-                    }
-                });
-            } else if (dependencies.includes('webServer')) {
-                callback({
-                    webServer: {
-                        register: ()=>undefined
-                    }
-                });
-            } else {
+                callback({ settings: settingsProvider });
+            }
+            else if (dependencies.includes('webServer')) {
+                callback({ webServer: { register: () => undefined } });
+            }
+            else {
                 throw new Error(`unexpected dependency injection: ${dependencies.join(',')}`);
             }
-        }
+        },
     };
     plugin.apply(context, {
-        provider: 'osm',
-        amapKey: '',
-        timeoutMs: 1000,
-        maxQps: 2,
-        defaultMode: 'driving',
-        language: 'zh'
+        provider: 'osm', amapKey: '', timeoutMs: 1000, maxQps: 2,
+        defaultMode: 'driving', language: 'zh',
     });
-    assert.deepEqual(registered.map((tool)=>tool.name).sort(), expectedTools, 'exactly seven map tools must register');
-    assert.equal(settingsCalls.length, 1, 'alpha.3 settings section must be installed once');
-    assert.equal(settingsCalls[0][1], 'dsh-map-tools', 'settings namespace must be stable');
-    assert.equal(typeof settingsCalls[0][4], 'object', 'alpha.3 installSection hooks must be supplied');
+    assert.deepEqual(activeToolNames(), expectedTools, 'exactly seven active map tools must register');
+    assert.equal(registerEvents.length, expectedTools.length * 2, 'installSection initial onChange must rebuild the map tools once');
+    assert.equal(toolDisposeEvents.length, expectedTools.length, 'installSection initial reload must dispose the first tool generation');
+    assert.equal(settingsRegistrations.length, 1, '0.1.5-rc.1 settings section must register once');
+    assert.equal(settingsRegistrations[0][0], settingsNamespaceValue, 'settings namespace must be the stable plain string');
+    assert.equal(settingsRegistrations[0][2] && typeof settingsRegistrations[0][2] === 'object', true, '0.1.5-rc.1 settings register options must be supplied');
+    assert.deepEqual(Object.keys(settingsRegistrations[0][2]).sort(), ['base'], '0.1.5-rc.1 registration must carry the composition base');
+    assert.equal(settingsWatchers.length, 1, '0.1.5-rc.1 installSection must attach one settings watcher');
+    assert.equal(settingsProviderDisposers.length, 1, '0.1.5-rc.1 installSection must attach one provider-detach fallback effect');
+    settingsWatchers[0]();
+    assert.deepEqual(activeToolNames(), expectedTools, 'settings watch reload must keep exactly seven active map tools');
+    assert.equal(registerEvents.length, expectedTools.length * 3, 'settings watch must rebuild the map tools');
+    assert.equal(toolDisposeEvents.length, expectedTools.length * 2, 'settings watch reload must dispose the previous generation');
+    settingsProviderDisposers[0]();
+    assert.deepEqual(activeToolNames(), expectedTools, 'settings provider detach fallback must keep exactly seven active map tools');
+    assert.equal(registerEvents.length, expectedTools.length * 4, 'provider detach fallback must rebuild the map tools');
+    assert.equal(toolDisposeEvents.length, expectedTools.length * 3, 'provider detach fallback must dispose the previous generation');
+    const finalActiveTools = [...registered.values()];
     const originalFetch = globalThis.fetch;
-    globalThis.fetch = async ()=>{
-        throw new Error('network forbidden by package proof');
-    };
+    globalThis.fetch = (async () => { throw new Error('network forbidden by package proof'); });
     try {
-        const geocode = registered.find((tool)=>tool.name === 'map_geocode');
+        const geocode = registered.get('map_geocode');
         assert.ok(geocode, 'map_geocode must be registered');
-        const result = await geocode.execute({
-            address: '116.397428,39.90923'
-        }, {
-            signal: new AbortController().signal
-        });
+        const result = await geocode.execute({ address: '116.397428,39.90923' }, { signal: new AbortController().signal });
         assert.equal(result.provider, 'inline');
-        assert.deepEqual(result.location, [
-            116.397428,
-            39.90923
-        ]);
-    } finally{
+        assert.deepEqual(result.location, [116.397428, 39.90923]);
+    }
+    finally {
         globalThis.fetch = originalFetch;
     }
+    for (const dispose of contextDisposers.splice(0).reverse())
+        dispose();
+    assert.equal(registered.size, 0, 'plugin unload must dispose the active map tool generation');
     console.log(JSON.stringify({
         proof: 'map-tools-vendor-package',
         status: 'PASS',
         artifactMode: cleanInstalledBin ? 'clean-installed-tarball' : 'packed-unpacked-focused',
         vendored: {
             sourcePackage: 'dsh-map-tools@0.5.1',
-            licenseSha256: upstreamLicenseSha256,
-            vendorFileCount: vendorTree.count,
-            vendorAggregateSha256: vendorTree.sha256
+            licenseSha256: upstreamLicenseSha256, vendorFileCount: vendorTree.count,
+            adaptedVendorAggregateSha256: vendorTree.sha256,
         },
         artifactVendor: vendorRoot,
-        dshClosure: {
-            tools: dshTools.version,
-            settings: dshSettings.version,
-            ...lockedDsh
+        dshClosure: { tools: dshTools.version, settings: dshSettings.version, ...lockedDsh },
+        settingsLifecycle: {
+            registerEvents: registerEvents.length,
+            toolDisposeEvents: toolDisposeEvents.length,
+            watchedReloads: 1,
+            providerDetachFallbacks: 1,
+            pluginUnloadDisposed: true,
         },
-        tools: registered.map((tool)=>tool.name).sort(),
-        inlineCoordinate: {
-            provider: 'inline',
-            network: 'forbidden'
-        }
+        tools: finalActiveTools.map(tool => tool.name).sort(),
+        inlineCoordinate: { provider: 'inline', network: 'forbidden' },
     }, null, 2));
-} finally{
-    if (proofRoot) rmSync(proofRoot, {
-        recursive: true,
-        force: true
-    });
 }
-
-
-//# sourceURL=ts/scripts/map-tools-vendor-package-proof.ts
+finally {
+    if (proofRoot)
+        rmSync(proofRoot, { recursive: true, force: true });
+}