foldkit-remote 0.20.0 → 0.22.0

package/dist/outbox-DNuc4kZp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox-DNuc4kZp.d.ts","names":["_$__requirement_js0.RelationRequirement"],"sources":["../src/outbox.ts"],"mappings":";;;;;;KAmBY;WACG;;WACA;WAAyB,OAAO;;;;;;;cAsDlC,aAAW,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiBZ,qBAAqB,YAAY;;UAiB5B;WACN,SAAS;WACT,MAAM;;cAGJ,mBAAmB;;cAUnB,WAAQ,MACb,uBAAqB,SAClB,0BACR;;;;;;;cAaU,cAAW,OAAW,cAAY,MAAQ,iBAAe;;cAgBzD,aAAU,aACV,kBAEV,OAAO,OAAO,cAAc,cAAc,oBAAoB,cAAc;;;;;;cAkBlE,gBAAa,aACb,kBAEV,OAAO,gBAAgB,cAAc,oBAAoB,cAAc;cAW7D,aAAU,QAAY,cAAY;;cAIlC,iBAAc,iBAAmB;;;;;cAUjC,YAAS,QAAY,cAAY;;KAUlC,SAAS,KAAK;;EAExB;aACW,OAAO;;aAEP;;aAEA;;aAEA,SAAS,OAAO,OAAO;;;EAGlC;aACW;aACA;;aAEA;aACA;aACA;;;cAGA,QAAM,KAAA,WAAA;;WAlBC,OAAA;WAEC;WAEC;WAEA,SAAA,OAAO,OAAO;;;WAIZ;WACD;WAEL;WACG;WACA;;;UAMJ;;WAEN,SAAS,OAAO;;WAEhB,KAAK,OAAO;;;;;WAKZ,OAAO,OAAO;;WAEd,OAAO,cAAc;;WAErB,MAAM;;cAGJ,aAAa;cAQb,cAAW;;WA7CJ,OAAA;WAEC;WAEC;WAEA,SAAA,OAAO,OAAO;;;WAIZ;WACD;WAEL;WACG;WACA;;cAmCR,aAAU;;WAlDH,OAAA;WAEC;WAEC;WAEA,SAAA,OAAO,OAAO;;;WAIZ;WACD;WAEL;WACG;WACA;;;cA8CR,WAAQ,QAAY,gBAAc;;cAQlC,YAAS,QAAY;;cAGrB,SAAM,QAAY,gBAAc,OAAO,OAAO;;;;;KAa/C;WACG;WAA2B,OAAO;WAAsB;;WAExD;WACA;WACA;WACA;WACA;;;cAIF,cAAW,QACd,cAAY,UAElB,qBACG,OAAO,QAAQ,mBAAmB,OAAO;WAAkB;QAC/D,cAAc;;UAqBA;WACN;;WAEA,UAAU,OAAO;WACjB,OAAO;;KAGN,kBAAkB,KAAK;;EAEjC;aAAoB;aAA0B,OAAO,OAAO,OAAO;;;EAEnE;aAAmB,OAAO;;;EAE1B;aAAuB;;;cAEZ,iBAAe,KAAA,WAAA;;WAJA,OAAA;;;WAEK;;;WAJF;WAAwB,OAAA,OAAO,OAAO;;;UASpD;WACN;WACA;;WAEA,OAAO,cAAc;;cAKnB,eAAY,QAAY,gBAAc;;;;;cAgCtC,aAAW,QAAA,UAAA,OAAA,OAAA;;;;;cASX,WAAY,GAAG,GAAG,GAAC,cAClB,QACJ,OAAO,OAAO,GAAG,GAAG,OAC3B,OAAO,OAAO,GAAG,GAAG;;cAgCV,aAAU,gBAAkB,OAAO,OAAO;;cAM1C,WAAQ;;cAGR,YAAS;;UAGL;;WAEN,OAAO,SAAS;;WAEhB,MAAM,SAAS;;;cAIb,UAAO,iBACH,UACN,iBACR,OAAO,OAAO,SAAS;;;;;;cAYb,aAAa,OAAO"}

package/dist/outbox.d.ts

@@ -0,0 +1,2 @@
+import { A as storedOf, C as readEntries, D as settledIn, E as sendLock, M as withDone, N as withLock, O as storeLock, S as outboxStatus, T as revisionOf, _ as headOf, a as OutboxStatus, b as operationOf, c as ReadEntry, d as StoredWrite, f as allStored, g as emptyStoredOutbox, h as emptyOutbox, i as OutboxState, j as storedText, k as storedFromText, l as RetryOptions, m as channelFor, n as OutboxItemState, o as Queued, p as backoff, r as OutboxLocks, s as QueuedState, t as OutboxItem, u as StoredOutbox, v as mergeStored, w as readStored, x as othersWaiting, y as onlineAgain } from "./outbox-DNuc4kZp.js";
+export { OutboxItem, OutboxItemState, OutboxLocks, OutboxState, OutboxStatus, Queued, QueuedState, ReadEntry, RetryOptions, StoredOutbox, StoredWrite, allStored, backoff, channelFor, emptyOutbox, emptyStoredOutbox, headOf, mergeStored, onlineAgain, operationOf, othersWaiting, outboxStatus, readEntries, readStored, revisionOf, sendLock, settledIn, storeLock, storedFromText, storedOf, storedText, withDone, withLock };

package/dist/outbox.js

