foldkit-remote 0.19.0 → 0.21.0

package/dist/{src-fsYu0YoT.mjs → src-lVP_7bf4.mjs}

@@ -1,14 +1,14 @@
 import { Context, Data, Deferred, Duration, Effect, Layer, Match, Option, Predicate, Record, Request, RequestResolver, Result, Schema, SchemaAST, SchemaGetter, Stream } from "effect";
 import { KeyValueStore } from "effect/persistence";
 import * as Domain from "foldkit-entity";
-import { Entity, Expr, Query, QueryEvaluateError, ReadFilter, SchemaShape, SelectionTypeId, Write, compareRows, dependenciesOf, evaluate } from "foldkit-entity";
+import { Entity, Expr, Operators, Query, QueryEvaluateError, ReadFilter, SchemaShape, SelectionTypeId, Write, compareRows, dependenciesOf, evaluateEach } from "foldkit-entity";
 import { mapMessage } from "foldkit/command";
 import { defineMessageUnion } from "foldkit/message";
 import * as Subscription from "foldkit/subscription";
 import { Metadata } from "foldkit-surface";
 import { Rpc, RpcGroup } from "effect/rpc";
 import { defineTaggedUnion } from "foldkit/schema";
-//#region src/requirement.ts
+// src/requirement.ts
 /**
 * What a Remote Projection needs from the server: entity slices and query
 * connections. They ride on `Projection.metadata` under Remote's own keys, so
@@ -110,8 +110,7 @@ const RemoteConnections = Metadata.key("remote.connection", {
 const requirementsOf = (projection) => RemoteRequirements.get(projection.metadata);
 /** The query connections a Projection carries. */
 const connectionsOf = (projection) => RemoteConnections.get(projection.metadata);
