@live-state/sync 0.0.7 → 1.0.0-canary-2

package/dist/server.d.ts

@@ -1,14 +1,20 @@
 import { z } from 'zod';
-import { L as LiveObjectAny, I as IncludeClause, a as InferLiveObject, W as WhereClause, S as Simplify, b as InferInsert, c as InferUpdate, M as MaterializedLiveType, d as Schema, e as LiveCollectionAny, f as InferLiveCollection, g as InferLiveObjectWithRelationalIds, h as Logger, i as LogLevel } from './index-hO1iQ-VU.js';
+import { L as LiveObjectAny, I as IncludeClause, W as WhereClause, S as Simplify, a as InferLiveObject, b as InferInsert, c as InferUpdate, d as Schema, e as LiveCollectionAny, f as InferLiveCollection, g as InferLiveObjectWithRelationalIds, M as MaterializedLiveType, h as Logger, i as LogLevel } from './index-hO1iQ-VU.js';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { PostgresPool, Kysely } from 'kysely';
 import { Application } from 'express-ws';
 
+/**
+ * Internal Tracked Query representation. A Custom Query handler returns an
+ * unresolved query builder; the server mints a `RawQueryRequest` from it via
+ * `buildQueryRequest()`, which the query engine subscribes and resolves against
+ * storage. This is **not** an inbound client→server message — clients can only
+ * invoke named Custom Query procedures (see ADR-0002).
+ */
 declare const querySchema: z.ZodObject<{
     resource: z.ZodString;
     where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     include: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    lastSyncedAt: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         key: z.ZodString;
@@ -19,14 +25,15 @@ declare const querySchema: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 type RawQueryRequest = z.infer<typeof querySchema>;
-declare const defaultMutationSchema: z.ZodObject<{
+declare const syncDeltaSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
-    type: z.ZodLiteral<"MUTATE">;
+    type: z.ZodLiteral<"SYNC">;
     resource: z.ZodString;
-    resourceId: z.ZodOptional<z.ZodString>;
-    procedure: z.ZodEnum<{
+    resourceId: z.ZodString;
+    op: z.ZodEnum<{
         INSERT: "INSERT";
         UPDATE: "UPDATE";
+        DELETE: "DELETE";
     }>;
     payload: z.ZodRecord<z.ZodString, z.ZodObject<{
         value: z.ZodNullable<z.ZodAny>;
@@ -39,83 +46,43 @@ declare const defaultMutationSchema: z.ZodObject<{
         originMutationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-type DefaultMutation = Omit<z.infer<typeof defaultMutationSchema>, "resourceId"> & {
-    resourceId: string;
-};
+type SyncDelta = z.infer<typeof syncDeltaSchema>;
 
 type ConditionalPromise<T, P extends boolean> = P extends true ? Promise<T> : T;
 type PromiseOrSync<T> = T | Promise<T>;
 
-/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
-
-declare abstract class Storage implements DataSource {
-    /**
-     * @deprecated Use db.[collection].one(id).get() instead
-     */
-    abstract findOne<T extends LiveObjectAny, TInclude extends IncludeClause<T> | undefined = undefined>(resource: T, id: string, options?: {
-        include?: TInclude;
-    }): Promise<InferLiveObject<T, TInclude> | undefined>;
-    /**
-     * @deprecated Use db.[collection].where({...}).get() instead
-     */
-    abstract find<T extends LiveObjectAny, TInclude extends IncludeClause<T> | undefined = undefined>(resource: T, options?: {
-        where?: WhereClause<T>;
-        include?: TInclude;
-        limit?: number;
-        sort?: {
-            key: string;
-            direction: "asc" | "desc";
-        }[];
-    }): Promise<InferLiveObject<T, TInclude>[]>;
-    /**
-     * @deprecated Use db.[collection].insert({...}) instead
-     */
-    insert<T extends LiveObjectAny>(resource: T, value: Simplify<InferInsert<T>>): Promise<InferLiveObject<T>>;
-    /**
-     * @deprecated Use db.[collection].update(id, {...}) instead
-     */
-    update<T extends LiveObjectAny>(resource: T, resourceId: string, value: InferUpdate<T>): Promise<Partial<InferLiveObject<T>>>;
-    abstract transaction<T>(fn: (opts: {
-        trx: Storage;
-        commit: () => Promise<void>;
-        rollback: () => Promise<void>;
-    }) => Promise<T>): Promise<T>;
-}
-
-/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
-
-declare class Batcher {
-    private storage;
-    private queue;
-    private scheduled;
-    constructor(storage: Storage);
-    rawFind<T extends LiveObjectAny>({ resource, commonWhere, uniqueWhere, ...rest }: {
-        resource: string;
-        commonWhere?: Record<string, any>;
-        uniqueWhere?: Record<string, any>;
-        include?: Record<string, any>;
-        limit?: number;
-        sort?: {
-            key: string;
-            direction: "asc" | "desc";
-        }[];
-    }): Promise<MaterializedLiveType<T>[]>;
-    private getBatchKey;
-    private processBatch;
-    private executeBatchedRequests;
-}
-
 interface DataSource {
     get(query: RawQueryRequest, extra?: {
         context?: any;
-        batcher?: Batcher;
     }): PromiseOrSync<any[]>;
 }
 
 /** biome-ignore-all lint/complexity/noBannedTypes: <explanation> */
 
+interface QueryExecutor extends DataSource {
+    subscribe(query: RawQueryRequest, callback: (value: any[]) => void): () => void;
+}
 type InferQueryResult<TCollection extends LiveObjectAny, TInclude extends IncludeClause<TCollection>, TSingle extends boolean = false> = TSingle extends true ? Simplify<InferLiveObject<TCollection, TInclude>> | undefined : Simplify<InferLiveObject<TCollection, TInclude>>[];
+/**
+ * Type-only brand recording a {@link QueryBuilder}'s inferable parameters.
+ *
+ * `CustomQueryResult` (client entry point) has to recognise a query-builder
+ * value returned from a route handler whose type flows through the *server*
+ * entry point. The two entry points are emitted as separate `.d.ts` graphs, so
+ * each gets its own `declare class QueryBuilder`; because the class has
+ * `private` members, TypeScript compares those declarations *nominally* and any
+ * `extends QueryBuilder<...>` check across the boundary fails. Narrowing on this
+ * structural brand instead makes the check independent of class identity — and
+ * therefore also of duplicate installed package versions.
+ */
+interface QueryBuilderBrand<TCollection extends LiveObjectAny, TInclude extends IncludeClause<TCollection>, TSingle extends boolean> {
+    collection: TCollection;
+    include: TInclude;
+    single: TSingle;
+}
 declare class QueryBuilder<TCollection extends LiveObjectAny, TInclude extends IncludeClause<TCollection> = {}, TSingle extends boolean = false, TShouldAwait extends boolean = false> {
+    /** Never assigned at runtime; exists only to carry {@link QueryBuilderBrand}. */
+    readonly __queryBuilderBrand: QueryBuilderBrand<TCollection, TInclude, TSingle>;
     private _collection;
     private _client;
     private _where;
@@ -148,6 +115,42 @@ declare class QueryBuilder<TCollection extends LiveObjectAny, TInclude extends I
 
 /** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
 
+declare abstract class Storage implements DataSource {
+    /**
+     * @deprecated Use db.[collection].one(id).get() instead
+     */
+    abstract findOne<T extends LiveObjectAny, TInclude extends IncludeClause<T> | undefined = undefined>(resource: T, id: string, options?: {
+        include?: TInclude;
+    }): Promise<InferLiveObject<T, TInclude> | undefined>;
+    /**
+     * @deprecated Use db.[collection].where({...}).get() instead
+     */
+    abstract find<T extends LiveObjectAny, TInclude extends IncludeClause<T> | undefined = undefined>(resource: T, options?: {
+        where?: WhereClause<T>;
+        include?: TInclude;
+        limit?: number;
+        sort?: {
+            key: string;
+            direction: "asc" | "desc";
+        }[];
+    }): Promise<InferLiveObject<T, TInclude>[]>;
+    /**
+     * @deprecated Use db.[collection].insert({...}) instead
+     */
+    insert<T extends LiveObjectAny>(resource: T, value: Simplify<InferInsert<T>>): Promise<InferLiveObject<T>>;
+    /**
+     * @deprecated Use db.[collection].update(id, {...}) instead
+     */
+    update<T extends LiveObjectAny>(resource: T, resourceId: string, value: InferUpdate<T>): Promise<Partial<InferLiveObject<T>>>;
+    abstract transaction<T>(fn: (opts: {
+        trx: Storage;
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+    }) => Promise<T>): Promise<T>;
+}
+
+/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
+
 /**
  * A QueryBuilder with added insert() and update() mutation methods for server-side use.
  */
@@ -214,100 +217,20 @@ type ServerDB<TSchema extends Schema<any>> = {
  */
 declare function createServerDB<TSchema extends Schema<any>>(storage: Storage, schema: TSchema, context?: Record<string, any>): ServerDB<TSchema>;
 
-/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
-/** biome-ignore-all lint/style/noNonNullAssertion: false positive */
+/** biome-ignore-all lint/suspicious/noExplicitAny: hooks operate generically over any entity shape */
 
-type AnyProcedureRoute = ProcedureRoute<Middleware<any>, Record<string, any>, Record<string, any>, any, any>;
-type AnyRouteOrProcedure = AnyRoute | AnyProcedureRoute;
-type RouteRecord = Record<string, AnyRouteOrProcedure>;
-declare class Router<TRoutes extends RouteRecord> {
-    readonly routes: TRoutes;
-    readonly hooksRegistry: Map<string, Hooks<any, any, any>>;
-    private constructor();
-    static create<TRoutes extends RouteRecord>(opts: {
-        routes: TRoutes;
-    }): Router<TRoutes>;
-    getHooks(resourceName: string): Hooks<any, any, any> | undefined;
-}
-declare const router: <TSchema extends Schema<any>, TRoutes extends Record<keyof TSchema, Route<any, any, any, any, any, any>> & Record<string, Route<any, any, any, any, any, any> | ProcedureRoute<any, any, any, any, any>>>(opts: {
-    schema: TSchema;
-    routes: TRoutes;
-}) => Router<TRoutes>;
-type AnyRouter = Router<any>;
-type QueryResult<TShape extends LiveObjectAny> = {
-    data: MaterializedLiveType<TShape>[];
-    unsubscribe?: () => void;
-};
-type MutationResult<TShape extends LiveObjectAny> = {
-    data: MaterializedLiveType<TShape>;
-    acceptedValues: Record<string, any> | null;
-};
-type Mutation<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput, TContext = Record<string, any>> = {
-    _type: "mutation";
-    inputValidator: TInputValidator;
-    handler: (opts: {
-        req: MutationRequest<TInputValidator extends StandardSchemaV1<any, any> ? StandardSchemaV1.InferOutput<TInputValidator> : undefined, TContext>;
-        db: ServerDB<any>;
-    }) => TOutput;
-};
-interface QueryProcedureRequest<TInput = any, TContext = Record<string, any>> extends BaseRequest<TContext> {
-    type: "CUSTOM_QUERY";
-    input: TInput;
-    resource: string;
-    procedure: string;
-}
-type Query<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput, TContext = Record<string, any>> = {
-    _type: "query";
-    inputValidator: TInputValidator;
-    handler: (opts: {
-        req: QueryProcedureRequest<TInputValidator extends StandardSchemaV1<any, any> ? StandardSchemaV1.InferOutput<TInputValidator> : undefined, TContext>;
-        db: ServerDB<any>;
-    }) => TOutput;
-};
-type Procedure<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput, TContext = Record<string, any>> = Mutation<TInputValidator, TOutput, TContext> | Query<TInputValidator, TOutput, TContext>;
-type QueryCreator<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = {
-    (): {
-        handler: <TOutput>(handler: (opts: {
-            req: QueryProcedureRequest<undefined, TContext>;
-            db: ServerDB<TSchema>;
-        }) => TOutput) => Query<StandardSchemaV1<any, undefined>, TOutput, TContext>;
-    };
-    <TInputValidator extends StandardSchemaV1<any, any>>(validator: TInputValidator): {
-        handler: <THandler extends (opts: {
-            req: QueryProcedureRequest<StandardSchemaV1.InferOutput<TInputValidator>, TContext>;
-            db: ServerDB<TSchema>;
-        }) => any>(handler: THandler) => Query<TInputValidator, ReturnType<THandler>, TContext>;
-    };
-};
-type MutationCreator<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = {
-    (): {
-        handler: <TOutput>(handler: (opts: {
-            req: MutationRequest<undefined, TContext>;
-            db: ServerDB<TSchema>;
-        }) => TOutput) => Mutation<StandardSchemaV1<any, undefined>, TOutput, TContext>;
-    };
-    <TInputValidator extends StandardSchemaV1<any, any>>(validator: TInputValidator): {
-        handler: <THandler extends (opts: {
-            req: MutationRequest<StandardSchemaV1.InferOutput<TInputValidator>, TContext>;
-            db: ServerDB<TSchema>;
-        }) => any>(handler: THandler) => Mutation<TInputValidator, ReturnType<THandler>, TContext>;
-    };
-};
-type ReadAuthorizationHandler<TShape extends LiveObjectAny, TContext = Record<string, any>> = (opts: {
-    ctx: TContext;
-}) => WhereClause<TShape> | boolean;
-type MutationAuthorizationHandler<TShape extends LiveObjectAny, TContext = Record<string, any>> = (opts: {
-    ctx: TContext;
-    value: Simplify<InferLiveObjectWithRelationalIds<TShape>>;
-}) => WhereClause<TShape> | boolean;
-type Authorization<TShape extends LiveObjectAny, TContext = Record<string, any>> = {
-    read?: ReadAuthorizationHandler<TShape, TContext>;
-    insert?: MutationAuthorizationHandler<TShape, TContext>;
-    update?: {
-        preMutation?: MutationAuthorizationHandler<TShape, TContext>;
-        postMutation?: MutationAuthorizationHandler<TShape, TContext>;
-    };
-};
+/**
+ * Database lifecycle hooks.
+ *
+ * These fire from the storage layer around every committed write (insert /
+ * update), regardless of how the write was produced — a custom mutation
+ * handler calling `db.x.insert(...)`, a transaction, etc. They are *not* tied
+ * to a particular mutation procedure.
+ *
+ * `before*` handlers may return a transformed raw value to replace what gets
+ * persisted; returning `void` leaves the value unchanged. `after*` handlers run
+ * once the write is committed.
+ */
 type BeforeInsertHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = (opts: {
     ctx?: TContext;
     value: Simplify<InferLiveObjectWithRelationalIds<TShape>> & {
@@ -354,73 +277,8 @@ type Hooks<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<an
     beforeUpdate?: BeforeUpdateHook<TShape, TSchema, TContext>;
     afterUpdate?: AfterUpdateHook<TShape, TSchema, TContext>;
 };
-declare class Route<TResourceSchema extends LiveObjectAny, TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, any>>, TCustomQueries extends Record<string, Query<any, any>>, TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> {
-    readonly resourceSchema: TResourceSchema;
-    readonly middlewares: Set<TMiddleware>;
-    readonly customMutations: TCustomMutations;
-    readonly customQueries: TCustomQueries;
-    readonly authorization?: Authorization<TResourceSchema, TContext>;
-    readonly hooks?: Hooks<TResourceSchema, TSchema, TContext>;
-    constructor(resourceSchema: TResourceSchema, customMutations?: TCustomMutations, customQueries?: TCustomQueries, authorization?: Authorization<TResourceSchema, TContext>, hooks?: Hooks<TResourceSchema, TSchema, TContext>);
-    use(...middlewares: TMiddleware[]): this;
-    withProcedures<T extends Record<string, Procedure<any, any, any>>>(procedureFactory: (opts: {
-        mutation: MutationCreator<TSchema, TContext>;
-        query: QueryCreator<TSchema, TContext>;
-    }) => T): Route<TResourceSchema, TMiddleware, { [K in keyof T as T[K] extends Mutation<any, any, Record<string, any>> ? K : never]: Extract<T[K], Mutation<any, any, Record<string, any>>>; }, { [K_1 in keyof T as T[K_1] extends Query<any, any, Record<string, any>> ? K_1 : never]: Extract<T[K_1], Query<any, any, Record<string, any>>>; }, TSchema, TContext>;
-    /**
-     * @deprecated Use `withProcedures` instead
-     */
-    withMutations<T extends Record<string, Mutation<any, any>>>(mutationFactory: (opts: {
-        mutation: MutationCreator<TSchema, TContext>;
-    }) => T): Route<TResourceSchema, TMiddleware, { [K in keyof T as T[K] extends Mutation<any, any, Record<string, any>> ? K : never]: Extract<T[K], Mutation<any, any, Record<string, any>>>; }, { [K_1 in keyof T as T[K_1] extends Query<any, any, Record<string, any>> ? K_1 : never]: Extract<T[K_1], Query<any, any, Record<string, any>>>; }, TSchema, TContext>;
-    /**
-     * @deprecated Declare hooks with `defineHooks` and pass them to `server({ hooks })` instead.
-     */
-    withHooks(hooks: Hooks<TResourceSchema, TSchema, TContext>): Route<TResourceSchema, TMiddleware, TCustomMutations, TCustomQueries, TSchema, TContext>;
-    getAuthorizationClause(req: QueryRequest): WhereClause<TResourceSchema> | undefined | boolean;
-    private handleSet;
-    private wrapInMiddlewares;
-}
-declare class ProcedureRoute<TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, any>>, TCustomQueries extends Record<string, Query<any, any>>, TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> {
-    readonly resourceSchema: undefined;
-    readonly middlewares: Set<TMiddleware>;
-    readonly customMutations: TCustomMutations;
-    readonly customQueries: TCustomQueries;
-    constructor(customMutations?: TCustomMutations, customQueries?: TCustomQueries);
-    use(...middlewares: TMiddleware[]): this;
-    getAuthorizationClause(): undefined;
-    private wrapInMiddlewares;
-}
-type TypedMiddleware<TContextIn, TContextOut> = {
-    _brand: "TypedMiddleware";
-    _rawMiddleware: Middleware<any>;
-    _contextIn?: TContextIn;
-    _contextOut?: TContextOut;
-};
-declare function createMiddleware<TContextIn, TContextOut = TContextIn>(fn: (opts: {
-    ctx: TContextIn;
-    req: Request<TContextIn>;
-    next: (ctx: TContextOut) => any;
-}) => any): TypedMiddleware<TContextIn, TContextOut>;
-declare class RouteFactory<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> {
-    private middlewares;
-    private constructor();
-    collectionRoute<T extends LiveObjectAny>(shape: T, authorization?: Authorization<T, TContext>): Route<T, Middleware<any>, Record<string, never>, Record<string, never>, TSchema, TContext>;
-    withProcedures<T extends Record<string, Procedure<any, any, any>>>(procedureFactory: (opts: {
-        mutation: MutationCreator<TSchema, TContext>;
-        query: QueryCreator<TSchema, TContext>;
-    }) => T): ProcedureRoute<Middleware<any>, { [K in keyof T as T[K] extends Mutation<any, any, Record<string, any>> ? K : never]: T[K]; } & Record<string, Mutation<any, any, Record<string, any>>>, { [K_1 in keyof T as T[K_1] extends Query<any, any, Record<string, any>> ? K_1 : never]: T[K_1]; } & Record<string, Query<any, any, Record<string, any>>>, TSchema, TContext>;
-    use<TNewContext>(mw: TypedMiddleware<TContext, TNewContext>): RouteFactory<TSchema, TNewContext>;
-    use(...middlewares: Middleware<any>[]): RouteFactory<TSchema, TContext>;
-    static create<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>>(): RouteFactory<TSchema, TContext>;
-}
-declare const routeFactory: typeof RouteFactory.create;
-type AnyRoute = Route<LiveObjectAny, Middleware<any>, Record<string, any>, Record<string, any>, any, any>;
-
-/** biome-ignore-all lint/suspicious/noExplicitAny: hooks operate generically over any entity shape */
-
 /**
- * Schema-keyed registry of lifecycle hooks.
+ * Schema-keyed registry of database lifecycle hooks.
  *
  * Top-level keys are constrained to entity names on `TSchema`. Per-entity
  * payloads (`value`, `rawValue`, `previousValue`, …) are inferred from the
@@ -430,11 +288,11 @@ type HooksRegistry<TSchema extends Schema<any>, TContext = Record<string, any>>
     [K in keyof TSchema]?: TSchema[K] extends LiveObjectAny ? Hooks<TSchema[K], TSchema, TContext> : never;
 };
 /**
- * Declares lifecycle hooks for a schema.
+ * Declares database lifecycle hooks for a schema.
  *
  * Identity function whose generic parameters constrain the returned object's
  * top-level keys to schema entity names and thread `TContext` through to
- * handler payloads.
+ * handler payloads. Pass the result to `server({ hooks })`.
  *
  * @example
  * ```ts
@@ -466,6 +324,114 @@ declare const mergeEntityHooks: (slices: Array<AnyHooks | undefined>) => AnyHook
  */
 declare const mergeHooks: <TSchema extends Schema<any>, TContext = Record<string, any>>(...definitions: HooksRegistry<TSchema, TContext>[]) => HooksRegistry<TSchema, TContext>;
 
+/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
+/** biome-ignore-all lint/style/noNonNullAssertion: false positive */
+
+type AnyRoute = Route<Middleware<any>, Record<string, any>, Record<string, any>, any, any>;
+type RouteRecord = Record<string, AnyRoute>;
+declare class Router<TRoutes extends RouteRecord, TSchema extends Schema<any> = Schema<any>> {
+    readonly routes: TRoutes;
+    readonly schema: TSchema;
+    private constructor();
+    static create<TRoutes extends RouteRecord, TSchema extends Schema<any>>(opts: {
+        routes: TRoutes;
+        schema: TSchema;
+    }): Router<TRoutes, TSchema>;
+}
+declare const router: <TSchema extends Schema<any>, TRoutes extends RouteRecord>(opts: {
+    schema: TSchema;
+    routes: TRoutes;
+}) => Router<TRoutes, TSchema>;
+type AnyRouter = Router<any, any>;
+type Mutation<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput, TContext = Record<string, any>> = {
+    _type: 'mutation';
+    inputValidator: TInputValidator;
+    handler: (opts: {
+        req: MutationRequest<TInputValidator extends StandardSchemaV1<any, any> ? StandardSchemaV1.InferOutput<TInputValidator> : undefined, TContext>;
+        db: ServerDB<any>;
+    }) => TOutput;
+};
+interface QueryProcedureRequest<TInput = any, TContext = Record<string, any>> extends BaseRequest<TContext> {
+    type: 'CUSTOM_QUERY';
+    input: TInput;
+    resource: string;
+    procedure: string;
+}
+type Query<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput, TContext = Record<string, any>> = {
+    _type: 'query';
+    inputValidator: TInputValidator;
+    handler: (opts: {
+        req: QueryProcedureRequest<TInputValidator extends StandardSchemaV1<any, any> ? StandardSchemaV1.InferOutput<TInputValidator> : undefined, TContext>;
+        db: ServerDB<any>;
+    }) => TOutput;
+};
+type Procedure<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput, TContext = Record<string, any>> = Mutation<TInputValidator, TOutput, TContext> | Query<TInputValidator, TOutput, TContext>;
+type QueryCreator<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = {
+    (): {
+        handler: <TOutput>(handler: (opts: {
+            req: QueryProcedureRequest<undefined, TContext>;
+            db: ServerDB<TSchema>;
+        }) => TOutput) => Query<StandardSchemaV1<any, undefined>, TOutput, TContext>;
+    };
+    <TInputValidator extends StandardSchemaV1<any, any>>(validator: TInputValidator): {
+        handler: <THandler extends (opts: {
+            req: QueryProcedureRequest<StandardSchemaV1.InferOutput<TInputValidator>, TContext>;
+            db: ServerDB<TSchema>;
+        }) => any>(handler: THandler) => Query<TInputValidator, ReturnType<THandler>, TContext>;
+    };
+};
+type MutationCreator<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> = {
+    (): {
+        handler: <TOutput>(handler: (opts: {
+            req: MutationRequest<undefined, TContext>;
+            db: ServerDB<TSchema>;
+        }) => TOutput) => Mutation<StandardSchemaV1<any, undefined>, TOutput, TContext>;
+    };
+    <TInputValidator extends StandardSchemaV1<any, any>>(validator: TInputValidator): {
+        handler: <THandler extends (opts: {
+            req: MutationRequest<StandardSchemaV1.InferOutput<TInputValidator>, TContext>;
+            db: ServerDB<TSchema>;
+        }) => any>(handler: THandler) => Mutation<TInputValidator, ReturnType<THandler>, TContext>;
+    };
+};
+declare class Route<TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, any>>, TCustomQueries extends Record<string, Query<any, any>>, TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> {
+    readonly middlewares: Set<TMiddleware>;
+    readonly customMutations: TCustomMutations;
+    readonly customQueries: TCustomQueries;
+    constructor(customMutations?: TCustomMutations, customQueries?: TCustomQueries);
+    use(...middlewares: TMiddleware[]): this;
+    private wrapInMiddlewares;
+}
+type TypedMiddleware<TContextIn, TContextOut> = {
+    _brand: 'TypedMiddleware';
+    _rawMiddleware: Middleware<any>;
+    _contextIn?: TContextIn;
+    _contextOut?: TContextOut;
+};
+declare function createMiddleware<TContextIn, TContextOut = TContextIn>(fn: (opts: {
+    ctx: TContextIn;
+    req: Request<TContextIn>;
+    next: (ctx: TContextOut) => any;
+}) => any): TypedMiddleware<TContextIn, TContextOut>;
+declare class RouteFactory<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>> {
+    private middlewares;
+    private constructor();
+    withProcedures<T extends Record<string, Procedure<any, any, any>>>(procedureFactory: (opts: {
+        mutation: MutationCreator<TSchema, TContext>;
+        query: QueryCreator<TSchema, TContext>;
+    }) => T): Route<Middleware<any>, { [K in keyof T as T[K] extends Mutation<any, any, Record<string, any>> ? K : never]: Extract<T[K], Mutation<any, any, Record<string, any>>>; }, { [K_1 in keyof T as T[K_1] extends Query<any, any, Record<string, any>> ? K_1 : never]: Extract<T[K_1], Query<any, any, Record<string, any>>>; }, TSchema, TContext>;
+    /**
+     * @deprecated Use `withProcedures` instead
+     */
+    withMutations<T extends Record<string, Mutation<any, any>>>(mutationFactory: (opts: {
+        mutation: MutationCreator<TSchema, TContext>;
+    }) => T): Route<Middleware<any>, { [K in keyof T as T[K] extends Mutation<any, any, Record<string, any>> ? K : never]: Extract<T[K], Mutation<any, any, Record<string, any>>>; }, { [K_1 in keyof T as T[K_1] extends Query<any, any, Record<string, any>> ? K_1 : never]: Extract<T[K_1], Query<any, any, Record<string, any>>>; }, TSchema, TContext>;
+    use<TNewContext>(mw: TypedMiddleware<TContext, TNewContext>): RouteFactory<TSchema, TNewContext>;
+    use(...middlewares: Middleware<any>[]): RouteFactory<TSchema, TContext>;
+    static create<TSchema extends Schema<any> = Schema<any>, TContext = Record<string, any>>(): RouteFactory<TSchema, TContext>;
+}
+declare const routeFactory: typeof RouteFactory.create;
+
 /** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
 
 declare class SQLStorage extends Storage {
@@ -528,18 +494,18 @@ interface BaseRequest<TContext = Record<string, any>> {
     context: TContext;
 }
 interface QueryRequest<TContext = Record<string, any>> extends BaseRequest<TContext>, RawQueryRequest {
-    type: "QUERY";
+    type: 'QUERY';
 }
 interface MutationRequest<TInput = any, TContext = Record<string, any>> extends BaseRequest<TContext> {
-    type: "MUTATE";
+    type: 'MUTATE';
     input: TInput;
     resource: string;
     resourceId?: string;
     procedure: string;
 }
 type Request<TContext = Record<string, any>> = QueryRequest<TContext> | MutationRequest<any, TContext> | QueryProcedureRequest<any, TContext>;
-type ContextProvider<TContext = Record<string, any>> = (req: Omit<BaseRequest, "context"> & {
-    transport: "HTTP" | "WEBSOCKET";
+type ContextProvider<TContext = Record<string, any>> = (req: Omit<BaseRequest, 'context'> & {
+    transport: 'HTTP' | 'WEBSOCKET';
 }) => TContext | Promise<TContext>;
 type NextFunction<O, R = Request> = (req: R) => PromiseOrSync<O>;
 type Middleware<T = any> = (opts: {
@@ -575,16 +541,12 @@ declare class Server<TRouter extends AnyRouter, TContext = Record<string, any>>
         logLevel?: LogLevel;
     }): Server<TRouter, Record<string, any>>;
     getHooks(resourceName: string): Hooks<any, any, any> | undefined;
-    handleQuery(opts: {
-        req: QueryRequest;
-        subscription?: (mutation: DefaultMutation) => void;
-    }): Promise<QueryResult<any>>;
     handleMutation(opts: {
         req: MutationRequest;
     }): Promise<any>;
     handleCustomQuery(opts: {
         req: QueryProcedureRequest;
-        subscription?: (mutation: DefaultMutation) => void;
+        subscription?: (mutation: SyncDelta) => void;
     }): Promise<any>;
     use(middleware: Middleware<any>): this;
     context(contextProvider: ContextProvider<TContext>): this;
@@ -593,4 +555,4 @@ declare class Server<TRouter extends AnyRouter, TContext = Record<string, any>>
 }
 declare const server: typeof Server.create;
 
-export { type AfterInsertHook, type AfterUpdateHook, type AnyProcedureRoute, type AnyRoute, type AnyRouteOrProcedure, type AnyRouter, type Authorization, type BaseRequest, type BeforeInsertHook, type BeforeUpdateHook, type ContextProvider, type Hooks, type HooksRegistry, type Middleware, type Mutation, type MutationAuthorizationHandler, type MutationRequest, type MutationResult, type NextFunction, type Procedure, ProcedureRoute, type Query, type QueryProcedureRequest, type QueryRequest, type QueryResult, type ReadAuthorizationHandler, type Request, Route, RouteFactory, type RouteRecord, Router, SQLStorage, Server, type ServerCollection, type ServerDB, Storage, type TypedMiddleware, createMiddleware, createServerDB, defineHooks, expressAdapter, mergeEntityHooks, mergeHooks, routeFactory, router, server };
+export { type AfterInsertHook, type AfterUpdateHook, type AnyRoute, type AnyRouter, type BaseRequest, type BeforeInsertHook, type BeforeUpdateHook, type ContextProvider, type Hooks, type HooksRegistry, type Middleware, type Mutation, type MutationRequest, type NextFunction, type Procedure, type Query, QueryBuilder, type QueryExecutor, type QueryProcedureRequest, type QueryRequest, type Request, Route, RouteFactory, type RouteRecord, Router, SQLStorage, Server, type ServerCollection, type ServerDB, Storage, type TypedMiddleware, createMiddleware, createServerDB, defineHooks, expressAdapter, mergeEntityHooks, mergeHooks, routeFactory, router, server };