@rocicorp/zero 1.12.0-canary.1 → 1.12.0-canary.11

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

@@ -1 +1 @@
-{"version":3,"file":"pong.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/pong.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAEhD,eAAO,MAAM,cAAc,6BAAe,CAAC;AAC3C,eAAO,MAAM,iBAAiB,4DAA+C,CAAC;AAE9E,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"pong.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/pong.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAGhD,eAAO,MAAM,iBAAiB,4DAA+C,CAAC;AAE9E,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

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

@@ -1 +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"}
+{"version":3,"file":"pong.js","names":["v"],"sources":["../../../../zero-protocol/src/pong.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\n\nconst pongBodySchema = v.object({});\nexport const pongMessageSchema = v.tuple([v.literal('pong'), pongBodySchema]);\n\nexport type PongMessage = v.Infer<typeof pongMessageSchema>;\n"],"mappings":";;AAEA,IAAM,iBAAiBA,eAAE,OAAO,CAAC,CAAC;AAClC,IAAa,oBAAoBA,eAAE,MAAM,CAACA,eAAE,QAAQ,MAAM,GAAG,cAAc,CAAC"}

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

@@ -1 +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"}
+{"version":3,"file":"primary-key.js","names":["v.readonly","v","v.readonlyRecord"],"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,mBAAmBA,SAE9BC,eAAE,MAAM,CAACA,eAAE,OAAO,CAAC,CAAC,CAAC,CAAC,OAAOA,eAAE,MAAMA,eAAE,OAAO,CAAC,CAAC,CAClD;AAIA,IAAa,wBAAwBA,eAAE,MACrCA,eAAE,OAAO,GACTA,eAAE,OAAO,GACTA,eAAE,QAAQ,CACZ;AAIA,IAAa,8BAA8BC,eACzC,qBACF"}

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

@@ -13,7 +13,7 @@
  * release. The server (`zero-cache`) must be deployed before clients start
  * running the new code.
  */
-export declare const PROTOCOL_VERSION = 53;
+export declare const PROTOCOL_VERSION = 57;
 /**
  * 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;;;;;;;;;;;;;;GAcG;AAiDH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;;;;;;;;;;;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;;;;;;;;;;;;;;GAcG;AAwDH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kCAAkC,KAAK,CAAC"}

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

@@ -1,4 +1,5 @@
 import { assert } from "../../shared/src/asserts.js";
+//#region ../zero-protocol/src/protocol-version.ts
 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 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 the CVR. The client's local database has its\n * own version, `STORAGE_VERSION` in zero-client. A bump that changes what the\n * client stores (as version 23 did by adding mutation results) must bump that\n * too.\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.\n// -- version 53 adds 'filter' node type to AnalyzeQueryResult\nexport const PROTOCOL_VERSION = 53;\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":";AAoFA,OAAA,MAEE,uEACF"}
+{"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 the CVR. The client's local database has its\n * own version, `STORAGE_VERSION` in zero-client. A bump that changes what the\n * client stores (as version 23 did by adding mutation results) must bump that\n * too.\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.\n// -- version 53 adds 'filter' node type to AnalyzeQueryResult\n// -- version 54 adds `aggregate` {fn,field} (count/sum/avg/min/max) to\n//    CorrelatedSubquery and, top-level, to AST\n// -- version 55 adds the `json` (JsonPathReference) condition value for JSON path filters\n// -- version 56 adds an optional JSON `path` to `aggregate`\n// -- version 57 adds `groupBy` to AST (alone, a SELECT DISTINCT of its columns;\n//    with an `aggregate`, that aggregate per group) and `distinct` to a\n//    `count` aggregate\nexport const PROTOCOL_VERSION = 57;\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":";;AA2FA,OACE,MACA,uEACF"}

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

@@ -1,10 +1,5 @@
 import * as v from '../../shared/src/valita.ts';
-export declare const pullRequestBodySchema: v.ObjectType<{
-    clientGroupID: v.Type<string>;
-    cookie: v.UnionType<[v.Type<string>, v.Type<null>]>;
-    requestID: v.Type<string>;
-}, undefined>;
-export declare const pullResponseBodySchema: v.ObjectType<{
+declare const pullResponseBodySchema: v.ObjectType<{
     cookie: v.Type<string>;
     requestID: v.Type<string>;
     lastMutationIDChanges: v.Type<Record<string, number>>;
@@ -19,8 +14,8 @@ export declare const pullResponseMessageSchema: v.TupleType<[v.Type<"pull">, v.O
     requestID: v.Type<string>;
     lastMutationIDChanges: v.Type<Record<string, number>>;
 }, undefined>]>;
-export type PullRequestBody = v.Infer<typeof pullRequestBodySchema>;
 export type PullResponseBody = v.Infer<typeof pullResponseBodySchema>;
 export type PullRequestMessage = v.Infer<typeof pullRequestMessageSchema>;
 export type PullResponseMessage = v.Infer<typeof pullResponseMessageSchema>;
+export {};
 //# sourceMappingURL=pull.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/pull.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAGhD,eAAO,MAAM,qBAAqB;;;;aAIhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;aAOjC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;eAGnC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;eAGpC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}
+{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/pull.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAShD,QAAA,MAAM,sBAAsB;;;;aAO1B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;eAGnC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;eAGpC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

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

@@ -1 +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"}
+{"version":3,"file":"pull.js","names":["v"],"sources":["../../../../zero-protocol/src/pull.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {nullableVersionSchema, versionSchema} from './version.ts';\n\nconst pullRequestBodySchema = v.object({\n  clientGroupID: v.string(),\n  cookie: nullableVersionSchema,\n  requestID: v.string(),\n});\n\nconst 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 PullResponseBody = v.Infer<typeof pullResponseBodySchema>;\n\nexport type PullRequestMessage = v.Infer<typeof pullRequestMessageSchema>;\nexport type PullResponseMessage = v.Infer<typeof pullResponseMessageSchema>;\n"],"mappings":";;;AAGA,IAAM,wBAAwBA,eAAE,OAAO;CACrC,eAAeA,eAAE,OAAO;CACxB,QAAQ;CACR,WAAWA,eAAE,OAAO;AACtB,CAAC;AAED,IAAM,yBAAyBA,eAAE,OAAO;CACtC,QAAQ;CAER,WAAWA,eAAE,OAAO;CACpB,uBAAuBA,eAAE,OAAOA,eAAE,OAAO,CAAC;AAG5C,CAAC;AAED,IAAa,2BAA2BA,eAAE,MAAM,CAC9CA,eAAE,QAAQ,MAAM,GAChB,qBACF,CAAC;AAED,IAAa,4BAA4BA,eAAE,MAAM,CAC/CA,eAAE,QAAQ,MAAM,GAChB,sBACF,CAAC"}

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

@@ -162,7 +162,7 @@ export declare const pushErrorSchema: v.UnionType<[v.ObjectType<{
         clientID: string;
     }[]>;
 }, undefined>]>;
-export declare const pushResponseBodySchema: v.UnionType<[v.ObjectType<{
+declare const pushResponseBodySchema: v.UnionType<[v.ObjectType<{
     mutations: v.ArrayType<v.ObjectType<{
         id: v.ObjectType<{
             id: v.Type<number>;
@@ -372,7 +372,6 @@ export declare const ackMutationResponsesMessageSchema: v.TupleType<[v.Type<"ack
 export type PushBody = v.Infer<typeof pushBodySchema>;
 export type PushMessage = v.Infer<typeof pushMessageSchema>;
 export type PushResponseBody = v.Infer<typeof pushResponseBodySchema>;
-export type PushResponse = v.Infer<typeof pushResponseSchema>;
 export type PushResponseMessage = v.Infer<typeof pushResponseMessageSchema>;
 export type MutationResponse = v.Infer<typeof mutationResponseSchema>;
 /**
@@ -380,6 +379,5 @@ export type MutationResponse = v.Infer<typeof mutationResponseSchema>;
  */
 export type PushError = v.Infer<typeof pushErrorSchema>;
 export type PushOk = v.Infer<typeof pushOkSchema>;
-export type AckMutationMessage = v.Infer<typeof ackMutationResponsesMessageSchema>;
 export {};
 //# sourceMappingURL=push.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/push.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAGhD,OAAO,EAAC,sBAAsB,EAAiB,MAAM,eAAe,CAAC;AAErE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUzB;;;OAGG;;IAEH,sDAAsD;;aAEtD,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAT5B;;;OAGG;;IAEH,sDAAsD;;eAIqB,CAAC;AAE9E,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;aAEhB,CAAC;AA4CH;;GAEG;AACH,eAAO,MAAM,eAAe;IAzC1B,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;eAWnB,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;IAhDjC,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;iBAawD,CAAC;AAE7E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;IAlD7B,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBnB,CAAC;AACF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;IAtDpC,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;mBAsBlB,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;eAG5C,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CACtC,OAAO,iCAAiC,CACzC,CAAC"}
+{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/push.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAGhD,OAAO,EAAC,sBAAsB,EAAiB,MAAM,eAAe,CAAC;AAErE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUzB;;;OAGG;;IAEH,sDAAsD;;aAEtD,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAT5B;;;OAGG;;IAEH,sDAAsD;;eAIqB,CAAC;AAE9E,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;aAEhB,CAAC;AA4CH;;GAEG;AACH,eAAO,MAAM,eAAe;IAzC1B,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;eAWnB,CAAC;AAEF,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;IAhD1B,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;iBAaiD,CAAC;AAEtE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;IAlD7B,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBnB,CAAC;AACF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;IAtDpC,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;;IAOlB,kBAAkB;;IAElB,kBAAkB;;IAElB,kBAAkB;;;;;mBAsBlB,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;eAG5C,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

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

@@ -1 +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"}
+{"version":3,"file":"push.js","names":["v"],"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\nconst 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 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>;\n"],"mappings":";;;;;AAKA,IAAa,iBAAiBA,eAAE,OAAO;CACrC,eAAeA,eAAE,OAAO;CACxB,WAAWA,eAAE,MAAM,cAAc;CACjC,aAAaA,eAAE,OAAO;CAItB,eAAeA,eAAE,OAAO,CAAC,CAAC,SAAS;CACnC,WAAWA,eAAE,OAAO;CACpB,WAAWA,eAAE,OAAO;;;;;CAKpB,MAAMA,eAAE,OAAO,CAAC,CAAC,SAAS;;CAE1B,aAAaA,eAAE,OAAO,CAAC,CAAC,SAAS;AACnC,CAAC;AAED,IAAa,oBAAoBA,eAAE,MAAM,CAACA,eAAE,QAAQ,MAAM,GAAG,cAAc,CAAC;AAE5E,IAAM,eAAeA,eAAE,OAAO,EAC5B,WAAWA,eAAE,MAAM,sBAAsB,EAC3C,CAAC;;;;AAKD,IAAM,+BAA+BA,eAAE,OAAO;;CAE5C,OAAOA,eAAE,QAAQ,wBAAwB;;CAEzC,aAAaA,eAAE,MAAM,gBAAgB,CAAC,CAAC,SAAS;AAClD,CAAC;;;;AAID,IAAM,iCAAiCA,eAAE,OAAO;;CAE9C,OAAOA,eAAE,QAAQ,0BAA0B;;CAE3C,aAAaA,eAAE,MAAM,gBAAgB,CAAC,CAAC,SAAS;AAClD,CAAC;;;;AAID,IAAM,kBAAkBA,eAAE,OAAO;;CAE/B,OAAOA,eAAE,QAAQ,MAAM;;CAEvB,QAAQA,eAAE,OAAO;;CAEjB,SAASA,eAAE,OAAO;;CAElB,aAAaA,eAAE,MAAM,gBAAgB,CAAC,CAAC,SAAS;AAClD,CAAC;;;;AAID,IAAM,wBAAwBA,eAAE,OAAO;;CAErC,OAAOA,eAAE,QAAQ,YAAY;;CAE7B,SAASA,eAAE,OAAO;;CAElB,aAAaA,eAAE,MAAM,gBAAgB,CAAC,CAAC,SAAS;AAClD,CAAC;;;;AAID,IAAa,kBAAkBA,eAAE,MAC/B,8BACA,gCACA,iBACA,qBACF;AAEA,IAAM,yBAAyBA,eAAE,MAAM,cAAc,eAAe;AAElCA,eAAE,MAClC,wBACA,oBACF;AACA,IAAa,4BAA4BA,eAAE,MAAM,CAC/CA,eAAE,QAAQ,cAAc,GACxB,sBACF,CAAC;AAED,IAAa,oCAAoCA,eAAE,MAAM,CACvDA,eAAE,QAAQ,sBAAsB,GAChC,gBACF,CAAC"}

package/out/zero-protocol/src/queries-patch.d.ts

@@ -1,9 +1,4 @@
 import * as v from '../../shared/src/valita.ts';
-export declare const putOpSchema: v.ObjectType<{
-    op: v.Type<"put">;
-    hash: v.Type<string>;
-    ttl: v.Optional<number>;
-}, undefined>;
 export declare const upPutOpSchema: v.ObjectType<Omit<{
     op: v.Type<"put">;
     hash: v.Type<string>;
@@ -13,13 +8,6 @@ export declare const upPutOpSchema: v.ObjectType<Omit<{
     name: v.Optional<string>;
     args: v.Optional<readonly import("../../shared/src/json.ts").ReadonlyJSONValue[]>;
 }, undefined>;
-declare const delOpSchema: v.ObjectType<{
-    op: v.Type<"del">;
-    hash: v.Type<string>;
-}, undefined>;
-declare const clearOpSchema: v.ObjectType<{
-    op: v.Type<"clear">;
-}, undefined>;
 declare const patchOpSchema: v.UnionType<[v.ObjectType<{
     op: v.Type<"put">;
     hash: v.Type<string>;
@@ -68,12 +56,8 @@ export declare const upQueriesPatchSchema: v.ArrayType<v.UnionType<[v.ObjectType
 }, undefined>, v.ObjectType<{
     op: v.Type<"clear">;
 }, undefined>]>>;
-export type QueriesPutOp = v.Infer<typeof putOpSchema>;
-export type QueriesDelOp = v.Infer<typeof delOpSchema>;
-export type QueriesClearOp = v.Infer<typeof clearOpSchema>;
 export type QueriesPatchOp = v.Infer<typeof patchOpSchema>;
 export type UpQueriesPatchOp = v.Infer<typeof upPatchOpSchema>;
-export type QueriesPatch = v.Infer<typeof queriesPatchSchema>;
 export type UpQueriesPatch = v.Infer<typeof upQueriesPatchSchema>;
 export {};
 //# sourceMappingURL=queries-patch.d.ts.map

package/out/zero-protocol/src/queries-patch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queries-patch.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/queries-patch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAGhD,eAAO,MAAM,WAAW;;;;aAItB,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;aAOxB,CAAC;AAEH,QAAA,MAAM,WAAW;;;aAGf,CAAC;AAEH,QAAA,MAAM,aAAa;;aAEjB,CAAC;AAEH,QAAA,MAAM,aAAa;;;;;;;;;eAAmD,CAAC;AACvE,QAAA,MAAM,eAAe;;;;;;;;;;;;;eAAqD,CAAC;AAE3E,eAAO,MAAM,kBAAkB;;;;;;;;;gBAAyB,CAAC;AACzD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;gBAA2B,CAAC;AAE7D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACvD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACvD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC3D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC3D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC/D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"queries-patch.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/queries-patch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAShD,eAAO,MAAM,aAAa;;;;;;;;aAOxB,CAAC;AAWH,QAAA,MAAM,aAAa;;;;;;;;;eAAmD,CAAC;AACvE,QAAA,MAAM,eAAe;;;;;;;;;;;;;eAAqD,CAAC;AAE3E,eAAO,MAAM,kBAAkB;;;;;;;;;gBAAyB,CAAC;AACzD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;gBAA2B,CAAC;AAE7D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC3D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC/D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

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

@@ -22,6 +22,6 @@ var upPatchOpSchema = valita_exports.union(upPutOpSchema, delOpSchema, clearOpSc
 var queriesPatchSchema = valita_exports.array(patchOpSchema);
 var upQueriesPatchSchema = valita_exports.array(upPatchOpSchema);
 //#endregion
-export { queriesPatchSchema, upQueriesPatchSchema };
+export { queriesPatchSchema, upPutOpSchema, upQueriesPatchSchema };
 
 //# sourceMappingURL=queries-patch.js.map

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

@@ -1 +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 {strictASTSchema} 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: strictASTSchema.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,gBAAgB,SAAS;CAC9B,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"}
+{"version":3,"file":"queries-patch.js","names":["v","v.readonly"],"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 {strictASTSchema} from './ast.ts';\n\nconst 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: strictASTSchema.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 QueriesPatchOp = v.Infer<typeof patchOpSchema>;\nexport type UpQueriesPatchOp = v.Infer<typeof upPatchOpSchema>;\nexport type UpQueriesPatch = v.Infer<typeof upQueriesPatchSchema>;\n"],"mappings":";;;;AAIA,IAAM,cAAcA,eAAE,OAAO;CAC3B,IAAIA,eAAE,QAAQ,KAAK;CACnB,MAAMA,eAAE,OAAO;CACf,KAAKA,eAAE,OAAO,CAAC,CAAC,SAAS;AAC3B,CAAC;AAED,IAAa,gBAAgB,YAAY,OAAO;CAI9C,KAAK,gBAAgB,SAAS;CAC9B,MAAMA,eAAE,OAAO,CAAC,CAAC,SAAS;CAC1B,MAAMC,SAAWD,eAAE,MAAM,UAAU,CAAC,CAAC,CAAC,SAAS;AACjD,CAAC;AAED,IAAM,cAAcA,eAAE,OAAO;CAC3B,IAAIA,eAAE,QAAQ,KAAK;CACnB,MAAMA,eAAE,OAAO;AACjB,CAAC;AAED,IAAM,gBAAgBA,eAAE,OAAO,EAC7B,IAAIA,eAAE,QAAQ,OAAO,EACvB,CAAC;AAED,IAAM,gBAAgBA,eAAE,MAAM,aAAa,aAAa,aAAa;AACrE,IAAM,kBAAkBA,eAAE,MAAM,eAAe,aAAa,aAAa;AAEzE,IAAa,qBAAqBA,eAAE,MAAM,aAAa;AACvD,IAAa,uBAAuBA,eAAE,MAAM,eAAe"}

package/out/zero-protocol/src/query-hash-visitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-hash-visitor.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/query-hash-visitor.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,gCAAgC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,KAAK,EACV,GAAG,EAIH,MAAM,EAEP,MAAM,UAAU,CAAC;AA8UlB,wBAAgB,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAcxC;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,OAAO,EAAE,GACvB,MAAM,CAaR;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,eAAe,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,GAC9C,MAAM,CA2BR"}
+{"version":3,"file":"query-hash-visitor.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/query-hash-visitor.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,gCAAgC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,KAAK,EAEV,GAAG,EAIH,MAAM,EAEP,MAAM,UAAU,CAAC;AAsYlB,wBAAgB,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAcxC;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,OAAO,EAAE,GACvB,MAAM,CAaR;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,eAAe,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,GAC9C,MAAM,CA2BR"}

package/out/zero-protocol/src/query-hash-visitor.js

@@ -63,6 +63,10 @@ var TAG_SYSTEM_PERMISSIONS = 8202;
 var TAG_SYSTEM_CLIENT = 8203;
 var TAG_SYSTEM_TEST = 8204;
 var TAG_JUNCTION = 8205;
+var TAG_AGGREGATE = 8206;
+var TAG_JSON = 8207;
+var TAG_GROUP_BY = 8208;
+var TAG_DISTINCT = 8209;
 var STR_MARK = 1073741824;
 function reset() {
 	h1 = PRIME32_5;
@@ -170,6 +174,11 @@ function visitValuePosition(v) {
 			if (typeof v.field === "string") mixString(v.field);
 			else visitCompoundKey(v.field);
 			return;
+		case "json":
+			mix(TAG_JSON);
+			visitValuePosition(v.value);
+			visitValue(v.path);
+			return;
 		default: unreachable(v);
 	}
 }
@@ -203,8 +212,31 @@ function visitCorrelatedSubquery(csq) {
 	visitCompoundKey(csq.correlation.childField);
 	mix(csq.hidden === void 0 ? TAG_UNDEF : csq.hidden ? TAG_TRUE : TAG_FALSE);
 	mixOptionalSystem(csq.system);
+	visitAggregate(csq.aggregate);
 	visitAST(csq.subquery);
 }
+/**
+* An absent aggregate writes nothing, unlike the other optionals, so that the
+* hash of every query without one is unchanged by the field's addition. That
+* is unambiguous because of where it is written: an aggregate is always
+* followed by a word no aggregate could begin with (TAG_END on an AST, TAG_OBJ
+* on a correlated subquery), and a present one leads with its own tag.
+*/
+function visitAggregate(aggregate) {
+	if (aggregate === void 0) return;
+	mix(TAG_AGGREGATE);
+	mixString(aggregate.fn);
+	visitOptionalString(aggregate.field);
+	if (aggregate.path !== void 0) {
+		mix(TAG_JSON);
+		visitValue(aggregate.path);
+	}
+	if (aggregate.distinct !== void 0) {
+		mix(TAG_DISTINCT);
+		mix(aggregate.distinct.length);
+		for (const col of aggregate.distinct) mixString(col);
+	}
+}
 function visitAST(ast) {
 	mix(TAG_OBJ);
 	visitOptionalString(ast.schema);
@@ -230,6 +262,12 @@ function visitAST(ast) {
 		mixNumber(ast.limit);
 	}
 	visitOrdering(ast.orderBy);
+	visitAggregate(ast.aggregate);
+	if (ast.groupBy !== void 0) {
+		mix(TAG_GROUP_BY);
+		mix(ast.groupBy.length);
+		for (const col of ast.groupBy) mixString(col);
+	}
 	mix(TAG_END);
 }
 function hashAST(ast) {

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

@@ -1 +1 @@
-{"version":3,"file":"query-hash-visitor.js","names":[],"sources":["../../../../zero-protocol/src/query-hash-visitor.ts"],"sourcesContent":["import {unreachable} from '../../shared/src/asserts.ts';\n// These live in shared/src/xxhash32.ts, imported via hash.ts's re-export\n// rather than directly: the direct zero-protocol -> shared/xxhash32.ts edge\n// makes tsc 7.0.2 mis-evaluate Query-type relations in other programs --\n// phantom TS2345s in zql's runnable-query-impl.ts under the packages/zero\n// declaration build, and zero-client silently losing the type error that\n// custom.test.ts pins with a ts-expect-error directive. Bisected cold-cache\n// to that one import statement; the hash.ts route checks clean everywhere.\n// Collapse to a direct import when TypeScript is upgraded past this.\nimport {\n  avalanche32,\n  PRIME32_1,\n  PRIME32_5,\n  round32,\n} from '../../shared/src/hash.ts';\nimport type {Format} from '../../zero-types/src/format.ts';\n\n/**\n * Hashes a normalized AST by visiting it, rather than by rendering it to JSON\n * and hashing the bytes. `hashOfAST` and `hashOfNameAndArgs` in\n * `query-hash.ts` are both built on this, so these digests are the query IDs\n * the client registers and the transformation hashes the server stores.\n *\n * The pipeline this replaced was\n * `h64(JSON.stringify(normalizeAST(ast))).toString(36)`, which materialized\n * the whole AST as a string, UTF-8 encoded it, and only then hashed it — three\n * passes over the data, two of which existed purely to produce bytes to hash.\n *\n * A visitor can fold values into the hash state as it walks, so nothing is\n * materialized at all. The primitives that make that pay off:\n *\n * - Two 32-bit accumulators held in module-level `let`s, so the \"state\" is\n *   plain numbers in registers rather than an object being threaded through\n *   the walk.\n * - xxHash32's own round and final mix, shared with `shared/src/hash.ts` via\n *   `shared/src/xxhash32.ts`. Only the ingestion differs: that one feeds them\n *   UTF-8 bytes, this one feeds them words straight out of the structure.\n * - Strings folded straight from `charCodeAt`, two UTF-16 units at a time, into\n *   one 32-bit word. No UTF-8 encoding, and half the loop iterations a\n *   byte-oriented hash would need over ASCII.\n *\n * These digests do not agree with xxHash32 over the old JSON encoding, and are\n * not meant to: nothing recomputes a hash produced elsewhere and compares it,\n * so the encoding is free to change as long as every writer moves together.\n * What it does have to give is distinct words for structurally distinct\n * queries — a 64-bit digest cannot promise that absolutely, but every field\n * and node kind must at least reach the mixer, and no two of them may be\n * written so as to be confusable. `query-hash-visitor.test.ts` holds that\n * line with a corpus and a per-field mutation test.\n *\n * The walk is deliberately specialized to the AST shape rather than written as\n * a generic JSON-value walk. That is not premature: a generic version was\n * measured alongside this one and came out ~2.4x slower, no better than the\n * `JSON.stringify` it was meant to replace, because `for...in` and the\n * megamorphic property loads cost about what the native stringify costs. Only\n * `visitValue` below stays generic, for the two places an AST holds arbitrary\n * JSON: a literal's value and a bound's row.\n */\nimport type {\n  AST,\n  Condition,\n  CorrelatedSubquery,\n  Ordering,\n  System,\n  ValuePosition,\n} from './ast.ts';\n\n// Two 32-bit lanes, combined into 64 bits at the end. Module-level so the walk\n// mutates registers rather than allocating or threading state through it.\nlet h1 = 0;\nlet h2 = 0;\n\n/**\n * Fold one 32-bit word into both lanes.\n *\n * Both lanes run xxHash32's own round; only their starting values differ, so\n * they diverge immediately and stay diverged. That is the same construction\n * `h64` uses to widen xxHash32 past 32 bits, just fed words taken from a\n * structure rather than bytes taken from a string.\n */\nfunction mix(w: number): void {\n  h1 = round32(h1, w);\n  h2 = round32(h2, w);\n}\n\n/**\n * Fold a string, two UTF-16 units per word.\n *\n * The leading length keeps `['ab','c']` and `['a','bc']` apart. STR_MARK is\n * folded into that same word rather than mixed separately: it costs nothing,\n * and since every other count written by this file is a small array length, a\n * string can never fold like one.\n */\nfunction mixString(s: string): void {\n  const n = s.length;\n  mix(n | STR_MARK);\n  let i = 0;\n  for (; i + 1 < n; i += 2) {\n    mix(s.charCodeAt(i) | (s.charCodeAt(i + 1) << 16));\n  }\n  if (i < n) {\n    mix(s.charCodeAt(i));\n  }\n}\n\n// A DataView with an explicit byte order, not a Float64Array/Int32Array\n// aliasing pair: typed arrays read the buffer in host byte order, and these\n// digests are persisted, so a big-endian runtime would fold a float's words\n// swapped and disagree with every little-endian peer.\nconst numView = new DataView(new ArrayBuffer(8));\n\n/** Fold a number: one word for an int32, two for anything else. */\nfunction mixNumber(n: number): void {\n  if ((n | 0) === n) {\n    mix(n);\n  } else {\n    numView.setFloat64(0, n, true);\n    mix(numView.getInt32(0, true));\n    mix(numView.getInt32(4, true));\n  }\n}\n\n// Structural tags. Distinct constants so that, say, a string \"1\" and the\n// number 1 cannot fold to the same state.\nconst TAG_NULL = 0x1001;\nconst TAG_FALSE = 0x1002;\nconst TAG_TRUE = 0x1003;\nconst TAG_INT = 0x1004;\nconst TAG_FLOAT = 0x1005;\nconst TAG_ARR = 0x1007;\nconst TAG_OBJ = 0x1008;\nconst TAG_END = 0x1009;\nconst TAG_UNDEF = 0x100a;\n\n// Discriminators for the AST's own unions, kept distinct from the value tags\n// above so a node kind can never fold like a value of some other type.\nconst TAG_LITERAL = 0x2001;\nconst TAG_COLUMN = 0x2002;\nconst TAG_STATIC = 0x2003;\nconst TAG_SIMPLE = 0x2004;\nconst TAG_SUBQUERY = 0x2005;\nconst TAG_AND = 0x2006;\nconst TAG_OR = 0x2007;\nconst TAG_FORMAT = 0x2008;\nconst TAG_NAME_ARGS = 0x2009;\n// `System` is a closed set of three, so it folds as one word rather than as a\n// string -- on an AST it appears once per correlated subquery, so this is on\n// the walk's hot path. The switch below is exhaustive, so adding a member is a\n// type error rather than a silent collision with an existing one.\nconst TAG_SYSTEM_PERMISSIONS = 0x200a;\nconst TAG_SYSTEM_CLIENT = 0x200b;\nconst TAG_SYSTEM_TEST = 0x200c;\nconst TAG_JUNCTION = 0x200d;\n\n// Set on a string's length word. High enough that no array length reaches it.\nconst STR_MARK = 0x40000000;\n\nfunction reset(): void {\n  h1 = PRIME32_5;\n  h2 = PRIME32_1;\n}\n\n/** Collapse the two lanes into one 64-bit value, avalanching each first. */\nfunction finalize(): string {\n  return (\n    avalanche32(h1).toString(36).padStart(7, '0') +\n    avalanche32(h2).toString(36).padStart(7, '0')\n  );\n}\n\n// ---------------------------------------------------------------------------\n// The generic part: arbitrary JSON, for literal values and bound rows.\n// ---------------------------------------------------------------------------\n\nfunction visitValue(v: unknown): void {\n  switch (typeof v) {\n    case 'string':\n      mixString(v);\n      return;\n    case 'number':\n      // NaN and Infinity are null by the time they reach the wire, because\n      // that is what JSON.stringify writes for them. Two queries identical on\n      // the wire must not get different IDs.\n      if (!Number.isFinite(v)) {\n        mix(TAG_NULL);\n        return;\n      }\n      mix((v | 0) === v ? TAG_INT : TAG_FLOAT);\n      mixNumber(v);\n      return;\n    case 'boolean':\n      mix(v ? TAG_TRUE : TAG_FALSE);\n      return;\n    case 'object': {\n      if (v === null) {\n        mix(TAG_NULL);\n        return;\n      }\n      if (Array.isArray(v)) {\n        mix(TAG_ARR);\n        for (let i = 0; i < v.length; i++) {\n          // An `undefined` element is `null` by the time it reaches the wire,\n          // because that is what JSON.stringify makes of it. Dropping it\n          // instead would fold `[undefined]` onto `[]`.\n          const e: unknown = v[i];\n          visitValue(e === undefined ? null : e);\n        }\n        mix(TAG_END);\n        return;\n      }\n      mix(TAG_OBJ);\n      // Sorted, so the digest is a function of the object's contents and not\n      // of its key order. Rows and custom-query args round-trip through\n      // Postgres JSONB, which reorders keys; an order-sensitive digest made\n      // reloaded query records look changed. (The AST's own fields don't need\n      // this: visitAST reads them in a fixed order by name.)\n      const keys = Object.keys(v).sort();\n      for (const k of keys) {\n        const val = (v as Record<string, unknown>)[k];\n        if (val === undefined) {\n          continue; // as JSON.stringify does\n        }\n        mixString(k);\n        visitValue(val);\n      }\n      mix(TAG_END);\n      return;\n    }\n    default:\n      // `undefined` and functions as an object's value: dropped, as\n      // JSON.stringify drops them. Array elements are handled above.\n      return;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// The specialized part: the AST's own shape.\n// ---------------------------------------------------------------------------\n\nfunction visitOptionalString(s: string | undefined): void {\n  if (s === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mixString(s);\n  }\n}\n\nfunction mixOptionalSystem(system: System | undefined): void {\n  if (system === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mixSystem(system);\n  }\n}\n\nfunction mixSystem(system: System): void {\n  switch (system) {\n    case 'permissions':\n      mix(TAG_SYSTEM_PERMISSIONS);\n      break;\n    case 'client':\n      mix(TAG_SYSTEM_CLIENT);\n      break;\n    case 'test':\n      mix(TAG_SYSTEM_TEST);\n      break;\n    default:\n      unreachable(system);\n  }\n}\n\nfunction visitCompoundKey(k: readonly string[]): void {\n  mix(k.length);\n  for (let i = 0; i < k.length; i++) {\n    mixString(k[i]);\n  }\n}\n\nfunction visitOrdering(o: Ordering | undefined): void {\n  if (o === undefined) {\n    mix(TAG_UNDEF);\n    return;\n  }\n  mix(o.length);\n  for (let i = 0; i < o.length; i++) {\n    const [field, dir] = o[i];\n    mixString(field);\n    mix(dir === 'asc' ? TAG_TRUE : TAG_FALSE);\n  }\n}\n\nfunction visitValuePosition(v: ValuePosition): void {\n  switch (v.type) {\n    case 'literal':\n      mix(TAG_LITERAL);\n      visitValue(v.value);\n      return;\n    case 'column':\n      mix(TAG_COLUMN);\n      mixString(v.name);\n      return;\n    case 'static': {\n      mix(TAG_STATIC);\n      mixString(v.anchor);\n      if (typeof v.field === 'string') {\n        mixString(v.field);\n      } else {\n        visitCompoundKey(v.field);\n      }\n      return;\n    }\n    default:\n      unreachable(v);\n  }\n}\n\nfunction visitCondition(c: Condition): void {\n  switch (c.type) {\n    case 'simple':\n      mix(TAG_SIMPLE);\n      mixString(c.op);\n      visitValuePosition(c.left);\n      visitValuePosition(c.right);\n      return;\n    case 'correlatedSubquery':\n      mix(TAG_SUBQUERY);\n      mixString(c.op);\n      mix(c.flip === undefined ? TAG_UNDEF : c.flip ? TAG_TRUE : TAG_FALSE);\n      mix(c.scalar === undefined ? TAG_UNDEF : c.scalar ? TAG_TRUE : TAG_FALSE);\n      visitCorrelatedSubquery(c.related);\n      return;\n    default: {\n      c.type satisfies 'and' | 'or';\n      mix(c.type === 'and' ? TAG_AND : TAG_OR);\n      const conds = c.conditions;\n      mix(conds.length);\n      for (let i = 0; i < conds.length; i++) {\n        visitCondition(conds[i]);\n      }\n      return;\n    }\n  }\n}\n\nfunction visitCorrelatedSubquery(csq: CorrelatedSubquery): void {\n  visitCompoundKey(csq.correlation.parentField);\n  visitCompoundKey(csq.correlation.childField);\n  mix(csq.hidden === undefined ? TAG_UNDEF : csq.hidden ? TAG_TRUE : TAG_FALSE);\n  mixOptionalSystem(csq.system);\n  visitAST(csq.subquery);\n}\n\nfunction visitAST(ast: AST): void {\n  mix(TAG_OBJ);\n  visitOptionalString(ast.schema);\n  mixString(ast.table);\n  visitOptionalString(ast.alias);\n\n  if (ast.where === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    visitCondition(ast.where);\n  }\n\n  const related = ast.related;\n  if (related === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mix(related.length);\n    for (let i = 0; i < related.length; i++) {\n      visitCorrelatedSubquery(related[i]);\n    }\n  }\n\n  const start = ast.start;\n  if (start === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mix(start.exclusive ? TAG_TRUE : TAG_FALSE);\n    visitValue(start.row);\n  }\n\n  if (ast.limit === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    // Tagged, because this is the one optional field whose present and absent\n    // forms would otherwise both write a single bare word: an untagged\n    // `limit: 4106` is the same word as TAG_UNDEF. The other optionals are\n    // safe -- a present string carries STR_MARK, a condition or bound leads\n    // with its own kind tag, and `related`/`orderBy` write a count followed by\n    // that many items, so their streams diverge straight after.\n    mix(TAG_INT);\n    mixNumber(ast.limit);\n  }\n\n  visitOrdering(ast.orderBy);\n  mix(TAG_END);\n}\n\nexport function hashAST(ast: AST): string {\n  // Save and restore the lanes: `visitValue` reads properties of arbitrary\n  // runtime objects, and a getter is free to ask for another hash mid-walk.\n  // Without this, the inner call's reset() would corrupt the outer digest.\n  const s1 = h1;\n  const s2 = h2;\n  try {\n    reset();\n    visitAST(ast);\n    return finalize();\n  } finally {\n    h1 = s1;\n    h2 = s2;\n  }\n}\n\n/**\n * The identity of a custom query: its name and its arguments.\n *\n * Same walk, entered at a different node. `args` is arbitrary JSON, which is\n * what `visitValue` already exists to handle. The leading tag keeps this hash\n * space disjoint from `hashAST`'s -- both produce query IDs that live in the\n * same namespace, so an AST must not be able to fold to the same words as some\n * name and args.\n */\nexport function hashNameAndArgs(\n  name: string,\n  args: readonly unknown[],\n): string {\n  const s1 = h1;\n  const s2 = h2;\n  try {\n    reset();\n    mix(TAG_NAME_ARGS);\n    mixString(name);\n    visitValue(args);\n    return finalize();\n  } finally {\n    h1 = s1;\n    h2 = s2;\n  }\n}\n\n/**\n * The identity of a query as the client sees it: its AST, the shape it returns,\n * the system it was built for, and -- for a custom query -- the name and\n * arguments it was declared with.\n *\n * Everything past the AST is here because it is part of what makes two queries\n * different while leaving no trace, or an incomplete one, in the AST itself:\n *\n * - **name and args**: `nameAndArgs` reuses the AST it is given and only\n *   attaches a `CustomQueryID`, so without these two different named queries\n *   over the same table would be indistinguishable.\n * - **system**: a query stamps it onto every `related` entry and every `exists`\n *   correlation it builds, so it is already hashed via\n *   {@link visitCorrelatedSubquery} -- but a query with neither has nowhere to\n *   put it, and would otherwise hash the same whether it was built for the\n *   client or for permissions.\n * - **currentJunction**: builder state, set on the sub-query handed to a\n *   two-hop relationship's callback, which makes `limit` and `orderBy` throw.\n *   It leaves no trace in the AST at all, so two queries that differ only in\n *   whether those methods work would otherwise be indistinguishable.\n *\n * The name and args are taken apart rather than as a `CustomQueryID` because\n * that type lives in `zql`, which is above this package; `hashNameAndArgs`\n * splits them the same way.\n */\nexport function hashOfQueryInternals(\n  ast: AST,\n  format: Format,\n  system: System,\n  currentJunction: string | undefined,\n  customQueryName: string | undefined,\n  customQueryArgs: readonly unknown[] | undefined,\n): string {\n  const s1 = h1;\n  const s2 = h2;\n  try {\n    reset();\n    visitAST(ast);\n    mix(TAG_FORMAT);\n    visitValue(format);\n    mixSystem(system);\n    if (currentJunction === undefined) {\n      mix(TAG_UNDEF);\n    } else {\n      mix(TAG_JUNCTION);\n      mixString(currentJunction);\n    }\n    if (customQueryName === undefined) {\n      mix(TAG_UNDEF);\n    } else {\n      mix(TAG_NAME_ARGS);\n      mixString(customQueryName);\n      visitValue(customQueryArgs);\n    }\n    return finalize();\n  } finally {\n    h1 = s1;\n    h2 = s2;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"query-hash-visitor.js","names":[],"sources":["../../../../zero-protocol/src/query-hash-visitor.ts"],"sourcesContent":["import {unreachable} from '../../shared/src/asserts.ts';\n// These live in shared/src/xxhash32.ts, imported via hash.ts's re-export\n// rather than directly: the direct zero-protocol -> shared/xxhash32.ts edge\n// makes tsc 7.0.2 mis-evaluate Query-type relations in other programs --\n// phantom TS2345s in zql's runnable-query-impl.ts under the packages/zero\n// declaration build, and zero-client silently losing the type error that\n// custom.test.ts pins with a ts-expect-error directive. Bisected cold-cache\n// to that one import statement; the hash.ts route checks clean everywhere.\n// Collapse to a direct import when TypeScript is upgraded past this.\nimport {\n  avalanche32,\n  PRIME32_1,\n  PRIME32_5,\n  round32,\n} from '../../shared/src/hash.ts';\nimport type {Format} from '../../zero-types/src/format.ts';\n\n/**\n * Hashes a normalized AST by visiting it, rather than by rendering it to JSON\n * and hashing the bytes. `hashOfAST` and `hashOfNameAndArgs` in\n * `query-hash.ts` are both built on this, so these digests are the query IDs\n * the client registers and the transformation hashes the server stores.\n *\n * The pipeline this replaced was\n * `h64(JSON.stringify(normalizeAST(ast))).toString(36)`, which materialized\n * the whole AST as a string, UTF-8 encoded it, and only then hashed it — three\n * passes over the data, two of which existed purely to produce bytes to hash.\n *\n * A visitor can fold values into the hash state as it walks, so nothing is\n * materialized at all. The primitives that make that pay off:\n *\n * - Two 32-bit accumulators held in module-level `let`s, so the \"state\" is\n *   plain numbers in registers rather than an object being threaded through\n *   the walk.\n * - xxHash32's own round and final mix, shared with `shared/src/hash.ts` via\n *   `shared/src/xxhash32.ts`. Only the ingestion differs: that one feeds them\n *   UTF-8 bytes, this one feeds them words straight out of the structure.\n * - Strings folded straight from `charCodeAt`, two UTF-16 units at a time, into\n *   one 32-bit word. No UTF-8 encoding, and half the loop iterations a\n *   byte-oriented hash would need over ASCII.\n *\n * These digests do not agree with xxHash32 over the old JSON encoding, and are\n * not meant to: nothing recomputes a hash produced elsewhere and compares it,\n * so the encoding is free to change as long as every writer moves together.\n * What it does have to give is distinct words for structurally distinct\n * queries — a 64-bit digest cannot promise that absolutely, but every field\n * and node kind must at least reach the mixer, and no two of them may be\n * written so as to be confusable. `query-hash-visitor.test.ts` holds that\n * line with a corpus and a per-field mutation test.\n *\n * The walk is deliberately specialized to the AST shape rather than written as\n * a generic JSON-value walk. That is not premature: a generic version was\n * measured alongside this one and came out ~2.4x slower, no better than the\n * `JSON.stringify` it was meant to replace, because `for...in` and the\n * megamorphic property loads cost about what the native stringify costs. Only\n * `visitValue` below stays generic, for the two places an AST holds arbitrary\n * JSON: a literal's value and a bound's row.\n */\nimport type {\n  Aggregate,\n  AST,\n  Condition,\n  CorrelatedSubquery,\n  Ordering,\n  System,\n  ValuePosition,\n} from './ast.ts';\n\n// Two 32-bit lanes, combined into 64 bits at the end. Module-level so the walk\n// mutates registers rather than allocating or threading state through it.\nlet h1 = 0;\nlet h2 = 0;\n\n/**\n * Fold one 32-bit word into both lanes.\n *\n * Both lanes run xxHash32's own round; only their starting values differ, so\n * they diverge immediately and stay diverged. That is the same construction\n * `h64` uses to widen xxHash32 past 32 bits, just fed words taken from a\n * structure rather than bytes taken from a string.\n */\nfunction mix(w: number): void {\n  h1 = round32(h1, w);\n  h2 = round32(h2, w);\n}\n\n/**\n * Fold a string, two UTF-16 units per word.\n *\n * The leading length keeps `['ab','c']` and `['a','bc']` apart. STR_MARK is\n * folded into that same word rather than mixed separately: it costs nothing,\n * and since every other count written by this file is a small array length, a\n * string can never fold like one.\n */\nfunction mixString(s: string): void {\n  const n = s.length;\n  mix(n | STR_MARK);\n  let i = 0;\n  for (; i + 1 < n; i += 2) {\n    mix(s.charCodeAt(i) | (s.charCodeAt(i + 1) << 16));\n  }\n  if (i < n) {\n    mix(s.charCodeAt(i));\n  }\n}\n\n// A DataView with an explicit byte order, not a Float64Array/Int32Array\n// aliasing pair: typed arrays read the buffer in host byte order, and these\n// digests are persisted, so a big-endian runtime would fold a float's words\n// swapped and disagree with every little-endian peer.\nconst numView = new DataView(new ArrayBuffer(8));\n\n/** Fold a number: one word for an int32, two for anything else. */\nfunction mixNumber(n: number): void {\n  if ((n | 0) === n) {\n    mix(n);\n  } else {\n    numView.setFloat64(0, n, true);\n    mix(numView.getInt32(0, true));\n    mix(numView.getInt32(4, true));\n  }\n}\n\n// Structural tags. Distinct constants so that, say, a string \"1\" and the\n// number 1 cannot fold to the same state.\nconst TAG_NULL = 0x1001;\nconst TAG_FALSE = 0x1002;\nconst TAG_TRUE = 0x1003;\nconst TAG_INT = 0x1004;\nconst TAG_FLOAT = 0x1005;\nconst TAG_ARR = 0x1007;\nconst TAG_OBJ = 0x1008;\nconst TAG_END = 0x1009;\nconst TAG_UNDEF = 0x100a;\n\n// Discriminators for the AST's own unions, kept distinct from the value tags\n// above so a node kind can never fold like a value of some other type.\nconst TAG_LITERAL = 0x2001;\nconst TAG_COLUMN = 0x2002;\nconst TAG_STATIC = 0x2003;\nconst TAG_SIMPLE = 0x2004;\nconst TAG_SUBQUERY = 0x2005;\nconst TAG_AND = 0x2006;\nconst TAG_OR = 0x2007;\nconst TAG_FORMAT = 0x2008;\nconst TAG_NAME_ARGS = 0x2009;\n// `System` is a closed set of three, so it folds as one word rather than as a\n// string -- on an AST it appears once per correlated subquery, so this is on\n// the walk's hot path. The switch below is exhaustive, so adding a member is a\n// type error rather than a silent collision with an existing one.\nconst TAG_SYSTEM_PERMISSIONS = 0x200a;\nconst TAG_SYSTEM_CLIENT = 0x200b;\nconst TAG_SYSTEM_TEST = 0x200c;\nconst TAG_JUNCTION = 0x200d;\nconst TAG_AGGREGATE = 0x200e;\nconst TAG_JSON = 0x200f;\nconst TAG_GROUP_BY = 0x2010;\nconst TAG_DISTINCT = 0x2011;\n\n// Set on a string's length word. High enough that no array length reaches it.\nconst STR_MARK = 0x40000000;\n\nfunction reset(): void {\n  h1 = PRIME32_5;\n  h2 = PRIME32_1;\n}\n\n/** Collapse the two lanes into one 64-bit value, avalanching each first. */\nfunction finalize(): string {\n  return (\n    avalanche32(h1).toString(36).padStart(7, '0') +\n    avalanche32(h2).toString(36).padStart(7, '0')\n  );\n}\n\n// ---------------------------------------------------------------------------\n// The generic part: arbitrary JSON, for literal values and bound rows.\n// ---------------------------------------------------------------------------\n\nfunction visitValue(v: unknown): void {\n  switch (typeof v) {\n    case 'string':\n      mixString(v);\n      return;\n    case 'number':\n      // NaN and Infinity are null by the time they reach the wire, because\n      // that is what JSON.stringify writes for them. Two queries identical on\n      // the wire must not get different IDs.\n      if (!Number.isFinite(v)) {\n        mix(TAG_NULL);\n        return;\n      }\n      mix((v | 0) === v ? TAG_INT : TAG_FLOAT);\n      mixNumber(v);\n      return;\n    case 'boolean':\n      mix(v ? TAG_TRUE : TAG_FALSE);\n      return;\n    case 'object': {\n      if (v === null) {\n        mix(TAG_NULL);\n        return;\n      }\n      if (Array.isArray(v)) {\n        mix(TAG_ARR);\n        for (let i = 0; i < v.length; i++) {\n          // An `undefined` element is `null` by the time it reaches the wire,\n          // because that is what JSON.stringify makes of it. Dropping it\n          // instead would fold `[undefined]` onto `[]`.\n          const e: unknown = v[i];\n          visitValue(e === undefined ? null : e);\n        }\n        mix(TAG_END);\n        return;\n      }\n      mix(TAG_OBJ);\n      // Sorted, so the digest is a function of the object's contents and not\n      // of its key order. Rows and custom-query args round-trip through\n      // Postgres JSONB, which reorders keys; an order-sensitive digest made\n      // reloaded query records look changed. (The AST's own fields don't need\n      // this: visitAST reads them in a fixed order by name.)\n      const keys = Object.keys(v).sort();\n      for (const k of keys) {\n        const val = (v as Record<string, unknown>)[k];\n        if (val === undefined) {\n          continue; // as JSON.stringify does\n        }\n        mixString(k);\n        visitValue(val);\n      }\n      mix(TAG_END);\n      return;\n    }\n    default:\n      // `undefined` and functions as an object's value: dropped, as\n      // JSON.stringify drops them. Array elements are handled above.\n      return;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// The specialized part: the AST's own shape.\n// ---------------------------------------------------------------------------\n\nfunction visitOptionalString(s: string | undefined): void {\n  if (s === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mixString(s);\n  }\n}\n\nfunction mixOptionalSystem(system: System | undefined): void {\n  if (system === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mixSystem(system);\n  }\n}\n\nfunction mixSystem(system: System): void {\n  switch (system) {\n    case 'permissions':\n      mix(TAG_SYSTEM_PERMISSIONS);\n      break;\n    case 'client':\n      mix(TAG_SYSTEM_CLIENT);\n      break;\n    case 'test':\n      mix(TAG_SYSTEM_TEST);\n      break;\n    default:\n      unreachable(system);\n  }\n}\n\nfunction visitCompoundKey(k: readonly string[]): void {\n  mix(k.length);\n  for (let i = 0; i < k.length; i++) {\n    mixString(k[i]);\n  }\n}\n\nfunction visitOrdering(o: Ordering | undefined): void {\n  if (o === undefined) {\n    mix(TAG_UNDEF);\n    return;\n  }\n  mix(o.length);\n  for (let i = 0; i < o.length; i++) {\n    const [field, dir] = o[i];\n    mixString(field);\n    mix(dir === 'asc' ? TAG_TRUE : TAG_FALSE);\n  }\n}\n\nfunction visitValuePosition(v: ValuePosition): void {\n  switch (v.type) {\n    case 'literal':\n      mix(TAG_LITERAL);\n      visitValue(v.value);\n      return;\n    case 'column':\n      mix(TAG_COLUMN);\n      mixString(v.name);\n      return;\n    case 'static': {\n      mix(TAG_STATIC);\n      mixString(v.anchor);\n      if (typeof v.field === 'string') {\n        mixString(v.field);\n      } else {\n        visitCompoundKey(v.field);\n      }\n      return;\n    }\n    case 'json':\n      // The wrapped column, then the path as a value: a string segment and a\n      // numeric one are tagged differently there, so `['0']` and `[0]` (an\n      // object key and an array index) never fold together.\n      mix(TAG_JSON);\n      visitValuePosition(v.value);\n      visitValue(v.path);\n      return;\n    default:\n      unreachable(v);\n  }\n}\n\nfunction visitCondition(c: Condition): void {\n  switch (c.type) {\n    case 'simple':\n      mix(TAG_SIMPLE);\n      mixString(c.op);\n      visitValuePosition(c.left);\n      visitValuePosition(c.right);\n      return;\n    case 'correlatedSubquery':\n      mix(TAG_SUBQUERY);\n      mixString(c.op);\n      mix(c.flip === undefined ? TAG_UNDEF : c.flip ? TAG_TRUE : TAG_FALSE);\n      mix(c.scalar === undefined ? TAG_UNDEF : c.scalar ? TAG_TRUE : TAG_FALSE);\n      visitCorrelatedSubquery(c.related);\n      return;\n    default: {\n      c.type satisfies 'and' | 'or';\n      mix(c.type === 'and' ? TAG_AND : TAG_OR);\n      const conds = c.conditions;\n      mix(conds.length);\n      for (let i = 0; i < conds.length; i++) {\n        visitCondition(conds[i]);\n      }\n      return;\n    }\n  }\n}\n\nfunction visitCorrelatedSubquery(csq: CorrelatedSubquery): void {\n  visitCompoundKey(csq.correlation.parentField);\n  visitCompoundKey(csq.correlation.childField);\n  mix(csq.hidden === undefined ? TAG_UNDEF : csq.hidden ? TAG_TRUE : TAG_FALSE);\n  mixOptionalSystem(csq.system);\n  // Before the subquery, whose first word is TAG_OBJ, so an absent aggregate\n  // (which writes nothing) is never confusable with a present one.\n  visitAggregate(csq.aggregate);\n  visitAST(csq.subquery);\n}\n\n/**\n * An absent aggregate writes nothing, unlike the other optionals, so that the\n * hash of every query without one is unchanged by the field's addition. That\n * is unambiguous because of where it is written: an aggregate is always\n * followed by a word no aggregate could begin with (TAG_END on an AST, TAG_OBJ\n * on a correlated subquery), and a present one leads with its own tag.\n */\nfunction visitAggregate(aggregate: Aggregate | undefined): void {\n  if (aggregate === undefined) {\n    return;\n  }\n  mix(TAG_AGGREGATE);\n  mixString(aggregate.fn);\n  visitOptionalString(aggregate.field);\n  // Like the aggregate itself, an absent path writes nothing, so aggregates\n  // without one hash as before; a present one leads with TAG_JSON, which no\n  // following word (TAG_END, TAG_OBJ) can be confused with.\n  if (aggregate.path !== undefined) {\n    mix(TAG_JSON);\n    visitValue(aggregate.path);\n  }\n  // Absent, it writes nothing too.\n  if (aggregate.distinct !== undefined) {\n    mix(TAG_DISTINCT);\n    mix(aggregate.distinct.length);\n    for (const col of aggregate.distinct) {\n      mixString(col);\n    }\n  }\n}\n\nfunction visitAST(ast: AST): void {\n  mix(TAG_OBJ);\n  visitOptionalString(ast.schema);\n  mixString(ast.table);\n  visitOptionalString(ast.alias);\n\n  if (ast.where === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    visitCondition(ast.where);\n  }\n\n  const related = ast.related;\n  if (related === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mix(related.length);\n    for (let i = 0; i < related.length; i++) {\n      visitCorrelatedSubquery(related[i]);\n    }\n  }\n\n  const start = ast.start;\n  if (start === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mix(start.exclusive ? TAG_TRUE : TAG_FALSE);\n    visitValue(start.row);\n  }\n\n  if (ast.limit === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    // Tagged, because this is the one optional field whose present and absent\n    // forms would otherwise both write a single bare word: an untagged\n    // `limit: 4106` is the same word as TAG_UNDEF. The other optionals are\n    // safe -- a present string carries STR_MARK, a condition or bound leads\n    // with its own kind tag, and `related`/`orderBy` write a count followed by\n    // that many items, so their streams diverge straight after.\n    mix(TAG_INT);\n    mixNumber(ast.limit);\n  }\n\n  visitOrdering(ast.orderBy);\n  visitAggregate(ast.aggregate);\n  // Like the aggregate, an absent groupBy writes nothing, so other queries\n  // hash as before.\n  if (ast.groupBy !== undefined) {\n    mix(TAG_GROUP_BY);\n    mix(ast.groupBy.length);\n    for (const col of ast.groupBy) {\n      mixString(col);\n    }\n  }\n  mix(TAG_END);\n}\n\nexport function hashAST(ast: AST): string {\n  // Save and restore the lanes: `visitValue` reads properties of arbitrary\n  // runtime objects, and a getter is free to ask for another hash mid-walk.\n  // Without this, the inner call's reset() would corrupt the outer digest.\n  const s1 = h1;\n  const s2 = h2;\n  try {\n    reset();\n    visitAST(ast);\n    return finalize();\n  } finally {\n    h1 = s1;\n    h2 = s2;\n  }\n}\n\n/**\n * The identity of a custom query: its name and its arguments.\n *\n * Same walk, entered at a different node. `args` is arbitrary JSON, which is\n * what `visitValue` already exists to handle. The leading tag keeps this hash\n * space disjoint from `hashAST`'s -- both produce query IDs that live in the\n * same namespace, so an AST must not be able to fold to the same words as some\n * name and args.\n */\nexport function hashNameAndArgs(\n  name: string,\n  args: readonly unknown[],\n): string {\n  const s1 = h1;\n  const s2 = h2;\n  try {\n    reset();\n    mix(TAG_NAME_ARGS);\n    mixString(name);\n    visitValue(args);\n    return finalize();\n  } finally {\n    h1 = s1;\n    h2 = s2;\n  }\n}\n\n/**\n * The identity of a query as the client sees it: its AST, the shape it returns,\n * the system it was built for, and -- for a custom query -- the name and\n * arguments it was declared with.\n *\n * Everything past the AST is here because it is part of what makes two queries\n * different while leaving no trace, or an incomplete one, in the AST itself:\n *\n * - **name and args**: `nameAndArgs` reuses the AST it is given and only\n *   attaches a `CustomQueryID`, so without these two different named queries\n *   over the same table would be indistinguishable.\n * - **system**: a query stamps it onto every `related` entry and every `exists`\n *   correlation it builds, so it is already hashed via\n *   {@link visitCorrelatedSubquery} -- but a query with neither has nowhere to\n *   put it, and would otherwise hash the same whether it was built for the\n *   client or for permissions.\n * - **currentJunction**: builder state, set on the sub-query handed to a\n *   two-hop relationship's callback, which makes `limit` and `orderBy` throw.\n *   It leaves no trace in the AST at all, so two queries that differ only in\n *   whether those methods work would otherwise be indistinguishable.\n *\n * The name and args are taken apart rather than as a `CustomQueryID` because\n * that type lives in `zql`, which is above this package; `hashNameAndArgs`\n * splits them the same way.\n */\nexport function hashOfQueryInternals(\n  ast: AST,\n  format: Format,\n  system: System,\n  currentJunction: string | undefined,\n  customQueryName: string | undefined,\n  customQueryArgs: readonly unknown[] | undefined,\n): string {\n  const s1 = h1;\n  const s2 = h2;\n  try {\n    reset();\n    visitAST(ast);\n    mix(TAG_FORMAT);\n    visitValue(format);\n    mixSystem(system);\n    if (currentJunction === undefined) {\n      mix(TAG_UNDEF);\n    } else {\n      mix(TAG_JUNCTION);\n      mixString(currentJunction);\n    }\n    if (customQueryName === undefined) {\n      mix(TAG_UNDEF);\n    } else {\n      mix(TAG_NAME_ARGS);\n      mixString(customQueryName);\n      visitValue(customQueryArgs);\n    }\n    return finalize();\n  } finally {\n    h1 = s1;\n    h2 = s2;\n  }\n}\n"],"mappings":"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"}

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

@@ -1,6 +1,6 @@
 import { getOrInsertComputed } from "../../shared/src/map.js";
 import { normalizeAST } from "./ast.js";
-import { hashAST } from "./query-hash-visitor.js";
+import { hashAST, hashNameAndArgs } from "./query-hash-visitor.js";
 //#region ../zero-protocol/src/query-hash.ts
 var hashCache = /* @__PURE__ */ new WeakMap();
 function hashOfAST(ast) {
@@ -14,6 +14,6 @@ function hashOfNormalizedAST(ast) {
 	return getOrInsertComputed(hashCache, ast, hashAST);
 }
 //#endregion
-export { hashOfAST };
+export { hashOfAST, hashNameAndArgs as hashOfNameAndArgs, hashOfNormalizedAST };
 
 //# sourceMappingURL=query-hash.js.map

package/out/zero-protocol/src/query-server.d.ts

@@ -1,23 +1,5 @@
 import * as v from '../../shared/src/valita.ts';
-export declare const queryResultSchema: v.UnionType<[v.ObjectType<{
-    id: v.Type<string>;
-    name: v.Type<string>;
-    ast: v.Type<import("./ast.ts").AST>;
-}, undefined>, v.UnionType<[v.ObjectType<{
-    error: v.Type<"app">;
-    id: v.Type<string>;
-    name: v.Type<string>;
-    message: v.Optional<string>;
-    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-}, undefined>, v.ObjectType<{
-    error: v.Type<"parse">;
-    id: v.Type<string>;
-    name: v.Type<string>;
-    message: v.Type<string>;
-    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-}, undefined>]>]>;
-export type QueryResult = v.Infer<typeof queryResultSchema>;
-export declare const queryResponseBodySchema: v.ArrayType<v.UnionType<[v.ObjectType<{
+declare const queryResponseBodySchema: v.ArrayType<v.UnionType<[v.ObjectType<{
     id: v.Type<string>;
     name: v.Type<string>;
     ast: v.Type<import("./ast.ts").AST>;
@@ -35,28 +17,6 @@ export declare const queryResponseBodySchema: v.ArrayType<v.UnionType<[v.ObjectT
     details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>]>]>>;
 export type QueryResponseBody = v.Infer<typeof queryResponseBodySchema>;
-export declare const querySuccessSchema: v.ObjectType<{
-    kind: v.Type<"QueryResponse">;
-    userID: v.Optional<string | null>;
-    queries: v.ArrayType<v.UnionType<[v.ObjectType<{
-        id: v.Type<string>;
-        name: v.Type<string>;
-        ast: v.Type<import("./ast.ts").AST>;
-    }, undefined>, v.UnionType<[v.ObjectType<{
-        error: v.Type<"app">;
-        id: v.Type<string>;
-        name: v.Type<string>;
-        message: v.Optional<string>;
-        details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-    }, undefined>, v.ObjectType<{
-        error: v.Type<"parse">;
-        id: v.Type<string>;
-        name: v.Type<string>;
-        message: v.Type<string>;
-        details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-    }, undefined>]>]>>;
-}, undefined>;
-export type QuerySuccess = v.Infer<typeof querySuccessSchema>;
 export declare const queryResponseSchema: v.UnionType<[v.ObjectType<{
     kind: v.Type<"QueryResponse">;
     userID: v.Optional<string | null>;
@@ -147,4 +107,5 @@ export declare const queryResponseSchema: v.UnionType<[v.ObjectType<{
     reason: v.Type<"internal" | "parse" | "timeout">;
 }, undefined>]>]>]>]>;
 export type QueryResponse = v.Infer<typeof queryResponseSchema>;
+export {};
 //# sourceMappingURL=query-server.d.ts.map

package/out/zero-protocol/src/query-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-server.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/query-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAQhD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;iBAG7B,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;kBAA6B,CAAC;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;aAI7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAK/B,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}
+{"version":3,"file":"query-server.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/query-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAUhD,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;kBAA6B,CAAC;AAC3D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAQxE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAK/B,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

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

@@ -1 +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"}
+{"version":3,"file":"query-server.js","names":["v"],"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\nconst queryResultSchema = v.union(transformedQuerySchema, erroredQuerySchema);\n\nconst queryResponseBodySchema = v.array(queryResultSchema);\nexport type QueryResponseBody = v.Infer<typeof queryResponseBodySchema>;\n\nconst querySuccessSchema = v.object({\n  kind: v.literal('QueryResponse'),\n  userID: v.string().nullable().optional(),\n  queries: queryResponseBodySchema,\n});\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,IAAM,oBAAoBA,eAAE,MAAM,wBAAwB,kBAAkB;AAE5E,IAAM,0BAA0BA,eAAE,MAAM,iBAAiB;AAGzD,IAAM,qBAAqBA,eAAE,OAAO;CAClC,MAAMA,eAAE,QAAQ,eAAe;CAC/B,QAAQA,eAAE,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;CACvC,SAAS;AACX,CAAC;AAED,IAAa,sBAAsBA,eAAE,MACnC,oBACA,2BAEA,8BACF"}

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

@@ -1 +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"}
+{"version":3,"file":"row-patch.js","names":["v"],"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,cAAcA,eAAE,OAAO;CAC3B,IAAIA,eAAE,QAAQ,KAAK;CACnB,WAAWA,eAAE,OAAO;CACpB,OAAO;AACT,CAAC;AAED,IAAM,iBAAiBA,eAAE,OAAO;CAC9B,IAAIA,eAAE,QAAQ,QAAQ;CACtB,WAAWA,eAAE,OAAO;CACpB,IAAI;CACJ,OAAO,iBAAiB,SAAS;CACjC,WAAWA,eAAE,MAAMA,eAAE,OAAO,CAAC,CAAC,CAAC,SAAS;AAC1C,CAAC;AAED,IAAM,cAAcA,eAAE,OAAO;CAC3B,IAAIA,eAAE,QAAQ,KAAK;CACnB,WAAWA,eAAE,OAAO;CACpB,IAAI;AACN,CAAC;AAED,IAAM,gBAAgBA,eAAE,OAAO,EAC7B,IAAIA,eAAE,QAAQ,OAAO,EACvB,CAAC;AAED,IAAM,mBAAmBA,eAAE,MACzB,aACA,gBACA,aACA,aACF;AAEA,IAAa,kBAAkBA,eAAE,MAAM,gBAAgB"}