@timurproko/a1 0.1.0 → 0.1.1-dev.2

package/dist/src/foundation/pi-tui-runtime-adapter/conformance.d.ts

@@ -1,14 +1,18 @@
-import { PI_TUI_PACKAGE_VERSION } from "./contracts.js";
+export interface PiTuiRuntimeConformanceOptions {
+    readonly packageVersion: string;
+}
 export interface PiTuiRuntimeConformanceReport {
     readonly packageName: "@earendil-works/pi-tui";
-    readonly packageVersion: typeof PI_TUI_PACKAGE_VERSION;
+    readonly packageVersion: string;
     readonly mode: "regular" | "fullscreen";
+    readonly constructedModes: readonly ("regular" | "fullscreen")[];
     readonly lifecycleRestored: boolean;
     readonly inputRouted: boolean;
     readonly overlayRouted: boolean;
+    readonly focusRouted: boolean;
+    readonly widthBounded: boolean;
     readonly differentialRendering: boolean;
     readonly resizeRedraw: boolean;
     readonly terminalNativeSelection: boolean;
 }
-export declare function runPiTuiRuntimeConformance(): Promise<PiTuiRuntimeConformanceReport>;
-//# sourceMappingURL=conformance.d.ts.map
+export declare function runPiTuiRuntimeConformance(options: PiTuiRuntimeConformanceOptions): Promise<PiTuiRuntimeConformanceReport>;

package/dist/src/foundation/pi-tui-runtime-adapter/conformance.js

@@ -1,6 +1,8 @@
-import { PI_TUI_PACKAGE_VERSION } from "./contracts.js";
 import { PiTuiRuntimeAdapter, PiTuiRuntimeError } from "./adapter.js";
