foldkit-remote 0.20.0 → 0.22.0

package/dist/sse-C7LhdbiQ.d.ts

@@ -0,0 +1,17 @@
+import { n as RemoteJsonClient, r as RemoteRpcClient } from "./client-B055kQuP.js";
+/** What `httpWithLive` needs besides the URL. Mirrors `http`, plus the fetch itself. */
+interface LiveFetchOptions {
+  /** Read per request, so a token that changes reaches the next call. */
+  readonly headers?: (() => Readonly<Record<string, string>>) | undefined;
+  /** Defaults to the global one; pass it to route calls elsewhere in tests. */
+  readonly fetch?: typeof fetch | undefined;
+}
+/** Remote's live stream over fetch: `serveFetch`'s live open as a `Stream`. */
+declare const liveFetch: (url: string, options?: LiveFetchOptions) => RemoteRpcClient['FoldkitRemoteLive'];
+/**
+ * Remote's client over HTTP with live: reads, queries, and mutations as
+ * `http` sends them, live as `liveFetch` streams it, for `clientLayer`.
+ */
+declare const httpWithLive: (url: string, options?: LiveFetchOptions) => RemoteJsonClient;
+export { httpWithLive as n, liveFetch as r, LiveFetchOptions as t };
+//# sourceMappingURL=sse-C7LhdbiQ.d.ts.map

package/dist/sse-C7LhdbiQ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-C7LhdbiQ.d.ts","names":[],"sources":["../src/sse.ts"],"mappings":";;UAuBiB;;WAEN,iBAAiB,SAAS;;WAE1B,eAAe;;;cA6Fb,YAAS,aACR,UAAW,qBAAwB;;;;;cAqDpC,eAAY,aAAe,UAAW,qBAAwB"}

package/dist/sse.d.ts

@@ -0,0 +1,2 @@
+import { n as httpWithLive, r as liveFetch, t as LiveFetchOptions } from "./sse-C7LhdbiQ.js";
+export { LiveFetchOptions, httpWithLive, liveFetch };

package/dist/sse.js

@@ -0,0 +1,127 @@
+import { LiveChange, RemoteLiveError, RemoteLiveRefused, RemoteUnauthenticated } from "./wire.js";
+import { http } from "./json.js";
+import { Effect, Predicate, Schema, Stream } from "effect";
+// src/sse.ts
+/**
+* Remote live over fetch with SSE framing: the other end of
+* `foldkit-remote-server/fetch`'s live open. One `POST` carries the live
+* requirement; the answer is a `text/event-stream` of `LiveChange` frames,
+* one `data:` frame per change, closing when the server has nothing more or
+* failing on a terminal `event: error` frame. Abandoning the stream aborts
+* the request, which interrupts the subscription server-side.
+*
+* `httpWithLive` is this live stream beside `http`'s reads, queries, and
+* mutations, for `Remote.clientLayer`.
+*/
+const decodeChange = Schema.decodeUnknownSync(LiveChange);
+const parseFrame = (text) => {
+	let event = "message";
+	const data = [];
+	for (const line of text.split(/\r\n|\n/)) {
+		if (line.startsWith(":") || line === "") continue;
+		const colon = line.indexOf(":");
+		if (colon < 0) continue;
+		const field = line.slice(0, colon);
+		const value = line.slice(colon + 1).startsWith(" ") ? line.slice(colon + 2) : line.slice(colon + 1);
+		if (field === "event") event = value;
+		else if (field === "data") data.push(value);
+	}
+	return {
+		event,
+		data
+	};
+};
+/** The frames of a body, split liberally: a blank line ends a frame. */
+async function* frames(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) break;
+			buffer += decoder.decode(next.value, { stream: true });
+			for (;;) {
+				const found = /(?:\r\n|\n){2}/.exec(buffer);
+				if (found === null) break;
+				yield parseFrame(buffer.slice(0, found.index));
+				buffer = buffer.slice(found.index + found[0].length);
+			}
+		}
+		buffer += decoder.decode();
+		if (buffer.trim() !== "") yield parseFrame(buffer);
+	} finally {
+		await reader.cancel().catch(() => {});
+		reader.releaseLock();
+	}
+}
+/** The wire changes of a live body: data frames decoded, error frames failed. */
+async function* changes(body) {
+	for await (const frame of frames(body)) {
+		if (frame.data.length === 0) continue;
+		const text = frame.data.join("\n");
+		if (frame.event === "error") {
+			const said = JSON.parse(text);
+			const message = Predicate.isObject(said) && typeof said.message === "string" ? said.message : text;
+			if (Predicate.isObject(said) && Predicate.isObject(said.unauthenticated)) {
+				const reason = said.unauthenticated.reason;
+				throw new RemoteUnauthenticated({
+					message,
+					...typeof reason === "string" ? { reason } : {}
+				});
+			}
+			if (Predicate.isObject(said) && said.refused === true) throw new RemoteLiveRefused({ message });
+			throw new RemoteLiveError({ message });
+		}
+		yield decodeChange(JSON.parse(text));
+	}
+}
+const liveError = (error) => error instanceof RemoteLiveError || error instanceof RemoteLiveRefused || error instanceof RemoteUnauthenticated ? error : new RemoteLiveError({ message: error instanceof Error ? error.message : String(error) });
+/** Remote's live stream over fetch: `serveFetch`'s live open as a `Stream`. */
+const liveFetch = (url, options = {}) => (payload) => Stream.unwrap(Effect.gen(function* () {
+	const via = options.fetch ?? fetch;
+	const controller = yield* Effect.acquireRelease(Effect.sync(() => new AbortController()), (open) => Effect.sync(() => open.abort()));
+	const response = yield* Effect.tryPromise({
+		try: () => via(url, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				...options.headers?.()
+			},
+			body: JSON.stringify({
+				operation: "live",
+				payload
+			}),
+			signal: controller.signal
+		}),
+		catch: liveError
+	});
+	if (!response.ok) {
+		const answered = yield* Effect.tryPromise({
+			try: () => response.json().catch(() => null),
+			catch: liveError
+		});
+		const message = Predicate.isObject(answered) && "error" in answered ? String(answered.error) : `HTTP ${response.status} ${response.statusText}`;
+		if (response.status === 401) {
+			const said = Predicate.isObject(answered) && Predicate.isObject(answered.unauthenticated) ? answered.unauthenticated.reason : void 0;
+			return yield* new RemoteUnauthenticated({
+				message,
+				...typeof said === "string" ? { reason: said } : {}
+			});
+		}
+		return yield* new RemoteLiveError({ message });
+	}
+	if (response.body === null) return yield* new RemoteLiveError({ message: "The server answered live with no body" });
+	return Stream.fromAsyncIterable(changes(response.body), liveError);
+}));
+/**
+* Remote's client over HTTP with live: reads, queries, and mutations as
+* `http` sends them, live as `liveFetch` streams it, for `clientLayer`.
+*/
+const httpWithLive = (url, options = {}) => ({
+	...http(url, options),
+	FoldkitRemoteLive: liveFetch(url, options)
+});
+export { httpWithLive, liveFetch };
+
+//# sourceMappingURL=sse.js.map

