@agentcomms/events-daemon 0.24.0 → 0.26.0

package/dist/cli.mjs

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
-import { $ as sourcesList, $t as assertControlSupported, A as normaliseWhatsAppSourceOptions, At as decideHeld, B as addTarget, Bt as CONTROL_PROTOCOL_VERSIONS, C as canonicalSseSubscriber, Ct as enableAll, D as normaliseResendSourceOptions, Dt as ACTIVATION_FAILURE, E as normaliseGmailSourceOptions, Et as doctor, F as canonicalJudgeBudget, Ft as catalogueList, G as addSubscriber, Gt as isControlRequest, H as targetsList, Ht as controlFailure, I as canonicalJudgeKindEnablement, It as catalogueShow, J as updateSubscriber, Jt as newInstanceRecord, K as removeSubscriber, Kt as negotiateVersion, L as judgeKindDefinition, Lt as approvalView, M as JUDGE_BUDGET_ID, Mt as dropDelivery, N as JUDGE_KIND_DEFINITIONS, Nt as heldList, O as normaliseSlackSourceOptions, Ot as isActivationFailureCode, P as canonicalJudge, Pt as retryDelivery, Q as sourceShow$1, Qt as writeInstance, R as createEventsMcpServer, Rt as EventControlClient, S as normaliseActivationDocument, St as updateJudge, T as classifySourceOptionChange, Tt as assertDoctorReportV2, U as updateTarget, Ut as encodeControlFrame, V as removeTarget$1, Vt as ControlFrameReader, W as targetTest, Wt as isControlHello, X as status, Xt as readInstance, Y as stop, Yt as processIsLive, Z as loadSqlite, Zt as removeInstance, _ as activationDocumentDigest, _t as judgeTest, an as ensureEventSocketDirectory, at as rulesList, b as canonicalTarget, bt as removeJudgeModel, cn as installErrorSink, ct as ruleTestRetained, d as B3_SECRET_TERMINAL_ORIGIN, dt as addJudge, en as assertSocketPathFits, et as createRule$1, f as isB3ControlOperation, ft as budgetShow, g as isOwnerControlWireOperation, gt as judgeModelStatus, h as OWNER_CONTROL_WIRES, ht as judgeKindsList, in as ensureEventPaths, it as ruleShow$1, j as APPROVED_TYPESAFE_MODELS, jt as deliveriesList, k as normaliseSourceOptions, kt as disableAll, lt as pause, m as renderB3ApprovalPreviewV1, mt as enableJudgeKind, nn as verifyControlSocket, nt as enableRule, on as ensureOwnerOnlyFile, ot as updateRule, p as isB3SecretOperation, pt as disableJudgeKind, q as subscribersList, qt as mayRecoverStaleInstance, rn as verifyPrivateSocketDirectory, rt as removeRule, sn as eventPaths, st as ruleTest, tn as controlEndpoint, tt as disableRule$1, ut as resume, v as canonicalFullRuleDocument, vt as judgesList, w as sseDeliveryTarget, wt as assertDoctorReportV1, x as disclosureBindingFor, xt as updateBudget, y as canonicalSubscriber, yt as removeJudge, z as VERSION, zt as probeControl } from "./b3-contract-C1q5aekF.mjs";
-import { a as EventDomainError, d as isJudgeKind, f as validateLocalEndpoint, g as parseIpLiteral, h as assertApprovedAddressSet, i as webhookDeliveryTarget, l as JUDGE_KIND_TYPESAFE, m as assertAddressAllowed, n as canonicalWebhookTarget, o as JUDGE_KINDS, p as AddressPolicyError, r as secretWebhookUrlDescriptor, s as JUDGE_KIND_LAYA, t as canonicalSecretWebhookUrl, u as assertJudgeKindEnabled } from "./webhook-target-DyDTwWhV.mjs";
-import { a as WriterQuiescer, c as openEventSecretStore, o as withEventWriterLease, r as RecordStorageError, s as migrateEventSecrets, t as EventRecordCipher } from "./records-DsUxYBwb.mjs";
+import { $ as addSubscriber, $t as isControlHello, A as normaliseSourceOptions, At as updateJudge, B as canonicalJudgeKindEnablement, Bt as deliveriesList, C as normaliseActivationDocument, Ct as judgeKindsList, D as normaliseGmailSourceOptions, Dt as removeJudge, E as classifySourceOptionChange, Et as judgesList, F as assertCreatableLayaJudge, Ft as doctor, G as registerLayaEnablementInputs, Gt as catalogueShow, H as layaEnablementInputsFor, Ht as heldList, I as assertLayaJudgeKindAvailable, It as ACTIVATION_FAILURE, J as addTarget, Jt as probeControl, K as createEventsMcpServer, Kt as approvalView, L as assertLayaRuleJudgeOffered, Lt as isActivationFailureCode, M as APPROVED_TYPESAFE_MODELS, Mt as assertDoctorReportV1, N as JUDGE_BUDGET_ID, Nt as assertDoctorReportV2, O as normaliseResendSourceOptions, Ot as removeJudgeModel, P as JUDGE_KIND_DEFINITIONS, Pt as assertDoctorReportV3, Q as targetTest, Qt as encodeControlFrame, R as canonicalJudge, Rt as disableAll, S as disclosureBindingFor, St as enableJudgeKind, T as sseDeliveryTarget, Tt as judgeTest, U as layaJudgeKindDefinitionFor, Ut as retryDelivery, V as judgeKindDefinition, Vt as dropDelivery, W as layaJudgeTermsFor, Wt as catalogueList, X as targetsList, Xt as ControlFrameReader, Y as removeTarget$1, Yt as CONTROL_PROTOCOL_VERSIONS, Z as updateTarget, Zt as controlFailure, _ as isOwnerControlWireOperation, _t as pause, an as readInstance, at as loadSqlite, b as canonicalSubscriber, bt as budgetShow, cn as assertControlSupported, ct as createRule$1, d as B3_SECRET_TERMINAL_ORIGIN, dn as verifyControlSocket, dt as removeRule, en as isControlRequest, et as removeSubscriber, f as isB3ControlOperation, fn as verifyPrivateSocketDirectory, ft as ruleShow$1, g as OWNER_CONTROL_WIRES, gn as eventPaths, gt as ruleTestRetained, h as layaJudgePreviewFor, hn as ensureOwnerOnlyFile, ht as ruleTest, in as processIsLive, it as status, j as normaliseWhatsAppSourceOptions, jt as enableAll, k as normaliseSlackSourceOptions, kt as updateBudget, ln as assertSocketPathFits, lt as disableRule$1, m as renderB3ApprovalPreviewV1, mn as ensureEventSocketDirectory, mt as updateRule, nn as mayRecoverStaleInstance, nt as updateSubscriber, on as removeInstance, ot as sourceShow$1, p as isB3SecretOperation, pn as ensureEventPaths, pt as rulesList, q as VERSION, qt as EventControlClient, rn as newInstanceRecord, rt as stop, sn as writeInstance, st as sourcesList, tn as negotiateVersion, tt as subscribersList, un as controlEndpoint, ut as enableRule, v as activationDocumentDigest, vt as resume, w as canonicalSseSubscriber, wt as judgeModelStatus, x as canonicalTarget, xt as disableJudgeKind, y as canonicalFullRuleDocument, yt as addJudge, z as canonicalJudgeBudget, zt as decideHeld } from "./b3-contract-CG8Z2OtX.mjs";
+import { a as createLayaWorkerBoundary, d as encodeWorkerFrame, h as isLayaTemplateId, l as WorkerFrameParser, u as createWorkerRequestId, v as installErrorSink } from "./worker-boundary-probe-CFN6EsyK.mjs";
+import { _ as JUDGE_KIND_TYPESAFE, c as validateLocalEndpoint, d as assertApprovedAddressSet, f as parseIpLiteral, h as JUDGE_KIND_LAYA, i as webhookDeliveryTarget, l as AddressPolicyError, m as JUDGE_KINDS, n as canonicalWebhookTarget, p as EventDomainError, r as secretWebhookUrlDescriptor, t as canonicalSecretWebhookUrl, u as assertAddressAllowed, v as assertJudgeKindEnabled, y as isJudgeKind } from "./webhook-target-EzLIFpIY.mjs";
+import { c as migrateEventSecrets, i as RecordStorageError, l as openEventSecretStore, n as LayaModelRepository, o as WriterQuiescer, s as withEventWriterLease, t as EventRecordCipher } from "./records-D15LoVeb.mjs";
 import process$1 from "node:process";
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
-import { chmod, lstat, open, readFile, rm, writeFile } from "node:fs/promises";
+import { appendFile, chmod, lstat, mkdir, mkdtemp, open, readFile, readdir, rename, rm, statfs, writeFile } from "node:fs/promises";
 import net, { createServer } from "node:net";
 import { CommsError, TaintCollector, agentMarker, canPrompt, canonicalJson, escapeForDisplay, hashChallenge, isCommsError, isDangerous, neutralise, newBoundary, openCore, renderFencedBody, resolvePaths, sanitizeHtmlToText, sanitizePlainText, sha256Hex, stripInvisible, wrapUntrusted } from "@agentcomms/core";
-import fs, { constants } from "node:fs";
-import path from "node:path";
+import fs, { constants, createReadStream } from "node:fs";
+import path, { basename, dirname, join, resolve, sep } from "node:path";
 import { CATALOGUE, TEST_CLOUD_EVENT, TEST_CLOUD_EVENT_BYTES, applyRepresentation, buildCloudEvent, canonicalJson as canonicalJson$1, catalogueEntry, classifyMapped, cloudEventBytes, compileMapping, conditionPointers, evaluateCondition, evaluateMapping, eventId, eventIdPreimage, expandPattern, getPointer, gmailMessageLabelledV1, gmailMessageReceivedV1, gmailMessageSentV1, parsePointer, validateEvent, whatsappMessageKey } from "@agentcomms/events";
+import childProcess from "node:child_process";
 import { createInterface } from "node:readline/promises";
 import { EventEmitter } from "node:events";
-import childProcess from "node:child_process";
 import { stripVTControlCharacters } from "node:util";
 import { createGmailEventSource, normaliseGmailEventMetadata } from "@agentcomms/gmail";
 import { createResendEventReaderForPaths } from "@agentcomms/resend";
@@ -20,6 +21,8 @@ import { openSlackEventSourceForPaths } from "@agentcomms/slack";
 import { chatKindOf, openWhatsAppEventOperations, visibilityUnitKey } from "@agentcomms/whatsapp";
 import tls from "node:tls";
 import dns from "node:dns";
+import { Readable } from "node:stream";
+import { createGunzip } from "node:zlib";
 //#region ../../node_modules/.pnpm/commander@15.0.0/node_modules/commander/lib/error.js
 /**
 * CommanderError class
@@ -3246,13 +3249,24 @@ function documentRecord(value) {
 	return JSON.parse(canonicalJson(value));
 }
 /** SQLite repository for D2's immutable, initially inert version rows. */