-export async function runPiTuiRuntimeConformance() {
+export async function runPiTuiRuntimeConformance(options) {
+    if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(options.packageVersion)) {
+        throw new TypeError("Pi TUI conformance requires an exact package version from compatibility authority");
+    }
     const terminal = new ConformanceTerminal();
     const root = new ConformanceComponent(["stable row", "before"]);
     const overlay = new ConformanceComponent(["overlay"]);
@@ -24,20 +26,26 @@ export async function runPiTuiRuntimeConformance() {
         terminal.resize(60, 10);
         runtime.renderNow();
         const resizeRedraw = runtime.fullRedraws > redrawsBeforeResize && runtime.viewport().columns === 60;
+        const fullscreenConstructed = runtime.switchMode("fullscreen");
+        runtime.renderNow(true);
+        const regularRestored = runtime.switchMode("regular");
+        runtime.renderNow(true);
         await runtime.stop({ drainMaxMs: 1, drainIdleMs: 1 });
         const emitted = terminal.writes.join("");
         return {
             packageName: "@earendil-works/pi-tui",
-            packageVersion: PI_TUI_PACKAGE_VERSION,
+            packageVersion: options.packageVersion,
             mode: runtime.mode,
-            lifecycleRestored: terminal.startCount === 1
-                && terminal.stopCount === 1
+            constructedModes: fullscreenConstructed && regularRestored ? ["regular", "fullscreen"] : ["regular"],
+            lifecycleRestored: terminal.startCount >= 1
+                && terminal.startCount === terminal.stopCount
                 && terminal.drainCount === 1
-                && !emitted.includes("\x1b[?1049h")
-                && !emitted.includes("\x1b[?1049l")
+                && (emitted.match(/\x1b\[\?1049h/g)?.length ?? 0) === (emitted.match(/\x1b\[\?1049l/g)?.length ?? 0)
                 && root.disposed,
             inputRouted: root.inputs.includes("root-input"),
             overlayRouted,
+            focusRouted: root.focusChanges.includes(true) && overlay.focusChanges.includes(true),
+            widthBounded: root.widths.every(width => width <= terminal.columns) && overlay.widths.every(width => width <= 12),
             differentialRendering: differentialFrame.includes("after") && !differentialFrame.includes("stable row"),
             resizeRedraw,
             terminalNativeSelection: !emitted.includes("\x1b[?1000h") && !emitted.includes("\x1b[?1006h"),
@@ -54,13 +62,19 @@ export async function runPiTuiRuntimeConformance() {
 class ConformanceComponent {
     lines;
     inputs = [];
+    focusChanges = [];
+    widths = [];
     disposed = false;
     constructor(lines) {
         this.lines = lines;
     }
-    render() {
+    render(width) {
+        this.widths.push(width);
         return this.lines;
     }
+    setFocused(focused) {
+        this.focusChanges.push(focused);
+    }
     handleInput(data) {
         this.inputs.push(data);
     }
@@ -129,4 +143,3 @@ class ConformanceTerminal {
         this.write(`progress:${active}`);
     }
 }
-//# sourceMappingURL=conformance.js.map

package/dist/src/foundation/pi-tui-runtime-adapter/contracts.d.ts

@@ -1,4 +1,3 @@
-export declare const PI_TUI_PACKAGE_VERSION: "0.84.2";
 export type PiTuiRuntimeState = "idle" | "running" | "stopping" | "stopped" | "failed";
 export interface PiTuiViewport {
     readonly columns: number;
@@ -119,4 +118,3 @@ export interface PiTuiStopOptions {
     readonly drainMaxMs?: number;
     readonly drainIdleMs?: number;
 }
-//# sourceMappingURL=contracts.d.ts.map

package/dist/src/foundation/pi-tui-runtime-adapter/contracts.js

@@ -1,2 +1 @@
-export const PI_TUI_PACKAGE_VERSION = "0.84.2";
-//# sourceMappingURL=contracts.js.map
+export {};

package/dist/src/foundation/pi-tui-runtime-adapter/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./contracts.js";
 export * from "./adapter.js";
 export * from "./conformance.js";
-//# sourceMappingURL=index.d.ts.map
+export * from "./presentation-adapter.js";

package/dist/src/foundation/pi-tui-runtime-adapter/index.js

@@ -1,4 +1,4 @@
 export * from "./contracts.js";
 export * from "./adapter.js";
 export * from "./conformance.js";
-//# sourceMappingURL=index.js.map
+export * from "./presentation-adapter.js";

package/dist/src/foundation/pi-tui-runtime-adapter/presentation-adapter.d.ts

@@ -0,0 +1,4 @@
+import type { PresentationComponentPort, PresentationRuntimePort, PresentationTerminalPort } from "../presentation-contracts/index.js";
+import type { PiTuiTerminalPort } from "./contracts.js";
+export declare function createPiPresentationRuntime(root: PresentationComponentPort, terminal: PresentationTerminalPort): PresentationRuntimePort;
+export declare function createPiTerminalBridge(terminal: PresentationTerminalPort): PiTuiTerminalPort;

package/dist/src/foundation/pi-tui-runtime-adapter/presentation-adapter.js

@@ -0,0 +1,48 @@
+import { PiTuiRuntimeAdapter } from "./adapter.js";
+export function createPiPresentationRuntime(root, terminal) {
+    return new PresentationRuntimeAdapter(root, terminal);
+}
+class PresentationRuntimeAdapter {
+    terminal;
+    #runtime;
+    constructor(root, terminal) {
+        this.terminal = terminal;
+        this.#runtime = new PiTuiRuntimeAdapter({ root, terminal: createPiTerminalBridge(terminal), mouse: false });
+    }
+    get state() { return this.#runtime.state; }
+    start() { this.#runtime.start(); }
+    render(force) { this.#runtime.renderNow(force); }
+    showOverlay(component, options) {
+        const handle = this.#runtime.showOverlay(component, {
+            anchor: options.anchor === "top" ? "top-center" : options.anchor === "bottom" ? "bottom-center" : "center",
+            ...(options.width === undefined ? {} : { width: options.width }),
+        });
+        return {
+            get visible() { return !handle.isHidden(); },
+            hide: () => handle.hide(),
+            show: () => handle.setHidden(false),
+            focus: () => handle.focus(),
+            dispose: () => handle.hide(),
+        };
+    }
+    async stop() { await this.#runtime.stop(); }
+}
+export function createPiTerminalBridge(terminal) {
+    return {
+        get columns() { return terminal.columns; },
+        get rows() { return terminal.rows; },
+        get kittyProtocolActive() { return terminal.enhancedKeyboard; },
+        start: (input, resize) => terminal.start(input, resize),
+        stop: () => terminal.stop(),
+        drainInput: (max, idle) => terminal.drainInput(max, idle),
+        write: data => terminal.write(data),
+        moveBy: lines => terminal.moveBy(lines),
+        hideCursor: () => terminal.hideCursor(),
+        showCursor: () => terminal.showCursor(),
+        clearLine: () => terminal.clearLine(),
+        clearFromCursor: () => terminal.clearFromCursor(),
+        clearScreen: () => terminal.clearScreen(),
+        setTitle: title => terminal.setTitle(title),
+        setProgress: active => terminal.setProgress(active),
+    };
+}

package/dist/src/foundation/presentation-contracts/index.d.ts

@@ -0,0 +1,96 @@
+export type PresentationRuntimeState = "idle" | "running" | "stopping" | "stopped" | "failed";
+export interface PresentationComponentPort {
+    render(width: number): readonly string[];
+    invalidate(): void;
+    handleInput?(data: string): void;
+    setFocused?(focused: boolean): void;
+    dispose?(): void;
+}
+export interface PresentationEditorPort extends PresentationComponentPort {
+    getText(): string;
+    setText(text: string): void;
+    submit(): Promise<void> | void;
+}
+export interface PresentationSelectorItem {
+    readonly id: string;
+    readonly label: string;
+    readonly detail?: string;
+}
+export interface PresentationSelectorPort extends PresentationComponentPort {
+    setItems(items: readonly PresentationSelectorItem[]): void;
+    readonly selectedId: string | null;
+}
+export interface PresentationDialogPort extends PresentationComponentPort {
+    readonly dialogId: string;
+    close(outcome: "accepted" | "cancelled"): void;
+}
+export interface PresentationExtensionUiPort {
+    mount(slot: PresentationContributionSlot, component: PresentationComponentPort): () => void;
+}
+export type PresentationContributionSlot = "transcript" | "tool" | "editor" | "status" | "dialog" | "overlay";
+export type PresentationFocusTarget = "transcript" | "editor" | "dialog" | "overlay" | "status";
+export interface PresentationFocusPort {
+    readonly focused: PresentationFocusTarget;
+    focus(target: PresentationFocusTarget): void;
+}
+export interface PresentationTerminalPort {
+    readonly columns: number;
+    readonly rows: number;
+    readonly enhancedKeyboard: boolean;
+    start(onInput: (data: string) => void, onResize: () => void): void;
+    stop(): void;
+    drainInput(maxMs?: number, idleMs?: number): Promise<void>;
+    write(data: string): void;
+    moveBy(lines: number): void;
+    clearLine(): void;
+    clearFromCursor(): void;
+    clearScreen(): void;
+    setTitle(title: string): void;
+    setProgress(active: boolean): void;
+    showCursor(): void;
+    hideCursor(): void;
+}
+export type PresentationLayoutNode = {
+    readonly type: "component";
+    readonly component: PresentationComponentPort;
+} | {
+    readonly type: "stack";
+    readonly direction: "vertical" | "horizontal";
+    readonly children: readonly PresentationLayoutNode[];
+    readonly gap?: number;
+} | {
+    readonly type: "scroll";
+    readonly id: string;
+    readonly child: PresentationLayoutNode;
+    readonly follow: "none" | "end";
+};
+export interface PresentationOverlayOptions {
+    readonly anchor: "center" | "top" | "bottom";
+    readonly width?: number | `${number}%`;
+    readonly modal: boolean;
+}
+export interface PresentationOverlayHandle {
+    readonly visible: boolean;
+    hide(): void;
+    show(): void;
+    focus(): void;
+    dispose(): void;
+}
+export interface OwnedUiApplicationPort {
+    readonly disposed: boolean;
+    start(): void;
+    flush(): Promise<void>;
+    waitUntilStopped(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export interface PresentationRuntimePort {
+    readonly state: PresentationRuntimeState;
+    readonly terminal: PresentationTerminalPort;
+    start(): void;
+    render(force?: boolean): void;
+    showOverlay(component: PresentationComponentPort, options: PresentationOverlayOptions): PresentationOverlayHandle;
+    stop(): Promise<void>;
+}
+export declare function assertPresentationComponent(component: PresentationComponentPort): void;
+export declare function assertPresentationRuntime(runtime: PresentationRuntimePort): void;
+export declare function probePresentationLifecycle(runtime: PresentationRuntimePort): Promise<void>;

package/dist/src/foundation/presentation-contracts/index.js

@@ -0,0 +1,38 @@
+export function assertPresentationComponent(component) {
+    requiredFunctions(component, ["render", "invalidate"], "presentation component");
+    const lines = component.render(80);
+    if (!Array.isArray(lines) || lines.some(line => typeof line !== "string" || line.includes("\n") || line.includes("\r"))) {
+        throw new TypeError("presentation component render must return newline-free string rows");
+    }
+}
+export function assertPresentationRuntime(runtime) {
+    requiredFunctions(runtime, ["start", "render", "showOverlay", "stop"], "presentation runtime");
+    if (!new Set(["idle", "running", "stopping", "stopped", "failed"]).has(runtime.state))
+        throw new TypeError("presentation runtime state is invalid");
+    const terminal = runtime.terminal;
+    requiredFunctions(terminal, ["start", "stop", "drainInput", "write", "moveBy", "clearLine", "clearFromCursor", "clearScreen", "setTitle", "setProgress", "showCursor", "hideCursor"], "presentation terminal");
+    if (!Number.isSafeInteger(terminal.columns) || terminal.columns < 1 || !Number.isSafeInteger(terminal.rows) || terminal.rows < 1)
+        throw new TypeError("presentation terminal geometry is invalid");
+}
+export async function probePresentationLifecycle(runtime) {
+    assertPresentationRuntime(runtime);
+    if (runtime.state !== "idle")
+        throw new TypeError("presentation runtime must begin idle");
+    runtime.start();
+    if (runtime.state !== "running")
+        throw new TypeError("presentation runtime did not enter running state");
+    runtime.render(true);
+    await runtime.stop();
+    if (runtime.state !== "stopped")
+        throw new TypeError("presentation runtime did not enter stopped state");
+    await runtime.stop();
+    if (runtime.state !== "stopped")
+        throw new TypeError("presentation runtime stop is not idempotent");
+}
+function requiredFunctions(value, names, label) {
+    if (!value)
+        throw new TypeError(`${label} is required`);
+    for (const name of names)
+        if (typeof value[name] !== "function")
+            throw new TypeError(`${label} requires ${name}`);
+}

package/dist/src/foundation/protocol/client.d.ts

@@ -14,4 +14,3 @@ export declare class SupervisorClient extends EventEmitter<ClientEvents> {
     close(): void;
 }
 export {};
-//# sourceMappingURL=client.d.ts.map

package/dist/src/foundation/protocol/client.js

@@ -124,4 +124,3 @@ function isTransientEndpointError(error) {
 function transientError(message, code) {
     return Object.assign(new Error(message), { code });
 }
-//# sourceMappingURL=client.js.map

package/dist/src/foundation/protocol/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./client.js";
 export * from "./messages.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/foundation/protocol/index.js

@@ -1,3 +1,2 @@
 export * from "./client.js";
 export * from "./messages.js";
-//# sourceMappingURL=index.js.map

package/dist/src/foundation/protocol/messages.d.ts

@@ -1,5 +1,5 @@
 import type { CommandResult, SupervisorCommand, SupervisorSnapshot } from "../lifecycle/index.js";
-export declare const CONTROL_ENVELOPE: "addone-control-envelope";
+export declare const CONTROL_ENVELOPE: string;
 export declare const CONTROL_ENVELOPE_REVISION: 1;
 export declare const REQUIRED_CONTROL_FEATURES: readonly ["handshake.features.v1", "snapshot.revision.v1", "commands.request-identity.v1", "generation.lifecycle.v1", "terminal.foreground-lease.v1"];
 export declare const OPTIONAL_CONTROL_FEATURES: readonly ["messages.unknown-additive-ignore.v1", "snapshot.resynchronize.v1"];
@@ -87,4 +87,3 @@ export declare function isControlHello(value: unknown): value is {
 export declare function isCommandMessage(value: unknown): value is Extract<ClientMessage, {
     type: "command";
 }>;
-//# sourceMappingURL=messages.d.ts.map

package/dist/src/foundation/protocol/messages.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
-export const CONTROL_ENVELOPE = "addone-control-envelope";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+export const CONTROL_ENVELOPE = PRODUCT_IDENTITY.protocol.controlEnvelope;
 export const CONTROL_ENVELOPE_REVISION = 1;
 export const REQUIRED_CONTROL_FEATURES = [
     "handshake.features.v1",
@@ -96,4 +97,3 @@ function isRecord(value) {
 function isStringArray(value) {
     return Array.isArray(value) && value.every(item => typeof item === "string" && item.length > 0);
 }
-//# sourceMappingURL=messages.js.map

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

@@ -27,4 +27,3 @@ export declare function releaseVerifiedIdleOwner(metadata: SupervisorEndpointMet
 }): Promise<boolean>;
 export declare function waitForProcessExit(pid: number, timeoutMs: number): Promise<void>;
 export declare function removeEndpointArtifacts(metadataPath: string, endpoint: string): Promise<void>;
-//# sourceMappingURL=bootstrap.d.ts.map

package/dist/src/foundation/release/bootstrap.js

@@ -5,41 +5,67 @@ import { platform } from "node:os";
 import { resolve } from "node:path";
 import { selectCohortLaunch } from "./cohort-selection.js";
 import { CohortStateStore } from "./cohort-state.js";
-import { assertLaunchProfileId, resolveAddOnePaths } from "../lifecycle/index.js";
+import { assertLaunchProfileId, resolveProductPaths } from "../lifecycle/index.js";
 import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
 import { cleanupProvenIdleOwner, processIsAlive } from "./process-cleanup.js";
-import { materializeRelease, readMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease } from "./release-store.js";
+import { materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease } from "./release-store.js";
+import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 export async function runBootstrap(options) {
     const environment = { ...(options.environment ?? process.env) };
-    const launchProfileId = options.launchIntent?.profile.id ?? "addone";
+    const launchProfileId = options.launchIntent?.profile.id ?? "a1";
     assertLaunchProfileId(launchProfileId);
-    environment.ADDONE_LAUNCH_PROFILE = launchProfileId;
+    environment[PRODUCT_IDENTITY.environment.launchProfile] = launchProfileId;
     const output = options.output ?? process.stderr;
-    const paths = resolveAddOnePaths(environment);
+    const paths = resolveProductPaths(environment);
     await mkdir(paths.runtimeDir, { recursive: true, mode: 0o700 });
-    const candidate = await materializeRelease(options.packageRoot, paths.dataDir);
     const stateStore = new CohortStateStore(paths.dataDir);
-    await stateStore.recordCandidate(candidate);
     let state = await stateStore.read();
+    let endpoint = await readEndpointMetadata(paths.endpointMetadataPath);
+    let probe = endpoint ? await probeOwnership(endpoint) : "dead";
+    const installedVersion = await readInstalledVersion(options.packageRoot);
+    const activeId = state.references.active;
+    const active = activeId === null ? undefined : state.releases[activeId];
+    if (active?.approval === "approved" && active.packageVersion === installedVersion) {
+        const endpointMatches = endpoint?.releaseId === active.releaseId
+            && endpoint.releaseRoot === active.releaseRoot
+            && endpoint.contentDigest === active.contentDigest;
+        if (endpointMatches && probe === "live-verified") {
+            const retained = await readCertifiedReleaseManifest(active, resolve(paths.dataDir, "releases"));
+            return await launchUi(retained, environment);
+        }
+        if (endpoint === null || probe === "dead") {
+            if (endpoint)
+                await removeEndpointArtifacts(paths.endpointMetadataPath, paths.endpoint);
+            const retained = await readMaterializedRelease(active.releaseRoot);
+            await startSupervisor(retained, environment);
+            await waitForVerifiedEndpoint(paths.endpointMetadataPath, retained, 8_000);
+            return await launchUi(retained, environment);
+        }
+    }
+    const candidate = await materializeRelease(options.packageRoot, paths.dataDir, {
+        onProgress: progress => output.write(`${PRODUCT_TEXT.diagnostic(`preparing ${progress.fileCount} installed release files; first launch may take a moment.`)}\n`),
+    });
+    await stateStore.recordCandidate(candidate);
+    state = await stateStore.read();
     if (!state.references.active) {
         const diagnosticsPath = await certifyMaterializedRelease(candidate, paths.dataDir);
         await stateStore.approve(candidate.releaseId, diagnosticsPath);
         await stateStore.activate(candidate.releaseId);
         state = await stateStore.read();
     }
-    const endpoint = await readEndpointMetadata(paths.endpointMetadataPath);
-    const probe = endpoint ? await probeOwnership(endpoint) : "dead";
+    endpoint = await readEndpointMetadata(paths.endpointMetadataPath);
+    probe = endpoint ? await probeOwnership(endpoint) : "dead";
     let decision = selectCohortLaunch(candidate, state, endpoint, probe);
     if (decision.action === "blocked") {
         await stateStore.blockPending(decision.reason, endpoint?.ownership.liveGenerationIds ?? []);
-        output.write(`AddOne startup is blocked to preserve uncertain live ownership: ${decision.reason}\n`);
+        output.write(`${PRODUCT_TEXT.diagnostic(`startup is blocked to preserve uncertain live ownership: ${decision.reason}`)}\n`);
         return 1;
     }
     if (decision.action === "clean-stale-owner" && endpoint) {
         const diagnostics = await cleanupProvenIdleOwner(endpoint);
         await writeFile(resolve(paths.dataDir, `cleanup-${Date.now()}.json`), JSON.stringify(diagnostics, null, 2));
         if (!diagnostics.terminated)
-            throw new Error(`could not safely clean stale AddOne supervisor ${endpoint.pid}`);
+            throw new Error(`could not safely clean stale ${PRODUCT_TEXT.displayName} supervisor ${endpoint.pid}`);
         await removeEndpointArtifacts(paths.endpointMetadataPath, paths.endpoint);
         decision = selectCohortLaunch(candidate, await stateStore.read(), null, "dead");
     }
@@ -62,12 +88,12 @@ export async function runBootstrap(options) {
         const released = await requestIdleOwnershipRelease(endpoint, candidate.releaseId, 2_000);
         if (!released) {
             await stateStore.blockPending("idle supervisor did not verify ownership release", endpoint.ownership.liveGenerationIds);
-            output.write("AddOne could not verify idle cohort ownership release; the retained release remains selected.\n");
+            output.write(`${PRODUCT_TEXT.diagnostic("could not verify idle cohort ownership release; the retained release remains selected.")}\n`);
             return 1;
         }
         if (!await releaseVerifiedIdleOwner(endpoint, paths.dataDir)) {
             await stateStore.blockPending("idle supervisor acknowledged release but did not terminate", endpoint.ownership.liveGenerationIds);
-            output.write("AddOne could not complete bounded idle cohort shutdown; the candidate remains pending.\n");
+            output.write(`${PRODUCT_TEXT.diagnostic("could not complete bounded idle cohort shutdown; the candidate remains pending.")}\n`);
             return 1;
         }
         await removeEndpointArtifacts(paths.endpointMetadataPath, paths.endpoint);
@@ -92,10 +118,18 @@ export async function runBootstrap(options) {
     await waitForVerifiedEndpoint(paths.endpointMetadataPath, selected, 8_000);
     return await launchUi(selected, environment);
 }
+async function readInstalledVersion(packageRoot) {
+    const manifest = JSON.parse(await readFile(resolve(packageRoot, "package.json"), "utf8"));
+    if (typeof manifest.version !== "string" || manifest.version.length === 0) {
+        throw new Error(PRODUCT_TEXT.diagnostic("package metadata has no version"));
+    }
+    return manifest.version;
+}
 export async function certifyMaterializedRelease(release, dataDir) {
     await verifyMaterializedRelease(release.releaseRoot, release, resolve(dataDir, "releases"));
     const path = resolve(dataDir, `certification-${release.releaseId}.json`);
     await writeFile(path, JSON.stringify({
+        schema: PRODUCT_IDENTITY.evidence.releaseCertificationSchema,
         releaseId: release.releaseId,
         contentDigest: release.contentDigest,
         verifiedAt: new Date().toISOString(),
@@ -104,7 +138,7 @@ export async function certifyMaterializedRelease(release, dataDir) {
     return path;
 }
 export async function startSupervisor(release, environment) {
-    const entry = await resolveReleaseEntryPoint(release, "bin/addone-supervisor.js");
+    const entry = await resolveReleaseEntryPoint(release, "bin/a1-supervisor.js");
     const child = spawn(process.execPath, [entry], {
         detached: true,
         env: releaseEnvironment(environment, release),
@@ -118,7 +152,7 @@ export async function startSupervisor(release, environment) {
     child.unref();
 }
 async function launchUi(release, environment) {
-    const entry = await resolveReleaseEntryPoint(release, "bin/addone-ui.js");
+    const entry = await resolveReleaseEntryPoint(release, "bin/a1-ui.js");
     return await new Promise((resolvePromise, rejectPromise) => {
         const child = spawn(process.execPath, [entry], {
             env: releaseEnvironment(environment, release),
@@ -132,9 +166,9 @@ async function launchUi(release, environment) {
 export function releaseEnvironment(environment, release) {
     return {
         ...environment,
-        ADDONE_RELEASE_ID: release.releaseId,
-        ADDONE_RELEASE_ROOT: release.releaseRoot,
-        ADDONE_RELEASE_DIGEST: release.contentDigest,
+        [PRODUCT_IDENTITY.environment.releaseId]: release.releaseId,
+        [PRODUCT_IDENTITY.environment.releaseRoot]: release.releaseRoot,
+        [PRODUCT_IDENTITY.environment.releaseDigest]: release.contentDigest,
     };
 }
 export async function waitForVerifiedEndpoint(path, release, timeoutMs) {
@@ -145,12 +179,12 @@ export async function waitForVerifiedEndpoint(path, release, timeoutMs) {
             return;
         await new Promise(resolvePromise => setTimeout(resolvePromise, 40));
     }
-    throw new Error(`AddOne supervisor did not publish verified endpoint metadata within ${timeoutMs}ms`);
+    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"));
-        if (!value || typeof value.supervisorId !== "string" || typeof value.endpoint !== "string" || !Number.isSafeInteger(value.pid)
+        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" || !value.ownership
             || !Array.isArray(value.ownership.liveGenerationIds) || !Array.isArray(value.ownership.nonResumableGenerationIds)) {
@@ -273,11 +307,10 @@ export async function waitForProcessExit(pid, timeoutMs) {
             return;
         await new Promise(resolvePromise => setTimeout(resolvePromise, 25));
     }
-    throw new Error(`AddOne supervisor ${pid} did not release process ownership within ${timeoutMs}ms`);
+    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 });
 }
-//# sourceMappingURL=bootstrap.js.map

package/dist/src/foundation/release/cohort-selection.d.ts

@@ -37,4 +37,3 @@ export type CohortLaunchDecision = {
     readonly pid: number | null;
 };
 export declare function selectCohortLaunch(candidate: MaterializedRelease, state: CohortState, endpoint: SupervisorEndpointMetadata | null, probe: OwnershipProbe): CohortLaunchDecision;
-//# sourceMappingURL=cohort-selection.d.ts.map

package/dist/src/foundation/release/cohort-selection.js

@@ -73,4 +73,3 @@ export function selectCohortLaunch(candidate, state, endpoint, probe) {
         reason: "candidate is not approved; retaining the active release",
     };
 }
-//# sourceMappingURL=cohort-selection.js.map

package/dist/src/foundation/release/cohort-state.d.ts

@@ -1,4 +1,5 @@
 import type { MaterializedRelease } from "./release-store.js";
+export declare const RELEASE_COHORT_SCHEMA: string;
 export type ReleaseApproval = "candidate" | "approved" | "rejected";
 export interface ReleaseRecord {
     readonly releaseId: string;
@@ -18,7 +19,7 @@ export interface ReleaseReferences {
     readonly retention: readonly string[];
 }
 export interface CohortState {
-    readonly schemaVersion: 1;
+    readonly schema: typeof RELEASE_COHORT_SCHEMA;
     readonly revision: number;
     readonly releases: Readonly<Record<string, ReleaseRecord>>;
     readonly references: ReleaseReferences;
@@ -35,6 +36,7 @@ export interface EndpointOwnership {
     readonly nonResumableGenerationIds: readonly string[];
 }
 export interface SupervisorEndpointMetadata {
+    readonly schema: string;
     readonly supervisorId: string;
     readonly endpoint: string;
     readonly pid: number;
@@ -65,4 +67,3 @@ export declare class CohortStateStore {
     removeUnreferencedRelease(releaseId: string, externalReferences: readonly string[]): Promise<CohortState>;
 }
 export declare function emptyState(): CohortState;
-//# sourceMappingURL=cohort-state.d.ts.map

package/dist/src/foundation/release/cohort-state.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+export const RELEASE_COHORT_SCHEMA = PRODUCT_IDENTITY.protocol.releaseCohortSchema;
 export class CohortStateStore {
     path;
     constructor(dataDir) {
@@ -153,7 +155,7 @@ export class CohortStateStore {
 }
 export function emptyState() {
     return {
-        schemaVersion: 1,
+        schema: RELEASE_COHORT_SCHEMA,
         revision: 0,
         releases: {},
         references: { active: null, pending: null, approved: null, rollback: null, retention: [] },
@@ -184,7 +186,7 @@ async function acquireLock(path) {
     }
 }
 function validateState(state) {
-    if (state.schemaVersion !== 1 || !Number.isSafeInteger(state.revision) || state.revision < 0)
+    if (state.schema !== RELEASE_COHORT_SCHEMA || !Number.isSafeInteger(state.revision) || state.revision < 0)
         throw new Error("invalid release cohort state");
     for (const reference of [state.references.active, state.references.pending, state.references.approved, state.references.rollback]) {
         if (reference !== null && !state.releases[reference])
@@ -193,9 +195,8 @@ function validateState(state) {
 }
 function validateTransition(current, next) {
     validateState(next);
-    if (next.schemaVersion !== current.schemaVersion)
+    if (next.schema !== current.schema)
         throw new Error("release cohort schema cannot change during a state update");
     if (next.revision !== current.revision)
         throw new Error("release cohort revision is controlled by the state store");
 }
-//# sourceMappingURL=cohort-state.js.map

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

@@ -0,0 +1 @@
+export declare function mapWithConcurrency<Value, Result>(values: readonly Value[], concurrency: number, operation: (value: Value, index: number) => Promise<Result>): Promise<Result[]>;

package/dist/src/foundation/release/concurrency.js

@@ -0,0 +1,17 @@
+export async function mapWithConcurrency(values, concurrency, operation) {
+    if (!Number.isSafeInteger(concurrency) || concurrency < 1)
+        throw new RangeError("concurrency must be a positive safe integer");
+    const results = new Array(values.length);
+    let nextIndex = 0;
+    const worker = async () => {
+        while (true) {
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= values.length)
+                return;
+            results[index] = await operation(values[index], index);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, worker));
+    return results;
+}