foldkit-remote 0.20.0 → 0.22.0

package/dist/persistence.js

@@ -0,0 +1,205 @@
+import { emptyStore } from "./store.js";
+import { stableStringify } from "./query.js";
+import { connectionIdentity } from "./optimistic.js";
+import { Effect, Option } from "effect";
+import { KeyValueStore } from "effect/persistence";
+// src/persistence.ts
+/**
+* Remote cache persistence: a snapshot of the entity store and nothing else.
+* Runtime state (connections' live cursors, optimistic layers, the mutation
+* ledger, gaps, retention roots) is never in a snapshot; it belongs to the
+* session that produced it.
+*
+* The cache is server-derived and disposable: an incompatible, oversized, or
+* corrupt snapshot is discarded (and removed from a `KeyValueStore`) so the
+* planner refetches. `dehydrate`/`hydrate` are the string forms, for SSR and
+* any other transport; `save`/`restore` put them behind Effect's
+* `KeyValueStore`, so the backend (memory, filesystem, SQL, Web Storage) is the
+* application's choice.
+*/
+/** Bump when the serialized shape changes; a mismatch discards the cache. */
+const REMOTE_CACHE_VERSION = 5;
+/**
+* A snapshot of a Model, keeping the entity cache and only the connections
+* named.
+*
+* Naming none — the default — is exactly what Remote did before connections
+* could be kept at all: a disposable, server-derived cache.
+*/
+const snapshotOf = (model, options = {}) => ({
+	entities: model.entities,
+	connections: Object.fromEntries((options.connections ?? []).flatMap((connection) => {
+		const identity = connectionIdentity(connection);
+		const held = model.connections[identity];
+		return held === void 0 ? [] : [[identity, held.segments.map((segment) => segment.edges)]];
+	}))
+});
+const sorted = (values) => [...values].sort();
+/**
+* The snapshot's data shape. `stableStringify` sorts object keys, and the
+* field sets are sorted here, so equal stores give byte-equal snapshots
+* whatever order they were built in.
+*/
+const serializeStore = (snapshot, scope) => ({
+	version: 5,
+	scope: scope ?? null,
+	connections: snapshot.connections,
+	entities: Object.fromEntries(Object.entries(snapshot.entities).map(([key, entry]) => [key, {
+		values: entry.values,
+		present: sorted(entry.present),
+		stale: sorted(entry.stale),
+		unavailable: sorted(entry.unavailable),
+		tombstone: entry.tombstone,
+		updatedAt: entry.updatedAt,
+		windows: entry.windows
+	}]))
+});
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+const isStringRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((item) => typeof item === "string");
+/** Throws on a malformed entry so the whole snapshot is discarded. */
+const parseEntry = (value) => {
+	if (value === null || typeof value !== "object") throw new Error("entry is not an object");
+	const entry = value;
+	if (entry.values === null || typeof entry.values !== "object" || Array.isArray(entry.values)) throw new Error("entry.values is not a record");
+	if (!isStringArray(entry.present)) throw new Error("entry.present is not a string array");
+	if (!isStringArray(entry.stale)) throw new Error("entry.stale is not a string array");
+	if (!isStringArray(entry.unavailable)) throw new Error("entry.unavailable is not a string array");
+	if (typeof entry.tombstone !== "boolean") throw new Error("entry.tombstone is not a boolean");
+	if (typeof entry.updatedAt !== "number") throw new Error("entry.updatedAt is not a number");
+	if (!isStringRecord(entry.windows)) throw new Error("entry.windows is not a string record");
+	return {
+		values: entry.values,
+		present: new Set(entry.present),
+		stale: new Set(entry.stale),
+		unavailable: new Set(entry.unavailable),
+		tombstone: entry.tombstone,
+		updatedAt: entry.updatedAt,
+		windows: entry.windows
+	};
+};
+/** Throws on a malformed edge so the whole snapshot is discarded. */
+const parseEdges = (value) => {
+	if (!Array.isArray(value)) throw new Error("segment is not an array of edges");
+	return value.map((edge) => {
+		const candidate = edge;
+		if (typeof candidate.key !== "string" || typeof candidate.ref?.entity !== "string" || typeof candidate.ref?.id !== "string") throw new Error("edge is not { key, ref: { entity, id } }");
+		return {
+			key: candidate.key,
+			ref: {
+				entity: candidate.ref.entity,
+				id: candidate.ref.id
+			}
+		};
+	});
+};
+const deserializeStore = (serialized) => ({
+	entities: Object.fromEntries(Object.entries(serialized.entities).map(([key, entry]) => [key, parseEntry(entry)])),
+	connections: Object.fromEntries(Object.entries(serialized.connections ?? {}).map(([key, segments]) => {
+		if (!Array.isArray(segments)) throw new Error("connection is not an array of segments");
+		return [key, segments.map(parseEdges)];
+	}))
+});
+function dehydrate(snapshot, options = {}) {
+	const text = stableStringify(serializeStore(snapshot, options.scope));
+	return exceeds(text, options.maxBytes) ? void 0 : text;
+}
+/**
+* Whether the UTF-8 size of `text` exceeds `maxBytes`. A character is one to
+* three bytes, so most texts are decided from their length alone; only the
+* rest are measured.
+*/
+const exceeds = (text, maxBytes) => {
+	if (maxBytes === void 0) return false;
+	if (text.length > maxBytes) return true;
+	if (text.length * 3 <= maxBytes) return false;
+	return new TextEncoder().encode(text).length > maxBytes;
+};
+/**
+* The store a snapshot text holds, or none when the text is missing,
+* oversized, not this version, for another scope, or malformed. Hydrating the
+* same text twice yields equal stores.
+*/
+const hydrate = (raw, options = {}) => {
+	if (raw === void 0 || raw === null) return Option.none();
+	if (exceeds(raw, options.maxBytes)) return Option.none();
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return Option.none();
+	}
+	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return Option.none();
+	const candidate = parsed;
+	if (candidate.version !== 5) return Option.none();
+	if ((candidate.scope ?? null) !== (options.scope ?? null)) return Option.none();
+	if (candidate.entities === null || typeof candidate.entities !== "object") return Option.none();
+	if (Array.isArray(candidate.entities)) return Option.none();
+	try {
+		return Option.some(deserializeStore(candidate));
+	} catch {
+		return Option.none();
+	}
+};
+/**
+* Brings a snapshot into a store that may already hold entries. `replace`
+* takes the snapshot's entry for every key it has; `preserve-existing` keeps
+* an entry the current store already has (it is at least as fresh as a
+* snapshot taken earlier). Either way, keys only the current store has stay.
+*/
+const mergeStores = (current, snapshot, policy) => Object.keys(snapshot).length === 0 ? current : policy === "replace" ? {
+	...current,
+	...snapshot
+} : {
+	...snapshot,
+	...current
+};
+/** An empty snapshot: the cache as a fresh session has it. */
+const emptySnapshot = {
+	entities: emptyStore,
+	connections: {}
+};
+const RemotePersistence = {
+	/** The snapshot text, or `undefined` when it would exceed `maxBytes`. */
+	dehydrate,
+	/** What a snapshot text holds, or none when it is refused. */
+	hydrate,
+	/**
+	* What to keep of a Model, naming the connections that should survive a
+	* reload. Naming none is the default and is what Remote always did.
+	*/
+	snapshotOf,
+	/** A snapshot's entities brought into a store by policy. */
+	mergeStores,
+	/** The cache as a fresh session has it; what a refused `restore` yields. */
+	emptySnapshot,
+	/**
+	* Writes the snapshot under `key`, or removes the key when the store would
+	* exceed `maxBytes`, so a stale smaller snapshot cannot outlive a larger
+	* store it no longer describes.
+	*/
+	save: (snapshot, options) => Effect.gen(function* () {
+		const kv = yield* KeyValueStore.KeyValueStore;
+		const text = dehydrate(snapshot, options);
+		if (text === void 0) yield* kv.remove(options.key);
+		else yield* kv.set(options.key, text);
+	}),
+	/**
+	* Reads the cache. A missing key yields `emptySnapshot`; anything `hydrate`
+	* refuses yields `emptySnapshot` and removes the key, so the next `restore`
+	* is clean and the planner refetches.
+	*/
+	restore: (options) => Effect.gen(function* () {
+		const kv = yield* KeyValueStore.KeyValueStore;
+		const raw = yield* kv.get(options.key);
+		if (raw === void 0) return emptySnapshot;
+		const restored = hydrate(raw, options);
+		if (Option.isNone(restored)) {
+			yield* kv.remove(options.key);
+			return emptySnapshot;
+		}
+		return restored.value;
+	})
+};
+export { REMOTE_CACHE_VERSION, RemotePersistence };
+
+//# sourceMappingURL=persistence.js.map

