@agentcomms/events-daemon 0.24.0 → 0.25.0

package/dist/index.d.mts

@@ -11574,6 +11574,141 @@ declare const JUDGE_KIND_LOCAL_ENDPOINT: "local-endpoint";
 declare const JUDGE_KINDS: readonly [typeof JUDGE_KIND_TYPESAFE, typeof JUDGE_KIND_LAYA, typeof JUDGE_KIND_LOCAL_ENDPOINT];
 type JudgeKind = (typeof JUDGE_KINDS)[number];
 //#endregion
+//#region src/domain/source-options.d.ts
+interface GmailSourceOptions {
+  readonly channel: "gmail";
+  readonly labels: readonly string[] | "inbox" | "any";
+  readonly includeSpamTrash: boolean;
+}
+interface SlackSourceOptions {
+  readonly channel: "slack";
+  readonly conversations: readonly string[];
+}
+interface ResendSourceOptions {
+  readonly channel: "resend";
+  readonly kinds: readonly ("received" | "status")[];
+}
+interface WhatsAppSourceOptions {
+  readonly channel: "whatsapp";
+  readonly chats: readonly string[] | "all-allowed";
+}
+type SourceOptions = GmailSourceOptions | SlackSourceOptions | ResendSourceOptions | WhatsAppSourceOptions;
+//#endregion
+//#region src/domain/webhook-target.d.ts
+interface PlainWebhookUrl {
+  readonly kind: "plain";
+  readonly value: string;
+}
+interface SecretWebhookUrl {
+  readonly kind: "secret";
+  readonly scheme: "http" | "https";
+  readonly host: string;
+  readonly port: number;
+  readonly sha256: string;
+}
+interface WebhookTargetDocument {
+  readonly targetId: string;
+  readonly version: number;
+  readonly kind: "webhook";
+  readonly url: PlainWebhookUrl | SecretWebhookUrl;
+  readonly approvedAddressSet: readonly string[];
+  readonly signing: "standard-webhooks";
+  readonly ordering: "strict";
+  readonly retryLimit: number;
+  readonly representation: "plain" | "enveloped";
+}
+//#endregion
+//#region src/runtime/laya/contracts.d.ts
+declare const LAYA_KIND: (typeof JUDGE_KINDS)[1];
+interface LayaManifestFile {
+  readonly path: string;
+  readonly size: number;
+  readonly sha256: string;
+}
+interface CanonicalLayaManifest {
+  readonly manifestVersion: 1;
+  readonly manifestId: string;
+  readonly source: {
+    readonly host: "huggingface.co";
+    readonly repo: string;
+    readonly revision: string;
+  };
+  readonly weights: {
+    readonly publisher: string;
+    readonly origin: string;
+    readonly originSha256: string;
+    readonly licence: string;
+  };
+  readonly files: readonly LayaManifestFile[];
+  readonly runtime: Readonly<Record<string, string>>;
+  readonly context: {
+    readonly maxTokens: 512;
+    readonly language: "en";
+  };
+  readonly promptTemplates: readonly string[];
+}
+interface LayaRuntimeFile {
+  readonly path: string;
+  readonly size: number;
+  readonly sha256: string;
+  readonly executable: boolean;
+}
+interface CanonicalLayaRuntimeLock {
+  readonly schemaVersion: 1;
+  readonly packages: readonly {
+    readonly name: string;
+    readonly version: string;
+    readonly url: string;
+    readonly integrity: string;
+  }[];
+  readonly platform: {
+    readonly id: string;
+    readonly files: readonly (LayaRuntimeFile & {
+      readonly package: string;
+    })[];
+    readonly digest: string;
+  };
+  readonly digest: string;
+}
+interface CanonicalLayaEnablement {
+  readonly id: `judge-kind:${typeof LAYA_KIND}`;
+  readonly kind: typeof LAYA_KIND;
+  readonly version: number;
+  readonly manifest: CanonicalLayaManifest;
+  readonly runtimeLock: CanonicalLayaRuntimeLock;
+  readonly disclosures: CanonicalLayaEnablementDisclosures;
+}
+interface CanonicalLayaEnablementDisclosures {
+  readonly modelBytes: number;
+  readonly runtimeBytes: number;
+  readonly runtimeLicences: readonly string[];
+  readonly workerMemory: string;
+  readonly facts: Readonly<{
+    readonly englishCpu: string;
+    readonly macosBoundary: string;
+    readonly linuxUnavailable: string;
+    readonly windowsUnavailable: string;
+    readonly downloadAfterApproval: string;
+    readonly oneAtATime: string;
+  }>;
+  readonly limitations: Readonly<{
+    readonly sandboxDeprecation: string;
+    readonly englishAccuracy: string;
+  }>;
+}
+//#endregion
+//#region src/runtime/laya/templates.d.ts
+/**
+ * Laya's two immutable prompt templates (E2-2, D11). The reviewed manifest lists which of them a release offers; their
+ * content lives here, in the daemon's worker source, so a semantic change is a new id and a new manifest entry, never
+ * an edit. Each has a stable SHA-256 over its canonical content, which the D11 gate subject binds.
+ *
+ * This module is loaded inside the isolated worker as well as by the daemon: it imports Node built-ins only.
+ */
+declare const LAYA_NOUL_TEMPLATE_ID: "laya-noul-v1";
+declare const LAYA_CHOICE2_TEMPLATE_ID: "laya-choice2-v1";
+type LayaTemplateId = typeof LAYA_NOUL_TEMPLATE_ID | typeof LAYA_CHOICE2_TEMPLATE_ID;
+//#endregion
 //#region src/domain/judges.d.ts
 declare const TYPESAFE_SYSTEM_ONE_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
 declare const JUDGE_BUDGET_ID = "judge-budget";
