@nylorun/runtime 0.22.0-beta → 0.24.0-beta

package/dist/vault/sources.d.ts

@@ -1,30 +1,19 @@
-/**
- * Where a session's MCP or HTTP tool credential comes from: the vaults attached to the session,
- * and nothing else. OSS holds no OAuth client and asks no credential resolver (protocol 10,
- * D49): a person's own keys live in their user vault, the installation's in its vaults.
- *
- * Both authorize sites call this: the gateway (`gates/tenant-vaults.ts`, remote MCP servers and
- * HTTP tools in the gates service) and the Tenant (`tenant/effects.ts`, the in-process MCP pool
- * and Tool Gate). The session comes from its row, never from the harness.
- */
-import { type CredentialSelection } from "@nylorun/core/contracts";
 import type { AuthorizeResult, VaultService } from "./service.js";
 /** The session a request is made for: its row, as stored. */
 export interface CredentialSession {
     readonly id: string;
     readonly ownerUserId: string;
-    readonly vaultIds?: readonly string[];
-    readonly credentialSelections?: readonly CredentialSelection[];
+    readonly environmentId?: string;
 }
-/** One MCP or HTTP tool request: its URL, and the name a credential selection matches. */
+/** One MCP or HTTP tool request: its URL, and the server's (or HTTP tool credential's) name. */
 export interface McpCredentialRequest {
     readonly url: string;
-    /** The server's name, or the HTTP tool's `credential`: what a credential selection names. */
+    /** The server's name, or the HTTP tool's `credential`, for audit and messages. */
     readonly serverName?: string;
 }
 /**
- * The credential of one request made for `session`: the vault's answer over the session's
- * attached vaults (`VaultService.authorize`). A credential with an identity header (R2b C2)
+ * The credential of one request made for `session`: the answer of its Environment's vault
+ * (`VaultService.authorize`). A credential with an identity header (R2b C2)
  * gets the session owner's subject in it (Q2), from the session row: the run token names no
  * owner, so neither the model nor the manifest can change it. A session whose owner is no
  * person (the reserved `installation`) sends none (Q3).

package/dist/vault/sources.js

@@ -1,7 +1,7 @@
 /**
- * Where a session's MCP or HTTP tool credential comes from: the vaults attached to the session,
- * and nothing else. OSS holds no OAuth client and asks no credential resolver (protocol 10,
- * D49): a person's own keys live in their user vault, the installation's in its vaults.
+ * Where a session's MCP or HTTP tool credential comes from: the vault of the Environment the
+ * session names (D56), and nothing else. OSS holds no OAuth client and asks no credential
+ * resolver (protocol 10, D49): a person's own keys live in the Environment the app maps to them.
  *
  * Both authorize sites call this: the gateway (`gates/tenant-vaults.ts`, remote MCP servers and
  * HTTP tools in the gates service) and the Tenant (`tenant/effects.ts`, the in-process MCP pool
@@ -9,8 +9,8 @@
  */
 import { isSubject } from "@nylorun/core/contracts";
 /**
- * The credential of one request made for `session`: the vault's answer over the session's
- * attached vaults (`VaultService.authorize`). A credential with an identity header (R2b C2)
+ * The credential of one request made for `session`: the answer of its Environment's vault
+ * (`VaultService.authorize`). A credential with an identity header (R2b C2)
  * gets the session owner's subject in it (Q2), from the session row: the run token names no
  * owner, so neither the model nor the manifest can change it. A session whose owner is no
  * person (the reserved `installation`) sends none (Q3).
@@ -18,10 +18,8 @@ import { isSubject } from "@nylorun/core/contracts";
 export async function sessionCredentials(vault, session, request) {
     const result = await vault.authorize({
         sessionId: session.id,
-        vaultIds: session.vaultIds ?? [],
-        credentialSelections: session.credentialSelections ?? [],
+        ...(session.environmentId === undefined ? {} : { environmentId: session.environmentId }),
         url: request.url,
-        ...(request.serverName === undefined ? {} : { serverName: request.serverName }),
     });
     if (result.status !== "authorized" || !result.identity || !isSubject(session.ownerUserId))
         return result;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.22.0-beta";
+export declare const RUNTIME_VERSION = "0.24.0-beta";

package/dist/version.js

@@ -1,3 +1,3 @@
-// Kept in step with package.json by runtime/scripts/check-package.mjs, which runs in npm run check.
+// Kept in step with package.json by runtime/server/scripts/check-package.mjs, which runs in npm run check.
 // release:prepare also rewrites this when it bumps @nylorun/runtime.
-export const RUNTIME_VERSION = "0.22.0-beta";
+export const RUNTIME_VERSION = "0.24.0-beta";

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.22.0-beta",
+  "version": "0.24.0-beta",
   "description": "Nylorun Runtime: the agent execution Host on Postgres, Restate and S2, and model providers.",
   "type": "module",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nylorun/agents.git",
-    "directory": "runtime"
+    "directory": "runtime/server"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -45,9 +45,9 @@
     "provenance": true
   },
   "scripts": {
-    "build": "npm run clean && node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json && node scripts/copy-migrations.mjs && node scripts/build-openapi.mjs",
+    "build": "npm run clean && node ../../scripts/check-typescript-version.mjs && tsc -p tsconfig.json && node scripts/copy-migrations.mjs && node scripts/build-openapi.mjs",
     "check": "npm run build && npm test && node scripts/check-package.mjs",
-    "typecheck": "node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json --noEmit",
+    "typecheck": "node ../../scripts/check-typescript-version.mjs && tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "test:integration": "vitest run --config vitest.integration.config.ts",
     "test:stack:up": "node test/stack/up.mjs up",
@@ -59,21 +59,22 @@
     "db:studio": "drizzle-kit studio"
   },
   "dependencies": {
-    "@ag-ui/core": "~1.0.1",
+    "@ag-ui/core": "~1.0.2",
     "@asteasolutions/zod-to-openapi": "^9.1.0",
     "@earendil-works/pi-ai": "0.99.1",
     "@hono/node-server": "^2.1.3",
     "@hono/zod-openapi": "^1.6.3",
-    "@modelcontextprotocol/sdk": "^1.31.0",
-    "@nylorun/core": "0.19.0-beta",
-    "@nylorun/harness": "0.25.1-beta",
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "@nylorun/core": "0.20.0-beta",
+    "@nylorun/harness": "0.26.0-beta",
     "@restatedev/restate-sdk": "1.17.2",
+    "@restatedev/restate-sdk-clients": "1.17.2",
     "@s2-dev/streamstore": "0.28.0",
     "aws4fetch": "1.0.20",
     "drizzle-orm": "^0.45.3",
-    "hono": "^4.13.12",
+    "hono": "^4.13.13",
     "jose": "^6.2.12",
-    "just-bash": "3.4.2",
+    "just-bash": "3.6.0",
     "pg": "8.23.1",
     "pg-logical-replication": "2.5.0",
     "postgres": "^3.4.9",
@@ -83,9 +84,9 @@
   },
   "devDependencies": {
     "@a2a-js/sdk": "~1.3.0",
-    "@ag-ui/client": "1.0.1",
-    "@scalar/openapi-parser": "^0.29.9",
-    "@types/node": "^26.5.0",
+    "@ag-ui/client": "1.0.2",
+    "@scalar/openapi-parser": "^0.29.11",
+    "@types/node": "^26.6.4",
     "@types/pg": "^8.23.1",
     "@types/ws": "^8.18.2",
     "@typescript/native": "npm:typescript@^7.0.2",

package/dist/api/http/routes/sandboxes.d.ts

@@ -1,9 +0,0 @@
-/**
- * Sandboxes as a resource (`/v1/sandboxes/**`, Host feature `sandboxes`): create or find one by
- * id, read it, list them by label, read its lifecycle stream, and delete it. Ids may hold `/`,
- * sent percent-encoded as one path segment (`team-a%2Fproj-42`). A token caller reaches only
- * the ids its sandbox grants match, and changes them only with `sandboxes:write`.
- */
-import type { OpenAPIHono } from "@hono/zod-openapi";
-import type { TenantEnv } from "../app.js";
-export declare function sandboxRoutes(api: OpenAPIHono<TenantEnv>): void;