package/dist/persistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.js","names":[],"sources":["../src/persistence.ts"],"sourcesContent":["/**\n * Remote cache persistence: a snapshot of the entity store and nothing else.\n * Runtime state (connections' live cursors, optimistic layers, the mutation\n * ledger, gaps, retention roots) is never in a snapshot; it belongs to the\n * session that produced it.\n *\n * The cache is server-derived and disposable: an incompatible, oversized, or\n * corrupt snapshot is discarded (and removed from a `KeyValueStore`) so the\n * planner refetches. `dehydrate`/`hydrate` are the string forms, for SSR and\n * any other transport; `save`/`restore` put them behind Effect's\n * `KeyValueStore`, so the backend (memory, filesystem, SQL, Web Storage) is the\n * application's choice.\n */\nimport { Effect, Option } from 'effect'\nimport { KeyValueStore } from 'effect/persistence'\nimport { type Connection, type Edge } from './connection.js'\nimport { connectionIdentity, type ConnectionIdentity } from './optimistic.js'\nimport { stableStringify } from './query.js'\nimport { emptyStore, type EntityEntry, type EntityStore } from './store.js'\n\n/** Bump when the serialized shape changes; a mismatch discards the cache. */\nexport const REMOTE_CACHE_VERSION = 5\n\n/**\n * What survives a reload: the entity cache, and the connections an application\n * **declared** should come back.\n *\n * Connections are session state by default and stay that way — `snapshotOf`\n * takes none unless asked. What a declared one keeps is its **edges and\n * nothing else**, which is not a simplification but the rule: a connection's\n * boundaries are cursors the server minted, and a cursor may name server state\n * that no longer exists. Restoring one would be claiming to know where the\n * page ends. The shape has nowhere to put a cursor, so that cannot be got\n * wrong later.\n */\nexport interface Snapshot {\n  readonly entities: EntityStore\n  /**\n   * By connection identity: its **segments**, each a run of edges. No\n   * boundaries.\n   *\n   * Segments rather than one flat list, because the gaps between them are\n   * knowledge too. A connection paged from both ends holds a head and a tail\n   * with an unfetched middle; flattening those into one run would claim the\n   * tail's first row follows the head's last, which is a thing the client was\n   * never told.\n   */\n  readonly connections: Readonly<Record<string, ReadonlyArray<ReadonlyArray<Edge>>>>\n}\n\n/**\n * A snapshot of a Model, keeping the entity cache and only the connections\n * named.\n *\n * Naming none — the default — is exactly what Remote did before connections\n * could be kept at all: a disposable, server-derived cache.\n */\nconst snapshotOf = (\n  model: {\n    readonly entities: EntityStore\n    readonly connections: Readonly<Record<string, Connection>>\n  },\n  options: { readonly connections?: ReadonlyArray<ConnectionIdentity> | undefined } = {},\n): Snapshot => ({\n  entities: model.entities,\n  connections: Object.fromEntries(\n    (options.connections ?? []).flatMap(connection => {\n      const identity = connectionIdentity(connection)\n      const held = model.connections[identity]\n      return held === undefined\n        ? []\n        : [[identity, held.segments.map(segment => segment.edges)] as const]\n    }),\n  ),\n})\n\nexport interface SnapshotOptions {\n  /**\n   * Who or what the snapshot is for (a user id, a tenant, a build). A snapshot\n   * taken under another scope is discarded rather than shown to the wrong\n   * reader. Default: unscoped, which only matches unscoped.\n   */\n  readonly scope?: string | undefined\n  /** Snapshots larger than this many bytes are not written and not read. */\n  readonly maxBytes?: number | undefined\n}\n\n/** How a snapshot meets a store that already has entries. */\nexport type MergePolicy = 'replace' | 'preserve-existing'\n\ninterface SerializedEntry {\n  readonly values: Readonly<Record<string, unknown>>\n  readonly present: ReadonlyArray<string>\n  readonly stale: ReadonlyArray<string>\n  readonly unavailable: ReadonlyArray<string>\n  readonly tombstone: boolean\n  readonly updatedAt: number\n  readonly windows: Readonly<Record<string, string>>\n}\n\ninterface SerializedStore {\n  readonly version: number\n  readonly scope: string | null\n  readonly entities: Readonly<Record<string, SerializedEntry>>\n  readonly connections: Readonly<Record<string, ReadonlyArray<ReadonlyArray<Edge>>>>\n}\n\nconst sorted = <T>(values: Iterable<T>): T[] => [...values].sort()\n\n/**\n * The snapshot's data shape. `stableStringify` sorts object keys, and the\n * field sets are sorted here, so equal stores give byte-equal snapshots\n * whatever order they were built in.\n */\nconst serializeStore = (snapshot: Snapshot, scope?: string): SerializedStore => ({\n  version: REMOTE_CACHE_VERSION,\n  scope: scope ?? null,\n  connections: snapshot.connections,\n  entities: Object.fromEntries(\n    Object.entries(snapshot.entities).map(([key, entry]) => [\n      key,\n      {\n        values: entry.values,\n        present: sorted(entry.present),\n        stale: sorted(entry.stale),\n        unavailable: sorted(entry.unavailable),\n        tombstone: entry.tombstone,\n        updatedAt: entry.updatedAt,\n        windows: entry.windows,\n      },\n    ]),\n  ),\n})\n\nconst isStringArray = (value: unknown): value is ReadonlyArray<string> =>\n  Array.isArray(value) && value.every(item => typeof item === 'string')\n\nconst isStringRecord = (value: unknown): value is Readonly<Record<string, string>> =>\n  value !== null &&\n  typeof value === 'object' &&\n  !Array.isArray(value) &&\n  Object.values(value as Record<string, unknown>).every(item => typeof item === 'string')\n\n/** Throws on a malformed entry so the whole snapshot is discarded. */\nconst parseEntry = (value: unknown): EntityEntry => {\n  if (value === null || typeof value !== 'object') throw new Error('entry is not an object')\n  const entry = value as Record<string, unknown>\n  if (entry.values === null || typeof entry.values !== 'object' || Array.isArray(entry.values)) {\n    throw new Error('entry.values is not a record')\n  }\n  if (!isStringArray(entry.present)) throw new Error('entry.present is not a string array')\n  if (!isStringArray(entry.stale)) throw new Error('entry.stale is not a string array')\n  if (!isStringArray(entry.unavailable)) throw new Error('entry.unavailable is not a string array')\n  if (typeof entry.tombstone !== 'boolean') throw new Error('entry.tombstone is not a boolean')\n  if (typeof entry.updatedAt !== 'number') throw new Error('entry.updatedAt is not a number')\n  if (!isStringRecord(entry.windows)) throw new Error('entry.windows is not a string record')\n  return {\n    values: entry.values as Readonly<Record<string, unknown>>,\n    present: new Set(entry.present),\n    stale: new Set(entry.stale),\n    unavailable: new Set(entry.unavailable),\n    tombstone: entry.tombstone,\n    updatedAt: entry.updatedAt,\n    windows: entry.windows,\n  }\n}\n\n/** Throws on a malformed edge so the whole snapshot is discarded. */\nconst parseEdges = (value: unknown): ReadonlyArray<Edge> => {\n  if (!Array.isArray(value)) throw new Error('segment is not an array of edges')\n  return value.map(edge => {\n    const candidate = edge as { key?: unknown; ref?: { entity?: unknown; id?: unknown } }\n    if (\n      typeof candidate.key !== 'string' ||\n      typeof candidate.ref?.entity !== 'string' ||\n      typeof candidate.ref?.id !== 'string'\n    ) {\n      throw new Error('edge is not { key, ref: { entity, id } }')\n    }\n    return { key: candidate.key, ref: { entity: candidate.ref.entity, id: candidate.ref.id } }\n  })\n}\n\nconst deserializeStore = (serialized: SerializedStore): Snapshot => ({\n  entities: Object.fromEntries(\n    Object.entries(serialized.entities).map(([key, entry]) => [key, parseEntry(entry)]),\n  ),\n  connections: Object.fromEntries(\n    Object.entries(serialized.connections ?? {}).map(([key, segments]) => {\n      if (!Array.isArray(segments)) throw new Error('connection is not an array of segments')\n      return [key, segments.map(parseEdges)]\n    }),\n  ),\n})\n\n/**\n * The snapshot text, or `undefined` when it would exceed `maxBytes`. Build the\n * snapshot with `snapshotOf`, which is where the connections that survive are\n * named; runtime state — optimistic layers, live cursors, gaps, the mutation\n * ledger — is never in one.\n */\nfunction dehydrate(\n  snapshot: Snapshot,\n  options?: SnapshotOptions & { readonly maxBytes?: undefined },\n): string\nfunction dehydrate(snapshot: Snapshot, options?: SnapshotOptions): string | undefined\nfunction dehydrate(snapshot: Snapshot, options: SnapshotOptions = {}): string | undefined {\n  const text = stableStringify(serializeStore(snapshot, options.scope))\n  return exceeds(text, options.maxBytes) ? undefined : text\n}\n\n/**\n * Whether the UTF-8 size of `text` exceeds `maxBytes`. A character is one to\n * three bytes, so most texts are decided from their length alone; only the\n * rest are measured.\n */\nconst exceeds = (text: string, maxBytes: number | undefined): boolean => {\n  if (maxBytes === undefined) return false\n  if (text.length > maxBytes) return true\n  if (text.length * 3 <= maxBytes) return false\n  return new TextEncoder().encode(text).length > maxBytes\n}\n\n/**\n * The store a snapshot text holds, or none when the text is missing,\n * oversized, not this version, for another scope, or malformed. Hydrating the\n * same text twice yields equal stores.\n */\nconst hydrate = (\n  raw: string | undefined | null,\n  options: SnapshotOptions = {},\n): Option.Option<Snapshot> => {\n  if (raw === undefined || raw === null) return Option.none()\n  if (exceeds(raw, options.maxBytes)) return Option.none()\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(raw)\n  } catch {\n    return Option.none()\n  }\n  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return Option.none()\n  const candidate = parsed as {\n    readonly version?: unknown\n    readonly scope?: unknown\n    readonly entities?: unknown\n  }\n  if (candidate.version !== REMOTE_CACHE_VERSION) return Option.none()\n  if ((candidate.scope ?? null) !== (options.scope ?? null)) return Option.none()\n  if (candidate.entities === null || typeof candidate.entities !== 'object') return Option.none()\n  if (Array.isArray(candidate.entities)) return Option.none()\n  try {\n    return Option.some(deserializeStore(candidate as SerializedStore))\n  } catch {\n    return Option.none()\n  }\n}\n\n/**\n * Brings a snapshot into a store that may already hold entries. `replace`\n * takes the snapshot's entry for every key it has; `preserve-existing` keeps\n * an entry the current store already has (it is at least as fresh as a\n * snapshot taken earlier). Either way, keys only the current store has stay.\n */\nconst mergeStores = (\n  current: EntityStore,\n  snapshot: EntityStore,\n  policy: MergePolicy,\n): EntityStore =>\n  Object.keys(snapshot).length === 0\n    ? current\n    : policy === 'replace'\n      ? { ...current, ...snapshot }\n      : { ...snapshot, ...current }\n\n/** An empty snapshot: the cache as a fresh session has it. */\nconst emptySnapshot: Snapshot = { entities: emptyStore, connections: {} }\n\nexport const RemotePersistence = {\n  /** The snapshot text, or `undefined` when it would exceed `maxBytes`. */\n  dehydrate,\n  /** What a snapshot text holds, or none when it is refused. */\n  hydrate,\n  /**\n   * What to keep of a Model, naming the connections that should survive a\n   * reload. Naming none is the default and is what Remote always did.\n   */\n  snapshotOf,\n  /** A snapshot's entities brought into a store by policy. */\n  mergeStores,\n  /** The cache as a fresh session has it; what a refused `restore` yields. */\n  emptySnapshot,\n\n  /**\n   * Writes the snapshot under `key`, or removes the key when the store would\n   * exceed `maxBytes`, so a stale smaller snapshot cannot outlive a larger\n   * store it no longer describes.\n   */\n  save: (snapshot: Snapshot, options: { readonly key: string } & SnapshotOptions) =>\n    Effect.gen(function* () {\n      const kv = yield* KeyValueStore.KeyValueStore\n      const text = dehydrate(snapshot, options)\n      if (text === undefined) yield* kv.remove(options.key)\n      else yield* kv.set(options.key, text)\n    }),\n\n  /**\n   * Reads the cache. A missing key yields `emptySnapshot`; anything `hydrate`\n   * refuses yields `emptySnapshot` and removes the key, so the next `restore`\n   * is clean and the planner refetches.\n   */\n  restore: (options: { readonly key: string } & SnapshotOptions) =>\n    Effect.gen(function* () {\n      const kv = yield* KeyValueStore.KeyValueStore\n      const raw = yield* kv.get(options.key)\n      if (raw === undefined) return emptySnapshot\n      const restored = hydrate(raw, options)\n      if (Option.isNone(restored)) {\n        yield* kv.remove(options.key)\n        return emptySnapshot\n      }\n      return restored.value\n    }),\n}\n"],"mappings":"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"}

