@astrale-os/sdk 0.6.0-beta.2 → 0.6.0-beta.21

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

@@ -1,176 +0,0 @@
-import { existsSync } from 'node:fs';
-import { mkdir, rm, writeFile } from 'node:fs/promises';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { admitRuntime, compile, resolveRuntime, runtime, verifyPreflight, } from '../../../deployment/index.js';
-import { admitProjectModule } from '../../../project/index.js';
-import { loadDeclaredSecrets } from '../dotenv.js';
-import { selectEnvironment } from '../project.js';
-import { projectImportPlugin } from './project-imports.js';
-import { DevelopmentSources } from './sources.js';
-/** Rebuild one complete, isolated Environment candidate from authored sources. */
-export class DevelopmentCandidateBuilder {
-    #configPath;
-    #projectDir;
-    #environment;
-    #runtimePath;
-    #overrideSecrets;
-    #generation = 0;
-    constructor(input) {
-        this.#configPath = input.configPath;
-        this.#projectDir = input.projectDir;
-        this.#environment = input.environment;
-        this.#runtimePath = input.runtimePath;
-        this.#overrideSecrets = input.overrideSecrets;
-    }
-    async prepare(signal) {
-        throwIfAborted(signal);
-        const directory = join(this.#projectDir, '.astrale', 'development', this.#environment, 'source', String(++this.#generation));
-        await mkdir(directory, { recursive: true });
-        const bridge = join(directory, 'bridge.ts');
-        const sources = new DevelopmentSources(this.#projectDir);
-        sources.record(join(this.#projectDir, 'package.json'));
-        const configImport = moduleSpecifier(dirname(bridge), this.#configPath);
-        const runtimeImport = moduleSpecifier(dirname(bridge), resolve(dirname(this.#configPath), this.#runtimePath));
-        await writeFile(bridge, `export { default as project } from ${JSON.stringify(configImport)}\n` +
-            `export { default as runtime } from ${JSON.stringify(runtimeImport)}\n`);
-        try {
-            const bunRuntime = bun();
-            const built = await bunRuntime.build({
-                entrypoints: [bridge],
-                outdir: directory,
-                naming: 'application.mjs',
-                target: 'bun',
-                format: 'esm',
-                packages: 'bundle',
-                plugins: [projectImportPlugin(this.#projectDir, bunRuntime)],
-                splitting: false,
-                sourcemap: 'inline',
-                metafile: true,
-                throw: false,
-            });
-            throwIfAborted(signal);
-            if (!built.success) {
-                const diagnostics = built.logs.map(({ message, position }) => position === undefined || position === null
-                    ? message
-                    : `${relative(this.#projectDir, position.file)}:${position.line}:${position.column}: ${message}`);
-                throw new Error(['Authored Application rebuild failed.', ...diagnostics].join('\n'));
-            }
-            const output = built.outputs.find((candidate) => candidate.path.endsWith('application.mjs'));
-            if (output === undefined)
-                throw new Error('Authored Application rebuild produced no module.');
-            const loaded = (await import(`${pathToFileURL(output.path).href}?development=${this.#generation}`));
-            if (Object.keys(loaded).some((key) => key !== 'project' && key !== 'runtime')) {
-                throw new TypeError('Development bridge produced unexpected exports.');
-            }
-            const project = admitProjectModule({ default: loaded.project });
-            if ((project.entrypoints?.runtime ?? './runtime.ts') !== this.#runtimePath) {
-                throw new Error('Runtime entrypoint changed; restart pnpm dev to apply it.');
-            }
-            const environment = selectEnvironment(project, this.#environment);
-            const resolved = await resolveRuntime(runtime(this.#runtimePath), async (path) => {
-                if (path !== this.#runtimePath) {
-                    throw new Error('Runtime entrypoint changed; restart pnpm dev to apply it.');
-                }
-                return Object.freeze({ default: loaded.runtime });
-            });
-            const build = compile(project.application);
-            admitRuntime({ runtime: build.runtime }, resolved);
-            const adapter = environment.deployment.adapter;
-            const parameters = environment.deployment.parameters;
-            for (const path of Object.keys(built.metafile?.inputs ?? {}))
-                sources.record(path);
-            const source = await adapter.prepare(parameters, {
-                projectDir: this.#projectDir,
-                environment: this.#environment,
-                ...(environment.installation === undefined
-                    ? {}
-                    : { installation: environment.installation }),
-                mode: 'release',
-                recordSource: sources.record,
-                signal,
-                build,
-                runtime: resolved,
-            });
-            const artifact = verifyPreflight({ build, runtime: resolved, source });
-            const declared = this.#overrideSecrets === undefined
-                ? secretsFor(adapter, parameters, this.#projectDir, resolved.runtime)
-                : { values: this.#overrideSecrets };
-            if (declared.path !== undefined)
-                sources.record(declared.path);
-            return Object.freeze({
-                adapter,
-                parameters,
-                ...(environment.installation === undefined
-                    ? {}
-                    : { installation: environment.installation }),
-                artifact,
-                secrets: declared.values,
-                sources: sources.snapshot(),
-            });
-        }
-        finally {
-            await rm(directory, { recursive: true, force: true });
-        }
-    }
-}
-export async function discoverRuntimePath(configPath) {
-    const loaded = (await import(`${pathToFileURL(configPath).href}?discover=${Date.now()}`));
-    const project = admitProjectModule(loaded);
-    return project.entrypoints?.runtime ?? './runtime.ts';
-}
-export function sameEnvironment(current, candidate) {
-    return (candidate.adapter.name === current.adapter.name &&
-        candidate.adapter.version === current.adapter.version &&
-        candidate.artifact.build.schema.compiled.root.origin ===
-            current.artifact.build.schema.compiled.root.origin &&
-        stable(candidate.parameters) === stable(current.parameters) &&
-        stable(candidate.installation) === stable(current.installation));
-}
-/** Identify a rebuilt candidate that cannot change provider or installation state. */
-export function sameDeploymentCandidate(current, candidate) {
-    return (sameEnvironment(current, candidate) &&
-        candidate.artifact.build.schema.compiled.root.revision ===
-            current.artifact.build.schema.compiled.root.revision &&
-        candidate.artifact.digest === current.artifact.digest &&
-        stable(candidate.secrets) === stable(current.secrets));
-}
-function secretsFor(adapter, parameters, projectDir, selectedRuntime) {
-    const file = adapter.secretsFile?.(parameters);
-    if (file === undefined)
-        return { values: Object.freeze({}) };
-    const path = isAbsolute(file) ? file : join(projectDir, file);
-    if (Object.keys(selectedRuntime.integrations).length === 0 && !existsSync(path)) {
-        return { values: Object.freeze({}) };
-    }
-    return { values: Object.freeze(loadDeclaredSecrets(path, file)), path };
-}
-function bun() {
-    const value = Reflect.get(globalThis, 'Bun');
-    if (value === undefined || typeof value.build !== 'function') {
-        throw new TypeError('Domain development requires the Bun runtime.');
-    }
-    return value;
-}
-function moduleSpecifier(from, target) {
-    const path = relative(from, target).split(sep).join('/');
-    return path.startsWith('.') ? path : `./${path}`;
-}
-function stable(input) {
-    if (input === undefined)
-        return 'undefined';
-    if (input === null || typeof input !== 'object')
-        return JSON.stringify(input);
-    if (Array.isArray(input))
-        return `[${input.map(stable).join(',')}]`;
-    const record = input;
-    return `{${Object.keys(record)
-        .sort()
-        .map((key) => `${JSON.stringify(key)}:${stable(record[key])}`)
-        .join(',')}}`;
-}
-function throwIfAborted(signal) {
-    if (signal.aborted) {
-        throw signal.reason instanceof Error ? signal.reason : new Error('Development interrupted.');
-    }
-}

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

@@ -1,16 +0,0 @@
-import type { ReadyDeployResult } from '../../../deployment/adapter/index.js';
-import type { InstallationEvidence } from '../installation/index.js';
-import type { DevelopmentCandidate } from './candidate.js';
-export interface DevelopmentDeploymentInput {
-    readonly projectDir: string;
-    readonly environment: string;
-    readonly deployOnly: boolean;
-    readonly identity?: string;
-    readonly credential?: string;
-    readonly installationExecutable?: string;
-}
-/** Commit and verify one complete remote candidate, then reconcile its optional installation. */
-export declare function deployDevelopmentCandidate(candidate: DevelopmentCandidate, input: DevelopmentDeploymentInput, signal: AbortSignal): Promise<{
-    readonly deployment: ReadyDeployResult;
-    readonly installation?: InstallationEvidence;
-}>;

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

@@ -1,39 +0,0 @@
-import { verifyDeployment } from '../../../deployment/index.js';
-import { reconcileEnvironmentRelease } from '../environment-release.js';
-/** Commit and verify one complete remote candidate, then reconcile its optional installation. */
-export async function deployDevelopmentCandidate(candidate, input, signal) {
-    const deployed = await candidate.adapter.deploy(candidate.parameters, {
-        projectDir: input.projectDir,
-        environment: input.environment,
-        ...(candidate.installation === undefined ? {} : { installation: candidate.installation }),
-        ...(input.identity === undefined ? {} : { identity: input.identity }),
-        ...(input.credential === undefined ? {} : { credential: input.credential }),
-        secrets: candidate.secrets,
-        artifact: candidate.artifact,
-        signal,
-    });
-    const verified = verifyDeployment(candidate.artifact, deployed);
-    if (verified.status === 'failed') {
-        throw new Error(`Deployment failed during ${verified.phase}: ${verified.error.message}`, {
-            cause: verified.error,
-        });
-    }
-    const installation = await reconcileEnvironmentRelease({
-        projectDir: input.projectDir,
-        environment: input.environment,
-        adapter: candidate.adapter,
-        deployment: verified,
-        ...(candidate.installation === undefined ? {} : { installation: candidate.installation }),
-        deployOnly: input.deployOnly,
-        ...(input.installationExecutable === undefined
-            ? {}
-            : { installationExecutable: input.installationExecutable }),
-        ...(input.identity === undefined ? {} : { identity: input.identity }),
-        ...(input.credential === undefined ? {} : { credential: input.credential }),
-        signal,
-    });
-    return Object.freeze({
-        deployment: verified,
-        ...(installation === undefined ? {} : { installation }),
-    });
-}

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

@@ -1,11 +0,0 @@
-/** Watch one Project Environment and serialize complete remote deployment generations. */
-export declare function develop(input: {
-    readonly configPath: string;
-    readonly projectDir: string;
-    readonly environment: string;
-    readonly deployOnly: boolean;
-    readonly identity?: string;
-    readonly credentialFile?: string;
-    readonly sessionFile?: string;
-    readonly secretsFile?: string;
-}): Promise<number>;

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/lease.d.ts

@@ -1,18 +0,0 @@
-export declare class DevelopmentLeaseError extends Error {
-    readonly code: 'DEVELOPMENT_LEASE_LOCKED' | 'DEVELOPMENT_LEASE_LOST';
-    readonly name = "DevelopmentLeaseError";
-    constructor(code: 'DEVELOPMENT_LEASE_LOCKED' | 'DEVELOPMENT_LEASE_LOST', message: string, options?: ErrorOptions);
-}
-export interface DevelopmentLease {
-    readonly path: string;
-    readonly recovered: boolean;
-    release(): Promise<void>;
-}
-/** One fail-closed filesystem lease engine for every local development coordinate. */
-export declare function acquireDevelopmentLease(input: {
-    readonly directory: string;
-    readonly coordinate: string;
-    readonly pid?: number;
-    readonly sessionId?: string;
-    readonly processAlive?: (pid: number) => boolean;
-}): Promise<DevelopmentLease>;

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

@@ -1,163 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { mkdir, open, readFile, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
-const LOCK_VERSION = 1;
-export class DevelopmentLeaseError extends Error {
-    code;
-    name = 'DevelopmentLeaseError';
-    constructor(code, message, options) {
-        super(message, options);
-        this.code = code;
-    }
-}
-/** One fail-closed filesystem lease engine for every local development coordinate. */
-export async function acquireDevelopmentLease(input) {
-    const path = join(input.directory, 'session.lock');
-    const recovery = `${path}.reclaim`;
-    const sessionId = input.sessionId ?? randomUUID();
-    const alive = input.processAlive ?? processAlive;
-    const owner = Object.freeze({
-        version: LOCK_VERSION,
-        pid: input.pid ?? process.pid,
-        sessionId,
-        coordinate: input.coordinate,
-        acquiredAt: new Date().toISOString(),
-    });
-    await mkdir(input.directory, { recursive: true, mode: 0o700 });
-    try {
-        await create(path, owner);
-        return handle(path, input.coordinate, owner, false);
-    }
-    catch (cause) {
-        if (errorCode(cause) !== 'EEXIST')
-            throw cause;
-    }
-    let recoveryHandle;
-    try {
-        recoveryHandle = await open(recovery, 'wx', 0o600);
-        await recoveryHandle.writeFile(`${sessionId}\n`, 'utf8');
-        await recoveryHandle.sync();
-    }
-    catch (cause) {
-        if (errorCode(cause) === 'EEXIST')
-            throw locked(input.coordinate);
-        throw cause;
-    }
-    finally {
-        await recoveryHandle?.close();
-    }
-    try {
-        const observed = await readOwner(path, input.coordinate);
-        if (observed === undefined || alive(observed.pid))
-            throw locked(input.coordinate, observed);
-        const current = await readOwner(path, input.coordinate);
-        if (!sameOwner(current, observed) || alive(observed.pid)) {
-            throw locked(input.coordinate, current);
-        }
-        await unlink(path);
-        try {
-            await create(path, owner);
-        }
-        catch (cause) {
-            if (errorCode(cause) === 'EEXIST')
-                throw locked(input.coordinate);
-            throw cause;
-        }
-        return handle(path, input.coordinate, owner, true);
-    }
-    finally {
-        await unlink(recovery).catch((cause) => {
-            if (errorCode(cause) !== 'ENOENT')
-                throw cause;
-        });
-    }
-}
-function handle(path, coordinate, owner, recovered) {
-    let released = false;
-    return Object.freeze({
-        path,
-        recovered,
-        async release() {
-            if (released)
-                return;
-            const current = await readOwner(path, coordinate);
-            if (!sameOwner(current, owner)) {
-                throw new DevelopmentLeaseError('DEVELOPMENT_LEASE_LOST', `Development lease ownership changed for ${coordinate}; refusing to remove it.`);
-            }
-            await unlink(path);
-            released = true;
-        },
-    });
-}
-async function create(path, owner) {
-    const file = await open(path, 'wx', 0o600);
-    try {
-        await file.writeFile(`${JSON.stringify(owner)}\n`, 'utf8');
-        await file.sync();
-    }
-    catch (cause) {
-        await file.close();
-        await unlink(path).catch(() => undefined);
-        throw cause;
-    }
-    await file.close();
-}
-async function readOwner(path, coordinate) {
-    let text;
-    try {
-        text = await readFile(path, 'utf8');
-    }
-    catch (cause) {
-        if (errorCode(cause) === 'ENOENT')
-            return undefined;
-        throw cause;
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch (cause) {
-        throw locked(coordinate, undefined, cause);
-    }
-    if (!isOwner(value) || value.coordinate !== coordinate)
-        throw locked(coordinate);
-    return value;
-}
-function isOwner(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input))
-        return false;
-    const owner = input;
-    return (Reflect.ownKeys(owner).every((key) => ['version', 'pid', 'sessionId', 'coordinate', 'acquiredAt'].includes(String(key))) &&
-        owner.version === LOCK_VERSION &&
-        Number.isSafeInteger(owner.pid) &&
-        (owner.pid ?? 0) > 0 &&
-        typeof owner.sessionId === 'string' &&
-        owner.sessionId.length > 0 &&
-        typeof owner.coordinate === 'string' &&
-        owner.coordinate.length > 0 &&
-        typeof owner.acquiredAt === 'string');
-}
-function sameOwner(left, right) {
-    return (left?.version === right.version &&
-        left.pid === right.pid &&
-        left.sessionId === right.sessionId &&
-        left.coordinate === right.coordinate);
-}
-function locked(coordinate, owner, cause) {
-    const detail = owner === undefined ? '' : ` by PID ${owner.pid} (session ${owner.sessionId})`;
-    return new DevelopmentLeaseError('DEVELOPMENT_LEASE_LOCKED', `Development coordinate ${coordinate} is already locked${detail}.`, cause === undefined ? undefined : { cause });
-}
-function processAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (cause) {
-        return errorCode(cause) !== 'ESRCH';
-    }
-}
-function errorCode(input) {
-    return input !== null && typeof input === 'object' && 'code' in input
-        ? String(Reflect.get(input, 'code'))
-        : undefined;
-}

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

@@ -1,9 +0,0 @@
-/** Own process signals for exactly one foreground development command. */
-export declare class DevelopmentLifecycle {
-    #private;
-    constructor();
-    get signal(): AbortSignal;
-    get stopped(): Promise<void>;
-    stop(reason?: unknown): void;
-    dispose(): void;
-}