@theoremjs/web 0.3.4-next.602.gb5a7fab → 0.3.4-next.604.ge4d5866

package/README.md

@@ -379,23 +379,23 @@ Each saved outcome records its absolute retention deadline. Changing a handler's
 Each issued gate records its absolute expiry. Changing `gateTtlMs` does not extend an issued gate.
 Ready, running, and uncertain operations do not expire.
 
-A session store declares its `capacity`: what it holds for one session, in bytes of UTF-8 JSON.
+A session store with a real limit declares its `capacity`: what it holds for one session, in bytes of UTF-8 JSON.
 
-| Field | What it bounds | Memory store default |
-| --- | --- | --- |
-| `maxStateBytes` | One session's saved state | 16 MiB |
-| `maxOutcomeBytes` | One tool result | 1 MiB (`DEFAULT_MAX_OUTCOME_BYTES`) |
+| Field | What it bounds |
+| --- | --- |
+| `maxStateBytes` | One session's saved state |
+| `maxOutcomeBytes` | One tool result |
 
-Pass `capacity` to `createMemorySessionStore` to change them. A store you write declares the capacity of its own storage.
+A store that declares no `capacity` holds any size. `createMemorySessionStore` declares none unless you pass `capacity`, with both fields. A store you write declares the capacity of its own storage, if it has one.
 
 Set `maxRequestBytes` to bound browser JSON before parsing. Its default is 16 MiB.
 The handler rejects oversized requests before provider access or tool preparation.
 Provider host options also accept `limits` for deadlines and upstream output.
-The handler keeps room for one `maxOutcomeBytes` result for each gate and each call that has not settled.
+When the store declares a capacity, the handler keeps room for one `maxOutcomeBytes` result for each gate and each call that has not settled.
 When a session is full, the handler drops its oldest settled results, then its oldest provider checkpoints.
 It never drops gates, permissions, or calls that have not settled. When those alone do not fit, the new call is refused before it runs, and the user reads `session.full`.
 A result larger than `maxOutcomeBytes` settles as the call's `result_too_large` failure. The call is never left unresolved because of its size.
-The handler fits each state to the store's capacity before `compareAndSwap`.
+The handler fits each state to the store's capacity, when it has one, before `compareAndSwap`.
 
 The default memory store coordinates handlers that share the same store object.
 It retains unexpired gates, unresolved operations, and unexpired outcomes during idle and capacity eviction.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theoremjs/web",
-  "version": "0.3.4-next.602.gb5a7fab",
+  "version": "0.3.4-next.604.ge4d5866",
   "description": "Theorem on the web platform, with no UI framework: Web-standard server handlers that serve a profile, and the browser client that talks to them.",
   "license": "MIT",
   "type": "module",
@@ -25,6 +25,6 @@
   },
   "peerDependencies": {
     "zod": "^4.6.5",
-    "@theoremjs/agents": "^0.3.4-next.602.gb5a7fab"
+    "@theoremjs/agents": "^0.3.4-next.604.ge4d5866"
   }
 }

package/server/mod.d.ts

@@ -20,7 +20,6 @@ export { checkRequest, parseLiveClientMessage, parseLiveOpenMessage } from './re
 export { sessionStateStore } from './session-authority.ts';
 export { createTheoremSessionBoundary, type PreparedLiveOpen, type SessionBoundaryOptions, type TheoremSessionBoundary, } from './session-boundary.ts';
 export type { TheoremSessionCapacity } from './session-limits.ts';
-export { DEFAULT_SESSION_CAPACITY } from './session-limits.ts';
 export { createMemorySessionStore, DEFAULT_OPERATION_RETENTION_MS, type MemorySessionStoreOptions, type PendingToolGate, type SessionSnapshot, type SessionToolOperation, type SessionWriteResult, type TheoremSessionState, type TheoremSessionStore, theoremSessionStateSchema, } from './session-store.ts';
 export { createMemorySteerInbox, type SteerInbox, type SteerUnit, steerStage, steerUnitOf, stopOnRequest, } from './steer-inbox.ts';
 export { sessionToolCoordinator } from './tool-operations.ts';

package/server/mod.js

