sneakoscope 7.1.0 → 7.3.0

package/dist/core/release/release-closure.js

@@ -1,163 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { HEAD_BINDING_MODE, RELEASE_CLOSURE_AUDIT_VERSION, RELEASE_630_MISSION_ID, RELEASE_CLOSURE_MANIFEST_SCHEMA, RELEASE_CLOSURE_SCHEMA, WORK_ORDER_SHA256 } from './release-closure-contract.js';
-import { attachmentTruth, deletionTruth, fileLineCount, fileSha256, flattenFindingProofs, flattenWorkOrderEvidence, gitOk, positiveLineCount, readJson, readJsonl, relative, requiredArtifactPaths, sameSet, sha40, sha256, sourceCommitBound, trackedBlobMatches, unique, validatePostSourceCommitDiff } from './release-closure-helpers.js';
-import { validateDeletion, validateFindings, validateMission, validateOfficialThreads, validateReleaseLedger } from './release-closure-validation.js';
-export { RELEASE_CLOSURE_AUDIT_VERSION, RELEASE_630_MISSION_ID, RELEASE_CLOSURE_MANIFEST_SCHEMA, RELEASE_CLOSURE_SCHEMA } from './release-closure-contract.js';
-export function releaseClosureManifestPath(root, version) {
-    return path.join(root, '.sneakoscope', 'release', version, 'release-closure.json');
-}
-export function inspectReleaseClosure(input) {
-    const blockers = [];
-    const expectedMissionId = input.expectedMissionId || RELEASE_630_MISSION_ID;
-    if (input.version !== RELEASE_CLOSURE_AUDIT_VERSION) {
-        if (!sha40(input.expectedBaseline))
-            blockers.push('expected_baseline_invalid');
-        if (!sha40(input.expectedHead))
-            blockers.push('expected_head_invalid');
-        if (sha40(input.expectedBaseline) && sha40(input.expectedHead)
-            && !sourceCommitAtOrAfterBaseline(input.root, input.expectedHead, input.expectedBaseline)) {
-            blockers.push('head_not_descended_from_baseline');
-        }
-        return {
-            schema: RELEASE_CLOSURE_SCHEMA,
-            ok: blockers.length === 0,
-            applicable: false,
-            applicability: `version_scoped_to_${RELEASE_CLOSURE_AUDIT_VERSION}`,
-            version: input.version,
-            head: sha40(input.expectedHead) ? input.expectedHead : null,
-            source_commit: sha40(input.expectedHead) ? input.expectedHead : null,
-            mission_id: expectedMissionId,
-            manifest_path: null,
-            manifest_sha256: null,
-            blockers: unique(blockers)
-        };
-    }
-    const manifestFile = releaseClosureManifestPath(input.root, input.version);
-    const manifestRel = relative(input.root, manifestFile);
-    const manifest = readJson(manifestFile);
-    const expectedWorkOrderSha256 = input.expectedWorkOrderSha256 || WORK_ORDER_SHA256;
-    if (!sha40(input.expectedBaseline))
-        blockers.push('expected_baseline_invalid');
-    if (!sha40(input.expectedHead))
-        blockers.push('expected_head_invalid');
-    if (!manifest || manifest.schema !== RELEASE_CLOSURE_MANIFEST_SCHEMA)
-        blockers.push('closure_manifest_missing_or_invalid');
-    if (manifest?.version !== input.version)
-        blockers.push('closure_manifest_version_mismatch');
-    if (manifest?.baseline !== input.expectedBaseline)
-        blockers.push('closure_manifest_baseline_mismatch');
-    if (manifest?.mission_id !== expectedMissionId)
-        blockers.push(`mission_id_mismatch:${String(manifest?.mission_id || 'missing')}`);
-    if (manifest?.head_binding !== HEAD_BINDING_MODE)
-        blockers.push('closure_manifest_head_binding_invalid');
-    const sourceCommit = String(manifest?.source_commit || '');
-    if (!sourceCommitBound(input.root, sourceCommit, input.expectedBaseline, input.expectedHead))
-        blockers.push('closure_source_commit_unbound');
-    validatePostSourceCommitDiff(input.root, sourceCommit, input.expectedHead, input.version, blockers);
-    const manifestHash = fileSha256(manifestFile);
-    if (!manifestHash)
-        blockers.push('closure_manifest_hash_unavailable');
-    if (!trackedBlobMatches(input.root, input.expectedHead, manifestRel, manifestHash))
-        blockers.push('closure_manifest_not_exact_head_blob');
-    const paths = requiredArtifactPaths(input.version, expectedMissionId);
-    for (const [key, spec] of Object.entries(paths)) {
-        const entry = manifest?.artifacts?.[key];
-        if (!entry || entry.path !== spec.path || !sha256(entry.sha256) || !positiveLineCount(entry.line_count)) {
-            blockers.push(`closure_artifact_manifest_invalid:${key}`);
-            continue;
-        }
-        const artifactFile = path.join(input.root, spec.path);
-        const actual = fileSha256(artifactFile);
-        const actualLineCount = fileLineCount(artifactFile);
-        if (!actual || actual !== entry.sha256)
-            blockers.push(`closure_artifact_hash_mismatch:${key}`);
-        if (actualLineCount !== entry.line_count)
-            blockers.push(`closure_artifact_line_count_mismatch:${key}`);
-        if (entry.schema !== spec.schema)
-            blockers.push(`closure_artifact_schema_contract_mismatch:${key}`);
-        if (spec.schema && key !== 'events') {
-            const artifact = readJson(artifactFile);
-            if (artifact?.schema !== spec.schema)
-                blockers.push(`closure_artifact_schema_invalid:${key}`);
-        }
-        if ((key === 'findings' || key === 'deletion')
-            && !trackedBlobMatches(input.root, input.expectedHead, spec.path, actual))
-            blockers.push(`closure_artifact_not_exact_head_blob:${key}`);
-    }
-    if (!sameSet(Object.keys(manifest?.artifacts || {}), Object.keys(paths)))
-        blockers.push('closure_artifact_set_invalid');
-    const findings = readJson(path.join(input.root, paths.findings.path));
-    validateFindings(input.root, findings, manifest, sourceCommit, expectedMissionId, input.expectedBaseline, blockers);
-    const mission = readJson(path.join(input.root, paths.mission.path));
-    validateMission(mission, sourceCommit, expectedMissionId, blockers);
-    const plan = readJson(path.join(input.root, paths.plan.path));
-    const rawEvents = readJsonl(path.join(input.root, paths.events.path));
-    const parent = readJson(path.join(input.root, paths.parent_summary.path));
-    const evidence = readJson(path.join(input.root, paths.evidence.path));
-    const summary = readJson(path.join(input.root, paths.summary.path));
-    const gate = readJson(path.join(input.root, paths.gate.path));
-    const ssot = readJson(path.join(input.root, paths.ssot.path));
-    validateOfficialThreads(input.root, { plan, rawEvents, parent, evidence, summary, gate, ssot, missionId: expectedMissionId }, blockers);
-    const ledger = readJson(path.join(input.root, paths.ledger.path));
-    validateReleaseLedger(input.root, ledger, manifest, sourceCommit, expectedMissionId, expectedWorkOrderSha256, blockers);
-    const deletion = readJson(path.join(input.root, paths.deletion.path));
-    validateDeletion(input.root, deletion, manifest, sourceCommit, input.expectedBaseline, blockers);
-    return {
-        schema: RELEASE_CLOSURE_SCHEMA,
-        ok: blockers.length === 0,
-        applicable: true,
-        applicability: `version_scoped_to_${RELEASE_CLOSURE_AUDIT_VERSION}`,
-        version: input.version,
-        head: sha40(input.expectedHead) ? input.expectedHead : null,
-        source_commit: sha40(sourceCommit) ? sourceCommit : null,
-        mission_id: expectedMissionId,
-        manifest_path: manifestRel,
-        manifest_sha256: manifestHash,
-        blockers: unique(blockers)
-    };
-}
-export function buildReleaseClosureManifest(input) {
-    if (input.version !== RELEASE_CLOSURE_AUDIT_VERSION) {
-        throw new Error(`Release closure manifest is version-scoped to ${RELEASE_CLOSURE_AUDIT_VERSION}; received ${input.version || 'missing'}.`);
-    }
-    const missionId = input.missionId || RELEASE_630_MISSION_ID;
-    const paths = requiredArtifactPaths(input.version, missionId);
-    const artifacts = {};
-    for (const [key, spec] of Object.entries(paths)) {
-        const artifactFile = path.join(input.root, spec.path);
-        artifacts[key] = {
-            path: spec.path,
-            sha256: fileSha256(artifactFile),
-            line_count: fileLineCount(artifactFile),
-            schema: spec.schema
-        };
-    }
-    const findings = readJson(path.join(input.root, paths.findings.path));
-    const ledger = readJson(path.join(input.root, paths.ledger.path));
-    const attachment = attachmentTruth(ledger);
-    const deletion = deletionTruth(input.root, input.baseline, input.sourceCommit);
-    return {
-        schema: RELEASE_CLOSURE_MANIFEST_SCHEMA,
-        version: input.version,
-        baseline: input.baseline,
-        source_commit: input.sourceCommit,
-        mission_id: missionId,
-        head_binding: HEAD_BINDING_MODE,
-        artifacts,
-        finding_proofs: flattenFindingProofs(findings),
-        work_order_evidence: flattenWorkOrderEvidence(ledger),
-        source_attachment: attachment.ok ? attachment.manifest : null,
-        deletion_truth: deletion.ok ? deletion.manifest : null,
-        generated_at: new Date().toISOString()
-    };
-}
-function sourceCommitAtOrAfterBaseline(root, head, baseline) {
-    return gitOk(root, ['merge-base', '--is-ancestor', baseline, head]);
-}
-export function writeReleaseClosureManifest(input) {
-    const output = releaseClosureManifestPath(input.root, input.version);
-    fs.mkdirSync(path.dirname(output), { recursive: true });
-    fs.writeFileSync(output, `${JSON.stringify(buildReleaseClosureManifest(input), null, 2)}\n`);
-    return output;
-}