-var ImmutableVersions = class {
+var ImmutableVersions = class ImmutableVersions {
 	#database;
-	constructor(database) {
+	#layaInputs;
+	#judgeContract = "b3-control-v1";
+	constructor(database, options = layaEnablementInputsFor(database)) {
 		this.#database = database;
+		this.#layaInputs = options;
+	}
+	/** The repository over this database's own Laya inputs, creating judges and rules as `contract` defines them. */
+	static forJudgeContract(database, contract) {
+		const versions = new ImmutableVersions(database);
+		versions.#judgeContract = contract;
+		return versions;
 	}
 	createRule(input) {
 		const document = canonicalFullRuleDocument(input);
+		if (this.#judgeContract === "b3-control-v3") assertCreatableLayaJudge(document.agentic?.judge, this.#layaInputs);
+		else this.#assertLayaRuleOffered(document);
 		this.assertEmbeddedVersions(document);
 		return this.insert("rule_versions", "rule", document.ruleId, document.version, document);
 	}
@@ -3272,9 +3286,24 @@ var ImmutableVersions = class {
 		const document = canonicalSubscriber(input);
 		return this.insert("subscriber_versions", "subscriber", document.subscriberId, document.version, document);
 	}
-	/** Validates a dormant judge version; this deliberately does not require an enabled kind. */
+	/**
+	* Validates a dormant judge version; this deliberately does not require an enabled kind. Under B3 v1 and v2 a Laya
+	* judge, or a rule naming one, is refused with the kind's own closed reason wherever this release or platform does
+	* not offer Laya — with the placeholder lock, everywhere. Under B3 v3 it is kept as configuration, naming this
+	* release's reviewed manifest and a template the worker runs (JudgeDocumentContract).
+	*/
 	prepareJudge(input) {
-		return canonicalJudge(input);
+		const document = canonicalJudge(input);
+		if (this.#judgeContract === "b3-control-v3") {
+			assertCreatableLayaJudge(document, this.#layaInputs);
+			return document;
+		}
+		if (document.kind === JUDGE_KINDS[1]) assertLayaJudgeKindAvailable(this.#layaInputs);
+		return document;
+	}
+	/** B3 v1 and v2: a rule naming a Laya judge exists only where this release and platform offer Laya (E2 Task 8). */
+	#assertLayaRuleOffered(document) {
+		if (document.agentic?.judge.kind === JUDGE_KINDS[1]) assertLayaJudgeKindAvailable(this.#layaInputs);
 	}
 	createJudge(input) {
 		const document = this.prepareJudge(input);
@@ -3309,16 +3338,15 @@ var ImmutableVersions = class {
 		return this.insert("judge_budget_versions", "judge-budget", document.budgetId, document.version, document);
 	}
 	prepareJudgeKindDocument(input) {
-		return canonicalJudgeKindEnablement(input);
+		return canonicalJudgeKindEnablement(input, this.#layaInputs);
 	}
 	/** The sole digest-verifying loader for an immutable kind enablement document. */
 	loadJudgeKind(kind, version) {
-		if (isJudgeKind(kind) && judgeKindDefinition(kind).availability === "unavailable") throw new EventDomainError("E2_REQUIRED", "laya is unavailable until E2");
 		const row = this.#database.prepare("SELECT document, digest FROM judge_kind_versions WHERE kind = ? AND version = ? AND revoked_at IS NULL").get(kind, version);
 		if (row === void 0) throw new EventDomainError("VERSION_DOCUMENT_INVALID", "the requested judge kind version does not exist");
 		let enablement;
 		try {
-			enablement = canonicalJudgeKindEnablement(JSON.parse(row.document));
+			enablement = canonicalJudgeKindEnablement(JSON.parse(row.document), this.#layaInputs);
 		} catch {
 			throw new EventDomainError("VERSION_DOCUMENT_INVALID", "the stored judge kind document is invalid");
 		}
@@ -3327,6 +3355,10 @@ var ImmutableVersions = class {
 	}
 	/** Loads one exact immutable kind enablement document, never inferring a default enabled state. */
 	prepareJudgeKind(kind, version) {
+		if (isJudgeKind(kind) && judgeKindDefinition(kind).availability === "unavailable") {
+			if (kind !== JUDGE_KINDS[1] || judgeKindDefinition(kind).implementation === void 0) throw new EventDomainError("E2_REQUIRED", "the judge kind requires its next phase implementation");
+			assertLayaJudgeKindAvailable(this.#layaInputs);
+		}
 		return {
 			documentVersion: 1,
 			kind: "judge-kind",
@@ -3350,7 +3382,10 @@ var ImmutableVersions = class {
 		if (row === void 0) throw new EventDomainError("VERSION_DOCUMENT_INVALID", "the requested rule version does not exist");
 		const rule = canonicalFullRuleDocument(JSON.parse(row.document));
 		this.assertEmbeddedVersions(rule);
-		if (rule.agentic !== void 0) assertJudgeKindEnabled(rule.agentic.judge.kind, this.activeVersion("judge-kind", rule.agentic.judge.kind) !== null);
+		if (rule.agentic !== void 0) {
+			if (rule.agentic.judge.kind === JUDGE_KINDS[1]) assertLayaRuleJudgeOffered(this.#layaInputs);
+			assertJudgeKindEnabled(rule.agentic.judge.kind, this.activeVersion("judge-kind", rule.agentic.judge.kind) !== null);
+		}
 		return normaliseActivationDocument({
 			documentVersion: 1,
 			kind: "rule",
@@ -7240,6 +7275,7 @@ function ruleAuthority(database, scope, judge) {
 function providerLimit(document, provider) {
 	const found = document.providers.find((entry) => entry.provider === provider);
 	if (found === void 0) refusal$2("PROVIDER_BUDGET_UNCONFIGURED", "the judge provider has no approved budget ceiling");
+	if (provider === "laya" && found.concurrency > 1) refusal$2("PROVIDER_BUDGET_UNCONFIGURED", "the Laya provider budget must remain one-at-a-time");
 	return found;
 }
 function usage(database, where, args, now) {
@@ -7536,7 +7572,7 @@ var JudgeReservationIoGate = class {
 		return this.#firstGateError;
 	}
 	finalGate = (phase, assertBeforeTransition) => {
-		const firstPhysicalPhase = this.#judgeKind === "typesafe" ? "dns" : "tcp";
+		const firstPhysicalPhase = this.#judgeKind === "typesafe" ? "dns" : this.#judgeKind === "laya" ? "write" : "tcp";
 		if (!this.#entered) {
 			if (phase !== firstPhysicalPhase) {
 				assertBeforeTransition?.();
@@ -8660,10 +8696,20 @@ function recoverRevokedJudgeVersions(input) {
 }
 //#endregion
 //#region src/runtime/judge-purge.ts
+const purgeListeners = /* @__PURE__ */ new WeakMap();
+/** One owner composes one listener per database; the returned function removes exactly that registration. */
+function registerJudgeWorkPurgeListener(database, listener) {
+	if (purgeListeners.has(database)) throw new Error("a judge work purge listener is already registered");
+	purgeListeners.set(database, listener);
+	return () => {
+		if (purgeListeners.get(database) === listener) purgeListeners.delete(database);
+	};
+}
 /**
 * The sole judge participant for a caller's already-open immediate transaction. It deliberately performs no
 * reservation transition itself: Task 5's idempotent recovery primitive releases pre-I/O work and terminalises
-* post-I/O work exactly once.
+* post-I/O work exactly once. After each transition it tells the database's work listener, so every E purge caller
+* — they all reach judge work through this class — also stops the in-memory work that transition orphaned.
 */
 var JudgePurgeParticipant = class {
 	#database;
@@ -8672,6 +8718,10 @@ var JudgePurgeParticipant = class {
 		this.#database = input.database;
 		this.#now = input.now ?? Date.now;
 	}
+	#purged(result) {
+		purgeListeners.get(this.#database)?.onWorkPurged();
+		return result;
+	}
 	all() {
 		const result = recoverJudgeWork({
 			database: this.#database,
@@ -8680,7 +8730,7 @@ var JudgePurgeParticipant = class {
 		});
 		purgeHeldDecisionsInTransaction(this.#database, { scope: "all" });
 		this.#database.prepare("UPDATE decisions SET encrypted_record = NULL WHERE encrypted_record IS NOT NULL").run();
-		return result;
+		return this.#purged(result);
 	}
 	kind(judgeKind) {
 		const result = recoverJudgeWork({
@@ -8695,16 +8745,16 @@ var JudgePurgeParticipant = class {
 			scope: "judge-kind",
 			judgeKind
 		});
-		return result;
+		return this.#purged(result);
 	}
 	/** Judge removal is version-exact and delegates each durable identity to the single recovery transition. */
 	judge(input) {
-		return recoverRevokedJudgeVersions({
+		return this.#purged(recoverRevokedJudgeVersions({
 			database: this.#database,
 			now: this.#now(),
 			judgeId: input.judgeId,
 			versions: input.versions
-		});
+		}));
 	}
 	account(input) {
 		const result = recoverJudgeWork({
@@ -8720,7 +8770,7 @@ var JudgePurgeParticipant = class {
 			scope: "source-account",
 			...input
 		});
-		return result;
+		return this.#purged(result);
 	}
 	event(input) {
 		if (input.ruleId === void 0 !== (input.ruleVersion === void 0)) throw new Error("a rule-bound judge event purge needs both rule id and version");
@@ -8755,7 +8805,7 @@ var JudgePurgeParticipant = class {
 			ruleId: input.ruleId,
 			ruleVersion: input.ruleVersion
 		});
-		return result;
+		return this.#purged(result);
 	}
 	/**
 	* Purge judge work for one retained projection without inferring its source from the replacement document.  The
@@ -8777,10 +8827,10 @@ var JudgePurgeParticipant = class {
 			released += result.released;
 			settled += result.settled;
 		}
-		return {
+		return this.#purged({
 			released,
 			settled
-		};
+		});
 	}
 	/** Enumerate the raw source/account identities first; each recovery call remains exact and account-scoped. */
 	rule(input) {
@@ -8842,10 +8892,10 @@ var JudgePurgeParticipant = class {
 			ruleId: input.ruleId,
 			ruleVersion: row.rule_version
 		});
-		return {
+		return this.#purged({
 			released,
 			settled
-		};
+		});
 	}
 };
 //#endregion
@@ -11680,6 +11730,18 @@ const EVENT_MIGRATIONS = [
        END`,
 			"UPDATE meta SET value = '22' WHERE key = 'schema_version'"
 		]
+	},
+	{
+		version: 23,
+		name: "event-laya-model-state-v1",
+		statements: [`CREATE TABLE laya_models (
+        manifest_id TEXT PRIMARY KEY CHECK (manifest_id <> ''),
+        state TEXT NOT NULL CHECK (state IN ('installing', 'downloading', 'ready', 'failed', 'removed')),
+        bytes_verified INTEGER NOT NULL CHECK (bytes_verified >= 0),
+        verified_at INTEGER,
+        failure_code TEXT,
+        updated_at INTEGER NOT NULL CHECK (updated_at >= 0)
+      ) STRICT`, "UPDATE meta SET value = '23' WHERE key = 'schema_version'"]
 	}
 ];
 function initialiseLedger(database) {
@@ -11846,6 +11908,8 @@ var ActivationRuntime = class {
 	#failpoint;
 	#deadlineFailpoint;
 	#assertObjectSecretReady;
+	#layaInputs;
+	#onJudgeKindEnabled;
 	/** One owner process writes this state directory, so this in-memory queue is enough to serialise one approval. */
 	#approvalOperations = /* @__PURE__ */ new Map();
 	constructor(options) {
@@ -11873,10 +11937,15 @@ var ActivationRuntime = class {
 		this.#failpoint = options.failpoint;
 		this.#deadlineFailpoint = options.deadlineFailpoint;
 		this.#assertObjectSecretReady = options.assertObjectSecretReady;
+		this.#layaInputs = {
+			...options.layaAssetSource === void 0 ? {} : { layaAssetSource: options.layaAssetSource },
+			...options.layaPlatformProbe === void 0 ? {} : { layaPlatformProbe: options.layaPlatformProbe }
+		};
+		this.#onJudgeKindEnabled = options.onJudgeKindEnabled;
 	}
 	async prepareRule(input) {
 		await this.assertNoCompletingMutation(input.ruleId);
-		const versions = new ImmutableVersions(this.#store.database);
+		const versions = this.#versions();
 		const document = versions.prepareRule(input.ruleId, input.version);
 		await this.#assertDocumentSecretsReady(document.rule);
 		this.#sourceRegistry.require(document.rule.source.channel);
@@ -11963,7 +12032,7 @@ var ActivationRuntime = class {
 				ruleVersion: row.version
 			}))
 		};
-		const versions = new ImmutableVersions(this.#store.database);
+		const versions = this.#versions();
 		const liveBySource = /* @__PURE__ */ new Map();
 		const points = [];
 		for (const row of rows) {
@@ -11987,7 +12056,7 @@ var ActivationRuntime = class {
 	/** Prepares the singleton budget solely from its immutable stored document. */
 	async prepareJudgeBudget(input) {
 		await this.assertNoCompletingMutation();
-		const versions = new ImmutableVersions(this.#store.database);
+		const versions = this.#versions();
 		const document = versions.prepareJudgeBudget(input.version);
 		const active = versions.activeVersion("judge-budget", JUDGE_BUDGET_ID);
 		if (active?.version === input.version) throw new CommsError("CONFIG", "the requested judge budget is already active");
@@ -12003,7 +12072,7 @@ var ActivationRuntime = class {
 	/** Prepares a separately approved available judge-kind pointer; it performs no provider work. */
 	async prepareJudgeKind(input) {
 		const disableGeneration = this.#judgeKindDisableGeneration(input.kind);
-		const versions = new ImmutableVersions(this.#store.database);
+		const versions = this.#versions();
 		const document = versions.prepareJudgeKind(input.kind, input.version);
 		await this.assertNoCompletingMutation();
 		const active = versions.activeVersion("judge-kind", document.enablement.kind);
@@ -12267,7 +12336,7 @@ var ActivationRuntime = class {
 	}
 	async #prepare(document, points, effect, replacementOfVersion) {
 		const intentId = this.#newIntentId();
-		const binding = disclosureBindingFor(intentId, document);
+		const binding = disclosureBindingFor(intentId, document, this.#layaInputs);
 		const now = this.#now();
 		const plannedAccounts = [...new Map(points.map((point) => [`${point.source}\u0000${point.accountId}`, point])).values()];
 		this.#store.immediate(() => {
@@ -12465,6 +12534,12 @@ var ActivationRuntime = class {
 		if (document.kind === "rule") await this.#assertDocumentSecretsReady(document.rule);
 		this.#finalise(current, document, preparedPoints, usedAt);
 		this.#failpoint?.("after-move");
+		if (document.kind === "judge-kind") try {
+			this.#onJudgeKindEnabled?.({
+				kind: document.enablement.kind,
+				version: document.enablement.version
+			});
+		} catch {}
 		return {
 			intentId: current.id,
 			status: "completed",
@@ -12506,7 +12581,7 @@ var ActivationRuntime = class {
 				}
 			}
 			if (document.kind === "rule") {
-				const active = new ImmutableVersions(this.#store.database).activeVersion("rule", document.rule.ruleId);
+				const active = this.#versions().activeVersion("rule", document.rule.ruleId);
 				if (latest.replacement_of_version === null && active !== null) throw new CommsError("TRANSIENT", "the active rule pointer changed during activation", { details: { reason: "ACTIVATION_COMPLETING" } });
 				if (latest.replacement_of_version !== null && (active === null || `${document.rule.ruleId}@${active.version}` !== latest.replacement_of_version)) {
 					this.#cancel(intent.id, ACTIVATION_FAILURE.STALE_POINTER);
@@ -12594,11 +12669,11 @@ var ActivationRuntime = class {
 	}
 	#liveBinding(intent) {
 		const document = this.#document(intent);
-		const binding = disclosureBindingFor(intent.id, document);
-		if (binding.digest !== intent.digest || activationDocumentDigest(document) !== intent.digest) throw new CommsError("APPROVAL_VOID", "the activation document changed after preparation");
+		const binding = disclosureBindingFor(intent.id, document, this.#layaInputs);
+		if (binding.digest !== intent.digest || activationDocumentDigest(document, this.#layaInputs) !== intent.digest) throw new CommsError("APPROVAL_VOID", "the activation document changed after preparation");
 		this.#assertBoundRuleAuthority(document);
 		if (document.kind === "rule") {
-			const active = new ImmutableVersions(this.#store.database).activeVersion("rule", document.rule.ruleId);
+			const active = this.#versions().activeVersion("rule", document.rule.ruleId);
 			if (active !== null && (intent.replacement_of_version === null || `${document.rule.ruleId}@${active.version}` !== intent.replacement_of_version)) throw new CommsError("APPROVAL_VOID", "the rule gained an active pointer after preparation");
 		} else if (document.kind === "enable-all") {
 			const current = this.#switch();
@@ -12624,19 +12699,22 @@ var ActivationRuntime = class {
 		const expectedVersion = document.kind === "judge-budget" ? document.budget.version : document.enablement.version;
 		if (pointer?.kind !== expectedKind || pointer.objectId !== expectedObjectId) throw new CommsError("APPROVAL_VOID", "the judge activation pointer expectation is invalid");
 		if (document.kind === "judge-kind" && pointer.disableGeneration !== this.#judgeKindDisableGeneration(expectedObjectId)) assertJudgeKindEnabled(document.enablement.kind, false);
-		const versions = new ImmutableVersions(this.#store.database);
+		const versions = this.#versions();
 		if ((versions.activeVersion(pointer.kind, pointer.objectId)?.version ?? null) !== pointer.version) throw new CommsError("APPROVAL_VOID", "the judge activation pointer changed after preparation");
 		const live = document.kind === "judge-budget" ? versions.prepareJudgeBudget(expectedVersion) : versions.prepareJudgeKind(expectedObjectId, expectedVersion);
-		if (canonicalJson(live) !== canonicalJson(document) || activationDocumentDigest(live) !== activationDocumentDigest(document)) throw new CommsError("APPROVAL_VOID", "the immutable judge activation document changed after preparation");
+		if (canonicalJson(live) !== canonicalJson(document) || activationDocumentDigest(live, this.#layaInputs) !== activationDocumentDigest(document, this.#layaInputs)) throw new CommsError("APPROVAL_VOID", "the immutable judge activation document changed after preparation");
 	}
 	/** A disable advances this durable fence even when the kind has no active pointer yet. */
+	#versions() {
+		return new ImmutableVersions(this.#store.database, this.#layaInputs);
+	}
 	#judgeKindDisableGeneration(kind) {
 		return this.#store.database.prepare("SELECT generation FROM judge_kind_disable_generations WHERE kind = ?").get(kind)?.generation ?? 0;
 	}
 	/** Re-read every exact bound rule, including its embedded judge revocation and kind pointer, at each authority gate. */
 	#assertBoundRuleAuthority(document) {
 		if (document.kind !== "rule" && document.kind !== "enable-all") return;
-		const versions = new ImmutableVersions(this.#store.database);
+		const versions = this.#versions();
 		if (document.kind === "rule") {
 			const live = versions.prepareRule(document.rule.ruleId, document.rule.version);
 			if (canonicalJson(live) !== canonicalJson(document)) throw new CommsError("APPROVAL_VOID", "the rule changed after preparation");
@@ -12647,7 +12725,7 @@ var ActivationRuntime = class {
 	/** Preparation may await local stores; the exact pointer plan captured before those awaits must still be current. */
 	#assertPreparationPlanLive(document, effect, replacementOfVersion) {
 		if (document.kind === "rule") {
-			const active = new ImmutableVersions(this.#store.database).activeVersion("rule", document.rule.ruleId);
+			const active = this.#versions().activeVersion("rule", document.rule.ruleId);
 			if ((active === null ? null : `${document.rule.ruleId}@${active.version}`) !== (replacementOfVersion ?? null) || this.#switch().generation !== effect.switchGeneration) throw new CommsError("APPROVAL_VOID", "the rule activation pointer plan changed during preparation");
 			return;
 		}
@@ -13391,7 +13469,7 @@ function resolutionHealth(database, source, accountId, category) {
 		}
 	};
 }
-function record(value) {
+function record$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
 function retry(value, first, next, attempts) {
@@ -13405,13 +13483,13 @@ function retry(value, first, next, attempts) {
 }
 /** Extracts only retry timing/count fields and immediately discards the decrypted source continuation. */
 function retriesFromState(source, cursorScope, state, category) {
-	const decrypted = record(state);
+	const decrypted = record$1(state);
 	if (decrypted === null) return [];
 	if (category === "metadata") {
 		if (source !== "gmail" || cursorScope !== "mailbox") return [];
-		const states = record(decrypted.messageStates);
+		const states = record$1(decrypted.messageStates);
 		return states === null ? [] : Object.values(states).flatMap((message) => {
-			const values = record(message);
+			const values = record$1(message);
 			const pending = values === null ? null : retry(values, "firstFailedAt", "nextRetryAt", "attempts");
 			return pending === null ? [] : [pending];
 		});
@@ -13421,7 +13499,7 @@ function retriesFromState(source, cursorScope, state, category) {
 		return pending === null ? [] : [pending];
 	}
 	if (source === "resend" && cursorScope === "received") {
-		const values = record(decrypted.retry);
+		const values = record$1(decrypted.retry);
 		const pending = values === null ? null : retry(values, "firstFailedAt", "nextRetryAt", "attempts");
 		return pending === null ? [] : [pending];
 	}
@@ -13700,6 +13778,23 @@ async function projectE9Doctor(input) {
 		}
 	});
 }
+/**
+* E2's successor beside the frozen doctor-v1 and doctor-v2 projections: the same v2 report, with no remaining judge
+* boundary, Laya's real kind state, and its content-free artifact entry from the one artifact manager.
+*/
+async function projectE2Doctor(input) {
+	const report = await projectE9Doctor(input);
+	return assertDoctorReportV3({
+		...report,
+		schemaVersion: "doctor-v3",
+		judgeBoundary: [],
+		judge: {
+			...report.judge,
+			kinds: report.judge.kinds.map((entry) => entry.kind === "laya" ? input.laya.kindEntry() : entry),
+			laya: await input.laya.doctor()
+		}
+	});
+}
 function whatsappHealth(database, live) {
 	const applied = new Map(database.prepare("SELECT account_id, changed_at FROM whatsapp_visibility").all().map((row) => [row.account_id, row.changed_at]));
 	const accountIds = new Set([...live].filter((identity) => identity.startsWith("whatsapp\0")).map((identity) => identity.slice(9)));
@@ -13757,7 +13852,8 @@ function unavailableE2() {
 //#region src/runtime/judge-kinds.ts
 function available(kind) {
 	if (!JUDGE_KINDS.includes(kind)) throw new CommsError("BAD_DATA", "the judge kind is not recognised");
-	if (JUDGE_KIND_DEFINITIONS.find((entry) => entry.kind === kind)?.availability !== "available") throw new EventDomainError("E2_REQUIRED", "laya is unavailable until E2");
+	const definition = JUDGE_KIND_DEFINITIONS.find((entry) => entry.kind === kind);
+	if (definition?.availability !== "available" && definition?.implementation === void 0) throw new EventDomainError("E2_REQUIRED", "the judge kind is unavailable");
 	return kind;
 }
 /** Task 4's dormant kind authority. Public operation registration remains Task 9's job. */
@@ -13765,10 +13861,21 @@ var JudgeKinds = class {
 	#store;
 	#now;
 	#activations;
+	#artifacts;
 	constructor(input) {
 		this.#store = input.store;
 		this.#now = input.now ?? Date.now;
 		this.#activations = input.activations;
+		this.#artifacts = input.artifacts;
+	}
+	/**
+	* The operation-facing disable. A kind with installed artifacts disables through their lifecycle, which wraps
+	* exactly the transaction below; every other kind is that transaction alone.
+	*/
+	async disableKind(kind) {
+		const enabledKind = available(kind);
+		if (this.#artifacts !== void 0 && this.#artifacts.kind === enabledKind) return this.#artifacts.disableKind(() => this.disable(enabledKind));
+		return this.disable(enabledKind);
 	}
 	prepareEnable(input) {
 		available(input.kind);
@@ -13812,6 +13919,12 @@ var B3OperatorControl = class {
 	#activations;
 	#judgeTest;
 	#holdResolver;
+	/**
+	* E2's artifact manager. When the owner composes it, every Laya operation answers with the real model state and a
+	* Laya judge is created and listed like any other (B3 control v3, which keeps v2's answers); without it this control
+	* keeps B3 v1's frozen typed `E2_REQUIRED` answers and v1's judge documents, which have no Laya variant.
+	*/
+	#laya;
 	constructor(input) {
 		this.#store = input.store;
 		this.#ports = input.ports;
@@ -13819,9 +13932,10 @@ var B3OperatorControl = class {
 		this.#activations = input.activations;
 		this.#judgeTest = input.judgeTest;
 		this.#holdResolver = input.holdResolver;
+		this.#laya = input.laya;
 	}
 	async handle(request) {
-		const unavailable = request.operation === "judgeModelStatus" || request.operation === "removeJudgeModel" || (request.operation === "enableJudgeKind" || request.operation === "disableJudgeKind") && request.args.kind === "laya" ? judgeUnavailable(request.operation, request.args) : void 0;
+		const unavailable = this.#laya === void 0 && (request.operation === "judgeModelStatus" || request.operation === "removeJudgeModel" || (request.operation === "enableJudgeKind" || request.operation === "disableJudgeKind") && request.args.kind === "laya") ? judgeUnavailable(request.operation, request.args) : void 0;
 		if (unavailable !== void 0) return unavailable;
 		switch (request.operation) {
 			case "subscribersList": return this.subscribersList();
@@ -13833,7 +13947,7 @@ var B3OperatorControl = class {
 			case "dropDelivery": return this.#ports.quiescer.withShared(async () => this.dropDelivery(requiredText$1(request.args.deliveryId, "delivery id")));
 			case "judgesList": return this.judgesList();
 			case "addJudge":
-			case "updateJudge": return this.#ports.quiescer.withShared(async () => this.#store.immediate(() => new ImmutableVersions(this.#store.database).createJudge(request.args.document)));
+			case "updateJudge": return this.#ports.quiescer.withShared(async () => this.#store.immediate(() => this.#judgeVersions().createJudge(request.args.document)));
 			case "removeJudge": return this.removeJudge(requiredText$1(request.args.judgeId, "judge id"));
 			case "judgeTest":
 				if (this.#judgeTest === void 0) throw new CommsError("CONFIG", "judge test is not composed for this operator control");
@@ -13846,6 +13960,8 @@ var B3OperatorControl = class {
 			case "judgeKindsList": return this.judgeKindsList();
 			case "enableJudgeKind": return this.enableJudgeKind(requiredText$1(request.args.kind, "judge kind"));
 			case "disableJudgeKind": return this.disableJudgeKind(requiredText$1(request.args.kind, "judge kind"));
+			case "judgeModelStatus": return this.requireLaya().status();
+			case "removeJudgeModel": return this.requireLaya().remove();
 			case "heldList": return this.heldList();
 			case "decideHeld":
 				if (this.#holdResolver === void 0) throw new CommsError("CONFIG", "held resolution has not been composed for this operator control");
@@ -13856,6 +13972,14 @@ var B3OperatorControl = class {
 			default: throw new CommsError("USAGE", `the local B3 operator control does not implement ${request.operation}`);
 		}
 	}
+	/** The judge documents this control answers: B3 v3's with E2's artifact manager, B3 v1's without it. */
+	#judgeVersions() {
+		return this.#laya === void 0 ? new ImmutableVersions(this.#store.database) : ImmutableVersions.forJudgeContract(this.#store.database, "b3-control-v3");
+	}
+	requireLaya() {
+		if (this.#laya === void 0) throw new CommsError("CONFIG", "the Laya artifact manager is not composed for this operator control");
+		return this.#laya;
+	}
 	requireActivations() {
 		if (this.#activations === void 0) throw new CommsError("CONFIG", "judge activation is not composed for this operator control");
 		return this.#activations;
@@ -13879,6 +14003,7 @@ var B3OperatorControl = class {
 	}
 	judgeKindsList() {
 		return JUDGE_KINDS.map((kind) => {
+			if (kind === "laya" && this.#laya !== void 0) return this.#laya.kindEntry();
 			if (JUDGE_KIND_DEFINITIONS.find((entry) => entry.kind === kind)?.availability === "unavailable") return {
 				kind: JUDGE_KIND_LAYA,
 				state: "unavailable",
@@ -13899,6 +14024,18 @@ var B3OperatorControl = class {
 	}
 	async enableJudgeKind(kind) {
 		const activations = this.requireActivations();
+		if (kind === "laya" && this.#laya !== void 0) {
+			const prepared = this.#laya.enablementVersion();
+			if (!("version" in prepared)) return prepared;
+			return new JudgeKinds({
+				store: this.#store,
+				now: this.#now,
+				activations
+			}).prepareEnable({
+				kind: JUDGE_KIND_LAYA,
+				version: prepared.version
+			});
+		}
 		const available = availableJudgeKind(kind);
 		const version = this.#store.immediate(() => {
 			const latest = this.#store.database.prepare("SELECT max(version) AS version FROM judge_kind_versions WHERE kind = ? AND revoked_at IS NULL").get(available);
@@ -13929,8 +14066,9 @@ var B3OperatorControl = class {
 		return new JudgeKinds({
 			store: this.#store,
 			now: this.#now,
-			activations
-		}).disable(kind);
+			activations,
+			artifacts: this.#laya
+		}).disableKind(kind);
 	}
 	async removeJudge(judgeId) {
 		return this.#store.immediate(() => {
@@ -13984,14 +14122,17 @@ var B3OperatorControl = class {
 		return this.#store.database.prepare("SELECT judge_id, version, document, revoked_at FROM judge_versions ORDER BY judge_id, version").all().flatMap((row) => {
 			try {
 				const judge = canonicalJudge(JSON.parse(row.document));
-				return [{
+				const entry = {
 					judgeId: row.judge_id,
 					version: row.version,
 					kind: judge.kind,
 					provider: judge.provider,
 					model: judge.model,
 					revokedAt: row.revoked_at
-				}];
+				};
+				if (this.#laya !== void 0) return [entry];
+				if (judge.kind === "laya") return [];
+				return [entry];
 			} catch {
 				return [];
 			}
@@ -15454,19 +15595,27 @@ const systemAddressResolver = { async lookup(hostname) {
 	})).map((answer) => answer.address);
 } };
 /** A literal host is its singleton answer; a hostname is resolved afresh by the injected resolver. */
-async function resolveHost(hostname, resolver = systemAddressResolver) {
+async function resolveHost(hostname, resolver = systemAddressResolver, options = {}) {
 	try {
 		return [parseIpLiteral(hostname).address];
 	} catch (error) {
 		if (!(error instanceof AddressPolicyError)) throw error;
 	}
-	const answers = await resolver.lookup(hostname);
+	const answers = await resolver.lookup(hostname, options);
 	if (answers.length === 0) throw new AddressPolicyError(`resolver returned no addresses for ${hostname}`);
 	return answers;
 }
 //#endregion
 //#region src/network/pinned-connection.ts
 const TYPESAFE_GLOBAL_ONLY_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
+var PinnedResponseError = class extends Error {
+	code;
+	constructor(code) {
+		super(`pinned network response refused: ${code}`);
+		this.name = "PinnedResponseError";
+		this.code = code;
+	}
+};
 function hostWithoutBrackets(hostname) {
 	return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
 }
@@ -15497,6 +15646,9 @@ function assertPinnedUrl(url) {
 	if (url.username !== "" || url.password !== "") throw new AddressPolicyError("network URL userinfo is refused");
 	if (url.hash !== "") throw new AddressPolicyError("network URL fragments are refused");
 }
+function abortReason(signal) {
+	return signal.reason instanceof Error ? signal.reason : new PinnedResponseError("NETWORK_ABORTED");
+}
 /** Resolves all answers, validates them all, and selects a literal only after the complete set passes. */
 async function preparePinnedConnection(options) {
 	const url = typeof options.url === "string" ? new URL(options.url) : new URL(options.url.href);
@@ -15513,7 +15665,7 @@ async function preparePinnedConnection(options) {
 	const literal = isLiteral(hostname);
 	if (url.protocol === "http:" && (!literal || hostname !== "127.0.0.1" && hostname !== "::1")) throw new AddressPolicyError("HTTP requires literal 127.0.0.1 or ::1");
 	if (url.protocol === "http:" && !globalOnly && !isSoleApprovedLiteral(options.approvedAddressSet, hostname)) throw new AddressPolicyError("HTTP requires its one exact approved literal loopback address");
-	const addresses = (await resolveHost(hostname, options.resolver ?? systemAddressResolver)).map((answer) => assertAddressAllowed(answer, options)).map((answer) => answer.address).sort((left, right) => left.localeCompare(right));
+	const addresses = (await resolveHost(hostname, options.resolver ?? systemAddressResolver, { signal: options.signal })).map((answer) => assertAddressAllowed(answer, options)).map((answer) => answer.address).sort((left, right) => left.localeCompare(right));
 	if (addresses.length === 0) throw new AddressPolicyError("resolver returned no vetted addresses");
 	const [address] = addresses;
 	if (address === void 0) throw new AddressPolicyError("resolver returned no selected address");
@@ -15545,36 +15697,160 @@ function requestBytesForPinnedConnection(connection, method, body = Buffer.alloc
 	const supplied = Object.entries(headers).map(([name, value]) => `${name}: ${value}`);
 	return Buffer.concat([Buffer.from(`${method} ${pathname} HTTP/1.1\r\nHost: ${connection.hostHeader}\r\nContent-Length: ${body.byteLength}\r\nConnection: close\r\n${supplied.join("\r\n")}\r\n\r\n`), Buffer.from(body)]);
 }
+/**
+* Generates a no-body raw GET for a fixed-purpose caller.  The caller's header
+* policy is deliberately outside B2; B2 only guarantees that these exact raw
+* bytes go over a previously pinned connection.
+*/
+function getRequestBytesForPinnedConnection(connection, headers) {
+	const pathname = `${connection.url.pathname}${connection.url.search}` || "/";
+	const supplied = Object.entries(headers).map(([name, value]) => `${name}: ${value}`);
+	return Buffer.from(`GET ${pathname} HTTP/1.1\r\nHost: ${connection.hostHeader}\r\nConnection: close\r\n${supplied.join("\r\n")}\r\n\r\n`, "latin1");
+}
+/** Streams one bounded raw response without retaining its bytes in memory. */
+function streamPinnedResponseTo(socket, request, options) {
+	const { maxBytes, onChunk, signal } = options;
+	if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) throw new PinnedResponseError("NETWORK_RESPONSE_TOO_LARGE");
+	for (const deadline of [options.idleTimeoutMs, options.totalTimeoutMs]) if (deadline !== void 0 && (!Number.isSafeInteger(deadline) || deadline < 1)) throw new PinnedResponseError("NETWORK_TIMEOUT_INVALID");
+	return new Promise((resolve, reject) => {
+		let total = 0;
+		let terminal;
+		let ended = false;
+		let pending = Promise.resolve();
+		let idleTimer;
+		let totalTimer;
+		const onError = (error) => fail(error);
+		const onAbort = () => fail(signal === void 0 ? new PinnedResponseError("NETWORK_ABORTED") : abortReason(signal));
+		const clearTimers = () => {
+			if (idleTimer !== void 0) clearTimeout(idleTimer);
+			if (totalTimer !== void 0) clearTimeout(totalTimer);
+		};
+		const resetIdleDeadline = () => {
+			if (options.idleTimeoutMs === void 0) return;
+			if (idleTimer !== void 0) clearTimeout(idleTimer);
+			idleTimer = setTimeout(() => fail(new PinnedResponseError("NETWORK_IDLE_TIMEOUT")), options.idleTimeoutMs);
+		};
+		const cleanup = () => {
+			clearTimers();
+			signal?.removeEventListener("abort", onAbort);
+			socket.off("error", onError);
+		};
+		const finish = () => {
+			if (terminal !== void 0) return;
+			terminal = null;
+			cleanup();
+			pending.then(() => resolve());
+		};
+		const fail = (error) => {
+			if (terminal !== void 0) return;
+			terminal = error;
+			cleanup();
+			socket.destroy();
+			pending.then(() => reject(error));
+		};
+		socket.once("error", onError);
+		if (signal?.aborted === true) {
+			fail(new PinnedResponseError("NETWORK_ABORTED"));
+			return;
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+		resetIdleDeadline();
+		if (options.totalTimeoutMs !== void 0) totalTimer = setTimeout(() => fail(new PinnedResponseError("NETWORK_TOTAL_TIMEOUT")), options.totalTimeoutMs);
+		socket.on("data", (chunk) => {
+			if (terminal !== void 0) return;
+			resetIdleDeadline();
+			total += chunk.byteLength;
+			if (total > maxBytes) {
+				fail(new PinnedResponseError("NETWORK_RESPONSE_TOO_LARGE"));
+				return;
+			}
+			socket.pause();
+			pending = pending.then(() => onChunk(Buffer.from(chunk))).then(() => {
+				if (terminal === void 0) socket.resume();
+				if (ended) finish();
+			}, (error) => fail(error instanceof Error ? error : /* @__PURE__ */ new Error("raw pinned response sink failed")));
+		});
+		socket.once("end", () => {
+			ended = true;
+			pending.then(() => finish());
+		});
+		socket.once("close", () => {
+			if (terminal === void 0) fail(new PinnedResponseError("NETWORK_RESPONSE_INCOMPLETE"));
+		});
+		try {
+			socket.write(request);
+		} catch (error) {
+			fail(error instanceof Error ? error : /* @__PURE__ */ new Error("raw pinned request write failed"));
+		}
+	});
+}
 /** Opens the selected literal TCP peer. Callers place their final authority fence immediately before this call. */
 function connectPinnedTcp(options) {
 	return new Promise((resolve, reject) => {
+		if (options.signal?.aborted === true) {
+			reject(abortReason(options.signal));
+			return;
+		}
 		const socket = net.connect({
 			host: options.host,
 			port: options.port
 		});
-		socket.once("error", reject);
 		installErrorSink(socket);
-		socket.once("connect", () => {
-			socket.off("error", reject);
+		const cleanup = () => {
+			options.signal?.removeEventListener("abort", onAbort);
+			socket.off("error", onError);
+			socket.off("connect", onConnect);
+		};
+		const fail = (error) => {
+			cleanup();
+			socket.destroy();
+			reject(error);
+		};
+		const onError = (error) => fail(error);
+		const onAbort = () => fail(options.signal === void 0 ? new PinnedResponseError("NETWORK_ABORTED") : abortReason(options.signal));
+		const onConnect = () => {
+			cleanup();
 			resolve(socket);
-		});
+		};
+		socket.once("error", onError);
+		socket.once("connect", onConnect);
+		options.signal?.addEventListener("abort", onAbort, { once: true });
 	});
 }
 /** Starts TLS only over the already-pinned TCP socket. Callers fence immediately before this ClientHello. */
 function connectPinnedTls(options) {
 	return new Promise((resolve, reject) => {
+		if (options.signal?.aborted === true) {
+			options.socket.destroy();
+			reject(abortReason(options.signal));
+			return;
+		}
 		const socket = tls.connect({
 			socket: options.socket,
 			rejectUnauthorized: options.rejectUnauthorized,
 			...options.servername === void 0 ? {} : { servername: options.servername },
 			checkServerIdentity: (_name, certificate) => tls.checkServerIdentity(options.certificateHost, certificate)
 		});
-		socket.once("error", reject);
 		installErrorSink(socket);
-		socket.once("secureConnect", () => {
-			socket.off("error", reject);
+		const cleanup = () => {
+			options.signal?.removeEventListener("abort", onAbort);
+			socket.off("error", onError);
+			socket.off("secureConnect", onSecureConnect);
+		};
+		const fail = (error) => {
+			cleanup();
+			socket.destroy();
+			reject(error);
+		};
+		const onError = (error) => fail(error);
+		const onAbort = () => fail(options.signal === void 0 ? new PinnedResponseError("NETWORK_ABORTED") : abortReason(options.signal));
+		const onSecureConnect = () => {
+			cleanup();
 			resolve(socket);
-		});
+		};
+		socket.once("error", onError);
+		socket.once("secureConnect", onSecureConnect);
+		options.signal?.addEventListener("abort", onAbort, { once: true });
 	});
 }
 //#endregion
@@ -15982,6 +16258,462 @@ var JudgeTransport = class {
 		}
 	}
 };
+/**
+* Each worker's owner-only working and proof directory is a fresh `mkdtemp` beneath `/tmp`, which is sticky and owned
+* by root as B1-G's socket-directory check accepts. Task 7's probe binds `<directory>/laya-boundary-XXXXXX/
+* boundary.sock`, 35 bytes beyond it, so this 27-byte directory keeps the socket at 62 bytes, inside macOS's 103 for
+* any home: core's data directory fits only while the home is at most 22 bytes.
+*/
+const LAYA_WORKER_DIRECTORY_PARENT = "/tmp";
+const LAYA_WORKER_DIRECTORY_PREFIX = "agentcomms-laya-";
+const BINDING_FIELDS = [
+	"nonce",
+	"pid",
+	"profile",
+	"entry",
+	"pipeGeneration"
+];
+function sameSelection(current, started) {
+	return current !== null && current.epoch === started.epoch && current.version === started.version && current.digest === started.digest && current.manifestId === started.manifestId;
+}
+function exactFrame(frame, keys) {
+	const found = Object.keys(frame).sort();
+	const expected = [...keys].sort();
+	return found.length === expected.length && found.every((key, index) => key === expected[index]);
+}
+function bound(frame, binding) {
+	return BINDING_FIELDS.every((field) => frame[field] === binding[field]);
+}
+/** The worker's reply, in its closed shapes only: a finite value in [0, 1], never clamped, and its token count. */
+function replyFrame(frame, binding, requestId) {
+	if (!bound(frame, binding) || frame.requestId !== requestId) return null;
+	if (frame.type === "answer") {
+		if (!exactFrame(frame, [
+			"type",
+			...BINDING_FIELDS,
+			"requestId",
+			"value",
+			"inputTokens"
+		])) return null;
+		const { value, inputTokens } = frame;
+		if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) return null;
+		if (!Number.isSafeInteger(inputTokens) || inputTokens < 1) return null;
+		if (inputTokens > 512) return null;
+		return {
+			kind: "answer",
+			value,
+			inputTokens
+		};
+	}
+	if (frame.type !== "refused" || !exactFrame(frame, [
+		"type",
+		...BINDING_FIELDS,
+		"requestId",
+		"code"
+	])) return null;
+	if (frame.code === "token-limit") return {
+		kind: "refused",
+		code: "laya-token-limit",
+		preIo: false
+	};
+	if (frame.code === "malformed") return {
+		kind: "refused",
+		code: "laya-malformed",
+		preIo: false
+	};
+	if (frame.code === "template-blocked") return {
+		kind: "refused",
+		code: "laya-template-blocked",
+		preIo: false
+	};
+	return null;
+}
+function loadFrame(frame, binding) {
+	if (!bound(frame, binding)) return null;
+	if (frame.type === "loaded" && exactFrame(frame, ["type", ...BINDING_FIELDS])) return "loaded";
+	if (frame.type === "load-refused" && exactFrame(frame, [
+		"type",
+		...BINDING_FIELDS,
+		"code"
+	])) return "refused";
+	return null;
+}
+function refusedBefore(code) {
+	return { refused: {
+		kind: "refused",
+		code,
+		preIo: true
+	} };
+}
+/**
+* The one isolated Laya worker (E2-7, D11): started lazily, one request at a time, and killed on a 30-second
+* deadline, a crash, any frame outside the protocol, a purge of its in-flight reservation, a kind disable or update
+* tightening, the owner's stop, and after ten idle minutes. It holds no database, account, event, target or secret:
+* E's coordinator reserves, gates and settles, and this supervisor moves only one bounded request to the child and
+* its bounded answer back. A later call after any kill starts a fresh child, proved again from the beginning.
+*/
+var LayaWorkerSupervisor = class {
+	#artifacts;
+	#startWorker;
+	#requestDeadlineMs;
+	#idleExitMs;
+	#loadDeadlineMs;
+	#detach;
+	#queue = Promise.resolve();
+	#worker;
+	/** Bumped by every stop: a start or request that began before it never adopts or keeps a worker. */
+	#generation = 0;
+	#stopping = new AbortController();
+	constructor(options) {
+		this.#artifacts = options.artifacts;
+		this.#startWorker = options.startWorker ?? ((start) => createLayaWorkerBoundary(start));
+		this.#requestDeadlineMs = options.requestDeadlineMs ?? 3e4;
+		this.#idleExitMs = options.idleExitMs ?? 6e5;
+		this.#loadDeadlineMs = options.loadDeadlineMs ?? 12e4;
+		this.#detach = options.artifacts.attachWorker(this);
+	}
+	availability() {
+		return this.#artifacts.availability();
+	}
+	/**
+	* Before E reserves anything: this release must offer Laya here, the enabled entry must be the judge's own manifest
+	* and list the judge's template, and the request must fit one frame. The body is what E reserves against.
+	*/
+	prepare(input) {
+		const availability = this.#artifacts.availability();
+		if (!availability.available) return {
+			ok: false,
+			code: availability.code
+		};
+		const selection = this.#artifacts.workerSelection();
+		if (selection === null) return {
+			ok: false,
+			code: "laya-not-ready"
+		};
+		const templateId = input.judge.promptTemplate;
+		if (input.judge.model !== selection.manifestId || !isLayaTemplateId(templateId) || !selection.promptTemplates.includes(templateId) || input.state.length === 0 || input.instructions.length === 0) return {
+			ok: false,
+			code: "laya-adapter-blocked"
+		};
+		const body = Buffer.from(JSON.stringify({
+			templateId,
+			instructions: input.instructions,
+			state: input.state
+		}));
+		if (body.length > 61440) return {
+			ok: false,
+			code: "laya-request-too-large"
+		};
+		return {
+			ok: true,
+			request: {
+				templateId,
+				instructions: input.instructions,
+				state: input.state,
+				body
+			}
+		};
+	}
+	/**
+	* One request at a time: the next one's frame is not written until this one has settled. Work is tracked by its
+	* E reservation from the moment it is handed over, so a purge reaches it while it waits, too.
+	*/
+	execute(request, hooks) {
+		const tracked = this.#artifacts.trackWork(hooks.reservationId);
+		const run = this.#queue.then(() => this.#execute(request, hooks, tracked.signal));
+		this.#queue = run.then(() => void 0, () => void 0);
+		return run.finally(() => tracked.release());
+	}
+	/** Kills the worker — a kind disable, an update tightening, the owner's stop — and fails whatever waited on it. */
+	async stop() {
+		this.#generation += 1;
+		const stopping = this.#stopping;
+		this.#stopping = new AbortController();
+		stopping.abort();
+		const worker = this.#worker;
+		this.#worker = void 0;
+		if (worker !== void 0) await this.#kill(worker, "laya-stopped");
+	}
+	/** The owner's final stop: also detaches from the manager. */
+	async close() {
+		await this.stop();
+		this.#detach();
+	}
+	async #execute(request, hooks, signal) {
+		const generation = this.#generation;
+		const stopping = this.#stopping.signal;
+		if (signal.aborted) return {
+			kind: "refused",
+			code: "laya-purged",
+			preIo: true
+		};
+		const started = await this.#ensureWorker(generation, signal, stopping);
+		if ("refused" in started) return started.refused;
+		const worker = started.worker;
+		if (signal.aborted) return {
+			kind: "refused",
+			code: "laya-purged",
+			preIo: true
+		};
+		if (generation !== this.#generation || this.#worker !== worker) return {
+			kind: "refused",
+			code: "laya-stopped",
+			preIo: true
+		};
+		if (!sameSelection(this.#artifacts.workerSelection(), worker.selection)) return {
+			kind: "refused",
+			code: "laya-authority-changed",
+			preIo: true
+		};
+		const requestId = createWorkerRequestId();
+		let bytes;
+		try {
+			bytes = encodeWorkerFrame({
+				type: "request",
+				...worker.binding,
+				requestId,
+				templateId: request.templateId,
+				instructions: request.instructions,
+				state: request.state
+			});
+		} catch {
+			return {
+				kind: "refused",
+				code: "laya-request-too-large",
+				preIo: true
+			};
+		}
+		this.#clearIdle(worker);
+		const reply = this.#expect(worker, this.#requestDeadlineMs, signal, stopping, (frame) => replyFrame(frame, worker.binding, requestId));
+		try {
+			hooks.finalGate();
+		} catch {
+			reply.cancel();
+			this.#armIdle(worker);
+			return {
+				kind: "refused",
+				code: "laya-authority-changed",
+				preIo: true
+			};
+		}
+		worker.child.stdin.write(bytes);
+		const result = await reply.settled;
+		if ("gone" in result) {
+			await this.#kill(worker, result.gone);
+			return {
+				kind: "refused",
+				code: result.gone,
+				preIo: false
+			};
+		}
+		this.#armIdle(worker);
+		return result.value;
+	}
+	async #ensureWorker(generation, signal, stopping) {
+		const running = this.#worker;
+		if (running !== void 0) return { worker: running };
+		const availability = this.#artifacts.availability();
+		if (!availability.available) return refusedBefore(availability.code);
+		const selection = this.#artifacts.workerSelection();
+		if (selection === null) return refusedBefore("laya-not-ready");
+		const verified = await this.#artifacts.verifyForWorkerStart();
+		if (!verified.ok) return refusedBefore(verified.failureCode ?? "laya-not-ready");
+		if (generation !== this.#generation || stopping.aborted) return refusedBefore("laya-stopped");
+		if (signal.aborted) return refusedBefore("laya-purged");
+		if (!sameSelection(this.#artifacts.workerSelection(), selection)) return refusedBefore("laya-authority-changed");
+		let directory;
+		try {
+			directory = await mkdtemp(join(LAYA_WORKER_DIRECTORY_PARENT, LAYA_WORKER_DIRECTORY_PREFIX));
+		} catch {
+			return refusedBefore("boundary-failed");
+		}
+		const proof = new AbortController();
+		const abortProof = () => proof.abort();
+		signal.addEventListener("abort", abortProof, { once: true });
+		stopping.addEventListener("abort", abortProof, { once: true });
+		if (signal.aborted || stopping.aborted) proof.abort();
+		let boundary;
+		try {
+			boundary = await this.#startWorker({
+				dataDirectory: directory,
+				signal: proof.signal
+			});
+		} catch {
+			boundary = {
+				ok: false,
+				code: "boundary-failed",
+				loadSent: false
+			};
+		} finally {
+			signal.removeEventListener("abort", abortProof);
+			stopping.removeEventListener("abort", abortProof);
+		}
+		if (!boundary.ok) {
+			await rm(directory, {
+				recursive: true,
+				force: true
+			}).catch(() => void 0);
+			if (proof.signal.aborted) return refusedBefore(signal.aborted ? "laya-purged" : "laya-stopped");
+			if (boundary.code === "boundary-failed") this.#artifacts.recordWorkerFailure(selection, "boundary-failed");
+			return refusedBefore(boundary.code);
+		}
+		const proven = boundary;
+		const worker = {
+			child: proven.child,
+			binding: proven.binding,
+			selection,
+			directory,
+			close: () => proven.close(),
+			pending: void 0,
+			idle: void 0,
+			closing: void 0
+		};
+		this.#read(worker);
+		if (generation !== this.#generation || stopping.aborted || signal.aborted) {
+			await this.#kill(worker, "laya-stopped");
+			return refusedBefore(signal.aborted ? "laya-purged" : "laya-stopped");
+		}
+		if (!sameSelection(this.#artifacts.workerSelection(), selection)) {
+			await this.#kill(worker, "laya-authority-changed");
+			return refusedBefore("laya-authority-changed");
+		}
+		const loaded = this.#expect(worker, this.#loadDeadlineMs, signal, stopping, (frame) => loadFrame(frame, worker.binding));
+		try {
+			await proven.sendLoad({
+				runtimeRoot: verified.runtimeRoot,
+				modelDir: verified.modelRoot
+			});
+		} catch {
+			loaded.cancel();
+			await this.#kill(worker, "laya-crashed");
+			return refusedBefore("laya-crashed");
+		}
+		const outcome = await loaded.settled;
+		if ("gone" in outcome || outcome.value !== "loaded") {
+			const gone = "gone" in outcome ? outcome.gone : "runtime-failed";
+			await this.#kill(worker, gone);
+			if (gone === "laya-purged" || gone === "laya-stopped") return refusedBefore(gone);
+			this.#artifacts.recordWorkerFailure(selection, "runtime-failed");
+			return refusedBefore("runtime-failed");
+		}
+		if (generation !== this.#generation || stopping.aborted) {
+			await this.#kill(worker, "laya-stopped");
+			return refusedBefore("laya-stopped");
+		}
+		this.#worker = worker;
+		return { worker };
+	}
+	/** Attaches the child's one stdout reader. A proven child's stdout is paused, and stays paused until resumed. */
+	#read(worker) {
+		const parser = new WorkerFrameParser();
+		worker.child.stdout.on("data", (chunk) => {
+			let frames;
+			try {
+				frames = parser.push(chunk);
+			} catch {
+				this.#kill(worker, "laya-malformed");
+				return;
+			}
+			for (const frame of frames) {
+				const pending = worker.pending;
+				if (pending === void 0) {
+					this.#kill(worker, "laya-malformed");
+					return;
+				}
+				pending.frame(frame);
+			}
+		});
+		worker.child.once("exit", () => void this.#kill(worker, "laya-crashed"));
+		worker.child.stdout.resume();
+		if (worker.child.exitCode !== null || worker.child.signalCode !== null) this.#kill(worker, "laya-crashed");
+	}
+	/**
+	* Waits for exactly one expected frame within a deadline. Any other frame, the child's end, the deadline, a purge of
+	* the waiting request or a stop settles it as gone; `cancel` withdraws it when nothing was written.
+	*/
+	#expect(worker, deadlineMs, signal, stopping, accept) {
+		let resolve = () => void 0;
+		const settled = new Promise((done) => {
+			resolve = done;
+		});
+		let done = false;
+		const onPurge = () => finish({ gone: "laya-purged" });
+		const onStop = () => finish({ gone: "laya-stopped" });
+		const timer = setTimeout(() => finish({ gone: "laya-timeout" }), deadlineMs);
+		const pending = {
+			frame: (frame) => {
+				const value = accept(frame);
+				finish(value === null ? { gone: "laya-malformed" } : { value });
+			},
+			gone: (code) => finish({ gone: code })
+		};
+		function withdraw() {
+			if (done) return false;
+			done = true;
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onPurge);
+			stopping.removeEventListener("abort", onStop);
+			if (worker.pending === pending) worker.pending = void 0;
+			return true;
+		}
+		function finish(result) {
+			if (withdraw()) resolve(result);
+		}
+		worker.pending = pending;
+		signal.addEventListener("abort", onPurge, { once: true });
+		stopping.addEventListener("abort", onStop, { once: true });
+		if (signal.aborted) onPurge();
+		if (stopping.aborted) onStop();
+		if (worker.closing !== void 0) finish({ gone: "laya-crashed" });
+		return {
+			settled,
+			cancel: () => void withdraw()
+		};
+	}
+	#clearIdle(worker) {
+		if (worker.idle !== void 0) clearTimeout(worker.idle);
+		worker.idle = void 0;
+	}
+	#armIdle(worker) {
+		this.#clearIdle(worker);
+		worker.idle = setTimeout(() => {
+			if (worker.pending === void 0) this.#kill(worker, "laya-stopped");
+		}, this.#idleExitMs);
+	}
+	/**
+	* SIGKILL, wait, and remove the worker's owner-only directory. Whatever was waiting learns why first, and the child's
+	* reader is detached, so no frame is read from a killed worker.
+	*/
+	#kill(worker, reason) {
+		worker.closing ??= (async () => {
+			if (this.#worker === worker) this.#worker = void 0;
+			this.#clearIdle(worker);
+			worker.child.stdout.removeAllListeners("data");
+			const pending = worker.pending;
+			worker.pending = void 0;
+			pending?.gone(reason);
+			await worker.close().catch(() => void 0);
+			await rm(worker.directory, {
+				recursive: true,
+				force: true
+			}).catch(() => void 0);
+		})();
+		return worker.closing;
+	}
+};
+/** One owner composes one Laya executor per database, as it does E's purge listener; a test composes its own. */
+const executors = /* @__PURE__ */ new WeakMap();
+function registerLayaJudgeExecutor(database, executor) {
+	if (executors.has(database)) throw new Error("a Laya judge executor is already registered");
+	executors.set(database, executor);
+	return () => {
+		if (executors.get(database) === executor) executors.delete(database);
+	};
+}
+/** The executor E's coordinator and judge test reach a Laya judge through; none means Laya cannot run here. */
+function layaJudgeExecutorFor(database) {
+	return executors.get(database);
+}
 //#endregion
 //#region src/runtime/judge-test.ts
 const TEST_ACCOUNT_ID = "synthetic-judge-test";
@@ -16020,6 +16752,29 @@ function activeRuleAuthority(database, judgeId, version) {
 	}
 	throw new JudgeBudgetError("JUDGE_AUTHORITY_CHANGED", "no active rule grants this exact judge test");
 }
+/**
+* A live Laya judge version where this release or platform does not offer Laya: Laya's own closed reason (the
+* placeholder lock's `E2_EXTERNAL_REFERENCE_BLOCKED`, or the platform's or the sandbox's), read from the database's
+* own Laya inputs as a rule naming one is (E2 Task 10a). Undefined for any other judge, and wherever Laya is offered.
+*/
+function unofferedLayaJudge(database, input) {
+	const row = database.prepare("SELECT document FROM judge_versions WHERE judge_id = ? AND version = ? AND revoked_at IS NULL").get(input.judgeId, input.version);
+	if (row === void 0) return void 0;
+	let kind;
+	try {
+		kind = JSON.parse(row.document).kind;
+	} catch {
+		return;
+	}
+	if (kind !== "laya") return void 0;
+	try {
+		assertLayaJudgeKindAvailable(layaEnablementInputsFor(database));
+		return;
+	} catch (error) {
+		if (error instanceof EventDomainError) return error.code;
+		throw error;
+	}
+}
 function switchGeneration(database) {
 	return database.prepare("SELECT switch_generation FROM event_settings WHERE singleton = 1").get()?.switch_generation ?? 0;
 }
@@ -16052,6 +16807,13 @@ var JudgeTestControl = class {
 	}
 	async test(input) {
 		if (typeof input.judgeId !== "string" || input.judgeId.length === 0 || !Number.isSafeInteger(input.version) || input.version < 1) throw new CommsError("USAGE", "judge test needs one exact judge id and positive version");
+		const unoffered = unofferedLayaJudge(this.#store.database, input);
+		if (unoffered !== void 0) return {
+			kind: "refused",
+			judgeId: input.judgeId,
+			version: input.version,
+			code: unoffered
+		};
 		let authority;
 		try {
 			authority = activeRuleAuthority(this.#store.database, input.judgeId, input.version);
@@ -16078,6 +16840,7 @@ var JudgeTestControl = class {
 				handles: []
 			}
 		});
+		if (authority.judge.kind === "laya") return this.#testLaya(input, authority, authority.judge);
 		let hostedApiKey;
 		if (authority.judge.kind === "typesafe") {
 			const key = await this.#hostedApiKeyFor({
@@ -16111,43 +16874,9 @@ var JudgeTestControl = class {
 				code: prepared.code
 			};
 		}
-		const reservationId = this.#newId();
 		let reservation;
 		try {
-			reservation = reserveJudgeTest({
-				store: this.#store,
-				id: reservationId,
-				workId: `judge-test:${reservationId}`,
-				testWorkId: `judge-test:${reservationId}`,
-				judge: authority.judge,
-				finalEnvelope: prepared.request,
-				switchGeneration: switchGeneration(this.#store.database),
-				now: this.#now(),
-				authority: {
-					ruleId: authority.ruleId,
-					ruleVersion: authority.ruleVersion,
-					..."activationId" in authority ? {
-						activationId: authority.activationId,
-						approval: authority.challenge
-					} : {}
-				},
-				assertAuthority: (database) => {
-					if ("activationId" in authority) {
-						const current = assertPendingRuleJudgeTestAuthority({
-							database,
-							activationId: authority.activationId,
-							ruleId: authority.ruleId,
-							ruleVersion: authority.ruleVersion,
-							judgeId: input.judgeId,
-							judgeVersion: input.version
-						});
-						if (current.question !== authority.question || current.maxInputTokens !== authority.maxInputTokens || current.maxOutputTokens !== authority.maxOutputTokens) throw new JudgeBudgetError("JUDGE_AUTHORITY_CHANGED", "the pending rule authority changed before judge test admission");
-						return;
-					}
-					const current = activeRuleAuthority(database, input.judgeId, input.version);
-					if (current.ruleId !== authority.ruleId || current.ruleVersion !== authority.ruleVersion) throw new JudgeBudgetError("JUDGE_AUTHORITY_CHANGED", "the active rule authority changed before judge test admission");
-				}
-			});
+			reservation = this.#reserve(input, authority, prepared.request);
 		} catch (error) {
 			return refusal(input.judgeId, input.version, error);
 		}
@@ -16198,13 +16927,2183 @@ var JudgeTestControl = class {
 			reservationId: reservation.id
 		};
 	}
-};
-//#endregion
-//#region src/runtime/lifecycle.ts
-var EventLifecycle = class {
-	store;
-	now;
-	constructor(store, now = Date.now) {
+	/** The one synthetic-test admission: the active singleton's global ceilings and this judge version's test charge. */
+	#reserve(input, authority, finalEnvelope) {
+		const reservationId = this.#newId();
+		return reserveJudgeTest({
+			store: this.#store,
+			id: reservationId,
+			workId: `judge-test:${reservationId}`,
+			testWorkId: `judge-test:${reservationId}`,
+			judge: authority.judge,
+			finalEnvelope,
+			switchGeneration: switchGeneration(this.#store.database),
+			now: this.#now(),
+			authority: {
+				ruleId: authority.ruleId,
+				ruleVersion: authority.ruleVersion,
+				..."activationId" in authority ? {
+					activationId: authority.activationId,
+					approval: authority.challenge
+				} : {}
+			},
+			assertAuthority: (database) => {
+				if ("activationId" in authority) {
+					const current = assertPendingRuleJudgeTestAuthority({
+						database,
+						activationId: authority.activationId,
+						ruleId: authority.ruleId,
+						ruleVersion: authority.ruleVersion,
+						judgeId: input.judgeId,
+						judgeVersion: input.version
+					});
+					if (current.question !== authority.question || current.maxInputTokens !== authority.maxInputTokens || current.maxOutputTokens !== authority.maxOutputTokens) throw new JudgeBudgetError("JUDGE_AUTHORITY_CHANGED", "the pending rule authority changed before judge test admission");
+					return;
+				}
+				const current = activeRuleAuthority(database, input.judgeId, input.version);
+				if (current.ruleId !== authority.ruleId || current.ruleVersion !== authority.ruleVersion) throw new JudgeBudgetError("JUDGE_AUTHORITY_CHANGED", "the active rule authority changed before judge test admission");
+			}
+		});
+	}
+	async #testLaya(input, authority, judge) {
+		const executor = layaJudgeExecutorFor(this.#store.database);
+		if (executor === void 0) return {
+			kind: "refused",
+			judgeId: input.judgeId,
+			version: input.version,
+			code: "ADAPTER_REFERENCE_BLOCKED"
+		};
+		const syntheticState = canonicalJson(TEST_CLOUD_EVENT);
+		const laya = executor.prepare({
+			judge,
+			state: syntheticState,
+			instructions: authority.question
+		});
+		if (!laya.ok) return {
+			kind: "refused",
+			judgeId: input.judgeId,
+			version: input.version,
+			code: laya.code
+		};
+		let reservation;
+		try {
+			reservation = this.#reserve(input, authority, laya.request.body);
+		} catch (error) {
+			return refusal(input.judgeId, input.version, error);
+		}
+		const ioGate = new JudgeReservationIoGate({
+			store: this.#store,
+			reservationId: reservation.id,
+			judgeKind: judge.kind,
+			now: this.#now
+		});
+		const result = await executor.execute(laya.request, {
+			reservationId: reservation.id,
+			finalGate: () => ioGate.finalGate("write")
+		});
+		if (result.kind === "answer") {
+			settleJudgeWork({
+				store: this.#store,
+				reservationId: reservation.id,
+				result: "completed",
+				actualInputTokens: result.inputTokens,
+				now: this.#now()
+			});
+			return {
+				kind: "completed",
+				judgeId: input.judgeId,
+				version: input.version,
+				value: result.value,
+				valueLabel: "probability",
+				reservationId: reservation.id
+			};
+		}
+		finalizeJudgeTransportRefusal({
+			store: this.#store,
+			reservationId: reservation.id,
+			result: result.code === "laya-timeout" ? "timeout" : "transport-failure",
+			now: this.#now()
+		});
+		if (ioGate.firstGateError !== void 0) return refusal(input.judgeId, input.version, ioGate.firstGateError);
+		if (result.preIo) return {
+			kind: "refused",
+			judgeId: input.judgeId,
+			version: input.version,
+			code: result.code
+		};
+		return {
+			kind: "deferred",
+			judgeId: input.judgeId,
+			version: input.version,
+			code: result.code,
+			reservationId: reservation.id
+		};
+	}
+};
+//#endregion
+//#region src/runtime/laya/artifact-paths.ts
+var LayaArtifactPathError = class extends Error {
+	code = "ARTIFACT_PATH";
+	constructor() {
+		super("Laya artifact path is outside the reviewed artifact tree");
+		this.name = "LayaArtifactPathError";
+	}
+};
+function safeSegment(value) {
+	return /^[a-z0-9][a-z0-9._-]*$/i.test(value) && value !== "." && value !== "..";
+}
+function safeRelativePath(value) {
+	return value.length > 0 && !value.includes("\\") && !value.includes("\0") && !/[\uD800-\uDFFF]/u.test(value) && value.normalize("NFC") === value && value.split("/").every(safeSegment);
+}
+function below(root, target) {
+	const resolvedRoot = resolve(root);
+	const resolvedTarget = resolve(target);
+	if (!resolvedTarget.startsWith(`${resolvedRoot}${sep}`)) throw new LayaArtifactPathError();
+	return resolvedTarget;
+}
+/** Derives owner-controlled locations only from the reviewed manifest identity and file list. */
+function layaModelArtifactPaths(dataDirectory, manifestId) {
+	if (!safeSegment(manifestId)) throw new LayaArtifactPathError();
+	const models = below(dataDirectory, join(dataDirectory, "models"));
+	const partial = below(models, join(models, `${manifestId}.partial`));
+	const complete = below(models, join(models, manifestId));
+	return {
+		models,
+		partial,
+		complete,
+		file(file, state) {
+			if (!safeRelativePath(file.path)) throw new LayaArtifactPathError();
+			return below(state === "partial" ? partial : complete, join(state === "partial" ? partial : complete, file.path));
+		}
+	};
+}
+//#endregion
+//#region src/runtime/laya/fetcher.ts
+const MAX_REDIRECTS = 5;
+const MAX_RESPONSE_HEADER_BYTES = 16384;
+const DEFAULT_IDLE_TIMEOUT_MS = 3e4;
+const DEFAULT_TOTAL_TIMEOUT_MS = 18e5;
+const USER_AGENT = "agentcomms-events/0.15.2";
+const REDIRECT_STATUSES = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+var LayaFetchError = class extends Error {
+	code;
+	constructor(code) {
+		super(`Laya artifact download refused: ${code}`);
+		this.name = "LayaFetchError";
+		this.code = code;
+	}
+};
+function exactLowercaseHex(value, length) {
+	return new RegExp(`^[a-f0-9]{${length}}$`).test(value);
+}
+function responseHeaderLimit(value) {
+	const limit = value ?? MAX_RESPONSE_HEADER_BYTES;
+	if (!Number.isSafeInteger(limit) || limit < 1) throw new LayaFetchError("RESPONSE_HEADERS");
+	return limit;
+}
+function fetchDeadline(value, fallback) {
+	const deadline = value ?? fallback;
+	if (!Number.isSafeInteger(deadline) || deadline < 1) throw new LayaFetchError("HTTP_RESPONSE");
+	return deadline;
+}
+function parseResponse(bytes, headerLimit) {
+	const boundary = bytes.indexOf("\r\n\r\n", 0, "latin1");
+	if (boundary < 0 || boundary + 4 > headerLimit) throw new LayaFetchError("RESPONSE_HEADERS");
+	const lines = bytes.subarray(0, boundary).toString("latin1").split("\r\n");
+	const status = /^HTTP\/1\.[01] ([0-9]{3}) [^\r\n]*$/u.exec(lines[0] ?? "");
+	if (status?.[1] === void 0) throw new LayaFetchError("HTTP_RESPONSE");
+	const headers = /* @__PURE__ */ new Map();
+	for (const line of lines.slice(1)) {
+		const separator = line.indexOf(":");
+		if (separator < 1) throw new LayaFetchError("RESPONSE_HEADERS");
+		const name = line.slice(0, separator).toLowerCase();
+		const value = line.slice(separator + 1).trim();
+		if (headers.has(name) || /[\r\n]/u.test(value)) throw new LayaFetchError("RESPONSE_HEADERS");
+		headers.set(name, value);
+	}
+	return {
+		status: Number(status[1]),
+		headers,
+		body: bytes.subarray(boundary + 4)
+	};
+}
+function contentLength(response) {
+	const value = response.headers.get("content-length");
+	if (value === void 0) return null;
+	if (!/^(?:0|[1-9]\d*)$/u.test(value)) throw new LayaFetchError("RESPONSE_HEADERS");
+	const length = Number(value);
+	if (!Number.isSafeInteger(length)) throw new LayaFetchError("RESPONSE_HEADERS");
+	return length;
+}
+function exactSriSha512(value) {
+	const matched = /^sha512-([A-Za-z0-9+/]{86}==)$/.exec(value);
+	if (matched?.[1] === void 0) throw new LayaFetchError("RUNTIME_INTEGRITY");
+	const decoded = Buffer.from(matched[1], "base64");
+	if (decoded.length !== 64 || decoded.toString("base64") !== matched[1]) throw new LayaFetchError("RUNTIME_INTEGRITY");
+	return decoded;
+}
+function isExactRegistryTarballUrl(source) {
+	if (!/^(?:@[-a-z0-9]+\/)?[-a-z0-9]+$/iu.test(source.name)) return false;
+	if (!/^[0-9A-Za-z][0-9A-Za-z.+-]*$/u.test(source.version)) return false;
+	const basename = source.name.slice(source.name.lastIndexOf("/") + 1);
+	return source.url === `https://registry.npmjs.org/${source.name}/-/${basename}-${source.version}.tgz`;
+}
+function throwIfAborted(signal) {
+	if (!signal.aborted) return;
+	if (signal.reason instanceof LayaFetchError) throw signal.reason;
+	throw new LayaFetchError("ABORTED");
+}
+/** One request-wide lifetime: total time starts before the first DNS query and never resets on redirects. */
+var FetchDeadline = class {
+	#controller = new AbortController();
+	#expiresAt;
+	#onCallerAbort;
+	#timer;
+	signal = this.#controller.signal;
+	constructor(callerSignal, totalTimeoutMs) {
+		this.#expiresAt = Date.now() + totalTimeoutMs;
+		this.#onCallerAbort = () => this.#abort(new LayaFetchError("ABORTED"));
+		if (callerSignal.aborted) this.#onCallerAbort();
+		else callerSignal.addEventListener("abort", this.#onCallerAbort, { once: true });
+		this.#timer = setTimeout(() => this.#abort(new LayaFetchError("TOTAL_TIMEOUT")), totalTimeoutMs);
+		this.#callerSignal = callerSignal;
+	}
+	#callerSignal;
+	remainingMs() {
+		throwIfAborted(this.signal);
+		return Math.max(1, this.#expiresAt - Date.now());
+	}
+	dispose() {
+		clearTimeout(this.#timer);
+		this.#callerSignal.removeEventListener("abort", this.#onCallerAbort);
+	}
+	#abort(reason) {
+		if (!this.signal.aborted) this.#controller.abort(reason);
+	}
+};
+function mapPinnedResponseError(error) {
+	if (error instanceof PinnedResponseError) {
+		if (error.code === "NETWORK_ABORTED") throw new LayaFetchError("ABORTED");
+		if (error.code === "NETWORK_IDLE_TIMEOUT") throw new LayaFetchError("IDLE_TIMEOUT");
+		if (error.code === "NETWORK_TOTAL_TIMEOUT") throw new LayaFetchError("TOTAL_TIMEOUT");
+	}
+	throw error;
+}
+function safeManifestPath(value) {
+	return value.length > 0 && !value.includes("\\") && !value.includes("\0") && !/[\uD800-\uDFFF]/u.test(value) && value.normalize("NFC") === value && value.split("/").every((part) => /^[a-z0-9][a-z0-9._-]*$/iu.test(part) && part !== "." && part !== "..");
+}
+function modelUrl(manifest, file) {
+	if (manifest.source.host !== "huggingface.co") throw new LayaFetchError("HTTP_RESPONSE");
+	if (!/^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*$/iu.test(manifest.source.repo)) throw new LayaFetchError("HTTP_RESPONSE");
+	if (!exactLowercaseHex(manifest.source.revision, 40) || !safeManifestPath(file.path)) throw new LayaFetchError("HTTP_RESPONSE");
+	return new URL(`https://${manifest.source.host}/${manifest.source.repo}/resolve/${manifest.source.revision}/${file.path}`);
+}
+/** Rejects every optional request header before any pinned DNS/TCP/TLS activity begins. */
+function assertLayaRequestHeaders(headers) {
+	const allowed = /* @__PURE__ */ new Set(["range", "user-agent"]);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [rawName, value] of Object.entries(headers)) {
+		const name = rawName.toLowerCase();
+		if (!allowed.has(name)) throw new LayaFetchError("REQUEST_HEADER");
+		if (seen.has(name)) throw new LayaFetchError("REQUEST_HEADER");
+		seen.add(name);
+		if (name === "user-agent" && value !== USER_AGENT) throw new LayaFetchError("REQUEST_HEADER");
+		if (name === "range" && !/^bytes=[1-9]\d*-$/.test(value)) throw new LayaFetchError("REQUEST_HEADER");
+	}
+}
+function expectedContentRange(value, start, size, received) {
+	if (value === void 0) throw new LayaFetchError("CONTENT_RANGE");
+	const matched = /^bytes (\d+)-(\d+)\/(\d+)$/u.exec(value);
+	if (matched === null) throw new LayaFetchError("CONTENT_RANGE");
+	const [, returnedStart, returnedEnd, total] = matched;
+	if (Number(returnedStart) !== start || Number(total) !== size || Number(returnedEnd) !== start + received - 1 || received < 1 || start + received > size) throw new LayaFetchError("CONTENT_RANGE");
+}
+/** Fixed-purpose raw artifact reader: it owns no proxy, agent, HTTP client, or loopback exception. */
+var LayaArtifactFetcher = class {
+	manifest;
+	#runtimePackages;
+	#resolver;
+	#tcpConnect;
+	#tlsConnect;
+	#headerLimit;
+	#idleTimeoutMs;
+	#totalTimeoutMs;
+	constructor(options) {
+		this.manifest = options.manifest;
+		this.#runtimePackages = options.runtimePackages;
+		this.#resolver = options.resolver;
+		this.#tcpConnect = options.tcpConnect ?? connectPinnedTcp;
+		this.#tlsConnect = options.tlsConnect ?? connectPinnedTls;
+		this.#headerLimit = responseHeaderLimit(options.maxResponseHeaderBytes);
+		this.#idleTimeoutMs = fetchDeadline(options.idleTimeoutMs, DEFAULT_IDLE_TIMEOUT_MS);
+		this.#totalTimeoutMs = fetchDeadline(options.totalTimeoutMs, DEFAULT_TOTAL_TIMEOUT_MS);
+	}
+	async fetchRuntimeArchive(input, options) {
+		const runtimePackage = this.#runtimePackages.find((candidate) => candidate.name === input.name && candidate.version === input.version);
+		if (runtimePackage === void 0) throw new LayaFetchError("RUNTIME_ORIGIN");
+		if (!isExactRegistryTarballUrl(runtimePackage)) throw new LayaFetchError("RUNTIME_ORIGIN");
+		const expected = exactSriSha512(runtimePackage.integrity);
+		const chunks = [];
+		const result = await this.#get(new URL(runtimePackage.url), void 0, 536870912, async (chunk) => {
+			chunks.push(Buffer.from(chunk));
+		}, options.signal, false);
+		const bytes = Buffer.concat(chunks);
+		if (result.status !== 200 || contentLength(result) !== null && contentLength(result) !== bytes.length) throw new LayaFetchError("HTTP_RESPONSE");
+		const actual = createHash("sha512").update(bytes).digest();
+		if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) throw new LayaFetchError("RUNTIME_INTEGRITY");
+		return bytes;
+	}
+	async fetchModelFile(file, resumeFrom, options) {
+		const chunks = [];
+		const result = await this.fetchModelFileTo(file, resumeFrom, async (chunk) => {
+			chunks.push(Buffer.from(chunk));
+		}, options);
+		return {
+			bytes: Buffer.concat(chunks),
+			url: result.url,
+			status: result.status,
+			headers: result.headers
+		};
+	}
+	async fetchModelFileTo(file, resumeFrom, onChunk, options) {
+		if (!Number.isSafeInteger(file.size) || file.size < 1 || !exactLowercaseHex(file.sha256, 64)) throw new LayaFetchError("HTTP_RESPONSE");
+		if (resumeFrom !== void 0 && (!Number.isSafeInteger(resumeFrom) || resumeFrom < 1 || resumeFrom >= file.size)) throw new LayaFetchError("CONTENT_RANGE");
+		const result = await this.#get(modelUrl(this.manifest, file), resumeFrom, file.size, onChunk, options.signal, true);
+		const declaredLength = contentLength(result);
+		if (declaredLength !== null && declaredLength !== result.bytesReceived) throw new LayaFetchError("RESPONSE_BODY");
+		if (resumeFrom === void 0) {
+			if (result.status !== 200 || result.bytesReceived !== file.size) throw new LayaFetchError("HTTP_RESPONSE");
+		} else {
+			if (result.status !== 206) throw new LayaFetchError("CONTENT_RANGE");
+			expectedContentRange(result.headers.get("content-range"), resumeFrom, file.size, result.bytesReceived);
+		}
+		return result;
+	}
+	async #globalApprovedAddresses(url, signal) {
+		const hostname = url.hostname.startsWith("[") && url.hostname.endsWith("]") ? url.hostname.slice(1, -1) : url.hostname;
+		let answers;
+		try {
+			answers = await resolveHost(hostname, this.#resolver, { signal });
+			const vetted = answers.map((answer) => assertAddressAllowed(answer, { addressMode: "global-only" }));
+			return [...new Set(vetted.map((answer) => answer.address))].sort((left, right) => left.localeCompare(right));
+		} catch (error) {
+			if (error instanceof AddressPolicyError) throw new LayaFetchError("ADDRESS");
+			throw error;
+		}
+	}
+	async #get(initial, resumeFrom, maximumBytes, onBody, signal, allowRedirects) {
+		let url = new URL(initial.href);
+		let redirects = 0;
+		const deadline = new FetchDeadline(signal, this.#totalTimeoutMs);
+		try {
+			while (true) {
+				throwIfAborted(deadline.signal);
+				if (url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.hash !== "") throw new LayaFetchError("REDIRECT");
+				const approvedAddressSet = await this.#waitForPhase(() => this.#globalApprovedAddresses(url, deadline.signal), deadline);
+				let connection;
+				try {
+					connection = await this.#waitForPhase(() => preparePinnedConnection({
+						url,
+						approvedAddressSet,
+						approvedAddressSetDigest: addressSetDigest(approvedAddressSet),
+						...this.#resolver === void 0 ? {} : { resolver: this.#resolver },
+						signal: deadline.signal
+					}), deadline);
+				} catch (error) {
+					if (error instanceof AddressPolicyError) throw new LayaFetchError("ADDRESS");
+					throw error;
+				}
+				const tcp = await this.#waitForPhase(() => this.#tcpConnect({
+					host: connection.address,
+					port: connection.port,
+					signal: deadline.signal
+				}), deadline, (late) => late.destroy());
+				let socket;
+				try {
+					socket = await this.#waitForPhase(() => this.#tlsConnect({
+						socket: tcp,
+						...connection.tls,
+						signal: deadline.signal
+					}), deadline, (late) => late.destroy());
+				} catch (error) {
+					tcp.destroy();
+					throw error;
+				}
+				const headers = { "User-Agent": USER_AGENT };
+				if (resumeFrom !== void 0) headers.Range = `bytes=${resumeFrom}-`;
+				assertLayaRequestHeaders(headers);
+				let header = Buffer.alloc(0);
+				let response;
+				let bytesReceived = 0;
+				const hash = createHash("sha256");
+				try {
+					await streamPinnedResponseTo(socket, getRequestBytesForPinnedConnection(connection, headers), {
+						maxBytes: maximumBytes + MAX_RESPONSE_HEADER_BYTES,
+						signal: deadline.signal,
+						idleTimeoutMs: this.#idleTimeoutMs,
+						totalTimeoutMs: deadline.remainingMs(),
+						onChunk: async (chunk) => {
+							let body = chunk;
+							if (response === void 0) {
+								header = Buffer.concat([header, chunk]);
+								const boundary = header.indexOf("\r\n\r\n", 0, "latin1");
+								if (boundary < 0) {
+									if (header.length > this.#headerLimit) throw new LayaFetchError("RESPONSE_HEADERS");
+									return;
+								}
+								response = parseResponse(header.subarray(0, boundary + 4), this.#headerLimit);
+								body = header.subarray(boundary + 4);
+								header = Buffer.alloc(0);
+							}
+							if (response === void 0 || REDIRECT_STATUSES.has(response.status) || body.length === 0) return;
+							bytesReceived += body.length;
+							if (bytesReceived > maximumBytes) throw new LayaFetchError("RESPONSE_BODY");
+							hash.update(body);
+							await onBody(body, deadline.signal);
+						}
+					});
+				} catch (error) {
+					mapPinnedResponseError(error);
+				}
+				if (response === void 0) throw new LayaFetchError("RESPONSE_HEADERS");
+				if (!REDIRECT_STATUSES.has(response.status)) return {
+					...response,
+					bytesReceived,
+					sha256: hash.digest("hex"),
+					url: url.href
+				};
+				if (!allowRedirects) throw new LayaFetchError("REDIRECT");
+				if (redirects >= MAX_REDIRECTS) throw new LayaFetchError("REDIRECT_LIMIT");
+				const location = response.headers.get("location");
+				if (location === void 0 || location.length === 0) throw new LayaFetchError("REDIRECT");
+				try {
+					url = new URL(location, url);
+				} catch {
+					throw new LayaFetchError("REDIRECT");
+				}
+				redirects += 1;
+			}
+		} finally {
+			deadline.dispose();
+		}
+	}
+	#waitForPhase(operation, deadline, destroyLate) {
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			const cleanup = () => deadline.signal.removeEventListener("abort", onAbort);
+			const fail = (error) => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				reject(error);
+			};
+			const onAbort = () => {
+				try {
+					throwIfAborted(deadline.signal);
+				} catch (error) {
+					fail(error instanceof Error ? error : new LayaFetchError("ABORTED"));
+				}
+			};
+			deadline.signal.addEventListener("abort", onAbort, { once: true });
+			if (deadline.signal.aborted) {
+				onAbort();
+				return;
+			}
+			Promise.resolve().then(() => {
+				throwIfAborted(deadline.signal);
+				return operation();
+			}).then((value) => {
+				if (settled || deadline.signal.aborted) {
+					destroyLate?.(value);
+					onAbort();
+					return;
+				}
+				settled = true;
+				cleanup();
+				resolve(value);
+			}, (error) => fail(error instanceof Error ? error : /* @__PURE__ */ new Error("pinned download phase failed")));
+		});
+	}
+};
+//#endregion
+//#region src/runtime/laya/model-downloader.ts
+const OWNER_ONLY_DIRECTORY_MODE$3 = 448;
+const OWNER_ONLY_FILE_MODE$1 = 384;
+const MAX_FILE_ATTEMPTS = 5;
+var LayaModelDownloadError = class extends Error {
+	code;
+	constructor(code) {
+		super(`Laya model download refused: ${code}`);
+		this.name = "LayaModelDownloadError";
+		this.code = code;
+	}
+};
+async function ownerOnlyDirectory$2(path) {
+	await mkdir(path, {
+		recursive: true,
+		mode: OWNER_ONLY_DIRECTORY_MODE$3
+	});
+	const info = await lstat(path);
+	if (!info.isDirectory() || info.isSymbolicLink()) throw new LayaModelDownloadError("MODEL_PATH");
+	await chmod(path, OWNER_ONLY_DIRECTORY_MODE$3);
+}
+async function missing(path) {
+	try {
+		await lstat(path);
+		return false;
+	} catch (error) {
+		if (error.code === "ENOENT") return true;
+		throw error;
+	}
+}
+function abortIfNeeded(signal) {
+	if (!signal.aborted) return;
+	if (signal.reason instanceof LayaFetchError) throw downloadErrorForFetch(signal.reason);
+	throw new LayaModelDownloadError("CANCELLED");
+}
+function awaitFenceWithSignal(wait, signal) {
+	return new Promise((resolve, reject) => {
+		const cleanup = () => signal.removeEventListener("abort", onAbort);
+		const onAbort = () => {
+			cleanup();
+			try {
+				abortIfNeeded(signal);
+			} catch (error) {
+				reject(error);
+			}
+		};
+		if (signal.aborted) {
+			wait.catch(() => void 0);
+			onAbort();
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+		wait.then(() => {
+			cleanup();
+			resolve();
+		}, (error) => {
+			cleanup();
+			reject(error);
+		});
+	});
+}
+function downloadErrorForFetch(error) {
+	if (error.code === "ABORTED") return new LayaModelDownloadError("CANCELLED");
+	if (error.code === "IDLE_TIMEOUT" || error.code === "TOTAL_TIMEOUT") return new LayaModelDownloadError("DEADLINE");
+	return new LayaModelDownloadError("DOWNLOAD_FAILED");
+}
+/**
+* A file's size and SHA-256, streamed one read at a time as the tree verifier does: the model's data file is 1.69 GB,
+* which a whole-file read would hold in memory at once (and Node refuses to read a file of 2 GiB or more whole).
+*/
+async function hashFile(path) {
+	const hash = createHash("sha256");
+	let size = 0;
+	for await (const chunk of createReadStream(path)) {
+		size += chunk.length;
+		hash.update(chunk);
+	}
+	return {
+		size,
+		sha256: hash.digest("hex")
+	};
+}
+async function partialSize(path) {
+	try {
+		const info = await lstat(path);
+		if (!info.isFile() || info.isSymbolicLink()) throw new LayaModelDownloadError("MODEL_PATH");
+		return info.size;
+	} catch (error) {
+		if (error.code === "ENOENT") return 0;
+		throw error;
+	}
+}
+async function verifyPartialFile(path, file, size) {
+	const actual = await hashFile(path);
+	if (actual.size !== size || size > file.size) throw new LayaModelDownloadError("DOWNLOAD_FAILED");
+	if (size === file.size && actual.sha256 !== file.sha256) throw new LayaModelDownloadError("DOWNLOAD_FAILED");
+}
+async function availableBytes$1(path) {
+	const stats = await statfs(path);
+	return Number(stats.bavail) * Number(stats.bsize);
+}
+/** Downloads only the reviewed complete manifest tree, keeping every incomplete byte under one partial root. */
+var LayaModelDownloader = class {
+	#dataDirectory;
+	#manifest;
+	#fetcher;
+	#fence;
+	constructor(options) {
+		if (options.fence === void 0) throw new LayaModelDownloadError("LIFECYCLE_FENCE");
+		this.#dataDirectory = options.dataDirectory;
+		this.#manifest = options.manifest;
+		this.#fetcher = options.fetcher;
+		this.#fence = options.fence;
+	}
+	async download(options) {
+		const paths = layaModelArtifactPaths(this.#dataDirectory, this.#manifest.manifestId);
+		try {
+			abortIfNeeded(options.signal);
+			await this.#assertCurrent("start", options.signal);
+			await ownerOnlyDirectory$2(paths.models);
+			if (!await missing(paths.complete)) throw new LayaModelDownloadError("MODEL_EXISTS");
+			await this.#assertCurrent("retry", options.signal);
+			await ownerOnlyDirectory$2(paths.partial);
+			const total = this.#manifest.files.reduce((sum, file) => sum + file.size, 0);
+			const free = await (options.freeBytes ?? (() => availableBytes$1(paths.models)))();
+			if (!Number.isSafeInteger(free) || free < Math.ceil(total * 1.1)) throw new LayaModelDownloadError("DISK_SPACE");
+			let verified = 0;
+			for (const file of this.#manifest.files) {
+				abortIfNeeded(options.signal);
+				await this.#assertCurrent("retry", options.signal);
+				verified += await this.#downloadFile(paths.file(file, "partial"), file, options.signal);
+			}
+			abortIfNeeded(options.signal);
+			if (!await missing(paths.complete)) throw new LayaModelDownloadError("MODEL_EXISTS");
+			return this.#fence.withArtifactLock(async () => {
+				abortIfNeeded(options.signal);
+				if (!await missing(paths.complete)) throw new LayaModelDownloadError("MODEL_EXISTS");
+				await this.#assertCurrent("promotion", options.signal);
+				await rename(paths.partial, paths.complete);
+				return {
+					root: paths.complete,
+					bytesVerified: verified
+				};
+			});
+		} catch (error) {
+			await rm(paths.partial, {
+				recursive: true,
+				force: true
+			});
+			if (error instanceof LayaModelDownloadError) throw error;
+			if (error instanceof LayaFetchError) throw downloadErrorForFetch(error);
+			throw error;
+		}
+	}
+	async cleanupPartial() {
+		const paths = layaModelArtifactPaths(this.#dataDirectory, this.#manifest.manifestId);
+		await rm(paths.partial, {
+			recursive: true,
+			force: true
+		});
+	}
+	async #assertCurrent(stage, signal) {
+		await awaitFenceWithSignal(this.#fence.assertCurrent(stage, signal), signal);
+	}
+	async #downloadFile(path, file, signal) {
+		await this.#assertCurrent("retry", signal);
+		await ownerOnlyDirectory$2(dirname(path));
+		for (let attempt = 0; attempt < MAX_FILE_ATTEMPTS; attempt += 1) {
+			abortIfNeeded(signal);
+			let current = await partialSize(path);
+			if (current > 0) try {
+				await verifyPartialFile(path, file, current);
+			} catch {
+				await rm(path, { force: true });
+				current = 0;
+			}
+			try {
+				let wrote = false;
+				await this.#fetcher.fetchModelFileTo(file, current === 0 ? void 0 : current, async (chunk, fetchSignal) => {
+					abortIfNeeded(fetchSignal);
+					await this.#assertCurrent("retry", fetchSignal);
+					abortIfNeeded(fetchSignal);
+					if (current === 0 && !wrote) await writeFile(path, chunk, {
+						mode: OWNER_ONLY_FILE_MODE$1,
+						flag: "wx"
+					});
+					else await appendFile(path, chunk, { mode: OWNER_ONLY_FILE_MODE$1 });
+					abortIfNeeded(fetchSignal);
+					wrote = true;
+				}, { signal });
+				abortIfNeeded(signal);
+				await this.#assertCurrent("retry", signal);
+				await chmod(path, OWNER_ONLY_FILE_MODE$1);
+				const final = await hashFile(path);
+				await this.#assertCurrent("retry", signal);
+				if (final.size !== file.size || final.sha256 !== file.sha256) throw new LayaModelDownloadError("DOWNLOAD_FAILED");
+				return final.size;
+			} catch (error) {
+				await rm(path, { force: true });
+				if (error instanceof LayaFetchError) {
+					const terminal = downloadErrorForFetch(error);
+					if (terminal.code === "CANCELLED" || terminal.code === "DEADLINE") throw terminal;
+				}
+				if (error instanceof LayaModelDownloadError && (error.code === "CANCELLED" || error.code === "DEADLINE")) throw error;
+				if (attempt + 1 === MAX_FILE_ATTEMPTS) {
+					if (error instanceof LayaModelDownloadError) throw error;
+					if (error instanceof LayaFetchError) throw downloadErrorForFetch(error);
+					throw new LayaModelDownloadError("DOWNLOAD_FAILED");
+				}
+			}
+		}
+		throw new LayaModelDownloadError("DOWNLOAD_FAILED");
+	}
+};
+//#endregion
+//#region src/runtime/laya/tar.ts
+const BLOCK_SIZE = 512;
+const OWNER_ONLY_DIRECTORY_MODE$2 = 448;
+const OWNER_ONLY_FILE_MODE = 384;
+const EXECUTABLE_FILE_MODE = 448;
+var LayaTarError = class extends Error {
+	code;
+	constructor(code) {
+		super(`Laya runtime archive refused: ${code}`);
+		this.name = "LayaTarError";
+		this.code = code;
+	}
+};
+var ByteReader = class {
+	#iterator;
+	#buffer = Buffer.alloc(0);
+	constructor(source) {
+		this.#iterator = source[Symbol.asyncIterator]();
+	}
+	async readExactly(size) {
+		while (this.#buffer.length < size) {
+			const next = await this.#iterator.next();
+			if (next.done) throw new LayaTarError("TAR_TRUNCATED");
+			this.#buffer = Buffer.concat([this.#buffer, Buffer.from(next.value)]);
+		}
+		const value = this.#buffer.subarray(0, size);
+		this.#buffer = this.#buffer.subarray(size);
+		return value;
+	}
+	async ensureEndIsZero() {
+		while (true) {
+			const next = await this.#iterator.next();
+			if (next.done) break;
+			this.#buffer = Buffer.concat([this.#buffer, Buffer.from(next.value)]);
+		}
+		if (this.#buffer.some((byte) => byte !== 0)) throw new LayaTarError("TAR_HEADER");
+	}
+};
+var TarBody = class {
+	#reader;
+	#remaining;
+	constructor(reader, size) {
+		this.#reader = reader;
+		this.#remaining = size;
+	}
+	async *chunks() {
+		while (this.#remaining > 0) {
+			const count = Math.min(this.#remaining, 65536);
+			const chunk = await this.#reader.readExactly(count);
+			this.#remaining -= chunk.length;
+			yield chunk;
+		}
+	}
+	async drain() {
+		for await (const _chunk of this.chunks());
+	}
+};
+function isRegularFile(type) {
+	return type === 0 || type === "0".charCodeAt(0);
+}
+function isSafeRelativePath(path) {
+	return path.length > 0 && !path.startsWith("/") && !path.endsWith("/") && !path.includes("\\") && path.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+function textField(bytes) {
+	const firstNul = bytes.indexOf(0);
+	const textBytes = firstNul === -1 ? bytes : bytes.subarray(0, firstNul);
+	if (firstNul !== -1 && bytes.subarray(firstNul).some((byte) => byte !== 0)) throw new LayaTarError("TAR_PATH");
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(textBytes);
+	} catch {
+		throw new LayaTarError("TAR_PATH");
+	}
+}
+function strictOctalField(bytes) {
+	if (bytes.length < 2) throw new LayaTarError("TAR_HEADER");
+	if (bytes.every((byte) => byte === 0)) return 0;
+	const terminator = bytes[bytes.length - 1];
+	if (terminator !== 0 && terminator !== 32) throw new LayaTarError("TAR_HEADER");
+	let value = 0;
+	let sawDigit = false;
+	for (let index = 0; index < bytes.length - 1; index += 1) {
+		const byte = bytes[index] ?? 0;
+		if (byte === 32) {
+			if (sawDigit) throw new LayaTarError("TAR_HEADER");
+			continue;
+		}
+		if (byte < "0".charCodeAt(0) || byte > "7".charCodeAt(0)) throw new LayaTarError("TAR_HEADER");
+		const digit = byte - "0".charCodeAt(0);
+		if (value > Math.floor((Number.MAX_SAFE_INTEGER - digit) / 8)) throw new LayaTarError("TAR_HEADER");
+		value = value * 8 + digit;
+		sawDigit = true;
+	}
+	if (!sawDigit) throw new LayaTarError("TAR_HEADER");
+	return value;
+}
+function checksumField(bytes) {
+	if (bytes.length !== 8) throw new LayaTarError("TAR_CHECKSUM");
+	const standardLayout = bytes[6] === 0 && bytes[7] === 32;
+	const archiverLayout = bytes[7] === 0 || bytes[7] === 32;
+	if (!standardLayout && !archiverLayout) throw new LayaTarError("TAR_CHECKSUM");
+	return strictOctalField(bytes.subarray(0, standardLayout ? 7 : 8));
+}
+function numericHeaderFields(header) {
+	const mode = strictOctalField(header.subarray(100, 108));
+	strictOctalField(header.subarray(108, 116));
+	strictOctalField(header.subarray(116, 124));
+	const size = strictOctalField(header.subarray(124, 136));
+	strictOctalField(header.subarray(136, 148));
+	strictOctalField(header.subarray(329, 337));
+	strictOctalField(header.subarray(337, 345));
+	return {
+		mode,
+		size
+	};
+}
+function headerChecksum(header) {
+	let sum = 0;
+	for (let index = 0; index < header.length; index += 1) sum += index >= 148 && index < 156 ? 32 : header[index] ?? 0;
+	return sum;
+}
+function packagePathIdentity(path) {
+	if (path !== path.normalize("NFC")) throw new LayaTarError("TAR_PATH");
+	return path.toUpperCase().toLowerCase().normalize("NFC");
+}
+function recordPathIdentities(path, identities) {
+	const parts = path.split("/");
+	for (let index = 1; index <= parts.length; index += 1) {
+		const candidate = parts.slice(0, index).join("/");
+		const kind = index === parts.length ? "file" : "directory";
+		const identity = packagePathIdentity(candidate);
+		const previous = identities.get(identity);
+		if (previous === void 0) {
+			identities.set(identity, {
+				path: candidate,
+				kind
+			});
+			continue;
+		}
+		if (previous.path !== candidate || previous.kind !== kind) throw new LayaTarError("TAR_DUPLICATE");
+		if (kind === "file") throw new LayaTarError("TAR_DUPLICATE");
+	}
+}
+function parseEntry(header) {
+	if (!header.subarray(257, 263).equals(Buffer.from("ustar\0", "ascii")) || !header.subarray(263, 265).equals(Buffer.from("00"))) throw new LayaTarError("TAR_HEADER");
+	if (checksumField(header.subarray(148, 156)) !== headerChecksum(header)) throw new LayaTarError("TAR_CHECKSUM");
+	const numeric = numericHeaderFields(header);
+	if (!isRegularFile(header[156] ?? 0)) throw new LayaTarError("TAR_ENTRY_TYPE");
+	const prefix = textField(header.subarray(345, 500));
+	const name = textField(header.subarray(0, 100));
+	const path = prefix.length === 0 ? name : `${prefix}/${name}`;
+	if (path.includes("\\") || !isSafeRelativePath(path)) throw new LayaTarError("TAR_PATH");
+	if (!path.startsWith("package/")) throw new LayaTarError("TAR_PATH");
+	const relative = path.slice(8);
+	packagePathIdentity(relative);
+	return {
+		path: relative,
+		size: numeric.size,
+		executable: (numeric.mode & 73) !== 0
+	};
+}
+async function parseGzippedUstar(archive, onEntry) {
+	const reader = new ByteReader(Readable.from([archive]).pipe(createGunzip()));
+	const allPathIdentities = /* @__PURE__ */ new Map();
+	while (true) {
+		const header = await reader.readExactly(BLOCK_SIZE);
+		if (header.every((byte) => byte === 0)) {
+			if (!(await reader.readExactly(BLOCK_SIZE)).every((byte) => byte === 0)) throw new LayaTarError("TAR_HEADER");
+			await reader.ensureEndIsZero();
+			return;
+		}
+		const entry = parseEntry(header);
+		recordPathIdentities(entry.path, allPathIdentities);
+		const body = new TarBody(reader, entry.size);
+		await onEntry(entry, body);
+		await body.drain();
+		const padding = (BLOCK_SIZE - entry.size % BLOCK_SIZE) % BLOCK_SIZE;
+		if (padding > 0) await reader.readExactly(padding);
+	}
+}
+function expectedFiles$1(files) {
+	const result = /* @__PURE__ */ new Map();
+	const identities = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		if (!isSafeRelativePath(file.path) || !Number.isSafeInteger(file.size) || file.size < 0 || !/^[a-f0-9]{64}$/.test(file.sha256) || typeof file.executable !== "boolean") throw new LayaTarError("TAR_PATH");
+		recordPathIdentities(file.path, identities);
+		if (result.has(file.path)) throw new LayaTarError("TAR_DUPLICATE");
+		result.set(file.path, file);
+	}
+	return result;
+}
+/** Validates a complete runtime tree listing before it is used to create or inspect a filesystem tree. */
+function validateRuntimeTreeFiles(files) {
+	return expectedFiles$1(files);
+}
+async function archiveBytes(source) {
+	const chunks = [];
+	for await (const chunk of source) chunks.push(Buffer.from(chunk));
+	return Buffer.concat(chunks);
+}
+async function validateExpectedPackageArchive(archive, expectedByPath) {
+	const found = /* @__PURE__ */ new Set();
+	await parseGzippedUstar(archive, async (entry, body) => {
+		const expected = expectedByPath.get(entry.path);
+		if (expected === void 0) return;
+		if (entry.size !== expected.size) throw new LayaTarError("TAR_SIZE");
+		if (entry.executable !== expected.executable) throw new LayaTarError("TAR_EXECUTABLE");
+		const hash = createHash("sha256");
+		for await (const chunk of body.chunks()) hash.update(chunk);
+		if (hash.digest("hex") !== expected.sha256) throw new LayaTarError("TAR_HASH");
+		found.add(entry.path);
+	});
+	for (const path of expectedByPath.keys()) if (!found.has(path)) throw new LayaTarError("TAR_MISSING");
+}
+async function makeOwnerOnlyDirectory(path) {
+	await mkdir(path, {
+		recursive: true,
+		mode: OWNER_ONLY_DIRECTORY_MODE$2
+	});
+	await chmod(path, OWNER_ONLY_DIRECTORY_MODE$2);
+}
+async function writeAll(handle, bytes) {
+	let offset = 0;
+	while (offset < bytes.length) {
+		const { bytesWritten } = await handle.write(bytes, offset, bytes.length - offset);
+		if (bytesWritten === 0) throw new LayaTarError("TAR_TRUNCATED");
+		offset += bytesWritten;
+	}
+}
+async function assertAbsent$1(path) {
+	try {
+		await lstat(path);
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	throw new LayaTarError("TAR_PATH");
+}
+/** Extracts only expected files from a strict package archive into a caller-owned owner-only partial tree. */
+async function extractPackageArchive(options) {
+	const expectedByPath = expectedFiles$1(options.files);
+	const archive = await archiveBytes(options.source);
+	await validateExpectedPackageArchive(archive, expectedByPath);
+	const written = /* @__PURE__ */ new Set();
+	await makeOwnerOnlyDirectory(dirname(options.destination));
+	await assertAbsent$1(options.destination);
+	const staging = await mkdtemp(join(dirname(options.destination), `.${basename(options.destination)}.staging-`));
+	await chmod(staging, OWNER_ONLY_DIRECTORY_MODE$2);
+	let promoted = false;
+	try {
+		await parseGzippedUstar(archive, async (entry, body) => {
+			const expected = expectedByPath.get(entry.path);
+			if (expected === void 0) return;
+			if (entry.size !== expected.size) throw new LayaTarError("TAR_SIZE");
+			if (entry.executable !== expected.executable) throw new LayaTarError("TAR_EXECUTABLE");
+			const target = join(staging, entry.path);
+			await makeOwnerOnlyDirectory(dirname(target));
+			const handle = await open(target, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, OWNER_ONLY_FILE_MODE);
+			const hash = createHash("sha256");
+			try {
+				for await (const chunk of body.chunks()) {
+					hash.update(chunk);
+					await writeAll(handle, chunk);
+				}
+			} finally {
+				await handle.close();
+			}
+			if (hash.digest("hex") !== expected.sha256) {
+				await rm(target, { force: true });
+				throw new LayaTarError("TAR_HASH");
+			}
+			await chmod(target, expected.executable ? EXECUTABLE_FILE_MODE : OWNER_ONLY_FILE_MODE);
+			written.add(entry.path);
+		});
+		for (const path of expectedByPath.keys()) if (!written.has(path)) throw new LayaTarError("TAR_MISSING");
+		await assertAbsent$1(options.destination);
+		await rename(staging, options.destination);
+		promoted = true;
+	} finally {
+		if (!promoted) await rm(staging, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+//#region src/runtime/laya/tree-verifier.ts
+function expectedFiles(files) {
+	try {
+		return new Map(validateRuntimeTreeFiles(files));
+	} catch {
+		return null;
+	}
+}
+function expectedDirectories(expected) {
+	const directories = /* @__PURE__ */ new Set();
+	for (const path of expected.keys()) {
+		const parts = path.split("/");
+		for (let index = 1; index < parts.length; index += 1) directories.add(parts.slice(0, index).join("/"));
+	}
+	return directories;
+}
+async function sha256(path) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(path)) hash.update(chunk);
+	return hash.digest("hex");
+}
+async function verifyDirectory(root, relative, expected, directories) {
+	let entries;
+	try {
+		entries = await readdir(join(root, relative), {
+			encoding: "utf8",
+			withFileTypes: true
+		});
+	} catch {
+		return {
+			ok: false,
+			code: "TREE_IO"
+		};
+	}
+	entries.sort((left, right) => Buffer.compare(Buffer.from(left.name), Buffer.from(right.name)));
+	for (const entry of entries) {
+		const relativePath = relative.length === 0 ? entry.name : `${relative}/${entry.name}`;
+		let info;
+		try {
+			info = await lstat(join(root, relativePath));
+		} catch {
+			return {
+				ok: false,
+				code: "TREE_IO"
+			};
+		}
+		if (info.isDirectory()) {
+			if (!directories.has(relativePath)) return {
+				ok: false,
+				code: "TREE_EXTRA"
+			};
+			const child = await verifyDirectory(root, relativePath, expected, directories);
+			if (!child.ok) return child;
+			continue;
+		}
+		const expectedFile = expected.get(relativePath);
+		if (expectedFile === void 0) return {
+			ok: false,
+			code: "TREE_EXTRA"
+		};
+		if (!info.isFile()) return {
+			ok: false,
+			code: "TREE_TYPE"
+		};
+		if (info.size !== expectedFile.size) return {
+			ok: false,
+			code: "TREE_SIZE"
+		};
+		if ((info.mode & 73) !== 0 !== expectedFile.executable) return {
+			ok: false,
+			code: "TREE_EXECUTABLE"
+		};
+		let digest;
+		try {
+			digest = await sha256(join(root, relativePath));
+		} catch {
+			return {
+				ok: false,
+				code: "TREE_IO"
+			};
+		}
+		if (digest !== expectedFile.sha256) return {
+			ok: false,
+			code: "TREE_HASH"
+		};
+		expected.delete(relativePath);
+	}
+	return { ok: true };
+}
+/** Compares the complete selected runtime or model tree without following links or returning a path. */
+async function verifyRuntimeTree(options) {
+	const expected = expectedFiles(options.files);
+	if (expected === null) return {
+		ok: false,
+		code: "TREE_EXPECTED"
+	};
+	try {
+		const root = await lstat(options.root);
+		if (!root.isDirectory() || root.isSymbolicLink()) return {
+			ok: false,
+			code: "TREE_TYPE"
+		};
+	} catch {
+		return {
+			ok: false,
+			code: "TREE_MISSING"
+		};
+	}
+	const result = await verifyDirectory(options.root, "", expected, expectedDirectories(expected));
+	if (!result.ok) return result;
+	return expected.size === 0 ? { ok: true } : {
+		ok: false,
+		code: "TREE_MISSING"
+	};
+}
+//#endregion
+//#region src/runtime/laya/runtime-installer.ts
+const OWNER_ONLY_DIRECTORY_MODE$1 = 448;
+var LayaRuntimeInstallError = class extends Error {
+	code;
+	constructor(code) {
+		super(`Laya runtime installation refused: ${code}`);
+		this.name = "LayaRuntimeInstallError";
+		this.code = code;
+	}
+};
+function isSafePackageName(packageName) {
+	const parts = packageName.split("/");
+	return (parts.length === 1 || parts.length === 2 && parts[0] !== void 0 && parts[0].startsWith("@")) && parts.every((part) => /^[a-z0-9][a-z0-9._-]*$/i.test(part.replace(/^@/, "")) && part !== "." && part !== "..");
+}
+async function ownerOnlyDirectory$1(path) {
+	await mkdir(path, {
+		recursive: true,
+		mode: OWNER_ONLY_DIRECTORY_MODE$1
+	});
+	const info = await lstat(path);
+	if (!info.isDirectory() || info.isSymbolicLink()) throw new LayaRuntimeInstallError("RUNTIME_PATH");
+	await chmod(path, OWNER_ONLY_DIRECTORY_MODE$1);
+}
+async function assertAbsent(path) {
+	try {
+		await lstat(path);
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	throw new LayaRuntimeInstallError("RUNTIME_EXISTS");
+}
+function filesForPackage(packageName, files) {
+	const prefix = `node_modules/${packageName}/`;
+	const selected = [];
+	for (const file of files) {
+		if (file.packageName !== packageName || !file.path.startsWith(prefix)) {
+			if (file.packageName === packageName) throw new LayaRuntimeInstallError("RUNTIME_PATH");
+			continue;
+		}
+		selected.push({
+			...file,
+			path: file.path.slice(prefix.length)
+		});
+	}
+	return selected;
+}
+function validateInstallation(packages, files) {
+	const packageNames = /* @__PURE__ */ new Set();
+	for (const runtimePackage of packages) {
+		if (!isSafePackageName(runtimePackage.packageName) || packageNames.has(runtimePackage.packageName)) throw new LayaRuntimeInstallError("RUNTIME_PATH");
+		packageNames.add(runtimePackage.packageName);
+	}
+	for (const file of files) {
+		if (!packageNames.has(file.packageName)) throw new LayaRuntimeInstallError("RUNTIME_PATH");
+		if (!file.path.startsWith(`node_modules/${file.packageName}/`)) throw new LayaRuntimeInstallError("RUNTIME_PATH");
+	}
+}
+/** Installs a complete selected lock tree into an owner-only partial directory and atomically promotes it once. */
+async function installRuntime(options) {
+	if (!/^[a-f0-9]{64}$/.test(options.lockDigest)) throw new LayaRuntimeInstallError("RUNTIME_DIGEST");
+	validateInstallation(options.packages, options.files);
+	await ownerOnlyDirectory$1(options.runtimeDirectory);
+	const root = join(options.runtimeDirectory, options.lockDigest);
+	const partial = `${root}.partial`;
+	await assertAbsent(root);
+	await rm(partial, {
+		recursive: true,
+		force: true
+	});
+	await ownerOnlyDirectory$1(partial);
+	try {
+		for (const runtimePackage of options.packages) {
+			const files = filesForPackage(runtimePackage.packageName, options.files);
+			await extractPackageArchive({
+				source: runtimePackage.source,
+				destination: join(partial, "node_modules", runtimePackage.packageName),
+				files
+			});
+		}
+		if (!(await verifyRuntimeTree({
+			root: partial,
+			files: options.files
+		})).ok) throw new LayaRuntimeInstallError("RUNTIME_TREE");
+		await assertAbsent(root);
+		await rename(partial, root);
+		return { root };
+	} catch (error) {
+		await rm(partial, {
+			recursive: true,
+			force: true
+		});
+		if (error instanceof LayaTarError && error.code === "TAR_MISSING") throw new LayaRuntimeInstallError("RUNTIME_INCOMPLETE");
+		throw error;
+	}
+}
+//#endregion
+//#region src/runtime/laya/manager.ts
+const OWNER_ONLY_DIRECTORY_MODE = 448;
+/**
+* A content-free refusal a person or app can act on: its stable `details.reason` is `LAYA_ENABLED` (remove while the
+* kind is enabled) or `LAYA_NOT_READY` (a worker start before the kind is enabled); it names no path or content.
+*/
+function layaRefusal(reason, message) {
+	return new CommsError(reason === "LAYA_ENABLED" ? "USAGE" : "CONFIG", message, { details: { reason } });
+}
+/** A job or repair whose selection, pointer or epoch moved on: it stops without writing anything. */
+var ArtifactWorkStale = class extends Error {
+	constructor() {
+		super("the Laya artifact work no longer owns the active selection");
+		this.name = "ArtifactWorkStale";
+	}
+};
+/** A closed failure the job records for `doctor`, the app and `judge model status`. */
+var ArtifactFailure = class extends Error {
+	failureCode;
+	constructor(failureCode) {
+		super(`Laya artifact work failed: ${failureCode}`);
+		this.name = "ArtifactFailure";
+		this.failureCode = failureCode;
+	}
+};
+/** One FIFO lock: every artifact promotion, deletion, disable, removal and update tightening runs inside it. */
+var ArtifactMutex = class {
+	#tail = Promise.resolve();
+	run(work) {
+		const result = this.#tail.then(work, work);
+		this.#tail = result.then(() => void 0, () => void 0);
+		return result;
+	}
+};
+/** The selected platform's runtime files as the installer and verifier read them: rooted at `node_modules/`. */
+function runtimeFiles(selection) {
+	return selection.runtimeLock.platform.files.map((file) => ({
+		packageName: file.package,
+		path: `node_modules/${file.package}/${file.path}`,
+		size: file.size,
+		sha256: file.sha256,
+		executable: file.executable
+	}));
+}
+function modelFiles(selection) {
+	return selection.manifest.files.map((file) => ({
+		...file,
+		executable: false
+	}));
+}
+function bytesOf(files) {
+	return files.reduce((sum, file) => sum + file.size, 0);
+}
+function totalBytes(selection) {
+	return bytesOf(selection.manifest.files) + bytesOf(selection.runtimeLock.platform.files);
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+/**
+* D11's update rule over the complete approved entries: the enabled document must equal this release's document
+* byte for byte — its embedded manifest, its complete package list with every exact URL, version and SRI, and the
+* selected platform's complete file list, not merely a digest. A manifest difference is `model-changed`; any other
+* difference, a downgrade among them, is `runtime-changed`.
+*/
+function layaUpdateReason(stored, release) {
+	if (canonicalJson(stored) === canonicalJson(release)) return null;
+	return canonicalJson(record(stored)?.manifest ?? null) !== canonicalJson(release.manifest) ? "model-changed" : "runtime-changed";
+}
+async function isDirectory(path) {
+	try {
+		const info = await lstat(path);
+		return info.isDirectory() && !info.isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+async function ownerOnlyDirectory(path) {
+	await mkdir(path, {
+		recursive: true,
+		mode: OWNER_ONLY_DIRECTORY_MODE
+	});
+}
+async function availableBytes(path) {
+	const stats = await statfs(path);
+	return Number(stats.bavail) * Number(stats.bsize);
+}
+/** The production fetcher, counting each streamed model byte for status only after the downloader's sink took it. */
+var ProgressReportingArtifactFetcher = class extends LayaArtifactFetcher {
+	#progress;
+	constructor(options, progress) {
+		super(options);
+		this.#progress = progress;
+	}
+	async fetchModelFileTo(file, resumeFrom, onChunk, options) {
+		let received = resumeFrom ?? 0;
+		this.#progress.set(file.path, received);
+		return super.fetchModelFileTo(file, resumeFrom, async (chunk, signal) => {
+			await onChunk(chunk, signal);
+			received += chunk.length;
+			this.#progress.set(file.path, received);
+		}, options);
+	}
+};
+/** How long a failed availability probe stands before the next request that needs it probes again. */
+const AVAILABILITY_RETRY_MS = 6e4;
+/**
+* The one serial owner of Laya's installation-wide artifacts. E stays the sole authority: the active Laya
+* judge-kind pointer starts every job, every post-await step rechecks that exact pointer, its embedded document and
+* this manager's epoch, and E's disable, purge and update tightenings stop the work they orphan. Only content-free
+* D8 model state is persisted; trees live under `runtime/<lockDigest>` and `models/<manifestId>` and nowhere else.
+*/
+var LayaArtifactManager = class {
+	kind = JUDGE_KIND_LAYA;
+	#store;
+	#root;
+	#inputs;
+	#reviewed;
+	#network;
+	#freeBytes;
+	#audit;
+	#now;
+	#failpoint;
+	#models;
+	#mutex = new ArtifactMutex();
+	#tracked = /* @__PURE__ */ new Map();
+	#availability;
+	#availabilityProbedAt = 0;
+	/** Bumped by every disable, removal, update tightening and stop: a job captures it and stops once it moves. */
+	#epoch = 0;
+	#job;
+	#stopped = false;
+	#worker;
+	constructor(options) {
+		this.#store = options.store;
+		this.#root = options.artifactRoot;
+		this.#inputs = options.inputs ?? {};
+		this.#network = options.network ?? {};
+		this.#freeBytes = options.freeBytes;
+		this.#audit = options.audit;
+		this.#now = options.now ?? Date.now;
+		this.#failpoint = options.failpoint;
+		this.#models = new LayaModelRepository(options.store.database);
+	}
+	/**
+	* The reviewed definition, parsed on first use: an owner whose Laya is never asked about never reads its assets,
+	* so a start-up needs them only once a Laya pointer, status or operation does.
+	*/
+	get #definition() {
+		this.#reviewed ??= layaJudgeKindDefinitionFor(this.#inputs);
+		return this.#reviewed;
+	}
+	/**
+	* The content-free availability probe: a fact about this machine, never a document input. Only a success is kept for
+	* the owner's life (E2 review round 1, B7); after a failure the next request that needs it probes again, at most once
+	* a minute, so a sandbox that failed once is not taken as missing until the daemon restarts.
+	*/
+	availability() {
+		const now = this.#now();
+		if (this.#availability === void 0 || !this.#availability.available && now - this.#availabilityProbedAt >= AVAILABILITY_RETRY_MS) {
+			this.#availability = this.#definition.availability();
+			this.#availabilityProbedAt = now;
+		}
+		return this.#availability;
+	}
+	/**
+	* The judge-kind version a Laya enable prepares: the newest live version if it is exactly this release's reviewed
+	* document, otherwise a new immutable version of it. Unavailable refuses before any version, intent or file exists.
+	*/
+	enablementVersion() {
+		const availability = this.availability();
+		if (!availability.available) return unavailableResult(availability.code);
+		return this.#store.immediate(() => {
+			const latest = this.#store.database.prepare(`SELECT version, document FROM judge_kind_versions
+            WHERE kind = ? AND revoked_at IS NULL ORDER BY version DESC LIMIT 1`).get(JUDGE_KIND_LAYA);
+			if (latest !== void 0) {
+				const release = this.#definition.preview({ version: latest.version });
+				if (canonicalJson(JSON.parse(latest.document)) === canonicalJson(release)) return { version: latest.version };
+			}
+			const version = (this.#store.database.prepare("SELECT max(version) AS version FROM judge_kind_versions WHERE kind = ?").get("laya").version ?? 0) + 1;
+			new ImmutableVersions(this.#store.database, this.#inputs).createJudgeKind(this.#definition.prepareEnablement({ version }));
+			return { version };
+		});
+	}
+	/** E's kind-list entry: the real pointer state while Laya is offered, its closed reason while it is not. */
+	kindEntry() {
+		const active = this.#activeEnablement();
+		if (active !== null) return {
+			kind: JUDGE_KIND_LAYA,
+			state: "enabled",
+			version: active.version
+		};
+		const availability = this.availability();
+		if (!availability.available) return {
+			kind: JUDGE_KIND_LAYA,
+			state: "unavailable",
+			code: availability.code
+		};
+		return {
+			kind: JUDGE_KIND_LAYA,
+			state: "disabled",
+			version: null
+		};
+	}
+	/**
+	* Starts (or joins) the install for the active pointer. Before the enablement's claim there is no pointer, so this
+	* does nothing: no request, row, directory or file. It never rejects; a failure becomes closed model state.
+	*/
+	ensureInstalled() {
+		try {
+			return this.#ensureInstalled();
+		} catch {
+			return Promise.resolve();
+		}
+	}
+	#ensureInstalled() {
+		if (this.#stopped) return Promise.resolve();
+		const active = this.#activeEnablement();
+		if (active === null) return Promise.resolve();
+		const running = this.#job;
+		if (running !== void 0 && running.epoch === this.#epoch && running.version === active.version) return running.settled;
+		const selection = this.#selectionFor(active);
+		if (selection === null || !this.availability().available) return Promise.resolve();
+		const job = {
+			epoch: this.#epoch,
+			version: active.version,
+			digest: active.digest,
+			selection,
+			controller: new AbortController(),
+			phase: "installing",
+			runtimeBytes: 0,
+			modelProgress: /* @__PURE__ */ new Map(),
+			settled: Promise.resolve()
+		};
+		const previous = running?.settled ?? Promise.resolve();
+		this.#job = job;
+		job.settled = previous.then(() => this.#install(job)).finally(() => {
+			if (this.#job === job) this.#job = void 0;
+		});
+		return job.settled;
+	}
+	/** Start-up's resume: an approved, unfinished install continues; a ready or failed model waits for its person. */
+	async resume() {
+		const active = this.#activeEnablement();
+		if (active === null) return;
+		const selection = this.#selectionFor(active);
+		if (selection === null) return;
+		const row = this.#models.get(selection.manifest.manifestId);
+		if (row?.state === "ready" || row?.state === "failed") return;
+		await this.ensureInstalled();
+	}
+	/**
+	* E's immediate kind disable, wrapped: this manager's work is fenced and aborted first, E's whole disable
+	* transaction runs under the artifact lock (so no promotion can land between its last recheck and its rename), and
+	* then the partial and staging trees the disable orphaned are deleted. Verified trees survive.
+	*/
+	async disableKind(disable) {
+		const job = this.#fence();
+		const result = await this.#mutex.run(async () => {
+			const disabled = disable();
+			await this.#removeUnverified();
+			return disabled;
+		});
+		await job?.settled.catch(() => void 0);
+		await this.#worker?.stop();
+		return result;
+	}
+	/**
+	* D11's start-up update rule. While Laya is enabled, its approved document is compared with this release's; any
+	* difference applies E's kind-disable tightening with `model-changed` or `runtime-changed`, keeps verified trees,
+	* and never re-approves. The tightening rechecks that the compared pointer is still the active one.
+	*/
+	async reconcileRelease(disable) {
+		const compared = this.#activeEnablement();
+		if (compared === null) return null;
+		let release;
+		try {
+			release = this.#definition.preview({ version: compared.version });
+		} catch {
+			release = null;
+		}
+		const reason = release === null ? "runtime-changed" : layaUpdateReason(compared.document, release);
+		if (reason === null) return null;
+		const job = this.#fence();
+		const applied = await this.#locked("update-disable", async () => {
+			const live = this.#activeEnablement();
+			if (live === null || live.version !== compared.version || live.digest !== compared.digest) return false;
+			disable();
+			await this.#removeUnverified();
+			return true;
+		});
+		await job?.settled.catch(() => void 0);
+		if (!applied) return null;
+		await this.#worker?.stop();
+		await this.#audit?.append({
+			inboxId: "",
+			operation: "events.disableJudgeKind",
+			outcome: "ok",
+			reason,
+			ids: {
+				kind: JUDGE_KIND_LAYA,
+				version: String(compared.version)
+			},
+			surface: "daemon",
+			origin: "daemon"
+		});
+		return reason;
+	}
+	/**
+	* `judge model remove` (D11): only while Laya is disabled, deletes every verified runtime and model tree under the
+	* Laya root — an earlier release's first, then this release's own with its unverified copies. Another selection's
+	* partial or staging tree is a disable's to delete, never a removal's. Each asynchronous deletion is followed by a
+	* recheck that Laya is still disabled; an enablement claimed meanwhile stops the removal and owns what remains.
+	*/
+	async remove() {
+		await this.#mutex.run(async () => {
+			if (this.#activeEnablement() !== null) throw layaRefusal("LAYA_ENABLED", "disable the Laya judge kind before removing its model");
+			if (!await this.#removeEarlierVerifiedTrees()) return;
+			const manifestId = this.#manifestId();
+			const recorded = manifestId === null ? null : this.#models.get(manifestId);
+			if (recorded === null || recorded.state === "removed") return;
+			const release = this.#releaseSelection();
+			if (release !== null) {
+				const runtimeRoot = this.#runtimeRoot(release);
+				await rm(runtimeRoot, {
+					recursive: true,
+					force: true
+				});
+				await rm(`${runtimeRoot}.staging`, {
+					recursive: true,
+					force: true
+				});
+			}
+			await this.#failpoint?.("remove-model");
+			if (this.#activeEnablement() !== null) return;
+			if (manifestId !== null) {
+				const paths = layaModelArtifactPaths(this.#root, manifestId);
+				await rm(paths.complete, {
+					recursive: true,
+					force: true
+				});
+				await rm(paths.partial, {
+					recursive: true,
+					force: true
+				});
+			}
+			if (this.#activeEnablement() !== null || manifestId === null) return;
+			this.#store.immediate(() => this.#models.markRemovedWhileDisabled({
+				manifestId,
+				now: this.#now()
+			}));
+		});
+		return this.status();
+	}
+	/**
+	* Immediately before a worker may start: both whole trees are walked and compared with the enabled lock and
+	* manifest. A failing tree is recorded as `integrity`, deleted and reinstalled once from its pinned source; if the
+	* fresh copy fails too, Laya stays `failed` until its person acts. Paths stay inside the daemon.
+	*/
+	async verifyForWorkerStart() {
+		const active = this.#activeEnablement();
+		if (active === null) throw layaRefusal("LAYA_NOT_READY", "the Laya judge kind is not enabled");
+		const selection = this.#selectionFor(active);
+		const row = selection === null ? null : this.#models.get(selection.manifest.manifestId);
+		if (selection === null || row?.state !== "ready" || this.#job !== void 0) return {
+			ok: false,
+			failureCode: row?.failureCode ?? null
+		};
+		const walkedEpoch = this.#epoch;
+		const runtimeRoot = this.#runtimeRoot(selection);
+		const modelRoot = layaModelArtifactPaths(this.#root, selection.manifest.manifestId).complete;
+		const runtimeOk = (await verifyRuntimeTree({
+			root: runtimeRoot,
+			files: runtimeFiles(selection)
+		})).ok;
+		const modelOk = (await verifyRuntimeTree({
+			root: modelRoot,
+			files: modelFiles(selection)
+		})).ok;
+		await this.#failpoint?.("worker-start-verify");
+		if (runtimeOk && modelOk) return {
+			ok: true,
+			runtimeRoot,
+			modelRoot
+		};
+		if (walkedEpoch !== this.#epoch || this.#job !== void 0) return {
+			ok: false,
+			failureCode: null
+		};
+		const job = this.#repairJob(active, selection);
+		const settled = this.#repair(job, {
+			runtime: !runtimeOk,
+			model: !modelOk
+		});
+		job.settled = settled.then(() => void 0, () => void 0);
+		this.#job = job;
+		try {
+			return await settled ? {
+				ok: true,
+				runtimeRoot,
+				modelRoot
+			} : {
+				ok: false,
+				failureCode: "integrity"
+			};
+		} finally {
+			if (this.#job === job) this.#job = void 0;
+		}
+	}
+	/** The stable status answer: the DTO `judge model status`, `doctor` and the desktop app read. */
+	status() {
+		const availability = this.availability();
+		const active = this.#activeEnablement();
+		if (active === null) {
+			if (!availability.available) {
+				const blocked = this.#definition.status();
+				return {
+					state: "unavailable",
+					manifestId: blocked.manifestId,
+					runtimeLockDigest: blocked.runtimeLockDigest,
+					bytesVerified: blocked.bytesVerified,
+					totalBytes: blocked.totalBytes,
+					failureCode: null,
+					reason: availability.code,
+					updatedAt: blocked.updatedAt
+				};
+			}
+			const release = this.#releaseSelection();
+			if (release === null) return this.#definition.status();
+			const row = this.#models.get(release.manifest.manifestId);
+			return {
+				state: "idle",
+				manifestId: release.manifest.manifestId,
+				runtimeLockDigest: release.runtimeLock.digest,
+				bytesVerified: row?.state === "ready" ? row.bytesVerified : 0,
+				totalBytes: totalBytes(release),
+				failureCode: null,
+				reason: null,
+				updatedAt: row?.updatedAt ?? null
+			};
+		}
+		const enabled = this.#enabledShape(active);
+		const row = enabled === null ? null : this.#models.get(enabled.manifestId);
+		const answer = (state, bytesVerified, failureCode, reason) => ({
+			state,
+			manifestId: enabled?.manifestId ?? null,
+			runtimeLockDigest: enabled?.runtimeLockDigest ?? null,
+			bytesVerified,
+			totalBytes: enabled?.totalBytes ?? 0,
+			failureCode,
+			reason,
+			updatedAt: row?.updatedAt ?? null
+		});
+		if (!availability.available) return answer("failed", row?.bytesVerified ?? 0, "boundary-failed", availability.code);
+		const job = this.#job;
+		if (job !== void 0 && job.version === active.version && job.epoch === this.#epoch) return answer(job.phase, this.#progress(job), null, null);
+		if (row === null || row.state === "removed") return answer("installing", 0, null, null);
+		return answer(row.state, row.bytesVerified, row.state === "failed" ? row.failureCode : null, null);
+	}
+	/** The doctor's view: the status answer plus the runtime and model states and the boundary reason, never a path. */
+	async doctor() {
+		const status = this.status();
+		const availability = this.availability();
+		const job = this.#job;
+		let runtime = "absent";
+		if (job !== void 0 && job.phase === "installing") runtime = "installing";
+		else if (status.runtimeLockDigest !== null && /^[a-f0-9]{64}$/.test(status.runtimeLockDigest)) runtime = await isDirectory(join(this.#root, "runtime", status.runtimeLockDigest)) ? "installed" : "absent";
+		const row = status.manifestId === null ? null : this.#models.get(status.manifestId);
+		return {
+			state: status.state,
+			manifestId: status.manifestId,
+			runtimeLockDigest: status.runtimeLockDigest,
+			runtime,
+			model: row?.state ?? "absent",
+			boundary: availability.available ? {
+				status: "active",
+				reason: null
+			} : {
+				status: "unavailable",
+				reason: availability.code
+			},
+			failureCode: status.failureCode,
+			bytesVerified: status.bytesVerified,
+			totalBytes: status.totalBytes
+		};
+	}
+	/** Task 8's one worker supervisor; the returned function detaches exactly that supervisor. */
+	attachWorker(worker) {
+		if (this.#worker !== void 0) throw new Error("a Laya worker supervisor is already attached");
+		this.#worker = worker;
+		return () => {
+			if (this.#worker === worker) this.#worker = void 0;
+		};
+	}
+	/**
+	* The selection a worker may start for: the active pointer, only while its document is exactly this release's
+	* reviewed one, with the manager's current epoch. Null before an enablement, after a disable, an update or a stop.
+	*/
+	workerSelection() {
+		if (this.#stopped) return null;
+		const active = this.#activeEnablement();
+		if (active === null) return null;
+		const selection = this.#selectionFor(active);
+		if (selection === null) return null;
+		return {
+			epoch: this.#epoch,
+			version: active.version,
+			digest: active.digest,
+			manifestId: selection.manifest.manifestId,
+			promptTemplates: selection.manifest.promptTemplates
+		};
+	}
+	/**
+	* D11: a worker whose per-start boundary proof failed, or whose verified runtime would not load, leaves Laya
+	* `failed` with that closed code until its person acts — no later request starts another child for it. The write is
+	* made only while the selection that worker verified is still the current one, in the same transaction.
+	*/
+	recordWorkerFailure(started, failureCode) {
+		try {
+			this.#store.immediate(() => {
+				const current = this.workerSelection();
+				if (current === null || current.epoch !== started.epoch || current.version !== started.version || current.digest !== started.digest) return;
+				const row = this.#models.get(started.manifestId);
+				if (row?.state !== "ready") return;
+				this.#models.write({
+					manifestId: started.manifestId,
+					state: "failed",
+					bytesVerified: row.bytesVerified,
+					failureCode,
+					now: this.#now()
+				});
+			});
+		} catch {}
+	}
+	/**
+	* Task 8's supervisor registers each in-flight worker request by its E reservation. The returned signal fires when
+	* an E purge terminalises exactly that reservation; nothing else is touched.
+	*/
+	trackWork(reservationId) {
+		const controller = new AbortController();
+		const work = {
+			reservationId,
+			controller
+		};
+		this.#tracked.set(reservationId, work);
+		return {
+			signal: controller.signal,
+			release: () => {
+				if (this.#tracked.get(reservationId) === work) this.#tracked.delete(reservationId);
+			}
+		};
+	}
+	/**
+	* E's purge participant calls this inside the purge transaction, after its recovery transition. Only tracked work
+	* whose own reservation that transition settled or released is stopped: an account, rule, hold, visibility,
+	* expiry or disable-all purge never touches an installation-wide verified tree or another scope's work.
+	*/
+	onWorkPurged() {
+		for (const work of [...this.#tracked.values()]) {
+			const row = this.#store.database.prepare("SELECT state FROM judge_budget_reservations WHERE id = ?").get(work.reservationId);
+			if (row !== void 0 && (row.state === "reserved" || row.state === "in-flight")) continue;
+			this.#tracked.delete(work.reservationId);
+			work.controller.abort(new ArtifactWorkStale());
+		}
+	}
+	/** Owner stop: no job outlives the database it writes to. */
+	async stop() {
+		this.#stopped = true;
+		const job = this.#fence();
+		for (const work of this.#tracked.values()) work.controller.abort(new ArtifactWorkStale());
+		this.#tracked.clear();
+		await job?.settled.catch(() => void 0);
+		await this.#worker?.stop();
+	}
+	#fence() {
+		this.#epoch += 1;
+		const job = this.#job;
+		job?.controller.abort(new ArtifactWorkStale());
+		return job;
+	}
+	#locked(edge, work) {
+		return this.#mutex.run(async () => {
+			await this.#failpoint?.(edge);
+			return work();
+		});
+	}
+	#activeEnablement() {
+		const row = this.#store.database.prepare(`SELECT active.version AS version, versions.document AS document, versions.digest AS digest
+           FROM active_versions AS active
+           JOIN judge_kind_versions AS versions
+             ON versions.kind = active.object_id AND versions.version = active.version
+          WHERE active.kind = 'judge-kind' AND active.object_id = ?`).get(JUDGE_KIND_LAYA);
+		if (row === void 0) return null;
+		let document;
+		try {
+			document = JSON.parse(row.document);
+		} catch {
+			document = null;
+		}
+		return {
+			version: row.version,
+			digest: row.digest,
+			document
+		};
+	}
+	/** The active document, only when it is exactly this release's reviewed document; an update leaves it null. */
+	#selectionFor(active) {
+		try {
+			const release = this.#definition.preview({ version: active.version });
+			return layaUpdateReason(active.document, release) === null ? release : null;
+		} catch {
+			return null;
+		}
+	}
+	#releaseSelection() {
+		try {
+			return this.#definition.preview({ version: 1 });
+		} catch {
+			return null;
+		}
+	}
+	#manifestId() {
+		return this.#releaseSelection()?.manifest.manifestId ?? this.#definition.status().manifestId;
+	}
+	/** The content-free identity of an enabled document, read even when this release no longer matches it. */
+	#enabledShape(active) {
+		const selection = this.#selectionFor(active);
+		if (selection !== null) return {
+			manifestId: selection.manifest.manifestId,
+			runtimeLockDigest: selection.runtimeLock.digest,
+			totalBytes: totalBytes(selection)
+		};
+		const document = active.document;
+		const manifestId = document?.manifest?.manifestId;
+		const digest = document?.runtimeLock?.digest;
+		if (typeof manifestId !== "string" || typeof digest !== "string") return null;
+		return {
+			manifestId,
+			runtimeLockDigest: digest,
+			totalBytes: bytesOf([...document?.manifest?.files ?? [], ...document?.runtimeLock?.platform?.files ?? []])
+		};
+	}
+	#runtimeRoot(selection) {
+		const digest = selection.runtimeLock.digest;
+		if (!/^[a-f0-9]{64}$/.test(digest)) throw new ArtifactFailure("runtime-failed");
+		return join(this.#root, "runtime", digest);
+	}
+	#progress(job) {
+		let model = 0;
+		for (const bytes of job.modelProgress.values()) model += bytes;
+		return Math.min(job.runtimeBytes + model, totalBytes(job.selection));
+	}
+	/** The synchronous recheck every post-await step makes: same pointer version, same document, same epoch. */
+	#assertCurrent(job) {
+		if (this.#stopped || job.epoch !== this.#epoch || job.controller.signal.aborted) throw new ArtifactWorkStale();
+		const active = this.#activeEnablement();
+		if (active === null || active.version !== job.version || active.digest !== job.digest) throw new ArtifactWorkStale();
+	}
+	#isCurrent(job) {
+		try {
+			this.#assertCurrent(job);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	#write(job, state, bytesVerified, failureCode) {
+		this.#store.immediate(() => {
+			this.#assertCurrent(job);
+			this.#models.write({
+				manifestId: job.selection.manifest.manifestId,
+				state,
+				bytesVerified,
+				...state === "ready" ? { verifiedAt: this.#now() } : {},
+				...failureCode === void 0 ? {} : { failureCode },
+				now: this.#now()
+			});
+		});
+	}
+	#fenceFor(job) {
+		return {
+			assertCurrent: async (stage) => {
+				if (stage === "promotion") await this.#failpoint?.("model-promotion");
+				this.#assertCurrent(job);
+			},
+			withArtifactLock: (work) => this.#mutex.run(work)
+		};
+	}
+	async #install(job) {
+		try {
+			await this.#locked("install-start", async () => {
+				this.#write(job, "installing", 0);
+			});
+			const selection = job.selection;
+			const runtimeRoot = this.#runtimeRoot(selection);
+			if (!(await verifyRuntimeTree({
+				root: runtimeRoot,
+				files: runtimeFiles(selection)
+			})).ok) {
+				this.#assertCurrent(job);
+				await this.#installRuntime(job, { replace: await isDirectory(runtimeRoot) });
+			}
+			this.#assertCurrent(job);
+			job.runtimeBytes = bytesOf(selection.runtimeLock.platform.files);
+			this.#write(job, "downloading", job.runtimeBytes);
+			job.phase = "downloading";
+			const modelRoot = layaModelArtifactPaths(this.#root, selection.manifest.manifestId).complete;
+			if (!(await verifyRuntimeTree({
+				root: modelRoot,
+				files: modelFiles(selection)
+			})).ok) {
+				this.#assertCurrent(job);
+				await this.#downloadModel(job, { replace: await isDirectory(modelRoot) });
+			}
+			job.phase = "verifying";
+			const runtime = await verifyRuntimeTree({
+				root: runtimeRoot,
+				files: runtimeFiles(selection)
+			});
+			const model = await verifyRuntimeTree({
+				root: modelRoot,
+				files: modelFiles(selection)
+			});
+			if (!runtime.ok || !model.ok) throw new ArtifactFailure("integrity");
+			await this.#locked("model-ready", async () => {
+				this.#write(job, "ready", totalBytes(selection));
+				await this.#removeObsoleteTrees(job);
+			});
+		} catch (error) {
+			this.#recordFailure(job, error);
+		}
+	}
+	#recordFailure(job, error) {
+		if (error instanceof ArtifactWorkStale || !this.#isCurrent(job)) return;
+		const failureCode = error instanceof ArtifactFailure ? error.failureCode : job.phase === "installing" ? "runtime-failed" : job.phase === "downloading" ? "download-failed" : "integrity";
+		try {
+			this.#write(job, "failed", this.#progress(job), failureCode);
+		} catch {}
+	}
+	/**
+	* Fetches every SRI-pinned archive, extracts only the selected platform's listed files into a staging tree that
+	* the strict installer verifies, then promotes that tree inside the artifact lock after the exact recheck.
+	*/
+	async #installRuntime(job, options) {
+		const selection = job.selection;
+		const runtimeRoot = this.#runtimeRoot(selection);
+		const staging = `${runtimeRoot}.staging`;
+		const files = runtimeFiles(selection);
+		await ownerOnlyDirectory(join(this.#root, "runtime"));
+		const free = await (this.#freeBytes ?? (() => availableBytes(join(this.#root, "runtime"))))();
+		if (!Number.isSafeInteger(free) || free < Math.ceil(bytesOf(files) * 1.1)) throw new ArtifactFailure("runtime-failed");
+		const fetcher = this.#fetcher(job);
+		const packages = [];
+		for (const pkg of selection.runtimeLock.packages) {
+			if (!files.some((file) => file.packageName === pkg.name)) continue;
+			this.#assertCurrent(job);
+			const bytes = await fetcher.fetchRuntimeArchive(pkg, { signal: job.controller.signal });
+			packages.push({
+				packageName: pkg.name,
+				source: (async function* () {
+					yield bytes;
+				})()
+			});
+		}
+		this.#assertCurrent(job);
+		await rm(staging, {
+			recursive: true,
+			force: true
+		});
+		try {
+			const installed = await installRuntime({
+				runtimeDirectory: staging,
+				lockDigest: selection.runtimeLock.digest,
+				packages,
+				files
+			});
+			await this.#locked("runtime-promotion", async () => {
+				this.#assertCurrent(job);
+				if (options.replace) await rm(runtimeRoot, {
+					recursive: true,
+					force: true
+				});
+				await rename(installed.root, runtimeRoot);
+			});
+		} finally {
+			await rm(staging, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	async #downloadModel(job, options) {
+		const selection = job.selection;
+		const paths = layaModelArtifactPaths(this.#root, selection.manifest.manifestId);
+		if (options.replace) await this.#mutex.run(async () => {
+			this.#assertCurrent(job);
+			await rm(paths.complete, {
+				recursive: true,
+				force: true
+			});
+		});
+		await new LayaModelDownloader({
+			dataDirectory: this.#root,
+			manifest: selection.manifest,
+			fetcher: this.#fetcher(job),
+			fence: this.#fenceFor(job)
+		}).download({
+			signal: job.controller.signal,
+			...this.#freeBytes === void 0 ? {} : { freeBytes: this.#freeBytes }
+		});
+	}
+	#fetcher(job) {
+		return new ProgressReportingArtifactFetcher({
+			manifest: job.selection.manifest,
+			runtimePackages: job.selection.runtimeLock.packages,
+			resolver: this.#network.resolver,
+			tcpConnect: this.#network.tcpConnect,
+			tlsConnect: this.#network.tlsConnect
+		}, job.modelProgress);
+	}
+	#repairJob(active, selection) {
+		return {
+			epoch: this.#epoch,
+			version: active.version,
+			digest: active.digest,
+			selection,
+			controller: new AbortController(),
+			phase: "installing",
+			runtimeBytes: 0,
+			modelProgress: /* @__PURE__ */ new Map(),
+			settled: Promise.resolve()
+		};
+	}
+	/** One repair per failing tree; the fresh copy must verify or Laya records `integrity` and stays failed. */
+	async #repair(job, failing) {
+		const selection = job.selection;
+		const runtimeRoot = this.#runtimeRoot(selection);
+		const modelRoot = layaModelArtifactPaths(this.#root, selection.manifest.manifestId).complete;
+		try {
+			await this.#locked("repair-delete", async () => {
+				this.#assertCurrent(job);
+				if (failing.runtime) await rm(runtimeRoot, {
+					recursive: true,
+					force: true
+				});
+				if (failing.model) await rm(modelRoot, {
+					recursive: true,
+					force: true
+				});
+				this.#write(job, "failed", 0, "integrity");
+			});
+			if (failing.runtime) await this.#installRuntime(job, { replace: false });
+			job.runtimeBytes = bytesOf(selection.runtimeLock.platform.files);
+			job.phase = "downloading";
+			if (failing.model) await this.#downloadModel(job, { replace: false });
+			job.phase = "verifying";
+			const runtime = await verifyRuntimeTree({
+				root: runtimeRoot,
+				files: runtimeFiles(selection)
+			});
+			const model = await verifyRuntimeTree({
+				root: modelRoot,
+				files: modelFiles(selection)
+			});
+			if (!runtime.ok || !model.ok) throw new ArtifactFailure("integrity");
+			await this.#locked("model-ready", async () => {
+				this.#write(job, "ready", totalBytes(selection));
+				await this.#removeObsoleteTrees(job);
+			});
+			return true;
+		} catch (error) {
+			if (error instanceof ArtifactWorkStale || !this.#isCurrent(job)) return false;
+			try {
+				this.#write(job, "failed", 0, "integrity");
+			} catch {}
+			return false;
+		}
+	}
+	/**
+	* D11 and E2-5: once a selection's model is ready, a tree no enabled entry names is obsolete. Inside the
+	* `model-ready` lock, every `runtime/` and `models/` entry but the selection's own two is deleted, partial and staging
+	* trees included, and the sweep stops at its first recheck that finds the job fenced by a disable, update or stop.
+	*/
+	#removeObsoleteTrees(job) {
+		const named = {
+			runtime: job.selection.runtimeLock.digest,
+			models: job.selection.manifest.manifestId
+		};
+		return this.#sweepTrees((directory, name) => name === named[directory], () => this.#isCurrent(job));
+	}
+	/**
+	* `judge model remove`'s sweep of every verified tree but this release's own, which the removal then deletes with
+	* its unverified copies. It stops at its first recheck that finds an enablement claimed meanwhile.
+	*/
+	#removeEarlierVerifiedTrees() {
+		const own = {
+			runtime: this.#releaseSelection()?.runtimeLock.digest,
+			models: this.#manifestId()
+		};
+		return this.#sweepTrees((directory, name) => name.endsWith(".partial") || name.endsWith(".staging") || name === own[directory], () => this.#activeEnablement() === null);
+	}
+	/**
+	* Deletes, one at a time in raw-byte name order, every entry under `runtime/` and `models/` that `keep` does not
+	* name, rechecking `current` after every await: a tightening or a claim that lands meanwhile stops the sweep before
+	* its next deletion. A deletion that fails is left for the next sweep. Resolves whether the sweep finished. Its
+	* callers hold the artifact lock.
+	*/
+	async #sweepTrees(keep, current) {
+		for (const directory of ["runtime", "models"]) {
+			let names;
+			try {
+				names = await readdir(join(this.#root, directory));
+			} catch {
+				names = [];
+			}
+			if (!current()) return false;
+			names.sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
+			for (const name of names) {
+				if (keep(directory, name)) continue;
+				await rm(join(this.#root, directory, name), {
+					recursive: true,
+					force: true
+				}).catch(() => void 0);
+				await this.#failpoint?.("tree-sweep");
+				if (!current()) return false;
+			}
+		}
+		return true;
+	}
+	/** Deletes every partial and staging tree beneath the artifact root, and never a verified one. */
+	async #removeUnverified() {
+		for (const directory of ["runtime", "models"]) {
+			const parent = join(this.#root, directory);
+			let names;
+			try {
+				names = await readdir(parent);
+			} catch {
+				continue;
+			}
+			for (const name of names) if (name.endsWith(".partial") || name.endsWith(".staging")) await rm(join(parent, name), {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+};
+function unavailableResult(code) {
+	return {
+		kind: "unavailable",
+		code,
+		phase: "E2"
+	};
+}
+//#endregion
+//#region src/runtime/lifecycle.ts
+var EventLifecycle = class {
+	store;
+	now;
+	constructor(store, now = Date.now) {
 		this.store = store;
 		this.now = now;
 	}
@@ -16799,10 +19698,6 @@ function closedReason(result) {
 	if (result.kind === "answer") return "completed";
 	return result.code.toLowerCase().replaceAll("_", "-");
 }
-/**
-* The sole agentic execution coordinator.  It owns no ledger transition and no socket path: Task 5's budget
-* functions and Task 6's sealed transport remain the only owners of those effects.
-*/
 var JudgeCoordinator = class {
 	#store;
 	#taint;
@@ -16838,6 +19733,7 @@ var JudgeCoordinator = class {
 			channel: input.rule.source.channel,
 			classification: envelope.classification
 		});
+		if (agentic.judge.kind === "laya") return this.#evaluateLaya(input, agentic.judge, envelope);
 		let hostedApiKey;
 		try {
 			hostedApiKey = agentic.judge.kind === "typesafe" ? await this.#hostedApiKeyFor({
@@ -16974,6 +19870,127 @@ var JudgeCoordinator = class {
 			}
 		};
 	}
+	/**
+	* E2's Laya adapter, in E's order: the deterministic prefilter, the minimised envelope and the taint flush have run;
+	* here the database owner's Laya executor checks the enabled entry and template and bounds the request before any
+	* reservation, E reserves the exact request payload, E's gate moves the reservation in flight immediately before the
+	* one frame is written, and only the worker's bounded value and token count come back for E's final settlement.
+	* Every failure is a closed reason and no-match: pre-I/O E releases the reservation, post-I/O E settles it.
+	*/
+	async #evaluateLaya(input, judge, envelope) {
+		const agentic = input.rule.agentic;
+		if (agentic === void 0) return { kind: "not-applicable" };
+		const executor = layaJudgeExecutorFor(this.#store.database);
+		if (executor === void 0) return {
+			kind: "closed",
+			reason: "adapter-reference-blocked",
+			reservationId: null
+		};
+		const laya = executor.prepare({
+			judge,
+			state: envelope.state,
+			instructions: agentic.question
+		});
+		if (!laya.ok) return {
+			kind: "closed",
+			reason: laya.code.toLowerCase(),
+			reservationId: null
+		};
+		let reservation;
+		try {
+			reservation = reserveJudgeWork({
+				store: this.#store,
+				id: this.#newId(),
+				workId: `judge:${input.eventId}:${input.ruleId}:${input.ruleVersion}`,
+				scope: {
+					scope: "source-owned",
+					source: input.rule.source.channel,
+					accountId: input.accountId,
+					eventId: input.eventId,
+					ruleId: input.ruleId,
+					ruleVersion: input.ruleVersion,
+					judgeId: judge.judgeId,
+					judgeVersion: judge.version
+				},
+				judge,
+				limits: {
+					callsPerRollingHour: agentic.callsPerRollingHour,
+					inputTokensPerRolling30Days: agentic.inputTokensPerRolling30Days,
+					concurrency: agentic.concurrency,
+					maxInputTokens: agentic.maxInputTokens
+				},
+				finalEnvelope: laya.request.body,
+				switchGeneration: input.switchGeneration,
+				now: this.#now()
+			});
+		} catch (error) {
+			const code = error instanceof Error && "code" in error ? String(error.code) : "budget-refused";
+			if (code === "JUDGE_PAUSED") return {
+				kind: "deferred",
+				reservationId: null
+			};
+			if (code === "JUDGE_WORK_OWNER_HELD") return { kind: "owner-held" };
+			return {
+				kind: "closed",
+				reason: code,
+				reservationId: null
+			};
+		}
+		const ioGate = new JudgeReservationIoGate({
+			store: this.#store,
+			reservationId: reservation.id,
+			judgeKind: judge.kind,
+			now: this.#now
+		});
+		const result = await executor.execute(laya.request, {
+			reservationId: reservation.id,
+			finalGate: () => ioGate.finalGate("write")
+		});
+		if (result.kind === "answer") return {
+			kind: "completed",
+			outcome: uncertainOutcome(input.rule, result.value),
+			value: result.value,
+			valueLabel: "probability",
+			actualInputTokens: result.inputTokens,
+			reservationId: reservation.id,
+			metadata: {
+				judgeId: judge.judgeId,
+				judgeVersion: judge.version,
+				provider: judge.provider,
+				model: judge.model,
+				promptTemplate: judge.promptTemplate,
+				threshold: agentic.threshold,
+				value: result.value,
+				valueLabel: "probability"
+			}
+		};
+		const disposition = finalizeJudgeTransportRefusal({
+			store: this.#store,
+			reservationId: reservation.id,
+			result: result.code === "laya-timeout" ? "timeout" : "unknown",
+			now: this.#now()
+		});
+		if (ioGate.firstGateError !== void 0) {
+			if (ioGate.firstGateError instanceof JudgeBudgetError && ioGate.firstGateError.code === "JUDGE_PAUSED") return {
+				kind: "deferred",
+				reservationId: reservation.id
+			};
+			return {
+				kind: "closed",
+				reason: ioGate.firstGateError instanceof Error && "code" in ioGate.firstGateError ? String(ioGate.firstGateError.code) : "authority-changed",
+				reservationId: reservation.id
+			};
+		}
+		if (disposition === "released" && result.code === "laya-stopped") return {
+			kind: "deferred",
+			reservationId: reservation.id
+		};
+		return {
+			kind: "closed",
+			reason: result.code.toLowerCase(),
+			reservationId: reservation.id
+		};
+	}
 };
 //#endregion
 //#region src/runtime/evaluate.ts
@@ -20167,7 +23184,8 @@ function createOwnerB3ControlService(options) {
 		now,
 		...judgeActivations === void 0 ? {} : { activations: judgeActivations },
 		...options.judgeTest === void 0 ? {} : { judgeTest: { test: options.judgeTest.test.bind(options.judgeTest) } },
-		...options.holdResolver === void 0 ? {} : { holdResolver: options.holdResolver }
+		...options.holdResolver === void 0 ? {} : { holdResolver: options.holdResolver },
+		...options.laya === void 0 ? {} : { laya: options.laya }
 	});
 	const target = (pendingOrigin) => new B3TargetTestControl({
 		store: options.store,
@@ -20228,7 +23246,7 @@ function createOwnerB3ControlService(options) {
 			}
 		}
 		switch (request.operation) {
-			case "approvalView": return approvalViewFromOwner(options.store, options.activations, now, request.args);
+			case "approvalView": return approvalViewFromOwner(options.store, options.activations, now, request.args, options.laya !== void 0);
 			case "ruleTest": return runCatalogueRuleTest({
 				document: request.args.document,
 				catalogue: request.args.catalogue
@@ -20396,16 +23414,21 @@ function terminalSecretResult(receipt) {
 		terminalReveal: reveal
 	};
 }
-async function approvalViewFromOwner(store, activations, now, args) {
+/**
+* The authoritative approval view. With E2's artifact manager composed the owner answers B3 control v3, whose view of
+* a rule naming a Laya judge also carries D11's Laya limits, from the same reviewed assets as the enablement.
+*/
+async function approvalViewFromOwner(store, activations, now, args, layaJudges = false) {
 	const approvalId = requiredText(args.approvalId, "approval id");
 	const digest = requiredText(args.digest, "approval digest");
 	const row = store.database.prepare("SELECT id, document, digest, status FROM activation_intents WHERE approval_id = ?").get(approvalId);
 	if (row === void 0 || row.status !== "pending") return { kind: "STALE_APPROVAL" };
 	if (row.digest !== digest) return { kind: "DIGEST_MISMATCH" };
+	const preview = normaliseActivationDocument(JSON.parse(row.document));
+	const layaJudge = layaJudges ? layaJudgePreviewFor(preview, layaJudgeTermsFor(layaEnablementInputsFor(store.database))) : void 0;
 	const nextExpiry = now() + 3e5;
 	const challenge = await activations.issueApprovalViewChallenge(approvalId, nextExpiry);
 	if (challenge === null) return { kind: "CHALLENGE_EXPIRED" };
-	const preview = normaliseActivationDocument(JSON.parse(row.document));
 	return {
 		kind: "READY",
 		approvalId,
@@ -20423,7 +23446,8 @@ async function approvalViewFromOwner(store, activations, now, args) {
 			digest: row.digest,
 			challenge,
 			expiresAt: nextExpiry
-		}
+		},
+		...layaJudge === void 0 ? {} : { layaJudge }
 	};
 }
 /**
@@ -20771,6 +23795,34 @@ async function startOwnerWithLock(options, stateDir, paths, lock, started, onDat
 			}
 		});
 	};
+	const layaInputs = {
+		...options.laya?.assets === void 0 ? {} : { layaAssetSource: options.laya.assets },
+		...options.laya?.platform === void 0 ? {} : { layaPlatformProbe: options.laya.platform }
+	};
+	const layaArtifacts = new LayaArtifactManager({
+		store: database,
+		artifactRoot: join(options.dataDir ?? core.paths.dataDir, "events", JUDGE_KIND_LAYA),
+		inputs: layaInputs,
+		network: options.laya?.network,
+		freeBytes: options.laya?.freeBytes,
+		failpoint: options.laya?.failpoint,
+		audit: core.audit,
+		now
+	});
+	const unregisterLayaPurge = registerJudgeWorkPurgeListener(database.database, layaArtifacts);
+	const unregisterLayaInputs = registerLayaEnablementInputs(database.database, layaInputs);
+	const layaWorker = new LayaWorkerSupervisor({
+		artifacts: layaArtifacts,
+		startWorker: options.laya?.startWorker
+	});
+	const unregisterLayaWorker = registerLayaJudgeExecutor(database.database, layaWorker);
+	onDatabase({ close: () => {
+		unregisterLayaWorker();
+		unregisterLayaInputs();
+		unregisterLayaPurge();
+		layaWorker.close();
+		database.close();
+	} });
 	const activations = new ActivationRuntime({
 		store: database,
 		approvals: core.approvals,
@@ -20909,7 +23961,11 @@ async function startOwnerWithLock(options, stateDir, paths, lock, started, onDat
 		retainedContentHooks: whatsappComposition.retainedContentHooks,
 		now,
 		...options.newIntentId === void 0 ? {} : { newIntentId: options.newIntentId },
-		assertObjectSecretReady: b3Ports.assertObjectSecretReady
+		assertObjectSecretReady: b3Ports.assertObjectSecretReady,
+		...layaInputs,
+		onJudgeKindEnabled: ({ kind }) => {
+			if (kind === "laya") layaArtifacts.ensureInstalled();
+		}
 	});
 	const scheduler = new EventScheduler({
 		store: database,
@@ -21063,10 +24119,11 @@ async function startOwnerWithLock(options, stateDir, paths, lock, started, onDat
 			}),
 			whatsappVisibilityFence: whatsappComposition.visibilityFence
 		}),
+		laya: layaArtifacts,
 		now
 	});
 	const doctorReport = async () => {
-		return projectE9Doctor({
+		return projectE2Doctor({
 			database: database.database,
 			installationId: database.installationId,
 			lifecycle: lifecycle.status(),
@@ -21075,6 +24132,7 @@ async function startOwnerWithLock(options, stateDir, paths, lock, started, onDat
 			config: core.config,
 			approvals: core.approvals,
 			decryptSourceState: decryptSourceStage,
+			laya: layaArtifacts,
 			now
 		});
 	};
@@ -21102,7 +24160,12 @@ async function startOwnerWithLock(options, stateDir, paths, lock, started, onDat
 			try {
 				await scheduler.stop();
 				await control?.close();
+				await layaWorker.close();
+				await layaArtifacts.stop();
 			} finally {
+				unregisterLayaWorker();
+				unregisterLayaInputs();
+				unregisterLayaPurge();
 				database.close();
 				await removeInstance(paths, instance.instanceId);
 				await rm(paths.controlToken, { force: true });
@@ -21119,7 +24182,13 @@ async function startOwnerWithLock(options, stateDir, paths, lock, started, onDat
 			database: database.database,
 			now: now()
 		}));
+		await withEventWriterLease(writerQuiescer, () => layaArtifacts.reconcileRelease(() => new JudgeKinds({
+			store: database,
+			now,
+			activations
+		}).disable(JUDGE_KIND_LAYA)));
 		await withEventWriterLease(writerQuiescer, () => recoverActivations(activations));
+		layaArtifacts.resume().catch(() => void 0);
 		await writeToken(paths, token);
 		control = await (options.startControlServer ?? startControlServer)({
 			endpoint: instance.endpoint,
@@ -21204,10 +24273,10 @@ async function handleControl(owner, lifecycle, database, activations, dispatcher
 		case OWNER_CONTROL_WIRES.ruleShow: return ruleShow(database, requiredText(request.args.ruleId, "rule id"));
 		case OWNER_CONTROL_WIRES.createRule:
 		case OWNER_CONTROL_WIRES.updateRule: return createRule(database, request.args.document);
-		case OWNER_CONTROL_WIRES.enableRule: return activations.prepareRule({
+		case OWNER_CONTROL_WIRES.enableRule: return domainAwaited(() => activations.prepareRule({
 			ruleId: requiredText(request.args.ruleId, "rule id"),
 			version: requiredVersion(request.args.version, "rule version")
-		});
+		}));
 		case OWNER_CONTROL_WIRES.disableRule:
 		case OWNER_CONTROL_WIRES.removeRule: return disableRule(database, activations, requiredText(request.args.ruleId, "rule id"));
 		case OWNER_CONTROL_WIRES.targetsList: return targetRows(database);
@@ -21252,6 +24321,15 @@ function domain(work) {
 		throw error;
 	}
 }
+/** `domain` for an operation that awaits: a refusal is the caller's input, with the same fixed reason. */
+async function domainAwaited(work) {
+	try {
+		return await work();
+	} catch (error) {
+		if (error instanceof EventDomainError) throw new CommsError("BAD_DATA", error.message, { details: { reason: error.code } });
+		throw error;
+	}
+}
 function ruleRows(database) {
 	return database.database.prepare("SELECT rule_id, version, digest, state, approval_id, authorization_activation_id FROM rule_versions ORDER BY rule_id, version").all();
 }
@@ -21263,8 +24341,9 @@ function ruleShow(database, ruleId) {
 		document: JSON.parse(row.document)
 	}));
 }
+/** The owner composes E2's artifact manager, so the rules it keeps carry B3 control v3's judge documents. */
 function createRule(database, document) {
-	return domain(() => new ImmutableVersions(database.database).createRule(document));
+	return domain(() => ImmutableVersions.forJudgeContract(database.database, "b3-control-v3").createRule(document));
 }
 function targetRows(database) {
 	return database.database.prepare("SELECT target_id, version, digest, revoked_at FROM target_versions ORDER BY target_id, version").all();
@@ -21823,7 +24902,7 @@ async function run(argv, deps = {}) {
 		const parsed = jsonArgument(document, "budget document");
 		print(await humanB3("updateBudget", { document: parsed }, () => updateBudget(parsed, controlOptions(program))));
 	});
-	judge.command("kinds").description("list disabled/enabled kinds and the typed Laya E2 seam").command("list").action(async () => {
+	judge.command("kinds").description("list each judge kind as disabled or enabled, or Laya as unavailable here with its reason").command("list").action(async () => {
 		ran = true;
 		print(await judgeKindsList(controlOptions(program)));
 	});
@@ -21836,7 +24915,7 @@ async function run(argv, deps = {}) {
 		ran = true;
 		print(await humanB3("disableJudgeKind", { kind }, () => disableJudgeKind(kind, controlOptions(program))));
 	});
-	const judgeModel = judge.command("model").description("local Laya model controls, which answer that Laya is not available yet");
+	const judgeModel = judge.command("model").description("report the local Laya runtime and model state, or remove its files while Laya is disabled");
 	judgeModel.command("status").action(async () => {
 		ran = true;
 		print(await judgeModelStatus(controlOptions(program)));