@timurproko/a1 0.1.8-dev.472 → 0.1.8-dev.508

package/dist/foundation/release/bootstrap.d.ts

@@ -1,4 +1,3 @@
-import { type OwnershipProbe } from "./cohort-selection.js";
 import { type SupervisorEndpointMetadata } from "./cohort-state.js";
 import { resolveProductPaths, type SessionSelection, type LaunchProfileId, type SupervisorStartupAttemptIdentity } from "../lifecycle/index.js";
 import { cleanupProvenIdleOwner } from "./process-cleanup.js";
@@ -45,11 +44,8 @@ export declare function startSupervisor(release: MaterializedRelease, environmen
  */
 export declare function releaseEnvironment(environment: NodeJS.ProcessEnv, release: MaterializedRelease, profile?: LaunchProfileId): NodeJS.ProcessEnv;
 export declare function waitForVerifiedEndpoint(path: string, release: MaterializedRelease, timeoutMs: number, startup?: SupervisorStartupAttempt): Promise<void>;
-export declare function readEndpointMetadata(path: string): Promise<SupervisorEndpointMetadata | null>;
-export declare function probeOwnership(metadata: SupervisorEndpointMetadata): Promise<OwnershipProbe>;
 export declare function releaseVerifiedIdleOwner(metadata: SupervisorEndpointMetadata, dataDir: string, operations?: {
     readonly waitForExit?: typeof waitForProcessExit;
     readonly cleanup?: typeof cleanupProvenIdleOwner;
 }): Promise<boolean>;
 export declare function waitForProcessExit(pid: number, timeoutMs: number): Promise<void>;
-export declare function removeEndpointArtifacts(metadataPath: string, endpoint: string): Promise<void>;

package/dist/foundation/release/bootstrap.js

@@ -9,7 +9,7 @@ import { CohortStateStore } from "./cohort-state.js";
 import { assertLaunchProfileId, createSupervisorStartupAttempt, readSupervisorStartupResult, resolveCohortEndpoint, resolveProductPaths, sessionSelectionArguments } from "../lifecycle/index.js";
 import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
 import { cleanupProvenIdleOwner, processIsAlive } from "./process-cleanup.js";
-import { sweepDeadEndpoints } from "./endpoints.js";
+import { probeOwnership, readEndpointMetadata, removeEndpointArtifacts, sweepDeadEndpoints } from "./endpoints.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
 import { selectUpdateLaunchRelease } from "./update-launch.js";
 import { consumeMaterializationProof, materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease } from "./release-store.js";
@@ -355,79 +355,6 @@ export async function waitForVerifiedEndpoint(path, release, timeoutMs, startup)
         throw collision;
     throw new Error(PRODUCT_TEXT.diagnostic(`supervisor did not publish verified endpoint metadata within ${timeoutMs}ms`));
 }
