agentic-workflow-manager 9.3.0 → 9.4.0

package/dist/src/commands/plan/index.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exitCodeFor = exitCodeFor;
+exports.formatReport = formatReport;
+exports.registerPlanCommand = registerPlanCommand;
+const validate_1 = require("../../core/plan/validate");
+const SUPPORTED_SCHEMA = 'compact-slices/v1';
+const MAX_PATH_LENGTH = 4096;
+const MAX_DIAGNOSTICS = 20;
+const MAX_DIAGNOSTIC_LENGTH = 4096;
+function assertText(value, name) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > MAX_PATH_LENGTH || value.startsWith('--') || /[\u0000-\u001F\u007F-\u009F]/.test(value)) {
+        throw new Error(`${name} must be a non-empty path without control characters`);
+    }
+}
+function terminalSafe(value) {
+    return value.replace(/[\u0000-\u001F\u007F-\u009F]/g, character => `\\u${character.codePointAt(0).toString(16).padStart(4, '0')}`);
+}
+function assertDependencies(deps) {
+    if (!deps || typeof deps.validatePlanFile !== 'function')
+        throw new Error('validatePlanFile must be a function');
+}
+function boundedDiagnostics(diagnostics) {
+    if (!Array.isArray(diagnostics))
+        throw new Error('plan validator returned invalid diagnostics');
+    return diagnostics.slice(0, MAX_DIAGNOSTICS).map((diagnostic) => {
+        if (!diagnostic || typeof diagnostic.code !== 'string' || typeof diagnostic.message !== 'string') {
+            throw new Error('plan validator returned an invalid diagnostic');
+        }
+        return {
+            code: diagnostic.code.slice(0, MAX_DIAGNOSTIC_LENGTH),
+            message: diagnostic.message.slice(0, MAX_DIAGNOSTIC_LENGTH),
+            ...(typeof diagnostic.field === 'string' ? { field: diagnostic.field.slice(0, MAX_DIAGNOSTIC_LENGTH) } : {}),
+        };
+    });
+}
+function reportPayload(report, planPath) {
+    switch (report.state) {
+        case 'valid':
+            return {
+                state: report.state, path: planPath, schema: report.schema, planId: report.manifest.planId,
+                requirements: report.manifest.requirements.length, sources: report.manifest.sources.length,
+                commands: report.manifest.commands.length, slices: report.manifest.slices.length, completeOwnership: true,
+            };
+        case 'legacy':
+            return { state: report.state, path: planPath, message: 'existing full-quality path applies; compact optimization was not requested.' };
+        case 'invalid':
+            return { state: report.state, path: planPath, diagnostics: boundedDiagnostics(report.diagnostics) };
+        case 'unsupported':
+            return {
+                state: report.state, path: planPath, schema: report.schema, supportedSchema: SUPPORTED_SCHEMA,
+                diagnostics: boundedDiagnostics(report.diagnostics), remedy: 'update AWM to support this compact plan schema.',
+            };
+        default:
+            throw new Error('plan validator returned an unknown report state');
+    }
+}
+function exitCodeFor(report) {
+    return report.state === 'valid' || report.state === 'legacy' ? 0 : 2;
+}
+function formatReport(report, planPath) {
+    const payload = reportPayload(report, planPath);
+    switch (report.state) {
+        case 'valid':
+            return `Plan validation: valid "${terminalSafe(planPath)}" (${terminalSafe(report.schema)}; ${payload.slices} slices; ${payload.requirements} requirements; complete ownership)\n`;
+        case 'legacy':
+            return `Plan validation: legacy "${terminalSafe(planPath)}" — existing full-quality path applies; compact optimization was not requested.\n`;
+        case 'invalid':
+            return `Plan validation: invalid "${terminalSafe(planPath)}"\n${payload.diagnostics.map(diagnostic => `- ${terminalSafe(diagnostic.code)}: ${terminalSafe(diagnostic.message)}${diagnostic.field ? ` (${terminalSafe(diagnostic.field)})` : ''}`).join('\n')}\n`;
+        case 'unsupported':
+            return `Plan validation: unsupported "${terminalSafe(planPath)}" (${terminalSafe(report.schema)}; supported: ${SUPPORTED_SCHEMA})\nUpdate AWM to support this compact plan schema.\n`;
+        default:
+            throw new Error('plan validator returned an unknown report state');
+    }
+}
+function registerPlanCommand(program, deps = { validatePlanFile: validate_1.validatePlanFile }) {
+    if (!program || typeof program.command !== 'function')
+        throw new Error('program must be a Commander command');
+    assertDependencies(deps);
+    const plan = program.command('plan').description('inspect plan contracts');
+    plan
+        .command('validate <plan-path>')
+        .description('validate a compact plan without modifying it')
+        .option('--json', 'emit one stable JSON report')
+        .option('--cwd <path>', 'repository root for plan containment and source resolution')
+        .action((planPath, options) => {
+        assertText(planPath, 'plan path');
+        const cwd = options.cwd ?? process.cwd();
+        assertText(cwd, '--cwd');
+        const report = deps.validatePlanFile(planPath, cwd);
+        const output = options.json === true
+            ? `${JSON.stringify(reportPayload(report, planPath))}\n`
+            : formatReport(report, planPath);
+        process.stdout.write(output);
+        const code = exitCodeFor(report);
+        process.exitCode = code;
+    });
+}

