@verax-ai/body 0.1.0

package/dist/server.js

@@ -0,0 +1,484 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createServer } from "node:http";
+import { Server as McpServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { approvalsLogFor, approvePending, explain, LedgerDenyUnrecorded, loadApprovalsFromDir, } from "@verax-ai/proxy";
+import { createVerifier, readBearer, resourceMetadataUrl, wwwAuthenticate } from "./auth.js";
+import { bumpMetric, bumpUnauthenticated } from "./metrics.js";
+import { isRevokedJti } from "./revoke.js";
+import { loadOrCreateSigners } from "./keys.js";
+import { matchingInputs } from "./inputs-read.js";
+import { readPolicySnapshots } from "./policy-store.js";
+import { readHeartbeat, readWitnessPulse } from "./health-extras.js";
+import { inventoryHealth, readInventoryFile } from "./inventory-file.js";
+import { createBodyServices, TOOL_NAMES } from "./wiring.js";
+const TOOL_META = [
+    {
+        name: "memory.get",
+        description: "Read a memory item. Stale items return { stale: true } without the body.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: { id: { type: "string" } },
+            required: ["id"],
+        },
+    },
+    {
+        name: "memory.put",
+        description: "Write a memory item. source and validUntilMs are required.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                id: { type: "string" },
+                body: {},
+                source: { type: "object" },
+                validFromMs: { type: "number" },
+                validUntilMs: { type: "number" },
+            },
+            required: ["id", "body", "source", "validUntilMs"],
+        },
+    },
+    {
+        name: "audit.explain",
+        description: "Explain a decision ref against the ledger.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: { ref: { type: "string" } },
+            required: ["ref"],
+        },
+    },
+    {
+        name: "message.read",
+        description: "Read the local inbox fixture as JSON.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {},
+        },
+    },
+    {
+        name: "message.send",
+        description: "Queue a message on the local outbox. Does not open a network.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                to: { type: "string" },
+                text: { type: "string" },
+            },
+            required: ["to", "text"],
+        },
+    },
+    {
+        name: "spend",
+        description: "Authorizes a payment; does not move money.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                amountMinor: { type: "integer" },
+                currency: { type: "string" },
+                payee: { type: "string" },
+                reference: { type: "string" },
+            },
+            required: ["amountMinor", "currency", "payee", "reference"],
+        },
+    },
+];
+const MAX_BODY_BYTES = 1024 * 1024;
+const responseSlot = new AsyncLocalStorage();
+function contentLengthOverLimit(req) {
+    const raw = req.headers["content-length"];
+    if (raw === undefined)
+        return false;
+    const n = Number(Array.isArray(raw) ? raw[0] : raw);
+    return Number.isFinite(n) && n > MAX_BODY_BYTES;
+}
+async function readJsonBody(req, max) {
+    if (contentLengthOverLimit(req))
+        return { ok: false, tooLarge: true };
+    const chunks = [];
+    let seen = 0;
+    try {
+        for await (const chunk of req) {
+            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            seen += buf.length;
+            if (seen > max) {
+                return { ok: false, tooLarge: true };
+            }
+            chunks.push(buf);
+        }
+    }
+    catch {
+        return { ok: false, bad: true };
+    }
+    const text = Buffer.concat(chunks).toString("utf8");
+    if (text === "")
+        return { ok: true, value: undefined };
+    try {
+        return { ok: true, value: JSON.parse(text) };
+    }
+    catch {
+        return { ok: false, bad: true };
+    }
+}
+function isProtectedResourcePath(pathname, audience) {
+    const want = new URL(resourceMetadataUrl(audience)).pathname;
+    return pathname === want || pathname === "/.well-known/oauth-protected-resource";
+}
+function send(res, status, body, headers) {
+    const text = typeof body === "string" ? body : JSON.stringify(body);
+    res.writeHead(status, {
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(text),
+        "x-content-type-options": "nosniff",
+        ...headers,
+    });
+    res.end(text);
+}
+export async function listen(config) {
+    const signers = loadOrCreateSigners(config.stateDir);
+    const services = createBodyServices({
+        stateDir: config.stateDir,
+        policyFile: config.policyFile,
+        recordSigner: signers.recordSigner,
+        effectSigner: signers.effectSigner,
+    });
+    const verify = createVerifier(config.jwksUrl, config.issuer, config.audience);
+    const attachHandlers = (mcp) => {
+        mcp.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOL_META }));
+        mcp.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+            const auth = extra?.authInfo;
+            const scopes = new Set(auth?.scopes ?? []);
+            const bag = (auth?.extra ?? {});
+            const brain = typeof bag.sub === "string" ? bag.sub : (auth?.clientId ?? "unknown");
+            try {
+                return await services.proxy.call({ name: request.params.name, arguments: (request.params.arguments ?? {}) }, {
+                    brain,
+                    scopes,
+                    ...(typeof bag.iss === "string" ? { iss: bag.iss } : {}),
+                    ...(typeof bag.tenant === "string" ? { tenant: bag.tenant } : {}),
+                    ...(typeof bag.org === "string" ? { org: bag.org } : {}),
+                });
+            }
+            catch (err) {
+                if (err instanceof LedgerDenyUnrecorded) {
+                    await bumpMetric(config.stateDir, "disk_deny_unrecorded");
+                    const res = responseSlot.getStore();
+                    if (res && !res.headersSent) {
+                        send(res, 507, { error: "insufficient-storage" });
+                    }
+                    throw err;
+                }
+                throw err;
+            }
+        });
+    };
+    const server = createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "127.0.0.1"}`);
+            if (req.method === "POST" && contentLengthOverLimit(req)) {
+                send(res, 413, { error: "payload-too-large" });
+                req.resume();
+                return;
+            }
+            if (req.method === "GET" && url.pathname === "/healthz") {
+                const token = readBearer(req.headers.authorization);
+                let canRead = false;
+                if (token) {
+                    try {
+                        const verified = await verify(token);
+                        // Counts name how often and when the body worked. `verax:read` is a
+                        // brain scope, so it cannot be the key here; the operator session
+                        // carries `verax:audit`. A revoked or jti-less token is an
+                        // unauthenticated probe: liveness only.
+                        const jti = typeof verified.payload.jti === "string" ? verified.payload.jti : "";
+                        canRead =
+                            jti !== "" &&
+                                !isRevokedJti(config.stateDir, jti) &&
+                                verified.principal.scopes.has("verax:audit");
+                    }
+                    catch {
+                        canRead = false;
+                    }
+                }
+                if (!canRead) {
+                    send(res, 200, { ok: true });
+                    return;
+                }
+                const decisions = await services.ledger.decisions();
+                const effects = await services.ledger.effects();
+                const last = decisions[decisions.length - 1];
+                send(res, 200, {
+                    ok: true,
+                    decisions: decisions.length,
+                    effects: effects.length,
+                    lastDecisionMs: last ? last.claims.timestampMs : null,
+                    lock: services.ledger.lockStatus(),
+                    heartbeat: readHeartbeat(config.stateDir),
+                    witness: readWitnessPulse(config.stateDir),
+                    inventory: inventoryHealth(readInventoryFile(config.inventoryFile)),
+                });
+                return;
+            }
+            if (req.method === "GET" && isProtectedResourcePath(url.pathname, config.audience)) {
+                send(res, 200, {
+                    resource: config.audience,
+                    authorization_servers: [config.issuer],
+                    bearer_methods_supported: ["header"],
+                    scopes_supported: [
+                        "verax:read",
+                        "verax:memory",
+                        "verax:act",
+                        "verax:pay",
+                        "verax:audit",
+                        "verax:approve",
+                    ],
+                });
+                return;
+            }
+            const apiLedger = req.method === "GET" && url.pathname === "/api/ledger";
+            const apiInventory = url.pathname === "/api/inventory";
+            const contest = req.method === "POST" && url.pathname.startsWith("/api/contest/");
+            const apiApprove = req.method === "POST" && url.pathname === "/api/approve";
+            if (url.pathname !== "/mcp" && !apiLedger && !apiInventory && !contest && !apiApprove) {
+                send(res, 404, { error: "not-found" });
+                return;
+            }
+            const token = readBearer(req.headers.authorization);
+            if (!token) {
+                await bumpUnauthenticated(config.stateDir);
+                send(res, 401, { error: "unauthorized" }, { "www-authenticate": wwwAuthenticate(config.audience) });
+                return;
+            }
+            let verified;
+            try {
+                verified = await verify(token);
+            }
+            catch {
+                await bumpUnauthenticated(config.stateDir);
+                send(res, 401, { error: "unauthorized" }, { "www-authenticate": wwwAuthenticate(config.audience) });
+                return;
+            }
+            const jti = typeof verified.payload.jti === "string" ? verified.payload.jti : "";
+            if (jti === "" || isRevokedJti(config.stateDir, jti)) {
+                await bumpUnauthenticated(config.stateDir);
+                send(res, 401, { error: "unauthorized" }, { "www-authenticate": wwwAuthenticate(config.audience) });
+                return;
+            }
+            try {
+                if (apiApprove) {
+                    // Reading the ledger is not approving from it. The audit scope opens
+                    // every door above; this one signs a new decision and lets money go,
+                    // so it has a scope of its own.
+                    if (!verified.principal.scopes.has("verax:approve")) {
+                        send(res, 403, { error: "scope-missing" });
+                        return;
+                    }
+                    const parsed = await readJsonBody(req, MAX_BODY_BYTES);
+                    if (!parsed.ok) {
+                        send(res, 400, { error: "bad-body" });
+                        return;
+                    }
+                    const asked = (parsed.value ?? {});
+                    const ref = typeof asked.ref === "string" ? asked.ref : "";
+                    const sawHash = typeof asked.requestHash === "string" ? asked.requestHash : "";
+                    if (ref === "" || sawHash === "") {
+                        send(res, 400, { error: "ref-and-requestHash-required" });
+                        return;
+                    }
+                    const waiting = loadApprovalsFromDir(config.stateDir).find((row) => row.ref === ref);
+                    if (!waiting) {
+                        send(res, 404, { error: "unknown-ref" });
+                        return;
+                    }
+                    // The list on a phone can be ten minutes old. An approval names the
+                    // request the operator was looking at, and if that is not what is
+                    // waiting any more, nothing is approved: "I approved what I saw" is
+                    // only true when something checks it.
+                    if (waiting.requestHash !== sawHash) {
+                        send(res, 409, { error: "stale", requestHash: waiting.requestHash });
+                        return;
+                    }
+                    const decisions = await services.ledger.decisions();
+                    const defer = decisions.find((d) => d.claims.ref === ref && d.claims.decision === "defer");
+                    if (!defer) {
+                        send(res, 404, { error: "unknown-ref" });
+                        return;
+                    }
+                    // Who approved, on the record. The CLI writes the machine's login name,
+                    // which says nothing about the person holding the phone; the session's
+                    // own subject does.
+                    const approver = verified.principal.brain;
+                    const outcome = await approvePending({
+                        ledger: services.ledger,
+                        recordSigner: loadOrCreateSigners(config.stateDir).recordSigner,
+                        now: () => Date.now(),
+                        nonce: () => crypto.randomUUID(),
+                        ref,
+                        approverId: approver,
+                        via: "http",
+                        policyHash: defer.claims.policyHash,
+                        approvals: approvalsLogFor(services.ledger),
+                    });
+                    if (!outcome.ok) {
+                        const code = outcome.reason === "unknown-ref" || outcome.reason === "snapshot-missing" ? 404 : 409;
+                        send(res, code, { error: outcome.reason });
+                        return;
+                    }
+                    send(res, 200, { allowRef: outcome.allowRef, approver });
+                    return;
+                }
+                if (apiLedger || apiInventory || contest) {
+                    // The audit doors hand out the whole ledger: every tenant's decisions, the
+                    // inputs documents that name their principals, and the approval snapshots
+                    // that carry spend arguments. `verax:read` is a brain scope, so it cannot be
+                    // the key here; the operator session carries `verax:audit`.
+                    if (!verified.principal.scopes.has("verax:audit")) {
+                        send(res, 403, { error: "scope-missing" });
+                        return;
+                    }
+                    if (apiInventory) {
+                        if (req.method !== "GET") {
+                            send(res, 405, { error: "method-not-allowed" });
+                            return;
+                        }
+                        send(res, 200, readInventoryFile(config.inventoryFile));
+                        return;
+                    }
+                    if (apiLedger) {
+                        const from = Number(url.searchParams.get("from") ?? "0");
+                        const to = Number(url.searchParams.get("to") ?? String(Number.MAX_SAFE_INTEGER));
+                        const decisions = (await services.ledger.decisions()).filter((d) => d.claims.timestampMs >= from && d.claims.timestampMs < to);
+                        const effects = (await services.ledger.effects()).filter((e) => e.row.timestampMs >= from && e.row.timestampMs < to);
+                        const hashes = [...new Set(decisions.map((d) => d.claims.policyHash))];
+                        send(res, 200, {
+                            decisions,
+                            effects,
+                            policy: { hash: services.policyHash, document: services.policyDocument },
+                            policies: readPolicySnapshots(config.stateDir, hashes),
+                            inputs: await matchingInputs(config.stateDir, decisions),
+                            approvals: loadApprovalsFromDir(config.stateDir),
+                        });
+                        return;
+                    }
+                    const ref = decodeURIComponent(url.pathname.slice("/api/contest/".length));
+                    const result = await explain(services.ledger, ref, await services.explainOpts());
+                    send(res, 200, { ...result, reAuditedAt: Date.now() });
+                    return;
+                }
+                if (req.method === "GET") {
+                    // Stateless: no standalone SSE. The SDK client treats 405 as "no GET stream".
+                    res.writeHead(405, {
+                        allow: "POST, DELETE",
+                        "content-type": "application/json",
+                        "x-content-type-options": "nosniff",
+                    });
+                    res.end(JSON.stringify({ error: "method-not-allowed" }));
+                    return;
+                }
+                const mcp = new McpServer({ name: "verax-body", version: "0.0.0" }, { capabilities: { tools: {} } });
+                attachHandlers(mcp);
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: undefined,
+                    enableJsonResponse: true,
+                });
+                await mcp.connect(transport);
+                const parsed = req.method === "POST" ? await readJsonBody(req, MAX_BODY_BYTES) : { ok: true, value: undefined };
+                if (parsed.ok === false && "tooLarge" in parsed) {
+                    send(res, 413, { error: "payload-too-large" });
+                    req.destroy();
+                    return;
+                }
+                if (parsed.ok === false) {
+                    send(res, 400, { error: "bad-request" });
+                    return;
+                }
+                try {
+                    await responseSlot.run(res, async () => {
+                        try {
+                            await transport.handleRequest(Object.assign(req, {
+                                auth: {
+                                    token,
+                                    clientId: verified.principal.brain,
+                                    scopes: [...verified.principal.scopes],
+                                    extra: {
+                                        sub: verified.principal.brain,
+                                        ...(verified.principal.iss ? { iss: verified.principal.iss } : {}),
+                                        ...(verified.principal.tenant ? { tenant: verified.principal.tenant } : {}),
+                                        ...(verified.principal.org ? { org: verified.principal.org } : {}),
+                                    },
+                                },
+                            }), res, parsed.value);
+                        }
+                        catch (err) {
+                            if (res.headersSent && res.statusCode === 507)
+                                return;
+                            throw err;
+                        }
+                    });
+                }
+                catch (err) {
+                    if (err instanceof LedgerDenyUnrecorded) {
+                        if (!res.headersSent) {
+                            await bumpMetric(config.stateDir, "disk_deny_unrecorded");
+                            send(res, 507, { error: "insufficient-storage" });
+                        }
+                        return;
+                    }
+                    if (res.headersSent && res.statusCode === 507) {
+                        return;
+                    }
+                    const detail = err instanceof Error ? err.message : "fault";
+                    process.stderr.write(`verax-transport: ${detail}\n`);
+                    if (!res.headersSent) {
+                        send(res, 500, { error: "transport" });
+                    }
+                }
+                finally {
+                    await transport.close();
+                }
+            }
+            catch (err) {
+                if (res.headersSent)
+                    return;
+                const msg = err instanceof Error ? err.message : "";
+                if (msg.startsWith("explain-unknown-ref:")) {
+                    send(res, 404, { error: "unknown-ref" });
+                    return;
+                }
+                if (err instanceof URIError) {
+                    send(res, 400, { error: "bad-request" });
+                    return;
+                }
+                process.stderr.write(`verax-handler: ${msg || "fault"}\n`);
+                send(res, 500, { error: "fault" });
+            }
+        }
+        catch (err) {
+            if (res.headersSent)
+                return;
+            if (err instanceof TypeError) {
+                send(res, 400, { error: "bad-request" });
+                return;
+            }
+            process.stderr.write(`verax-handler: ${err instanceof Error ? err.message : "fault"}\n`);
+            send(res, 500, { error: "fault" });
+        }
+        finally {
+            // Swallow so a bad Host cannot reject the request listener.
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(config.bindPort, config.bindHost, () => resolve());
+    });
+    server.on("close", () => {
+        services.ledger.close();
+    });
+    return server;
+}
+export { TOOL_NAMES };

package/dist/tools/audit.d.ts

@@ -0,0 +1,2 @@
+import { type ExplainOpts, type Ledger, type ToolCall, type ToolResult } from "@verax-ai/proxy";
+export declare function auditExplain(call: ToolCall, ledger: Ledger, opts?: ExplainOpts): Promise<ToolResult>;

package/dist/tools/audit.js

@@ -0,0 +1,48 @@
+import { explain, spokenReason, } from "@verax-ai/proxy";
+export async function auditExplain(call, ledger, opts) {
+    const ref = call.arguments.ref;
+    if (typeof ref !== "string" || ref === "") {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ error: "ref-required" }) }],
+            isError: true,
+        };
+    }
+    let result;
+    try {
+        result = await explain(ledger, ref, opts);
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.startsWith("explain-unknown-ref:")) {
+            // Spoken the same as a tenant-mismatch refuse so the two calls look alike.
+            // The operator HTTP contest path still names unknown-ref.
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: spokenReason("tenant-mismatch") }) }],
+                isError: true,
+            };
+        }
+        throw err;
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    record: result.record.claims,
+                    effect: result.effect,
+                    finding: result.finding,
+                    witnessClass: result.witnessClass,
+                    guarantee: result.guarantee,
+                    warnings: result.warnings,
+                    trustRoot: result.trustRoot,
+                    pair: result.pair
+                        ? {
+                            defer: result.pair.defer?.claims ?? null,
+                            resolution: result.pair.resolution?.claims ?? null,
+                        }
+                        : undefined,
+                }),
+            },
+        ],
+        isError: false,
+    };
+}

package/dist/tools/memory.d.ts

@@ -0,0 +1,10 @@
+import { type Principal, type ToolCall, type ToolResult } from "@verax-ai/proxy";
+/** True when `id` exists under a different tenant. Does not read legacy `memory/`. */
+export declare function memoryBelongsToOtherTenant(stateDir: string, id: string, selfKey: string): boolean;
+export declare function readMemoryMeta(stateDir: string, id: string, principal?: Principal): Promise<{
+    versionHash: string;
+    validFromMs: number;
+    validUntilMs: number;
+} | null>;
+export declare function memoryGet(call: ToolCall, stateDir: string, now: () => number, principal: Principal): Promise<ToolResult>;
+export declare function memoryPut(call: ToolCall, stateDir: string, principal: Principal): Promise<ToolResult>;

package/dist/tools/memory.js

@@ -0,0 +1,137 @@
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { resolve, sep } from "node:path";
+import { canonical } from "@cedulon/core";
+import { tenantKey } from "@verax-ai/proxy";
+function sha256Canonical(value) {
+    return createHash("sha256").update(canonical(value), "utf8").digest("hex");
+}
+const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function jsonResult(value, isError = false) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(value) }],
+        isError,
+    };
+}
+function resolveMemoryPath(stateDir, id, principal) {
+    if (!ID_RE.test(id))
+        return null;
+    const memoryDir = resolve(stateDir, "tenants", tenantKey(principal), "memory");
+    const path = resolve(memoryDir, `${id}.json`);
+    const prefix = memoryDir.endsWith(sep) ? memoryDir : `${memoryDir}${sep}`;
+    if (!path.startsWith(prefix))
+        return null;
+    return path;
+}
+/** True when `id` exists under a different tenant. Does not read legacy `memory/`. */
+export function memoryBelongsToOtherTenant(stateDir, id, selfKey) {
+    if (!ID_RE.test(id))
+        return false;
+    const tenantsRoot = resolve(stateDir, "tenants");
+    if (!existsSync(tenantsRoot))
+        return false;
+    let names;
+    try {
+        names = readdirSync(tenantsRoot);
+    }
+    catch {
+        return false;
+    }
+    for (const name of names) {
+        if (name === selfKey)
+            continue;
+        const path = resolve(tenantsRoot, name, "memory", `${id}.json`);
+        const prefix = resolve(tenantsRoot, name, "memory");
+        const guarded = prefix.endsWith(sep) ? prefix : `${prefix}${sep}`;
+        if (!path.startsWith(guarded))
+            continue;
+        if (existsSync(path))
+            return true;
+    }
+    return false;
+}
+export async function readMemoryMeta(stateDir, id, principal) {
+    if (!principal)
+        return null;
+    const path = resolveMemoryPath(stateDir, id, principal);
+    if (path === null)
+        return null;
+    try {
+        const item = JSON.parse(await readFile(path, "utf8"));
+        const validFromMs = typeof item.validFromMs === "number" ? item.validFromMs : 0;
+        const validUntilMs = typeof item.validUntilMs === "number" ? item.validUntilMs : 0;
+        const versionHash = typeof item.versionHash === "string"
+            ? item.versionHash
+            : sha256Canonical({ id: item.id, body: item.body, validFromMs, validUntilMs });
+        return { versionHash, validFromMs, validUntilMs };
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+export async function memoryGet(call, stateDir, now, principal) {
+    const id = call.arguments.id;
+    if (typeof id !== "string" || id === "") {
+        return jsonResult({ error: "id-required" }, true);
+    }
+    const path = resolveMemoryPath(stateDir, id, principal);
+    if (path === null) {
+        return jsonResult({ error: "id-invalid" }, true);
+    }
+    try {
+        const item = JSON.parse(await readFile(path, "utf8"));
+        if (typeof item.validFromMs === "number" && item.validFromMs > now()) {
+            return jsonResult({ notYetValid: true, id: item.id, validFromMs: item.validFromMs });
+        }
+        if (typeof item.validUntilMs === "number" && item.validUntilMs < now()) {
+            return jsonResult({ stale: true, id: item.id, validUntilMs: item.validUntilMs });
+        }
+        return jsonResult(item);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return jsonResult({ error: "not-found", id }, true);
+        }
+        throw err;
+    }
+}
+export async function memoryPut(call, stateDir, principal) {
+    const id = call.arguments.id;
+    const body = call.arguments.body;
+    const source = call.arguments.source;
+    const validFromMs = call.arguments.validFromMs;
+    const validUntilMs = call.arguments.validUntilMs;
+    if (typeof id !== "string" || id === "") {
+        return jsonResult({ error: "id-required" }, true);
+    }
+    const path = resolveMemoryPath(stateDir, id, principal);
+    if (path === null) {
+        return jsonResult({ error: "id-invalid" }, true);
+    }
+    if (source === null || typeof source !== "object" || Array.isArray(source)) {
+        return jsonResult({ error: "source-required" }, true);
+    }
+    if (typeof validUntilMs !== "number") {
+        return jsonResult({ error: "validUntilMs-required" }, true);
+    }
+    const fromMs = typeof validFromMs === "number" ? validFromMs : 0;
+    const versionHash = sha256Canonical({ id, body, validFromMs: fromMs, validUntilMs });
+    const rec = {
+        id,
+        body,
+        source,
+        validFromMs: fromMs,
+        validUntilMs,
+        versionHash,
+    };
+    const dir = resolve(stateDir, "tenants", tenantKey(principal), "memory");
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify(rec)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    return jsonResult({ ok: true, id, versionHash });
+}