-export async function readEndpointMetadata(path) {
-    try {
-        const value = JSON.parse(await readFile(path, "utf8"));
-        const ownership = value.ownership;
-        const liveInstanceIds = Array.isArray(ownership?.liveInstanceIds)
-            ? ownership.liveInstanceIds
-            : Array.isArray(ownership?.liveGenerationIds) ? ownership.liveGenerationIds : null;
-        const nonResumableInstanceIds = Array.isArray(ownership?.nonResumableInstanceIds)
-            ? ownership.nonResumableInstanceIds
-            : Array.isArray(ownership?.nonResumableGenerationIds) ? ownership.nonResumableGenerationIds : null;
-        const uncertainInstanceIds = Array.isArray(ownership?.uncertainInstanceIds) ? ownership.uncertainInstanceIds : [];
-        if (!value || value.schema !== PRODUCT_IDENTITY.protocol.supervisorSchema || typeof value.supervisorId !== "string" || typeof value.endpoint !== "string" || !Number.isSafeInteger(value.pid)
-            || typeof value.pidStartIdentity !== "string" || typeof value.bootNonce !== "string" || typeof value.releaseId !== "string"
-            || typeof value.releaseRoot !== "string" || typeof value.contentDigest !== "string" || !ownership
-            || !isStringArray(liveInstanceIds) || !isStringArray(nonResumableInstanceIds) || !isStringArray(uncertainInstanceIds)) {
-            return null;
-        }
-        return {
-            ...value,
-            ownership: {
-                ...ownership,
-                liveInstanceIds,
-                nonResumableInstanceIds,
-                uncertainInstanceIds,
-            },
-        };
-    }
-    catch {
-        return null;
-    }
-}
-export async function probeOwnership(metadata) {
-    if (!processIsAlive(metadata.pid))
-        return "dead";
-    const identity = await requestIdentity(metadata.endpoint, 500);
-    if (!identity)
-        return "unresponsive";
-    return identity.supervisorId === metadata.supervisorId
-        && identity.bootNonce === metadata.bootNonce
-        && identity.pidStartIdentity === metadata.pidStartIdentity
-        && identity.releaseId === metadata.releaseId
-        ? "live-verified"
-        : "identity-mismatch";
-}
-async function requestIdentity(endpoint, timeoutMs) {
-    return await new Promise(resolvePromise => {
-        const socket = connect(endpoint);
-        const decoder = new LineFrameDecoder();
-        let settled = false;
-        const finish = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            socket.destroy();
-            resolvePromise(value);
-        };
-        socket.once("error", () => finish(null));
-        socket.once("connect", () => socket.write(encodeFrame({ type: "identity-probe" })));
-        socket.on("data", chunk => {
-            try {
-                const message = decoder.push(chunk)[0];
-                if (message?.type === "identity" && typeof message.supervisorId === "string" && typeof message.bootNonce === "string"
-                    && typeof message.pidStartIdentity === "string" && typeof message.releaseId === "string") {
-                    finish({ supervisorId: message.supervisorId, bootNonce: message.bootNonce, pidStartIdentity: message.pidStartIdentity, releaseId: message.releaseId });
-                }
-            }
-            catch {
-                finish(null);
-            }
-        });
-        setTimeout(() => finish(null), timeoutMs).unref();
-    });
-}
 async function activatePendingAfterBlockerExit(candidate, stateStore, paths, environment) {
     const deadline = Date.now() + 2_000;
     let endpoint = null;
@@ -489,9 +416,6 @@ async function requestIdleOwnershipRelease(metadata, candidateReleaseId, timeout
         setTimeout(() => finish(false), timeoutMs).unref();
     });
 }
-function isStringArray(value) {
-    return Array.isArray(value) && value.every(item => typeof item === "string" && item.length > 0);
-}
 export async function waitForProcessExit(pid, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -501,8 +425,3 @@ export async function waitForProcessExit(pid, timeoutMs) {
     }
     throw new Error(PRODUCT_TEXT.diagnostic(`supervisor ${pid} did not release process ownership within ${timeoutMs}ms`));
 }
-export async function removeEndpointArtifacts(metadataPath, endpoint) {
-    await rm(metadataPath, { force: true });
-    if (platform() !== "win32")
-        await rm(endpoint, { force: true });
-}

package/dist/foundation/release/dependency-layer.d.ts

@@ -1,6 +1,8 @@
 import { type ReadDependencyCertificationOptions } from "./dependency-certification.js";
 export { dependencyLayerCertificationPath, legacyDependencyLayerCertificationPath } from "./dependency-certification.js";
 import { type ReleaseFileIdentity } from "./release.js";
+import type { DependencyLayerReference } from "./types.js";
+export type { DependencyLayerReference } from "./types.js";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 export declare const DEPENDENCY_LAYER_SCHEMA: string;
 export declare const DEPENDENCY_LAYER_MANIFEST = "dependency-layer-manifest.json";
@@ -25,11 +27,6 @@ export interface DependencyLayerIdentity {
     readonly files: readonly ReleaseFileIdentity[];
     readonly inventory: RuntimePayloadInventory;
 }
