@b00dea/cockpit 0.0.0-bootstrap.0 → 0.1.0

package/dist/diagnostics.js

@@ -0,0 +1,335 @@
+import { snapshotJson } from './environment/contract.js';
+import { admitDiagnosticFix, bindConfigPath, cockpitCommand, initCommand } from './fix-catalogue.js';
+const COMMON_REFUSAL_GUIDANCE = Object.freeze({
+    INIT_CANONICAL_OWNERSHIP_MISSING: Object.freeze({
+        why: 'init cannot safely resume when its recorded bootstrap state and generated ownership disagree',
+        fix: `restore the committed ownership metadata, then rerun ${initCommand()} with the root, target and options you ran it with`,
+    }),
+    SURFACE_SOURCE_UNAVAILABLE: Object.freeze({
+        why: 'generated instructions cannot be trusted without the declared sibling source',
+        fix: `restore the named sibling checkout at its declared path, then rerun ${cockpitCommand('sync')}`,
+    }),
+    SURFACE_OWNERSHIP_INVALID: Object.freeze({
+        why: 'cockpit cannot prove which generated settings it is allowed to replace',
+        fix: `restore the last committed generated ownership metadata, then rerun ${cockpitCommand('sync')}`,
+    }),
+    SURFACE_STATE_CONFLICT: Object.freeze({
+        why: 'sync would overwrite content that cockpit did not write',
+        fix: `for a generated file you edited, move the change into cockpit.toml or a surface overlay, then ask the person who owns the cockpit before you undo the edit or delete the file, and rerun ${cockpitCommand('sync')}; for the team's own .claude/settings.json, .codex/config.toml or .codex/hooks.json, have a human approve ${cockpitCommand('sync', { args: '--adopt <path>' })}`,
+    }),
+    GENERATED_ARTIFACT_DRIFT: Object.freeze({
+        why: 'generated files no longer match the canonical cockpit configuration',
+        fix: `run ${cockpitCommand('sync')}, then retry`,
+    }),
+    GENERATED_OWNERSHIP_INVALID: Object.freeze({
+        why: 'publication cannot safely update files without authenticated ownership metadata',
+        fix: `restore the committed ownership metadata and rerun ${cockpitCommand('sync')}`,
+    }),
+    GUARD_AUTHORITY_UNAVAILABLE: Object.freeze({
+        why: 'the guard cannot make a safe allow or deny decision without current generated authority',
+        fix: `restore cockpit.toml and the generated guard files, then have a human run ${cockpitCommand('sync')}`,
+    }),
+    GUARD_REFUSED: Object.freeze({
+        why: 'the requested command is outside the current cockpit guard policy',
+        fix: `follow the refusal reason or ask a human to change cockpit.toml and run ${cockpitCommand('sync')}`,
+    }),
+    RUNTIME_UNAVAILABLE: Object.freeze({
+        why: 'cockpit cannot start or inspect the declared environment without a container runtime it can reach and identify',
+        fix: 'start the configured container runtime and verify docker info succeeds, then retry',
+    }),
+    RUNTIME_UNMEASURED: Object.freeze({
+        why: 'this machine has no passing measurement for the current runtime, so cockpit cannot vouch for its mounts, labels, health and teardown',
+        fix: `run ${cockpitCommand('runtime measure', { args: '--image <local-image>' })}, which records the result for this machine only, then retry`,
+    }),
+    CLAIM_CO_TENANT: Object.freeze({
+        why: 'another holder still owns or is using the same stack',
+        fix: `for a failed up attempt, run ${cockpitCommand('up')} to resume or ${cockpitCommand('down')} to release; otherwise end each cockpit session the message names (let its command finish, or stop the named process), then retry; a session whose process is gone is released by the next up, sleep, down or reset`,
+    }),
+    PORT_FAMILY_COLLISION: Object.freeze({
+        why: 'one or more ports selected for this stack are already in use',
+        fix: 'stop the named listener or release the inactive stack, then retry',
+    }),
+    PORT_LEASE_EXHAUSTED: Object.freeze({
+        why: 'every declared port family is leased or occupied',
+        fix: 'release an inactive stack or extend ports.count after checking host capacity',
+    }),
+    SETUP_MANUAL_MISSING: Object.freeze({
+        why: 'a manually managed sibling must already exist before cockpit can wire it',
+        fix: `create the named checkout at its declared path, then run ${cockpitCommand('setup')} again`,
+    }),
+    SETUP_REMOTE_MISMATCH: Object.freeze({
+        why: 'rewiring an existing checkout to a different repository could replace the wrong source',
+        fix: `correct the checkout remote or the sibling declaration, then run ${cockpitCommand('setup')} again`,
+    }),
+    SETUP_REMOTE_UNRESOLVABLE: Object.freeze({
+        why: 'a relative local remote that cannot be resolved cannot be compared with, or cloned into, a checkout',
+        fix: `make the remote path readable or declare an absolute path or URL, then run ${cockpitCommand('setup')} again`,
+    }),
+});
+// Command-line mistakes (as opposed to failed work) get a pointer to the relevant --help.
+const USAGE_ERROR_CODE = /^CLI_(?:USAGE_INVALID|UNKNOWN_COMMAND|COMMAND_REQUIRED)$|_(?:DUPLICATE|UNSUPPORTED)$/;
+function escapeForTerminal(value) {
+    return value.replace(/[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028-\u202e\u2066-\u2069]/g, (character) => {
+        if (/[\u0080-\u009f\u061c\u200e\u200f\u2028-\u202e\u2066-\u2069]/.test(character)) {
+            return `\\u${character.codePointAt(0).toString(16).padStart(4, '0')}`;
+        }
+        const escaped = JSON.stringify(character);
+        return escaped.slice(1, -1);
+    });
+}
+function terminalSafeJson(value, space) {
+    // JSON already escapes C0; the remaining terminal controls must retain their JSON value.
+    return JSON.stringify(value, null, space).replace(/[\u007f-\u009f\u061c\u200e\u200f\u2028-\u202e\u2066-\u2069]/g, (character) => `\\u${character.codePointAt(0).toString(16).padStart(4, '0')}`);
+}
+function humanLines(value, depth) {
+    const indent = '  '.repeat(depth);
+    if (value === null)
+        return [`${indent}none`];
+    if (typeof value === 'string')
+        return [`${indent}${escapeForTerminal(value)}`];
+    if (typeof value === 'boolean' || typeof value === 'number')
+        return [`${indent}${String(value)}`];
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return [`${indent}(none)`];
+        return value.flatMap((item) => {
+            if (item === null || typeof item !== 'object') {
+                const [line] = humanLines(item, 0);
+                return [`${indent}- ${line}`];
+            }
+            return [`${indent}-`, ...humanLines(item, depth + 1)];
+        });
+    }
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+        return [`${indent}(none)`];
+    return entries.flatMap(([key, item]) => {
+        const label = `${indent}${escapeForTerminal(key)}:`;
+        if (item === null || typeof item !== 'object') {
+            const [line] = humanLines(item, 0);
+            return [`${label} ${line}`];
+        }
+        return [label, ...humanLines(item, depth + 1)];
+    });
+}
+export function renderHumanValue(value) {
+    const captured = snapshotJson(value);
+    return captured === undefined ? 'Result is not available as bounded human-readable text.\n'
+        : `${humanLines(captured, 0).join('\n')}\n`;
+}
+function projectDiagnostics(input, context) {
+    const diagnostics = new Map();
+    const guidance = new Map();
+    for (const source of input) {
+        const { severity, code, target, fix } = source;
+        const admitted = admitDiagnosticFix(source, context);
+        const identity = { code, ...(target === undefined ? {} : { target }) };
+        const message = bindConfigPath(source.message, context);
+        const diagnostic = { severity, ...identity, message, ...(admitted ? { fix: admitted.command } : {}) };
+        diagnostics.set(JSON.stringify(diagnostic), diagnostic);
+        if (fix !== undefined && !admitted) {
+            const row = { ...identity, text: bindConfigPath(fix, context) };
+            guidance.set(JSON.stringify(row), row);
+        }
+        else if (fix === undefined && Object.prototype.hasOwnProperty.call(COMMON_REFUSAL_GUIDANCE, code)) {
+            const row = { ...identity, text: bindConfigPath(COMMON_REFUSAL_GUIDANCE[code].fix, context) };
+            guidance.set(JSON.stringify(row), row);
+        }
+    }
+    return { diagnostics: [...diagnostics.values()], guidance: [...guidance.values()] };
+}
+// What each lifecycle `change` means to the person who ran the command; `--json` keeps the raw value.
+const LIFECYCLE_CHANGES = Object.freeze({
+    up: Object.freeze({ started: 'Stack started', resumed: 'Stack resumed', unchanged: 'Stack already running' }),
+    sleep: Object.freeze({
+        stopped: 'Stack stopped',
+        retained: "Released this checkout's hold; another holder keeps the stack running",
+        unchanged: 'Nothing to stop: no session holds the stack',
+    }),
+    down: Object.freeze({ removed: 'Stack removed' }),
+    reset: Object.freeze({ unchanged: 'Nothing to reset' }),
+});
+function resetTargetLines(targets) {
+    return targets.map(({ kind, identity, declaration }) => `  ${escapeForTerminal(`${String(kind)} ${String(identity)}${declaration === identity ? '' : ` (${String(declaration)})`}`)}\n`).join('');
+}
+// A successful up, sleep, down or preflight printed nothing in human mode, so a person could not
+// tell success from a command that never ran. One line says what happened; anything outside the
+// known result shape prints nothing rather than a guess.
+function lifecycleSummary(command, result) {
+    if (command === 'preflight') {
+        if (typeof result.verdict !== 'string' || !Array.isArray(result.checks))
+            return '';
+        const counts = new Map();
+        for (const check of result.checks) {
+            const verdict = String(check?.verdict).replaceAll('-', ' ');
+            counts.set(verdict, (counts.get(verdict) ?? 0) + 1);
+        }
+        const tally = [...counts].map(([verdict, count]) => `${count} ${verdict === 'pass' ? count === 1 ? 'check passes' : 'checks pass' : verdict}`);
+        return escapeForTerminal(`Preflight ${result.verdict === 'pass' ? 'passed' : result.verdict}: ${tally.join(', ') || 'no checks'}.`) + '\n';
+    }
+    // A plain reset only previews; printing nothing left a person unable to tell an empty plan from
+    // one that would delete their data volume.
+    if (command === 'reset' && typeof result.planDigest === 'string' && Array.isArray(result.targets)) {
+        if (typeof result.stackId !== 'string')
+            return '';
+        const targets = result.targets;
+        if (targets.length === 0)
+            return `${escapeForTerminal(`Nothing to reset (${result.stackId}).`)}\n`;
+        return `${escapeForTerminal(`Reset would remove ${targets.length} ${targets.length === 1 ? 'target' : 'targets'} (${result.stackId}); plan ${result.planDigest}:`)}\n`
+            + `${resetTargetLines(targets)}Nothing was changed. To apply this plan, run the same command with --interactive and approve it.\n`;
+    }
+    // An applied reset printed nothing, so a person could not tell that their data was gone.
+    if (command === 'reset' && result.change === 'reset' && Array.isArray(result.targets)) {
+        if (typeof result.stackId !== 'string')
+            return '';
+        const targets = result.targets;
+        return `${escapeForTerminal(`Reset removed ${targets.length} ${targets.length === 1 ? 'target' : 'targets'} (${result.stackId}):`)}\n`
+            + resetTargetLines(targets)
+            + 'The next up recreates the removed volumes and, where environment.seed is declared, runs the seed to fill them.\n';
+    }
+    const headline = Object.hasOwn(LIFECYCLE_CHANGES, command) && typeof result.change === 'string'
+        && Object.hasOwn(LIFECYCLE_CHANGES[command], result.change) ? LIFECYCLE_CHANGES[command][result.change] : undefined;
+    if (headline === undefined || typeof result.stackId !== 'string')
+        return '';
+    const cold = result.coldStart;
+    const timing = typeof cold?.measuredMillis === 'number' && typeof cold.limitMillis === 'number'
+        ? `; cold start ${(cold.measuredMillis / 1000).toFixed(1)}s of the ${Math.round(cold.limitMillis / 1000)}s limit` : '';
+    const entrypoints = Array.isArray(result.entrypoints) ? result.entrypoints
+        .filter(({ name, value }) => typeof name === 'string' && typeof value === 'string')
+        .map(({ name, value }) => `  ${escapeForTerminal(String(name))}: ${escapeForTerminal(String(value))}\n`) : [];
+    return `${escapeForTerminal(`${headline} (${result.stackId})${timing}.`)}\n${entrypoints.join('')}`;
+}
+function plural(count, one, many = `${one}s`) {
+    return `${count} ${count === 1 ? one : many}`;
+}
+// Doctor's full result is a structured report for scripts; printed whole it buried the findings
+// under thousands of lines. A person gets one line per area and the commands that show the detail.
+function doctorSummary(result, diagnostics, fixContext) {
+    if (typeof result.verdict !== 'string' || !Array.isArray(result.checks))
+        return renderHumanValue(result);
+    const lines = [];
+    const errors = diagnostics.filter(({ severity }) => severity === 'error').length;
+    const warnings = diagnostics.filter(({ severity }) => severity === 'warning').length;
+    const findings = [errors > 0 ? plural(errors, 'error') : '', warnings > 0 ? plural(warnings, 'warning') : ''].filter(Boolean);
+    lines.push(`Doctor: ${result.verdict}. ${findings.length === 0 ? 'No findings.' : `Findings: ${findings.join(' and ')}, listed below.`}`);
+    const tally = new Map();
+    for (const check of result.checks) {
+        const verdict = String(check?.verdict).replaceAll('-', ' ');
+        tally.set(verdict, (tally.get(verdict) ?? 0) + 1);
+    }
+    lines.push(`Checks: ${[...tally].map(([verdict, count]) => `${count} ${verdict}`).join(', ') || 'none ran'}.`);
+    if (Array.isArray(result.comparisons) && result.comparisons.length > 0)
+        lines.push(`Remote comparisons: ${result.comparisons.length}.`);
+    const freshness = result.freshness;
+    if (freshness?.local) {
+        const changes = Array.isArray(freshness.changes) ? freshness.changes.length : 0;
+        const refused = freshness.local.kind !== 'complete' && Array.isArray(freshness.local.diagnostics)
+            ? freshness.local.diagnostics.map(({ code }) => String(code)) : [];
+        lines.push(`Generated files: ${refused.length > 0 ? `check refused (${refused.join(', ')})`
+            : changes === 0 ? 'current' : `${plural(changes, 'change')} pending`}.`);
+    }
+    const overrides = result.surfaceOverrides;
+    if (overrides?.kind === 'complete' && Array.isArray(overrides.activeOverrides) && Array.isArray(overrides.changedOverrideOriginals)) {
+        const active = overrides.activeOverrides.map(({ name }) => String(name));
+        const changed = overrides.changedOverrideOriginals.map(({ name }) => String(name));
+        lines.push(`Surface overrides: ${active.length === 0 ? 'none' : `${active.length} active (${active.join(', ')})`}`
+            + `${changed.length === 0 ? '' : `; ${changed.length} changed upstream (${changed.join(', ')})`}.`);
+    }
+    else if (overrides)
+        lines.push(`Surface overrides: not inspected (${String(overrides.code)}).`);
+    if (Array.isArray(result.declarations) && result.declarations.length > 0) {
+        const rows = result.declarations;
+        const named = (state) => rows.filter(row => row.state === state).map(row => String(row.subject).replaceAll('-', ' '));
+        const declared = named('declared');
+        const absent = named('not-declared');
+        lines.push(`Declared: ${declared.join(', ') || 'nothing'}${absent.length === 0 ? '' : `; not declared: ${absent.join(', ')}`}.`);
+    }
+    const readiness = result.readiness;
+    if (readiness && Array.isArray(readiness.gaps)) {
+        const gaps = readiness.gaps;
+        const clear = Array.isArray(readiness.noFinding) ? readiness.noFinding.length : 0;
+        lines.push(`Readiness: ${gaps.length === 0 ? 'no gaps' : plural(gaps.length, 'gap')}; ${plural(clear, 'other prerequisite')} with no finding.`);
+        for (const gap of gaps) {
+            const codes = Array.isArray(gap.findings) ? [...new Set(gap.findings.map(({ code }) => String(code)))] : [];
+            lines.push(`  ${String(gap.level)} ${String(gap.id)}: ${String(gap.needs)} (${codes.join(', ')})`);
+        }
+    }
+    const release = freshness?.release;
+    if (release?.kind === 'known') {
+        lines.push(`Release: ${release.currency === 'same-version' ? `${String(release.installedVersion)} is the latest`
+            : `${String(release.latestVersion)} is published; ${String(release.installedVersion)} is installed`}.`);
+    }
+    else if (release?.kind === 'unknown')
+        lines.push(`Release: unknown (${String(release.reason)}).`);
+    lines.push(`Full report: ${bindConfigPath(cockpitCommand('doctor', { args: '--json' }), fixContext)}`);
+    lines.push(`Generated file detail: ${bindConfigPath(cockpitCommand('check'), fixContext)}`);
+    return `${lines.map(escapeForTerminal).join('\n')}\n`;
+}
+export function renderHumanDiagnostics(diagnostics, review, fixContext, usageHint) {
+    if (review) {
+        const { command, outcome } = review;
+        if (outcome.result === null || typeof outcome.result !== 'object')
+            return '';
+        // Work, grade, browser and test commands return their whole result as the answer, and an unmet gate,
+        // grade or step returns one with a failing status: the person needs that evidence either way.
+        if (command !== undefined && /^(?:(?:work|browser) |test-run$|grade$)/.test(command))
+            return renderHumanValue(outcome.result);
+        if (outcome.status !== 0)
+            return '';
+        if (command === 'sync' && 'dryRun' in outcome.result && outcome.result.dryRun === true
+            && 'changes' in outcome.result && Array.isArray(outcome.result.changes)) {
+            const changes = outcome.result.changes;
+            if (!changes.every((change) => change && (change.operation === 'write' || change.operation === 'remove')
+                && typeof change.path === 'string'))
+                return '';
+            const stale = 'staleRemoval' in outcome.result ? outcome.result.staleRemoval : undefined;
+            const approval = typeof stale?.digest === 'string' && /^[a-f0-9]{64}$/.test(stale.digest)
+                ? `${escapeForTerminal(`Stale-removal digest ${stale.digest}: to approve these removals, a person runs `
+                    + `${bindConfigPath(cockpitCommand('sync', { args: '--interactive' }), fixContext)} in a terminal and types it.`)}\n` : '';
+            return (changes.length === 0 ? 'No generated changes.\n'
+                : `${changes.map((change) => `${change.operation} ${terminalSafeJson(change.path)}`).join('\n')}\n`) + approval;
+        }
+        if (command === 'logs' && 'records' in outcome.result && Array.isArray(outcome.result.records)) {
+            const records = outcome.result.records;
+            return records.length === 0 ? 'No log records.\n'
+                : `${records.map(record => escapeForTerminal(`${String(record.timestamp)} ${String(record.stream)} ${String(record.message)}`)).join('\n')}\n`;
+        }
+        if (command === 'doctor') {
+            return doctorSummary(outcome.result, outcome.diagnostics ?? [], fixContext);
+        }
+        if (command === 'selftest' || command === 'upgrade' || command === 'init') {
+            return renderHumanValue(outcome.result);
+        }
+        return command === undefined ? '' : lifecycleSummary(command, outcome.result);
+    }
+    if (diagnostics.length === 0)
+        return '';
+    const projected = projectDiagnostics(diagnostics, fixContext);
+    const hint = usageHint !== undefined && diagnostics.some(({ code }) => USAGE_ERROR_CODE.test(code)) ? usageHint : '';
+    return `${projected.diagnostics
+        .map((diagnostic) => {
+        const target = diagnostic.target ? ` [${escapeForTerminal(diagnostic.target)}]` : '';
+        const guidance = projected.guidance.filter(row => row.code === diagnostic.code && row.target === diagnostic.target);
+        const common = Object.prototype.hasOwnProperty.call(COMMON_REFUSAL_GUIDANCE, diagnostic.code)
+            ? COMMON_REFUSAL_GUIDANCE[diagnostic.code]
+            : undefined;
+        if (common) {
+            const fix = diagnostic.fix ?? guidance[0]?.text ?? bindConfigPath(common.fix, fixContext);
+            return `${diagnostic.severity.toUpperCase()} ${escapeForTerminal(diagnostic.code)}${target}\n`
+                + `What failed: ${escapeForTerminal(diagnostic.message)}\n`
+                + `Why it matters: ${escapeForTerminal(common.why)}\n`
+                + `Fix: ${escapeForTerminal(fix)}`;
+        }
+        const fix = diagnostic.fix ? ` Fix: ${escapeForTerminal(diagnostic.fix)}` : '';
+        const renderedGuidance = guidance.map(row => ` Guidance: ${escapeForTerminal(row.text)}`).join('');
+        return `${diagnostic.severity.toUpperCase()} ${escapeForTerminal(diagnostic.code)}${target}: ${escapeForTerminal(diagnostic.message)}${fix}${renderedGuidance}`;
+    })
+        .join('\n')}\n${hint}`;
+}
+export function renderJsonResponse(outcome, fixContext) {
+    const { result, diagnostics, evidence, progress, invocation } = outcome;
+    const projected = projectDiagnostics(diagnostics, fixContext);
+    return `${terminalSafeJson({ result, diagnostics: projected.diagnostics,
+        ...(projected.guidance.length === 0 ? {} : { guidance: projected.guidance }), ...(evidence === undefined ? {} : { evidence }),
+        ...(progress === undefined ? {} : { progress }), ...(invocation === undefined ? {} : { invocation }) })}\n`;
+}

