@fougere/core 0.12.0-alpha.0 → 0.12.2-alpha.0

package/src/builtin/Carry.ts

@@ -24,6 +24,7 @@ export class Carry {
       try {
         this.take(record);
       } catch { /* announcing never breaks logging, for the same reason a sink does not */ }
+
       return;
     }
     this.held.push(record);

package/src/builtin/Logger.ts

@@ -12,6 +12,7 @@ let threshold: number = LEVELS[envLevel() ?? 'info'];
 /** The level the PROCESS was started with. */
 export function envLevel(): LogLevel | undefined {
   const raw = typeof process === 'undefined' ? undefined : process.env.FOUGERE_LOG_LEVEL;
+
   return raw !== undefined && raw in LEVELS ? (raw as LogLevel) : undefined;
 }
 
@@ -51,8 +52,10 @@ function supportsColor(): boolean {
   if (typeof process !== 'undefined') {
     if (process.env.NO_COLOR) return false;
     if (process.env.FORCE_COLOR === '1') return true;
+
     return process.stdout?.isTTY === true;
   }
+
   return false;
 }
 
@@ -62,6 +65,7 @@ function stamp(at: number | Date): string {
   const m = String(d.getMinutes()).padStart(2, '0');
   const s = String(d.getSeconds()).padStart(2, '0');
   const ms = String(d.getMilliseconds()).padStart(3, '0');
+
   return `${h}:${m}:${s}.${ms}`;
 }
 
@@ -92,7 +96,7 @@ export class Logger {
       level: level as LogRecord['level'], name: this.name, message: msg, args, at: Date.now(),
     };
 
-    this.carry?.push(record);
+    this.carry?.push({ ...record, args: args.map(objectOf) });
 
     // The console ALWAYS, whoever else took the line. Skipping it once a destination
     // existed made `calls()` — a devtools ring that prints nothing — silence the
@@ -103,6 +107,10 @@ export class Logger {
   }
 }
 