package/dist/placement-jZdsIpmj.d.ts

@@ -0,0 +1,50 @@
+import { i as Edge, n as Connection } from "./connection-BRyaJy89.js";
+import { r as EntityStore } from "./store-ah2qjcJW.js";
+import { Data } from "effect";
+import { AnyQuery, MemoryOperators } from "foldkit-entity";
+/** Where a row falls in a loaded list. */
+type RowPlace = Data.TaggedEnum<{
+  /** Just before this edge, in this segment. */
+  Before: {
+    readonly segment: number;
+    readonly edge: string;
+  };
+  /** After every edge of this segment, which ends the list. */
+  End: {
+    readonly segment: number;
+  };
+  /** In rows the list has not loaded: past a `Cursor` boundary, or in a gap. */
+  Outside: {};
+  /** Not judged exactly, and why. */
+  Unknown: {
+    readonly reason: string;
+  };
+}>;
+declare const RowPlace: Data.TaggedEnum.Constructor<{
+  readonly _tag: "Before";
+  readonly segment: number;
+  readonly edge: string;
+} | {
+  readonly _tag: "End";
+  readonly segment: number;
+} | {
+  readonly _tag: "Outside";
+} | {
+  readonly _tag: "Unknown";
+  readonly reason: string;
+}>;
+/**
+ * Where the row stored under `key` falls in `connection`, by `body`'s order
+ * for `input` (encoded, as a connection's identity carries it), a call in it
+ * run by `operators`. The row's own edge, if the list holds it, is left out:
+ * placing a row that moved asks where it goes now.
+ */
+declare const placeIn: (store: EntityStore, connection: Connection, body: AnyQuery, input: Readonly<Record<string, unknown>>, key: string, operators: MemoryOperators) => RowPlace;
+/** The connection without the edge of `key`, or the connection itself when it holds none. */
+declare const withoutEdge: (connection: Connection, key: string) => Connection;
+/** The connection with `edge` where `place` says: before an edge, or at a segment's end. */
+declare const withEdge: (connection: Connection, added: Edge, place: Extract<RowPlace, {
+  readonly _tag: 'Before' | 'End';
+}>) => Connection;
+export { withoutEdge as i, placeIn as n, withEdge as r, RowPlace as t };
+//# sourceMappingURL=placement-jZdsIpmj.d.ts.map

