stitchkit 0.80.0 → 0.81.0

package/dist/server/index.js

@@ -13,7 +13,8 @@ import {
   sseRoute,
   streamingRoute,
   webSocketLane
-} from "../index-k9ay6v6d.js";
+} from "../index-vchzar7e.js";
+import"../index-y91ry9h2.js";
 import {
   withDeadline
 } from "../index-b9aefrqd.js";
@@ -24,7 +25,7 @@ import {
   ShutdownStatusSchema,
   createServerLifecycle
 } from "../index-3z73fh2c.js";
-import"../index-t0z5p5w6.js";
+import"../index-apn8repm.js";
 import"../index-2qzskm8h.js";
 import {
   composeAuthHooks,
@@ -33,12 +34,13 @@ import {
   defineCookie,
   deriveCodeChallenge,
   extractToken,
+  parseCookieHeader,
   parseCookies,
   serializeCookie,
   signJwt,
   verifyJwt,
   verifyPkce
-} from "../index-xcetq6j3.js";
+} from "../index-90d7h2cr.js";
 import {
   DEFAULT_CORS_ALLOW_HEADERS,
   DEFAULT_CORS_EXPOSE_HEADERS,
@@ -52,20 +54,22 @@ import {
   defineMultipartStream,
   implement,
   implementRegistry
-} from "../index-m9kzax52.js";
+} from "../index-p18f59zy.js";
 import {
   isWithinDir,
   realPathWithinDir
 } from "../index-sbdmyz75.js";
