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

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

@@ -10,45 +10,34 @@ export declare const transformedQuerySchema: v.ObjectType<{
     name: v.Type<string>;
     ast: v.Type<import("./ast.ts").AST>;
 }, undefined>;
-export declare const appQueryErrorSchema: v.ObjectType<{
+export declare const appErroredQuerySchema: v.ObjectType<{
     error: v.Type<"app">;
     id: v.Type<string>;
     name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    message: v.Optional<string>;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>;
-export declare const zeroErrorSchema: v.ObjectType<{
-    error: v.Type<"zero">;
+export declare const parseErroredQuerySchema: v.ObjectType<{
+    error: v.Type<"parse">;
     id: v.Type<string>;
     name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-}, undefined>;
-export declare const httpQueryErrorSchema: v.ObjectType<{
-    error: v.Type<"http">;
-    id: v.Type<string>;
-    name: v.Type<string>;
-    status: v.Type<number>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    message: v.Type<string>;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>;
 export declare const erroredQuerySchema: v.UnionType<[v.ObjectType<{
     error: v.Type<"app">;
     id: v.Type<string>;
     name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    message: v.Optional<string>;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>, v.ObjectType<{
-    error: v.Type<"http">;
+    error: v.Type<"parse">;
     id: v.Type<string>;
     name: v.Type<string>;
-    status: v.Type<number>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-}, undefined>, v.ObjectType<{
-    error: v.Type<"zero">;
-    id: v.Type<string>;
-    name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    message: v.Type<string>;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>]>;
 export type ErroredQuery = v.Infer<typeof erroredQuerySchema>;
-export type AppQueryError = v.Infer<typeof appQueryErrorSchema>;
-export type HttpQueryError = v.Infer<typeof httpQueryErrorSchema>;
 export declare const transformResponseBodySchema: v.ArrayType<v.UnionType<[v.ObjectType<{
     id: v.Type<string>;
     name: v.Type<string>;
@@ -57,18 +46,14 @@ export declare const transformResponseBodySchema: v.ArrayType<v.UnionType<[v.Obj
     error: v.Type<"app">;
     id: v.Type<string>;
     name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    message: v.Optional<string>;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>, v.ObjectType<{
-    error: v.Type<"http">;
+    error: v.Type<"parse">;
     id: v.Type<string>;
     name: v.Type<string>;
-    status: v.Type<number>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-}, undefined>, v.ObjectType<{
-    error: v.Type<"zero">;
-    id: v.Type<string>;
-    name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    message: v.Type<string>;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>]>]>>;
 export type TransformResponseBody = v.Infer<typeof transformResponseBodySchema>;
 export declare const transformRequestMessageSchema: v.TupleType<[v.Type<"transform">, v.ArrayType<v.ObjectType<{
@@ -81,21 +66,17 @@ export declare const transformErrorMessageSchema: v.TupleType<[v.Type<"transform
     error: v.Type<"app">;
     id: v.Type<string>;
     name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-}, undefined>, v.ObjectType<{
-    error: v.Type<"http">;
-    id: v.Type<string>;
-    name: v.Type<string>;
-    status: v.Type<number>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    message: v.Optional<string>;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>, v.ObjectType<{
-    error: v.Type<"zero">;
+    error: v.Type<"parse">;
     id: v.Type<string>;
     name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    message: v.Type<string>;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>]>>]>;
 export type TransformErrorMessage = v.Infer<typeof transformErrorMessageSchema>;
-export declare const transformResponseMessageSchema: v.TupleType<[v.Type<"transformed">, v.ArrayType<v.UnionType<[v.ObjectType<{
+export declare const transformResponseMessageSchema: v.UnionType<[v.TupleType<[v.Type<"transformed">, v.ArrayType<v.UnionType<[v.ObjectType<{
     id: v.Type<string>;
     name: v.Type<string>;
     ast: v.Type<import("./ast.ts").AST>;
@@ -103,18 +84,40 @@ export declare const transformResponseMessageSchema: v.TupleType<[v.Type<"transf
     error: v.Type<"app">;
     id: v.Type<string>;
     name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    message: v.Optional<string>;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>, v.ObjectType<{
-    error: v.Type<"http">;
-    id: v.Type<string>;
-    name: v.Type<string>;
+    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>]>]>>]>, v.TupleType<[v.Type<"transformFailed">, v.UnionType<[v.ObjectType<Omit<{
+    kind: v.Type<"TransformFailed">;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    queryIDs: v.ArrayType<v.Type<string>>;
+    message: v.Type<string>;
+}, "reason" | "origin"> & {
+    origin: v.Type<"server">;
+    reason: v.Type<"parse" | "database" | "internal">;
+}, undefined>, v.ObjectType<Omit<{
+    kind: v.Type<"TransformFailed">;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    queryIDs: v.ArrayType<v.Type<string>>;
+    message: v.Type<string>;
+}, "reason" | "status" | "origin" | "bodyPreview"> & {
+    origin: v.Type<"zeroCache">;
+    reason: v.Type<"http">;
     status: v.Type<number>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-}, undefined>, v.ObjectType<{
-    error: v.Type<"zero">;
-    id: v.Type<string>;
-    name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-}, undefined>]>]>>]>;
+    bodyPreview: v.Optional<string>;
+}, undefined>, v.ObjectType<Omit<{
+    kind: v.Type<"TransformFailed">;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    queryIDs: v.ArrayType<v.Type<string>>;
+    message: v.Type<string>;
+}, "reason" | "origin"> & {
+    origin: v.Type<"zeroCache">;
+    reason: v.Type<"parse" | "internal" | "timeout">;
+}, undefined>]>]>]>;
 export type TransformResponseMessage = v.Infer<typeof transformResponseMessageSchema>;
 //# sourceMappingURL=custom-queries.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"custom-queries.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/custom-queries.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAGhD,eAAO,MAAM,0BAA0B;;;;cAMtC,CAAC;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,sBAAsB;;;;aAIjC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;aAK9B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;aAK1B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;aAM/B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;eAI9B,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,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;AAElE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;kBAEvC,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,6BAA6B;;;;gBAGxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AACF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;kBAGtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;oBAGzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC"}
+{"version":3,"file":"custom-queries.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/custom-queries.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAIhD,eAAO,MAAM,0BAA0B;;;;cAMtC,CAAC;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,sBAAsB;;;;aAIjC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;aAOhC,CAAC;AACH,eAAO,MAAM,uBAAuB;;;;;;aAMlC,CAAC;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;eAG9B,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;kBAEvC,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,6BAA6B;;;;gBAGxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AACF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;kBAGtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAWhF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAG1C,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC"}

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

@@ -1,47 +1,71 @@
 import { jsonSchema } from "../../shared/src/json-schema.js";
-import * as v from "../../shared/src/valita.js";
+import { readonly } from "../../shared/src/valita.js";
 import { astSchema } from "./ast.js";
-export const transformRequestBodySchema = v.array(v.object({
-    id: v.string(),
-    name: v.string(),
-    args: v.readonly(v.array(jsonSchema)),
-}));
-export const transformedQuerySchema = v.object({
-    id: v.string(),
-    name: v.string(),
-    ast: astSchema,
+import { transformFailedBodySchema } from "./error.js";
+import { array, object, string, literal, union, tuple } from "@badrap/valita";
+const transformRequestBodySchema = array(
+  object({
+    id: string(),
+    name: string(),
+    args: readonly(array(jsonSchema))
+  })
+);
+const transformedQuerySchema = object({
+  id: string(),
+  name: string(),
+  ast: astSchema
 });
-export const appQueryErrorSchema = v.object({
-    error: v.literal('app'),
-    id: v.string(),
-    name: v.string(),
-    details: jsonSchema,
+const appErroredQuerySchema = object({
+  error: literal("app"),
+  id: string(),
+  name: string(),
+  // optional for backwards compatibility
+  message: string().optional(),
+  details: jsonSchema.optional()
 });
-export const zeroErrorSchema = v.object({
-    error: v.literal('zero'),
-    id: v.string(),
-    name: v.string(),
-    details: jsonSchema,
+const parseErroredQuerySchema = object({
+  error: literal("parse"),
+  id: string(),
+  name: string(),
+  message: string(),
+  details: jsonSchema.optional()
 });
-export const httpQueryErrorSchema = v.object({
-    error: v.literal('http'),
-    id: v.string(),
-    name: v.string(),
-    status: v.number(),
-    details: jsonSchema,
-});
-export const erroredQuerySchema = v.union(appQueryErrorSchema, httpQueryErrorSchema, zeroErrorSchema);
-export const transformResponseBodySchema = v.array(v.union(transformedQuerySchema, erroredQuerySchema));
-export const transformRequestMessageSchema = v.tuple([
-    v.literal('transform'),
-    transformRequestBodySchema,
+const erroredQuerySchema = union(
+  appErroredQuerySchema,
+  parseErroredQuerySchema
+);
+const transformResponseBodySchema = array(
+  union(transformedQuerySchema, erroredQuerySchema)
+);
+const transformRequestMessageSchema = tuple([
+  literal("transform"),
+  transformRequestBodySchema
+]);
+const transformErrorMessageSchema = tuple([
+  literal("transformError"),
+  array(erroredQuerySchema)
 ]);
-export const transformErrorMessageSchema = v.tuple([
-    v.literal('transformError'),
-    v.array(erroredQuerySchema),
+const transformFailedMessageSchema = tuple([
+  literal("transformFailed"),
+  transformFailedBodySchema
 ]);
-export const transformResponseMessageSchema = v.tuple([
-    v.literal('transformed'),
-    transformResponseBodySchema,
+const transformOkMessageSchema = tuple([
+  literal("transformed"),
+  transformResponseBodySchema
 ]);
-//# sourceMappingURL=custom-queries.js.map
+const transformResponseMessageSchema = union(
+  transformOkMessageSchema,
+  transformFailedMessageSchema
+);
+export {
+  appErroredQuerySchema,
+  erroredQuerySchema,
+  parseErroredQuerySchema,
+  transformErrorMessageSchema,
+  transformRequestBodySchema,
+  transformRequestMessageSchema,
+  transformResponseBodySchema,
+  transformResponseMessageSchema,
+  transformedQuerySchema
+};
+//# sourceMappingURL=custom-queries.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"custom-queries.js","sourceRoot":"","sources":["../../../../zero-protocol/src/custom-queries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,iCAAiC,CAAC;AAC3D,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAChD,OAAO,EAAC,SAAS,EAAC,MAAM,UAAU,CAAC;AAEnC,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC/C,CAAC,CAAC,MAAM,CAAC;IACP,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;CACtC,CAAC,CACH,CAAC;AAGF,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,GAAG,EAAE,SAAS;CACf,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;IACvB,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,UAAU;CACpB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IACxB,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,UAAU;CACpB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IACxB,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,OAAO,EAAE,UAAU;CACpB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CACvC,mBAAmB,EACnB,oBAAoB,EACpB,eAAe,CAChB,CAAC;AAKF,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAChD,CAAC,CAAC,KAAK,CAAC,sBAAsB,EAAE,kBAAkB,CAAC,CACpD,CAAC;AAGF,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC;IACnD,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;IACtB,0BAA0B;CAC3B,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC;IACjD,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC;IAC3B,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC;CAC5B,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC;IACpD,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IACxB,2BAA2B;CAC5B,CAAC,CAAC"}
+{"version":3,"file":"custom-queries.js","sources":["../../../../zero-protocol/src/custom-queries.ts"],"sourcesContent":["import {jsonSchema} from '../../shared/src/json-schema.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport {astSchema} from './ast.ts';\nimport {transformFailedBodySchema} from './error.ts';\n\nexport const transformRequestBodySchema = v.array(\n  v.object({\n    id: v.string(),\n    name: v.string(),\n    args: v.readonly(v.array(jsonSchema)),\n  }),\n);\nexport type TransformRequestBody = v.Infer<typeof transformRequestBodySchema>;\n\nexport const transformedQuerySchema = v.object({\n  id: v.string(),\n  name: v.string(),\n  ast: astSchema,\n});\n\nexport const appErroredQuerySchema = v.object({\n  error: v.literal('app'),\n  id: v.string(),\n  name: v.string(),\n  // optional for backwards compatibility\n  message: v.string().optional(),\n  details: jsonSchema.optional(),\n});\nexport const parseErroredQuerySchema = v.object({\n  error: v.literal('parse'),\n  id: v.string(),\n  name: v.string(),\n  message: v.string(),\n  details: jsonSchema.optional(),\n});\nexport const erroredQuerySchema = v.union(\n  appErroredQuerySchema,\n  parseErroredQuerySchema,\n);\nexport type ErroredQuery = v.Infer<typeof erroredQuerySchema>;\n\nexport const transformResponseBodySchema = v.array(\n  v.union(transformedQuerySchema, erroredQuerySchema),\n);\nexport type TransformResponseBody = v.Infer<typeof transformResponseBodySchema>;\n\nexport const transformRequestMessageSchema = v.tuple([\n  v.literal('transform'),\n  transformRequestBodySchema,\n]);\nexport type TransformRequestMessage = v.Infer<\n  typeof transformRequestMessageSchema\n>;\nexport const transformErrorMessageSchema = v.tuple([\n  v.literal('transformError'),\n  v.array(erroredQuerySchema),\n]);\nexport type TransformErrorMessage = v.Infer<typeof transformErrorMessageSchema>;\n\nconst transformFailedMessageSchema = v.tuple([\n  v.literal('transformFailed'),\n  transformFailedBodySchema,\n]);\nconst transformOkMessageSchema = v.tuple([\n  v.literal('transformed'),\n  transformResponseBodySchema,\n]);\n\nexport const transformResponseMessageSchema = v.union(\n  transformOkMessageSchema,\n  transformFailedMessageSchema,\n);\nexport type TransformResponseMessage = v.Infer<\n  typeof transformResponseMessageSchema\n>;\n"],"names":["v.array","v.object","v.string","v.readonly","v.literal","v.union","v.tuple"],"mappings":";;;;;AAKO,MAAM,6BAA6BA;AAAAA,EACxCC,OAAS;AAAA,IACP,IAAIC,OAAE;AAAA,IACN,MAAMA,OAAE;AAAA,IACR,MAAMC,SAAWH,MAAQ,UAAU,CAAC;AAAA,EAAA,CACrC;AACH;AAGO,MAAM,yBAAyBC,OAAS;AAAA,EAC7C,IAAIC,OAAE;AAAA,EACN,MAAMA,OAAE;AAAA,EACR,KAAK;AACP,CAAC;AAEM,MAAM,wBAAwBD,OAAS;AAAA,EAC5C,OAAOG,QAAU,KAAK;AAAA,EACtB,IAAIF,OAAE;AAAA,EACN,MAAMA,OAAE;AAAA;AAAA,EAER,SAASA,OAAE,EAAS,SAAA;AAAA,EACpB,SAAS,WAAW,SAAA;AACtB,CAAC;AACM,MAAM,0BAA0BD,OAAS;AAAA,EAC9C,OAAOG,QAAU,OAAO;AAAA,EACxB,IAAIF,OAAE;AAAA,EACN,MAAMA,OAAE;AAAA,EACR,SAASA,OAAE;AAAA,EACX,SAAS,WAAW,SAAA;AACtB,CAAC;AACM,MAAM,qBAAqBG;AAAAA,EAChC;AAAA,EACA;AACF;AAGO,MAAM,8BAA8BL;AAAAA,EACzCK,MAAQ,wBAAwB,kBAAkB;AACpD;AAGO,MAAM,gCAAgCC,MAAQ;AAAA,EACnDF,QAAU,WAAW;AAAA,EACrB;AACF,CAAC;AAIM,MAAM,8BAA8BE,MAAQ;AAAA,EACjDF,QAAU,gBAAgB;AAAA,EAC1BJ,MAAQ,kBAAkB;AAC5B,CAAC;AAGD,MAAM,+BAA+BM,MAAQ;AAAA,EAC3CF,QAAU,iBAAiB;AAAA,EAC3B;AACF,CAAC;AACD,MAAM,2BAA2BE,MAAQ;AAAA,EACvCF,QAAU,aAAa;AAAA,EACvB;AACF,CAAC;AAEM,MAAM,iCAAiCC;AAAAA,EAC5C;AAAA,EACA;AACF;"}

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

@@ -1,5 +1,10 @@
 import { jsonSchema } from "../../shared/src/json-schema.js";
-import * as v from "../../shared/src/valita.js";
-export const valueSchema = v.union(jsonSchema, v.undefined());
-export const rowSchema = v.readonlyRecord(valueSchema);
-//# sourceMappingURL=data.js.map
+import { readonlyRecord } from "../../shared/src/valita.js";
+import { union, undefined as _undefined } from "@badrap/valita";
+const valueSchema = union(jsonSchema, _undefined());
+const rowSchema = readonlyRecord(valueSchema);
+export {
+  rowSchema,
+  valueSchema
+};
+//# sourceMappingURL=data.js.map

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

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

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

@@ -1,10 +1,17 @@
-import * as v from "../../shared/src/valita.js";
-export const deleteClientsBodySchema = v.union(v.readonlyObject({
-    clientIDs: v.readonlyArray(v.string()).optional(),
-    clientGroupIDs: v.readonlyArray(v.string()).optional(),
-}));
-export const deleteClientsMessageSchema = v.tuple([
-    v.literal('deleteClients'),
-    deleteClientsBodySchema,
+import { readonlyObject, readonlyArray } from "../../shared/src/valita.js";
+import { union, string, tuple, literal } from "@badrap/valita";
+const deleteClientsBodySchema = union(
+  readonlyObject({
+    clientIDs: readonlyArray(string()).optional(),
+    clientGroupIDs: readonlyArray(string()).optional()
+  })
+);
+const deleteClientsMessageSchema = tuple([
+  literal("deleteClients"),
+  deleteClientsBodySchema
 ]);
-//# sourceMappingURL=delete-clients.js.map
+export {
+  deleteClientsBodySchema,
+  deleteClientsMessageSchema
+};
+//# sourceMappingURL=delete-clients.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"delete-clients.js","sourceRoot":"","sources":["../../../../zero-protocol/src/delete-clients.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAEhD,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC5C,CAAC,CAAC,cAAc,CAAC;IACf,SAAS,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACjD,cAAc,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;CACvD,CAAC,CACH,CAAC;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC;IAChD,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC;IAC1B,uBAAuB;CACxB,CAAC,CAAC"}
+{"version":3,"file":"delete-clients.js","sources":["../../../../zero-protocol/src/delete-clients.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\n\nexport const deleteClientsBodySchema = v.union(\n  v.readonlyObject({\n    clientIDs: v.readonlyArray(v.string()).optional(),\n    clientGroupIDs: v.readonlyArray(v.string()).optional(),\n  }),\n);\n\nexport const deleteClientsMessageSchema = v.tuple([\n  v.literal('deleteClients'),\n  deleteClientsBodySchema,\n]);\n\nexport type DeleteClientsBody = v.Infer<typeof deleteClientsBodySchema>;\nexport type DeleteClientsMessage = v.Infer<typeof deleteClientsMessageSchema>;\n"],"names":["v.union","v.readonlyObject","v.readonlyArray","v.string","v.tuple","v.literal"],"mappings":";;AAEO,MAAM,0BAA0BA;AAAAA,EACrCC,eAAiB;AAAA,IACf,WAAWC,cAAgBC,OAAE,CAAQ,EAAE,SAAA;AAAA,IACvC,gBAAgBD,cAAgBC,OAAE,CAAQ,EAAE,SAAA;AAAA,EAAS,CACtD;AACH;AAEO,MAAM,6BAA6BC,MAAQ;AAAA,EAChDC,QAAU,eAAe;AAAA,EACzB;AACF,CAAC;"}

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

@@ -58,6 +58,7 @@ export declare const downstreamSchema: v.UnionType<[v.TupleType<[v.Type<"connect
                 clientID: string;
             };
             result: {
+                message?: string | undefined;
                 details?: import("../../shared/src/json.ts").ReadonlyJSONValue | undefined;
                 error: "app";
             } | {
@@ -95,9 +96,10 @@ export declare const downstreamSchema: v.UnionType<[v.TupleType<[v.Type<"connect
             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.Type<"oooMutation" | "alreadyProcessed">;
+            error: v.UnionType<[v.Type<"oooMutation">, v.Type<"alreadyProcessed">]>;
             details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
         }, undefined>]>]>;
     }, undefined>>;
@@ -130,7 +132,7 @@ export declare const downstreamSchema: v.UnionType<[v.TupleType<[v.Type<"connect
     }[]>;
 }, undefined>]>]>]>, v.TupleType<[v.Type<"inspect">, v.UnionType<[v.ObjectType<Omit<{
     id: v.Type<string>;
-}, "op" | "value"> & {
+}, "value" | "op"> & {
     op: v.Type<"queries">;
     value: v.ArrayType<v.ObjectType<{
         clientID: v.Type<string>;
@@ -150,7 +152,7 @@ export declare const downstreamSchema: v.UnionType<[v.TupleType<[v.Type<"connect
     }, undefined>>;
 }, undefined>, v.ObjectType<Omit<{
     id: v.Type<string>;
-}, "op" | "value"> & {
+}, "value" | "op"> & {
     op: v.Type<"metrics">;
     value: v.ObjectType<{
         'query-materialization-server': v.VariadicTupleType<[v.Type<number>], v.Type<number>, []>;
@@ -158,17 +160,17 @@ export declare const downstreamSchema: v.UnionType<[v.TupleType<[v.Type<"connect
     }, undefined>;
 }, undefined>, v.ObjectType<Omit<{
     id: v.Type<string>;
-}, "op" | "value"> & {
+}, "value" | "op"> & {
     op: v.Type<"version">;
     value: v.Type<string>;
 }, undefined>, v.ObjectType<Omit<{
     id: v.Type<string>;
-}, "op" | "value"> & {
+}, "value" | "op"> & {
     op: v.Type<"authenticated">;
     value: v.Type<boolean>;
 }, undefined>, v.ObjectType<Omit<{
     id: v.Type<string>;
-}, "op" | "value"> & {
+}, "value" | "op"> & {
     op: v.Type<"analyze-query">;
     value: v.ObjectType<{
         warnings: v.ArrayType<v.Type<string>>;
@@ -184,28 +186,124 @@ export declare const downstreamSchema: v.UnionType<[v.TupleType<[v.Type<"connect
         readRows: v.Optional<Record<string, Record<string, Readonly<Record<string, import("../../shared/src/json.ts").ReadonlyJSONValue | undefined>>[]>>>;
         readRowCountsByQuery: v.Optional<Record<string, Record<string, number>>>;
         readRowCount: v.Optional<number>;
+        dbScansByQuery: v.Optional<Record<string, Record<string, number>>>;
+        plannerEvents: v.Optional<({
+            type: "attempt-start";
+            attemptNumber: number;
+            totalAttempts: number;
+        } | {
+            type: "connection-costs";
+            attemptNumber: number;
+            costs: {
+                connection: string;
+                cost: number;
+                costEstimate: {
+                    limit?: number | undefined;
+                    startupCost: number;
+                    scanEst: number;
+                    cost: number;
+                    returnedRows: number;
+                    selectivity: number;
+                };
+                pinned: boolean;
+                constraints: Record<string, Record<string, unknown> | null>;
+                constraintCosts: Record<string, {
+                    limit?: number | undefined;
+                    startupCost: number;
+                    scanEst: number;
+                    cost: number;
+                    returnedRows: number;
+                    selectivity: number;
+                }>;
+            }[];
+        } | {
+            type: "connection-selected";
+            attemptNumber: number;
+            connection: string;
+            cost: number;
+            isRoot: boolean;
+        } | {
+            type: "constraints-propagated";
+            attemptNumber: number;
+            connectionConstraints: {
+                connection: string;
+                constraints: Record<string, Record<string, unknown> | null>;
+                constraintCosts: Record<string, {
+                    limit?: number | undefined;
+                    startupCost: number;
+                    scanEst: number;
+                    cost: number;
+                    returnedRows: number;
+                    selectivity: number;
+                }>;
+            }[];
+        } | {
+            type: "plan-complete";
+            attemptNumber: number;
+            totalCost: number;
+            flipPattern: number;
+            joinStates: {
+                join: string;
+                type: "semi" | "flipped" | "unflippable";
+            }[];
+        } | {
+            type: "plan-failed";
+            attemptNumber: number;
+            reason: string;
+        } | {
+            type: "best-plan-selected";
+            bestAttemptNumber: number;
+            totalCost: number;
+            flipPattern: number;
+            joinStates: {
+                join: string;
+                type: "semi" | "flipped" | "unflippable";
+            }[];
+        } | {
+            attemptNumber?: number | undefined;
+            filters?: import("./ast.ts").Condition | undefined;
+            ordering?: readonly (readonly [string, "desc" | "asc"])[] | undefined;
+            joinType?: "semi" | "flipped" | "unflippable" | undefined;
+            type: "node-cost";
+            nodeType: "join" | "connection" | "fan-out" | "fan-in" | "terminus";
+            node: string;
+            branchPattern: number[];
+            downstreamChildSelectivity: number;
+            costEstimate: {
+                limit?: number | undefined;
+                startupCost: number;
+                scanEst: number;
+                cost: number;
+                returnedRows: number;
+                selectivity: number;
+            };
+        } | {
+            attemptNumber?: number | undefined;
+            constraint?: Record<string, unknown> | null | undefined;
+            type: "node-constraint";
+            nodeType: "join" | "connection" | "fan-out" | "fan-in" | "terminus";
+            node: string;
+            branchPattern: number[];
+            from: string;
+        })[]>;
     }, undefined>;
 }, undefined>, v.ObjectType<Omit<{
     id: v.Type<string>;
-}, "op" | "value"> & {
+}, "value" | "op"> & {
     op: v.Type<"error">;
     value: v.Type<string>;
 }, undefined>]>]>, v.TupleType<[v.Type<"transformError">, v.ArrayType<v.UnionType<[v.ObjectType<{
     error: v.Type<"app">;
     id: v.Type<string>;
     name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
-}, undefined>, v.ObjectType<{
-    error: v.Type<"http">;
-    id: v.Type<string>;
-    name: v.Type<string>;
-    status: v.Type<number>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    message: v.Optional<string>;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>, v.ObjectType<{
-    error: v.Type<"zero">;
+    error: v.Type<"parse">;
     id: v.Type<string>;
     name: v.Type<string>;
-    details: v.Type<import("../../shared/src/json.ts").ReadonlyJSONValue>;
+    message: v.Type<string>;
+    details: v.Optional<import("../../shared/src/json.ts").ReadonlyJSONValue>;
 }, undefined>]>>]>]>;
 export type Downstream = v.Infer<typeof downstreamSchema>;
 //# sourceMappingURL=down.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"down.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/down.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAehD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAY5B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"down.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/down.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAehD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAY5B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

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

@@ -1,12 +1,28 @@
-import * as v from "../../shared/src/valita.js";
+import "../../shared/src/valita.js";
 import { connectedMessageSchema } from "./connect.js";
 import { transformErrorMessageSchema } from "./custom-queries.js";
 import { deleteClientsMessageSchema } from "./delete-clients.js";
 import { errorMessageSchema } from "./error.js";
 import { inspectDownMessageSchema } from "./inspect-down.js";
-import { pokeEndMessageSchema, pokePartMessageSchema, pokeStartMessageSchema, } from "./poke.js";
+import { pokeStartMessageSchema, pokePartMessageSchema, pokeEndMessageSchema } from "./poke.js";
 import { pongMessageSchema } from "./pong.js";
 import { pullResponseMessageSchema } from "./pull.js";
 import { pushResponseMessageSchema } from "./push.js";
-export const downstreamSchema = v.union(connectedMessageSchema, errorMessageSchema, pongMessageSchema, pokeStartMessageSchema, pokePartMessageSchema, pokeEndMessageSchema, pullResponseMessageSchema, deleteClientsMessageSchema, pushResponseMessageSchema, inspectDownMessageSchema, transformErrorMessageSchema);
-//# sourceMappingURL=down.js.map
+import { union } from "@badrap/valita";
+const downstreamSchema = union(
+  connectedMessageSchema,
+  errorMessageSchema,
+  pongMessageSchema,
+  pokeStartMessageSchema,
+  pokePartMessageSchema,
+  pokeEndMessageSchema,
+  pullResponseMessageSchema,
+  deleteClientsMessageSchema,
+  pushResponseMessageSchema,
+  inspectDownMessageSchema,
+  transformErrorMessageSchema
+);
+export {
+  downstreamSchema
+};
+//# sourceMappingURL=down.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"down.js","sourceRoot":"","sources":["../../../../zero-protocol/src/down.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAChD,OAAO,EAAC,sBAAsB,EAAC,MAAM,cAAc,CAAC;AACpD,OAAO,EAAC,2BAA2B,EAAC,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAC,0BAA0B,EAAC,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAC,kBAAkB,EAAC,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAC,wBAAwB,EAAC,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,iBAAiB,EAAC,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAC,yBAAyB,EAAC,MAAM,WAAW,CAAC;AACpD,OAAO,EAAC,yBAAyB,EAAC,MAAM,WAAW,CAAC;AAEpD,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CACrC,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EACzB,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,EACxB,2BAA2B,CAC5B,CAAC"}
+{"version":3,"file":"down.js","sources":["../../../../zero-protocol/src/down.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {connectedMessageSchema} from './connect.ts';\nimport {transformErrorMessageSchema} from './custom-queries.ts';\nimport {deleteClientsMessageSchema} from './delete-clients.ts';\nimport {errorMessageSchema} from './error.ts';\nimport {inspectDownMessageSchema} from './inspect-down.ts';\nimport {\n  pokeEndMessageSchema,\n  pokePartMessageSchema,\n  pokeStartMessageSchema,\n} from './poke.ts';\nimport {pongMessageSchema} from './pong.ts';\nimport {pullResponseMessageSchema} from './pull.ts';\nimport {pushResponseMessageSchema} from './push.ts';\n\nexport const downstreamSchema = v.union(\n  connectedMessageSchema,\n  errorMessageSchema,\n  pongMessageSchema,\n  pokeStartMessageSchema,\n  pokePartMessageSchema,\n  pokeEndMessageSchema,\n  pullResponseMessageSchema,\n  deleteClientsMessageSchema,\n  pushResponseMessageSchema,\n  inspectDownMessageSchema,\n  transformErrorMessageSchema,\n);\n\nexport type Downstream = v.Infer<typeof downstreamSchema>;\n"],"names":["v.union"],"mappings":";;;;;;;;;;;AAeO,MAAM,mBAAmBA;AAAAA,EAC9B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;"}