-//#endregion
-//#region src/data.ts
+// src/data.ts
 /**
 * Whether two values the server sent are the same data: equal primitives, or
 * arrays and plain objects whose entries are. Anything else is compared by
@@ -129,8 +128,7 @@ const isPlain = (value) => {
 	const prototype = Object.getPrototypeOf(value);
 	return prototype === Object.prototype || prototype === null;
 };
-//#endregion
-//#region src/relation.ts
+// src/relation.ts
 /**
 * Relation values on the wire and in the store: a ref key (`"Entity:id"`), a
 * nullable ref key, an array of ref keys, or a page of ref keys. The planner
@@ -218,8 +216,7 @@ const shapeOf = (ast, nullable) => {
 		}
 	}
 };
-//#endregion
-//#region src/store.ts
+// src/store.ts
 /**
 * The pure entity store: values, per-field presence, staleness, and tombstones.
 *
@@ -406,8 +403,7 @@ const missingFields = (store, key, fields, windows) => {
 		return requested !== void 0 && stored !== void 0 && stored !== "" && stored !== requested;
 	});
 };
-//#endregion
-//#region src/mutation.ts
+// src/mutation.ts
 /**
 * Mutation status and idempotent reconciliation.
 *
@@ -560,16 +556,17 @@ const patchOfWrite = (bound) => ({
 /**
 * What a declared write shows before the server answers: an update's or an
 * insert's row as a patch (an update's only for the keys named, when some
-* are), and an update's increments as amounts over the value the store holds. A delete shows nothing, since no operation removes a row from every
-* list it is in; its answer does.
+* are), and an update's increments and computed fields, worked out over the
+* row the store holds when it is read. A delete shows nothing, since no
+* operation removes a row from every list it is in; its answer does.
 */
 const optimisticOfWrite = (write, input, keys) => Match.value(write).pipe(Match.tagsExhaustive({
 	Update: () => {
 		const bound = Write.bind(write, input, keys);
-		const patch = patchOfWrite(bound);
-		return [Object.keys(bound.increments).length === 0 ? patch : {
-			...patch,
-			adds: bound.increments
+		return [{
+			...patchOfWrite(bound),
+			...Object.keys(bound.increments).length === 0 ? {} : { adds: bound.increments },
+			...Object.keys(bound.assignments).length === 0 ? {} : { computes: bound.assignments }
 		}];
 	},
 	Insert: () => {
@@ -612,8 +609,7 @@ const Mutation = {
 		Refusal: config.Refusal ?? Schema.Never
 	})
 };
-//#endregion
-//#region src/query.ts
+// src/query.ts
 /**
 * Queries and connections. A connection's identity is its descriptor plus the
 * canonical encoded filter/sort input — **never** the pagination window, so
@@ -755,8 +751,7 @@ const Query$1 = {
 		}
 	})
 };
-//#endregion
-//#region src/wire.ts
+// src/wire.ts
 /**
 * The Remote wire: Effect RPC semantics over `effect/rpc`. Remote owns
 * the message shapes; Effect owns the transport. `Make`ing reads batch, mutations
@@ -1027,8 +1022,7 @@ const QueryRpc = Rpc.make("FoldkitRemoteQuery", {
 	error: Schema.Union([RemoteQueryError, RemoteUnauthenticated])
 });
 const RemoteRpc = RpcGroup.make(Read, Mutate, QueryRpc, Live);
-//#endregion
-//#region src/coalesce.ts
+// src/coalesce.ts
 /**
 * Read coalescing: every requirement a client asks for goes through one
 * `RequestResolver`, so requirements issued together become one `ReadBatch`
@@ -1152,8 +1146,7 @@ const coalesceReads = (read, options = {}) => Effect.gen(function* () {
 		};
 	}));
 });
-//#endregion
-//#region src/client.ts
+// src/client.ts
 /**
 * The transport seam: the `RemoteClient` Effect service, the RPC client it is
 * built from, the wire-to-client reconstructions, and the mutation call.
@@ -1286,8 +1279,7 @@ const mutateRemote = Effect.fn("Remote.mutate")(function* (mutation, input, requ
 		deleted: result.deleted ?? []
 	};
 });
-//#endregion
-//#region src/connection.ts
+// src/connection.ts
 /**
 * The pure connection model: an ordered normalized structure of edges with
 * explicit known boundaries. Pages, live events, and optimistic inserts are all
@@ -1401,7 +1393,10 @@ const dedupeConnection = (segments) => {
 /** Adds a page to the connection, joining contiguous or overlapping segments. */
 const merge = (current, page) => {
 	const incoming = normalize(page);
-	if (incoming.edges.length === 0) return current;
+	if (incoming.edges.length === 0) return incoming.start._tag === "Terminal" && incoming.end._tag === "Terminal" && current.segments.length === 0 ? {
+		...current,
+		segments: [incoming]
+	} : current;
 	const segments = [...current.segments.map(normalize), incoming];
 	let joined = true;
 	while (joined) {
@@ -1450,8 +1445,7 @@ const hasNext = (connection) => {
 };
 /** A connection with more than one segment has an explicit unknown gap. */
 const isGapped = (connection) => connection.segments.length > 1;
-//#endregion
-//#region src/selection.ts
+// src/selection.ts
 /**
 * Selections: the fields a Surface picks of an entity (nested through
 * relations, paged through connections), the requirement graph they imply,
@@ -1633,8 +1627,7 @@ const assembleRelation = (store, value, relation) => {
 		refreshing
 	};
 };
-//#endregion
-//#region src/entity.ts
+// src/entity.ts
 /**
 * Entities: the descriptor an application declares, refs, ref pages, and
 * patches, with the codecs that carry refs on the wire.
@@ -1722,8 +1715,7 @@ const Entity$1 = {
 		values: patch
 	})
 };
-//#endregion
-//#region src/placement.ts
+// src/placement.ts
 /**
 * Where one row falls in a loaded list, by the list's own declared order:
 * the decidable half of placing a row instead of fetching the list again.
@@ -1740,16 +1732,14 @@ const Entity$1 = {
 */
 const RowPlace = Data.taggedEnum();
 /**
-* The values a row holds of the fields an order reads, or none when it lacks
-* one. An `id` no Selection stored is its key's, when the id is stored as
+* The values a row holds of the fields an order reads, a call's arguments
+* included, or none when it lacks one. An `id` no Selection stored is its key's, when the id is stored as
 * text as a key holds it, so the id tie-break every order ends on does not
 * make such a row unplaceable; a number id is never compared as text.
 */
 const keysOf = (store, key, id, idIsText, terms) => {
 	const values = Object.create(null);
-	for (const term of terms) {
-		if (term.expr._tag !== "Field") return Option.none();
-		const field = term.expr.key;
+	for (const { key: field } of dependenciesOf(...terms).fields) {
 		const stored = readField(store, key, field);
 		const value = field === "id" && Option.isNone(stored) && idIsText ? id : stored;
 		if (Option.isNone(value)) return Option.none();
@@ -1759,12 +1749,12 @@ const keysOf = (store, key, id, idIsText, terms) => {
 };
 /**
 * Where the row stored under `key` falls in `connection`, by `body`'s order
-* for `input` (encoded, as a connection's identity carries it). The row's own
-* edge, if the list holds it, is left out: placing a row that moved asks
-* where it goes now.
+* for `input` (encoded, as a connection's identity carries it), a call in it
+* run by `operators`. The row's own edge, if the list holds it, is left out:
+* placing a row that moved asks where it goes now.
 */
-const placeIn = (store, connection, body, input, key) => {
-	const placement = Query.placement(body, input);
+const placeIn = (store, connection, body, input, key, operators) => {
+	const placement = Query.placement(body, input, { operators });
 	if (placement._tag === "NotPlaceable") return RowPlace.Unknown({ reason: placement.reason });
 	const terms = Query.orderFor(body, input);
 	const prefix = `${body.entity.name}:`;
@@ -1776,7 +1766,10 @@ const placeIn = (store, connection, body, input, key) => {
 	/** Negative when the row sorts before the edge; none when the edge cannot be compared. */
 	const against = (edge) => Option.flatMap(keysOf(store, entityKey(edge.ref.entity, edge.ref.id), Option.some(edge.ref.id), idIsText, terms), (values) => {
 		try {
-			return Option.some(compareRows(terms, row.value, values, body.entity.name));
+			return Option.some(compareRows(terms, row.value, values, body.entity.name, {
+				input,
+				operators
+			}));
 		} catch {
 			return Option.none();
 		}
@@ -1832,8 +1825,7 @@ const withEdge = (connection, added, place) => ({
 		};
 	})
 });
-//#endregion
-//#region src/matching.ts
+// src/matching.ts
 /**
 * Running a query body against the rows the client already holds.
 *
@@ -1919,9 +1911,11 @@ const matchingEncoded = (store, descriptor, encoded, options = {}) => {
 			__key: key
 		});
 	}
+	const judged = evaluateEach(body, encoded, rows, { operators: options.operators });
+	const keyOf = (row) => row.__key;
 	return {
-		matched: evaluate(body, encoded, rows).map((row) => row.__key),
-		skipped
+		matched: judged.matched.map(keyOf),
+		skipped: [...skipped, ...judged.refused.map(keyOf)]
 	};
 };
 /**
@@ -1933,7 +1927,7 @@ const matchingEncoded = (store, descriptor, encoded, options = {}) => {
 * asymmetry with `matching`, which takes a decoded input, is the shape of the
 * two real callers rather than an oversight.
 */
-const belongsEncoded = (store, descriptor, encoded, key) => {
+const belongsEncoded = (store, descriptor, encoded, key, operators) => {
 	const entry = store[key];
 	if (entry === void 0) return "unknown";
 	if (entry.tombstone) return "no";
@@ -1941,7 +1935,10 @@ const belongsEncoded = (store, descriptor, encoded, key) => {
 	if (body !== void 0 && decidableOn(body).some((field) => entry.stale.has(field))) return "unknown";
 	let judged;
 	try {
-		judged = matchingEncoded(store, descriptor, encoded, { among: [key] });
+		judged = matchingEncoded(store, descriptor, encoded, {
+			among: [key],
+			operators
+		});
 	} catch (error) {
 		if (error instanceof QueryEvaluateError) return "unknown";
 		throw error;
@@ -1950,8 +1947,7 @@ const belongsEncoded = (store, descriptor, encoded, key) => {
 	if (judged.skipped.includes(key)) return "unknown";
 	return "no";
 };
-//#endregion
-//#region src/impact.ts
+// src/impact.ts
 /**
 * What a write did to the lists the client holds: given one change and one
 * loaded connection, whether the connection is still right as it stands.
@@ -2014,7 +2010,7 @@ const sameOrder = (left, right) => left.segments.length === right.segments.lengt
 * What `change` does to `connection`, judged against `store`, the store after
 * the write.
 */
-const impactOn = (connection, store, change) => {
+const impactOn = (connection, store, change, operators) => {
 	const { descriptor } = connection;
 	const body = descriptor.body;
 	if ((body?.entity.name ?? descriptor.Result.entity) !== change.entity) return kept;
@@ -2040,7 +2036,7 @@ const impactOn = (connection, store, change) => {
 			const refilters = touches(roles.predicate);
 			const unloaded = hasPrevious(pages) || hasNext(pages) || isGapped(pages);
 			if (!(held && reorders) && !refilters && !(!held && (created || reorders && unloaded))) return kept;
-			const belongs = held && !refilters ? "yes" : belongsEncoded(store, descriptor, connection.encoded, key);
+			const belongs = held && !refilters ? "yes" : belongsEncoded(store, descriptor, connection.encoded, key, operators);
 			if (belongs === "unknown") return Impact.Invalidated({ reason: `${key} changed a field "${descriptor.name}" filters on, and the client cannot judge it` });
 			if (!held && belongs === "no") return kept;
 			if (held && belongs === "yes" && !reorders) return kept;
@@ -2055,7 +2051,7 @@ const impactOn = (connection, store, change) => {
 				}), place);
 				return sameOrder(pages, next) ? kept : Impact.Placed({ connection: next });
 			};
-			return RowPlace.$match(placeIn(store, pages, body, connection.encoded, key), {
+			return RowPlace.$match(placeIn(store, pages, body, connection.encoded, key, operators), {
 				Before: placedAt,
 				End: placedAt,
 				Outside: () => held ? Impact.Placed({ connection: withoutEdge(pages, key) }) : kept,
@@ -2064,8 +2060,7 @@ const impactOn = (connection, store, change) => {
 		}
 	});
 };
-//#endregion
-//#region src/inspect.ts
+// src/inspect.ts
 const inspectEntry = (key, entry) => ({
 	key,
 	present: [...entry.present],
@@ -2095,8 +2090,7 @@ const inspectEntity = (model, key) => {
 	const entry = model.entities[key];
 	return entry === void 0 ? void 0 : inspectEntry(key, entry);
 };
-//#endregion
-//#region src/optimistic.ts
+// src/optimistic.ts
 /**
 * Optimistic layers. Pending changes are held as ordered layers over a base
 * store and as overlays over a connection; the visible value is recomputed, never
@@ -2202,7 +2196,7 @@ const removeOverlay = (optimistic, id) => {
 * entity only a request holds (a temporary id) is not the server's to age, and
 * is dated `Infinity`, so freshness never plans or times it.
 */
-const visibleStore = (base, optimistic) => writeEntities(base, resolvedPatches(base, optimistic).map((patch) => {
+const visibleStore = (base, optimistic, operators = Operators.kernel) => writeEntities(base, resolvedPatches(base, optimistic, operators).map((patch) => {
 	const key = entityKey(patch.entity, patch.id);
 	const under = base[key];
 	return {
@@ -2212,32 +2206,56 @@ const visibleStore = (base, optimistic) => writeEntities(base, resolvedPatches(b
 	};
 }));
 /**
-* Every pending patch in order, each amount added to the value under it: the
-* store's, or an earlier layer's. A prediction, so only over a number the
-* client holds: a field it has not read, or holds as anything else, keeps
-* what it shows until the server answers with the sum.
+* Every pending patch in order, each amount added and each computed field
+* worked out over the row under it (the store's, with earlier layers over
+* it) by `Write.apply`, with the client's table (the kernel's when not
+* given). A prediction, so only over
+* what the client holds: a field it has not read, an amount over anything
+* but a number, or a computation by an operator its table lacks keeps what
+* it shows until the server answers.
 */
-const resolvedPatches = (base, optimistic) => {
+const resolvedPatches = (base, optimistic, operators = Operators.kernel) => {
 	const shown = /* @__PURE__ */ new Map();
-	return optimistic.layers.flatMap((layer) => layer.patches.map(({ adds, ...patch }) => {
+	const unsure = /* @__PURE__ */ new Map();
+	return optimistic.layers.flatMap((layer) => layer.patches.map(({ adds, computes, ...patch }) => {
 		const key = entityKey(patch.entity, patch.id);
 		const earlier = shown.get(key) ?? {};
+		const unknown = new Set([...unsure.get(key) ?? []].filter((field) => !Object.hasOwn(patch.values, field)));
 		const values = { ...patch.values };
-		const under = base[key];
-		const valueUnder = (field) => Object.hasOwn(earlier, field) ? Option.some(earlier[field]) : Option.fromUndefinedOr(under?.values[field]);
-		for (const [field, amount] of Object.entries(adds ?? {})) Option.map(Option.filter(valueUnder(field), Predicate.isNumber), (current) => {
-			values[field] = current + amount;
-		});
+		const row = Object.fromEntries(Object.entries({
+			...base[key]?.values,
+			...earlier
+		}).filter(([field]) => !unknown.has(field)));
+		const moved = {
+			values: {},
+			increments: adds ?? {},
+			assignments: computes ?? {}
+		};
+		const predicted = predicting(() => Write.apply(row, moved, { operators }));
+		for (const field of [...Object.keys(moved.increments), ...Object.keys(moved.assignments)]) if (predicted !== void 0 && !predicted.unknown.includes(field)) {
+			values[field] = predicted.row[field];
+			unknown.delete(field);
+		} else unknown.add(field);
 		shown.set(key, {
 			...earlier,
 			...values
 		});
+		unsure.set(key, unknown);
 		return {
 			...patch,
 			values
 		};
 	}));
 };
+/** A prediction, or none where an operator refuses the row it is given: the server will answer. */
+const predicting = (predict) => {
+	try {
+		return predict();
+	} catch (error) {
+		if (error instanceof QueryEvaluateError) return void 0;
+		throw error;
+	}
+};
 /**
 * A fresh page is newer than any settled overlay it covers: an edge the page
 * carries no longer needs an insert overlay, and a `remove` overlay hiding it
@@ -2311,8 +2329,7 @@ const visibleItems = (connection, connectionId, overlays, store) => {
 		...take("append")
 	];
 };
-//#endregion
-//#region src/live.ts
+// src/live.ts
 const emptyLiveState = {
 	cursor: 0,
 	boundary: {}
@@ -2432,8 +2449,7 @@ const applyConnectionEvent = (state, optimistic, event, policy = {}) => {
 const liveHasPrevious = (connection, state, connectionId) => hasPrevious(connection) || (state.boundary[connectionId]?.before ?? 0) > 0;
 /** `hasNext` accounting for edges recorded outside the loaded boundary. */
 const liveHasNext = (connection, state, connectionId) => hasNext(connection) || (state.boundary[connectionId]?.after ?? 0) > 0;
-//#endregion
-//#region src/plan.ts
+// src/plan.ts
 /**
 * The pure requirement planner.
 *
@@ -2526,8 +2542,7 @@ const plan = (store, requirements, options = {}) => {
 	const nested = followed.length === 0 ? [] : plan(store, followed, options);
 	return [...Requirement.merge([...planned, ...nested])].sort((a, b) => entityKey(a.entity, a.id) < entityKey(b.entity, b.id) ? -1 : 1);
 };
-//#endregion
-//#region src/retain.ts
+// src/retain.ts
 /**
 * The entity keys the roots reach: each root entity, the targets its retained
 * fields refer to, and recursively the targets a nested relation selects.
@@ -2599,8 +2614,7 @@ const keptOf = (record, keep) => {
 	const kept = entries.filter(([key]) => keep(key));
 	return kept.length === entries.length ? record : Object.fromEntries(kept);
 };
-//#endregion
-//#region src/persistence.ts
+// src/persistence.ts
 /**
 * Remote cache persistence: a snapshot of the entity store and nothing else.
 * Runtime state (connections' live cursors, optimistic layers, the mutation
@@ -2797,8 +2811,7 @@ const RemotePersistence = {
 		return restored;
 	})
 };
-//#endregion
-//#region src/remoteData.ts
+// src/remoteData.ts
 /** `RemoteData`: the state of a value the store may not hold yet. */
 /**
 * The server would not answer who is asking: their session ended or was
@@ -2954,8 +2967,7 @@ const RemoteData = {
 		}
 	}
 };
-//#endregion
-//#region src/model.ts
+// src/model.ts
 /**
 * The Remote submodel: the store, connections, mutations, live state, and
 * optimistic layers an application keeps in its Model, the Messages that
@@ -3842,8 +3854,7 @@ const writeRead = (store, requests, result, now = 0) => {
 	}
 	return setUnavailable(writeEntities(answered, writes, now), result.settled.map((entry) => [entityKey(entry.entity, entry.id), entry.fields]), true);
 };
-//#endregion
-//#region src/policy.ts
+// src/policy.ts
 const RemotePolicy = {
 	/** Fetch only what the store lacks. */
 	cacheFirst: { _tag: "CacheFirst" },
@@ -3872,8 +3883,7 @@ const RemotePolicy = {
 	*/
 	refreshes: (policy) => policy._tag !== "CacheFirst"
 };
-//#endregion
-//#region src/resume.ts
+// src/resume.ts
 /**
 * What of Remote's state crosses from a server render to the browser.
 *
@@ -4087,8 +4097,7 @@ const resumePart = (domain, options = {}) => ({
 		onSuccess: (capture) => Result.succeed(domain.store.set(model, restoreRemote(domain.store.get(model), capture)))
 	})
 });
-//#endregion
-//#region src/json.ts
+// src/json.ts
 /**
 * Remote's three calls as JSON: one request, `{ operation, payload }`, and one
 * answer, `{ result }` or `{ error }`. `RemoteServer.answer` is the other end.
@@ -4193,8 +4202,7 @@ const http = (url, options = {}) => json(async (request) => {
 	if (body === notJson) throw new Error(status);
 	return body;
 });
-//#endregion
-//#region src/sse.ts
+// 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
@@ -4314,8 +4322,7 @@ const httpWithLive = (url, options = {}) => ({
 	...http(url, options),
 	FoldkitRemoteLive: liveFetch(url, options)
 });
-//#endregion
-//#region src/index.ts
+// src/index.ts
 /**
 * `foldkit-remote` — normalized application-facing server state.
 *
@@ -4330,7 +4337,11 @@ const explainedDependencies = (dependencies) => ({
 		key
 	})),
 	inputs: dependencies.inputs,
-	operations: dependencies.operations
+	operations: dependencies.operations,
+	operators: dependencies.operators.map(({ id, version }) => ({
+		id,
+		version
+	}))
 });
 const descriptorOf = (entity) => Entity.is(entity) ? Entity$1.from(entity) : entity;
 const selectionOf = (selection) => SelectionTypeId in selection ? Selection.from(selection) : selection;
@@ -4357,11 +4368,11 @@ const readContract = (source, shape, window) => {
 * compared with neighbours that hold those fields. What the view reads, and so
 * decodes, stays its Selection.
 */
-const placeableReadContract = (contract, body) => {
+const placeableReadContract = (contract, body, operators) => {
 	if (body === void 0) return contract;
 	const { requirement, ref } = contract;
 	const encoded = Schema.encodeSync(ref.Input)(ref.input);
-	if (Query.placement(body, encoded)._tag !== "Placeable") return contract;
+	if (Query.placement(body, encoded, { operators })._tag !== "Placeable") return contract;
 	const missing = Query.dependencies(body).fields.filter((field) => !requirement.select.fields.includes(field.key));
 	if (missing.length === 0) return contract;
 	return {
@@ -4375,8 +4386,8 @@ const placeableReadContract = (contract, body) => {
 		}
 	};
 };
-const metaOf = (remote, asked) => {
-	const visible = visibleStoreOf(remote.entities, remote.optimistic);
+const metaOf = (remote, asked, operators) => {
+	const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
 	let updatedAt;
 	let stale = false;
 	let loading = false;
@@ -4426,7 +4437,7 @@ const metaOf = (remote, asked) => {
 */
 const storeOf = (bound, model) => {
 	const remote = bound.store.get(model);
-	return visibleStoreOf(remote.entities, remote.optimistic);
+	return visibleStoreOf(remote.entities, remote.optimistic, bound.operators);
 };
 /**
 * The Model as it would be with nothing optimistic pending. Every read reaches
@@ -4445,15 +4456,20 @@ const confirmed = (bound, projection) => ({
 	read: (root) => projection.read(withoutOptimistic(bound, root))
 });
 const visibleStores = /* @__PURE__ */ new WeakMap();
-const visibleStoreOf = (entities, optimistic) => {
-	let byStore = visibleStores.get(optimistic.layers);
+const visibleStoreOf = (entities, optimistic, operators) => {
+	let byLayers = visibleStores.get(operators);
+	if (byLayers === void 0) {
+		byLayers = /* @__PURE__ */ new WeakMap();
+		visibleStores.set(operators, byLayers);
+	}
+	let byStore = byLayers.get(optimistic.layers);
 	if (byStore === void 0) {
 		byStore = /* @__PURE__ */ new WeakMap();
-		visibleStores.set(optimistic.layers, byStore);
+		byLayers.set(optimistic.layers, byStore);
 	}
 	let visible = byStore.get(entities);
 	if (visible === void 0) {
-		visible = visibleStore(entities, optimistic);
+		visible = visibleStore(entities, optimistic, operators);
 		byStore.set(entities, visible);
 	}
 	return visible;
@@ -4562,9 +4578,10 @@ const defineRemote = (config) => {
 	};
 };
 /** Binds a Remote domain to its store's location in the application Model. */
-const bindRemote = (definition, store) => ({
+const bindRemote = (definition, store, operators) => ({
 	definition,
 	store,
+	operators,
 	contract: {
 		kind: "remote",
 		name: store.dependency.join(".") || "remote",
@@ -4670,7 +4687,7 @@ const missingRows = (known, window, size) => {
 		before: to.cursor
 	};
 };
-const planAsked = (remote, asked, options) => {
+const planAsked = (remote, asked, options, operators) => {
 	const queries = [];
 	const items = [];
 	const connections = Requirement.mergeConnections(asked.connections);
@@ -4688,7 +4705,7 @@ const planAsked = (remote, asked, options) => {
 		const edges = visibleItems(known, connection.identity, remote.optimistic.overlays, remote.entities);
 		items.push(...itemsOf(edges.map((edge) => edge.ref), connection.select));
 	}
-	const visible = visibleStoreOf(remote.entities, remote.optimistic);
+	const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
 	const read = [...asked.requirements, ...items];
 	const planned = plan(visible, read, options);
 	return {
@@ -4891,7 +4908,7 @@ const observeEntry = (bound, askedOf, toMessage, options) => {
 			let byAsked = planned.get(remote);
 			const known = byAsked?.get(askedKey);
 			if (known !== void 0 && at < known.until) return known.dependencies;
-			const plan = planAsked(remote, asked, RemotePolicy.toPlan(policy, at));
+			const plan = planAsked(remote, asked, RemotePolicy.toPlan(policy, at), bound.operators);
 			const dependencies = {
 				refresh: refreshedAt(remote.refresh, plan.requirements, plan.queries.map((query) => query.identity)),
 				requirements: plan.requirements,
@@ -5122,7 +5139,10 @@ const Remote = {
 	* in one step; the result carries the application-facing operations. The
 	* descriptor alone is `Remote.define`, the binding alone `Remote.at`.
 	*/
-	make: (config) => bindDomain(defineRemote(config), config.model, { verifyPlacement: config.verifyPlacement }),
+	make: (config) => bindDomain(defineRemote(config), config.model, {
+		verifyPlacement: config.verifyPlacement,
+		operators: config.operators
+	}),
 	/**
 	* Declares a Remote domain without binding it: its entities, queries, and
 	* mutations, plus the submodel. For a domain reused across applications or
@@ -5132,9 +5152,11 @@ const Remote = {
 	/**
 	* Binds a Remote domain to its store's location in the application Model. The
 	* registered entity names are carried on the returned value, so `Remote.select`
-	* rejects a selection for an entity this domain never declared.
+	* rejects a selection for an entity this domain never declared. `operators`
+	* is the client's table, which a pending computed assignment is predicted by
+	* (`Operators.kernel` when not given), as `Remote.make`'s is.
 	*/
-	at: bindRemote,
+	at: (definition, store, options = {}) => bindRemote(definition, store, options.operators ?? Operators.kernel),
 	/**
 	* The resume part for this domain, for `foldkit-ssr`'s `SSR.plan({ parts })`:
 	* a server render sends what the plan's active Surfaces read from the store,
@@ -5219,18 +5241,18 @@ const Remote = {
 	* connection marked stale; `loading` is any of them in flight. Optimistic
 	* previews do not date: showing only one reads `updatedAt: undefined`.
 	*/
-	meta: (bound, model, projection) => metaOf(bound.store.get(model), askedOf(projection)),
+	meta: (bound, model, projection) => metaOf(bound.store.get(model), askedOf(projection), bound.operators),
 	/**
 	* The pure plan for a projection against a Model: the requirements its
 	* remote store does not satisfy, under `options` (freshness, force). A
 	* Surface's projection is `surface.projection(params)`.
 	*/
-	plan: (bound, model, projection, options) => planAsked(bound.store.get(model), askedOf(projection), options ?? {}).requirements,
+	plan: (bound, model, projection, options) => planAsked(bound.store.get(model), askedOf(projection), options ?? {}, bound.operators).requirements,
 	/**
 	* The queries a projection needs run before its connections read: those the
 	* Model does not hold, or holds stale (every one under `force`).
 	*/
-	planQueries: (bound, model, projection, options) => planAsked(bound.store.get(model), askedOf(projection), options ?? {}).queries.flatMap((query) => query.ref === void 0 ? [] : [query.ref]),
+	planQueries: (bound, model, projection, options) => planAsked(bound.store.get(model), askedOf(projection), options ?? {}, bound.operators).queries.flatMap((query) => query.ref === void 0 ? [] : [query.ref]),
 	/**
 	* The store reads see: the base store under the pending optimistic layers.
 	* One store is shared by every read and plan of a Model whose remote state
@@ -5292,7 +5314,7 @@ const Remote = {
 			const known = remote.connections[connection.identity];
 			return known === void 0 ? [] : itemsOf(visibleItems(known, connection.identity, remote.optimistic.overlays, remote.entities).map((edge) => edge.ref), connection.select);
 		});
-		const requirements = plan(visibleStoreOf(remote.entities, remote.optimistic), [...asked.requirements, ...items], { force: true });
+		const requirements = plan(visibleStoreOf(remote.entities, remote.optimistic, bound.operators), [...asked.requirements, ...items], { force: true });
 		const invalidated = connections.filter((connection) => remote.connections[connection.identity] !== void 0 || connection.identity in remote.failures.connections).map((connection) => connection.identity);
 		const marked = [...requirements.length === 0 ? [] : [{
 			_tag: "RefreshStarted",
@@ -5484,7 +5506,8 @@ const failedReadWords = (error) => {
 };
 /** The bound domain: the descriptor, the binding, and the operations over them. */
 const bindDomain = (definition, store, options = {}) => {
-	const bound = bindRemote(definition, store);
+	const operators = options.operators ?? Operators.kernel;
+	const bound = bindRemote(definition, store, operators);
 	const readers = /* @__PURE__ */ new Map();
 	const keptConnections = /* @__PURE__ */ new Set();
 	/**
@@ -5516,7 +5539,7 @@ const bindDomain = (definition, store, options = {}) => {
 		const declared = (descriptor?.Result)?.live;
 		if (descriptor?.body === void 0) return declared;
 		const encoded = JSON.parse(identity.slice(identity.indexOf("\0") + 1));
-		return belongsEncoded(storeOf(bound, model), descriptor, encoded, entityKey(event.edge.ref.entity, event.edge.ref.id)) === "no" ? {
+		return belongsEncoded(storeOf(bound, model), descriptor, encoded, entityKey(event.edge.ref.entity, event.edge.ref.id), operators) === "no" ? {
 			prepend: "ignore",
 			append: "ignore"
 		} : declared;
@@ -5565,7 +5588,7 @@ const bindDomain = (definition, store, options = {}) => {
 				...query.value,
 				connection: placed,
 				holds
-			}, store, change), {
+			}, store, change, operators), {
 				Kept: () => placed,
 				Placed: ({ connection }) => connection,
 				Invalidated: () => placed
@@ -5585,7 +5608,7 @@ const bindDomain = (definition, store, options = {}) => {
 			pages,
 			layers,
 			remote.entities
-		], `placed:${identity}`, () => placedHeld(identity, pages, changesOf({ entities: resolvedPatches(remote.entities, remote.optimistic) }, remote.entities), visibleStoreOf(remote.entities, remote.optimistic)));
+		], `placed:${identity}`, () => placedHeld(identity, pages, changesOf({ entities: resolvedPatches(remote.entities, remote.optimistic, operators) }, remote.entities), visibleStoreOf(remote.entities, remote.optimistic, operators)));
 	};
 	/**
 	* The edges a loaded list shows: its pages with pending edits placed, and
@@ -5605,7 +5628,7 @@ const bindDomain = (definition, store, options = {}) => {
 	};
 	const insertsPlaced = (remote, identity, pages) => {
 		const { overlays } = remote.optimistic;
-		const store = visibleStoreOf(remote.entities, remote.optimistic);
+		const store = visibleStoreOf(remote.entities, remote.optimistic, operators);
 		return memoRead([
 			pages,
 			overlays,
@@ -5628,7 +5651,7 @@ const bindDomain = (definition, store, options = {}) => {
 			for (const edge of inserted.values()) {
 				if (held.has(edge.key)) continue;
 				const key = entityKey(edge.ref.entity, edge.ref.id);
-				RowPlace.$match(placeIn(store, placed, body, query.value.encoded, key), {
+				RowPlace.$match(placeIn(store, placed, body, query.value.encoded, key, operators), {
 					Before: (place) => void (placed = withEdge(placed, edge, place)),
 					End: (place) => void (placed = withEdge(placed, edge, place)),
 					Outside: () => void outside.push(edge),
@@ -5698,7 +5721,7 @@ const bindDomain = (definition, store, options = {}) => {
 			keys.add(change.edge.key);
 			named.set(change.connection, keys);
 		}
-		const visible = visibleStoreOf(remote.entities, remote.optimistic);
+		const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
 		const placed = {};
 		const invalidated = [];
 		for (const identity of Object.keys(remote.connections)) {
@@ -5717,7 +5740,7 @@ const bindDomain = (definition, store, options = {}) => {
 					connection: pages,
 					holds
 				};
-				const after = Impact.$match(impactOn(held, visible, change), {
+				const after = Impact.$match(impactOn(held, visible, change, operators), {
 					Kept: () => Option.some(pages),
 					Placed: ({ connection }) => Option.some(connection),
 					Invalidated: () => Option.none()
@@ -5785,11 +5808,11 @@ const bindDomain = (definition, store, options = {}) => {
 			const client = yield* RemoteClient;
 			const planOptions = RemotePolicy.toPlan(policy, now());
 			let current = model;
-			for (const query of planAsked(store.get(current), askedOf(projection), planOptions).queries) {
+			for (const query of planAsked(store.get(current), askedOf(projection), planOptions, operators).queries) {
 				const page = yield* queryRequestOf(query).pipe(Effect.flatMap((request) => client.query(request)));
 				current = hear(current, pageMessage(query.identity, page, true, query.window, query.select, now()));
 			}
-			const requirements = planAsked(store.get(current), askedOf(projection), planOptions).requirements;
+			const requirements = planAsked(store.get(current), askedOf(projection), planOptions, operators).requirements;
 			if (requirements.length === 0) return current;
 			const at = now();
 			const result = yield* client.read({
@@ -5810,7 +5833,7 @@ const bindDomain = (definition, store, options = {}) => {
 		entries.forEach(assertOwned);
 		const planOptions = RemotePolicy.toPlan(RemotePolicy.cacheFirst, now());
 		const plans = (current, projections) => {
-			const planned = planAsked(store.get(current), askedUnion(projections), planOptions);
+			const planned = planAsked(store.get(current), askedUnion(projections), planOptions, operators);
 			return planned.queries.length > 0 || planned.requirements.length > 0;
 		};
 		let current = model;
@@ -5899,7 +5922,7 @@ const bindDomain = (definition, store, options = {}) => {
 			const listed = query.Result.entity;
 			if (listed === void 0) throw new Error(`Remote: query "${query.name}" is not a connection over an entity, so it has no page to select`);
 			if (select.entity !== listed) throw new Error(`Remote: the selection is of "${select.entity}", but query "${query.name}" lists "${listed}"`);
-			const { ref, relation, requirement } = placeableReadContract(readContract(query.ref(input), select, window), query.body);
+			const { ref, relation, requirement } = placeableReadContract(readContract(query.ref(input), select, window), query.body, operators);
 			const relationKey = stableStringify(relation);
 			const sizeOf = (remote) => windowSize(remote, ref);
 			const shown = (remote, connection) => cutToWindow(shownEdges(remote, ref.identity, connection), ref.window, sizeOf(remote));
@@ -5922,7 +5945,7 @@ const bindDomain = (definition, store, options = {}) => {
 				}
 			};
 			const readPage = (remote, connection) => {
-				const visible = visibleStoreOf(remote.entities, remote.optimistic);
+				const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
 				return memoRead([
 					visible,
 					connection,
@@ -6110,11 +6133,14 @@ const bindDomain = (definition, store, options = {}) => {
 			if (filters !== void 0 && filters !== over.selection.entity) throw new Error(`Remote: query "${by.name}" is over "${filters}", but the list is of "${over.selection.entity}", so it cannot filter it`);
 			const remote = store.get(model);
 			const connection = remote.connections[over.ref.identity];
-			const visible = visibleStoreOf(remote.entities, remote.optimistic);
+			const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
 			const among = (connection === void 0 ? [] : shownEdges(remote, over.ref.identity, connection)).map((edge) => entityKey(edge.ref.entity, edge.ref.id));
 			let judged;
 			try {
-				judged = matching(visible, by, input, { among });
+				judged = matching(visible, by, input, {
+					among,
+					operators
+				});
 			} catch (error) {
 				if (error instanceof QueryEvaluateError) return {
 					items: [],
@@ -6351,7 +6377,6 @@ const pickWindow = (window) => ({
 	...window.after === void 0 ? {} : { after: window.after },
 	...window.before === void 0 ? {} : { before: window.before }
 });
-//#endregion
 export { emptyOptimistic as $, RelationEntityAnnotation as $n, PageSize as $t, writeRead as A, optimisticOfWrite as An, unknown as At, plan as B, isFieldUnavailable as Bn, requirementKey as Bt, remoteMessageCases as C, stableStringify as Cn, hasNext as Ct, updateRemote as D, emptyMutationState as Dn, merge as Dt, retentionRootsSchema as E, beginMutation as En, items as Et, REMOTE_CACHE_VERSION as F, emptyStore as Fn, mintOperation as Ft, emptyLiveState as G, remove as Gn, LiveRequirement as Gt, applyConnectionEvent as H, markStale as Hn, Live as Ht, RemotePersistence as I, entityKey as In, mutateRemote as It, ConnectionChange as J, tombstone as Jn, Mutate as Jt, liveHasNext as K, setStale as Kn, MAX_FIELDS_PER_REQUEST as Kt, gc as L, entry as Ln, remoteError as Lt, RemoteData as M, reconcileMutation as Mn, coalescedLayer as Mt, remoteDataSchema as N, schemaOf as Nn, connectionChangeOf as Nt, windowGrowthKey as O, failMutation as On, segment as Ot, remoteErrorSchema as P, clearStale as Pn, liveEventOf as Pt, connectionIdentity as Q, RelationAnnotation as Qn, OperationId as Qt, reachable as R, hasField as Rn, coalesceQueries as Rt, refreshedAt as S, Query$1 as Sn, emptyConnection as St, remoteModelSchema as T, Refusal as Tn, isGapped as Tt, applyEntityEvent as U, missingFields as Un, LiveChange as Ut, windowKey as V, isTombstone as Vn, ConnectionChangeSchema as Vt, classifyLive as W, readField as Wn, LiveEdge as Wt, addOverlay as X, writeEntity as Xn, MutationResult as Xt, addLayer as Y, writeEntities as Yn, MutationRequest as Yt, beginOptimistic as Z, RELATION_ALIAS as Zn, NormalizedEntity as Zt, isRemoteMessage as _, RemoteUnauthenticated as _n, pageSchema as _t, RemoteJsonAnswer as a, Read as an, relationShape as ar, settleSuccess as at, overlaysOf as b, WireBoundary as bn, cursor as bt, emptyRefresh as c, ReadRequest as cn, RemoteRequirements as cr, inspectEntity as ct, initialRemoteModel as d, RemoteLiveError as dn, requirementsOf as dr, matching as dt, QueryEdge as en, aliasedField as er, pruneOverlays as et, invalidateConnections as f, RemoteMutationError as fn, RowPlace as ft, isQueryLoading as g, RemoteRpc as gn, assemble as gt, isLoadingThrough as h, RemoteReadError as hn, Selection as ht, liveFetch as i, REMOTE_PROTOCOL_VERSION as in, relationAlias as ir, settleFailure as it, Denied as j, patchOfWrite as jn, RemoteClient as jt, withRefreshRequested as k, mutationStatus as kn, terminal as kt, failureOf as l, RelationRequest as ln, Requirement as lr, inspectRemote as lt, isLoading as m, RemoteQueryError as mn, Entity$1 as mt, RemoteUnsatisfied as n, QueryResult as nn, refParts as nr, removeOverlay as nt, RemoteJsonRequest as o, ReadBatch as on, targetsOf as or, visibleItems as ot, isFieldFailed as p, RemoteProtocolError as pn, placeIn as pt, liveHasPrevious as q, setUnavailable as qn, MAX_RELATION_DEPTH as qt, httpWithLive as r, QueryRpc as rn, refsIn as rr, resolvedPatches as rt, RemotePolicy as s, ReadBatchResult as sn, RemoteConnections as sr, visibleStore as st, Remote as t, QueryRequest as tn, isRefPage as tr, removeLayer as tt, forgetRemote as u, RemoteForbidden as un, connectionsOf as ur, belongsEncoded as ut, noFailures as v, SettledFields as vn, relationOf as vt, remoteMessageSchema as w, Mutation as wn, hasPrevious as wt, refreshIsInFlight as x, IDENTITY_SEPARATOR as xn, edge as xt, onlyOverlaid as y, WindowSchema as yn, unavailableOf as yt, deadlineOf as z, isFieldStale as zn, coalesceReads as zt };
 
-//# sourceMappingURL=src-fsYu0YoT.mjs.map
+//# sourceMappingURL=src-lVP_7bf4.mjs.map