@rehearsal-db/core 0.1.0-rc.2 → 0.1.0-rc.4

package/dist/src/cli/runtime_commands.d.mts

@@ -8,6 +8,7 @@ import { buildRehearsalPlan } from "../runtime/plan.mjs";
 import { loadRuntimeTopology } from "../runtime/topology.mjs";
 import type { RuntimeTopologyTarget } from "../runtime/topology.mjs";
 import type { InstalledPackageFingerprint } from "../shared/operation_guard.mjs";
+import type { RuntimeStatusSnapshot } from "../runtime/status.mjs";
 import type { RehearsalCliFlags } from "./arguments.mjs";
 import type { RehearsalErrorCategory } from "../shared/diagnostics.mjs";
 import type { CliSessionState } from "./command_contract.mjs";
@@ -18,6 +19,7 @@ interface ManagerReceipt {
     readonly target: string;
     readonly durationMs: number;
     readonly output: string;
+    readonly runtimeStatus?: RuntimeStatusSnapshot;
 }
 interface RuntimeStackResult {
     readonly topology: RuntimeTopology;
@@ -73,6 +75,23 @@ export declare const buildRuntimeStackPlan: (planOptions: RehearsalConfigPathOpt
             sha256: string;
         }[];
     };
+    lifecycle: {
+        run: "keep-until-stop" | "stop-after-run";
+        open: "keep-until-stop" | "stop-on-application-exit";
+        dataOnStop: string;
+    };
+    application: {
+        startCommand: string;
+        proofCommand: string;
+        readiness: {
+            url: string;
+            expectedStatus: number;
+            timeoutSeconds: number;
+        } | null;
+    };
+    cleanup: {
+        retainBaselineGenerations: number;
+    };
     execution: string[];
     guarantee: string;
     paths: {
@@ -81,6 +100,39 @@ export declare const buildRuntimeStackPlan: (planOptions: RehearsalConfigPathOpt
         sanitizationPolicy: string;
     };
 } | {
+    config: {
+        schemaVersion: 1;
+        path: string;
+        project: string;
+    };
+    environment: {
+        target: "postgresql" | "supabase";
+        kind: string;
+        applicationUrl: string;
+        projectId: string;
+        ports: Readonly<{
+            api?: number;
+            database: number;
+            studio?: number;
+        }>;
+        hostedAccess: "disabled";
+        outboundNetwork: "deny";
+        authenticationProviders: readonly string[];
+        authenticationCallback: string | null;
+        barriers: string[];
+    };
+    application: {
+        startCommand: string;
+        proofCommand: string;
+        readiness: {
+            url: string;
+            expectedStatus: number;
+            timeoutSeconds: number;
+        } | null;
+    };
+    cleanup: {
+        retainBaselineGenerations: number;
+    };
     targets: {
         name: string;
         declaration: RuntimeTopologyTarget["declaration"];
@@ -90,6 +142,11 @@ export declare const buildRuntimeStackPlan: (planOptions: RehearsalConfigPathOpt
         candidateCount: number;
         candidateSha256: string;
     };
+    lifecycle: {
+        run: "keep-until-stop" | "stop-after-run";
+        open: "keep-until-stop" | "stop-on-application-exit";
+        dataOnStop: string;
+    };
     execution: string[];
     guarantee: string;
 }>;
@@ -209,9 +266,9 @@ export declare const createRuntimeCommands: ({ packageRoot, projectRoot, manager
             targets: readonly ManagerReceipt[];
         }>;
         preparations: {
+            target: string;
             command: string;
             output: string;
-            target: string;
         }[];
         application: {
             command: string;
@@ -222,11 +279,18 @@ export declare const createRuntimeCommands: ({ packageRoot, projectRoot, manager
             stoppedBy: string;
             diagnostics: import("../application/session.mjs").ApplicationDiagnostics;
         };
+        lifecycle: import("../runtime/persistence.mjs").RuntimePersistenceOutcome<ManagerReceipt | Readonly<{
+            action: RuntimeAction;
+            durationMs: number;
+            output: string;
+            targets: readonly ManagerReceipt[];
+        }>>;
     }>;
-    startRuntimeApplication: ({ flags, planOptions, session: commandSession, }: {
+    startRuntimeApplication: ({ flags, planOptions, session: commandSession, onRuntimeStarted, }: {
         flags: RehearsalCliFlags;
         planOptions: RehearsalConfigPathOptions;
         session: CliSessionState;
+        onRuntimeStarted?: () => void;
     }) => Promise<{
         started: ManagerReceipt | Readonly<{
             action: RuntimeAction;
@@ -241,9 +305,9 @@ export declare const createRuntimeCommands: ({ packageRoot, projectRoot, manager
             targets: readonly ManagerReceipt[];
         }>;
         preparations: {
+            target: string;
             command: string;
             output: string;
-            target: string;
         }[];
         command: string;
         session: import("../application/session.mjs").ApplicationSession;
@@ -257,11 +321,11 @@ export declare const createRuntimeCommands: ({ packageRoot, projectRoot, manager
     prepareDependentTargets: ({ topology, environment, }: {
         topology: RuntimeTopology;
         environment: NodeJS.ProcessEnv;
-    }) => {
+    }) => Promise<{
+        target: string;
         command: string;
         output: string;
-        target: string;
-    }[];
+    }[]>;
     proveRuntimeStack: ({ topology, planOptions, environment, }: {
         topology: RuntimeTopology;
         planOptions: RehearsalConfigPathOptions;
@@ -283,7 +347,7 @@ export declare const createRuntimeCommands: ({ packageRoot, projectRoot, manager
         configPath?: string;
         confirmation?: string;
         targetName?: string;
-    }) => ManagerReceipt;
+    }) => Promise<ManagerReceipt>;
     runRuntimeStack: ({ command, flags, planOptions, session, }: {
         command: RuntimeAction;
         flags: RehearsalCliFlags;

package/dist/src/cli/runtime_commands.mjs

@@ -13,7 +13,11 @@ import { buildRehearsalPlan, runRehearsalDoctor } from "../runtime/plan.mjs";
 import { inspectRuntimeTopologyCandidates, loadRuntimeTopology, } from "../runtime/topology.mjs";
 import { RehearsalError, normalizeRehearsalError, redactDiagnosticValue, } from "../shared/diagnostics.mjs";
 import { assertInstalledPackageFingerprint } from "../shared/operation_guard.mjs";
+import { getOperationCancellationSignal, throwIfOperationCancelled, } from "../shared/cancellation.mjs";
+import { runOwnedProcess } from "../shared/owned_process.mjs";
 import { buildRuntimeManagerArguments } from "../targets/target.mjs";
+import { parseRuntimeStatusSnapshot, renderRuntimeStatusSnapshot, } from "../runtime/status.mjs";
+import { applyRuntimePersistence } from "../runtime/persistence.mjs";
 import { formatDuration, isHumanTerminal, promptForConfirmation, terminalStyle, useStyledPrompts, } from "./terminal.mjs";
 const errorMessage = (error) => error instanceof Error ? error.message : String(error);
 export const buildRuntimeStackPlan = async (planOptions) => {
@@ -32,12 +36,22 @@ export const buildRuntimeStackPlan = async (planOptions) => {
         });
     }
     const candidates = await inspectRuntimeTopologyCandidates(planOptions);
+    const primaryPlan = targets[0].plan;
     return {
+        config: primaryPlan.config,
+        environment: primaryPlan.environment,
+        application: primaryPlan.application,
+        cleanup: primaryPlan.cleanup,
         targets,
         migrations: {
             candidateCount: candidates.candidateCount,
             candidateSha256: candidates.candidateSha256,
         },
+        lifecycle: {
+            run: topology.primary.config.lifecycle.run,
+            open: topology.primary.config.lifecycle.open,
+            dataOnStop: "preserved",
+        },
         execution: [
             "verify every immutable baseline and migration prefix",
             "restore and migrate the primary runtime",
@@ -47,6 +61,9 @@ export const buildRuntimeStackPlan = async (planOptions) => {
                 .map((target) => `run ${target.name} preparation: ${target.declaration.prepareCommand}`),
             ...topology.dependents.map((target) => `run ${target.name} proof: ${target.config.application.proofCommand}`),
             `run primary proof: ${topology.primary.config.application.proofCommand}`,
+            topology.primary.config.lifecycle.run === "stop-after-run"
+                ? "stop every database target after proofs while preserving its data"
+                : "keep every database target available until an explicit stop",
         ],
         guarantee: "Every database target is isolated by its own project ID, ports, artifact directory, and local-only safety policy. No production resources will be contacted.",
     };
@@ -256,15 +273,18 @@ export const topologyEnvironmentFiles = (topology) => ({
         target.paths.applicationEnvironment,
     ])),
 });
-const runProjectCommand = ({ source, configuredRoot, label, project, environment = {}, }) => {
+const runProjectCommand = async ({ source, configuredRoot, label, project, environment = {}, }) => {
     const [command, ...args] = parseCommand(source);
-    const result = spawnSync(command, args, {
+    const cancellationSignal = getOperationCancellationSignal();
+    const result = await runOwnedProcess({
+        command,
+        args,
         cwd: configuredRoot,
-        encoding: "utf8",
         env: projectCommandEnvironment(environment),
-        stdio: ["ignore", "pipe", "pipe"],
-        maxBuffer: 16 * 1024 * 1024,
+        stdin: "ignore",
+        ...(cancellationSignal ? { signal: cancellationSignal } : {}),
     });
+    throwIfOperationCancelled();
     if (result.error || result.status !== 0) {
         throw new RehearsalError({
             category: "application_proof_failure",
@@ -286,7 +306,7 @@ const runProjectCommand = ({ source, configuredRoot, label, project, environment
     };
 };
 export const createRuntimeCommands = ({ packageRoot, projectRoot, managerPath, getActivePackageFingerprint, }) => {
-    const runManager = ({ action, flags, configPath = flags.configPath, confirmation = flags.confirmation, targetName, }) => {
+    const runManager = async ({ action, flags, configPath = flags.configPath, confirmation = flags.confirmation, targetName, }) => {
         const fingerprint = getActivePackageFingerprint();
         if (fingerprint) {
             assertInstalledPackageFingerprint({
@@ -299,6 +319,7 @@ export const createRuntimeCommands = ({ packageRoot, projectRoot, managerPath, g
             action,
             ...(configPath === undefined ? {} : { configPath }),
             ...(confirmation === undefined ? {} : { confirmation }),
+            structuredResult: action === "status",
         });
         const runtimeStartedMs = performance.now();
         const actionDescription = {
@@ -321,13 +342,25 @@ export const createRuntimeCommands = ({ packageRoot, projectRoot, managerPath, g
         else if (isHumanTerminal(flags)) {
             console.log(`\n${terminalStyle(flags, "1;36", action === "run" ? "REHEARSING" : "REHEARSAL")}\n${terminalStyle(flags, "36", "→")} ${describedAction}. This can take a moment.`);
         }
-        const result = spawnSync(process.execPath, args, {
+        const cancellationSignal = getOperationCancellationSignal();
+        // VS Code extensions launch the package CLI through Electron's executable in
+        // Node mode. Preserve that mode only for Rehearsal's nested Node manager;
+        // project-owned application commands continue to receive the reduced
+        // project environment above.
+        const managerEnvironment = {
+            ...(cancellationSignal ? { REHEARSAL_CANCELLABLE_OPERATION: "1" } : {}),
+            ...(process.env.ELECTRON_RUN_AS_NODE === "1"
+                ? { ELECTRON_RUN_AS_NODE: "1" }
+                : {}),
+        };
+        const result = await runOwnedProcess({
+            command: process.execPath,
+            args,
             cwd: projectRoot,
-            encoding: "utf8",
-            env: projectCommandEnvironment(),
-            stdio: ["inherit", "pipe", "pipe"],
-            maxBuffer: 16 * 1024 * 1024,
+            env: projectCommandEnvironment(managerEnvironment),
+            ...(cancellationSignal ? { signal: cancellationSignal } : {}),
         });
+        throwIfOperationCancelled();
         const currentFingerprint = getActivePackageFingerprint();
         if (currentFingerprint) {
             assertInstalledPackageFingerprint({
@@ -396,11 +429,17 @@ export const createRuntimeCommands = ({ packageRoot, projectRoot, managerPath, g
         else if (isHumanTerminal(flags)) {
             console.log(`${terminalStyle(flags, "32", "✓")} Local runtime step completed in ${formatDuration(durationMs)}.`);
         }
+        const runtimeStatus = action === "status"
+            ? parseRuntimeStatusSnapshot(JSON.parse(String(result.stdout ?? "")))
+            : undefined;
         return {
             action,
             target: targetName ?? "primary",
             durationMs: Math.round(durationMs * 100) / 100,
-            output: String(redactDiagnosticValue(String(result.stdout ?? "").trim())),
+            output: runtimeStatus
+                ? renderRuntimeStatusSnapshot(runtimeStatus)
+                : String(redactDiagnosticValue(String(result.stdout ?? "").trim())),
+            ...(runtimeStatus ? { runtimeStatus } : {}),
         };
     };
     const runRuntimeStack = async ({ command, flags, planOptions, session, }) => {
@@ -410,16 +449,17 @@ export const createRuntimeCommands = ({ packageRoot, projectRoot, managerPath, g
         const targets = reverse
             ? [...topology.targets].reverse()
             : topology.targets;
-        const results = targets.map((target) => {
+        const results = [];
+        for (const target of targets) {
             const confirmation = session.targetConfirmations?.get(target.configPath);
-            return runManager({
+            results.push(await runManager({
                 action: command,
                 flags,
                 configPath: target.configPath,
                 ...(confirmation === undefined ? {} : { confirmation }),
                 ...(topology.targets.length > 1 ? { targetName: target.name } : {}),
-            });
-        });
+            }));
+        }
         if (results.length === 1)
             return { topology, runtime: results[0] };
         return {
@@ -449,22 +489,24 @@ export const createRuntimeCommands = ({ packageRoot, projectRoot, managerPath, g
                 : { environment: options.environment }),
         });
     };
-    const prepareDependentTargets = ({ topology, environment, }) => topology.dependents.flatMap((target) => {
-        if (!target.declaration?.prepareCommand)
-            return [];
-        return [
-            {
+    const prepareDependentTargets = async ({ topology, environment, }) => {
+        const preparations = [];
+        for (const target of topology.dependents) {
+            if (!target.declaration?.prepareCommand)
+                continue;
+            preparations.push({
                 target: target.name,
-                ...runProjectCommand({
+                ...(await runProjectCommand({
                     source: target.declaration.prepareCommand,
                     configuredRoot: topology.projectRoot,
                     label: `preparation command for ${target.name}`,
                     project: topology.primary.config.project.name,
                     environment,
-                }),
-            },
-        ];
-    });
+                })),
+            });
+        }
+        return preparations;
+    };
     const proveRuntimeStack = async ({ topology, planOptions, environment, }) => {
         const dependentProofs = [];
         for (const target of topology.dependents) {
@@ -479,7 +521,7 @@ export const createRuntimeCommands = ({ packageRoot, projectRoot, managerPath, g
         });
         return { applicationProof, dependentProofs };
     };
-    const startRuntimeApplication = async ({ flags, planOptions, session: commandSession, }) => {
+    const startRuntimeApplication = async ({ flags, planOptions, session: commandSession, onRuntimeStarted = () => undefined, }) => {
         const topology = await loadRuntimeTopology(planOptions);
         const application = topology.primary.config.application;
         if (!application.readiness) {
@@ -505,13 +547,14 @@ export const createRuntimeCommands = ({ packageRoot, projectRoot, managerPath, g
             planOptions,
             session: commandSession,
         });
+        onRuntimeStarted();
         const verified = await runRuntimeStack({
             command: "verify",
             flags,
             planOptions,
             session: commandSession,
         });
-        const preparations = prepareDependentTargets({
+        const preparations = await prepareDependentTargets({
             topology,
             environment: topologyCommandEnvironment(topology),
         });
@@ -531,15 +574,34 @@ export const createRuntimeCommands = ({ packageRoot, projectRoot, managerPath, g
         };
     };
     const openRuntimeApplication = async ({ flags, planOptions, session: commandSession, onReady = () => undefined, }) => {
-        const active = await startRuntimeApplication({
-            flags,
-            planOptions,
-            session: commandSession,
-        });
-        const closed = await holdApplicationSession({
-            session: active.session,
-            onReady,
+        const topology = await loadRuntimeTopology(planOptions);
+        let runtimeStarted = false;
+        const { result, lifecycle } = await applyRuntimePersistence({
+            mode: topology.primary.config.lifecycle.open,
+            canStop: () => runtimeStarted,
+            operation: async () => {
+                const active = await startRuntimeApplication({
+                    flags,
+                    planOptions,
+                    session: commandSession,
+                    onRuntimeStarted: () => {
+                        runtimeStarted = true;
+                    },
+                });
+                const closed = await holdApplicationSession({
+                    session: active.session,
+                    onReady,
+                });
+                return { active, closed };
+            },
+            stop: async () => (await runRuntimeStack({
+                command: "stop",
+                flags,
+                planOptions,
+                session: commandSession,
+            })).runtime,
         });
+        const { active, closed } = result;
         return {
             action: "open",
             started: active.started,
@@ -551,6 +613,7 @@ export const createRuntimeCommands = ({ packageRoot, projectRoot, managerPath, g
                 stoppedBy: closed.signal,
                 diagnostics: closed.diagnostics,
             },
+            lifecycle,
         };
     };
     const prepareCandidateConfirmation = async ({ command, flags, planOptions, session, }) => {

package/dist/src/cli/source_commands.d.mts

@@ -2,6 +2,7 @@
  * CLI orchestration for temporary production-source access and safe baseline
  * replacement. Domain validation remains in src/source and src/baseline.
  */
+import { activateBaselineGeneration } from "../baseline/artifact.mjs";
 import type { RehearsalConfigPathOptions } from "../project/configuration.mjs";
 import type { RehearsalCliFlags } from "./arguments.mjs";
 import type { CliSessionState } from "./command_contract.mjs";
@@ -53,6 +54,10 @@ export declare const loadPreparationContext: (planOptions: RehearsalConfigPathOp
             containerRuntime: Readonly<{
                 autoStartColima: boolean;
             }>;
+            lifecycle: Readonly<{
+                run: "keep-until-stop" | "stop-after-run";
+                open: "keep-until-stop" | "stop-on-application-exit";
+            }>;
             cleanup: Readonly<{
                 retainBaselineGenerations: number;
             }>;
@@ -201,6 +206,10 @@ export declare const buildRefreshWorkflowPlan: (planOptions: RehearsalConfigPath
             containerRuntime: Readonly<{
                 autoStartColima: boolean;
             }>;
+            lifecycle: Readonly<{
+                run: "keep-until-stop" | "stop-after-run";
+                open: "keep-until-stop" | "stop-on-application-exit";
+            }>;
             cleanup: Readonly<{
                 retainBaselineGenerations: number;
             }>;
@@ -323,7 +332,7 @@ export declare const buildRefreshWorkflowPlan: (planOptions: RehearsalConfigPath
         digest: string;
     };
 }>;
-export declare const createRefreshWorkflow: ({ runRuntimeStack, prepareDependentTargets, topologyCommandEnvironment, buildPlan, refreshBaseline, }: {
+export declare const createRefreshWorkflow: ({ runRuntimeStack, prepareDependentTargets, topologyCommandEnvironment, buildPlan, refreshBaseline, activateBaseline, }: {
     runRuntimeStack: (input: {
         command: "reset";
         flags: RehearsalCliFlags;
@@ -336,10 +345,11 @@ export declare const createRefreshWorkflow: ({ runRuntimeStack, prepareDependent
     prepareDependentTargets: (input: {
         topology: RuntimeTopology;
         environment: NodeJS.ProcessEnv;
-    }) => unknown[];
+    }) => Promise<unknown[]>;
     topologyCommandEnvironment: (topology: RuntimeTopology) => NodeJS.ProcessEnv;
     buildPlan?: (options: RehearsalConfigPathOptions) => Promise<RefreshPlanContext>;
     refreshBaseline?: typeof runSourceBaselineRefresh;
+    activateBaseline?: typeof activateBaselineGeneration;
 }) => ({ flags, planOptions, session, }: SourceCommandInput & {
     session: CliSessionState;
 }) => Promise<{

package/dist/src/cli/source_commands.mjs

@@ -14,6 +14,7 @@ import { refreshPostgresqlBaseline } from "../source/baseline.mjs";
 import { resolvePrivacyMappedAssets } from "../source/privacy_paths.mjs";
 import { applyPostgresqlSourceAccess, planPostgresqlSourceAccessRetirement, resolvePostgresqlSourceStatePaths, retirePostgresqlSourceAccess, } from "../source/postgresql_access.mjs";
 import { loadRuntimeTopology } from "../runtime/topology.mjs";
+import { isOperationCancelled, throwIfOperationCancelled, withOperationCancellationShield, } from "../shared/cancellation.mjs";
 const parseSourceAccessReceipt = (source) => {
     const parsed = JSON.parse(source);
     if (typeof parsed.targetFingerprint !== "string" ||
@@ -224,7 +225,7 @@ export const buildRefreshWorkflowPlan = async (planOptions) => {
         },
     };
 };
-export const createRefreshWorkflow = ({ runRuntimeStack, prepareDependentTargets, topologyCommandEnvironment, buildPlan = buildRefreshWorkflowPlan, refreshBaseline = runSourceBaselineRefresh, }) => async ({ flags, planOptions, session, }) => {
+export const createRefreshWorkflow = ({ runRuntimeStack, prepareDependentTargets, topologyCommandEnvironment, buildPlan = buildRefreshWorkflowPlan, refreshBaseline = runSourceBaselineRefresh, activateBaseline = activateBaselineGeneration, }) => async ({ flags, planOptions, session, }) => {
     const context = await buildPlan(planOptions);
     if (!flags.refreshConfirmation) {
         return { mode: "preview", plan: context.plan };
@@ -236,40 +237,48 @@ export const createRefreshWorkflow = ({ runRuntimeStack, prepareDependentTargets
     let runtime;
     let preparations = [];
     try {
+        throwIfOperationCancelled();
         refreshed = await refreshBaseline({ planOptions });
+        throwIfOperationCancelled();
         const stack = await runRuntimeStack({
             command: "reset",
             flags,
             planOptions,
             session,
         });
+        throwIfOperationCancelled();
         runtime = stack.runtime;
-        preparations = prepareDependentTargets({
+        preparations = await prepareDependentTargets({
             topology: stack.topology,
             environment: topologyCommandEnvironment(stack.topology),
         });
+        throwIfOperationCancelled();
     }
     catch (error) {
         if (refreshed) {
-            await activateBaselineGeneration({
-                artifactRoot: context.loaded.paths.artifactDirectory,
-                generationId: context.plan.review.currentBaseline,
-            });
             try {
-                const rollback = await runRuntimeStack({
-                    command: "reset",
-                    flags,
-                    planOptions,
-                    session,
-                });
-                prepareDependentTargets({
-                    topology: rollback.topology,
-                    environment: topologyCommandEnvironment(rollback.topology),
+                await withOperationCancellationShield(async () => {
+                    await activateBaseline({
+                        artifactRoot: context.loaded.paths.artifactDirectory,
+                        generationId: context.plan.review.currentBaseline,
+                    });
+                    const rollback = await runRuntimeStack({
+                        command: "reset",
+                        flags,
+                        planOptions,
+                        session,
+                    });
+                    await prepareDependentTargets({
+                        topology: rollback.topology,
+                        environment: topologyCommandEnvironment(rollback.topology),
+                    });
                 });
             }
             catch (rollbackError) {
                 throw new AggregateError([error, rollbackError], "The refreshed runtime failed and the previous local runtime could not be restored automatically. The previous immutable baseline is active; run rehearsal reset after correcting the reported problem.");
             }
+            if (isOperationCancelled(error))
+                throw error;
             throw new Error("The refreshed runtime failed verification. Rehearsal restored the previous baseline and local runtime.", { cause: error });
         }
         throw error;

package/dist/src/index.d.mts

@@ -1,4 +1,4 @@
 /** Public Rehearsal package entry point. */
-export { REHEARSAL_CONFIG_VERSION, defineRehearsalConfig, findRehearsalConfigPath, inspectDetectedProject, loadRehearsalConfig, renderDetectedConfig, renderDetectedPostgresqlConfig, } from "./project/configuration.mjs";
-export type { DetectedProject, NormalizedRehearsalConfig, RehearsalConfig, RehearsalConfigPathOptions, RehearsalConfigVersion, } from "./project/configuration.mjs";
+export { REHEARSAL_CONFIG_VERSION, defineRehearsalConfig, discoverProjectProfile, findRehearsalConfigPath, inspectDetectedProject, PROJECT_DISCOVERY_SCHEMA_VERSION, loadRehearsalConfig, renderDetectedConfig, renderDetectedPostgresqlConfig, } from "./project/configuration.mjs";
+export type { DetectedProject, DecisionDiscoveryItem, DetectedDiscoveryItem, DiscoveredConfigurationField, DiscoveryConfidence, DiscoveryEvidence, DiscoveryValue, NormalizedRehearsalConfig, ProjectDiscoveryResult, RehearsalConfig, RehearsalConfigPathOptions, RehearsalConfigVersion, } from "./project/configuration.mjs";
 export { EXCLUDED_VALUE, SANITIZATION_ACTIONS, applySanitizationAction, normalizeSanitizationAction, readBoundRuntimeSanitizationPolicy, validateSanitizationCoverage, validateRuntimeSanitizationPolicy, } from "./baseline/sanitization_policy.mjs";

package/dist/src/index.mjs

@@ -1,3 +1,3 @@
 /** Public Rehearsal package entry point. */
-export { REHEARSAL_CONFIG_VERSION, defineRehearsalConfig, findRehearsalConfigPath, inspectDetectedProject, loadRehearsalConfig, renderDetectedConfig, renderDetectedPostgresqlConfig, } from "./project/configuration.mjs";
+export { REHEARSAL_CONFIG_VERSION, defineRehearsalConfig, discoverProjectProfile, findRehearsalConfigPath, inspectDetectedProject, PROJECT_DISCOVERY_SCHEMA_VERSION, loadRehearsalConfig, renderDetectedConfig, renderDetectedPostgresqlConfig, } from "./project/configuration.mjs";
 export { EXCLUDED_VALUE, SANITIZATION_ACTIONS, applySanitizationAction, normalizeSanitizationAction, readBoundRuntimeSanitizationPolicy, validateSanitizationCoverage, validateRuntimeSanitizationPolicy, } from "./baseline/sanitization_policy.mjs";

package/dist/src/project/configuration.d.mts

@@ -10,4 +10,6 @@ export { loadRehearsalConfig } from "./configuration_resolution.mjs";
 export type { NormalizedRehearsalConfig } from "./configuration_resolution.mjs";
 export { inspectDetectedProject } from "./project_detection.mjs";
 export type { DetectedProject } from "./project_detection.mjs";
+export { discoverProjectProfile, probeContainerEngineWithoutStarting, PROJECT_DISCOVERY_SCHEMA_VERSION, } from "./project_discovery.mjs";
+export type { ContainerEngineProbe, DecisionDiscoveryItem, DetectedDiscoveryItem, DiscoveredConfigurationField, DiscoveryConfidence, DiscoveryEvidence, DiscoveryValue, ProjectDiscoveryResult, SuggestedDiscoveryItem, } from "./project_discovery.mjs";
 export { renderDetectedConfig, renderDetectedPostgresqlConfig, } from "./configuration_rendering.mjs";

package/dist/src/project/configuration.mjs

@@ -6,4 +6,5 @@ export { defineRehearsalConfig, REHEARSAL_CONFIG_VERSION, REHEARSAL_DEFAULTS, }
 export { findRehearsalConfigPath } from "./configuration_discovery.mjs";
 export { loadRehearsalConfig } from "./configuration_resolution.mjs";
 export { inspectDetectedProject } from "./project_detection.mjs";
+export { discoverProjectProfile, probeContainerEngineWithoutStarting, PROJECT_DISCOVERY_SCHEMA_VERSION, } from "./project_discovery.mjs";
 export { renderDetectedConfig, renderDetectedPostgresqlConfig, } from "./configuration_rendering.mjs";

package/dist/src/project/configuration_contract.d.mts

@@ -1,5 +1,7 @@
 /** Public configuration types, format version, and stable defaults. */
 export type RehearsalConfigVersion = 1;
+export type RunPersistenceMode = "keep-until-stop" | "stop-after-run";
+export type OpenPersistenceMode = "keep-until-stop" | "stop-on-application-exit";
 export interface RehearsalConfig {
     schemaVersion: RehearsalConfigVersion;
     project: {
@@ -38,6 +40,10 @@ export interface RehearsalConfig {
     containerRuntime?: {
         autoStartColima?: boolean;
     };
+    lifecycle?: {
+        run?: RunPersistenceMode;
+        open?: OpenPersistenceMode;
+    };
     cleanup?: {
         retainBaselineGenerations?: number;
     };
@@ -108,6 +114,10 @@ export declare const REHEARSAL_DEFAULTS: Readonly<{
     containerRuntime: Readonly<{
         autoStartColima: false;
     }>;
+    lifecycle: Readonly<{
+        run: RunPersistenceMode;
+        open: OpenPersistenceMode;
+    }>;
     cleanup: Readonly<{
         retainBaselineGenerations: 2;
     }>;

package/dist/src/project/configuration_contract.mjs

@@ -3,6 +3,10 @@ export const REHEARSAL_CONFIG_VERSION = 1;
 export const REHEARSAL_DEFAULTS = Object.freeze({
     baseline: Object.freeze({ artifactDirectory: ".rehearsal" }),
     containerRuntime: Object.freeze({ autoStartColima: false }),
+    lifecycle: Object.freeze({
+        run: "keep-until-stop",
+        open: "keep-until-stop",
+    }),
     cleanup: Object.freeze({ retainBaselineGenerations: 2 }),
     runtime: Object.freeze({
         applicationUrl: "http://localhost:5175",

package/dist/src/project/configuration_normalization.d.mts

@@ -41,6 +41,10 @@ export declare const normalizeRehearsalConfig: (input: unknown) => Readonly<{
     containerRuntime: Readonly<{
         autoStartColima: boolean;
     }>;
+    lifecycle: Readonly<{
+        run: "keep-until-stop" | "stop-after-run";
+        open: "keep-until-stop" | "stop-on-application-exit";
+    }>;
     cleanup: Readonly<{
         retainBaselineGenerations: number;
     }>;