package/dist/scripts/build-dist.js

@@ -1,124 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { writeTextAtomic } from '../core/fsx.js';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const srcRoot = path.join(root, 'src');
-const distRoot = path.join(root, 'dist');
-await fsp.mkdir(distRoot, { recursive: true });
-await removeDistMjs(distRoot);
-await copyRuntimeConfigFiles();
-await copyNativeMenuBarSources();
-await writeSkillsManifest();
-await removeDistNonRuntimeArtifacts(distRoot);
-await writeCommonJsBinScope();
-await import('./write-build-manifest.js');
-async function removeDistMjs(dir) {
-    if (!fs.existsSync(dir))
-        return;
-    for (const entry of await fsp.readdir(dir, { withFileTypes: true })) {
-        const file = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            await removeDistMjs(file);
-        else if (entry.isFile() && entry.name.endsWith('.mjs'))
-            await fsp.rm(file, { force: true });
-    }
-}
-async function removeDistNonRuntimeArtifacts(dir) {
-    if (!fs.existsSync(dir))
-        return;
-    for (const entry of await fsp.readdir(dir, { withFileTypes: true })) {
-        const file = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            await removeDistNonRuntimeArtifacts(file);
-        else if (entry.isFile() && (entry.name.endsWith('.js.map') || entry.name.endsWith('.d.ts.map') || entry.name.endsWith('.d.ts'))) {
-            await fsp.rm(file, { force: true });
-        }
-    }
-}
-async function copyRuntimeConfigFiles() {
-    const configs = ['core/performance-budgets.json'];
-    for (const rel of configs) {
-        const from = path.join(srcRoot, rel);
-        const to = path.join(distRoot, rel);
-        if (!fs.existsSync(from))
-            continue;
-        await fsp.mkdir(path.dirname(to), { recursive: true });
-        await fsp.copyFile(from, to);
-    }
-    await copyDirIfPresent(path.join(srcRoot, 'vendor', 'openai-codex'), path.join(distRoot, 'vendor', 'openai-codex'));
-}
-async function copyNativeMenuBarSources() {
-    await copyDirIfPresent(new URL('../../native/sks-menubar', import.meta.url), path.join(distRoot, 'native', 'sks-menubar'));
-}
-async function writeSkillsManifest() {
-    const { generatePackagedSkillsManifest } = await import('../core/init/skills.js');
-    const manifest = await generatePackagedSkillsManifest();
-    const out = path.join(distRoot, 'config', 'skills-manifest.json');
-    await fsp.mkdir(path.dirname(out), { recursive: true });
-    await writeTextAtomic(out, `${JSON.stringify(manifest, null, 2)}\n`);
-}
-async function writeCommonJsBinScope() {
-    const binDir = path.join(distRoot, 'bin');
-    if (!fs.existsSync(binDir))
-        return;
-    await writeTextAtomic(path.join(binDir, 'package.json'), '{"type":"commonjs"}\n');
-    await rewriteIfPresent(path.join(binDir, 'sks.js'), (text) => stripSourceMap(text)
-        .replace(/^import \{ PACKAGE_VERSION \} from '\.\.\/core\/version\.js';$/m, "const { version: PACKAGE_VERSION } = require('../../package.json');")
-        .replace(/\nexport \{\};\n?/, '\n'));
-    await rewriteIfPresent(path.join(binDir, 'sks-dispatch.js'), (text) => {
-        const next = stripGeneratedCommonJsExports(stripSourceMap(text).replace(/^export async function runSks/m, 'async function runSks'), ['runSks']);
-        return `${next}\n\nexports.runSks = runSks;\n`;
-    });
-    await rewriteIfPresent(path.join(binDir, 'fast-inline.js'), (text) => {
-        const names = [
-            'rootJsonFastInline',
-            'doctorJsonFastInline',
-            'narutoHelpJsonFastInline',
-            'hookUserPromptSubmitPerfInline'
-        ];
-        let next = stripSourceMap(text);
-        for (const name of names) {
-            next = next.replace(new RegExp(`^export (async )?function ${name}`, 'm'), '$1function ' + name);
-        }
-        next = stripGeneratedCommonJsExports(next, names);
-        return `${next}\n\n${names.map((name) => `exports.${name} = ${name};`).join('\n')}\n`;
-    });
-    await rewriteIfPresent(path.join(binDir, 'install.js'), (text) => stripSourceMap(text).replace(/^import \{ spawnSync \} from 'node:child_process';/m, "const { spawnSync } = require('node:child_process');"));
-}
-async function rewriteIfPresent(file, rewrite) {
-    if (!fs.existsSync(file))
-        return;
-    const text = await fsp.readFile(file, 'utf8');
-    await writeTextAtomic(file, rewrite(text));
-}
-function stripSourceMap(text) {
-    return text.replace(/\n\/\/# sourceMappingURL=.*\.map\s*$/s, '\n');
-}
-function stripGeneratedCommonJsExports(text, names) {
-    const escaped = names.map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
-    return text
-        .replace(new RegExp(`^exports\\.(${escaped}) = \\1;\\s*$`, 'gm'), '')
-        .replace(/\n{3,}/g, '\n\n')
-        .trimEnd();
-}
-async function copyDirIfPresent(from, to) {
-    from = fileURLToPathIfNeeded(from);
-    if (!fs.existsSync(from))
-        return;
-    await fsp.rm(to, { recursive: true, force: true });
-    await fsp.mkdir(to, { recursive: true });
-    for (const entry of await fsp.readdir(from, { withFileTypes: true })) {
-        const source = path.join(from, entry.name);
-        const target = path.join(to, entry.name);
-        if (entry.isDirectory())
-            await copyDirIfPresent(source, target);
-        else if (entry.isFile())
-            await fsp.copyFile(source, target);
-    }
-}
-function fileURLToPathIfNeeded(value) {
-    return value instanceof URL ? fileURLToPath(value) : value;
-}

package/dist/scripts/build-once-runner-check.js

@@ -1,6 +0,0 @@
-import { assertGate, emitGate, importDist, readText } from './sks-1-18-gate-lib.js';
-const src = readText('src/core/build/build-once-runner.ts');
-assertGate(src.includes('.sks-build-proof.json') && src.includes('build:incremental'), 'build-once runner must write dist proof and use incremental build', src.slice(0, 500));
-const mod = await importDist('core/build/build-once-runner.js');
-assertGate(mod.BUILD_ONCE_PROOF_SCHEMA === 'sks.build-once-proof.v1', 'build-once proof schema missing');
-emitGate('build-once:runner');

package/dist/scripts/canonical-test-runner.js

@@ -1,234 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { SKS_TEMP_LEASE_FILE, tmpdir, writeJsonAtomic } from '../core/fsx.js';
-import { canonicalTestCorpus, canonicalTestProofPath, sameCanonicalTestCorpus, writeCanonicalTestProof } from '../core/release/canonical-test-proof.js';
-import { releaseAuthorizationSnapshot, sameReleaseAuthorizationSnapshot } from '../core/release/release-authorization-snapshot.js';
-const root = process.cwd();
-const proofPath = canonicalTestProofPath(root);
-function removeCanonicalTestProof() {
-    fs.rmSync(proofPath, { force: true });
-}
-removeCanonicalTestProof();
-const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const startedAt = new Date().toISOString();
-const initialAuthorization = releaseAuthorizationSnapshot(root, pkg);
-const initialCorpus = canonicalTestCorpus(root);
-const compiled = discover(path.join(root, 'dist'), (file) => file.endsWith('.test.js') && file.includes(`${path.sep}__tests__${path.sep}`));
-const unit = discover(path.join(root, 'test', 'unit'), (file) => file.endsWith('.test.mjs'));
-const files = [...compiled, ...unit].sort();
-if (!compiled.length || !unit.length) {
-    console.error(JSON.stringify({
-        schema: 'sks.canonical-test-runner.v1',
-        ok: false,
-        compiled_tests: compiled.length,
-        unit_tests: unit.length,
-        blockers: ['canonical_test_surface_missing']
-    }));
-    process.exit(1);
-}
-const scratch = tmpdir('sks-canonical-test-');
-let cleaned = false;
-let finalized = false;
-let proofCommitted = false;
-const removeScratchSync = () => {
-    if (cleaned)
-        return null;
-    try {
-        fs.rmSync(scratch, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
-        if (!fs.existsSync(scratch)) {
-            cleaned = true;
-            return null;
-        }
-        return new Error(`canonical test scratch still exists after cleanup: ${scratch}`);
-    }
-    catch (error) {
-        return error instanceof Error ? error : new Error(String(error));
-    }
-};
-const cleanup = async () => {
-    if (cleaned)
-        return null;
-    const deadline = Date.now() + 2_000;
-    let lastError = null;
-    do {
-        lastError = removeScratchSync();
-        if (!lastError) {
-            await delay(100);
-            if (!fs.existsSync(scratch))
-                return null;
-            cleaned = false;
-            lastError = new Error(`canonical test scratch was recreated during cleanup: ${scratch}`);
-        }
-        await delay(50);
-    } while (Date.now() < deadline);
-    return lastError ?? new Error(`canonical test scratch cleanup timed out: ${scratch}`);
-};
-process.once('exit', () => {
-    const error = removeScratchSync();
-    if (error)
-        console.error(`canonical test cleanup failed during exit: ${error.message}`);
-    if (!proofCommitted)
-        removeCanonicalTestProof();
-});
-await writeJsonAtomic(path.join(scratch, SKS_TEMP_LEASE_FILE), {
-    schema: 'sks.temp-lease.v1',
-    kind: 'canonical-test-runner',
-    pid: process.pid,
-    created_at: new Date().toISOString()
-});
-const isolatedProcessGroup = process.platform !== 'win32';
-const childEnv = {
-    ...process.env,
-    TMPDIR: scratch,
-    TMP: scratch,
-    TEMP: scratch,
-    SKS_TMP_DIR: scratch
-};
-delete childEnv.NODE_OPTIONS;
-const child = spawn(process.execPath, ['--test', '--test-concurrency=1', ...files, ...process.argv.slice(2)], {
-    cwd: root,
-    detached: isolatedProcessGroup,
-    env: childEnv,
-    stdio: 'inherit'
-});
-child.on('error', (error) => {
-    void finalize(1, null, error);
-});
-child.on('close', (code, signal) => {
-    void finalize(code ?? 1, signal, null);
-});
-const signals = ['SIGINT', 'SIGTERM', 'SIGHUP'];
-const signalExitCodes = { SIGINT: 130, SIGTERM: 143, SIGHUP: 129 };
-let forwardedSignal = null;
-let signalTimer = null;
-const signalHandlers = new Map();
-for (const signal of signals) {
-    const handler = () => {
-        if (forwardedSignal)
-            return;
-        forwardedSignal = signal;
-        signalChildTree(signal);
-        signalTimer = setTimeout(() => {
-            signalChildTree('SIGKILL');
-            void finalize(signalExitCodes[signal], signal, null);
-        }, 5_000);
-    };
-    signalHandlers.set(signal, handler);
-    process.once(signal, handler);
-}
-function removeSignalHandlers() {
-    for (const [signal, handler] of signalHandlers)
-        process.removeListener(signal, handler);
-}
-async function finalize(code, signal, spawnError) {
-    if (finalized)
-        return;
-    finalized = true;
-    if (signalTimer)
-        clearTimeout(signalTimer);
-    await settleChildTree();
-    const cleanupError = await cleanup();
-    removeSignalHandlers();
-    if (spawnError)
-        console.error(`canonical test runner failed: ${spawnError.message}`);
-    if (cleanupError)
-        console.error(`canonical test cleanup failed: ${cleanupError.message}`);
-    let proofError = null;
-    const successfulRun = code === 0 && !signal && !forwardedSignal && !spawnError && !cleanupError;
-    if (successfulRun) {
-        try {
-            const finalAuthorization = releaseAuthorizationSnapshot(root, pkg);
-            const finalCorpus = canonicalTestCorpus(root);
-            if (!sameReleaseAuthorizationSnapshot(initialAuthorization, finalAuthorization)) {
-                throw new Error('canonical_test_release_authorization_drift');
-            }
-            if (!sameCanonicalTestCorpus(initialCorpus, finalCorpus)) {
-                throw new Error('canonical_test_corpus_drift');
-            }
-            await writeCanonicalTestProof(root, {
-                started_at: startedAt,
-                completed_at: new Date().toISOString(),
-                corpus: finalCorpus,
-                release_authorization_snapshot: finalAuthorization
-            });
-            proofCommitted = true;
-        }
-        catch (error) {
-            proofError = error instanceof Error ? error : new Error(String(error));
-            console.error(`canonical test proof failed: ${proofError.message}`);
-        }
-    }
-    if (!proofCommitted)
-        removeCanonicalTestProof();
-    if (forwardedSignal)
-        process.kill(process.pid, forwardedSignal);
-    else if (signal)
-        process.kill(process.pid, signal);
-    else
-        process.exitCode = spawnError || cleanupError || proofError ? 1 : code;
-}
-function signalChildTree(signal) {
-    if (!child.pid)
-        return;
-    if (isolatedProcessGroup) {
-        try {
-            process.kill(-child.pid, signal);
-            return;
-        }
-        catch { }
-    }
-    try {
-        child.kill(signal);
-    }
-    catch { }
-}
-function childTreeAlive() {
-    if (!isolatedProcessGroup || !child.pid)
-        return false;
-    try {
-        process.kill(-child.pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function settleChildTree() {
-    if (!childTreeAlive())
-        return;
-    signalChildTree('SIGTERM');
-    const termDeadline = Date.now() + 750;
-    while (childTreeAlive() && Date.now() < termDeadline)
-        await delay(25);
-    if (!childTreeAlive())
-        return;
-    signalChildTree('SIGKILL');
-    const killDeadline = Date.now() + 750;
-    while (childTreeAlive() && Date.now() < killDeadline)
-        await delay(25);
-}
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function discover(dir, accept) {
-    const out = [];
-    if (!fs.existsSync(dir))
-        return out;
-    const stack = [dir];
-    while (stack.length) {
-        const current = stack.pop();
-        if (!current)
-            continue;
-        const entries = fs.readdirSync(current, { withFileTypes: true });
-        for (const entry of entries) {
-            const file = path.join(current, entry.name);
-            if (entry.isDirectory())
-                stack.push(file);
-            else if (entry.isFile() && accept(file))
-                out.push(file);
-        }
-    }
-    return out;
-}

package/dist/scripts/changelog-check.js

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const changelogPath = path.join(root, 'CHANGELOG.md');
-const packagePath = path.join(root, 'package.json');
-function fail(message) {
-    console.error(`Changelog check failed: ${message}`);
-    process.exit(2);
-}
-function escapeRegExp(value) {
-    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function sectionFor(text, headingRe) {
-    const match = headingRe.exec(text);
-    if (!match)
-        return null;
-    const start = match.index + match[0].length;
-    const rest = text.slice(start);
-    const next = rest.search(/^##\s+/m);
-    return next >= 0 ? rest.slice(0, next) : rest;
-}
-function hasReleaseEntry(section) {
-    return /^###\s+(Added|Changed|Fixed|Docs|Internal|Security|Removed)\s*$/m.test(section)
-        && /^\s*-\s+\S/m.test(section);
-}
-const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-const version = pkg.version;
-if (!version)
-    fail('package.json has no version.');
-if (!fs.existsSync(changelogPath))
-    fail('CHANGELOG.md is missing.');
-const text = fs.readFileSync(changelogPath, 'utf8');
-if (!/^#\s+Changelog\s*$/m.test(text))
-    fail('CHANGELOG.md must start with a Changelog title.');
-if (!/^##\s+\[Unreleased\]\s*$/m.test(text))
-    fail('CHANGELOG.md must include an [Unreleased] section.');
-const versionHeading = new RegExp(`^##\\s+\\[${escapeRegExp(version)}\\]\\s+-\\s+\\d{4}-\\d{2}-\\d{2}\\s*$`, 'm');
-const versionSection = sectionFor(text, versionHeading);
-if (!versionSection)
-    fail(`CHANGELOG.md is missing a [${version}] - YYYY-MM-DD section.`);
-if (!hasReleaseEntry(versionSection))
-    fail(`CHANGELOG.md [${version}] section must include at least one categorized bullet.`);
-console.log(`Changelog check passed: ${version}`);