package/dist/emit.d.ts

@@ -0,0 +1,22 @@
+import type { CockpitConfig } from './schema.js';
+import type { DocumentedSibling, Gap } from './registry-resolve/registry.js';
+/**
+ * Render a config as `cockpit.toml`.
+ *
+ * The round trip this closes is the acceptance test for the whole schema: a registry read
+ * out of an existing harness, emitted here, and parsed back must mean the same thing. Until
+ * this existed the "round trip" stopped at an in-memory object, which proves the parser
+ * agrees with itself and nothing else.
+ */
+export declare function emitToml(config: CockpitConfig): string;
+/**
+ * Render the gaps a registry draft could not answer, as commented TOML.
+ *
+ * Deliberately emitted as comments rather than placeholder values: a placeholder is a value,
+ * and a value is indistinguishable from an answer the moment the file is read by anything
+ * other than the person who generated it. A blocking gap keeps the config invalid on
+ * purpose, so the schema refuses it until a human writes the real answer.
+ */
+export declare function emitGaps(gaps: readonly Gap[]): string;
+/** The sibling rows as the schema wants them, dropping fields the source did not carry. */
+export declare function toSiblingRows(siblings: readonly DocumentedSibling[]): Record<string, unknown>[];

package/dist/emit.js

@@ -0,0 +1,43 @@
+import { stringify } from 'smol-toml';
+/**
+ * Render a config as `cockpit.toml`.
+ *
+ * The round trip this closes is the acceptance test for the whole schema: a registry read
+ * out of an existing harness, emitted here, and parsed back must mean the same thing. Until
+ * this existed the "round trip" stopped at an in-memory object, which proves the parser
+ * agrees with itself and nothing else.
+ */
+export function emitToml(config) {
+    return stringify(config);
+}
+/**
+ * Render the gaps a registry draft could not answer, as commented TOML.
+ *
+ * Deliberately emitted as comments rather than placeholder values: a placeholder is a value,
+ * and a value is indistinguishable from an answer the moment the file is read by anything
+ * other than the person who generated it. A blocking gap keeps the config invalid on
+ * purpose, so the schema refuses it until a human writes the real answer.
+ */
+export function emitGaps(gaps) {
+    if (gaps.length === 0)
+        return '';
+    const lines = ['# Gaps — cockpit could not read these from its sources.', '#'];
+    for (const g of gaps) {
+        const mark = g.blocking ? 'REQUIRED' : 'optional';
+        lines.push(`# [${mark}] ${g.slug}.${g.field}: ${g.why}`);
+    }
+    return lines.join('\n') + '\n';
+}
+/** The sibling rows as the schema wants them, dropping fields the source did not carry. */
+export function toSiblingRows(siblings) {
+    return siblings.map((s) => ({
+        slug: s.slug,
+        dir: s.dir,
+        ...(s.remote ? { remote: s.remote } : {}),
+        ...(s.branch ? { branch: s.branch } : {}),
+        mount: s.mount.value,
+        acquire: s.acquire.value,
+        var: s.var,
+        purpose: s.purpose,
+    }));
+}