+import {
+  getTraceId
+} from "../index-vsbzgd7b.js";
 import {
   extractIp,
   generateTraceId,
   getClientInfo,
-  getTraceId,
   isPublicIp,
   resolveSocketIp,
   resolveTraceId
-} from "../index-dwf1f2ap.js";
+} from "../index-f9mb610r.js";
 import {
   jsonSchemaFields,
   toJsonSchema
@@ -74,18 +78,18 @@ import {
   inputIsQuery,
   parseSSE,
   streamSSE
-} from "../index-hb5pf3s4.js";
+} from "../index-qmgs7y68.js";
 import {
   errorCode,
   formatZodError,
   normalizeError,
   zodIssues
-} from "../index-fxz0v7vg.js";
+} from "../index-7evdsyez.js";
 import {
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
   joinRoutePath,
   parseTrailingWildcard
-} from "../index-y01f4223.js";
+} from "../index-2bxcmqkb.js";
 import"../index-6k1937bx.js";
 import {
   AppError,
@@ -99,10 +103,223 @@ import {
   rateLimited,
   unauthorized
 } from "../index-0w9abg87.js";
+import"../index-zcgf3gqf.js";
 import"../index-kzfs85xp.js";
 import {
   isRecord
 } from "../index-77fekveh.js";
+// src/realtime/registry.ts
+var authorizedRoom = Symbol("stitchkit.authorized-room");
+function freezeRoom(name) {
+  return Object.freeze({ name, [authorizedRoom]: true });
+}
+function bindSocketRegistry(server, options) {
+  const members = new Map;
+  const minted = new WeakSet;
+  let revision = 0;
+  let closed = false;
+  const setups = new Set;
+  const maxBufferedFrames = Math.max(1, options.maxBufferedFrames ?? 1000);
+  const token = (name) => {
+    const created = freezeRoom(name);
+    minted.add(created);
+    return created;
+  };
+  const assertToken = (room) => {
+    if (!minted.has(room))
+      throw new Error("Room was not authorized by this registry");
+    return room.name;
+  };
+  const leaveQuietly = async (member, room) => {
+    try {
+      await member.connection.raw.leave(room);
+    } catch {}
+  };
+  const remove = async (member) => {
+    if (member.disconnected)
+      return;
+    member.disconnected = true;
+    member.connection.raw.off?.("disconnect", member.disconnect);
+    members.delete(member.connection.raw.id);
+    for (const room of member.joined)
+      await leaveQuietly(member, room);
+    member.joined.clear();
+    member.buffer = null;
+    revision += 1;
+  };
+  const replayMember = async (member) => {
+    if (!options.replay || member.disconnected || closed)
+      return !member.disconnected && !closed;
+    const attempts = Math.max(1, options.replayAttempts ?? 3);
+    for (let attempt = 0;attempt < attempts && !member.disconnected && !closed; attempt += 1) {
+      member.buffer = [];
+      member.overflow = false;
+      const before = await options.revision?.();
+      if (member.disconnected || closed)
+        break;
+      const frames = await options.replay({
+        identity: member.identity,
+        rooms: Object.freeze([...member.joined].map(token)),
+        revision: before
+      });
+      const after = await options.revision?.();
+      if (member.disconnected || closed)
+        break;
+      if (options.revision && !Object.is(before, after))
+        continue;
+      if (member.overflow)
+        continue;
+      for (const frame of frames)
+        member.connection.events.emit(frame.event, ...frame.args);
+      const buffered = member.buffer;
+      member.buffer = null;
+      for (const deferred of buffered ?? [])
+        deferred();
+      return !member.disconnected && !closed;
+    }
+    member.buffer = null;
+    member.overflow = false;
+    if (!member.disconnected)
+      await options.onResyncRequired?.(member.connection.raw.id, member.identity);
+    return false;
+  };
+  const resyncMember = (member) => {
+    if (member.replayPromise)
+      return member.replayPromise;
+    const active = replayMember(member).finally(() => {
+      if (member.replayPromise === active)
+        member.replayPromise = undefined;
+    });
+    member.replayPromise = active;
+    return active;
+  };
+  const setupConnection = async (connection) => {
+    if (closed)
+      return;
+    const member = {
+      connection,
+      identity: connection.raw.data,
+      authorized: new Set,
+      joined: new Set,
+      buffer: null,
+      overflow: false,
+      disconnected: false,
+      disconnect: () => {
+        return;
+      }
+    };
+    member.disconnect = () => void remove(member);
+    connection.raw.on("disconnect", member.disconnect);
+    members.set(connection.raw.id, member);
+    try {
+      const authorized = new Set(await options.rooms(connection.raw.data));
+      if (member.disconnected || closed) {
+        await remove(member);
+        return;
+      }
+      member.authorized = authorized;
+      for (const name of authorized) {
+        await connection.raw.join(name);
+        if (member.disconnected || closed) {
+          await leaveQuietly(member, name);
+          await remove(member);
+          return;
+        }
+        member.joined.add(name);
+      }
+      if (closed) {
+        await remove(member);
+        return;
+      }
+      revision += 1;
+      await resyncMember(member);
+    } catch {
+      await remove(member);
+    }
+  };
+  const stopListening = server.onConnection((connection) => {
+    let setup;
+    setup = setupConnection(connection).finally(() => setups.delete(setup));
+    setups.add(setup);
+    return setup;
+  });
+  return {
+    room: token,
+    async join(socketId, room) {
+      const name = assertToken(room);
+      const member = members.get(socketId);
+      if (!member)
+        throw new Error(`Unknown socket: ${socketId}`);
+      if (!member.authorized.has(name))
+        throw new Error(`Socket is not authorized for room: ${name}`);
+      if (member.joined.has(name))
+        return;
+      await member.connection.raw.join(name);
+      if (!member.disconnected)
+        member.joined.add(name);
+      revision += 1;
+    },
+    async leave(socketId, room) {
+      const name = assertToken(room);
+      const member = members.get(socketId);
+      if (!member?.joined.has(name))
+        return;
+      await member.connection.raw.leave(name);
+      member.joined.delete(name);
+      revision += 1;
+    },
+    emitTo(room, event, ...args) {
+      const name = assertToken(room);
+      let recipients = 0;
+      for (const member of members.values()) {
+        if (!member.joined.has(name) || member.disconnected)
+          continue;
+        recipients += 1;
+        if (!member.buffer) {
+          member.connection.events.emit(event, ...args);
+        } else if (member.buffer.length >= maxBufferedFrames) {
+          member.overflow = true;
+        } else {
+          member.buffer.push(() => member.connection.events.emit(event, ...args));
+        }
+      }
+      return recipients;
+    },
+    resync: async (socketId) => {
+      const member = members.get(socketId);
+      return member ? resyncMember(member) : false;
+    },
+    snapshot() {
+      const connections = [...members.values()].map((member) => Object.freeze({
+        socketId: member.connection.raw.id,
+        identity: member.identity,
+        rooms: Object.freeze([...member.joined].sort()),
+        replaying: member.buffer !== null
+      }));
+      const roomMap = {};
+      for (const entry of connections) {
+        for (const name of entry.rooms) {
+          roomMap[name] = Object.freeze([...roomMap[name] ?? [], entry.socketId]);
+        }
+      }
+      return Object.freeze({
+        revision,
+        connections: Object.freeze(connections),
+        rooms: Object.freeze(roomMap)
+      });
+    },
+    async unbind() {
+      if (closed)
+        return;
+      closed = true;
+      stopListening();
+      await Promise.allSettled([...setups]);
+      const active = [...members.values()];
+      for (const member of active)
+        await remove(member);
+    }
+  };
+}
 // src/server/bun.ts
 import { chmodSync, statSync, unlinkSync } from "node:fs";
 function reclaimStaleUnixSocket(path) {
@@ -389,10 +606,15 @@ function cacheHeaders(maxAge, scope = "public") {
 }
 // src/server/error-hook.ts
 function createErrorHook(config) {
+  if (config.vocabulary && (config.codeMap !== undefined || config.unmappedCode !== undefined)) {
+    throw new Error("[stitchkit] createErrorHook: `vocabulary` carries the wire map — it cannot be combined with `codeMap` or `unmappedCode`");
+  }
   return async (ctx, error, endpoint) => {
     const appErr = normalizeError(error);
     const stitchCode = isStitchErrorCode(appErr.code) ? appErr.code : undefined;
-    const mapped = stitchCode === undefined ? undefined : config.codeMap?.[stitchCode];
+    const vocabularyMap = config.vocabulary?.codeMap;
+    const configuredMap = vocabularyMap ?? config.codeMap;
+    const mapped = stitchCode === undefined ? undefined : configuredMap?.[stitchCode];
     const fallback = mapped === undefined && stitchCode !== undefined ? typeof config.unmappedCode === "function" ? config.unmappedCode(stitchCode) : config.unmappedCode : undefined;
     const code = mapped ?? fallback ?? appErr.code;
     const info = {
@@ -775,6 +997,221 @@ async function serveFile(req, opts) {
   base.set("Content-Length", String(size));
   return new Response(isHead ? null : file, { status: 200, headers: base });
 }
+// src/server/file-state-store.ts
+import { mkdir, open, readdir, readFile as readFile2, rename, stat as stat2, unlink } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+var ABANDONED_LOCK_MULTIPLIER = 10;
+var ABANDONED_HEARTBEATS = 30;
+var MIN_HEARTBEAT_MS = 10;
+var delay = (milliseconds) => new Promise((resolve2) => setTimeout(resolve2, milliseconds));
+async function missing(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function existing(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+async function ownerState(lockPath) {
+  let owner;
+  try {
+    owner = JSON.parse(await readFile2(lockPath, "utf8"));
+  } catch {
+    return "unknown";
+  }
+  if (typeof owner !== "object" || owner === null || !("pid" in owner) || typeof owner.pid !== "number" || !Number.isSafeInteger(owner.pid) || owner.pid <= 0) {
+    return "unknown";
+  }
+  try {
+    process.kill(owner.pid, 0);
+    return "alive";
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "ESRCH" ? "gone" : "unknown";
+  }
+}
+async function sweepTemporaries(path, staleLockMs) {
+  const prefix = `${basename(path)}.tmp.`;
+  const directory = dirname(path);
+  let entries;
+  try {
+    entries = await readdir(directory);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith(prefix))
+      continue;
+    const candidate = join(directory, entry);
+    const info = await stat2(candidate).catch(() => null);
+    if (info && Date.now() - info.mtimeMs > staleLockMs) {
+      await unlink(candidate).catch(() => {
+        return;
+      });
+    }
+  }
+}
+async function reclaim(lockPath, observed, staleLockMs, abandonedAfterMs) {
+  const guardPath = `${lockPath}.reclaim`;
+  let guard;
+  try {
+    guard = await open(guardPath, "wx");
+  } catch (error) {
+    if (!existing(error))
+      throw error;
+    const orphan = await stat2(guardPath).catch(() => null);
+    if (orphan && Date.now() - orphan.mtimeMs > staleLockMs) {
+      await unlink(guardPath).catch(() => {
+        return;
+      });
+    }
+    return false;
+  }
+  try {
+    const current = await stat2(lockPath).catch(() => null);
+    if (!current || current.dev !== observed.dev || current.ino !== observed.ino || current.mtimeMs !== observed.mtimeMs) {
+      return false;
+    }
+    const owner = await ownerState(lockPath);
+    const age = Date.now() - current.mtimeMs;
+    if (owner !== "gone" && age < abandonedAfterMs)
+      return false;
+    await unlink(lockPath);
+    return true;
+  } finally {
+    await guard.close().catch(() => {
+      return;
+    });
+    await unlink(guardPath).catch(() => {
+      return;
+    });
+  }
+}
+function createFileStateStore(path, options) {
+  const lockPath = `${path}.lock`;
+  const lockTimeoutMs = options.lockTimeoutMs ?? 1e4;
+  const staleLockMs = options.staleLockMs ?? 3000;
+  const retryMs = options.retryMs ?? 10;
+  const heartbeatMs = Math.max(MIN_HEARTBEAT_MS, Math.floor(staleLockMs / 3));
+  const abandonedAfterMs = Math.max(staleLockMs * ABANDONED_LOCK_MULTIPLIER, heartbeatMs * ABANDONED_HEARTBEATS);
+  if (staleLockMs >= lockTimeoutMs) {
+    throw new Error(`[stitchkit] createFileStateStore: staleLockMs (${staleLockMs}) must be below lockTimeoutMs (${lockTimeoutMs}), or a crashed holder blocks every update until the timeout`);
+  }
+  let sweptTemporaries = false;
+  const parseFile = async () => {
+    let source;
+    try {
+      source = await readFile2(path, "utf8");
+    } catch (error) {
+      if (await missing(error))
+        return null;
+      throw error;
+    }
+    try {
+      return options.schema.parse(JSON.parse(source));
+    } catch (error) {
+      await options.onCorrupt?.({ path, error });
+      if ((options.corrupt ?? "throw") === "empty")
+        return null;
+      throw error;
+    }
+  };
+  const acquire = async () => {
+    await mkdir(dirname(path), { recursive: true });
+    if (!sweptTemporaries) {
+      sweptTemporaries = true;
+      await sweepTemporaries(path, staleLockMs);
+    }
+    const deadline = Date.now() + lockTimeoutMs;
+    while (true) {
+      try {
+        const handle = await open(lockPath, "wx");
+        const token = crypto.randomUUID();
+        try {
+          await handle.writeFile(JSON.stringify({ token, pid: process.pid, acquiredAt: Date.now() }));
+          await handle.sync();
+        } catch (error) {
+          await handle.close().catch(() => {
+            return;
+          });
+          await unlink(lockPath).catch(() => {
+            return;
+          });
+          throw error;
+        }
+        return {
+          refresh: async () => {
+            const now = new Date;
+            await handle.utimes(now, now);
+          },
+          release: async () => {
+            await handle.close();
+            try {
+              const owner = JSON.parse(await readFile2(lockPath, "utf8"));
+              if (isRecord(owner) && owner.token === token)
+                await unlink(lockPath);
+            } catch (error) {
+              if (!await missing(error))
+                throw error;
+            }
+          }
+        };
+      } catch (error) {
+        if (!existing(error))
+          throw error;
+        try {
+          const lock = await stat2(lockPath);
+          if (Date.now() - lock.mtimeMs > staleLockMs) {
+            if (await reclaim(lockPath, lock, staleLockMs, abandonedAfterMs))
+              continue;
+          }
+        } catch (statError) {
+          if (await missing(statError))
+            continue;
+          throw statError;
+        }
+        if (Date.now() >= deadline) {
+          throw new Error(`[stitchkit] timed out acquiring state lock for ${path}`);
+        }
+        await delay(retryMs);
+      }
+    }
+  };
+  const write = async (state) => {
+    const validated = options.schema.parse(state);
+    const temporary = `${path}.tmp.${process.pid}.${crypto.randomUUID()}`;
+    const handle = await open(temporary, "wx");
+    try {
+      try {
+        await handle.writeFile(`${JSON.stringify(validated)}
+`);
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await rename(temporary, path);
+    } catch (error) {
+      await unlink(temporary).catch(() => {
+        return;
+      });
+      throw error;
+    }
+  };
+  return {
+    read: parseFile,
+    async update(transition) {
+      const lock = await acquire();
+      const heartbeat = setInterval(() => void lock.refresh().catch(() => {
+        return;
+      }), heartbeatMs);
+      try {
+        const next = await transition(await parseFile());
+        await write(next.state);
+        return next.result;
+      } finally {
+        clearInterval(heartbeat);
+        await lock.release();
+      }
+    }
+  };
+}
 // src/server/lifecycle.ts
 function composeLifecycleHooks(...hooks) {
   return {
@@ -1105,9 +1542,10 @@ function generateOpenApiDocument(config) {
           };
         } else if (method.inputSchema) {
           const required = jsonSchemaFields(safeJson(method.inputSchema, "input")).some((f) => f.required);
+          const schema = safeJson(method.inputSchema, "input");
           operation.requestBody = {
             required,
-            content: { "application/json": { schema: safeJson(method.inputSchema, "input") } }
+            content: method.safelistedBody ? { "application/json": { schema }, "text/plain": { schema } } : { "application/json": { schema } }
           };
         }
       }
@@ -1198,6 +1636,22 @@ async function parseBody(req, schema) {
   const parsed = schema.safeParse(raw);
   return parsed.success ? parsed.data : null;
 }
+// src/server/release-signal.ts
+function bindReleaseRefreshSignal(marker, options = {}) {
+  const signal = options.signal ?? "SIGUSR2";
+  const source = options.source ?? process;
+  const handler = () => {
+    try {
+      options.onRefresh?.(marker.refresh());
+    } catch (error) {
+      try {
+        options.onError?.(error);
+      } catch {}
+    }
+  };
+  source.on(signal, handler);
+  return () => source.off(signal, handler);
+}
 export {
   zodIssues,
   webSocketLane,
@@ -1220,6 +1674,7 @@ export {
   parseSSE,
   parseMultipart,
   parseCookies,
+  parseCookieHeader,
   parseByteRange,
   parseBody,
   openApiRoute,
@@ -1255,6 +1710,7 @@ export {
   createImplementRegistry,
   createImplement,
   createHandler,
+  createFileStateStore,
   createEventBus,
   createErrorHook,
   createCache,
@@ -1267,6 +1723,8 @@ export {
   composeLifecycleHooks,
   composeAuthHooks,
   cacheHeaders,
+  bindSocketRegistry,
+  bindReleaseRefreshSignal,
   bindRealtimeServer,
   bindProcessSignals,
   badRequest,

package/dist/server/middleware/cookies.d.ts

@@ -1,4 +1,29 @@
+/**
+ * Every `name=value` pair of a `Cookie` header, in header order, duplicates
+ * kept. The order is the browser's (RFC 6265 §5.4: longer path first, then
+ * earlier creation time) and a server "SHOULD NOT rely upon" it (§4.2.2) — so
+ * this list is what a reader consults when it needs to see *all* candidates
+ * rather than the one the order happened to put last.
+ */
+export declare function parseCookieHeader(header: string | null): Array<[string, string]>;
+/**
+ * The `Cookie` header as a record. Two cookies with one name collapse to the
+ * **last** occurrence — a fact of the record shape, not a rule about cookies;
+ * `parseCookieHeader` keeps both, and `defineCookie` lets a handle declare
+ * which it wants.
+ */
 export declare function parseCookies(header: string | null): Record<string, string>;
+/**
+ * What `get` answers when the request carries more than one cookie of this
+ * name. The browser decides their order, so `'last'` and `'first'` are each a
+ * coin the browser flips; they exist so an application can *name* the
+ * behaviour it relies on. `'reject'` refuses to flip it: two **different**
+ * values yield `undefined`, so a session reader sees "no session" instead of
+ * a session that works in one browser and not another. Two identical values
+ * are one value — a host cookie and a parent-domain cookie set by the same
+ * application — and are returned.
+ */
+export type CookieDuplicatesPolicy = 'last' | 'first' | 'reject';
 export interface CookieOptions {
     maxAge?: number;
     path?: string;
@@ -6,12 +31,19 @@ export interface CookieOptions {
     secure?: boolean;
     httpOnly?: boolean;
     sameSite?: 'Strict' | 'Lax' | 'None';
+    /** How `get` resolves two cookies of this name; default `'last'`. */
+    duplicates?: CookieDuplicatesPolicy;
 }
 export declare function serializeCookie(name: string, value: string, opts?: CookieOptions): string;
 /** A cookie's name + options bundled into a typed read/set/clear handle. */
 export interface CookieDef {
-    /** Read this cookie's value from a request (`undefined` if absent). */
+    /**
+     * Read this cookie's value from a request (`undefined` if absent). With two
+     * cookies of this name the answer follows the handle's `duplicates` policy.
+     */
     get(req: Request): string | undefined;
+    /** Every value of this name the request carries, in header order. */
+    getAll(req: Request): string[];
     /** Build a `Set-Cookie` header value for `value` with the baked-in options. */
     set(value: string): string;
     /** Build a `Set-Cookie` header value that clears the cookie. */

package/dist/server/middleware/cookies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cookies.d.ts","sourceRoot":"","sources":["../../../src/server/middleware/cookies.ts"],"names":[],"mappings":"AAEA,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkB1E;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;CACtC;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,aAAkB,GACvB,MAAM,CASR;AAED,4EAA4E;AAC5E,MAAM,WAAW,SAAS;IACxB,uEAAuE;IACvE,GAAG,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IACtC,+EAA+E;IAC/E,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,gEAAgE;IAChE,KAAK,IAAI,MAAM,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAahF"}
+{"version":3,"file":"cookies.d.ts","sourceRoot":"","sources":["../../../src/server/middleware/cookies.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAmBhF;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQ1E;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEjE,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;IACrC,qEAAqE;IACrE,UAAU,CAAC,EAAE,sBAAsB,CAAC;CACrC;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,aAAkB,GACvB,MAAM,CASR;AAED,4EAA4E;AAC5E,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,GAAG,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IACtC,qEAAqE;IACrE,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;IAC/B,+EAA+E;IAC/E,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,gEAAgE;IAChE,KAAK,IAAI,MAAM,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAwBhF"}

package/dist/server/middleware/cors.d.ts

@@ -43,8 +43,12 @@ export declare const DEFAULT_CORS_ALLOW_HEADERS = "Content-Type, Authorization,
  * Note the deliberate asymmetry with {@link DEFAULT_CORS_ALLOW_HEADERS}:
  * inbound the id may arrive as `X-Trace-Id`, outbound it is always
  * `X-Request-Id` — one name on the wire out, no alias.
+ *
+ * `X-Build-Id` is the release a handler configured with a release marker
+ * names on every response; a cross-origin page reads it to learn it is stale
+ * (`stitchkit/release`).
  */
-export declare const DEFAULT_CORS_EXPOSE_HEADERS = "Content-Disposition, Content-Length, Content-Range, Accept-Ranges, ETag, Last-Modified, X-Request-Id";
+export declare const DEFAULT_CORS_EXPOSE_HEADERS = "Content-Disposition, Content-Length, Content-Range, Accept-Ranges, ETag, Last-Modified, X-Request-Id, X-Build-Id";
 /**
  * Reject an unsafe CORS config at construction. `credentials: true` with a
  * wildcard origin would reflect *any* caller's `Origin` with
@@ -52,6 +56,17 @@ export declare const DEFAULT_CORS_EXPOSE_HEADERS = "Content-Disposition, Content
  * requests. Credentials require an explicit origin allow-list.
  */
 export declare function assertCorsConfig(config: CorsConfig): void;
+/**
+ * Is `requestOrigin` on the server's **explicit** allow-list? The question a
+ * safelisted request body asks before it is read (→ ADR 0165), and it is
+ * deliberately stricter than `resolveOrigin`: a wildcard is not an allow-list
+ * (a simple request is sent with cookies from any site, so `'*'` would admit
+ * every site), `null` is what a sandboxed iframe, a cross-origin redirect and
+ * `file://` send and names no site, and an absent header is no answer at all.
+ * A string origin is compared, not echoed. Case-insensitive, like
+ * `resolveOrigin`'s list branch.
+ */
+export declare function isOriginAllowed(config: CorsConfig | undefined, requestOrigin: string | null | undefined): boolean;
 export declare function corsHeaders(config: CorsConfig, requestOrigin?: string | null): Record<string, string>;
 export declare function corsPreflightResponse(config: CorsConfig, req: Request): Response;
 //# sourceMappingURL=cors.d.ts.map

package/dist/server/middleware/cors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cors.d.ts","sourceRoot":"","sources":["../../../src/server/middleware/cors.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACnC;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B,qEAC6B,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,2BAA2B,yGACgE,CAAC;AAEzG;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAoBzD;AAwBD,wBAAgB,WAAW,CACzB,MAAM,EAAE,UAAU,EAClB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA4BxB;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,OAAO,GAAG,QAAQ,CAKhF"}
+{"version":3,"file":"cors.d.ts","sourceRoot":"","sources":["../../../src/server/middleware/cors.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACnC;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B,qEAC6B,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,2BAA2B,qHAC4E,CAAC;AAErH;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAoBzD;AAwBD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACvC,OAAO,CAMT;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,UAAU,EAClB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA4BxB;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,OAAO,GAAG,QAAQ,CAKhF"}