@rocicorp/zero 1.6.0-canary.0 → 1.6.0-canary.10

package/out/packages/zero-protocol/src/connect.js

@@ -0,0 +1,54 @@
+import { valita_exports } from "../../shared/src/valita.js";
+import { clientSchemaSchema } from "./client-schema.js";
+import { deleteClientsBodySchema } from "./delete-clients.js";
+import { upQueriesPatchSchema } from "./queries-patch.js";
+//#region ../zero-protocol/src/connect.ts
+/**
+* After opening a websocket the client waits for a `connected` message
+* from the server.  It then sends an `initConnection` message to the
+* server.  The server waits for the `initConnection` message before
+* beginning to send pokes to the newly connected client, so as to avoid
+* syncing lots of queries which are no longer desired by the client.
+*/
+var connectedBodySchema = valita_exports.object({
+	wsid: valita_exports.string(),
+	timestamp: valita_exports.number().optional()
+});
+var connectedMessageSchema = valita_exports.tuple([valita_exports.literal("connected"), connectedBodySchema]);
+var initConnectionBodySchema = valita_exports.object({
+	desiredQueriesPatch: upQueriesPatchSchema,
+	clientSchema: clientSchemaSchema.optional(),
+	deleted: deleteClientsBodySchema.optional(),
+	userPushURL: valita_exports.string().optional(),
+	userPushHeaders: valita_exports.record(valita_exports.string()).optional(),
+	userQueryURL: valita_exports.string().optional(),
+	userQueryHeaders: valita_exports.record(valita_exports.string()).optional(),
+	/**
+	* `activeClients` is an optional array of client IDs that are currently active
+	* in the client group. This is used to inform the server about the clients
+	* that are currently active (aka running, aka alive), so it can inactive
+	* queries from inactive clients.
+	*/
+	activeClients: valita_exports.array(valita_exports.string()).optional(),
+	/** W3C traceparent header for distributed tracing. */
+	traceparent: valita_exports.string().optional()
+});
+var initConnectionMessageSchema = valita_exports.tuple([valita_exports.literal("initConnection"), initConnectionBodySchema]);
+function encodeSecProtocols(initConnectionMessage, authToken) {
+	const protocols = {
+		initConnectionMessage,
+		authToken
+	};
+	const bytes = new TextEncoder().encode(JSON.stringify(protocols));
+	const s = Array.from(bytes, (byte) => String.fromCharCode(byte)).join("");
+	return encodeURIComponent(btoa(s));
+}
+function decodeSecProtocols(secProtocol) {
+	const binString = atob(decodeURIComponent(secProtocol));
+	const bytes = Uint8Array.from(binString, (c) => c.charCodeAt(0));
+	return JSON.parse(new TextDecoder().decode(bytes));
+}
+//#endregion
+export { connectedMessageSchema, decodeSecProtocols, encodeSecProtocols, initConnectionMessageSchema };
+
+//# sourceMappingURL=connect.js.map

