@nylorun/runtime 0.13.0-beta → 0.15.0-beta

package/dist/tenant/ephemeral.js

@@ -1,29 +1,28 @@
 /**
- * `startEphemeralRuntime`: a private, in-process Host on port 0 with one Tenant, for tests and
- * embeds that need the Runtime's HTTP API without the Docker stack. Nothing in it is durable:
- * its Tenants live in memory (the memory Session Store and memory Durable Streams) and are gone
- * after `close()`, or in the Postgres database a test passes. Scheduling is the in-process
- * execution each Tenant starts for itself.
+ * `startEphemeralRuntime`: a private, in-process Host on port 0 serving one Tenant, for tests
+ * and embeds that need the Runtime's HTTP API without Restate and S2. Its Tenant is the one
+ * the Postgres database the caller passes holds (`store/postgres/tenant.ts`), created there on
+ * first start through the same path as a Host's; there is no in-memory Session Store. The rest
+ * is not durable: Durable Streams are in memory and gone after `close()`, and scheduling is
+ * the in-process execution the Tenant starts for itself.
  *
- * It is not the temporary Tenant the smoke checks use (scripts/lib/temporary-tenant.mjs):
- * that one is created on the running stack, with the Tenant-level fixture model
- * (`model-setting.ts`), and deleted afterwards.
+ * The smoke checks do not use it: they reset the Tenant of a temporary Docker stack and seed
+ * the Tenant-level fixture model (`model-setting.ts`, scripts/lib/stack-tenant.mjs).
  */
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { createRequire } from "node:module";
 import { newTenantId } from "@nylorun/core/compatibility";
-import { hashToken, mintBearerToken } from "../core/executors.js";
+import { mintBearerToken } from "../core/bearer.js";
 import { createHost } from "../host/create-host.js";
 import { createKekFile } from "../vault/kek.js";
-import { MemorySessionStore } from "../store/memory.js";
 import { createTenantModule } from "./module.js";
-import { createMemoryTenantStore } from "./store-memory.js";
-import { createPostgresTenantStore } from "./store-pg.js";
+import { createPostgresTenantOpener } from "./store-pg.js";
+import { createPostgresClient, } from "../store/postgres/connect.js";
 import { MemoryStreams } from "../streams/memory.js";
 import { createTenantLogger } from "./logger.js";
 import { hostPaths, tenantPaths } from "./paths.js";
