foldkit-remote 0.20.0 → 0.22.0

package/dist/wire-DthPcTM6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire-DthPcTM6.d.ts","names":[],"sources":["../src/wire.ts"],"mappings":";;;;;;;;cAca;;;;cAEA,wBAAwB;;;;;;cAIxB,4BAA4B;;;;;;;;;;cAe5B,0BAA0B;;;;;;;;;;cAS1B,wBAAwB;;;;;;;;;;;cAWxB,8BAA8B;;;;cAQ9B,wBAAwB;;;;;;;;;cASxB,0BAA0B;;;;;;;cAM1B,4BAA4B;;cAM5B,UAAQ,OAAA;cAER,cAAY,OAAA;;;;;;;cAQZ;;cAEA;cAwBA,iBAAe,OAAA,MAAA,qBAAA;cAEf,aAAa,OAAO,MAAM,aAAa;cAUvC,WAAS,OAAA;;;;cAKT,kBAAgB,OAAA;;;;;;;;;;cAWhB,eAAa,OAAA;;;;;cAMb,iBAAe,OAAA;;;;;;;;;;;;;cAMf,YAAU,OAAA;;;;;;;;;;;;;;;;;;;;cAUV,aAAW,OAAA;;cAOX;;;;;cAMA,YAAY,OAAO,MAAM,qBAAqB;cAO9C,iBAAe,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cA2Bf,UAAQ,OAAA;;;;;;cAOR,wBAAsB,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;cAUtB,gBAAc,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiBd,cAAY,OAAA;;;;;;;;;;;;;;;;;cAaZ;cAEA,iBAAe,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAaf,YAAU,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCV,MAAI,IAAA,yBAAA,OAAA;;;;;;;;;;;;;;IAIf,OAAA,uBAAA,wBAAA,4BAAA;cAEW,QAAM,IAAA,2BAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIjB,OAAA,uBAAA,4BAAA,wBAAA;cAEW,MAAI,IAAA,yBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAUf,OAAA,uBAAA,wBAAA,0BAAA,4BAAA,0BAAA,OAAA;;;;cAEW,yBAAyB;cAIzB,cAAY,OAAA,gBAAA,OAAA;;;;;;;;cAMZ,WAAS,OAAA;;;;;cAMT,aAAW,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAaX,UAAQ,IAAA,0BAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAInB,OAAA,uBAAA,yBAAA;cAEW,WAAS,SAAA,SAAA,IAAA,yBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA8C,OAAA,uBAAA,wBAAA,4BAAA"}

package/dist/wire.d.ts

@@ -0,0 +1,2 @@
+import { A as RemoteMutationError, B as WireBoundary, C as ReadBatch, D as RemoteForbidden, E as RelationRequest, F as RemoteUnauthenticated, I as RemoteUnreachable, L as SettledFields, M as RemoteQueryError, N as RemoteReadError, O as RemoteLiveError, P as RemoteRpc, R as ShownSlice, S as Read, T as ReadRequest, _ as QueryEdge, a as LiveEdge, b as QueryRpc, c as MAX_LIVE_QUERIES, d as Mutate, f as MutationRequest, g as PageSize, h as OperationId, i as LiveChange, j as RemoteProtocolError, k as RemoteLiveRefused, l as MAX_RELATION_DEPTH, m as NormalizedEntity, n as ConnectionChangeSchema, o as LiveRequirement, p as MutationResult, r as Live, s as MAX_FIELDS_PER_REQUEST, t as AnswerRead, u as MAX_SHOWN_ENTITIES, v as QueryRequest, w as ReadBatchResult, x as REMOTE_PROTOCOL_VERSION, y as QueryResult, z as WindowSchema } from "./wire-DthPcTM6.js";
+export { AnswerRead, ConnectionChangeSchema, Live, LiveChange, LiveEdge, LiveRequirement, MAX_FIELDS_PER_REQUEST, MAX_LIVE_QUERIES, MAX_RELATION_DEPTH, MAX_SHOWN_ENTITIES, Mutate, MutationRequest, MutationResult, NormalizedEntity, OperationId, PageSize, QueryEdge, QueryRequest, QueryResult, QueryRpc, REMOTE_PROTOCOL_VERSION, Read, ReadBatch, ReadBatchResult, ReadRequest, RelationRequest, RemoteForbidden, RemoteLiveError, RemoteLiveRefused, RemoteMutationError, RemoteProtocolError, RemoteQueryError, RemoteReadError, RemoteRpc, RemoteUnauthenticated, RemoteUnreachable, SettledFields, ShownSlice, WindowSchema, WireBoundary };

