@rocicorp/zero 1.10.0-canary.26 → 1.10.0-canary.27

package/out/zero-protocol/src/connect.d.ts

@@ -1,5 +1,4 @@
 import * as v from '../../shared/src/valita.ts';
-import { ProtocolFlags } from './protocol-flag.ts';
 /**
  * After opening a websocket the client waits for a `connected` message
  * from the server.  It then sends an `initConnection` message to the
@@ -101,18 +100,6 @@ export type ConnectedBody = v.Infer<typeof connectedBodySchema>;
 export type ConnectedMessage = v.Infer<typeof connectedMessageSchema>;
 export type InitConnectionBody = v.Infer<typeof initConnectionBodySchema>;
 export type InitConnectionMessage = v.Infer<typeof initConnectionMessageSchema>;
-/**
- * Adds the client's protocol flags to the connect URL: every flag this client
- * knows.
- */
-export declare function setProtocolFlags(params: URLSearchParams): void;
-/**
- * Reads the protocol flags a client sent in the connect URL. A flag it didn't
- * send means the server's default. Flags this server doesn't know are dropped,
- * and a malformed value counts as no flags, so newer clients can always
- * connect.
- */
-export declare function getProtocolFlags(params: URLSearchParams): ProtocolFlags;
 export declare function encodeSecProtocols(initConnectionMessage: InitConnectionMessage | undefined, authToken: string | undefined): string;
 export declare function decodeSecProtocols(secProtocol: string): {
     initConnectionMessage: InitConnectionMessage | undefined;

package/out/zero-protocol/src/connect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/connect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAGhD,OAAO,EAAe,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAG/D;;;;;;GAMG;AAEH,eAAO,MAAM,mBAAmB;;;aAG9B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;eAGjC,CAAC;AAEH,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAe5B;;;;;OAKG;;IAEH,sDAAsD;;aAEtD,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAXtC;;;;;OAKG;;IAEH,sDAAsD;;eAOtD,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAMhF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAO9D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,aAAa,CAYvE;AAED,wBAAgB,kBAAkB,CAChC,qBAAqB,EAAE,qBAAqB,GAAG,SAAS,EACxD,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,MAAM,CAgBR;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG;IACvD,qBAAqB,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACzD,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B,CAIA"}
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/connect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAKhD;;;;;;GAMG;AAEH,eAAO,MAAM,mBAAmB;;;aAG9B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;eAGjC,CAAC;AAEH,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAe5B;;;;;OAKG;;IAEH,sDAAsD;;aAEtD,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAXtC;;;;;OAKG;;IAEH,sDAAsD;;eAOtD,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,wBAAgB,kBAAkB,CAChC,qBAAqB,EAAE,qBAAqB,GAAG,SAAS,EACxD,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,MAAM,CAgBR;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG;IACvD,qBAAqB,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACzD,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B,CAIA"}

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

@@ -1,9 +1,6 @@
 import { valita_exports } from "../../shared/src/valita.js";
 import { clientSchemaSchema } from "./client-schema.js";
-import { fromBase64url, toBase64url } from "../../shared/src/base64.js";
 import { deleteClientsBodySchema } from "./delete-clients.js";
-import { protocol_flag_enum_exports } from "./protocol-flag-enum.js";
-import { ProtocolFlags } from "./protocol-flag.js";
 import { upQueriesPatchSchema } from "./queries-patch.js";
 //#region ../zero-protocol/src/connect.ts
 /**
@@ -37,32 +34,6 @@ var initConnectionBodySchema = valita_exports.object({
 	traceparent: valita_exports.string().optional()
 });
 var initConnectionMessageSchema = valita_exports.tuple([valita_exports.literal("initConnection"), initConnectionBodySchema]);
-var PROTOCOL_FLAGS_PARAM = "f";
-/**
-* Adds the client's protocol flags to the connect URL: every flag this client
-* knows.
-*/
-function setProtocolFlags(params) {
-	const flags = Object.values(protocol_flag_enum_exports);
-	const bytes = new Uint8Array((Math.max(...flags) >> 3) + 1);
-	for (const flag of flags) bytes[flag >> 3] |= 1 << (flag & 7);
-	params.set(PROTOCOL_FLAGS_PARAM, toBase64url(bytes));
-}
-/**
-* Reads the protocol flags a client sent in the connect URL. A flag it didn't
-* send means the server's default. Flags this server doesn't know are dropped,
-* and a malformed value counts as no flags, so newer clients can always
-* connect.
-*/
-function getProtocolFlags(params) {
-	let bytes;
-	try {
-		bytes = fromBase64url(params.get(PROTOCOL_FLAGS_PARAM) ?? "");
-	} catch {
-		return new ProtocolFlags();
-	}
-	return new ProtocolFlags(Object.values(protocol_flag_enum_exports).filter((flag) => ((bytes[flag >> 3] ?? 0) >> (flag & 7) & 1) !== 0));
-}
 function encodeSecProtocols(initConnectionMessage, authToken) {
 	const protocols = {
 		initConnectionMessage,
@@ -78,6 +49,6 @@ function decodeSecProtocols(secProtocol) {
 	return JSON.parse(new TextDecoder().decode(bytes));
 }
 //#endregion
-export { connectedMessageSchema, decodeSecProtocols, encodeSecProtocols, getProtocolFlags, initConnectionMessageSchema, setProtocolFlags };
+export { connectedMessageSchema, decodeSecProtocols, encodeSecProtocols, initConnectionMessageSchema };
 
 //# sourceMappingURL=connect.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"connect.js","names":[],"sources":["../../../../zero-protocol/src/connect.ts"],"sourcesContent":["import {fromBase64url, toBase64url} from '../../shared/src/base64.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport {clientSchemaSchema} from './client-schema.ts';\nimport {deleteClientsBodySchema} from './delete-clients.ts';\nimport {ProtocolFlag, ProtocolFlags} from './protocol-flag.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\n// The connect URL parameter that carries the protocol flags: a bit set with\n// flag n at bit n % 8 of byte floor(n / 8), in unpadded base64url.\nconst PROTOCOL_FLAGS_PARAM = 'f';\n\n/**\n * Adds the client's protocol flags to the connect URL: every flag this client\n * knows.\n */\nexport function setProtocolFlags(params: URLSearchParams): void {\n  const flags = Object.values(ProtocolFlag);\n  const bytes = new Uint8Array((Math.max(...flags) >> 3) + 1);\n  for (const flag of flags) {\n    bytes[flag >> 3] |= 1 << (flag & 7);\n  }\n  params.set(PROTOCOL_FLAGS_PARAM, toBase64url(bytes));\n}\n\n/**\n * Reads the protocol flags a client sent in the connect URL. A flag it didn't\n * send means the server's default. Flags this server doesn't know are dropped,\n * and a malformed value counts as no flags, so newer clients can always\n * connect.\n */\nexport function getProtocolFlags(params: URLSearchParams): ProtocolFlags {\n  let bytes: Uint8Array;\n  try {\n    bytes = fromBase64url(params.get(PROTOCOL_FLAGS_PARAM) ?? '');\n  } catch {\n    return new ProtocolFlags();\n  }\n  return new ProtocolFlags(\n    Object.values(ProtocolFlag).filter(\n      flag => (((bytes[flag >> 3] ?? 0) >> (flag & 7)) & 1) !== 0,\n    ),\n  );\n}\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":";;;;;;;;;;;;;;;AAeA,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;AASD,IAAM,uBAAuB;;;;;AAM7B,SAAgB,iBAAiB,QAA+B;CAC9D,MAAM,QAAQ,OAAO,OAAO,0BAAY;CACxC,MAAM,QAAQ,IAAI,YAAY,KAAK,IAAI,GAAG,KAAK,KAAK,KAAK,CAAC;CAC1D,KAAK,MAAM,QAAQ,OACjB,MAAM,QAAQ,MAAM,MAAM,OAAO;CAEnC,OAAO,IAAI,sBAAsB,YAAY,KAAK,CAAC;AACrD;;;;;;;AAQA,SAAgB,iBAAiB,QAAwC;CACvE,IAAI;CACJ,IAAI;EACF,QAAQ,cAAc,OAAO,IAAI,oBAAoB,KAAK,EAAE;CAC9D,QAAQ;EACN,OAAO,IAAI,cAAc;CAC3B;CACA,OAAO,IAAI,cACT,OAAO,OAAO,0BAAY,EAAE,QAC1B,WAAW,MAAM,QAAQ,MAAM,OAAO,OAAO,KAAM,OAAO,CAC5D,CACF;AACF;AAEA,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"}
+{"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/zero-protocol/src/poke.d.ts

@@ -12,9 +12,8 @@ import * as v from '../../shared/src/valita.ts';
  * the poke is updating from and the `cookie` the poke is updating to.
  *
  * Through protocol version 51, the poke continues with zero to many
- * `poke-part` JSON messages. Starting in version 52, or when the client sends
- * the `PokeChunk` protocol flag, it continues with zero to many binary
- * `pokeChunk` messages instead. Each binary message starts with a message
+ * `poke-part` JSON messages. Starting in version 52, it continues with zero to
+ * many binary `pokeChunk` messages. Each binary message starts with a message
  * type byte. Concatenating and decoding the payload after that byte produces a
  * PokePartBody array. pokeChunk boundaries have no semantic meaning.
  *
@@ -271,15 +270,9 @@ export type PokeParts = v.Infer<typeof pokePartsSchema>;
 export type PokeEndBody = v.Infer<typeof pokeEndBodySchema>;
 /** The first byte identifying a binary WebSocket message as a poke chunk. */
 export declare const POKE_CHUNK_MESSAGE_TYPE = 0;
-/**
- * The first protocol version that receives binary poke chunks without the
- * `PokeChunk` protocol flag.
- */
+/** The first protocol version that receives binary poke chunks. */
 export declare const POKE_CHUNK_PROTOCOL_VERSION = 52;
-/**
- * The last protocol version that receives JSON pokePart messages unless the
- * client sends the `PokeChunk` protocol flag.
- */
+/** The last protocol version that receives JSON pokePart messages. */
 export declare const LAST_POKE_PART_PROTOCOL_VERSION = 51;
 /** A tagged binary poke chunk WebSocket message. */
 export type PokeChunk = Uint8Array;

package/out/zero-protocol/src/poke.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"poke.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/poke.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAMhD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,eAAO,MAAM,mBAAmB;;;IAM9B;;;OAGG;;;;;;aAQH,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAa7B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA8B,CAAC;AAE3D,eAAO,MAAM,iBAAiB;;;;aAO5B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;IA5CjC;;;OAGG;;;;;;eA4CH,CAAC;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAGhC,CAAC;AACH,eAAO,MAAM,oBAAoB;;;;eAG/B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,6EAA6E;AAC7E,eAAO,MAAM,uBAAuB,IAAO,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,+BAA+B,KAAK,CAAC;AAElD,oDAAoD;AACpD,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC;AAEnC,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"poke.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/poke.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAMhD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,eAAO,MAAM,mBAAmB;;;IAM9B;;;OAGG;;;;;;aAQH,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAa7B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA8B,CAAC;AAE3D,eAAO,MAAM,iBAAiB;;;;aAO5B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;IA5CjC;;;OAGG;;;;;;eA4CH,CAAC;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAGhC,CAAC;AACH,eAAO,MAAM,oBAAoB;;;;eAG/B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,6EAA6E;AAC7E,eAAO,MAAM,uBAAuB,IAAO,CAAC;AAE5C,mEAAmE;AACnE,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAE9C,sEAAsE;AACtE,eAAO,MAAM,+BAA+B,KAAK,CAAC;AAElD,oDAAoD;AACpD,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC;AAEnC,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

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

@@ -17,9 +17,8 @@ import { nullableVersionSchema, versionSchema } from "./version.js";
 * the poke is updating from and the `cookie` the poke is updating to.
 *
 * Through protocol version 51, the poke continues with zero to many
-* `poke-part` JSON messages. Starting in version 52, or when the client sends
-* the `PokeChunk` protocol flag, it continues with zero to many binary
-* `pokeChunk` messages instead. Each binary message starts with a message
+* `poke-part` JSON messages. Starting in version 52, it continues with zero to
+* many binary `pokeChunk` messages. Each binary message starts with a message
 * type byte. Concatenating and decoding the payload after that byte produces a
 * PokePartBody array. pokeChunk boundaries have no semantic meaning.
 *

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

@@ -1 +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 * Through protocol version 51, the poke continues with zero to many\n * `poke-part` JSON messages. Starting in version 52, or when the client sends\n * the `PokeChunk` protocol flag, it continues with zero to many binary\n * `pokeChunk` messages instead. Each binary message starts with a message\n * type byte. Concatenating and decoding the payload after that byte produces a\n * PokePartBody array. pokeChunk boundaries have no semantic meaning.\n *\n * Finally, the poke ends with a `poke-end` message. The decoded patches can\n * 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  // 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  pokeID: v.string(),\n});\n\n/**\n * The logical payload carried by binary poke chunks. Chunk boundaries are\n * arbitrary; concatenating and decoding all chunks for a poke produces this\n * array.\n */\nexport const pokePartsSchema = v.array(pokePartBodySchema);\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 PokeParts = v.Infer<typeof pokePartsSchema>;\nexport type PokeEndBody = v.Infer<typeof pokeEndBodySchema>;\n\n/** The first byte identifying a binary WebSocket message as a poke chunk. */\nexport const POKE_CHUNK_MESSAGE_TYPE = 0x00;\n\n/**\n * The first protocol version that receives binary poke chunks without the\n * `PokeChunk` protocol flag.\n */\nexport const POKE_CHUNK_PROTOCOL_VERSION = 52;\n\n/**\n * The last protocol version that receives JSON pokePart messages unless the\n * client sends the `PokeChunk` protocol flag.\n */\nexport const LAST_POKE_PART_PROTOCOL_VERSION = 51;\n\n/** A tagged binary poke chunk WebSocket message. */\nexport type PokeChunk = Uint8Array;\n\nexport type PokeStartMessage = v.Infer<typeof pokeStartMessageSchema>;\nexport type PokePartMessage = v.Infer<typeof pokePartMessageSchema>;\nexport type PokeEndMessage = v.Infer<typeof pokeEndMessageSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,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;CAEzC,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;CAC9C,QAAQ,eAAE,OAAO;AACnB,CAAC;;;;;;AAOD,IAAa,kBAAkB,eAAE,MAAM,kBAAkB;AAEzD,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"}
+{"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 * Through protocol version 51, the poke continues with zero to many\n * `poke-part` JSON messages. Starting in version 52, it continues with zero to\n * many binary `pokeChunk` messages. Each binary message starts with a message\n * type byte. Concatenating and decoding the payload after that byte produces a\n * PokePartBody array. pokeChunk boundaries have no semantic meaning.\n *\n * Finally, the poke ends with a `poke-end` message. The decoded patches can\n * 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  // 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  pokeID: v.string(),\n});\n\n/**\n * The logical payload carried by binary poke chunks. Chunk boundaries are\n * arbitrary; concatenating and decoding all chunks for a poke produces this\n * array.\n */\nexport const pokePartsSchema = v.array(pokePartBodySchema);\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 PokeParts = v.Infer<typeof pokePartsSchema>;\nexport type PokeEndBody = v.Infer<typeof pokeEndBodySchema>;\n\n/** The first byte identifying a binary WebSocket message as a poke chunk. */\nexport const POKE_CHUNK_MESSAGE_TYPE = 0x00;\n\n/** The first protocol version that receives binary poke chunks. */\nexport const POKE_CHUNK_PROTOCOL_VERSION = 52;\n\n/** The last protocol version that receives JSON pokePart messages. */\nexport const LAST_POKE_PART_PROTOCOL_VERSION = 51;\n\n/** A tagged binary poke chunk WebSocket message. */\nexport type PokeChunk = Uint8Array;\n\nexport type PokeStartMessage = v.Infer<typeof pokeStartMessageSchema>;\nexport type PokePartMessage = v.Infer<typeof pokePartMessageSchema>;\nexport type PokeEndMessage = v.Infer<typeof pokeEndMessageSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,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;CAEzC,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;CAC9C,QAAQ,eAAE,OAAO;AACnB,CAAC;;;;;;AAOD,IAAa,kBAAkB,eAAE,MAAM,kBAAkB;AAEzD,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/zero-protocol/src/protocol-version.d.ts

@@ -1,40 +1,16 @@
 /**
- * The highest sync protocol version `zero-cache` accepts (i.e. the version
- * declared in the "/sync/v{#}/connect" URL). Clients send
- * {@link CLIENT_PROTOCOL_VERSION}.
+ * The current `PROTOCOL_VERSION` of the code.
  *
- * The protocol encompasses both the wire-protocol of the `/sync/...`
+ * The `PROTOCOL_VERSION` encompasses both the wire-protocol of the `/sync/...`
  * connection between the browser and `zero-cache`, as well as the format of
  * the `AST` objects stored in both components (i.e. IDB and CVR).
  *
- * A client one release ahead of the server must still be able to connect, so
- * that clients and `zero-cache` can be updated and rolled back in either
- * order. Two rules keep that working:
- *
- * 1. A change an old server can ignore goes behind a protocol flag (see
- *    `protocol-flag-enum.ts`) and the client keeps sending the same
- *    {@link CLIENT_PROTOCOL_VERSION}. Old servers ignore flags they don't
- *    know, so the client must keep supporting the old behavior.
- * 2. A change an old server can't ignore (e.g. new `AST` functionality)
- *    increments `PROTOCOL_VERSION` one release before clients start sending
- *    it in {@link CLIENT_PROTOCOL_VERSION}.
+ * A change in the `AST` schema (e.g. new functionality added) must be
+ * accompanied by an increment of the `PROTOCOL_VERSION` and a new major
+ * release. The server (`zero-cache`) must be deployed before clients start
+ * running the new code.
  */
 export declare const PROTOCOL_VERSION = 52;
-/**
- * The sync protocol version clients send in the "/sync/v{#}/connect" URL.
- *
- * Kept below {@link PROTOCOL_VERSION} so that clients can connect to servers
- * from earlier releases: 1.9 servers accept versions up to 51. Clients ask for
- * newer behavior with protocol flags instead (rule 1 above). Only increase it
- * to a version that every supported server already accepts (rule 2 above).
- *
- * This number is also part of the client's local database name (Replicache
- * `schemaVersion`). Changing it opens a fresh local database, which drops
- * unsent mutations because Zero disables mutation recovery. Canary clients
- * already used 52 and 53 in their database names, so if the name changes it
- * must move above 53; reusing 52 or 53 would open a stale canary database.
- */
-export declare const CLIENT_PROTOCOL_VERSION = 51;
 /**
  * The minimum server-supported sync protocol version (i.e. the version
  * declared in the "/sync/v{#}/connect" URL).

package/out/zero-protocol/src/protocol-version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol-version.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/protocol-version.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AAiDH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kCAAkC,KAAK,CAAC"}
+{"version":3,"file":"protocol-version.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/protocol-version.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAgDH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kCAAkC,KAAK,CAAC"}

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

@@ -1,5 +1,5 @@
 import { assert } from "../../shared/src/asserts.js";
-assert(true, "CLIENT_PROTOCOL_VERSION must be between MIN_SERVER_SUPPORTED_SYNC_PROTOCOL and PROTOCOL_VERSION");
+assert(true, "MIN_SERVER_SUPPORTED_SYNC_PROTOCOL must be less than PROTOCOL_VERSION");
 //#endregion
 export {};
 

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

@@ -1 +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 highest sync protocol version `zero-cache` accepts (i.e. the version\n * declared in the \"/sync/v{#}/connect\" URL). Clients send\n * {@link CLIENT_PROTOCOL_VERSION}.\n *\n * The protocol 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 client one release ahead of the server must still be able to connect, so\n * that clients and `zero-cache` can be updated and rolled back in either\n * order. Two rules keep that working:\n *\n * 1. A change an old server can ignore goes behind a protocol flag (see\n *    `protocol-flag-enum.ts`) and the client keeps sending the same\n *    {@link CLIENT_PROTOCOL_VERSION}. Old servers ignore flags they don't\n *    know, so the client must keep supporting the old behavior.\n * 2. A change an old server can't ignore (e.g. new `AST` functionality)\n *    increments `PROTOCOL_VERSION` one release before clients start sending\n *    it in {@link CLIENT_PROTOCOL_VERSION}.\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\n// -- version 52 replaces JSON pokePart messages with binary poke chunks for\n//    clients using protocol version 52 or newer. Older clients retain pokePart\n//    unless they send the `PokeChunk` protocol flag. (1.10 canaries)\nexport const PROTOCOL_VERSION = 52;\n\n/**\n * The sync protocol version clients send in the \"/sync/v{#}/connect\" URL.\n *\n * Kept below {@link PROTOCOL_VERSION} so that clients can connect to servers\n * from earlier releases: 1.9 servers accept versions up to 51. Clients ask for\n * newer behavior with protocol flags instead (rule 1 above). Only increase it\n * to a version that every supported server already accepts (rule 2 above).\n *\n * This number is also part of the client's local database name (Replicache\n * `schemaVersion`). Changing it opens a fresh local database, which drops\n * unsent mutations because Zero disables mutation recovery. Canary clients\n * already used 52 and 53 in their database names, so if the name changes it\n * must move above 53; reusing 52 or 53 would open a stale canary database.\n */\nexport const CLIENT_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).\n *\n * CloudZero can serve applications running old client releases indefinitely.\n * Consequently, this value must never be increased: `zero-cache` must continue\n * to support every sync protocol from this version through `PROTOCOL_VERSION`.\n * A wire change that an old client cannot ignore must branch on the client's\n * protocol version and retain the old behavior. Keep each compatibility fork\n * isolated at the boundary that owns the changed behavior and test both sides\n * of its version cutoff.\n *\n * Client connections from protocol versions before this historical floor are\n * closed with a `VersionNotSupported` error.\n */\nexport const MIN_SERVER_SUPPORTED_SYNC_PROTOCOL = 30;\n\nassert(\n  MIN_SERVER_SUPPORTED_SYNC_PROTOCOL <= CLIENT_PROTOCOL_VERSION &&\n    CLIENT_PROTOCOL_VERSION <= PROTOCOL_VERSION,\n  'CLIENT_PROTOCOL_VERSION must be between MIN_SERVER_SUPPORTED_SYNC_PROTOCOL and PROTOCOL_VERSION',\n);\n"],"mappings":";AA0GA,OAAA,MAGE,iGACF"}
+{"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\n// -- version 52 replaces JSON pokePart messages with binary poke chunks for\n//    clients using protocol version 52 or newer. Older clients retain pokePart.\nexport const PROTOCOL_VERSION = 52;\n\n/**\n * The minimum server-supported sync protocol version (i.e. the version\n * declared in the \"/sync/v{#}/connect\" URL).\n *\n * CloudZero can serve applications running old client releases indefinitely.\n * Consequently, this value must never be increased: `zero-cache` must continue\n * to support every sync protocol from this version through `PROTOCOL_VERSION`.\n * A wire change that an old client cannot ignore must branch on the client's\n * protocol version and retain the old behavior. Keep each compatibility fork\n * isolated at the boundary that owns the changed behavior and test both sides\n * of its version cutoff.\n *\n * Client connections from protocol versions before this historical floor 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":";AAgFA,OAAA,MAEE,uEACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocicorp/zero",
-  "version": "1.10.0-canary.26",
+  "version": "1.10.0-canary.27",
   "description": "Zero is a web framework for serverless web development.",
   "homepage": "https://zero.rocicorp.dev",
   "bugs": {

package/out/shared/src/base64.d.ts

@@ -1,19 +0,0 @@
-/** Encodes `bytes` as unpadded base64url. */
-export declare function toBase64url(bytes: Uint8Array): string;
-/**
- * Decodes base64url, padded or not.
- *
- * @throws SyntaxError if `encoded` is not base64url, including when it has
- *   whitespace, which the standard and atob skip. atob doesn't reject
- *   everything the standard rejects, so this checks first.
- */
-export declare function fromBase64url(encoded: string): Uint8Array;
-/** @visibleForTesting */
-export declare function toBase64urlWithBtoa(bytes: Uint8Array): string;
-/**
- * Decodes base64url that {@link fromBase64url} has checked.
- *
- * @visibleForTesting
- */
-export declare function fromBase64urlWithAtob(s: string): Uint8Array;
-//# sourceMappingURL=base64.d.ts.map

package/out/shared/src/base64.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../../../shared/src/base64.ts"],"names":[],"mappings":"AAaA,6CAA6C;AAC7C,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAOrD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAUzD;AAED,yBAAyB;AACzB,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAU7D;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAI3D"}

package/out/shared/src/base64.js

@@ -1,40 +0,0 @@
-//#region ../shared/src/base64.ts
-var PADDING = /=+$/;
-var BASE64URL = /^(?:[\w-]{4})*(?:[\w-]{2}(?:==)?|[\w-]{3}=?)?$/;
-/** Encodes `bytes` as unpadded base64url. */
-function toBase64url(bytes) {
-	const native = bytes;
-	return native.toBase64 ? native.toBase64({
-		alphabet: "base64url",
-		omitPadding: true
-	}) : toBase64urlWithBtoa(bytes);
-}
-/**
-* Decodes base64url, padded or not.
-*
-* @throws SyntaxError if `encoded` is not base64url, including when it has
-*   whitespace, which the standard and atob skip. atob doesn't reject
-*   everything the standard rejects, so this checks first.
-*/
-function fromBase64url(encoded) {
-	if (!BASE64URL.test(encoded)) throw new SyntaxError("Invalid base64url");
-	const native = Uint8Array;
-	return native.fromBase64 ? native.fromBase64(encoded, { alphabet: "base64url" }) : fromBase64urlWithAtob(encoded);
-}
-/** @visibleForTesting */
-function toBase64urlWithBtoa(bytes) {
-	const { fromCharCode } = String;
-	return btoa(Array.from(bytes, (b) => fromCharCode(b)).join("")).replaceAll("+", "-").replaceAll("/", "_").replace(PADDING, "");
-}
-/**
-* Decodes base64url that {@link fromBase64url} has checked.
-*
-* @visibleForTesting
-*/
-function fromBase64urlWithAtob(s) {
-	return Uint8Array.from(atob(s.replaceAll("-", "+").replaceAll("_", "/")), (c) => c.charCodeAt(0));
-}
-//#endregion
-export { fromBase64url, toBase64url };
-
-//# sourceMappingURL=base64.js.map

package/out/shared/src/base64.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base64.js","names":[],"sources":["../../../../shared/src/base64.ts"],"sourcesContent":["// Unpadded base64url (RFC 4648 §5: base64 with `-` and `_` instead of `+` and\n// `/`) for Uint8Arrays. Uses the standard `Uint8Array.prototype.toBase64` and\n// `Uint8Array.fromBase64` when the runtime has them, and btoa/atob otherwise\n// (Node 22, older browsers). Node's Buffer isn't used: React Native apps\n// often polyfill it with the `buffer` package, which has no base64url.\n\ntype Base64urlOptions = {alphabet: 'base64url'; omitPadding?: boolean};\n\nconst PADDING = /=+$/;\n// Whole groups of four characters, then an unpadded or correctly padded last\n// group.\nconst BASE64URL = /^(?:[\\w-]{4})*(?:[\\w-]{2}(?:==)?|[\\w-]{3}=?)?$/;\n\n/** Encodes `bytes` as unpadded base64url. */\nexport function toBase64url(bytes: Uint8Array): string {\n  const native = bytes as Uint8Array & {\n    toBase64?: (options: Base64urlOptions) => string;\n  };\n  return native.toBase64\n    ? native.toBase64({alphabet: 'base64url', omitPadding: true})\n    : toBase64urlWithBtoa(bytes);\n}\n\n/**\n * Decodes base64url, padded or not.\n *\n * @throws SyntaxError if `encoded` is not base64url, including when it has\n *   whitespace, which the standard and atob skip. atob doesn't reject\n *   everything the standard rejects, so this checks first.\n */\nexport function fromBase64url(encoded: string): Uint8Array {\n  if (!BASE64URL.test(encoded)) {\n    throw new SyntaxError('Invalid base64url');\n  }\n  const native = Uint8Array as {\n    fromBase64?: (s: string, options: Base64urlOptions) => Uint8Array;\n  };\n  return native.fromBase64\n    ? native.fromBase64(encoded, {alphabet: 'base64url'})\n    : fromBase64urlWithAtob(encoded);\n}\n\n/** @visibleForTesting */\nexport function toBase64urlWithBtoa(bytes: Uint8Array): string {\n  // A local, so the loop doesn't look it up on String for every byte\n  // (Hermes).\n  const {fromCharCode} = String;\n  // One character per byte. Spreading a large array into fromCharCode could\n  // overflow the stack.\n  return btoa(Array.from(bytes, b => fromCharCode(b)).join(''))\n    .replaceAll('+', '-')\n    .replaceAll('/', '_')\n    .replace(PADDING, '');\n}\n\n/**\n * Decodes base64url that {@link fromBase64url} has checked.\n *\n * @visibleForTesting\n */\nexport function fromBase64urlWithAtob(s: string): Uint8Array {\n  return Uint8Array.from(atob(s.replaceAll('-', '+').replaceAll('_', '/')), c =>\n    c.charCodeAt(0),\n  );\n}\n"],"mappings":";AAQA,IAAM,UAAU;AAGhB,IAAM,YAAY;;AAGlB,SAAgB,YAAY,OAA2B;CACrD,MAAM,SAAS;CAGf,OAAO,OAAO,WACV,OAAO,SAAS;EAAC,UAAU;EAAa,aAAa;CAAI,CAAC,IAC1D,oBAAoB,KAAK;AAC/B;;;;;;;;AASA,SAAgB,cAAc,SAA6B;CACzD,IAAI,CAAC,UAAU,KAAK,OAAO,GACzB,MAAM,IAAI,YAAY,mBAAmB;CAE3C,MAAM,SAAS;CAGf,OAAO,OAAO,aACV,OAAO,WAAW,SAAS,EAAC,UAAU,YAAW,CAAC,IAClD,sBAAsB,OAAO;AACnC;;AAGA,SAAgB,oBAAoB,OAA2B;CAG7D,MAAM,EAAC,iBAAgB;CAGvB,OAAO,KAAK,MAAM,KAAK,QAAO,MAAK,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EACzD,WAAW,KAAK,GAAG,EACnB,WAAW,KAAK,GAAG,EACnB,QAAQ,SAAS,EAAE;AACxB;;;;;;AAOA,SAAgB,sBAAsB,GAAuB;CAC3D,OAAO,WAAW,KAAK,KAAK,EAAE,WAAW,KAAK,GAAG,EAAE,WAAW,KAAK,GAAG,CAAC,IAAG,MACxE,EAAE,WAAW,CAAC,CAChB;AACF"}

package/out/zero-protocol/src/protocol-flag-enum.d.ts

@@ -1,7 +0,0 @@
-/**
- * Binary poke chunks instead of JSON `pokePart` messages. Defaults to on for
- * clients at protocol version 52 or above.
- */
-export declare const PokeChunk = 0;
-export type PokeChunk = typeof PokeChunk;
-//# sourceMappingURL=protocol-flag-enum.d.ts.map

package/out/zero-protocol/src/protocol-flag-enum.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protocol-flag-enum.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/protocol-flag-enum.ts"],"names":[],"mappings":"AAaA;;;GAGG;AACH,eAAO,MAAM,SAAS,IAAI,CAAC;AAE3B,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC"}

package/out/zero-protocol/src/protocol-flag-enum.js

@@ -1,7 +0,0 @@
-import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
-//#region ../zero-protocol/src/protocol-flag-enum.ts
-var protocol_flag_enum_exports = /* @__PURE__ */ __exportAll({ PokeChunk: () => 0 });
-//#endregion
-export { protocol_flag_enum_exports };
-
-//# sourceMappingURL=protocol-flag-enum.js.map

package/out/zero-protocol/src/protocol-flag-enum.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"protocol-flag-enum.js","names":[],"sources":["../../../../zero-protocol/src/protocol-flag-enum.ts"],"sourcesContent":["// Protocol flags let a client ask for behavior that an older server can\n// ignore, without raising CLIENT_PROTOCOL_VERSION (see protocol-version.ts).\n//\n// The client sends its flags in one connect URL parameter (setProtocolFlags in\n// connect.ts). A flag the client doesn't send means the server's default. A\n// server ignores flags it doesn't know, so the client must keep supporting the\n// old behavior. A client can't turn off a feature that is on by default; to let\n// it, add a flag that turns the feature off.\n//\n// The numbers are part of the wire protocol: they are bit positions in that\n// parameter. Never change a flag's number, and never reuse the number of a\n// retired flag.\n\n/**\n * Binary poke chunks instead of JSON `pokePart` messages. Defaults to on for\n * clients at protocol version 52 or above.\n */\nexport const PokeChunk = 0;\n\nexport type PokeChunk = typeof PokeChunk;\n"],"mappings":""}

package/out/zero-protocol/src/protocol-flag.d.ts

@@ -1,14 +0,0 @@
-import type { Enum } from '../../shared/src/enum.ts';
-import * as ProtocolFlagEnum from './protocol-flag-enum.ts';
-export { ProtocolFlagEnum as ProtocolFlag };
-export type ProtocolFlag = Enum<typeof ProtocolFlagEnum>;
-/** A set of protocol flags. */
-export type ProtocolFlags = ReadonlySet<Enum<typeof ProtocolFlagEnum>>;
-/** `Set`, typed so that `new ProtocolFlags()` needs no type argument. */
-export declare const ProtocolFlags: {
-    new (values?: readonly 0[] | null | undefined): Set<0>;
-    new (iterable?: Iterable<0> | null | undefined): Set<0>;
-    readonly prototype: Set<any>;
-    readonly [Symbol.species]: SetConstructor;
-};
-//# sourceMappingURL=protocol-flag.d.ts.map

package/out/zero-protocol/src/protocol-flag.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protocol-flag.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/protocol-flag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,gBAAgB,MAAM,yBAAyB,CAAC;AAE5D,OAAO,EAAC,gBAAgB,IAAI,YAAY,EAAC,CAAC;AAC1C,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAKzD,+BAA+B;AAC/B,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC;AAEvE,yEAAyE;AACzE,eAAO,MAAM,aAAa;;;;;CAAqC,CAAC"}

package/out/zero-protocol/src/protocol-flag.js

@@ -1,8 +0,0 @@
-import "./protocol-flag-enum.js";
-//#region ../zero-protocol/src/protocol-flag.ts
-/** `Set`, typed so that `new ProtocolFlags()` needs no type argument. */
-var ProtocolFlags = Set;
-//#endregion
-export { ProtocolFlags };
-
-//# sourceMappingURL=protocol-flag.js.map

package/out/zero-protocol/src/protocol-flag.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"protocol-flag.js","names":[],"sources":["../../../../zero-protocol/src/protocol-flag.ts"],"sourcesContent":["import type {Enum} from '../../shared/src/enum.ts';\nimport * as ProtocolFlagEnum from './protocol-flag-enum.ts';\n\nexport {ProtocolFlagEnum as ProtocolFlag};\nexport type ProtocolFlag = Enum<typeof ProtocolFlagEnum>;\n\n// Spelled out instead of using ProtocolFlag: TypeScript 6 can't emit\n// declarations that refer to a name this file both re-exports and declares.\n\n/** A set of protocol flags. */\nexport type ProtocolFlags = ReadonlySet<Enum<typeof ProtocolFlagEnum>>;\n\n/** `Set`, typed so that `new ProtocolFlags()` needs no type argument. */\nexport const ProtocolFlags = Set<Enum<typeof ProtocolFlagEnum>>;\n"],"mappings":";;;AAaA,IAAa,gBAAgB"}