@astrale-os/sdk 0.5.0-beta.13 → 0.5.0-beta.130

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

@@ -0,0 +1,10 @@
+/** 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

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

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

@@ -0,0 +1,14 @@
+import { info } from '../log.js';
+export function reportDevelopmentDeployment(deployed, installation, adapter, input) {
+    info(`Environment: ${input.environment}`);
+    info(`Adapter: ${adapter.name}@${adapter.version}`);
+    info(`Deployment: ${deployed.progress.provider.evidence.deployment}`);
+    if (deployed.progress.provider.evidence.preflight !== undefined) {
+        info(`Preflight: ${deployed.progress.provider.evidence.preflight}; public readiness verified`);
+    }
+    info(`Public: ${deployed.release.addressing.issuer}`);
+    info(`Publication: ${deployed.release.publication.schema.revision} · ${deployed.release.publication.etag}`);
+    info(installation === undefined
+        ? `Installation: skipped${input.deployOnly ? ' (--deploy-only)' : ''}`
+        : `Installation: ${installation.instance} · ${installation.status}`);
+}

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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,337 @@
+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/source-watch.d.ts

@@ -0,0 +1,14 @@
+export interface SourceWatch {
+    update(sources: ReadonlySet<string>): void;
+    stop(): Promise<void>;
+}
+/** Observe only the admitted authored module closure and declared secrets. */
+export declare function watchSources(input: {
+    readonly projectDir: string;
+    readonly configPath: string;
+    readonly sources: ReadonlySet<string>;
+    readonly onInvalidate: () => void;
+    readonly onRestartRequired: () => void;
+    readonly onError: (cause: unknown) => void;
+    readonly debounceMs?: number;
+}): SourceWatch;

package/dist/tooling/cli/development/source-watch.js

@@ -0,0 +1,127 @@
+import { statSync, watch } from 'node:fs';
+import { resolve } from 'node:path';
+/** Observe only the admitted authored module closure and declared secrets. */
+export function watchSources(input) {
+    let sources = canonicalSources(input.sources);
+    let closed = false;
+    let timer;
+    let dirty = false;
+    let restart = false;
+    const config = resolve(input.configPath);
+    let configFingerprint = fingerprint(config);
+    let sourceFingerprints = fingerprints(sources);
+    const directoryWatchers = new Map();
+    const watcher = watch(input.projectDir, { recursive: true }, () => {
+        if (closed)
+            return;
+        let changed = false;
+        try {
+            const nextConfig = fingerprint(config);
+            if (nextConfig !== configFingerprint) {
+                configFingerprint = nextConfig;
+                restart = true;
+                changed = true;
+            }
+            for (const path of sources) {
+                const next = fingerprint(path);
+                if (next === sourceFingerprints.get(path))
+                    continue;
+                sourceFingerprints.set(path, next);
+                dirty = true;
+                changed = true;
+            }
+        }
+        catch (cause) {
+            input.onError(cause);
+            return;
+        }
+        if (!changed)
+            return;
+        schedule();
+    });
+    watcher.on('error', input.onError);
+    syncDirectoryWatchers();
+    function schedule() {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = setTimeout(flush, input.debounceMs ?? 80);
+    }
+    function syncDirectoryWatchers() {
+        const directories = new Set([...sourceFingerprints]
+            .filter(([, value]) => value.startsWith('directory:'))
+            .map(([path]) => path));
+        for (const [path, owned] of directoryWatchers) {
+            if (directories.has(path))
+                continue;
+            owned.off('error', input.onError);
+            owned.close();
+            directoryWatchers.delete(path);
+        }
+        for (const path of directories) {
+            if (directoryWatchers.has(path))
+                continue;
+            const owned = watch(path, () => {
+                if (closed)
+                    return;
+                dirty = true;
+                schedule();
+            });
+            owned.on('error', input.onError);
+            directoryWatchers.set(path, owned);
+        }
+    }
+    function flush() {
+        timer = undefined;
+        if (closed)
+            return;
+        if (restart)
+            input.onRestartRequired();
+        else if (dirty)
+            input.onInvalidate();
+        restart = false;
+        dirty = false;
+    }
+    return Object.freeze({
+        update(next) {
+            sources = canonicalSources(next);
+            sourceFingerprints = fingerprints(sources);
+            syncDirectoryWatchers();
+        },
+        async stop() {
+            if (closed)
+                return;
+            closed = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            watcher.off('error', input.onError);
+            watcher.close();
+            for (const owned of directoryWatchers.values()) {
+                owned.off('error', input.onError);
+                owned.close();
+            }
+            directoryWatchers.clear();
+        },
+    });
+}
+function canonicalSources(input) {
+    return new Set([...input].map((path) => resolve(path)));
+}
+function fingerprints(paths) {
+    return new Map([...paths].map((path) => [path, fingerprint(path)]));
+}
+function fingerprint(path) {
+    try {
+        const value = statSync(path, { bigint: true });
+        return `${value.isDirectory() ? 'directory' : 'file'}:${value.size}:${value.mtimeNs}:${value.ctimeNs}`;
+    }
+    catch (cause) {
+        if (errorCode(cause) === 'ENOENT')
+            return 'missing';
+        throw cause;
+    }
+}
+function errorCode(input) {
+    return input !== null && typeof input === 'object' && 'code' in input
+        ? String(Reflect.get(input, 'code'))
+        : undefined;
+}

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

@@ -0,0 +1,7 @@
+/** Own the canonical project-local files and directories that invalidate a candidate. */
+export declare class DevelopmentSources {
+    #private;
+    constructor(projectDir: string);
+    record: (path: string) => void;
+    snapshot(): ReadonlySet<string>;
+}

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

@@ -0,0 +1,48 @@
+import { realpathSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+/** Own the canonical project-local files and directories that invalidate a candidate. */
+export class DevelopmentSources {
+    #declaredProjectDir;
+    #projectDir;
+    #sources = new Set();
+    constructor(projectDir) {
+        this.#declaredProjectDir = resolve(projectDir);
+        try {
+            this.#projectDir = realpathSync.native(this.#declaredProjectDir);
+        }
+        catch {
+            this.#projectDir = this.#declaredProjectDir;
+        }
+    }
+    record = (path) => {
+        if (typeof path !== 'string' || path.length === 0 || path.includes('\0')) {
+            throw new TypeError('An adapter reported an invalid preparation source path.');
+        }
+        const declared = isAbsolute(path) ? resolve(path) : resolve(this.#declaredProjectDir, path);
+        let absolute;
+        try {
+            absolute = realpathSync.native(declared);
+        }
+        catch (cause) {
+            if (errorCode(cause) !== 'ENOENT')
+                throw cause;
+            absolute = declared.startsWith(`${this.#declaredProjectDir}${sep}`)
+                ? resolve(this.#projectDir, relative(this.#declaredProjectDir, declared))
+                : declared;
+        }
+        if (!absolute.startsWith(`${this.#projectDir}${sep}`))
+            return;
+        const topLevel = relative(this.#projectDir, absolute).split(sep)[0];
+        if (topLevel === '.astrale' || topLevel === '.git' || topLevel === 'node_modules')
+            return;
+        this.#sources.add(absolute);
+    };
+    snapshot() {
+        return new Set(this.#sources);
+    }
+}
+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

@@ -0,0 +1,16 @@
+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>;