package/dist/placement-jZdsIpmj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placement-jZdsIpmj.d.ts","names":[],"sources":["../src/placement.ts"],"mappings":";;;;;KA2BY,WAAW,KAAK;;EAE1B;aAAmB;aAA0B;;;EAE7C;aAAgB;;;EAEhB;;EAEA;aAAoB;;;cAET,UAAQ,KAAA,WAAA;;WARS;WAAuB;;;WAE1B;;;;;WAIG;;;;;;;;cAiCjB,UAAO,OACX,aAAW,YACN,YAAU,MAChB,UAAQ,OACP,SAAS,0BAAwB,aAC7B,WACA,oBACV;;cAyEU,cAAW,YAAgB,YAAU,gBAAgB;;cAYrD,WAAQ,YACP,YAAU,OACf,MAAI,OACJ,QAAQ;WAAqB;OACnC"}

package/dist/placement.d.ts

@@ -0,0 +1,2 @@
+import { i as withoutEdge, n as placeIn, r as withEdge, t as RowPlace } from "./placement-jZdsIpmj.js";
+export { RowPlace, placeIn, withEdge, withoutEdge };

package/dist/placement.js

@@ -0,0 +1,116 @@
+import { entityKey, readField } from "./store.js";
+import { Data, Match, Option, Schema, SchemaAST } from "effect";
+import { Query, compareRows, dependenciesOf } from "foldkit-entity";
+// src/placement.ts
+/**
+* Where one row falls in a loaded list, by the list's own declared order:
+* the decidable half of placing a row instead of fetching the list again.
+*
+* A list is segments of edges between boundaries, and only a `Terminal`
+* boundary says nothing lies beyond it. So a row is placed between two loaded
+* edges, or before a segment's first edge when that segment starts the list,
+* or at its end when it ends it; a row that sorts past a `Cursor` or into a
+* gap belongs to rows the client has not read, and is `Outside`. Anything the
+* client cannot judge exactly (a body it cannot place, a field a row lacks,
+* keys it cannot compare) is `Unknown`, with why, never a guess.
+*
+* Pure: it reads the store and the list it is given.
+*/
+const RowPlace = Data.taggedEnum();
+/**
+* The values a row holds of the fields an order reads, a call's arguments
+* included, or none when it lacks one. An `id` no Selection stored is its key's, when the id is stored as
+* text as a key holds it, so the id tie-break every order ends on does not
+* make such a row unplaceable; a number id is never compared as text.
+*/
+const keysOf = (store, key, id, idIsText, terms) => {
+	const values = Object.create(null);
+	for (const { key: field } of dependenciesOf(...terms).fields) {
+		const stored = readField(store, key, field);
+		const value = field === "id" && Option.isNone(stored) && idIsText ? id : stored;
+		if (Option.isNone(value)) return Option.none();
+		values[field] = value.value;
+	}
+	return Option.some(values);
+};
+/**
+* Where the row stored under `key` falls in `connection`, by `body`'s order
+* for `input` (encoded, as a connection's identity carries it), a call in it
+* run by `operators`. The row's own edge, if the list holds it, is left out:
+* placing a row that moved asks where it goes now.
+*/
+const placeIn = (store, connection, body, input, key, operators) => {
+	const placement = Query.placement(body, input, { operators });
+	if (placement._tag === "NotPlaceable") return RowPlace.Unknown({ reason: placement.reason });
+	const terms = Query.orderFor(body, input);
+	const prefix = `${body.entity.name}:`;
+	const id = key.startsWith(prefix) ? Option.some(key.slice(prefix.length)) : Option.none();
+	const idField = body.entity.fields.id;
+	const idIsText = idField !== void 0 && SchemaAST.isString(Schema.toEncoded(idField.schema).ast);
+	const row = keysOf(store, key, id, idIsText, terms);
+	if (Option.isNone(row)) return RowPlace.Unknown({ reason: `${key} lacks a field the order reads` });
+	/** Negative when the row sorts before the edge; none when the edge cannot be compared. */
+	const against = (edge) => Option.flatMap(keysOf(store, entityKey(edge.ref.entity, edge.ref.id), Option.some(edge.ref.id), idIsText, terms), (values) => {
+		try {
+			return Option.some(compareRows(terms, row.value, values, body.entity.name, {
+				input,
+				operators
+			}));
+		} catch {
+			return Option.none();
+		}
+	});
+	const boundary = RowPlace.Unknown({ reason: `${key} was where its page met rows not loaded` });
+	const { segments } = connection;
+	for (let index = 0; index < segments.length; index++) {
+		const segment = segments[index];
+		const held = segment.edges.findIndex((edge) => edge.key === key);
+		const edges = segment.edges.filter((edge) => edge.key !== key);
+		for (let position = 0; position < edges.length; position++) {
+			const edge = edges[position];
+			const sign = against(edge);
+			if (Option.isNone(sign)) return RowPlace.Unknown({ reason: `${edge.key} lacks a field the order reads` });
+			if (sign.value < 0) {
+				const before = RowPlace.Before({
+					segment: index,
+					edge: edge.key
+				});
+				if (position > 0) return before;
+				return Match.value(segment.start).pipe(Match.tag("Terminal", () => before), Match.orElse(() => held === 0 ? boundary : RowPlace.Outside()));
+			}
+		}
+		if (Match.value(segment.end).pipe(Match.tag("Terminal", () => true), Match.orElse(() => false))) return RowPlace.End({ segment: index });
+		if (held >= 0 && held === segment.edges.length - 1) return boundary;
+	}
+	return RowPlace.Outside();
+};
+/** The connection without the edge of `key`, or the connection itself when it holds none. */
+const withoutEdge = (connection, key) => connection.segments.some((segment) => segment.edges.some((edge) => edge.key === key)) ? {
+	...connection,
+	segments: connection.segments.map((segment) => ({
+		...segment,
+		edges: segment.edges.filter((edge) => edge.key !== key)
+	}))
+} : connection;
+/** The connection with `edge` where `place` says: before an edge, or at a segment's end. */
+const withEdge = (connection, added, place) => ({
+	...connection,
+	segments: connection.segments.map((segment, index) => {
+		if (index !== place.segment) return segment;
+		const at = Match.value(place).pipe(Match.tagsExhaustive({
+			Before: ({ edge }) => segment.edges.findIndex((held) => held.key === edge),
+			End: () => segment.edges.length
+		}));
+		return {
+			...segment,
+			edges: [
+				...segment.edges.slice(0, at),
+				added,
+				...segment.edges.slice(at)
+			]
+		};
+	})
+});
+export { RowPlace, placeIn, withEdge, withoutEdge };
+
+//# sourceMappingURL=placement.js.map