+/** A line travels as a fact, where `args` states `json()` — an object. */
+const objectOf = (arg: unknown): object =>
+  typeof arg === 'object' && arg !== null && !Array.isArray(arg) ? arg : { value: arg };
+
 export function formatted(
   record: Rendered,
   color = supportsColor(),

package/src/builtin/config.ts

@@ -9,5 +9,6 @@ export class Config {
 
 function envOfProcess(): Record<string, string | undefined> {
   const proc = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process;
+
   return proc?.env ?? {};
 }

package/src/contract.ts

@@ -29,6 +29,7 @@ export { MAX_BODY_BYTES } from './wire/SignedCall.js';
 // call log ignoring its own reader — has to be able to name it.
 export { RPC_ENTITY } from './wire/RpcAnswer.js';
 export type { CallPage } from './wire/CallPage.js';
+export { pageOf, asPage, type Page } from './wire/Page.js';
 export type { CallRecord } from './wire/CallRecord.js';
 // The comparison of two cards, which a consumer runs about a producer — browser-safe on
 // purpose: a panel showing the drift holds only the two cards, never the app.
@@ -55,6 +56,7 @@ export type { Edge } from './wire/topology/Edge.js';
 export type { FrondPlacement } from './wire/topology/FrondPlacement.js';
 export type { TopologyReport } from './wire/topology/TopologyReport.js';
 export { assertIdentityCard } from './wire/card/IdentityCard.js';
+export { decoded } from './dispatch/decoded.js';
 
 /** The key a class name is filed under — 'Post' → 'post'. */
 export { lowerFirst } from '@fougere/schema';
@@ -78,5 +80,6 @@ export function callValueOf(
     typeof opOrInput === 'string'
       ? [{ entity: lowerFirst((target as { name: string }).name), op: opOrInput }, input]
       : [target as FrondCall, opOrInput];
+
   return { call, invocation: Invocation.from(given) };
 }

package/src/crypto/encoding.ts

@@ -13,6 +13,7 @@ export function b64url(input: Uint8Array | string): string {
   // One character at a time: `String.fromCharCode(...bytes)` overflows the argument
   // limit on a key, and a signature is small enough that the loop costs nothing.
   for (const byte of bytes) binary += String.fromCharCode(byte);
+
   return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
 }
 
@@ -20,6 +21,7 @@ export function unb64url(input: string): Uint8Array {
   const binary = atob(input.replace(/-/g, '+').replace(/_/g, '/'));
   const bytes = new Uint8Array(binary.length);
   for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+
   return bytes;
 }
 
@@ -28,6 +30,7 @@ export const unb64 = (input: string): Uint8Array => {
   const binary = atob(input);
   const bytes = new Uint8Array(binary.length);
   for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+
   return bytes;
 };
 
@@ -35,5 +38,6 @@ export const unb64 = (input: string): Uint8Array => {
 export function derOf(pem: string): Uint8Array {
   const body = pem.replace(/-----(BEGIN|END)[^-]+-----/g, '').replace(/\s+/g, '');
   if (body.length === 0) throw new Error('Not a PEM: no base64 body between the armour');
+
   return unb64(body);
 }

package/src/crypto/node.ts

@@ -13,6 +13,7 @@ export const crypto: CryptoPort = {
   async signerOf(privateKeyPem): Promise<Signer> {
     // Parsed here and captured, so a call signs against a KeyObject and never a string.
     const key = createPrivateKey(privateKeyPem);
+
     return { async sign(data) { return new Uint8Array(sign(null, data, key)); } };
   },
 
@@ -20,6 +21,7 @@ export const crypto: CryptoPort = {
     const parsed = typeof key === 'string'
       ? createPublicKey(key)
       : createPublicKey({ key: key as never, format: 'jwk' });
+
     return { async verify(data, signature) { return verify(null, data, parsed, signature); } };
   },
 };

package/src/crypto/webcrypto.ts

@@ -33,6 +33,7 @@ export const crypto: CryptoPort = {
     // Imported once, at boot. Doing it per call would put an async key parse inside
     // every outgoing request — the reason the port hands back a signer at all.
     const key = await subtle().importKey('pkcs8', derOf(privateKeyPem), ED25519, false, ['sign']);
+
     return { async sign(data) { return new Uint8Array(await subtle().sign(ED25519, key, data)); } };
   },
 
@@ -40,6 +41,7 @@ export const crypto: CryptoPort = {
     const imported = typeof key === 'string'
       ? await subtle().importKey('spki', derOf(key), ED25519, false, ['verify'])
       : await subtle().importKey('jwk', key, ED25519, false, ['verify']);
+
     return { verify: (data, signature) => subtle().verify(ED25519, imported, signature, data) };
   },
 };

package/src/descriptor/Fronds.ts

@@ -12,6 +12,7 @@ export class Fronds extends Array<FrondDescriptor> {
   static hosting(fronds: readonly FrondDescriptor[]): Fronds {
     const all = new Fronds();
     all.push(...fronds);
+
     return all;
   }
 
@@ -26,6 +27,7 @@ export class Fronds extends Array<FrondDescriptor> {
       const found = frond.entities.find((e) => e.name === name);
       if (found) return found;
     }
+
     return undefined;
   }
 

package/src/dispatch/ArrayResult.ts

@@ -6,5 +6,6 @@ export function preserveArrayProperties<T extends unknown[]>(source: unknown[],
         (source as unknown as Record<string, unknown>)[key];
     }
   }
+
   return target;
 }

package/src/dispatch/Dispatcher.ts

@@ -71,6 +71,7 @@ export class Dispatcher implements DispatchPort {
       this.lifecycle.publish(DispatchEvent.resolved(call, route.kind));
       const result = await route.execute(call);
       this.lifecycle.publish(DispatchEvent.completed(call, route.kind));
+
       return result;
     } catch (error) {
       this.lifecycle.publish(DispatchEvent.failed(call, error, route?.kind));

package/src/dispatch/HandlerFacade.ts

@@ -116,15 +116,23 @@ export class HandlerFacade {
 
     const args = contract.binding ? await this.arguments.resolve(contract.binding, validated) : [];
     const { instance, method } = this.resolveImplementation(op);
-    const view = this.viewOf(op);
-    const output = view.project(await instance[method](...args));
+    const answered = await instance[method](...args);
 
+    const view = this.viewOf(op);
     const { presenter } = this.facade;
+    const computed = view.closed || !presenter
+      ? answered
+      : await this.present(op, presenter, answered, validated);
 
-    return view.closed || !presenter ? output : this.present(op, presenter, output, validated);
+    return view.project(computed);
   }
 
-  /** The computed fields a presenter adds, over the page the façade just projected. */
+  /**
+   * The computed fields a presenter adds, over the rows the handler answered and BEFORE the
+   * view projects them. A presenter runs on the server, so what it reads is the row the
+   * storage holds: a `writeOnly` field is gone by the time the client sees it, and deriving
+   * from one is the whole reason to declare it.
+   */
   private present(
     op: string,
     presenter: PresenterEntry,
@@ -180,12 +188,14 @@ export class HandlerFacade {
       operation?.outputClosed ?? false,
     );
     this.cachedViews.set(op, resolved);
+
     return resolved;
   }
 
   /** The handler itself, resolved on first call — never at boot. */
   private resolveHandler(): any {
     if (!this.instance) this.instance = this.scope.resolve(this.handlerKey);
+
     return this.instance;
   }
 
@@ -208,6 +218,7 @@ export class HandlerFacade {
         + `${operation.implementation.method}, but boot found ${matches.length} matching handlers.`,
       );
     }
+
     return matches[0]!;
   }
 
@@ -225,6 +236,7 @@ export class HandlerFacade {
       instance = this.scope.resolve(key);
       this.implementationInstances.set(key, instance);
     }
+
     return { instance, method: operation.implementation.method };
   }
 }

package/src/dispatch/InFlight.ts

@@ -23,6 +23,7 @@ export class InFlight {
 
     this.running++;
     let released = false;
+
     return () => {
       if (released) return;
       released = true;
@@ -41,6 +42,7 @@ export class InFlight {
 
   whenIdle(): Promise<void> {
     if (this.running === 0) return Promise.resolve();
+
     return new Promise((resolve) => this.idle.push(resolve));
   }
 }

package/src/dispatch/LocalRoutePolicy.ts

@@ -22,6 +22,7 @@ export class LocalRoutePolicy implements RoutePolicy {
     const hosted = this.hostedNames(call.address.surface);
     const entity = call.address.entity;
     const surface = call.address.surface;
+
     return new FougereError({
       code: ErrorCode.NOT_FOUND,
       message: (surface

package/src/dispatch/OutputView.ts

@@ -1,5 +1,6 @@
 import { Visibility, type Fields } from '@fougere/schema';
 import { preserveArrayProperties } from './ArrayResult.js';
+import { asPage } from '../wire/Page.js';
 
 /** What one operation result may show. One of the two exits a validator watches. */
 export class OutputView {
@@ -15,6 +16,12 @@ export class OutputView {
       return preserveArrayProperties(result, result.map((item) => this.project(item)));
     }
 
+    // A paged op answers an envelope, so what a view applies to is its ROWS. Projecting the
+    // envelope itself let every field of every row through — `Visibility.encode` finds none of
+    // its own keys on `{ items, total }` and hands the object back.
+    const page = asPage(result, this.fields);
+    if (page) return { ...page, items: page.items.map((item) => this.project(item)) };
+
     if (typeof result !== 'object') return result;
 
     const record = result as Record<string, unknown>;

package/src/dispatch/PresenterExecutor.ts

@@ -2,6 +2,7 @@ import { ErrorCode } from '../wire/ErrorCode.js';
 import { FougereError } from '../wire/FougereError.js';
 import { preserveArrayProperties } from './ArrayResult.js';
 import type { PresenterArgs } from './PresenterArgs.js';
+import { asPage } from '../wire/Page.js';
 
 /** Adds a presenter's computed fields after output projection. */
 export class PresenterExecutor {
@@ -17,6 +18,12 @@ export class PresenterExecutor {
       return result;
     }
 
+    // A paged op answers an envelope, and what a computed field sits on is a ROW. Handed the
+    // envelope itself, a presenter added its fields to `{ items, total }` and every row came
+    // back untouched.
+    const page = asPage(result, Object.fromEntries(this.fieldNames.map((name) => [name, true])));
+    if (page) return { ...page, items: await this.present(page.items, args) as unknown[] };
+
     const rows = Array.isArray(result) ? result : [result];
     const values = new Map<string, unknown[]>();
     for (const name of this.fieldNames) {

package/src/dispatch/Received.ts

@@ -0,0 +1,2 @@
+/** What a facade puts back into an answer before handing it to its caller, read per operation. */
+export type Received = (operation: string, answer: unknown) => unknown;

package/src/dispatch/RouteRegistry.ts

@@ -35,6 +35,7 @@ export class RouteRegistry {
       entity: address.entity,
       operation: address.operation,
     }).key());
+
     return shared?.kind === 'system' ? shared : undefined;
   }
 
@@ -48,6 +49,7 @@ export class RouteRegistry {
 
     const resolution = this.resolveUnknown(address).finally(() => this.pending.delete(key));
     this.pending.set(key, resolution);
+
     return resolution;
   }
 
@@ -56,8 +58,10 @@ export class RouteRegistry {
       const route = await resolver(address);
       if (!route) continue;
       this.register(route);
+
       return route;
     }
+
     return undefined;
   }
 

package/src/dispatch/StorageGuard.ts

@@ -1,4 +1,4 @@
-import { FieldSet, FieldValueValidator, InputRefusal, type Fields, type Verdict } from '@fougere/schema';
+import { FieldSet, FieldValueValidator, InputRefusal, Role, type Fields, type Verdict } from '@fougere/schema';
 import { COMPARISONS, comparisonOf, unknownIn } from '../storage/Comparison.js';
 import { assertListOptions } from '../storage/Storage.js';
 import { ErrorCode } from '../wire/ErrorCode.js';
@@ -69,12 +69,14 @@ export class StorageGuard {
     guarded.create = async function (...args) {
       args[0] = validation.validated(args[0], 'create');
       await validation.targetsOf([args[0]], 'create');
+
       return writer.create.apply(this, args);
     };
 
     guarded.update = async function (...args) {
       args[1] = validation.validated(args[1], 'update');
       await validation.targetsOf([args[1]], 'update');
+
       return writer.update.apply(this, args);
     };
 
@@ -83,6 +85,7 @@ export class StorageGuard {
       guarded.upsert = async function (...args) {
         args[0] = validation.validated(args[0], 'upsert');
         await validation.targetsOf([args[0]], 'upsert');
+
         return upsert.apply(this, args);
       };
     }
@@ -94,6 +97,7 @@ export class StorageGuard {
       guarded.upsertAll = async function (...args) {
         args[0] = args[0].map((row, index) => validation.validated(row, 'upsertAll', index));
         await validation.targetsOf(args[0], 'upsertAll');
+
         return upsertAll.apply(this, args);
       };
     }
@@ -122,6 +126,7 @@ export class StorageGuard {
   private rowAt(row: unknown, index: number): string {
     const primary = FieldSet.of(this.fields).primary;
     const key = primary === undefined ? undefined : (row as Record<string, unknown>)[primary];
+
     return key === undefined ? `row ${index} of this page` : `row ${primary} ${JSON.stringify(key)}`;
   }
 
@@ -213,6 +218,8 @@ export class StorageGuard {
   private written(key: string, item: unknown): Verdict {
     const field = this.fields[key];
     if (!field) return { message: InputRefusal.unknownField };
+    // Declared, and still nothing to write: the other side of the relation carries the key.
+    if (Role.of(field).isCollection()) return { message: InputRefusal.readOnly };
     if (item === undefined) return { value: item };
 
     return FieldValueValidator.of(field).parse(item);
@@ -220,6 +227,7 @@ export class StorageGuard {
 
   private value(field: Fields[string], asked: unknown): Verdict {
     if (asked === null || asked === undefined) return { value: asked };
+
     return FieldValueValidator.of(field).parse(asked);
   }
 

package/src/dispatch/decoded.ts

@@ -0,0 +1,37 @@
+import { Visibility, type Fields, type SchemaView } from '@fougere/schema';
+import { preserveArrayProperties } from './ArrayResult.js';
+import { asPage } from '../wire/Page.js';
+
+/**
+ * What a caller receives, read back into the shape its type promises — the dual of
+ * `OutputView.project`, applied on the other side of the call.
+ *
+ * `date-time` means a `Date` on both sides (`Boundary.forShape`), and only the outgoing half was
+ * ever applied: `Visibility.encode` turned `new Date(0)` into `"1970-01-01T00:00:00.000Z"` and
+ * nobody turned it back, so `Facade<PostHandler>` promised `createdAt: Date` and handed over a
+ * string — in this process as well as across a wire.
+ *
+ * Applied by the facade a caller HOLDS, never by the one that answers: a row leaves as data,
+ * which is what a Rust frond or a plain HTTP client reads, and the codecs are what this side
+ * knows how to put back. Measured 2026-09-18: 389 ns per row against the 1 277 ns encoding one
+ * already costs.
+ *
+ * Documented: [the gradient](https://fougere.dev/docs/infra/gradient).
+ */
+export function decoded(schema: SchemaView | undefined, answer: unknown): unknown {
+  if (!schema || answer === null || answer === undefined) return answer;
+
+  const fields = schema.getFields() as Fields;
+  const visibility = Visibility.of(fields);
+  const row = (one: unknown) => (one !== null && typeof one === 'object' && !Array.isArray(one)
+    ? visibility.decode(one as Record<string, unknown>)
+    : one);
+
+  const page = asPage(answer, fields);
+  if (page) return { ...page, items: page.items.map(row) };
+
+  // An op annotating `ListResult<T>` still answers the array those properties ride on.
+  return Array.isArray(answer)
+    ? preserveArrayProperties(answer, answer.map(row))
+    : row(answer);
+}

package/src/entry/facade.ts

@@ -2,6 +2,7 @@ import { Call } from '../wire/Call.js';
 
 import { RouteAddress } from '../wire/RouteAddress.js';
 import type { DispatchPort } from '../dispatch/DispatchPort.js';
+import type { Received } from '../dispatch/Received.js';
 
 type Operation = (...args: any[]) => unknown;
 
@@ -22,21 +23,32 @@ export function dynamicOperations(operation: (name: string) => Operation): Recor
   });
 }
 
-/** Turns facade method calls into canonical dispatches. */
+/**
+ * Turns facade method calls into canonical dispatches.
+ *
+ * `received` is what this side puts back before handing the answer over: a row leaves as data
+ * and `date-time` means a `Date` on both sides. A facade built without one hands over what the
+ * wire carried, which is what a caller holding no schema can do.
+ */
 export function facadeOperations(
   dispatcher: DispatchPort,
   entity: string,
   operationNames?: Iterable<string>,
   surface?: string,
+  received?: Received,
 ): Record<string, Operation> {
-  const operation = (name: string): Operation => (invocation) => dispatcher.dispatch(new Call(
-    new RouteAddress({
-      entity,
-      operation: name,
-      ...(surface !== undefined ? { surface } : {}),
-    }),
-    invocation,
-  ));
+  const operation = (name: string): Operation => async (invocation) => {
+    const answer = await dispatcher.dispatch(new Call(
+      new RouteAddress({
+        entity,
+        operation: name,
+        ...(surface !== undefined ? { surface } : {}),
+      }),
+      invocation,
+    ));
+
+    return received ? received(name, answer) : answer;
+  };
 
   return operationNames
     ? Object.fromEntries([...operationNames].map((name) => [name, operation(name)]))

package/src/identity-keys.ts

@@ -5,6 +5,7 @@ import { b64url } from './crypto/encoding.js';
 /** A fresh Ed25519 pair, PEM both ways. The root's and a frond's are the same kind. */
 export function generateKeyPair(): { privateKey: string; publicKey: string } {
   const { privateKey, publicKey } = generateKeyPairSync('ed25519');
+
   return {
     privateKey: privateKey.export({ type: 'pkcs8', format: 'pem' }).toString(),
     publicKey: publicKey.export({ type: 'spki', format: 'pem' }).toString(),
@@ -26,5 +27,6 @@ export function issueGrant(
   const header = b64url(JSON.stringify({ alg: 'EdDSA', typ: 'fougere-grant' }));
   const payload = b64url(JSON.stringify({ sub: name, jwk, iat: now, exp: now + ttlDays * 86_400_000 }));
   const signingInput = `${header}.${payload}`;
+
   return `${signingInput}.${b64url(new Uint8Array(sign(null, Buffer.from(signingInput), createPrivateKey(rootPrivateKey))))}`;
 }

package/src/index.ts

@@ -49,6 +49,7 @@ export { JOURNAL, type Journal } from './dispatch/Journal.js';
 // them — or a test of one — has to be able to make one through the facade.
 export { DispatchEvent } from './dispatch/DispatchEvent.js';
 export type { CallPage, CallRecord } from './contract.js';
+export { pageOf, asPage, type Page } from './contract.js';
 export { driftOf, agrees, explain, type CardDrift } from './contract.js';
 export type { OperationContract } from './wire/OperationContract.js';
 export type { OperationsMap } from './wire/OperationsMap.js';

package/src/loader.ts

@@ -11,6 +11,7 @@ const defaultLoader: ModuleLoader = async (filePath, options) => {
   // On the URL, never on the path: `pathToFileURL` percent-encodes a `?` into the
   // filename, and the import then looks for a file whose name ends in `%3Fv=…`.
   const url = pathToFileURL(filePath).href;
+
   return await import(options?.fresh ? `${url}?v=${Date.now()}` : url);
 };
 

package/src/prefab/CrudConstructor.ts

@@ -6,6 +6,7 @@ import type { OperationContract } from '../wire/OperationContract.js';
 import { targetOf } from './prefab.js';
 import type { CrudOpName } from './CrudOpName.js';
 import type { CrudViews } from './CrudViews.js';
+import { pageOf, type Page } from '../wire/Page.js';
 import type { CrudOps } from './CrudOps.js';
 
 /**
@@ -51,12 +52,13 @@ const returns = (raw: string, name: string, extra?: { array?: boolean; nullable?
 function crudOps(entity: SchemaView & { partial?: () => SchemaView }): Record<string, OperationContract> {
   const name = (entity as { name?: string }).name ?? 'Entity';
   const input = inputParam(name);
+
   return {
     list: {
       output: entity, cardinality: 'page',
       binding: [{ name: 'options', source: { kind: 'query' }, optional: true }],
       signature: {
-        name: 'list', returnType: returns(`ListResult<${name}>`, 'ListResult'),
+        name: 'list', returnType: returns(`Page<${name}>`, 'Page'),
         params: [{ name: 'options', type: { raw: 'ListOptions', name: 'ListOptions' }, optional: true }],
       },
     },
@@ -139,7 +141,7 @@ export function Crud<E extends EntityConstructor, V extends CrudViews | EntityCo
       this.storage = storage as Storage<T>;
     }
 
-    async list(options?: ListOptions): Promise<ListResult<T>> { return this.storage.list(options) as Promise<ListResult<T>>; }
+    async list(options?: ListOptions): Promise<Page<T>> { return pageOf(await this.storage.list(options)); }
     async findById(id: string): Promise<T | undefined> { return this.storage.findById(id); }
     async create(input: Partial<T>): Promise<T> { return this.storage.create(input); }
     async update(id: string, input: Partial<T>): Promise<T> { return this.storage.update(id, input); }

package/src/prefab/CrudOps.ts

@@ -1,7 +1,7 @@
 import type { CrudOpName } from './CrudOpName.js';
 import type { EntityConstructor } from '@fougere/schema';
 import type { ListOptions } from '../storage/ListOptions.js';
-import type { ListResult } from '../storage/ListResult.js';
+import type { Page } from '../wire/Page.js';
 import type { Storage } from '../storage/Storage.js';
 
 /** The view an op emits, fabricated. */
@@ -16,7 +16,7 @@ type OutOf<V, K extends CrudOpName, T> =
 /** The five ops, typed from the entity and its views. */
 export interface CrudOps<T, V = {}> {
   storage: Storage<T>;
-  list(options?: ListOptions, ...collected: never[]): Promise<ListResult<OutOf<V, 'list', T>>>;
+  list(options?: ListOptions, ...collected: never[]): Promise<Page<OutOf<V, 'list', T>>>;
   findById(id: string, ...collected: never[]): Promise<OutOf<V, 'findById', T> | undefined>;
   create(input: Partial<T>, ...collected: never[]): Promise<OutOf<V, 'create', T>>;
   update(id: string, input: Partial<T>, ...collected: never[]): Promise<OutOf<V, 'update', T>>;

package/src/prefab/MirrorConstructor.ts

@@ -27,7 +27,7 @@ export function Mirror<E extends EntityConstructor>(shape: E): MirrorConstructor
         written += await this.storage.upsertAll(page);
       }
 
-      return { written, since, ms: Date.now() - started };
+      return { written, ...(since && { since: since.toISOString() }), ms: Date.now() - started };
     }
   }
 

package/src/prefab/Refreshed.ts

@@ -2,8 +2,13 @@
 export interface Refreshed {
   /** Instances written, counting a replaced one once. */
   written: number;
-  /** The age the pull was asked to start from — absent when it asked for everything. */
-  since?: Date;
+  /**
+   * The age the pull was asked to start from, as an ISO string — absent when it asked for
+   * everything. A STRING because a refresh is an operation: what it answers leaves through a
+   * facade, where only data crosses, and a `Date` reaches a caller here and an ISO string
+   * behind `fronds:` off the same code.
+   */
+  since?: string;
   /** How long the whole pass took, pull included. */
   ms: number;
 }

package/src/prefab/collector.ts

@@ -10,6 +10,7 @@ export function Collector<T extends abstract new (...args: any[]) => any>(target
   class CollectorBase {
     static readonly __entity = target;
   }
+
   return CollectorBase;
 }
 

package/src/prefab/presenter.ts

@@ -18,6 +18,7 @@ export function Presenter<E extends EntityConstructor>(entity: E, views?: Presen
     static readonly __entity = entity;
     static readonly __views = views;
   }
+
   return PresenterBase;
 }
 

package/src/storage/Storage.ts

@@ -159,6 +159,7 @@ const HELD = 'Storage';
  */
 export function togetherKeyOf(entities: readonly string[], providers: readonly string[] = []): string {
   const named = entities.map(upperFirst).join(SEPARATOR);
+
   return `${named}${providers.length ? KINDS + providers.map(upperFirst).join(SEPARATOR) : ''}${FRAME}`;
 }
 
@@ -174,5 +175,6 @@ export function membersOfTogetherKey(key: string): { entities: string[]; provide
   if (key.length <= FRAME.length || !key.endsWith(FRAME)) return undefined;
   const [entities = '', providers = ''] = key.slice(0, -FRAME.length).split(KINDS);
   const split = (list: string) => list.split(SEPARATOR).filter(Boolean);
+
   return { entities: split(entities), providers: split(providers) };
 }