sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/release-real-check.js

@@ -1,330 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { writeJsonAtomic } from '../core/fsx.js';
-const args = process.argv.slice(2);
-const skipReleaseCheck = args.includes('--skip-release-check') || process.env.SKS_RELEASE_REAL_CHECK_SKIP_RELEASE_CHECK === '1';
-const root = process.cwd();
-const concurrency = Math.max(1, Math.floor(Number(process.env.SKS_RELEASE_REAL_CHECK_CONCURRENCY || 4)));
-const report = {
-    schema: 'sks.release-real-check.v1',
-    generated_at: new Date().toISOString(),
-    ok: false,
-    pipeline_shape: {
-        schema: 'sks.release-real-check-diamond.v1',
-        stages: ['design', 'parallel_processing', 'parallel_verification', 'aggregation'],
-        concurrency,
-        dependency_model: 'dag-with-ordered-zellij-proof-chains'
-    },
-    release_check: null,
-    environment_required_checks: [],
-    real_smoke_checks: [],
-    real_ui_checks: [],
-    all_checks: [],
-    phase_results: [],
-    blockers: [],
-    warnings: []
-};
-const tasks = [
-    task('codex:actual-config-load-probe', 'codex:actual-config-load-probe', { group: 'environment_required', phase: 'parallel_processing' }),
-    task('codex:0.137-compat:require-real', 'codex:0.137-compat:require-real', { group: 'environment_required', phase: 'parallel_processing', env: { SKS_REQUIRE_CODEX_0137: '1' } }),
-    task('codex:0.136-compat:require-real', 'codex:0.136-compat:require-real', { group: 'environment_required', phase: 'parallel_processing' }),
-    task('codex:0.135-compat:require-real', 'codex:0.135-compat:require-real', { group: 'environment_required', phase: 'parallel_processing' }),
-    task('doctor:codex-doctor-parity:actual', 'doctor:codex-doctor-parity:actual', { group: 'environment_required', phase: 'parallel_processing' }),
-    task('publish:dry-run-performance', 'publish:dry-run-performance', { group: 'environment_required', phase: 'parallel_processing' }),
-    task('zellij:capability', 'zellij:capability', { group: 'environment_required', phase: 'parallel_processing', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' } }),
-    task('zellij:layout-valid', 'zellij:layout-valid', { group: 'environment_required', phase: 'parallel_processing', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:capability'] }),
-    task('zellij:real-session-launch:base', 'zellij:real-session-launch', { group: 'environment_required', phase: 'parallel_verification', args: ['--require-real', '--main-only', '--mission', 'M-release-real-zellij', '--session', 'sks-rrz'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('zellij:pane-proof:base', 'zellij:pane-proof', { group: 'environment_required', phase: 'parallel_verification', args: ['--require-real', '--mission', 'M-release-real-zellij', '--session', 'sks-rrz', '--expected-lanes', '0'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:real-session-launch:base'] }),
-    task('zellij:screen-proof:base', 'zellij:screen-proof', { group: 'environment_required', phase: 'parallel_verification', args: ['--require-real', '--main-only', '--mission', 'M-release-real-zellij'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:real-session-launch:base'] }),
-    task('zellij:real-session-cleanup:base', 'zellij:real-session-cleanup', { group: 'environment_required', phase: 'aggregation', args: ['--mission', 'M-release-real-zellij', '--session', 'sks-rrz'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:pane-proof:base', 'zellij:screen-proof:base'] }),
-    task('zellij:first-slot-down-stack:real', 'zellij:first-slot-down-stack:real', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('zellij:right-column-real-geometry', 'zellij:right-column-real-geometry', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('naruto:zellij-dynamic-right-column', 'naruto:zellij-dynamic-right-column', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('zellij:worker-pane-real-ui:blackbox', 'zellij:worker-pane-real-ui:blackbox', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('zellij:real-session-launch:extra', 'zellij:real-session-launch', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real', '--main-only', '--mission', 'M-release-real-zellij-extra', '--session', 'sks-rrz-extra'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('zellij:pane-proof:extra', 'zellij:pane-proof', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real', '--mission', 'M-release-real-zellij-extra', '--session', 'sks-rrz-extra', '--expected-lanes', '0'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:real-session-launch:extra'] }),
-    task('zellij:screen-proof:extra', 'zellij:screen-proof', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real', '--main-only', '--mission', 'M-release-real-zellij-extra'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:real-session-launch:extra'] }),
-    task('zellij:real-session-cleanup:extra', 'zellij:real-session-cleanup', { group: 'real_ui', phase: 'aggregation', args: ['--mission', 'M-release-real-zellij-extra', '--session', 'sks-rrz-extra'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:pane-proof:extra', 'zellij:screen-proof:extra'] }),
-    task('naruto:worktree-coding:blackbox', 'naruto:worktree-coding:blackbox', { group: 'real_smoke', phase: 'parallel_processing', args: ['--require-real'], env: { SKS_REQUIRE_GIT_WORKTREE: '1' } }),
-    task('codex-control:real-smoke', 'codex-control:real-smoke', { group: 'real_smoke', phase: 'parallel_processing', args: ['--require-real'] }),
-    task('codex-sdk:real-smoke', 'codex-sdk:real-smoke', { group: 'real_smoke', phase: 'parallel_processing', args: ['--require-real'] }),
-    task('local-llm:smoke', 'local-llm:smoke', { group: 'real_smoke', phase: 'parallel_processing', args: ['--require-real'], env: { SKS_REQUIRE_LOCAL_LLM: '1' } }),
-    task('local-llm:throughput', 'local-llm:throughput', { group: 'real_smoke', phase: 'parallel_verification', env: { SKS_REQUIRE_LOCAL_LLM: '1' }, deps: ['local-llm:smoke'] }),
-    task('local-llm:cache-performance', 'local-llm:cache-performance', { group: 'real_smoke', phase: 'parallel_verification', env: { SKS_REQUIRE_LOCAL_LLM: '1' }, deps: ['local-llm:smoke'] }),
-    task('python-sdk:real-smoke', 'python-sdk:real-smoke', {
-        group: 'real_smoke',
-        phase: 'parallel_verification',
-        env: { SKS_REQUIRE_PYTHON_CODEX_SDK: '1', SKS_PYTHON_CODEX_SDK_TIMEOUT_MS: '240000' },
-        deps: ['codex-sdk:real-smoke', 'codex-control:real-smoke', 'agent:real-codex-in-zellij-worker-pane'],
-        retries: 2,
-        retryDelayMs: 1500
-    }),
-    task('codex:0.134-runner-truth', 'codex:0.134-runner-truth', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-patch-envelope-smoke', 'agent:real-codex-patch-envelope-smoke', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-parallel-workers', 'agent:real-codex-parallel-workers', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-parallel-workers-5', 'agent:real-codex-parallel-workers-5', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-parallel-workers-10', 'agent:real-codex-parallel-workers-10', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-parallel-workers-20', 'agent:real-codex-parallel-workers-20', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-dynamic-smoke-v2', 'agent:real-codex-dynamic-smoke-v2', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-dynamic-smoke', 'agent:real-codex-dynamic-smoke', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-in-zellij-worker-pane', 'agent:real-codex-in-zellij-worker-pane', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real'], deps: ['zellij:layout-valid'] }),
-    task('imagegen:real-smoke', 'imagegen:real-smoke', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('ux-review:real-imagegen-smoke', 'ux-review:real-imagegen-smoke', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('ppt:real-imagegen-smoke', 'ppt:real-imagegen-smoke', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('naruto:real-local-gpt-final-smoke', 'naruto:real-local-gpt-final-smoke', { group: 'real_smoke', phase: 'parallel_verification', env: { SKS_REQUIRE_LOCAL_LLM: '1', SKS_REQUIRE_GPT_FINAL: '1' }, deps: ['local-llm:smoke'] }),
-    task('local-collab:gpt-final-performance', 'local-collab:gpt-final-performance', { group: 'real_smoke', phase: 'parallel_verification', env: { SKS_REQUIRE_LOCAL_LLM: '1', SKS_REQUIRE_GPT_FINAL: '1' }, deps: ['local-llm:smoke'] })
-];
-main().catch(async (err) => {
-    report.blockers.push(`release_real_check_exception:${err?.message || String(err)}`);
-    await finish(false);
-});
-async function main() {
-    if (!skipReleaseCheck) {
-        report.release_check = await runNpm(task('release:check', 'release:check', { group: 'design', phase: 'design' }));
-        collect(report.release_check);
-        if (!report.release_check.ok)
-            return await finish(false);
-    }
-    else {
-        report.release_check = {
-            id: 'release:check',
-            script: 'release:check',
-            group: 'design',
-            phase: 'design',
-            ok: true,
-            skipped: true,
-            note: 'Skipped because caller already verified release:check in this workspace.'
-        };
-    }
-    const result = await runDag(tasks, concurrency);
-    report.all_checks = result.results;
-    report.environment_required_checks = result.results.filter((row) => row.group === 'environment_required');
-    report.real_smoke_checks = result.results.filter((row) => row.group === 'real_smoke');
-    report.real_ui_checks = result.results.filter((row) => row.group === 'real_ui');
-    report.phase_results = summarizePhases(result.results);
-    for (const row of result.results)
-        collect(row);
-    await finish(result.results.every((row) => row.ok));
-}
-function task(id, script, options = {}) {
-    return {
-        id,
-        script,
-        group: options.group || 'real_smoke',
-        phase: options.phase || 'parallel_processing',
-        args: options.args || [],
-        env: options.env || {},
-        deps: options.deps || [],
-        retries: Number(options.retries || 0),
-        retryDelayMs: Number(options.retryDelayMs || 0)
-    };
-}
-async function runDag(taskList, maxConcurrency) {
-    const pending = new Map(taskList.map((row) => [row.id, row]));
-    const running = new Map();
-    const completed = new Map();
-    const results = [];
-    while (pending.size || running.size) {
-        for (const [id, row] of [...pending]) {
-            const failedDeps = row.deps.filter((dep) => completed.has(dep) && !completed.get(dep).ok);
-            if (failedDeps.length) {
-                pending.delete(id);
-                const blocked = blockedResult(row, failedDeps);
-                completed.set(id, blocked);
-                results.push(blocked);
-            }
-        }
-        const ready = [...pending.values()].filter((row) => row.deps.every((dep) => completed.get(dep)?.ok === true));
-        while (running.size < maxConcurrency && ready.length) {
-            const row = ready.shift();
-            pending.delete(row.id);
-            const promise = runNpm(row);
-            running.set(row.id, promise);
-        }
-        if (!running.size) {
-            if (pending.size) {
-                for (const row of pending.values()) {
-                    const blocked = blockedResult(row, row.deps.filter((dep) => !completed.get(dep)?.ok));
-                    completed.set(row.id, blocked);
-                    results.push(blocked);
-                }
-                pending.clear();
-            }
-            continue;
-        }
-        const result = await Promise.race([...running.values()]);
-        running.delete(result.id);
-        completed.set(result.id, result);
-        results.push(result);
-    }
-    return { results };
-}
-async function runNpm(row) {
-    const maxAttempts = Math.max(1, Number(row.retries || 0) + 1);
-    const attempts = [];
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const result = await runNpmOnce(row, attempt);
-        attempts.push(compactAttempt(result));
-        if (result.ok || attempt >= maxAttempts) {
-            return {
-                ...result,
-                attempt,
-                attempts,
-                retried: attempts.length > 1
-            };
-        }
-        await sleep(Math.max(0, Number(row.retryDelayMs || 0)));
-    }
-}
-function runNpmOnce(row, attempt) {
-    const npmArgs = ['run', row.script, '--silent'];
-    if (row.args?.length)
-        npmArgs.push('--', ...row.args);
-    const started = Date.now();
-    let stdout = '';
-    let stderr = '';
-    return new Promise((resolve) => {
-        const child = spawn('npm', npmArgs, {
-            cwd: root,
-            env: { ...process.env, ...(row.env || {}) },
-            stdio: ['ignore', 'pipe', 'pipe']
-        });
-        child.stdout.on('data', (chunk) => { stdout = appendTail(stdout, chunk); });
-        child.stderr.on('data', (chunk) => { stderr = appendTail(stderr, chunk); });
-        child.on('error', (err) => {
-            resolve(normalizeResult(row, npmArgs, 1, null, { code: err.code, message: err.message }, stdout, stderr, Date.now() - started, attempt));
-        });
-        child.on('close', (code, signal) => {
-            resolve(normalizeResult(row, npmArgs, code, signal, null, stdout, stderr, Date.now() - started, attempt));
-        });
-    });
-}
-function normalizeResult(row, npmArgs, code, signal, error, stdout, stderr, durationMs, attempt) {
-    const parsed = parseJson(stdout);
-    return {
-        id: row.id,
-        script: row.script,
-        group: row.group,
-        phase: row.phase,
-        deps: row.deps || [],
-        command: ['npm', ...npmArgs],
-        ok: code === 0,
-        attempt,
-        exit_code: code,
-        signal,
-        duration_ms: durationMs,
-        error,
-        parsed_schema: parsed?.schema || null,
-        parsed_ok: typeof parsed?.ok === 'boolean' ? parsed.ok : null,
-        blockers: extractList(parsed, 'blockers'),
-        warnings: extractList(parsed, 'warnings'),
-        stdout_tail: tail(stdout),
-        stderr_tail: tail(stderr)
-    };
-}
-function compactAttempt(result) {
-    return {
-        attempt: result.attempt,
-        ok: result.ok,
-        exit_code: result.exit_code,
-        duration_ms: result.duration_ms,
-        blockers: result.blockers || [],
-        stderr_tail: tail(result.stderr_tail || '', 600)
-    };
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function blockedResult(row, failedDeps) {
-    return {
-        id: row.id,
-        script: row.script,
-        group: row.group,
-        phase: row.phase,
-        deps: row.deps || [],
-        command: ['npm', 'run', row.script, '--silent'],
-        ok: false,
-        blocked: true,
-        exit_code: null,
-        signal: null,
-        duration_ms: 0,
-        error: null,
-        parsed_schema: null,
-        parsed_ok: null,
-        blockers: failedDeps.map((dep) => `blocked_by_failed_dependency:${dep}`),
-        warnings: [],
-        stdout_tail: '',
-        stderr_tail: `blocked by failed dependency: ${failedDeps.join(', ')}`
-    };
-}
-function collect(result) {
-    for (const blocker of result.blockers || []) {
-        if (!report.blockers.includes(blocker))
-            report.blockers.push(blocker);
-    }
-    if (!result.ok && !(result.blockers || []).length) {
-        const blocker = `${result.id.replace(/[^A-Za-z0-9]+/g, '_')}_failed`;
-        if (!report.blockers.includes(blocker))
-            report.blockers.push(blocker);
-    }
-    for (const warning of result.warnings || []) {
-        if (!report.warnings.includes(warning))
-            report.warnings.push(warning);
-    }
-}
-function summarizePhases(results) {
-    return ['design', 'parallel_processing', 'parallel_verification', 'aggregation'].map((phase) => {
-        const rows = phase === 'design' ? [report.release_check].filter(Boolean) : results.filter((row) => row.phase === phase);
-        return {
-            phase,
-            total: rows.length,
-            passed: rows.filter((row) => row.ok).length,
-            failed: rows.filter((row) => !row.ok).length,
-            duration_ms: rows.reduce((sum, row) => sum + Number(row.duration_ms || 0), 0)
-        };
-    });
-}
-async function finish(ok) {
-    report.ok = ok && report.blockers.length === 0;
-    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'release-real-check.json'), report);
-    console.log(JSON.stringify(report, null, 2));
-    if (!report.ok)
-        process.exitCode = 1;
-}
-function parseJson(text) {
-    const value = String(text || '').trim();
-    if (!value)
-        return null;
-    const start = value.indexOf('{');
-    if (start < 0)
-        return null;
-    try {
-        return JSON.parse(value.slice(start));
-    }
-    catch {
-        return null;
-    }
-}
-function extractList(parsed, key) {
-    if (!parsed || typeof parsed !== 'object')
-        return [];
-    const values = [];
-    const top = parsed[key];
-    const nested = parsed.report && typeof parsed.report === 'object' ? parsed.report[key] : null;
-    for (const list of [top, nested]) {
-        if (Array.isArray(list))
-            values.push(...list);
-    }
-    return [...new Set(values)];
-}
-function appendTail(previous, chunk, limit = 50 * 1024) {
-    const text = previous + String(chunk || '');
-    return text.length <= limit ? text : text.slice(-limit);
-}
-function tail(value, limit = 4000) {
-    const text = String(value || '');
-    return text.length <= limit ? text : text.slice(-limit);
-}
-//# sourceMappingURL=release-real-check.js.map

package/dist/scripts/release-registry-check.js

@@ -1,344 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const expectedRegistry = 'https://registry.npmjs.org/';
-const requireUnpublished = process.argv.includes('--require-unpublished');
-const requirePublishAuth = process.argv.includes('--require-publish-auth');
-const skipNetwork = process.env.SKS_SKIP_REGISTRY_NETWORK_CHECK === '1';
-const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-function fail(message, detail = '') {
-    console.error(`Release registry check failed: ${message}`);
-    if (detail)
-        console.error(detail.trim());
-    process.exit(2);
-}
-function normalizeRegistry(value) {
-    if (!value)
-        return '';
-    return String(value).trim().replace(/\/?$/, '/');
-}
-function readJson(file) {
-    try {
-        return JSON.parse(fs.readFileSync(path.join(root, file), 'utf8'));
-    }
-    catch (err) {
-        fail(`unable to read ${file}`, err.message);
-    }
-}
-function run(cmd, args, options = {}) {
-    return spawnSync(cmd, args, {
-        cwd: root,
-        encoding: 'utf8',
-        timeout: 30000,
-        ...options
-    });
-}
-function npmRegistryReadEnv(overrides = {}) {
-    const env = { ...process.env, ...overrides };
-    delete env.npm_config_tag;
-    delete env.NPM_CONFIG_TAG;
-    return env;
-}
-function checkPackagePublishConfig(pkg) {
-    if (pkg.private)
-        fail('package.json private=true would block public npm publication');
-    if (pkg.publishConfig?.access !== 'public') {
-        fail('package.json publishConfig.access must be public', `found: ${pkg.publishConfig?.access || 'missing'}`);
-    }
-    const registry = normalizeRegistry(pkg.publishConfig?.registry);
-    if (registry !== expectedRegistry) {
-        fail('package.json publishConfig.registry must target npmjs', `found: ${registry || 'missing'}\nexpected: ${expectedRegistry}`);
-    }
-    const isPrerelease = /-/.test(String(pkg.version || ''));
-    if (isPrerelease && pkg.publishConfig?.tag !== 'rc') {
-        fail('package.json publishConfig.tag must be rc for prerelease versions', `found: ${pkg.publishConfig?.tag || 'missing'}\nversion: ${pkg.version}`);
-    }
-    if (!isPrerelease && pkg.publishConfig?.tag && pkg.publishConfig.tag !== 'latest') {
-        fail('package.json publishConfig.tag must be latest or omitted for stable versions', `found: ${pkg.publishConfig.tag}\nversion: ${pkg.version}`);
-    }
-}
-function checkRootNpmrc(pkg) {
-    const npmrcPath = path.join(root, '.npmrc');
-    if (!fs.existsSync(npmrcPath))
-        return;
-    const text = fs.readFileSync(npmrcPath, 'utf8');
-    const unsafe = [];
-    const isPrerelease = /-/.test(String(pkg.version || ''));
-    for (const [index, line] of text.split(/\r?\n/).entries()) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';'))
-            continue;
-        const match = trimmed.match(/^(?:@[^:]+:)?registry\s*=\s*(.+)$/);
-        if (match && normalizeRegistry(match[1]) !== expectedRegistry)
-            unsafe.push(`${index + 1}: ${trimmed}`);
-        const tagMatch = trimmed.match(/^tag\s*=\s*(.+)$/);
-        if (tagMatch) {
-            const tag = tagMatch[1].trim();
-            if (isPrerelease && tag !== 'rc')
-                unsafe.push(`${index + 1}: ${trimmed}`);
-            if (!isPrerelease && tag !== 'latest')
-                unsafe.push(`${index + 1}: ${trimmed}`);
-        }
-    }
-    if (unsafe.length) {
-        fail('root .npmrc contains publish config incompatible with this release', unsafe.join('\n'));
-    }
-}
-function checkLockfile(pkg) {
-    const lock = readJson('package-lock.json');
-    const rootPackage = lock.packages?.[''];
-    const mismatches = [
-        ['package-lock.json name', lock.name, pkg.name],
-        ['package-lock.json version', lock.version, pkg.version],
-        ['package-lock root package name', rootPackage?.name, pkg.name],
-        ['package-lock root package version', rootPackage?.version, pkg.version]
-    ].filter(([, actual, expected]) => actual !== expected);
-    if (mismatches.length) {
-        fail('package-lock metadata is not synchronized', mismatches.map(([label, actual, expected]) => `${label}: ${actual || 'missing'} (expected ${expected})`).join('\n'));
-    }
-    const unsafeResolved = [];
-    for (const [entry, meta] of Object.entries(lock.packages || {})) {
-        const resolved = meta?.resolved;
-        if (!resolved || resolved.startsWith('file:') || resolved.startsWith('link:'))
-            continue;
-        let parsed;
-        try {
-            parsed = new URL(resolved);
-        }
-        catch {
-            unsafeResolved.push(`${entry || '<root>'}: ${resolved}`);
-            continue;
-        }
-        if (parsed.protocol === 'https:' && parsed.hostname === 'registry.npmjs.org')
-            continue;
-        unsafeResolved.push(`${entry || '<root>'}: ${resolved}`);
-    }
-    if (unsafeResolved.length) {
-        fail('package-lock contains dependencies resolved outside registry.npmjs.org', unsafeResolved.join('\n'));
-    }
-}
-function checkPackedMetadata(pkg) {
-    const env = npmRegistryReadEnv({
-        npm_config_cache: process.env.SKS_RELEASE_NPM_CACHE || path.join(os.tmpdir(), 'sneakoscope-npm-cache')
-    });
-    const result = run(npmBin, ['pack', '--dry-run', '--json', '--ignore-scripts', '--registry', expectedRegistry], { env });
-    if (result.status !== 0)
-        fail('npm pack dry-run failed', `${result.stdout || ''}\n${result.stderr || ''}`);
-    let info;
-    try {
-        info = JSON.parse(result.stdout)[0];
-    }
-    catch {
-        fail('npm pack dry-run returned non-json output', result.stdout || '');
-    }
-    if (!info)
-        fail('npm pack dry-run returned no package metadata');
-    if (info.name !== pkg.name || info.version !== pkg.version) {
-        fail('packed package metadata differs from package.json', `pack: ${info.name || 'missing'}@${info.version || 'missing'}\npackage.json: ${pkg.name}@${pkg.version}`);
-    }
-}
-function compareVersions(a, b) {
-    const pa = String(a || '').split(/[.-]/).map((part) => Number.parseInt(part, 10));
-    const pb = String(b || '').split(/[.-]/).map((part) => Number.parseInt(part, 10));
-    const len = Math.max(pa.length, pb.length);
-    for (let i = 0; i < len; i += 1) {
-        const da = Number.isFinite(pa[i]) ? pa[i] : 0;
-        const db = Number.isFinite(pb[i]) ? pb[i] : 0;
-        if (da !== db)
-            return da > db ? 1 : -1;
-    }
-    return 0;
-}
-function checkPublishedVersion(pkg) {
-    if (skipNetwork) {
-        console.log('Registry network check skipped by SKS_SKIP_REGISTRY_NETWORK_CHECK=1.');
-        return;
-    }
-    const env = npmRegistryReadEnv({
-        npm_config_cache: process.env.SKS_RELEASE_NPM_CACHE || path.join(os.tmpdir(), 'sneakoscope-npm-cache')
-    });
-    const result = run(npmBin, ['view', `${pkg.name}@latest`, 'version', 'dist-tags', '--json', '--registry', expectedRegistry], { env });
-    if (result.status !== 0)
-        fail('npm registry metadata lookup failed', `${result.stdout || ''}\n${result.stderr || ''}`);
-    let info;
-    try {
-        info = JSON.parse(result.stdout);
-    }
-    catch {
-        fail('npm registry metadata lookup returned non-json output', result.stdout || '');
-    }
-    const latest = info?.['dist-tags']?.latest || info?.version || null;
-    if (!latest)
-        fail('npm registry metadata lookup did not return a latest version');
-    const exact = run(npmBin, ['view', `${pkg.name}@${pkg.version}`, 'version', '--json', '--registry', expectedRegistry], { env });
-    let exactPublished = false;
-    if (exact.status === 0) {
-        try {
-            const exactInfo = JSON.parse(exact.stdout);
-            exactPublished = Array.isArray(exactInfo) ? exactInfo.includes(pkg.version) : exactInfo === pkg.version;
-        }
-        catch {
-            exactPublished = String(exact.stdout || '').includes(pkg.version);
-        }
-    }
-    else if (!/E404|No match found|not in this registry/i.test(`${exact.stdout || ''}\n${exact.stderr || ''}`)) {
-        fail('npm exact-version lookup failed', `${exact.stdout || ''}\n${exact.stderr || ''}`);
-    }
-    if (requireUnpublished && exactPublished) {
-        fail('package version is already published on npm', `${pkg.name}@${pkg.version}`);
-    }
-    const cmp = compareVersions(pkg.version, latest);
-    if (requireUnpublished && cmp <= 0) {
-        fail('package version is not newer than the npm latest dist-tag', `package.json: ${pkg.version}\nnpm latest: ${latest}`);
-    }
-    const note = exactPublished
-        ? `exact version already exists; current npm latest is ${latest}`
-        : (cmp > 0 ? `ready for new publish over npm latest ${latest}` : `current npm latest is ${latest}`);
-    console.log(`Registry metadata check passed: ${pkg.name}@${pkg.version}; ${note}.`);
-}
-function checkPublishAuth(pkg) {
-    if (skipNetwork) {
-        fail('publish auth check cannot run when SKS_SKIP_REGISTRY_NETWORK_CHECK=1 is set');
-    }
-    const env = npmRegistryReadEnv({
-        npm_config_cache: process.env.SKS_RELEASE_NPM_CACHE || path.join(os.tmpdir(), 'sneakoscope-npm-cache')
-    });
-    const whoami = run(npmBin, ['whoami', '--registry', expectedRegistry], { env });
-    if (whoami.status !== 0) {
-        const authHints = npmAuthSourceHints(env);
-        fail('npm publish auth is missing or invalid', [
-            tail(`${whoami.stdout || ''}\n${whoami.stderr || ''}`),
-            '',
-            ...publishAuthRepairInstructions(pkg, authHints)
-        ].join('\n'));
-    }
-    const user = normalizeNpmUser(whoami.stdout);
-    if (!user)
-        fail('npm whoami returned an empty username', whoami.stdout || '');
-    const maintainers = packageMaintainers(pkg, env);
-    if (maintainers.length > 0 && !maintainers.includes(user)) {
-        fail('authenticated npm user is not a package maintainer', [
-            `npm whoami: ${user}`,
-            `${pkg.name} maintainers: ${maintainers.join(', ')}`,
-            `Log in as one of the listed maintainers or ask an owner to run \`npm owner add ${user} ${pkg.name}\`.`
-        ].join('\n'));
-    }
-    const report = {
-        schema: 'sks.release-publish-auth.v1',
-        ok: true,
-        package: pkg.name,
-        version: pkg.version,
-        registry: expectedRegistry,
-        npm_user: user,
-        maintainers,
-        maintainer_match: maintainers.length === 0 ? null : maintainers.includes(user),
-        generated_at: new Date().toISOString()
-    };
-    const out = path.join(root, '.sneakoscope', 'reports', 'release-publish-auth.json');
-    fs.mkdirSync(path.dirname(out), { recursive: true });
-    fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-    console.log(`Publish auth check passed: ${pkg.name}@${pkg.version} as ${user}.`);
-}
-function publishAuthRepairInstructions(pkg, authHints) {
-    const lines = [];
-    if (authHints.length > 0) {
-        lines.push(`npm auth config was found (${authHints.join(', ')}), but the npm registry rejected it.`);
-        lines.push('That usually means the token is expired, revoked, not valid for npmjs.org, or not publish-capable for this package.');
-    }
-    else {
-        lines.push('No npm auth token was found in the checked npm config/env locations.');
-    }
-    lines.push(`Refresh local auth: \`npm logout --registry ${expectedRegistry}\`, then \`npm login --registry ${expectedRegistry}\` as a maintainer of ${pkg.name}.`);
-    lines.push(`Verify before publishing: \`npm whoami --registry ${expectedRegistry}\`.`);
-    lines.push('For token-based publishing, configure npm itself with a registry token, for example `//registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}` in the npm userconfig/project .npmrc and export a publish-capable token. A raw `NPM_TOKEN` environment variable alone is not enough unless npm config references it.');
-    return lines;
-}
-function npmAuthSourceHints(env) {
-    const hints = [];
-    if (env.NODE_AUTH_TOKEN)
-        hints.push('NODE_AUTH_TOKEN env');
-    if (env.NPM_TOKEN)
-        hints.push('NPM_TOKEN env (requires npmrc interpolation)');
-    for (const file of npmConfigCandidateFiles(env)) {
-        for (const hint of npmAuthHintsFromFile(file))
-            hints.push(hint);
-    }
-    return [...new Set(hints)];
-}
-function npmConfigCandidateFiles(env) {
-    const files = [
-        path.join(root, '.npmrc'),
-        env.npm_config_userconfig,
-        env.NPM_CONFIG_USERCONFIG,
-        path.join(os.homedir(), '.npmrc')
-    ].filter(Boolean);
-    return [...new Set(files.map((file) => path.resolve(String(file))))];
-}
-function npmAuthHintsFromFile(file) {
-    if (!fs.existsSync(file))
-        return [];
-    let text = '';
-    try {
-        text = fs.readFileSync(file, 'utf8');
-    }
-    catch {
-        return [];
-    }
-    const hints = [];
-    for (const [index, line] of text.split(/\r?\n/).entries()) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';'))
-            continue;
-        const lower = trimmed.toLowerCase();
-        const hasAuthKey = /(?::|^)_authtoken\s*=|(?::|^)_auth\s*=|(?::|^)username\s*=|(?::|^)_password\s*=/.test(lower);
-        if (!hasAuthKey)
-            continue;
-        const scopedToExpectedRegistry = lower.includes('//registry.npmjs.org/') || lower.startsWith('_auth');
-        if (scopedToExpectedRegistry)
-            hints.push(`${file}:${index + 1}`);
-    }
-    return hints;
-}
-function packageMaintainers(pkg, env) {
-    const result = run(npmBin, ['view', pkg.name, 'maintainers', '--json', '--registry', expectedRegistry], { env });
-    if (result.status !== 0) {
-        const text = `${result.stdout || ''}\n${result.stderr || ''}`;
-        if (/E404|not in this registry|No match found/i.test(text))
-            return [];
-        fail('npm maintainer lookup failed', text);
-    }
-    try {
-        const parsed = JSON.parse(result.stdout);
-        const rows = Array.isArray(parsed) ? parsed : (parsed ? [parsed] : []);
-        return [...new Set(rows.map(normalizeNpmUser).filter(Boolean))].sort();
-    }
-    catch {
-        return [...new Set(String(result.stdout || '').split(/\r?\n/).map(normalizeNpmUser).filter(Boolean))].sort();
-    }
-}
-function normalizeNpmUser(value) {
-    if (!value)
-        return '';
-    if (typeof value === 'object')
-        return normalizeNpmUser(value.name || value.username || '');
-    return String(value).trim().replace(/^@/, '').split(/\s+/)[0].toLowerCase();
-}
-function tail(value, limit = 1200) {
-    const text = String(value || '').trim();
-    return text.length > limit ? text.slice(-limit) : text;
-}
-const pkg = readJson('package.json');
-checkPackagePublishConfig(pkg);
-checkRootNpmrc(pkg);
-checkLockfile(pkg);
-checkPackedMetadata(pkg);
-checkPublishedVersion(pkg);
-if (requirePublishAuth)
-    checkPublishAuth(pkg);
-console.log(`Release registry check passed: ${pkg.name}@${pkg.version} -> ${expectedRegistry}`);
-//# sourceMappingURL=release-registry-check.js.map