package/dist/api/http/routes/sandboxes.js

@@ -1,153 +0,0 @@
-import { z } from "zod";
-import { isSandboxId, PutSandboxRequestSchema } from "@nylorun/core/contracts";
-import { DeleteSandboxResponse, ListSandboxEventsResponse, ListSandboxesResponse, SandboxPage, PutSandboxRequest, SandboxView, } from "../../components.js";
-import { fail } from "../../../tenant/http.js";
-import { deleteSandbox, getSandbox, listSandboxes, putSandbox, resetSandbox, sandboxEventsOf, stopSandbox, } from "../../../tenant/sandboxes.js";
-import { readJson } from "../body.js";
-import { tenantRoute } from "../define.js";
-import { pageQuery, sandboxPage } from "./reads.js";
-import { jsonResponse } from "../respond.js";
-/** Reading a sandbox: any caller that may use sessions, or change sandboxes. */
-const READ = {
-    credentials: ["application", "subject", "token"],
-    scopes: ["sessions:own", "sandboxes:write"],
-};
-/** Creating or deleting one. */
-const WRITE = {
-    credentials: ["application", "subject", "token"],
-    scopes: ["sandboxes:write"],
-};
-const json = (schema, description) => ({
-    description,
-    content: { "application/json": { schema } },
-});
-const sandboxId = z.object({
-    sandboxId: z
-        .string()
-        .meta({ description: "The sandbox id, percent-encoded: `team-a%2Fproj-42` for `team-a/proj-42`" }),
-});
-/** The path's sandbox id, or a 400 naming the rule. */
-function idOf(value) {
-    if (!isSandboxId(value))
-        return fail(400, "A sandbox id is up to 200 characters: /-separated segments of letters, digits, '.', '_' and '-'");
-    return value;
-}
-/** `label=k=v`, repeated: every one must match. */
-function labelsOf(values) {
-    const labels = {};
-    for (const value of values ?? []) {
-        const at = value.indexOf("=");
-        if (at <= 0)
-            fail(400, `label must be key=value, not ${value}`);
-        labels[value.slice(0, at)] = value.slice(at + 1);
-    }
-    return labels;
-}
-export function sandboxRoutes(api) {
-    tenantRoute(api, READ, {
-        method: "get",
-        path: "/v1/sandboxes",
-        tags: ["Sandboxes"],
-        summary: "List sandboxes",
-        description: "Every sandbox with all the labels asked for. A token caller sees only the sandboxes its grants reach.",
-        request: {
-            query: pageQuery.extend({
-                label: z
-                    .union([z.string(), z.array(z.string())])
-                    .optional()
-                    .meta({ description: "`key=value`; repeat it to require several labels" }),
-            }),
-        },
-        responses: { 200: json(z.union([ListSandboxesResponse, SandboxPage]), "The sandboxes; limit opts into pagination") },
-    }, async (c) => jsonResponse(200, c.req.query("limit") !== undefined
-        ? await sandboxPage(c.env.tenant, c.get("scope"), c.req.query(), labelsOf(c.req.queries("label")))
-        : await listSandboxes(c.env.tenant, labelsOf(c.req.queries("label")), c.get("scope"))));
-    tenantRoute(api, WRITE, {
-        method: "put",
-        path: "/v1/sandboxes/{sandboxId}",
-        tags: ["Sandboxes"],
-        summary: "Create or find a sandbox",
-        description: "Creates the sandbox within the Tenant's limits, or answers the one with this id, so get-or-create is one call. Its spec is fixed once it exists; labels, when sent, replace its labels. Kind `pod` needs sandbox pods (`nylorun sandbox enable`): it is created at once, and a PUT on an existing pod sandbox starts it again when it was stopped, or revives it with a longer `lifecycle.ttl`.",
-        request: {
-            params: sandboxId,
-            body: { required: true, content: { "application/json": { schema: PutSandboxRequest } } },
-        },
-        responses: {
-            200: json(SandboxView, "The sandbox"),
-            409: {
-                description: "A sandbox with this id has another spec, the Tenant holds as many sandboxes as it allows (`limit_exceeded`), kind pod without sandbox pods (`sandbox_unavailable`), or a lost pod sandbox (`sandbox_lost`)",
-            },
-        },
-    }, async (c) => {
-        const id = idOf(c.req.param("sandboxId"));
-        const body = PutSandboxRequestSchema.parse(await readJson(c.req.raw));
-        return jsonResponse(200, await putSandbox(c.env.tenant, id, body, c.get("scope")));
-    });
-    tenantRoute(api, READ, {
-        method: "get",
-        path: "/v1/sandboxes/{sandboxId}",
-        tags: ["Sandboxes"],
-        summary: "Get a sandbox",
-        description: "Its spec, labels, state and the sessions attached to it (acting for a person, only theirs).",
-        request: { params: sandboxId },
-        responses: { 200: json(SandboxView, "The sandbox") },
-    }, async (c) => jsonResponse(200, await getSandbox(c.env.tenant, idOf(c.req.param("sandboxId")), c.get("scope"))));
-    tenantRoute(api, READ, {
-        method: "get",
-        path: "/v1/sandboxes/{sandboxId}/events",
-        tags: ["Sandboxes"],
-        summary: "Read a sandbox's lifecycle events",
-        description: "`sandbox.created`, `sandbox.attached`, `sandbox.detached` and `sandbox.deleted`, in order, numbered from 0.",
-        request: {
-            params: sandboxId,
-            query: z.object({
-                from: z.string().optional().meta({ description: "The first `seq` to return" }),
-            }),
-        },
-        responses: { 200: json(ListSandboxEventsResponse, "The events") },
-    }, async (c) => {
-        const from = c.req.query("from");
-        if (from !== undefined && !/^\d+$/.test(from))
-            fail(400, "from must be a seq");
-        return jsonResponse(200, await sandboxEventsOf(c.env.tenant, idOf(c.req.param("sandboxId")), c.get("scope"), from === undefined ? undefined : Number(from)));
-    });
-    tenantRoute(api, WRITE, {
-        method: "delete",
-        path: "/v1/sandboxes/{sandboxId}",
-        tags: ["Sandboxes"],
-        summary: "Delete a sandbox",
-        description: "Deletes the sandbox and its files. Sessions attached to it stay attached by id; their next turn is refused until a sandbox with this id exists again.",
-        request: { params: sandboxId },
-        responses: {
-            200: json(DeleteSandboxResponse, "Deleted, or there was none"),
-            409: { description: "A session attached to it has a turn running (`sandbox_busy`)" },
-        },
-    }, async (c) => jsonResponse(200, await deleteSandbox(c.env.tenant, idOf(c.req.param("sandboxId")), c.get("scope"))));
-    for (const [action, summary, description, run] of [
-        [
-            "stop",
-            "Stop a pod sandbox",
-            "Suspends the pod: its volume is kept, and the next turn of a session attached to it (or a PUT) starts it again. Refused during a turn (`sandbox_busy`).",
-            stopSandbox,
-        ],
-        [
-            "reset",
-            "Reset a pod sandbox",
-            "A new pod on a new, empty volume; the old pod and volume are deleted. The way out of `sandbox_lost`. Refused during a turn (`sandbox_busy`).",
-            resetSandbox,
-        ],
-    ])
-        tenantRoute(api, WRITE, {
-            method: "post",
-            path: `/v1/sandboxes/{sandboxId}/${action}`,
-            tags: ["Sandboxes"],
-            summary,
-            description,
-            request: { params: sandboxId },
-            responses: {
-                200: json(SandboxView, "The sandbox"),
-                400: { description: "The sandbox is virtual" },
-                409: { description: "A turn holds it (`sandbox_busy`), or no sandbox pods (`sandbox_unavailable`)" },
-            },
-        }, async (c) => jsonResponse(200, await run(c.env.tenant, idOf(c.req.param("sandboxId")), c.get("scope"))));
-}

