@lsync/transport 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lsync contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# @lsync/transport
+
+Shared MessagePack wire contracts and transport helpers for lsync.
+
+```sh
+pnpm add @lsync/transport
+```
+
+Most applications use this package transitively through `@lsync/client` or `@lsync/server`.

package/dist/index.d.mts

@@ -0,0 +1,528 @@
+import { z } from "zod";
+
+//#region src/api.d.ts
+declare const operationTypeSchema: z.ZodEnum<{
+  insert: "insert";
+  update: "update";
+  delete: "delete";
+}>;
+declare const updateSchema: z.ZodObject<{
+  id: z.ZodString;
+  collection: z.ZodString;
+  path: z.ZodOptional<z.ZodString>;
+  key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+  type: z.ZodEnum<{
+    insert: "insert";
+    update: "update";
+    delete: "delete";
+  }>;
+  value: z.ZodOptional<z.ZodUnknown>;
+  previousValue: z.ZodOptional<z.ZodUnknown>;
+  clientId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodNumber;
+}, z.core.$strip>;
+declare const sequencedUpdateSchema: z.ZodObject<{
+  id: z.ZodString;
+  collection: z.ZodString;
+  path: z.ZodOptional<z.ZodString>;
+  key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+  type: z.ZodEnum<{
+    insert: "insert";
+    update: "update";
+    delete: "delete";
+  }>;
+  value: z.ZodOptional<z.ZodUnknown>;
+  previousValue: z.ZodOptional<z.ZodUnknown>;
+  clientId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodNumber;
+  sequence: z.ZodNumber;
+  serverCreatedAt: z.ZodString;
+}, z.core.$strip>;
+declare const batchSchema: z.ZodObject<{
+  updates: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    type: z.ZodEnum<{
+      insert: "insert";
+      update: "update";
+      delete: "delete";
+    }>;
+    value: z.ZodOptional<z.ZodUnknown>;
+    previousValue: z.ZodOptional<z.ZodUnknown>;
+    clientId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const readFilterOperatorSchema: z.ZodEnum<{
+  eq: "eq";
+  ne: "ne";
+  gt: "gt";
+  gte: "gte";
+  lt: "lt";
+  lte: "lte";
+  in: "in";
+}>;
+declare const readFilterSchema: z.ZodObject<{
+  field: z.ZodString;
+  op: z.ZodDefault<z.ZodEnum<{
+    eq: "eq";
+    ne: "ne";
+    gt: "gt";
+    gte: "gte";
+    lt: "lt";
+    lte: "lte";
+    in: "in";
+  }>>;
+  value: z.ZodUnknown;
+}, z.core.$strip>;
+type ReadPredicate = {
+  type: "comparison";
+  field: string;
+  op: z.infer<typeof readFilterOperatorSchema>;
+  value: unknown;
+} | {
+  type: "and" | "or";
+  predicates: Array<ReadPredicate>;
+};
+declare const readPredicateSchema: z.ZodType<ReadPredicate>;
+declare const readOrderBySchema: z.ZodObject<{
+  field: z.ZodString;
+  direction: z.ZodDefault<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>;
+}, z.core.$strip>;
+declare const readCursorSchema: z.ZodObject<{
+  whereCurrent: z.ZodType<ReadPredicate, unknown, z.core.$ZodTypeInternals<ReadPredicate, unknown>>;
+  whereFrom: z.ZodType<ReadPredicate, unknown, z.core.$ZodTypeInternals<ReadPredicate, unknown>>;
+  lastKey: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+declare const readQuerySchema: z.ZodObject<{
+  collection: z.ZodString;
+  filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodDefault<z.ZodEnum<{
+      eq: "eq";
+      ne: "ne";
+      gt: "gt";
+      gte: "gte";
+      lt: "lt";
+      lte: "lte";
+      in: "in";
+    }>>;
+    value: z.ZodUnknown;
+  }, z.core.$strip>>>;
+  predicate: z.ZodOptional<z.ZodType<ReadPredicate, unknown, z.core.$ZodTypeInternals<ReadPredicate, unknown>>>;
+  orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    field: z.ZodString;
+    direction: z.ZodDefault<z.ZodEnum<{
+      asc: "asc";
+      desc: "desc";
+    }>>;
+  }, z.core.$strip>>>;
+  cursor: z.ZodOptional<z.ZodObject<{
+    whereCurrent: z.ZodType<ReadPredicate, unknown, z.core.$ZodTypeInternals<ReadPredicate, unknown>>;
+    whereFrom: z.ZodType<ReadPredicate, unknown, z.core.$ZodTypeInternals<ReadPredicate, unknown>>;
+    lastKey: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+  }, z.core.$strip>>;
+  limit: z.ZodOptional<z.ZodNumber>;
+  offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const readResultSchema: z.ZodObject<{
+  rows: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const pushResultSchema: z.ZodObject<{
+  accepted: z.ZodNumber;
+  watermark: z.ZodNumber;
+}, z.core.$strip>;
+declare const syncChangesQuerySchema: z.ZodObject<{
+  collections: z.ZodRecord<z.ZodString, z.ZodNumber>;
+  limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const syncChangesResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"changes">;
+  updates: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    type: z.ZodEnum<{
+      insert: "insert";
+      update: "update";
+      delete: "delete";
+    }>;
+    value: z.ZodOptional<z.ZodUnknown>;
+    previousValue: z.ZodOptional<z.ZodUnknown>;
+    clientId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    sequence: z.ZodNumber;
+    serverCreatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  watermark: z.ZodNumber;
+  hasMore: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"resyncRequired">;
+  collections: z.ZodArray<z.ZodString>;
+  watermark: z.ZodNumber;
+}, z.core.$strip>], "type">;
+declare const apiCallSchema: z.ZodObject<{
+  path: z.ZodString;
+  input: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const collectionSubscriptionSchema: z.ZodObject<{
+  collection: z.ZodString;
+}, z.core.$strip>;
+declare const collectionSubscriptionResultSchema: z.ZodObject<{
+  collection: z.ZodString;
+  subscriptions: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const collectionInvalidationSchema: z.ZodObject<{
+  collection: z.ZodString;
+}, z.core.$strip>;
+declare const broadcastSchema: z.ZodObject<{
+  type: z.ZodLiteral<"updates">;
+  shardId: z.ZodString;
+  updates: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    type: z.ZodEnum<{
+      insert: "insert";
+      update: "update";
+      delete: "delete";
+    }>;
+    value: z.ZodOptional<z.ZodUnknown>;
+    previousValue: z.ZodOptional<z.ZodUnknown>;
+    clientId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    sequence: z.ZodNumber;
+    serverCreatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  watermark: z.ZodNumber;
+  invalidations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    collection: z.ZodString;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const webSocketAttachmentSchema: z.ZodObject<{
+  clientId: z.ZodString;
+  connectedAt: z.ZodNumber;
+  auth: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  subscriptions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type OperationType = z.infer<typeof operationTypeSchema>;
+type Update = z.infer<typeof updateSchema>;
+type SequencedUpdate = z.infer<typeof sequencedUpdateSchema>;
+type Batch = z.infer<typeof batchSchema>;
+type ReadFilterOperator = z.infer<typeof readFilterOperatorSchema>;
+type ReadFilter = z.output<typeof readFilterSchema>;
+type ReadFilterInput = z.input<typeof readFilterSchema>;
+type ReadCursor = z.output<typeof readCursorSchema>;
+type ReadCursorInput = z.input<typeof readCursorSchema>;
+type ReadOrderBy = z.output<typeof readOrderBySchema>;
+type ReadOrderByInput = z.input<typeof readOrderBySchema>;
+type ApiCall = z.output<typeof apiCallSchema>;
+type ApiCallInput = z.input<typeof apiCallSchema>;
+type CollectionSubscription = z.output<typeof collectionSubscriptionSchema>;
+type CollectionSubscriptionInput = z.input<typeof collectionSubscriptionSchema>;
+type CollectionSubscriptionResult = z.output<typeof collectionSubscriptionResultSchema>;
+type CollectionInvalidation = z.output<typeof collectionInvalidationSchema>;
+interface ApiRoute<TInput = unknown, TOutput = unknown> {
+  input: TInput;
+  output: TOutput;
+}
+type ApiContract = Record<string, ApiRoute>;
+type ApiPath<TApi extends ApiContract> = Extract<keyof TApi, string>;
+type ApiInput<TApi extends ApiContract, TPath extends ApiPath<TApi>> = TApi[TPath]["input"];
+type ApiOutput<TApi extends ApiContract, TPath extends ApiPath<TApi>> = TApi[TPath]["output"];
+type ApiCallArgs<TApi extends ApiContract, TPath extends ApiPath<TApi>> = undefined extends ApiInput<TApi, TPath> ? [input?: ApiInput<TApi, TPath>] : [input: ApiInput<TApi, TPath>];
+interface ReadQuery {
+  collection: string;
+  filters?: Array<ReadFilter>;
+  predicate?: ReadPredicate;
+  orderBy?: Array<ReadOrderBy>;
+  cursor?: ReadCursor;
+  limit?: number;
+  offset?: number;
+}
+interface ReadQueryInput {
+  collection: string;
+  filters?: Array<ReadFilterInput>;
+  predicate?: ReadPredicate;
+  orderBy?: Array<ReadOrderByInput>;
+  cursor?: ReadCursorInput;
+  limit?: number;
+  offset?: number;
+}
+type PushResult = z.infer<typeof pushResultSchema>;
+type SyncChangesQuery = z.output<typeof syncChangesQuerySchema>;
+type SyncChangesQueryInput = z.input<typeof syncChangesQuerySchema>;
+type SyncChangesResult = z.infer<typeof syncChangesResultSchema>;
+type Broadcast = z.infer<typeof broadcastSchema>;
+type WebSocketAttachment = z.infer<typeof webSocketAttachmentSchema>;
+interface ReadResult<T = unknown> {
+  rows: Array<T>;
+}
+//#endregion
+//#region src/expression.d.ts
+type ReadExpression = FuncExpression | RefExpression | ValExpression | {
+  expression: ReadExpression;
+};
+interface FuncExpression {
+  type: "func";
+  name: string;
+  args: Array<unknown>;
+}
+interface RefExpression {
+  type: "ref";
+  source?: "row" | "reference";
+  name?: string;
+  path: Array<string | number>;
+}
+interface ValExpression {
+  type: "val";
+  value: unknown;
+}
+type ReadExpressionInput = ReadExpression;
+type ReadExpressionField = RefExpression & Record<string, any>;
+type ReadExpressionRow<T extends object = Record<string, unknown>> = { readonly [K in keyof T]: ReadExpressionField };
+declare function readExpressionRow<T extends object = Record<string, unknown>>(): ReadExpressionRow<T>;
+declare function readExpressionReferences<TReferences extends Record<string, object> = Record<string, Record<string, unknown>>>(names: Array<keyof TReferences & string>): { readonly [K in keyof TReferences]: ReadExpressionRow<TReferences[K]> };
+declare function field(path: string | Array<string | number>): RefExpression;
+declare function val(value: unknown): ValExpression;
+declare function eq(left: unknown, right: unknown): FuncExpression;
+declare function ne(left: unknown, right: unknown): FuncExpression;
+declare function gt(left: unknown, right: unknown): FuncExpression;
+declare function gte(left: unknown, right: unknown): FuncExpression;
+declare function lt(left: unknown, right: unknown): FuncExpression;
+declare function lte(left: unknown, right: unknown): FuncExpression;
+declare function inArray(left: unknown, values: unknown): FuncExpression;
+declare function and(...expressions: Array<unknown>): FuncExpression;
+declare function or(...expressions: Array<unknown>): FuncExpression;
+declare function not(expression: unknown): FuncExpression;
+declare function compileReadExpression(expression: unknown): ReadPredicate;
+//#endregion
+//#region src/predicate-match.d.ts
+declare function matchesReadPredicate(row: unknown, predicate: ReadPredicate | undefined): boolean;
+//#endregion
+//#region src/rpc.d.ts
+declare const rpcIdSchema: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+declare const clientRpcRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+  id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  method: z.ZodLiteral<"mutation">;
+  params: z.ZodObject<{
+    path: z.ZodLiteral<"push">;
+    input: z.ZodObject<{
+      json: z.ZodObject<{
+        updates: z.ZodArray<z.ZodObject<{
+          id: z.ZodString;
+          collection: z.ZodString;
+          path: z.ZodOptional<z.ZodString>;
+          key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+          type: z.ZodEnum<{
+            insert: "insert";
+            update: "update";
+            delete: "delete";
+          }>;
+          value: z.ZodOptional<z.ZodUnknown>;
+          previousValue: z.ZodOptional<z.ZodUnknown>;
+          clientId: z.ZodOptional<z.ZodString>;
+          createdAt: z.ZodNumber;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  method: z.ZodLiteral<"query">;
+  params: z.ZodObject<{
+    path: z.ZodLiteral<"read">;
+    input: z.ZodObject<{
+      json: z.ZodObject<{
+        collection: z.ZodString;
+        filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+          field: z.ZodString;
+          op: z.ZodDefault<z.ZodEnum<{
+            eq: "eq";
+            ne: "ne";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            in: "in";
+          }>>;
+          value: z.ZodUnknown;
+        }, z.core.$strip>>>;
+        predicate: z.ZodOptional<z.ZodType<ReadPredicate, unknown, z.core.$ZodTypeInternals<ReadPredicate, unknown>>>;
+        orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+          field: z.ZodString;
+          direction: z.ZodDefault<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+          }>>;
+        }, z.core.$strip>>>;
+        cursor: z.ZodOptional<z.ZodObject<{
+          whereCurrent: z.ZodType<ReadPredicate, unknown, z.core.$ZodTypeInternals<ReadPredicate, unknown>>;
+          whereFrom: z.ZodType<ReadPredicate, unknown, z.core.$ZodTypeInternals<ReadPredicate, unknown>>;
+          lastKey: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        }, z.core.$strip>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  method: z.ZodLiteral<"query">;
+  params: z.ZodObject<{
+    path: z.ZodLiteral<"changes">;
+    input: z.ZodObject<{
+      json: z.ZodObject<{
+        collections: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  method: z.ZodLiteral<"mutation">;
+  params: z.ZodObject<{
+    path: z.ZodLiteral<"api">;
+    input: z.ZodObject<{
+      json: z.ZodObject<{
+        path: z.ZodString;
+        input: z.ZodOptional<z.ZodUnknown>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  method: z.ZodEnum<{
+    subscribe: "subscribe";
+    unsubscribe: "unsubscribe";
+  }>;
+  params: z.ZodObject<{
+    input: z.ZodObject<{
+      json: z.ZodObject<{
+        collection: z.ZodString;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+}, z.core.$strip>]>;
+declare const rpcResultMessageSchema: z.ZodObject<{
+  id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  result: z.ZodObject<{
+    type: z.ZodLiteral<"data">;
+    data: z.ZodObject<{
+      json: z.ZodUnknown;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const rpcErrorMessageSchema: z.ZodObject<{
+  id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  error: z.ZodObject<{
+    message: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const subscriptionMessageSchema: z.ZodObject<{
+  method: z.ZodLiteral<"subscription">;
+  params: z.ZodObject<{
+    path: z.ZodLiteral<"updates">;
+    input: z.ZodObject<{
+      json: z.ZodObject<{
+        type: z.ZodLiteral<"updates">;
+        shardId: z.ZodString;
+        updates: z.ZodArray<z.ZodObject<{
+          id: z.ZodString;
+          collection: z.ZodString;
+          path: z.ZodOptional<z.ZodString>;
+          key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+          type: z.ZodEnum<{
+            insert: "insert";
+            update: "update";
+            delete: "delete";
+          }>;
+          value: z.ZodOptional<z.ZodUnknown>;
+          previousValue: z.ZodOptional<z.ZodUnknown>;
+          clientId: z.ZodOptional<z.ZodString>;
+          createdAt: z.ZodNumber;
+          sequence: z.ZodNumber;
+          serverCreatedAt: z.ZodString;
+        }, z.core.$strip>>;
+        watermark: z.ZodNumber;
+        invalidations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+          collection: z.ZodString;
+        }, z.core.$strip>>>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const serverMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
+  id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  result: z.ZodObject<{
+    type: z.ZodLiteral<"data">;
+    data: z.ZodObject<{
+      json: z.ZodUnknown;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  error: z.ZodObject<{
+    message: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  method: z.ZodLiteral<"subscription">;
+  params: z.ZodObject<{
+    path: z.ZodLiteral<"updates">;
+    input: z.ZodObject<{
+      json: z.ZodObject<{
+        type: z.ZodLiteral<"updates">;
+        shardId: z.ZodString;
+        updates: z.ZodArray<z.ZodObject<{
+          id: z.ZodString;
+          collection: z.ZodString;
+          path: z.ZodOptional<z.ZodString>;
+          key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+          type: z.ZodEnum<{
+            insert: "insert";
+            update: "update";
+            delete: "delete";
+          }>;
+          value: z.ZodOptional<z.ZodUnknown>;
+          previousValue: z.ZodOptional<z.ZodUnknown>;
+          clientId: z.ZodOptional<z.ZodString>;
+          createdAt: z.ZodNumber;
+          sequence: z.ZodNumber;
+          serverCreatedAt: z.ZodString;
+        }, z.core.$strip>>;
+        watermark: z.ZodNumber;
+        invalidations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+          collection: z.ZodString;
+        }, z.core.$strip>>>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+}, z.core.$strip>]>;
+type RpcId = string | number | null | undefined;
+type ClientRpcRequest = z.input<typeof clientRpcRequestSchema>;
+type ParsedClientRpcRequest = z.output<typeof clientRpcRequestSchema>;
+type RpcResultMessage = z.output<typeof rpcResultMessageSchema>;
+type RpcErrorMessage = z.output<typeof rpcErrorMessageSchema>;
+type SubscriptionMessage = z.output<typeof subscriptionMessageSchema>;
+type ServerMessage = z.output<typeof serverMessageSchema>;
+type TransportPayload = ArrayBuffer | ArrayBufferView | string;
+interface TransportSocket {
+  send(data: ArrayBuffer): void;
+}
+declare function parseClientRpcRequest(data: TransportPayload): ParsedClientRpcRequest;
+declare function parseServerMessage(data: TransportPayload): ServerMessage;
+declare function readRpcId(data: TransportPayload): RpcId;
+declare function encodeClientRpcRequest(message: ClientRpcRequest): ArrayBuffer;
+declare function encodeServerMessage(message: ServerMessage): ArrayBuffer;
+declare function sendClientRpcRequest(socket: TransportSocket, message: ClientRpcRequest): void;
+declare function sendServerMessage(socket: TransportSocket, message: ServerMessage): void;
+//#endregion
+export { type ApiCall, type ApiCallArgs, type ApiCallInput, type ApiContract, type ApiInput, type ApiOutput, type ApiPath, type ApiRoute, type Batch, type Broadcast, type ClientRpcRequest, type CollectionInvalidation, type CollectionSubscription, type CollectionSubscriptionInput, type CollectionSubscriptionResult, type FuncExpression, type OperationType, type ParsedClientRpcRequest, type PushResult, type ReadCursor, type ReadCursorInput, type ReadExpression, type ReadExpressionField, type ReadExpressionInput, type ReadExpressionRow, type ReadFilter, type ReadFilterInput, type ReadFilterOperator, type ReadOrderBy, type ReadOrderByInput, type ReadPredicate, type ReadQuery, type ReadQueryInput, type ReadResult, type RefExpression, type RpcErrorMessage, type RpcId, type RpcResultMessage, type SequencedUpdate, type ServerMessage, type SubscriptionMessage, type SyncChangesQuery, type SyncChangesQueryInput, type SyncChangesResult, type TransportSocket, type Update, type ValExpression, type WebSocketAttachment, and, apiCallSchema, batchSchema, broadcastSchema, clientRpcRequestSchema, collectionInvalidationSchema, collectionSubscriptionResultSchema, collectionSubscriptionSchema, compileReadExpression, encodeClientRpcRequest, encodeServerMessage, eq, field, gt, gte, inArray, lt, lte, matchesReadPredicate, ne, not, operationTypeSchema, or, parseClientRpcRequest, parseServerMessage, pushResultSchema, readCursorSchema, readExpressionReferences, readExpressionRow, readFilterOperatorSchema, readFilterSchema, readOrderBySchema, readPredicateSchema, readQuerySchema, readResultSchema, readRpcId, rpcErrorMessageSchema, rpcIdSchema, rpcResultMessageSchema, sendClientRpcRequest, sendServerMessage, sequencedUpdateSchema, serverMessageSchema, subscriptionMessageSchema, syncChangesQuerySchema, syncChangesResultSchema, updateSchema, val, webSocketAttachmentSchema };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/api.ts","../src/expression.ts","../src/predicate-match.ts","../src/rpc.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,410 @@
+import { z } from "zod";
+import { decode, encode } from "@msgpack/msgpack";
+//#region src/api.ts
+const operationTypeSchema = z.enum([
+	"insert",
+	"update",
+	"delete"
+]);
+const updateSchema = z.object({
+	id: z.string(),
+	collection: z.string(),
+	path: z.string().optional(),
+	key: z.union([z.string(), z.number()]),
+	type: operationTypeSchema,
+	value: z.unknown().optional(),
+	previousValue: z.unknown().optional(),
+	clientId: z.string().optional(),
+	createdAt: z.number()
+});
+const sequencedUpdateSchema = updateSchema.extend({
+	sequence: z.number().int().positive(),
+	serverCreatedAt: z.string()
+});
+const batchSchema = z.object({ updates: z.array(updateSchema).min(1) });
+const readFilterOperatorSchema = z.enum([
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"in"
+]);
+const readFilterSchema = z.object({
+	field: z.string().min(1),
+	op: readFilterOperatorSchema.default("eq"),
+	value: z.unknown()
+});
+const readComparisonPredicateSchema = z.object({
+	type: z.literal("comparison"),
+	field: z.string().min(1),
+	op: readFilterOperatorSchema,
+	value: z.unknown()
+});
+const readCompoundPredicateSchema = z.object({
+	type: z.enum(["and", "or"]),
+	predicates: z.array(z.lazy(() => readPredicateSchema)).min(1)
+});
+const readPredicateSchema = z.lazy(() => z.discriminatedUnion("type", [readComparisonPredicateSchema, readCompoundPredicateSchema]));
+const readOrderBySchema = z.object({
+	field: z.string().min(1),
+	direction: z.enum(["asc", "desc"]).default("asc")
+});
+const readCursorSchema = z.object({
+	whereCurrent: readPredicateSchema,
+	whereFrom: readPredicateSchema,
+	lastKey: z.union([z.string(), z.number()]).optional()
+});
+const readQuerySchema = z.object({
+	collection: z.string(),
+	filters: z.array(readFilterSchema).optional(),
+	predicate: readPredicateSchema.optional(),
+	orderBy: z.array(readOrderBySchema).optional(),
+	cursor: readCursorSchema.optional(),
+	limit: z.number().int().positive().max(1e3).optional(),
+	offset: z.number().int().nonnegative().optional()
+});
+const readResultSchema = z.object({ rows: z.array(z.unknown()) });
+const pushResultSchema = z.object({
+	accepted: z.number().int().nonnegative(),
+	watermark: z.number().int().nonnegative()
+});
+const syncChangesQuerySchema = z.object({
+	collections: z.record(z.string(), z.number().int().nonnegative()),
+	limit: z.number().int().positive().max(1e3).optional()
+});
+const syncChangesPageResultSchema = z.object({
+	type: z.literal("changes"),
+	updates: z.array(sequencedUpdateSchema),
+	watermark: z.number().int().nonnegative(),
+	hasMore: z.boolean()
+});
+const syncChangesResyncRequiredResultSchema = z.object({
+	type: z.literal("resyncRequired"),
+	collections: z.array(z.string()),
+	watermark: z.number().int().nonnegative()
+});
+const syncChangesResultSchema = z.discriminatedUnion("type", [syncChangesPageResultSchema, syncChangesResyncRequiredResultSchema]);
+const apiCallSchema = z.object({
+	path: z.string().min(1),
+	input: z.unknown().optional()
+});
+const collectionSubscriptionSchema = z.object({ collection: z.string().min(1) });
+const collectionSubscriptionResultSchema = z.object({
+	collection: z.string(),
+	subscriptions: z.array(z.string())
+});
+const collectionInvalidationSchema = z.object({ collection: z.string() });
+const broadcastSchema = z.object({
+	type: z.literal("updates"),
+	shardId: z.string(),
+	updates: z.array(sequencedUpdateSchema),
+	watermark: z.number().int().nonnegative(),
+	invalidations: z.array(collectionInvalidationSchema).optional()
+});
+const webSocketAttachmentSchema = z.object({
+	clientId: z.string(),
+	connectedAt: z.number(),
+	auth: z.record(z.string(), z.unknown()).optional(),
+	subscriptions: z.array(z.string()).default([])
+});
+//#endregion
+//#region src/expression.ts
+function readExpressionRow() {
+	return refProxy([], "row");
+}
+function readExpressionReferences(names) {
+	return Object.fromEntries(names.map((name) => [name, refProxy([], "reference", name)]));
+}
+function field(path) {
+	return {
+		type: "ref",
+		source: "row",
+		path: Array.isArray(path) ? path : path.split(".")
+	};
+}
+function val(value) {
+	return {
+		type: "val",
+		value
+	};
+}
+function eq(left, right) {
+	return func("eq", left, right);
+}
+function ne(left, right) {
+	return func("not_eq", left, right);
+}
+function gt(left, right) {
+	return func("gt", left, right);
+}
+function gte(left, right) {
+	return func("gte", left, right);
+}
+function lt(left, right) {
+	return func("lt", left, right);
+}
+function lte(left, right) {
+	return func("lte", left, right);
+}
+function inArray(left, values) {
+	return func("in", left, values);
+}
+function and(...expressions) {
+	return func("and", ...expressions);
+}
+function or(...expressions) {
+	return func("or", ...expressions);
+}
+function not(expression) {
+	return func("not", expression);
+}
+function compileReadExpression(expression) {
+	const unwrapped = unwrapExpression(expression);
+	if (!isFuncExpression(unwrapped)) throw new Error("Read access expressions must be function expressions");
+	if (unwrapped.name === "and" || unwrapped.name === "or") return {
+		type: unwrapped.name,
+		predicates: unwrapped.args.map(compileReadExpression)
+	};
+	if (unwrapped.name === "not") return negatePredicate(compileReadExpression(unwrapped.args[0]));
+	const comparison = comparisonFromExpression(unwrapped);
+	if (!comparison) throw new Error(`Unsupported read access operator: ${unwrapped.name}`);
+	return {
+		type: "comparison",
+		...comparison
+	};
+}
+function func(name, ...args) {
+	return {
+		type: "func",
+		name,
+		args: args.map(toExpressionArg)
+	};
+}
+function toExpressionArg(value) {
+	return isReadExpressionInput(value) ? value : val(value);
+}
+function comparisonFromExpression(expression) {
+	const op = toReadFilterOperator(expression.name);
+	const [left, right] = expression.args;
+	const leftExpression = unwrapExpression(left);
+	const rightExpression = unwrapExpression(right);
+	if (!op || !isRefExpression(leftExpression) || !isValExpression(rightExpression)) return;
+	return {
+		field: rowField(leftExpression),
+		op,
+		value: rightExpression.value
+	};
+}
+function rowField(expression) {
+	if (expression.source && expression.source !== "row") throw new Error("Read access expressions must reduce reference refs before compilation");
+	return expression.path.join(".");
+}
+function toReadFilterOperator(operator) {
+	switch (operator) {
+		case "eq":
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte":
+		case "in": return operator;
+		case "not_eq": return "ne";
+		default: return;
+	}
+}
+function negatePredicate(predicate) {
+	if (predicate.type === "and" || predicate.type === "or") return {
+		type: predicate.type === "and" ? "or" : "and",
+		predicates: predicate.predicates.map(negatePredicate)
+	};
+	const comparison = predicate;
+	return {
+		...comparison,
+		op: negateOperator(comparison.op)
+	};
+}
+function negateOperator(operator) {
+	switch (operator) {
+		case "eq": return "ne";
+		case "ne": return "eq";
+		case "gt": return "lte";
+		case "gte": return "lt";
+		case "lt": return "gte";
+		case "lte": return "gt";
+		case "in": throw new Error("Unsupported read access operator: not(in)");
+	}
+}
+function refProxy(path, source, name) {
+	return new Proxy({
+		type: "ref",
+		source,
+		...name ? { name } : {},
+		path
+	}, { get(target, property) {
+		if (property in target) return target[property];
+		if (typeof property === "symbol") return;
+		return refProxy([...path, property], source, name);
+	} });
+}
+function unwrapExpression(value) {
+	if (typeof value === "object" && value !== null && "expression" in value && isExpressionLike(value.expression)) return value.expression;
+	return value;
+}
+function isReadExpressionInput(value) {
+	return isExpressionLike(value) || typeof value === "object" && value !== null && "expression" in value && isReadExpressionInput(value.expression);
+}
+function isExpressionLike(value) {
+	return typeof value === "object" && value !== null && "type" in value;
+}
+function isFuncExpression(value) {
+	return isExpressionLike(value) && value.type === "func" && typeof value.name === "string" && Array.isArray(value.args);
+}
+function isRefExpression(value) {
+	return isExpressionLike(value) && value.type === "ref" && Array.isArray(value.path);
+}
+function isValExpression(value) {
+	return isExpressionLike(value) && value.type === "val";
+}
+//#endregion
+//#region src/predicate-match.ts
+function matchesReadPredicate(row, predicate) {
+	if (!predicate) return true;
+	if (predicate.type === "comparison") return matchesComparison(row, predicate);
+	if (predicate.type === "and") return predicate.predicates.every((child) => matchesReadPredicate(row, child));
+	return predicate.predicates.some((child) => matchesReadPredicate(row, child));
+}
+function matchesComparison(row, predicate) {
+	const value = valueAtPath(row, predicate.field);
+	switch (predicate.op) {
+		case "eq": return value === predicate.value;
+		case "ne": return value !== predicate.value;
+		case "gt": return compareValues(value, predicate.value, (left, right) => left > right);
+		case "gte": return compareValues(value, predicate.value, (left, right) => left >= right);
+		case "lt": return compareValues(value, predicate.value, (left, right) => left < right);
+		case "lte": return compareValues(value, predicate.value, (left, right) => left <= right);
+		case "in": return Array.isArray(predicate.value) && predicate.value.includes(value);
+	}
+}
+function compareValues(left, right, compare) {
+	if (typeof left === "number" && typeof right === "number") return compare(left, right);
+	if (typeof left === "string" && typeof right === "string") return compare(left, right);
+	return false;
+}
+function valueAtPath(row, fieldName) {
+	return fieldName.split(".").reduce((value, segment) => {
+		if (typeof value !== "object" || value === null) return;
+		return value[segment];
+	}, row);
+}
+//#endregion
+//#region src/rpc.ts
+const rpcIdSchema = z.union([z.string(), z.number()]).nullable().optional();
+const rpcInputSchema = z.object({ json: z.unknown() });
+const clientRpcMutationRequestSchema = z.object({
+	id: rpcIdSchema,
+	method: z.literal("mutation"),
+	params: z.object({
+		path: z.literal("push"),
+		input: z.object({ json: batchSchema })
+	})
+});
+const clientRpcReadQueryRequestSchema = z.object({
+	id: rpcIdSchema,
+	method: z.literal("query"),
+	params: z.object({
+		path: z.literal("read"),
+		input: z.object({ json: readQuerySchema })
+	})
+});
+const clientRpcChangesQueryRequestSchema = z.object({
+	id: rpcIdSchema,
+	method: z.literal("query"),
+	params: z.object({
+		path: z.literal("changes"),
+		input: z.object({ json: syncChangesQuerySchema })
+	})
+});
+const clientRpcApiCallRequestSchema = z.object({
+	id: rpcIdSchema,
+	method: z.literal("mutation"),
+	params: z.object({
+		path: z.literal("api"),
+		input: z.object({ json: apiCallSchema })
+	})
+});
+const clientRpcSubscriptionRequestSchema = z.object({
+	id: rpcIdSchema,
+	method: z.enum(["subscribe", "unsubscribe"]),
+	params: z.object({ input: z.object({ json: collectionSubscriptionSchema }) })
+});
+const clientRpcRequestSchema = z.union([
+	clientRpcMutationRequestSchema,
+	clientRpcReadQueryRequestSchema,
+	clientRpcChangesQueryRequestSchema,
+	clientRpcApiCallRequestSchema,
+	clientRpcSubscriptionRequestSchema
+]);
+const rpcResultMessageSchema = z.object({
+	id: rpcIdSchema,
+	result: z.object({
+		type: z.literal("data"),
+		data: rpcInputSchema
+	})
+});
+const rpcErrorMessageSchema = z.object({
+	id: rpcIdSchema,
+	error: z.object({ message: z.string() })
+});
+const subscriptionMessageSchema = z.object({
+	method: z.literal("subscription"),
+	params: z.object({
+		path: z.literal("updates"),
+		input: z.object({ json: broadcastSchema })
+	})
+});
+const serverMessageSchema = z.union([
+	rpcResultMessageSchema,
+	rpcErrorMessageSchema,
+	subscriptionMessageSchema
+]);
+function parseClientRpcRequest(data) {
+	return clientRpcRequestSchema.parse(decodeMessage(data));
+}
+function parseServerMessage(data) {
+	return serverMessageSchema.parse(decodeMessage(data));
+}
+function readRpcId(data) {
+	try {
+		const message = z.object({ id: rpcIdSchema }).safeParse(decodeMessage(data));
+		return message.success ? message.data.id : null;
+	} catch {
+		return null;
+	}
+}
+function encodeClientRpcRequest(message) {
+	return encodeMessage(message);
+}
+function encodeServerMessage(message) {
+	return encodeMessage(message);
+}
+function sendClientRpcRequest(socket, message) {
+	socket.send(encodeClientRpcRequest(message));
+}
+function sendServerMessage(socket, message) {
+	socket.send(encodeServerMessage(message));
+}
+function decodeMessage(data) {
+	if (typeof data === "string") return decode(new TextEncoder().encode(data));
+	return decode(data);
+}
+function encodeMessage(message) {
+	const bytes = encode(message);
+	const buffer = new ArrayBuffer(bytes.byteLength);
+	new Uint8Array(buffer).set(bytes);
+	return buffer;
+}
+//#endregion
+export { and, apiCallSchema, batchSchema, broadcastSchema, clientRpcRequestSchema, collectionInvalidationSchema, collectionSubscriptionResultSchema, collectionSubscriptionSchema, compileReadExpression, encodeClientRpcRequest, encodeServerMessage, eq, field, gt, gte, inArray, lt, lte, matchesReadPredicate, ne, not, operationTypeSchema, or, parseClientRpcRequest, parseServerMessage, pushResultSchema, readCursorSchema, readExpressionReferences, readExpressionRow, readFilterOperatorSchema, readFilterSchema, readOrderBySchema, readPredicateSchema, readQuerySchema, readResultSchema, readRpcId, rpcErrorMessageSchema, rpcIdSchema, rpcResultMessageSchema, sendClientRpcRequest, sendServerMessage, sequencedUpdateSchema, serverMessageSchema, subscriptionMessageSchema, syncChangesQuerySchema, syncChangesResultSchema, updateSchema, val, webSocketAttachmentSchema };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/api.ts","../src/expression.ts","../src/predicate-match.ts","../src/rpc.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const operationTypeSchema = z.enum([\"insert\", \"update\", \"delete\"]);\n\nexport const updateSchema = z.object({\n  id: z.string(),\n  collection: z.string(),\n  path: z.string().optional(),\n  key: z.union([z.string(), z.number()]),\n  type: operationTypeSchema,\n  value: z.unknown().optional(),\n  previousValue: z.unknown().optional(),\n  clientId: z.string().optional(),\n  createdAt: z.number(),\n});\n\nexport const sequencedUpdateSchema = updateSchema.extend({\n  sequence: z.number().int().positive(),\n  serverCreatedAt: z.string(),\n});\n\nexport const batchSchema = z.object({\n  updates: z.array(updateSchema).min(1),\n});\n\nexport const readFilterOperatorSchema = z.enum([\"eq\", \"ne\", \"gt\", \"gte\", \"lt\", \"lte\", \"in\"]);\n\nexport const readFilterSchema = z.object({\n  field: z.string().min(1),\n  op: readFilterOperatorSchema.default(\"eq\"),\n  value: z.unknown(),\n});\n\nexport type ReadPredicate =\n  | {\n      type: \"comparison\";\n      field: string;\n      op: z.infer<typeof readFilterOperatorSchema>;\n      value: unknown;\n    }\n  | {\n      type: \"and\" | \"or\";\n      predicates: Array<ReadPredicate>;\n    };\n\nconst readComparisonPredicateSchema = z.object({\n  type: z.literal(\"comparison\"),\n  field: z.string().min(1),\n  op: readFilterOperatorSchema,\n  value: z.unknown(),\n});\n\nconst readCompoundPredicateSchema = z.object({\n  type: z.enum([\"and\", \"or\"]),\n  predicates: z.array(z.lazy(() => readPredicateSchema)).min(1),\n});\n\nexport const readPredicateSchema: z.ZodType<ReadPredicate> = z.lazy(() =>\n  z.discriminatedUnion(\"type\", [readComparisonPredicateSchema, readCompoundPredicateSchema]),\n);\n\nexport const readOrderBySchema = z.object({\n  field: z.string().min(1),\n  direction: z.enum([\"asc\", \"desc\"]).default(\"asc\"),\n});\n\nexport const readCursorSchema = z.object({\n  whereCurrent: readPredicateSchema,\n  whereFrom: readPredicateSchema,\n  lastKey: z.union([z.string(), z.number()]).optional(),\n});\n\nexport const readQuerySchema = z.object({\n  collection: z.string(),\n  filters: z.array(readFilterSchema).optional(),\n  predicate: readPredicateSchema.optional(),\n  orderBy: z.array(readOrderBySchema).optional(),\n  cursor: readCursorSchema.optional(),\n  limit: z.number().int().positive().max(1000).optional(),\n  offset: z.number().int().nonnegative().optional(),\n});\n\nexport const readResultSchema = z.object({\n  rows: z.array(z.unknown()),\n});\n\nexport const pushResultSchema = z.object({\n  accepted: z.number().int().nonnegative(),\n  watermark: z.number().int().nonnegative(),\n});\n\nexport const syncChangesQuerySchema = z.object({\n  collections: z.record(z.string(), z.number().int().nonnegative()),\n  limit: z.number().int().positive().max(1000).optional(),\n});\n\nconst syncChangesPageResultSchema = z.object({\n  type: z.literal(\"changes\"),\n  updates: z.array(sequencedUpdateSchema),\n  watermark: z.number().int().nonnegative(),\n  hasMore: z.boolean(),\n});\n\nconst syncChangesResyncRequiredResultSchema = z.object({\n  type: z.literal(\"resyncRequired\"),\n  collections: z.array(z.string()),\n  watermark: z.number().int().nonnegative(),\n});\n\nexport const syncChangesResultSchema = z.discriminatedUnion(\"type\", [\n  syncChangesPageResultSchema,\n  syncChangesResyncRequiredResultSchema,\n]);\n\nexport const apiCallSchema = z.object({\n  path: z.string().min(1),\n  input: z.unknown().optional(),\n});\n\nexport const collectionSubscriptionSchema = z.object({\n  collection: z.string().min(1),\n});\n\nexport const collectionSubscriptionResultSchema = z.object({\n  collection: z.string(),\n  subscriptions: z.array(z.string()),\n});\n\nexport const collectionInvalidationSchema = z.object({\n  collection: z.string(),\n});\n\nexport const broadcastSchema = z.object({\n  type: z.literal(\"updates\"),\n  shardId: z.string(),\n  updates: z.array(sequencedUpdateSchema),\n  watermark: z.number().int().nonnegative(),\n  invalidations: z.array(collectionInvalidationSchema).optional(),\n});\n\nexport const webSocketAttachmentSchema = z.object({\n  clientId: z.string(),\n  connectedAt: z.number(),\n  auth: z.record(z.string(), z.unknown()).optional(),\n  subscriptions: z.array(z.string()).default([]),\n});\n\nexport type OperationType = z.infer<typeof operationTypeSchema>;\nexport type Update = z.infer<typeof updateSchema>;\nexport type SequencedUpdate = z.infer<typeof sequencedUpdateSchema>;\nexport type Batch = z.infer<typeof batchSchema>;\nexport type ReadFilterOperator = z.infer<typeof readFilterOperatorSchema>;\nexport type ReadFilter = z.output<typeof readFilterSchema>;\nexport type ReadFilterInput = z.input<typeof readFilterSchema>;\nexport type ReadCursor = z.output<typeof readCursorSchema>;\nexport type ReadCursorInput = z.input<typeof readCursorSchema>;\nexport type ReadOrderBy = z.output<typeof readOrderBySchema>;\nexport type ReadOrderByInput = z.input<typeof readOrderBySchema>;\nexport type ApiCall = z.output<typeof apiCallSchema>;\nexport type ApiCallInput = z.input<typeof apiCallSchema>;\nexport type CollectionSubscription = z.output<typeof collectionSubscriptionSchema>;\nexport type CollectionSubscriptionInput = z.input<typeof collectionSubscriptionSchema>;\nexport type CollectionSubscriptionResult = z.output<typeof collectionSubscriptionResultSchema>;\nexport type CollectionInvalidation = z.output<typeof collectionInvalidationSchema>;\n\nexport interface ApiRoute<TInput = unknown, TOutput = unknown> {\n  input: TInput;\n  output: TOutput;\n}\n\nexport type ApiContract = Record<string, ApiRoute>;\nexport type ApiPath<TApi extends ApiContract> = Extract<keyof TApi, string>;\nexport type ApiInput<TApi extends ApiContract, TPath extends ApiPath<TApi>> = TApi[TPath][\"input\"];\nexport type ApiOutput<\n  TApi extends ApiContract,\n  TPath extends ApiPath<TApi>,\n> = TApi[TPath][\"output\"];\nexport type ApiCallArgs<TApi extends ApiContract, TPath extends ApiPath<TApi>> =\n  undefined extends ApiInput<TApi, TPath>\n    ? [input?: ApiInput<TApi, TPath>]\n    : [input: ApiInput<TApi, TPath>];\n\nexport interface ReadQuery {\n  collection: string;\n  filters?: Array<ReadFilter>;\n  predicate?: ReadPredicate;\n  orderBy?: Array<ReadOrderBy>;\n  cursor?: ReadCursor;\n  limit?: number;\n  offset?: number;\n}\nexport interface ReadQueryInput {\n  collection: string;\n  filters?: Array<ReadFilterInput>;\n  predicate?: ReadPredicate;\n  orderBy?: Array<ReadOrderByInput>;\n  cursor?: ReadCursorInput;\n  limit?: number;\n  offset?: number;\n}\nexport type PushResult = z.infer<typeof pushResultSchema>;\nexport type SyncChangesQuery = z.output<typeof syncChangesQuerySchema>;\nexport type SyncChangesQueryInput = z.input<typeof syncChangesQuerySchema>;\nexport type SyncChangesResult = z.infer<typeof syncChangesResultSchema>;\nexport type Broadcast = z.infer<typeof broadcastSchema>;\nexport type WebSocketAttachment = z.infer<typeof webSocketAttachmentSchema>;\n\nexport interface ReadResult<T = unknown> {\n  rows: Array<T>;\n}\n","import type { ReadFilterOperator, ReadPredicate } from \"./api\";\n\nexport type ReadExpression =\n  | FuncExpression\n  | RefExpression\n  | ValExpression\n  | { expression: ReadExpression };\ntype ReadExpressionNode = FuncExpression | RefExpression | ValExpression;\n\nexport interface FuncExpression {\n  type: \"func\";\n  name: string;\n  args: Array<unknown>;\n}\n\nexport interface RefExpression {\n  type: \"ref\";\n  source?: \"row\" | \"reference\";\n  name?: string;\n  path: Array<string | number>;\n}\n\nexport interface ValExpression {\n  type: \"val\";\n  value: unknown;\n}\n\nexport type ReadExpressionInput = ReadExpression;\nexport type ReadExpressionField = RefExpression & Record<string, any>;\nexport type ReadExpressionRow<T extends object = Record<string, unknown>> = {\n  readonly [K in keyof T]: ReadExpressionField;\n};\n\nexport function readExpressionRow<\n  T extends object = Record<string, unknown>,\n>(): ReadExpressionRow<T> {\n  return refProxy([], \"row\") as ReadExpressionRow<T>;\n}\n\nexport function readExpressionReferences<\n  TReferences extends Record<string, object> = Record<string, Record<string, unknown>>,\n>(\n  names: Array<keyof TReferences & string>,\n): {\n  readonly [K in keyof TReferences]: ReadExpressionRow<TReferences[K]>;\n} {\n  return Object.fromEntries(\n    names.map((name) => [name, refProxy([], \"reference\", name)]),\n  ) as unknown as {\n    readonly [K in keyof TReferences]: ReadExpressionRow<TReferences[K]>;\n  };\n}\n\nexport function field(path: string | Array<string | number>): RefExpression {\n  return {\n    type: \"ref\",\n    source: \"row\",\n    path: Array.isArray(path) ? path : path.split(\".\"),\n  };\n}\n\nexport function val(value: unknown): ValExpression {\n  return { type: \"val\", value };\n}\n\nexport function eq(left: unknown, right: unknown): FuncExpression {\n  return func(\"eq\", left, right);\n}\n\nexport function ne(left: unknown, right: unknown): FuncExpression {\n  return func(\"not_eq\", left, right);\n}\n\nexport function gt(left: unknown, right: unknown): FuncExpression {\n  return func(\"gt\", left, right);\n}\n\nexport function gte(left: unknown, right: unknown): FuncExpression {\n  return func(\"gte\", left, right);\n}\n\nexport function lt(left: unknown, right: unknown): FuncExpression {\n  return func(\"lt\", left, right);\n}\n\nexport function lte(left: unknown, right: unknown): FuncExpression {\n  return func(\"lte\", left, right);\n}\n\nexport function inArray(left: unknown, values: unknown): FuncExpression {\n  return func(\"in\", left, values);\n}\n\nexport function and(...expressions: Array<unknown>): FuncExpression {\n  return func(\"and\", ...expressions);\n}\n\nexport function or(...expressions: Array<unknown>): FuncExpression {\n  return func(\"or\", ...expressions);\n}\n\nexport function not(expression: unknown): FuncExpression {\n  return func(\"not\", expression);\n}\n\nexport function compileReadExpression(expression: unknown): ReadPredicate {\n  const unwrapped = unwrapExpression(expression);\n\n  if (!isFuncExpression(unwrapped)) {\n    throw new Error(\"Read access expressions must be function expressions\");\n  }\n\n  if (unwrapped.name === \"and\" || unwrapped.name === \"or\") {\n    return {\n      type: unwrapped.name,\n      predicates: unwrapped.args.map(compileReadExpression),\n    };\n  }\n\n  if (unwrapped.name === \"not\") {\n    return negatePredicate(compileReadExpression(unwrapped.args[0]));\n  }\n\n  const comparison = comparisonFromExpression(unwrapped);\n  if (!comparison) {\n    throw new Error(`Unsupported read access operator: ${unwrapped.name}`);\n  }\n\n  return {\n    type: \"comparison\",\n    ...comparison,\n  };\n}\n\nfunction func(name: string, ...args: Array<unknown>): FuncExpression {\n  return {\n    type: \"func\",\n    name,\n    args: args.map(toExpressionArg),\n  };\n}\n\nfunction toExpressionArg(value: unknown): unknown {\n  return isReadExpressionInput(value) ? value : val(value);\n}\n\nfunction comparisonFromExpression(\n  expression: FuncExpression,\n): Omit<Extract<ReadPredicate, { type: \"comparison\" }>, \"type\"> | undefined {\n  const op = toReadFilterOperator(expression.name);\n  const [left, right] = expression.args;\n  const leftExpression = unwrapExpression(left);\n  const rightExpression = unwrapExpression(right);\n  if (!op || !isRefExpression(leftExpression) || !isValExpression(rightExpression)) {\n    return undefined;\n  }\n\n  return {\n    field: rowField(leftExpression),\n    op,\n    value: rightExpression.value,\n  };\n}\n\nfunction rowField(expression: RefExpression): string {\n  if (expression.source && expression.source !== \"row\") {\n    throw new Error(\"Read access expressions must reduce reference refs before compilation\");\n  }\n\n  return expression.path.join(\".\");\n}\n\nfunction toReadFilterOperator(operator: string): ReadFilterOperator | undefined {\n  switch (operator) {\n    case \"eq\":\n    case \"gt\":\n    case \"gte\":\n    case \"lt\":\n    case \"lte\":\n    case \"in\":\n      return operator;\n    case \"not_eq\":\n      return \"ne\";\n    default:\n      return undefined;\n  }\n}\n\nfunction negatePredicate(predicate: ReadPredicate): ReadPredicate {\n  if (predicate.type === \"and\" || predicate.type === \"or\") {\n    return {\n      type: predicate.type === \"and\" ? \"or\" : \"and\",\n      predicates: predicate.predicates.map(negatePredicate),\n    };\n  }\n\n  const comparison = predicate as Extract<ReadPredicate, { type: \"comparison\" }>;\n  return {\n    ...comparison,\n    op: negateOperator(comparison.op),\n  };\n}\n\nfunction negateOperator(operator: ReadFilterOperator): ReadFilterOperator {\n  switch (operator) {\n    case \"eq\":\n      return \"ne\";\n    case \"ne\":\n      return \"eq\";\n    case \"gt\":\n      return \"lte\";\n    case \"gte\":\n      return \"lt\";\n    case \"lt\":\n      return \"gte\";\n    case \"lte\":\n      return \"gt\";\n    case \"in\":\n      throw new Error(\"Unsupported read access operator: not(in)\");\n  }\n}\n\nfunction refProxy(\n  path: Array<string | number>,\n  source: RefExpression[\"source\"],\n  name?: string,\n): ReadExpressionField {\n  return new Proxy({ type: \"ref\", source, ...(name ? { name } : {}), path } as RefExpression, {\n    get(target, property) {\n      if (property in target) {\n        return target[property as keyof RefExpression];\n      }\n\n      if (typeof property === \"symbol\") {\n        return undefined;\n      }\n\n      return refProxy([...path, property], source, name);\n    },\n  }) as ReadExpressionField;\n}\n\nfunction unwrapExpression(value: unknown): unknown {\n  if (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"expression\" in value &&\n    isExpressionLike((value as { expression: unknown }).expression)\n  ) {\n    return (value as { expression: unknown }).expression;\n  }\n\n  return value;\n}\n\nfunction isReadExpressionInput(value: unknown): value is ReadExpression {\n  return (\n    isExpressionLike(value) ||\n    (typeof value === \"object\" &&\n      value !== null &&\n      \"expression\" in value &&\n      isReadExpressionInput((value as { expression: unknown }).expression))\n  );\n}\n\nfunction isExpressionLike(value: unknown): value is ReadExpressionNode {\n  return typeof value === \"object\" && value !== null && \"type\" in value;\n}\n\nfunction isFuncExpression(value: unknown): value is FuncExpression {\n  return (\n    isExpressionLike(value) &&\n    value.type === \"func\" &&\n    typeof value.name === \"string\" &&\n    Array.isArray(value.args)\n  );\n}\n\nfunction isRefExpression(value: unknown): value is RefExpression {\n  return isExpressionLike(value) && value.type === \"ref\" && Array.isArray(value.path);\n}\n\nfunction isValExpression(value: unknown): value is ValExpression {\n  return isExpressionLike(value) && value.type === \"val\";\n}\n","import type { ReadPredicate } from \"./api\";\n\nexport function matchesReadPredicate(row: unknown, predicate: ReadPredicate | undefined): boolean {\n  if (!predicate) {\n    return true;\n  }\n\n  if (predicate.type === \"comparison\") {\n    return matchesComparison(row, predicate);\n  }\n\n  if (predicate.type === \"and\") {\n    return predicate.predicates.every((child) => matchesReadPredicate(row, child));\n  }\n\n  return predicate.predicates.some((child) => matchesReadPredicate(row, child));\n}\n\nfunction matchesComparison(\n  row: unknown,\n  predicate: Extract<ReadPredicate, { type: \"comparison\" }>,\n): boolean {\n  const value = valueAtPath(row, predicate.field);\n\n  switch (predicate.op) {\n    case \"eq\":\n      return value === predicate.value;\n    case \"ne\":\n      return value !== predicate.value;\n    case \"gt\":\n      return compareValues(value, predicate.value, (left, right) => left > right);\n    case \"gte\":\n      return compareValues(value, predicate.value, (left, right) => left >= right);\n    case \"lt\":\n      return compareValues(value, predicate.value, (left, right) => left < right);\n    case \"lte\":\n      return compareValues(value, predicate.value, (left, right) => left <= right);\n    case \"in\":\n      return Array.isArray(predicate.value) && predicate.value.includes(value);\n  }\n}\n\nfunction compareValues(\n  left: unknown,\n  right: unknown,\n  compare: (left: number | string, right: number | string) => boolean,\n): boolean {\n  if (typeof left === \"number\" && typeof right === \"number\") {\n    return compare(left, right);\n  }\n\n  if (typeof left === \"string\" && typeof right === \"string\") {\n    return compare(left, right);\n  }\n\n  return false;\n}\n\nfunction valueAtPath(row: unknown, fieldName: string): unknown {\n  return fieldName.split(\".\").reduce<unknown>((value, segment) => {\n    if (typeof value !== \"object\" || value === null) {\n      return undefined;\n    }\n\n    return (value as Record<string, unknown>)[segment];\n  }, row);\n}\n","import { decode, encode } from \"@msgpack/msgpack\";\nimport { z } from \"zod\";\nimport {\n  apiCallSchema,\n  batchSchema,\n  broadcastSchema,\n  collectionSubscriptionSchema,\n  readQuerySchema,\n  syncChangesQuerySchema,\n} from \"./api\";\n\nexport const rpcIdSchema = z.union([z.string(), z.number()]).nullable().optional();\n\nconst rpcInputSchema = z.object({\n  json: z.unknown(),\n});\n\nconst clientRpcMutationRequestSchema = z.object({\n  id: rpcIdSchema,\n  method: z.literal(\"mutation\"),\n  params: z.object({\n    path: z.literal(\"push\"),\n    input: z.object({\n      json: batchSchema,\n    }),\n  }),\n});\n\nconst clientRpcReadQueryRequestSchema = z.object({\n  id: rpcIdSchema,\n  method: z.literal(\"query\"),\n  params: z.object({\n    path: z.literal(\"read\"),\n    input: z.object({\n      json: readQuerySchema,\n    }),\n  }),\n});\n\nconst clientRpcChangesQueryRequestSchema = z.object({\n  id: rpcIdSchema,\n  method: z.literal(\"query\"),\n  params: z.object({\n    path: z.literal(\"changes\"),\n    input: z.object({\n      json: syncChangesQuerySchema,\n    }),\n  }),\n});\n\nconst clientRpcApiCallRequestSchema = z.object({\n  id: rpcIdSchema,\n  method: z.literal(\"mutation\"),\n  params: z.object({\n    path: z.literal(\"api\"),\n    input: z.object({\n      json: apiCallSchema,\n    }),\n  }),\n});\n\nconst clientRpcSubscriptionRequestSchema = z.object({\n  id: rpcIdSchema,\n  method: z.enum([\"subscribe\", \"unsubscribe\"]),\n  params: z.object({\n    input: z.object({\n      json: collectionSubscriptionSchema,\n    }),\n  }),\n});\n\nexport const clientRpcRequestSchema = z.union([\n  clientRpcMutationRequestSchema,\n  clientRpcReadQueryRequestSchema,\n  clientRpcChangesQueryRequestSchema,\n  clientRpcApiCallRequestSchema,\n  clientRpcSubscriptionRequestSchema,\n]);\n\nexport const rpcResultMessageSchema = z.object({\n  id: rpcIdSchema,\n  result: z.object({\n    type: z.literal(\"data\"),\n    data: rpcInputSchema,\n  }),\n});\n\nexport const rpcErrorMessageSchema = z.object({\n  id: rpcIdSchema,\n  error: z.object({\n    message: z.string(),\n  }),\n});\n\nexport const subscriptionMessageSchema = z.object({\n  method: z.literal(\"subscription\"),\n  params: z.object({\n    path: z.literal(\"updates\"),\n    input: z.object({\n      json: broadcastSchema,\n    }),\n  }),\n});\n\nexport const serverMessageSchema = z.union([\n  rpcResultMessageSchema,\n  rpcErrorMessageSchema,\n  subscriptionMessageSchema,\n]);\n\nexport type RpcId = string | number | null | undefined;\nexport type ClientRpcRequest = z.input<typeof clientRpcRequestSchema>;\nexport type ParsedClientRpcRequest = z.output<typeof clientRpcRequestSchema>;\nexport type RpcResultMessage = z.output<typeof rpcResultMessageSchema>;\nexport type RpcErrorMessage = z.output<typeof rpcErrorMessageSchema>;\nexport type SubscriptionMessage = z.output<typeof subscriptionMessageSchema>;\nexport type ServerMessage = z.output<typeof serverMessageSchema>;\n\nexport type TransportPayload = ArrayBuffer | ArrayBufferView | string;\n\nexport interface TransportSocket {\n  send(data: ArrayBuffer): void;\n}\n\nexport function parseClientRpcRequest(data: TransportPayload): ParsedClientRpcRequest {\n  return clientRpcRequestSchema.parse(decodeMessage(data));\n}\n\nexport function parseServerMessage(data: TransportPayload): ServerMessage {\n  return serverMessageSchema.parse(decodeMessage(data));\n}\n\nexport function readRpcId(data: TransportPayload): RpcId {\n  try {\n    const message = z.object({ id: rpcIdSchema }).safeParse(decodeMessage(data));\n    return message.success ? message.data.id : null;\n  } catch {\n    return null;\n  }\n}\n\nexport function encodeClientRpcRequest(message: ClientRpcRequest): ArrayBuffer {\n  return encodeMessage(message);\n}\n\nexport function encodeServerMessage(message: ServerMessage): ArrayBuffer {\n  return encodeMessage(message);\n}\n\nexport function sendClientRpcRequest(socket: TransportSocket, message: ClientRpcRequest): void {\n  socket.send(encodeClientRpcRequest(message));\n}\n\nexport function sendServerMessage(socket: TransportSocket, message: ServerMessage): void {\n  socket.send(encodeServerMessage(message));\n}\n\nfunction decodeMessage(data: TransportPayload): unknown {\n  if (typeof data === \"string\") {\n    return decode(new TextEncoder().encode(data));\n  }\n\n  return decode(data);\n}\n\nfunction encodeMessage(message: unknown): ArrayBuffer {\n  const bytes = encode(message);\n  const buffer = new ArrayBuffer(bytes.byteLength);\n  new Uint8Array(buffer).set(bytes);\n  return buffer;\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@lsync/transport",
+  "version": "0.0.1",
+  "homepage": "https://github.com/Myrannas/lsync#readme",
+  "bugs": {
+    "url": "https://github.com/Myrannas/lsync/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Myrannas/lsync.git",
+    "directory": "packages/transport"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@msgpack/msgpack": "^3.1.3",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
+    "vite-plus": "0.2.2"
+  },
+  "scripts": {
+    "build": "vp pack"
+  }
+}