@nomix-ai/nomix-harness 0.2.4 → 0.2.6

package/dist/kernel/session-projection/lib/index.js

@@ -1,11 +1,11 @@
-import { Service } from "@nomix-ai/cordis";
+import { Service } from "../../cordis/lib/index.js";
 //#region lib/types/index.js
 /**
-* Service Definition and drive registry for the session-projection capability seam: the merge-extensible `SessionProjectionMap` type
-* table, the `ProjectionDefinition` state-driven computation unit contract,
+* Service Definition and drive registry for the session-projection capability seam: the merge-extensible state and client-view type
+* tables, the `ProjectionDefinition` state-driven computation unit contract,
 * and the `ctx.sessionProjections` registry that DRIVES every registered unit
 * forward eagerly over committed session events. Domain host plugins
-* contribute pure mathematics (init/apply/view); the framework owns the
+* contribute pure folds and optional client views; the framework owns the
 * subscription, the per-session watermark cache, and change notification;
 * carriers consume the snapshot read face and the change feed. Neither side
 * knows the other
@@ -22,7 +22,8 @@ import { Service } from "@nomix-ai/cordis";
 * `ctx.sessionProjections`: the projection unit table and its drive. The
 * service subscribes to `session/event` once; every committed event passes
 * every registered unit's `apply` (eager drive), and a changed state
-* reference notifies the change feed with the schema-validated view.
+* reference in a client-visible unit notifies the change feed with the
+* schema-validated view.
 * Cells build lazily — a unit registered after events flowed, or a session
 * older than the registry, folds `init` over the in-memory log on first
 * touch (event or read). Registration is an effect (disposer rides the
@@ -47,26 +48,30 @@ var SessionProjectionRegistry = class extends Service {
 			this.drive(session, event);
 		});
 	}
-	/**
-	* Register one domain's unit. The registration is an effect on the calling
-	* context's fiber: disposing the fiber (or calling the returned disposer)
-	* removes the key — and the unit's cached cells — from subsequent drives
-	* and snapshots.
-	* @param definition - key, state schema, pure unit functions, and stateVersion.
-	* @returns the exact disposer that unregisters this unit.
-	*/
 	register(definition) {
+		const wire = definition.wire;
+		const erased = {
+			key: definition.key,
+			stateSchema: definition.stateSchema,
+			init: () => definition.init(),
+			apply: (state, event) => definition.apply(state, event),
+			wire: wire === void 0 ? void 0 : {
+				viewSchema: wire.viewSchema,
+				view: (state) => wire.view(state)
+			},
+			stateVersion: definition.stateVersion
+		};
 		if (!Number.isSafeInteger(definition.stateVersion) || definition.stateVersion < 0) throw new Error(`session projection ${JSON.stringify(definition.key)} stateVersion must be a non-negative integer, got ${String(definition.stateVersion)}`);
 		const dispose = this.ctx.effect(function* () {
-			const key = definition.key;
+			const key = erased.key;
 			const existing = this.registrations.get(key);
 			if (existing === void 0) this.registrations.set(key, {
-				def: definition,
+				def: erased,
 				cells: /* @__PURE__ */ new WeakMap(),
 				refs: 1
 			});
 			else {
-				if (existing.def.stateVersion !== definition.stateVersion) throw new Error(`session projection key ${JSON.stringify(key)} is already registered at stateVersion ${String(existing.def.stateVersion)}; refusing to share it with stateVersion ${String(definition.stateVersion)}`);
+				if (existing.def.stateVersion !== erased.stateVersion) throw new Error(`session projection key ${JSON.stringify(key)} is already registered at stateVersion ${String(existing.def.stateVersion)}; refusing to share it with stateVersion ${String(erased.stateVersion)}`);
 				existing.refs += 1;
 			}
 			yield () => {
@@ -82,7 +87,7 @@ var SessionProjectionRegistry = class extends Service {
 	/**
 	* Subscribe to the change feed. The registration is an effect on the
 	* calling context's fiber.
-	* @param listener - called once per unit whose state reference changed, per committed event.
+	* @param listener - called once per client-visible unit whose state reference changed, per committed event.
 	* @returns the exact disposer that unsubscribes.
 	*/
 	onChanged(listener) {
@@ -95,18 +100,31 @@ var SessionProjectionRegistry = class extends Service {
 		return () => void dispose();
 	}
 	/**
-	* One consistent cut over every registered unit for one session, read from
+	* Read one unit's current host state without computing unrelated views.
+	* The returned value is live; callers must not mutate it.
+	* @param session - the session whose state is read.
+	* @param key - the registered unit key.
+	* @returns current state, or `undefined` when the key is not registered.
+	*/
+	stateOf(session, key) {
+		const registration = this.registrations.get(key);
+		if (registration === void 0) return void 0;
+		return this.cellFor(registration, session).state;
+	}
+	/**
+	* One consistent cut over every registered client-visible unit for one session, read from
 	* the watermark cache (missing cells fold lazily over the in-memory log).
 	* Fully synchronous — every value and `asOfSeq` reflect the same log
-	* position. Each value passes its unit's schema before leaving.
+	* position. Each value passes its unit's `viewSchema` before leaving.
 	* @param session - the session whose projection values are read.
-	* @returns the snapshot; `values` is empty when no unit is registered.
+	* @returns the snapshot; `values` is empty when no client-visible unit is registered.
 	*/
 	snapshot(session) {
 		const values = {};
 		for (const registration of this.registrations.values()) {
+			if (registration.def.wire === void 0) continue;
 			const cell = this.cellFor(registration, session);
-			values[registration.def.key] = registration.def.schema.parse(registration.def.view(cell.state));
+			values[registration.def.key] = registration.def.wire.viewSchema.parse(registration.def.wire.view(cell.state));
 		}
 		return {
 			asOfSeq: session.seq - 1,
@@ -114,7 +132,7 @@ var SessionProjectionRegistry = class extends Service {
 		};
 	}
 	/**
-	* State-level checkpoint of every registered unit for one session, read
+	* State-level checkpoint of every persisted unit for one session, read
 	* from the watermark cache (missing cells fold lazily over the in-memory
 	* log). This is the write side of the persisted projection cache: the
 	* returned rows are the `(key → {ver, seq, val})` part of the durable
@@ -125,7 +143,7 @@ var SessionProjectionRegistry = class extends Service {
 	* every subsequent snapshot and frame through it (plain JSON by the unit
 	* contract, so the clone is total).
 	* @param session - the session whose unit states are checkpointed.
-	* @returns one row per registered key; empty when no unit is registered.
+	* @returns one row per registered key.
 	*/
 	checkpoint(session) {
 		const rows = {};
@@ -166,8 +184,8 @@ var SessionProjectionRegistry = class extends Service {
 	}
 	/**
 	* View a checkpoint's rows without any log read: for every registered
-	* unit whose row's `ver` matches, serve the schema-validated
-	* `view` of the stored state; mismatched or absent rows leave their key
+	* client-visible unit whose row's `ver` matches, serve the schema-validated
+	* `view` of the schema-validated stored state; mismatched, malformed, or absent rows leave their key
 	* absent (a cold or listing consumer treats it as not-yet-available and a
 	* fuller read path refolds it). The zero-I/O rung of the read ladder —
 	* values are as stale as their rows, never wrong.
@@ -178,14 +196,21 @@ var SessionProjectionRegistry = class extends Service {
 		const values = {};
 		for (const registration of this.registrations.values()) {
 			const def = registration.def;
+			if (def.wire === void 0) continue;
 			const row = checkpoint[def.key];
 			if (row === void 0 || row.ver !== def.stateVersion) continue;
-			values[def.key] = def.schema.parse(def.view(row.val));
+			let state;
+			try {
+				state = def.stateSchema.parse(row.val);
+			} catch {
+				continue;
+			}
+			values[def.key] = def.wire.viewSchema.parse(def.wire.view(state));
 		}
 		return values;
 	}
 	/**
-	* Cold read: fold every registered unit over a stored log suffix, seeding
+	* Cold read: fold every persisted unit over a stored log suffix, seeding
 	* each from its checkpoint row when usable — the one read recipe (cached
 	* state + forward tail replay + `view`) applied without a live `Session`.
 	* Call with the events returned by a persistence
@@ -215,10 +240,10 @@ var SessionProjectionRegistry = class extends Service {
 			const row = checkpoint[def.key];
 			const usable = row !== void 0 && row.ver === def.stateVersion && row.seq >= baseSeq - 1 && row.seq <= endSeq;
 			if (!usable && baseSeq > 0) throw new Error(`session projection ${JSON.stringify(def.key)} cannot restore from seq ${baseSeq}: its checkpoint row is missing, version-mismatched, or beyond the supplied log end; re-read from seq 0`);
-			let state = usable ? row.val : def.init();
+			let state = usable ? def.stateSchema.parse(row.val) : def.init();
 			const from = usable ? row.seq : baseSeq - 1;
 			for (const event of events) if (event.seq > from) state = def.apply(state, event);
-			values[def.key] = def.schema.parse(def.view(state));
+			if (def.wire !== void 0) values[def.key] = def.wire.viewSchema.parse(def.wire.view(state));
 			refreshed[def.key] = {
 				ver: def.stateVersion,
 				seq: endSeq,
@@ -263,8 +288,8 @@ var SessionProjectionRegistry = class extends Service {
 			const changed = !Object.is(next, cell.state);
 			cell.state = next;
 			cell.observedSeq = event.seq;
-			if (changed && this.listeners.size > 0) {
-				const value = registration.def.schema.parse(registration.def.view(next));
+			if (changed && registration.def.wire !== void 0 && this.listeners.size > 0) {
+				const value = registration.def.wire.viewSchema.parse(registration.def.wire.view(next));
 				for (const listener of this.listeners) listener(session, registration.def.key, value, event.seq);
 			}
 		}

package/dist/kernel/session-projection/lib/types/index.d.ts

@@ -1,9 +1,9 @@
 /**
- * Service Definition and drive registry for the session-projection capability seam: the merge-extensible `SessionProjectionMap` type
- * table, the `ProjectionDefinition` state-driven computation unit contract,
+ * Service Definition and drive registry for the session-projection capability seam: the merge-extensible state and client-view type
+ * tables, the `ProjectionDefinition` state-driven computation unit contract,
  * and the `ctx.sessionProjections` registry that DRIVES every registered unit
  * forward eagerly over committed session events. Domain host plugins
- * contribute pure mathematics (init/apply/view); the framework owns the
+ * contribute pure folds and optional client views; the framework owns the
  * subscription, the per-session watermark cache, and change notification;
  * carriers consume the snapshot read face and the change feed. Neither side
  * knows the other
@@ -16,7 +16,7 @@
  *
  * @module @nomix-ai/nomix-session-projection
  */
-import { Context, Service } from '@nomix-ai/cordis';
+import { Context, Service } from '../../../cordis/lib/index.js';
 import type { ZodType } from 'zod';
 import type { Session, SessionEvent } from '../../../session/lib/index.js';
 declare module '@nomix-ai/cordis' {
@@ -24,26 +24,26 @@ declare module '@nomix-ai/cordis' {
         sessionProjections: SessionProjectionRegistry;
     }
 }
-import type { SessionProjectionMap } from './types.ts';
-export type { SessionProjectionMap } from './types.ts';
+import type { SessionProjectionMap, SessionProjectionStateMap } from './types.ts';
+export type { SessionProjectionMap, SessionProjectionStateMap } from './types.ts';
 /**
- * One domain's state-driven computation unit: three pure synchronous
- * functions plus declarations — never an opaque getter. The framework drives
+ * One domain's state-driven computation unit: a pure synchronous fold plus
+ * declarations and an optional client view — never an opaque getter. The framework drives
  * `apply` on every committed session event; the domain holds no
- * subscriptions and owns only the mathematics. All three functions MUST be
- * synchronous (an async unit would tear the carriers' consistency cut) and
+ * subscriptions and owns only the computation. All functions MUST be
+ * synchronous (an async unit would tear the carriers' consistency cut), and
  * `state` MUST be plain JSON (the persisted-cache precondition).
  */
-export interface ProjectionDefinition<K extends keyof SessionProjectionMap, S> {
-    /** The projection key this unit owns (its `SessionProjectionMap` entry). */
+export interface ProjectionDefinition<K extends keyof SessionProjectionStateMap, S extends SessionProjectionStateMap[K] = SessionProjectionStateMap[K]> {
+    /** The projection key this unit owns (its `SessionProjectionStateMap` entry). */
     key: K;
-    /** Validates the wire payload (`view` output) before it leaves the host. */
-    schema: ZodType<SessionProjectionMap[K]>;
+    /** Validates persisted state before it seeds a fold. */
+    stateSchema: ZodType<S>;
     /**
      * State for the empty log.
      * @returns the initial state.
      */
-    init(): S;
+    init(): NoInfer<S>;
     /**
      * Pure transition: previous state + one committed event → next state. A
      * unit uninterested in an event MUST return the same state reference — an
@@ -52,13 +52,18 @@ export interface ProjectionDefinition<K extends keyof SessionProjectionMap, S> {
      * @param event - the next committed session event.
      * @returns the next state (same reference when the event is not the unit's).
      */
-    apply(state: S, event: SessionEvent): S;
-    /**
-     * State → wire payload (the read-side projection).
-     * @param state - the current state.
-     * @returns the whole current value for this unit's key.
-     */
-    view(state: S): SessionProjectionMap[K];
+    apply(state: NoInfer<S>, event: SessionEvent): NoInfer<S>;
+    /** Client view. Omit for host-only units. */
+    wire?: K extends keyof SessionProjectionMap ? {
+        /** Validates the wire payload before it leaves the host. */
+        viewSchema: ZodType<SessionProjectionMap[K]>;
+        /**
+         * State → wire payload (the read-side projection).
+         * @param state - the current state.
+         * @returns the whole current value for this unit's key.
+         */
+        view(state: NoInfer<S>): SessionProjectionMap[K];
+    } : never;
     /**
      * Persisted-cache invalidation version: bump whenever the serialized state fields or the
      * fold semantics change, so persisted `(sessionId, key, ver, seq, val)`
@@ -74,14 +79,14 @@ export interface ProjectionDefinition<K extends keyof SessionProjectionMap, S> {
  */
 export type ProjectionChangeListener = (session: Session, key: Extract<keyof SessionProjectionMap, string>, value: unknown, seq: number) => void;
 /**
- * One consistent read cut over every registered unit for one session.
+ * One consistent read cut over every registered client-visible unit for one session.
  * `asOfSeq` is the shared watermark — the seq of the last event every value
  * reflects (`-1` for an empty log, mirroring `session/subscribed.lastSeq`).
  */
 export interface ProjectionSnapshot {
     /** Seq of the last event the values reflect; -1 for an empty log. */
     asOfSeq: number;
-    /** Whole current value per registered key. */
+    /** Whole current client value per registered key. */
     values: Partial<SessionProjectionMap>;
 }
 /**
@@ -106,7 +111,8 @@ export type ProjectionCheckpoint = Record<string, ProjectionCheckpointRow>;
  * `ctx.sessionProjections`: the projection unit table and its drive. The
  * service subscribes to `session/event` once; every committed event passes
  * every registered unit's `apply` (eager drive), and a changed state
- * reference notifies the change feed with the schema-validated view.
+ * reference in a client-visible unit notifies the change feed with the
+ * schema-validated view.
  * Cells build lazily — a unit registered after events flowed, or a session
  * older than the registry, folds `init` over the in-memory log on first
  * touch (event or read). Registration is an effect (disposer rides the
@@ -134,25 +140,42 @@ export declare class SessionProjectionRegistry extends Service {
      * @param definition - key, state schema, pure unit functions, and stateVersion.
      * @returns the exact disposer that unregisters this unit.
      */
-    register<K extends keyof SessionProjectionMap, S>(definition: ProjectionDefinition<K, S>): () => void;
+    register<K extends keyof SessionProjectionMap, S extends SessionProjectionStateMap[K]>(definition: Omit<ProjectionDefinition<K, S>, 'wire'> & {
+        wire: NonNullable<ProjectionDefinition<K, S>['wire']>;
+    }): () => void;
+    /**
+     * Register one host-only unit. Its state is omitted from client snapshots
+     * and always checkpointed like every other unit.
+     * @param definition - key, state schema, pure unit functions, and stateVersion.
+     * @returns the exact disposer that unregisters this unit.
+     */
+    register<K extends Exclude<keyof SessionProjectionStateMap, keyof SessionProjectionMap>, S extends SessionProjectionStateMap[K]>(definition: Omit<ProjectionDefinition<K, S>, 'wire'>): () => void;
     /**
      * Subscribe to the change feed. The registration is an effect on the
      * calling context's fiber.
-     * @param listener - called once per unit whose state reference changed, per committed event.
+     * @param listener - called once per client-visible unit whose state reference changed, per committed event.
      * @returns the exact disposer that unsubscribes.
      */
     onChanged(listener: ProjectionChangeListener): () => void;
     /**
-     * One consistent cut over every registered unit for one session, read from
+     * Read one unit's current host state without computing unrelated views.
+     * The returned value is live; callers must not mutate it.
+     * @param session - the session whose state is read.
+     * @param key - the registered unit key.
+     * @returns current state, or `undefined` when the key is not registered.
+     */
+    stateOf<K extends keyof SessionProjectionStateMap>(session: Session, key: K): SessionProjectionStateMap[K] | undefined;
+    /**
+     * One consistent cut over every registered client-visible unit for one session, read from
      * the watermark cache (missing cells fold lazily over the in-memory log).
      * Fully synchronous — every value and `asOfSeq` reflect the same log
-     * position. Each value passes its unit's schema before leaving.
+     * position. Each value passes its unit's `viewSchema` before leaving.
      * @param session - the session whose projection values are read.
-     * @returns the snapshot; `values` is empty when no unit is registered.
+     * @returns the snapshot; `values` is empty when no client-visible unit is registered.
      */
     snapshot(session: Session): ProjectionSnapshot;
     /**
-     * State-level checkpoint of every registered unit for one session, read
+     * State-level checkpoint of every persisted unit for one session, read
      * from the watermark cache (missing cells fold lazily over the in-memory
      * log). This is the write side of the persisted projection cache: the
      * returned rows are the `(key → {ver, seq, val})` part of the durable
@@ -163,7 +186,7 @@ export declare class SessionProjectionRegistry extends Service {
      * every subsequent snapshot and frame through it (plain JSON by the unit
      * contract, so the clone is total).
      * @param session - the session whose unit states are checkpointed.
-     * @returns one row per registered key; empty when no unit is registered.
+     * @returns one row per registered key.
      */
     checkpoint(session: Session): ProjectionCheckpoint;
     /**
@@ -185,8 +208,8 @@ export declare class SessionProjectionRegistry extends Service {
     restoreFloor(checkpoint: ProjectionCheckpoint): number | undefined;
     /**
      * View a checkpoint's rows without any log read: for every registered
-     * unit whose row's `ver` matches, serve the schema-validated
-     * `view` of the stored state; mismatched or absent rows leave their key
+     * client-visible unit whose row's `ver` matches, serve the schema-validated
+     * `view` of the schema-validated stored state; mismatched, malformed, or absent rows leave their key
      * absent (a cold or listing consumer treats it as not-yet-available and a
      * fuller read path refolds it). The zero-I/O rung of the read ladder —
      * values are as stale as their rows, never wrong.
@@ -195,7 +218,7 @@ export declare class SessionProjectionRegistry extends Service {
      */
     viewCheckpoint(checkpoint: ProjectionCheckpoint): Partial<SessionProjectionMap>;
     /**
-     * Cold read: fold every registered unit over a stored log suffix, seeding
+     * Cold read: fold every persisted unit over a stored log suffix, seeding
      * each from its checkpoint row when usable — the one read recipe (cached
      * state + forward tail replay + `view`) applied without a live `Session`.
      * Call with the events returned by a persistence

package/dist/kernel/session-projection/lib/types/index.js

@@ -1,9 +1,9 @@
 /**
- * Service Definition and drive registry for the session-projection capability seam: the merge-extensible `SessionProjectionMap` type
- * table, the `ProjectionDefinition` state-driven computation unit contract,
+ * Service Definition and drive registry for the session-projection capability seam: the merge-extensible state and client-view type
+ * tables, the `ProjectionDefinition` state-driven computation unit contract,
  * and the `ctx.sessionProjections` registry that DRIVES every registered unit
  * forward eagerly over committed session events. Domain host plugins
- * contribute pure mathematics (init/apply/view); the framework owns the
+ * contribute pure folds and optional client views; the framework owns the
  * subscription, the per-session watermark cache, and change notification;
  * carriers consume the snapshot read face and the change feed. Neither side
  * knows the other
@@ -16,12 +16,13 @@
  *
  * @module @nomix-ai/nomix-session-projection
  */
-import { Service } from '@nomix-ai/cordis';
+import { Service } from '../../../cordis/lib/index.js';
 /**
  * `ctx.sessionProjections`: the projection unit table and its drive. The
  * service subscribes to `session/event` once; every committed event passes
  * every registered unit's `apply` (eager drive), and a changed state
- * reference notifies the change feed with the schema-validated view.
+ * reference in a client-visible unit notifies the change feed with the
+ * schema-validated view.
  * Cells build lazily — a unit registered after events flowed, or a session
  * older than the registry, folds `init` over the in-memory log on first
  * touch (event or read). Registration is an effect (disposer rides the
@@ -46,31 +47,30 @@ export class SessionProjectionRegistry extends Service {
             this.drive(session, event);
         });
     }
-    /**
-     * Register one domain's unit. The registration is an effect on the calling
-     * context's fiber: disposing the fiber (or calling the returned disposer)
-     * removes the key — and the unit's cached cells — from subsequent drives
-     * and snapshots.
-     * @param definition - key, state schema, pure unit functions, and stateVersion.
-     * @returns the exact disposer that unregisters this unit.
-     */
     register(definition) {
+        const wire = definition.wire;
+        const erased = {
+            key: definition.key,
+            stateSchema: definition.stateSchema,
+            init: () => definition.init(),
+            apply: (state, event) => definition.apply(state, event),
+            wire: wire === undefined
+                ? undefined
+                : { viewSchema: wire.viewSchema, view: state => wire.view(state) },
+            stateVersion: definition.stateVersion,
+        };
         if (!Number.isSafeInteger(definition.stateVersion) || definition.stateVersion < 0) {
             throw new Error(`session projection ${JSON.stringify(definition.key)} stateVersion must be a non-negative integer, got ${String(definition.stateVersion)}`);
         }
         const dispose = this.ctx.effect(function* () {
-            const key = definition.key;
+            const key = erased.key;
             const existing = this.registrations.get(key);
             if (existing === undefined) {
-                this.registrations.set(key, { def: definition, cells: new WeakMap(), refs: 1 });
+                this.registrations.set(key, { def: erased, cells: new WeakMap(), refs: 1 });
             }
             else {
-                // A differing `stateVersion` is the one incompatibility this can name:
-                // the versioned contract says the cached state shape differs, so the
-                // two registrants cannot share cells. Anything else about a definition
-                // is functions, which no runtime comparison can tell apart.
-                if (existing.def.stateVersion !== definition.stateVersion) {
-                    throw new Error(`session projection key ${JSON.stringify(key)} is already registered at stateVersion ${String(existing.def.stateVersion)}; refusing to share it with stateVersion ${String(definition.stateVersion)}`);
+                if (existing.def.stateVersion !== erased.stateVersion) {
+                    throw new Error(`session projection key ${JSON.stringify(key)} is already registered at stateVersion ${String(existing.def.stateVersion)}; refusing to share it with stateVersion ${String(erased.stateVersion)}`);
                 }
                 existing.refs += 1;
             }
@@ -89,7 +89,7 @@ export class SessionProjectionRegistry extends Service {
     /**
      * Subscribe to the change feed. The registration is an effect on the
      * calling context's fiber.
-     * @param listener - called once per unit whose state reference changed, per committed event.
+     * @param listener - called once per client-visible unit whose state reference changed, per committed event.
      * @returns the exact disposer that unsubscribes.
      */
     onChanged(listener) {
@@ -102,23 +102,38 @@ export class SessionProjectionRegistry extends Service {
         return () => void dispose();
     }
     /**
-     * One consistent cut over every registered unit for one session, read from
+     * Read one unit's current host state without computing unrelated views.
+     * The returned value is live; callers must not mutate it.
+     * @param session - the session whose state is read.
+     * @param key - the registered unit key.
+     * @returns current state, or `undefined` when the key is not registered.
+     */
+    stateOf(session, key) {
+        const registration = this.registrations.get(key);
+        if (registration === undefined)
+            return undefined;
+        return this.cellFor(registration, session).state;
+    }
+    /**
+     * One consistent cut over every registered client-visible unit for one session, read from
      * the watermark cache (missing cells fold lazily over the in-memory log).
      * Fully synchronous — every value and `asOfSeq` reflect the same log
-     * position. Each value passes its unit's schema before leaving.
+     * position. Each value passes its unit's `viewSchema` before leaving.
      * @param session - the session whose projection values are read.
-     * @returns the snapshot; `values` is empty when no unit is registered.
+     * @returns the snapshot; `values` is empty when no client-visible unit is registered.
      */
     snapshot(session) {
         const values = {};
         for (const registration of this.registrations.values()) {
+            if (registration.def.wire === undefined)
+                continue;
             const cell = this.cellFor(registration, session);
-            values[registration.def.key] = registration.def.schema.parse(registration.def.view(cell.state));
+            values[registration.def.key] = registration.def.wire.viewSchema.parse(registration.def.wire.view(cell.state));
         }
-        return { asOfSeq: session.seq - 1, values: values };
+        return { asOfSeq: session.seq - 1, values };
     }
     /**
-     * State-level checkpoint of every registered unit for one session, read
+     * State-level checkpoint of every persisted unit for one session, read
      * from the watermark cache (missing cells fold lazily over the in-memory
      * log). This is the write side of the persisted projection cache: the
      * returned rows are the `(key → {ver, seq, val})` part of the durable
@@ -129,7 +144,7 @@ export class SessionProjectionRegistry extends Service {
      * every subsequent snapshot and frame through it (plain JSON by the unit
      * contract, so the clone is total).
      * @param session - the session whose unit states are checkpointed.
-     * @returns one row per registered key; empty when no unit is registered.
+     * @returns one row per registered key.
      */
     checkpoint(session) {
         const rows = {};
@@ -172,8 +187,8 @@ export class SessionProjectionRegistry extends Service {
     }
     /**
      * View a checkpoint's rows without any log read: for every registered
-     * unit whose row's `ver` matches, serve the schema-validated
-     * `view` of the stored state; mismatched or absent rows leave their key
+     * client-visible unit whose row's `ver` matches, serve the schema-validated
+     * `view` of the schema-validated stored state; mismatched, malformed, or absent rows leave their key
      * absent (a cold or listing consumer treats it as not-yet-available and a
      * fuller read path refolds it). The zero-I/O rung of the read ladder —
      * values are as stale as their rows, never wrong.
@@ -184,15 +199,24 @@ export class SessionProjectionRegistry extends Service {
         const values = {};
         for (const registration of this.registrations.values()) {
             const def = registration.def;
+            if (def.wire === undefined)
+                continue;
             const row = checkpoint[def.key];
             if (row === undefined || row.ver !== def.stateVersion)
                 continue;
-            values[def.key] = def.schema.parse(def.view(row.val));
+            let state;
+            try {
+                state = def.stateSchema.parse(row.val);
+            }
+            catch {
+                continue;
+            }
+            values[def.key] = def.wire.viewSchema.parse(def.wire.view(state));
         }
         return values;
     }
     /**
-     * Cold read: fold every registered unit over a stored log suffix, seeding
+     * Cold read: fold every persisted unit over a stored log suffix, seeding
      * each from its checkpoint row when usable — the one read recipe (cached
      * state + forward tail replay + `view`) applied without a live `Session`.
      * Call with the events returned by a persistence
@@ -228,13 +252,14 @@ export class SessionProjectionRegistry extends Service {
                 throw new Error(`session projection ${JSON.stringify(def.key)} cannot restore from seq ${baseSeq}: `
                     + 'its checkpoint row is missing, version-mismatched, or beyond the supplied log end; re-read from seq 0');
             }
-            let state = usable ? row.val : def.init();
+            let state = usable ? def.stateSchema.parse(row.val) : def.init();
             const from = usable ? row.seq : baseSeq - 1;
             for (const event of events) {
                 if (event.seq > from)
                     state = def.apply(state, event);
             }
-            values[def.key] = def.schema.parse(def.view(state));
+            if (def.wire !== undefined)
+                values[def.key] = def.wire.viewSchema.parse(def.wire.view(state));
             refreshed[def.key] = { ver: def.stateVersion, seq: endSeq, val: state };
         }
         return {
@@ -272,8 +297,8 @@ export class SessionProjectionRegistry extends Service {
             const changed = !Object.is(next, cell.state);
             cell.state = next;
             cell.observedSeq = event.seq;
-            if (changed && this.listeners.size > 0) {
-                const value = registration.def.schema.parse(registration.def.view(next));
+            if (changed && registration.def.wire !== undefined && this.listeners.size > 0) {
+                const value = registration.def.wire.viewSchema.parse(registration.def.wire.view(next));
                 for (const listener of this.listeners) {
                     listener(session, registration.def.key, value, event.seq);
                 }

package/dist/kernel/session-projection/lib/types/invariant.d.ts

@@ -2,7 +2,7 @@
  * Package-owned invariant companion for `@nomix-ai/nomix-session-projection`.
  * @module @nomix-ai/nomix-session-projection/invariant
  */
-import type { Context } from '@nomix-ai/cordis';
+import type { Context } from '../../../cordis/lib/index.js';
 /** Cordis companion plugin name. */
 export declare const name = "session-projection-invariant";
 /** Service required before the companion can reserve package ownership. */

package/dist/kernel/session-projection/lib/types/types.d.ts

@@ -8,11 +8,18 @@
  * @module @nomix-ai/nomix-session-projection/types
  */
 /**
- * The single projection type table for the whole chain (host provider, wire
- * block, client cell, React hook). Domain packages merge their key here via
- * declaration merging; values are wire-JSON whole values. How a value is
- * rendered is the slot system's business, never this layer's.
+ * The merge-extensible client projection table shared by wire blocks, client
+ * cells, and React hooks. Domain packages merge their client-visible key here;
+ * values are wire-JSON whole values. How a value is rendered is the slot
+ * system's business, never this layer's.
  */
 export interface SessionProjectionMap {
 }
+/**
+ * The merge-extensible host fold-state table. Each client-visible key also
+ * appears in {@link SessionProjectionMap}; host-only keys appear only here.
+ * Values must be plain JSON so the projection cache can persist them.
+ */
+export interface SessionProjectionStateMap {
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/kernel/session-projection/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-session-projection",
   "description": "Session-projection seam: the merge-extensible projection type table, the provider contract, and the ctx.sessionProjections registry serving whole current values of log-derived per-session state",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/session-projection-cache/lib/index.js

@@ -1,5 +1,5 @@
-import { Service } from "@nomix-ai/cordis";
-import z from "@nomix-ai/schemastery";
+import { Service } from "../../cordis/lib/index.js";
+import z from "../../schemastery/lib/index.mjs";
 import { snapshotJsonValue } from "../../session/lib/index.js";
 import { z as z$1 } from "zod";
 import { defineDomain, domainTable } from "../../storage-domain/lib/index.js";
@@ -64,7 +64,7 @@ const projectionCacheDomainSpec = defineDomain({
 //#region lib/types/index.js
 /**
 * Persisted projection cache (`ctx.sessionProjectionCache`): durable
-* checkpoints of every registered projection unit's state, one record per
+* checkpoints of every client-visible or explicitly persisted projection unit's state, one record per
 * session on the domain data form (`session_projcache` domain — the shipped
 * json backend lands it beside `workspace.json`). The cache is a fold
 * shortcut, never an authority: a row is possibly stale (its `seq`