package/dist/api/http/routes/vaults.d.ts

@@ -1,10 +0,0 @@
-/**
- * Vaults and their credentials (`/v1/tenant/vaults/**`, the Management API, protocol 8): secrets
- * a session's tools use. Only a management key (or Studio's key, acting as itself) reaches these
- * routes; an application key is `403 key_role_mismatch`, and nothing acts for a subject here. The
- * installation's own vaults (`scope: "installation"`) attach to any session (`vaultIds`); a vault
- * of one person (`ownerUserId`) attaches only to that person's sessions.
- */
-import type { OpenAPIHono } from "@hono/zod-openapi";
-import type { TenantEnv } from "../app.js";
-export declare function vaultRoutes(api: OpenAPIHono<TenantEnv>): void;

package/dist/api/http/routes/vaults.js

@@ -1,139 +0,0 @@
-import { z } from "zod";
-import { CreateCredentialRequestSchema, CreateVaultRequestSchema, RotateCredentialRequestSchema, } from "@nylorun/core/contracts";
-import { CreateCredentialRequest, CreateVaultRequest, CredentialInfo, DeletedResponse, ListCredentialsResponse, ListVaultsResponse, RotateCredentialRequest, VaultInfo, } from "../../components.js";
-import { readJson } from "../body.js";
-import { tenantRoute } from "../define.js";
-import { jsonResponse } from "../respond.js";
-/** The Management API's vault routes (`/v1/tenant/vaults`): a management key. */
-const MANAGEMENT = { credentials: ["management"], scopes: "never" };
-const json = (schema, description) => ({
-    description,
-    content: { "application/json": { schema } },
-});
-const body = (schema) => ({
-    required: true,
-    content: { "application/json": { schema } },
-});
-const vaultId = z.object({ vaultId: z.string() });
-const credentialId = vaultId.extend({ credentialId: z.string() });
-/** The vault routes under `base` (`/v1/tenant/vaults`). */
-function vaultRoutesAt(api, base, access) {
-    tenantRoute(api, access, {
-        method: "post",
-        path: `${base}`,
-        tags: ["Vaults"],
-        summary: "Create a vault",
-        description: "With `scope: \"installation\"` the installation's own vault, owned by `installation`, which any session may attach; or a vault of one person (`ownerUserId`), which only that person's sessions attach.",
-        request: { body: body(CreateVaultRequest) },
-        responses: {
-            200: json(VaultInfo, "The vault"),
-            409: { description: "The idempotency key was used for another vault" },
-        },
-    }, async (c) => {
-        const request = CreateVaultRequestSchema.parse(await readJson(c.req.raw));
-        return jsonResponse(200, await c.env.tenant.vault.createVault(request));
-    });
-    tenantRoute(api, access, {
-        method: "get",
-        path: `${base}`,
-        tags: ["Vaults"],
-        summary: "List vaults",
-        description: "The installation vaults, after the vaults of `ownerUserId` when it names a person.",
-        request: {
-            query: z.object({
-                ownerUserId: z
-                    .string()
-                    .optional()
-                    .meta({ description: "Also list this person's vaults" }),
-            }),
-        },
-        responses: { 200: json(ListVaultsResponse, "The vaults") },
-    }, async (c) => {
-        return jsonResponse(200, {
-            vaults: await c.env.tenant.vault.listVaults(c.req.query("ownerUserId"), {
-                installation: true,
-            }),
-        });
-    });
-    tenantRoute(api, access, {
-        method: "get",
-        path: `${base}/{vaultId}`,
-        tags: ["Vaults"],
-        summary: "Get a vault",
-        request: { params: vaultId },
-        responses: { 200: json(VaultInfo, "The vault") },
-    }, async (c) => {
-        return jsonResponse(200, await c.env.tenant.vault.getVault(c.req.param("vaultId")));
-    });
-    tenantRoute(api, access, {
-        method: "delete",
-        path: `${base}/{vaultId}`,
-        tags: ["Vaults"],
-        summary: "Delete a vault and its credentials",
-        request: { params: vaultId },
-        responses: { 200: json(DeletedResponse, "Deleted") },
-    }, async (c) => {
-        return jsonResponse(200, await c.env.tenant.vault.deleteVault(c.req.param("vaultId")));
-    });
-    tenantRoute(api, access, {
-        method: "post",
-        path: `${base}/{vaultId}/credentials`,
-        tags: ["Vaults"],
-        summary: "Add a credential",
-        description: "A bearer token, bound to the URL a tool may send it to.",
-        request: { params: vaultId, body: body(CreateCredentialRequest) },
-        responses: { 200: json(CredentialInfo, "The credential, without its secret") },
-    }, async (c) => {
-        const request = CreateCredentialRequestSchema.parse(await readJson(c.req.raw));
-        return jsonResponse(200, await c.env.tenant.keys.createCredential(c.req.param("vaultId"), request));
-    });
-    tenantRoute(api, access, {
-        method: "get",
-        path: `${base}/{vaultId}/credentials`,
-        tags: ["Vaults"],
-        summary: "List a vault's credentials",
-        request: { params: vaultId },
-        responses: { 200: json(ListCredentialsResponse, "The credentials, without their secrets") },
-    }, async (c) => {
-        return jsonResponse(200, {
-            credentials: await c.env.tenant.vault.listCredentials(c.req.param("vaultId")),
-        });
-    });
-    tenantRoute(api, access, {
-        method: "get",
-        path: `${base}/{vaultId}/credentials/{credentialId}`,
-        tags: ["Vaults"],
-        summary: "Get a credential",
-        request: { params: credentialId },
-        responses: { 200: json(CredentialInfo, "The credential, without its secret") },
-    }, async (c) => {
-        return jsonResponse(200, await c.env.tenant.vault.getCredential(c.req.param("vaultId"), c.req.param("credentialId")));
-    });
-    tenantRoute(api, access, {
-        method: "post",
-        path: `${base}/{vaultId}/credentials/{credentialId}`,
-        tags: ["Vaults"],
-        summary: "Rotate a credential's secret",
-        request: { params: credentialId, body: body(RotateCredentialRequest) },
-        responses: {
-            200: json(CredentialInfo, "The credential"),
-            409: { description: "A credential's type cannot change" },
-        },
-    }, async (c) => {
-        const request = RotateCredentialRequestSchema.parse(await readJson(c.req.raw));
-        return jsonResponse(200, await c.env.tenant.keys.rotateCredential(c.req.param("vaultId"), c.req.param("credentialId"), request));
-    });
-    tenantRoute(api, access, {
-        method: "delete",
-        path: `${base}/{vaultId}/credentials/{credentialId}`,
-        tags: ["Vaults"],
-        summary: "Delete a credential",
-        request: { params: credentialId },
-        responses: { 200: json(DeletedResponse, "Deleted") },
-    }, async (c) => {
-        return jsonResponse(200, await c.env.tenant.vault.deleteCredential(c.req.param("vaultId"), c.req.param("credentialId")));
-    });
-}
-export function vaultRoutes(api) {
-    vaultRoutesAt(api, "/v1/tenant/vaults", MANAGEMENT);
-}

