@timurproko/a1 0.2.7-dev.1249 → 0.2.7-dev.1252

package/dist/foundation/release/release-store.js

@@ -167,8 +167,8 @@ export async function repairMaterializedRelease(packageRoot, releaseRoot) {
 }
 /**
  * Load metadata for a release whose bytes were already certified by the
- * current parent process or an authenticated live supervisor. Callers must
- * establish one of those preconditions; untrusted releases require full
+ * current parent process or recorded by an authenticated certification. Callers must
+ * establish that precondition; untrusted releases require full
  * verification.
  */
 export async function readCertifiedReleaseManifest(record, selectedStoreRoot, options = {}) {

package/dist/foundation/release/restart-certification.js

@@ -10,7 +10,7 @@ import { PRODUCT_PACKAGE_NAME } from "./release.js";
 import { RELEASE_MANIFEST_FILENAME } from "./release-store.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
 const RESTART_SEAL_VERSION = 1;
-const REQUIRED_LAUNCH_ENTRIES = ["bin/supervisor.js", "bin/guardian.js"];
+const REQUIRED_LAUNCH_ENTRIES = ["bin/ui.js"];
 /** Build compact restart authority after complete content verification established read-only payload files. */
 export async function createRestartSeal(release, dataDir) {
     const policy = immutablePlatformPolicy();

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

@@ -1,4 +1,3 @@
-import type { ContinuityOptions } from "../resident-tabs/index.js";
 /**
  * The one activation contract an installed tree can offer the updater that installed it.
  * The updater knows nothing else about the tree: the manifest names the contracts the tree
@@ -9,10 +8,6 @@ export declare const UPDATE_ACTIVATION_ENTRY = "bin/activate.js";
 /** Manifest field listing the activation contracts an installed tree serves. */
 export declare const UPDATE_ACTIVATION_MANIFEST_FIELD = "updateActivationContracts";
 export type UpdateActivationPhase = "materialized" | "certified" | "active-reference-committed";
-/** A certified candidate is safe to retain, but resident control continuity blocks selection. */
-export declare class UpdateActivationBlockedError extends Error {
-    readonly code: "resident-continuity-blocked";
-}
 /**
  * Copying the release is the longest step with nothing to say for itself, so it
  * reports the files it has written against the files it must write. A caller that
@@ -49,12 +44,11 @@ export type UpdateActivationEvent = {
 } | {
     readonly event: "failed";
     readonly message: string;
-    readonly code?: UpdateActivationBlockedError["code"];
 };
 /**
  * Activate the installed tree at `packageRoot` with this process's own release code:
- * materialize it into the immutable store, certify, warm, verify supervision, and only
- * then move the active reference. This is what the installed tree runs for itself through
+ * materialize it into the immutable store, certify, warm, and only then move the active
+ * reference. This is what the installed tree runs for itself through
  * its activation entry, and what an updater runs in-process for a tree older than the contract.
  */
 export declare function activateInstalledRelease(request: UpdateActivationRequest, callbacks: UpdateActivationCallbacks): Promise<void>;
@@ -76,4 +70,3 @@ export declare function delegateActivation(request: UpdateActivationRequest, cal
 export declare function runActivationEntry(argv: readonly string[], entryUrl: string, io?: {
     write(line: string): void;
 }, environment?: NodeJS.ProcessEnv): Promise<number>;
-export declare function assertContinuityOrBlock(context: ContinuityOptions): Promise<void>;

package/dist/foundation/release/update-activation.js

@@ -2,10 +2,9 @@ import { spawn } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
-import { certifyMaterializedRelease, ensureSupervisor } from "./bootstrap.js";
+import { PRODUCT_TEXT } from "../../product-identity.js";
+import { certifyMaterializedRelease } from "./bootstrap.js";
 import { CohortStateStore } from "./cohort-state.js";
-import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
 import { resolveProductPaths } from "../lifecycle/index.js";
 import { materializeRelease } from "./release-store.js";
 import { warmMaterializedRelease } from "./warmup.js";
@@ -19,14 +18,12 @@ export const UPDATE_ACTIVATION_ENTRY = "bin/activate.js";
 /** Manifest field listing the activation contracts an installed tree serves. */
 export const UPDATE_ACTIVATION_MANIFEST_FIELD = "updateActivationContracts";
 const ACTIVATION_DIAGNOSTIC_LIMIT = 2_000;
-/** A certified candidate is safe to retain, but resident control continuity blocks selection. */
-export class UpdateActivationBlockedError extends Error {
-    code = "resident-continuity-blocked";
-}
+/** Bound on one progress line; the activator's events are all far shorter. */
+const ACTIVATION_LINE_LIMIT = 64 * 1_024;
 /**
  * Activate the installed tree at `packageRoot` with this process's own release code:
- * materialize it into the immutable store, certify, warm, verify supervision, and only
- * then move the active reference. This is what the installed tree runs for itself through
+ * materialize it into the immutable store, certify, warm, and only then move the active
+ * reference. This is what the installed tree runs for itself through
  * its activation entry, and what an updater runs in-process for a tree older than the contract.
  */
 export async function activateInstalledRelease(request, callbacks) {
@@ -55,16 +52,6 @@ export async function activateInstalledRelease(request, callbacks) {
     callbacks.onWarmup?.("started");
     await warmMaterializedRelease(candidate, request.environment);
     callbacks.onWarmup?.("completed");
-    await completeActivation(candidate, request, callbacks, stateStore);
-}
-async function completeActivation(candidate, request, callbacks, stateStore) {
-    const paths = resolveProductPaths(request.environment);
-    const continuity = { releaseRoot: candidate.releaseRoot, dataDir: request.dataDir, environment: request.environment,
-        profileRoot: request.environment[PRODUCT_IDENTITY.environment.profileHome] ?? paths.configDir, runtimeDir: paths.runtimeDir };
-    await assertContinuityOrBlock(continuity);
-    await ensureSupervisor(candidate, request.environment);
-    // Invariant: revalidate after supervision, before committing client activation or restart readiness.
-    await assertContinuityOrBlock(continuity);
     await stateStore.activate(candidate.releaseId);
     await callbacks.phase("active-reference-committed");
 }
@@ -94,7 +81,7 @@ export async function delegateActivation(request, callbacks) {
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: true,
     });
-    const decoder = new LineFrameDecoder();
+    let pending = "";
     let diagnostics = "";
     let failure = null;
     let completed = false;
@@ -102,14 +89,25 @@ export async function delegateActivation(request, callbacks) {
     let relay = Promise.resolve();
     child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", chunk => { diagnostics = `${diagnostics}${chunk}`.slice(-ACTIVATION_DIAGNOSTIC_LIMIT); });
+    child.stdout?.setEncoding("utf8");
     child.stdout?.on("data", chunk => {
-        let events;
-        try {
-            events = decoder.push(chunk);
+        const lines = `${pending}${String(chunk)}`.split("\n");
+        pending = lines.pop() ?? "";
+        if (pending.length > ACTIVATION_LINE_LIMIT) {
+            failure ??= new Error("activation event exceeds the line limit");
+            pending = "";
         }
-        catch (error) {
-            failure ??= new Error(errorMessage(error));
-            return;
+        const events = [];
+        for (const line of lines) {
+            if (line.trim().length === 0)
+                continue;
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch (error) {
+                failure ??= new Error(errorMessage(error));
+                return;
+            }
         }
         for (const event of events) {
             relay = relay.then(async () => {
@@ -127,9 +125,7 @@ export async function delegateActivation(request, callbacks) {
                 else if (parsed.event === "completed")
                     completed = true;
                 else
-                    failure ??= parsed.code === "resident-continuity-blocked"
-                        ? new UpdateActivationBlockedError(parsed.message)
-                        : new Error(parsed.message);
+                    failure ??= new Error(parsed.message);
             }).catch(error => { failure ??= new Error(errorMessage(error)); });
         }
     });
@@ -150,7 +146,7 @@ export async function delegateActivation(request, callbacks) {
  * writing one progress event per line so the updater that started it can follow along.
  */
 export async function runActivationEntry(argv, entryUrl, io = { write: line => process.stdout.write(line) }, environment = process.env) {
-    const emit = (event) => io.write(encodeFrame(event));
+    const emit = (event) => io.write(`${JSON.stringify(event)}\n`);
     try {
         const arguments_ = parseEntryArguments(argv);
         const packageRoot = resolve(fileURLToPath(new URL("..", entryUrl)));
@@ -168,7 +164,7 @@ export async function runActivationEntry(argv, entryUrl, io = { write: line => p
         return 0;
     }
     catch (error) {
-        emit({ event: "failed", message: errorMessage(error), ...(error instanceof UpdateActivationBlockedError ? { code: error.code } : {}) });
+        emit({ event: "failed", message: errorMessage(error) });
         return 1;
     }
 }
@@ -206,22 +202,11 @@ function parseActivationEvent(value) {
         case "completed":
             return { event: "completed" };
         case "failed":
-            return typeof record.message === "string" && (record.code === undefined || record.code === "resident-continuity-blocked")
-                ? { event: "failed", message: record.message, ...(record.code === undefined ? {} : { code: record.code }) }
-                : null;
+            return typeof record.message === "string" ? { event: "failed", message: record.message } : null;
         default:
             return null;
     }
 }
-export async function assertContinuityOrBlock(context) {
-    const { assertResidentContinuity } = await import("../resident-tabs/index.js");
-    try {
-        await assertResidentContinuity(context);
-    }
-    catch (error) {
-        throw new UpdateActivationBlockedError(errorMessage(error), { cause: error });
-    }
-}
 function summarize(text) {
     const lines = text.split(/\r?\n/).map(line => line.trim()).filter(line => line.length > 0);
     return lines.length === 0 ? "" : `: ${lines.slice(0, 4).join(" | ")}`;

package/dist/foundation/release/update-execution-lease.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import lockfile from "proper-lockfile";
-import { processIsAlive } from "./process-cleanup.js";
+import { processIsAlive } from "./process-liveness.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
 export const UPDATE_EXECUTION_LEASE_FILENAME = "update-execution.json";
 const LEASE_SCHEMA = 1;

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

@@ -2,5 +2,3 @@ import type { CohortState, ReleaseRecord } from "./cohort-state.js";
 import type { UpdateTransaction } from "./update-transaction.js";
 /** Keep interactive launches on the last successful release until the update commits success. */
 export declare function selectUpdateLaunchRelease(state: CohortState, transaction: UpdateTransaction | null): ReleaseRecord | null;
-/** Pause cohort retirement during preparation; afterward only the successful launch release admits new sessions. */
-export declare function selectSupervisorLaunchReleaseId(state: CohortState, transaction: UpdateTransaction | null): string | null;

package/dist/foundation/release/update-launch.js

@@ -8,10 +8,3 @@ export function selectUpdateLaunchRelease(state, transaction) {
     }
     return prior;
 }
-/** Pause cohort retirement during preparation; afterward only the successful launch release admits new sessions. */
-export function selectSupervisorLaunchReleaseId(state, transaction) {
-    // Concurrency: both the previous cohort and the warming candidate must remain available until cutover.
-    if (transaction?.status === "active")
-        return null;
-    return selectUpdateLaunchRelease(state, transaction)?.releaseId ?? state.references.active;
-}

package/dist/foundation/release/update-recovery.js

@@ -4,7 +4,7 @@ import { chmod, lstat, mkdir, open, readFile, readdir, realpath, rename, rm, wri
 import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
-import { processIsAlive } from "./process-cleanup.js";
+import { processIsAlive } from "./process-liveness.js";
 import { PRIVATE_LAUNCH_CONTRACT, assertCurrentLaunchContract } from "../launch-context/index.js";
 export const UPDATE_RECOVERY_SCHEMA = "a1-update-recovery-v1";
 const WORKER_TIMEOUT_MS = 15 * 60 * 1_000;

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

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

package/dist/foundation/release/update-transaction.js

@@ -3,13 +3,16 @@ import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 export const UPDATE_JOURNAL_SCHEMA = PRODUCT_IDENTITY.protocol.updateJournalSchema;
+/** Compatibility: a journal written before supervision was removed may name its last phase. */
+const LEGACY_FINAL_PHASE = "supervisor-verified";
 /** Persists the durable update journal and permits only validated forward transaction phases. */
 export class UpdateTransactionStore {
     path;
     constructor(dataDir) { this.path = resolve(dataDir, "update-transaction.json"); }
     async read() {
         try {
-            const value = JSON.parse(await readFile(this.path, "utf8"));
+            const parsed = JSON.parse(await readFile(this.path, "utf8"));
+            const value = parsed.phase === LEGACY_FINAL_PHASE ? { ...parsed, phase: "active-reference-committed" } : parsed;
             validate(value);
             return value;
         }
@@ -87,7 +90,7 @@ export class UpdateTransactionStore {
     }
 }
 function phaseOrder(phase) {
-    return ["shutdown-intent", "ownership-released", "package-installed", "materialized", "certified", "active-reference-committed", "supervisor-verified"].indexOf(phase);
+    return ["shutdown-intent", "ownership-released", "package-installed", "materialized", "certified", "active-reference-committed"].indexOf(phase);
 }
 function validate(value) {
     if (value.schema !== UPDATE_JOURNAL_SCHEMA || typeof value.transactionId !== "string" || !["stable", "next"].includes(value.channel)

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

@@ -40,7 +40,7 @@ export interface UpdateOutput {
     stdout(message: string): void;
     stderr(message: string): void;
 }
-export type UpdateMeasuredPhase = "package-version" | "target-resolution" | "global-root" | "ownership-release" | "npm-install" | "materialized" | "certified" | "active-reference-committed" | "warmup" | "supervisor-verified" | "transaction-complete";
+export type UpdateMeasuredPhase = "package-version" | "target-resolution" | "global-root" | "ownership-release" | "npm-install" | "materialized" | "certified" | "active-reference-committed" | "warmup" | "transaction-complete";
 export interface UpdatePhaseTimingEvent {
     readonly phase: UpdateMeasuredPhase;
     readonly durationMs: number;
@@ -89,13 +89,8 @@ export interface SelfUpdateOptions {
 export type { UpdateActivationPhase, UpdateMaterializationProgress } from "./update-activation.js";
 export interface UpdateLifecycleCoordinator {
     targetIsActive(targetVersion: string): Promise<boolean>;
-    verifyAutomaticSafety?(): Promise<void>;
-    shutdownVerifiedOwners(targetVersion: string): Promise<{
-        priorActiveVersion: string | null;
-    }>;
     verifyPackageUnlocked(packageRoot: string): Promise<void>;
     activateInstalled(packageRoot: string, targetVersion: string, phase: (phase: UpdateActivationPhase) => Promise<void>, onMaterializing?: (progress: UpdateMaterializationProgress) => void, onWarmup?: (state: "started" | "completed") => void): Promise<void>;
-    activatePrepared?(targetVersion: string, phase: (phase: UpdateActivationPhase) => Promise<void>): Promise<void>;
 }
 export interface UpdateTransactionJournal {
     readonly path: string;
@@ -136,7 +131,6 @@ export interface UpdatePackageReplacementInput {
  */
 export declare const PACKAGE_UNLOCK_PATIENCE_MS = 15000;
 export declare const UPDATE_ALREADY_RUNNING_EXIT_CODE = 75;
-export declare const UPDATE_ACTIVATION_BLOCKED_EXIT_CODE = 76;
 /** Whether a rename failure means something holds the tree, as opposed to the tree being wrong. */
 export declare function isPackageLockError(error: unknown): boolean;
 /** What the user reads when the package stayed held for the whole patience window. */
@@ -144,9 +138,7 @@ export declare function lockedPackageDiagnostic(packageRoot: string, waitedMs: n
 /** Bound on the child diagnostics an update keeps: enough for npm's failure reason, never a log. */
 export declare const CHILD_DIAGNOSTIC_LIMIT = 8000;
 export declare function createNpmProcessRunner(platform?: NodeJS.Platform): UpdateProcessRunner;
-export type UpdateOwnershipAction = "clean-dead-record" | "leave-running" | "end-session";
-export declare function planUpdateOwnership(ownership: "live-verified" | "dead", runsFromRetainedRelease: boolean): UpdateOwnershipAction;
-export declare function createUpdateLifecycleCoordinator(environment?: NodeJS.ProcessEnv, fileSystem?: UpdateFileSystem, output?: UpdateOutput, patience?: UpdateUnlockPatience): UpdateLifecycleCoordinator;
+export declare function createUpdateLifecycleCoordinator(environment?: NodeJS.ProcessEnv, fileSystem?: UpdateFileSystem, _output?: UpdateOutput, patience?: UpdateUnlockPatience): UpdateLifecycleCoordinator;
 /** Renders the terminal-only update meter; the visual preview shares this exact frame. */
 export declare function renderUpdateProgressBar(percent: number, accent?: string): string;
 export declare function runSelfUpdate(options: SelfUpdateOptions): Promise<number>;