@@ -18,7 +18,6 @@ export { createMemoryPageToolBroker, pageToolResultSchema, sessionPageDispatch,
 export { checkRequest, parseLiveClientMessage, parseLiveOpenMessage } from "./request-check.js";
 export { sessionStateStore } from "./session-authority.js";
 export { createTheoremSessionBoundary, } from "./session-boundary.js";
-export { DEFAULT_SESSION_CAPACITY } from "./session-limits.js";
 export { createMemorySessionStore, DEFAULT_OPERATION_RETENTION_MS, theoremSessionStateSchema, } from "./session-store.js";
 export { createMemorySteerInbox, steerStage, steerUnitOf, stopOnRequest, } from "./steer-inbox.js";
 export { sessionToolCoordinator } from "./tool-operations.js";

package/server/session-authority.d.ts

@@ -6,7 +6,7 @@ export type MutableStore<T> = {
 };
 /** Session state with the capacity its store declared. */
 export type SessionStateStore = MutableStore<TheoremSessionState> & {
-    readonly capacity: TheoremSessionCapacity;
+    readonly capacity?: TheoremSessionCapacity;
 };
 /** Session state, with expired gates dropped as it loads so they can't be answered. */
 export declare function sessionStateStore(store: TheoremSessionStore, gateTtlMs: number, operationRetentionMs: number): SessionStateStore;

package/server/session-authority.js

@@ -35,7 +35,7 @@ export function sessionStateStore(store, gateTtlMs, operationRetentionMs) {
         return { revision: snapshot?.revision ?? null, state };
     };
     return {
-        capacity,
+        ...(capacity ? { capacity } : {}),
         async read(sessionId) {
             return (await load(sessionId, Date.now())).state;
         },
@@ -50,7 +50,8 @@ export function sessionStateStore(store, gateTtlMs, operationRetentionMs) {
                     if (operation.status === 'settled')
                         operation.retainUntil ??= operation.settledAt + operationRetentionMs;
                 }
-                fitSession(state, capacity);
+                if (capacity)
+                    fitSession(state, capacity);
                 const next = theoremSessionStateSchema.safeParse(state);
                 if (!next.success) {
                     throw new TheoremError('config', labelText('error.config'), {

package/server/session-limits.d.ts

@@ -1,15 +1,16 @@
 import type { TheoremSessionState } from './session-store.ts';
-/** What a session store holds for one session, in bytes of UTF-8 JSON. The store declares it. */
+/** What a session store holds for one session, in bytes of UTF-8 JSON. A store with a real limit declares it. */
 export interface TheoremSessionCapacity {
     /** The most one session's saved state may take. */
     maxStateBytes: number;
     /** The most one tool result may take. Room for one is kept for each call that has not settled. */
     maxOutcomeBytes: number;
 }
-/** The memory store's default: room for sixteen full-size tool results in each session. */
-export declare const DEFAULT_SESSION_CAPACITY: TheoremSessionCapacity;
-/** The store's declared capacity, refused as `config` unless both are positive and one result fits. */
-export declare function checkedCapacity(capacity: unknown): TheoremSessionCapacity;
+/**
+ * The store's declared capacity, refused as `config` unless both are positive and one result fits.
+ * Undefined when the store declares none: then it holds any size.
+ */
+export declare function checkedCapacity(capacity: unknown): TheoremSessionCapacity | undefined;
 /**
  * Fits the state in the store's capacity: drops the oldest settled results, then the oldest
  * provider checkpoints, and refuses with `session.full` when open work alone does not fit.

package/server/session-limits.js

@@ -1,11 +1,11 @@
-import { DEFAULT_MAX_OUTCOME_BYTES, labelText, TheoremError } from '@theoremjs/agents';
-/** The memory store's default: room for sixteen full-size tool results in each session. */
-export const DEFAULT_SESSION_CAPACITY = {
-    maxStateBytes: 16 * DEFAULT_MAX_OUTCOME_BYTES,
-    maxOutcomeBytes: DEFAULT_MAX_OUTCOME_BYTES,
-};
-/** The store's declared capacity, refused as `config` unless both are positive and one result fits. */
+import { labelText, TheoremError } from '@theoremjs/agents';
+/**
+ * The store's declared capacity, refused as `config` unless both are positive and one result fits.
+ * Undefined when the store declares none: then it holds any size.
+ */
 export function checkedCapacity(capacity) {
+    if (capacity === undefined)
+        return undefined;
     const { maxStateBytes, maxOutcomeBytes } = (capacity ?? {});
     if (!Number.isSafeInteger(maxStateBytes) ||
         !Number.isSafeInteger(maxOutcomeBytes) ||

package/server/session-store.d.ts

@@ -88,8 +88,11 @@ export type SessionWriteResult = {
  * store (KV, Redis, a database row) when requests can reach different instances.
  */
 export interface TheoremSessionStore {
-    /** What it holds for one session. The handler fits each write to it before `compareAndSwap`. */
-    readonly capacity: TheoremSessionCapacity;
+    /**
+     * What it holds for one session, when it has a limit. The handler fits each write to it before
+     * `compareAndSwap`. Unset, the handler writes the state whole.
+     */
+    readonly capacity?: TheoremSessionCapacity;
     load(sessionId: string): Promise<SessionSnapshot | undefined>;
     /** Compare and replace atomically; null creates only an absent session. */
     compareAndSwap(sessionId: string, expectedRevision: string | null, next: TheoremSessionState): Promise<SessionWriteResult>;
@@ -101,8 +104,8 @@ export declare function pruneGates<Gate extends {
     expiresAt?: number;
 }>(gates: Record<string, Gate>, now: number, ttlMs: number): Record<string, Gate>;
 export type MemorySessionStoreOptions = {
-    /** What it holds for one session. Default {@linkcode DEFAULT_SESSION_CAPACITY}. */
-    capacity?: Partial<TheoremSessionCapacity>;
+    /** What it holds for one session. Unset, it holds any size. */
+    capacity?: TheoremSessionCapacity;
     /** invariant: Idle retention is in milliseconds. Protected authority remains. Default 24h. */
     ttlMs?: number;
     /** Oldest sessions are evicted past this count. Default 10 000. */

package/server/session-store.js

@@ -10,7 +10,7 @@
  */
 import { jsonObjectSchema, jsonValueSchema, labelText, savedToolInvocationSchema, TheoremError, TOOL_AUTH_TYPES, TOOL_GATE_KINDS, TOOL_PERMISSION, toolOperationOutcomeSchema, turnHistoryMessageSchema, turnToolSnapshotSchema, z, } from '@theoremjs/agents';
 import { gateExpired } from '@theoremjs/agents/kernel';
-import { checkedCapacity, DEFAULT_SESSION_CAPACITY, } from "./session-limits.js";
+import { checkedCapacity } from "./session-limits.js";
 export const DEFAULT_OPERATION_RETENTION_MS = 24 * 60 * 60 * 1000;
 const blobSchema = z.strictObject({
     data: z.string(),
@@ -219,7 +219,7 @@ export function createMemorySessionMap(options = {}) {
 }
 export function createMemorySessionStore(options = {}) {
     const { ttlMs, maxSessions } = memoryStoreLimits(options);
-    const capacity = checkedCapacity({ ...DEFAULT_SESSION_CAPACITY, ...options.capacity });
+    const capacity = checkedCapacity(options.capacity);
     const sessions = new Map();
     const held = (entry) => Object.values(entry.snapshot.state.gates).some((gate) => gate.expiresAt === undefined || Date.now() < gate.expiresAt) ||
         Object.values(entry.snapshot.state.operations).some((operation) => operation.status !== 'settled' ||
@@ -234,7 +234,7 @@ export function createMemorySessionStore(options = {}) {
         return entry?.snapshot;
     };
     return {
-        capacity,
+        ...(capacity ? { capacity } : {}),
         load(sessionId) {
             return Promise.resolve(structuredClone(current(sessionId)));
         },

package/server/tool-operations.d.ts

@@ -1,7 +1,7 @@
 import { type ToolExecutionCoordinator } from '@theoremjs/agents';
 import type { TheoremSessionState } from './session-store.ts';
 export declare function sessionToolCoordinator(store: {
-    readonly capacity: {
+    readonly capacity?: {
         maxOutcomeBytes: number;
     };
     mutate<T>(id: string, change: (state: TheoremSessionState) => T): Promise<T>;

package/server/tool-operations.js

@@ -69,7 +69,7 @@ function saveOutcome(state, identity, outcome) {
 }
 export function sessionToolCoordinator(store, sessionId) {
     return {
-        maxOutcomeBytes: store.capacity.maxOutcomeBytes,
+        ...(store.capacity ? { maxOutcomeBytes: store.capacity.maxOutcomeBytes } : {}),
         lookup(identity) {
             return store.mutate(sessionId, (state) => {
                 const record = checkedRecord(state, identity);