@noopolis/daimon 0.1.1 → 0.2.0

package/dist/runtime/engineBrokerService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerService.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerService.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AAGlH,OAAO,EAA6B,KAAK,wBAAwB,EAAE,KAAK,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AACpI,MAAM,WAAW,yBAAyB;IACxC,IAAI,CAAC,OAAO,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,WAAW,EAAC,MAAM,EAAC,MAAM,CAAC,EAAC,WAAW,EAAC,MAAM,CAAC,EAAC,8BAA8B,GAAE,OAAO,CAAC,QAAQ,CAAC;QAAC,IAAI,EAAC,MAAM,CAAC;QAAA,SAAS,EAAC,MAAM,CAAC;QAAA,SAAS,EAAC,MAAM,CAAC;QAAA,eAAe,EAAC,MAAM,CAAA;KAAC,CAAC,GAAC,0BAA0B,CAAC,CAAC;IACpP,SAAS,IAAG,QAAQ,CAAC;QAAC,iBAAiB,EAAC,MAAM,CAAC;QAAA,aAAa,EAAC,MAAM,CAAC;QAAA,aAAa,EAAC,MAAM,CAAC;QAAA,eAAe,EAAC,OAAO,CAAC;QAAA,UAAU,EAAC,OAAO,CAAC;QAAA,eAAe,EAAC,OAAO,CAAA;KAAC,CAAC,CAAC;IAC9J,KAAK,IAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,yJAAyJ;IACzJ,qBAAqB,CAAC,CAAC,OAAO,EAAC,yBAAyB,GAAE,wBAAwB,CAAC;IACnF,qBAAqB,CAAC,CAAC,OAAO,EAAC,MAAM,GAAE,OAAO,CAAC;CAChD;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAC,yBAAyB,EAAC,UAAU,SAAyC;;;;;;GAE5H;AACD,wBAAsB,oCAAoC,CAAC,MAAM,EAAC,yBAAyB,EAAC,UAAU,EAAC,MAAM,EAAC,WAAW,EAAC,MAAM;;;;;;GAK/H"}

package/dist/runtime/engineBrokerService.js