@@ -11606,7 +11741,20 @@ type LocalEndpointJudgeDocument = (LocalEndpointJudgeBase & {
   readonly protocol: "json-score";
   readonly scorePointer: string;
 });
-type CanonicalJudgeDocument = TypeSafeJudgeDocument | LocalEndpointJudgeDocument;
+/**
+ * A Laya judge (D2, D11): the canonical Laya provider, the reviewed manifest entry in the endpoint's place — with one
+ * model per entry it is also the model, so the document names it once, as `model` — and one of the two immutable
+ * prompt templates. Execution refuses it unless that entry is the enabled one and lists the template.
+ */
+interface LayaJudgeDocument {
+  readonly judgeId: string;
+  readonly version: number;
+  readonly kind: typeof JUDGE_KIND_LAYA;
+  readonly provider: typeof JUDGE_KIND_LAYA;
+  readonly model: string;
+  readonly promptTemplate: LayaTemplateId;
+}
+type CanonicalJudgeDocument = TypeSafeJudgeDocument | LocalEndpointJudgeDocument | LayaJudgeDocument;
 interface JudgeBudgetLimits {
   readonly callsPerRollingHour: number;
   readonly inputTokensPerRolling30Days: number;
@@ -11629,27 +11777,7 @@ type CanonicalJudgeKindEnablementDocument = {
   readonly id: "judge-kind:local-endpoint";
   readonly kind: typeof JUDGE_KIND_LOCAL_ENDPOINT;
   readonly version: number;
-};
-//#endregion
-//#region src/domain/source-options.d.ts
-interface GmailSourceOptions {
-  readonly channel: "gmail";
-  readonly labels: readonly string[] | "inbox" | "any";
-  readonly includeSpamTrash: boolean;
-}
-interface SlackSourceOptions {
-  readonly channel: "slack";
-  readonly conversations: readonly string[];
-}
-interface ResendSourceOptions {
-  readonly channel: "resend";
-  readonly kinds: readonly ("received" | "status")[];
-}
-interface WhatsAppSourceOptions {
-  readonly channel: "whatsapp";
-  readonly chats: readonly string[] | "all-allowed";
-}
-type SourceOptions = GmailSourceOptions | SlackSourceOptions | ResendSourceOptions | WhatsAppSourceOptions;
+} | CanonicalLayaEnablement;
 //#endregion
 //#region src/domain/sse-subscriber.d.ts
 interface SseSubscriberDocument {
@@ -11672,30 +11800,6 @@ interface SseTargetDocument {
   readonly representation: "plain" | "enveloped";
 }
 //#endregion
-//#region src/domain/webhook-target.d.ts
-interface PlainWebhookUrl {
-  readonly kind: "plain";
-  readonly value: string;
-}
-interface SecretWebhookUrl {
-  readonly kind: "secret";
-  readonly scheme: "http" | "https";
-  readonly host: string;
-  readonly port: number;
-  readonly sha256: string;
-}
-interface WebhookTargetDocument {
-  readonly targetId: string;
-  readonly version: number;
-  readonly kind: "webhook";
-  readonly url: PlainWebhookUrl | SecretWebhookUrl;
-  readonly approvedAddressSet: readonly string[];
-  readonly signing: "standard-webhooks";
-  readonly ordering: "strict";
-  readonly retryLimit: number;
-  readonly representation: "plain" | "enveloped";
-}
-//#endregion
 //#region src/domain/activation-documents.d.ts
 interface DryRunTargetDocument {
   readonly targetId: string;
@@ -12800,7 +12904,8 @@ interface B3ApprovalPreviewTerminalView {
 }
 /**
  * The terminal and desktop fixture boundary. This formats only daemon-authored identifiers and a canonical, neutralised
- * preview representation; it never consumes a secret operation or claims the approval.
+ * preview representation; it never consumes a secret operation or claims the approval. A B3 v3 rule preview naming a
+ * Laya judge also carries D11's Laya limits, rendered after the preview.
  */
 export declare function renderB3ApprovalPreviewV1(value: unknown): B3ApprovalPreviewTerminalView;
 interface B3ControlContract {

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { R as createEventsMcpServer, X as status, a as B3_CONTROL_V1_OPERATION_SPECS, c as B3_CONTROL_V1_SUCCESSOR_REQUIREMENT, d as B3_SECRET_TERMINAL_ORIGIN, i as B3_CONTROL_ERROR_CODES, l as B3_DESKTOP_CONTROL_OPERATIONS, m as renderB3ApprovalPreviewV1, n as B3_CAPABILITIES, o as B3_CONTROL_V1_RESULT_OPERATIONS, r as B3_CONTROL_CONTRACT, s as B3_CONTROL_V1_SCHEMA_VERSION, t as B3_APPROVAL_VIEW_VARIANTS, u as B3_JUDGE_UNAVAILABLE_VARIANTS } from "./b3-contract-C1q5aekF.mjs";
+import { K as createEventsMcpServer, a as B3_CONTROL_V1_OPERATION_SPECS, c as B3_CONTROL_V1_SUCCESSOR_REQUIREMENT, d as B3_SECRET_TERMINAL_ORIGIN, i as B3_CONTROL_ERROR_CODES, it as status, l as B3_DESKTOP_CONTROL_OPERATIONS, m as renderB3ApprovalPreviewV1, n as B3_CAPABILITIES, o as B3_CONTROL_V1_RESULT_OPERATIONS, r as B3_CONTROL_CONTRACT, s as B3_CONTROL_V1_SCHEMA_VERSION, t as B3_APPROVAL_VIEW_VARIANTS, u as B3_JUDGE_UNAVAILABLE_VARIANTS } from "./b3-contract-ByO1DTgr.mjs";
 export { B3_APPROVAL_VIEW_VARIANTS, B3_CAPABILITIES, B3_CONTROL_CONTRACT, B3_CONTROL_ERROR_CODES, B3_CONTROL_V1_OPERATION_SPECS, B3_CONTROL_V1_RESULT_OPERATIONS, B3_CONTROL_V1_SCHEMA_VERSION, B3_CONTROL_V1_SUCCESSOR_REQUIREMENT, B3_DESKTOP_CONTROL_OPERATIONS, B3_JUDGE_UNAVAILABLE_VARIANTS, B3_SECRET_TERMINAL_ORIGIN, createEventsMcpServer, renderB3ApprovalPreviewV1, status };

package/dist/laya-worker.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/laya-worker.mjs

@@ -0,0 +1,356 @@
+import { _ as layaTemplate, f as writeWorkerFrame, g as layaLayout, h as isLayaTemplateId, i as assertWorkerLoadBinding, l as WorkerFrameParser, o as runWorkerBoundaryProbe, r as assertNoProbeSocketsRemain, s as sealWorkerNetworkAfterProbe } from "./worker-boundary-probe-CFN6EsyK.mjs";
+import { readFile } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/runtime/laya/worker-runtime.ts
+/** The sequence's own markers: `[CLS]`, the head's `[SEP]`, and the `[SEP]` either side of the state. */
+const LAYA_SEQUENCE_MARKERS = 4;
+/** The one question each request asks; the name is not part of the rendered sequence. */
+const LAYA_QUESTION_NAME = "decision";
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function exactKeys(value, keys) {
+	const found = Object.keys(value).sort();
+	const expected = [...keys].sort();
+	return found.length === expected.length && found.every((key, index) => key === expected[index]);
+}
+function normalAbsolute(value) {
+	return typeof value === "string" && value.length > 0 && isAbsolute(value) && resolve(value) === value;
+}
+function layaLoadPayload(value) {
+	if (!isRecord(value) || !exactKeys(value, ["runtimeRoot", "modelDir"])) return null;
+	if (!normalAbsolute(value.runtimeRoot) || !normalAbsolute(value.modelDir)) return null;
+	return {
+		runtimeRoot: value.runtimeRoot,
+		modelDir: value.modelDir
+	};
+}
+function layaWorkerRequest(value) {
+	if (!isLayaTemplateId(value.templateId)) return null;
+	if (typeof value.instructions !== "string" || value.instructions.length === 0) return null;
+	if (typeof value.state !== "string" || value.state.length === 0) return null;
+	return {
+		templateId: value.templateId,
+		instructions: value.instructions,
+		state: value.state
+	};
+}
+function tokens(runtime, text) {
+	const counted = runtime.countTokens(text);
+	if (!Number.isSafeInteger(counted) || counted < 0) throw new Error("the Laya tokenizer count is not a token count");
+	return counted;
+}
+/**
+* The exact length of the sequence the runtime would build, counted over the complete, uncut layout, or null when it
+* would cut anything: an option over 48 tokens, a head over its 192-token budget, or a sequence over 512. (The
+* runtime's further cut of options that leave the head under a 16-token reserve cannot apply to a two-option
+* template whose options are each within 48; a template with more options is a new id and a new review.) Within these
+* bounds nothing is cut, so the runtime's own `usage.input_tokens` must equal this count (hf-laya-onnx-config).
+*/
+function layaSequenceTokens(runtime, request) {
+	const layout = layaLayout(request.templateId, request);
+	const head = tokens(runtime, layout.head);
+	const options = layout.options.map((option) => tokens(runtime, option));
+	const state = tokens(runtime, layout.state);
+	const optionTokens = options.reduce((sum, count) => sum + count, 0);
+	if (options.some((count) => count > 48)) return null;
+	if (2 + head + options.length + optionTokens > 192) return null;
+	const sequence = head + options.length + optionTokens + state + LAYA_SEQUENCE_MARKERS;
+	return sequence > 512 ? null : sequence;
+}
+/**
+* Reads one `noul` answer where System One puts it — `answers.<name>.noul` — exactly as the runtime returns it, after
+* the checks D5 makes: a finite number in [0, 1], never clamped. The usage must be the uncut count with no output
+* tokens (npm-receptron-laya-0.1.2-output), or the runtime cut something and the answer is malformed.
+*/
+function noulValue(answer, sequenceTokens) {
+	if (!isRecord(answer) || !isRecord(answer.answers) || !isRecord(answer.usage)) return null;
+	if (!exactKeys(answer.answers, ["decision"])) return null;
+	const decision = answer.answers[LAYA_QUESTION_NAME];
+	if (!isRecord(decision) || decision.type !== "noul") return null;
+	const value = decision.noul;
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) return null;
+	if (answer.usage.input_tokens !== sequenceTokens || answer.usage.output_tokens !== 0) return null;
+	return value;
+}
+/**
+* One request: count, refuse rather than let the runtime cut, ask, check. `laya-choice2-v1` is laid out and counted
+* like any template but refuses before the runtime is asked: System One's `choice` `criteria` shape is "not stated"
+* in the Phase E provider record, and the Task 8 record names neither it nor where the runtime puts a choice's
+* probabilities, so building or reading that wire would be an inference. It stays `template-blocked` until a record
+* names both.
+*/
+async function evaluateLayaRequest(runtime, request) {
+	let sequenceTokens;
+	try {
+		sequenceTokens = layaSequenceTokens(runtime, request);
+	} catch {
+		return {
+			kind: "refused",
+			code: "malformed"
+		};
+	}
+	if (sequenceTokens === null) return {
+		kind: "refused",
+		code: "token-limit"
+	};
+	if (layaTemplate(request.templateId).type !== "noul") return {
+		kind: "refused",
+		code: "template-blocked"
+	};
+	const questions = Object.create(null);
+	questions[LAYA_QUESTION_NAME] = {
+		type: "noul",
+		instructions: request.instructions
+	};
+	let answer;
+	try {
+		answer = await runtime.systemOne(request.state, questions);
+	} catch {
+		return {
+			kind: "refused",
+			code: "malformed"
+		};
+	}
+	const value = noulValue(answer, sequenceTokens);
+	return value === null ? {
+		kind: "refused",
+		code: "malformed"
+	} : {
+		kind: "answer",
+		value,
+		inputTokens: sequenceTokens
+	};
+}
+/**
+* Exactly the verified model directory and the CPU provider (D11's `Laya.load({ modelDir, executionProviders: ["cpu"] })`).
+* With `modelDir` set the package never calls its downloader, and no repo, revision, token, cache directory, progress
+* callback or session option is passed, so neither a download nor a provider override is reachable
+* (npm-receptron-laya-0.1.2-load, npm-receptron-laya-0.1.2-download).
+*/
+function layaLoadOptions(modelDir) {
+	return {
+		modelDir,
+		executionProviders: ["cpu"]
+	};
+}
+/** The module that defines `Laya.load` inside the verified runtime tree (npm-receptron-laya-0.1.2-load). */
+const LAYA_RUNTIME_MODULE = "node_modules/@receptron/laya/dist/laya.js";
+/** The tokenizer package `Laya.load` builds its tokenizer from (npm-receptron-laya-0.1.2-load). */
+const LAYA_TOKENIZERS_PACKAGE = "node_modules/@huggingface/tokenizers";
+function within(root, path) {
+	const offset = relative(root, path);
+	return offset.length > 0 && !offset.startsWith("..") && !isAbsolute(offset) && !offset.split(sep).includes("..");
+}
+/**
+* The worker's one computed import: an absolute file URL inside the tree the daemon verified just before this start.
+* There is no package-name fallback — nothing resolves through the daemon's own `node_modules` — and phase E's
+* static check admits exactly this call, in exactly this file.
+*/
+async function importVerified(root, entry) {
+	const verifiedEntry = resolve(root, entry);
+	if (!within(root, verifiedEntry)) throw new Error("the Laya runtime entry is outside its verified tree");
+	return await import(pathToFileURL(verifiedEntry).href);
+}
+async function jsonFile(path) {
+	return JSON.parse(await readFile(path, "utf8"));
+}
+function relativeEntry(value) {
+	if (typeof value !== "string") return null;
+	const entry = value.startsWith("./") ? value.slice(2) : value;
+	if (entry.length === 0 || entry.includes("\\") || entry.includes("\0") || entry.startsWith("/")) return null;
+	return entry.split("/").some((part) => part === "" || part === "." || part === "..") ? null : entry;
+}
+/** Node's package entry for an ES module import, over a closed subset of `package.json` forms; anything else fails. */
+function moduleEntry(manifest) {
+	if (!isRecord(manifest)) return null;
+	const exported = manifest.exports;
+	if (exported !== void 0) {
+		const root = isRecord(exported) && Object.hasOwn(exported, ".") ? exported["."] : exported;
+		if (typeof root === "string") return relativeEntry(root);
+		if (!isRecord(root)) return null;
+		const imported = root.import;
+		if (typeof imported === "string") return relativeEntry(imported);
+		if (isRecord(imported) && typeof imported.default === "string") return relativeEntry(imported.default);
+		return relativeEntry(root.default);
+	}
+	return relativeEntry(manifest.module ?? manifest.main);
+}
+/**
+* Loads the runtime from the daemon-verified trees: the model's own context limits, the bundle's tokenizer, and
+* `Laya.load` with only `layaLoadOptions`. Any shape it does not recognise refuses the load; it never falls back.
+*/
+async function loadVerifiedLayaRuntime(payload) {
+	const config = await jsonFile(resolve(payload.modelDir, "laya_config.json"));
+	if (!isRecord(config) || config.max_len !== 512 || config.head_max_len !== 192) throw new Error("the verified Laya model does not have its reviewed context limits");
+	const tokenizerJson = await jsonFile(resolve(payload.modelDir, "tokenizer", "tokenizer.json"));
+	const tokenizerConfig = await jsonFile(resolve(payload.modelDir, "tokenizer", "tokenizer_config.json"));
+	const tokenizersEntry = moduleEntry(await jsonFile(resolve(payload.runtimeRoot, LAYA_TOKENIZERS_PACKAGE, "package.json")));
+	if (tokenizersEntry === null) throw new Error("the verified tokenizer package has no module entry");
+	const tokenizers = await importVerified(payload.runtimeRoot, `${LAYA_TOKENIZERS_PACKAGE}/${tokenizersEntry}`);
+	if (typeof tokenizers.Tokenizer !== "function") throw new Error("the verified tokenizer package has no Tokenizer");
+	const tokenizer = new tokenizers.Tokenizer(tokenizerJson, tokenizerConfig);
+	if (typeof tokenizer.encode !== "function") throw new Error("the verified tokenizer cannot encode");
+	const encode = tokenizer.encode.bind(tokenizer);
+	const countTokens = (text) => {
+		const encoded = encode(text, { add_special_tokens: false });
+		const ids = isRecord(encoded) ? encoded.ids : void 0;
+		if (!Array.isArray(ids) || !ids.every((id) => Number.isSafeInteger(id))) throw new Error("the verified tokenizer returned no token ids");
+		return ids.length;
+	};
+	countTokens("boundary");
+	const runtime = (await importVerified(payload.runtimeRoot, LAYA_RUNTIME_MODULE)).Laya;
+	if (runtime === void 0 || runtime === null || typeof runtime.load !== "function") throw new Error("the verified runtime has no Laya.load");
+	const loaded = await runtime.load.call(runtime, layaLoadOptions(payload.modelDir));
+	if (loaded === null || typeof loaded.systemOne !== "function" || typeof loaded.close !== "function") throw new Error("the verified runtime did not load a System One model");
+	const systemOne = loaded.systemOne.bind(loaded);
+	const close = loaded.close.bind(loaded);
+	return {
+		countTokens,
+		systemOne: (state, questions) => systemOne(state, questions),
+		close: async () => {
+			await close();
+		}
+	};
+}
+//#endregion
+//#region src/runtime/laya/worker-main.ts
+function bindingFromProbe(frame) {
+	if (typeof frame.nonce !== "string" || typeof frame.pid !== "number" || !Number.isSafeInteger(frame.pid) || typeof frame.profile !== "string" || typeof frame.entry !== "string" || typeof frame.pipeGeneration !== "string" || typeof frame.tcpPort !== "number" || !Number.isSafeInteger(frame.tcpPort) || typeof frame.udpPort !== "number" || !Number.isSafeInteger(frame.udpPort) || typeof frame.udsPath !== "string") return null;
+	return {
+		nonce: frame.nonce,
+		pid: frame.pid,
+		profile: frame.profile,
+		entry: frame.entry,
+		pipeGeneration: frame.pipeGeneration,
+		tcpPort: frame.tcpPort,
+		udpPort: frame.udpPort,
+		udsPath: frame.udsPath
+	};
+}
+/** The probe must name this very process: its PID, the entry Node is running and the reviewed profile. */
+function namesThisWorker(probe) {
+	return probe.pid === process.pid && probe.entry === process.argv[1] && probe.profile === "(version 1) (allow default) (deny network*)";
+}
+/** Only the exact binding of the proven child, and these fields, may arrive on a request frame. */
+const REQUEST_FIELDS = [
+	"type",
+	"nonce",
+	"pid",
+	"profile",
+	"entry",
+	"pipeGeneration",
+	"requestId",
+	"templateId",
+	"instructions",
+	"state"
+];
+function requestFrame(binding, frame) {
+	const keys = Object.keys(frame).sort();
+	const expected = [...REQUEST_FIELDS].sort();
+	if (frame.type !== "request" || keys.length !== expected.length || keys.some((key, index) => key !== expected[index]) || frame.nonce !== binding.nonce || frame.pid !== binding.pid || frame.profile !== binding.profile || frame.entry !== binding.entry || frame.pipeGeneration !== binding.pipeGeneration || typeof frame.requestId !== "string" || frame.requestId.length === 0) return null;
+	const request = layaWorkerRequest(frame);
+	return request === null ? null : {
+		requestId: frame.requestId,
+		request
+	};
+}
+async function rejectAndExit() {
+	process.exitCode = 70;
+	process.stdin.destroy();
+	throw new Error("worker protocol");
+}
+const parser = new WorkerFrameParser();
+let binding;
+/** The load frame is answered exactly once: `loaded`, or `load-refused` after which every frame ends the worker. */
+let loadAnswered = false;
+let runtime;
+let work = Promise.resolve();
+process.stdin.on("data", (chunk) => {
+	work = work.then(async () => {
+		for (const frame of parser.push(chunk)) {
+			if (binding === void 0) {
+				const probe = frame.type === "probe" ? bindingFromProbe(frame) : null;
+				if (probe === null || !namesThisWorker(probe)) return rejectAndExit();
+				const result = await runWorkerBoundaryProbe(probe, async (attempt, outcome) => {
+					await writeWorkerFrame(process.stdout, {
+						type: "probe-attempt",
+						...probe,
+						attempt,
+						outcome
+					});
+				});
+				sealWorkerNetworkAfterProbe();
+				await assertNoProbeSocketsRemain();
+				binding = {
+					nonce: probe.nonce,
+					pid: probe.pid,
+					profile: probe.profile,
+					entry: probe.entry,
+					pipeGeneration: probe.pipeGeneration
+				};
+				await writeWorkerFrame(process.stdout, {
+					type: "probe-result",
+					...probe,
+					...result
+				});
+				continue;
+			}
+			if (!loadAnswered) {
+				try {
+					assertWorkerLoadBinding(binding, frame);
+				} catch {
+					await rejectAndExit();
+				}
+				loadAnswered = true;
+				const payload = layaLoadPayload(frame.payload);
+				try {
+					if (payload === null) throw new Error("load payload");
+					runtime = await loadVerifiedLayaRuntime(payload);
+				} catch {
+					await writeWorkerFrame(process.stdout, {
+						type: "load-refused",
+						...binding,
+						code: "runtime-failed"
+					});
+					continue;
+				}
+				await writeWorkerFrame(process.stdout, {
+					type: "loaded",
+					...binding
+				});
+				continue;
+			}
+			const request = runtime === void 0 ? null : requestFrame(binding, frame);
+			if (runtime === void 0 || request === null) return rejectAndExit();
+			const outcome = await evaluateLayaRequest(runtime, request.request);
+			await writeWorkerFrame(process.stdout, outcome.kind === "answer" ? {
+				type: "answer",
+				...binding,
+				requestId: request.requestId,
+				value: outcome.value,
+				inputTokens: outcome.inputTokens
+			} : {
+				type: "refused",
+				...binding,
+				requestId: request.requestId,
+				code: outcome.code
+			});
+		}
+	});
+	work.catch(() => {
+		process.exitCode = 70;
+		process.stdin.destroy();
+	});
+});
+process.stdin.on("end", () => {
+	try {
+		parser.finish();
+	} catch {
+		process.exitCode = 70;
+	}
+	if (runtime !== void 0) runtime.close().catch(() => void 0).finally(() => process.exit());
+});
+//#endregion
+export {};