package/out/packages/zero-protocol/src/connect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.js","names":[],"sources":["../../../../../zero-protocol/src/connect.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {clientSchemaSchema} from './client-schema.ts';\nimport {deleteClientsBodySchema} from './delete-clients.ts';\nimport {upQueriesPatchSchema} from './queries-patch.ts';\n\n/**\n * After opening a websocket the client waits for a `connected` message\n * from the server.  It then sends an `initConnection` message to the\n * server.  The server waits for the `initConnection` message before\n * beginning to send pokes to the newly connected client, so as to avoid\n * syncing lots of queries which are no longer desired by the client.\n */\n\nexport const connectedBodySchema = v.object({\n  wsid: v.string(),\n  timestamp: v.number().optional(),\n});\n\nexport const connectedMessageSchema = v.tuple([\n  v.literal('connected'),\n  connectedBodySchema,\n]);\n\nconst initConnectionBodySchema = v.object({\n  desiredQueriesPatch: upQueriesPatchSchema,\n  // As the schema can be large, client only sends when it does not have a\n  // server snapshot (i.e. a snapshot with a cookie).  Once it has a server\n  // snapshot it will assume the zero-cache already has the schema for this\n  // client's client group in the CVR store.\n  clientSchema: clientSchemaSchema.optional(),\n  deleted: deleteClientsBodySchema.optional(),\n  // parameters to configure the mutate endpoint\n  userPushURL: v.string().optional(),\n  userPushHeaders: v.record(v.string()).optional(),\n  // parameters to configure the query endpoint\n  userQueryURL: v.string().optional(),\n  userQueryHeaders: v.record(v.string()).optional(),\n\n  /**\n   * `activeClients` is an optional array of client IDs that are currently active\n   * in the client group. This is used to inform the server about the clients\n   * that are currently active (aka running, aka alive), so it can inactive\n   * queries from inactive clients.\n   */\n  activeClients: v.array(v.string()).optional(),\n  /** W3C traceparent header for distributed tracing. */\n  traceparent: v.string().optional(),\n});\n\nexport const initConnectionMessageSchema = v.tuple([\n  v.literal('initConnection'),\n  initConnectionBodySchema,\n]);\n\nexport type ConnectedBody = v.Infer<typeof connectedBodySchema>;\nexport type ConnectedMessage = v.Infer<typeof connectedMessageSchema>;\nexport type InitConnectionBody = v.Infer<typeof initConnectionBodySchema>;\nexport type InitConnectionMessage = v.Infer<typeof initConnectionMessageSchema>;\n\nexport function encodeSecProtocols(\n  initConnectionMessage: InitConnectionMessage | undefined,\n  authToken: string | undefined,\n): string {\n  const protocols = {\n    initConnectionMessage,\n    authToken,\n  };\n  // WS sec protocols needs to be URI encoded. To save space, we base64 encode\n  // the JSON before URI encoding it. But InitConnectionMessage can contain\n  // arbitrary unicode strings, so we need to encode the JSON as UTF-8 first.\n  // Phew!\n  const bytes = new TextEncoder().encode(JSON.stringify(protocols));\n\n  // Convert bytes to string without spreading all bytes as arguments\n  // to avoid \"Maximum call stack size exceeded\" error with large data\n  const s = Array.from(bytes, byte => String.fromCharCode(byte)).join('');\n\n  return encodeURIComponent(btoa(s));\n}\n\nexport function decodeSecProtocols(secProtocol: string): {\n  initConnectionMessage: InitConnectionMessage | undefined;\n  authToken: string | undefined;\n} {\n  const binString = atob(decodeURIComponent(secProtocol));\n  const bytes = Uint8Array.from(binString, c => c.charCodeAt(0));\n  return JSON.parse(new TextDecoder().decode(bytes));\n}\n"],"mappings":";;;;;;;;;;;;AAaA,IAAa,sBAAsB,eAAE,OAAO;CAC1C,MAAM,eAAE,OAAO;CACf,WAAW,eAAE,OAAO,EAAE,SAAS;AACjC,CAAC;AAED,IAAa,yBAAyB,eAAE,MAAM,CAC5C,eAAE,QAAQ,WAAW,GACrB,mBACF,CAAC;AAED,IAAM,2BAA2B,eAAE,OAAO;CACxC,qBAAqB;CAKrB,cAAc,mBAAmB,SAAS;CAC1C,SAAS,wBAAwB,SAAS;CAE1C,aAAa,eAAE,OAAO,EAAE,SAAS;CACjC,iBAAiB,eAAE,OAAO,eAAE,OAAO,CAAC,EAAE,SAAS;CAE/C,cAAc,eAAE,OAAO,EAAE,SAAS;CAClC,kBAAkB,eAAE,OAAO,eAAE,OAAO,CAAC,EAAE,SAAS;;;;;;;CAQhD,eAAe,eAAE,MAAM,eAAE,OAAO,CAAC,EAAE,SAAS;;CAE5C,aAAa,eAAE,OAAO,EAAE,SAAS;AACnC,CAAC;AAED,IAAa,8BAA8B,eAAE,MAAM,CACjD,eAAE,QAAQ,gBAAgB,GAC1B,wBACF,CAAC;AAOD,SAAgB,mBACd,uBACA,WACQ;CACR,MAAM,YAAY;EAChB;EACA;CACF;CAKA,MAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,KAAK,UAAU,SAAS,CAAC;CAIhE,MAAM,IAAI,MAAM,KAAK,QAAO,SAAQ,OAAO,aAAa,IAAI,CAAC,EAAE,KAAK,EAAE;CAEtE,OAAO,mBAAmB,KAAK,CAAC,CAAC;AACnC;AAEA,SAAgB,mBAAmB,aAGjC;CACA,MAAM,YAAY,KAAK,mBAAmB,WAAW,CAAC;CACtD,MAAM,QAAQ,WAAW,KAAK,YAAW,MAAK,EAAE,WAAW,CAAC,CAAC;CAC7D,OAAO,KAAK,MAAM,IAAI,YAAY,EAAE,OAAO,KAAK,CAAC;AACnD"}

package/out/packages/zero-protocol/src/custom-queries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-queries.js","names":[],"sources":["../../../../../zero-protocol/src/custom-queries.ts"],"sourcesContent":["import {jsonSchema} from '../../shared/src/json-schema.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport {astSchema} from './ast.ts';\nimport {transformFailedBodySchema} from './error.ts';\n\nexport const transformRequestBodySchema = v.array(\n  v.object({\n    id: v.string(),\n    name: v.string(),\n    args: v.readonly(v.array(jsonSchema)),\n  }),\n);\nexport type TransformRequestBody = v.Infer<typeof transformRequestBodySchema>;\n\nexport const transformedQuerySchema = v.object({\n  id: v.string(),\n  name: v.string(),\n  ast: astSchema,\n});\n\nexport const appErroredQuerySchema = v.object({\n  error: v.literal('app'),\n  id: v.string(),\n  name: v.string(),\n  // optional for backwards compatibility\n  message: v.string().optional(),\n  details: jsonSchema.optional(),\n});\nexport const parseErroredQuerySchema = v.object({\n  error: v.literal('parse'),\n  id: v.string(),\n  name: v.string(),\n  message: v.string(),\n  details: jsonSchema.optional(),\n});\nexport const erroredQuerySchema = v.union(\n  appErroredQuerySchema,\n  parseErroredQuerySchema,\n);\nexport type ErroredQuery = v.Infer<typeof erroredQuerySchema>;\n\nexport const transformResponseBodySchema = v.array(\n  v.union(transformedQuerySchema, erroredQuerySchema),\n);\nexport type TransformResponseBody = v.Infer<typeof transformResponseBodySchema>;\n\nexport const transformRequestMessageSchema = v.tuple([\n  v.literal('transform'),\n  transformRequestBodySchema,\n]);\nexport type TransformRequestMessage = v.Infer<\n  typeof transformRequestMessageSchema\n>;\nexport const transformErrorMessageSchema = v.tuple([\n  v.literal('transformError'),\n  v.array(erroredQuerySchema),\n]);\nexport type TransformErrorMessage = v.Infer<typeof transformErrorMessageSchema>;\n\nconst transformFailedMessageSchema = v.tuple([\n  v.literal('transformFailed'),\n  transformFailedBodySchema,\n]);\nconst transformOkMessageSchema = v.tuple([\n  v.literal('transformed'),\n  transformResponseBodySchema,\n]);\n\nexport const transformResponseMessageSchema = v.union(\n  transformOkMessageSchema,\n  transformFailedMessageSchema,\n);\nexport type TransformResponseMessage = v.Infer<\n  typeof transformResponseMessageSchema\n>;\n"],"mappings":";;;;;AAKA,IAAa,6BAA6B,eAAE,MAC1C,eAAE,OAAO;CACP,IAAI,eAAE,OAAO;CACb,MAAM,eAAE,OAAO;CACf,MAAM,SAAW,eAAE,MAAM,UAAU,CAAC;AACtC,CAAC,CACH;AAGA,IAAa,yBAAyB,eAAE,OAAO;CAC7C,IAAI,eAAE,OAAO;CACb,MAAM,eAAE,OAAO;CACf,KAAK;AACP,CAAC;AAED,IAAa,wBAAwB,eAAE,OAAO;CAC5C,OAAO,eAAE,QAAQ,KAAK;CACtB,IAAI,eAAE,OAAO;CACb,MAAM,eAAE,OAAO;CAEf,SAAS,eAAE,OAAO,EAAE,SAAS;CAC7B,SAAS,WAAW,SAAS;AAC/B,CAAC;AACD,IAAa,0BAA0B,eAAE,OAAO;CAC9C,OAAO,eAAE,QAAQ,OAAO;CACxB,IAAI,eAAE,OAAO;CACb,MAAM,eAAE,OAAO;CACf,SAAS,eAAE,OAAO;CAClB,SAAS,WAAW,SAAS;AAC/B,CAAC;AACD,IAAa,qBAAqB,eAAE,MAClC,uBACA,uBACF;AAGA,IAAa,8BAA8B,eAAE,MAC3C,eAAE,MAAM,wBAAwB,kBAAkB,CACpD;AAGA,IAAa,gCAAgC,eAAE,MAAM,CACnD,eAAE,QAAQ,WAAW,GACrB,0BACF,CAAC;AAID,IAAa,8BAA8B,eAAE,MAAM,CACjD,eAAE,QAAQ,gBAAgB,GAC1B,eAAE,MAAM,kBAAkB,CAC5B,CAAC;AAGD,IAAM,+BAA+B,eAAE,MAAM,CAC3C,eAAE,QAAQ,iBAAiB,GAC3B,yBACF,CAAC;AACD,IAAM,2BAA2B,eAAE,MAAM,CACvC,eAAE,QAAQ,aAAa,GACvB,2BACF,CAAC;AAED,IAAa,iCAAiC,eAAE,MAC9C,0BACA,4BACF"}

package/out/packages/zero-protocol/src/data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.js","names":[],"sources":["../../../../../zero-protocol/src/data.ts"],"sourcesContent":["import {jsonSchema} from '../../shared/src/json-schema.ts';\nimport * as v from '../../shared/src/valita.ts';\n\nexport const valueSchema = v.union(jsonSchema, v.undefined());\n\nexport const rowSchema = v.readonlyRecord(valueSchema);\n\n/**\n * The data types that Zero can represent are limited by two things:\n *\n * 1. The underlying Replicache sync layer currently can only represent JSON\n *    types. This could possibly be expanded in the future, but we do want to be\n *    careful of adding encoding overhead. By using JSON, we are taking\n *    advantage of IndexedDB’s fast native JSValue [de]serialization which has\n *    historically been a perf advantage for us.\n *\n * 2. IDs in Zero need to be comparable because we use them for sorting and row\n *    identity. We could expand the set of allowed value types (to include,\n *    i.e., Objects) but we would then need to restrict IDs to only comparable\n *    types.\n *\n * These two facts leave us with the following allowed types. Zero's replication\n * layer must convert other types into these for tables to be used with Zero.\n *\n * For developer convenience we also allow `undefined`, which we treat\n * equivalently to `null`.\n */\nexport type Value = v.Infer<typeof valueSchema>;\n\n/**\n * A Row is represented as a JS Object.\n *\n * We do everything in IVM as loosely typed values because these pipelines are\n * going to be constructed at runtime by other code, so type-safety can't buy us\n * anything.\n *\n * Also since the calling code on the client ultimately wants objects to work\n * with we end up with a lot less copies by using objects throughout.\n */\nexport type Row = v.Infer<typeof rowSchema>;\n"],"mappings":";;AAKA,IAAa,YAAY,eAFE,eAAE,MAAM,YAAY,eAAE,UAAU,CAEjB,CAAW"}

package/out/packages/zero-protocol/src/delete-clients.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-clients.js","names":[],"sources":["../../../../../zero-protocol/src/delete-clients.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\n\nexport const deleteClientsBodySchema = v.union(\n  v.readonlyObject({\n    clientIDs: v.readonlyArray(v.string()).optional(),\n    clientGroupIDs: v.readonlyArray(v.string()).optional(),\n  }),\n);\n\nexport const deleteClientsMessageSchema = v.tuple([\n  v.literal('deleteClients'),\n  deleteClientsBodySchema,\n]);\n\nexport type DeleteClientsBody = v.Infer<typeof deleteClientsBodySchema>;\nexport type DeleteClientsMessage = v.Infer<typeof deleteClientsMessageSchema>;\n"],"mappings":";;AAEA,IAAa,0BAA0B,eAAE,MACvC,eAAiB;CACf,WAAW,cAAgB,eAAE,OAAO,CAAC,EAAE,SAAS;CAChD,gBAAgB,cAAgB,eAAE,OAAO,CAAC,EAAE,SAAS;AACvD,CAAC,CACH;AAEA,IAAa,6BAA6B,eAAE,MAAM,CAChD,eAAE,QAAQ,eAAe,GACzB,uBACF,CAAC"}

package/out/packages/zero-protocol/src/down.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"down.js","names":[],"sources":["../../../../../zero-protocol/src/down.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {connectedMessageSchema} from './connect.ts';\nimport {transformErrorMessageSchema} from './custom-queries.ts';\nimport {deleteClientsMessageSchema} from './delete-clients.ts';\nimport {errorMessageSchema} from './error.ts';\nimport {inspectDownMessageSchema} from './inspect-down.ts';\nimport {\n  pokeEndMessageSchema,\n  pokePartMessageSchema,\n  pokeStartMessageSchema,\n} from './poke.ts';\nimport {pongMessageSchema} from './pong.ts';\nimport {pullResponseMessageSchema} from './pull.ts';\nimport {pushResponseMessageSchema} from './push.ts';\n\nexport const downstreamSchema = v.union(\n  connectedMessageSchema,\n  errorMessageSchema,\n  pongMessageSchema,\n  pokeStartMessageSchema,\n  pokePartMessageSchema,\n  pokeEndMessageSchema,\n  pullResponseMessageSchema,\n  deleteClientsMessageSchema,\n  pushResponseMessageSchema,\n  inspectDownMessageSchema,\n  transformErrorMessageSchema,\n);\n\nexport type Downstream = v.Infer<typeof downstreamSchema>;\n"],"mappings":";;;;;;;;;;;AAeA,IAAa,mBAAmB,eAAE,MAChC,wBACA,oBACA,mBACA,wBACA,uBACA,sBACA,2BACA,4BACA,2BACA,0BACA,2BACF"}

package/out/packages/zero-protocol/src/error-kind-enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-kind-enum.js","names":[],"sources":["../../../../../zero-protocol/src/error-kind-enum.ts"],"sourcesContent":["// Note: Metric names depend on these values,\n// so if you add or change on here a corresponding dashboard\n// change will likely be needed.\n\nexport const AuthInvalidated = 'AuthInvalidated';\nexport const ClientNotFound = 'ClientNotFound';\nexport const InvalidConnectionRequest = 'InvalidConnectionRequest';\nexport const InvalidConnectionRequestBaseCookie =\n  'InvalidConnectionRequestBaseCookie';\nexport const InvalidConnectionRequestLastMutationID =\n  'InvalidConnectionRequestLastMutationID';\nexport const InvalidConnectionRequestClientDeleted =\n  'InvalidConnectionRequestClientDeleted';\nexport const InvalidMessage = 'InvalidMessage';\nexport const InvalidPush = 'InvalidPush';\nexport const PushFailed = 'PushFailed';\nexport const MutationFailed = 'MutationFailed';\nexport const MutationRateLimited = 'MutationRateLimited';\nexport const Rebalance = 'Rebalance';\nexport const Rehome = 'Rehome';\nexport const TransformFailed = 'TransformFailed';\nexport const Unauthorized = 'Unauthorized';\nexport const VersionNotSupported = 'VersionNotSupported';\nexport const SchemaVersionNotSupported = 'SchemaVersionNotSupported';\nexport const ServerOverloaded = 'ServerOverloaded';\nexport const Internal = 'Internal';\n\n/**\n * The app rejected the client's auth token (used in CRUD mutators).\n * @deprecated auth errors are now represented as ['error', { ... }] messages\n */\nexport type AuthInvalidated = typeof AuthInvalidated;\n/**\n * zero-cache no longer has CVR state for the client.\n */\nexport type ClientNotFound = typeof ClientNotFound;\n/**\n * Handshake metadata is invalid or incomplete.\n */\nexport type InvalidConnectionRequest = typeof InvalidConnectionRequest;\n/**\n * Client's base cookie is ahead of the replica snapshot.\n */\nexport type InvalidConnectionRequestBaseCookie =\n  typeof InvalidConnectionRequestBaseCookie;\n/**\n * Client's last mutation ID is ahead of the replica.\n */\nexport type InvalidConnectionRequestLastMutationID =\n  typeof InvalidConnectionRequestLastMutationID;\n/**\n * The server deleted the client.\n */\nexport type InvalidConnectionRequestClientDeleted =\n  typeof InvalidConnectionRequestClientDeleted;\n/**\n * Upstream message failed schema validation or JSON parsing.\n */\nexport type InvalidMessage = typeof InvalidMessage;\n/**\n * Push payload could not be applied (version mismatch, out-of-order mutation).\n */\nexport type InvalidPush = typeof InvalidPush;\n/**\n * Push failed during processing.\n */\nexport type PushFailed = typeof PushFailed;\n/**\n * Transform failed during processing.\n */\nexport type TransformFailed = typeof TransformFailed;\n/**\n * CRUD mutator failure.\n * @deprecated\n */\nexport type MutationFailed = typeof MutationFailed;\n/**\n * CRUD mutator rate limit.\n * @deprecated\n */\nexport type MutationRateLimited = typeof MutationRateLimited;\n/**\n * Cache is rebalancing ownership.\n */\nexport type Rebalance = typeof Rebalance;\n/**\n * Replica ownership moved.\n */\nexport type Rehome = typeof Rehome;\n/**\n * Unauthorized client request.\n */\nexport type Unauthorized = typeof Unauthorized;\n/**\n * Client requested unsupported protocol version.\n */\nexport type VersionNotSupported = typeof VersionNotSupported;\n/**\n * Client schema hash or version is outside zero-cache window.\n */\nexport type SchemaVersionNotSupported = typeof SchemaVersionNotSupported;\n/**\n * zero-cache is overloaded.\n */\nexport type ServerOverloaded = typeof ServerOverloaded;\n/**\n * Unhandled zero-cache exception.\n */\nexport type Internal = typeof Internal;\n"],"mappings":";AAIA,IAAa,kBAAkB;AAC/B,IAAa,iBAAiB;AAC9B,IAAa,2BAA2B;AACxC,IAAa,qCACX;AACF,IAAa,yCACX;AACF,IAAa,wCACX;AACF,IAAa,iBAAiB;AAC9B,IAAa,cAAc;AAC3B,IAAa,aAAa;AAC1B,IAAa,iBAAiB;AAC9B,IAAa,sBAAsB;AACnC,IAAa,YAAY;AACzB,IAAa,SAAS;AACtB,IAAa,kBAAkB;AAC/B,IAAa,eAAe;AAC5B,IAAa,sBAAsB;AACnC,IAAa,4BAA4B;AACzC,IAAa,mBAAmB;AAChC,IAAa,WAAW"}

package/out/packages/zero-protocol/src/error-origin-enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-origin-enum.js","names":[],"sources":["../../../../../zero-protocol/src/error-origin-enum.ts"],"sourcesContent":["export const Client = 'client';\nexport const Server = 'server';\nexport const ZeroCache = 'zeroCache';\n\nexport type Client = typeof Client;\nexport type Server = typeof Server;\nexport type ZeroCache = typeof ZeroCache;\n"],"mappings":";AAAA,IAAa,SAAS;AACtB,IAAa,SAAS;AACtB,IAAa,YAAY"}

package/out/packages/zero-protocol/src/error-reason-enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-reason-enum.js","names":[],"sources":["../../../../../zero-protocol/src/error-reason-enum.ts"],"sourcesContent":["export const Database = 'database';\nexport const Parse = 'parse';\nexport const OutOfOrderMutation = 'oooMutation';\nexport const UnsupportedPushVersion = 'unsupportedPushVersion';\nexport const Internal = 'internal';\nexport const HTTP = 'http';\nexport const Timeout = 'timeout';\n\nexport type Database = typeof Database;\nexport type Parse = typeof Parse;\nexport type OutOfOrderMutation = typeof OutOfOrderMutation;\nexport type UnsupportedPushVersion = typeof UnsupportedPushVersion;\nexport type Internal = typeof Internal;\nexport type HTTP = typeof HTTP;\nexport type Timeout = typeof Timeout;\n"],"mappings":";AAAA,IAAa,WAAW;AACxB,IAAa,QAAQ;AACrB,IAAa,qBAAqB;AAClC,IAAa,yBAAyB;AACtC,IAAa,WAAW;AACxB,IAAa,OAAO;AACpB,IAAa,UAAU"}

package/out/packages/zero-protocol/src/error.js

@@ -0,0 +1,91 @@
+import { literalUnion, valita_exports } from "../../shared/src/valita.js";
+import { jsonSchema } from "../../shared/src/json-schema.js";
+import { AuthInvalidated, ClientNotFound, Internal, InvalidConnectionRequest, InvalidConnectionRequestBaseCookie, InvalidConnectionRequestClientDeleted, InvalidConnectionRequestLastMutationID, InvalidMessage, InvalidPush, MutationFailed, MutationRateLimited, PushFailed, Rebalance, Rehome, SchemaVersionNotSupported, ServerOverloaded, TransformFailed, Unauthorized, VersionNotSupported } from "./error-kind-enum.js";
+import { Server, ZeroCache } from "./error-origin-enum.js";
+import { Database, HTTP, Internal as Internal$1, OutOfOrderMutation, Parse, Timeout, UnsupportedPushVersion } from "./error-reason-enum.js";
+import { mutationIDSchema } from "./mutation-id.js";
+//#region ../zero-protocol/src/error.ts
+var basicErrorKindSchema = literalUnion(AuthInvalidated, ClientNotFound, InvalidConnectionRequest, InvalidConnectionRequestBaseCookie, InvalidConnectionRequestLastMutationID, InvalidConnectionRequestClientDeleted, InvalidMessage, InvalidPush, MutationRateLimited, MutationFailed, Unauthorized, VersionNotSupported, SchemaVersionNotSupported, Internal);
+var basicErrorBodySchema = valita_exports.object({
+	kind: basicErrorKindSchema,
+	message: valita_exports.string(),
+	origin: literalUnion(Server, ZeroCache).optional()
+});
+var backoffErrorKindSchema = literalUnion(Rebalance, Rehome, ServerOverloaded);
+var backoffBodySchema = valita_exports.object({
+	kind: backoffErrorKindSchema,
+	message: valita_exports.string(),
+	minBackoffMs: valita_exports.number().optional(),
+	maxBackoffMs: valita_exports.number().optional(),
+	reconnectParams: valita_exports.record(valita_exports.string()).optional(),
+	origin: valita_exports.literal(ZeroCache).optional()
+});
+var pushFailedErrorKindSchema = valita_exports.literal(PushFailed);
+var transformFailedErrorKindSchema = valita_exports.literal(TransformFailed);
+var errorKindSchema = valita_exports.union(basicErrorKindSchema, backoffErrorKindSchema, pushFailedErrorKindSchema, transformFailedErrorKindSchema);
+var pushFailedBaseSchema = valita_exports.object({
+	kind: pushFailedErrorKindSchema,
+	details: jsonSchema.optional(),
+	/**
+	* The mutationIDs of the mutations that failed to process.
+	* This can be a subset of the mutationIDs in the request.
+	*/
+	mutationIDs: valita_exports.array(mutationIDSchema),
+	message: valita_exports.string()
+});
+var pushFailedBodySchema = valita_exports.union(pushFailedBaseSchema.extend({
+	origin: valita_exports.literal(Server),
+	reason: literalUnion(Database, Parse, OutOfOrderMutation, UnsupportedPushVersion, Internal$1)
+}), pushFailedBaseSchema.extend({
+	origin: valita_exports.literal(ZeroCache),
+	reason: valita_exports.literal(HTTP),
+	status: valita_exports.number(),
+	bodyPreview: valita_exports.string().optional()
+}), pushFailedBaseSchema.extend({
+	origin: valita_exports.literal(ZeroCache),
+	reason: literalUnion(Timeout, Parse, Internal$1)
+}));
+var transformFailedBaseSchema = valita_exports.object({
+	kind: transformFailedErrorKindSchema,
+	details: jsonSchema.optional(),
+	/**
+	* The queryIDs of the queries that failed to transform.
+	*/
+	queryIDs: valita_exports.array(valita_exports.string()),
+	message: valita_exports.string()
+});
+var transformFailedBodySchema = valita_exports.union(transformFailedBaseSchema.extend({
+	origin: valita_exports.literal(Server),
+	reason: literalUnion(Database, Parse, Internal$1)
+}), transformFailedBaseSchema.extend({
+	origin: valita_exports.literal(ZeroCache),
+	reason: valita_exports.literal(HTTP),
+	status: valita_exports.number(),
+	bodyPreview: valita_exports.string().optional()
+}), transformFailedBaseSchema.extend({
+	origin: valita_exports.literal(ZeroCache),
+	reason: literalUnion(Timeout, Parse, Internal$1)
+}));
+var errorBodySchema = valita_exports.union(basicErrorBodySchema, backoffBodySchema, pushFailedBodySchema, transformFailedBodySchema);
+var errorMessageSchema = valita_exports.tuple([valita_exports.literal("error"), errorBodySchema]);
+/**
+* Represents an error used across zero-client, zero-cache, and zero-server.
+*/
+var ProtocolError = class extends Error {
+	errorBody;
+	constructor(errorBody, options) {
+		super(errorBody.message, options);
+		this.name = "ProtocolError";
+		this.errorBody = errorBody;
+	}
+	get kind() {
+		return this.errorBody.kind;
+	}
+};
+function isProtocolError(error) {
+	return error instanceof ProtocolError;
+}
+//#endregion
+export { ProtocolError, errorKindSchema, errorMessageSchema, isProtocolError, pushFailedBodySchema, transformFailedBodySchema };
+
+//# sourceMappingURL=error.js.map

package/out/packages/zero-protocol/src/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","names":[],"sources":["../../../../../zero-protocol/src/error.ts"],"sourcesContent":["import {jsonSchema} from '../../shared/src/json-schema.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport {ErrorKind} from './error-kind.ts';\nimport {ErrorOrigin} from './error-origin.ts';\nimport {ErrorReason} from './error-reason.ts';\nimport {mutationIDSchema} from './mutation-id.ts';\n\nconst basicErrorKindSchema = v.literalUnion(\n  ErrorKind.AuthInvalidated,\n  ErrorKind.ClientNotFound,\n  ErrorKind.InvalidConnectionRequest,\n  ErrorKind.InvalidConnectionRequestBaseCookie,\n  ErrorKind.InvalidConnectionRequestLastMutationID,\n  ErrorKind.InvalidConnectionRequestClientDeleted,\n  ErrorKind.InvalidMessage,\n  ErrorKind.InvalidPush,\n  ErrorKind.MutationRateLimited,\n  ErrorKind.MutationFailed,\n  ErrorKind.Unauthorized,\n  ErrorKind.VersionNotSupported,\n  ErrorKind.SchemaVersionNotSupported,\n  ErrorKind.Internal,\n);\n\nconst basicErrorBodySchema = v.object({\n  kind: basicErrorKindSchema,\n  message: v.string(),\n  // this is optional for backwards compatibility\n  origin: v.literalUnion(ErrorOrigin.Server, ErrorOrigin.ZeroCache).optional(),\n});\n\nconst backoffErrorKindSchema = v.literalUnion(\n  ErrorKind.Rebalance,\n  ErrorKind.Rehome,\n  ErrorKind.ServerOverloaded,\n);\n\nconst backoffBodySchema = v.object({\n  kind: backoffErrorKindSchema,\n  message: v.string(),\n  minBackoffMs: v.number().optional(),\n  maxBackoffMs: v.number().optional(),\n  // Query parameters to send in the next reconnect. In the event of\n  // a conflict, these will be overridden by the parameters used by\n  // the client; it is the responsibility of the server to avoid\n  // parameter name conflicts.\n  //\n  // The parameters will only be added to the immediately following\n  // reconnect, and not after that.\n  reconnectParams: v.record(v.string()).optional(),\n  origin: v.literal(ErrorOrigin.ZeroCache).optional(),\n});\n\nconst pushFailedErrorKindSchema = v.literal(ErrorKind.PushFailed);\nconst transformFailedErrorKindSchema = v.literal(ErrorKind.TransformFailed);\n\nexport const errorKindSchema: v.Type<ErrorKind> = v.union(\n  basicErrorKindSchema,\n  backoffErrorKindSchema,\n  pushFailedErrorKindSchema,\n  transformFailedErrorKindSchema,\n);\n\nconst pushFailedBaseSchema = v.object({\n  kind: pushFailedErrorKindSchema,\n  details: jsonSchema.optional(),\n  /**\n   * The mutationIDs of the mutations that failed to process.\n   * This can be a subset of the mutationIDs in the request.\n   */\n  mutationIDs: v.array(mutationIDSchema),\n  message: v.string(),\n});\n\nexport const pushFailedBodySchema = v.union(\n  pushFailedBaseSchema.extend({\n    origin: v.literal(ErrorOrigin.Server),\n    reason: v.literalUnion(\n      ErrorReason.Database,\n      ErrorReason.Parse,\n      ErrorReason.OutOfOrderMutation,\n      ErrorReason.UnsupportedPushVersion,\n      ErrorReason.Internal,\n    ),\n  }),\n  pushFailedBaseSchema.extend({\n    origin: v.literal(ErrorOrigin.ZeroCache),\n    reason: v.literal(ErrorReason.HTTP),\n    status: v.number(),\n    bodyPreview: v.string().optional(),\n  }),\n  pushFailedBaseSchema.extend({\n    origin: v.literal(ErrorOrigin.ZeroCache),\n    reason: v.literalUnion(\n      ErrorReason.Timeout,\n      ErrorReason.Parse,\n      ErrorReason.Internal,\n    ),\n  }),\n);\n\nconst transformFailedBaseSchema = v.object({\n  kind: transformFailedErrorKindSchema,\n  details: jsonSchema.optional(),\n  /**\n   * The queryIDs of the queries that failed to transform.\n   */\n  queryIDs: v.array(v.string()),\n  message: v.string(),\n});\n\nexport const transformFailedBodySchema = v.union(\n  transformFailedBaseSchema.extend({\n    origin: v.literal(ErrorOrigin.Server),\n    reason: v.literalUnion(\n      ErrorReason.Database,\n      ErrorReason.Parse,\n      ErrorReason.Internal,\n    ),\n  }),\n  transformFailedBaseSchema.extend({\n    origin: v.literal(ErrorOrigin.ZeroCache),\n    reason: v.literal(ErrorReason.HTTP),\n    status: v.number(),\n    bodyPreview: v.string().optional(),\n  }),\n  transformFailedBaseSchema.extend({\n    origin: v.literal(ErrorOrigin.ZeroCache),\n    reason: v.literalUnion(\n      ErrorReason.Timeout,\n      ErrorReason.Parse,\n      ErrorReason.Internal,\n    ),\n  }),\n);\n\nexport const errorBodySchema = v.union(\n  basicErrorBodySchema,\n  backoffBodySchema,\n  pushFailedBodySchema,\n  transformFailedBodySchema,\n);\n\nexport type BackoffBody = v.Infer<typeof backoffBodySchema>;\nexport type PushFailedBody = v.Infer<typeof pushFailedBodySchema>;\nexport type TransformFailedBody = v.Infer<typeof transformFailedBodySchema>;\nexport type ErrorBody = v.Infer<typeof errorBodySchema>;\n\nexport const errorMessageSchema: v.Type<ErrorMessage> = v.tuple([\n  v.literal('error'),\n  errorBodySchema,\n]);\n\nexport type ErrorMessage = ['error', ErrorBody];\n\n/**\n * Represents an error used across zero-client, zero-cache, and zero-server.\n */\nexport class ProtocolError<\n  const T extends ErrorBody = ErrorBody,\n> extends Error {\n  readonly errorBody: T;\n\n  constructor(errorBody: T, options?: ErrorOptions) {\n    super(errorBody.message, options);\n    this.name = 'ProtocolError';\n    this.errorBody = errorBody;\n  }\n\n  get kind(): T['kind'] {\n    return this.errorBody.kind;\n  }\n}\n\nexport function isProtocolError(error: unknown): error is ProtocolError {\n  return error instanceof ProtocolError;\n}\n"],"mappings":";;;;;;;AAOA,IAAM,uBAAuB,aAC3B,iBACA,gBACA,0BACA,oCACA,wCACA,uCACA,gBACA,aACA,qBACA,gBACA,cACA,qBACA,2BACA,QACF;AAEA,IAAM,uBAAuB,eAAE,OAAO;CACpC,MAAM;CACN,SAAS,eAAE,OAAO;CAElB,QAAQ,aAAe,QAAoB,SAAqB,EAAE,SAAS;AAC7E,CAAC;AAED,IAAM,yBAAyB,aAC7B,WACA,QACA,gBACF;AAEA,IAAM,oBAAoB,eAAE,OAAO;CACjC,MAAM;CACN,SAAS,eAAE,OAAO;CAClB,cAAc,eAAE,OAAO,EAAE,SAAS;CAClC,cAAc,eAAE,OAAO,EAAE,SAAS;CAQlC,iBAAiB,eAAE,OAAO,eAAE,OAAO,CAAC,EAAE,SAAS;CAC/C,QAAQ,eAAE,QAAQ,SAAqB,EAAE,SAAS;AACpD,CAAC;AAED,IAAM,4BAA4B,eAAE,QAAQ,UAAoB;AAChE,IAAM,iCAAiC,eAAE,QAAQ,eAAyB;AAE1E,IAAa,kBAAqC,eAAE,MAClD,sBACA,wBACA,2BACA,8BACF;AAEA,IAAM,uBAAuB,eAAE,OAAO;CACpC,MAAM;CACN,SAAS,WAAW,SAAS;;;;;CAK7B,aAAa,eAAE,MAAM,gBAAgB;CACrC,SAAS,eAAE,OAAO;AACpB,CAAC;AAED,IAAa,uBAAuB,eAAE,MACpC,qBAAqB,OAAO;CAC1B,QAAQ,eAAE,QAAQ,MAAkB;CACpC,QAAQ,aACN,UACA,OACA,oBACA,wBACA,UACF;AACF,CAAC,GACD,qBAAqB,OAAO;CAC1B,QAAQ,eAAE,QAAQ,SAAqB;CACvC,QAAQ,eAAE,QAAQ,IAAgB;CAClC,QAAQ,eAAE,OAAO;CACjB,aAAa,eAAE,OAAO,EAAE,SAAS;AACnC,CAAC,GACD,qBAAqB,OAAO;CAC1B,QAAQ,eAAE,QAAQ,SAAqB;CACvC,QAAQ,aACN,SACA,OACA,UACF;AACF,CAAC,CACH;AAEA,IAAM,4BAA4B,eAAE,OAAO;CACzC,MAAM;CACN,SAAS,WAAW,SAAS;;;;CAI7B,UAAU,eAAE,MAAM,eAAE,OAAO,CAAC;CAC5B,SAAS,eAAE,OAAO;AACpB,CAAC;AAED,IAAa,4BAA4B,eAAE,MACzC,0BAA0B,OAAO;CAC/B,QAAQ,eAAE,QAAQ,MAAkB;CACpC,QAAQ,aACN,UACA,OACA,UACF;AACF,CAAC,GACD,0BAA0B,OAAO;CAC/B,QAAQ,eAAE,QAAQ,SAAqB;CACvC,QAAQ,eAAE,QAAQ,IAAgB;CAClC,QAAQ,eAAE,OAAO;CACjB,aAAa,eAAE,OAAO,EAAE,SAAS;AACnC,CAAC,GACD,0BAA0B,OAAO;CAC/B,QAAQ,eAAE,QAAQ,SAAqB;CACvC,QAAQ,aACN,SACA,OACA,UACF;AACF,CAAC,CACH;AAEA,IAAa,kBAAkB,eAAE,MAC/B,sBACA,mBACA,sBACA,yBACF;AAOA,IAAa,qBAA2C,eAAE,MAAM,CAC9D,eAAE,QAAQ,OAAO,GACjB,eACF,CAAC;;;;AAOD,IAAa,gBAAb,cAEU,MAAM;CACd;CAEA,YAAY,WAAc,SAAwB;EAChD,MAAM,UAAU,SAAS,OAAO;EAChC,KAAK,OAAO;EACZ,KAAK,YAAY;CACnB;CAEA,IAAI,OAAkB;EACpB,OAAO,KAAK,UAAU;CACxB;AACF;AAEA,SAAgB,gBAAgB,OAAwC;CACtE,OAAO,iBAAiB;AAC1B"}

package/out/packages/zero-protocol/src/inspect-down.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect-down.js","names":[],"sources":["../../../../../zero-protocol/src/inspect-down.ts"],"sourcesContent":["import {jsonSchema} from '../../shared/src/json-schema.ts';\nimport {tdigestSchema} from '../../shared/src/tdigest-schema.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport {analyzeQueryResultSchema} from './analyze-query-result.ts';\nimport {astSchema} from './ast.ts';\n\nconst serverMetricsSchema = v.object({\n  'query-materialization-server': tdigestSchema,\n  'query-update-server': tdigestSchema,\n});\n\nexport type ServerMetrics = v.Infer<typeof serverMetricsSchema>;\n\n/**\n * Per-query server metrics sent with each query row in the inspector protocol.\n * `query-hydration-server-ms` is a plain number (milliseconds) since each\n * query is typically hydrated only once. `query-update-server` is a TDigest\n * histogram since queries receive many incremental updates.\n */\nconst queryServerMetricsSchema = v.object({\n  'query-hydration-server-ms': v.number().optional(),\n  'query-update-server': tdigestSchema,\n});\n\nexport type QueryServerMetrics = v.Infer<typeof queryServerMetricsSchema>;\n\nconst inspectQueryRowSchema = v.object({\n  clientID: v.string(),\n  queryID: v.string(),\n  // This is the server return AST for custom queries\n  // TODO: Return server generated AST\n  ast: astSchema.nullable(),\n  // not null for custom queries\n  name: v.string().nullable(),\n  // not null for custom queries\n  args: v.readonlyArray(jsonSchema).nullable(),\n  got: v.boolean(),\n  deleted: v.boolean(),\n  ttl: v.number(),\n  inactivatedAt: v.number().nullable(),\n  rowCount: v.number(),\n  metrics: queryServerMetricsSchema.nullable().optional(),\n});\n\nexport type InspectQueryRow = v.Infer<typeof inspectQueryRowSchema>;\n\nconst inspectBaseDownSchema = v.object({\n  id: v.string(),\n});\n\nexport const inspectQueriesDownSchema = inspectBaseDownSchema.extend({\n  op: v.literal('queries'),\n  value: v.array(inspectQueryRowSchema),\n});\n\nexport type InspectQueriesDown = v.Infer<typeof inspectQueriesDownSchema>;\n\nexport const inspectMetricsDownSchema = inspectBaseDownSchema.extend({\n  op: v.literal('metrics'),\n  value: serverMetricsSchema,\n});\n\nexport type InspectMetricsDown = v.Infer<typeof inspectMetricsDownSchema>;\n\nexport const inspectVersionDownSchema = inspectBaseDownSchema.extend({\n  op: v.literal('version'),\n  value: v.string(),\n});\n\nexport const inspectAuthenticatedDownSchema = inspectBaseDownSchema.extend({\n  op: v.literal('authenticated'),\n  value: v.boolean(),\n});\n\nexport type InspectAuthenticatedDown = v.Infer<\n  typeof inspectAuthenticatedDownSchema\n>;\n\nexport const inspectAnalyzeQueryDownSchema = inspectBaseDownSchema.extend({\n  op: v.literal('analyze-query'),\n  value: analyzeQueryResultSchema,\n});\n\nexport type InspectAnalyzeQueryDown = v.Infer<\n  typeof inspectAnalyzeQueryDownSchema\n>;\n\nexport const inspectErrorDownSchema = inspectBaseDownSchema.extend({\n  op: v.literal('error'),\n  value: v.string(),\n});\n\nexport type InspectErrorDown = v.Infer<typeof inspectErrorDownSchema>;\n\nexport const inspectDownBodySchema = v.union(\n  inspectQueriesDownSchema,\n  inspectMetricsDownSchema,\n  inspectVersionDownSchema,\n  inspectAuthenticatedDownSchema,\n  inspectAnalyzeQueryDownSchema,\n  inspectErrorDownSchema,\n);\n\nexport const inspectDownMessageSchema = v.tuple([\n  v.literal('inspect'),\n  inspectDownBodySchema,\n]);\n\nexport type InspectDownMessage = v.Infer<typeof inspectDownMessageSchema>;\n\nexport type InspectDownBody = v.Infer<typeof inspectDownBodySchema>;\n"],"mappings":";;;;;;AAMA,IAAM,sBAAsB,eAAE,OAAO;CACnC,gCAAgC;CAChC,uBAAuB;AACzB,CAAC;;;;;;;AAUD,IAAM,2BAA2B,eAAE,OAAO;CACxC,6BAA6B,eAAE,OAAO,EAAE,SAAS;CACjD,uBAAuB;AACzB,CAAC;AAID,IAAM,wBAAwB,eAAE,OAAO;CACrC,UAAU,eAAE,OAAO;CACnB,SAAS,eAAE,OAAO;CAGlB,KAAK,UAAU,SAAS;CAExB,MAAM,eAAE,OAAO,EAAE,SAAS;CAE1B,MAAM,cAAgB,UAAU,EAAE,SAAS;CAC3C,KAAK,eAAE,QAAQ;CACf,SAAS,eAAE,QAAQ;CACnB,KAAK,eAAE,OAAO;CACd,eAAe,eAAE,OAAO,EAAE,SAAS;CACnC,UAAU,eAAE,OAAO;CACnB,SAAS,yBAAyB,SAAS,EAAE,SAAS;AACxD,CAAC;AAID,IAAM,wBAAwB,eAAE,OAAO,EACrC,IAAI,eAAE,OAAO,EACf,CAAC;AAED,IAAa,2BAA2B,sBAAsB,OAAO;CACnE,IAAI,eAAE,QAAQ,SAAS;CACvB,OAAO,eAAE,MAAM,qBAAqB;AACtC,CAAC;AAID,IAAa,2BAA2B,sBAAsB,OAAO;CACnE,IAAI,eAAE,QAAQ,SAAS;CACvB,OAAO;AACT,CAAC;AAID,IAAa,2BAA2B,sBAAsB,OAAO;CACnE,IAAI,eAAE,QAAQ,SAAS;CACvB,OAAO,eAAE,OAAO;AAClB,CAAC;AAED,IAAa,iCAAiC,sBAAsB,OAAO;CACzE,IAAI,eAAE,QAAQ,eAAe;CAC7B,OAAO,eAAE,QAAQ;AACnB,CAAC;AAMD,IAAa,gCAAgC,sBAAsB,OAAO;CACxE,IAAI,eAAE,QAAQ,eAAe;CAC7B,OAAO;AACT,CAAC;AAMD,IAAa,yBAAyB,sBAAsB,OAAO;CACjE,IAAI,eAAE,QAAQ,OAAO;CACrB,OAAO,eAAE,OAAO;AAClB,CAAC;AAID,IAAa,wBAAwB,eAAE,MACrC,0BACA,0BACA,0BACA,gCACA,+BACA,sBACF;AAEA,IAAa,2BAA2B,eAAE,MAAM,CAC9C,eAAE,QAAQ,SAAS,GACnB,qBACF,CAAC"}

package/out/packages/zero-protocol/src/inspect-up.js

@@ -0,0 +1,35 @@
+import { readonlyArray, valita_exports } from "../../shared/src/valita.js";
+import { jsonSchema } from "../../shared/src/json-schema.js";
+import { astSchema } from "./ast.js";
+//#region ../zero-protocol/src/inspect-up.ts
+var inspectUpBase = valita_exports.object({ id: valita_exports.string() });
+var inspectQueriesUpBodySchema = inspectUpBase.extend({
+	op: valita_exports.literal("queries"),
+	clientID: valita_exports.string().optional()
+});
+var inspectMetricsUpSchema = inspectUpBase.extend({ op: valita_exports.literal("metrics") });
+var inspectVersionUpSchema = inspectUpBase.extend({ op: valita_exports.literal("version") });
+var inspectAuthenticateUpSchema = inspectUpBase.extend({
+	op: valita_exports.literal("authenticate"),
+	value: valita_exports.string()
+});
+var analyzeQueryOptionsSchema = valita_exports.object({
+	vendedRows: valita_exports.boolean().optional(),
+	syncedRows: valita_exports.boolean().optional(),
+	joinPlans: valita_exports.boolean().optional()
+});
+var inspectAnalyzeQueryUpSchema = inspectUpBase.extend({
+	op: valita_exports.literal("analyze-query"),
+	/** @deprecated Use {@linkcode ast} instead */
+	value: astSchema.optional(),
+	options: analyzeQueryOptionsSchema.optional(),
+	ast: astSchema.optional(),
+	name: valita_exports.string().optional(),
+	args: readonlyArray(jsonSchema).optional()
+});
+var inspectUpBodySchema = valita_exports.union(inspectQueriesUpBodySchema, inspectMetricsUpSchema, inspectVersionUpSchema, inspectAuthenticateUpSchema, inspectAnalyzeQueryUpSchema);
+var inspectUpMessageSchema = valita_exports.tuple([valita_exports.literal("inspect"), inspectUpBodySchema]);
+//#endregion
+export { inspectUpMessageSchema };
+
+//# sourceMappingURL=inspect-up.js.map

package/out/packages/zero-protocol/src/inspect-up.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect-up.js","names":[],"sources":["../../../../../zero-protocol/src/inspect-up.ts"],"sourcesContent":["import {jsonSchema} from '../../shared/src/json-schema.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport {astSchema} from './ast.ts';\n\nconst inspectUpBase = v.object({\n  id: v.string(),\n});\n\nconst inspectQueriesUpBodySchema = inspectUpBase.extend({\n  op: v.literal('queries'),\n  clientID: v.string().optional(),\n});\n\nexport type InspectQueriesUpBody = v.Infer<typeof inspectQueriesUpBodySchema>;\n\nconst inspectMetricsUpSchema = inspectUpBase.extend({\n  op: v.literal('metrics'),\n});\n\nexport type InspectMetricsUpBody = v.Infer<typeof inspectMetricsUpSchema>;\n\nconst inspectVersionUpSchema = inspectUpBase.extend({\n  op: v.literal('version'),\n});\n\nexport type InspectVersionUpBody = v.Infer<typeof inspectVersionUpSchema>;\n\nexport const inspectAuthenticateUpSchema = inspectUpBase.extend({\n  op: v.literal('authenticate'),\n  value: v.string(),\n});\n\nexport type InspectAuthenticateUpBody = v.Infer<\n  typeof inspectAuthenticateUpSchema\n>;\n\nconst analyzeQueryOptionsSchema = v.object({\n  vendedRows: v.boolean().optional(),\n  syncedRows: v.boolean().optional(),\n  joinPlans: v.boolean().optional(),\n});\n\nexport type AnalyzeQueryOptions = v.Infer<typeof analyzeQueryOptionsSchema>;\n\nexport const inspectAnalyzeQueryUpSchema = inspectUpBase.extend({\n  op: v.literal('analyze-query'),\n  /** @deprecated Use {@linkcode ast} instead */\n  value: astSchema.optional(),\n  options: analyzeQueryOptionsSchema.optional(),\n  ast: astSchema.optional(),\n  name: v.string().optional(),\n  args: v.readonlyArray(jsonSchema).optional(),\n});\n\nexport type InspectAnalyzeQueryUpBody = v.Infer<\n  typeof inspectAnalyzeQueryUpSchema\n>;\n\nconst inspectUpBodySchema = v.union(\n  inspectQueriesUpBodySchema,\n  inspectMetricsUpSchema,\n  inspectVersionUpSchema,\n  inspectAuthenticateUpSchema,\n  inspectAnalyzeQueryUpSchema,\n);\n\nexport const inspectUpMessageSchema = v.tuple([\n  v.literal('inspect'),\n  inspectUpBodySchema,\n]);\n\nexport type InspectUpMessage = v.Infer<typeof inspectUpMessageSchema>;\n\nexport type InspectUpBody = v.Infer<typeof inspectUpBodySchema>;\n"],"mappings":";;;;AAIA,IAAM,gBAAgB,eAAE,OAAO,EAC7B,IAAI,eAAE,OAAO,EACf,CAAC;AAED,IAAM,6BAA6B,cAAc,OAAO;CACtD,IAAI,eAAE,QAAQ,SAAS;CACvB,UAAU,eAAE,OAAO,EAAE,SAAS;AAChC,CAAC;AAID,IAAM,yBAAyB,cAAc,OAAO,EAClD,IAAI,eAAE,QAAQ,SAAS,EACzB,CAAC;AAID,IAAM,yBAAyB,cAAc,OAAO,EAClD,IAAI,eAAE,QAAQ,SAAS,EACzB,CAAC;AAID,IAAa,8BAA8B,cAAc,OAAO;CAC9D,IAAI,eAAE,QAAQ,cAAc;CAC5B,OAAO,eAAE,OAAO;AAClB,CAAC;AAMD,IAAM,4BAA4B,eAAE,OAAO;CACzC,YAAY,eAAE,QAAQ,EAAE,SAAS;CACjC,YAAY,eAAE,QAAQ,EAAE,SAAS;CACjC,WAAW,eAAE,QAAQ,EAAE,SAAS;AAClC,CAAC;AAID,IAAa,8BAA8B,cAAc,OAAO;CAC9D,IAAI,eAAE,QAAQ,eAAe;;CAE7B,OAAO,UAAU,SAAS;CAC1B,SAAS,0BAA0B,SAAS;CAC5C,KAAK,UAAU,SAAS;CACxB,MAAM,eAAE,OAAO,EAAE,SAAS;CAC1B,MAAM,cAAgB,UAAU,EAAE,SAAS;AAC7C,CAAC;AAMD,IAAM,sBAAsB,eAAE,MAC5B,4BACA,wBACA,wBACA,6BACA,2BACF;AAEA,IAAa,yBAAyB,eAAE,MAAM,CAC5C,eAAE,QAAQ,SAAS,GACnB,mBACF,CAAC"}

package/out/packages/zero-protocol/src/mutate-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutate-server.js","names":[],"sources":["../../../../../zero-protocol/src/mutate-server.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {pushFailedBodySchema} from './error.ts';\nimport {mutationResponseSchema} from './mutation.ts';\nimport {pushErrorSchema} from './push.ts';\n\nconst legacyPushSuccessSchema = v.object({\n  mutations: v.array(mutationResponseSchema),\n});\n\nconst legacyPushResponseSchema = v.union(\n  legacyPushSuccessSchema,\n  pushErrorSchema,\n  pushFailedBodySchema,\n);\n\nexport const mutateSuccessSchema = v.object({\n  kind: v.literal('MutateResponse'),\n  userID: v.string().nullable().optional(),\n  mutations: v.array(mutationResponseSchema),\n});\nexport type MutateSuccess = v.Infer<typeof mutateSuccessSchema>;\n\nexport const mutateResponseSchema = v.union(\n  mutateSuccessSchema,\n  pushFailedBodySchema,\n  // for backwards compatibility\n  legacyPushResponseSchema,\n);\nexport type MutateResponse = v.Infer<typeof mutateResponseSchema>;\n\n/**\n * The schema for the querystring parameters of the custom mutate endpoint.\n */\nexport const mutateParamsSchema = v.object({\n  schema: v.string(),\n  appID: v.string(),\n});\n"],"mappings":";;;;;AAKA,IAAM,0BAA0B,eAAE,OAAO,EACvC,WAAW,eAAE,MAAM,sBAAsB,EAC3C,CAAC;AAED,IAAM,2BAA2B,eAAE,MACjC,yBACA,iBACA,oBACF;AAEA,IAAa,sBAAsB,eAAE,OAAO;CAC1C,MAAM,eAAE,QAAQ,gBAAgB;CAChC,QAAQ,eAAE,OAAO,EAAE,SAAS,EAAE,SAAS;CACvC,WAAW,eAAE,MAAM,sBAAsB;AAC3C,CAAC;AAGD,IAAa,uBAAuB,eAAE,MACpC,qBACA,sBAEA,wBACF;;;;AAMA,IAAa,qBAAqB,eAAE,OAAO;CACzC,QAAQ,eAAE,OAAO;CACjB,OAAO,eAAE,OAAO;AAClB,CAAC"}

package/out/packages/zero-protocol/src/mutation-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-id.js","names":[],"sources":["../../../../../zero-protocol/src/mutation-id.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\n\nexport const mutationIDSchema = v.object({\n  id: v.number(),\n  clientID: v.string(),\n});\n\nexport type MutationID = v.Infer<typeof mutationIDSchema>;\n"],"mappings":";;AAEA,IAAa,mBAAmB,eAAE,OAAO;CACvC,IAAI,eAAE,OAAO;CACb,UAAU,eAAE,OAAO;AACrB,CAAC"}

package/out/packages/zero-protocol/src/mutation-type-enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-type-enum.js","names":[],"sources":["../../../../../zero-protocol/src/mutation-type-enum.ts"],"sourcesContent":["export const CRUD = 'crud';\nexport const Custom = 'custom';\nexport type MutationType = typeof CRUD | typeof Custom;\n\nexport type CRUD = typeof CRUD;\nexport type Custom = typeof Custom;\n"],"mappings":";AAAA,IAAa,OAAO;AACpB,IAAa,SAAS"}

package/out/packages/zero-protocol/src/mutation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation.js","names":[],"sources":["../../../../../zero-protocol/src/mutation.ts"],"sourcesContent":["import {jsonSchema} from '../../shared/src/json-schema.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport type {NameMapper} from '../../zero-types/src/name-mapper.ts';\nimport {rowSchema} from './data.ts';\nimport {mutationIDSchema} from './mutation-id.ts';\nimport * as MutationType from './mutation-type-enum.ts';\nimport {primaryKeySchema, primaryKeyValueRecordSchema} from './primary-key.ts';\n\n// NOTE! If you change this name you must also change the\n// string in `replicache-impl.ts` But CRUD mutators are being\n// deleted soon so this should not happen.\nexport const CRUD_MUTATION_NAME = '_zero_crud';\n\n// Internal mutation name for cleaning up mutation results.\n// This mutation is sent from zero-cache to zero-server to delete\n// acknowledged mutation results from the upstream database.\nexport const CLEANUP_RESULTS_MUTATION_NAME = '_zero_cleanupResults';\n\nexport const cleanupResultsArgSchema = v.union(\n  // Legacy format (no type field) - treat as single\n  v.object({\n    clientGroupID: v.string(),\n    clientID: v.string(),\n    upToMutationID: v.number(),\n  }),\n  // Explicit single: delete up to a specific mutation ID for one client\n  v.object({\n    type: v.literal('single'),\n    clientGroupID: v.string(),\n    clientID: v.string(),\n    upToMutationID: v.number(),\n  }),\n  // Bulk: delete all mutations for multiple clients\n  v.object({\n    type: v.literal('bulk'),\n    clientGroupID: v.string(),\n    // oxlint-disable-next-line e18e/prefer-spread-syntax\n    clientIDs: v.tuple([v.string()]).concat(v.array(v.string())),\n  }),\n);\n\n/**\n * Inserts if entity with id does not already exist.\n */\nconst insertOpSchema = v.object({\n  op: v.literal('insert'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  value: rowSchema,\n});\n\n/**\n * Upsert semantics. Inserts if entity with id does not already exist,\n * otherwise updates existing entity with id.\n */\nconst upsertOpSchema = v.object({\n  op: v.literal('upsert'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  value: rowSchema,\n});\n\n/**\n * Updates if entity with id exists, otherwise does nothing.\n */\nconst updateOpSchema = v.object({\n  op: v.literal('update'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  // Partial value with at least the primary key fields\n  value: rowSchema,\n});\n\n/**\n * Deletes entity with id if it exists, otherwise does nothing.\n */\nconst deleteOpSchema = v.object({\n  op: v.literal('delete'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  // Partial value representing the primary key\n  value: primaryKeyValueRecordSchema,\n});\n\nconst crudOpSchema = v.union(\n  insertOpSchema,\n  upsertOpSchema,\n  updateOpSchema,\n  deleteOpSchema,\n);\n\nconst crudArgSchema = v.object({\n  ops: v.array(crudOpSchema),\n});\n\nconst crudArgsSchema = v.tuple([crudArgSchema]);\n\nexport const crudMutationSchema = v.object({\n  type: v.literal(MutationType.CRUD),\n  id: v.number(),\n  clientID: v.string(),\n  name: v.literal(CRUD_MUTATION_NAME),\n  args: crudArgsSchema,\n  timestamp: v.number(),\n});\n\nexport const customMutationSchema = v.object({\n  type: v.literal(MutationType.Custom),\n  id: v.number(),\n  clientID: v.string(),\n  name: v.string(),\n  args: v.array(jsonSchema),\n  timestamp: v.number(),\n});\n\nexport const mutationSchema = v.union(crudMutationSchema, customMutationSchema);\n\nconst appErrorSchema = v.object({\n  error: v.literal('app'),\n  // The user can return any additional data here\n  message: v.string().optional(),\n  details: jsonSchema.optional(),\n});\nconst zeroErrorSchema = v.object({\n  error: v.union(\n    /** @deprecated push oooMutation errors are now represented as ['error', { ... }] messages */\n    v.literal('oooMutation'),\n    v.literal('alreadyProcessed'),\n  ),\n  details: jsonSchema.optional(),\n});\n\nconst mutationOkSchema = v.object({\n  // The user can return any additional data here\n  data: jsonSchema.optional(),\n});\nconst mutationErrorSchema = v.union(appErrorSchema, zeroErrorSchema);\n\nexport const mutationResultSchema = v.union(\n  mutationOkSchema,\n  mutationErrorSchema,\n);\n\nexport const mutationResponseSchema = v.object({\n  id: mutationIDSchema,\n  result: mutationResultSchema,\n});\n\nexport type InsertOp = v.Infer<typeof insertOpSchema>;\nexport type UpsertOp = v.Infer<typeof upsertOpSchema>;\nexport type UpdateOp = v.Infer<typeof updateOpSchema>;\nexport type DeleteOp = v.Infer<typeof deleteOpSchema>;\nexport type CRUDOp = v.Infer<typeof crudOpSchema>;\nexport type CRUDOpKind = CRUDOp['op'];\nexport type CRUDMutationArg = v.Infer<typeof crudArgSchema>;\nexport type CRUDMutation = v.Infer<typeof crudMutationSchema>;\nexport type CustomMutation = v.Infer<typeof customMutationSchema>;\nexport type Mutation = v.Infer<typeof mutationSchema>;\n\nexport type MutationResponse = v.Infer<typeof mutationResponseSchema>;\nexport type MutationOk = v.Infer<typeof mutationOkSchema>;\nexport type MutationError = v.Infer<typeof mutationErrorSchema>;\nexport type MutationResult = v.Infer<typeof mutationResultSchema>;\nexport type CleanupResultsArg = v.Infer<typeof cleanupResultsArgSchema>;\n\nexport function mapCRUD(\n  arg: CRUDMutationArg,\n  map: NameMapper,\n): CRUDMutationArg {\n  return {\n    ops: arg.ops.map(\n      ({op, tableName, primaryKey, value}) =>\n        ({\n          op,\n          tableName: map.tableName(tableName),\n          primaryKey: map.columns(tableName, primaryKey),\n          value: map.row(tableName, value),\n          // The cast is necessary because ts objects to the `value` field\n          // for \"delete\" ops being different.\n        }) as unknown as CRUDOp,\n    ),\n  };\n}\n"],"mappings":";;;;;;;AAWA,IAAa,qBAAqB;AAKlC,IAAa,gCAAgC;AAE7C,IAAa,0BAA0B,eAAE,MAEvC,eAAE,OAAO;CACP,eAAe,eAAE,OAAO;CACxB,UAAU,eAAE,OAAO;CACnB,gBAAgB,eAAE,OAAO;AAC3B,CAAC,GAED,eAAE,OAAO;CACP,MAAM,eAAE,QAAQ,QAAQ;CACxB,eAAe,eAAE,OAAO;CACxB,UAAU,eAAE,OAAO;CACnB,gBAAgB,eAAE,OAAO;AAC3B,CAAC,GAED,eAAE,OAAO;CACP,MAAM,eAAE,QAAQ,MAAM;CACtB,eAAe,eAAE,OAAO;CAExB,WAAW,eAAE,MAAM,CAAC,eAAE,OAAO,CAAC,CAAC,EAAE,OAAO,eAAE,MAAM,eAAE,OAAO,CAAC,CAAC;AAC7D,CAAC,CACH;;;;AAKA,IAAM,iBAAiB,eAAE,OAAO;CAC9B,IAAI,eAAE,QAAQ,QAAQ;CACtB,WAAW,eAAE,OAAO;CACpB,YAAY;CACZ,OAAO;AACT,CAAC;;;;;AAMD,IAAM,iBAAiB,eAAE,OAAO;CAC9B,IAAI,eAAE,QAAQ,QAAQ;CACtB,WAAW,eAAE,OAAO;CACpB,YAAY;CACZ,OAAO;AACT,CAAC;;;;AAKD,IAAM,iBAAiB,eAAE,OAAO;CAC9B,IAAI,eAAE,QAAQ,QAAQ;CACtB,WAAW,eAAE,OAAO;CACpB,YAAY;CAEZ,OAAO;AACT,CAAC;;;;AAKD,IAAM,iBAAiB,eAAE,OAAO;CAC9B,IAAI,eAAE,QAAQ,QAAQ;CACtB,WAAW,eAAE,OAAO;CACpB,YAAY;CAEZ,OAAO;AACT,CAAC;AAED,IAAM,eAAe,eAAE,MACrB,gBACA,gBACA,gBACA,cACF;AAEA,IAAM,gBAAgB,eAAE,OAAO,EAC7B,KAAK,eAAE,MAAM,YAAY,EAC3B,CAAC;AAED,IAAM,iBAAiB,eAAE,MAAM,CAAC,aAAa,CAAC;AAE9C,IAAa,qBAAqB,eAAE,OAAO;CACzC,MAAM,eAAE,QAAQ,IAAiB;CACjC,IAAI,eAAE,OAAO;CACb,UAAU,eAAE,OAAO;CACnB,MAAM,eAAE,QAAQ,kBAAkB;CAClC,MAAM;CACN,WAAW,eAAE,OAAO;AACtB,CAAC;AAED,IAAa,uBAAuB,eAAE,OAAO;CAC3C,MAAM,eAAE,QAAQ,MAAmB;CACnC,IAAI,eAAE,OAAO;CACb,UAAU,eAAE,OAAO;CACnB,MAAM,eAAE,OAAO;CACf,MAAM,eAAE,MAAM,UAAU;CACxB,WAAW,eAAE,OAAO;AACtB,CAAC;AAED,IAAa,iBAAiB,eAAE,MAAM,oBAAoB,oBAAoB;AAE9E,IAAM,iBAAiB,eAAE,OAAO;CAC9B,OAAO,eAAE,QAAQ,KAAK;CAEtB,SAAS,eAAE,OAAO,EAAE,SAAS;CAC7B,SAAS,WAAW,SAAS;AAC/B,CAAC;AACD,IAAM,kBAAkB,eAAE,OAAO;CAC/B,OAAO,eAAE;;EAEP,eAAE,QAAQ,aAAa;EACvB,eAAE,QAAQ,kBAAkB;CAC9B;CACA,SAAS,WAAW,SAAS;AAC/B,CAAC;AAED,IAAM,mBAAmB,eAAE,OAAO,EAEhC,MAAM,WAAW,SAAS,EAC5B,CAAC;AACD,IAAM,sBAAsB,eAAE,MAAM,gBAAgB,eAAe;AAEnE,IAAa,uBAAuB,eAAE,MACpC,kBACA,mBACF;AAEA,IAAa,yBAAyB,eAAE,OAAO;CAC7C,IAAI;CACJ,QAAQ;AACV,CAAC;AAmBD,SAAgB,QACd,KACA,KACiB;CACjB,OAAO,EACL,KAAK,IAAI,IAAI,KACV,EAAC,IAAI,WAAW,YAAY,aAC1B;EACC;EACA,WAAW,IAAI,UAAU,SAAS;EAClC,YAAY,IAAI,QAAQ,WAAW,UAAU;EAC7C,OAAO,IAAI,IAAI,WAAW,KAAK;CAGjC,EACJ,EACF;AACF"}

package/out/packages/zero-protocol/src/mutations-patch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutations-patch.js","names":[],"sources":["../../../../../zero-protocol/src/mutations-patch.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {mutationIDSchema} from './mutation-id.ts';\nimport {mutationResponseSchema} from './mutation.ts';\n\n/**\n * Mutation results are stored ephemerally in the client\n * hence why we only have the `put` operation.\n *\n * On put the mutation promise is resolved/rejected\n * and reference released.\n */\nexport const putOpSchema = v.object({\n  op: v.literal('put'),\n  mutation: mutationResponseSchema,\n});\nexport const delOpSchema = v.object({\n  op: v.literal('del'),\n  id: mutationIDSchema,\n});\n\nconst patchOpSchema = v.union(putOpSchema, delOpSchema);\nexport const mutationsPatchSchema = v.array(patchOpSchema);\nexport type MutationPatch = v.Infer<typeof patchOpSchema>;\n"],"mappings":";;;;;;;;;;;AAWA,IAAa,cAAc,eAAE,OAAO;CAClC,IAAI,eAAE,QAAQ,KAAK;CACnB,UAAU;AACZ,CAAC;AACD,IAAa,cAAc,eAAE,OAAO;CAClC,IAAI,eAAE,QAAQ,KAAK;CACnB,IAAI;AACN,CAAC;AAED,IAAM,gBAAgB,eAAE,MAAM,aAAa,WAAW;AACtD,IAAa,uBAAuB,eAAE,MAAM,aAAa"}

package/out/packages/zero-protocol/src/ping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ping.js","names":[],"sources":["../../../../../zero-protocol/src/ping.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\n\nexport const pingBodySchema = v.object({});\nexport const pingMessageSchema = v.tuple([v.literal('ping'), pingBodySchema]);\n\nexport type PingBody = v.Infer<typeof pingBodySchema>;\nexport type PingMessage = v.Infer<typeof pingMessageSchema>;\n"],"mappings":";;AAEA,IAAa,iBAAiB,eAAE,OAAO,CAAC,CAAC;AACzC,IAAa,oBAAoB,eAAE,MAAM,CAAC,eAAE,QAAQ,MAAM,GAAG,cAAc,CAAC"}

package/out/packages/zero-protocol/src/poke.js

@@ -0,0 +1,63 @@
+import { valita_exports } from "../../shared/src/valita.js";
+import { queriesPatchSchema } from "./queries-patch.js";
+import { mutationsPatchSchema } from "./mutations-patch.js";
+import { rowsPatchSchema } from "./row-patch.js";
+import { nullableVersionSchema, versionSchema } from "./version.js";
+//#region ../zero-protocol/src/poke.ts
+/**
+* Pokes use a multi-part format. Pokes send entity data to the client and can
+* be multiple mega-bytes in size. Using a multi-part format allows the server
+* to avoid having to have the full poke in memory at one time.
+*
+* Each poke is assigned a `pokeID`, a unique id (within the context of the
+* connection) for identifying the poke.  All messages for a poke will have the
+* same `pokeID`.
+*
+* A poke begins with a `poke-start` message which contains the `baseCookie`
+* the poke is updating from and the `cookie` the poke is updating to.
+*
+* The poke continues with zero to many `poke-part` messages, each of which
+* can contain patch parts.  These patch parts should be merged in the order
+* received.
+*
+* Finally, the poke ends with a `poke-end` message.  The merged `poke-parts`
+* can now be applied as a whole to update from `baseCookie` to `cookie`.
+*
+* Poke messages can be intermingled with other `down` messages, but cannot be
+* intermingled with poke messages for a different `pokeID`. If this is
+* observed it is an unexpected error; the client should ignore both pokes,
+* disconnect, and reconnect.
+*/
+var pokeStartBodySchema = valita_exports.object({
+	pokeID: valita_exports.string(),
+	baseCookie: nullableVersionSchema,
+	/**
+	* This field is always set if the poke contains a `rowsPatch`.
+	* It may be absent for patches that only update clients and queries.
+	*/
+	schemaVersions: valita_exports.object({
+		minSupportedVersion: valita_exports.number(),
+		maxSupportedVersion: valita_exports.number()
+	}).optional(),
+	timestamp: valita_exports.number().optional()
+});
+var pokePartBodySchema = valita_exports.object({
+	pokeID: valita_exports.string(),
+	lastMutationIDChanges: valita_exports.record(valita_exports.number()).optional(),
+	desiredQueriesPatches: valita_exports.record(queriesPatchSchema).optional(),
+	gotQueriesPatch: queriesPatchSchema.optional(),
+	rowsPatch: rowsPatchSchema.optional(),
+	mutationsPatch: mutationsPatchSchema.optional()
+});
+var pokeEndBodySchema = valita_exports.object({
+	pokeID: valita_exports.string(),
+	cookie: versionSchema,
+	cancel: valita_exports.boolean().optional()
+});
+var pokeStartMessageSchema = valita_exports.tuple([valita_exports.literal("pokeStart"), pokeStartBodySchema]);
+var pokePartMessageSchema = valita_exports.tuple([valita_exports.literal("pokePart"), pokePartBodySchema]);
+var pokeEndMessageSchema = valita_exports.tuple([valita_exports.literal("pokeEnd"), pokeEndBodySchema]);
+//#endregion
+export { pokeEndMessageSchema, pokePartMessageSchema, pokeStartMessageSchema };
+
+//# sourceMappingURL=poke.js.map

package/out/packages/zero-protocol/src/poke.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poke.js","names":[],"sources":["../../../../../zero-protocol/src/poke.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {mutationsPatchSchema} from './mutations-patch.ts';\nimport {queriesPatchSchema} from './queries-patch.ts';\nimport {rowsPatchSchema} from './row-patch.ts';\nimport {nullableVersionSchema, versionSchema} from './version.ts';\n\n/**\n * Pokes use a multi-part format. Pokes send entity data to the client and can\n * be multiple mega-bytes in size. Using a multi-part format allows the server\n * to avoid having to have the full poke in memory at one time.\n *\n * Each poke is assigned a `pokeID`, a unique id (within the context of the\n * connection) for identifying the poke.  All messages for a poke will have the\n * same `pokeID`.\n *\n * A poke begins with a `poke-start` message which contains the `baseCookie`\n * the poke is updating from and the `cookie` the poke is updating to.\n *\n * The poke continues with zero to many `poke-part` messages, each of which\n * can contain patch parts.  These patch parts should be merged in the order\n * received.\n *\n * Finally, the poke ends with a `poke-end` message.  The merged `poke-parts`\n * can now be applied as a whole to update from `baseCookie` to `cookie`.\n *\n * Poke messages can be intermingled with other `down` messages, but cannot be\n * intermingled with poke messages for a different `pokeID`. If this is\n * observed it is an unexpected error; the client should ignore both pokes,\n * disconnect, and reconnect.\n */\n\nexport const pokeStartBodySchema = v.object({\n  pokeID: v.string(),\n  // We always specify a Version as our cookie, but Replicache starts clients\n  // with initial cookie `null`, before the first request. So we have to be\n  // able to send a base cookie with value `null` to match that state.\n  baseCookie: nullableVersionSchema,\n  /**\n   * This field is always set if the poke contains a `rowsPatch`.\n   * It may be absent for patches that only update clients and queries.\n   */\n  schemaVersions: v\n    .object({\n      minSupportedVersion: v.number(),\n      maxSupportedVersion: v.number(),\n    })\n    .optional(),\n  timestamp: v.number().optional(),\n});\n\nexport const pokePartBodySchema = v.object({\n  pokeID: v.string(),\n  // Changes to last mutation id by client id.\n  lastMutationIDChanges: v.record(v.number()).optional(),\n  // Patches to the desired query sets by client id.\n  desiredQueriesPatches: v.record(queriesPatchSchema).optional(),\n  // Patches to the set of queries for which entities are sync'd in\n  // rowsPatch.\n  gotQueriesPatch: queriesPatchSchema.optional(),\n  // Patches to the rows set.\n  rowsPatch: rowsPatchSchema.optional(),\n  // Mutation results patch\n  mutationsPatch: mutationsPatchSchema.optional(),\n});\n\nexport const pokeEndBodySchema = v.object({\n  pokeID: v.string(),\n  // Note: This should be ignored (and may be empty) if cancel === `true`.\n  cookie: versionSchema,\n  // If `true`, the poke with id `pokeID` should be discarded without\n  // applying it.\n  cancel: v.boolean().optional(),\n});\n\nexport const pokeStartMessageSchema = v.tuple([\n  v.literal('pokeStart'),\n  pokeStartBodySchema,\n]);\nexport const pokePartMessageSchema = v.tuple([\n  v.literal('pokePart'),\n  pokePartBodySchema,\n]);\nexport const pokeEndMessageSchema = v.tuple([\n  v.literal('pokeEnd'),\n  pokeEndBodySchema,\n]);\n\nexport type PokeStartBody = v.Infer<typeof pokeStartBodySchema>;\nexport type PokePartBody = v.Infer<typeof pokePartBodySchema>;\nexport type PokeEndBody = v.Infer<typeof pokeEndBodySchema>;\n\nexport type PokeStartMessage = v.Infer<typeof pokeStartMessageSchema>;\nexport type PokePartMessage = v.Infer<typeof pokePartMessageSchema>;\nexport type PokeEndMessage = v.Infer<typeof pokeEndMessageSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,sBAAsB,eAAE,OAAO;CAC1C,QAAQ,eAAE,OAAO;CAIjB,YAAY;;;;;CAKZ,gBAAgB,eACb,OAAO;EACN,qBAAqB,eAAE,OAAO;EAC9B,qBAAqB,eAAE,OAAO;CAChC,CAAC,EACA,SAAS;CACZ,WAAW,eAAE,OAAO,EAAE,SAAS;AACjC,CAAC;AAED,IAAa,qBAAqB,eAAE,OAAO;CACzC,QAAQ,eAAE,OAAO;CAEjB,uBAAuB,eAAE,OAAO,eAAE,OAAO,CAAC,EAAE,SAAS;CAErD,uBAAuB,eAAE,OAAO,kBAAkB,EAAE,SAAS;CAG7D,iBAAiB,mBAAmB,SAAS;CAE7C,WAAW,gBAAgB,SAAS;CAEpC,gBAAgB,qBAAqB,SAAS;AAChD,CAAC;AAED,IAAa,oBAAoB,eAAE,OAAO;CACxC,QAAQ,eAAE,OAAO;CAEjB,QAAQ;CAGR,QAAQ,eAAE,QAAQ,EAAE,SAAS;AAC/B,CAAC;AAED,IAAa,yBAAyB,eAAE,MAAM,CAC5C,eAAE,QAAQ,WAAW,GACrB,mBACF,CAAC;AACD,IAAa,wBAAwB,eAAE,MAAM,CAC3C,eAAE,QAAQ,UAAU,GACpB,kBACF,CAAC;AACD,IAAa,uBAAuB,eAAE,MAAM,CAC1C,eAAE,QAAQ,SAAS,GACnB,iBACF,CAAC"}

package/out/packages/zero-protocol/src/pong.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pong.js","names":[],"sources":["../../../../../zero-protocol/src/pong.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\n\nexport const pongBodySchema = v.object({});\nexport const pongMessageSchema = v.tuple([v.literal('pong'), pongBodySchema]);\n\nexport type PongBody = v.Infer<typeof pongBodySchema>;\nexport type PongMessage = v.Infer<typeof pongMessageSchema>;\n"],"mappings":";;AAEA,IAAa,iBAAiB,eAAE,OAAO,CAAC,CAAC;AACzC,IAAa,oBAAoB,eAAE,MAAM,CAAC,eAAE,QAAQ,MAAM,GAAG,cAAc,CAAC"}

package/out/packages/zero-protocol/src/primary-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primary-key.js","names":[],"sources":["../../../../../zero-protocol/src/primary-key.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\n\nexport const primaryKeySchema = v.readonly(\n  // oxlint-disable-next-line e18e/prefer-spread-syntax\n  v.tuple([v.string()]).concat(v.array(v.string())),\n);\n\nexport type PrimaryKey = v.Infer<typeof primaryKeySchema>;\n\nexport const primaryKeyValueSchema = v.union(\n  v.string(),\n  v.number(),\n  v.boolean(),\n);\n\nexport type PrimaryKeyValue = v.Infer<typeof primaryKeyValueSchema>;\n\nexport const primaryKeyValueRecordSchema = v.readonlyRecord(\n  primaryKeyValueSchema,\n);\n\nexport type PrimaryKeyValueRecord = v.Infer<typeof primaryKeyValueRecordSchema>;\n"],"mappings":";;AAEA,IAAa,mBAAmB,SAE9B,eAAE,MAAM,CAAC,eAAE,OAAO,CAAC,CAAC,EAAE,OAAO,eAAE,MAAM,eAAE,OAAO,CAAC,CAAC,CAClD;AAIA,IAAa,wBAAwB,eAAE,MACrC,eAAE,OAAO,GACT,eAAE,OAAO,GACT,eAAE,QAAQ,CACZ;AAIA,IAAa,8BAA8B,eACzC,qBACF"}

package/out/packages/zero-protocol/src/protocol-version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-version.js","names":[],"sources":["../../../../../zero-protocol/src/protocol-version.ts"],"sourcesContent":["import {assert} from '../../shared/src/asserts.ts';\n\n/**\n * The current `PROTOCOL_VERSION` of the code.\n *\n * The `PROTOCOL_VERSION` encompasses both the wire-protocol of the `/sync/...`\n * connection between the browser and `zero-cache`, as well as the format of\n * the `AST` objects stored in both components (i.e. IDB and CVR).\n *\n * A change in the `AST` schema (e.g. new functionality added) must be\n * accompanied by an increment of the `PROTOCOL_VERSION` and a new major\n * release. The server (`zero-cache`) must be deployed before clients start\n * running the new code.\n */\n// History:\n// -- Version 5 adds support for `pokeEnd.cookie`. (0.14)\n// -- Version 6 makes `pokeStart.cookie` optional. (0.16)\n// -- Version 7 introduces the initConnection.clientSchema field. (0.17)\n// -- Version 8 drops support for Version 5 (0.18).\n// -- Version 11 adds inspect queries. (0.18)\n// -- Version 12 adds 'timestamp' and 'date' types to the ClientSchema ValueType. (not shipped, reversed by version 14)\n// -- Version 14 removes 'timestamp' and 'date' types from the ClientSchema ValueType. (0.18)\n// -- Version 15 adds a `userPushParams` field to `initConnection` (0.19)\n// -- Version 16 adds a new error type (alreadyProcessed) to mutation responses (0.19)\n// -- Version 17 deprecates `AST` in downstream query puts. It was never used anyway. (0.21)\n// -- Version 18 adds `name` and `args` to the `queries-patch` protocol (0.21)\n// -- Version 19 adds `activeClients` to the `initConnection` protocol (0.22)\n// -- Version 20 changes inspector down message (0.22)\n// -- Version 21 removes `AST` in downstream query puts which was deprecated in Version 17, removes support for versions < 18 (0.22)\n// -- Version 22 adds an optional 'userQueryParams' field to `initConnection` (0.22)\n// -- Version 23 add `mutationResults` to poke (0.22)\n// -- Version 24 adds `ackMutationResults` to upstream (0.22).\n// -- version 25 modifies `mutationsResults` to include `del` patches (0.22)\n// -- version 26 adds inspect/metrics and adds metrics to inspect/query (0.23)\n// -- version 27 adds inspect/version (0.23)\n// -- version 28 adds more inspect/metrics (0.23)\n// -- version 29 adds error responses for custom queries (0.23)\n// -- version 30 adds an optional primaryKey to the ClientSchema (0.24)\n// -- version 31 adds admin password authentication to inspector RPC calls (0.24)\n// -- version 32 adds analyze-query to the inspector RPC calls (0.24)\n// -- version 33 adds `flip` to CorrelatedSubquery (0.25)\n// -- version 34 moves `flip` from CorrelatedSubquery to CorrelatedSubqueryCondition (0.25)\n// -- version 35 adds `readRows`, `readRowCountsByQuery` and `readRowCount` to analyze-query result (0.25)\n// -- version 36 changes inspector analyze-query and adds error response to RPC (0.25)\n// -- version 37 adds `elapsed` to AnalyzeQueryResult (0.25)\n// -- version 38 adds structured push/transform error responses (0.25)\n// -- version 39 removes per-transform error types and adds `message` to app error (0.25)\n// -- version 40 adds `dbRowScansByQuery` to AnalyzeQueryResult (0.25)\n// -- version 41 makes ClientSchema.primaryKey required (0.25)\n// -- version 42 adds planner events to AnalyzeQueryResult (0.25)\n// -- version 43 renames `plans` to `sqlitePlans`, `plannerEvents` to `joinPlans`, and `plannerDebug` option to `joinPlans` (0.25)\n// -- version 44 adds profileID to connection URL (0.25)\n// -- version 45 adds userPushHeaders and userQueryHeaders to initConnection (0.25)\n// -- version 46 adds scalarSubquery condition type to AST\n// -- version 47 adds optional auth token to push body\n// -- version 48 adds updateAuth\n// -- version 49 adds `scalar` to CorrelatedSubqueryCondition, removes scalarSubquery\n// -- version 50 adds OTEL headers to push and query messages\n// -- version 51 changes inspector metrics fields\nexport const PROTOCOL_VERSION = 51;\n\n/**\n * The minimum server-supported sync protocol version (i.e. the version\n * declared in the \"/sync/v{#}/connect\" URL). The contract for\n * backwards compatibility is that a `zero-cache` supports the current\n * `PROTOCOL_VERSION` and at least the previous one (i.e. `PROTOCOL_VERSION - 1`)\n * if not earlier ones as well. This corresponds to supporting clients running\n * the current release and the previous (major) release. Any client connections\n * from protocol versions before `MIN_SERVER_SUPPORTED_PROTOCOL_VERSION` are\n * closed with a `VersionNotSupported` error.\n */\nexport const MIN_SERVER_SUPPORTED_SYNC_PROTOCOL = 30;\n\nassert(\n  MIN_SERVER_SUPPORTED_SYNC_PROTOCOL < PROTOCOL_VERSION,\n  'MIN_SERVER_SUPPORTED_SYNC_PROTOCOL must be less than PROTOCOL_VERSION',\n);\n"],"mappings":";AAyEA,OAAA,MAEE,uEACF"}

package/out/packages/zero-protocol/src/pull.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull.js","names":[],"sources":["../../../../../zero-protocol/src/pull.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {nullableVersionSchema, versionSchema} from './version.ts';\n\nexport const pullRequestBodySchema = v.object({\n  clientGroupID: v.string(),\n  cookie: nullableVersionSchema,\n  requestID: v.string(),\n});\n\nexport const pullResponseBodySchema = v.object({\n  cookie: versionSchema,\n  // Matches pullRequestBodySchema requestID that initiated this response\n  requestID: v.string(),\n  lastMutationIDChanges: v.record(v.number()),\n  // Pull is currently only used for mutation recovery which does not use\n  // the patch so we save work by not computing the patch.\n});\n\nexport const pullRequestMessageSchema = v.tuple([\n  v.literal('pull'),\n  pullRequestBodySchema,\n]);\n\nexport const pullResponseMessageSchema = v.tuple([\n  v.literal('pull'),\n  pullResponseBodySchema,\n]);\n\nexport type PullRequestBody = v.Infer<typeof pullRequestBodySchema>;\nexport type PullResponseBody = v.Infer<typeof pullResponseBodySchema>;\n\nexport type PullRequestMessage = v.Infer<typeof pullRequestMessageSchema>;\nexport type PullResponseMessage = v.Infer<typeof pullResponseMessageSchema>;\n"],"mappings":";;;AAGA,IAAa,wBAAwB,eAAE,OAAO;CAC5C,eAAe,eAAE,OAAO;CACxB,QAAQ;CACR,WAAW,eAAE,OAAO;AACtB,CAAC;AAED,IAAa,yBAAyB,eAAE,OAAO;CAC7C,QAAQ;CAER,WAAW,eAAE,OAAO;CACpB,uBAAuB,eAAE,OAAO,eAAE,OAAO,CAAC;AAG5C,CAAC;AAED,IAAa,2BAA2B,eAAE,MAAM,CAC9C,eAAE,QAAQ,MAAM,GAChB,qBACF,CAAC;AAED,IAAa,4BAA4B,eAAE,MAAM,CAC/C,eAAE,QAAQ,MAAM,GAChB,sBACF,CAAC"}

package/out/packages/zero-protocol/src/push.js

@@ -0,0 +1,76 @@
+import { valita_exports } from "../../shared/src/valita.js";
+import { mutationIDSchema } from "./mutation-id.js";
+import { pushFailedBodySchema } from "./error.js";
+import { mutationResponseSchema, mutationSchema } from "./mutation.js";
+//#region ../zero-protocol/src/push.ts
+var pushBodySchema = valita_exports.object({
+	clientGroupID: valita_exports.string(),
+	mutations: valita_exports.array(mutationSchema),
+	pushVersion: valita_exports.number(),
+	schemaVersion: valita_exports.number().optional(),
+	timestamp: valita_exports.number(),
+	requestID: valita_exports.string(),
+	/**
+	* @deprecated auth is managed at client-group scope via connect/updateAuth
+	* and should not be included in push messages.
+	*/
+	auth: valita_exports.string().optional(),
+	/** W3C traceparent header for distributed tracing. */
+	traceparent: valita_exports.string().optional()
+});
+var pushMessageSchema = valita_exports.tuple([valita_exports.literal("push"), pushBodySchema]);
+var pushOkSchema = valita_exports.object({ mutations: valita_exports.array(mutationResponseSchema) });
+/**
+* @deprecated push errors are now represented as ['error', { ... }] messages
+*/
+var unsupportedPushVersionSchema = valita_exports.object({
+	/** @deprecated */
+	error: valita_exports.literal("unsupportedPushVersion"),
+	/** @deprecated */
+	mutationIDs: valita_exports.array(mutationIDSchema).optional()
+});
+/**
+* @deprecated push errors are now represented as ['error', { ... }] messages
+*/
+var unsupportedSchemaVersionSchema = valita_exports.object({
+	/** @deprecated */
+	error: valita_exports.literal("unsupportedSchemaVersion"),
+	/** @deprecated */
+	mutationIDs: valita_exports.array(mutationIDSchema).optional()
+});
+/**
+* @deprecated push http errors are now represented as ['error', { ... }] messages
+*/
+var httpErrorSchema = valita_exports.object({
+	/** @deprecated */
+	error: valita_exports.literal("http"),
+	/** @deprecated */
+	status: valita_exports.number(),
+	/** @deprecated */
+	details: valita_exports.string(),
+	/** @deprecated */
+	mutationIDs: valita_exports.array(mutationIDSchema).optional()
+});
+/**
+* @deprecated push zero errors are now represented as ['error', { ... }] messages
+*/
+var zeroPusherErrorSchema = valita_exports.object({
+	/** @deprecated */
+	error: valita_exports.literal("zeroPusher"),
+	/** @deprecated */
+	details: valita_exports.string(),
+	/** @deprecated */
+	mutationIDs: valita_exports.array(mutationIDSchema).optional()
+});
+/**
+* @deprecated push errors are now represented as ['error', { ... }] messages
+*/
+var pushErrorSchema = valita_exports.union(unsupportedPushVersionSchema, unsupportedSchemaVersionSchema, httpErrorSchema, zeroPusherErrorSchema);
+var pushResponseBodySchema = valita_exports.union(pushOkSchema, pushErrorSchema);
+valita_exports.union(pushResponseBodySchema, pushFailedBodySchema);
+var pushResponseMessageSchema = valita_exports.tuple([valita_exports.literal("pushResponse"), pushResponseBodySchema]);
+var ackMutationResponsesMessageSchema = valita_exports.tuple([valita_exports.literal("ackMutationResponses"), mutationIDSchema]);
+//#endregion
+export { ackMutationResponsesMessageSchema, pushBodySchema, pushErrorSchema, pushMessageSchema, pushResponseMessageSchema };
+
+//# sourceMappingURL=push.js.map

package/out/packages/zero-protocol/src/push.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.js","names":[],"sources":["../../../../../zero-protocol/src/push.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {pushFailedBodySchema} from './error.ts';\nimport {mutationIDSchema} from './mutation-id.ts';\nimport {mutationResponseSchema, mutationSchema} from './mutation.ts';\n\nexport const pushBodySchema = v.object({\n  clientGroupID: v.string(),\n  mutations: v.array(mutationSchema),\n  pushVersion: v.number(),\n  // For legacy (CRUD) mutations, the schema is tied to the client group /\n  // sync connection. For custom mutations, schema versioning is delegated\n  // to the custom protocol / api-server.\n  schemaVersion: v.number().optional(),\n  timestamp: v.number(),\n  requestID: v.string(),\n  /**\n   * @deprecated auth is managed at client-group scope via connect/updateAuth\n   * and should not be included in push messages.\n   */\n  auth: v.string().optional(),\n  /** W3C traceparent header for distributed tracing. */\n  traceparent: v.string().optional(),\n});\n\nexport const pushMessageSchema = v.tuple([v.literal('push'), pushBodySchema]);\n\nconst pushOkSchema = v.object({\n  mutations: v.array(mutationResponseSchema),\n});\n\n/**\n * @deprecated push errors are now represented as ['error', { ... }] messages\n */\nconst unsupportedPushVersionSchema = v.object({\n  /** @deprecated */\n  error: v.literal('unsupportedPushVersion'),\n  /** @deprecated */\n  mutationIDs: v.array(mutationIDSchema).optional(),\n});\n/**\n * @deprecated push errors are now represented as ['error', { ... }] messages\n */\nconst unsupportedSchemaVersionSchema = v.object({\n  /** @deprecated */\n  error: v.literal('unsupportedSchemaVersion'),\n  /** @deprecated */\n  mutationIDs: v.array(mutationIDSchema).optional(),\n});\n/**\n * @deprecated push http errors are now represented as ['error', { ... }] messages\n */\nconst httpErrorSchema = v.object({\n  /** @deprecated */\n  error: v.literal('http'),\n  /** @deprecated */\n  status: v.number(),\n  /** @deprecated */\n  details: v.string(),\n  /** @deprecated */\n  mutationIDs: v.array(mutationIDSchema).optional(),\n});\n/**\n * @deprecated push zero errors are now represented as ['error', { ... }] messages\n */\nconst zeroPusherErrorSchema = v.object({\n  /** @deprecated */\n  error: v.literal('zeroPusher'),\n  /** @deprecated */\n  details: v.string(),\n  /** @deprecated */\n  mutationIDs: v.array(mutationIDSchema).optional(),\n});\n/**\n * @deprecated push errors are now represented as ['error', { ... }] messages\n */\nexport const pushErrorSchema = v.union(\n  unsupportedPushVersionSchema,\n  unsupportedSchemaVersionSchema,\n  httpErrorSchema,\n  zeroPusherErrorSchema,\n);\n\nexport const pushResponseBodySchema = v.union(pushOkSchema, pushErrorSchema);\n\nexport const pushResponseSchema = v.union(\n  pushResponseBodySchema,\n  pushFailedBodySchema,\n);\nexport const pushResponseMessageSchema = v.tuple([\n  v.literal('pushResponse'),\n  pushResponseBodySchema,\n]);\n\nexport const ackMutationResponsesMessageSchema = v.tuple([\n  v.literal('ackMutationResponses'),\n  mutationIDSchema,\n]);\n\nexport type PushBody = v.Infer<typeof pushBodySchema>;\nexport type PushMessage = v.Infer<typeof pushMessageSchema>;\nexport type PushResponseBody = v.Infer<typeof pushResponseBodySchema>;\nexport type PushResponse = v.Infer<typeof pushResponseSchema>;\nexport type PushResponseMessage = v.Infer<typeof pushResponseMessageSchema>;\nexport type MutationResponse = v.Infer<typeof mutationResponseSchema>;\n/**\n * @deprecated push errors are now represented as ['error', { ... }] messages\n */\nexport type PushError = v.Infer<typeof pushErrorSchema>;\nexport type PushOk = v.Infer<typeof pushOkSchema>;\nexport type AckMutationMessage = v.Infer<\n  typeof ackMutationResponsesMessageSchema\n>;\n"],"mappings":";;;;;AAKA,IAAa,iBAAiB,eAAE,OAAO;CACrC,eAAe,eAAE,OAAO;CACxB,WAAW,eAAE,MAAM,cAAc;CACjC,aAAa,eAAE,OAAO;CAItB,eAAe,eAAE,OAAO,EAAE,SAAS;CACnC,WAAW,eAAE,OAAO;CACpB,WAAW,eAAE,OAAO;;;;;CAKpB,MAAM,eAAE,OAAO,EAAE,SAAS;;CAE1B,aAAa,eAAE,OAAO,EAAE,SAAS;AACnC,CAAC;AAED,IAAa,oBAAoB,eAAE,MAAM,CAAC,eAAE,QAAQ,MAAM,GAAG,cAAc,CAAC;AAE5E,IAAM,eAAe,eAAE,OAAO,EAC5B,WAAW,eAAE,MAAM,sBAAsB,EAC3C,CAAC;;;;AAKD,IAAM,+BAA+B,eAAE,OAAO;;CAE5C,OAAO,eAAE,QAAQ,wBAAwB;;CAEzC,aAAa,eAAE,MAAM,gBAAgB,EAAE,SAAS;AAClD,CAAC;;;;AAID,IAAM,iCAAiC,eAAE,OAAO;;CAE9C,OAAO,eAAE,QAAQ,0BAA0B;;CAE3C,aAAa,eAAE,MAAM,gBAAgB,EAAE,SAAS;AAClD,CAAC;;;;AAID,IAAM,kBAAkB,eAAE,OAAO;;CAE/B,OAAO,eAAE,QAAQ,MAAM;;CAEvB,QAAQ,eAAE,OAAO;;CAEjB,SAAS,eAAE,OAAO;;CAElB,aAAa,eAAE,MAAM,gBAAgB,EAAE,SAAS;AAClD,CAAC;;;;AAID,IAAM,wBAAwB,eAAE,OAAO;;CAErC,OAAO,eAAE,QAAQ,YAAY;;CAE7B,SAAS,eAAE,OAAO;;CAElB,aAAa,eAAE,MAAM,gBAAgB,EAAE,SAAS;AAClD,CAAC;;;;AAID,IAAa,kBAAkB,eAAE,MAC/B,8BACA,gCACA,iBACA,qBACF;AAEA,IAAa,yBAAyB,eAAE,MAAM,cAAc,eAAe;AAEzC,eAAE,MAClC,wBACA,oBACF;AACA,IAAa,4BAA4B,eAAE,MAAM,CAC/C,eAAE,QAAQ,cAAc,GACxB,sBACF,CAAC;AAED,IAAa,oCAAoC,eAAE,MAAM,CACvD,eAAE,QAAQ,sBAAsB,GAChC,gBACF,CAAC"}

package/out/packages/zero-protocol/src/queries-patch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries-patch.js","names":[],"sources":["../../../../../zero-protocol/src/queries-patch.ts"],"sourcesContent":["import {jsonSchema} from '../../shared/src/json-schema.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport {astSchema} from './ast.ts';\n\nexport const putOpSchema = v.object({\n  op: v.literal('put'),\n  hash: v.string(),\n  ttl: v.number().optional(),\n});\n\nexport const upPutOpSchema = putOpSchema.extend({\n  // All fields are optional in this transitional period.\n  // - ast is filled in for client queries\n  // - name and args are filled in for custom queries\n  ast: astSchema.optional(),\n  name: v.string().optional(),\n  args: v.readonly(v.array(jsonSchema)).optional(),\n});\n\nconst delOpSchema = v.object({\n  op: v.literal('del'),\n  hash: v.string(),\n});\n\nconst clearOpSchema = v.object({\n  op: v.literal('clear'),\n});\n\nconst patchOpSchema = v.union(putOpSchema, delOpSchema, clearOpSchema);\nconst upPatchOpSchema = v.union(upPutOpSchema, delOpSchema, clearOpSchema);\n\nexport const queriesPatchSchema = v.array(patchOpSchema);\nexport const upQueriesPatchSchema = v.array(upPatchOpSchema);\n\nexport type QueriesPutOp = v.Infer<typeof putOpSchema>;\nexport type QueriesDelOp = v.Infer<typeof delOpSchema>;\nexport type QueriesClearOp = v.Infer<typeof clearOpSchema>;\nexport type QueriesPatchOp = v.Infer<typeof patchOpSchema>;\nexport type UpQueriesPatchOp = v.Infer<typeof upPatchOpSchema>;\nexport type QueriesPatch = v.Infer<typeof queriesPatchSchema>;\nexport type UpQueriesPatch = v.Infer<typeof upQueriesPatchSchema>;\n"],"mappings":";;;;AAIA,IAAa,cAAc,eAAE,OAAO;CAClC,IAAI,eAAE,QAAQ,KAAK;CACnB,MAAM,eAAE,OAAO;CACf,KAAK,eAAE,OAAO,EAAE,SAAS;AAC3B,CAAC;AAED,IAAa,gBAAgB,YAAY,OAAO;CAI9C,KAAK,UAAU,SAAS;CACxB,MAAM,eAAE,OAAO,EAAE,SAAS;CAC1B,MAAM,SAAW,eAAE,MAAM,UAAU,CAAC,EAAE,SAAS;AACjD,CAAC;AAED,IAAM,cAAc,eAAE,OAAO;CAC3B,IAAI,eAAE,QAAQ,KAAK;CACnB,MAAM,eAAE,OAAO;AACjB,CAAC;AAED,IAAM,gBAAgB,eAAE,OAAO,EAC7B,IAAI,eAAE,QAAQ,OAAO,EACvB,CAAC;AAED,IAAM,gBAAgB,eAAE,MAAM,aAAa,aAAa,aAAa;AACrE,IAAM,kBAAkB,eAAE,MAAM,eAAe,aAAa,aAAa;AAEzE,IAAa,qBAAqB,eAAE,MAAM,aAAa;AACvD,IAAa,uBAAuB,eAAE,MAAM,eAAe"}

package/out/packages/zero-protocol/src/query-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-hash.js","names":[],"sources":["../../../../../zero-protocol/src/query-hash.ts"],"sourcesContent":["import {h64} from '../../shared/src/hash.ts';\nimport {normalizeAST, type AST} from './ast.ts';\n\nconst hashCache = new WeakMap<AST, string>();\n\nexport function hashOfAST(ast: AST): string {\n  const normalized = normalizeAST(ast);\n  const cached = hashCache.get(normalized);\n  if (cached) {\n    return cached;\n  }\n  const hash = h64(JSON.stringify(normalized)).toString(36);\n  hashCache.set(normalized, hash);\n  return hash;\n}\n\nexport function hashOfNameAndArgs(\n  name: string,\n  args: readonly unknown[],\n): string {\n  const argsString = JSON.stringify(args);\n  return h64(`${name}:${argsString}`).toString(36);\n}\n"],"mappings":";;;AAGA,IAAM,4BAAY,IAAI,QAAqB;AAE3C,SAAgB,UAAU,KAAkB;CAC1C,MAAM,aAAa,aAAa,GAAG;CACnC,MAAM,SAAS,UAAU,IAAI,UAAU;CACvC,IAAI,QACF,OAAO;CAET,MAAM,OAAO,IAAI,KAAK,UAAU,UAAU,CAAC,EAAE,SAAS,EAAE;CACxD,UAAU,IAAI,YAAY,IAAI;CAC9B,OAAO;AACT;AAEA,SAAgB,kBACd,MACA,MACQ;CAER,OAAO,IAAI,GAAG,KAAK,GADA,KAAK,UAAU,IACZ,GAAY,EAAE,SAAS,EAAE;AACjD"}

package/out/packages/zero-protocol/src/query-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-server.js","names":[],"sources":["../../../../../zero-protocol/src/query-server.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {\n  erroredQuerySchema,\n  transformedQuerySchema,\n  transformResponseMessageSchema,\n} from './custom-queries.ts';\nimport {transformFailedBodySchema} from './error.ts';\n\nexport const queryResultSchema = v.union(\n  transformedQuerySchema,\n  erroredQuerySchema,\n);\nexport type QueryResult = v.Infer<typeof queryResultSchema>;\n\nexport const queryResponseBodySchema = v.array(queryResultSchema);\nexport type QueryResponseBody = v.Infer<typeof queryResponseBodySchema>;\n\nexport const querySuccessSchema = v.object({\n  kind: v.literal('QueryResponse'),\n  userID: v.string().nullable().optional(),\n  queries: queryResponseBodySchema,\n});\nexport type QuerySuccess = v.Infer<typeof querySuccessSchema>;\n\nexport const queryResponseSchema = v.union(\n  querySuccessSchema,\n  transformFailedBodySchema,\n  // for backwards compatibility\n  transformResponseMessageSchema,\n);\nexport type QueryResponse = v.Infer<typeof queryResponseSchema>;\n"],"mappings":";;;;AAQA,IAAa,oBAAoB,eAAE,MACjC,wBACA,kBACF;AAGA,IAAa,0BAA0B,eAAE,MAAM,iBAAiB;AAGhE,IAAa,qBAAqB,eAAE,OAAO;CACzC,MAAM,eAAE,QAAQ,eAAe;CAC/B,QAAQ,eAAE,OAAO,EAAE,SAAS,EAAE,SAAS;CACvC,SAAS;AACX,CAAC;AAGD,IAAa,sBAAsB,eAAE,MACnC,oBACA,2BAEA,8BACF"}

package/out/packages/zero-protocol/src/row-patch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-patch.js","names":[],"sources":["../../../../../zero-protocol/src/row-patch.ts"],"sourcesContent":["import {jsonObjectSchema} from '../../shared/src/json-schema.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport {rowSchema} from './data.ts';\nimport {primaryKeyValueRecordSchema} from './primary-key.ts';\n\nconst putOpSchema = v.object({\n  op: v.literal('put'),\n  tableName: v.string(),\n  value: rowSchema,\n});\n\nconst updateOpSchema = v.object({\n  op: v.literal('update'),\n  tableName: v.string(),\n  id: primaryKeyValueRecordSchema,\n  merge: jsonObjectSchema.optional(),\n  constrain: v.array(v.string()).optional(),\n});\n\nconst delOpSchema = v.object({\n  op: v.literal('del'),\n  tableName: v.string(),\n  id: primaryKeyValueRecordSchema,\n});\n\nconst clearOpSchema = v.object({\n  op: v.literal('clear'),\n});\n\nconst rowPatchOpSchema = v.union(\n  putOpSchema,\n  updateOpSchema,\n  delOpSchema,\n  clearOpSchema,\n);\n\nexport const rowsPatchSchema = v.array(rowPatchOpSchema);\nexport type RowPatchOp = v.Infer<typeof rowPatchOpSchema>;\n"],"mappings":";;;;;AAKA,IAAM,cAAc,eAAE,OAAO;CAC3B,IAAI,eAAE,QAAQ,KAAK;CACnB,WAAW,eAAE,OAAO;CACpB,OAAO;AACT,CAAC;AAED,IAAM,iBAAiB,eAAE,OAAO;CAC9B,IAAI,eAAE,QAAQ,QAAQ;CACtB,WAAW,eAAE,OAAO;CACpB,IAAI;CACJ,OAAO,iBAAiB,SAAS;CACjC,WAAW,eAAE,MAAM,eAAE,OAAO,CAAC,EAAE,SAAS;AAC1C,CAAC;AAED,IAAM,cAAc,eAAE,OAAO;CAC3B,IAAI,eAAE,QAAQ,KAAK;CACnB,WAAW,eAAE,OAAO;CACpB,IAAI;AACN,CAAC;AAED,IAAM,gBAAgB,eAAE,OAAO,EAC7B,IAAI,eAAE,QAAQ,OAAO,EACvB,CAAC;AAED,IAAM,mBAAmB,eAAE,MACzB,aACA,gBACA,aACA,aACF;AAEA,IAAa,kBAAkB,eAAE,MAAM,gBAAgB"}

package/out/packages/zero-protocol/src/up.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"up.js","names":[],"sources":["../../../../../zero-protocol/src/up.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {changeDesiredQueriesMessageSchema} from './change-desired-queries.ts';\nimport {closeConnectionMessageSchema} from './close-connection.ts';\nimport {initConnectionMessageSchema} from './connect.ts';\nimport {deleteClientsMessageSchema} from './delete-clients.ts';\nimport {inspectUpMessageSchema} from './inspect-up.ts';\nimport {pingMessageSchema} from './ping.ts';\nimport {pullRequestMessageSchema} from './pull.ts';\nimport {ackMutationResponsesMessageSchema, pushMessageSchema} from './push.ts';\nimport {updateAuthMessageSchema} from './update-auth.ts';\n\nexport const upstreamSchema = v.union(\n  initConnectionMessageSchema,\n  pingMessageSchema,\n  deleteClientsMessageSchema,\n  changeDesiredQueriesMessageSchema,\n  pullRequestMessageSchema,\n  updateAuthMessageSchema,\n  pushMessageSchema,\n  closeConnectionMessageSchema,\n  inspectUpMessageSchema,\n  ackMutationResponsesMessageSchema,\n);\n\nexport type Upstream = v.Infer<typeof upstreamSchema>;\n"],"mappings":";;;;;;;;;;;AAWA,IAAa,iBAAiB,eAAE,MAC9B,6BACA,mBACA,4BACA,mCACA,0BACA,yBACA,mBACA,8BACA,wBACA,iCACF"}

package/out/packages/zero-protocol/src/update-auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-auth.js","names":[],"sources":["../../../../../zero-protocol/src/update-auth.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\n\nconst updateAuthBodySchema = v.object({\n  auth: v.string(),\n});\n\nexport const updateAuthMessageSchema = v.tuple([\n  v.literal('updateAuth'),\n  updateAuthBodySchema,\n]);\n\nexport type UpdateAuthBody = v.Infer<typeof updateAuthBodySchema>;\nexport type UpdateAuthMessage = v.Infer<typeof updateAuthMessageSchema>;\n"],"mappings":";;AAEA,IAAM,uBAAuB,eAAE,OAAO,EACpC,MAAM,eAAE,OAAO,EACjB,CAAC;AAED,IAAa,0BAA0B,eAAE,MAAM,CAC7C,eAAE,QAAQ,YAAY,GACtB,oBACF,CAAC"}

package/out/packages/zero-protocol/src/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","names":[],"sources":["../../../../../zero-protocol/src/version.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\n\nexport const versionSchema = v.string();\nexport const nullableVersionSchema = v.union(versionSchema, v.null());\n\nexport type Version = v.Infer<typeof versionSchema>;\nexport type NullableVersion = v.Infer<typeof nullableVersionSchema>;\n"],"mappings":";;AAEA,IAAa,gBAAgB,eAAE,OAAO;AACtC,IAAa,wBAAwB,eAAE,MAAM,eAAe,eAAE,KAAK,CAAC"}

package/out/packages/zero-react/src/use-connection-state.js

@@ -0,0 +1,19 @@
+import { __toESM } from "../../../_virtual/_rolldown/runtime.js";
+import { require_react } from "../../../node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+import { useZero } from "./zero-provider.js";
+//#region ../zero-react/src/use-connection-state.tsx
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+/**
+* Hook to subscribe to the connection status of the Zero instance.
+*
+* @returns The connection status of the Zero instance.
+* @see {@link ConnectionState} for more details on the connection state.
+*/
+function useConnectionState() {
+	const zero = useZero();
+	return (0, import_react.useSyncExternalStore)(zero.connection.state.subscribe, () => zero.connection.state.current, () => zero.connection.state.current);
+}
+//#endregion
+export { useConnectionState };
+
+//# sourceMappingURL=use-connection-state.js.map