@agentcomms/events-daemon 0.24.0 → 0.25.0

package/dist/{webhook-target-DyDTwWhV.mjs → webhook-target-EzLIFpIY.mjs}

@@ -1,4 +1,30 @@
+import { h as isLayaTemplateId } from "./worker-boundary-probe-CFN6EsyK.mjs";
 import { canonicalJson, sha256Hex } from "@agentcomms/core";
+import { spawnSync } from "node:child_process";
+//#region src/domain/lifecycle.ts
+/** A content-free domain refusal. No caller should substitute an arbitrary Error message at a control boundary. */
+var EventDomainError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "EventDomainError";
+		this.code = code;
+	}
+};
+const JUDGE_KIND_TYPESAFE = "typesafe";
+const JUDGE_KIND_LAYA = "laya";
+const JUDGE_KIND_LOCAL_ENDPOINT = "local-endpoint";
+const JUDGE_KINDS = [
+	JUDGE_KIND_TYPESAFE,
+	JUDGE_KIND_LAYA,
+	JUDGE_KIND_LOCAL_ENDPOINT
+];
+function isJudgeKind(value) {
+	return typeof value === "string" && JUDGE_KINDS.includes(value);
+}
+function assertJudgeKindEnabled(kind, enabled) {
+	if (!enabled) throw new EventDomainError("JUDGE_KIND_DISABLED", `the ${kind} judge kind is disabled`);
+}
 //#endregion
 //#region src/network/iana-special-purpose.ts
 /** Checked-in IANA policy; network code must never refresh or consult it at runtime. */
@@ -504,29 +530,537 @@ function validateLocalEndpoint(input, approvedAddressSet) {
 	};
 }
 //#endregion
