@rocicorp/zero 1.12.0-canary.8 → 1.12.0-canary.9

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

@@ -1,25 +1,4 @@
 import * as v from '../../shared/src/valita.ts';
-export declare const mutateSuccessSchema: v.ObjectType<{
-    kind: v.Type<"MutateResponse">;
-    userID: v.Optional<string | null>;
-    mutations: v.ArrayType<v.ObjectType<{
-        id: v.ObjectType<{
-            id: v.Type<number>;
-            clientID: v.Type<string>;
-        }, undefined>;
-        result: v.UnionType<[v.ObjectType<{
-            data: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-        }, undefined>, v.UnionType<[v.ObjectType<{
-            error: v.Type<"app">;
-            message: v.Optional<string>;
-            details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-        }, undefined>, v.ObjectType<{
-            error: v.UnionType<[v.Type<"oooMutation">, v.Type<"alreadyProcessed">]>;
-            details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-        }, undefined>]>]>;
-    }, undefined>>;
-}, undefined>;
-export type MutateSuccess = v.Infer<typeof mutateSuccessSchema>;
 export declare const mutateResponseSchema: v.UnionType<[v.ObjectType<{
     kind: v.Type<"MutateResponse">;
     userID: v.Optional<string | null>;

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

@@ -1 +1 @@
-{"version":3,"file":"mutate-server.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/mutate-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAehD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;aAI9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAKhC,CAAC;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;aAG7B,CAAC"}
+{"version":3,"file":"mutate-server.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/mutate-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAqBhD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAKhC,CAAC;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;aAG7B,CAAC"}

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

@@ -19,6 +19,6 @@ var mutateParamsSchema = valita_exports.object({
 	appID: valita_exports.string()
 });
 //#endregion
-export { mutateParamsSchema, mutateResponseSchema, mutateSuccessSchema };
+export { mutateParamsSchema, mutateResponseSchema };
 
 //# sourceMappingURL=mutate-server.js.map

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

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

package/out/zero-protocol/src/mutation-type-enum.d.ts

@@ -1,6 +1,5 @@
 export declare const CRUD = "crud";
 export declare const Custom = "custom";
-export type MutationType = typeof CRUD | typeof Custom;
 export type CRUD = typeof CRUD;
 export type Custom = typeof Custom;
 //# sourceMappingURL=mutation-type-enum.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mutation-type-enum.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/mutation-type-enum.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,SAAS,CAAC;AAC3B,eAAO,MAAM,MAAM,WAAW,CAAC;AAC/B,MAAM,MAAM,YAAY,GAAG,OAAO,IAAI,GAAG,OAAO,MAAM,CAAC;AAEvD,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC;AAC/B,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC"}
+{"version":3,"file":"mutation-type-enum.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/mutation-type-enum.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,SAAS,CAAC;AAC3B,eAAO,MAAM,MAAM,WAAW,CAAC;AAE/B,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC;AAC/B,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC"}

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

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

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

@@ -97,7 +97,7 @@ declare const crudArgSchema: v.ObjectType<{
         value: v.Type<Readonly<Record<string, string | number | boolean>>>;
     }, undefined>]>>;
 }, undefined>;
-export declare const crudMutationSchema: v.ObjectType<{
+declare const crudMutationSchema: v.ObjectType<{
     type: v.Type<"crud">;
     id: v.Type<number>;
     clientID: v.Type<string>;
@@ -127,7 +127,7 @@ export declare const crudMutationSchema: v.ObjectType<{
     }, undefined>]>;
     timestamp: v.Type<number>;
 }, undefined>;
-export declare const customMutationSchema: v.ObjectType<{
+declare const customMutationSchema: v.ObjectType<{
     type: v.Type<"custom">;
     id: v.Type<number>;
     clientID: v.Type<string>;
@@ -214,12 +214,10 @@ export type UpsertOp = v.Infer<typeof upsertOpSchema>;
 export type UpdateOp = v.Infer<typeof updateOpSchema>;
 export type DeleteOp = v.Infer<typeof deleteOpSchema>;
 export type CRUDOp = v.Infer<typeof crudOpSchema>;
-export type CRUDOpKind = CRUDOp['op'];
 export type CRUDMutationArg = v.Infer<typeof crudArgSchema>;
 export type CRUDMutation = v.Infer<typeof crudMutationSchema>;
 export type CustomMutation = v.Infer<typeof customMutationSchema>;
 export type Mutation = v.Infer<typeof mutationSchema>;
-export type MutationResponse = v.Infer<typeof mutationResponseSchema>;
 export type MutationOk = v.Infer<typeof mutationOkSchema>;
 export type MutationError = v.Infer<typeof mutationErrorSchema>;
 export type MutationResult = v.Infer<typeof mutationResultSchema>;

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

@@ -1 +1 @@
-{"version":3,"file":"mutation.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/mutation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAChD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,qCAAqC,CAAC;AASpE,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAK/C,eAAO,MAAM,6BAA6B,yBAAyB,CAAC;AAEpE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;eAqBnC,CAAC;AAEF;;GAEG;AACH,QAAA,MAAM,cAAc;;;;;aAKlB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,cAAc;;;;;aAKlB,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,cAAc;;;;;aAMlB,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,cAAc;;;;;aAMlB,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;eAKjB,CAAC;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;aAEjB,CAAC;AAIH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAO7B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;aAO/B,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAoD,CAAC;AAiBhF,QAAA,MAAM,gBAAgB;;aAGpB,CAAC;AACH,QAAA,MAAM,mBAAmB;;;;;;;eAA2C,CAAC;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;iBAGhC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;aAGjC,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;AACtC,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC5D,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;AAClE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,wBAAgB,OAAO,CACrB,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,UAAU,GACd,eAAe,CAcjB"}
+{"version":3,"file":"mutation.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/mutation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAChD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,qCAAqC,CAAC;AASpE,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAK/C,eAAO,MAAM,6BAA6B,yBAAyB,CAAC;AAEpE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;eAqBnC,CAAC;AAEF;;GAEG;AACH,QAAA,MAAM,cAAc;;;;;aAKlB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,cAAc;;;;;aAKlB,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,cAAc;;;;;aAMlB,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,cAAc;;;;;aAMlB,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;eAKjB,CAAC;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;aAEjB,CAAC;AAIH,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAOtB,CAAC;AAEH,QAAA,MAAM,oBAAoB;;;;;;;aAOxB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAoD,CAAC;AAiBhF,QAAA,MAAM,gBAAgB;;aAGpB,CAAC;AACH,QAAA,MAAM,mBAAmB;;;;;;;eAA2C,CAAC;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;iBAGhC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;aAGjC,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC5D,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;AAClE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,wBAAgB,OAAO,CACrB,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,UAAU,GACd,eAAe,CAcjB"}

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

@@ -107,6 +107,6 @@ function mapCRUD(arg, map) {
 	})) };
 }
 //#endregion