package/dist/src/commands/preflight/checks.js

@@ -15,6 +15,8 @@ const run_1 = require("../sensors/run");
 const paths_1 = require("../../core/paths");
 const registries_1 = require("../../core/registries");
 const inspect_1 = require("../../core/context-kernel/inspect");
+const registries_2 = require("../../core/registries");
+const check_1 = require("../../core/currentness/check");
 const MANIFEST = path_1.default.join('.awm', 'sensors.json');
 /**
  * The agent needs project context delivered every session. A repo with neither file
@@ -34,7 +36,17 @@ function checkContext(cwd) {
     return { id: 'context', ok: true, detail: present.join(', ') };
 }
 function checkContextKernel(cwd) {
-    const resolution = (0, registries_1.resolveProjectContextSchema)();
+    let resolution;
+    try {
+        resolution = (0, registries_1.resolveProjectContextSchema)();
+    }
+    catch {
+        return {
+            id: 'context-kernel', ok: false, advisory: false,
+            detail: 'configured registry inventory could not be read',
+            remedy: 'Repair the local registry inventory and rerun preflight.',
+        };
+    }
     if (resolution.diagnostics.length > 0) {
         return {
             id: 'context-kernel',
@@ -379,9 +391,46 @@ function checkHost(cwd) {
     // Bitbucket, Azure DevOps, an internal git server, etc. — don't overclaim support.
     return { id: 'host', ok: true, detail: 'git host not recognized (github/gitlab) — PR/MR automation not applicable' };
 }
+function bounded(value, limit = 512) {
+    return value.length <= limit ? value : `${value.slice(0, limit - 1)}…`;
+}
+function checkCompatibility() {
+    let failures;
+    try {
+        failures = (0, registries_2.verifyMinCliVersions)();
+    }
+    catch {
+        return {
+            id: 'compatibility', ok: false,
+            detail: 'configured registry inventory could not be read',
+            remedy: 'Repair the local registry inventory and rerun strict preflight.',
+        };
+    }
+    if (failures.length === 0)
+        return { id: 'compatibility', ok: true, detail: 'all configured registry minCliVersion requirements are satisfied' };
+    return {
+        id: 'compatibility', ok: false,
+        detail: bounded(failures.map(failure => `${failure.name} requires CLI >= ${failure.min}`).join('; ')),
+        remedy: 'npm i -g agentic-workflow-manager@latest && rerun in a fresh process',
+    };
+}
+function checkAuthoritativeCurrentness(report) {
+    const failing = report.components.filter(component => component.status !== 'current');
+    const components = report.components.map(component => bounded(`${component.component}: installed=${component.installed ?? 'unknown'} latest=${component.latest ?? 'unknown'} `
+        + `channel=${component.channel} source=${component.source}${component.pin ? ` pin=${component.pin}` : ''} `
+        + `checkedAt=${component.checkedAt} status=${component.status}`));
+    return failing.length === 0
+        ? { id: 'currentness', ok: true, detail: `Currentness: current. ${components.join('; ')}` }
+        : {
+            id: 'currentness', ok: false, detail: `Currentness: ${failing.map(component => component.status).join(', ')}. ${components.join('; ')}`,
+            remedy: bounded(failing.map(component => component.remedy).join('; ')),
+        };
+}
 async function preflight(cwd = process.cwd(), opts = {}) {
-    if (!opts || typeof opts !== 'object' || Array.isArray(opts) || (opts.verifySensors !== undefined && typeof opts.verifySensors !== 'boolean')) {
-        throw new Error('preflight options must contain an optional boolean verifySensors');
+    if (!opts || typeof opts !== 'object' || Array.isArray(opts)
+        || (opts.verifySensors !== undefined && typeof opts.verifySensors !== 'boolean')
+        || (opts.requireCurrent !== undefined && typeof opts.requireCurrent !== 'boolean')) {
+        throw new Error('preflight options must contain optional boolean verifySensors and requireCurrent');
     }
     const manifest = readManifest(cwd);
     const manifestExists = fs_1.default.existsSync(path_1.default.join(cwd, MANIFEST));
@@ -397,6 +446,8 @@ async function preflight(cwd = process.cwd(), opts = {}) {
         // The empirical mode is intentionally opt-in: ordinary preflight remains a
         // quick static inspection and must not dispatch project software.
         ...(opts.verifySensors === true ? [await checkSensorExecution(cwd)] : []),
+        // Strict mode is the only path that contacts authoritative npm/Git sources.
+        ...(opts.requireCurrent === true ? [checkCompatibility()] : []),
         // Runs unconditionally — orthogonal to sensor configuration entirely, this is
         // about PR/MR tooling, not sensors.
         checkHost(cwd),
@@ -407,5 +458,14 @@ async function preflight(cwd = process.cwd(), opts = {}) {
         : !manifestExists ? 'not_configured'
             : checks.some(blockingFailure) ? 'degraded'
                 : 'ready';
-    return { status, checks };
+    const currentness = opts.requireCurrent === true ? await (0, check_1.checkCurrentness)(cwd) : undefined;
+    if (currentness) {
+        checks.splice(checks.length - 1, 0, checkAuthoritativeCurrentness(currentness));
+    }
+    const strictFailure = checks.some(blockingFailure);
+    const strictStatus = invalidContextKernel ? 'degraded'
+        : !manifestExists ? 'not_configured'
+            : strictFailure ? 'degraded'
+                : 'ready';
+    return currentness ? { status: strictStatus, checks, currentness } : { status, checks };
 }

package/dist/src/commands/preflight/index.js

@@ -44,9 +44,13 @@ function registerPreflightCommand(program) {
         .description('verify the project harness can actually gate before development starts')
         .option('--json', 'emit the report as JSON')
         .option('--verify-sensors', 'run the complete sensor gate before unattended execution')
+        .option('--require-current', 'require authoritative CLI and registry currentness before unattended execution')
         .option('--cwd <path>', 'project directory to check (default: current)')
         .action(async (opts) => {
-        const report = await (0, checks_1.preflight)(opts.cwd ?? process.cwd(), { verifySensors: opts.verifySensors === true });
+        const report = await (0, checks_1.preflight)(opts.cwd ?? process.cwd(), {
+            verifySensors: opts.verifySensors === true,
+            requireCurrent: opts.requireCurrent === true,
+        });
         process.stdout.write(opts.json ? JSON.stringify(report, null, 2) + '\n' : formatReport(report));
         const code = exitCodeFor(report);
         // `process.exit()` may truncate the JSON written immediately above when

package/dist/src/core/currentness/check.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCurrentness = checkCurrentness;
+exports.sanitizeSource = sanitizeSource;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const cli_version_1 = require("../cli-version");
+const registries_1 = require("../registries");
+const config_1 = require("../../utils/config");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const TIMEOUT_MS = 2_000;
+const MAX_OUTPUT_BYTES = 64 * 1024;
+const NPM_SOURCE = `https://registry.npmjs.org/${cli_version_1.CLI_PACKAGE_NAME}`;
+const STRICT_SEMVER = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+function deadline(operation, timeoutMs = TIMEOUT_MS) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error('currentness transport timed out')), timeoutMs);
+    });
+    return Promise.race([operation, timeout]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
+function bounded(value, limit = 512) {
+    return value.length <= limit ? value : `${value.slice(0, limit - 1)}…`;
+}
+function authoritativeSource(value) {
+    try {
+        const url = new URL(value);
+        // HTTPS userinfo is a credential-bearing transport URL. Reject it before
+        // constructing any Git argv, rather than merely redacting it for output.
+        if (url.protocol === 'https:' && url.hostname && !url.username && !url.password && !url.search && !url.hash) {
+            return bounded(`https://${url.host}${url.pathname}`);
+        }
+        if (url.protocol === 'ssh:' && url.hostname && !url.password && !url.search && !url.hash) {
+            return bounded(`ssh://${url.host}${url.pathname}`);
+        }
+        return null;
+    }
+    catch {
+        // SCP-style Git remotes have no URL parser representation. Permit only an
+        // intentionally narrow grammar and remove the optional userinfo; all other
+        // schemes fail closed.
+        const match = /^(?:[A-Za-z0-9._-]+@)?([A-Za-z0-9.-]+):([A-Za-z0-9._/-]+)$/.exec(value);
+        return match
+            ? bounded(`${match[1]}:${match[2]}`)
+            : null;
+    }
+}
+function sanitizeSource(value) {
+    return authoritativeSource(value) ?? '[configured remote]';
+}
+function parseVersion(value) {
+    const match = STRICT_SEMVER.exec(value.trim());
+    if (!match)
+        return null;
+    return [match[1], match[2], match[3]];
+}
+function compareNumericIdentifier(a, b) {
+    if (a.length !== b.length)
+        return a.length < b.length ? -1 : 1;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareStrict(a, b) {
+    const av = parseVersion(a);
+    const bv = parseVersion(b);
+    if (!av || !bv)
+        return null;
+    return compareNumericIdentifier(av[0], bv[0])
+        || compareNumericIdentifier(av[1], bv[1])
+        || compareNumericIdentifier(av[2], bv[2]);
+}
+function iso(now) {
+    const value = now();
+    if (!Number.isFinite(value))
+        throw new Error('currentness clock must return a finite timestamp');
+    return new Date(value).toISOString();
+}
+const defaultGit = async (cwd, args, options) => {
+    const result = await execFileAsync('git', args, {
+        cwd,
+        timeout: options.timeoutMs,
+        maxBuffer: options.maxOutputBytes,
+        windowsHide: true,
+    });
+    return result.stdout;
+};
+function unavailable(component, source, checkedAt, installed, pin) {
+    return {
+        component, installed, latest: null, channel: 'stable', source, ...(pin ? { pin } : {}), checkedAt,
+        status: 'unverifiable', detail: 'Authoritative currentness could not be verified.',
+        remedy: 'Restore source access and rerun strict preflight.',
+    };
+}
+async function latestCli(fetchImpl) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+        const response = await deadline(fetchImpl(NPM_SOURCE, { signal: controller.signal }));
+        if (!response.ok)
+            return null;
+        const text = await deadline(response.text());
+        if (Buffer.byteLength(text, 'utf8') > MAX_OUTPUT_BYTES)
+            return null;
+        const body = JSON.parse(text);
+        if (!body || typeof body !== 'object')
+            return null;
+        const tags = body['dist-tags'];
+        const latest = tags && typeof tags === 'object' ? tags.latest : undefined;
+        return typeof latest === 'string' && parseVersion(latest) ? latest : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function latestStableTag(output) {
+    if (Buffer.byteLength(output, 'utf8') > MAX_OUTPUT_BYTES)
+        return null;
+    const tags = new Map();
+    for (const line of output.split(/\r?\n/)) {
+        const match = /^([0-9a-fA-F]{40,64})\trefs\/tags\/(v?\d+\.\d+\.\d+)(\^\{\})?$/.exec(line);
+        if (!match)
+            continue;
+        const tag = tags.get(match[2]) ?? { sha: '' };
+        if (match[3])
+            tag.peeled = match[1];
+        else
+            tag.sha = match[1];
+        tags.set(match[2], tag);
+    }
+    let latest = null;
+    for (const [tag, ref] of tags) {
+        if (!ref.sha)
+            continue;
+        if (!latest || (compareStrict(tag, latest.tag) ?? -1) > 0)
+            latest = { sha: ref.peeled ?? ref.sha, tag };
+    }
+    return latest;
+}
+async function registryComponent(registry, git, prefs, checkedAt) {
+    const authorizedSource = authoritativeSource(registry.remote);
+    const source = authorizedSource ?? '[configured remote]';
+    const pin = prefs.pins?.[registry.name];
+    if (!authorizedSource)
+        return unavailable(`registry:${registry.name}`, source, checkedAt, null, pin);
+    let origin;
+    let head;
+    let exactTag;
+    let remoteTags;
+    try {
+        [origin, head, exactTag, remoteTags] = await Promise.all([
+            deadline(git(registry.contentRoot, ['remote', 'get-url', 'origin'], { timeoutMs: TIMEOUT_MS, maxOutputBytes: MAX_OUTPUT_BYTES })),
+            deadline(git(registry.contentRoot, ['rev-parse', 'HEAD'], { timeoutMs: TIMEOUT_MS, maxOutputBytes: MAX_OUTPUT_BYTES })),
+            deadline(git(registry.contentRoot, ['describe', '--tags', '--exact-match', 'HEAD'], { timeoutMs: TIMEOUT_MS, maxOutputBytes: MAX_OUTPUT_BYTES })),
+            deadline(git(registry.contentRoot, ['ls-remote', '--tags', registry.remote], { timeoutMs: TIMEOUT_MS, maxOutputBytes: MAX_OUTPUT_BYTES })),
+        ]);
+    }
+    catch {
+        return unavailable(`registry:${registry.name}`, source, checkedAt, null, pin);
+    }
+    const installed = exactTag.trim();
+    const latest = latestStableTag(remoteTags);
+    const localHead = head.trim();
+    const installedVersion = parseVersion(installed);
+    if (!installedVersion || !latest || !/^[0-9a-fA-F]{40,64}$/.test(localHead) || origin.trim() !== registry.remote) {
+        return unavailable(`registry:${registry.name}`, source, checkedAt, installedVersion ? installed : null, pin);
+    }
+    const relation = compareStrict(installed, latest.tag);
+    if (relation === null)
+        return unavailable(`registry:${registry.name}`, source, checkedAt, installed, pin);
+    if (relation === 0 && localHead === latest.sha) {
+        return { component: `registry:${registry.name}`, installed, latest: latest.tag, channel: 'stable', source, ...(pin ? { pin } : {}), checkedAt, status: 'current', detail: 'Exact stable tag and configured origin match the authoritative remote.', remedy: 'No action required.' };
+    }
+    if (relation < 0) {
+        return {
+            component: `registry:${registry.name}`, installed, latest: latest.tag, channel: 'stable', source, ...(pin ? { pin } : {}), checkedAt,
+            status: pin ? 'pinned-behind' : 'stale', detail: 'Installed stable tag is behind the authoritative remote.',
+            remedy: pin ? `awm unpin ${registry.name} && awm update --yes` : 'awm update --yes',
+        };
+    }
+    return unavailable(`registry:${registry.name}`, source, checkedAt, installed, pin);
+}
+/** Strict, read-only remote currentness check. It intentionally never reads/writes update cache. */
+async function checkCurrentness(cwd, deps = {}) {
+    if (!cwd || typeof cwd !== 'string')
+        throw new Error('currentness cwd must be a non-empty string');
+    const now = deps.now ?? Date.now;
+    const checkedAt = iso(now);
+    const getCliVersion = deps.cliVersion ?? cli_version_1.cliVersion;
+    const fetchImpl = deps.fetch ?? fetch;
+    const git = deps.git ?? defaultGit;
+    const preferences = (deps.readPreferences ?? config_1.readPreferences)();
+    const installedCli = getCliVersion();
+    const latest = await latestCli(fetchImpl);
+    const cli = !parseVersion(installedCli) || !latest || compareStrict(installedCli, latest) === null
+        ? unavailable('cli', NPM_SOURCE, checkedAt, parseVersion(installedCli) ? installedCli : null)
+        : compareStrict(installedCli, latest) === 0
+            ? { component: 'cli', installed: installedCli, latest, channel: 'stable', source: NPM_SOURCE, checkedAt, status: 'current', detail: 'Installed version equals npm dist-tags.latest.', remedy: 'No action required.' }
+            : { component: 'cli', installed: installedCli, latest, channel: 'stable', source: NPM_SOURCE, checkedAt, status: 'stale', detail: 'Installed version is behind npm dist-tags.latest.', remedy: `npm i -g ${cli_version_1.CLI_PACKAGE_NAME}@latest && rerun in a fresh process` };
+    const components = [cli];
+    let registries;
+    try {
+        registries = (deps.listRegistries ?? registries_1.listRegistries)();
+        if (!Array.isArray(registries))
+            throw new Error('currentness registry inventory must be an array');
+    }
+    catch {
+        components.push({
+            ...unavailable('registry:inventory', '[configured registry inventory]', checkedAt, null),
+            remedy: 'Repair the local registry inventory and rerun strict preflight.',
+        });
+        return { checkedAt, components, compatibility: { status: 'not-checked' } };
+    }
+    if (registries.length === 0)
+        components.push(unavailable('registry:none', '[configured remote]', checkedAt, null));
+    else
+        for (const registry of registries)
+            components.push(await registryComponent(registry, git, preferences, checkedAt));
+    return { checkedAt, components, compatibility: { status: 'not-checked' } };
+}