package/dist/wire.js

@@ -0,0 +1,329 @@
+import { Schema } from "effect";
+import { Rpc, RpcGroup } from "effect/rpc";
+// 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
+* preserve order, and live data is a stream.
+*/
+/**
+* The read/live protocol version. A batch names the version it speaks and the
+* server refuses a mismatch with `RemoteProtocolError`, so a shape change never
+* drifts silently: bump it whenever `ReadRequest` or `LiveRequirement` change.
+*/
+const REMOTE_PROTOCOL_VERSION = 5;
+var RemoteReadError = class extends Schema.TaggedError()("RemoteReadError", { message: Schema.String }) {};
+var RemoteMutationError = class extends Schema.TaggedError()("RemoteMutationError", {
+	message: Schema.String,
+	/** The mutation's own `Refusal`, encoded, when the server refused it as one. */
+	refusal: Schema.optional(Schema.Unknown)
+}) {};
+/**
+* No answer came back: the request could not be sent, or what came back was
+* not an answer. The server may or may not have run it, so it is safe to send
+* again only as the same operation, which a ledgered writer answers from its
+* record. The outbox sends a durable write again after it (#247).
+*/
+var RemoteUnreachable = class extends Schema.TaggedError()("Unreachable", { message: Schema.String }) {};
+/**
+* The server refused who is asking: they may not do this, and asking again
+* as the same principal is refused again. `reason` is the application's own
+* words for the person who asked; without it the refusal says nothing of why.
+*/
+var RemoteForbidden = class extends Schema.TaggedError()("Forbidden", {
+	message: Schema.String,
+	reason: Schema.optional(Schema.String)
+}) {};
+/**
+* The server could not tell who is asking: a credential was sent and no
+* longer holds, or none was sent where one is needed. Asking again as the
+* same caller is refused again; signing in again is the remedy. `reason` is
+* words for the person who asked; without it the refusal says nothing of why.
+*/
+var RemoteUnauthenticated = class extends Schema.TaggedError()("Unauthenticated", {
+	message: Schema.String,
+	reason: Schema.optional(Schema.String)
+}) {};
+var RemoteLiveError = class extends Schema.TaggedError()("RemoteLiveError", { message: Schema.String }) {};
+/**
+* The server refused a live subscription for what it asks (more ids of one
+* Entity than `maxIdsPerEntity`), before reading anything. The same
+* requirements are refused again, so a client does not reconnect it.
+*/
+var RemoteLiveRefused = class extends Schema.TaggedError()("RemoteLiveRefused", { message: Schema.String }) {};
+/** The peer speaks another protocol version; nothing was read. */
+var RemoteProtocolError = class extends Schema.TaggedError()("RemoteProtocolError", {
+	message: Schema.String,
+	expected: Schema.Number,
+	received: Schema.Number
+}) {};
+/** A page size: a non-negative integer, refused at decode otherwise rather than defaulted. */
+const PageSize = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0));
+const WindowSchema = Schema.Struct({
+	first: Schema.optional(PageSize),
+	last: Schema.optional(PageSize),
+	after: Schema.optional(Schema.String),
+	before: Schema.optional(Schema.String)
+});
+/** A request may not name more fields of one entity than this; a selection never does. */
+const MAX_FIELDS_PER_REQUEST = 256;
+/** A selection may not nest relations deeper than this; the wire refuses more. */
+const MAX_RELATION_DEPTH = 8;
+const Fields = Schema.Array(Schema.String).check(Schema.isMaxLength(256));
+/**
+* The slice required of a relation's target; the ids come from the parent's
+* refs. Built as `MAX_RELATION_DEPTH` nested structs rather than a recursive
+* schema, so a deeper selection is refused at decode with a schema error.
+*/
+const relationLevel = (depth) => {
+	const slice = {
+		entity: Schema.String,
+		fields: Fields,
+		windows: Schema.optional(Schema.Record(Schema.String, WindowSchema))
+	};
+	return depth === 0 ? Schema.Struct({
+		...slice,
+		relations: Schema.optionalKey(Schema.Never)
+	}) : Schema.Struct({
+		...slice,
+		relations: Schema.optional(Schema.Record(Schema.String, relationLevel(depth - 1)))
+	});
+};
+const RelationRequest = relationLevel(7);
+const ReadRequest = Schema.Struct({
+	entity: Schema.String,
+	id: Schema.String,
+	fields: Fields,
+	/** Pagination window per relation field. */
+	windows: Schema.optional(Schema.Record(Schema.String, WindowSchema)),
+	/** The slice required of each relation field's target, resolved in the same read. */
+	relations: Schema.optional(Schema.Record(Schema.String, RelationRequest))
+});
+const ReadBatch = Schema.Struct({
+	version: Schema.Number,
+	requests: Schema.Array(ReadRequest)
+});
+const NormalizedEntity = Schema.Struct({
+	entity: Schema.String,
+	id: Schema.String,
+	values: Schema.Record(Schema.String, Schema.Unknown)
+});
+/**
+* Fields a read asked for that the server answered without, and will not
+* answer with: the client stops asking. It says nothing about why, so a rule
+* that withholds a field is not itself on the wire.
+*/
+const SettledFields = Schema.Struct({
+	entity: Schema.String,
+	id: Schema.String,
+	fields: Schema.Array(Schema.String)
+});
+const ReadBatchResult = Schema.Struct({
+	entities: Schema.Array(NormalizedEntity),
+	settled: Schema.Array(SettledFields)
+});
+/** A read a mutation's answer carries: what was asked, and what came back. */
+const AnswerRead = Schema.Struct({
+	requests: Schema.Array(ReadRequest),
+	result: ReadBatchResult
+});
+/**
+* One operation's identity across every client: minted where it is first sent
+* and sent again with each retry of it. Bounded, since a server keys a record
+* of the write by it.
+*/
+const OperationId = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(128), Schema.isPattern(/^[A-Za-z0-9:._-]+$/));
+/** A mutation request may name at most this many entities in `shown`. */
+const MAX_SHOWN_ENTITIES = 256;
+/**
+* What a client reads of one entity's rows: a read request without its id. It
+* nests as deep as a read request does, so any slice a read asks can be sent.
+*/
+const ShownSlice = Schema.Struct({
+	entity: Schema.String,
+	fields: Fields,
+	windows: Schema.optional(Schema.Record(Schema.String, WindowSchema)),
+	relations: Schema.optional(Schema.Record(Schema.String, RelationRequest))
+});
+const MutationRequest = Schema.Struct({
+	/**
+	* This client's id for the request, the same on each retry of it. It is
+	* unique within one client's Model only (a counter there), so it names a
+	* request to that client; `operation` names it to a server.
+	*/
+	requestId: Schema.String,
+	/** The operation's identity across clients: what a server keys a record of the write by. */
+	operation: Schema.optional(OperationId),
+	mutation: Schema.String,
+	input: Schema.Unknown,
+	/** For a mutation that is a `Write`: the input keys to write, when not all of them. */
+	keys: Schema.optional(Schema.Array(Schema.String)),
+	/**
+	* When the reader acted, in milliseconds since the epoch: what the client
+	* predicted the write's time as. A server takes it within its `clockSkew`
+	* of its own clock. Optional, so a client and a server of either age agree.
+	*/
+	now: Schema.optional(Schema.Int),
+	/**
+	* What the client's active reads show of each entity's rows. The server
+	* answers, of each row the mutation names, the shown fields its answer
+	* left out, read as any read is (`MutationResult.read`).
+	*/
+	shown: Schema.optional(Schema.Array(ShownSlice).check(Schema.isMaxLength(256)))
+});
+const LiveEdge = Schema.Struct({
+	entity: Schema.String,
+	id: Schema.String,
+	key: Schema.String
+});
+/** A connection change a mutation confirms: the same facts a live event carries, without a cursor. */
+const ConnectionChangeSchema = Schema.Union([Schema.Struct({
+	_tag: Schema.Literal("Insert"),
+	connection: Schema.String,
+	position: Schema.Union([Schema.Literal("prepend"), Schema.Literal("append")]),
+	edge: LiveEdge
+}), Schema.Struct({
+	_tag: Schema.Literal("Remove"),
+	connection: Schema.String,
+	edge: LiveEdge
+})]);
+const MutationResult = Schema.Struct({
+	output: Schema.Unknown,
+	entities: Schema.Array(NormalizedEntity),
+	/** Connection changes the mutation made, applied alongside its entity patches. */
+	connections: Schema.optional(Schema.Array(ConnectionChangeSchema)),
+	/** Entities the mutation deleted; the client knows them absent from then on. */
+	deleted: Schema.optional(Schema.Array(Schema.Struct({
+		entity: Schema.String,
+		id: Schema.String
+	}))),
+	/**
+	* A fresh read, after the write, of what the request's `shown` asks of the
+	* rows the answer names: the requirements read and what came back, written
+	* as a read is.
+	*/
+	read: Schema.optional(AnswerRead)
+});
+const QueryRequest = Schema.Struct({
+	query: Schema.String,
+	input: Schema.Unknown,
+	window: WindowSchema,
+	/**
+	* What to read of each item, as the relation slice a read asks the server
+	* for. Absent for a query run without one: the response carries only edges,
+	* and the client's read entry fetches fields in a second round trip.
+	*/
+	select: Schema.optional(RelationRequest)
+});
+/** A live subscription may watch no more lists than this; each is run again every tick. */
+const MAX_LIVE_QUERIES = 32;
+const LiveRequirement = Schema.Struct({
+	version: Schema.Number,
+	requirements: Schema.Array(ReadRequest),
+	/** Lists read live (`Data.query(…, { live: true })`), each as its read sends it. */
+	queries: Schema.optional(Schema.Array(QueryRequest).check(Schema.isMaxLength(32))),
+	/** Resume cursor; events at or before it are duplicates. */
+	after: Schema.Number
+});
+/**
+* A live change. Entity changes update the store; connection changes alter
+* membership and ordering; both carry a per-stream cursor.
+*/
+const LiveChange = Schema.Union([
+	Schema.Struct({
+		_tag: Schema.Literal("EntityPatched"),
+		cursor: Schema.Number,
+		entity: Schema.String,
+		id: Schema.String,
+		values: Schema.Record(Schema.String, Schema.Unknown),
+		changed: Schema.Array(Schema.String)
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("EntityDeleted"),
+		cursor: Schema.Number,
+		entity: Schema.String,
+		id: Schema.String
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("ConnectionInsert"),
+		cursor: Schema.Number,
+		connection: Schema.String,
+		position: Schema.Union([Schema.Literal("prepend"), Schema.Literal("append")]),
+		edge: LiveEdge
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("ConnectionRemove"),
+		cursor: Schema.Number,
+		connection: Schema.String,
+		edge: LiveEdge
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("ConnectionInvalidate"),
+		cursor: Schema.Number,
+		connection: Schema.String
+	})
+]);
+const Read = Rpc.make("FoldkitRemoteRead", {
+	payload: ReadBatch,
+	success: ReadBatchResult,
+	error: Schema.Union([
+		RemoteReadError,
+		RemoteProtocolError,
+		RemoteUnauthenticated
+	])
+});
+const Mutate = Rpc.make("FoldkitRemoteMutate", {
+	payload: MutationRequest,
+	success: MutationResult,
+	error: Schema.Union([
+		RemoteMutationError,
+		RemoteForbidden,
+		RemoteUnauthenticated
+	])
+});
+const Live = Rpc.make("FoldkitRemoteLive", {
+	payload: LiveRequirement,
+	success: LiveChange,
+	error: Schema.Union([
+		RemoteLiveError,
+		RemoteLiveRefused,
+		RemoteProtocolError,
+		RemoteUnauthenticated
+	]),
+	stream: true
+});
+var RemoteQueryError = class extends Schema.TaggedError()("RemoteQueryError", { message: Schema.String }) {};
+const WireBoundary = Schema.Union([
+	Schema.Struct({ _tag: Schema.Literal("Terminal") }),
+	Schema.Struct({
+		_tag: Schema.Literal("Cursor"),
+		cursor: Schema.String
+	}),
+	Schema.Struct({ _tag: Schema.Literal("Unknown") })
+]);
+const QueryEdge = Schema.Struct({
+	entity: Schema.String,
+	id: Schema.String,
+	key: Schema.String
+});
+const QueryResult = Schema.Struct({
+	edges: Schema.Array(QueryEdge),
+	start: WireBoundary,
+	end: WireBoundary,
+	/**
+	* The selected fields of the page's items, in the same shape a read batch
+	* returns. Absent from a server that predates payload planning: the client
+	* reads it as empty and fetches fields as before.
+	*/
+	entities: Schema.optional(Schema.Array(NormalizedEntity)),
+	settled: Schema.optional(Schema.Array(SettledFields))
+});
+const QueryRpc = Rpc.make("FoldkitRemoteQuery", {
+	payload: QueryRequest,
+	success: QueryResult,
+	error: Schema.Union([RemoteQueryError, RemoteUnauthenticated])
+});
+const RemoteRpc = RpcGroup.make(Read, Mutate, QueryRpc, Live);
+export { AnswerRead, ConnectionChangeSchema, Live, LiveChange, LiveEdge, LiveRequirement, MAX_FIELDS_PER_REQUEST, MAX_LIVE_QUERIES, MAX_RELATION_DEPTH, MAX_SHOWN_ENTITIES, Mutate, MutationRequest, MutationResult, NormalizedEntity, OperationId, PageSize, QueryEdge, QueryRequest, QueryResult, QueryRpc, REMOTE_PROTOCOL_VERSION, Read, ReadBatch, ReadBatchResult, ReadRequest, RelationRequest, RemoteForbidden, RemoteLiveError, RemoteLiveRefused, RemoteMutationError, RemoteProtocolError, RemoteQueryError, RemoteReadError, RemoteRpc, RemoteUnauthenticated, RemoteUnreachable, SettledFields, ShownSlice, WindowSchema, WireBoundary };
+
+//# sourceMappingURL=wire.js.map