@@ -0,0 +1,138 @@
+import { chmod, lstat, unlink } from "node:fs/promises";
+import { createServer } from "node:net";
+import { encodeEngineBrokerFrame, EngineBrokerFrameDecoder, parseEngineBrokerRequest } from "./engineBrokerProtocol.js";
+import { EngineBrokerTurnFailure } from "./grokEngineBroker.js";
+import { GROK_INFERENCE_PROXY_BASE_URL } from "./engineBrokerInferenceProtocol.js";
+import { GrokInferenceGrantRefused } from "./grokInferenceGrants.js";
+export function startEngineBrokerService(broker, socketPath = "/run/daimon-engine-broker/backend.sock") {
+    return startEngineBrokerServiceWithIdentity(broker, socketPath, 2100);
+}
+export async function startEngineBrokerServiceWithIdentity(broker, socketPath, expectedUid) {
+    if (process.getuid?.() !== expectedUid)
+        throw new Error("engine broker service requires broker identity");
+    await removeOwnedSocket(socketPath, expectedUid);
+    const active = new Map(), connections = new Set();
+    const server = createServer((socket) => { connections.add(socket); socket.once("close", () => connections.delete(socket)); handle(socket, broker, active); });
+    await listen(server, socketPath);
+    try {
+        await chmod(socketPath, 0o600);
+        await verifySocket(socketPath, expectedUid);
+    }
+    catch (error) {
+        await closeServer(server, connections);
+        await unlink(socketPath).catch(() => undefined);
+        throw error;
+    }
+    let closed = false;
+    return { close: async () => { if (closed)
+            return; closed = true; for (const controller of active.values())
+            controller.abort(); const results = await Promise.allSettled([closeServer(server, connections), broker.close()]); await unlink(socketPath).catch(() => undefined); const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []); if (failures.length)
+            throw new AggregateError(failures, "engine broker service shutdown failed"); }, health: () => ({ activeTurns: active.size, socketPath }) };
+}
+/**
+ * A connection error is a client that went away, never a reason to take the
+ * broker down with it.
+ *
+ * Without this listener an accepted socket that emits `error` had none, and
+ * node turns an unhandled `error` on a stream into an uncaught exception — so a
+ * single departing client killed the whole service and every other in-flight
+ * turn with it. That is reachable from the ordinary cancellation path: the
+ * client destroys its socket on abort, this side aborts the turn, the engine
+ * rejects, and this side then writes a `failed` frame to a peer that is already
+ * gone. On Linux that write/read races an RST and surfaces as ECONNRESET; macOS
+ * closes cleanly enough that the error never arrives, which is why this was
+ * invisible until the suite ran in a container.
+ *
+ * Treated exactly like `close`: abort whatever turn this connection owned and
+ * drop the socket. The turn's own result is already unreachable — its only
+ * reader has disconnected.
+ */
+function handleSocketError(socket, owned) { socket.on("error", () => { owned()?.controller.abort(); socket.destroy(); }); }
+function handle(socket, broker, active) { const decoder = new EngineBrokerFrameDecoder(); let started = false, owned; handleSocketError(socket, () => owned); socket.once("close", () => owned?.controller.abort()); socket.on("data", (chunk) => { try {
+    for (const value of decoder.push(chunk)) {
+        const request = parseEngineBrokerRequest(value);
+        if (request.kind === "health") {
+            if (started)
+                throw new Error();
+            started = true;
+            const ready = broker.readiness();
+            if (ready.providerProxyPort !== 43123 || ready.mcpFacadePort !== 43124 || ready.registrations < 1 || ready.credentialStale || !ready.realmLease || !ready.workerIsolation)
+                throw new Error();
+            return send(socket, { version: request.version, kind: "ready", requestId: request.requestId, brokerUid: 2100, providerProxyPort: 43123, mcpFacadePort: 43124, registrations: ready.registrations, credentialStale: false, realmLease: true, workerIsolation: true });
+        }
+        if (request.kind === "cancel_turn") {
+            active.get(request.turnId)?.abort();
+            continue;
+        }
+        if (request.kind === "request_inference_grant" || request.kind === "release_inference_grant") {
+            if (started)
+                throw new Error();
+            started = true;
+            serveInferenceGrant(socket, broker, request);
+            continue;
+        }
+        if (started || active.has(request.turnId))
+            throw new Error();
+        started = true;
+        const controller = new AbortController();
+        owned = { turnId: request.turnId, controller };
+        active.set(request.turnId, controller);
+        socket.write(encodeEngineBrokerFrame({ version: request.version, kind: "accepted", requestId: request.requestId, turnId: request.turnId }));
+        void broker.turn(request.agentId, request.wakeId, request.prompt, request.mcpEndpoint, controller.signal, request.limits).then((result) => send(socket, { version: request.version, kind: "completed", requestId: request.requestId, turnId: request.turnId, text: result.text, workerPid: result.workerPid, workerUid: result.workerUid, workerStartTime: result.workerStartTime, outcome: "completed", usage: result.usage, model: result.model, requests: result.requests, limitReason: "none" }), (error) => failed(socket, request, error, controller.signal.aborted)).finally(() => { if (active.get(request.turnId) === controller)
+            active.delete(request.turnId); owned = undefined; });
+    }
+}
+catch {
+    socket.destroy();
+} }); }
+/**
+ * Every failure the broker raises for a known registration carries its
+ * accounting (a wake that tried to raise a limit: `usage: null`, zero
+ * requests). A failure with no registration behind it (unknown agent, closed
+ * broker) has no declared model to report, so it is refused as a bare
+ * connection close and the client reports the broker unavailable.
+ */
+function failed(socket, request, error, aborted) {
+    const accounting = error instanceof EngineBrokerTurnFailure ? error.accounting : undefined;
+    if (accounting === undefined) {
+        socket.destroy();
+        return;
+    }
+    const code = error instanceof EngineBrokerTurnFailure ? error.code : aborted ? "cancelled" : "engine_failed";
+    send(socket, { version: request.version, kind: "failed", requestId: request.requestId, turnId: request.turnId, code, ...(error instanceof EngineBrokerTurnFailure && error.diagnostic ? { diagnostic: error.diagnostic } : {}), ...(error instanceof EngineBrokerTurnFailure && error.mcpCalls ? { mcpCalls: error.mcpCalls } : {}), outcome: "failed", usage: accounting.usage, model: accounting.model, requests: accounting.requests, limitReason: accounting.limitReason });
+}
+/** One grant verb per connection, answered and closed; any failure becomes a closed-code refusal and never touches turn state. */
+function serveInferenceGrant(socket, broker, request) {
+    const refuse = (code) => send(socket, { version: request.version, kind: "inference_grant_refused", requestId: request.requestId, code });
+    try {
+        if (request.kind === "release_inference_grant") {
+            if (!broker.releaseInferenceGrant)
+                return refuse("unavailable");
+            return send(socket, { version: request.version, kind: "inference_grant_released", requestId: request.requestId, grantId: request.grantId, released: broker.releaseInferenceGrant(request.grantId) });
+        }
+        if (!broker.requestInferenceGrant)
+            return refuse("unavailable");
+        const grant = broker.requestInferenceGrant({ model: request.model, reasoningEffort: request.reasoningEffort, purpose: request.purpose });
+        send(socket, { version: request.version, kind: "inference_grant", requestId: request.requestId, grantId: grant.grantId, token: grant.token, baseUrl: GROK_INFERENCE_PROXY_BASE_URL, model: grant.policy.model, reasoningEffort: grant.policy.reasoningEffort, purpose: grant.purpose, expiresAt: new Date(grant.expiresAt).toISOString(), limits: grant.limits });
+    }
+    catch (error) {
+        refuse(error instanceof GrokInferenceGrantRefused ? error.code : "unavailable");
+    }
+}
+function send(socket, response) { if (!socket.destroyed)
+    socket.end(encodeEngineBrokerFrame(response)); }
+async function removeOwnedSocket(file, uid) { try {
+    const entry = await lstat(file);
+    if (!entry.isSocket() || Number(entry.uid) !== uid)
+        throw new Error("unsafe broker socket");
+    await unlink(file);
+}
+catch (error) {
+    if (error.code !== "ENOENT")
+        throw error;
+} }
+async function verifySocket(file, uid) { const entry = await lstat(file); if (!entry.isSocket() || Number(entry.uid) !== uid || (Number(entry.mode) & 0o777) !== 0o600)
+    throw new Error("unsafe broker socket"); }
+function listen(server, file) { return new Promise((resolve, reject) => { server.once("error", reject); server.listen(file, () => { server.off("error", reject); resolve(); }); }); }
+function closeServer(server, connections) { for (const socket of connections)
+    socket.destroy(); return new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve())); }

package/dist/runtime/engineBrokerServiceCli.d.ts

@@ -0,0 +1,5 @@
+import { parseEngineBrokerServiceConfig } from "./engineBrokerServiceConfig.js";
+export { parseEngineBrokerServiceConfig };
+export declare const ENGINE_BROKER_SERVICE_CONFIG = "/etc/daimon-engine-broker/service.json";
+export declare function runEngineBrokerServiceCli(): Promise<void>;
+//# sourceMappingURL=engineBrokerServiceCli.d.ts.map

package/dist/runtime/engineBrokerServiceCli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerServiceCli.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerServiceCli.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,8BAA8B,EAAE,MAAM,gCAAgC,CAAC;AAGhF,OAAO,EAAE,8BAA8B,EAAE,CAAC;AAE1C,eAAO,MAAM,4BAA4B,2CAA2C,CAAC;AAGrF,wBAAsB,yBAAyB,IAAG,OAAO,CAAC,IAAI,CAAC,CAO9D"}

package/dist/runtime/engineBrokerServiceCli.js

@@ -0,0 +1,32 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { startEngineBrokerService } from "./engineBrokerService.js";
+import { parseEngineBrokerServiceConfig } from "./engineBrokerServiceConfig.js";
+import { startGrokEngineBroker } from "./grokEngineBroker.js";
+export { parseEngineBrokerServiceConfig };
+export const ENGINE_BROKER_SERVICE_CONFIG = "/etc/daimon-engine-broker/service.json";
+const MAX_CONFIG_BYTES = 65_536;
+export async function runEngineBrokerServiceCli() {
+    if (process.getuid?.() !== 2100)
+        throw new Error("engine broker service requires broker identity");
+    const config = parseEngineBrokerServiceConfig(await readRootConfig(ENGINE_BROKER_SERVICE_CONFIG));
+    const broker = await startGrokEngineBroker({ grokCommand: "/usr/local/bin/grok", nativeClient: "/opt/daimon/bin/daimon-engine-broker", credentialHome: config.credentialHome, turnStore: config.turnStore, registrations: config.registrations, ...(config.inferenceLedgerPath === undefined ? {} : { inferenceLedgerPath: config.inferenceLedgerPath }) });
+    const service = await startEngineBrokerService(broker);
+    let stopping;
+    const stop = () => { stopping ??= service.close(); return stopping; };
+    const onSignal = () => { void stop().catch(() => { process.exitCode = 1; }); };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+}
+async function readRootConfig(file) { const handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW); try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.uid !== 0 || stat.gid !== 2100 || (stat.mode & 0o777) !== 0o440 || stat.size < 2 || stat.size > MAX_CONFIG_BYTES)
+        throw new Error("unsafe engine broker service config");
+    const bytes = await handle.readFile();
+    if (bytes.length > MAX_CONFIG_BYTES)
+        throw new Error("unsafe engine broker service config");
+    return JSON.parse(bytes.toString("utf8"));
+}
+finally {
+    await handle.close();
+} }

package/dist/runtime/engineBrokerServiceConfig.d.ts

@@ -0,0 +1,50 @@
+import { type EngineBrokerTurnLimits } from "./engineBrokerTurnAccounting.js";
+import { type GrokBrokerModelPolicy } from "./grokBrokerModelPolicy.js";
+export declare const ENGINE_BROKER_SERVICE_V1: "noopolis.daimon.engine-broker-service.v1";
+export declare const ENGINE_BROKER_SERVICE_V2: "noopolis.daimon.engine-broker-service.v2";
+/** One root-provisioned broker slot. Every field is fixed at provisioning time; a wake can only lower `limits`. */
+export type EngineBrokerServiceRegistration = Readonly<{
+    agentId: string;
+    slot: number;
+    workerUid: number;
+    workspace: string;
+    profilePath: string;
+    eventsPath: string;
+    profileSha256: string;
+    /** Per-slot usage ledger the broker appends turn rows to; per-request rows go to `requests.jsonl` and per-turn seals to `turns.jsonl` beside it. */
+    usageLedgerPath: string;
+    limits: EngineBrokerTurnLimits;
+    model: GrokBrokerModelPolicy;
+}>;
+/**
+ * `inferenceLedgerPath` (v2, optional) is where evaluator inference grants
+ * append their rows (`inferenceUsageLedger.ts`). Without it the broker refuses
+ * every grant request. It can never be a subject ledger: not any
+ * registration's usage ledger or its `requests.jsonl`, and not the container
+ * ledger the wake fuse sums.
+ */
+export type EngineBrokerServiceConfig = Readonly<{
+    credentialHome: string;
+    turnStore: string;
+    registrations: readonly EngineBrokerServiceRegistration[];
+    inferenceLedgerPath?: string;
+}>;
+/** The per-request stream written beside a registration's usage ledger. */
+export declare const engineBrokerRequestLedgerPathFor: (usageLedgerPath: string) => string;
+/**
+ * The per-turn seal stream written beside the other two
+ * (`engineBrokerSealLedger.ts`): the operator-visible half of a sealed terminal
+ * response, for the turn whose response never reaches a client.
+ */
+export declare const engineBrokerSealLedgerPathFor: (usageLedgerPath: string) => string;
+/**
+ * Strict `service.json` parser.
+ *
+ * v2 requires every registration to declare its usage ledger, limits and model
+ * (`model.id`/`model.reasoningEffort` from the closed lists); unknown keys at
+ * any level are refused. v1 is still accepted and receives today's defaults:
+ * the container ledger, {@link DEFAULT_GROK_BROKER_TURN_LIMITS}, and
+ * `grok-4.6`/`low`.
+ */
+export declare function parseEngineBrokerServiceConfig(value: unknown): EngineBrokerServiceConfig;
+//# sourceMappingURL=engineBrokerServiceConfig.d.ts.map

package/dist/runtime/engineBrokerServiceConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerServiceConfig.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerServiceConfig.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgE,KAAK,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC5I,OAAO,EAAuF,KAAK,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAK7J,eAAO,MAAM,wBAAwB,EAAG,0CAAmD,CAAC;AAC5F,eAAO,MAAM,wBAAwB,EAAG,0CAAmD,CAAC;AAE5F,mHAAmH;AACnH,MAAM,MAAM,+BAA+B,GAAG,QAAQ,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IACpI,oJAAoJ;IACpJ,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,KAAK,EAAE,qBAAqB,CAAC;CAC9B,CAAC,CAAC;AACH;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,SAAS,+BAA+B,EAAE,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAczL,2EAA2E;AAC3E,eAAO,MAAM,gCAAgC,GAAI,iBAAiB,MAAM,KAAG,MAAgF,CAAC;AAE5J;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,GAAI,iBAAiB,MAAM,KAAG,MAA6E,CAAC;AAEtJ;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CA6BxF"}

package/dist/runtime/engineBrokerServiceConfig.js

@@ -0,0 +1,92 @@
+import path from "node:path";
+import { DEFAULT_GROK_BROKER_TURN_LIMITS, parseEngineBrokerTurnLimits } from "./engineBrokerTurnAccounting.js";
+import { DEFAULT_GROK_BROKER_MODEL_POLICY, GROK_BROKER_MODELS, GROK_BROKER_REASONING_EFFORTS } from "./grokBrokerModelPolicy.js";
+import { grokWorkerEventsPathFor } from "./grokWorkerSandboxProfile.js";
+import { TURN_REQUEST_LEDGER } from "./turnRequestLedger.js";
+import { TURN_USAGE_LEDGER } from "./turnUsageLedger.js";
+export const ENGINE_BROKER_SERVICE_V1 = "noopolis.daimon.engine-broker-service.v1";
+export const ENGINE_BROKER_SERVICE_V2 = "noopolis.daimon.engine-broker-service.v2";
+const V1_REGISTRATION = ["agentId", "slot", "workerUid", "workspace", "profilePath", "eventsPath", "profileSha256"];
+const V2_REGISTRATION = [...V1_REGISTRATION, "usageLedgerPath", "limits", "model"];
+const invalid = () => new TypeError("invalid engine broker service config");
+const plain = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const exact = (value, fields) => { if (Object.keys(value).length !== fields.length || fields.some((field) => !Object.hasOwn(value, field)))
+    throw invalid(); };
+/**
+ * Absolute and canonical: no `.`/`..`/empty components and no trailing slash.
+ * The native launcher derives HOME, GROK_HOME and TMPDIR from the registered
+ * home and refuses a non-canonical one, so the broker's view must match it.
+ */
+const absolute = (item) => typeof item === "string" && item.length > 1 && item.startsWith("/") && !item.endsWith("/") && path.posix.normalize(item) === item && !item.split("/").slice(1).some((part) => part === "." || part === "..") && !item.includes("\0");
+/** The per-request stream written beside a registration's usage ledger. */
+export const engineBrokerRequestLedgerPathFor = (usageLedgerPath) => path.posix.join(path.posix.dirname(usageLedgerPath), "requests.jsonl");
+/**
+ * The per-turn seal stream written beside the other two
+ * (`engineBrokerSealLedger.ts`): the operator-visible half of a sealed terminal
+ * response, for the turn whose response never reaches a client.
+ */
+export const engineBrokerSealLedgerPathFor = (usageLedgerPath) => path.posix.join(path.posix.dirname(usageLedgerPath), "turns.jsonl");
+/**
+ * Strict `service.json` parser.
+ *
+ * v2 requires every registration to declare its usage ledger, limits and model
+ * (`model.id`/`model.reasoningEffort` from the closed lists); unknown keys at
+ * any level are refused. v1 is still accepted and receives today's defaults:
+ * the container ledger, {@link DEFAULT_GROK_BROKER_TURN_LIMITS}, and
+ * `grok-4.6`/`low`.
+ */
+export function parseEngineBrokerServiceConfig(value) {
+    if (!plain(value))
+        throw invalid();
+    const v2 = value.version === ENGINE_BROKER_SERVICE_V2;
+    if (!v2 && value.version !== ENGINE_BROKER_SERVICE_V1)
+        throw invalid();
+    const top = ["version", "credentialHome", "turnStore", "registrations"];
+    exact(value, v2 && Object.hasOwn(value, "inferenceLedgerPath") ? [...top, "inferenceLedgerPath"] : top);
+    if (!absolute(value.credentialHome) || !absolute(value.turnStore) || !Array.isArray(value.registrations) || value.registrations.length === 0)
+        throw invalid();
+    const seen = new Set(), slots = new Set();
+    const registrations = value.registrations.map((entry) => {
+        if (!plain(entry))
+            throw invalid();
+        exact(entry, v2 ? V2_REGISTRATION : V1_REGISTRATION);
+        const { agentId, slot, workerUid, workspace, profilePath, eventsPath, profileSha256 } = entry;
+        if (typeof agentId !== "string" || !agentId.trim() || seen.has(agentId) || !Number.isSafeInteger(slot) || slot < 0 || slots.has(slot) || !Number.isSafeInteger(workerUid) || workerUid < 2200 || !absolute(workspace) || !absolute(profilePath) || !absolute(eventsPath) || typeof profileSha256 !== "string" || !/^[a-f0-9]{64}$/u.test(profileSha256) || eventsPath !== grokWorkerEventsPathFor(profilePath) || !profilePath.endsWith("/sandbox.toml"))
+            throw invalid();
+        seen.add(agentId);
+        slots.add(slot);
+        const base = { agentId, slot: slot, workerUid: workerUid, workspace, profilePath, eventsPath, profileSha256 };
+        if (!v2)
+            return { ...base, usageLedgerPath: TURN_USAGE_LEDGER.filePath, limits: DEFAULT_GROK_BROKER_TURN_LIMITS, model: DEFAULT_GROK_BROKER_MODEL_POLICY };
+        const usageLedgerPath = entry.usageLedgerPath;
+        if (!ledgerPath(usageLedgerPath) || usageLedgerPath === engineBrokerRequestLedgerPathFor(usageLedgerPath) || usageLedgerPath === engineBrokerSealLedgerPathFor(usageLedgerPath))
+            throw invalid();
+        let limits;
+        try {
+            limits = parseEngineBrokerTurnLimits(entry.limits);
+        }
+        catch {
+            throw invalid();
+        }
+        return { ...base, usageLedgerPath, limits, model: parseServiceModel(entry.model) };
+    });
+    const base = { credentialHome: value.credentialHome, turnStore: value.turnStore, registrations };
+    if (!Object.hasOwn(value, "inferenceLedgerPath"))
+        return base;
+    const inferenceLedgerPath = value.inferenceLedgerPath;
+    if (!ledgerPath(inferenceLedgerPath))
+        throw invalid();
+    const subject = new Set([TURN_USAGE_LEDGER.filePath, TURN_REQUEST_LEDGER.filePath, ...registrations.flatMap((entry) => [entry.usageLedgerPath, engineBrokerRequestLedgerPathFor(entry.usageLedgerPath), engineBrokerSealLedgerPathFor(entry.usageLedgerPath)])]);
+    if (subject.has(inferenceLedgerPath))
+        throw invalid();
+    return { ...base, inferenceLedgerPath };
+}
+const ledgerPath = (item) => absolute(item) && item.endsWith(".jsonl") && path.posix.normalize(item) === item;
+function parseServiceModel(value) {
+    if (!plain(value))
+        throw invalid();
+    exact(value, ["id", "reasoningEffort"]);
+    if (!GROK_BROKER_MODELS.includes(value.id) || !GROK_BROKER_REASONING_EFFORTS.includes(value.reasoningEffort))
+        throw invalid();
+    return Object.freeze({ model: value.id, reasoningEffort: value.reasoningEffort });
+}

package/dist/runtime/engineBrokerSingleflight.d.ts

@@ -0,0 +1,13 @@
+export declare class EngineBrokerSingleflight<T> {
+    private active;
+    run(operation: () => Promise<T>): Promise<T>;
+}
+export declare class EngineBrokerGenerationFence {
+    private generation;
+    private stale;
+    restore(generation: number): void;
+    snapshot(): number;
+    promote(expected: number): number;
+    markStale(): void;
+}
+//# sourceMappingURL=engineBrokerSingleflight.d.ts.map

package/dist/runtime/engineBrokerSingleflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerSingleflight.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerSingleflight.ts"],"names":[],"mappings":"AAAA,qBAAa,wBAAwB,CAAC,CAAC;IACrC,OAAO,CAAC,MAAM,CAAyB;IACvC,GAAG,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAM7C;AAED,qBAAa,2BAA2B;IACtC,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,UAAU,EAAC,MAAM,GAAE,IAAI;IAC/B,QAAQ,IAAI,MAAM;IAClB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IACjC,SAAS,IAAI,IAAI;CAClB"}

package/dist/runtime/engineBrokerSingleflight.js

@@ -0,0 +1,24 @@
+export class EngineBrokerSingleflight {
+    active;
+    run(operation) {
+        if (this.active !== undefined)
+            return this.active;
+        const current = operation();
+        this.active = current;
+        void current.then(() => { if (this.active === current)
+            this.active = undefined; }, () => { if (this.active === current)
+            this.active = undefined; });
+        return current;
+    }
+}
+export class EngineBrokerGenerationFence {
+    generation = 0;
+    stale = false;
+    restore(generation) { if (this.stale || this.generation !== 0 || !Number.isSafeInteger(generation) || generation < 0)
+        throw new Error("broker credential generation conflict"); this.generation = generation; }
+    snapshot() { if (this.stale)
+        throw new Error("broker credential authority is stale"); return this.generation; }
+    promote(expected) { if (this.stale || expected !== this.generation)
+        throw new Error("broker credential generation conflict"); return ++this.generation; }
+    markStale() { this.stale = true; }
+}

package/dist/runtime/engineBrokerTurnAccounting.d.ts

@@ -0,0 +1,76 @@
+import type { GrokBrokerModel } from "./grokBrokerModelPolicy.js";
+/**
+ * Numeric-only accounting the Grok engine broker seals beside every terminal
+ * turn response, and the per-turn limits it enforces.
+ *
+ * The broker is the single writer of this data (turn registry record, control
+ * response, usage ledger row). Nothing engine-controlled and non-numeric is
+ * persisted: `model` is a member of the closed declared list, never the
+ * provider's own string, and `limitReason` is a closed vocabulary.
+ *
+ * Buckets are disjoint and `total = input + cacheRead + cacheWrite + output`.
+ * `reasoning` is reported only when the source separates it; it is already
+ * inside `output` and never added to `total`.
+ */
+export type EngineBrokerTurnUsage = Readonly<{
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    output: number;
+    total: number;
+    reasoning?: number;
+}>;
+export declare const ENGINE_BROKER_LIMIT_REASONS: readonly ["tokens", "requests", "timeout", "none"];
+export type EngineBrokerLimitReason = (typeof ENGINE_BROKER_LIMIT_REASONS)[number];
+export type EngineBrokerTurnLimits = Readonly<{
+    maxRequests: number;
+    maxTokens: number;
+    timeoutMs: number;
+}>;
+export type EngineBrokerTurnLimitOverrides = Readonly<Partial<EngineBrokerTurnLimits>>;
+export type EngineBrokerTurnAccounting = Readonly<{
+    outcome: "completed" | "failed";
+    usage: EngineBrokerTurnUsage | null;
+    model: GrokBrokerModel;
+    requests: number;
+    limitReason: EngineBrokerLimitReason;
+}>;
+/**
+ * Bounds every declared limit must sit inside, and the v1 defaults, both from
+ * the runtime contract manifest. `maxRequests` stays at or below the
+ * launcher's compiled `--max-turns` backstop, so the broker ceiling is the one
+ * that fires first.
+ */
+export declare const ENGINE_BROKER_LIMIT_BOUNDS: {
+    readonly maxRequests: readonly [1, 48];
+    readonly maxTokens: readonly [1, 10000000];
+    readonly timeoutMs: readonly [1000, 3600000];
+};
+/** What a v1 `service.json` registration gets; equal to the Codex per-wake defaults. */
+export declare const DEFAULT_GROK_BROKER_TURN_LIMITS: EngineBrokerTurnLimits;
+type JsonRecord = Record<string, unknown>;
+/** Exactly `{maxRequests, maxTokens, timeoutMs}`, each inside its bound. */
+export declare function parseEngineBrokerTurnLimits(value: unknown, label?: string): EngineBrokerTurnLimits;
+/** A non-empty subset of the limit keys, each inside its bound. */
+export declare function parseEngineBrokerTurnLimitOverrides(value: unknown, label?: string): EngineBrokerTurnLimitOverrides;
+/**
+ * The limits one turn runs under: the registration's, lowered by the wake.
+ * A wake can never raise a declared limit; asking to is refused rather than
+ * clamped, so a misconfigured caller learns it instead of silently getting less.
+ */
+export declare function lowerEngineBrokerTurnLimits(declared: EngineBrokerTurnLimits, overrides: EngineBrokerTurnLimitOverrides | undefined): EngineBrokerTurnLimits;
+/** Four disjoint buckets plus an optional reasoning split; the total invariant is re-checked. */
+export declare function parseEngineBrokerTurnUsage(value: unknown, label?: string): EngineBrokerTurnUsage;
+export declare const sumEngineBrokerTurnUsage: (items: readonly EngineBrokerTurnUsage[]) => EngineBrokerTurnUsage | null;
+/** Validates the accounting members of a v2 terminal response against its kind. */
+export declare function parseEngineBrokerTurnAccounting(value: JsonRecord, kind: "completed" | "failed"): EngineBrokerTurnAccounting;
+/**
+ * Maps a provider-reported model key onto the declared closed-list model.
+ *
+ * Grok 1.0.34 reports `grok-4.6` usage under `grok-4.6-build` (P0). The exact
+ * declared id and its `-build` alias are accepted; anything else is a
+ * different model and yields `undefined`.
+ */
+export declare const mapGrokReportedModel: (reported: string, declared: GrokBrokerModel) => GrokBrokerModel | undefined;
+export {};
+//# sourceMappingURL=engineBrokerTurnAccounting.d.ts.map

package/dist/runtime/engineBrokerTurnAccounting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerTurnAccounting.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerTurnAccounting.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC1J,eAAO,MAAM,2BAA2B,oDAA6C,CAAC;AACtF,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AACnF,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC7G,MAAM,MAAM,8BAA8B,GAAG,QAAQ,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC;AACvF,MAAM,MAAM,0BAA0B,GAAG,QAAQ,CAAC;IAChD,OAAO,EAAE,WAAW,GAAG,QAAQ,CAAC;IAChC,KAAK,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACpC,KAAK,EAAE,eAAe,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,uBAAuB,CAAC;CACtC,CAAC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;CAAuC,CAAC;AAE/E,wFAAwF;AACxF,eAAO,MAAM,+BAA+B,EAAE,sBAAuF,CAAC;AAGtI,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAY1C,4EAA4E;AAC5E,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAA8B,GAAG,sBAAsB,CAGvH;AAED,mEAAmE;AACnE,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAA8B,GAAG,8BAA8B,CAKvI;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,sBAAsB,EAAE,SAAS,EAAE,8BAA8B,GAAG,SAAS,GAAG,sBAAsB,CAO3J;AAED,iGAAiG;AACjG,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAA6B,GAAG,qBAAqB,CAUpH;AAED,eAAO,MAAM,wBAAwB,GAAI,OAAO,SAAS,qBAAqB,EAAE,KAAG,qBAAqB,GAAG,IAK1G,CAAC;AAEF,mFAAmF;AACnF,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,0BAA0B,CAS3H;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,UAAU,MAAM,EAAE,UAAU,eAAe,KAAG,eAAe,GAAG,SACnB,CAAC"}

package/dist/runtime/engineBrokerTurnAccounting.js

@@ -0,0 +1,108 @@
+import { GROK_BROKER_MODELS } from "../contracts/grokWorkerContract.js";
+import { GROK_ENGINE_BROKER } from "../contracts/runtimeContractManifest.js";
+export const ENGINE_BROKER_LIMIT_REASONS = GROK_ENGINE_BROKER.turnLimits.limitReasons;
+/**
+ * Bounds every declared limit must sit inside, and the v1 defaults, both from
+ * the runtime contract manifest. `maxRequests` stays at or below the
+ * launcher's compiled `--max-turns` backstop, so the broker ceiling is the one
+ * that fires first.
+ */
+export const ENGINE_BROKER_LIMIT_BOUNDS = GROK_ENGINE_BROKER.turnLimits.bounds;
+/** What a v1 `service.json` registration gets; equal to the Codex per-wake defaults. */
+export const DEFAULT_GROK_BROKER_TURN_LIMITS = Object.freeze({ ...GROK_ENGINE_BROKER.turnLimits.v1Defaults });
+const LIMIT_KEYS = ["maxRequests", "maxTokens", "timeoutMs"];
+const plain = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+const count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+const invalid = (label) => new TypeError(`invalid ${label}`);
+const limitValue = (key, value, label) => {
+    const [minimum, maximum] = ENGINE_BROKER_LIMIT_BOUNDS[key];
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum || value > maximum)
+        throw invalid(label);
+    return value;
+};
+/** Exactly `{maxRequests, maxTokens, timeoutMs}`, each inside its bound. */
+export function parseEngineBrokerTurnLimits(value, label = "engine broker turn limits") {
+    if (!plain(value) || Object.keys(value).length !== LIMIT_KEYS.length || LIMIT_KEYS.some((key) => !Object.hasOwn(value, key)))
+        throw invalid(label);
+    return Object.freeze({ maxRequests: limitValue("maxRequests", value.maxRequests, label), maxTokens: limitValue("maxTokens", value.maxTokens, label), timeoutMs: limitValue("timeoutMs", value.timeoutMs, label) });
+}
+/** A non-empty subset of the limit keys, each inside its bound. */
+export function parseEngineBrokerTurnLimitOverrides(value, label = "engine broker turn limits") {
+    if (!plain(value) || Object.keys(value).length === 0 || Object.keys(value).some((key) => !LIMIT_KEYS.includes(key)))
+        throw invalid(label);
+    const result = {};
+    for (const key of LIMIT_KEYS)
+        if (Object.hasOwn(value, key))
+            result[key] = limitValue(key, value[key], label);
+    return Object.freeze(result);
+}
+/**
+ * The limits one turn runs under: the registration's, lowered by the wake.
+ * A wake can never raise a declared limit; asking to is refused rather than
+ * clamped, so a misconfigured caller learns it instead of silently getting less.
+ */
+export function lowerEngineBrokerTurnLimits(declared, overrides) {
+    if (overrides === undefined)
+        return declared;
+    for (const key of LIMIT_KEYS) {
+        const requested = overrides[key];
+        if (requested !== undefined && requested > declared[key])
+            throw new RangeError(`engine broker turn limit ${key} may only be lowered`);
+    }
+    return Object.freeze({ maxRequests: overrides.maxRequests ?? declared.maxRequests, maxTokens: overrides.maxTokens ?? declared.maxTokens, timeoutMs: overrides.timeoutMs ?? declared.timeoutMs });
+}
+/** Four disjoint buckets plus an optional reasoning split; the total invariant is re-checked. */
+export function parseEngineBrokerTurnUsage(value, label = "engine broker turn usage") {
+    const required = ["input", "cacheRead", "cacheWrite", "output", "total"];
+    if (!plain(value))
+        throw invalid(label);
+    const keys = Object.keys(value);
+    if (required.some((key) => !Object.hasOwn(value, key)) || keys.some((key) => !required.includes(key) && key !== "reasoning"))
+        throw invalid(label);
+    if (![value.input, value.cacheRead, value.cacheWrite, value.output, value.total].every(count))
+        throw invalid(label);
+    const usage = value;
+    if (usage.total !== usage.input + usage.cacheRead + usage.cacheWrite + usage.output)
+        throw invalid(label);
+    if (usage.reasoning !== undefined && (!count(usage.reasoning) || usage.reasoning > usage.output))
+        throw invalid(label);
+    return Object.freeze({ input: usage.input, cacheRead: usage.cacheRead, cacheWrite: usage.cacheWrite, output: usage.output, total: usage.total, ...(usage.reasoning === undefined ? {} : { reasoning: usage.reasoning }) });
+}
+export const sumEngineBrokerTurnUsage = (items) => {
+    if (items.length === 0)
+        return null;
+    const sum = (pick) => items.reduce((total, usage) => total + pick(usage), 0);
+    const reasoning = items.every((usage) => usage.reasoning !== undefined) ? { reasoning: sum((usage) => usage.reasoning ?? 0) } : {};
+    return Object.freeze({ input: sum((usage) => usage.input), cacheRead: sum((usage) => usage.cacheRead), cacheWrite: sum((usage) => usage.cacheWrite), output: sum((usage) => usage.output), total: sum((usage) => usage.total), ...reasoning });
+};
+/** Validates the accounting members of a v2 terminal response against its kind. */
+export function parseEngineBrokerTurnAccounting(value, kind) {
+    if (value.outcome !== kind)
+        throw invalid("broker frame");
+    if (!GROK_BROKER_MODELS.includes(value.model))
+        throw invalid("broker frame");
+    if (!count(value.requests) || value.requests > 1_024)
+        throw invalid("broker frame");
+    if (!ENGINE_BROKER_LIMIT_REASONS.includes(value.limitReason))
+        throw invalid("broker frame");
+    if (kind === "completed" && value.limitReason !== "none")
+        throw invalid("broker frame");
+    let usage = null;
+    if (value.usage !== null) {
+        try {
+            usage = parseEngineBrokerTurnUsage(value.usage);
+        }
+        catch {
+            throw invalid("broker frame");
+        }
+    }
+    return { outcome: kind, usage, model: value.model, requests: value.requests, limitReason: value.limitReason };
+}
+/**
+ * Maps a provider-reported model key onto the declared closed-list model.
+ *
+ * Grok 1.0.34 reports `grok-4.6` usage under `grok-4.6-build` (P0). The exact
+ * declared id and its `-build` alias are accepted; anything else is a
+ * different model and yields `undefined`.
+ */
+export const mapGrokReportedModel = (reported, declared) => reported === declared || reported === `${declared}-build` ? declared : undefined;