package/dist/placement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"placement.js","names":["Relational"],"sources":["../src/placement.ts"],"sourcesContent":["/**\n * Where one row falls in a loaded list, by the list's own declared order:\n * the decidable half of placing a row instead of fetching the list again.\n *\n * A list is segments of edges between boundaries, and only a `Terminal`\n * boundary says nothing lies beyond it. So a row is placed between two loaded\n * edges, or before a segment's first edge when that segment starts the list,\n * or at its end when it ends it; a row that sorts past a `Cursor` or into a\n * gap belongs to rows the client has not read, and is `Outside`. Anything the\n * client cannot judge exactly (a body it cannot place, a field a row lacks,\n * keys it cannot compare) is `Unknown`, with why, never a guess.\n *\n * Pure: it reads the store and the list it is given.\n */\nimport { Data, Match, Option, Schema, SchemaAST } from 'effect'\nimport {\n  Query as Relational,\n  compareRows,\n  dependenciesOf,\n  type AnyQuery,\n  type MemoryOperators,\n  type OrderTerm,\n} from 'foldkit-entity'\nimport type { Connection, Edge } from './connection.js'\nimport { entityKey, readField, type EntityStore } from './store.js'\n\n/** Where a row falls in a loaded list. */\nexport type RowPlace = Data.TaggedEnum<{\n  /** Just before this edge, in this segment. */\n  Before: { readonly segment: number; readonly edge: string }\n  /** After every edge of this segment, which ends the list. */\n  End: { readonly segment: number }\n  /** In rows the list has not loaded: past a `Cursor` boundary, or in a gap. */\n  Outside: {}\n  /** Not judged exactly, and why. */\n  Unknown: { readonly reason: string }\n}>\nexport const RowPlace = Data.taggedEnum<RowPlace>()\n\n/**\n * The values a row holds of the fields an order reads, a call's arguments\n * included, or none when it lacks one. An `id` no Selection stored is its key's, when the id is stored as\n * text as a key holds it, so the id tie-break every order ends on does not\n * make such a row unplaceable; a number id is never compared as text.\n */\nconst keysOf = (\n  store: EntityStore,\n  key: string,\n  id: Option.Option<string>,\n  idIsText: boolean,\n  terms: ReadonlyArray<OrderTerm>,\n): Option.Option<Readonly<Record<string, unknown>>> => {\n  const values: Record<string, unknown> = Object.create(null)\n  for (const { key: field } of dependenciesOf(...terms).fields) {\n    const stored = readField(store, key, field)\n    const value = field === 'id' && Option.isNone(stored) && idIsText ? id : stored\n    if (Option.isNone(value)) return Option.none()\n    values[field] = value.value\n  }\n  return Option.some(values)\n}\n\n/**\n * Where the row stored under `key` falls in `connection`, by `body`'s order\n * for `input` (encoded, as a connection's identity carries it), a call in it\n * run by `operators`. The row's own edge, if the list holds it, is left out:\n * placing a row that moved asks where it goes now.\n */\nexport const placeIn = (\n  store: EntityStore,\n  connection: Connection,\n  body: AnyQuery,\n  input: Readonly<Record<string, unknown>>,\n  key: string,\n  operators: MemoryOperators,\n): RowPlace => {\n  const placement = Relational.placement(body, input, { operators })\n  if (placement._tag === 'NotPlaceable') return RowPlace.Unknown({ reason: placement.reason })\n  const terms = Relational.orderFor(body, input)\n  // The row is of the body's Entity, so its key is that name, a colon, its id.\n  const prefix = `${body.entity.name}:`\n  const id = key.startsWith(prefix) ? Option.some(key.slice(prefix.length)) : Option.none()\n  const idField = (body.entity.fields as Readonly<Record<string, { readonly schema: Schema.Top }>>)\n    .id\n  const idIsText = idField !== undefined && SchemaAST.isString(Schema.toEncoded(idField.schema).ast)\n  const row = keysOf(store, key, id, idIsText, terms)\n  if (Option.isNone(row)) {\n    return RowPlace.Unknown({ reason: `${key} lacks a field the order reads` })\n  }\n  /** Negative when the row sorts before the edge; none when the edge cannot be compared. */\n  const against = (edge: Edge): Option.Option<number> =>\n    Option.flatMap(\n      keysOf(\n        store,\n        entityKey(edge.ref.entity, edge.ref.id),\n        Option.some(edge.ref.id),\n        idIsText,\n        terms,\n      ),\n      values => {\n        try {\n          return Option.some(\n            compareRows(terms, row.value, values, body.entity.name, { input, operators }),\n          )\n        } catch {\n          return Option.none()\n        }\n      },\n    )\n\n  // A row that was a segment's first or last edge beside a `Cursor` was\n  // itself where its page began or ended: its old keys are gone from the\n  // store, so whether it moved past that boundary cannot be told.\n  const boundary = RowPlace.Unknown({ reason: `${key} was where its page met rows not loaded` })\n  const { segments } = connection\n  for (let index = 0; index < segments.length; index++) {\n    const segment = segments[index]!\n    const held = segment.edges.findIndex(edge => edge.key === key)\n    const edges = segment.edges.filter(edge => edge.key !== key)\n    for (let position = 0; position < edges.length; position++) {\n      const edge = edges[position]!\n      const sign = against(edge)\n      if (Option.isNone(sign)) {\n        return RowPlace.Unknown({ reason: `${edge.key} lacks a field the order reads` })\n      }\n      if (sign.value < 0) {\n        const before = RowPlace.Before({ segment: index, edge: edge.key })\n        if (position > 0) return before\n        // Before this segment's first edge is loaded only when nothing precedes it.\n        return Match.value(segment.start).pipe(\n          Match.tag('Terminal', () => before),\n          Match.orElse(() => (held === 0 ? boundary : RowPlace.Outside())),\n        )\n      }\n    }\n    // After every edge of this segment: its end, if nothing follows; else the\n    // next segment, or rows not loaded.\n    const ends = Match.value(segment.end).pipe(\n      Match.tag('Terminal', () => true),\n      Match.orElse(() => false),\n    )\n    if (ends) return RowPlace.End({ segment: index })\n    if (held >= 0 && held === segment.edges.length - 1) return boundary\n  }\n  return RowPlace.Outside()\n}\n\n/** The connection without the edge of `key`, or the connection itself when it holds none. */\nexport const withoutEdge = (connection: Connection, key: string): Connection =>\n  connection.segments.some(segment => segment.edges.some(edge => edge.key === key))\n    ? {\n        ...connection,\n        segments: connection.segments.map(segment => ({\n          ...segment,\n          edges: segment.edges.filter(edge => edge.key !== key),\n        })),\n      }\n    : connection\n\n/** The connection with `edge` where `place` says: before an edge, or at a segment's end. */\nexport const withEdge = (\n  connection: Connection,\n  added: Edge,\n  place: Extract<RowPlace, { readonly _tag: 'Before' | 'End' }>,\n): Connection => ({\n  ...connection,\n  segments: connection.segments.map((segment, index) => {\n    if (index !== place.segment) return segment\n    const at = Match.value(place).pipe(\n      Match.tagsExhaustive({\n        Before: ({ edge }) => segment.edges.findIndex(held => held.key === edge),\n        End: () => segment.edges.length,\n      }),\n    )\n    return { ...segment, edges: [...segment.edges.slice(0, at), added, ...segment.edges.slice(at)] }\n  }),\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqCA,MAAa,WAAW,KAAK,WAAqB;;;;;;;AAQlD,MAAM,UACJ,OACA,KACA,IACA,UACA,UACqD;CACrD,MAAM,SAAkC,OAAO,OAAO,IAAI;CAC1D,KAAK,MAAM,EAAE,KAAK,WAAW,eAAe,GAAG,KAAK,CAAC,CAAC,QAAQ;EAC5D,MAAM,SAAS,UAAU,OAAO,KAAK,KAAK;EAC1C,MAAM,QAAQ,UAAU,QAAQ,OAAO,OAAO,MAAM,KAAK,WAAW,KAAK;EACzE,IAAI,OAAO,OAAO,KAAK,GAAG,OAAO,OAAO,KAAK;EAC7C,OAAO,SAAS,MAAM;CACxB;CACA,OAAO,OAAO,KAAK,MAAM;AAC3B;;;;;;;AAQA,MAAa,WACX,OACA,YACA,MACA,OACA,KACA,cACa;CACb,MAAM,YAAYA,MAAW,UAAU,MAAM,OAAO,EAAE,UAAU,CAAC;CACjE,IAAI,UAAU,SAAS,gBAAgB,OAAO,SAAS,QAAQ,EAAE,QAAQ,UAAU,OAAO,CAAC;CAC3F,MAAM,QAAQA,MAAW,SAAS,MAAM,KAAK;CAE7C,MAAM,SAAS,GAAG,KAAK,OAAO,KAAK;CACnC,MAAM,KAAK,IAAI,WAAW,MAAM,IAAI,OAAO,KAAK,IAAI,MAAM,OAAO,MAAM,CAAC,IAAI,OAAO,KAAK;CACxF,MAAM,UAAW,KAAK,OAAO,OAC1B;CACH,MAAM,WAAW,YAAY,KAAA,KAAa,UAAU,SAAS,OAAO,UAAU,QAAQ,MAAM,CAAC,CAAC,GAAG;CACjG,MAAM,MAAM,OAAO,OAAO,KAAK,IAAI,UAAU,KAAK;CAClD,IAAI,OAAO,OAAO,GAAG,GACnB,OAAO,SAAS,QAAQ,EAAE,QAAQ,GAAG,IAAI,gCAAgC,CAAC;;CAG5E,MAAM,WAAW,SACf,OAAO,QACL,OACE,OACA,UAAU,KAAK,IAAI,QAAQ,KAAK,IAAI,EAAE,GACtC,OAAO,KAAK,KAAK,IAAI,EAAE,GACvB,UACA,KACF,IACA,WAAU;EACR,IAAI;GACF,OAAO,OAAO,KACZ,YAAY,OAAO,IAAI,OAAO,QAAQ,KAAK,OAAO,MAAM;IAAE;IAAO;GAAU,CAAC,CAC9E;EACF,QAAQ;GACN,OAAO,OAAO,KAAK;EACrB;CACF,CACF;CAKF,MAAM,WAAW,SAAS,QAAQ,EAAE,QAAQ,GAAG,IAAI,yCAAyC,CAAC;CAC7F,MAAM,EAAE,aAAa;CACrB,KAAK,IAAI,QAAQ,GAAG,QAAQ,SAAS,QAAQ,SAAS;EACpD,MAAM,UAAU,SAAS;EACzB,MAAM,OAAO,QAAQ,MAAM,WAAU,SAAQ,KAAK,QAAQ,GAAG;EAC7D,MAAM,QAAQ,QAAQ,MAAM,QAAO,SAAQ,KAAK,QAAQ,GAAG;EAC3D,KAAK,IAAI,WAAW,GAAG,WAAW,MAAM,QAAQ,YAAY;GAC1D,MAAM,OAAO,MAAM;GACnB,MAAM,OAAO,QAAQ,IAAI;GACzB,IAAI,OAAO,OAAO,IAAI,GACpB,OAAO,SAAS,QAAQ,EAAE,QAAQ,GAAG,KAAK,IAAI,gCAAgC,CAAC;GAEjF,IAAI,KAAK,QAAQ,GAAG;IAClB,MAAM,SAAS,SAAS,OAAO;KAAE,SAAS;KAAO,MAAM,KAAK;IAAI,CAAC;IACjE,IAAI,WAAW,GAAG,OAAO;IAEzB,OAAO,MAAM,MAAM,QAAQ,KAAK,CAAC,CAAC,KAChC,MAAM,IAAI,kBAAkB,MAAM,GAClC,MAAM,aAAc,SAAS,IAAI,WAAW,SAAS,QAAQ,CAAE,CACjE;GACF;EACF;EAOA,IAJa,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KACpC,MAAM,IAAI,kBAAkB,IAAI,GAChC,MAAM,aAAa,KAAK,CAEnB,GAAG,OAAO,SAAS,IAAI,EAAE,SAAS,MAAM,CAAC;EAChD,IAAI,QAAQ,KAAK,SAAS,QAAQ,MAAM,SAAS,GAAG,OAAO;CAC7D;CACA,OAAO,SAAS,QAAQ;AAC1B;;AAGA,MAAa,eAAe,YAAwB,QAClD,WAAW,SAAS,MAAK,YAAW,QAAQ,MAAM,MAAK,SAAQ,KAAK,QAAQ,GAAG,CAAC,IAC5E;CACE,GAAG;CACH,UAAU,WAAW,SAAS,KAAI,aAAY;EAC5C,GAAG;EACH,OAAO,QAAQ,MAAM,QAAO,SAAQ,KAAK,QAAQ,GAAG;CACtD,EAAE;AACJ,IACA;;AAGN,MAAa,YACX,YACA,OACA,WACgB;CAChB,GAAG;CACH,UAAU,WAAW,SAAS,KAAK,SAAS,UAAU;EACpD,IAAI,UAAU,MAAM,SAAS,OAAO;EACpC,MAAM,KAAK,MAAM,MAAM,KAAK,CAAC,CAAC,KAC5B,MAAM,eAAe;GACnB,SAAS,EAAE,WAAW,QAAQ,MAAM,WAAU,SAAQ,KAAK,QAAQ,IAAI;GACvE,WAAW,QAAQ,MAAM;EAC3B,CAAC,CACH;EACA,OAAO;GAAE,GAAG;GAAS,OAAO;IAAC,GAAG,QAAQ,MAAM,MAAM,GAAG,EAAE;IAAG;IAAO,GAAG,QAAQ,MAAM,MAAM,EAAE;GAAC;EAAE;CACjG,CAAC;AACH"}

package/dist/plan-D9cftxC_.d.ts

@@ -0,0 +1,35 @@
+import { r as EntityStore } from "./store-ah2qjcJW.js";
+import { a as Requirement } from "./requirement-D57S2LpH.js";
+type Window = NonNullable<Requirement['windows']>[string];
+/** A stable key for a window, so two equal windows compare equal. */
+declare const windowKey: (window: Window) => string;
+interface PlanFreshness {
+  readonly now: number;
+  /** A present entry older than this many milliseconds is refreshed whole. */
+  readonly freshness: number;
+}
+interface PlanOptions {
+  readonly freshness?: PlanFreshness | undefined;
+  /** Plan every requested field, present or not, tombstoned or not. */
+  readonly force?: boolean | undefined;
+}
+/** When present values next go stale, and the requirements of the entities that do. */
+interface Deadline {
+  readonly at: number;
+  readonly due: ReadonlyArray<Requirement>;
+}
+/**
+ * The earliest moment a value `requirements` read, following the relations the
+ * store holds as `plan` does, goes stale under `freshness`, with the
+ * requirements of the entities that go stale then. A field the server settled
+ * without a value ages with its entity too, since `plan` asks for it again once
+ * the entity expires. Nothing when no such field is still fresh: what is
+ * already expired or stale is planned, not awaited, which is what keeps a
+ * timer from firing on what it already fired on. It is the next moment the
+ * plan can change with the clock alone, which the read entry relies on to
+ * reuse its plan until then.
+ */
+declare const deadlineOf: (store: EntityStore, requirements: readonly Requirement[], freshness: PlanFreshness) => Deadline | undefined;
+declare const plan: (store: EntityStore, requirements: readonly Requirement[], options?: PlanOptions) => ReadonlyArray<Requirement>;
+export { plan as a, deadlineOf as i, PlanFreshness as n, windowKey as o, PlanOptions as r, Deadline as t };
+//# sourceMappingURL=plan-D9cftxC_.d.ts.map

