@maiaos/node 0.1.0-canary.44938d4.manual.1

package/dist/session/testing/built-session-execution-authority.js

@@ -0,0 +1,1242 @@
+import { randomBytes } from "node:crypto";
+import { mkdtemp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { Cause, Deferred, Duration, Effect, Exit, Layer, Semaphore, } from "effect";
+import { createBoundedCapture, decodeBoundedUtf8, encodeUtf8IntoBounded, } from "./built-session-bounded-capture.js";
+import { attestReceipt, receiptVerifierFor, signReceipt, } from "./built-session-execution-authenticator.js";
+import { captureExecutionBudget, monotonicMilliseconds, runWithinRemaining, } from "./built-session-execution-budget.js";
+import { BuiltSessionExecutionAuthority, } from "./built-session-execution-contract.js";
+import { BuiltSessionAuthorityFailure, cleanupUnknownFailure, primaryFailureAfterCleanup, } from "./built-session-execution-failure.js";
+import { decodeBoundaryHandle, } from "./built-session-execution-handle.js";
+import { decodeBoundedExit, decodeCensus, decodeCreateSessionInput, decodeHarnessOptions, decodeIdentityInput, decodeInvocationRequest, decodeOfficialFakeScript, decodeOwnedRootInput, decodeRemoveRootInput, decodeRootPathInput, decodeSessionEmptyInput, gateInvocationRequest, } from "./built-session-execution-input.js";
+import { describeBuiltSessionLifecycle, initialBuiltSessionLifecycle, transitionBuiltSessionLifecycle, } from "./built-session-execution-lifecycle.js";
+import { builtSessionExecutionLimits, hasBuiltSessionWaiterCapacity, validateBuiltSessionRequestLimits, } from "./built-session-execution-policy.js";
+import { boundaryHandleMismatch, copyBoundedExit, projectBoundaryController, projectEmptyReceipt, projectFakeBoundaryHandle, projectFakeCensus, projectInvocationSnapshot, projectOfficialFakeSnapshot, projectOwnedRootSnapshot, projectPreparedReceipt, projectReceiptIdentity, projectRootReceiptBody, projectSessionEmptyExpected, projectSessionEmptyLifecycle, projectSessionSnapshot, projectStartedReceipt, receiptOccurrence, } from "./built-session-execution-projection.js";
+import { acceptLifecycleReceipt, decodeEmptyReceipt, decodePreparedReceipt, decodeSessionEmptyReceipt, decodeStartedReceipt, decodeTerminationReceipt, digestInvocationRequest, digestRootIdentity, occurrenceTime, } from "./built-session-execution-receipt.js";
+import { captureRootIdentity, rootIdentityMatches, } from "./built-session-execution-record.js";
+import { freezeSnapshot, } from "./built-session-execution-snapshot.js";
+export { BuiltSessionExecutionAuthority } from "./built-session-execution-contract.js";
+const fail = (input) => Effect.fail(new BuiltSessionAuthorityFailure(input));
+const opaqueId = (prefix) => `${prefix}_${randomBytes(16).toString("hex")}`;
+const fakeFor = (state) => {
+    if (state.fake === undefined)
+        throw new Error("Official fake state is unavailable.");
+    return state.fake;
+};
+const helperSecretFor = (state) => {
+    if (state.helperSecret === undefined)
+        throw new Error("Official fake secret is unavailable.");
+    return state.helperSecret;
+};
+const controllerFor = (record) => {
+    if (record.controller === undefined)
+        throw new Error("Boundary controller is unavailable.");
+    return record.controller;
+};
+const initialSnapshot = () => initialBuiltSessionLifecycle();
+const transitionRecord = (record, event) => {
+    const next = transitionBuiltSessionLifecycle(record.snapshot, event);
+    if (next === undefined) {
+        return new BuiltSessionAuthorityFailure({
+            message: `Illegal lifecycle event ${event.type} in ${describeBuiltSessionLifecycle(record.snapshot)}.`,
+            reason: "cleanup_unknown",
+        });
+    }
+    record.snapshot = next;
+};
+const mutateRecord = (record, update) => record.session.mutex.withPermit(Effect.suspend(() => {
+    const failure = update();
+    return failure === undefined ? Effect.void : Effect.fail(failure);
+}));
+const lifecycleOf = (record) => describeBuiltSessionLifecycle(record.snapshot);
+const eventNames = [
+    "acquireEntered",
+    "emptyEntered",
+    "prepared",
+    "prepareEntered",
+    "semanticExitCompleted",
+    "startDispatched",
+    "startedAndWaitingForExit",
+    "terminateEntered",
+];
+const gateNames = [
+    "empty",
+    "exit",
+    "open",
+    "prepare",
+    "start",
+    "startAck",
+    "terminate",
+];
+const makeEvents = () => Object.fromEntries(eventNames.map((name) => [name, { pending: 0, waiters: [] }]));
+const makeGates = (held) => Object.fromEntries(gateNames.map((name) => [
+    name,
+    { held: held.has(name), permits: 0, waiters: [] },
+]));
+const initialFakeFields = () => ({
+    acquireCalls: 0,
+    censusCalls: 0,
+    closeCalls: 0,
+    descendantPresent: false,
+    empty: false,
+    emptyProofCalls: 0,
+    eventWaiterCount: 0,
+    gateWaiterCount: 0,
+    helpersCreated: 0,
+    prepareCalls: 0,
+    prepared: false,
+    reclaimCalls: 0,
+    reclaimedControllerIds: [],
+    retainedWaiterCount: 0,
+    sessionEmptyProofCalls: 0,
+    startCalls: 0,
+    started: false,
+    targetsCreated: 0,
+    terminateCalls: 0,
+    terminated: false,
+    terminatedControllerIds: [],
+});
+const makeFake = Effect.fn("BuiltSessionOfficialFake.make")(function* (script) {
+    return {
+        ...initialFakeFields(),
+        controllers: new Map(),
+        events: makeEvents(),
+        gates: makeGates(new Set(script.heldGates ?? [])),
+        mutex: yield* Semaphore.make(1),
+        script,
+    };
+});
+const signalEvent = (fake, name) => Effect.uninterruptible(Effect.gen(function* () {
+    const waiter = yield* fake.mutex.withPermit(Effect.sync(() => {
+        const event = fake.events[name];
+        const next = event.waiters.shift();
+        if (next === undefined)
+            event.pending += 1;
+        else {
+            fake.eventWaiterCount -= 1;
+            fake.retainedWaiterCount -= 1;
+        }
+        return next;
+    }));
+    if (waiter !== undefined)
+        yield* Deferred.succeed(waiter, true);
+}));
+const forgetWaiter = (input) => input.fake.mutex.withPermit(Effect.sync(() => {
+    const waiters = input.select();
+    const index = waiters.indexOf(input.waiter);
+    if (index >= 0) {
+        waiters.splice(index, 1);
+        input.fake[input.counter] -= 1;
+        input.fake.retainedWaiterCount -= 1;
+    }
+}));
+const selectGateWaiter = Effect.fn("BuiltSessionOfficialFake.selectGate")(function* (fake, name) {
+    return yield* fake.mutex.withPermit(Effect.gen(function* () {
+        const gate = fake.gates[name];
+        if (!gate.held)
+            return;
+        if (gate.permits > 0) {
+            gate.permits -= 1;
+            return;
+        }
+        if (!hasBuiltSessionWaiterCapacity(fake.retainedWaiterCount)) {
+            return yield* fail({
+                message: "Official fake waiters are saturated.",
+                reason: "cleanup_unknown",
+            });
+        }
+        const deferred = yield* Deferred.make();
+        gate.waiters.push(deferred);
+        fake.gateWaiterCount += 1;
+        fake.retainedWaiterCount += 1;
+        return deferred;
+    }));
+});
+const waitGate = (fake, name) => Effect.acquireUseRelease(selectGateWaiter(fake, name), (selected) => selected === undefined ? Effect.succeed(true) : Deferred.await(selected), (selected) => selected === undefined
+    ? Effect.void
+    : forgetWaiter({
+        counter: "gateWaiterCount",
+        fake,
+        select: () => fake.gates[name].waiters,
+        waiter: selected,
+    }));
+const failOutcome = Effect.fn("BuiltSessionOfficialFake.outcome")(function* (outcome, label) {
+    if (outcome === "defect")
+        return yield* Effect.die(new Error(label));
+    if (outcome === "eof" || outcome === "lost") {
+        return yield* fail({
+            message: `The ${label} acknowledgement was unavailable.`,
+            reason: "cleanup_unknown",
+        });
+    }
+    if (outcome === "never")
+        return yield* Effect.never;
+});
+const requireController = (fake, controllerId) => {
+    const existing = fake.controllers.get(controllerId);
+    if (existing !== undefined)
+        return existing;
+    const created = {
+        helpersCreated: 0,
+        published: false,
+        reclaimed: false,
+        targetsCreated: 0,
+        terminated: false,
+    };
+    fake.controllers.set(controllerId, created);
+    return created;
+};
+const fakeInspect = (fake) => fake.mutex.withPermit(Effect.sync(() => projectOfficialFakeSnapshot(fake)));
+const selectEventWaiter = Effect.fn("BuiltSessionOfficialFake.selectEvent")(function* (fake, name) {
+    return yield* fake.mutex.withPermit(Effect.gen(function* () {
+        const event = fake.events[name];
+        if (event.pending > 0) {
+            event.pending -= 1;
+            return;
+        }
+        if (!hasBuiltSessionWaiterCapacity(fake.retainedWaiterCount)) {
+            return yield* fail({
+                message: "Official fake event waiters are saturated.",
+                reason: "deadline",
+            });
+        }
+        const deferred = yield* Deferred.make();
+        event.waiters.push(deferred);
+        fake.eventWaiterCount += 1;
+        fake.retainedWaiterCount += 1;
+        return deferred;
+    }));
+});
+const awaitSelectedEvent = (selected) => selected === undefined
+    ? Effect.succeed(true)
+    : Deferred.await(selected).pipe(Effect.timeout(Duration.millis(builtSessionExecutionLimits.maxMaximumTotalMilliseconds)), Effect.catchTag("TimeoutError", () => fail({
+        message: "Official fake event wait exceeded its validated maximum.",
+        reason: "deadline",
+    })));
+const awaitOfficialEvent = Effect.fn("BuiltSessionOfficialFake.awaitEvent")(function* (fake, name) {
+    return yield* Effect.acquireUseRelease(selectEventWaiter(fake, name), awaitSelectedEvent, (selected) => selected === undefined
+        ? Effect.void
+        : forgetWaiter({
+            counter: "eventWaiterCount",
+            fake,
+            select: () => fake.events[name].waiters,
+            waiter: selected,
+        }));
+});
+const releaseOfficialGate = Effect.fn("BuiltSessionOfficialFake.releaseGate")(function* (fake, name) {
+    yield* Effect.uninterruptible(Effect.gen(function* () {
+        const waiter = yield* fake.mutex.withPermit(Effect.sync(() => {
+            const gate = fake.gates[name];
+            if (!gate.held)
+                return;
+            const selected = gate.waiters.shift();
+            if (selected === undefined)
+                gate.permits += 1;
+            else {
+                fake.gateWaiterCount -= 1;
+                fake.retainedWaiterCount -= 1;
+            }
+            return selected;
+        }));
+        if (waiter !== undefined)
+            yield* Deferred.succeed(waiter, true);
+    }));
+});
+const methodsOnlyControl = (fake) => ({
+    awaitEvent: (name) => {
+        if (!eventNames.includes(name)) {
+            return fail({
+                message: "Unknown official fake event name.",
+                reason: "spawn",
+            });
+        }
+        return awaitOfficialEvent(fake, name);
+    },
+    inspect: () => fakeInspect(fake),
+    releaseGate: (name) => {
+        if (!gateNames.includes(name)) {
+            return fail({
+                message: "Unknown official fake gate name.",
+                reason: "spawn",
+            });
+        }
+        return releaseOfficialGate(fake, name);
+    },
+});
+const recordAcquired = (fake, controller, boundaryId) => fake.mutex.withPermit(Effect.sync(() => {
+    const state = requireController(fake, controller.controllerId);
+    fake.acquireCalls += 1;
+    fake.helpersCreated += 1;
+    state.boundaryId = boundaryId;
+    state.helpersCreated = 1;
+    state.published = true;
+}));
+const markAcquireDefect = (fake, controllerId) => fake.mutex.withPermit(Effect.sync(() => {
+    requireController(fake, controllerId).reclaimed = true;
+    fake.reclaimedControllerIds.push(controllerId);
+}));
+const fakeAcquire = Effect.fn("BuiltSessionOfficialFake.acquire")(function* (fake, controller, acquireEntry) {
+    yield* signalEvent(fake, "acquireEntered");
+    yield* waitGate(fake, "open");
+    const call = yield* fake.mutex.withPermit(Effect.sync(() => fake.acquireCalls + 1));
+    if (fake.script.openDefectOnCall === call) {
+        yield* markAcquireDefect(fake, controller.controllerId);
+        return yield* Effect.die(new Error("acquireBoundary defected"));
+    }
+    yield* failOutcome(fake.script.open ?? "ok", "open");
+    const openedAt = yield* monotonicMilliseconds();
+    const boundaryId = opaqueId("boundary");
+    yield* recordAcquired(fake, controller, boundaryId);
+    return projectFakeBoundaryHandle({
+        boundaryId,
+        controller,
+        fake,
+        openedAt: Math.max(acquireEntry, openedAt),
+    });
+});
+const fakeReclaim = Effect.fn("BuiltSessionOfficialFake.reclaim")(function* (fake, controller) {
+    yield* fake.mutex.withPermit(Effect.sync(() => {
+        fake.reclaimCalls += 1;
+    }));
+    yield* failOutcome(fake.script.reclaim ?? "ok", "reclaim");
+    yield* fake.mutex.withPermit(Effect.sync(() => {
+        const state = requireController(fake, controller.controllerId);
+        if (state.reclaimed || state.terminated)
+            return;
+        state.reclaimed = true;
+        state.helpersCreated = 0;
+        state.targetsCreated = 0;
+        fake.reclaimedControllerIds.push(controller.controllerId);
+    }));
+});
+const fakeCensus = Effect.fn("BuiltSessionOfficialFake.census")(function* (fake, handle) {
+    const call = yield* fake.mutex.withPermit(Effect.sync(() => {
+        fake.censusCalls += 1;
+        return fake.censusCalls;
+    }));
+    if (fake.script.censusNeverOnCall === call)
+        return yield* Effect.never;
+    if (fake.script.censusDefectOnCall === call) {
+        return yield* Effect.die(new Error("hostile census defect"));
+    }
+    yield* failOutcome(fake.script.census ?? "ok", "census");
+    return yield* fake.mutex.withPermit(Effect.sync(() => projectFakeCensus(fake, handle)));
+});
+const markPrepared = (fake, record) => fake.mutex.withPermit(Effect.sync(() => {
+    fake.prepareCalls += 1;
+    fake.prepared = true;
+    fake.targetsCreated += 1;
+    requireController(fake, controllerFor(record).controllerId).targetsCreated = 1;
+}));
+const fakePrepared = Effect.fn("BuiltSessionOfficialFake.prepare")(function* (state, record) {
+    const fake = fakeFor(state);
+    if (fake.script.helperEofAt === "before_prepared") {
+        return yield* fail({
+            message: "The helper ended before PREPARED.",
+            reason: "cleanup_unknown",
+        });
+    }
+    yield* signalEvent(fake, "prepareEntered");
+    yield* waitGate(fake, "prepare");
+    yield* failOutcome(fake.script.prepare ?? "ok", "prepare");
+    yield* markPrepared(fake, record);
+    const now = yield* monotonicMilliseconds();
+    const body = projectPreparedReceipt(fake.script, record, now);
+    if (fake.script.defectAfterPrepared === true) {
+        return yield* Effect.die(new Error("defect after PREPARED production"));
+    }
+    return attestReceipt(helperSecretFor(state), body);
+});
+const markStarted = (fake) => fake.mutex.withPermit(Effect.sync(() => {
+    fake.startCalls += 1;
+    fake.started = true;
+    fake.descendantPresent = fake.script.descendantAfterStart === true;
+    fake.empty = fake.script.descendantAfterStart !== true;
+}));
+const fakeStarted = Effect.fn("BuiltSessionOfficialFake.start")(function* (state, record) {
+    const fake = fakeFor(state);
+    if (fake.script.helperEofAt === "after_prepared") {
+        return yield* fail({
+            message: "The helper ended before START.",
+            reason: "cleanup_unknown",
+        });
+    }
+    yield* waitGate(fake, "start");
+    yield* failOutcome(fake.script.start ?? "ok", "start");
+    yield* markStarted(fake);
+    yield* signalEvent(fake, "startDispatched");
+    yield* waitGate(fake, "startAck");
+    const now = yield* monotonicMilliseconds();
+    return attestReceipt(helperSecretFor(state), projectStartedReceipt(fake.script, record, now));
+});
+const boundedFakeExit = (fake, maxOutputBytes) => {
+    const stdout = createBoundedCapture(maxOutputBytes);
+    const stderr = createBoundedCapture(maxOutputBytes);
+    encodeUtf8IntoBounded(fake.script.stdout ?? "", stdout);
+    return {
+        code: fake.script.exitCode ?? 0,
+        stderr: {
+            bytes: [...stderr.bytes.subarray(0, stderr.stored)],
+            stored: stderr.stored,
+        },
+        stdout: {
+            bytes: [...stdout.bytes.subarray(0, stdout.stored)],
+            stored: stdout.stored,
+        },
+    };
+};
+const fakeDirectExit = Effect.fn("BuiltSessionOfficialFake.exit")(function* (fake, maxOutputBytes) {
+    yield* signalEvent(fake, "startedAndWaitingForExit");
+    if (fake.script.stdoutError === true) {
+        return yield* fail({
+            message: "The fake stdout stream failed.",
+            reason: "stdout_failed",
+        });
+    }
+    if (fake.script.stderrError === true) {
+        return yield* fail({
+            message: "The fake stderr stream failed.",
+            reason: "stderr_failed",
+        });
+    }
+    yield* waitGate(fake, "exit");
+    yield* signalEvent(fake, "semanticExitCompleted");
+    return boundedFakeExit(fake, maxOutputBytes);
+});
+const fakeIsPopulated = (fake, outcome) => fake.mutex.withPermit(Effect.sync(() => outcome === "populated" ||
+    fake.script.populatedEmpty === true ||
+    fake.descendantPresent));
+const markTerminated = (fake, record) => fake.mutex.withPermit(Effect.sync(() => {
+    const id = controllerFor(record).controllerId;
+    const controller = requireController(fake, id);
+    if (!controller.terminated && !controller.reclaimed) {
+        controller.terminated = true;
+        controller.targetsCreated = 0;
+        fake.terminateCalls += 1;
+        fake.terminated = true;
+        fake.terminatedControllerIds.push(id);
+    }
+    if (fake.script.emptyProof !== "populated") {
+        fake.descendantPresent = false;
+        fake.empty = true;
+    }
+}));
+const fakeTerminate = Effect.fn("BuiltSessionOfficialFake.terminate")(function* (state, record) {
+    const fake = fakeFor(state);
+    yield* signalEvent(fake, "terminateEntered");
+    yield* waitGate(fake, "terminate");
+    yield* failOutcome(fake.script.terminate ?? "ok", "terminate");
+    yield* markTerminated(fake, record);
+    const now = yield* monotonicMilliseconds();
+    const { identity } = projectReceiptIdentity(record, now);
+    return attestReceipt(helperSecretFor(state), {
+        ...identity,
+        order: record.lastAcceptedOrder + 1,
+        phase: "terminated",
+        terminatedAt: receiptOccurrence(fake.script, now, record.budget.absoluteDeadline),
+    });
+});
+const emptyReceipt = (input) => {
+    const { fake, now, record, state } = input;
+    return attestReceipt(helperSecretFor(state), projectEmptyReceipt(fake.script, record, now));
+};
+const incrementEmptyProof = (fake) => fake.mutex.withPermit(Effect.sync(() => {
+    fake.emptyProofCalls += 1;
+}));
+const markEmpty = (fake) => fake.mutex.withPermit(Effect.sync(() => {
+    fake.empty = true;
+}));
+const fakeEmpty = Effect.fn("BuiltSessionOfficialFake.empty")(function* (state, record) {
+    const fake = fakeFor(state);
+    if (fake.script.helperEofAt === "during_cleanup") {
+        return yield* fail({
+            message: "The helper ended before EMPTY.",
+            reason: "cleanup_unknown",
+        });
+    }
+    yield* signalEvent(fake, "emptyEntered");
+    yield* waitGate(fake, "empty");
+    yield* incrementEmptyProof(fake);
+    const outcome = fake.script.emptyProof ?? "empty";
+    yield* failOutcome(outcome, "empty proof");
+    const populated = yield* fakeIsPopulated(fake, outcome);
+    if (populated || outcome === "invalid" || outcome === "late") {
+        return yield* fail({
+            message: "The boundary is not exactly empty.",
+            reason: "cleanup_unknown",
+        });
+    }
+    yield* markEmpty(fake);
+    const now = yield* monotonicMilliseconds();
+    return emptyReceipt({ fake, now, record, state });
+});
+const acceptReceipt = (input) => Effect.gen(function* () {
+    const now = yield* monotonicMilliseconds();
+    const expected = projectReceiptIdentity(input.record, now).expected;
+    const receipt = yield* acceptLifecycleReceipt({
+        decode: input.decode,
+        expected,
+        lastAcceptedAt: input.record.lastAcceptedAt,
+        lastAcceptedOrder: input.record.lastAcceptedOrder,
+        receipt: input.raw,
+        verifier: receiptVerifierFor(helperSecretFor(input.state)),
+    });
+    yield* mutateRecord(input.record, () => {
+        input.record.lastAcceptedAt = occurrenceTime(receipt);
+        input.record.lastAcceptedOrder = receipt.order;
+        return;
+    });
+    return receipt;
+});
+const decodeCensusOutput = (observed) => decodeCensus(observed).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+    message: "The provider census failed strict schema validation.",
+    reason: "cleanup_unknown",
+})));
+const rejectPopulatedCensus = (phase, decoded) => phase === "cleanup_census" &&
+    (decoded.helpersCreated !== 0 || decoded.targetsCreated !== 0)
+    ? fail({
+        message: "Cleanup census retained a helper or target.",
+        reason: "cleanup_unknown",
+    })
+    : Effect.succeed(decoded);
+const updateCensus = Effect.fn("BuiltSessionAuthority.census")(function* (state, record, phase) {
+    const observed = yield* runWithinRemaining(record.budget, phase, fakeCensus(fakeFor(state), record.handle));
+    const decoded = yield* decodeCensusOutput(observed);
+    yield* mutateRecord(record, () => {
+        record.helpersCreated = decoded.helpersCreated;
+        record.targetsCreated = decoded.targetsCreated;
+        return;
+    });
+    return yield* rejectPopulatedCensus(phase, decoded);
+});
+const reserveBoundaryId = (state, boundaryId) => state.boundaryMutex.withPermit(Effect.sync(() => {
+    if (state.boundaryIds.size >=
+        builtSessionExecutionLimits.maxRetainedBoundaryIds ||
+        state.boundaryIds.has(boundaryId))
+        return false;
+    state.boundaryIds.add(boundaryId);
+    return true;
+}));
+const publishBoundary = (record, handle) => record.session.mutex.withPermit(Effect.suspend(() => {
+    record.boundaryId = handle.boundaryId;
+    record.handle = { ...handle };
+    record.handlePublished = true;
+    const illegal = transitionRecord(record, { type: "boundaryReady" });
+    return illegal === undefined ? Effect.void : Effect.fail(illegal);
+}));
+const decodePublishedHandle = (raw) => decodeBoundaryHandle(raw).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+    message: "The published handle failed strict schema validation.",
+    reason: "cleanup_unknown",
+})));
+const acquireBoundaryHandle = Effect.fn("BuiltSessionAuthority.acquireBoundaryHandle")(function* (state, record, controller) {
+    const acquireEntry = yield* monotonicMilliseconds();
+    const raw = yield* runWithinRemaining(record.budget, "helper_open", fakeAcquire(fakeFor(state), controller, acquireEntry));
+    const handle = yield* decodePublishedHandle(raw);
+    const now = yield* monotonicMilliseconds();
+    if (boundaryHandleMismatch({ acquireEntry, controller, handle, now, record })) {
+        return yield* fail({
+            message: "The published handle did not match the complete acquired authority identity.",
+            reason: "cleanup_unknown",
+        });
+    }
+    return handle;
+});
+const openBoundary = Effect.fn("BuiltSessionAuthority.open")(function* (state, record) {
+    const controller = projectBoundaryController(record, opaqueId("controller"));
+    yield* mutateRecord(record, () => {
+        record.controller = controller;
+        record.providerName = controller.providerName;
+        record.providerVersion = controller.providerVersion;
+        return transitionRecord(record, { type: "acquire" });
+    });
+    const handle = yield* acquireBoundaryHandle(state, record, controller);
+    const freshBoundary = yield* reserveBoundaryId(state, handle.boundaryId);
+    if (!freshBoundary) {
+        return yield* fail({
+            message: "The provider replayed an existing boundary identity.",
+            reason: "cleanup_unknown",
+        });
+    }
+    yield* publishBoundary(record, handle);
+    yield* updateCensus(state, record, "census");
+});
+const prepareRecord = Effect.fn("BuiltSessionAuthority.prepareRecord")(function* (state, record) {
+    yield* mutateRecord(record, () => transitionRecord(record, { type: "prepare" }));
+    const raw = yield* runWithinRemaining(record.budget, "prepare", fakePrepared(state, record)).pipe(Effect.ensuring(updateCensus(state, record, "census").pipe(Effect.ignore)));
+    yield* acceptReceipt({
+        decode: decodePreparedReceipt,
+        raw,
+        record,
+        state,
+    });
+});
+const registerRecord = (state, record) => mutateRecord(record, () => {
+    const prepared = transitionRecord(record, { type: "prepared" });
+    if (prepared !== undefined)
+        return prepared;
+    const registered = transitionRecord(record, { type: "register" });
+    if (registered !== undefined)
+        return registered;
+    record.registrationAttestation = signReceipt(state.authoritySecret, {
+        authorityId: record.authorityId,
+        invocationId: record.invocationId,
+        requestDigest: record.requestDigest,
+        sessionAuthorityId: record.session.sessionAuthorityId,
+        treeId: record.treeId,
+    });
+});
+const startRecord = Effect.fn("BuiltSessionAuthority.startRecord")(function* (state, record) {
+    yield* mutateRecord(record, () => {
+        record.startDispatched = true;
+        return transitionRecord(record, { type: "start" });
+    });
+    yield* signalEvent(fakeFor(state), "prepared");
+    const raw = yield* runWithinRemaining(record.budget, "start", fakeStarted(state, record));
+    yield* acceptReceipt({
+        decode: decodeStartedReceipt,
+        raw,
+        record,
+        state,
+    });
+    yield* mutateRecord(record, () => {
+        record.startAcknowledged = true;
+        return transitionRecord(record, { type: "started" });
+    });
+});
+const prepareRegisterStart = Effect.fn("BuiltSessionAuthority.prepareStart")(function* (state, record) {
+    yield* prepareRecord(state, record);
+    yield* registerRecord(state, record);
+    yield* startRecord(state, record);
+});
+const decodeCopiedExit = Effect.fn("BuiltSessionAuthority.decodeExit")(function* (record, raw) {
+    const decoded = yield* decodeBoundedExit(raw).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+        message: "The provider exit payload failed strict schema validation.",
+        reason: "cleanup_unknown",
+    })));
+    const copied = copyBoundedExit(record.maxOutputBytes, decoded);
+    if (copied === undefined) {
+        return yield* fail({
+            message: "The provider output exceeded its pre-materialized byte contract.",
+            reason: "cleanup_unknown",
+        });
+    }
+    return copied;
+});
+const persistBoundedExit = Effect.fn("BuiltSessionAuthority.persistExit")(function* (record, raw) {
+    const copied = yield* decodeCopiedExit(record, raw);
+    const stdout = decodeBoundedUtf8(copied.stdoutBytes, record.maxOutputBytes).text;
+    const stderr = decodeBoundedUtf8(copied.stderrBytes, record.maxOutputBytes).text;
+    yield* mutateRecord(record, () => {
+        record.directExitObserved = true;
+        record.stdout = stdout;
+        record.stderr = stderr;
+        return transitionRecord(record, { type: "exitObserved" });
+    });
+    return { code: copied.code, stderr, stdout };
+});
+const primaryInvocation = Effect.fn("BuiltSessionAuthority.primary")(function* (state, record, request) {
+    yield* openBoundary(state, record);
+    yield* prepareRegisterStart(state, record);
+    const rawExit = yield* runWithinRemaining(record.budget, "wait", fakeDirectExit(fakeFor(state), record.maxOutputBytes));
+    if (request.stdin !== undefined &&
+        fakeFor(state).script.stdinError === true) {
+        return yield* fail({
+            message: "The fake stdin stream failed.",
+            reason: "stdin_failed",
+        });
+    }
+    return yield* persistBoundedExit(record, rawExit);
+});
+const waitForAbort = (signal) => Effect.callback((resume) => {
+    const abort = () => {
+        resume(Effect.fail(new BuiltSessionAuthorityFailure({
+            message: "The built-session invocation was cancelled.",
+            reason: "cancelled",
+        })));
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    return Effect.sync(() => {
+        signal.removeEventListener("abort", abort);
+    });
+});
+const runPrimary = (state, record, request) => {
+    const primary = primaryInvocation(state, record, request);
+    if (request.abortSignal?.aborted === true) {
+        return primary.pipe(Effect.flatMap(() => fail({
+            message: "The built-session invocation was cancelled.",
+            reason: "cancelled",
+        })));
+    }
+    return request.abortSignal === undefined
+        ? primary
+        : Effect.raceFirst(primary, waitForAbort(request.abortSignal));
+};
+const installRelease = Effect.fn("BuiltSessionAuthority.installRelease")(function* (state, record) {
+    const completed = yield* record.session.mutex.withPermit(Effect.sync(() => record.releaseCompleted));
+    if (completed)
+        return { deferred: undefined, first: false };
+    return yield* state.registry.mutex.withPermit(Effect.gen(function* () {
+        if (record.releaseCompleted) {
+            return { deferred: undefined, first: false };
+        }
+        const existing = state.registry.latches.get(record.invocationId);
+        if (existing !== undefined) {
+            return { deferred: existing, first: false };
+        }
+        const deferred = yield* Deferred.make();
+        state.registry.latches.set(record.invocationId, deferred);
+        state.registry.scopes.add(record.invocationId);
+        return { deferred, first: true };
+    }));
+});
+const commitRelease = (input) => input.record.session.mutex.withPermit(Effect.sync(() => {
+    const { cleanupExit, record } = input;
+    if (!record.cleanupCounted ||
+        !Number.isSafeInteger(record.session.cleanupActive) ||
+        record.session.cleanupActive < 1) {
+        record.cleanupCause = new Error("cleanupActive invariant violated");
+    }
+    else {
+        record.cleanupCounted = false;
+        record.session.cleanupActive -= 1;
+    }
+    if (Exit.isFailure(cleanupExit)) {
+        record.cleanupCause = Cause.squash(cleanupExit.cause);
+    }
+    record.releaseCompleted = true;
+}));
+const forgetRelease = ({ record, state }) => state.registry.mutex.withPermit(Effect.sync(() => {
+    state.registry.latches.delete(record.invocationId);
+    state.registry.scopes.delete(record.invocationId);
+}));
+const completeRelease = Effect.fn("BuiltSessionAuthority.completeRelease")(function* (input) {
+    yield* commitRelease(input);
+    yield* Deferred.succeed(input.deferred, true);
+    yield* forgetRelease(input);
+});
+const terminatePublished = Effect.fn("BuiltSessionAuthority.terminatePublished")(function* (state, record) {
+    yield* mutateRecord(record, () => transitionRecord(record, { type: "terminate" }));
+    const rawTerminated = yield* runWithinRemaining(record.budget, "terminate", fakeTerminate(state, record));
+    yield* acceptReceipt({
+        decode: decodeTerminationReceipt,
+        raw: rawTerminated,
+        record,
+        state,
+    });
+});
+const provePublishedEmpty = Effect.fn("BuiltSessionAuthority.provePublishedEmpty")(function* (state, record) {
+    yield* mutateRecord(record, () => transitionRecord(record, { type: "waitEmpty" }));
+    const rawEmpty = yield* runWithinRemaining(record.budget, "empty_proof", fakeEmpty(state, record));
+    const empty = yield* acceptReceipt({
+        decode: decodeEmptyReceipt,
+        raw: rawEmpty,
+        record,
+        state,
+    });
+    if (empty.populated !== 0) {
+        return yield* fail({
+            message: "EMPTY requires populated === 0.",
+            reason: "cleanup_unknown",
+        });
+    }
+    yield* mutateRecord(record, () => transitionRecord(record, { type: "emptyProven" }));
+});
+const closePublished = Effect.fn("BuiltSessionAuthority.closePublished")(function* (state, record) {
+    const fake = fakeFor(state);
+    yield* fake.mutex.withPermit(Effect.sync(() => {
+        if (record.controller !== undefined) {
+            requireController(fake, record.controller.controllerId).helpersCreated = 0;
+        }
+        fake.closeCalls += 1;
+    }));
+    yield* updateCensus(state, record, "cleanup_census");
+});
+const cleanupPublished = Effect.fn("BuiltSessionAuthority.cleanupPublished")(function* (state, record) {
+    const stateName = yield* record.session.mutex.withPermit(Effect.sync(() => lifecycleOf(record)));
+    if (stateName === "empty_proven" || stateName === "cleanup_unknown_fenced")
+        return;
+    yield* terminatePublished(state, record);
+    yield* provePublishedEmpty(state, record);
+    yield* closePublished(state, record);
+});
+const reclaimUnpublished = Effect.fn("BuiltSessionAuthority.reclaim")(function* (state, record) {
+    if (record.controller !== undefined) {
+        yield* runWithinRemaining(record.budget, "reclaim", fakeReclaim(fakeFor(state), record.controller));
+    }
+    yield* mutateRecord(record, () => {
+        const current = lifecycleOf(record);
+        if (current === "requested" ||
+            current === "validated" ||
+            current === "boundary_acquiring") {
+            return transitionRecord(record, { type: "reject" });
+        }
+        return;
+    });
+});
+const fenceCleanup = (record, error) => mutateRecord(record, () => {
+    if (lifecycleOf(record) !== "cleanup_unknown_fenced") {
+        const illegal = transitionRecord(record, { type: "fence" });
+        if (illegal !== undefined)
+            record.cleanupCause = illegal;
+    }
+    record.cleanupCause = error;
+    return;
+}).pipe(Effect.andThen(Effect.fail(error)));
+const cleanupRecord = Effect.fn("BuiltSessionAuthority.cleanup")(function* (state, record) {
+    if (!record.handlePublished) {
+        yield* reclaimUnpublished(state, record);
+        return;
+    }
+    return yield* cleanupPublished(state, record).pipe(Effect.catch((error) => fenceCleanup(record, error)));
+});
+const beginCleanup = (record) => record.session.mutex.withPermit(Effect.sync(() => {
+    if (record.cleanupCounted) {
+        throw new Error("Invocation cleanup was counted twice.");
+    }
+    record.releaseStarted = true;
+    record.cleanupCounted = true;
+    record.session.cleanupActive += 1;
+}));
+const releaseRecord = Effect.fn("BuiltSessionAuthority.release")(function* (state, record) {
+    return yield* Effect.acquireUseRelease(state.cleanupAdmission.take(1), () => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+        const installed = yield* installRelease(state, record);
+        if (installed.deferred === undefined)
+            return;
+        if (!installed.first) {
+            yield* restore(Deferred.await(installed.deferred));
+            return;
+        }
+        yield* beginCleanup(record);
+        const cleanupExit = yield* restore(cleanupRecord(state, record)).pipe(Effect.exit);
+        yield* completeRelease({
+            cleanupExit,
+            deferred: installed.deferred,
+            record,
+            state,
+        });
+    })), () => state.cleanupAdmission.release(1));
+});
+const cleanupSnapshot = (record) => record.session.mutex.withPermit(Effect.sync(() => ({
+    cleanupCause: record.cleanupCause,
+    directExitObserved: record.directExitObserved,
+    lifecycle: lifecycleOf(record),
+    startDispatched: record.startDispatched,
+})));
+const resultAfterCleanup = Effect.fn("BuiltSessionAuthority.publish")(function* (record, primary) {
+    const snapshot = yield* cleanupSnapshot(record);
+    const cleanupFailure = cleanupUnknownFailure(snapshot);
+    if (cleanupFailure !== undefined)
+        return yield* Effect.fail(cleanupFailure);
+    if (Exit.isSuccess(primary))
+        return primary.value;
+    return yield* Effect.fail(primaryFailureAfterCleanup(snapshot, primary.cause));
+});
+const lookupSession = Effect.fn("BuiltSessionAuthority.lookupSession")(function* (state, sessionAuthorityId) {
+    const session = yield* state.storeMutex.withPermit(Effect.sync(() => state.sessions.get(sessionAuthorityId)));
+    if (session === undefined) {
+        return yield* fail({
+            message: "The session authority does not exist.",
+            reason: "spawn",
+        });
+    }
+    return session;
+});
+const lookupRecord = Effect.fn("BuiltSessionAuthority.lookupRecord")(function* (state, invocationId) {
+    const record = yield* state.storeMutex.withPermit(Effect.sync(() => state.records.get(invocationId)));
+    if (record === undefined) {
+        return yield* fail({
+            message: "The invocation does not exist.",
+            reason: "spawn",
+        });
+    }
+    return record;
+});
+const invocationDefaults = {
+    cleanupCounted: false,
+    directExitObserved: false,
+    handlePublished: false,
+    helpersCreated: 0,
+    lastAcceptedAt: 0,
+    lastAcceptedOrder: 0,
+    releaseCompleted: false,
+    releaseStarted: false,
+    startAcknowledged: false,
+    startDispatched: false,
+    stderr: "",
+    stdout: "",
+    targetsCreated: 0,
+};
+const makeInvocationRecord = ({ budget, request, session, }) => {
+    const invocationId = opaqueId("invocation");
+    return {
+        ...invocationDefaults,
+        authorityId: invocationId,
+        budget,
+        invocationId,
+        maxOutputBytes: request.maxOutputBytes,
+        ownerKind: request.ownerKind,
+        program: request.program,
+        requestDigest: digestInvocationRequest(request),
+        rootPath: request.rootPath,
+        session,
+        snapshot: initialSnapshot(),
+        treeId: opaqueId("tree"),
+    };
+};
+const insertInvocationRecord = (input) => input.state.storeMutex.withPermit(input.session.mutex.withPermit(Effect.suspend(() => {
+    if (input.state.records.size >=
+        builtSessionExecutionLimits.maxRetainedInvocations) {
+        return fail({
+            message: "The retained invocation registry is at capacity.",
+            reason: "spawn",
+        });
+    }
+    const illegal = transitionRecord(input.record, { type: "validate" });
+    if (illegal !== undefined)
+        return Effect.fail(illegal);
+    input.state.records.set(input.record.invocationId, input.record);
+    input.session.invocationIds.push(input.record.invocationId);
+    return Effect.void;
+})));
+const persistRecord = Effect.fn("BuiltSessionAuthority.persistRecord")(function* (input) {
+    const record = makeInvocationRecord(input);
+    yield* insertInvocationRecord({ ...input, record });
+    return record;
+});
+const adjustAdmission = (session, change) => session.mutex.withPermit(Effect.sync(() => {
+    session.admissionActive += change;
+}));
+const runAdmitted = Effect.fn("BuiltSessionAuthority.runAdmitted")(function* (input) {
+    const { record, request, state } = input;
+    const { session } = record;
+    yield* adjustAdmission(session, 1);
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+        const primary = yield* restore(runPrimary(state, record, request)).pipe(Effect.ensuring(adjustAdmission(session, -1)), Effect.exit);
+        yield* releaseRecord(state, record);
+        return yield* resultAfterCleanup(record, primary);
+    }));
+});
+const qualifiedSession = Effect.fn("BuiltSessionAuthority.qualifiedSession")(function* (state, request) {
+    if (request.sessionAuthorityId === undefined) {
+        return yield* fail({
+            message: "Qualified execution requires a session authority.",
+            reason: "spawn",
+        });
+    }
+    const session = yield* lookupSession(state, request.sessionAuthorityId);
+    const compatible = yield* session.mutex.withPermit(Effect.sync(() => !session.emptyAccepted &&
+        (request.rootPath === undefined ||
+            request.rootPath === session.rootPath)));
+    if (!compatible) {
+        return yield* fail({
+            message: "The invocation does not match the session root.",
+            reason: "spawn",
+        });
+    }
+    return session;
+});
+const runQualified = Effect.fn("BuiltSessionAuthority.runQualified")(function* (state, request) {
+    const invalid = validateBuiltSessionRequestLimits(request);
+    if (invalid !== undefined)
+        return yield* fail(invalid);
+    const budget = yield* captureExecutionBudget({
+        cleanupReserveMilliseconds: request.cleanupReserveMilliseconds,
+        maximumTotalMilliseconds: request.maximumTotalMilliseconds,
+    });
+    const session = yield* qualifiedSession(state, request);
+    const record = yield* Effect.acquireUseRelease(runWithinRemaining(budget, "admission", state.admission.take(1).pipe(Effect.asVoid)), () => persistRecord({ budget, request, session, state }), () => state.admission.release(1));
+    return yield* runAdmitted({ record, request, state });
+});
+const requireSessionEmptyPreconditions = (state, session) => {
+    const complete = session.rootPath !== undefined &&
+        session.ownedRoot !== undefined &&
+        session.admissionActive === 0 &&
+        session.cleanupActive === 0 &&
+        sessionRecordsClean(state, session);
+    return complete
+        ? Effect.void
+        : fail({
+            message: "Session EMPTY preconditions are not satisfied.",
+            reason: "spawn",
+        });
+};
+const runSessionEmptyProof = Effect.fn("BuiltSessionAuthority.sessionEmptyProof")(function* (fake) {
+    yield* fake.mutex.withPermit(Effect.sync(() => {
+        fake.sessionEmptyProofCalls += 1;
+    }));
+    const outcome = fake.script.sessionEmptyProof ?? "empty";
+    yield* failOutcome(outcome, "session empty proof");
+    if (outcome === "populated" || fake.script.populatedSessionEmpty === true) {
+        return yield* fail({
+            message: "The session subtree is populated.",
+            reason: "cleanup_unknown",
+        });
+    }
+});
+const signedSessionEmpty = (input) => {
+    const { now: _expectedAt, ...identity } = input.expected;
+    return attestReceipt(helperSecretFor(input.state), {
+        ...identity,
+        order: input.session.lastAcceptedOrder + 1,
+        phase: "session_empty",
+        populated: 0,
+        provenAt: receiptOccurrence(fakeFor(input.state).script, input.now, input.budget.absoluteDeadline),
+    });
+};
+const acceptProjectedSessionEmpty = (input) => runWithinRemaining(input.budget, "session_empty", acceptLifecycleReceipt({
+    decode: decodeSessionEmptyReceipt,
+    expected: input.expected,
+    lastAcceptedAt: input.session.lastAcceptedAt,
+    lastAcceptedOrder: input.session.lastAcceptedOrder,
+    receipt: input.raw,
+    verifier: receiptVerifierFor(helperSecretFor(input.state)),
+}));
+const acceptSessionEmpty = Effect.fn("BuiltSessionAuthority.acceptSessionEmpty")(function* (state, session, budget) {
+    const now = yield* monotonicMilliseconds();
+    const rootIdentity = session.ownedRoot?.receipt.rootIdentity;
+    if (rootIdentity === undefined) {
+        return yield* fail({
+            message: "Session EMPTY lost its owned root.",
+            reason: "cleanup_unknown",
+        });
+    }
+    const expected = projectSessionEmptyExpected({
+        absoluteDeadline: budget.absoluteDeadline,
+        now,
+        rootIdentity,
+        session,
+    });
+    const raw = signedSessionEmpty({ budget, expected, now, session, state });
+    return yield* acceptProjectedSessionEmpty({
+        budget,
+        expected,
+        raw,
+        session,
+        state,
+    });
+});
+const commitSessionEmpty = (session, accepted) => {
+    const projected = lifecycleOf(session) === "empty_proven"
+        ? session.snapshot
+        : projectSessionEmptyLifecycle(session.snapshot);
+    if (projected instanceof BuiltSessionAuthorityFailure) {
+        return Effect.fail(projected);
+    }
+    session.snapshot = projected;
+    session.emptyAccepted = true;
+    session.emptyReceipt = accepted;
+    session.lastAcceptedAt = accepted.provenAt;
+    session.lastAcceptedOrder = accepted.order;
+    return Effect.succeed(freezeSnapshot(accepted));
+};
+const proveSessionEmptyLocked = Effect.fn("BuiltSessionAuthority.proveSessionEmptyLocked")(function* (state, session, budget) {
+    yield* requireSessionEmptyPreconditions(state, session);
+    yield* runSessionEmptyProof(fakeFor(state));
+    const accepted = yield* acceptSessionEmpty(state, session, budget);
+    return yield* commitSessionEmpty(session, accepted);
+});
+const proveSessionEmpty = Effect.fn("BuiltSessionAuthority.proveSessionEmpty")(function* (state, input) {
+    if (state.fake === undefined || state.helperSecret === undefined) {
+        return yield* fail({
+            message: "Session EMPTY has no qualified provider.",
+            reason: "cleanup_unknown",
+        });
+    }
+    const budget = yield* captureExecutionBudget(input);
+    const session = yield* lookupSession(state, input.sessionAuthorityId);
+    return yield* session.mutex.withPermit(proveSessionEmptyLocked(state, session, budget));
+});
+const rootEligible = (session) => {
+    const root = session.rootPath;
+    const owned = session.ownedRoot;
+    if (root === undefined || owned === undefined)
+        return false;
+    if (!session.emptyAccepted || session.emptyReceipt?.populated !== 0)
+        return false;
+    if (session.admissionActive !== 0 || session.cleanupActive !== 0)
+        return false;
+    if (lifecycleOf(session) !== "empty_proven")
+        return false;
+    if (!rootIdentityMatches({ expected: owned.identity, rootPath: root }))
+        return false;
+    if (owned.receipt.rootIdentity !== digestRootIdentity(owned.identity))
+        return false;
+    return true;
+};
+const commitOwnedRoot = (context) => {
+    const { input, rootPath, session, state } = context;
+    if (session.ownedRoot !== undefined ||
+        input.createdAt < session.lastAcceptedAt ||
+        input.createdAt > input.deadline) {
+        return fail({
+            message: "Owned-root occurrence ordering is invalid.",
+            reason: "spawn",
+        });
+    }
+    const identity = captureRootIdentity(rootPath, true);
+    const body = projectRootReceiptBody(session, input, identity);
+    const receipt = attestReceipt(state.authoritySecret, body);
+    session.ownedRoot = { identity, receipt };
+    session.rootPath = rootPath;
+    session.lastAcceptedAt = input.createdAt;
+    session.lastAcceptedOrder = receipt.order;
+    return Effect.succeed(projectOwnedRootSnapshot({ identity, receipt, rootPath }));
+};
+const createOwnedRoot = Effect.fn("BuiltSessionAuthority.createOwnedRoot")(function* (state, input) {
+    const session = yield* lookupSession(state, input.sessionAuthorityId);
+    return yield* session.mutex.withPermit(Effect.acquireUseRelease(Effect.tryPromise({
+        catch: (cause) => new BuiltSessionAuthorityFailure({
+            cause,
+            message: "Owned-root creation failed.",
+            reason: "spawn",
+        }),
+        try: () => mkdtemp(join(input.parentDirectory, ".maia-session-")),
+    }), (rootPath) => commitOwnedRoot({ input, rootPath, session, state }), (rootPath, exit) => Exit.isSuccess(exit)
+        ? Effect.void
+        : Effect.promise(() => rm(rootPath, { force: true, recursive: true }))));
+});
+const createOwnedRootMethod = (state, raw) => decodeOwnedRootInput(raw).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+    message: "Owned-root input is invalid.",
+    reason: "spawn",
+})), Effect.flatMap((input) => createOwnedRoot(state, input)));
+const makeSession = Effect.fn("BuiltSessionAuthority.makeSession")(function* (rootPath) {
+    return {
+        admissionActive: 0,
+        cleanupActive: 0,
+        deleting: false,
+        emptyAccepted: false,
+        invocationIds: [],
+        lastAcceptedAt: 0,
+        lastAcceptedOrder: 0,
+        mutex: yield* Semaphore.make(1),
+        rootPath,
+        sessionAuthorityId: opaqueId("session"),
+        snapshot: initialSnapshot(),
+        treeId: opaqueId("session-tree"),
+    };
+});
+const persistSession = (state, session) => state.storeMutex.withPermit(Effect.suspend(() => {
+    if (state.sessions.size >= builtSessionExecutionLimits.maxRetainedSessions) {
+        return fail({
+            message: "The retained session registry is at capacity.",
+            reason: "spawn",
+        });
+    }
+    state.sessions.set(session.sessionAuthorityId, session);
+    return Effect.succeed(freezeSnapshot({ sessionAuthorityId: session.sessionAuthorityId }));
+}));
+const createSessionMethod = (state, raw) => decodeCreateSessionInput(raw).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+    message: "Session input is invalid.",
+    reason: "spawn",
+})), Effect.flatMap((input) => makeSession(input.rootPath)), Effect.flatMap((session) => persistSession(state, session)));
+const inspectInvocationMethod = (state, raw) => decodeIdentityInput(raw).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+    message: "Invocation identity is invalid.",
+    reason: "spawn",
+})), Effect.flatMap((id) => lookupRecord(state, id)), Effect.flatMap((record) => record.session.mutex.withPermit(Effect.sync(() => projectInvocationSnapshot(record)))));
+const inspectRegistryMethod = (state) => state.registry.mutex.withPermit(Effect.sync(() => freezeSnapshot({
+    latches: state.registry.latches.size,
+    scopes: state.registry.scopes.size,
+})));
+const sessionRecordsClean = (state, session) => session.invocationIds.every((id) => {
+    const record = state.records.get(id);
+    return (record !== undefined &&
+        record.releaseCompleted &&
+        record.helpersCreated === 0 &&
+        record.targetsCreated === 0 &&
+        lifecycleOf(record) === "empty_proven");
+});
+const inspectRootEligibilityMethod = Effect.fn("BuiltSessionAuthority.inspectRootEligibility")(function* (state, raw) {
+    const rootPath = yield* decodeRootPathInput(raw).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+        message: "Root path is invalid.",
+        reason: "spawn",
+    })));
+    const session = yield* state.storeMutex.withPermit(Effect.sync(() => [...state.sessions.values()].find((item) => item.rootPath === rootPath)));
+    if (session === undefined)
+        return false;
+    return yield* session.mutex.withPermit(Effect.sync(() => rootEligible(session) && sessionRecordsClean(state, session)));
+});
+const inspectSessionMethod = (state, raw) => decodeIdentityInput(raw).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+    message: "Session identity is invalid.",
+    reason: "spawn",
+})), Effect.flatMap((id) => lookupSession(state, id)), Effect.flatMap((session) => session.mutex.withPermit(Effect.sync(() => projectSessionSnapshot(session)))));
+const inspectSessionInvocationsMethod = (state, raw) => decodeIdentityInput(raw).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+    message: "Session identity is invalid.",
+    reason: "spawn",
+})), Effect.flatMap((id) => lookupSession(state, id)), Effect.flatMap((session) => session.mutex.withPermit(Effect.sync(() => freezeSnapshot([...session.invocationIds].sort())))));
+const proveSessionEmptyMethod = (state, raw) => decodeSessionEmptyInput(raw).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+    message: "Session EMPTY input is invalid.",
+    reason: "spawn",
+})), Effect.flatMap((input) => proveSessionEmpty(state, input)));
+const releaseMethod = (state, raw) => decodeIdentityInput(raw).pipe(Effect.flatMap((id) => state.storeMutex.withPermit(Effect.sync(() => state.records.get(id)))), Effect.flatMap((record) => record === undefined ? Effect.void : releaseRecord(state, record)), Effect.catchCause(() => Effect.void));
+const removeOwnedRootMethod = (raw) => decodeRemoveRootInput(raw).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+    message: "Owned-root deletion input is invalid.",
+    reason: "spawn",
+})), Effect.flatMap((input) => fail({
+    cleanupCause: new Error(`Owned root ${input.rootPath} was retained.`),
+    message: "Owned-root deletion is platform_unsupported: this slice has no descriptor-bound recursive deletion authority.",
+    reason: "platform_unsupported",
+})));
+const runInvocationMethod = (state, raw) => {
+    return gateInvocationRequest(raw).pipe(Effect.mapError(() => new BuiltSessionAuthorityFailure({
+        message: "The invocation request failed structural validation.",
+        reason: "spawn",
+    })), Effect.flatMap((plain) => state.fake === undefined
+        ? fail({
+            message: "A qualified built-session boundary provider is unavailable on this platform.",
+            reason: "platform_unsupported",
+        })
+        : decodeInvocationRequest(plain).pipe(Effect.flatMap((request) => request.allowTestProvider === true
+            ? runQualified(state, request)
+            : fail({
+                message: "The closed official fake requires explicit test-provider authority.",
+                reason: "platform_unsupported",
+            })))));
+};
+const createService = (state) => ({
+    createOwnedRoot: (raw) => createOwnedRootMethod(state, raw),
+    createSession: (raw) => createSessionMethod(state, raw),
+    inspectInvocation: (id) => inspectInvocationMethod(state, id),
+    inspectReleaseRegistry: () => inspectRegistryMethod(state),
+    inspectRootEligibility: (rootPath) => inspectRootEligibilityMethod(state, rootPath),
+    inspectSession: (id) => inspectSessionMethod(state, id),
+    inspectSessionInvocations: (id) => inspectSessionInvocationsMethod(state, id),
+    proveSessionEmpty: (raw) => proveSessionEmptyMethod(state, raw),
+    release: (id) => releaseMethod(state, id),
+    removeOwnedRoot: removeOwnedRootMethod,
+    runInvocation: (raw) => runInvocationMethod(state, raw),
+});
+const makeState = Effect.fn("BuiltSessionAuthority.makeState")(function* (admissionPermits, fake) {
+    return {
+        admission: yield* Semaphore.make(admissionPermits),
+        authoritySecret: randomBytes(32),
+        boundaryIds: new Set(),
+        boundaryMutex: yield* Semaphore.make(1),
+        cleanupAdmission: yield* Semaphore.make(admissionPermits),
+        fake,
+        helperSecret: fake === undefined ? undefined : randomBytes(32),
+        records: new Map(),
+        registry: {
+            latches: new Map(),
+            mutex: yield* Semaphore.make(1),
+            scopes: new Set(),
+        },
+        sessions: new Map(),
+        storeMutex: yield* Semaphore.make(1),
+    };
+});
+const platformState = Effect.runSync(makeState(builtSessionExecutionLimits.admissionPermits));
+export const platformBuiltSessionAuthorityLayer = Layer.succeed(BuiltSessionExecutionAuthority, createService(platformState));
+export const openBuiltSessionTestHarness = Effect.fn("BuiltSessionExecutionAuthority.openHarness")(function* (script = {}, options = {}) {
+    // Arbitrary uncooperative providers require the later process/IPC boundary.
+    // This composable fake stays closed here and remains interruptible by construction.
+    const decodedScript = yield* decodeOfficialFakeScript(script);
+    const decodedOptions = yield* decodeHarnessOptions(options);
+    const fake = yield* makeFake(decodedScript);
+    const state = yield* makeState(decodedOptions.admissionPermits ??
+        builtSessionExecutionLimits.admissionPermits, fake);
+    return Object.freeze({
+        control: Object.freeze(methodsOnlyControl(fake)),
+        layer: Layer.succeed(BuiltSessionExecutionAuthority, createService(state)),
+    });
+});
+//# sourceMappingURL=built-session-execution-authority.js.map