-export interface DependencyLayerReference {
-    readonly layerId: string;
-    readonly contentDigest: string;
-    readonly binding: "node_modules";
-}
 export interface MaterializedDependencyLayer extends DependencyLayerIdentity {
     readonly layerRoot: string;
     readonly reused: boolean;

package/dist/foundation/release/endpoints.d.ts

@@ -1,3 +1,4 @@
+import type { OwnershipProbe } from "./cohort-selection.js";
 import type { SupervisorEndpointMetadata } from "./cohort-state.js";
 import type { CohortEndpointPaths, ProductPaths } from "../lifecycle/index.js";
 export interface RecordedEndpoint {
@@ -18,3 +19,6 @@ export declare function listRecordedEndpoints(paths: ProductPaths): Promise<read
 export declare function sweepDeadEndpoints(paths: ProductPaths): Promise<readonly string[]>;
 /** The releases that an identity-verified live cohort runs from and that must be retained. */
 export declare function liveReleaseIds(paths: ProductPaths): Promise<readonly string[]>;
+export declare function readEndpointMetadata(path: string): Promise<SupervisorEndpointMetadata | null>;
+export declare function probeOwnership(metadata: SupervisorEndpointMetadata): Promise<OwnershipProbe>;
+export declare function removeEndpointArtifacts(metadataPath: string, endpoint: string): Promise<void>;

package/dist/foundation/release/endpoints.js

@@ -1,6 +1,9 @@
-import { readdir } from "node:fs/promises";
+import { readdir, readFile, rm } from "node:fs/promises";
+import { connect } from "node:net";
+import { platform } from "node:os";
 import { resolve } from "node:path";
-import { probeOwnership, readEndpointMetadata, removeEndpointArtifacts } from "./bootstrap.js";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
 import { processIsAlive } from "./process-cleanup.js";
 /**
  * Every endpoint recorded under this runtime directory: one per cohort, plus the single
@@ -48,3 +51,84 @@ export async function liveReleaseIds(paths) {
     })));
     return [...new Set(ownership.filter(item => item.probe === "live-verified").map(item => item.releaseId))].sort();
 }
+export async function readEndpointMetadata(path) {
+    try {
+        const value = JSON.parse(await readFile(path, "utf8"));
+        const ownership = value.ownership;
+        const liveInstanceIds = Array.isArray(ownership?.liveInstanceIds)
+            ? ownership.liveInstanceIds
+            : Array.isArray(ownership?.liveGenerationIds) ? ownership.liveGenerationIds : null;
+        const nonResumableInstanceIds = Array.isArray(ownership?.nonResumableInstanceIds)
+            ? ownership.nonResumableInstanceIds
+            : Array.isArray(ownership?.nonResumableGenerationIds) ? ownership.nonResumableGenerationIds : null;
+        const uncertainInstanceIds = Array.isArray(ownership?.uncertainInstanceIds) ? ownership.uncertainInstanceIds : [];
+        if (!value || value.schema !== PRODUCT_IDENTITY.protocol.supervisorSchema || typeof value.supervisorId !== "string" || typeof value.endpoint !== "string" || !Number.isSafeInteger(value.pid)
+            || typeof value.pidStartIdentity !== "string" || typeof value.bootNonce !== "string" || typeof value.releaseId !== "string"
+            || typeof value.releaseRoot !== "string" || typeof value.contentDigest !== "string" || !ownership
+            || !isStringArray(liveInstanceIds) || !isStringArray(nonResumableInstanceIds) || !isStringArray(uncertainInstanceIds)) {
+            return null;
+        }
+        return {
+            ...value,
+            ownership: {
+                ...ownership,
+                liveInstanceIds,
+                nonResumableInstanceIds,
+                uncertainInstanceIds,
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function probeOwnership(metadata) {
+    if (!processIsAlive(metadata.pid))
+        return "dead";
+    const identity = await requestIdentity(metadata.endpoint, 500);
+    if (!identity)
+        return "unresponsive";
+    return identity.supervisorId === metadata.supervisorId
+        && identity.bootNonce === metadata.bootNonce
+        && identity.pidStartIdentity === metadata.pidStartIdentity
+        && identity.releaseId === metadata.releaseId
+        ? "live-verified"
+        : "identity-mismatch";
+}
+async function requestIdentity(endpoint, timeoutMs) {
+    return await new Promise(resolvePromise => {
+        const socket = connect(endpoint);
+        const decoder = new LineFrameDecoder();
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolvePromise(value);
+        };
+        socket.once("error", () => finish(null));
+        socket.once("connect", () => socket.write(encodeFrame({ type: "identity-probe" })));
+        socket.on("data", chunk => {
+            try {
+                const message = decoder.push(chunk)[0];
+                if (message?.type === "identity" && typeof message.supervisorId === "string" && typeof message.bootNonce === "string"
+                    && typeof message.pidStartIdentity === "string" && typeof message.releaseId === "string") {
+                    finish({ supervisorId: message.supervisorId, bootNonce: message.bootNonce, pidStartIdentity: message.pidStartIdentity, releaseId: message.releaseId });
+                }
+            }
+            catch {
+                finish(null);
+            }
+        });
+        setTimeout(() => finish(null), timeoutMs).unref();
+    });
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every(item => typeof item === "string" && item.length > 0);
+}
+export async function removeEndpointArtifacts(metadataPath, endpoint) {
+    await rm(metadataPath, { force: true });
+    if (platform() !== "win32")
+        await rm(endpoint, { force: true });
+}

package/dist/foundation/release/index.d.ts

@@ -1,16 +1,30 @@
-export * from "./bootstrap.js";
-export * from "./cohort-selection.js";
-export * from "./cohort-state.js";
-export * from "./dependency-layer.js";
-export * from "./endpoints.js";
-export * from "./process-cleanup.js";
-export * from "./release.js";
-export * from "./release-gc.js";
-export * from "./release-store.js";
-export * from "./restart-certification.js";
-export * from "./stable-release.js";
-export * from "./update.js";
-export * from "./update-launch.js";
-export * from "./update-recovery.js";
-export * from "./update-transaction.js";
-export * from "./warmup.js";
+export { certifyMaterializedRelease, ensureSupervisor, recordParentCertifiedRelease, releaseEnvironment, releaseVerifiedIdleOwner, runBootstrap, startSupervisor, waitForProcessExit, waitForVerifiedEndpoint, } from "./bootstrap.js";
+export type { BootstrapOptions, SupervisorStartupAttempt } from "./bootstrap.js";
+export { selectCohortLaunch } from "./cohort-selection.js";
+export type { CohortLaunchDecision, OwnershipProbe } from "./cohort-selection.js";
+export { CohortStateStore, RELEASE_COHORT_SCHEMA, emptyState, planProtectedReleases } from "./cohort-state.js";
+export type { ActiveReleaseTransactionReference, CohortState, EndpointOwnership, ExternalReleaseHold, ExternalReleaseHoldAuthority, OrphanReleaseDisposition, ProtectedReleaseInputs, ProtectedReleasePlan, ReleaseApproval, ReleaseCleanupDiagnostic, ReleaseCleanupDisposition, ReleaseCleanupStage, ReleaseCleanupState, ReleaseCleanupWorkerRun, ReleaseCleanupWorkerStatus, ReleaseCleanupWorkerSummary, ReleaseRecord, ReleaseReferences, ReleaseRetentionReconciliation, SupervisorEndpointMetadata, } from "./cohort-state.js";
+export { DEPENDENCY_LAYER_MANIFEST, DEPENDENCY_LAYER_SCHEMA, RUNTIME_PAYLOAD_INVENTORY, dependencyLayerCertificationPath, dependencyReference, generateDependencyRuntimePayload, legacyDependencyLayerCertificationPath, materializeDependencyLayer, readCertifiedDependencyLayer, selectDependencyRuntimePayload, selectPublishedDependencyRuntimePayload, verifyDependencyLayer, } from "./dependency-layer.js";
+export type { DependencyLayerIdentity, DependencyLayerOperationEvent, DependencyLayerReference, GeneratedRuntimePayload, MaterializeDependencyLayerOptions, MaterializedDependencyLayer, PublishedRuntimeFileClassification, PublishedRuntimePayload, ReadCertifiedDependencyLayerOptions, RuntimePayloadExclusion, RuntimePayloadInventory, SelectedRuntimePayload, } from "./dependency-layer.js";
+export { listRecordedEndpoints, liveReleaseIds, probeOwnership, readEndpointMetadata, removeEndpointArtifacts, sweepDeadEndpoints } from "./endpoints.js";
+export type { RecordedEndpoint } from "./endpoints.js";
+export { cleanupProvenIdleOwner, cleanupVerifiedOwner, processIsAlive } from "./process-cleanup.js";
+export type { CleanupDiagnostics } from "./process-cleanup.js";
+export { PRODUCT_PACKAGE_NAME, createReleaseIdentity, deriveReleaseIdentity, digestManifestFiles, discoverReleasePayload, packageRootFromModule, releaseFileIdentity, resolveWithin, } from "./release.js";
+export type { DiscoverReleasePayloadOptions, DiscoveredReleasePayload, ReleaseFileIdentity, ReleaseIdentity } from "./release.js";
+export { collectRelease, prepareReleaseCleanup, runBoundedReleaseCleanup, runReleaseCleanupWorker, scheduleReleaseCleanup } from "./release-gc.js";
+export type { ReleaseCleanupLimits, ReleaseCleanupOperations, ReleaseCleanupOptions, ReleaseCleanupResult, ReleaseCleanupWorkerOptions } from "./release-gc.js";
+export { RELEASE_MANIFEST_FILENAME, assertImmutableExecutionRoot, consumeMaterializationProof, materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease, } from "./release-store.js";
+export type { CertifiedReleaseRecord, MaterializeReleaseOptions, MaterializedRelease, ReadCertifiedReleaseManifestOptions, ReleaseContentOperation, ReleaseContentOperationEvent, VerifyMaterializedReleaseOptions, } from "./release-store.js";
+export { createRestartSeal, readRestartCertifiedRelease, releaseCertificationDocument, restartSealDigest } from "./restart-certification.js";
+export type { RestartSeal, RestartValidationEvent } from "./restart-certification.js";
+export { STABLE_RELEASE_SCHEMA, createStableReleaseEvidence, verifyStableRegistry } from "./stable-release.js";
+export type { StableRegistryState, StableRegistryVerificationOptions, StableReleaseEvidence, StableReleaseEvidenceInput } from "./stable-release.js";
+export { PRODUCT_PACKAGE, assertUpdatePerformanceBudget, createNpmProcessRunner, createUpdateLifecycleCoordinator, planUpdateOwnership, renderUpdateProgressBar, runSelfUpdate, } from "./update.js";
+export type { ProcessRequest, ProcessResult, SelfUpdateOptions, UpdateActivationPhase, UpdateChannel, UpdateFileSystem, UpdateLifecycleCoordinator, UpdateMaterializationProgress, UpdateMeasuredPhase, UpdateOutput, UpdateOwnershipAction, UpdatePackageReplacementInput, UpdatePerformanceEvidence, UpdatePhaseTimingEvent, UpdateProcessRunner, UpdateTransactionJournal, } from "./update.js";
+export { selectSupervisorLaunchReleaseId, selectUpdateLaunchRelease } from "./update-launch.js";
+export { UPDATE_RECOVERY_SCHEMA, cleanupUpdateRecoveryCapsules, inspectUpdateLauncherSet, prepareUpdateRecoveryCapsule, readUpdateRecoveryCapsule, removeUpdateRecoveryCapsule, runProtectedPackageReplacement, updateLauncherPaths, } from "./update-recovery.js";
+export type { ProtectedPackageReplacementOptions, ProtectedPackageReplacementResult, UpdateRecoveryCapsule, UpdateRecoveryResult } from "./update-recovery.js";
+export { UPDATE_JOURNAL_SCHEMA, UpdateTransactionStore } from "./update-transaction.js";
+export type { UpdateRecoveryState, UpdateTransaction, UpdateTransactionPhase } from "./update-transaction.js";
+export { warmMaterializedRelease } from "./warmup.js";

package/dist/foundation/release/index.js

@@ -1,16 +1,16 @@
-export * from "./bootstrap.js";
-export * from "./cohort-selection.js";
-export * from "./cohort-state.js";
-export * from "./dependency-layer.js";
-export * from "./endpoints.js";
-export * from "./process-cleanup.js";
-export * from "./release.js";
-export * from "./release-gc.js";
-export * from "./release-store.js";
-export * from "./restart-certification.js";
-export * from "./stable-release.js";
-export * from "./update.js";
-export * from "./update-launch.js";
-export * from "./update-recovery.js";
-export * from "./update-transaction.js";
-export * from "./warmup.js";
+export { certifyMaterializedRelease, ensureSupervisor, recordParentCertifiedRelease, releaseEnvironment, releaseVerifiedIdleOwner, runBootstrap, startSupervisor, waitForProcessExit, waitForVerifiedEndpoint, } from "./bootstrap.js";
+export { selectCohortLaunch } from "./cohort-selection.js";
+export { CohortStateStore, RELEASE_COHORT_SCHEMA, emptyState, planProtectedReleases } from "./cohort-state.js";
+export { DEPENDENCY_LAYER_MANIFEST, DEPENDENCY_LAYER_SCHEMA, RUNTIME_PAYLOAD_INVENTORY, dependencyLayerCertificationPath, dependencyReference, generateDependencyRuntimePayload, legacyDependencyLayerCertificationPath, materializeDependencyLayer, readCertifiedDependencyLayer, selectDependencyRuntimePayload, selectPublishedDependencyRuntimePayload, verifyDependencyLayer, } from "./dependency-layer.js";
+export { listRecordedEndpoints, liveReleaseIds, probeOwnership, readEndpointMetadata, removeEndpointArtifacts, sweepDeadEndpoints } from "./endpoints.js";
+export { cleanupProvenIdleOwner, cleanupVerifiedOwner, processIsAlive } from "./process-cleanup.js";
+export { PRODUCT_PACKAGE_NAME, createReleaseIdentity, deriveReleaseIdentity, digestManifestFiles, discoverReleasePayload, packageRootFromModule, releaseFileIdentity, resolveWithin, } from "./release.js";
+export { collectRelease, prepareReleaseCleanup, runBoundedReleaseCleanup, runReleaseCleanupWorker, scheduleReleaseCleanup } from "./release-gc.js";
+export { RELEASE_MANIFEST_FILENAME, assertImmutableExecutionRoot, consumeMaterializationProof, materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease, } from "./release-store.js";
+export { createRestartSeal, readRestartCertifiedRelease, releaseCertificationDocument, restartSealDigest } from "./restart-certification.js";
+export { STABLE_RELEASE_SCHEMA, createStableReleaseEvidence, verifyStableRegistry } from "./stable-release.js";
+export { PRODUCT_PACKAGE, assertUpdatePerformanceBudget, createNpmProcessRunner, createUpdateLifecycleCoordinator, planUpdateOwnership, renderUpdateProgressBar, runSelfUpdate, } from "./update.js";
+export { selectSupervisorLaunchReleaseId, selectUpdateLaunchRelease } from "./update-launch.js";
+export { UPDATE_RECOVERY_SCHEMA, cleanupUpdateRecoveryCapsules, inspectUpdateLauncherSet, prepareUpdateRecoveryCapsule, readUpdateRecoveryCapsule, removeUpdateRecoveryCapsule, runProtectedPackageReplacement, updateLauncherPaths, } from "./update-recovery.js";
+export { UPDATE_JOURNAL_SCHEMA, UpdateTransactionStore } from "./update-transaction.js";
+export { warmMaterializedRelease } from "./warmup.js";

package/dist/foundation/release/release.d.ts

@@ -1,4 +1,4 @@
-import type { DependencyLayerReference } from "./dependency-layer.js";
+import type { DependencyLayerReference } from "./types.js";
 export declare const PRODUCT_PACKAGE_NAME: string;
 export interface ReleaseFileIdentity {
     readonly path: string;

package/dist/foundation/release/types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Leaf types shared across the release subsystem. They live here so that the transaction store,
+ * launch selection, and dependency layers can name them without importing the update command or
+ * the release reader, which is what closed the subsystem's import cycles.
+ */
+export type UpdateChannel = "stable" | "next";
+export interface DependencyLayerReference {
+    readonly layerId: string;
+    readonly contentDigest: string;
+    readonly binding: "node_modules";
+}

package/dist/foundation/release/types.js

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

package/dist/foundation/release/update-transaction.d.ts

@@ -1,5 +1,5 @@
 export declare const UPDATE_JOURNAL_SCHEMA: string;
-import type { UpdateChannel } from "./update.js";
+import type { UpdateChannel } from "./types.js";
 export type UpdateTransactionPhase = "shutdown-intent" | "ownership-released" | "package-installed" | "materialized" | "certified" | "active-reference-committed" | "supervisor-verified";
 export interface UpdateRecoveryState {
     readonly capsulePath: string;

package/dist/foundation/release/update.d.ts

@@ -1,7 +1,8 @@
+import type { UpdateChannel } from "./types.js";
 import { type UpdateRecoveryState, type UpdateTransaction, type UpdateTransactionPhase } from "./update-transaction.js";
 import { type ProtectedPackageReplacementResult } from "./update-recovery.js";
 export declare const PRODUCT_PACKAGE: string;
-export type UpdateChannel = "stable" | "next";
+export type { UpdateChannel } from "./types.js";
 export interface ProcessRequest {
     captureStdout: boolean;
 }

package/dist/foundation/release/update.js

@@ -5,7 +5,8 @@ import { isAbsolute, relative, resolve, sep } from "node:path";
 import crossSpawn from "cross-spawn";
 import { valid as validSemver } from "semver";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
-import { certifyMaterializedRelease, probeOwnership, readEndpointMetadata, removeEndpointArtifacts, ensureSupervisor, waitForProcessExit, } from "./bootstrap.js";
+import { certifyMaterializedRelease, ensureSupervisor, waitForProcessExit, } from "./bootstrap.js";
+import { probeOwnership, readEndpointMetadata, removeEndpointArtifacts } from "./endpoints.js";
 import { resolveCohortEndpoint, resolveProductPaths } from "../lifecycle/index.js";
 import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
 import { CohortStateStore } from "./cohort-state.js";
@@ -470,19 +471,6 @@ export async function runSelfUpdate(options) {
                 transaction = await transactionStore.advance("package-installed");
             }
         }
-        // Compatibility: npm 12 blocks install scripts unless allowScripts covers the package, so
-        // the postinstall that points the #pi-tui proxy at the tree npm just built
-        // may never have run. Run the shipped script directly: the proxy must be
-        // correct before the release store copies this tree. A failure is reported
-        // and left to the launch-time self-heal rather than failing the update.
-        try {
-            const proxySync = await runner(process.execPath, [resolve(packageRoot, "bin", "sync-pi-tui-proxy.js")], { captureStdout: true });
-            if (proxySync.code !== 0)
-                output.stderr(`${PRODUCT_TEXT.diagnostic(`could not point the #pi-tui proxy at the installed tree (exited ${formatExitCode(proxySync.code)}).`)}\n`);
-        }
-        catch (error) {
-            output.stderr(`${PRODUCT_TEXT.diagnostic(`could not point the #pi-tui proxy at the installed tree: ${errorMessage(error)}`)}\n`);
-        }
         progress.set(70, 75);
         // Concurrency: ownership can be reacquired after an interrupted installation (for
         // example, if bare A1 is launched before the update is resumed). Recheck
@@ -623,10 +611,7 @@ function phaseBefore(current, target) {
 }
 class UpdateFailure extends Error {
     exitCode;
-    constructor(exitCode, message) {
-        super(message);
-        this.exitCode = exitCode;
-    }
+    constructor(exitCode, message) { super(message); this.exitCode = exitCode; }
 }
 async function canonicalImmutableRoot(dataDir, releaseRoot) {
     try {

package/dist/foundation/startup/index.d.ts

@@ -1,2 +1,4 @@
-export * from "./startup-budget.js";
-export * from "./startup-runtime.js";
+export { assertStartupPerformanceBudget, evaluateStartupPerformanceBudget, formatStartupBudgetViolation, resolveStartupBudgetMs } from "./startup-budget.js";
+export type { StartupBudgetViolation, StartupPerformanceEvidence } from "./startup-budget.js";
+export { assertImmutableWarmupEnvironment, collectCompileCaches, enableEnvironmentCompileCache, enableStartupCompileCache, initializeStartupTrace, markStartupPhase, parseStartupTrace, startupCompileCachePath, } from "./startup-runtime.js";
+export type { StartupPhase, StartupTraceEvent } from "./startup-runtime.js";

package/dist/foundation/startup/index.js

@@ -1,2 +1,2 @@
-export * from "./startup-budget.js";
-export * from "./startup-runtime.js";
+export { assertStartupPerformanceBudget, evaluateStartupPerformanceBudget, formatStartupBudgetViolation, resolveStartupBudgetMs } from "./startup-budget.js";
+export { assertImmutableWarmupEnvironment, collectCompileCaches, enableEnvironmentCompileCache, enableStartupCompileCache, initializeStartupTrace, markStartupPhase, parseStartupTrace, startupCompileCachePath, } from "./startup-runtime.js";

package/dist/foundation/startup/startup-descriptor.js

@@ -10,7 +10,7 @@ export const STARTUP_DESCRIPTOR = Object.freeze({
   ],
   "generatedArtifact": {
     "path": "dist/integrations/pi/startup-public.js",
-    "sha256": "98c412f7a4340a4fa4057df12f8a7f8ba25caa10dfa882de5d4c68786d20489e"
+    "sha256": "8782a192051008e2d99edaa7abc2eb47bd37a8b8ebda1b7fbd62a74f990e6d48"
   },
   "dependencyLayerIdentity": {
     "source": "A1_RELEASE_LAYERS",
@@ -19,7 +19,7 @@ export const STARTUP_DESCRIPTOR = Object.freeze({
   "compileCacheNamespace": {
     "strategy": "node-abi-version-and-ordered-layer-sha256-v1"
   },
-  "identity": "12c7247858e9048b2439225f7f4f6a83811309abee82cefe2fe6a6c8e6bd9df1"
+  "identity": "24b9db93df1ea18ef3fc7f669a9f45587750eb50c6de2ed7f57541c26c42ff0e"
 });
 
 export function loadDeclaredStartupGraph() {

package/dist/foundation/storage/control-store.d.ts

@@ -1,27 +1,12 @@
 import { DatabaseSync } from "node:sqlite";
-import type { ManagedAgentDescriptor, PaneId, AgentRecoveryAuthority, RecoveryReferenceId, TerminalSessionLaunch, TerminalTopologySnapshot } from "../../contracts/workspace/index.js";
 import type { LaunchInstance, LaunchInstanceId, LaunchInstanceOutcome, NativeProcessIdentity, ProcessContainmentIdentity } from "../lifecycle/index.js";
-export declare const DEFAULT_WORKSPACE_ID = "workspace-default";
-export interface WorkspaceAgentPresentation {
-    readonly unreadActivity: number;
-    readonly attention: boolean;
-    readonly failure: {
-        readonly code: string;
-        readonly message: string;
-    } | null;
-}
-export interface StoredWorkspaceAgent {
-    readonly agent: ManagedAgentDescriptor;
-    readonly presentation: WorkspaceAgentPresentation;
-}
 /** Owns WAL-backed control persistence and reconciles prior-boot records before current use. */
 export declare class ControlStore {
     #private;
-    readonly bootNonce: string | null;
     readonly database: DatabaseSync;
+    readonly bootNonce: string | null;
     constructor(path: string, bootNonce?: string | null);
     migrate(): void;
-    reconcilePriorBootGenerations(bootNonce: string): number;
     createLaunchInstance(instance: LaunchInstance): void;
     activateLaunchInstance(instanceId: LaunchInstanceId, ownerClientId: string, rootIdentity: NativeProcessIdentity, containmentIdentity: ProcessContainmentIdentity, activatedAt: string): boolean;
     beginLaunchInstanceStop(instanceId: LaunchInstanceId, ownerClientId: string, stoppingAt: string): boolean;
@@ -29,34 +14,5 @@ export declare class ControlStore {
     loadActiveLaunchInstances(): LaunchInstance[];
     loadLaunchInstance(instanceId: LaunchInstanceId): LaunchInstance | null;
     reconcilePriorBootLaunchInstances(bootNonce: string, reconciledAt?: string): number;
-    persistWorkspaceAgent(agent: ManagedAgentDescriptor, updatedAt?: string): void;
-    persistWorkspaceAgentRecord(record: StoredWorkspaceAgent, updatedAt?: string): void;
-    replaceWorkspaceAgentRecords(records: readonly StoredWorkspaceAgent[], selectedAgentId: string | null, revision: number, updatedAt?: string): void;
-    loadWorkspaceAgents(): ManagedAgentDescriptor[];
-    loadWorkspaceAgentRecord(agentId: string): StoredWorkspaceAgent | null;
-    loadWorkspaceAgentRecords(): StoredWorkspaceAgent[];
-    loadSelectedWorkspaceAgentId(): string | null;
-    loadWorkspaceRevision(): number;
-    saveNativeHostTopology(topology: TerminalTopologySnapshot, rollbackTopology: TerminalTopologySnapshot | null, updatedAt?: string): void;
-    loadNativeHostTopology(hostInstanceId: string): {
-        readonly topology: TerminalTopologySnapshot;
-        readonly rollback: unknown;
-        readonly updatedAt: string;
-    } | null;
-    persistTerminalSession(session: TerminalSessionLaunch, hostInstanceId: string, paneId: PaneId, lifecycle: string, recoveryReferenceId: RecoveryReferenceId | null, updatedAt?: string): void;
-    loadTerminalSessions(): {
-        readonly session: TerminalSessionLaunch;
-        readonly hostInstanceId: string;
-        readonly paneId: PaneId;
-        readonly lifecycle: string;
-        readonly recoveryReferenceId: RecoveryReferenceId | null;
-    }[];
-    persistRecoveryReference(authority: AgentRecoveryAuthority, status: "pending" | "accepted" | "rejected" | "discontinuous", rollbackMetadata: Readonly<Record<string, unknown>>, updatedAt?: string): void;
-    loadRecoveryReference(id: RecoveryReferenceId): {
-        readonly authority: unknown;
-        readonly status: string;
-        readonly rollback: unknown;
-        readonly updatedAt: string;
-    } | null;
     close(): void;
 }