-export { CLEANUP_RESULTS_MUTATION_NAME, CRUD_MUTATION_NAME, cleanupResultsArgSchema, crudMutationSchema, customMutationSchema, mapCRUD, mutationResponseSchema, mutationResultSchema, mutationSchema };
+export { CLEANUP_RESULTS_MUTATION_NAME, CRUD_MUTATION_NAME, cleanupResultsArgSchema, mapCRUD, mutationResponseSchema, mutationResultSchema, mutationSchema };
 
 //# sourceMappingURL=mutation.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"mutation.js","names":["v","MutationType.CRUD","MutationType.Custom"],"sources":["../../../../zero-protocol/src/mutation.ts"],"sourcesContent":["import {jsonSchema} from '../../shared/src/json-schema.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport type {NameMapper} from '../../zero-types/src/name-mapper.ts';\nimport {rowSchema} from './data.ts';\nimport {mutationIDSchema} from './mutation-id.ts';\nimport * as MutationType from './mutation-type-enum.ts';\nimport {primaryKeySchema, primaryKeyValueRecordSchema} from './primary-key.ts';\n\n// NOTE! If you change this name you must also change the\n// string in `replicache-impl.ts` But CRUD mutators are being\n// deleted soon so this should not happen.\nexport const CRUD_MUTATION_NAME = '_zero_crud';\n\n// Internal mutation name for cleaning up mutation results.\n// This mutation is sent from zero-cache to zero-server to delete\n// acknowledged mutation results from the upstream database.\nexport const CLEANUP_RESULTS_MUTATION_NAME = '_zero_cleanupResults';\n\nexport const cleanupResultsArgSchema = v.union(\n  // Legacy format (no type field) - treat as single\n  v.object({\n    clientGroupID: v.string(),\n    clientID: v.string(),\n    upToMutationID: v.number(),\n  }),\n  // Explicit single: delete up to a specific mutation ID for one client\n  v.object({\n    type: v.literal('single'),\n    clientGroupID: v.string(),\n    clientID: v.string(),\n    upToMutationID: v.number(),\n  }),\n  // Bulk: delete all mutations for multiple clients\n  v.object({\n    type: v.literal('bulk'),\n    clientGroupID: v.string(),\n    // oxlint-disable-next-line e18e/prefer-spread-syntax\n    clientIDs: v.tuple([v.string()]).concat(v.array(v.string())),\n  }),\n);\n\n/**\n * Inserts if entity with id does not already exist.\n */\nconst insertOpSchema = v.object({\n  op: v.literal('insert'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  value: rowSchema,\n});\n\n/**\n * Upsert semantics. Inserts if entity with id does not already exist,\n * otherwise updates existing entity with id.\n */\nconst upsertOpSchema = v.object({\n  op: v.literal('upsert'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  value: rowSchema,\n});\n\n/**\n * Updates if entity with id exists, otherwise does nothing.\n */\nconst updateOpSchema = v.object({\n  op: v.literal('update'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  // Partial value with at least the primary key fields\n  value: rowSchema,\n});\n\n/**\n * Deletes entity with id if it exists, otherwise does nothing.\n */\nconst deleteOpSchema = v.object({\n  op: v.literal('delete'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  // Partial value representing the primary key\n  value: primaryKeyValueRecordSchema,\n});\n\nconst crudOpSchema = v.union(\n  insertOpSchema,\n  upsertOpSchema,\n  updateOpSchema,\n  deleteOpSchema,\n);\n\nconst crudArgSchema = v.object({\n  ops: v.array(crudOpSchema),\n});\n\nconst crudArgsSchema = v.tuple([crudArgSchema]);\n\nexport const crudMutationSchema = v.object({\n  type: v.literal(MutationType.CRUD),\n  id: v.number(),\n  clientID: v.string(),\n  name: v.literal(CRUD_MUTATION_NAME),\n  args: crudArgsSchema,\n  timestamp: v.number(),\n});\n\nexport const customMutationSchema = v.object({\n  type: v.literal(MutationType.Custom),\n  id: v.number(),\n  clientID: v.string(),\n  name: v.string(),\n  args: v.array(jsonSchema),\n  timestamp: v.number(),\n});\n\nexport const mutationSchema = v.union(crudMutationSchema, customMutationSchema);\n\nconst appErrorSchema = v.object({\n  error: v.literal('app'),\n  // The user can return any additional data here\n  message: v.string().optional(),\n  details: jsonSchema.optional(),\n});\nconst zeroErrorSchema = v.object({\n  error: v.union(\n    /** @deprecated push oooMutation errors are now represented as ['error', { ... }] messages */\n    v.literal('oooMutation'),\n    v.literal('alreadyProcessed'),\n  ),\n  details: jsonSchema.optional(),\n});\n\nconst mutationOkSchema = v.object({\n  // The user can return any additional data here\n  data: jsonSchema.optional(),\n});\nconst mutationErrorSchema = v.union(appErrorSchema, zeroErrorSchema);\n\nexport const mutationResultSchema = v.union(\n  mutationOkSchema,\n  mutationErrorSchema,\n);\n\nexport const mutationResponseSchema = v.object({\n  id: mutationIDSchema,\n  result: mutationResultSchema,\n});\n\nexport type InsertOp = v.Infer<typeof insertOpSchema>;\nexport type UpsertOp = v.Infer<typeof upsertOpSchema>;\nexport type UpdateOp = v.Infer<typeof updateOpSchema>;\nexport type DeleteOp = v.Infer<typeof deleteOpSchema>;\nexport type CRUDOp = v.Infer<typeof crudOpSchema>;\nexport type CRUDOpKind = CRUDOp['op'];\nexport type CRUDMutationArg = v.Infer<typeof crudArgSchema>;\nexport type CRUDMutation = v.Infer<typeof crudMutationSchema>;\nexport type CustomMutation = v.Infer<typeof customMutationSchema>;\nexport type Mutation = v.Infer<typeof mutationSchema>;\n\nexport type MutationResponse = v.Infer<typeof mutationResponseSchema>;\nexport type MutationOk = v.Infer<typeof mutationOkSchema>;\nexport type MutationError = v.Infer<typeof mutationErrorSchema>;\nexport type MutationResult = v.Infer<typeof mutationResultSchema>;\nexport type CleanupResultsArg = v.Infer<typeof cleanupResultsArgSchema>;\n\nexport function mapCRUD(\n  arg: CRUDMutationArg,\n  map: NameMapper,\n): CRUDMutationArg {\n  return {\n    ops: arg.ops.map(\n      ({op, tableName, primaryKey, value}) =>\n        ({\n          op,\n          tableName: map.tableName(tableName),\n          primaryKey: map.columns(tableName, primaryKey),\n          value: map.row(tableName, value),\n          // The cast is necessary because ts objects to the `value` field\n          // for \"delete\" ops being different.\n        }) as unknown as CRUDOp,\n    ),\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"mutation.js","names":["v","MutationType.CRUD","MutationType.Custom"],"sources":["../../../../zero-protocol/src/mutation.ts"],"sourcesContent":["import {jsonSchema} from '../../shared/src/json-schema.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport type {NameMapper} from '../../zero-types/src/name-mapper.ts';\nimport {rowSchema} from './data.ts';\nimport {mutationIDSchema} from './mutation-id.ts';\nimport * as MutationType from './mutation-type-enum.ts';\nimport {primaryKeySchema, primaryKeyValueRecordSchema} from './primary-key.ts';\n\n// NOTE! If you change this name you must also change the\n// string in `replicache-impl.ts` But CRUD mutators are being\n// deleted soon so this should not happen.\nexport const CRUD_MUTATION_NAME = '_zero_crud';\n\n// Internal mutation name for cleaning up mutation results.\n// This mutation is sent from zero-cache to zero-server to delete\n// acknowledged mutation results from the upstream database.\nexport const CLEANUP_RESULTS_MUTATION_NAME = '_zero_cleanupResults';\n\nexport const cleanupResultsArgSchema = v.union(\n  // Legacy format (no type field) - treat as single\n  v.object({\n    clientGroupID: v.string(),\n    clientID: v.string(),\n    upToMutationID: v.number(),\n  }),\n  // Explicit single: delete up to a specific mutation ID for one client\n  v.object({\n    type: v.literal('single'),\n    clientGroupID: v.string(),\n    clientID: v.string(),\n    upToMutationID: v.number(),\n  }),\n  // Bulk: delete all mutations for multiple clients\n  v.object({\n    type: v.literal('bulk'),\n    clientGroupID: v.string(),\n    // oxlint-disable-next-line e18e/prefer-spread-syntax\n    clientIDs: v.tuple([v.string()]).concat(v.array(v.string())),\n  }),\n);\n\n/**\n * Inserts if entity with id does not already exist.\n */\nconst insertOpSchema = v.object({\n  op: v.literal('insert'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  value: rowSchema,\n});\n\n/**\n * Upsert semantics. Inserts if entity with id does not already exist,\n * otherwise updates existing entity with id.\n */\nconst upsertOpSchema = v.object({\n  op: v.literal('upsert'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  value: rowSchema,\n});\n\n/**\n * Updates if entity with id exists, otherwise does nothing.\n */\nconst updateOpSchema = v.object({\n  op: v.literal('update'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  // Partial value with at least the primary key fields\n  value: rowSchema,\n});\n\n/**\n * Deletes entity with id if it exists, otherwise does nothing.\n */\nconst deleteOpSchema = v.object({\n  op: v.literal('delete'),\n  tableName: v.string(),\n  primaryKey: primaryKeySchema,\n  // Partial value representing the primary key\n  value: primaryKeyValueRecordSchema,\n});\n\nconst crudOpSchema = v.union(\n  insertOpSchema,\n  upsertOpSchema,\n  updateOpSchema,\n  deleteOpSchema,\n);\n\nconst crudArgSchema = v.object({\n  ops: v.array(crudOpSchema),\n});\n\nconst crudArgsSchema = v.tuple([crudArgSchema]);\n\nconst crudMutationSchema = v.object({\n  type: v.literal(MutationType.CRUD),\n  id: v.number(),\n  clientID: v.string(),\n  name: v.literal(CRUD_MUTATION_NAME),\n  args: crudArgsSchema,\n  timestamp: v.number(),\n});\n\nconst customMutationSchema = v.object({\n  type: v.literal(MutationType.Custom),\n  id: v.number(),\n  clientID: v.string(),\n  name: v.string(),\n  args: v.array(jsonSchema),\n  timestamp: v.number(),\n});\n\nexport const mutationSchema = v.union(crudMutationSchema, customMutationSchema);\n\nconst appErrorSchema = v.object({\n  error: v.literal('app'),\n  // The user can return any additional data here\n  message: v.string().optional(),\n  details: jsonSchema.optional(),\n});\nconst zeroErrorSchema = v.object({\n  error: v.union(\n    /** @deprecated push oooMutation errors are now represented as ['error', { ... }] messages */\n    v.literal('oooMutation'),\n    v.literal('alreadyProcessed'),\n  ),\n  details: jsonSchema.optional(),\n});\n\nconst mutationOkSchema = v.object({\n  // The user can return any additional data here\n  data: jsonSchema.optional(),\n});\nconst mutationErrorSchema = v.union(appErrorSchema, zeroErrorSchema);\n\nexport const mutationResultSchema = v.union(\n  mutationOkSchema,\n  mutationErrorSchema,\n);\n\nexport const mutationResponseSchema = v.object({\n  id: mutationIDSchema,\n  result: mutationResultSchema,\n});\n\nexport type InsertOp = v.Infer<typeof insertOpSchema>;\nexport type UpsertOp = v.Infer<typeof upsertOpSchema>;\nexport type UpdateOp = v.Infer<typeof updateOpSchema>;\nexport type DeleteOp = v.Infer<typeof deleteOpSchema>;\nexport type CRUDOp = v.Infer<typeof crudOpSchema>;\nexport type CRUDMutationArg = v.Infer<typeof crudArgSchema>;\nexport type CRUDMutation = v.Infer<typeof crudMutationSchema>;\nexport type CustomMutation = v.Infer<typeof customMutationSchema>;\nexport type Mutation = v.Infer<typeof mutationSchema>;\n\nexport type MutationOk = v.Infer<typeof mutationOkSchema>;\nexport type MutationError = v.Infer<typeof mutationErrorSchema>;\nexport type MutationResult = v.Infer<typeof mutationResultSchema>;\nexport type CleanupResultsArg = v.Infer<typeof cleanupResultsArgSchema>;\n\nexport function mapCRUD(\n  arg: CRUDMutationArg,\n  map: NameMapper,\n): CRUDMutationArg {\n  return {\n    ops: arg.ops.map(\n      ({op, tableName, primaryKey, value}) =>\n        ({\n          op,\n          tableName: map.tableName(tableName),\n          primaryKey: map.columns(tableName, primaryKey),\n          value: map.row(tableName, value),\n          // The cast is necessary because ts objects to the `value` field\n          // for \"delete\" ops being different.\n        }) as unknown as CRUDOp,\n    ),\n  };\n}\n"],"mappings":"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"}

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