-//#region src/domain/lifecycle.ts
-/** A content-free domain refusal. No caller should substitute an arbitrary Error message at a control boundary. */
-var EventDomainError = class extends Error {
+//#region src/runtime/laya/contracts.ts
+const LAYA_KIND = JUDGE_KINDS[1];
+const PLATFORM_PREFIX = "darwin-";
+const SANDBOX_TRIVIAL_PROGRAM = "/usr/bin/true";
+const SANDBOX_PROBE_TIMEOUT_MS = 250;
+const SYSCTL = "/usr/sbin/sysctl";
+const ROSETTA_QUERY = ["-in", "sysctl.proc_translated"];
+const LAYA_MODEL_FAILURE_CODES = [
+	"boundary-failed",
+	"download-failed",
+	"integrity",
+	"runtime-failed"
+];
+var LayaContractError = class extends Error {
 	code;
 	constructor(code, message) {
 		super(message);
-		this.name = "EventDomainError";
+		this.name = "LayaContractError";
 		this.code = code;
 	}
 };
-const JUDGE_KIND_TYPESAFE = "typesafe";
-const JUDGE_KIND_LAYA = "laya";
-const JUDGE_KIND_LOCAL_ENDPOINT = "local-endpoint";
-const JUDGE_KINDS = [
-	JUDGE_KIND_TYPESAFE,
-	JUDGE_KIND_LAYA,
-	JUDGE_KIND_LOCAL_ENDPOINT
-];
-function isJudgeKind(value) {
-	return typeof value === "string" && JUDGE_KINDS.includes(value);
+function fail$1(code, message) {
+	throw new LayaContractError(code, message);
 }
-function assertJudgeKindEnabled(kind, enabled) {
-	if (!enabled) throw new EventDomainError("JUDGE_KIND_DISABLED", `the ${kind} judge kind is disabled`);
+function object(value, name) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return fail$1("LAYA_ASSET_INVALID", `${name} is an object`);
+	return value;
+}
+function exactKeys(value, keys, name) {
+	const found = Object.keys(value).sort();
+	const expected = [...keys].sort();
+	if (found.length !== expected.length || found.some((key, index) => key !== expected[index])) fail$1("LAYA_ASSET_INVALID", `${name} has exact reviewed fields`);
+}
+function text$1(value, name) {
+	if (typeof value !== "string" || value.length === 0) fail$1("LAYA_ASSET_INVALID", `${name} is a non-empty string`);
+	return value;
+}
+function positive(value, name) {
+	if (!Number.isSafeInteger(value) || value < 1) fail$1("LAYA_ASSET_INVALID", `${name} is a positive integer`);
+	return value;
+}
+function safePath(value, name) {
+	const path = text$1(value, name);
+	if (path.includes("\\") || path.includes("\0") || path.startsWith("/") || path.split("/").some((part) => part === "" || part === "." || part === "..")) fail$1("LAYA_ASSET_INVALID", `${name} is a safe relative path`);
+	return path;
+}
+function sha256(value, name) {
+	const digest = text$1(value, name);
+	if (!/^[a-f0-9]{64}$/.test(digest)) fail$1("LAYA_ASSET_INVALID", `${name} is lowercase SHA-256`);
+	return digest;
+}
+function ordered(values, key, name) {
+	for (let index = 1; index < values.length; index += 1) if (key(values[index - 1]) >= key(values[index])) fail$1("LAYA_ASSET_INVALID", `${name} is sorted and duplicate-free`);
+	return values;
+}
+function manifest(value) {
+	const candidate = object(value, "the Laya manifest");
+	exactKeys(candidate, [
+		"manifestVersion",
+		"manifestId",
+		"source",
+		"weights",
+		"files",
+		"runtime",
+		"context",
+		"promptTemplates"
+	], "the Laya manifest");
+	if (candidate.manifestVersion !== 1) fail$1("LAYA_ASSET_INVALID", "the Laya manifest has version 1");
+	const source = object(candidate.source, "the Laya source");
+	exactKeys(source, [
+		"host",
+		"repo",
+		"revision"
+	], "the Laya source");
+	if (source.host !== "huggingface.co") fail$1("LAYA_ASSET_INVALID", "the Laya source has its reviewed host");
+	const revision = text$1(source.revision, "the Laya revision");
+	if (!/^[a-f0-9]{40}$/.test(revision)) fail$1("LAYA_ASSET_INVALID", "the Laya revision is a full lowercase commit");
+	const weights = object(candidate.weights, "the Laya weights");
+	exactKeys(weights, [
+		"publisher",
+		"origin",
+		"originSha256",
+		"licence"
+	], "the Laya weights");
+	if (!Array.isArray(candidate.files) || candidate.files.length === 0) fail$1("LAYA_ASSET_INVALID", "the Laya files are non-empty");
+	const files = ordered(candidate.files.map((entry) => {
+		const file = object(entry, "a Laya manifest file");
+		exactKeys(file, [
+			"path",
+			"size",
+			"sha256"
+		], "a Laya manifest file");
+		return {
+			path: safePath(file.path, "a Laya manifest path"),
+			size: positive(file.size, "a Laya manifest size"),
+			sha256: sha256(file.sha256, "a Laya manifest SHA-256")
+		};
+	}), (file) => Buffer.from(file.path, "utf8").toString("hex"), "the Laya manifest files");
+	const runtime = object(candidate.runtime, "the Laya runtime preview");
+	const runtimeEntries = Object.entries(runtime);
+	if (runtimeEntries.length === 0 || runtimeEntries.some(([name, version]) => name.length === 0 || typeof version !== "string" || version.length === 0)) fail$1("LAYA_ASSET_INVALID", "the Laya runtime preview is reviewed");
+	const context = object(candidate.context, "the Laya context");
+	exactKeys(context, ["maxTokens", "language"], "the Laya context");
+	if (context.maxTokens !== 512 || context.language !== "en") fail$1("LAYA_ASSET_INVALID", "the Laya context is English and bounded to 512 tokens");
+	if (!Array.isArray(candidate.promptTemplates) || candidate.promptTemplates.length === 0 || !candidate.promptTemplates.every((entry) => isLayaTemplateId(entry))) fail$1("LAYA_ASSET_INVALID", "the Laya prompt templates are reviewed templates the worker implements");
+	const promptTemplates = ordered(candidate.promptTemplates.map((entry) => text$1(entry, "a Laya prompt template")), (entry) => entry, "the Laya prompt templates");
+	return {
+		manifestVersion: 1,
+		manifestId: text$1(candidate.manifestId, "the Laya manifest id"),
+		source: {
+			host: "huggingface.co",
+			repo: text$1(source.repo, "the Laya repository"),
+			revision
+		},
+		weights: {
+			publisher: text$1(weights.publisher, "the Laya weights publisher"),
+			origin: text$1(weights.origin, "the Laya weights origin"),
+			originSha256: sha256(weights.originSha256, "the Laya weights origin SHA-256"),
+			licence: text$1(weights.licence, "the Laya weights licence")
+		},
+		files,
+		runtime: Object.fromEntries(runtimeEntries.map(([name, version]) => [name, version])),
+		context: {
+			maxTokens: 512,
+			language: "en"
+		},
+		promptTemplates
+	};
+}
+function runtimeLock(value) {
+	const candidate = object(value, "the Laya runtime lock");
+	if (candidate.schemaVersion === 1 && candidate.blocked === "E2_EXTERNAL_REFERENCE_BLOCKED") {
+		exactKeys(candidate, ["schemaVersion", "blocked"], "the blocked Laya runtime lock");
+		return { blocked: "E2_EXTERNAL_REFERENCE_BLOCKED" };
+	}
+	exactKeys(candidate, ["schemaVersion", "packages"], "the Laya runtime lock");
+	if (candidate.schemaVersion !== 1 || !Array.isArray(candidate.packages) || candidate.packages.length === 0) fail$1("LAYA_ASSET_INVALID", "the Laya runtime lock is complete");
+	return {
+		schemaVersion: 1,
+		packages: ordered(candidate.packages.map((entry) => {
+			const pkg = object(entry, "a Laya runtime package");
+			exactKeys(pkg, [
+				"name",
+				"version",
+				"url",
+				"integrity",
+				"files"
+			], "a Laya runtime package");
+			const filesByPlatform = object(pkg.files, "a Laya runtime package file list");
+			const files = Object.fromEntries(Object.entries(filesByPlatform).map(([platform, entries]) => {
+				if (!platform.startsWith(PLATFORM_PREFIX) || !Array.isArray(entries)) fail$1("LAYA_ASSET_INVALID", "a Laya runtime package has macOS file lists");
+				return [platform, ordered(entries.map((file) => {
+					const parsed = object(file, "a Laya runtime file");
+					exactKeys(parsed, [
+						"path",
+						"size",
+						"sha256",
+						"executable"
+					], "a Laya runtime file");
+					if (typeof parsed.executable !== "boolean") fail$1("LAYA_ASSET_INVALID", "a Laya runtime executable bit is boolean");
+					return {
+						path: safePath(parsed.path, "a Laya runtime path"),
+						size: positive(parsed.size, "a Laya runtime size"),
+						sha256: sha256(parsed.sha256, "a Laya runtime SHA-256"),
+						executable: parsed.executable
+					};
+				}), (file) => Buffer.from(file.path, "utf8").toString("hex"), "a Laya runtime package file list")];
+			}));
+			const url = text$1(pkg.url, "a Laya runtime URL");
+			if (!url.startsWith("https://registry.npmjs.org/") || /[?#]/.test(url)) fail$1("LAYA_ASSET_INVALID", "a Laya runtime URL is its reviewed registry URL");
+			const integrity = text$1(pkg.integrity, "a Laya runtime SRI");
+			if (!/^sha512-[A-Za-z0-9+/]+={0,2}$/.test(integrity)) fail$1("LAYA_ASSET_INVALID", "a Laya runtime SRI is exact SHA-512");
+			return {
+				name: text$1(pkg.name, "a Laya runtime package name"),
+				version: text$1(pkg.version, "a Laya runtime package version"),
+				url,
+				integrity,
+				files
+			};
+		}), (pkg) => pkg.name, "the Laya runtime packages")
+	};
+}
+function rawByteCompare(left, right) {
+	return Buffer.compare(Buffer.from(left, "utf8"), Buffer.from(right, "utf8"));
+}
+function sourceText(bytes, name) {
+	const source = Buffer.from(bytes).toString("utf8");
+	if (!Buffer.from(source, "utf8").equals(Buffer.from(bytes))) fail$1("LAYA_ASSET_INVALID", `${name} is strict UTF-8`);
+	return source;
+}
+function jsonSource(bytes, name) {
+	const source = sourceText(bytes, name);
+	try {
+		return JSON.parse(source);
+	} catch {
+		return fail$1("LAYA_ASSET_INVALID", `${name} is strict JSON`);
+	}
+}
+function canonicalManifestSource(value) {
+	const runtime = {
+		"@receptron/laya": value.runtime["@receptron/laya"],
+		"onnxruntime-node": value.runtime["onnxruntime-node"],
+		"@huggingface/tokenizers": value.runtime["@huggingface/tokenizers"]
+	};
+	const source = `${JSON.stringify({
+		manifestVersion: value.manifestVersion,
+		manifestId: value.manifestId,
+		source: value.source,
+		weights: value.weights,
+		files: value.files,
+		runtime,
+		context: value.context,
+		promptTemplates: value.promptTemplates
+	}, null, 2)}\n`;
+	const multilineTemplates = `  "promptTemplates": [\n${value.promptTemplates.map((id) => `    ${JSON.stringify(id)}`).join(",\n")}\n  ]`;
+	return source.replace(multilineTemplates, `  "promptTemplates": [${value.promptTemplates.map((id) => JSON.stringify(id)).join(", ")}]`);
+}
+function canonicalRuntimeLockSource(value) {
+	if ("blocked" in value) return `${JSON.stringify({
+		schemaVersion: 1,
+		blocked: value.blocked
+	}, null, 2)}\n`;
+	return `${JSON.stringify({
+		schemaVersion: 1,
+		packages: value.packages.map((pkg) => ({
+			name: pkg.name,
+			version: pkg.version,
+			url: pkg.url,
+			integrity: pkg.integrity,
+			files: Object.fromEntries(Object.entries(pkg.files).sort(([left], [right]) => rawByteCompare(left, right)).map(([platform, files]) => [platform, files]))
+		}))
+	}, null, 2)}\n`;
+}
+const REQUIRED_PREVIEW_LIMITATIONS = ["sandboxDeprecation", "englishAccuracy"];
+function disclosureText(value) {
+	const candidate = object(value, "the Laya enablement disclosures");
+	exactKeys(candidate, [
+		"schemaVersion",
+		"runtimeLicences",
+		"workerMemory",
+		"facts",
+		"limitations"
+	], "the Laya enablement disclosures");
+	if (candidate.schemaVersion !== 1) fail$1("LAYA_ASSET_INVALID", "the Laya enablement disclosures have version 1");
+	if (!Array.isArray(candidate.runtimeLicences) || candidate.runtimeLicences.length === 0) fail$1("LAYA_ASSET_INVALID", "the Laya runtime licences are reviewed");
+	const runtimeLicences = candidate.runtimeLicences.map((licence) => text$1(licence, "a Laya runtime licence"));
+	if (runtimeLicences.some((licence, index) => index > 0 && runtimeLicences[index - 1] >= licence)) fail$1("LAYA_ASSET_INVALID", "the Laya runtime licences are sorted and duplicate-free");
+	const facts = object(candidate.facts, "the Laya disclosure facts");
+	exactKeys(facts, [
+		"englishCpu",
+		"macosBoundary",
+		"linuxUnavailable",
+		"windowsUnavailable",
+		"downloadAfterApproval",
+		"oneAtATime"
+	], "the Laya disclosure facts");
+	const limitations = object(candidate.limitations, "the Laya disclosure limitations");
+	const reviewed = { limitations: Object.keys(limitations) };
+	if (!REQUIRED_PREVIEW_LIMITATIONS.every((fact) => reviewed.limitations.includes(fact))) fail$1("LAYA_ASSET_INVALID", "the Laya disclosure limitations are complete");
+	if (reviewed.limitations.length > REQUIRED_PREVIEW_LIMITATIONS.length) fail$1("LAYA_ASSET_INVALID", "the Laya disclosure limitations have no unreviewed fields");
+	for (const [name, disclosure] of Object.entries(limitations)) text$1(disclosure, `the ${name} Laya limitation`);
+	return {
+		runtimeLicences,
+		workerMemory: text$1(candidate.workerMemory, "the Laya worker memory disclosure"),
+		facts: {
+			englishCpu: text$1(facts.englishCpu, "the English Laya disclosure"),
+			macosBoundary: text$1(facts.macosBoundary, "the macOS Laya disclosure"),
+			linuxUnavailable: text$1(facts.linuxUnavailable, "the Linux Laya disclosure"),
+			windowsUnavailable: text$1(facts.windowsUnavailable, "the Windows Laya disclosure"),
+			downloadAfterApproval: text$1(facts.downloadAfterApproval, "the Laya download disclosure"),
+			oneAtATime: text$1(facts.oneAtATime, "the Laya concurrency disclosure")
+		},
+		limitations
+	};
+}
+function canonicalDisclosureSource(value) {
+	const source = `${JSON.stringify({
+		schemaVersion: 1,
+		runtimeLicences: value.runtimeLicences,
+		workerMemory: value.workerMemory,
+		facts: value.facts,
+		limitations: value.limitations
+	}, null, 2)}\n`;
+	const multilineRuntimeLicences = `${JSON.stringify(value.runtimeLicences, null, 2).split("\n").map((line, index) => index === 0 ? `  "runtimeLicences": ${line}` : `  ${line}`).join("\n")},`;
+	return source.replace(multilineRuntimeLicences, `  "runtimeLicences": ${JSON.stringify(value.runtimeLicences)},`);
+}
+function parseReviewedAssets(source) {
+	const manifestSource = sourceText(source.manifestBytes, "the Laya manifest");
+	const parsedManifest = manifest(jsonSource(source.manifestBytes, "the Laya manifest"));
+	if (canonicalManifestSource(parsedManifest) !== manifestSource) fail$1("LAYA_ASSET_INVALID", "the Laya manifest bytes are canonical");
+	const runtimeSource = sourceText(source.runtimeLockBytes, "the Laya runtime lock");
+	const parsedRuntimeLock = runtimeLock(jsonSource(source.runtimeLockBytes, "the Laya runtime lock"));
+	if (canonicalRuntimeLockSource(parsedRuntimeLock) !== runtimeSource) fail$1("LAYA_ASSET_INVALID", "the Laya runtime lock bytes are canonical");
+	const disclosuresSource = sourceText(source.disclosuresBytes, "the Laya enablement disclosures");
+	const disclosures = disclosureText(jsonSource(source.disclosuresBytes, "the Laya enablement disclosures"));
+	if (canonicalDisclosureSource(disclosures) !== disclosuresSource) fail$1("LAYA_ASSET_INVALID", "the Laya enablement disclosure bytes are canonical");
+	return {
+		manifest: parsedManifest,
+		runtimeLock: parsedRuntimeLock,
+		disclosures
+	};
+}
+function selectedPlatform(lock, probe) {
+	const id = `${PLATFORM_PREFIX}${probe.architecture}`;
+	const files = lock.packages.flatMap((pkg) => (pkg.files[id] ?? []).map((file) => ({
+		package: pkg.name,
+		...file
+	})));
+	if (files.length === 0) fail$1("LAYA_ASSET_INVALID", "the reviewed runtime lock has this macOS architecture");
+	return {
+		id,
+		files,
+		digest: sha256Hex(canonicalJson(files))
+	};
+}
+function completeRuntimeLock(lock, probe) {
+	const platform = selectedPlatform(lock, probe);
+	const packages = lock.packages.map(({ name, version, url, integrity }) => ({
+		name,
+		version,
+		url,
+		integrity
+	}));
+	return {
+		schemaVersion: 1,
+		packages,
+		platform,
+		digest: sha256Hex(canonicalJson({
+			schemaVersion: 1,
+			packages,
+			platform
+		}))
+	};
+}
+/**
+* E2 review round 1 (A5): whether this process runs under Rosetta. `sysctl.proc_translated` is 1 there (a translated
+* process's children run translated, `sysctl` among them), 0 natively, and absent on an Intel Mac whose macOS predates
+* it, which `-i` prints as nothing. Anything but a clean 0 or nothing counts as translated: no evidence covers a
+* translated worker, so Rosetta is never offered the Intel lock.
+*/
+function translatedByRosetta(probe) {
+	if (probe.platform !== "darwin") return false;
+	const options = {
+		cwd: "/",
+		env: { PATH: "/usr/bin:/bin" },
+		shell: false,
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		],
+		encoding: "utf8",
+		timeout: SANDBOX_PROBE_TIMEOUT_MS,
+		killSignal: "SIGKILL"
+	};
+	try {
+		const result = probe.spawnSync?.(SYSCTL, ROSETTA_QUERY, options) ?? spawnSync(SYSCTL, ROSETTA_QUERY, {
+			...options,
+			stdio: [...options.stdio]
+		});
+		if (result.status !== 0 || result.signal !== null || result.error !== void 0) return true;
+		const answer = String(result.stdout ?? "").trim();
+		return answer !== "0" && answer !== "";
+	} catch {
+		return true;
+	}
+}
+/** The Task 1 availability probe is separate from Task 7's per-child proof and intentionally content-free. */
+function sandboxExecAvailable(probe) {
+	if (probe.platform !== "darwin") return false;
+	const options = {
+		cwd: "/",
+		env: { PATH: "/usr/bin:/bin" },
+		shell: false,
+		stdio: "ignore",
+		timeout: SANDBOX_PROBE_TIMEOUT_MS,
+		killSignal: "SIGKILL"
+	};
+	try {
+		const result = probe.spawnSync?.("/usr/bin/sandbox-exec", [
+			"-p",
+			"(version 1) (allow default) (deny network*)",
+			SANDBOX_TRIVIAL_PROGRAM
+		], options) ?? spawnSync("/usr/bin/sandbox-exec", [
+			"-p",
+			"(version 1) (allow default) (deny network*)",
+			SANDBOX_TRIVIAL_PROGRAM
+		], options);
+		return result.status === 0 && result.signal === null && result.error === void 0;
+	} catch {
+		return false;
+	}
+}
+function available(assets, probe) {
+	const lock = assets.runtimeLock;
+	if ("blocked" in lock) return {
+		available: false,
+		code: lock.blocked
+	};
+	if (probe.platform !== "darwin") return {
+		available: false,
+		code: "LAYA_PLATFORM_UNAVAILABLE"
+	};
+	if (translatedByRosetta(probe)) return {
+		available: false,
+		code: "LAYA_PLATFORM_UNAVAILABLE"
+	};
+	if (!sandboxExecAvailable(probe)) return {
+		available: false,
+		code: "LAYA_SANDBOX_UNAVAILABLE"
+	};
+	try {
+		selectedPlatform(lock, probe);
+	} catch {
+		return {
+			available: false,
+			code: "LAYA_PLATFORM_UNAVAILABLE"
+		};
+	}
+	return { available: true };
+}
+function assertAvailable(assets, probe) {
+	const state = available(assets, probe);
+	if (!state.available) fail$1(state.code, "the reviewed Laya runtime is unavailable before enablement preparation");
+	const lock = assets.runtimeLock;
+	if ("blocked" in lock) fail$1(lock.blocked, "the reviewed Laya runtime lock is blocked");
+	return lock;
+}
+function disclosures(reviewedDisclosure, runtime, parsedManifest) {
+	const modelBytes = parsedManifest.files.reduce((sum, file) => sum + file.size, 0);
+	const runtimeBytes = runtime.platform.files.reduce((sum, file) => sum + file.size, 0);
+	const facts = [...{ facts: [
+		reviewedDisclosure.facts.englishCpu,
+		reviewedDisclosure.facts.macosBoundary,
+		reviewedDisclosure.facts.linuxUnavailable,
+		reviewedDisclosure.facts.windowsUnavailable,
+		reviewedDisclosure.facts.downloadAfterApproval,
+		reviewedDisclosure.facts.oneAtATime
+	] }.facts];
+	return {
+		modelBytes,
+		runtimeBytes,
+		runtimeLicences: reviewedDisclosure.runtimeLicences,
+		workerMemory: reviewedDisclosure.workerMemory,
+		facts: {
+			englishCpu: facts[0],
+			macosBoundary: facts[1],
+			linuxUnavailable: facts[2],
+			windowsUnavailable: facts[3],
+			downloadAfterApproval: facts[4],
+			oneAtATime: facts[5]
+		},
+		limitations: reviewedDisclosure.limitations
+	};
+}
+/**
+* The concrete E2 replacement for Phase E's opaque slot. Tests may inject only canonical synthetic asset bytes and
+* the sandbox spawn; production supplies the shipped bytes and never accepts a caller path, manifest, lock, template
+* or prebuilt definition.
+*/
+function createLayaJudgeKindDefinition(input) {
+	const assets = parseReviewedAssets(input.assets);
+	const parsedManifest = assets.manifest;
+	const status = () => available(assets, input.platform);
+	const modelBytes = parsedManifest.files.reduce((sum, file) => sum + file.size, 0);
+	const unavailableStatus = () => {
+		const availability = status();
+		return {
+			state: "unavailable",
+			manifestId: parsedManifest.manifestId,
+			runtimeLockDigest: null,
+			bytesVerified: 0,
+			totalBytes: modelBytes,
+			failureCode: null,
+			reason: availability.available ? "E2_EXTERNAL_REFERENCE_BLOCKED" : availability.code,
+			updatedAt: null
+		};
+	};
+	const preview = ({ version }) => {
+		if (!Number.isSafeInteger(version) || version < 1) fail$1("LAYA_ENABLEMENT_EXACT", "a Laya enablement version is positive");
+		const lock = assets.runtimeLock;
+		if ("blocked" in lock) fail$1(lock.blocked, "the reviewed Laya runtime lock is blocked");
+		const complete = completeRuntimeLock(lock, input.platform);
+		return {
+			id: `judge-kind:${LAYA_KIND}`,
+			kind: LAYA_KIND,
+			version,
+			manifest: parsedManifest,
+			runtimeLock: complete,
+			disclosures: disclosures(assets.disclosures, complete, parsedManifest)
+		};
+	};
+	const prepareEnablement = ({ version }) => {
+		assertAvailable(assets, input.platform);
+		return preview({ version });
+	};
+	return {
+		kind: LAYA_KIND,
+		availability: status,
+		judgeTerms: () => ({
+			manifestId: parsedManifest.manifestId,
+			promptTemplates: parsedManifest.promptTemplates,
+			facts: assets.disclosures.facts,
+			limitations: assets.disclosures.limitations
+		}),
+		prepareEnablement,
+		canonicalEnablement(value) {
+			const candidate = object(value, "the Laya enablement");
+			const { manifestPath, modelPath, template, ...reviewed } = candidate;
+			if (manifestPath !== void 0 || modelPath !== void 0 || template !== void 0) fail$1("LAYA_ENABLEMENT_EXACT", "a Laya enablement cannot select a manifest, path or template");
+			const version = positive(candidate.version, "the Laya enablement version");
+			const expected = preview({ version });
+			if (canonicalJson(reviewed) !== canonicalJson(expected)) fail$1("LAYA_ENABLEMENT_EXACT", "a Laya enablement must embed exactly the reviewed assets and disclosures");
+			return expected;
+		},
+		preview,
+		async onEnabled(_enablement, _activation) {
+			return unavailableStatus();
+		},
+		async execute(_request, _reservation) {
+			return fail$1("E2_EXTERNAL_REFERENCE_BLOCKED", "the Laya worker adapter is not installed");
+		},
+		async onWorkPurged(_scope) {},
+		async onDisabled() {},
+		status() {
+			return unavailableStatus();
+		},
+		async removeWhenDisabled() {
+			return unavailableStatus();
+		}
+	};
 }
 //#endregion
 //#region src/domain/webhook-target.ts
@@ -670,4 +1204,4 @@ function webhookDeliveryTarget(document) {
 	};
 }
 //#endregion
-export { EventDomainError as a, JUDGE_KIND_LOCAL_ENDPOINT as c, isJudgeKind as d, validateLocalEndpoint as f, parseIpLiteral as g, assertApprovedAddressSet as h, webhookDeliveryTarget as i, JUDGE_KIND_TYPESAFE as l, assertAddressAllowed as m, canonicalWebhookTarget as n, JUDGE_KINDS as o, AddressPolicyError as p, secretWebhookUrlDescriptor as r, JUDGE_KIND_LAYA as s, canonicalSecretWebhookUrl as t, assertJudgeKindEnabled as u };
+export { JUDGE_KIND_TYPESAFE as _, LAYA_MODEL_FAILURE_CODES as a, validateLocalEndpoint as c, assertApprovedAddressSet as d, parseIpLiteral as f, JUDGE_KIND_LOCAL_ENDPOINT as g, JUDGE_KIND_LAYA as h, webhookDeliveryTarget as i, AddressPolicyError as l, JUDGE_KINDS as m, canonicalWebhookTarget as n, LayaContractError as o, EventDomainError as p, secretWebhookUrlDescriptor as r, createLayaJudgeKindDefinition as s, canonicalSecretWebhookUrl as t, assertAddressAllowed as u, assertJudgeKindEnabled as v, isJudgeKind as y };