package/dist/sse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.js","names":[],"sources":["../src/sse.ts"],"sourcesContent":["/**\n * Remote live over fetch with SSE framing: the other end of\n * `foldkit-remote-server/fetch`'s live open. One `POST` carries the live\n * requirement; the answer is a `text/event-stream` of `LiveChange` frames,\n * one `data:` frame per change, closing when the server has nothing more or\n * failing on a terminal `event: error` frame. Abandoning the stream aborts\n * the request, which interrupts the subscription server-side.\n *\n * `httpWithLive` is this live stream beside `http`'s reads, queries, and\n * mutations, for `Remote.clientLayer`.\n */\nimport { Effect, Predicate, Schema, Stream } from 'effect'\nimport type { RemoteJsonClient, RemoteRpcClient } from './client.js'\nimport { http } from './json.js'\nimport {\n  LiveChange,\n  RemoteLiveError,\n  RemoteLiveRefused,\n  RemoteUnauthenticated,\n  type LiveRequirement,\n} from './wire.js'\n\n/** What `httpWithLive` needs besides the URL. Mirrors `http`, plus the fetch itself. */\nexport interface LiveFetchOptions {\n  /** Read per request, so a token that changes reaches the next call. */\n  readonly headers?: (() => Readonly<Record<string, string>>) | undefined\n  /** Defaults to the global one; pass it to route calls elsewhere in tests. */\n  readonly fetch?: typeof fetch | undefined\n}\n\nconst decodeChange = Schema.decodeUnknownSync(LiveChange)\n\n/**\n * One SSE frame: its event (default `message`) and its data lines. Comment\n * and other lines decide nothing and are left out rather than kept.\n */\ninterface Frame {\n  readonly event: string\n  readonly data: ReadonlyArray<string>\n}\n\nconst parseFrame = (text: string): Frame => {\n  let event = 'message'\n  const data: string[] = []\n  for (const line of text.split(/\\r\\n|\\n/)) {\n    if (line.startsWith(':') || line === '') continue\n    const colon = line.indexOf(':')\n    if (colon < 0) continue\n    const field = line.slice(0, colon)\n    const value = line.slice(colon + 1).startsWith(' ')\n      ? line.slice(colon + 2)\n      : line.slice(colon + 1)\n    if (field === 'event') event = value\n    else if (field === 'data') data.push(value)\n  }\n  return { event, data }\n}\n\n/** The frames of a body, split liberally: a blank line ends a frame. */\nasync function* frames(body: ReadableStream<Uint8Array>): AsyncGenerator<Frame> {\n  const reader = body.getReader()\n  const decoder = new TextDecoder()\n  let buffer = ''\n  try {\n    for (;;) {\n      const next = await reader.read()\n      if (next.done) break\n      buffer += decoder.decode(next.value, { stream: true })\n      for (;;) {\n        const found = /(?:\\r\\n|\\n){2}/.exec(buffer)\n        if (found === null) break\n        yield parseFrame(buffer.slice(0, found.index))\n        buffer = buffer.slice(found.index + found[0].length)\n      }\n    }\n    buffer += decoder.decode()\n    if (buffer.trim() !== '') yield parseFrame(buffer)\n  } finally {\n    await reader.cancel().catch(() => {})\n    reader.releaseLock()\n  }\n}\n\n/** The wire changes of a live body: data frames decoded, error frames failed. */\nasync function* changes(\n  body: ReadableStream<Uint8Array>,\n): AsyncGenerator<Schema.Schema.Type<typeof LiveChange>> {\n  for await (const frame of frames(body)) {\n    if (frame.data.length === 0) continue\n    const text = frame.data.join('\\n')\n    if (frame.event === 'error') {\n      const said: unknown = JSON.parse(text)\n      const message =\n        Predicate.isObject(said) && typeof said.message === 'string' ? said.message : text\n      // A stream ended because who it serves could no longer be told says so.\n      if (Predicate.isObject(said) && Predicate.isObject(said.unauthenticated)) {\n        const reason = said.unauthenticated.reason\n        throw new RemoteUnauthenticated({\n          message,\n          ...(typeof reason === 'string' ? { reason } : {}),\n        })\n      }\n      // Refused for what it asks: opening it again is refused again.\n      if (Predicate.isObject(said) && said.refused === true) {\n        throw new RemoteLiveRefused({ message })\n      }\n      throw new RemoteLiveError({ message })\n    }\n    yield decodeChange(JSON.parse(text))\n  }\n}\n\nconst liveError = (error: unknown): RemoteLiveError | RemoteLiveRefused | RemoteUnauthenticated =>\n  error instanceof RemoteLiveError ||\n  error instanceof RemoteLiveRefused ||\n  error instanceof RemoteUnauthenticated\n    ? error\n    : new RemoteLiveError({ message: error instanceof Error ? error.message : String(error) })\n\n/** Remote's live stream over fetch: `serveFetch`'s live open as a `Stream`. */\nexport const liveFetch =\n  (url: string, options: LiveFetchOptions = {}): RemoteRpcClient['FoldkitRemoteLive'] =>\n  (payload: Schema.Schema.Type<typeof LiveRequirement>) =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const via = options.fetch ?? fetch\n        const controller = yield* Effect.acquireRelease(\n          Effect.sync(() => new AbortController()),\n          open => Effect.sync(() => open.abort()),\n        )\n        const response = yield* Effect.tryPromise({\n          try: () =>\n            via(url, {\n              method: 'POST',\n              headers: { 'content-type': 'application/json', ...options.headers?.() },\n              body: JSON.stringify({ operation: 'live', payload }),\n              signal: controller.signal,\n            }),\n          catch: liveError,\n        })\n        if (!response.ok) {\n          // A body that is not an answer still answers: null stands in for it.\n          const answered = yield* Effect.tryPromise({\n            try: () => response.json().catch(() => null) as Promise<unknown>,\n            catch: liveError,\n          })\n          const message =\n            Predicate.isObject(answered) && 'error' in answered\n              ? String(answered.error)\n              : `HTTP ${response.status} ${response.statusText}`\n          if (response.status === 401) {\n            // `serveFetch` says why under `unauthenticated`; middleware may say nothing.\n            const said =\n              Predicate.isObject(answered) && Predicate.isObject(answered.unauthenticated)\n                ? answered.unauthenticated.reason\n                : undefined\n            return yield* new RemoteUnauthenticated({\n              message,\n              ...(typeof said === 'string' ? { reason: said } : {}),\n            })\n          }\n          return yield* new RemoteLiveError({ message })\n        }\n        if (response.body === null) {\n          return yield* new RemoteLiveError({ message: 'The server answered live with no body' })\n        }\n        return Stream.fromAsyncIterable(changes(response.body), liveError)\n      }),\n    )\n\n/**\n * Remote's client over HTTP with live: reads, queries, and mutations as\n * `http` sends them, live as `liveFetch` streams it, for `clientLayer`.\n */\nexport const httpWithLive = (url: string, options: LiveFetchOptions = {}): RemoteJsonClient => ({\n  ...http(url, options),\n  FoldkitRemoteLive: liveFetch(url, options),\n})\n"],"mappings":"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"}

package/dist/store-ah2qjcJW.d.ts

@@ -0,0 +1,100 @@
+import { Option } from "effect";
+type EntityKey = string;
+interface EntityEntry {
+  readonly values: Readonly<Record<string, unknown>>;
+  readonly present: ReadonlySet<string>;
+  /**
+   * Present fields whose value may be outdated (revalidation needed). On a
+   * tombstone, the fields it is being asked about again (`askAgain`).
+   */
+  readonly stale: ReadonlySet<string>;
+  /**
+   * Fields the server settled without a value: asked for, and answered without
+   * them, whatever the reason. Not planned again until a refresh asks; a later
+   * write of the field clears it.
+   */
+  readonly unavailable: ReadonlySet<string>;
+  /** The entity is known to be absent; a later write clears this. */
+  readonly tombstone: boolean;
+  /** Injected clock reading of the last write; never read from ambient state. */
+  readonly updatedAt: number;
+  /**
+   * The canonical window each present field was fetched with (`""` for none).
+   * A later request with a *known, different* window is planned as missing.
+   */
+  readonly windows: Readonly<Record<string, string>>;
+}
+type EntityStore = Readonly<Record<EntityKey, EntityEntry>>;
+/** The separator keeps an untrusted id from colliding with a prototype key. */
+declare const entityKey: (entity: string, id: string) => EntityKey;
+declare const emptyStore: EntityStore;
+interface EntityWrite {
+  readonly key: EntityKey;
+  readonly values: Readonly<Record<string, unknown>>;
+  /** The canonical window each written relation field was fetched with. */
+  readonly windows?: Readonly<Record<string, string>> | undefined;
+  /** When this write dates the entity, instead of the batch's `now`. */
+  readonly updatedAt?: number | undefined;
+}
+/**
+ * Merges known values into many entities, copying the store once. Every
+ * written field becomes present and non-stale; a tombstone is cleared because
+ * the entity is evidently not absent.
+ */
+declare const writeEntities: (store: EntityStore, writes: ReadonlyArray<EntityWrite>, now?: number) => EntityStore;
+/** `writeEntities` for one entity. */
+declare const writeEntity: (store: EntityStore, key: EntityKey, values: Readonly<Record<string, unknown>>, now?: number, windows?: Readonly<Record<string, string>>) => EntityStore;
+/**
+ * Marks present fields stale (`true`) or ends their staleness (`false`) across
+ * many entities, copying the store once. A field never present stays missing;
+ * an unknown entity is left alone.
+ */
+declare const setStale: (store: EntityStore, marks: ReadonlyArray<readonly [key: EntityKey, fields: Iterable<string>]>, stale: boolean) => EntityStore;
+/** Marks present fields stale; fields that were never present stay missing. */
+declare const markStale: (store: EntityStore, key: EntityKey, fields: Iterable<string>) => EntityStore;
+/** Ends a refresh that did not land: the fields are present again as they were. */
+declare const clearStale: (store: EntityStore, key: EntityKey, fields: Iterable<string>) => EntityStore;
+/**
+ * Records fields the server settled without a value. A present field is left
+ * as it is: the answer that settled it was not about the value it holds.
+ * `false` forgets the marks, which is how a refresh asks again.
+ */
+declare const setUnavailable: (store: EntityStore, marks: ReadonlyArray<readonly [key: EntityKey, fields: Iterable<string>]>, unavailable: boolean) => EntityStore;
+/** Whether the server settled this field without a value, and nothing has written it since. */
+declare const isFieldUnavailable: (store: EntityStore, key: EntityKey, field: string) => boolean;
+/**
+ * Records that the entity is known to be absent, so it is not refetched. On a
+ * tombstone being asked about again, the answer: still absent, so the asking ends.
+ */
+declare const tombstone: (store: EntityStore, key: EntityKey) => EntityStore;
+/**
+ * Asks about tombstoned entities again: each stays absent, so a list keeps
+ * hiding it and a read of it keeps `NotFound`, while `missingFields` plans the
+ * fields asked for. A write clears the tombstone; `tombstone` ends the asking.
+ * An entity that is not a tombstone is left alone.
+ */
+declare const askAgain: (store: EntityStore, marks: ReadonlyArray<readonly [key: EntityKey, fields: Iterable<string>]>) => EntityStore;
+/** Forgets everything known about the entity, including a tombstone. */
+declare const remove: (store: EntityStore, key: EntityKey) => EntityStore;
+declare const entry: (store: EntityStore, key: EntityKey) => Option.Option<EntityEntry>;
+declare const isTombstone: (store: EntityStore, key: EntityKey) => boolean;
+/** A field is known only if it is present and not stale. */
+declare const hasField: (store: EntityStore, key: EntityKey, field: string) => boolean;
+/** A present field whose value may be outdated; absent fields are not stale. */
+declare const isFieldStale: (store: EntityStore, key: EntityKey, field: string) => boolean;
+/**
+ * Reads a present field, stale or not. Absence and a tombstone both yield
+ * `Option.none()`; a present `undefined`/`null` yields `Option.some`.
+ */
+declare const readField: (store: EntityStore, key: EntityKey, field: string) => Option.Option<unknown>;
+/**
+ * The fields the planner must fetch. A tombstone makes every field known
+ * (absent), so it returns only what it is asked about again, and a
+ * field the server settled without a value is known the same way. A
+ * requested window that differs from the one a field was fetched with also
+ * marks it missing, but only when the stored window is known (never `""`), so a
+ * writer that does not record windows cannot cause a refetch loop.
+ */
+declare const missingFields: (store: EntityStore, key: EntityKey, fields: Iterable<string>, windows?: Readonly<Record<string, string>>) => ReadonlyArray<string>;
+export { writeEntity as S, remove as _, askAgain as a, tombstone as b, entityKey as c, isFieldStale as d, isFieldUnavailable as f, readField as g, missingFields as h, EntityWrite as i, entry as l, markStale as m, EntityKey as n, clearStale as o, isTombstone as p, EntityStore as r, emptyStore as s, EntityEntry as t, hasField as u, setStale as v, writeEntities as x, setUnavailable as y };
+//# sourceMappingURL=store-ah2qjcJW.d.ts.map

package/dist/store-ah2qjcJW.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-ah2qjcJW.d.ts","names":[],"sources":["../src/store.ts"],"mappings":";KAaY;UAEK;WACN,QAAQ,SAAS;WACjB,SAAS;;;;;WAKT,OAAO;;;;;;WAMP,aAAa;;WAEb;;WAEA;;;;;WAKA,SAAS,SAAS;;KAGjB,cAAc,SAAS,OAAO,WAAW;;cAGxC,YAAS,gBAAkB,eAAe;cAY1C,YAAY;UAiDR;WACN,KAAK;WACL,QAAQ,SAAS;;WAEjB,UAAU,SAAS;;WAEnB;;;;;;;cAQE,gBAAa,OACjB,aAAW,QACV,cAAc,cAAY,iBAEjC;;cAeU,cAAW,OACf,aAAW,KACb,WAAS,QACN,SAAS,0BAAwB,cAAA,UAE/B,SAAS,4BAClB;;;;;;cAOU,WAAQ,OACZ,aAAW,OACX,wBAAwB,KAAK,WAAW,QAAQ,oBAAkB,mBAExE;;cAoBU,YAAS,OACb,aAAW,KACb,WAAS,QACN,qBACP;;cAGU,aAAU,OACd,aAAW,KACb,WAAS,QACN,qBACP;;;;;;cAOU,iBAAc,OAClB,aAAW,OACX,wBAAwB,KAAK,WAAW,QAAQ,oBAAkB,yBAExE;;cAmBU,qBAAkB,OAAW,aAAW,KAAO,WAAS;;;;;cASxD,YAAS,OAAW,aAAW,KAAO,cAAY;;;;;;;cAmBlD,WAAQ,OACZ,aAAW,OACX,wBAAwB,KAAK,WAAW,QAAQ,uBACtD;;cAcU,SAAM,OAAW,aAAW,KAAO,cAAY;cAO/C,QAAK,OAAW,aAAW,KAAO,cAAY,OAAO,OAAO;cAK5D,cAAW,OAAW,aAAW,KAAO;;cAIxC,WAAQ,OAAW,aAAW,KAAO,WAAS;;cAQ9C,eAAY,OAAW,aAAW,KAAO,WAAS;;;;;cASlD,YAAS,OACb,aAAW,KACb,WAAS,kBAEb,OAAO;;;;;;;;;cAcG,gBAAa,OACjB,aAAW,KACb,WAAS,QACN,kBAAgB,UACd,SAAS,4BAClB"}

package/dist/store.d.ts

@@ -0,0 +1,2 @@
+import { S as writeEntity, _ as remove, a as askAgain, b as tombstone, c as entityKey, d as isFieldStale, f as isFieldUnavailable, g as readField, h as missingFields, i as EntityWrite, l as entry, m as markStale, n as EntityKey, o as clearStale, p as isTombstone, r as EntityStore, s as emptyStore, t as EntityEntry, u as hasField, v as setStale, x as writeEntities, y as setUnavailable } from "./store-ah2qjcJW.js";
+export { EntityEntry, EntityKey, EntityStore, EntityWrite, askAgain, clearStale, emptyStore, entityKey, entry, hasField, isFieldStale, isFieldUnavailable, isTombstone, markStale, missingFields, readField, remove, setStale, setUnavailable, tombstone, writeEntities, writeEntity };

package/dist/store.js

@@ -0,0 +1,218 @@
+import { own, put } from "./record.js";
+import { sameData } from "./data.js";
+import "./relation.js";
+import { Option } from "effect";
+// src/store.ts
+/**
+* The pure entity store: values, per-field presence, staleness, and tombstones.
+*
+* Presence is tracked **separately** from values, so `undefined`/`null`/absent/
+* stale/not-found are distinct states and a missing field is never inferred from
+* `value === undefined`. Nothing here performs I/O or mutates its input; an
+* operation that changes nothing returns the store it was given.
+*/
+/** The separator keeps an untrusted id from colliding with a prototype key. */
+const entityKey = (entity, id) => `${entity}:${id}`;
+const emptyEntry = {
+	values: {},
+	present: /* @__PURE__ */ new Set(),
+	stale: /* @__PURE__ */ new Set(),
+	unavailable: /* @__PURE__ */ new Set(),
+	tombstone: false,
+	updatedAt: 0,
+	windows: {}
+};
+const emptyStore = {};
+const replace = (store, key, entry) => ({
+	...store,
+	[key]: entry
+});
+const written = (previous, values, now, windows) => {
+	const present = new Set(previous.present);
+	const stale = new Set(previous.stale);
+	const unavailable = new Set(previous.unavailable);
+	const nextWindows = { ...previous.windows };
+	for (const field of Object.keys(values)) {
+		present.add(field);
+		stale.delete(field);
+		unavailable.delete(field);
+		const requested = own(windows, field);
+		if (requested !== void 0 && requested !== "") put(nextWindows, field, requested);
+		else delete nextWindows[field];
+		if (!field.includes("@")) {
+			for (const held of present) if (held.startsWith(`${field}@`) && !(held in values)) stale.add(held);
+		}
+	}
+	return {
+		values: Object.keys(values).every((field) => Object.hasOwn(previous.values, field) && sameData(previous.values[field], values[field])) ? previous.values : {
+			...previous.values,
+			...values
+		},
+		present,
+		stale,
+		unavailable,
+		tombstone: false,
+		updatedAt: now,
+		windows: nextWindows
+	};
+};
+/**
+* Merges known values into many entities, copying the store once. Every
+* written field becomes present and non-stale; a tombstone is cleared because
+* the entity is evidently not absent.
+*/
+const writeEntities = (store, writes, now = 0) => {
+	if (writes.length === 0) return store;
+	const next = { ...store };
+	for (const write of writes) next[write.key] = written(next[write.key] ?? emptyEntry, write.values, write.updatedAt ?? now, write.windows);
+	return next;
+};
+/** `writeEntities` for one entity. */
+const writeEntity = (store, key, values, now = 0, windows) => writeEntities(store, [{
+	key,
+	values,
+	windows
+}], now);
+/**
+* Marks present fields stale (`true`) or ends their staleness (`false`) across
+* many entities, copying the store once. A field never present stays missing;
+* an unknown entity is left alone.
+*/
+const setStale = (store, marks, stale) => {
+	let next;
+	for (const [key, fields] of marks) {
+		const previous = (next ?? store)[key];
+		if (previous === void 0) continue;
+		const staleFields = new Set(previous.stale);
+		for (const field of fields) if (stale) {
+			if (previous.present.has(field)) staleFields.add(field);
+		} else staleFields.delete(field);
+		if (staleFields.size === previous.stale.size) continue;
+		next ??= { ...store };
+		next[key] = {
+			...previous,
+			stale: staleFields
+		};
+	}
+	return next ?? store;
+};
+/** Marks present fields stale; fields that were never present stay missing. */
+const markStale = (store, key, fields) => setStale(store, [[key, fields]], true);
+/** Ends a refresh that did not land: the fields are present again as they were. */
+const clearStale = (store, key, fields) => setStale(store, [[key, fields]], false);
+/**
+* Records fields the server settled without a value. A present field is left
+* as it is: the answer that settled it was not about the value it holds.
+* `false` forgets the marks, which is how a refresh asks again.
+*/
+const setUnavailable = (store, marks, unavailable) => {
+	let next;
+	for (const [key, fields] of marks) {
+		const previous = (next ?? store)[key] ?? emptyEntry;
+		if (previous.tombstone) continue;
+		const marked = new Set(previous.unavailable);
+		for (const field of fields) if (unavailable) {
+			if (!previous.present.has(field)) marked.add(field);
+		} else marked.delete(field);
+		if (marked.size === previous.unavailable.size) continue;
+		next ??= { ...store };
+		next[key] = {
+			...previous,
+			unavailable: marked
+		};
+	}
+	return next ?? store;
+};
+/** Whether the server settled this field without a value, and nothing has written it since. */
+const isFieldUnavailable = (store, key, field) => {
+	const value = store[key];
+	return value !== void 0 && !value.tombstone && value.unavailable.has(field);
+};
+/**
+* Records that the entity is known to be absent, so it is not refetched. On a
+* tombstone being asked about again, the answer: still absent, so the asking ends.
+*/
+const tombstone = (store, key) => isTombstone(store, key) && store[key].stale.size === 0 ? store : replace(store, key, {
+	values: {},
+	present: /* @__PURE__ */ new Set(),
+	stale: /* @__PURE__ */ new Set(),
+	unavailable: /* @__PURE__ */ new Set(),
+	tombstone: true,
+	updatedAt: 0,
+	windows: {}
+});
+/**
+* Asks about tombstoned entities again: each stays absent, so a list keeps
+* hiding it and a read of it keeps `NotFound`, while `missingFields` plans the
+* fields asked for. A write clears the tombstone; `tombstone` ends the asking.
+* An entity that is not a tombstone is left alone.
+*/
+const askAgain = (store, marks) => {
+	let next;
+	for (const [key, fields] of marks) {
+		const previous = (next ?? store)[key];
+		if (previous === void 0 || !previous.tombstone) continue;
+		const asked = /* @__PURE__ */ new Set([...previous.stale, ...fields]);
+		if (asked.size === previous.stale.size) continue;
+		next ??= { ...store };
+		next[key] = {
+			...previous,
+			stale: asked
+		};
+	}
+	return next ?? store;
+};
+/** Forgets everything known about the entity, including a tombstone. */
+const remove = (store, key) => {
+	if (store[key] === void 0) return store;
+	const next = { ...store };
+	delete next[key];
+	return next;
+};
+const entry = (store, key) => {
+	const value = store[key];
+	return value === void 0 ? Option.none() : Option.some(value);
+};
+const isTombstone = (store, key) => store[key]?.tombstone === true;
+/** A field is known only if it is present and not stale. */
+const hasField = (store, key, field) => {
+	const value = store[key];
+	return value !== void 0 && !value.tombstone && value.present.has(field) && !value.stale.has(field);
+};
+/** A present field whose value may be outdated; absent fields are not stale. */
+const isFieldStale = (store, key, field) => {
+	const value = store[key];
+	return value !== void 0 && !value.tombstone && value.stale.has(field);
+};
+/**
+* Reads a present field, stale or not. Absence and a tombstone both yield
+* `Option.none()`; a present `undefined`/`null` yields `Option.some`.
+*/
+const readField = (store, key, field) => {
+	const value = store[key];
+	if (value === void 0 || value.tombstone || !value.present.has(field)) return Option.none();
+	return Option.some(value.values[field]);
+};
+/**
+* The fields the planner must fetch. A tombstone makes every field known
+* (absent), so it returns only what it is asked about again, and a
+* field the server settled without a value is known the same way. A
+* requested window that differs from the one a field was fetched with also
+* marks it missing, but only when the stored window is known (never `""`), so a
+* writer that does not record windows cannot cause a refetch loop.
+*/
+const missingFields = (store, key, fields, windows) => {
+	const value = store[key];
+	if (value !== void 0 && value.tombstone) return [...fields].filter((f) => value.stale.has(f));
+	return [...fields].filter((field) => {
+		if (value === void 0) return true;
+		if (!value.present.has(field)) return !value.unavailable.has(field);
+		if (value.stale.has(field)) return true;
+		const requested = own(windows, field);
+		const stored = own(value.windows, field);
+		return requested !== void 0 && stored !== void 0 && stored !== "" && stored !== requested;
+	});
+};
+export { askAgain, clearStale, emptyStore, entityKey, entry, hasField, isFieldStale, isFieldUnavailable, isTombstone, markStale, missingFields, readField, remove, setStale, setUnavailable, tombstone, writeEntities, writeEntity };
+
+//# sourceMappingURL=store.js.map

package/dist/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":[],"sources":["../src/store.ts"],"sourcesContent":["/**\n * The pure entity store: values, per-field presence, staleness, and tombstones.\n *\n * Presence is tracked **separately** from values, so `undefined`/`null`/absent/\n * stale/not-found are distinct states and a missing field is never inferred from\n * `value === undefined`. Nothing here performs I/O or mutates its input; an\n * operation that changes nothing returns the store it was given.\n */\nimport { Option } from 'effect'\nimport { sameData } from './data.js'\nimport { own, put } from './record.js'\nimport { RELATION_ALIAS } from './relation.js'\n\nexport type EntityKey = string\n\nexport interface EntityEntry {\n  readonly values: Readonly<Record<string, unknown>>\n  readonly present: ReadonlySet<string>\n  /**\n   * Present fields whose value may be outdated (revalidation needed). On a\n   * tombstone, the fields it is being asked about again (`askAgain`).\n   */\n  readonly stale: ReadonlySet<string>\n  /**\n   * Fields the server settled without a value: asked for, and answered without\n   * them, whatever the reason. Not planned again until a refresh asks; a later\n   * write of the field clears it.\n   */\n  readonly unavailable: ReadonlySet<string>\n  /** The entity is known to be absent; a later write clears this. */\n  readonly tombstone: boolean\n  /** Injected clock reading of the last write; never read from ambient state. */\n  readonly updatedAt: number\n  /**\n   * The canonical window each present field was fetched with (`\"\"` for none).\n   * A later request with a *known, different* window is planned as missing.\n   */\n  readonly windows: Readonly<Record<string, string>>\n}\n\nexport type EntityStore = Readonly<Record<EntityKey, EntityEntry>>\n\n/** The separator keeps an untrusted id from colliding with a prototype key. */\nexport const entityKey = (entity: string, id: string): EntityKey => `${entity}:${id}`\n\nconst emptyEntry: EntityEntry = {\n  values: {},\n  present: new Set(),\n  stale: new Set(),\n  unavailable: new Set(),\n  tombstone: false,\n  updatedAt: 0,\n  windows: {},\n}\n\nexport const emptyStore: EntityStore = {}\n\nconst replace = (store: EntityStore, key: EntityKey, entry: EntityEntry): EntityStore => ({\n  ...store,\n  [key]: entry,\n})\n\nconst written = (\n  previous: EntityEntry,\n  values: Readonly<Record<string, unknown>>,\n  now: number,\n  windows?: Readonly<Record<string, string>>,\n): EntityEntry => {\n  const present = new Set(previous.present)\n  const stale = new Set(previous.stale)\n  const unavailable = new Set(previous.unavailable)\n  const nextWindows: Record<string, string> = { ...previous.windows }\n  for (const field of Object.keys(values)) {\n    present.add(field)\n    stale.delete(field)\n    unavailable.delete(field)\n    // A write without a window clears any remembered one: the value changed.\n    const requested = own(windows, field)\n    if (requested !== undefined && requested !== '') put(nextWindows, field, requested)\n    else delete nextWindows[field]\n    // The whole list changed, so a page of it read under an alias may have too.\n    if (!field.includes(RELATION_ALIAS))\n      for (const held of present)\n        if (held.startsWith(`${field}${RELATION_ALIAS}`) && !(held in values)) stale.add(held)\n  }\n  return {\n    // Equal data keeps the object it was, so what is derived from it by\n    // identity (a read's decoded row) survives a refetch that changed nothing.\n    // Comparing costs the size of the written data, less than decoding it again.\n    values: Object.keys(values).every(\n      field =>\n        Object.hasOwn(previous.values, field) && sameData(previous.values[field], values[field]),\n    )\n      ? previous.values\n      : { ...previous.values, ...values },\n    present,\n    stale,\n    unavailable,\n    tombstone: false,\n    updatedAt: now,\n    windows: nextWindows,\n  }\n}\n\nexport interface EntityWrite {\n  readonly key: EntityKey\n  readonly values: Readonly<Record<string, unknown>>\n  /** The canonical window each written relation field was fetched with. */\n  readonly windows?: Readonly<Record<string, string>> | undefined\n  /** When this write dates the entity, instead of the batch's `now`. */\n  readonly updatedAt?: number | undefined\n}\n\n/**\n * Merges known values into many entities, copying the store once. Every\n * written field becomes present and non-stale; a tombstone is cleared because\n * the entity is evidently not absent.\n */\nexport const writeEntities = (\n  store: EntityStore,\n  writes: ReadonlyArray<EntityWrite>,\n  now = 0,\n): EntityStore => {\n  if (writes.length === 0) return store\n  const next: Record<EntityKey, EntityEntry> = { ...store }\n  for (const write of writes) {\n    next[write.key] = written(\n      next[write.key] ?? emptyEntry,\n      write.values,\n      write.updatedAt ?? now,\n      write.windows,\n    )\n  }\n  return next\n}\n\n/** `writeEntities` for one entity. */\nexport const writeEntity = (\n  store: EntityStore,\n  key: EntityKey,\n  values: Readonly<Record<string, unknown>>,\n  now = 0,\n  windows?: Readonly<Record<string, string>>,\n): EntityStore => writeEntities(store, [{ key, values, windows }], now)\n\n/**\n * Marks present fields stale (`true`) or ends their staleness (`false`) across\n * many entities, copying the store once. A field never present stays missing;\n * an unknown entity is left alone.\n */\nexport const setStale = (\n  store: EntityStore,\n  marks: ReadonlyArray<readonly [key: EntityKey, fields: Iterable<string>]>,\n  stale: boolean,\n): EntityStore => {\n  let next: Record<EntityKey, EntityEntry> | undefined\n  for (const [key, fields] of marks) {\n    const previous = (next ?? store)[key]\n    if (previous === undefined) continue\n    const staleFields = new Set(previous.stale)\n    for (const field of fields) {\n      if (stale) {\n        if (previous.present.has(field)) staleFields.add(field)\n      } else staleFields.delete(field)\n    }\n    // Only ever added to or only ever removed from, so an equal size is the same set.\n    if (staleFields.size === previous.stale.size) continue\n    next ??= { ...store }\n    next[key] = { ...previous, stale: staleFields }\n  }\n  return next ?? store\n}\n\n/** Marks present fields stale; fields that were never present stay missing. */\nexport const markStale = (\n  store: EntityStore,\n  key: EntityKey,\n  fields: Iterable<string>,\n): EntityStore => setStale(store, [[key, fields]], true)\n\n/** Ends a refresh that did not land: the fields are present again as they were. */\nexport const clearStale = (\n  store: EntityStore,\n  key: EntityKey,\n  fields: Iterable<string>,\n): EntityStore => setStale(store, [[key, fields]], false)\n\n/**\n * Records fields the server settled without a value. A present field is left\n * as it is: the answer that settled it was not about the value it holds.\n * `false` forgets the marks, which is how a refresh asks again.\n */\nexport const setUnavailable = (\n  store: EntityStore,\n  marks: ReadonlyArray<readonly [key: EntityKey, fields: Iterable<string>]>,\n  unavailable: boolean,\n): EntityStore => {\n  let next: Record<EntityKey, EntityEntry> | undefined\n  for (const [key, fields] of marks) {\n    const previous = (next ?? store)[key] ?? emptyEntry\n    if (previous.tombstone) continue\n    const marked = new Set(previous.unavailable)\n    for (const field of fields) {\n      if (unavailable) {\n        if (!previous.present.has(field)) marked.add(field)\n      } else marked.delete(field)\n    }\n    if (marked.size === previous.unavailable.size) continue\n    next ??= { ...store }\n    next[key] = { ...previous, unavailable: marked }\n  }\n  return next ?? store\n}\n\n/** Whether the server settled this field without a value, and nothing has written it since. */\nexport const isFieldUnavailable = (store: EntityStore, key: EntityKey, field: string): boolean => {\n  const value = store[key]\n  return value !== undefined && !value.tombstone && value.unavailable.has(field)\n}\n\n/**\n * Records that the entity is known to be absent, so it is not refetched. On a\n * tombstone being asked about again, the answer: still absent, so the asking ends.\n */\nexport const tombstone = (store: EntityStore, key: EntityKey): EntityStore =>\n  isTombstone(store, key) && store[key]!.stale.size === 0\n    ? store\n    : replace(store, key, {\n        values: {},\n        present: new Set(),\n        stale: new Set(),\n        unavailable: new Set(),\n        tombstone: true,\n        updatedAt: 0,\n        windows: {},\n      })\n\n/**\n * Asks about tombstoned entities again: each stays absent, so a list keeps\n * hiding it and a read of it keeps `NotFound`, while `missingFields` plans the\n * fields asked for. A write clears the tombstone; `tombstone` ends the asking.\n * An entity that is not a tombstone is left alone.\n */\nexport const askAgain = (\n  store: EntityStore,\n  marks: ReadonlyArray<readonly [key: EntityKey, fields: Iterable<string>]>,\n): EntityStore => {\n  let next: Record<EntityKey, EntityEntry> | undefined\n  for (const [key, fields] of marks) {\n    const previous = (next ?? store)[key]\n    if (previous === undefined || !previous.tombstone) continue\n    const asked = new Set([...previous.stale, ...fields])\n    if (asked.size === previous.stale.size) continue\n    next ??= { ...store }\n    next[key] = { ...previous, stale: asked }\n  }\n  return next ?? store\n}\n\n/** Forgets everything known about the entity, including a tombstone. */\nexport const remove = (store: EntityStore, key: EntityKey): EntityStore => {\n  if (store[key] === undefined) return store\n  const next = { ...store }\n  delete next[key]\n  return next\n}\n\nexport const entry = (store: EntityStore, key: EntityKey): Option.Option<EntityEntry> => {\n  const value = store[key]\n  return value === undefined ? Option.none() : Option.some(value)\n}\n\nexport const isTombstone = (store: EntityStore, key: EntityKey): boolean =>\n  store[key]?.tombstone === true\n\n/** A field is known only if it is present and not stale. */\nexport const hasField = (store: EntityStore, key: EntityKey, field: string): boolean => {\n  const value = store[key]\n  return (\n    value !== undefined && !value.tombstone && value.present.has(field) && !value.stale.has(field)\n  )\n}\n\n/** A present field whose value may be outdated; absent fields are not stale. */\nexport const isFieldStale = (store: EntityStore, key: EntityKey, field: string): boolean => {\n  const value = store[key]\n  return value !== undefined && !value.tombstone && value.stale.has(field)\n}\n\n/**\n * Reads a present field, stale or not. Absence and a tombstone both yield\n * `Option.none()`; a present `undefined`/`null` yields `Option.some`.\n */\nexport const readField = (\n  store: EntityStore,\n  key: EntityKey,\n  field: string,\n): Option.Option<unknown> => {\n  const value = store[key]\n  if (value === undefined || value.tombstone || !value.present.has(field)) return Option.none()\n  return Option.some(value.values[field])\n}\n\n/**\n * The fields the planner must fetch. A tombstone makes every field known\n * (absent), so it returns only what it is asked about again, and a\n * field the server settled without a value is known the same way. A\n * requested window that differs from the one a field was fetched with also\n * marks it missing, but only when the stored window is known (never `\"\"`), so a\n * writer that does not record windows cannot cause a refetch loop.\n */\nexport const missingFields = (\n  store: EntityStore,\n  key: EntityKey,\n  fields: Iterable<string>,\n  windows?: Readonly<Record<string, string>>,\n): ReadonlyArray<string> => {\n  const value = store[key]\n  if (value !== undefined && value.tombstone) return [...fields].filter(f => value.stale.has(f))\n  return [...fields].filter(field => {\n    if (value === undefined) return true\n    if (!value.present.has(field)) return !value.unavailable.has(field)\n    if (value.stale.has(field)) return true\n    const requested = own(windows, field)\n    const stored = own(value.windows, field)\n    return requested !== undefined && stored !== undefined && stored !== '' && stored !== requested\n  })\n}\n"],"mappings":"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"}