package/dist/entrypoint-kinds.d.ts

@@ -0,0 +1,3 @@
+export declare const ENTRYPOINT_KINDS: readonly ["entrypoint", "origin", "callback_url", "advertised_listener", "cors_origin", "public_base_url"];
+export type EntrypointKind = (typeof ENTRYPOINT_KINDS)[number];
+export declare function isEntrypointKind(value: unknown): value is EntrypointKind;

package/dist/entrypoint-kinds.js

@@ -0,0 +1,11 @@
+export const ENTRYPOINT_KINDS = Object.freeze([
+    'entrypoint',
+    'origin',
+    'callback_url',
+    'advertised_listener',
+    'cors_origin',
+    'public_base_url',
+]);
+export function isEntrypointKind(value) {
+    return typeof value === 'string' && ENTRYPOINT_KINDS.includes(value);
+}

package/dist/environment/application/destructive.d.ts

@@ -0,0 +1,6 @@
+import { type DownCommandAdapters, type DownCommandInput, type DownCommandResult, type OperatorResetSession, type ResetCommandAdapters, type ResetCommandInput, type ResetCommandResult } from './lifecycle-context.js';
+export declare function runDown(input: DownCommandInput, adapters: DownCommandAdapters): Promise<DownCommandResult>;
+export declare function runReset(input: ResetCommandInput, adapters: ResetCommandAdapters): Promise<ResetCommandResult>;
+export declare function beginOperatorReset(input: ResetCommandInput, adapters: ResetCommandAdapters): Promise<OperatorResetSession | Extract<ResetCommandResult, {
+    kind: 'refusal';
+}>>;