@timurproko/a1 0.1.8-dev.ece8cef → 0.2.1-dev.590

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

@@ -1,335 +0,0 @@
-import { spawn } from "node:child_process";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { connect } from "node:net";
-import { platform } from "node:os";
-import { resolve } from "node:path";
-import { selectCohortLaunch } from "./cohort-selection.js";
-import { CohortStateStore } from "./cohort-state.js";
-import { assertLaunchProfileId, resolveProductPaths } from "../lifecycle/index.js";
-import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
-import { cleanupProvenIdleOwner, processIsAlive } from "./process-cleanup.js";
-import { consumeMaterializationProof, 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 ?? "a1";
-    assertLaunchProfileId(launchProfileId);
-    environment[PRODUCT_IDENTITY.environment.launchProfile] = launchProfileId;
-    const output = options.output ?? process.stderr;
-    const paths = resolveProductPaths(environment);
-    await mkdir(paths.runtimeDir, { recursive: true, mode: 0o700 });
-    const stateStore = new CohortStateStore(paths.dataDir);
-    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);
-    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();
-    }
-    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.liveInstanceIds ?? []);
-        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 ${PRODUCT_TEXT.displayName} supervisor ${endpoint.pid}`);
-        await removeEndpointArtifacts(paths.endpointMetadataPath, paths.endpoint);
-        decision = selectCohortLaunch(candidate, await stateStore.read(), null, "dead");
-    }
-    else if (endpoint && probe === "dead") {
-        await removeEndpointArtifacts(paths.endpointMetadataPath, paths.endpoint);
-    }
-    if (decision.action === "launch-retained-ui") {
-        const retained = await verifyMaterializedRelease(decision.releaseRoot, undefined, resolve(paths.dataDir, "releases"));
-        if (decision.recordPending && endpoint) {
-            await stateStore.blockPending("candidate activation deferred by live non-resumable instances", endpoint.ownership.nonResumableInstanceIds);
-        }
-        const code = await launchUi(retained, environment);
-        if (decision.recordPending)
-            await activatePendingAfterBlockerExit(candidate, stateStore, paths, environment);
-        return code;
-    }
-    if (decision.action === "replace-idle-cohort" && endpoint) {
-        const diagnosticsPath = await certifyMaterializedRelease(candidate, paths.dataDir);
-        await stateStore.approve(candidate.releaseId, diagnosticsPath);
-        const released = await requestIdleOwnershipRelease(endpoint, candidate.releaseId, 2_000);
-        if (!released) {
-            await stateStore.blockPending("idle supervisor did not verify ownership release", endpoint.ownership.liveInstanceIds);
-            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.liveInstanceIds);
-            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);
-        await stateStore.activate(candidate.releaseId);
-        decision = { action: "activate-candidate", releaseId: candidate.releaseId, releaseRoot: candidate.releaseRoot, reason: "idle cohort released ownership" };
-    }
-    let selected;
-    if (decision.action === "activate-candidate") {
-        const current = await stateStore.read();
-        if (current.releases[candidate.releaseId]?.approval !== "approved") {
-            const diagnosticsPath = await certifyMaterializedRelease(candidate, paths.dataDir);
-            await stateStore.approve(candidate.releaseId, diagnosticsPath);
-        }
-        if ((await stateStore.read()).references.active !== candidate.releaseId)
-            await stateStore.activate(candidate.releaseId);
-        selected = candidate;
-    }
-    else {
-        selected = await readMaterializedRelease(decision.releaseRoot);
-    }
-    await startSupervisor(selected, environment);
-    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, verification = {}) {
-    if (!consumeMaterializationProof(release)) {
-        await verifyMaterializedRelease(release.releaseRoot, release, resolve(dataDir, "releases"), verification);
-    }
-    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(),
-        checks: [{ id: "immutable-content", passed: true }],
-    }, null, 2), { mode: 0o600 });
-    return path;
-}
-export async function startSupervisor(release, environment) {
-    const entry = await resolveReleaseEntryPoint(release, "bin/supervisor.js");
-    const child = spawn(process.execPath, [entry], {
-        detached: true,
-        env: releaseEnvironment(environment, release),
-        stdio: "ignore",
-        windowsHide: true,
-    });
-    await new Promise((resolvePromise, rejectPromise) => {
-        child.once("spawn", resolvePromise);
-        child.once("error", rejectPromise);
-    });
-    child.unref();
-}
-async function launchUi(release, environment) {
-    const entry = await resolveReleaseEntryPoint(release, "bin/guardian.js");
-    return await new Promise((resolvePromise, rejectPromise) => {
-        const child = spawn(process.execPath, [entry], {
-            env: releaseEnvironment(environment, release),
-            stdio: "inherit",
-            windowsHide: false,
-        });
-        child.once("error", rejectPromise);
-        child.once("close", (code, signal) => resolvePromise(code ?? (signal ? 1 : 0)));
-    });
-}
-export function releaseEnvironment(environment, release) {
-    return {
-        ...environment,
-        [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) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const metadata = await readEndpointMetadata(path);
-        if (metadata && metadata.releaseId === release.releaseId && await probeOwnership(metadata) === "live-verified")
-            return;
-        await new Promise(resolvePromise => setTimeout(resolvePromise, 40));
-    }
-    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;
-    while (Date.now() < deadline) {
-        endpoint = await readEndpointMetadata(paths.endpointMetadataPath);
-        if (!endpoint || endpoint.ownership.liveInstanceIds.length === 0)
-            break;
-        await new Promise(resolvePromise => setTimeout(resolvePromise, 40));
-    }
-    if (!endpoint || endpoint.ownership.liveInstanceIds.length > 0 || await probeOwnership(endpoint) !== "live-verified")
-        return;
-    const diagnosticsPath = await certifyMaterializedRelease(candidate, paths.dataDir);
-    await stateStore.approve(candidate.releaseId, diagnosticsPath);
-    if (!await requestIdleOwnershipRelease(endpoint, candidate.releaseId, 2_000))
-        return;
-    if (!await releaseVerifiedIdleOwner(endpoint, paths.dataDir))
-        return;
-    await removeEndpointArtifacts(paths.endpointMetadataPath, paths.endpoint);
-    await stateStore.activate(candidate.releaseId);
-    await startSupervisor(candidate, environment);
-    await waitForVerifiedEndpoint(paths.endpointMetadataPath, candidate, 8_000);
-}
-export async function releaseVerifiedIdleOwner(metadata, dataDir, operations = {}) {
-    try {
-        await (operations.waitForExit ?? waitForProcessExit)(metadata.pid, 3_000);
-        return true;
-    }
-    catch {
-        // The authenticated idle-release handshake authorizes bounded cleanup of
-        // this exact boot when a native handle outlives graceful shutdown.
-        const diagnostics = await (operations.cleanup ?? cleanupProvenIdleOwner)(metadata);
-        await writeFile(resolve(dataDir, `cleanup-${Date.now()}.json`), JSON.stringify(diagnostics, null, 2));
-        return diagnostics.terminated;
-    }
-}
-async function requestIdleOwnershipRelease(metadata, candidateReleaseId, timeoutMs) {
-    return await new Promise(resolvePromise => {
-        const socket = connect(metadata.endpoint);
-        const decoder = new LineFrameDecoder();
-        let settled = false;
-        const finish = (released) => {
-            if (settled)
-                return;
-            settled = true;
-            socket.destroy();
-            resolvePromise(released);
-        };
-        socket.once("error", () => finish(false));
-        socket.once("connect", () => socket.write(encodeFrame({ type: "release-idle-ownership", bootNonce: metadata.bootNonce, candidateReleaseId })));
-        socket.on("data", chunk => {
-            try {
-                const message = decoder.push(chunk)[0];
-                if (message?.type === "release-ownership-result")
-                    finish(message.released === true);
-            }
-            catch {
-                finish(false);
-            }
-        });
-        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) {
-        if (!processIsAlive(pid))
-            return;
-        await new Promise(resolvePromise => setTimeout(resolvePromise, 25));
-    }
-    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/src/foundation/release/cohort-state.d.ts

@@ -1,70 +0,0 @@
-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;
-    readonly releaseRoot: string;
-    readonly packageVersion: string;
-    readonly contentDigest: string;
-    readonly approval: ReleaseApproval;
-    readonly materializedAt: string;
-    readonly certifiedAt: string | null;
-    readonly diagnosticsPath: string | null;
-}
-export interface ReleaseReferences {
-    readonly active: string | null;
-    readonly pending: string | null;
-    readonly approved: string | null;
-    readonly rollback: string | null;
-    readonly retention: readonly string[];
-}
-export interface CohortState {
-    readonly schema: typeof RELEASE_COHORT_SCHEMA;
-    readonly revision: number;
-    readonly releases: Readonly<Record<string, ReleaseRecord>>;
-    readonly references: ReleaseReferences;
-    readonly activation: {
-        readonly state: "idle" | "pending" | "draining" | "blocked" | "failed";
-        readonly reason: string | null;
-        readonly blockerGenerationIds: readonly string[];
-        readonly updatedAt: string;
-    };
-}
-export interface EndpointOwnership {
-    readonly state: "idle" | "busy" | "draining" | "released" | "blocked";
-    readonly liveInstanceIds: readonly string[];
-    readonly nonResumableInstanceIds: readonly string[];
-    readonly uncertainInstanceIds: readonly string[];
-}
-export interface SupervisorEndpointMetadata {
-    readonly schema: string;
-    readonly supervisorId: string;
-    readonly endpoint: string;
-    readonly pid: number;
-    readonly pidStartIdentity: string;
-    readonly bootNonce: string;
-    readonly startedAt: string;
-    readonly releaseId: string;
-    readonly releaseRoot: string;
-    readonly contentDigest: string;
-    readonly ownership: EndpointOwnership;
-    readonly envelope: string;
-    readonly envelopeRevision: number;
-    readonly requiredFeatures: readonly string[];
-    readonly optionalFeatures: readonly string[];
-    readonly contractDigest: string;
-}
-export declare class CohortStateStore {
-    readonly path: string;
-    constructor(dataDir: string);
-    read(): Promise<CohortState>;
-    update(operation: (current: CohortState) => CohortState): Promise<CohortState>;
-    recordCandidate(release: MaterializedRelease): Promise<CohortState>;
-    approve(releaseId: string, diagnosticsPath: string): Promise<CohortState>;
-    activate(releaseId: string): Promise<CohortState>;
-    blockPending(reason: string, blockerGenerationIds: readonly string[]): Promise<CohortState>;
-    rollback(ownershipReleased: boolean): Promise<CohortState>;
-    setRetention(releaseIds: readonly string[]): Promise<CohortState>;
-    removeUnreferencedRelease(releaseId: string, externalReferences: readonly string[]): Promise<CohortState>;
-}
-export declare function emptyState(): CohortState;

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

@@ -1,202 +0,0 @@
-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) {
-        this.path = resolve(dataDir, "release-state.json");
-    }
-    async read() {
-        try {
-            const state = JSON.parse(await readFile(this.path, "utf8"));
-            validateState(state);
-            return state;
-        }
-        catch (error) {
-            if (error instanceof Error && "code" in error && error.code === "ENOENT")
-                return emptyState();
-            throw error;
-        }
-    }
-    async update(operation) {
-        await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
-        const lockPath = `${this.path}.lock`;
-        const lock = await acquireLock(lockPath);
-        try {
-            const current = await this.read();
-            const next = operation(current);
-            validateTransition(current, next);
-            const committed = { ...next, revision: current.revision + 1 };
-            const temporary = `${this.path}.${process.pid}.${randomUUID()}.tmp`;
-            const file = await open(temporary, "wx", 0o600);
-            try {
-                await file.writeFile(JSON.stringify(committed, null, 2));
-                await file.sync();
-            }
-            finally {
-                await file.close();
-            }
-            await rename(temporary, this.path);
-            return committed;
-        }
-        finally {
-            await lock.close();
-            await rm(lockPath, { force: true });
-        }
-    }
-    async recordCandidate(release) {
-        return await this.update(current => {
-            const existing = current.releases[release.releaseId];
-            const record = existing ?? {
-                releaseId: release.releaseId,
-                releaseRoot: release.releaseRoot,
-                packageVersion: release.packageVersion,
-                contentDigest: release.contentDigest,
-                approval: "candidate",
-                materializedAt: new Date().toISOString(),
-                certifiedAt: null,
-                diagnosticsPath: null,
-            };
-            return {
-                ...current,
-                releases: { ...current.releases, [release.releaseId]: record },
-                references: {
-                    ...current.references,
-                    pending: current.references.active === release.releaseId ? current.references.pending : release.releaseId,
-                    retention: unique([...current.references.retention, release.releaseId]),
-                },
-                activation: activation("pending", "candidate awaits certification and safe activation"),
-            };
-        });
-    }
-    async approve(releaseId, diagnosticsPath) {
-        return await this.update(current => {
-            const release = requiredRelease(current, releaseId);
-            return {
-                ...current,
-                releases: { ...current.releases, [releaseId]: { ...release, approval: "approved", certifiedAt: new Date().toISOString(), diagnosticsPath } },
-                references: { ...current.references, approved: releaseId, pending: current.references.active === releaseId ? null : releaseId },
-            };
-        });
-    }
-    async activate(releaseId) {
-        return await this.update(current => {
-            const release = requiredRelease(current, releaseId);
-            if (release.approval !== "approved")
-                throw new Error(`cannot activate unverified release ${releaseId}`);
-            const prior = current.references.active;
-            return {
-                ...current,
-                references: {
-                    active: releaseId,
-                    pending: null,
-                    approved: releaseId,
-                    rollback: prior && prior !== releaseId ? prior : current.references.rollback,
-                    retention: unique([...current.references.retention, releaseId, ...(prior ? [prior] : [])]),
-                },
-                activation: activation("idle", null),
-            };
-        });
-    }
-    async blockPending(reason, blockerGenerationIds) {
-        return await this.update(current => ({ ...current, activation: { ...activation("blocked", reason), blockerGenerationIds: [...blockerGenerationIds] } }));
-    }
-    async rollback(ownershipReleased) {
-        if (!ownershipReleased)
-            throw new Error("cannot roll back before current cohort ownership is released");
-        return await this.update(current => {
-            const rollbackId = current.references.rollback;
-            if (!rollbackId)
-                throw new Error("no rollback release is recorded");
-            const rollback = requiredRelease(current, rollbackId);
-            if (rollback.approval !== "approved")
-                throw new Error(`cannot roll back to unverified release ${rollbackId}`);
-            return {
-                ...current,
-                references: {
-                    ...current.references,
-                    active: rollbackId,
-                    pending: null,
-                    approved: rollbackId,
-                    rollback: current.references.active,
-                    retention: unique([...current.references.retention, rollbackId, ...(current.references.active ? [current.references.active] : [])]),
-                },
-                activation: activation("idle", null),
-            };
-        });
-    }
-    async setRetention(releaseIds) {
-        return await this.update(current => {
-            for (const releaseId of releaseIds)
-                requiredRelease(current, releaseId);
-            return { ...current, references: { ...current.references, retention: unique(releaseIds) } };
-        });
-    }
-    async removeUnreferencedRelease(releaseId, externalReferences) {
-        return await this.update(current => {
-            requiredRelease(current, releaseId);
-            const protectedIds = new Set([
-                current.references.active,
-                current.references.pending,
-                current.references.approved,
-                current.references.rollback,
-                ...current.references.retention,
-                ...externalReferences,
-            ].filter((value) => value !== null));
-            if (protectedIds.has(releaseId))
-                throw new Error(`release ${releaseId} is still referenced and cannot be collected`);
-            const releases = { ...current.releases };
-            delete releases[releaseId];
-            return { ...current, releases };
-        });
-    }
-}
-export function emptyState() {
-    return {
-        schema: RELEASE_COHORT_SCHEMA,
-        revision: 0,
-        releases: {},
-        references: { active: null, pending: null, approved: null, rollback: null, retention: [] },
-        activation: activation("idle", null),
-    };
-}
-function activation(state, reason) {
-    return { state, reason, blockerGenerationIds: [], updatedAt: new Date().toISOString() };
-}
-function requiredRelease(state, releaseId) {
-    const release = state.releases[releaseId];
-    if (!release)
-        throw new Error(`unknown release ${releaseId}`);
-    return release;
-}
-function unique(values) { return [...new Set(values)]; }
-async function acquireLock(path) {
-    const deadline = Date.now() + 5_000;
-    while (true) {
-        try {
-            return await open(path, "wx", 0o600);
-        }
-        catch (error) {
-            if (!(error instanceof Error && "code" in error && error.code === "EEXIST") || Date.now() >= deadline)
-                throw error;
-            await new Promise(resolvePromise => setTimeout(resolvePromise, 20));
-        }
-    }
-}
-function validateState(state) {
-    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])
-            throw new Error(`release reference points to an unknown release: ${reference}`);
-    }
-}
-function validateTransition(current, next) {
-    validateState(next);
-    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");
-}

package/dist/src/foundation/release/development-preview-release.d.ts

@@ -1,49 +0,0 @@
-export declare const PREVIEW_RELEASE_SCHEMA: string;
-export interface DevelopmentPreviewCandidate {
-    readonly version: string;
-    readonly requiresVersionCommit: boolean;
-}
-export interface DevelopmentPreviewRegistryState {
-    readonly published: boolean;
-    readonly nextVersion: string | null;
-}
-export interface DevelopmentPreviewVerificationOptions {
-    readonly attempts?: number;
-    readonly delayMs?: number;
-    readonly delay?: (milliseconds: number) => Promise<void>;
-}
-export interface DevelopmentPreviewPublishResult {
-    readonly published: boolean;
-    readonly recoveredPublishError: unknown | null;
-}
-export interface UncertifiedDevelopmentPreviewEvidenceInput {
-    readonly packageName: string;
-    readonly version: string;
-    readonly commit: string;
-    readonly tarball: string;
-    readonly integrity: string;
-    readonly shasum: string;
-    readonly platform: NodeJS.Platform;
-    readonly architecture: string;
-    readonly recordedAt: string;
-}
-export interface UncertifiedDevelopmentPreviewEvidence extends UncertifiedDevelopmentPreviewEvidenceInput {
-    readonly schema: typeof PREVIEW_RELEASE_SCHEMA;
-    readonly channel: "next";
-    readonly certificationStatus: "uncertified-development-preview";
-    readonly terminalCapability: "owned-ui";
-    readonly manualAcceptance: "accepted";
-    readonly physicalHostCertification: "deferred";
-    readonly crossPlatformCertification: "deferred";
-    readonly stableReleaseEligible: false;
-}
-export declare function createUncertifiedDevelopmentPreviewEvidence(input: UncertifiedDevelopmentPreviewEvidenceInput): UncertifiedDevelopmentPreviewEvidence;
-export declare function requireManuallyAcceptedDevelopmentPreview(version: string, acceptedVersion: string): void;
-export declare function selectDevelopmentPreviewCandidate(currentVersion: string, publishedVersions: readonly string[]): DevelopmentPreviewCandidate;
-/**
- * Treats npm's process result as provisional: browser-auth completion can fail
- * after the immutable upload succeeds. Registry identity remains authoritative.
- */
-export declare function publishDevelopmentPreviewWithRecovery(publish: () => Promise<void>, verify: () => Promise<void>): Promise<DevelopmentPreviewPublishResult>;
-export declare function verifyDevelopmentPreviewRegistry(version: string, observe: () => Promise<DevelopmentPreviewRegistryState>, repairNextTag: () => Promise<void>, options?: DevelopmentPreviewVerificationOptions): Promise<void>;
-export declare function developmentPreviewTarballName(packageName: string, version: string): string;