@astrale-os/sdk 0.6.0-beta.13 → 0.6.0-beta.15

package/dist/tooling/cli/development/develop.js

@@ -1,243 +0,0 @@
-import { rm, rmdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { resolveAstraleInstanceIssuer } from '../astrale/instance.js';
-import { resolveCompatibleAstrale } from '../astrale/version.js';
-import { loadPrivateCredentialFile } from '../credential.js';
-import { deprecationWarnings } from '../deprecations.js';
-import { loadPrivateSecretsFile } from '../dotenv.js';
-import { error, info, warn } from '../log.js';
-import { DevelopmentCandidateBuilder, discoverRuntimePath, sameDeploymentCandidate, sameEnvironment, } from './candidate.js';
-import { deployDevelopmentCandidate } from './deployment.js';
-import { DevelopmentLifecycle } from './lifecycle.js';
-import { acquireProjectLock } from './project-lock.js';
-import { LatestRebuild } from './rebuild.js';
-import { developmentReleaseEvidence } from './release-evidence.js';
-import { reportDevelopmentDeployment } from './report.js';
-import { DevelopmentSessionFileWriter } from './session-file.js';
-import { watchSources } from './source-watch.js';
-import { acquireDevelopmentTargetLock } from './target-lock.js';
-import { DevelopmentView } from './view.js';
-/** Watch one Project Environment and serialize complete remote deployment generations. */
-export async function develop(input) {
-    const lifecycle = new DevelopmentLifecycle();
-    let sessionFile;
-    let lock;
-    let targetLock;
-    let view;
-    let installationExecutable;
-    let installationIssuer;
-    let sourceWatch;
-    let rebuild;
-    let current;
-    let lastEvidence;
-    let failure;
-    const cleanup = [];
-    try {
-        if (input.sessionFile !== undefined) {
-            sessionFile = await DevelopmentSessionFileWriter.create(input.sessionFile);
-        }
-        lock = await acquireProjectLock({
-            projectRoot: input.projectDir,
-            environment: input.environment,
-        });
-        const overrideSecrets = input.secretsFile === undefined
-            ? undefined
-            : Object.freeze(loadPrivateSecretsFile(input.secretsFile));
-        const credential = input.credentialFile === undefined
-            ? undefined
-            : loadPrivateCredentialFile(input.credentialFile);
-        const runtimePath = await discoverRuntimePath(input.configPath);
-        const builder = new DevelopmentCandidateBuilder({
-            ...input,
-            runtimePath,
-            overrideSecrets,
-        });
-        current = await builder.prepare(lifecycle.signal);
-        if (credential !== undefined && current.installation?.identity !== undefined) {
-            throw new TypeError('--credential-file cannot be combined with the Environment installation identity.');
-        }
-        if (sessionFile !== undefined && (current.installation === undefined || input.deployOnly)) {
-            throw new TypeError('--session-file requires an Environment installation that is active for this development session.');
-        }
-        info(`Domain: ${current.artifact.build.schema.compiled.root.origin}`);
-        for (const warning of deprecationWarnings(current.artifact.build))
-            warn(warning);
-        if (current.installation !== undefined && !input.deployOnly) {
-            installationExecutable = await resolveCompatibleAstrale({
-                projectDir: input.projectDir,
-                signal: lifecycle.signal,
-            });
-            installationIssuer = await resolveAstraleInstanceIssuer({
-                executable: installationExecutable,
-                projectDir: input.projectDir,
-                instance: current.installation.instance,
-                signal: lifecycle.signal,
-            });
-            targetLock = await acquireDevelopmentTargetLock({
-                issuer: installationIssuer,
-                origin: current.artifact.build.schema.compiled.root.origin,
-            });
-            view = new DevelopmentView({
-                executable: installationExecutable,
-                projectDir: input.projectDir,
-                instance: current.installation.instance,
-                ...(credential === undefined
-                    ? { identity: input.identity ?? current.installation.identity }
-                    : { credential }),
-            });
-            if (current.artifact.build.frontend !== undefined)
-                await view.prepare(lifecycle.signal);
-        }
-        const first = await deployDevelopmentCandidate(current, { ...input, credential, installationExecutable }, lifecycle.signal);
-        lastEvidence =
-            first.installation === undefined ? undefined : developmentReleaseEvidence(first.installation);
-        await sessionFile?.transition('ready', lastEvidence);
-        reportDevelopmentDeployment(first.deployment, first.installation, current.adapter, input);
-        await refreshView(view, first.deployment.release, lifecycle.signal);
-        let restartReported = false;
-        rebuild = new LatestRebuild({
-            async prepare(_ignored, signal) {
-                info(`Rebuilding: ${input.environment}`);
-                if (lastEvidence !== undefined)
-                    await sessionFile?.transition('updating', lastEvidence);
-                return builder.prepare(signal);
-            },
-            async commit(candidate, signal) {
-                if (!sameEnvironment(current, candidate)) {
-                    restartReported = true;
-                    throw new Error('Project Environment configuration changed; restart pnpm dev to apply it.');
-                }
-                if (sameDeploymentCandidate(current, candidate)) {
-                    current = candidate;
-                    await sessionFile?.transition('ready', lastEvidence);
-                    sourceWatch?.update(candidate.sources);
-                    return;
-                }
-                if (installationIssuer !== undefined && candidate.installation !== undefined) {
-                    await resolveAstraleInstanceIssuer({
-                        executable: installationExecutable,
-                        projectDir: input.projectDir,
-                        instance: candidate.installation.instance,
-                        expectedIssuer: installationIssuer,
-                        signal,
-                    });
-                }
-                if (candidate.artifact.build.frontend !== undefined)
-                    await view?.prepare(signal);
-                const deployed = await deployDevelopmentCandidate(candidate, { ...input, credential, installationExecutable }, signal);
-                current = candidate;
-                lastEvidence =
-                    deployed.installation === undefined
-                        ? undefined
-                        : developmentReleaseEvidence(deployed.installation);
-                await sessionFile?.transition('ready', lastEvidence);
-                sourceWatch?.update(candidate.sources);
-                info(`Updated: ${candidate.artifact.build.schema.compiled.root.revision}`);
-                reportDevelopmentDeployment(deployed.deployment, deployed.installation, candidate.adapter, input);
-                await refreshView(view, deployed.deployment.release, signal);
-            },
-            async failed(cause) {
-                error(cause instanceof Error ? cause.message : String(cause));
-                if (lastEvidence === undefined)
-                    return;
-                try {
-                    await sessionFile?.transition('recovering', lastEvidence);
-                }
-                catch (sessionCause) {
-                    const terminal = new AggregateError([cause, sessionCause], 'Development rebuild failed and session evidence could not be recovered.');
-                    failure ??= terminal;
-                    lifecycle.stop(terminal);
-                }
-            },
-        });
-        sourceWatch = watchSources({
-            projectDir: input.projectDir,
-            configPath: input.configPath,
-            sources: current.sources,
-            onInvalidate: () => rebuild.invalidate(),
-            onRestartRequired: () => {
-                if (restartReported)
-                    return;
-                restartReported = true;
-                error('Project Environment configuration changed; restart pnpm dev to apply it.');
-            },
-            onError: (cause) => {
-                failure = cause;
-                lifecycle.stop(cause);
-            },
-        });
-        info('Ready: watching for remote deployments');
-        // Edits made while the first build/deployment was in flight predate this watcher.
-        // Catch up once; artifact deduplication prevents an unchanged second deployment.
-        rebuild.invalidate();
-        await lifecycle.stopped;
-    }
-    catch (cause) {
-        failure = cause;
-    }
-    lifecycle.stop(failure);
-    try {
-        await sessionFile?.transition('stopping', lastEvidence);
-    }
-    catch (cause) {
-        failure ??= cause;
-    }
-    for (const operation of [
-        () => sourceWatch?.stop(),
-        () => rebuild?.stop(failure),
-        () => view?.close(AbortSignal.timeout(30_000)),
-        () => rm(join(input.projectDir, '.astrale', 'development', input.environment, 'source'), {
-            recursive: true,
-            force: true,
-        }),
-        () => targetLock?.release(),
-        () => lock?.release(),
-    ]) {
-        try {
-            await operation();
-        }
-        catch (cause) {
-            cleanup.push(cause);
-        }
-    }
-    for (const directory of [
-        join(input.projectDir, '.astrale', 'development', input.environment),
-        join(input.projectDir, '.astrale', 'development'),
-    ]) {
-        try {
-            await rmdir(directory);
-        }
-        catch (cause) {
-            const code = cause.code;
-            if (code !== 'ENOENT' && code !== 'ENOTEMPTY' && code !== 'EEXIST')
-                cleanup.push(cause);
-        }
-    }
-    try {
-        await sessionFile?.transition(failure === undefined && cleanup.length === 0 ? 'stopped' : 'failed');
-    }
-    catch (cause) {
-        cleanup.push(cause);
-    }
-    lifecycle.dispose();
-    if (failure !== undefined) {
-        if (cleanup.length > 0)
-            error(new AggregateError(cleanup, 'Development cleanup failed.').message);
-        throw failure;
-    }
-    if (cleanup.length > 0)
-        throw new AggregateError(cleanup, 'Development cleanup failed.');
-    return 0;
-}
-async function refreshView(view, release, signal) {
-    if (view === undefined)
-        return;
-    try {
-        const pageUrl = await view.refresh(release, signal);
-        if (pageUrl !== undefined)
-            info(`View: ${pageUrl}`);
-    }
-    catch (cause) {
-        error(`View unavailable: ${cause instanceof Error ? cause.message : String(cause)}`);
-    }
-}

package/dist/tooling/cli/development/release-evidence.d.ts

@@ -1,4 +0,0 @@
-import type { InstallationEvidence } from '../installation/index.js';
-import type { DevelopmentSessionReleaseEvidenceV1 } from './session-file.js';
-/** Project installed evidence projected into the stable development-session representation. */
-export declare function developmentReleaseEvidence(installation: InstallationEvidence): DevelopmentSessionReleaseEvidenceV1;

package/dist/tooling/cli/development/release-evidence.js

@@ -1,10 +0,0 @@
-/** Project installed evidence projected into the stable development-session representation. */
-export function developmentReleaseEvidence(installation) {
-    return Object.freeze({
-        origin: installation.origin,
-        revision: installation.revision,
-        issuer: installation.issuer,
-        etag: installation.etag,
-        generation: installation.generation,
-    });
-}

package/dist/tooling/cli/development/report.d.ts

@@ -1,9 +0,0 @@
-import type { ReadyDeployResult } from '../../../deployment/adapter/index.js';
-import type { InstallationEvidence } from '../installation/index.js';
-export declare function reportDevelopmentDeployment(deployed: ReadyDeployResult, installation: InstallationEvidence | undefined, adapter: {
-    readonly name: string;
-    readonly version: string;
-}, input: {
-    readonly environment: string;
-    readonly deployOnly: boolean;
-}): void;

package/dist/tooling/cli/development/session-file.d.ts

@@ -1,53 +0,0 @@
-export declare const DEVELOPMENT_SESSION_FILE_VERSION: 1;
-export type DevelopmentSessionPhaseV1 = 'starting' | 'ready' | 'updating' | 'recovering' | 'stopping' | 'stopped' | 'failed';
-export interface DevelopmentSessionProjectV1 {
-    readonly origin: string;
-}
-export interface DevelopmentSessionReleaseV1 {
-    readonly revision: string;
-    readonly issuer: string;
-    readonly etag: string;
-    readonly generation: string;
-}
-interface DevelopmentSessionFileBaseV1 {
-    readonly version: typeof DEVELOPMENT_SESSION_FILE_VERSION;
-    readonly sessionId: string;
-    readonly sequence: number;
-    readonly phase: DevelopmentSessionPhaseV1;
-}
-interface DevelopmentSessionStartingFileV1 extends DevelopmentSessionFileBaseV1 {
-    readonly phase: 'starting';
-}
-interface DevelopmentSessionActiveFileV1 extends DevelopmentSessionFileBaseV1 {
-    readonly phase: 'ready' | 'updating' | 'recovering';
-    readonly project: DevelopmentSessionProjectV1;
-    readonly release: DevelopmentSessionReleaseV1;
-}
-interface DevelopmentSessionTerminalFileBaseV1 extends DevelopmentSessionFileBaseV1 {
-    readonly phase: 'stopping' | 'stopped' | 'failed';
-}
-type DevelopmentSessionTerminalFileV1 = DevelopmentSessionTerminalFileBaseV1 & ({
-    readonly project: DevelopmentSessionProjectV1;
-    readonly release: DevelopmentSessionReleaseV1;
-} | {
-    readonly project?: never;
-    readonly release?: never;
-});
-export type DevelopmentSessionFileV1 = DevelopmentSessionStartingFileV1 | DevelopmentSessionActiveFileV1 | DevelopmentSessionTerminalFileV1;
-export interface DevelopmentSessionReleaseEvidenceV1 extends DevelopmentSessionProjectV1, DevelopmentSessionReleaseV1 {
-}
-export declare class DevelopmentSessionFileError extends Error {
-    readonly code: 'INVALID_SESSION_FILE_PATH' | 'SESSION_FILE_PATH_UNSAFE' | 'SESSION_FILE_EXISTS' | 'SESSION_FILE_TAMPERED' | 'SESSION_FILE_TRANSITION_INVALID' | 'SESSION_FILE_EVIDENCE_INCOHERENT';
-    readonly name = "DevelopmentSessionFileError";
-    constructor(code: 'INVALID_SESSION_FILE_PATH' | 'SESSION_FILE_PATH_UNSAFE' | 'SESSION_FILE_EXISTS' | 'SESSION_FILE_TAMPERED' | 'SESSION_FILE_TRANSITION_INVALID' | 'SESSION_FILE_EVIDENCE_INCOHERENT', message: string, options?: ErrorOptions);
-}
-export declare function acceptDevelopmentSessionFileV1(input: unknown): DevelopmentSessionFileV1;
-/** SDK-private sole writer for one caller-selected machine-integration file. */
-export declare class DevelopmentSessionFileWriter {
-    #private;
-    private constructor();
-    static create(path: string): Promise<DevelopmentSessionFileWriter>;
-    transition(phase: Exclude<DevelopmentSessionPhaseV1, 'starting'>, evidence?: DevelopmentSessionReleaseEvidenceV1): Promise<DevelopmentSessionFileV1>;
-}
-export declare function developmentSessionTransitionAllowed(previous: DevelopmentSessionPhaseV1, next: Exclude<DevelopmentSessionPhaseV1, 'starting'>): boolean;
-export {};

package/dist/tooling/cli/development/session-file.js

@@ -1,337 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { link, lstat, open, readFile, realpath, rename, unlink } from 'node:fs/promises';
-import { basename, dirname, isAbsolute, join, normalize, parse, sep } from 'node:path';
-import { patterns } from '../../../platform/schema/index.js';
-export const DEVELOPMENT_SESSION_FILE_VERSION = 1;
-export class DevelopmentSessionFileError extends Error {
-    code;
-    name = 'DevelopmentSessionFileError';
-    constructor(code, message, options) {
-        super(message, options);
-        this.code = code;
-    }
-}
-export function acceptDevelopmentSessionFileV1(input) {
-    const value = record(input, 'Development session file');
-    if (value.metadata !== undefined ||
-        value.extensions !== undefined ||
-        value.vendor !== undefined) {
-        invalid('Development session file cannot contain a metadata, extensions, or vendor bag.');
-    }
-    if (value.version !== DEVELOPMENT_SESSION_FILE_VERSION) {
-        invalid(`Unsupported development session file version: ${String(value.version)}.`);
-    }
-    const sessionId = text(value.sessionId, 'Development session id');
-    const sequence = integer(value.sequence, 'Development session sequence');
-    const phase = admitPhase(value.phase);
-    const base = Object.freeze({ version: 1, sessionId, sequence, phase });
-    const hasProject = value.project !== undefined;
-    const hasRelease = value.release !== undefined;
-    if (phase === 'starting') {
-        if (hasProject || hasRelease) {
-            invalid('Development session starting phase cannot contain Release evidence.');
-        }
-        return Object.freeze({ ...base, phase: 'starting' });
-    }
-    if (phase === 'ready' || phase === 'updating' || phase === 'recovering') {
-        if (!hasProject || !hasRelease)
-            invalid(`Development session phase ${phase} requires a Release.`);
-        return Object.freeze({
-            ...base,
-            phase,
-            project: project(value.project),
-            release: release(value.release),
-        });
-    }
-    if (hasProject !== hasRelease) {
-        invalid('Development session terminal project and Release must be present together.');
-    }
-    if (!hasProject)
-        return Object.freeze({ ...base, phase });
-    return Object.freeze({
-        ...base,
-        phase,
-        project: project(value.project),
-        release: release(value.release),
-    });
-}
-/** SDK-private sole writer for one caller-selected machine-integration file. */
-export class DevelopmentSessionFileWriter {
-    #path;
-    #parent;
-    #sessionId;
-    #sequence = 0;
-    #phase = 'starting';
-    #last;
-    #tail = Promise.resolve();
-    constructor(path, parent, sessionId) {
-        this.#path = path;
-        this.#parent = parent;
-        this.#sessionId = sessionId;
-    }
-    static async create(path) {
-        const admitted = await admitSessionFilePath(path);
-        const writer = new DevelopmentSessionFileWriter(admitted.path, admitted.parent, randomUUID());
-        await writer.#create();
-        return writer;
-    }
-    transition(phase, evidence) {
-        const operation = this.#tail.then(async () => {
-            if (!developmentSessionTransitionAllowed(this.#phase, phase)) {
-                throw new DevelopmentSessionFileError('SESSION_FILE_TRANSITION_INVALID', `Development session cannot transition from ${this.#phase} to ${phase}.`);
-            }
-            if (evidence !== undefined)
-                this.#last = admitEvidence(evidence);
-            if (['ready', 'updating', 'recovering'].includes(phase) && this.#last === undefined) {
-                throw new TypeError(`Development session phase ${phase} requires Release evidence.`);
-            }
-            const snapshot = this.#snapshot(phase, this.#sequence + 1);
-            await this.#replace(snapshot);
-            this.#sequence = snapshot.sequence;
-            this.#phase = snapshot.phase;
-            return snapshot;
-        });
-        this.#tail = operation.then(() => undefined, () => undefined);
-        return operation;
-    }
-    async #create() {
-        const snapshot = this.#snapshot('starting', 1);
-        const staging = await writeStaging(this.#parent, this.#path, this.#sessionId, snapshot);
-        try {
-            await link(staging, this.#path);
-        }
-        catch (cause) {
-            if (errorCode(cause) === 'EEXIST') {
-                throw new DevelopmentSessionFileError('SESSION_FILE_EXISTS', `Development session file already exists: ${this.#path}`, { cause });
-            }
-            throw cause;
-        }
-        finally {
-            await unlink(staging).catch((cause) => {
-                if (errorCode(cause) !== 'ENOENT')
-                    throw cause;
-            });
-        }
-        await syncDirectory(this.#parent);
-        this.#sequence = snapshot.sequence;
-    }
-    #snapshot(phase, sequence) {
-        const base = {
-            version: DEVELOPMENT_SESSION_FILE_VERSION,
-            sessionId: this.#sessionId,
-            sequence,
-        };
-        if (phase === 'starting')
-            return Object.freeze({ ...base, phase: 'starting' });
-        if (this.#last === undefined) {
-            if (phase === 'ready' || phase === 'updating' || phase === 'recovering') {
-                throw new TypeError(`Development session phase ${phase} requires Release evidence.`);
-            }
-            return Object.freeze({ ...base, phase });
-        }
-        return Object.freeze({
-            ...base,
-            phase,
-            project: Object.freeze({ origin: this.#last.origin }),
-            release: Object.freeze({
-                revision: this.#last.revision,
-                issuer: this.#last.issuer,
-                etag: this.#last.etag,
-                generation: this.#last.generation,
-            }),
-        });
-    }
-    async #replace(snapshot) {
-        await assertParent(this.#parent);
-        const current = await readCurrent(this.#path);
-        if (current.sessionId !== this.#sessionId || current.sequence !== snapshot.sequence - 1) {
-            throw new DevelopmentSessionFileError('SESSION_FILE_TAMPERED', `Development session file ownership changed: ${this.#path}`);
-        }
-        const staging = await writeStaging(this.#parent, this.#path, this.#sessionId, snapshot);
-        try {
-            await rename(staging, this.#path);
-            await syncDirectory(this.#parent);
-        }
-        finally {
-            await unlink(staging).catch((cause) => {
-                if (errorCode(cause) !== 'ENOENT')
-                    throw cause;
-            });
-        }
-    }
-}
-function admitEvidence(input) {
-    const admittedProject = project({ origin: input.origin });
-    const admittedRelease = release(input);
-    return Object.freeze({ origin: admittedProject.origin, ...admittedRelease });
-}
-async function admitSessionFilePath(input) {
-    if (!isAbsolute(input) || normalize(input) !== input || basename(input).length === 0) {
-        throw new DevelopmentSessionFileError('INVALID_SESSION_FILE_PATH', '--session-file requires one normalized absolute file path.');
-    }
-    const parent = dirname(input);
-    await assertParent(parent);
-    try {
-        await lstat(input);
-        throw new DevelopmentSessionFileError('SESSION_FILE_EXISTS', `Development session file path must not exist: ${input}`);
-    }
-    catch (cause) {
-        if (errorCode(cause) !== 'ENOENT')
-            throw cause;
-    }
-    return Object.freeze({ path: input, parent });
-}
-async function assertParent(parent) {
-    const root = parse(parent).root;
-    let cursor = root;
-    for (const segment of parent.slice(root.length).split(sep).filter(Boolean)) {
-        cursor = join(cursor, segment);
-        const entry = await lstat(cursor);
-        if (entry.isSymbolicLink())
-            unsafe(`Development session file path crosses a symlink: ${cursor}`);
-    }
-    const canonical = await realpath(parent);
-    if (canonical !== parent)
-        unsafe(`Development session file parent is not canonical: ${parent}`);
-    const entry = await lstat(parent);
-    if (!entry.isDirectory())
-        unsafe(`Development session file parent is not a directory: ${parent}`);
-    const uid = process.getuid?.();
-    if (uid !== undefined && entry.uid !== uid) {
-        unsafe(`Development session file parent is not owned by the current user: ${parent}`);
-    }
-    if ((entry.mode & 0o077) !== 0) {
-        unsafe(`Development session file parent must be owner-only: ${parent}`);
-    }
-}
-async function writeStaging(parent, target, sessionId, snapshot) {
-    const path = join(parent, `.${basename(target)}.${sessionId}.${randomUUID()}.next`);
-    const file = await open(path, 'wx', 0o600);
-    try {
-        await file.writeFile(`${JSON.stringify(snapshot, null, 2)}\n`, 'utf8');
-        await file.sync();
-    }
-    catch (cause) {
-        await file.close();
-        await unlink(path).catch(() => undefined);
-        throw cause;
-    }
-    await file.close();
-    return path;
-}
-async function syncDirectory(path) {
-    const directory = await open(path, 'r');
-    try {
-        await directory.sync();
-    }
-    finally {
-        await directory.close();
-    }
-}
-async function readCurrent(path) {
-    const entry = await lstat(path);
-    if (!entry.isFile() || entry.isSymbolicLink() || (entry.mode & 0o077) !== 0) {
-        throw new DevelopmentSessionFileError('SESSION_FILE_TAMPERED', `Development session file is no longer one owner-only regular file: ${path}`);
-    }
-    try {
-        return acceptDevelopmentSessionFileV1(JSON.parse(await readFile(path, 'utf8')));
-    }
-    catch (cause) {
-        if (cause instanceof DevelopmentSessionFileError)
-            throw cause;
-        throw new DevelopmentSessionFileError('SESSION_FILE_TAMPERED', `Development session file is unreadable or invalid: ${path}`, { cause });
-    }
-}
-function project(input) {
-    const value = record(input, 'Development session project');
-    rejectBags(value, 'Development session project');
-    const origin = text(value.origin, 'Development session project origin');
-    if (!patterns.origin.test(origin))
-        invalid('Development session project origin is invalid.');
-    return Object.freeze({ origin });
-}
-function release(input) {
-    const value = record(input, 'Development session Release');
-    rejectBags(value, 'Development session Release');
-    const revision = digest(value.revision, 'Development session Release revision');
-    const etag = digest(value.etag, 'Development session Release etag');
-    const generation = digest(value.generation, 'Development session Release generation');
-    const issuer = origin(value.issuer);
-    return Object.freeze({ revision, issuer, etag, generation });
-}
-function origin(input) {
-    const value = text(input, 'Development session Release issuer');
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch (cause) {
-        throw new TypeError('Development session Release issuer must be an HTTP(S) origin.', { cause });
-    }
-    if (!['http:', 'https:'].includes(url.protocol) || url.href !== `${url.origin}/`) {
-        invalid('Development session Release issuer must be an HTTP(S) origin.');
-    }
-    return url.origin;
-}
-function digest(input, label) {
-    const value = text(input, label);
-    if (!/^sha256:[0-9a-f]{64}$/u.test(value))
-        invalid(`${label} must be a sha256 digest.`);
-    return value;
-}
-function admitPhase(input) {
-    if (input !== 'starting' &&
-        input !== 'ready' &&
-        input !== 'updating' &&
-        input !== 'recovering' &&
-        input !== 'stopping' &&
-        input !== 'stopped' &&
-        input !== 'failed') {
-        invalid(`Unknown development session phase: ${String(input)}.`);
-    }
-    return input;
-}
-export function developmentSessionTransitionAllowed(previous, next) {
-    if (previous === 'stopped' || previous === 'failed')
-        return false;
-    if (previous === 'stopping')
-        return next === 'stopped' || next === 'failed';
-    if (next === 'stopping' || next === 'failed')
-        return true;
-    if (previous === 'starting')
-        return next === 'ready';
-    return next === 'ready' || next === 'updating' || next === 'recovering';
-}
-function rejectBags(value, label) {
-    if (value.metadata !== undefined ||
-        value.extensions !== undefined ||
-        value.vendor !== undefined) {
-        invalid(`${label} cannot contain a metadata, extensions, or vendor bag.`);
-    }
-}
-function record(input, label) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input))
-        invalid(`${label} must be an object.`);
-    return input;
-}
-function text(input, label) {
-    if (typeof input !== 'string' || input.length === 0)
-        invalid(`${label} must be text.`);
-    return input;
-}
-function integer(input, label) {
-    if (!Number.isSafeInteger(input) || Number(input) <= 0)
-        invalid(`${label} must be a positive integer.`);
-    return Number(input);
-}
-function invalid(message) {
-    throw new TypeError(message);
-}
-function unsafe(message) {
-    throw new DevelopmentSessionFileError('SESSION_FILE_PATH_UNSAFE', message);
-}
-function errorCode(input) {
-    return input !== null && typeof input === 'object' && 'code' in input
-        ? String(Reflect.get(input, 'code'))
-        : undefined;
-}

package/dist/tooling/cli/development/target-lock.d.ts

@@ -1,16 +0,0 @@
-import type { DevelopmentLease } from './lease.js';
-export declare class DevelopmentTargetLockError extends Error {
-    readonly code: 'DEVELOPMENT_TARGET_LOCKED' | 'DEVELOPMENT_TARGET_LOCK_LOST';
-    readonly name = "DevelopmentTargetLockError";
-    constructor(code: 'DEVELOPMENT_TARGET_LOCKED' | 'DEVELOPMENT_TARGET_LOCK_LOST', message: string, options?: ErrorOptions);
-}
-/** Exclude local sessions targeting one installed Domain across separate checkouts. */
-export declare function acquireDevelopmentTargetLock(input: {
-    readonly issuer: string;
-    readonly origin: string;
-}, dependencies?: {
-    readonly root?: string;
-    readonly pid?: number;
-    readonly sessionId?: string;
-    readonly processAlive?: (pid: number) => boolean;
-}): Promise<DevelopmentLease>;