@@ -0,0 +1,326 @@
+import { RelationRequest } from "./wire.js";
+import { remoteErrorSchema } from "./remoteData.js";
+import { Context, Data, Duration, Effect, Option, Random, Schema } from "effect";
+import { KeyValueStore } from "effect/persistence";
+// src/outbox.ts
+/**
+* The durable outbox (#247, operations phase 7): a write made with
+* `Data.mutate(…, { durable: true })` is queued in the Model, copied to a
+* `KeyValueStore`, and sent from there, in order, by one tab, so a reload
+* keeps it, layer and all, and sends it again with the same operation id and
+* the same `now`. Remote sends it later; Sync converges, which this does not.
+*
+* The Model's queue is the truth for this page; the store is its copy, shared
+* by every tab on the same key, and written as a merge so no tab's write
+* overwrites another's.
+*/
+const QueuedStateSchema = Schema.Union([Schema.Struct({ _tag: Schema.Literal("Waiting") }), Schema.Struct({
+	_tag: Schema.Literal("Failed"),
+	error: remoteErrorSchema
+})]);
+const CollationSchema = Schema.Union([
+	Schema.Struct({ _tag: Schema.Literal("Binary") }),
+	Schema.Struct({ _tag: Schema.Literal("AsciiFold") }),
+	Schema.Struct({
+		_tag: Schema.Literal("Locale"),
+		locale: Schema.String
+	})
+]);
+const ComputationSchema = Schema.Union([
+	Schema.Struct({
+		_tag: Schema.Literal("Field"),
+		key: Schema.String
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Value"),
+		value: Schema.Unknown
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Call"),
+		operator: Schema.String,
+		args: Schema.Array(Schema.suspend(() => ComputationSchema)),
+		collation: Schema.NullOr(CollationSchema)
+	})
+]);
+const Ref = Schema.Struct({
+	entity: Schema.String,
+	id: Schema.String
+});
+/** The layer a write showed, as stored: read back only where every operation still has its shape. */
+const OptimisticSchema = Schema.Union([
+	Schema.Struct({
+		entity: Schema.String,
+		id: Schema.String,
+		values: Schema.Record(Schema.String, Schema.Unknown),
+		adds: Schema.optionalKey(Schema.Record(Schema.String, Schema.Number)),
+		computes: Schema.optionalKey(Schema.Record(Schema.String, ComputationSchema))
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Delete"),
+		entity: Schema.String,
+		id: Schema.String
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Insert"),
+		connection: Schema.String,
+		position: Schema.Literals(["prepend", "append"]),
+		edge: Schema.Struct({
+			key: Schema.String,
+			ref: Ref
+		})
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Remove"),
+		connection: Schema.String,
+		edge: Schema.Struct({
+			key: Schema.String,
+			ref: Ref
+		})
+	})
+]);
+/**
+* A durable write as the store keeps it: what a later page needs to show it
+* and send it as itself. Its input is encoded by the Mutation's `Input`, so a
+* page reads it back with the Mutation it has then.
+*/
+const StoredWrite = Schema.Struct({
+	/** Its operation id, which is also its request id. */
+	operation: Schema.String,
+	mutation: Schema.String,
+	input: Schema.Unknown,
+	keys: Schema.optionalKey(Schema.Array(Schema.String)),
+	now: Schema.optionalKey(Schema.Number),
+	/** The layer it shows until it settles. */
+	optimistic: Schema.Array(OptimisticSchema),
+	/** Who its layer was predicted for. */
+	viewer: Schema.optionalKey(Ref),
+	/** What the reader was shown when they acted, for the answer to carry. */
+	shown: Schema.Array(RelationRequest),
+	/** Moves on each change of `state`; of two copies, the higher wins. */
+	revision: Schema.Number,
+	state: QueuedStateSchema
+});
+/** What makes a stored entry an operation at all: one without these is dropped. */
+const OperationKey = Schema.Struct({
+	operation: Schema.String,
+	revision: Schema.Number
+});
+const keyOf = Schema.decodeUnknownOption(OperationKey);
+const OUTBOX_VERSION = 1;
+/** The record one key holds: every tab's queued writes, and the operations settled lately. */
+const StoredOutboxSchema = Schema.Struct({
+	version: Schema.Literal(OUTBOX_VERSION),
+	scope: Schema.String,
+	entries: Schema.Array(Schema.Unknown),
+	done: Schema.Array(Schema.String)
+});
+const emptyStoredOutbox = {
+	entries: [],
+	done: []
+};
+/** `done` with `settled` after it, the newest `DONE_WINDOW`, each once. */
+const withDone = (done, settled) => {
+	if (settled.every((operation) => done.includes(operation))) return done;
+	const kept = new Set(done);
+	for (const operation of settled) kept.add(operation);
+	return [...kept].slice(-256);
+};
+/**
+* Two copies of a queue as one: entries of both by operation, none that
+* either settled, the higher revision of each, in the store's order and then
+* mine. A join, so tabs that save at once lose nothing the next save does
+* not put back.
+*/
+const mergeStored = (store, mine) => {
+	const done = withDone(store.done, mine.done);
+	const gone = new Set(done);
+	const kept = /* @__PURE__ */ new Map();
+	for (const raw of [...store.entries, ...mine.entries]) {
+		const key = keyOf(raw);
+		if (Option.isNone(key) || gone.has(key.value.operation)) continue;
+		const held = kept.get(key.value.operation);
+		if (held === void 0 || held.revision < key.value.revision) kept.set(key.value.operation, {
+			raw,
+			revision: key.value.revision
+		});
+	}
+	return {
+		entries: [...kept.values()].map(({ raw }) => raw),
+		done
+	};
+};
+/** The record under `key` for `scope`: none when absent, of another scope or version, or not JSON. */
+const readStored = (key, scope) => Effect.gen(function* () {
+	const text = yield* (yield* KeyValueStore.KeyValueStore).get(key);
+	if (text === void 0) return emptyStoredOutbox;
+	const parsed = Schema.decodeUnknownOption(Schema.fromJsonString(StoredOutboxSchema))(text);
+	return Option.match(parsed, {
+		onNone: () => emptyStoredOutbox,
+		onSome: (record) => record.scope === scope ? {
+			entries: record.entries,
+			done: record.done
+		} : emptyStoredOutbox
+	});
+});
+/**
+* Whether the record under `key` holds writes waiting for another scope than
+* `scope`: a key that is not one per principal. Writing over it would lose
+* them, so it is not written.
+*/
+const othersWaiting = (key, scope) => Effect.gen(function* () {
+	const text = yield* (yield* KeyValueStore.KeyValueStore).get(key);
+	return Option.exists(Option.flatMap(Option.fromUndefinedOr(text), (stored) => Schema.decodeUnknownOption(Schema.fromJsonString(StoredOutboxSchema))(stored)), (record) => record.scope !== scope && record.entries.length > 0);
+});
+const storedText = (outbox, scope) => JSON.stringify({
+	version: OUTBOX_VERSION,
+	scope,
+	entries: outbox.entries,
+	done: outbox.done
+});
+/** A queue's text, as `storedText` wrote it, read back. */
+const storedFromText = (text) => Option.match(Schema.decodeUnknownOption(Schema.fromJsonString(StoredOutboxSchema))(text), {
+	onNone: () => emptyStoredOutbox,
+	onSome: ({ entries, done }) => ({
+		entries,
+		done
+	})
+});
+/**
+* Whether the store says `operation` is settled: done, or refused. A store
+* that lacks it says nothing (it could not be written), and it is sent.
+*/
+const settledIn = (outbox, operation) => outbox.done.includes(operation) || outbox.entries.some((raw) => Option.exists(Schema.decodeUnknownOption(StoredWrite)(raw), (write) => write.operation === operation && write.state._tag !== "Waiting"));
+const Queued = Data.taggedEnum();
+const emptyOutbox = {
+	session: Option.none(),
+	key: Option.none(),
+	scope: Option.none(),
+	queue: [],
+	done: []
+};
+const operationOf = Queued.$match({
+	Readable: ({ write }) => write.operation,
+	Unreadable: ({ operation }) => operation
+});
+const revisionOf = Queued.$match({
+	Readable: ({ write }) => write.revision,
+	Unreadable: ({ revision }) => revision
+});
+const isStored = Queued.$match({
+	Readable: ({ stored }) => stored,
+	Unreadable: ({ stored }) => stored
+});
+/** The queue as the store keeps it. */
+const storedOf = (outbox) => ({
+	entries: outbox.queue.map(Queued.$match({
+		Readable: ({ write }) => write,
+		Unreadable: ({ raw }) => raw
+	})),
+	done: outbox.done
+});
+/** Whether every queued write is in the store as the Model holds it. */
+const allStored = (outbox) => outbox.queue.every(isStored);
+/** The write sent next: the oldest one waiting that the store holds. */
+const headOf = (outbox) => {
+	for (const queued of outbox.queue) if (queued._tag === "Readable" && queued.write.state._tag === "Waiting" && queued.stored) return Option.some(queued.write);
+	return Option.none();
+};
+/** A stored queue as a page reads it, entry by entry: one bad entry never fails the rest. */
+const readEntries = (outbox, inputOf) => outbox.entries.flatMap((raw) => {
+	const key = keyOf(raw);
+	if (Option.isNone(key)) return [];
+	const unreadable = (reason) => [{
+		_tag: "Unreadable",
+		...key.value,
+		raw,
+		reason
+	}];
+	const write = Schema.decodeUnknownOption(StoredWrite)(raw);
+	if (Option.isNone(write)) return unreadable("it was stored in a shape this version cannot read");
+	return Option.match(inputOf(write.value.mutation), {
+		onNone: () => unreadable(`${write.value.mutation} is not a mutation this version registers`),
+		onSome: (decode) => Option.match(decode(write.value.input), {
+			onNone: () => unreadable(`its input no longer decodes as ${write.value.mutation}'s`),
+			onSome: ({ decoded }) => [{
+				_tag: "Readable",
+				write: write.value,
+				input: decoded
+			}]
+		})
+	});
+});
+const OutboxItemState = Data.taggedEnum();
+const MutationName = Schema.Struct({ mutation: Schema.String });
+const outboxStatus = (outbox) => {
+	const items = outbox.queue.map(Queued.$match({
+		Readable: ({ write, attempt, delayed }) => ({
+			requestId: write.operation,
+			mutation: Option.some(write.mutation),
+			state: write.state._tag === "Waiting" ? OutboxItemState.Waiting({
+				attempt,
+				error: delayed
+			}) : OutboxItemState.Failed({ error: write.state.error })
+		}),
+		Unreadable: ({ operation, raw, reason }) => ({
+			requestId: operation,
+			mutation: Option.map(Schema.decodeUnknownOption(MutationName)(raw), ({ mutation }) => mutation),
+			state: OutboxItemState.Unreadable({ reason })
+		})
+	}));
+	return {
+		waiting: items.filter((item) => item.state._tag === "Waiting").length,
+		failed: items.filter((item) => item.state._tag === "Failed").length,
+		items
+	};
+};
+/**
+* Where the outbox takes its Web Locks: the browser's, where it has them. A
+* trace, which is one tab, takes none.
+*/
+const OutboxLocks = Context.Reference("foldkit-remote/OutboxLocks", { defaultValue: () => Option.fromUndefinedOr(globalThis.navigator?.locks) });
+/**
+* Holds the Web Lock `name` while `effect` runs, where there are Web Locks;
+* elsewhere runs it as it is (one tab, or a server).
+*/
+const withLock = (name, effect) => Effect.flatMap(Effect.service(OutboxLocks), (held) => Option.match(held, {
+	onNone: () => effect,
+	onSome: (locks) => heldWhile(locks, name, effect)
+}));
+const heldWhile = (locks, name, effect) => Effect.acquireUseRelease(Effect.callback((resume, signal) => {
+	locks.request(name, { signal }, () => {
+		let release = () => void 0;
+		const held = new Promise((done) => {
+			release = done;
+		});
+		resume(Effect.succeed(release));
+		return held;
+	}).catch(() => void 0);
+}), () => effect, (release) => Effect.sync(release));
+/** The `BroadcastChannel` the tabs on one key speak on; none where there is none. */
+const channelFor = (key) => typeof globalThis.BroadcastChannel === "function" ? Option.some(new globalThis.BroadcastChannel(`foldkit-remote-outbox:${key}`)) : Option.none();
+/** The lock the tabs on one key send under: one sends, the others wait. */
+const sendLock = (key) => `foldkit-remote-outbox:${key}:send`;
+/** The lock a write to the store is made under, so two tabs never write it at once. */
+const storeLock = (key) => `foldkit-remote-outbox:${key}:store`;
+/** `base` doubled per attempt, up to `max`, ±20% so tabs that failed together do not retry together. */
+const backoff = (attempt, options = {}) => {
+	const base = Duration.toMillis(Duration.fromInputUnsafe(options.base ?? "1 second"));
+	const max = Duration.toMillis(Duration.fromInputUnsafe(options.max ?? "30 seconds"));
+	const wait = Math.min(max, base * 2 ** Math.max(0, attempt - 1));
+	return Effect.map(Random.nextBetween(.8, 1.2), (jitter) => Duration.millis(wait * jitter));
+};
+/**
+* Waits until the browser says it is online again, where it can say so;
+* never elsewhere. A wait for a retry races it, so a write goes as soon as
+* the network is back.
+*/
+const onlineAgain = Effect.callback((resume) => {
+	const target = globalThis.window;
+	if (target === void 0 || typeof target.addEventListener !== "function") return;
+	const online = () => resume(Effect.void);
+	target.addEventListener("online", online, { once: true });
+	return Effect.sync(() => target.removeEventListener("online", online));
+});
+export { OutboxItemState, OutboxLocks, Queued, StoredWrite, allStored, backoff, channelFor, emptyOutbox, emptyStoredOutbox, headOf, mergeStored, onlineAgain, operationOf, othersWaiting, outboxStatus, readEntries, readStored, revisionOf, sendLock, settledIn, storeLock, storedFromText, storedOf, storedText, withDone, withLock };
+
+//# sourceMappingURL=outbox.js.map