package/dist/src/core/currentness/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/core/plan/json.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonNoDuplicate = parseJsonNoDuplicate;
+/** Parses JSON after rejecting duplicate object keys without runtime dependencies. */
+function parseJsonNoDuplicate(text) {
+    if (typeof text !== 'string')
+        throw new Error('JSON input must be a string');
+    let index = 0;
+    const fail = (message) => { throw new Error(`invalid JSON: ${message}`); };
+    const whitespace = () => { while (/\s/.test(text[index] ?? ''))
+        index++; };
+    const string = () => {
+        if (text[index++] !== '"')
+            fail('expected string');
+        let out = '';
+        while (index < text.length) {
+            const char = text[index++];
+            if (char === '"')
+                return out;
+            if (char === '\\') {
+                const escape = text[index++];
+                if (!escape)
+                    fail('unterminated escape');
+                if (escape === 'u') {
+                    const hex = text.slice(index, index + 4);
+                    if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                        fail('invalid unicode escape');
+                    out += String.fromCharCode(Number.parseInt(hex, 16));
+                    index += 4;
+                }
+                else {
+                    const decoded = { '"': '"', '\\': '\\', '/': '/', b: '\b', f: '\f', n: '\n', r: '\r', t: '\t' };
+                    if (!(escape in decoded))
+                        fail('invalid escape');
+                    out += decoded[escape];
+                }
+            }
+            else {
+                if (char < ' ')
+                    fail('control character in string');
+                out += char;
+            }
+        }
+        return fail('unterminated string');
+    };
+    const value = () => {
+        whitespace();
+        const char = text[index];
+        if (char === '"') {
+            string();
+            return;
+        }
+        if (char === '{') {
+            object();
+            return;
+        }
+        if (char === '[') {
+            array();
+            return;
+        }
+        if (text.startsWith('true', index) || text.startsWith('false', index) || text.startsWith('null', index)) {
+            index += text.startsWith('true', index) ? 4 : text.startsWith('false', index) ? 5 : 4;
+            return;
+        }
+        const match = text.slice(index).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/);
+        if (!match)
+            return fail('expected value');
+        index += match[0].length;
+    };
+    const array = () => { index++; whitespace(); if (text[index] === ']') {
+        index++;
+        return;
+    } while (true) {
+        value();
+        whitespace();
+        if (text[index] === ']') {
+            index++;
+            return;
+        }
+        if (text[index++] !== ',')
+            fail('expected comma');
+    } };
+    const object = () => { index++; const keys = new Set(); whitespace(); if (text[index] === '}') {
+        index++;
+        return;
+    } while (true) {
+        whitespace();
+        if (text[index] !== '"')
+            fail('expected object key');
+        const key = string();
+        if (keys.has(key))
+            fail(`duplicate key ${JSON.stringify(key)}`);
+        keys.add(key);
+        whitespace();
+        if (text[index++] !== ':')
+            fail('expected colon');
+        value();
+        whitespace();
+        if (text[index] === '}') {
+            index++;
+            return;
+        }
+        if (text[index++] !== ',')
+            fail('expected comma');
+    } };
+    value();
+    whitespace();
+    if (index !== text.length)
+        fail('trailing content');
+    return JSON.parse(text);
+}

package/dist/src/core/plan/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });