@astrale-os/sdk 0.5.0-beta.68 → 0.5.0-beta.69

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.5.0-beta.69](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.68...sdk-v0.5.0-beta.69) (2026-08-28)
+
+
+### Features
+
+* add coordinated Domain development sessions ([#300](https://github.com/astrale-os/sdk/issues/300)) ([102104f](https://github.com/astrale-os/sdk/commit/102104f1ed55333f5892db23c036578aa0ffd2e1))
+* **tooling:** keep frontend composition application-owned ([#310](https://github.com/astrale-os/sdk/issues/310)) ([31e9bb6](https://github.com/astrale-os/sdk/commit/31e9bb6de256ef9cdbcdb0296abb973086f11ff0))
+
+
+### Bug Fixes
+
+* **adapter-astrale:** preserve explicit Services installation ownership ([#305](https://github.com/astrale-os/sdk/issues/305)) ([1b9dd64](https://github.com/astrale-os/sdk/commit/1b9dd6422e5d80a552ec5a70b5d262b8413dd6bc))
+* **cli:** skip unused secrets files ([3a1c534](https://github.com/astrale-os/sdk/commit/3a1c53439d5172add9c2c724060daaffc0a517bb))
+
 ## [0.5.0-beta.68](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.67...sdk-v0.5.0-beta.68) (2026-08-28)
 
 

package/dist/deployment/adapter/adapter.d.ts

@@ -1,13 +1,13 @@
 import type { DeployContext, DeployResult } from './deploy/index.js';
+import type { DevelopmentContext, DevelopmentSession } from './development/index.js';
 import type { ArtifactSource, PrepareContext } from './prepare/index.js';
-import type { WatchContext, WatchHandle } from './watch/index.js';
 export interface Adapter<Parameters = unknown> {
     readonly kind: 'adapter';
     readonly name: string;
     readonly version: string;
     parameters(environment: string): Parameters;
     prepare(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
-    watch(parameters: Parameters, context: WatchContext): Promise<WatchHandle>;
+    develop(parameters: Parameters, context: DevelopmentContext): Promise<DevelopmentSession>;
     deploy(parameters: Parameters, context: DeployContext): Promise<DeployResult>;
     readonly secretsFile?: (parameters: Parameters) => string | undefined;
 }
@@ -16,7 +16,7 @@ export interface AdapterInput<Parameters> {
     readonly version: string;
     readonly environments: Readonly<Record<string, Parameters>>;
     prepare(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
-    watch(parameters: Parameters, context: WatchContext): Promise<WatchHandle>;
+    develop(parameters: Parameters, context: DevelopmentContext): Promise<DevelopmentSession>;
     deploy(parameters: Parameters, context: DeployContext): Promise<DeployResult>;
     readonly secretsFile?: (parameters: Parameters) => string | undefined;
 }

package/dist/deployment/adapter/define.js

@@ -2,7 +2,7 @@ const admittedAdapters = new WeakSet();
 /** Capture one receiver-bound provider adapter and its environment parameters. */
 export function defineAdapter(input) {
     const value = record(input, 'Adapter definition');
-    exact(value, ['name', 'version', 'environments', 'prepare', 'watch', 'deploy'], ['secretsFile']);
+    exact(value, ['name', 'version', 'environments', 'prepare', 'develop', 'deploy'], ['secretsFile']);
     const name = stableName(input.name);
     const version = stableName(input.version);
     const environments = record(input.environments, 'Adapter environments');
@@ -13,7 +13,7 @@ export function defineAdapter(input) {
     const names = Object.keys(capturedEnvironments).sort();
     const receiver = Object.freeze({ ...input, environments: capturedEnvironments });
     const prepare = capture(receiver, 'prepare');
-    const watch = capture(receiver, 'watch');
+    const develop = capture(receiver, 'develop');
     const deploy = capture(receiver, 'deploy');
     const secretsFile = optional(receiver, 'secretsFile');
     const adapter = Object.freeze({
@@ -27,7 +27,7 @@ export function defineAdapter(input) {
             throw new TypeError(`Adapter ${name} has no environment ${environment}; known environments: ${names.length === 0 ? '(none)' : names.join(', ')}.`);
         },
         prepare,
-        watch,
+        develop,
         deploy,
         ...(secretsFile === undefined ? {} : { secretsFile }),
     });

package/dist/deployment/adapter/development/context.d.ts

@@ -0,0 +1,14 @@
+import type { DevelopmentInput } from './input.js';
+import type { DevelopmentPlacement } from './placement.js';
+export interface DevelopmentOverrides {
+    readonly publicUrl?: string;
+    readonly localPort?: number;
+}
+/** Provider-neutral inputs retained for one complete development session. */
+export interface DevelopmentContext extends DevelopmentInput {
+    readonly projectDir: string;
+    readonly environment: string;
+    readonly overrides: DevelopmentOverrides;
+    readonly signal: AbortSignal;
+    onPlacement(placement: DevelopmentPlacement): Promise<void>;
+}

package/dist/deployment/adapter/development/index.d.ts

@@ -0,0 +1,4 @@
+export type { DevelopmentContext, DevelopmentOverrides } from './context.js';
+export type { DevelopmentInput } from './input.js';
+export type { DevelopmentPlacement } from './placement.js';
+export type { DevelopmentSession } from './session.js';

package/dist/deployment/adapter/{watch/context.d.ts → development/input.d.ts}

@@ -1,8 +1,6 @@
 import type { PreparedArtifact } from '../prepare/index.js';
-export interface WatchContext {
-    readonly projectDir: string;
-    readonly environment: string;
-    readonly secrets: Readonly<Record<string, string>>;
+/** One admitted application artifact and its declared provider secrets. */
+export interface DevelopmentInput {
     readonly artifact: PreparedArtifact;
-    onReload(): void;
+    readonly secrets: Readonly<Record<string, string>>;
 }

package/dist/deployment/adapter/development/placement.d.ts

@@ -0,0 +1,5 @@
+/** Exact serving coordinates committed by one development placement generation. */
+export interface DevelopmentPlacement {
+    readonly releaseUrl: string;
+    readonly localUrl?: string;
+}

package/dist/deployment/adapter/development/placement.js

@@ -0,0 +1 @@
+export {};

package/dist/deployment/adapter/development/session.d.ts

@@ -0,0 +1,9 @@
+import type { DevelopmentInput } from './input.js';
+import type { DevelopmentPlacement } from './placement.js';
+/** Lifecycle capability for one ready development placement. */
+export interface DevelopmentSession {
+    current(): DevelopmentPlacement;
+    update(input: DevelopmentInput): Promise<void>;
+    readonly finished: Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/deployment/adapter/development/session.js

@@ -0,0 +1 @@
+export {};

package/dist/deployment/adapter/index.d.ts

@@ -1,5 +1,5 @@
 export type { Adapter, AdapterInput } from './adapter.js';
 export { defineAdapter, isAdapter } from './define.js';
 export type * from './prepare/index.js';
-export type * from './watch/index.js';
+export type * from './development/index.js';
 export type * from './deploy/index.js';

package/dist/deployment/adapter/prepare/context.d.ts

@@ -3,6 +3,13 @@ import type { ResolvedRuntimeReference } from '../../runtime/index.js';
 export interface PrepareContext<BuildValue extends Build = Build> {
     readonly projectDir: string;
     readonly environment: string;
+    /**
+     * Preparation purpose. Development may omit immutable frontend output because
+     * the live provider serves the declared frontend source directly; release
+     * preparation must remain complete. Omitted by older custom callers means
+     * release for compatibility.
+     */
+    readonly mode?: 'development' | 'release';
     readonly build: BuildValue;
     readonly runtime: ResolvedRuntimeReference;
 }

package/dist/deployment/index.d.ts

@@ -1,5 +1,5 @@
 export { defineAdapter, isAdapter } from './adapter/index.js';
-export type { Adapter, AdapterInput, AddressingPlan, ArtifactFile, ArtifactSource, DeployContext, DeploymentPhase, DeploymentProgress, DeployResult, FailedDeployResult, MutationKnowledge, PreparedArtifact, PreparedArtifactFile, PrepareContext, ReadyDeployResult, WatchContext, WatchHandle, } from './adapter/index.js';
+export type { Adapter, AdapterInput, AddressingPlan, ArtifactFile, ArtifactSource, DeployContext, DevelopmentContext, DevelopmentInput, DevelopmentOverrides, DevelopmentPlacement, DevelopmentSession, DeploymentPhase, DeploymentProgress, DeployResult, FailedDeployResult, MutationKnowledge, PreparedArtifact, PreparedArtifactFile, PrepareContext, ReadyDeployResult, } from './adapter/index.js';
 export { compile, isBuild } from './build/index.js';
 export type { Build, BuildBundle, BuildSchema } from './build/index.js';
 export { deploy, isDeployment } from './deploy.js';

package/dist/tooling/cli/arguments.d.ts

@@ -2,7 +2,6 @@ import type { LintReportFormat } from '../linter/index.js';
 export interface ParsedArgs {
     readonly command: 'dev' | 'build' | 'deploy' | 'lint' | 'package';
     readonly env: string;
-    readonly watch: boolean;
     readonly fix?: boolean;
     readonly format?: LintReportFormat;
     readonly port?: number;

package/dist/tooling/cli/arguments.js

@@ -1,7 +1,7 @@
+import { isIP } from 'node:net';
 /** Parse the frozen `astrale-domain` command grammar without performing effects. */
 export function parseArgs(argv) {
     const [command, ...rest] = argv;
-    const watch = rest.includes('--watch');
     const fix = rest.includes('--fix');
     let port;
     let host;
@@ -13,13 +13,13 @@ export function parseArgs(argv) {
         if (argument === '--port') {
             const value = rest[++index];
             port = Number(value);
-            if (!Number.isInteger(port) || port <= 0) {
+            if (!Number.isInteger(port) || port <= 0 || port > 65_535) {
                 throw new Error(`--port needs a port number, got "${value}"`);
             }
         }
         else if (argument.startsWith('--port=')) {
             port = Number(argument.slice('--port='.length));
-            if (!Number.isInteger(port) || port <= 0) {
+            if (!Number.isInteger(port) || port <= 0 || port > 65_535) {
                 throw new Error(`--port needs a port number, got "${argument}"`);
             }
         }
@@ -41,7 +41,7 @@ export function parseArgs(argv) {
         else if (argument.startsWith('--environment=')) {
             environment = requiredValue('--environment', argument.slice('--environment='.length));
         }
-        else if (argument === '--watch' || argument === '--fix') {
+        else if (argument === '--fix') {
             continue;
         }
         else if (argument.startsWith('-')) {
@@ -56,9 +56,6 @@ export function parseArgs(argv) {
     if (format !== undefined && command !== 'lint') {
         throw new Error('`--format` is only valid for `lint`.');
     }
-    if (watch && !['dev', 'deploy'].includes(command ?? '')) {
-        throw new Error('`--watch` is only valid for the dev / deploy commands.');
-    }
     if ((port !== undefined || host !== undefined) && command !== 'dev') {
         throw new Error('`--port` and `--host` are only valid for `dev`.');
     }
@@ -76,7 +73,6 @@ export function parseArgs(argv) {
             return {
                 command: 'dev',
                 env: environment ?? positionals[0] ?? 'dev',
-                watch: true,
                 ...(port !== undefined ? { port } : {}),
                 ...(host !== undefined ? { host } : {}),
             };
@@ -89,24 +85,22 @@ export function parseArgs(argv) {
             return {
                 command: 'deploy',
                 env,
-                watch,
             };
         }
         case 'build':
             if (positionals.length > 0)
                 throw new Error('`build` does not accept positional arguments.');
-            return { command: 'build', env: 'dev', watch: false };
+            return { command: 'build', env: 'dev' };
         case 'package':
             if (positionals.length > 0)
                 throw new Error('`package` does not accept positional arguments.');
-            return { command: 'package', env: 'dev', watch: false };
+            return { command: 'package', env: 'dev' };
         case 'lint':
             if (positionals.length > 0)
                 throw new Error('`lint` does not accept positional arguments.');
             return {
                 command: 'lint',
                 env: 'dev',
-                watch: false,
                 ...(fix ? { fix: true } : {}),
                 ...(format ? { format } : {}),
             };
@@ -119,12 +113,46 @@ function normalizeHost(input) {
         throw new Error(`--host needs a public URL, got "${input ?? ''}"`);
     }
     try {
-        return new URL(/^https?:\/\//u.test(input) ? input : `https://${input}`).origin;
+        const url = new URL(input);
+        if ((url.protocol !== 'https:' && url.protocol !== 'http:') ||
+            url.username !== '' ||
+            url.password !== '' ||
+            url.pathname !== '/' ||
+            url.search !== '' ||
+            url.hash !== '' ||
+            privateHostname(url.hostname))
+            throw new Error('invalid');
+        return url.origin;
     }
     catch {
         throw new Error(`--host needs a valid URL, got "${input}"`);
     }
 }
+function privateHostname(input) {
+    const host = input
+        .toLowerCase()
+        .replace(/^\[|\]$/gu, '')
+        .replace(/\.$/u, '');
+    if (host === 'localhost' || host.endsWith('.localhost'))
+        return true;
+    if (isIP(host) === 4) {
+        const parts = host.split('.').map(Number);
+        return (parts[0] === 0 ||
+            parts[0] === 10 ||
+            parts[0] === 127 ||
+            (parts[0] === 169 && parts[1] === 254) ||
+            (parts[0] === 172 && (parts[1] ?? 0) >= 16 && (parts[1] ?? 0) <= 31) ||
+            (parts[0] === 192 && parts[1] === 168));
+    }
+    if (isIP(host) !== 6)
+        return false;
+    return (host === '::' ||
+        host === '::1' ||
+        host.startsWith('fc') ||
+        host.startsWith('fd') ||
+        /^fe[89ab]/u.test(host) ||
+        /^::ffff:(?:0|10|127|169\.254|172\.(?:1[6-9]|2\d|3[01])|192\.168)\./u.test(host));
+}
 function lintFormat(input) {
     if (input !== 'stylish' && input !== 'json') {
         throw new Error(`--format must be "stylish" or "json", got "${input ?? ''}"`);

package/dist/tooling/cli/bun.d.ts

@@ -10,5 +10,6 @@ export type BunOutcome = {
 };
 /** Re-enter the published executable under Bun only when authored TypeScript must be imported. */
 export declare function runWithBun(executable: string, argv: readonly string[]): Promise<BunOutcome>;
+export declare function isolateDevelopmentProcessGroup(argv: readonly string[], platform?: NodeJS.Platform): boolean;
 /** Prefer the generated project's exact Bun package binary over an ambient executable or shim. */
 export declare function resolveBunExecutable(cwd: string): string;

package/dist/tooling/cli/bun.js

@@ -14,6 +14,10 @@ export function runWithBun(executable, argv) {
     return new Promise((resolve, reject) => {
         const child = spawn(resolveBunExecutable(process.cwd()), [executable, ...argv], {
             stdio: 'inherit',
+            // Keep a long-lived development runtime outside the launcher's terminal
+            // process group. The launcher receives Ctrl-C, forwards it exactly once,
+            // and remains alive until Bun finishes provider and Kernel cleanup.
+            detached: isolateDevelopmentProcessGroup(argv),
         });
         const handlers = FORWARDED_SIGNALS.map((signal) => [signal, () => child.kill(signal)]);
         for (const [signal, handler] of handlers)
@@ -40,6 +44,9 @@ export function runWithBun(executable, argv) {
         });
     });
 }
+export function isolateDevelopmentProcessGroup(argv, platform = process.platform) {
+    return platform !== 'win32' && argv[0] === 'dev';
+}
 /** Prefer the generated project's exact Bun package binary over an ambient executable or shim. */
 export function resolveBunExecutable(cwd) {
     const projectRequire = createRequire(join(cwd, 'package.json'));

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

@@ -0,0 +1,8 @@
+import type { DevelopmentOverrides } from '../../../deployment/adapter/index.js';
+/** Run one complete provider-neutral development session until interruption. */
+export declare function develop(input: {
+    readonly configPath: string;
+    readonly projectDir: string;
+    readonly environment: string;
+    readonly overrides: DevelopmentOverrides;
+}): Promise<number>;

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

@@ -0,0 +1,284 @@
+import { existsSync } from 'node:fs';
+import { mkdir, rm, rmdir, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { admitRuntime, compile, isDeployment, resolveRuntime, verifyPreflight, } from '../../../deployment/index.js';
+import { loadDeclaredSecrets } from '../dotenv.js';
+import { error, info } from '../log.js';
+import { DevelopmentLifecycle } from './lifecycle.js';
+import { acquireProjectLock } from './project-lock.js';
+import { LatestRebuild } from './rebuild.js';
+import { watchSources } from './source-watch.js';
+/** Run one complete provider-neutral development session until interruption. */
+export async function develop(input) {
+    const lifecycle = new DevelopmentLifecycle();
+    let lock;
+    let session;
+    let sourceWatch;
+    let rebuild;
+    let failure;
+    let failed = false;
+    let watcherFailure;
+    try {
+        lock = await acquireProjectLock({
+            projectRoot: input.projectDir,
+            environment: input.environment,
+        });
+        const runtimePath = await discoverRuntimePath(input.configPath);
+        const builder = new ProjectBuilder({ ...input, runtimePath });
+        let current = await builder.prepare(lifecycle.signal);
+        const adapter = current.adapter;
+        const parameters = current.parameters;
+        let restartReported = false;
+        info(`Domain: ${current.artifact.build.schema.compiled.root.origin}`);
+        session = await adapter.develop(parameters, {
+            projectDir: input.projectDir,
+            environment: input.environment,
+            artifact: current.artifact,
+            secrets: current.secrets,
+            overrides: input.overrides,
+            signal: lifecycle.signal,
+            async onPlacement(placement) {
+                info(`Public: ${placement.releaseUrl}`);
+                if (placement.localUrl !== undefined)
+                    info(`Runtime: ${placement.localUrl}`);
+            },
+        });
+        rebuild = new LatestRebuild({
+            prepare: (_ignored, signal) => builder.prepare(signal),
+            async commit(candidate) {
+                if (candidate.adapter.name !== adapter.name ||
+                    candidate.adapter.version !== adapter.version ||
+                    stable(candidate.parameters) !== stable(parameters)) {
+                    restartReported = true;
+                    throw new Error('Adapter configuration changed; restart pnpm dev to apply it.');
+                }
+                const previous = current;
+                current = candidate;
+                try {
+                    await session.update({ artifact: candidate.artifact, secrets: candidate.secrets });
+                    sourceWatch?.update(candidate.sources);
+                    info(`Updated ${candidate.artifact.build.schema.compiled.root.revision}.`);
+                }
+                catch (cause) {
+                    current = previous;
+                    throw cause;
+                }
+            },
+            failed(cause) {
+                error(cause instanceof Error ? cause.message : String(cause));
+            },
+        });
+        sourceWatch = watchSources({
+            projectDir: input.projectDir,
+            configPath: input.configPath,
+            sources: current.sources,
+            onInvalidate: () => rebuild.invalidate(),
+            onRestartRequired: () => {
+                if (restartReported)
+                    return;
+                restartReported = true;
+                error('Adapter configuration changed; restart pnpm dev to apply it.');
+            },
+            onError: (cause) => {
+                watcherFailure = cause;
+                lifecycle.stop(cause);
+            },
+        });
+        const placement = session.current();
+        info(`Ready: watching for changes (${placement.releaseUrl}).`);
+        const completed = await Promise.race([
+            session.finished.then(() => 'session'),
+            lifecycle.stopped.then(() => 'signal'),
+        ]);
+        if (completed === 'session' && !lifecycle.signal.aborted) {
+            throw new Error('Development provider stopped unexpectedly.');
+        }
+        if (watcherFailure !== undefined)
+            throw watcherFailure;
+    }
+    catch (cause) {
+        failed = true;
+        failure = cause;
+    }
+    lifecycle.stop(failure);
+    const cleanup = [];
+    for (const operation of [
+        () => sourceWatch?.stop(),
+        () => rebuild?.stop(failure),
+        () => session?.stop(),
+        () => rm(join(input.projectDir, '.astrale', 'development', input.environment, 'source'), {
+            recursive: true,
+            force: true,
+        }),
+        () => 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);
+        }
+    }
+    lifecycle.dispose();
+    if (failed) {
+        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;
+}
+class ProjectBuilder {
+    #configPath;
+    #projectDir;
+    #environment;
+    #runtimePath;
+    #generation = 0;
+    constructor(input) {
+        this.#configPath = input.configPath;
+        this.#projectDir = input.projectDir;
+        this.#environment = input.environment;
+        this.#runtimePath = input.runtimePath;
+    }
+    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 configImport = moduleSpecifier(dirname(bridge), this.#configPath);
+        const runtimeImport = moduleSpecifier(dirname(bridge), resolve(dirname(this.#configPath), this.#runtimePath));
+        await writeFile(bridge, `export { default as deployment } from ${JSON.stringify(configImport)}\n` +
+            `export { default as runtime } from ${JSON.stringify(runtimeImport)}\n`);
+        try {
+            const built = await bun().build({
+                entrypoints: [bridge],
+                outdir: directory,
+                naming: 'application.mjs',
+                target: 'bun',
+                format: 'esm',
+                packages: 'external',
+                splitting: false,
+                sourcemap: 'inline',
+                metafile: true,
+            });
+            throwIfAborted(signal);
+            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 !== 'deployment' && key !== 'runtime')) {
+                throw new TypeError('Development bridge produced unexpected exports.');
+            }
+            const deployment = loaded.deployment;
+            if (!isDeployment(deployment)) {
+                throw new TypeError('astrale.config.ts default export must be created by deploy().');
+            }
+            const admitted = deployment;
+            const resolved = await resolveRuntime(admitted.entrypoint, 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(admitted.application);
+            admitRuntime({ runtime: build.runtime }, resolved);
+            const adapter = admitted.adapter;
+            const parameters = adapter.parameters(this.#environment);
+            const source = await adapter.prepare(parameters, {
+                projectDir: this.#projectDir,
+                environment: this.#environment,
+                mode: 'development',
+                build,
+                runtime: resolved,
+            });
+            const artifact = verifyPreflight({ build, runtime: resolved, source });
+            const declared = secretsFor(adapter, parameters, this.#projectDir, resolved.runtime);
+            const sources = new Set();
+            for (const path of Object.keys(built.metafile?.inputs ?? {})) {
+                const absolute = isAbsolute(path) ? path : resolve(this.#projectDir, path);
+                if (!absolute.startsWith(`${resolve(this.#projectDir)}${sep}`))
+                    continue;
+                if (absolute.includes(`${sep}.astrale${sep}`))
+                    continue;
+                sources.add(absolute);
+            }
+            if (declared.path !== undefined)
+                sources.add(declared.path);
+            return Object.freeze({
+                adapter,
+                parameters,
+                artifact,
+                secrets: declared.values,
+                sources,
+            });
+        }
+        finally {
+            await rm(directory, { recursive: true, force: true });
+        }
+    }
+}
+async function discoverRuntimePath(configPath) {
+    const loaded = (await import(`${pathToFileURL(configPath).href}?discover=${Date.now()}`));
+    if (Object.keys(loaded).length !== 1 || !Object.hasOwn(loaded, 'default')) {
+        throw new TypeError('astrale.config.ts must export exactly one default Deployment.');
+    }
+    if (!isDeployment(loaded.default)) {
+        throw new TypeError('Default export must be created by deploy().');
+    }
+    return loaded.default.entrypoint.path;
+}
+function secretsFor(adapter, parameters, projectDir, runtime) {
+    const file = adapter.secretsFile?.(parameters);
+    if (file === undefined)
+        return { values: Object.freeze({}) };
+    const path = isAbsolute(file) ? file : join(projectDir, file);
+    // An Integration-free Runtime has no Providers and therefore no author-owned
+    // environment secrets. Adapter-owned secrets, such as the signing identity,
+    // are resolved separately by the adapter and must not make this file required.
+    if (Object.keys(runtime.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 === 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/lifecycle.d.ts

@@ -0,0 +1,9 @@
+/** 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;
+}