package/dist/plan-D9cftxC_.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-D9cftxC_.d.ts","names":[],"sources":["../src/plan.ts"],"mappings":";;KAiBK,SAAS,YAAY;;cAGb,YAAS,QAAY;UAEjB;WACN;;WAEA;;UAGM;WACN,YAAY;;WAEZ;;;UAoBM;WACN;WACA,KAAK,cAAc;;;;;;;;;;;;;cAcjB,aAAU,OACd,aAAW,uBACK,eAAa,WACzB,kBACV;cAgCU,OAAI,OACR,aAAW,uBACK,eAAa,UAC3B,gBACR,cAAc"}

package/dist/plan.d.ts

@@ -0,0 +1,2 @@
+import { a as plan, i as deadlineOf, n as PlanFreshness, o as windowKey, r as PlanOptions, t as Deadline } from "./plan-D9cftxC_.js";
+export { Deadline, PlanFreshness, PlanOptions, deadlineOf, plan, windowKey };

package/dist/plan.js

@@ -0,0 +1,100 @@
+import { Requirement } from "./requirement.js";
+import { targetsOf } from "./relation.js";
+import { entityKey, missingFields, readField } from "./store.js";
+import { stableStringify } from "./query.js";
+// src/plan.ts
+/**
+* The pure requirement planner.
+*
+* A `Requirement` is plain data: which entity fields a Remote projection needs,
+* and through `relations`, which fields of each relation's target. `plan` diffs
+* requirements against the store and returns only the missing fields, grouped
+* and deterministically ordered. A relation whose field is being fetched keeps
+* its nested requirement on the request, so the server resolves the graph in
+* one read; a relation whose refs the store already holds is followed into
+* concrete requirements for the targets. Time enters through `PlanFreshness`,
+* never from ambient state; `force` plans every field.
+*/
+/** A stable key for a window, so two equal windows compare equal. */
+const windowKey = (window) => stableStringify(window);
+const pickFields = (record, fields) => {
+	if (record === void 0) return void 0;
+	const picked = Object.fromEntries(Object.entries(record).filter(([field]) => fields.has(field)));
+	return Object.keys(picked).length === 0 ? void 0 : picked;
+};
+/** The concrete requirements a known relation value contributes for its targets. */
+const followRelation = (value, relation) => targetsOf(value, relation).map((ref) => ({
+	...relation,
+	id: ref.id
+}));
+/**
+* The earliest moment a value `requirements` read, following the relations the
+* store holds as `plan` does, goes stale under `freshness`, with the
+* requirements of the entities that go stale then. A field the server settled
+* without a value ages with its entity too, since `plan` asks for it again once
+* the entity expires. Nothing when no such field is still fresh: what is
+* already expired or stale is planned, not awaited, which is what keeps a
+* timer from firing on what it already fired on. It is the next moment the
+* plan can change with the clock alone, which the read entry relies on to
+* reuse its plan until then.
+*/
+const deadlineOf = (store, requirements, freshness) => {
+	let at;
+	let due = [];
+	const walk = (group) => {
+		const key = entityKey(group.entity, group.id);
+		const entry = store[key];
+		if (entry === void 0 || entry.tombstone) return;
+		if (group.fields.some((field) => entry.present.has(field) && !entry.stale.has(field) || entry.unavailable.has(field))) {
+			const expires = entry.updatedAt + freshness.freshness;
+			if (expires >= freshness.now && Number.isFinite(expires)) {
+				if (at === void 0 || expires < at) {
+					at = expires;
+					due = [group];
+				} else if (expires === at) due.push(group);
+			}
+		}
+		for (const [field, relation] of Object.entries(group.relations ?? {})) {
+			const value = readField(store, key, field);
+			if (value._tag === "Some") for (const next of followRelation(value.value, relation)) walk(next);
+		}
+	};
+	for (const group of Requirement.merge(requirements)) walk(group);
+	return at === void 0 ? void 0 : {
+		at,
+		due: Requirement.merge(due)
+	};
+};
+const plan = (store, requirements, options = {}) => {
+	const { freshness, force = false } = options;
+	const planned = [];
+	const followed = [];
+	for (const group of Requirement.merge(requirements)) {
+		const key = entityKey(group.entity, group.id);
+		const entry = store[key];
+		const expired = freshness !== void 0 && entry !== void 0 && !entry.tombstone && freshness.now - entry.updatedAt > freshness.freshness;
+		const windowKeys = Object.fromEntries(Object.entries(group.windows ?? {}).map(([field, window]) => [field, windowKey(window)]));
+		const missing = force || expired ? group.fields : missingFields(store, key, group.fields, windowKeys);
+		const missingSet = new Set(missing);
+		for (const [field, relation] of Object.entries(group.relations ?? {})) {
+			if (missingSet.has(field)) continue;
+			const value = readField(store, key, field);
+			if (value._tag === "Some") followed.push(...followRelation(value.value, relation));
+		}
+		if (missing.length === 0) continue;
+		const windows = pickFields(group.windows, missingSet);
+		const relations = pickFields(group.relations, missingSet);
+		planned.push({
+			entity: group.entity,
+			id: group.id,
+			fields: missing,
+			...windows === void 0 ? {} : { windows },
+			...relations === void 0 ? {} : { relations }
+		});
+	}
+	const nested = followed.length === 0 ? [] : plan(store, followed, options);
+	return [...Requirement.merge([...planned, ...nested])].sort((a, b) => entityKey(a.entity, a.id) < entityKey(b.entity, b.id) ? -1 : 1);
+};
+export { deadlineOf, plan, windowKey };
+
+//# sourceMappingURL=plan.js.map