@@ -1,37 +1,4 @@
 import * as v from '../../shared/src/valita.ts';
-/**
- * Mutation results are stored ephemerally in the client
- * hence why we only have the `put` operation.
- *
- * On put the mutation promise is resolved/rejected
- * and reference released.
- */
-export declare const putOpSchema: v.ObjectType<{
-    op: v.Type<"put">;
-    mutation: v.ObjectType<{
-        id: v.ObjectType<{
-            id: v.Type<number>;
-            clientID: v.Type<string>;
-        }, undefined>;
-        result: v.UnionType<[v.ObjectType<{
-            data: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-        }, undefined>, v.UnionType<[v.ObjectType<{
-            error: v.Type<"app">;
-            message: v.Optional<string>;
-            details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-        }, undefined>, v.ObjectType<{
-            error: v.UnionType<[v.Type<"oooMutation">, v.Type<"alreadyProcessed">]>;
-            details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-        }, undefined>]>]>;
-    }, undefined>;
-}, undefined>;
-export declare const delOpSchema: v.ObjectType<{
-    op: v.Type<"del">;
-    id: v.ObjectType<{
-        id: v.Type<number>;
-        clientID: v.Type<string>;
-    }, undefined>;
-}, undefined>;
 declare const patchOpSchema: v.UnionType<[v.ObjectType<{
     op: v.Type<"put">;
     mutation: v.ObjectType<{

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

@@ -1 +1 @@
-{"version":3,"file":"mutations-patch.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/mutations-patch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAIhD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;aAGtB,CAAC;AACH,eAAO,MAAM,WAAW;;;;;;aAGtB,CAAC;AAEH,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;eAAoC,CAAC;AACxD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;gBAAyB,CAAC;AAC3D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}
+{"version":3,"file":"mutations-patch.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/mutations-patch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAoBhD,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;eAAoC,CAAC;AACxD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;gBAAyB,CAAC;AAC3D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

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

@@ -20,6 +20,6 @@ var delOpSchema = valita_exports.object({
 var patchOpSchema = valita_exports.union(putOpSchema, delOpSchema);
 var mutationsPatchSchema = valita_exports.array(patchOpSchema);
 //#endregion
-export { delOpSchema, mutationsPatchSchema, putOpSchema };
+export { mutationsPatchSchema };
 
 //# sourceMappingURL=mutations-patch.js.map

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

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

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

@@ -1,6 +1,4 @@
 import * as v from '../../shared/src/valita.ts';
-export declare const pingBodySchema: v.ObjectType<{}, undefined>;
 export declare const pingMessageSchema: v.TupleType<[v.Type<"ping">, v.ObjectType<{}, undefined>]>;
-export type PingBody = v.Infer<typeof pingBodySchema>;
 export type PingMessage = v.Infer<typeof pingMessageSchema>;
 //# sourceMappingURL=ping.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ping.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/ping.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":"ping.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/ping.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/ping.js

@@ -3,6 +3,6 @@ import { valita_exports } from "../../shared/src/valita.js";
 var pingBodySchema = valita_exports.object({});
 var pingMessageSchema = valita_exports.tuple([valita_exports.literal("ping"), pingBodySchema]);
 //#endregion
-export { pingBodySchema, pingMessageSchema };
+export { pingMessageSchema };
 
 //# sourceMappingURL=ping.js.map

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

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

@@ -25,7 +25,7 @@ import * as v from '../../shared/src/valita.ts';
  * observed it is an unexpected error; the client should ignore both pokes,
  * disconnect, and reconnect.
  */
-export declare const pokeStartBodySchema: v.ObjectType<{
+declare const pokeStartBodySchema: v.ObjectType<{
     pokeID: v.Type<string>;
     baseCookie: v.UnionType<[v.Type<string>, v.Type<null>]>;
     /**
@@ -175,7 +175,7 @@ export declare const pokePartsSchema: v.ArrayType<v.ObjectType<{
     })[]>;
     pokeID: v.Type<string>;
 }, undefined>>;
-export declare const pokeEndBodySchema: v.ObjectType<{
+declare const pokeEndBodySchema: v.ObjectType<{
     pokeID: v.Type<string>;
     cookie: v.Type<string>;
     cancel: v.Optional<boolean>;
@@ -279,4 +279,5 @@ export type PokeChunk = Uint8Array;
 export type PokeStartMessage = v.Infer<typeof pokeStartMessageSchema>;
 export type PokePartMessage = v.Infer<typeof pokePartMessageSchema>;
 export type PokeEndMessage = v.Infer<typeof pokeEndMessageSchema>;
+export {};
 //# sourceMappingURL=poke.d.ts.map

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

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

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

@@ -66,6 +66,6 @@ var pokeStartMessageSchema = valita_exports.tuple([valita_exports.literal("pokeS
 var pokePartMessageSchema = valita_exports.tuple([valita_exports.literal("pokePart"), pokePartBodySchema]);
 var pokeEndMessageSchema = valita_exports.tuple([valita_exports.literal("pokeEnd"), pokeEndBodySchema]);
 //#endregion
-export { pokeEndBodySchema, pokeEndMessageSchema, pokePartBodySchema, pokePartMessageSchema, pokePartsSchema, pokeStartBodySchema, pokeStartMessageSchema };
+export { pokeEndMessageSchema, pokePartBodySchema, pokePartMessageSchema, pokePartsSchema, pokeStartMessageSchema };
 
 //# sourceMappingURL=poke.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"poke.js","names":["v"],"sources":["../../../../zero-protocol/src/poke.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {mutationsPatchSchema} from './mutations-patch.ts';\nimport {queriesPatchSchema} from './queries-patch.ts';\nimport {rowsPatchSchema} from './row-patch.ts';\nimport {nullableVersionSchema, versionSchema} from './version.ts';\n\n/**\n * Pokes use a multi-part format. Pokes send entity data to the client and can\n * be multiple mega-bytes in size. Using a multi-part format allows the server\n * to avoid having to have the full poke in memory at one time.\n *\n * Each poke is assigned a `pokeID`, a unique id (within the context of the\n * connection) for identifying the poke.  All messages for a poke will have the\n * same `pokeID`.\n *\n * A poke begins with a `poke-start` message which contains the `baseCookie`\n * the poke is updating from and the `cookie` the poke is updating to.\n *\n * Through protocol version 51, the poke continues with zero to many\n * `poke-part` JSON messages. Starting in version 52, it continues with zero to\n * many binary `pokeChunk` messages. Each binary message starts with a message\n * type byte. Concatenating and decoding the payload after that byte produces a\n * PokePartBody array. pokeChunk boundaries have no semantic meaning.\n *\n * Finally, the poke ends with a `poke-end` message. The decoded patches can\n * now be applied as a whole to update from `baseCookie` to `cookie`.\n *\n * Poke messages can be intermingled with other `down` messages, but cannot be\n * intermingled with poke messages for a different `pokeID`. If this is\n * observed it is an unexpected error; the client should ignore both pokes,\n * disconnect, and reconnect.\n */\n\nexport const pokeStartBodySchema = v.object({\n  pokeID: v.string(),\n  // We always specify a Version as our cookie, but Replicache starts clients\n  // with initial cookie `null`, before the first request. So we have to be\n  // able to send a base cookie with value `null` to match that state.\n  baseCookie: nullableVersionSchema,\n  /**\n   * This field is always set if the poke contains a `rowsPatch`.\n   * It may be absent for patches that only update clients and queries.\n   */\n  schemaVersions: v\n    .object({\n      minSupportedVersion: v.number(),\n      maxSupportedVersion: v.number(),\n    })\n    .optional(),\n  timestamp: v.number().optional(),\n});\n\nexport const pokePartBodySchema = v.object({\n  // Changes to last mutation id by client id.\n  lastMutationIDChanges: v.record(v.number()).optional(),\n  // Patches to the desired query sets by client id.\n  desiredQueriesPatches: v.record(queriesPatchSchema).optional(),\n  // Patches to the set of queries for which entities are sync'd in\n  // rowsPatch.\n  gotQueriesPatch: queriesPatchSchema.optional(),\n  // Patches to the rows set.\n  rowsPatch: rowsPatchSchema.optional(),\n  // Mutation results patch\n  mutationsPatch: mutationsPatchSchema.optional(),\n  pokeID: v.string(),\n});\n\n/**\n * The logical payload carried by binary poke chunks. Chunk boundaries are\n * arbitrary; concatenating and decoding all chunks for a poke produces this\n * array.\n */\nexport const pokePartsSchema = v.array(pokePartBodySchema);\n\nexport const pokeEndBodySchema = v.object({\n  pokeID: v.string(),\n  // Note: This should be ignored (and may be empty) if cancel === `true`.\n  cookie: versionSchema,\n  // If `true`, the poke with id `pokeID` should be discarded without\n  // applying it.\n  cancel: v.boolean().optional(),\n});\n\nexport const pokeStartMessageSchema = v.tuple([\n  v.literal('pokeStart'),\n  pokeStartBodySchema,\n]);\nexport const pokePartMessageSchema = v.tuple([\n  v.literal('pokePart'),\n  pokePartBodySchema,\n]);\nexport const pokeEndMessageSchema = v.tuple([\n  v.literal('pokeEnd'),\n  pokeEndBodySchema,\n]);\n\nexport type PokeStartBody = v.Infer<typeof pokeStartBodySchema>;\nexport type PokePartBody = v.Infer<typeof pokePartBodySchema>;\nexport type PokeParts = v.Infer<typeof pokePartsSchema>;\nexport type PokeEndBody = v.Infer<typeof pokeEndBodySchema>;\n\n/** The first byte identifying a binary WebSocket message as a poke chunk. */\nexport const POKE_CHUNK_MESSAGE_TYPE = 0x00;\n\n/** The first protocol version that receives binary poke chunks. */\nexport const POKE_CHUNK_PROTOCOL_VERSION = 52;\n\n/** The last protocol version that receives JSON pokePart messages. */\nexport const LAST_POKE_PART_PROTOCOL_VERSION = 51;\n\n/** A tagged binary poke chunk WebSocket message. */\nexport type PokeChunk = Uint8Array;\n\nexport type PokeStartMessage = v.Infer<typeof pokeStartMessageSchema>;\nexport type PokePartMessage = v.Infer<typeof pokePartMessageSchema>;\nexport type PokeEndMessage = v.Infer<typeof pokeEndMessageSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAa,sBAAsBA,eAAE,OAAO;CAC1C,QAAQA,eAAE,OAAO;CAIjB,YAAY;;;;;CAKZ,gBAAgBA,eACb,OAAO;EACN,qBAAqBA,eAAE,OAAO;EAC9B,qBAAqBA,eAAE,OAAO;CAChC,CAAC,CAAC,CACD,SAAS;CACZ,WAAWA,eAAE,OAAO,CAAC,CAAC,SAAS;AACjC,CAAC;AAED,IAAa,qBAAqBA,eAAE,OAAO;CAEzC,uBAAuBA,eAAE,OAAOA,eAAE,OAAO,CAAC,CAAC,CAAC,SAAS;CAErD,uBAAuBA,eAAE,OAAO,kBAAkB,CAAC,CAAC,SAAS;CAG7D,iBAAiB,mBAAmB,SAAS;CAE7C,WAAW,gBAAgB,SAAS;CAEpC,gBAAgB,qBAAqB,SAAS;CAC9C,QAAQA,eAAE,OAAO;AACnB,CAAC;;;;;;AAOD,IAAa,kBAAkBA,eAAE,MAAM,kBAAkB;AAEzD,IAAa,oBAAoBA,eAAE,OAAO;CACxC,QAAQA,eAAE,OAAO;CAEjB,QAAQ;CAGR,QAAQA,eAAE,QAAQ,CAAC,CAAC,SAAS;AAC/B,CAAC;AAED,IAAa,yBAAyBA,eAAE,MAAM,CAC5CA,eAAE,QAAQ,WAAW,GACrB,mBACF,CAAC;AACD,IAAa,wBAAwBA,eAAE,MAAM,CAC3CA,eAAE,QAAQ,UAAU,GACpB,kBACF,CAAC;AACD,IAAa,uBAAuBA,eAAE,MAAM,CAC1CA,eAAE,QAAQ,SAAS,GACnB,iBACF,CAAC"}
+{"version":3,"file":"poke.js","names":["v"],"sources":["../../../../zero-protocol/src/poke.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {mutationsPatchSchema} from './mutations-patch.ts';\nimport {queriesPatchSchema} from './queries-patch.ts';\nimport {rowsPatchSchema} from './row-patch.ts';\nimport {nullableVersionSchema, versionSchema} from './version.ts';\n\n/**\n * Pokes use a multi-part format. Pokes send entity data to the client and can\n * be multiple mega-bytes in size. Using a multi-part format allows the server\n * to avoid having to have the full poke in memory at one time.\n *\n * Each poke is assigned a `pokeID`, a unique id (within the context of the\n * connection) for identifying the poke.  All messages for a poke will have the\n * same `pokeID`.\n *\n * A poke begins with a `poke-start` message which contains the `baseCookie`\n * the poke is updating from and the `cookie` the poke is updating to.\n *\n * Through protocol version 51, the poke continues with zero to many\n * `poke-part` JSON messages. Starting in version 52, it continues with zero to\n * many binary `pokeChunk` messages. Each binary message starts with a message\n * type byte. Concatenating and decoding the payload after that byte produces a\n * PokePartBody array. pokeChunk boundaries have no semantic meaning.\n *\n * Finally, the poke ends with a `poke-end` message. The decoded patches can\n * now be applied as a whole to update from `baseCookie` to `cookie`.\n *\n * Poke messages can be intermingled with other `down` messages, but cannot be\n * intermingled with poke messages for a different `pokeID`. If this is\n * observed it is an unexpected error; the client should ignore both pokes,\n * disconnect, and reconnect.\n */\n\nconst pokeStartBodySchema = v.object({\n  pokeID: v.string(),\n  // We always specify a Version as our cookie, but Replicache starts clients\n  // with initial cookie `null`, before the first request. So we have to be\n  // able to send a base cookie with value `null` to match that state.\n  baseCookie: nullableVersionSchema,\n  /**\n   * This field is always set if the poke contains a `rowsPatch`.\n   * It may be absent for patches that only update clients and queries.\n   */\n  schemaVersions: v\n    .object({\n      minSupportedVersion: v.number(),\n      maxSupportedVersion: v.number(),\n    })\n    .optional(),\n  timestamp: v.number().optional(),\n});\n\nexport const pokePartBodySchema = v.object({\n  // Changes to last mutation id by client id.\n  lastMutationIDChanges: v.record(v.number()).optional(),\n  // Patches to the desired query sets by client id.\n  desiredQueriesPatches: v.record(queriesPatchSchema).optional(),\n  // Patches to the set of queries for which entities are sync'd in\n  // rowsPatch.\n  gotQueriesPatch: queriesPatchSchema.optional(),\n  // Patches to the rows set.\n  rowsPatch: rowsPatchSchema.optional(),\n  // Mutation results patch\n  mutationsPatch: mutationsPatchSchema.optional(),\n  pokeID: v.string(),\n});\n\n/**\n * The logical payload carried by binary poke chunks. Chunk boundaries are\n * arbitrary; concatenating and decoding all chunks for a poke produces this\n * array.\n */\nexport const pokePartsSchema = v.array(pokePartBodySchema);\n\nconst pokeEndBodySchema = v.object({\n  pokeID: v.string(),\n  // Note: This should be ignored (and may be empty) if cancel === `true`.\n  cookie: versionSchema,\n  // If `true`, the poke with id `pokeID` should be discarded without\n  // applying it.\n  cancel: v.boolean().optional(),\n});\n\nexport const pokeStartMessageSchema = v.tuple([\n  v.literal('pokeStart'),\n  pokeStartBodySchema,\n]);\nexport const pokePartMessageSchema = v.tuple([\n  v.literal('pokePart'),\n  pokePartBodySchema,\n]);\nexport const pokeEndMessageSchema = v.tuple([\n  v.literal('pokeEnd'),\n  pokeEndBodySchema,\n]);\n\nexport type PokeStartBody = v.Infer<typeof pokeStartBodySchema>;\nexport type PokePartBody = v.Infer<typeof pokePartBodySchema>;\nexport type PokeParts = v.Infer<typeof pokePartsSchema>;\nexport type PokeEndBody = v.Infer<typeof pokeEndBodySchema>;\n\n/** The first byte identifying a binary WebSocket message as a poke chunk. */\nexport const POKE_CHUNK_MESSAGE_TYPE = 0x00;\n\n/** The first protocol version that receives binary poke chunks. */\nexport const POKE_CHUNK_PROTOCOL_VERSION = 52;\n\n/** The last protocol version that receives JSON pokePart messages. */\nexport const LAST_POKE_PART_PROTOCOL_VERSION = 51;\n\n/** A tagged binary poke chunk WebSocket message. */\nexport type PokeChunk = Uint8Array;\n\nexport type PokeStartMessage = v.Infer<typeof pokeStartMessageSchema>;\nexport type PokePartMessage = v.Infer<typeof pokePartMessageSchema>;\nexport type PokeEndMessage = v.Infer<typeof pokeEndMessageSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAM,sBAAsBA,eAAE,OAAO;CACnC,QAAQA,eAAE,OAAO;CAIjB,YAAY;;;;;CAKZ,gBAAgBA,eACb,OAAO;EACN,qBAAqBA,eAAE,OAAO;EAC9B,qBAAqBA,eAAE,OAAO;CAChC,CAAC,CAAC,CACD,SAAS;CACZ,WAAWA,eAAE,OAAO,CAAC,CAAC,SAAS;AACjC,CAAC;AAED,IAAa,qBAAqBA,eAAE,OAAO;CAEzC,uBAAuBA,eAAE,OAAOA,eAAE,OAAO,CAAC,CAAC,CAAC,SAAS;CAErD,uBAAuBA,eAAE,OAAO,kBAAkB,CAAC,CAAC,SAAS;CAG7D,iBAAiB,mBAAmB,SAAS;CAE7C,WAAW,gBAAgB,SAAS;CAEpC,gBAAgB,qBAAqB,SAAS;CAC9C,QAAQA,eAAE,OAAO;AACnB,CAAC;;;;;;AAOD,IAAa,kBAAkBA,eAAE,MAAM,kBAAkB;AAEzD,IAAM,oBAAoBA,eAAE,OAAO;CACjC,QAAQA,eAAE,OAAO;CAEjB,QAAQ;CAGR,QAAQA,eAAE,QAAQ,CAAC,CAAC,SAAS;AAC/B,CAAC;AAED,IAAa,yBAAyBA,eAAE,MAAM,CAC5CA,eAAE,QAAQ,WAAW,GACrB,mBACF,CAAC;AACD,IAAa,wBAAwBA,eAAE,MAAM,CAC3CA,eAAE,QAAQ,UAAU,GACpB,kBACF,CAAC;AACD,IAAa,uBAAuBA,eAAE,MAAM,CAC1CA,eAAE,QAAQ,SAAS,GACnB,iBACF,CAAC"}

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

@@ -1,6 +1,4 @@
 import * as v from '../../shared/src/valita.ts';
-export declare const pongBodySchema: v.ObjectType<{}, undefined>;
 export declare const pongMessageSchema: v.TupleType<[v.Type<"pong">, v.ObjectType<{}, undefined>]>;
-export type PongBody = v.Infer<typeof pongBodySchema>;
 export type PongMessage = v.Infer<typeof pongMessageSchema>;
 //# sourceMappingURL=pong.d.ts.map

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

@@ -3,6 +3,6 @@ import { valita_exports } from "../../shared/src/valita.js";
 var pongBodySchema = valita_exports.object({});
 var pongMessageSchema = valita_exports.tuple([valita_exports.literal("pong"), pongBodySchema]);
 //#endregion
-export { pongBodySchema, pongMessageSchema };
+export { pongMessageSchema };
 
 //# sourceMappingURL=pong.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"pong.js","names":["v"],"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,iBAAiBA,eAAE,OAAO,CAAC,CAAC;AACzC,IAAa,oBAAoBA,eAAE,MAAM,CAACA,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/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

@@ -14,6 +14,6 @@ var pullResponseBodySchema = valita_exports.object({
 var pullRequestMessageSchema = valita_exports.tuple([valita_exports.literal("pull"), pullRequestBodySchema]);
 var pullResponseMessageSchema = valita_exports.tuple([valita_exports.literal("pull"), pullResponseBodySchema]);
 //#endregion
-export { pullRequestBodySchema, pullRequestMessageSchema, pullResponseBodySchema, pullResponseMessageSchema };
+export { pullRequestMessageSchema, pullResponseMessageSchema };
 
 //# sourceMappingURL=pull.js.map

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

@@ -1 +1 @@
-{"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\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,wBAAwBA,eAAE,OAAO;CAC5C,eAAeA,eAAE,OAAO;CACxB,QAAQ;CACR,WAAWA,eAAE,OAAO;AACtB,CAAC;AAED,IAAa,yBAAyBA,eAAE,OAAO;CAC7C,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"}
+{"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

@@ -71,6 +71,6 @@ valita_exports.union(pushResponseBodySchema, pushFailedBodySchema);
 var pushResponseMessageSchema = valita_exports.tuple([valita_exports.literal("pushResponse"), pushResponseBodySchema]);
 var ackMutationResponsesMessageSchema = valita_exports.tuple([valita_exports.literal("ackMutationResponses"), mutationIDSchema]);
 //#endregion
-export { ackMutationResponsesMessageSchema, pushBodySchema, pushErrorSchema, pushMessageSchema, pushResponseBodySchema, pushResponseMessageSchema };
+export { ackMutationResponsesMessageSchema, pushBodySchema, pushErrorSchema, pushMessageSchema, pushResponseMessageSchema };
 
 //# sourceMappingURL=push.js.map

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

@@ -1 +1 @@
-{"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\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,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,IAAa,yBAAyBA,eAAE,MAAM,cAAc,eAAe;AAEzCA,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"}
+{"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 { putOpSchema, queriesPatchSchema, upPutOpSchema, 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":["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\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,cAAcA,eAAE,OAAO;CAClC,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"}
+{"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"}