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

package/dist/tooling/cli/astrale/process.js

@@ -1,94 +0,0 @@
-import { spawn } from 'node:child_process';
-const OUTPUT_LIMIT = 256 * 1024;
-const TERMINATION_GRACE_MS = 1_000;
-/** Run one exact Kernel CLI executable with bounded output, time, and termination. */
-export function runAstrale(input) {
-    if (input.signal.aborted)
-        return Promise.reject(abortError(input.signal));
-    return new Promise((resolve, reject) => {
-        let child;
-        try {
-            child = spawn(input.executable, [...input.args], {
-                cwd: input.projectDir,
-                stdio: ['pipe', 'pipe', 'pipe'],
-                shell: false,
-                // This owner already forwards cancellation and enforces a deadline. Keep
-                // terminal group signals from killing installation observation/View cleanup.
-                detached: process.platform !== 'win32',
-            });
-            child.stdin.end();
-        }
-        catch (cause) {
-            reject(new Error('Astrale CLI is unavailable.', { cause }));
-            return;
-        }
-        let stdout = '';
-        let stderr = '';
-        let stdoutBytes = 0;
-        let stderrBytes = 0;
-        let settled = false;
-        let termination;
-        let escalation;
-        const abort = () => terminate(input.signal.reason instanceof Error
-            ? input.signal.reason
-            : new Error('Project operation interrupted.'));
-        input.signal.addEventListener('abort', abort, { once: true });
-        const cleanup = () => {
-            clearTimeout(timeout);
-            if (escalation !== undefined)
-                clearTimeout(escalation);
-            input.signal.removeEventListener('abort', abort);
-        };
-        const terminate = (cause) => {
-            if (settled || termination !== undefined)
-                return;
-            termination = cause;
-            child.stdin.destroy();
-            child.kill('SIGTERM');
-            escalation = setTimeout(() => {
-                if (child.exitCode === null && child.signalCode === null)
-                    child.kill('SIGKILL');
-            }, TERMINATION_GRACE_MS);
-        };
-        const timeout = setTimeout(() => terminate(new Error('Astrale CLI command timed out.')), input.timeoutMs);
-        child.stdout.on('data', (chunk) => {
-            stdoutBytes += chunk.byteLength;
-            if (stdoutBytes > OUTPUT_LIMIT) {
-                terminate(new Error('Astrale CLI stdout exceeded the supported limit.'));
-            }
-            else
-                stdout += chunk.toString('utf8');
-        });
-        child.stderr.on('data', (chunk) => {
-            stderrBytes += chunk.byteLength;
-            if (stderrBytes > OUTPUT_LIMIT) {
-                terminate(new Error('Astrale CLI stderr exceeded the supported limit.'));
-            }
-            else
-                stderr += chunk.toString('utf8');
-        });
-        child.once('error', (cause) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            reject(new Error('Astrale CLI could not be started.', { cause }));
-        });
-        child.once('close', (code) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            if (termination !== undefined) {
-                reject(termination);
-                return;
-            }
-            resolve(Object.freeze({ code: code ?? 1, stdout, stderr }));
-        });
-    });
-}
-function abortError(signal) {
-    return signal.reason instanceof Error
-        ? signal.reason
-        : new Error('Project operation interrupted.');
-}

package/dist/tooling/cli/astrale/version.d.ts

@@ -1,18 +0,0 @@
-import type { AstraleProcessResult } from './process.js';
-import { resolveAstraleExecutable } from './executable.js';
-export declare const MINIMUM_KERNEL_CLI_VERSION = "1.0.0-beta.48";
-export interface CompatibleAstraleDependencies {
-    readonly resolveExecutable: typeof resolveAstraleExecutable;
-    readonly run: (input: {
-        readonly executable: string;
-        readonly args: readonly string[];
-        readonly projectDir: string;
-        readonly signal: AbortSignal;
-        readonly timeoutMs: number;
-    }) => Promise<AstraleProcessResult>;
-}
-/** Pin and admit one compatible CLI before any configured Kernel installation effect. */
-export declare function resolveCompatibleAstrale(input: {
-    readonly projectDir: string;
-    readonly signal: AbortSignal;
-}, dependencies?: CompatibleAstraleDependencies): Promise<string>;

package/dist/tooling/cli/astrale/version.js