package/dist/runtime/engineBrokerTurnRegistry.d.ts

@@ -0,0 +1,57 @@
+import { type EngineBrokerRequest, type EngineBrokerTerminalResponse } from "./engineBrokerProtocol.js";
+import type { GrokBrokerModel } from "./grokBrokerModelPolicy.js";
+import { type BrokerTurnLedgerLines } from "./grokEngineBrokerLedger.js";
+type Start = Extract<EngineBrokerRequest, {
+    kind: "start_turn";
+}>;
+type Terminal = EngineBrokerTerminalResponse;
+export declare const ENGINE_BROKER_TURN_RECORD_V1: "noopolis.daimon.engine-broker-turn.v1";
+export declare const ENGINE_BROKER_TURN_RECORD_V2: "noopolis.daimon.engine-broker-turn.v2";
+type Observed = Readonly<{
+    version: typeof ENGINE_BROKER_TURN_RECORD_V1 | typeof ENGINE_BROKER_TURN_RECORD_V2;
+    digest: string;
+    state: "active" | "terminal";
+    bootId: string;
+    response?: Terminal;
+    ledger?: BrokerTurnLedgerLines;
+}>;
+/**
+ * Durable per-turn state. Record v2 stores the terminal response *with* its
+ * sealed accounting (usage, outcome, model, requests, limitReason), so a replay
+ * returns exactly what was metered and never meters again: metering happens
+ * only on the path that returned `"start"`.
+ */
+export declare class EngineBrokerTurnRegistry {
+    private readonly root;
+    private readonly bootId;
+    private readonly syncDirectoryOf;
+    /** `syncDirectoryOf` is injectable only so the post-publish failure path can be exercised under test. */
+    constructor(root: string, bootId?: string, syncDirectoryOf?: (directory: string) => Promise<void>);
+    /** `model` is the registration's declared model, used only to upgrade a v1 record on replay. */
+    begin(request: Start, model: GrokBrokerModel): Promise<"start" | {
+        replay: Terminal;
+        ledger: BrokerTurnLedgerLines;
+    }>;
+    /**
+     * `ledger` is the exact ledger bytes this turn owes, sealed with it so a replay can finish an interrupted append.
+     *
+     * The rename is the publish point. A failure before it rejects (nothing was
+     * published); a failure after it — the directory fsync — must not, because
+     * the terminal record is already the visible truth and a caller that saw a
+     * rejection would believe the turn unsealed and write a contradicting
+     * record over it. That durability gap is reported as `directorySynced: false`
+     * instead: the record is published but may not survive a power loss.
+     */
+    finish(request: Start, response: Terminal, ledger?: BrokerTurnLedgerLines): Promise<Readonly<{
+        directorySynced: boolean;
+    }>>;
+}
+/**
+ * Strict record parser. v2 accepts exactly `{version,digest,state,bootId}`
+ * plus `response` and its sealed `ledger` bytes when terminal, and the response must be a v2 terminal frame.
+ * v1 records keep their historical looser shape and are upgraded on read: no
+ * usage (`null`), zero requests, `limitReason: "none"`, the declared model.
+ */
+export declare function parseEngineBrokerTurnRecord(text: string, model: GrokBrokerModel): Observed;
+export {};
+//# sourceMappingURL=engineBrokerTurnRegistry.d.ts.map

package/dist/runtime/engineBrokerTurnRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineBrokerTurnRegistry.d.ts","sourceRoot":"","sources":["../../src/runtime/engineBrokerTurnRegistry.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkE,KAAK,mBAAmB,EAAE,KAAK,4BAA4B,EAAE,MAAM,2BAA2B,CAAC;AACxK,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAwD,KAAK,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAE/H,KAAK,KAAK,GAAG,OAAO,CAAC,mBAAmB,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC;AAClE,KAAK,QAAQ,GAAG,4BAA4B,CAAC;AAC7C,eAAO,MAAM,4BAA4B,EAAG,uCAAgD,CAAC;AAC7F,eAAO,MAAM,4BAA4B,EAAG,uCAAgD,CAAC;AAK7F,KAAK,QAAQ,GAAG,QAAQ,CAAC;IAAE,OAAO,EAAE,OAAO,4BAA4B,GAAG,OAAO,4BAA4B,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,QAAQ,GAAG,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAAC,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAAE,CAAC,CAAC;AAEpO;;;;;GAKG;AACH,qBAAa,wBAAwB;IAEvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAAS,OAAO,CAAC,QAAQ,CAAC,MAAM;IAAqB,OAAO,CAAC,QAAQ,CAAC,eAAe;IADtH,yGAAyG;gBAC5E,IAAI,EAAE,MAAM,EAAkB,MAAM,GAAC,MAAmB,EAAkB,eAAe,GAAC,CAAC,SAAS,EAAC,MAAM,KAAG,OAAO,CAAC,IAAI,CAAe;IACtK,gGAAgG;IAC1F,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,GAAG;QAAE,MAAM,EAAE,QAAQ,CAAC;QAAC,MAAM,EAAE,qBAAqB,CAAA;KAAE,CAAC;IAW3H;;;;;;;;;OASG;IACG,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAE,qBAAgD,GAAG,OAAO,CAAC,QAAQ,CAAC;QAAE,eAAe,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAO5J;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,QAAQ,CAyB1F"}