package/dist/record/sandbox.d.ts

@@ -1,25 +0,0 @@
-import { type SandboxEvent, type SandboxEventPayload, type SandboxEventType } from "@nylorun/core/contracts";
-/** The sandbox stream's two statements, in the caller's transaction. */
-export interface SandboxRecordWriter {
-    /** The seq the sandbox's next event takes: one past its last, or 0. */
-    nextSeq(sandboxId: string): Promise<number>;
-    insert(row: {
-        sandboxId: string;
-        seq: number;
-        type: string;
-        body: SandboxEvent;
-    }): Promise<void>;
-}
-export interface SandboxAppendInput<T extends SandboxEventType> {
-    tenantId: string;
-    sandboxId: string;
-    time: Date;
-    type: T;
-    payload: SandboxEventPayload<T>;
-}
-/** Builds the event and checks it against the sandbox event catalog. */
-export declare function buildSandboxEvent<T extends SandboxEventType>(input: SandboxAppendInput<T> & {
-    seq: number;
-}): SandboxEvent;
-/** Appends one event to the sandbox's stream through `writer`. */
-export declare function appendSandboxEvent<T extends SandboxEventType>(writer: SandboxRecordWriter, input: SandboxAppendInput<T>): Promise<SandboxEvent>;

package/dist/record/sandbox.js