-import { bootstrapPrincipal } from "./principals.js";
+import { hostPrincipals } from "./principals.js";
 import { openTenantRuntime } from "./runtime.js";
 const nodeRequire = createRequire(import.meta.url);
 function coreVersion() {
@@ -38,69 +37,8 @@ function newHostId() {
     return `host_${newTenantId().slice(3)}`;
 }
 /**
- * A Tenant store whose Tenants live in memory: one memory Session Store per Tenant, created
- * with its bootstrap principals, kept across closes and re-opens, dropped on delete.
- */
-function memoryTenants(options) {
-    const stores = new Map();
-    const inner = createMemoryTenantStore({
-        configFor: options.configFor,
-        logger: options.logger,
-        openRuntime: async (config) => {
-            const store = stores.get(config.tenantId);
-            if (!store)
-                throw new Error(`Tenant ${config.tenantId} has no Session Store`);
-            return openTenantRuntime(config, {
-                createKekIfMissing: true,
-                streams: options.streams,
-                store: kept(store),
-                envelope: await inner.readEnvelope(config.tenantId),
-            });
-        },
-    });
-    const store = {
-        ...inner,
-        async create(envelope, bootstrap) {
-            const created = await inner.create(envelope, bootstrap);
-            if (created === "created") {
-                const sessions = new MemorySessionStore({ tenantId: envelope.id });
-                await sessions.tx((t) => bootstrapPrincipal(t, bootstrap));
-                stores.set(envelope.id, sessions);
-            }
-            return created;
-        },
-        async trash(id, now) {
-            await inner.trash(id, now);
-            await stores.get(id)?.close();
-            stores.delete(id);
-        },
-        async removePartial(id) {
-            await inner.removePartial(id);
-            await stores.get(id)?.close();
-            stores.delete(id);
-        },
-    };
-    return {
-        store,
-        async close() {
-            for (const sessions of stores.values())
-                await sessions.close();
-            stores.clear();
-        },
-    };
-}
-/** The Tenant closes its store on close; a memory store must outlive that for a re-open. */
-function kept(store) {
-    return {
-        tenantId: store.tenantId,
-        tx: (fn) => store.tx(fn),
-        onCommit: (listener) => store.onCommit(listener),
-        health: () => store.health(),
-        close: async () => { },
-    };
-}
-/**
- * Private Host on port 0 with one Tenant (D9 / A19). Not durable (see the module comment).
+ * Private Host on port 0 serving one Tenant (D9 / A19). Durable only in its database (see the
+ * module comment).
  * Exported from `@nylorun/runtime` and `@nylorun/runtime/core`.
  */
 export async function startEphemeralRuntime(options) {
@@ -108,8 +46,6 @@ export async function startEphemeralRuntime(options) {
     const paths = hostPaths(hostRoot);
     mkdirSync(paths.home, { recursive: true });
     mkdirSync(paths.tmp, { recursive: true });
-    mkdirSync(paths.tenants, { recursive: true });
-    mkdirSync(paths.trash, { recursive: true });
     const hostId = newHostId();
     const adminKey = options.adminKey ?? randomBytes(32).toString("hex");
     const hostConfig = {
@@ -131,7 +67,7 @@ export async function startEphemeralRuntime(options) {
     const baseline = options.baseline ?? {};
     const model = options.model ?? { kind: "scripted", output: "ok" };
     const configFor = (tenantId) => {
-        const tenant = tenantPaths(hostRoot, tenantId);
+        const tenant = tenantPaths(hostRoot);
         // A seeded `sandbox.backend` setting overrides this when the Tenant opens.
         const sandboxBackend = options.sandboxBackend ?? "virtual";
         return {
@@ -152,13 +88,26 @@ export async function startEphemeralRuntime(options) {
         };
     };
     const streams = new MemoryStreams();
-    const memory = options.database
-        ? undefined
-        : memoryTenants({ configFor, streams, logger });
-    const store = options.database
-        ? createPostgresTenantStore({
+    const ownPool = typeof options.database === "string"
+        ? createPostgresClient(options.database)
+        : undefined;
+    const applicationKey = options.applicationKey ?? mintBearerToken();
+    const principalId = options.principalId ?? `principal_${randomBytes(8).toString("hex")}`;
+    const module = createTenantModule({
+        open: createPostgresTenantOpener({
             hostRoot,
-            sql: options.database,
+            sql: ownPool ?? options.database,
+            create: {
+                tenantId: options.tenantId ?? newTenantId(),
+                name: options.name ?? "ephemeral",
+                principals: hostPrincipals({
+                    adminKey,
+                    application: { principalId, key: applicationKey },
+                    ...(options.studioCredentialHash
+                        ? { studioCredentialHash: options.studioCredentialHash }
+                        : {}),
+                }),
+            },
             configFor,
             logger,
             openRuntime: (config, opened) => openTenantRuntime(config, {
@@ -166,44 +115,58 @@ export async function startEphemeralRuntime(options) {
                 streams,
                 ...opened,
             }),
-        })
-        : memory.store;
-    const module = createTenantModule({
-        store,
+        }),
         logger,
-        onDeleted: (tenantId) => streams.deleteTenant(tenantId),
     });
-    await module.start();
-    const tenantId = options.tenantId ?? newTenantId();
-    const applicationKey = options.applicationKey ?? mintBearerToken();
-    const principalId = options.principalId ?? `principal_${randomBytes(8).toString("hex")}`;
-    const credentialHash = hashToken(applicationKey);
-    await module.create({
-        tenantId,
-        name: options.name ?? "ephemeral",
-        principalId,
-        credentialHash,
-        idempotencyKey: `ephemeral-${tenantId}`,
-        ...(options.studioCredentialHash
-            ? { studioCredentialHash: options.studioCredentialHash }
-            : {}),
-    });
-    // KEK for first vault write; openTenantRuntime also creates when hooks allow.
-    const kekPath = tenantPaths(hostRoot, tenantId).kek;
-    if (!existsSync(kekPath))
-        createKekFile(kekPath);
-    const host = createHost({
-        hostRoot,
-        module,
-        config: hostConfig,
-        credentials,
-        logger,
-        coreVersion: coreVersion(),
-    });
-    await host.listen();
+    let host;
+    /** Closes what was opened, in reverse order; `close()` and a failed start share it. */
+    const release = async () => {
+        await host?.close();
+        await module.close();
+        await streams.close();
+        await ownPool?.end({ timeout: 5 });
+        if (!options.retainRoot)
+            rmSync(hostRoot, { recursive: true, force: true });
+    };
+    let tenantId;
+    try {
+        // KEK for first vault write; openTenantRuntime also creates when hooks allow.
+        const kekPath = tenantPaths(hostRoot).kek;
+        mkdirSync(tenantPaths(hostRoot).root, { recursive: true, mode: 0o700 });
+        if (!existsSync(kekPath))
+            createKekFile(kekPath);
+        host = createHost({
+            hostRoot,
+            module,
+            config: hostConfig,
+            credentials,
+            logger,
+            coreVersion: coreVersion(),
+            browserAccess: options.browserAccess === true,
+            ...(options.operatorListener
+                ? { operator: { host: "127.0.0.1", port: 0 } }
+                : {}),
+        });
+        // Opens the Tenant: creates it in the database first when it holds none.
+        await host.listen();
+        const tenant = module.tenant();
+        if (tenant.state !== "open" || !tenant.id)
+            throw new Error(tenant.cause
+                ? `The Tenant could not be opened (${tenant.cause.code}): ${tenant.cause.message}`
+                : "The Tenant could not be opened: its database is unavailable");
+        tenantId = tenant.id;
+    }
+    catch (error) {
+        await release().catch((cleanup) => logger.warn("ephemeral runtime cleanup failed", {
+            message: cleanup instanceof Error ? cleanup.message : String(cleanup),
+        }));
+        throw error;
+    }
+    const started = host;
     let closed = false;
     return {
-        url: host.url,
+        url: started.url,
+        adminUrl: started.adminUrl,
         tenantId,
         applicationKey,
         adminKey,
@@ -213,12 +176,7 @@ export async function startEphemeralRuntime(options) {
             if (closed)
                 return;
             closed = true;
-            await host.close();
-            await module.close();
-            await memory?.close();
-            await streams.close();
-            if (!options.retainRoot)
-                rmSync(hostRoot, { recursive: true, force: true });
+            await release();
         },
     };
 }

package/dist/tenant/history.d.ts

@@ -0,0 +1,64 @@
+/**
+ * One history (blueprint P0.3): the own loop's model-facing transcript is a fold of the
+ * session's record, not a copy on the session row.
+ *
+ * - **Write.** After a segment that keeps the engine's state (a rollover, or a settle that is
+ *   not a failure), the Runtime appends `transcript.updated` events: an edit from the
+ *   transcript the segment started with to the one the engine returned (`transcriptUpdates`).
+ *   Normal steps only append; compaction replaces the prefix, so its edit is a snapshot.
+ * - **Fold.** `foldTranscript` applies the edits in order. `turn.cancelled` and `turn.failed`
+ *   restore the transcript from before that turn's first edit, as cancel and failure restore
+ *   `turnStartState`.
+ * - **Lean rows.** The session row stores the engine state with an empty transcript
+ *   (`leanState`). `runSegment` folds the record from `Session.history.from` and hands the
+ *   engine the full transcript (`withTranscript`).
+ * - **Shadow mode** (on in the runtime's tests, `test/setup/transcript-shadow.ts`) keeps the
+ *   transcript on the row too and checks the fold against it at every segment start.
+ */
+import type { LiveEvent } from "@nylorun/core/contracts";
+/** The payload of one `transcript.updated` event. */
+export interface TranscriptUpdate {
+    keep: number;
+    entries: unknown[];
+    length: number;
+}
+/** Where a session's fold starts. */
+export interface SessionHistory {
+    /** The fold reads the record from this seq: a snapshot at or before the turn's start. */
+    from: number;
+    /** The latest snapshot (`keep: 0`), which `from` moves to when the next turn starts. */
+    snapshot?: number;
+}
+/** An edit's entries are split so each event stays well under S2's 1 MiB record limit. */
+export declare const CHUNK_BYTES: number;
+/** Shadow mode: keep the transcript on the session row and check the fold against it. */
+export declare function transcriptShadow(): boolean;
+/** Tests switch shadow mode off to exercise lean rows. Returns the previous setting. */
+export declare function setTranscriptShadow(on: boolean): boolean;
+export declare class TranscriptFoldError extends Error {
+    constructor(message: string);
+}
+/** The fold and the transcript on the row differ (shadow mode only). */
+export declare class TranscriptParityError extends Error {
+    constructor(sessionId: string, at: number, folded: number, stored: number);
+}
+/** The engine state's transcript, or none. */
+export declare function transcriptOf(state: unknown): unknown[];
+/**
+ * The edits from `before` to `after`, split into chunks of at most `CHUNK_BYTES` of entries.
+ * Empty when nothing changed.
+ */
+export declare function transcriptUpdates(before: readonly unknown[], after: readonly unknown[], chunkBytes?: number): TranscriptUpdate[];
+/** Applies one edit. Throws `TranscriptFoldError` when it does not fit the transcript. */
+export declare function applyUpdate(transcript: readonly unknown[], update: TranscriptUpdate): unknown[];
+/**
+ * Folds a session's events, from the start of its record or from a snapshot, into the
+ * transcript the engine resumes from.
+ */
+export declare function foldTranscript(events: Iterable<Pick<LiveEvent, "type" | "turnId" | "payload">>): unknown[];
+/** `state` with an empty transcript (what the session row stores outside shadow mode). */
+export declare function leanState<T>(state: T): T;
+/** `state` with `transcript` (what the engine runs on). */
+export declare function withTranscript<T>(state: T, transcript: readonly unknown[]): T;
+/** In shadow mode, checks the fold against the transcript the row kept. */
+export declare function checkParity(sessionId: string, folded: readonly unknown[], stored: readonly unknown[]): void;

package/dist/tenant/history.js

@@ -0,0 +1,120 @@
+/** An edit's entries are split so each event stays well under S2's 1 MiB record limit. */
+export const CHUNK_BYTES = 256 * 1024;
+let shadow = false;
+/** Shadow mode: keep the transcript on the session row and check the fold against it. */
+export function transcriptShadow() {
+    return shadow;
+}
+/** Tests switch shadow mode off to exercise lean rows. Returns the previous setting. */
+export function setTranscriptShadow(on) {
+    const previous = shadow;
+    shadow = on;
+    return previous;
+}
+export class TranscriptFoldError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TranscriptFoldError";
+    }
+}
+/** The fold and the transcript on the row differ (shadow mode only). */
+export class TranscriptParityError extends Error {
+    constructor(sessionId, at, folded, stored) {
+        super(`Session ${sessionId}: the folded transcript differs from the stored one at entry ${at}` +
+            ` (folded ${folded} entries, stored ${stored})`);
+        this.name = "TranscriptParityError";
+    }
+}
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/** The engine state's transcript, or none. */
+export function transcriptOf(state) {
+    const transcript = state?.transcript;
+    return Array.isArray(transcript) ? transcript : [];
+}
+/**
+ * The edits from `before` to `after`, split into chunks of at most `CHUNK_BYTES` of entries.
+ * Empty when nothing changed.
+ */
+export function transcriptUpdates(before, after, chunkBytes = CHUNK_BYTES) {
+    let keep = 0;
+    while (keep < before.length && keep < after.length && same(before[keep], after[keep]))
+        keep += 1;
+    if (keep === before.length && keep === after.length)
+        return [];
+    const added = after.slice(keep);
+    if (added.length === 0)
+        return [{ keep, entries: [], length: keep }];
+    const updates = [];
+    let chunk = [];
+    let bytes = 0;
+    let base = keep;
+    const flush = () => {
+        updates.push({ keep: base, entries: chunk, length: base + chunk.length });
+        base += chunk.length;
+        chunk = [];
+        bytes = 0;
+    };
+    for (const entry of added) {
+        const size = JSON.stringify(entry).length;
+        if (chunk.length > 0 && bytes + size > chunkBytes)
+            flush();
+        chunk.push(entry);
+        bytes += size;
+    }
+    flush();
+    return updates;
+}
+/** Applies one edit. Throws `TranscriptFoldError` when it does not fit the transcript. */
+export function applyUpdate(transcript, update) {
+    if (update.keep > transcript.length)
+        throw new TranscriptFoldError(`transcript.updated keeps ${update.keep} entries of ${transcript.length}`);
+    const next = [...transcript.slice(0, update.keep), ...update.entries];
+    if (next.length !== update.length)
+        throw new TranscriptFoldError(`transcript.updated should give ${update.length} entries, not ${next.length}`);
+    return next;
+}
+/**
+ * Folds a session's events, from the start of its record or from a snapshot, into the
+ * transcript the engine resumes from.
+ */
+export function foldTranscript(events) {
+    let transcript = [];
+    // The transcript before the current turn's first edit: what a cancel or failure restores.
+    let turn;
+    for (const event of events) {
+        if (event.type === "transcript.updated") {
+            if (!turn || turn.id !== event.turnId)
+                turn = { id: event.turnId, before: transcript };
+            transcript = applyUpdate(transcript, event.payload);
+        }
+        else if (event.type === "turn.cancelled" || event.type === "turn.failed") {
+            if (turn && turn.id === event.turnId)
+                transcript = turn.before;
+            turn = undefined;
+        }
+        else if (event.type === "turn.completed")
+            turn = undefined;
+    }
+    return transcript;
+}
+/** `state` with an empty transcript (what the session row stores outside shadow mode). */
+export function leanState(state) {
+    if (shadow || !state || transcriptOf(state).length === 0)
+        return state;
+    return { ...state, transcript: [] };
+}
+/** `state` with `transcript` (what the engine runs on). */
+export function withTranscript(state, transcript) {
+    if (!state)
+        return state;
+    return { ...state, transcript: [...transcript] };
+}
+/** In shadow mode, checks the fold against the transcript the row kept. */
+export function checkParity(sessionId, folded, stored) {
+    if (!shadow)
+        return;
+    const length = Math.max(folded.length, stored.length);
+    for (let i = 0; i < length; i += 1)
+        if (!same(folded[i], stored[i]))
+            throw new TranscriptParityError(sessionId, i, folded.length, stored.length);
+}

package/dist/tenant/http.d.ts

@@ -1,10 +1,9 @@
 /**
- * HTTP plumbing shared by the Tenant route modules: typed rejections, the opaque 404 for
- * unknown credentials (D5), request-body parsing and the client-abort signal.
+ * The Tenant's typed rejections: what a route or the code it calls throws for the client to
+ * see (`api/http/respond.ts` answers it), and the opaque 404 for unknown credentials (D5).
  *
  * Later waves: stable; the streams seam (Wave 2 / Y) keeps using these helpers.
  */
-import type { IncomingMessage } from "node:http";
 /** D5 opaque failure for unknown/rejected credentials on Tenant routes. */
 export declare const OPAQUE_NOT_FOUND: {
     status: "rejected";
@@ -19,9 +18,13 @@ export interface Rejection {
 export declare class HttpError extends Error {
     readonly status: number;
     readonly rejection: Rejection;
-    constructor(status: number, message: string, rejection?: Rejection);
+    /** Response headers the rejection carries, such as `retry-after` or `www-authenticate`. */
+    readonly headers: Readonly<Record<string, string>>;
+    constructor(status: number, message: string, rejection?: Rejection, 
+    /** Response headers the rejection carries, such as `retry-after` or `www-authenticate`. */
+    headers?: Readonly<Record<string, string>>);
 }
-export declare const fail: (status: number, message: string, rejection?: Rejection) => never;
+export declare const fail: (status: number, message: string, rejection?: Rejection, headers?: Readonly<Record<string, string>>) => never;
 export declare class OpaqueAuthError extends Error {
     readonly status = 404;
     readonly body: {
@@ -32,7 +35,3 @@ export declare class OpaqueAuthError extends Error {
     constructor();
 }
 export declare const failOpaque: () => never;
-/** AbortSignal tied to the HTTP request being closed by the client. */
-export declare function requestAborted(request: IncomingMessage): AbortSignal;
-/** Read a JSON request body, capped at 1 MiB. */
-export declare function readBody(request: IncomingMessage): Promise<unknown>;

package/dist/tenant/http.js

@@ -1,3 +1,9 @@
+/**
+ * The Tenant's typed rejections: what a route or the code it calls throws for the client to
+ * see (`api/http/respond.ts` answers it), and the opaque 404 for unknown credentials (D5).
+ *
+ * Later waves: stable; the streams seam (Wave 2 / Y) keeps using these helpers.
+ */
 /** D5 opaque failure for unknown/rejected credentials on Tenant routes. */
 export const OPAQUE_NOT_FOUND = {
     status: "rejected",
@@ -7,14 +13,18 @@ export const OPAQUE_NOT_FOUND = {
 export class HttpError extends Error {
     status;
     rejection;
-    constructor(status, message, rejection = {}) {
+    headers;
+    constructor(status, message, rejection = {}, 
+    /** Response headers the rejection carries, such as `retry-after` or `www-authenticate`. */
+    headers = {}) {
         super(message);
         this.status = status;
         this.rejection = rejection;
+        this.headers = headers;
     }
 }
-export const fail = (status, message, rejection) => {
-    throw new HttpError(status, message, rejection);
+export const fail = (status, message, rejection, headers) => {
+    throw new HttpError(status, message, rejection, headers);
 };
 export class OpaqueAuthError extends Error {
     status = 404;
@@ -27,27 +37,3 @@ export class OpaqueAuthError extends Error {
 export const failOpaque = () => {
     throw new OpaqueAuthError();
 };
-/** AbortSignal tied to the HTTP request being closed by the client. */
-export function requestAborted(request) {
-    const controller = new AbortController();
-    request.on("close", () => {
-        if (!request.complete)
-            controller.abort();
-    });
-    return controller.signal;
-}
-/** Read a JSON request body, capped at 1 MiB. */
-export async function readBody(request) {
-    let data = "";
-    for await (const chunk of request) {
-        data += chunk;
-        if (Buffer.byteLength(data) > 1024 * 1024)
-            fail(413, "Request too large");
-    }
-    try {
-        return JSON.parse(data);
-    }
-    catch {
-        return fail(400, "Invalid JSON");
-    }
-}

package/dist/tenant/jwt.d.ts

@@ -0,0 +1,16 @@
+export declare const MAX_TOKEN_BYTES = 4096;
+export declare const CLOCK_TOLERANCE_SECONDS = 30;
+/** True when `bearer` has the shape of a JWT; application keys never do. */
+export declare function looksLikeToken(bearer: string): boolean;
+/** The `typ` of a JWT-shaped bearer, or `undefined` when its header cannot be read. */
+export declare function tokenType(raw: string): string | undefined;
+/**
+ * Why the header of a token of type `typ` is refused before any key is read, or its key id
+ * when it is not: `malformed` (size, shape, undecodable) or `header` (algorithm, type, key id,
+ * or a header that could name another key).
+ */
+export declare function tokenKeyId(raw: string, typ: string): {
+    kid: string;
+} | {
+    refused: "malformed" | "header";
+};

package/dist/tenant/jwt.js

@@ -0,0 +1,50 @@
+/**
+ * What subject tokens and delivery tokens share: the Tenant's ES256 JWTs, recognised by shape,
+ * told apart by their `typ`, and refused before any key is read when the header is not one the
+ * Runtime issues.
+ */
+import { decodeProtectedHeader } from "jose";
+import { SIGNING_KEY_ID_PATTERN } from "@nylorun/core/compatibility";
+export const MAX_TOKEN_BYTES = 4096;
+export const CLOCK_TOLERANCE_SECONDS = 30;
+const JWT_SHAPE = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+const FORBIDDEN_HEADERS = ["jku", "jwk", "x5u", "x5c", "x5t", "crit"];
+/** True when `bearer` has the shape of a JWT; application keys never do. */
+export function looksLikeToken(bearer) {
+    return JWT_SHAPE.test(bearer);
+}
+/** The `typ` of a JWT-shaped bearer, or `undefined` when its header cannot be read. */
+export function tokenType(raw) {
+    if (Buffer.byteLength(raw) > MAX_TOKEN_BYTES || !JWT_SHAPE.test(raw))
+        return undefined;
+    try {
+        const typ = decodeProtectedHeader(raw).typ;
+        return typeof typ === "string" ? typ : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Why the header of a token of type `typ` is refused before any key is read, or its key id
+ * when it is not: `malformed` (size, shape, undecodable) or `header` (algorithm, type, key id,
+ * or a header that could name another key).
+ */
+export function tokenKeyId(raw, typ) {
+    if (Buffer.byteLength(raw) > MAX_TOKEN_BYTES || !JWT_SHAPE.test(raw))
+        return { refused: "malformed" };
+    let header;
+    try {
+        header = decodeProtectedHeader(raw);
+    }
+    catch {
+        return { refused: "malformed" };
+    }
+    if (header.alg !== "ES256" ||
+        header.typ !== typ ||
+        typeof header.kid !== "string" ||
+        !SIGNING_KEY_ID_PATTERN.test(header.kid) ||
+        FORBIDDEN_HEADERS.some((name) => name in header))
+        return { refused: "header" };
+    return { kid: header.kid };
+}

package/dist/tenant/model-setting.d.ts

@@ -2,8 +2,8 @@
  * The Tenant-level fixture model: Tenant setting `model.fixture`, seeded with
  * `fixtureModel: true` (`PUT /v1/tenant/config/seed`, Host feature `tenant-fixture-model`).
  * A Tenant with it answers every model call with the Runtime's deterministic fixture model
- * (`core/provider.ts` `toolFixtureModel`) instead of its configured model, whatever the Host
- * uses for other Tenants. Temporary test Tenants seed it (scripts/lib/temporary-tenant.mjs).
+ * (`core/provider.ts` `toolFixtureModel`) instead of its configured model. Smoke checks seed
+ * it (scripts/lib/stack-tenant.mjs).
  *
  * The setting is read once per advance, in a transaction the advance makes anyway, so a Tenant
  * seeded on another node takes it at its next advance.