package/dist/wire.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.js","names":[],"sources":["../src/wire.ts"],"sourcesContent":["/**\n * The Remote wire: Effect RPC semantics over `effect/rpc`. Remote owns\n * the message shapes; Effect owns the transport. `Make`ing reads batch, mutations\n * preserve order, and live data is a stream.\n */\nimport { Schema } from 'effect'\nimport { Rpc, RpcGroup } from 'effect/rpc'\nimport type { RelationRequirement, Requirement } from './requirement.js'\n\n/**\n * The read/live protocol version. A batch names the version it speaks and the\n * server refuses a mismatch with `RemoteProtocolError`, so a shape change never\n * drifts silently: bump it whenever `ReadRequest` or `LiveRequirement` change.\n */\nexport const REMOTE_PROTOCOL_VERSION = 5\n\nexport class RemoteReadError extends Schema.TaggedError<RemoteReadError>()('RemoteReadError', {\n  message: Schema.String,\n}) {}\n\nexport class RemoteMutationError extends Schema.TaggedError<RemoteMutationError>()(\n  'RemoteMutationError',\n  {\n    message: Schema.String,\n    /** The mutation's own `Refusal`, encoded, when the server refused it as one. */\n    refusal: Schema.optional(Schema.Unknown),\n  },\n) {}\n\n/**\n * No answer came back: the request could not be sent, or what came back was\n * not an answer. The server may or may not have run it, so it is safe to send\n * again only as the same operation, which a ledgered writer answers from its\n * record. The outbox sends a durable write again after it (#247).\n */\nexport class RemoteUnreachable extends Schema.TaggedError<RemoteUnreachable>()('Unreachable', {\n  message: Schema.String,\n}) {}\n\n/**\n * The server refused who is asking: they may not do this, and asking again\n * as the same principal is refused again. `reason` is the application's own\n * words for the person who asked; without it the refusal says nothing of why.\n */\nexport class RemoteForbidden extends Schema.TaggedError<RemoteForbidden>()('Forbidden', {\n  message: Schema.String,\n  reason: Schema.optional(Schema.String),\n}) {}\n\n/**\n * The server could not tell who is asking: a credential was sent and no\n * longer holds, or none was sent where one is needed. Asking again as the\n * same caller is refused again; signing in again is the remedy. `reason` is\n * words for the person who asked; without it the refusal says nothing of why.\n */\nexport class RemoteUnauthenticated extends Schema.TaggedError<RemoteUnauthenticated>()(\n  'Unauthenticated',\n  {\n    message: Schema.String,\n    reason: Schema.optional(Schema.String),\n  },\n) {}\n\nexport class RemoteLiveError extends Schema.TaggedError<RemoteLiveError>()('RemoteLiveError', {\n  message: Schema.String,\n}) {}\n\n/**\n * The server refused a live subscription for what it asks (more ids of one\n * Entity than `maxIdsPerEntity`), before reading anything. The same\n * requirements are refused again, so a client does not reconnect it.\n */\nexport class RemoteLiveRefused extends Schema.TaggedError<RemoteLiveRefused>()(\n  'RemoteLiveRefused',\n  { message: Schema.String },\n) {}\n\n/** The peer speaks another protocol version; nothing was read. */\nexport class RemoteProtocolError extends Schema.TaggedError<RemoteProtocolError>()(\n  'RemoteProtocolError',\n  { message: Schema.String, expected: Schema.Number, received: Schema.Number },\n) {}\n\n/** A page size: a non-negative integer, refused at decode otherwise rather than defaulted. */\nexport const PageSize = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0))\n\nexport const WindowSchema = Schema.Struct({\n  first: Schema.optional(PageSize),\n  last: Schema.optional(PageSize),\n  after: Schema.optional(Schema.String),\n  before: Schema.optional(Schema.String),\n})\n\n/** A request may not name more fields of one entity than this; a selection never does. */\nexport const MAX_FIELDS_PER_REQUEST = 256\n/** A selection may not nest relations deeper than this; the wire refuses more. */\nexport const MAX_RELATION_DEPTH = 8\n\nconst Fields = Schema.Array(Schema.String).check(Schema.isMaxLength(MAX_FIELDS_PER_REQUEST))\n\n/**\n * The slice required of a relation's target; the ids come from the parent's\n * refs. Built as `MAX_RELATION_DEPTH` nested structs rather than a recursive\n * schema, so a deeper selection is refused at decode with a schema error.\n */\nconst relationLevel = (depth: number): Schema.Codec<RelationRequirement, RelationRequirement> => {\n  const slice = {\n    entity: Schema.String,\n    fields: Fields,\n    windows: Schema.optional(Schema.Record(Schema.String, WindowSchema)),\n  }\n  // A struct drops an unknown key silently; the last level refuses one instead.\n  return (depth === 0\n    ? Schema.Struct({ ...slice, relations: Schema.optionalKey(Schema.Never) })\n    : Schema.Struct({\n        ...slice,\n        relations: Schema.optional(Schema.Record(Schema.String, relationLevel(depth - 1))),\n      })) as unknown as Schema.Codec<RelationRequirement, RelationRequirement>\n}\n\nexport const RelationRequest = relationLevel(MAX_RELATION_DEPTH - 1)\n\nexport const ReadRequest: Schema.Codec<Requirement, Requirement> = Schema.Struct({\n  entity: Schema.String,\n  id: Schema.String,\n  fields: Fields,\n  /** Pagination window per relation field. */\n  windows: Schema.optional(Schema.Record(Schema.String, WindowSchema)),\n  /** The slice required of each relation field's target, resolved in the same read. */\n  relations: Schema.optional(Schema.Record(Schema.String, RelationRequest)),\n}) as unknown as Schema.Codec<Requirement, Requirement>\n\nexport const ReadBatch = Schema.Struct({\n  version: Schema.Number,\n  requests: Schema.Array(ReadRequest),\n})\n\nexport const NormalizedEntity = Schema.Struct({\n  entity: Schema.String,\n  id: Schema.String,\n  values: Schema.Record(Schema.String, Schema.Unknown),\n})\n\n/**\n * Fields a read asked for that the server answered without, and will not\n * answer with: the client stops asking. It says nothing about why, so a rule\n * that withholds a field is not itself on the wire.\n */\nexport const SettledFields = Schema.Struct({\n  entity: Schema.String,\n  id: Schema.String,\n  fields: Schema.Array(Schema.String),\n})\n\nexport const ReadBatchResult = Schema.Struct({\n  entities: Schema.Array(NormalizedEntity),\n  settled: Schema.Array(SettledFields),\n})\n\n/** A read a mutation's answer carries: what was asked, and what came back. */\nexport const AnswerRead = Schema.Struct({\n  requests: Schema.Array(ReadRequest),\n  result: ReadBatchResult,\n})\n\n/**\n * One operation's identity across every client: minted where it is first sent\n * and sent again with each retry of it. Bounded, since a server keys a record\n * of the write by it.\n */\nexport const OperationId = Schema.String.check(\n  Schema.isMinLength(1),\n  Schema.isMaxLength(128),\n  Schema.isPattern(/^[A-Za-z0-9:._-]+$/),\n)\n\n/** A mutation request may name at most this many entities in `shown`. */\nexport const MAX_SHOWN_ENTITIES = 256\n\n/**\n * What a client reads of one entity's rows: a read request without its id. It\n * nests as deep as a read request does, so any slice a read asks can be sent.\n */\nexport const ShownSlice: Schema.Codec<RelationRequirement, RelationRequirement> = Schema.Struct({\n  entity: Schema.String,\n  fields: Fields,\n  windows: Schema.optional(Schema.Record(Schema.String, WindowSchema)),\n  relations: Schema.optional(Schema.Record(Schema.String, RelationRequest)),\n}) as unknown as Schema.Codec<RelationRequirement, RelationRequirement>\n\nexport const MutationRequest = Schema.Struct({\n  /**\n   * This client's id for the request, the same on each retry of it. It is\n   * unique within one client's Model only (a counter there), so it names a\n   * request to that client; `operation` names it to a server.\n   */\n  requestId: Schema.String,\n  /** The operation's identity across clients: what a server keys a record of the write by. */\n  operation: Schema.optional(OperationId),\n  mutation: Schema.String,\n  input: Schema.Unknown,\n  /** For a mutation that is a `Write`: the input keys to write, when not all of them. */\n  keys: Schema.optional(Schema.Array(Schema.String)),\n  /**\n   * When the reader acted, in milliseconds since the epoch: what the client\n   * predicted the write's time as. A server takes it within its `clockSkew`\n   * of its own clock. Optional, so a client and a server of either age agree.\n   */\n  now: Schema.optional(Schema.Int),\n  /**\n   * What the client's active reads show of each entity's rows. The server\n   * answers, of each row the mutation names, the shown fields its answer\n   * left out, read as any read is (`MutationResult.read`).\n   */\n  shown: Schema.optional(Schema.Array(ShownSlice).check(Schema.isMaxLength(MAX_SHOWN_ENTITIES))),\n})\n\nexport const LiveEdge = Schema.Struct({\n  entity: Schema.String,\n  id: Schema.String,\n  key: Schema.String,\n})\n\n/** A connection change a mutation confirms: the same facts a live event carries, without a cursor. */\nexport const ConnectionChangeSchema = Schema.Union([\n  Schema.Struct({\n    _tag: Schema.Literal('Insert'),\n    connection: Schema.String,\n    position: Schema.Union([Schema.Literal('prepend'), Schema.Literal('append')]),\n    edge: LiveEdge,\n  }),\n  Schema.Struct({ _tag: Schema.Literal('Remove'), connection: Schema.String, edge: LiveEdge }),\n])\n\nexport const MutationResult = Schema.Struct({\n  output: Schema.Unknown,\n  entities: Schema.Array(NormalizedEntity),\n  /** Connection changes the mutation made, applied alongside its entity patches. */\n  connections: Schema.optional(Schema.Array(ConnectionChangeSchema)),\n  /** Entities the mutation deleted; the client knows them absent from then on. */\n  deleted: Schema.optional(\n    Schema.Array(Schema.Struct({ entity: Schema.String, id: Schema.String })),\n  ),\n  /**\n   * A fresh read, after the write, of what the request's `shown` asks of the\n   * rows the answer names: the requirements read and what came back, written\n   * as a read is.\n   */\n  read: Schema.optional(AnswerRead),\n})\n\nexport const QueryRequest = Schema.Struct({\n  query: Schema.String,\n  input: Schema.Unknown,\n  window: WindowSchema,\n  /**\n   * What to read of each item, as the relation slice a read asks the server\n   * for. Absent for a query run without one: the response carries only edges,\n   * and the client's read entry fetches fields in a second round trip.\n   */\n  select: Schema.optional(RelationRequest),\n})\n\n/** A live subscription may watch no more lists than this; each is run again every tick. */\nexport const MAX_LIVE_QUERIES = 32\n\nexport const LiveRequirement = Schema.Struct({\n  version: Schema.Number,\n  requirements: Schema.Array(ReadRequest),\n  /** Lists read live (`Data.query(…, { live: true })`), each as its read sends it. */\n  queries: Schema.optional(Schema.Array(QueryRequest).check(Schema.isMaxLength(MAX_LIVE_QUERIES))),\n  /** Resume cursor; events at or before it are duplicates. */\n  after: Schema.Number,\n})\n\n/**\n * A live change. Entity changes update the store; connection changes alter\n * membership and ordering; both carry a per-stream cursor.\n */\nexport const LiveChange = Schema.Union([\n  Schema.Struct({\n    _tag: Schema.Literal('EntityPatched'),\n    cursor: Schema.Number,\n    entity: Schema.String,\n    id: Schema.String,\n    values: Schema.Record(Schema.String, Schema.Unknown),\n    changed: Schema.Array(Schema.String),\n  }),\n  Schema.Struct({\n    _tag: Schema.Literal('EntityDeleted'),\n    cursor: Schema.Number,\n    entity: Schema.String,\n    id: Schema.String,\n  }),\n  Schema.Struct({\n    _tag: Schema.Literal('ConnectionInsert'),\n    cursor: Schema.Number,\n    connection: Schema.String,\n    position: Schema.Union([Schema.Literal('prepend'), Schema.Literal('append')]),\n    edge: LiveEdge,\n  }),\n  Schema.Struct({\n    _tag: Schema.Literal('ConnectionRemove'),\n    cursor: Schema.Number,\n    connection: Schema.String,\n    edge: LiveEdge,\n  }),\n  Schema.Struct({\n    _tag: Schema.Literal('ConnectionInvalidate'),\n    cursor: Schema.Number,\n    connection: Schema.String,\n  }),\n])\n\nexport const Read = Rpc.make('FoldkitRemoteRead', {\n  payload: ReadBatch,\n  success: ReadBatchResult,\n  error: Schema.Union([RemoteReadError, RemoteProtocolError, RemoteUnauthenticated]),\n})\n\nexport const Mutate = Rpc.make('FoldkitRemoteMutate', {\n  payload: MutationRequest,\n  success: MutationResult,\n  error: Schema.Union([RemoteMutationError, RemoteForbidden, RemoteUnauthenticated]),\n})\n\nexport const Live = Rpc.make('FoldkitRemoteLive', {\n  payload: LiveRequirement,\n  success: LiveChange,\n  error: Schema.Union([\n    RemoteLiveError,\n    RemoteLiveRefused,\n    RemoteProtocolError,\n    RemoteUnauthenticated,\n  ]),\n  stream: true,\n})\n\nexport class RemoteQueryError extends Schema.TaggedError<RemoteQueryError>()('RemoteQueryError', {\n  message: Schema.String,\n}) {}\n\nexport const WireBoundary = Schema.Union([\n  Schema.Struct({ _tag: Schema.Literal('Terminal') }),\n  Schema.Struct({ _tag: Schema.Literal('Cursor'), cursor: Schema.String }),\n  Schema.Struct({ _tag: Schema.Literal('Unknown') }),\n])\n\nexport const QueryEdge = Schema.Struct({\n  entity: Schema.String,\n  id: Schema.String,\n  key: Schema.String,\n})\n\nexport const QueryResult = Schema.Struct({\n  edges: Schema.Array(QueryEdge),\n  start: WireBoundary,\n  end: WireBoundary,\n  /**\n   * The selected fields of the page's items, in the same shape a read batch\n   * returns. Absent from a server that predates payload planning: the client\n   * reads it as empty and fetches fields as before.\n   */\n  entities: Schema.optional(Schema.Array(NormalizedEntity)),\n  settled: Schema.optional(Schema.Array(SettledFields)),\n})\n\nexport const QueryRpc = Rpc.make('FoldkitRemoteQuery', {\n  payload: QueryRequest,\n  success: QueryResult,\n  error: Schema.Union([RemoteQueryError, RemoteUnauthenticated]),\n})\n\nexport const RemoteRpc = RpcGroup.make(Read, Mutate, QueryRpc, Live)\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foldkit-remote",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Normalized application-facing server state for Foldkit: entities, selections, and the pure remote core.",
   "keywords": [
     "foldkit",
@@ -29,13 +29,18 @@
   "exports": {
     ".": {
       "foldkit-plus:source": "./src/index.ts",
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
     "./port": {
       "foldkit-plus:source": "./src/port.ts",
-      "types": "./dist/port.d.mts",
-      "import": "./dist/port.mjs"
+      "types": "./dist/port.d.ts",
+      "import": "./dist/port.js"
+    },
+    "./testing": {
+      "foldkit-plus:source": "./src/testing.ts",
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js"
     }
   },
   "files": [
@@ -44,21 +49,21 @@
     "LICENSE"
   ],
   "dependencies": {
-    "foldkit-entity": "0.12.0",
-    "foldkit-metadata": "0.1.0",
-    "foldkit-surface": "0.10.2"
+    "foldkit-entity": "0.14.0",
+    "foldkit-surface": "0.11.0",
+    "foldkit-metadata": "0.1.0"
   },
   "peerDependencies": {
-    "effect": "^4.0.0",
-    "foldkit": "^0.169.0"
+    "effect": "^4.1.0",
+    "foldkit": "^0.170.0"
   },
   "devDependencies": {
-    "@effect/platform-browser": "^4.0.5",
-    "effect": "^4.0.5",
-    "foldkit": "0.169.0",
+    "@effect/platform-browser": "^4.1.0",
+    "effect": "^4.1.0",
+    "foldkit": "0.170.0",
     "tsdown": "^0.23.1",
     "typescript": "7.0.2",
-    "foldkit-bundle": "0.8.1"
+    "foldkit-bundle": "0.9.0"
   },
   "scripts": {
     "build": "tsdown",