@@ -1,43 +0,0 @@
-/**
- * A sandbox's lifecycle stream (blueprint D39, F7.1): `sandbox.created`, `sandbox.attached`,
- * `sandbox.detached` and `sandbox.deleted`, on the `nylorun.sandbox-event/1` envelope, numbered
- * from 0 per sandbox id in `nylorun_streams.sandbox_events`. The record module is its only
- * writer, as for session events; the store runs the two statements through
- * `SandboxRecordWriter` in the caller's transaction, under the sandbox row's lock (or, for a
- * sandbox being created, its new row).
- *
- * The stream lives in the record only: it is not published to the stream relay, so no S2
- * stream follows it yet. Clients read it with `GET /v1/sandboxes/{id}/events`.
- */
-import { randomUUID } from "node:crypto";
-import { z } from "zod";
-import { SANDBOX_EVENT_PAYLOADS, SANDBOX_EVENT_SCHEMA, SandboxEventSchema, } from "@nylorun/core/contracts";
-import { InvalidEventError } from "./envelope.js";
-/** Builds the event and checks it against the sandbox event catalog. */
-export function buildSandboxEvent(input) {
-    const payload = SANDBOX_EVENT_PAYLOADS[input.type];
-    const checkedPayload = payload.safeParse(input.payload);
-    if (!checkedPayload.success)
-        throw new InvalidEventError(input.type, z.prettifyError(checkedPayload.error));
-    const event = JSON.parse(JSON.stringify({
-        schema: SANDBOX_EVENT_SCHEMA,
-        eventId: randomUUID(),
-        tenantId: input.tenantId,
-        sandboxId: input.sandboxId,
-        seq: input.seq,
-        time: input.time.toISOString(),
-        type: input.type,
-        payload: input.payload,
-    }));
-    const checked = SandboxEventSchema.safeParse(event);
-    if (!checked.success)
-        throw new InvalidEventError(input.type, z.prettifyError(checked.error));
-    return event;
-}
-/** Appends one event to the sandbox's stream through `writer`. */
-export async function appendSandboxEvent(writer, input) {
-    const seq = await writer.nextSeq(input.sandboxId);
-    const event = buildSandboxEvent({ ...input, seq });
-    await writer.insert({ sandboxId: input.sandboxId, seq, type: input.type, body: event });
-    return event;
-}