package/dist/outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.js","names":[],"sources":["../src/outbox.ts"],"sourcesContent":["/**\n * The durable outbox (#247, operations phase 7): a write made with\n * `Data.mutate(…, { durable: true })` is queued in the Model, copied to a\n * `KeyValueStore`, and sent from there, in order, by one tab, so a reload\n * keeps it, layer and all, and sends it again with the same operation id and\n * the same `now`. Remote sends it later; Sync converges, which this does not.\n *\n * The Model's queue is the truth for this page; the store is its copy, shared\n * by every tab on the same key, and written as a merge so no tab's write\n * overwrites another's.\n */\nimport { Context, Data, Duration, Effect, Option, Random, Schema } from 'effect'\nimport { KeyValueStore } from 'effect/persistence'\nimport type { Computation } from 'foldkit-entity'\nimport type { OptimisticOperation } from './optimistic.js'\nimport { remoteErrorSchema, type RemoteError } from './remoteData.js'\nimport { RelationRequest } from './wire.js'\n\n/** Where a queued write stands, as the store keeps it. */\nexport type QueuedState =\n  | { readonly _tag: 'Waiting' }\n  | { readonly _tag: 'Failed'; readonly error: RemoteError }\n\nconst QueuedStateSchema = Schema.Union([\n  Schema.Struct({ _tag: Schema.Literal('Waiting') }),\n  Schema.Struct({ _tag: Schema.Literal('Failed'), error: remoteErrorSchema }),\n])\n\nconst CollationSchema = Schema.Union([\n  Schema.Struct({ _tag: Schema.Literal('Binary') }),\n  Schema.Struct({ _tag: Schema.Literal('AsciiFold') }),\n  Schema.Struct({ _tag: Schema.Literal('Locale'), locale: Schema.String }),\n])\n\nconst ComputationSchema: Schema.Codec<Computation> = Schema.Union([\n  Schema.Struct({ _tag: Schema.Literal('Field'), key: Schema.String }),\n  Schema.Struct({ _tag: Schema.Literal('Value'), value: Schema.Unknown }),\n  Schema.Struct({\n    _tag: Schema.Literal('Call'),\n    operator: Schema.String,\n    args: Schema.Array(Schema.suspend((): Schema.Codec<Computation> => ComputationSchema)),\n    collation: Schema.NullOr(CollationSchema),\n  }),\n])\n\nconst Ref = Schema.Struct({ entity: Schema.String, id: Schema.String })\n\n/** The layer a write showed, as stored: read back only where every operation still has its shape. */\nconst OptimisticSchema: Schema.Codec<OptimisticOperation> = Schema.Union([\n  Schema.Struct({\n    entity: Schema.String,\n    id: Schema.String,\n    values: Schema.Record(Schema.String, Schema.Unknown),\n    adds: Schema.optionalKey(Schema.Record(Schema.String, Schema.Number)),\n    computes: Schema.optionalKey(Schema.Record(Schema.String, ComputationSchema)),\n  }),\n  Schema.Struct({ _tag: Schema.Literal('Delete'), entity: Schema.String, id: Schema.String }),\n  Schema.Struct({\n    _tag: Schema.Literal('Insert'),\n    connection: Schema.String,\n    position: Schema.Literals(['prepend', 'append']),\n    edge: Schema.Struct({ key: Schema.String, ref: Ref }),\n  }),\n  Schema.Struct({\n    _tag: Schema.Literal('Remove'),\n    connection: Schema.String,\n    edge: Schema.Struct({ key: Schema.String, ref: Ref }),\n  }),\n])\n\n/**\n * A durable write as the store keeps it: what a later page needs to show it\n * and send it as itself. Its input is encoded by the Mutation's `Input`, so a\n * page reads it back with the Mutation it has then.\n */\nexport const StoredWrite = Schema.Struct({\n  /** Its operation id, which is also its request id. */\n  operation: Schema.String,\n  mutation: Schema.String,\n  input: Schema.Unknown,\n  keys: Schema.optionalKey(Schema.Array(Schema.String)),\n  now: Schema.optionalKey(Schema.Number),\n  /** The layer it shows until it settles. */\n  optimistic: Schema.Array(OptimisticSchema),\n  /** Who its layer was predicted for. */\n  viewer: Schema.optionalKey(Ref),\n  /** What the reader was shown when they acted, for the answer to carry. */\n  shown: Schema.Array(RelationRequest),\n  /** Moves on each change of `state`; of two copies, the higher wins. */\n  revision: Schema.Number,\n  state: QueuedStateSchema,\n})\nexport type StoredWrite = typeof StoredWrite.Type\n\n/** What makes a stored entry an operation at all: one without these is dropped. */\nconst OperationKey = Schema.Struct({ operation: Schema.String, revision: Schema.Number })\nconst keyOf = Schema.decodeUnknownOption(OperationKey)\n\nconst OUTBOX_VERSION = 1\n\n/** The record one key holds: every tab's queued writes, and the operations settled lately. */\nconst StoredOutboxSchema = Schema.Struct({\n  version: Schema.Literal(OUTBOX_VERSION),\n  scope: Schema.String,\n  entries: Schema.Array(Schema.Unknown),\n  done: Schema.Array(Schema.String),\n})\n\n/** A key's queue as stored, each entry as it was written, read or not. */\nexport interface StoredOutbox {\n  readonly entries: ReadonlyArray<unknown>\n  readonly done: ReadonlyArray<string>\n}\n\nexport const emptyStoredOutbox: StoredOutbox = { entries: [], done: [] }\n\n/**\n * How many settled operation ids are kept. A copy of a write settled longer\n * ago than this could come back from a tab that slept through it; the\n * server's ledger answers it again from its record.\n */\nconst DONE_WINDOW = 256\n\n/** `done` with `settled` after it, the newest `DONE_WINDOW`, each once. */\nexport const withDone = (\n  done: ReadonlyArray<string>,\n  settled: ReadonlyArray<string>,\n): ReadonlyArray<string> => {\n  if (settled.every(operation => done.includes(operation))) return done\n  const kept = new Set(done)\n  for (const operation of settled) kept.add(operation)\n  return [...kept].slice(-DONE_WINDOW)\n}\n\n/**\n * Two copies of a queue as one: entries of both by operation, none that\n * either settled, the higher revision of each, in the store's order and then\n * mine. A join, so tabs that save at once lose nothing the next save does\n * not put back.\n */\nexport const mergeStored = (store: StoredOutbox, mine: StoredOutbox): StoredOutbox => {\n  const done = withDone(store.done, mine.done)\n  const gone = new Set(done)\n  const kept = new Map<string, { readonly raw: unknown; readonly revision: number }>()\n  for (const raw of [...store.entries, ...mine.entries]) {\n    const key = keyOf(raw)\n    if (Option.isNone(key) || gone.has(key.value.operation)) continue\n    const held = kept.get(key.value.operation)\n    if (held === undefined || held.revision < key.value.revision) {\n      kept.set(key.value.operation, { raw, revision: key.value.revision })\n    }\n  }\n  return { entries: [...kept.values()].map(({ raw }) => raw), done }\n}\n\n/** The record under `key` for `scope`: none when absent, of another scope or version, or not JSON. */\nexport const readStored = (\n  key: string,\n  scope: string,\n): Effect.Effect<StoredOutbox, KeyValueStore.KeyValueStoreError, KeyValueStore.KeyValueStore> =>\n  Effect.gen(function* () {\n    const kv = yield* KeyValueStore.KeyValueStore\n    const text = yield* kv.get(key)\n    if (text === undefined) return emptyStoredOutbox\n    const parsed = Schema.decodeUnknownOption(Schema.fromJsonString(StoredOutboxSchema))(text)\n    return Option.match(parsed, {\n      onNone: () => emptyStoredOutbox,\n      onSome: record =>\n        record.scope === scope ? { entries: record.entries, done: record.done } : emptyStoredOutbox,\n    })\n  })\n\n/**\n * Whether the record under `key` holds writes waiting for another scope than\n * `scope`: a key that is not one per principal. Writing over it would lose\n * them, so it is not written.\n */\nexport const othersWaiting = (\n  key: string,\n  scope: string,\n): Effect.Effect<boolean, KeyValueStore.KeyValueStoreError, KeyValueStore.KeyValueStore> =>\n  Effect.gen(function* () {\n    const text = yield* (yield* KeyValueStore.KeyValueStore).get(key)\n    return Option.exists(\n      Option.flatMap(Option.fromUndefinedOr(text), stored =>\n        Schema.decodeUnknownOption(Schema.fromJsonString(StoredOutboxSchema))(stored),\n      ),\n      record => record.scope !== scope && record.entries.length > 0,\n    )\n  })\n\nexport const storedText = (outbox: StoredOutbox, scope: string): string =>\n  JSON.stringify({ version: OUTBOX_VERSION, scope, entries: outbox.entries, done: outbox.done })\n\n/** A queue's text, as `storedText` wrote it, read back. */\nexport const storedFromText = (text: string): StoredOutbox =>\n  Option.match(Schema.decodeUnknownOption(Schema.fromJsonString(StoredOutboxSchema))(text), {\n    onNone: () => emptyStoredOutbox,\n    onSome: ({ entries, done }) => ({ entries, done }),\n  })\n\n/**\n * Whether the store says `operation` is settled: done, or refused. A store\n * that lacks it says nothing (it could not be written), and it is sent.\n */\nexport const settledIn = (outbox: StoredOutbox, operation: string): boolean =>\n  outbox.done.includes(operation) ||\n  outbox.entries.some(raw =>\n    Option.exists(\n      Schema.decodeUnknownOption(StoredWrite)(raw),\n      write => write.operation === operation && write.state._tag !== 'Waiting',\n    ),\n  )\n\n/** A queued write in the Model. */\nexport type Queued = Data.TaggedEnum<{\n  /** One this version can send: shown, in the ledger, and sent in its turn. */\n  Readable: {\n    readonly write: StoredWrite\n    /** Whether the store is known to hold this revision: only then is it sent. */\n    readonly stored: boolean\n    /** Sends in a row that nothing answered, this page. */\n    readonly attempt: number\n    /** Why the last of them failed. */\n    readonly delayed: Option.Option<RemoteError>\n  }\n  /** One this version cannot read (a Mutation it lacks, an input that no longer decodes): kept, never sent. */\n  Unreadable: {\n    readonly operation: string\n    readonly revision: number\n    /** The entry as it was stored, written back as it is. */\n    readonly raw: unknown\n    readonly reason: string\n    readonly stored: boolean\n  }\n}>\nexport const Queued = Data.taggedEnum<Queued>()\n\n/** The durable writes this page holds, and the store they are copied to. */\nexport interface OutboxState {\n  /** Names this page load's operations; minted by the outbox's restore. */\n  readonly session: Option.Option<string>\n  /** The store key the queue was read from; it is saved there and nowhere else. */\n  readonly key: Option.Option<string>\n  /**\n   * Whose queue it is, as it was read: a page whose scope moves on sends none\n   * of it, and reads the new scope's instead.\n   */\n  readonly scope: Option.Option<string>\n  /** Every tab's queued writes, in the order they are sent. */\n  readonly queue: ReadonlyArray<Queued>\n  /** Operations settled lately, here or in another tab. */\n  readonly done: ReadonlyArray<string>\n}\n\nexport const emptyOutbox: OutboxState = {\n  session: Option.none(),\n  key: Option.none(),\n  scope: Option.none(),\n  queue: [],\n  done: [],\n}\n\nexport const operationOf = Queued.$match({\n  Readable: ({ write }) => write.operation,\n  Unreadable: ({ operation }) => operation,\n})\n\nexport const revisionOf = Queued.$match({\n  Readable: ({ write }) => write.revision,\n  Unreadable: ({ revision }) => revision,\n})\n\nconst isStored = Queued.$match({\n  Readable: ({ stored }) => stored,\n  Unreadable: ({ stored }) => stored,\n})\n\n/** The queue as the store keeps it. */\nexport const storedOf = (outbox: OutboxState): StoredOutbox => ({\n  entries: outbox.queue.map(\n    Queued.$match({ Readable: ({ write }) => write, Unreadable: ({ raw }) => raw }),\n  ),\n  done: outbox.done,\n})\n\n/** Whether every queued write is in the store as the Model holds it. */\nexport const allStored = (outbox: OutboxState): boolean => outbox.queue.every(isStored)\n\n/** The write sent next: the oldest one waiting that the store holds. */\nexport const headOf = (outbox: OutboxState): Option.Option<StoredWrite> => {\n  for (const queued of outbox.queue) {\n    if (queued._tag === 'Readable' && queued.write.state._tag === 'Waiting' && queued.stored) {\n      return Option.some(queued.write)\n    }\n  }\n  return Option.none()\n}\n\n/**\n * A stored entry as a page reads it: a write it can send, with its input\n * decoded, or one it cannot, with why.\n */\nexport type ReadEntry =\n  | { readonly _tag: 'Readable'; readonly write: StoredWrite; readonly input: unknown }\n  | {\n      readonly _tag: 'Unreadable'\n      readonly operation: string\n      readonly revision: number\n      readonly raw: unknown\n      readonly reason: string\n    }\n\n/** A stored queue as a page reads it, entry by entry: one bad entry never fails the rest. */\nexport const readEntries = (\n  outbox: StoredOutbox,\n  inputOf: (\n    mutation: string,\n  ) => Option.Option<(input: unknown) => Option.Option<{ readonly decoded: unknown }>>,\n): ReadonlyArray<ReadEntry> =>\n  outbox.entries.flatMap((raw): ReadonlyArray<ReadEntry> => {\n    const key = keyOf(raw)\n    // Not an operation at all: nothing to send, show, or dismiss.\n    if (Option.isNone(key)) return []\n    const unreadable = (reason: string): ReadonlyArray<ReadEntry> => [\n      { _tag: 'Unreadable', ...key.value, raw, reason },\n    ]\n    const write = Schema.decodeUnknownOption(StoredWrite)(raw)\n    if (Option.isNone(write)) return unreadable('it was stored in a shape this version cannot read')\n    return Option.match(inputOf(write.value.mutation), {\n      onNone: () => unreadable(`${write.value.mutation} is not a mutation this version registers`),\n      onSome: decode =>\n        Option.match(decode(write.value.input), {\n          onNone: () => unreadable(`its input no longer decodes as ${write.value.mutation}'s`),\n          onSome: ({ decoded }) => [{ _tag: 'Readable', write: write.value, input: decoded }],\n        }),\n    })\n  })\n\n/** One item of `Data.outboxStatus`. */\nexport interface OutboxItem {\n  readonly requestId: string\n  /** The Mutation it names; none where the stored entry names none this version can read. */\n  readonly mutation: Option.Option<string>\n  readonly state: OutboxItemState\n}\n\nexport type OutboxItemState = Data.TaggedEnum<{\n  /** Not answered yet: `attempt` sends nothing answered so far, `error` the last one's. */\n  Waiting: { readonly attempt: number; readonly error: Option.Option<RemoteError> }\n  /** The server answered no: `Data.retry` or `Data.dismiss` it. */\n  Failed: { readonly error: RemoteError }\n  /** Stored by a version of the app this one cannot read: `Data.dismiss` it. */\n  Unreadable: { readonly reason: string }\n}>\nexport const OutboxItemState = Data.taggedEnum<OutboxItemState>()\n\n/** What the outbox holds, for a view: \"3 changes waiting\". */\nexport interface OutboxStatus {\n  readonly waiting: number\n  readonly failed: number\n  /** Every durable write not yet settled, in the order they are sent. */\n  readonly items: ReadonlyArray<OutboxItem>\n}\n\nconst MutationName = Schema.Struct({ mutation: Schema.String })\n\nexport const outboxStatus = (outbox: OutboxState): OutboxStatus => {\n  const items = outbox.queue.map(\n    Queued.$match({\n      Readable: ({ write, attempt, delayed }): OutboxItem => ({\n        requestId: write.operation,\n        mutation: Option.some(write.mutation),\n        state:\n          write.state._tag === 'Waiting'\n            ? OutboxItemState.Waiting({ attempt, error: delayed })\n            : OutboxItemState.Failed({ error: write.state.error }),\n      }),\n      Unreadable: ({ operation, raw, reason }): OutboxItem => ({\n        requestId: operation,\n        mutation: Option.map(\n          Schema.decodeUnknownOption(MutationName)(raw),\n          ({ mutation }) => mutation,\n        ),\n        state: OutboxItemState.Unreadable({ reason }),\n      }),\n    }),\n  )\n  return {\n    waiting: items.filter(item => item.state._tag === 'Waiting').length,\n    failed: items.filter(item => item.state._tag === 'Failed').length,\n    items,\n  }\n}\n\n/**\n * Where the outbox takes its Web Locks: the browser's, where it has them. A\n * trace, which is one tab, takes none.\n */\nexport const OutboxLocks = Context.Reference<Option.Option<LockManager>>(\n  'foldkit-remote/OutboxLocks',\n  { defaultValue: () => Option.fromUndefinedOr(globalThis.navigator?.locks) },\n)\n\n/**\n * Holds the Web Lock `name` while `effect` runs, where there are Web Locks;\n * elsewhere runs it as it is (one tab, or a server).\n */\nexport const withLock = <A, E, R>(\n  name: string,\n  effect: Effect.Effect<A, E, R>,\n): Effect.Effect<A, E, R> =>\n  Effect.flatMap(Effect.service(OutboxLocks), held =>\n    Option.match(held, {\n      onNone: () => effect,\n      onSome: locks => heldWhile(locks, name, effect),\n    }),\n  )\n\nconst heldWhile = <A, E, R>(\n  locks: LockManager,\n  name: string,\n  effect: Effect.Effect<A, E, R>,\n): Effect.Effect<A, E, R> =>\n  Effect.acquireUseRelease(\n    Effect.callback<() => void>((resume, signal) => {\n      locks\n        .request(name, { signal }, () => {\n          let release: () => void = () => undefined\n          const held = new Promise<void>(done => {\n            release = done\n          })\n          resume(Effect.succeed(release))\n          return held\n        })\n        // An abandoned wait rejects with the signal's reason; nothing waits on it.\n        .catch(() => undefined)\n    }),\n    () => effect,\n    release => Effect.sync(release),\n  )\n\n/** The `BroadcastChannel` the tabs on one key speak on; none where there is none. */\nexport const channelFor = (key: string): Option.Option<BroadcastChannel> =>\n  typeof globalThis.BroadcastChannel === 'function'\n    ? Option.some(new globalThis.BroadcastChannel(`foldkit-remote-outbox:${key}`))\n    : Option.none()\n\n/** The lock the tabs on one key send under: one sends, the others wait. */\nexport const sendLock = (key: string): string => `foldkit-remote-outbox:${key}:send`\n\n/** The lock a write to the store is made under, so two tabs never write it at once. */\nexport const storeLock = (key: string): string => `foldkit-remote-outbox:${key}:store`\n\n/** How long the outbox waits before sending again after `attempt` sends nothing answered. */\nexport interface RetryOptions {\n  /** The first wait; 1 second unless given. */\n  readonly base?: Duration.Input | undefined\n  /** The longest; 30 seconds unless given. */\n  readonly max?: Duration.Input | undefined\n}\n\n/** `base` doubled per attempt, up to `max`, ±20% so tabs that failed together do not retry together. */\nexport const backoff = (\n  attempt: number,\n  options: RetryOptions = {},\n): Effect.Effect<Duration.Duration> => {\n  const base = Duration.toMillis(Duration.fromInputUnsafe(options.base ?? '1 second'))\n  const max = Duration.toMillis(Duration.fromInputUnsafe(options.max ?? '30 seconds'))\n  const wait = Math.min(max, base * 2 ** Math.max(0, attempt - 1))\n  return Effect.map(Random.nextBetween(0.8, 1.2), jitter => Duration.millis(wait * jitter))\n}\n\n/**\n * Waits until the browser says it is online again, where it can say so;\n * never elsewhere. A wait for a retry races it, so a write goes as soon as\n * the network is back.\n */\nexport const onlineAgain: Effect.Effect<void> = Effect.callback<void>(resume => {\n  const target = globalThis.window\n  if (target === undefined || typeof target.addEventListener !== 'function') return\n  const online = () => resume(Effect.void)\n  target.addEventListener('online', online, { once: true })\n  return Effect.sync(() => target.removeEventListener('online', online))\n})\n"],"mappings":"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"}

package/dist/patchValues.d.ts

@@ -0,0 +1,10 @@
+import { r as EntityDescriptor } from "./entity-CgsG5Uel.js";
+import { Schema } from "effect";
+/**
+ * `Remote.patch`'s values as the store holds them: each relation's refs
+ * written as ref keys. A relation given anything but a ref to its target (a
+ * ref key typed by hand, a ref to another Entity) is refused here, where the
+ * patch is made.
+ */
+export declare const wireValues: (descriptor: EntityDescriptor<string, Schema.Struct.Fields>, values: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>>;
+//# sourceMappingURL=patchValues.d.ts.map

package/dist/patchValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patchValues.d.ts","names":[],"sources":["../src/patchValues.ts"],"mappings":";;;;;;;;qBAoDa,aAAU,YACT,yBAAyB,OAAO,OAAO,SAAO,QAClD,SAAS,6BAChB,SAAS"}

package/dist/patchValues.js

@@ -0,0 +1,57 @@
+import { relationShape } from "./relation.js";
+import { entityKey } from "./store.js";
+// src/patchValues.ts
+const relationShapes = /* @__PURE__ */ new WeakMap();
+/** A descriptor's relation fields and their shapes, read once per descriptor. */
+const relationsOf = (fields) => {
+	const known = relationShapes.get(fields);
+	if (known !== void 0) return known;
+	const shapes = /* @__PURE__ */ new Map();
+	for (const [key, schema] of Object.entries(fields)) {
+		const shape = relationShape(schema);
+		if (shape !== void 0) shapes.set(key, shape);
+	}
+	relationShapes.set(fields, shapes);
+	return shapes;
+};
+const isRefTo = (value, entity) => value !== null && typeof value === "object" && value.entity === entity && typeof value.id === "string";
+/** One relation value as the store holds it, or a refusal naming what the field takes. */
+const wireRelation = (shape, value, refuse) => {
+	if (value === void 0) return value;
+	if (value === null) return shape.nullable ? null : refuse();
+	const key = (ref) => isRefTo(ref, shape.entity) ? entityKey(ref.entity, ref.id) : refuse();
+	if (shape.kind === "one") return key(value);
+	if (shape.kind === "many") return Array.isArray(value) ? value.map(key) : refuse();
+	const page = value;
+	return Array.isArray(page.refs) && typeof page.hasNext === "boolean" && typeof page.hasPrevious === "boolean" ? {
+		refs: page.refs.map(key),
+		hasNext: page.hasNext,
+		hasPrevious: page.hasPrevious
+	} : refuse();
+};
+/**
+* `Remote.patch`'s values as the store holds them: each relation's refs
+* written as ref keys. A relation given anything but a ref to its target (a
+* ref key typed by hand, a ref to another Entity) is refused here, where the
+* patch is made.
+*/
+const wireValues = (descriptor, values) => {
+	const relations = relationsOf(descriptor.fields);
+	if (relations.size === 0) return values;
+	return Object.fromEntries(Object.entries(values).map(([field, value]) => {
+		const shape = relations.get(field);
+		if (shape === void 0) return [field, value];
+		const refuse = () => {
+			const takes = {
+				one: "a ref",
+				many: "an array of refs",
+				page: "a page of refs"
+			}[shape.kind];
+			throw new Error(`Remote.patch: "${field}" of "${descriptor.name}" takes ${takes} to ${shape.entity} (Remote.ref(${shape.entity}, id))${shape.nullable ? " or null" : ""}, not ${JSON.stringify(value)}`);
+		};
+		return [field, wireRelation(shape, value, refuse)];
+	}));
+};
+export { wireValues };
+
+//# sourceMappingURL=patchValues.js.map

package/dist/patchValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patchValues.js","names":[],"sources":["../src/patchValues.ts"],"sourcesContent":["/**\n * `Remote.patch`'s relation values written as the store holds them: a ref\n * becomes its ref key, and anything else in a relation is refused.\n */\nimport type { Schema } from 'effect'\nimport type { EntityDescriptor, EntityRef, RefPage } from './entity.js'\nimport { relationShape, type RelationShape } from './relation.js'\nimport { entityKey } from './store.js'\n\nconst relationShapes = new WeakMap<Schema.Struct.Fields, ReadonlyMap<string, RelationShape>>()\n\n/** A descriptor's relation fields and their shapes, read once per descriptor. */\nconst relationsOf = (fields: Schema.Struct.Fields): ReadonlyMap<string, RelationShape> => {\n  const known = relationShapes.get(fields)\n  if (known !== undefined) return known\n  const shapes = new Map<string, RelationShape>()\n  for (const [key, schema] of Object.entries(fields)) {\n    const shape = relationShape(schema)\n    if (shape !== undefined) shapes.set(key, shape)\n  }\n  relationShapes.set(fields, shapes)\n  return shapes\n}\n\nconst isRefTo = (value: unknown, entity: string): value is EntityRef<string> =>\n  value !== null &&\n  typeof value === 'object' &&\n  (value as Partial<EntityRef<string>>).entity === entity &&\n  typeof (value as Partial<EntityRef<string>>).id === 'string'\n\n/** One relation value as the store holds it, or a refusal naming what the field takes. */\nconst wireRelation = (shape: RelationShape, value: unknown, refuse: () => never): unknown => {\n  if (value === undefined) return value\n  if (value === null) return shape.nullable ? null : refuse()\n  const key = (ref: unknown): string =>\n    isRefTo(ref, shape.entity) ? entityKey(ref.entity, ref.id) : refuse()\n  if (shape.kind === 'one') return key(value)\n  if (shape.kind === 'many') return Array.isArray(value) ? value.map(key) : refuse()\n  const page = value as Partial<RefPage<string>>\n  return Array.isArray(page.refs) &&\n    typeof page.hasNext === 'boolean' &&\n    typeof page.hasPrevious === 'boolean'\n    ? { refs: page.refs.map(key), hasNext: page.hasNext, hasPrevious: page.hasPrevious }\n    : refuse()\n}\n\n/**\n * `Remote.patch`'s values as the store holds them: each relation's refs\n * written as ref keys. A relation given anything but a ref to its target (a\n * ref key typed by hand, a ref to another Entity) is refused here, where the\n * patch is made.\n */\nexport const wireValues = (\n  descriptor: EntityDescriptor<string, Schema.Struct.Fields>,\n  values: Readonly<Record<string, unknown>>,\n): Readonly<Record<string, unknown>> => {\n  const relations = relationsOf(descriptor.fields)\n  if (relations.size === 0) return values\n  return Object.fromEntries(\n    Object.entries(values).map(([field, value]) => {\n      const shape = relations.get(field)\n      if (shape === undefined) return [field, value]\n      const refuse = (): never => {\n        const takes = { one: 'a ref', many: 'an array of refs', page: 'a page of refs' }[shape.kind]\n        throw new Error(\n          `Remote.patch: \"${field}\" of \"${descriptor.name}\" takes ${takes} to ${shape.entity} (Remote.ref(${shape.entity}, id))${shape.nullable ? ' or null' : ''}, not ${JSON.stringify(value)}`,\n        )\n      }\n      return [field, wireRelation(shape, value, refuse)]\n    }),\n  )\n}\n"],"mappings":";;;AASA,MAAM,iCAAiB,IAAI,QAAkE;;AAG7F,MAAM,eAAe,WAAqE;CACxF,MAAM,QAAQ,eAAe,IAAI,MAAM;CACvC,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,MAAM,yBAAS,IAAI,IAA2B;CAC9C,KAAK,MAAM,CAAC,KAAK,WAAW,OAAO,QAAQ,MAAM,GAAG;EAClD,MAAM,QAAQ,cAAc,MAAM;EAClC,IAAI,UAAU,KAAA,GAAW,OAAO,IAAI,KAAK,KAAK;CAChD;CACA,eAAe,IAAI,QAAQ,MAAM;CACjC,OAAO;AACT;AAEA,MAAM,WAAW,OAAgB,WAC/B,UAAU,QACV,OAAO,UAAU,YAChB,MAAqC,WAAW,UACjD,OAAQ,MAAqC,OAAO;;AAGtD,MAAM,gBAAgB,OAAsB,OAAgB,WAAiC;CAC3F,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,IAAI,UAAU,MAAM,OAAO,MAAM,WAAW,OAAO,OAAO;CAC1D,MAAM,OAAO,QACX,QAAQ,KAAK,MAAM,MAAM,IAAI,UAAU,IAAI,QAAQ,IAAI,EAAE,IAAI,OAAO;CACtE,IAAI,MAAM,SAAS,OAAO,OAAO,IAAI,KAAK;CAC1C,IAAI,MAAM,SAAS,QAAQ,OAAO,MAAM,QAAQ,KAAK,IAAI,MAAM,IAAI,GAAG,IAAI,OAAO;CACjF,MAAM,OAAO;CACb,OAAO,MAAM,QAAQ,KAAK,IAAI,KAC5B,OAAO,KAAK,YAAY,aACxB,OAAO,KAAK,gBAAgB,YAC1B;EAAE,MAAM,KAAK,KAAK,IAAI,GAAG;EAAG,SAAS,KAAK;EAAS,aAAa,KAAK;CAAY,IACjF,OAAO;AACb;;;;;;;AAQA,MAAa,cACX,YACA,WACsC;CACtC,MAAM,YAAY,YAAY,WAAW,MAAM;CAC/C,IAAI,UAAU,SAAS,GAAG,OAAO;CACjC,OAAO,OAAO,YACZ,OAAO,QAAQ,MAAM,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW;EAC7C,MAAM,QAAQ,UAAU,IAAI,KAAK;EACjC,IAAI,UAAU,KAAA,GAAW,OAAO,CAAC,OAAO,KAAK;EAC7C,MAAM,eAAsB;GAC1B,MAAM,QAAQ;IAAE,KAAK;IAAS,MAAM;IAAoB,MAAM;GAAiB,EAAE,MAAM;GACvF,MAAM,IAAI,MACR,kBAAkB,MAAM,QAAQ,WAAW,KAAK,UAAU,MAAM,MAAM,MAAM,OAAO,eAAe,MAAM,OAAO,QAAQ,MAAM,WAAW,aAAa,GAAG,QAAQ,KAAK,UAAU,KAAK,GACtL;EACF;EACA,OAAO,CAAC,OAAO,aAAa,OAAO,OAAO,MAAM,CAAC;CACnD,CAAC,CACH;AACF"}

package/dist/persistence-CCMnvg7-.d.ts

@@ -0,0 +1,114 @@
+import { i as Edge, n as Connection } from "./connection-BRyaJy89.js";
+import { r as EntityStore } from "./store-ah2qjcJW.js";
+import { n as ConnectionIdentity } from "./optimistic-CECsfNGY.js";
+import { Effect, Option } from "effect";
+import { KeyValueStore } from "effect/persistence";
+/** Bump when the serialized shape changes; a mismatch discards the cache. */
+declare const REMOTE_CACHE_VERSION = 5;
+/**
+ * What survives a reload: the entity cache, and the connections an application
+ * **declared** should come back.
+ *
+ * Connections are session state by default and stay that way — `snapshotOf`
+ * takes none unless asked. What a declared one keeps is its **edges and
+ * nothing else**, which is not a simplification but the rule: a connection's
+ * boundaries are cursors the server minted, and a cursor may name server state
+ * that no longer exists. Restoring one would be claiming to know where the
+ * page ends. The shape has nowhere to put a cursor, so that cannot be got
+ * wrong later.
+ */
+interface Snapshot {
+  readonly entities: EntityStore;
+  /**
+   * By connection identity: its **segments**, each a run of edges. No
+   * boundaries.
+   *
+   * Segments rather than one flat list, because the gaps between them are
+   * knowledge too. A connection paged from both ends holds a head and a tail
+   * with an unfetched middle; flattening those into one run would claim the
+   * tail's first row follows the head's last, which is a thing the client was
+   * never told.
+   */
+  readonly connections: Readonly<Record<string, ReadonlyArray<ReadonlyArray<Edge>>>>;
+}
+/**
+ * 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.
+ */
+declare const snapshotOf: (model: {
+  readonly entities: EntityStore;
+  readonly connections: Readonly<Record<string, Connection>>;
+}, options?: {
+  readonly connections?: ReadonlyArray<ConnectionIdentity> | undefined;
+}) => Snapshot;
+interface SnapshotOptions {
+  /**
+   * Who or what the snapshot is for (a user id, a tenant, a build). A snapshot
+   * taken under another scope is discarded rather than shown to the wrong
+   * reader. Default: unscoped, which only matches unscoped.
+   */
+  readonly scope?: string | undefined;
+  /** Snapshots larger than this many bytes are not written and not read. */
+  readonly maxBytes?: number | undefined;
+}
+/** How a snapshot meets a store that already has entries. */
+type MergePolicy = 'replace' | 'preserve-existing';
+/**
+ * The snapshot text, or `undefined` when it would exceed `maxBytes`. Build the
+ * snapshot with `snapshotOf`, which is where the connections that survive are
+ * named; runtime state — optimistic layers, live cursors, gaps, the mutation
+ * ledger — is never in one.
+ */
+declare function dehydrate(snapshot: Snapshot, options?: SnapshotOptions & {
+  readonly maxBytes?: undefined;
+}): string;
+declare function dehydrate(snapshot: Snapshot, options?: SnapshotOptions): string | undefined;
+/**
+ * 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.
+ */
+declare const hydrate: (raw: string | undefined | null, options?: SnapshotOptions) => Option.Option<Snapshot>;
+/**
+ * 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.
+ */
+declare const mergeStores: (current: EntityStore, snapshot: EntityStore, policy: MergePolicy) => EntityStore;
+declare const RemotePersistence: {
+  /** The snapshot text, or `undefined` when it would exceed `maxBytes`. */
+  dehydrate: typeof dehydrate;
+  /** What a snapshot text holds, or none when it is refused. */
+  hydrate: typeof 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: typeof snapshotOf;
+  /** A snapshot's entities brought into a store by policy. */
+  mergeStores: typeof mergeStores;
+  /** The cache as a fresh session has it; what a refused `restore` yields. */
+  emptySnapshot: Snapshot;
+  /**
+   * 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: Snapshot, options: {
+    readonly key: string;
+  } & SnapshotOptions) => Effect.Effect<void, KeyValueStore.KeyValueStoreError, KeyValueStore.KeyValueStore>;
+  /**
+   * 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: {
+    readonly key: string;
+  } & SnapshotOptions) => Effect.Effect<Snapshot, KeyValueStore.KeyValueStoreError, KeyValueStore.KeyValueStore>;
+};
+export { SnapshotOptions as a, Snapshot as i, REMOTE_CACHE_VERSION as n, RemotePersistence as r, MergePolicy as t };
+//# sourceMappingURL=persistence-CCMnvg7-.d.ts.map

package/dist/persistence-CCMnvg7-.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence-CCMnvg7-.d.ts","names":[],"sources":["../src/persistence.ts"],"mappings":";;;;;;cAqBa;;;;;;;;;;;;;UAcI;WACN,UAAU;;;;;;;;;;;WAWV,aAAa,SAAS,eAAe,cAAc,cAAc;;;;;;;;;cAUtE,aAAU;WAEH,UAAU;WACV,aAAa,SAAS,eAAe;GAC/C;WACmB,cAAc,cAAc;MAC/C;UAac;;;;;;WAMN;;WAEA;;;KAIC;;;;;;;iBAiHH,UACP,UAAU,UACV,UAAU;WAA6B;;iBAEhC,UAAU,UAAU,UAAU,UAAU;;;;;;cAuB3C,UAAO,gCACmB,UACrB,oBACR,OAAO,OAAO;;;;;;;cAgCX,cAAW,SACN,aAAW,UACV,aAAW,QACb,gBACP;cAUU;;;;;;;;;;;;;;;;;;;EAoBM,OAAA,UAAA,UAAQ;aAAsB;MAAgB,oBAAe,OAAA,aAAA,cAAA,oBAAA,cAAA;;;;;;EAa3D,UAAA;aAAW;MAAgB,oBAAe,OAAA,OAAA,UAAA,cAAA,oBAAA,cAAA"}

package/dist/persistence.d.ts

@@ -0,0 +1,2 @@
+import { a as SnapshotOptions, i as Snapshot, n as REMOTE_CACHE_VERSION, r as RemotePersistence, t as MergePolicy } from "./persistence-CCMnvg7-.js";
+export { MergePolicy, REMOTE_CACHE_VERSION, RemotePersistence, Snapshot, SnapshotOptions };