package/dist/plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.js","names":[],"sources":["../src/plan.ts"],"sourcesContent":["/**\n * The pure requirement planner.\n *\n * A `Requirement` is plain data: which entity fields a Remote projection needs,\n * and through `relations`, which fields of each relation's target. `plan` diffs\n * requirements against the store and returns only the missing fields, grouped\n * and deterministically ordered. A relation whose field is being fetched keeps\n * its nested requirement on the request, so the server resolves the graph in\n * one read; a relation whose refs the store already holds is followed into\n * concrete requirements for the targets. Time enters through `PlanFreshness`,\n * never from ambient state; `force` plans every field.\n */\nimport { stableStringify } from './query.js'\nimport { targetsOf } from './relation.js'\nimport { Requirement, type RelationRequirement } from './requirement.js'\nimport { entityKey, missingFields, readField, type EntityStore } from './store.js'\n\ntype Window = NonNullable<Requirement['windows']>[string]\n\n/** A stable key for a window, so two equal windows compare equal. */\nexport const windowKey = (window: Window): string => stableStringify(window)\n\nexport interface PlanFreshness {\n  readonly now: number\n  /** A present entry older than this many milliseconds is refreshed whole. */\n  readonly freshness: number\n}\n\nexport interface PlanOptions {\n  readonly freshness?: PlanFreshness | undefined\n  /** Plan every requested field, present or not, tombstoned or not. */\n  readonly force?: boolean | undefined\n}\n\nconst pickFields = <T>(\n  record: Readonly<Record<string, T>> | undefined,\n  fields: ReadonlySet<string>,\n): Readonly<Record<string, T>> | undefined => {\n  if (record === undefined) return undefined\n  const picked = Object.fromEntries(Object.entries(record).filter(([field]) => fields.has(field)))\n  return Object.keys(picked).length === 0 ? undefined : picked\n}\n\n/** The concrete requirements a known relation value contributes for its targets. */\nconst followRelation = (\n  value: unknown,\n  relation: RelationRequirement,\n): ReadonlyArray<Requirement> =>\n  targetsOf(value, relation).map(ref => ({ ...relation, id: ref.id }))\n\n/** When present values next go stale, and the requirements of the entities that do. */\nexport interface Deadline {\n  readonly at: number\n  readonly due: ReadonlyArray<Requirement>\n}\n\n/**\n * The earliest moment a value `requirements` read, following the relations the\n * store holds as `plan` does, goes stale under `freshness`, with the\n * requirements of the entities that go stale then. A field the server settled\n * without a value ages with its entity too, since `plan` asks for it again once\n * the entity expires. Nothing when no such field is still fresh: what is\n * already expired or stale is planned, not awaited, which is what keeps a\n * timer from firing on what it already fired on. It is the next moment the\n * plan can change with the clock alone, which the read entry relies on to\n * reuse its plan until then.\n */\nexport const deadlineOf = (\n  store: EntityStore,\n  requirements: readonly Requirement[],\n  freshness: PlanFreshness,\n): Deadline | undefined => {\n  let at: number | undefined\n  let due: Requirement[] = []\n  const walk = (group: Requirement): void => {\n    const key = entityKey(group.entity, group.id)\n    const entry = store[key]\n    if (entry === undefined || entry.tombstone) return\n    const fresh = group.fields.some(\n      field =>\n        (entry.present.has(field) && !entry.stale.has(field)) || entry.unavailable.has(field),\n    )\n    if (fresh) {\n      const expires = entry.updatedAt + freshness.freshness\n      // An entity dated `Infinity` never ages (see `visibleStore`): no deadline.\n      // At `expires` itself `plan` does not yet fetch it, so it is still awaited.\n      if (expires >= freshness.now && Number.isFinite(expires)) {\n        if (at === undefined || expires < at) {\n          at = expires\n          due = [group]\n        } else if (expires === at) due.push(group)\n      }\n    }\n    for (const [field, relation] of Object.entries(group.relations ?? {})) {\n      const value = readField(store, key, field)\n      if (value._tag === 'Some')\n        for (const next of followRelation(value.value, relation)) walk(next)\n    }\n  }\n  for (const group of Requirement.merge(requirements)) walk(group)\n  return at === undefined ? undefined : { at, due: Requirement.merge(due) }\n}\n\nexport const plan = (\n  store: EntityStore,\n  requirements: readonly Requirement[],\n  options: PlanOptions = {},\n): ReadonlyArray<Requirement> => {\n  const { freshness, force = false } = options\n  const planned: Requirement[] = []\n  const followed: Requirement[] = []\n\n  for (const group of Requirement.merge(requirements)) {\n    const key = entityKey(group.entity, group.id)\n    const entry = store[key]\n    const expired =\n      freshness !== undefined &&\n      entry !== undefined &&\n      !entry.tombstone &&\n      freshness.now - entry.updatedAt > freshness.freshness\n    const windowKeys = Object.fromEntries(\n      Object.entries(group.windows ?? {}).map(([field, window]) => [field, windowKey(window)]),\n    )\n    const missing =\n      force || expired ? group.fields : missingFields(store, key, group.fields, windowKeys)\n    const missingSet = new Set(missing)\n\n    // A relation the store already holds is followed into its targets; one\n    // being fetched rides on the request instead.\n    for (const [field, relation] of Object.entries(group.relations ?? {})) {\n      if (missingSet.has(field)) continue\n      const value = readField(store, key, field)\n      if (value._tag === 'Some') followed.push(...followRelation(value.value, relation))\n    }\n\n    if (missing.length === 0) continue\n    // Only a field being fetched carries its window and its relation.\n    const windows = pickFields(group.windows, missingSet)\n    const relations = pickFields(group.relations, missingSet)\n    planned.push({\n      entity: group.entity,\n      id: group.id,\n      fields: missing,\n      ...(windows === undefined ? {} : { windows }),\n      ...(relations === undefined ? {} : { relations }),\n    })\n  }\n\n  const nested = followed.length === 0 ? [] : plan(store, followed, options)\n  return [...Requirement.merge([...planned, ...nested])].sort((a, b) =>\n    entityKey(a.entity, a.id) < entityKey(b.entity, b.id) ? -1 : 1,\n  )\n}\n"],"mappings":"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"}

package/dist/policy-DsWHmIAq.d.ts

@@ -0,0 +1,42 @@
+import { r as PlanOptions } from "./plan-D9cftxC_.js";
+type RemotePolicy =
+/** Fetch only fields the store lacks (missing, stale, or re-windowed). */
+{
+  readonly _tag: 'CacheFirst';
+} |
+/**
+ * Keep present values visible, read them as `Refreshing`, and refetch an
+ * entry older than `maxAge` milliseconds.
+ */
+{
+  readonly _tag: 'StaleWhileRevalidate';
+  readonly maxAge: number;
+} |
+/** Fetch every selected field regardless of coverage; cached values stay visible meanwhile. */
+{
+  readonly _tag: 'NetworkOnly';
+};
+declare const RemotePolicy: {
+  /** Fetch only what the store lacks. */
+  cacheFirst: {
+    readonly _tag: 'CacheFirst';
+  };
+  /** Keep present values visible, read as `Refreshing`, and refetch an entry older than `maxAge` ms. */
+  staleWhileRevalidate: (options: {
+    readonly maxAge: number;
+  }) => RemotePolicy;
+  /** Fetch every selected field regardless of coverage; cached values stay visible meanwhile. */
+  networkOnly: {
+    readonly _tag: 'NetworkOnly';
+  };
+  /** The planner options a policy compiles to at `now`. */
+  toPlan: (policy: RemotePolicy, now: number) => PlanOptions;
+  /**
+   * Whether a read under this policy may refetch fields the store already
+   * holds, so an observer marks them stale (read as `Refreshing`) while the
+   * request is pending.
+   */
+  refreshes: (policy: RemotePolicy) => boolean;
+};
+export { RemotePolicy as t };
+//# sourceMappingURL=policy-DsWHmIAq.d.ts.map