@@ -1,55 +0,0 @@
-import { resolveAstraleExecutable } from './executable.js';
-import { astraleFailure } from './failure.js';
-import { runAstrale } from './process.js';
-export const MINIMUM_KERNEL_CLI_VERSION = '1.0.0-beta.48';
-/** Pin and admit one compatible CLI before any configured Kernel installation effect. */
-export async function resolveCompatibleAstrale(input, dependencies = {
-    resolveExecutable: resolveAstraleExecutable,
-    run: runAstrale,
-}) {
-    const executable = await dependencies.resolveExecutable();
-    const result = await dependencies.run({
-        executable,
-        projectDir: input.projectDir,
-        args: ['--version'],
-        signal: input.signal,
-        timeoutMs: 10_000,
-    });
-    if (result.code !== 0)
-        throw astraleFailure('version', result);
-    const version = result.stdout.trim().replace(/^v/u, '');
-    if (!isCompatible(version)) {
-        const diagnostic = semver(version) === undefined ? '<invalid>' : version;
-        throw new TypeError(`Astrale CLI ${diagnostic} is incompatible; ${MINIMUM_KERNEL_CLI_VERSION} or newer is required.`);
-    }
-    return executable;
-}
-function isCompatible(input) {
-    const value = semver(input);
-    const minimum = semver(MINIMUM_KERNEL_CLI_VERSION);
-    if (value === undefined)
-        return false;
-    for (let index = 0; index < 3; index += 1) {
-        if (value.core[index] > minimum.core[index])
-            return true;
-        if (value.core[index] < minimum.core[index])
-            return false;
-    }
-    if (value.prerelease === undefined)
-        return true;
-    if (minimum.prerelease === undefined)
-        return false;
-    if (value.prerelease.name !== minimum.prerelease.name) {
-        return value.prerelease.name.localeCompare(minimum.prerelease.name) > 0;
-    }
-    return value.prerelease.number >= minimum.prerelease.number;
-}
-function semver(input) {
-    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z]+)\.(\d+))?$/u.exec(input);
-    if (match === null)
-        return undefined;
-    return {
-        core: [Number(match[1]), Number(match[2]), Number(match[3])],
-        ...(match[4] === undefined ? {} : { prerelease: { name: match[4], number: Number(match[5]) } }),
-    };
-}

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/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>;

package/dist/tooling/cli/development/target-lock.js

@@ -1,68 +0,0 @@
-import { createHash } from 'node:crypto';
-import { mkdir, rmdir } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { acquireDevelopmentLease, DevelopmentLeaseError } from './lease.js';
-export class DevelopmentTargetLockError extends Error {
-    code;
-    name = 'DevelopmentTargetLockError';
-    constructor(code, message, options) {
-        super(message, options);
-        this.code = code;
-    }
-}
-/** Exclude local sessions targeting one installed Domain across separate checkouts. */
-export async function acquireDevelopmentTargetLock(input, dependencies = {}) {
-    const coordinate = `${input.issuer}#${input.origin}`;
-    const root = dependencies.root ?? join(tmpdir(), 'astrale-domain-development-targets');
-    const key = createHash('sha256')
-        .update(input.issuer)
-        .update('\0')
-        .update(input.origin)
-        .digest('hex');
-    const directory = join(root, key);
-    await mkdir(root, { recursive: true, mode: 0o700 });
-    let lease;
-    try {
-        lease = await acquireDevelopmentLease({
-            directory,
-            coordinate,
-            ...(dependencies.pid === undefined ? {} : { pid: dependencies.pid }),
-            ...(dependencies.sessionId === undefined ? {} : { sessionId: dependencies.sessionId }),
-            ...(dependencies.processAlive === undefined
-                ? {}
-                : { processAlive: dependencies.processAlive }),
-        });
-    }
-    catch (cause) {
-        if (cause instanceof DevelopmentLeaseError) {
-            throw new DevelopmentTargetLockError('DEVELOPMENT_TARGET_LOCKED', cause.message, { cause });
-        }
-        throw cause;
-    }
-    return Object.freeze({
-        ...lease,
-        async release() {
-            try {
-                await lease.release();
-            }
-            catch (cause) {
-                if (cause instanceof DevelopmentLeaseError) {
-                    throw new DevelopmentTargetLockError('DEVELOPMENT_TARGET_LOCK_LOST', cause.message, {
-                        cause,
-                    });
-                }
-                throw cause;
-            }
-            await rmdir(directory).catch(ignoreNonEmpty);
-            await rmdir(root).catch(ignoreNonEmpty);
-        },
-    });
-}
-function ignoreNonEmpty(cause) {
-    const code = cause !== null && typeof cause === 'object' && 'code' in cause
-        ? String(Reflect.get(cause, 'code'))
-        : undefined;
-    if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(code ?? ''))
-        throw cause;
-}