@lunora/server 1.0.0-alpha.17 → 1.0.0-alpha.19

package/README.md

@@ -99,6 +99,52 @@ The builder chain is `<builder>.input(validators).<kind>(handler)`, plus `.use(m
 
 > This README covers the basics. For the full API, options, and guides, see the **[documentation](https://lunora.sh/docs/packages/server)**.
 
+### Caching with Workers Cache
+
+Lunora supports Cloudflare Workers Cache for HTTP actions (`httpRoute`). RPC queries and mutations are `POST /_lunora/rpc` and are not cacheable at the edge by design.
+
+**Enable Workers Cache** in `wrangler.jsonc`:
+
+```jsonc
+{
+    "cache": { "enabled": true },
+}
+```
+
+The dev server and CLI automatically bump `compatibility_date` to the minimum required when cache is enabled — you do not need to set it manually.
+
+**Set cache headers declaratively** on an `httpRoute`:
+
+```ts
+import { httpRoute } from "./_generated/server";
+
+export const getProduct = httpRoute
+    .get("/api/products/:id")
+    .params({ id: v.string() })
+    .cacheControl("public, max-age=300, stale-while-revalidate=3600")
+    .cacheTag("products")
+    .handler(async ({ ctx, params }) => {
+        return { id: params.id, name: "Widget" };
+    });
+```
+
+**Purge cache by tag** from an action handler:
+
+```ts
+import { action } from "./_generated/server";
+
+export const refreshProducts = action.action(async ({ ctx }) => {
+    if (!ctx.cache) {
+        throw new Error("Workers Cache is not enabled in wrangler.jsonc");
+    }
+
+    await ctx.cache.purge({ tags: ["products"] });
+    return { ok: true };
+});
+```
+
+The `ctx.cache.purge` API accepts `{ tags?: string[]; purgeEverything?: boolean }`. Only action handlers expose `ctx.cache`; queries and mutations run inside the Durable Object and do not have access to the Worker-level cache binding.
+
 ## Related
 
 - [`@lunora/values`](https://www.npmjs.com/package/@lunora/values) — the `v.*` validators re-exported here.

package/dist/data-model.d.mts

@@ -345,12 +345,24 @@ interface TableWriterFacade<DM, IM extends Record<keyof DM, object>, REL extends
   * {@link TableWriterFacade.hardDelete} to force physical removal.
   */
   delete: (id: Id<string & T>) => Promise<void>;
-  /** Delete many rows in this table by id in one call; returns the *requested* id count (unknown ids are no-ops). Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  deleteMany: (ids: ReadonlyArray<Id<string & T>>, options?: {
-    limit?: number;
-  }) => Promise<{
-    deleted: number;
-  }>;
+  /**
+  * Delete many rows in this table. Pass an array of ids (requested count is
+  * returned; unknown ids are no-ops) or `{ where }` to delete matching rows
+  * (actual removed count is returned). Atomic within a mutation.
+  */
+  deleteMany: {
+    (ids: ReadonlyArray<Id<string & T>>, options?: {
+      limit?: number;
+    }): Promise<{
+      deleted: number;
+    }>;
+    (args: {
+      limit?: number;
+      where: Partial<DM[T]>;
+    }): Promise<{
+      deleted: number;
+    }>;
+  };
   /** Physically remove a row (and physically cascade `onDelete`), bypassing `.softDelete()`. Same as `delete()` on a non-soft table. */
   hardDelete: (id: Id<string & T>) => Promise<void>;
   /**
@@ -366,18 +378,44 @@ interface TableWriterFacade<DM, IM extends Record<keyof DM, object>, REL extends
       skipDuplicates?: boolean;
     }): Promise<Id<string & T>>;
   };
-  /** Insert many documents into this table in one call, returning the minted ids in input order. Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  insertMany: (values: ReadonlyArray<IM[T]>, options?: {
-    limit?: number;
-  }) => Promise<Id<string & T>[]>;
+  /**
+  * Insert many documents into this table in one call, returning the minted ids
+  * in input order. With `{ skipDuplicates: true }`, UNIQUE breaches resolve to
+  * `null` for that row instead of failing the batch. Atomic within a mutation.
+  */
+  insertMany: {
+    (values: ReadonlyArray<IM[T]>, options: {
+      limit?: number;
+      skipDuplicates: true;
+    }): Promise<(Id<string & T> | null)[]>;
+    (values: ReadonlyArray<IM[T]>, options?: {
+      limit?: number;
+      skipDuplicates?: boolean;
+    }): Promise<Id<string & T>[]>;
+  };
   patch: (id: Id<string & T>, values: Partial<IM[T]>) => Promise<void>;
-  /** Patch many rows in this table by id in one call. Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  patchMany: (patches: ReadonlyArray<{
-    id: Id<string & T>;
-    values: Partial<IM[T]>;
-  }>, options?: {
-    limit?: number;
-  }) => Promise<void>;
+  /**
+  * Patch many rows in this table. Pass an array of `{ id, values }` or
+  * `{ where, values }` to patch matching rows with the same values. Returns
+  * the actual patched count. Atomic within a mutation.
+  */
+  patchMany: {
+    (patches: ReadonlyArray<{
+      id: Id<string & T>;
+      values: Partial<IM[T]>;
+    }>, options?: {
+      limit?: number;
+    }): Promise<{
+      patched: number;
+    }>;
+    (args: {
+      limit?: number;
+      values: Partial<IM[T]>;
+      where: Partial<DM[T]>;
+    }): Promise<{
+      patched: number;
+    }>;
+  };
   replace: (id: Id<string & T>, values: IM[T]) => Promise<void>;
   /** Un-soft-delete a row by id: clears the `.softDelete()` marker so list reads see it again. Throws on a non-soft table. */
   restore: (id: Id<string & T>) => Promise<void>;

package/dist/data-model.d.ts

@@ -345,12 +345,24 @@ interface TableWriterFacade<DM, IM extends Record<keyof DM, object>, REL extends
   * {@link TableWriterFacade.hardDelete} to force physical removal.
   */
   delete: (id: Id<string & T>) => Promise<void>;
-  /** Delete many rows in this table by id in one call; returns the *requested* id count (unknown ids are no-ops). Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  deleteMany: (ids: ReadonlyArray<Id<string & T>>, options?: {
-    limit?: number;
-  }) => Promise<{
-    deleted: number;
-  }>;
+  /**
+  * Delete many rows in this table. Pass an array of ids (requested count is
+  * returned; unknown ids are no-ops) or `{ where }` to delete matching rows
+  * (actual removed count is returned). Atomic within a mutation.
+  */
+  deleteMany: {
+    (ids: ReadonlyArray<Id<string & T>>, options?: {
+      limit?: number;
+    }): Promise<{
+      deleted: number;
+    }>;
+    (args: {
+      limit?: number;
+      where: Partial<DM[T]>;
+    }): Promise<{
+      deleted: number;
+    }>;
+  };
   /** Physically remove a row (and physically cascade `onDelete`), bypassing `.softDelete()`. Same as `delete()` on a non-soft table. */
   hardDelete: (id: Id<string & T>) => Promise<void>;
   /**
@@ -366,18 +378,44 @@ interface TableWriterFacade<DM, IM extends Record<keyof DM, object>, REL extends
       skipDuplicates?: boolean;
     }): Promise<Id<string & T>>;
   };
-  /** Insert many documents into this table in one call, returning the minted ids in input order. Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  insertMany: (values: ReadonlyArray<IM[T]>, options?: {
-    limit?: number;
-  }) => Promise<Id<string & T>[]>;
+  /**
+  * Insert many documents into this table in one call, returning the minted ids
+  * in input order. With `{ skipDuplicates: true }`, UNIQUE breaches resolve to
+  * `null` for that row instead of failing the batch. Atomic within a mutation.
+  */
+  insertMany: {
+    (values: ReadonlyArray<IM[T]>, options: {
+      limit?: number;
+      skipDuplicates: true;
+    }): Promise<(Id<string & T> | null)[]>;
+    (values: ReadonlyArray<IM[T]>, options?: {
+      limit?: number;
+      skipDuplicates?: boolean;
+    }): Promise<Id<string & T>[]>;
+  };
   patch: (id: Id<string & T>, values: Partial<IM[T]>) => Promise<void>;
-  /** Patch many rows in this table by id in one call. Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  patchMany: (patches: ReadonlyArray<{
-    id: Id<string & T>;
-    values: Partial<IM[T]>;
-  }>, options?: {
-    limit?: number;
-  }) => Promise<void>;
+  /**
+  * Patch many rows in this table. Pass an array of `{ id, values }` or
+  * `{ where, values }` to patch matching rows with the same values. Returns
+  * the actual patched count. Atomic within a mutation.
+  */
+  patchMany: {
+    (patches: ReadonlyArray<{
+      id: Id<string & T>;
+      values: Partial<IM[T]>;
+    }>, options?: {
+      limit?: number;
+    }): Promise<{
+      patched: number;
+    }>;
+    (args: {
+      limit?: number;
+      values: Partial<IM[T]>;
+      where: Partial<DM[T]>;
+    }): Promise<{
+      patched: number;
+    }>;
+  };
   replace: (id: Id<string & T>, values: IM[T]) => Promise<void>;
   /** Un-soft-delete a row by id: clears the `.softDelete()` marker so list reads see it again. Throws on a non-soft table. */
   restore: (id: Id<string & T>) => Promise<void>;

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import { Validator, Infer, ValidatorMap, InferValidatorMap, v } from '@lunora/values';
 export { type ColumnValidator, type Id, type Infer, ValidationError, type Validator, type ValidatorKind, v } from '@lunora/values';
 import { ArgsValidator, InferArgs, RegisteredAction, ActionCtx, MutationCtx, RegisteredMutation, QueryCtx, RegisteredQuery, RegisteredStream, FunctionKind, Secrets, LifecycleEvent, RegisteredLifecycleHook, TableDefinition, RegisteredFunction, VectorIndexDefinition, Schema, AggregateOp, DurableObjectJurisdiction, RelationDefinition, GlobalBackend, OnDeleteAction, ExternalSourceDefinition, TriggerBuilder, TriggerDefinition, VectorEmbedder, VectorMetric, AggregateIndexDefinition, RankIndexDefinition } from "./types.mjs";
-export { type AnyApi, type AuthState, type DatabaseReader, type DatabaseWriter, type FunctionVisibility, type IndexDefinition, type IndexRangeBuilder, type LifecycleEventKind, type LunoraLogger, type PaginationOptions, type PaginationResult, type RankSortKey, type ReadOnlyStorage, type ScheduledFunctionDoc, type ScheduledJob, type Scheduler, type SearchFilterBuilder, type SearchIndexDefinition, type ShardMode, type Storage, type StorageMetadata, type SystemDatabaseReader, type SystemDoc, type SystemQuery, type SystemTableName, type TableReader, type TableVectorIndex, type TriggerAggregateOptions, type TriggerCtx, type TriggerDatabase, type TriggerDeleteEvent, type TriggerEvent, type TriggerGroupByEntry, type TriggerGroupByOptions, type TriggerHandler, type TriggerInsertEvent, type TriggerOp, type TriggerQueryArgs, type TriggerQueryPage, type TriggerRankOptions, type TriggerRankPageOptions, type TriggerRankResult, type TriggerRow, type TriggerTiming, type TriggerUpdateEvent, type VectorMatch, type VectorMatches, type VectorQueryInput, type VectorRecord, type VectorSearch, type VectorSearchReader, type VectorUpsertInput, type WorkflowCreateOptions, type WorkflowHandle, type WorkflowInstance, type WorkflowInstanceStatus, type WorkflowStatusResult, type Workflows, anyApi } from "./types.mjs";
+export { type AnyApi, type AuthState, type CachePurge, type DatabaseReader, type DatabaseWriter, type FunctionVisibility, type IndexDefinition, type IndexRangeBuilder, type LifecycleEventKind, type LunoraLogger, type PaginationOptions, type PaginationResult, type RankSortKey, type ReadOnlyStorage, type ScheduledFunctionDoc, type ScheduledJob, type Scheduler, type SearchFilterBuilder, type SearchIndexDefinition, type ShardMode, type Storage, type StorageMetadata, type SystemDatabaseReader, type SystemDoc, type SystemQuery, type SystemTableName, type TableReader, type TableVectorIndex, type TriggerAggregateOptions, type TriggerCtx, type TriggerDatabase, type TriggerDeleteEvent, type TriggerEvent, type TriggerGroupByEntry, type TriggerGroupByOptions, type TriggerHandler, type TriggerInsertEvent, type TriggerOp, type TriggerQueryArgs, type TriggerQueryPage, type TriggerRankOptions, type TriggerRankPageOptions, type TriggerRankResult, type TriggerRow, type TriggerTiming, type TriggerUpdateEvent, type VectorMatch, type VectorMatches, type VectorQueryInput, type VectorRecord, type VectorSearch, type VectorSearchReader, type VectorUpsertInput, type WorkflowCreateOptions, type WorkflowHandle, type WorkflowInstance, type WorkflowInstanceStatus, type WorkflowStatusResult, type Workflows, anyApi } from "./types.mjs";
 import { LunoraError as LunoraError$1, LunoraErrorCode } from '@lunora/errors';
 export type { LunoraErrorCode } from '@lunora/errors';
 import { Context, Hono } from 'hono';
@@ -299,6 +299,11 @@ interface FacadeWriterLike {
   }, expectedTable?: string): Promise<{
     deleted: number;
   }>;
+  deleteWhere?(tableName: string, where: Record<string, unknown>, options?: {
+    limit?: number;
+  }): Promise<{
+    deleted: number;
+  }>;
   findFirst(tableName: string, args?: unknown): Promise<unknown>;
   findFirstOrThrow(tableName: string, args?: unknown): Promise<unknown>;
   findMany(tableName: string, args?: unknown): Promise<unknown>;
@@ -307,14 +312,25 @@ interface FacadeWriterLike {
   insert(tableName: string, document: Record<string, unknown>): Promise<string>;
   insertMany?(tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }): Promise<string[]>;
+    skipDuplicates?: boolean;
+  }): Promise<(string | null)[]>;
   patch(id: string, patch: Record<string, unknown>, expectedTable?: string): Promise<void>;
   patchMany?(patches: ReadonlyArray<{
     id: string;
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }, expectedTable?: string): Promise<void>;
+  }, expectedTable?: string): Promise<{
+    patched: number;
+  }>;
+  patchWhere?(tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: {
+    limit?: number;
+  }): Promise<{
+    patched: number;
+  }>;
   query(tableName: string): {
     withSearchIndex(indexName: string, search: (q: unknown) => unknown): unknown;
   };
@@ -328,11 +344,19 @@ interface FacadeEntry {
   aggregate: (options: unknown) => Promise<unknown>;
   count: (where?: unknown) => Promise<number>;
   delete: (id: string) => Promise<void>;
-  deleteMany: (ids: ReadonlyArray<string>, options?: {
-    limit?: number;
-  }) => Promise<{
-    deleted: number;
-  }>;
+  deleteMany: {
+    (ids: ReadonlyArray<string>, options?: {
+      limit?: number;
+    }): Promise<{
+      deleted: number;
+    }>;
+    (args: {
+      limit?: number;
+      where: Record<string, unknown>;
+    }): Promise<{
+      deleted: number;
+    }>;
+  };
   /** `true` when at least one row matches `where` (or any row exists when omitted). Honors RLS like `findFirst`. */
   exists: (where?: unknown) => Promise<boolean>;
   findFirst: (args?: unknown) => Promise<unknown>;
@@ -343,16 +367,34 @@ interface FacadeEntry {
   /** Physically remove a row (and physically cascade), bypassing `.softDelete()`. */
   hardDelete: (id: string) => Promise<void>;
   insert: (document: Record<string, unknown>, options?: FacadeInsertOptions) => Promise<null | string>;
+  /**
+  * Insert many documents into this table in one call. With
+  * `{ skipDuplicates: true }`, UNIQUE breaches resolve to `null` for that row
+  * instead of failing the batch. The typed facade narrows the return to
+  * `Id&lt;T>[]` when skipDuplicates is not requested.
+  */
   insertMany: (documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   patch: (id: string, patch: Record<string, unknown>) => Promise<void>;
-  patchMany: (patches: ReadonlyArray<{
-    id: string;
-    values: Record<string, unknown>;
-  }>, options?: {
-    limit?: number;
-  }) => Promise<void>;
+  patchMany: {
+    (patches: ReadonlyArray<{
+      id: string;
+      values: Record<string, unknown>;
+    }>, options?: {
+      limit?: number;
+    }): Promise<{
+      patched: number;
+    }>;
+    (args: {
+      limit?: number;
+      values: Record<string, unknown>;
+      where: Record<string, unknown>;
+    }): Promise<{
+      patched: number;
+    }>;
+  };
   rank: (indexName: string, options: unknown) => Promise<unknown>;
   rankPage: (indexName: string, options?: unknown) => Promise<unknown>;
   replace: (id: string, document: Record<string, unknown>) => Promise<void>;
@@ -435,7 +477,7 @@ type HttpMethod = "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PU
 * `storage` surface — reach the data layer through `runQuery` / `runMutation` /
 * `runAction`, which forward to the owning shard.
 */
-type HttpActionCtx = Pick<ActionCtx, "auth" | "fetch" | "runAction" | "runMutation" | "runQuery">;
+type HttpActionCtx = Pick<ActionCtx, "auth" | "cache" | "fetch" | "runAction" | "runMutation" | "runQuery">;
 /** A raw handler wrapped by {@link httpAction}. Receives the raw request, returns the raw response. */
 type HttpActionHandler = (context: HttpActionCtx, request: Request) => Promise<Response> | Response;
 /**
@@ -519,6 +561,16 @@ interface HttpStreamHandlerOptions<SearchParams extends ArgsValidator, Params ex
 */
 interface HttpRouteBuilder<SearchParams extends ArgsValidator, Body extends ArgsValidator, Params extends ArgsValidator, Output = undefined> {
   body: <B extends ArgsValidator>(validators: B) => HttpRouteBuilder<SearchParams, B & Body, Params, Output>;
+  /**
+  * Attach a `Cache-Control` header to the response. Only meaningful when
+  * Workers Cache is enabled in `wrangler.jsonc` (`"cache": { "enabled": true }`).
+  */
+  cacheControl: (value: string) => HttpRouteBuilder<SearchParams, Body, Params, Output>;
+  /**
+  * Attach a `Cache-Tag` header to the response for tag-based purging via
+  * `ctx.cache.purge({ tags: [...] })`.
+  */
+  cacheTag: (value: string) => HttpRouteBuilder<SearchParams, Body, Params, Output>;
   handler: [Output] extends [undefined] ? <R>(handler: (options: HttpRouteHandlerOptions<SearchParams, Body, Params>) => Promise<R> | R) => LunoraRouteHandler : (handler: (options: HttpRouteHandlerOptions<SearchParams, Body, Params>) => Output | Promise<Output>) => LunoraRouteHandler;
   output: <V extends Validator>(validator: V) => HttpRouteBuilder<SearchParams, Body, Params, Infer<V>>;
   params: <P extends ArgsValidator>(validators: P) => HttpRouteBuilder<SearchParams, Body, P & Params, Output>;
@@ -533,6 +585,11 @@ interface HttpRouteBuilder<SearchParams extends ArgsValidator, Body extends Args
   * handler's yielded type.
   */
   stream: <R>(handler: (options: HttpStreamHandlerOptions<SearchParams, Params>) => AsyncGenerator<R, void, void> | AsyncIterable<R>) => LunoraRouteHandler;
+  /**
+  * Attach a `Vary` header to the response so Cloudflare stores separate
+  * cached variants per distinct value of the listed request headers.
+  */
+  vary: (value: string) => HttpRouteBuilder<SearchParams, Body, Params, Output>;
 }
 /** Opens a fresh {@link HttpRouteBuilder}. The `path` documents intent; hono owns the actual routing at mount. */
 type HttpRouteFactory = (path: string) => HttpRouteBuilder<EmptyArgs, EmptyArgs, EmptyArgs>;
@@ -828,6 +885,11 @@ interface MaskDatabase {
   }) => Promise<{
     deleted: number;
   }>;
+  deleteWhere?: (tableName: string, where: Record<string, unknown>, options?: {
+    limit?: number;
+  }) => Promise<{
+    deleted: number;
+  }>;
   findFirst: (tableName: string, args?: QueryArgs$1) => Promise<Record<string, unknown> | null>;
   findFirstOrThrow: (tableName: string, args?: QueryArgs$1) => Promise<Record<string, unknown>>;
   findMany: (tableName: string, args?: QueryArgs$1) => Promise<QueryPage$1>;
@@ -839,7 +901,8 @@ interface MaskDatabase {
   insert: (tableName: string, document: Record<string, unknown>) => Promise<string>;
   insertMany: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   lookupById?: (id: string, expectedTable?: string) => Promise<null | {
     row: Record<string, unknown>;
     tableName: string;
@@ -850,7 +913,17 @@ interface MaskDatabase {
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }) => Promise<void>;
+  }) => Promise<{
+    patched: number;
+  }>;
+  patchWhere?: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: {
+    limit?: number;
+  }) => Promise<{
+    patched: number;
+  }>;
   query: (tableName: string) => TableReaderLike$1;
   rank: (tableName: string, indexName: string, options: unknown) => Promise<null | {
     position: number;
@@ -1722,6 +1795,11 @@ interface DatabaseWriterLike {
   }, expectedTable?: string) => Promise<{
     deleted: number;
   }>;
+  deleteWhere?: (tableName: string, where: WhereInput, options?: {
+    limit?: number;
+  }) => Promise<{
+    deleted: number;
+  }>;
   findFirst: (tableName: string, args?: QueryArgs) => Promise<Record<string, unknown> | null>;
   findFirstOrThrow: (tableName: string, args?: QueryArgs) => Promise<Record<string, unknown>>;
   findMany: (tableName: string, args?: QueryArgs) => Promise<QueryPage>;
@@ -1738,7 +1816,8 @@ interface DatabaseWriterLike {
   insert: (tableName: string, document: Record<string, unknown>) => Promise<string>;
   insertMany: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   insertManyUnsafe: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     allowExplicitId?: boolean;
     limit?: number;
@@ -1761,7 +1840,17 @@ interface DatabaseWriterLike {
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }, expectedTable?: string) => Promise<void>;
+  }, expectedTable?: string) => Promise<{
+    patched: number;
+  }>;
+  patchWhere?: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: WhereInput;
+  }, options?: {
+    limit?: number;
+  }) => Promise<{
+    patched: number;
+  }>;
   query: (tableName: string) => TableReaderLike;
   /**
   * Rank a row within its partition. A position is a count-of-rows-before, so

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Validator, Infer, ValidatorMap, InferValidatorMap, v } from '@lunora/values';
 export { type ColumnValidator, type Id, type Infer, ValidationError, type Validator, type ValidatorKind, v } from '@lunora/values';
 import { ArgsValidator, InferArgs, RegisteredAction, ActionCtx, MutationCtx, RegisteredMutation, QueryCtx, RegisteredQuery, RegisteredStream, FunctionKind, Secrets, LifecycleEvent, RegisteredLifecycleHook, TableDefinition, RegisteredFunction, VectorIndexDefinition, Schema, AggregateOp, DurableObjectJurisdiction, RelationDefinition, GlobalBackend, OnDeleteAction, ExternalSourceDefinition, TriggerBuilder, TriggerDefinition, VectorEmbedder, VectorMetric, AggregateIndexDefinition, RankIndexDefinition } from "./types.js";
-export { type AnyApi, type AuthState, type DatabaseReader, type DatabaseWriter, type FunctionVisibility, type IndexDefinition, type IndexRangeBuilder, type LifecycleEventKind, type LunoraLogger, type PaginationOptions, type PaginationResult, type RankSortKey, type ReadOnlyStorage, type ScheduledFunctionDoc, type ScheduledJob, type Scheduler, type SearchFilterBuilder, type SearchIndexDefinition, type ShardMode, type Storage, type StorageMetadata, type SystemDatabaseReader, type SystemDoc, type SystemQuery, type SystemTableName, type TableReader, type TableVectorIndex, type TriggerAggregateOptions, type TriggerCtx, type TriggerDatabase, type TriggerDeleteEvent, type TriggerEvent, type TriggerGroupByEntry, type TriggerGroupByOptions, type TriggerHandler, type TriggerInsertEvent, type TriggerOp, type TriggerQueryArgs, type TriggerQueryPage, type TriggerRankOptions, type TriggerRankPageOptions, type TriggerRankResult, type TriggerRow, type TriggerTiming, type TriggerUpdateEvent, type VectorMatch, type VectorMatches, type VectorQueryInput, type VectorRecord, type VectorSearch, type VectorSearchReader, type VectorUpsertInput, type WorkflowCreateOptions, type WorkflowHandle, type WorkflowInstance, type WorkflowInstanceStatus, type WorkflowStatusResult, type Workflows, anyApi } from "./types.js";
+export { type AnyApi, type AuthState, type CachePurge, type DatabaseReader, type DatabaseWriter, type FunctionVisibility, type IndexDefinition, type IndexRangeBuilder, type LifecycleEventKind, type LunoraLogger, type PaginationOptions, type PaginationResult, type RankSortKey, type ReadOnlyStorage, type ScheduledFunctionDoc, type ScheduledJob, type Scheduler, type SearchFilterBuilder, type SearchIndexDefinition, type ShardMode, type Storage, type StorageMetadata, type SystemDatabaseReader, type SystemDoc, type SystemQuery, type SystemTableName, type TableReader, type TableVectorIndex, type TriggerAggregateOptions, type TriggerCtx, type TriggerDatabase, type TriggerDeleteEvent, type TriggerEvent, type TriggerGroupByEntry, type TriggerGroupByOptions, type TriggerHandler, type TriggerInsertEvent, type TriggerOp, type TriggerQueryArgs, type TriggerQueryPage, type TriggerRankOptions, type TriggerRankPageOptions, type TriggerRankResult, type TriggerRow, type TriggerTiming, type TriggerUpdateEvent, type VectorMatch, type VectorMatches, type VectorQueryInput, type VectorRecord, type VectorSearch, type VectorSearchReader, type VectorUpsertInput, type WorkflowCreateOptions, type WorkflowHandle, type WorkflowInstance, type WorkflowInstanceStatus, type WorkflowStatusResult, type Workflows, anyApi } from "./types.js";
 import { LunoraError as LunoraError$1, LunoraErrorCode } from '@lunora/errors';
 export type { LunoraErrorCode } from '@lunora/errors';
 import { Context, Hono } from 'hono';
@@ -299,6 +299,11 @@ interface FacadeWriterLike {
   }, expectedTable?: string): Promise<{
     deleted: number;
   }>;
+  deleteWhere?(tableName: string, where: Record<string, unknown>, options?: {
+    limit?: number;
+  }): Promise<{
+    deleted: number;
+  }>;
   findFirst(tableName: string, args?: unknown): Promise<unknown>;
   findFirstOrThrow(tableName: string, args?: unknown): Promise<unknown>;
   findMany(tableName: string, args?: unknown): Promise<unknown>;
@@ -307,14 +312,25 @@ interface FacadeWriterLike {
   insert(tableName: string, document: Record<string, unknown>): Promise<string>;
   insertMany?(tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }): Promise<string[]>;
+    skipDuplicates?: boolean;
+  }): Promise<(string | null)[]>;
   patch(id: string, patch: Record<string, unknown>, expectedTable?: string): Promise<void>;
   patchMany?(patches: ReadonlyArray<{
     id: string;
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }, expectedTable?: string): Promise<void>;
+  }, expectedTable?: string): Promise<{
+    patched: number;
+  }>;
+  patchWhere?(tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: {
+    limit?: number;
+  }): Promise<{
+    patched: number;
+  }>;
   query(tableName: string): {
     withSearchIndex(indexName: string, search: (q: unknown) => unknown): unknown;
   };
@@ -328,11 +344,19 @@ interface FacadeEntry {
   aggregate: (options: unknown) => Promise<unknown>;
   count: (where?: unknown) => Promise<number>;
   delete: (id: string) => Promise<void>;
-  deleteMany: (ids: ReadonlyArray<string>, options?: {
-    limit?: number;
-  }) => Promise<{
-    deleted: number;
-  }>;
+  deleteMany: {
+    (ids: ReadonlyArray<string>, options?: {
+      limit?: number;
+    }): Promise<{
+      deleted: number;
+    }>;
+    (args: {
+      limit?: number;
+      where: Record<string, unknown>;
+    }): Promise<{
+      deleted: number;
+    }>;
+  };
   /** `true` when at least one row matches `where` (or any row exists when omitted). Honors RLS like `findFirst`. */
   exists: (where?: unknown) => Promise<boolean>;
   findFirst: (args?: unknown) => Promise<unknown>;
@@ -343,16 +367,34 @@ interface FacadeEntry {
   /** Physically remove a row (and physically cascade), bypassing `.softDelete()`. */
   hardDelete: (id: string) => Promise<void>;
   insert: (document: Record<string, unknown>, options?: FacadeInsertOptions) => Promise<null | string>;
+  /**
+  * Insert many documents into this table in one call. With
+  * `{ skipDuplicates: true }`, UNIQUE breaches resolve to `null` for that row
+  * instead of failing the batch. The typed facade narrows the return to
+  * `Id&lt;T>[]` when skipDuplicates is not requested.
+  */
   insertMany: (documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   patch: (id: string, patch: Record<string, unknown>) => Promise<void>;
-  patchMany: (patches: ReadonlyArray<{
-    id: string;
-    values: Record<string, unknown>;
-  }>, options?: {
-    limit?: number;
-  }) => Promise<void>;
+  patchMany: {
+    (patches: ReadonlyArray<{
+      id: string;
+      values: Record<string, unknown>;
+    }>, options?: {
+      limit?: number;
+    }): Promise<{
+      patched: number;
+    }>;
+    (args: {
+      limit?: number;
+      values: Record<string, unknown>;
+      where: Record<string, unknown>;
+    }): Promise<{
+      patched: number;
+    }>;
+  };
   rank: (indexName: string, options: unknown) => Promise<unknown>;
   rankPage: (indexName: string, options?: unknown) => Promise<unknown>;
   replace: (id: string, document: Record<string, unknown>) => Promise<void>;
@@ -435,7 +477,7 @@ type HttpMethod = "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PU
 * `storage` surface — reach the data layer through `runQuery` / `runMutation` /
 * `runAction`, which forward to the owning shard.
 */
-type HttpActionCtx = Pick<ActionCtx, "auth" | "fetch" | "runAction" | "runMutation" | "runQuery">;
+type HttpActionCtx = Pick<ActionCtx, "auth" | "cache" | "fetch" | "runAction" | "runMutation" | "runQuery">;
 /** A raw handler wrapped by {@link httpAction}. Receives the raw request, returns the raw response. */
 type HttpActionHandler = (context: HttpActionCtx, request: Request) => Promise<Response> | Response;
 /**
@@ -519,6 +561,16 @@ interface HttpStreamHandlerOptions<SearchParams extends ArgsValidator, Params ex
 */
 interface HttpRouteBuilder<SearchParams extends ArgsValidator, Body extends ArgsValidator, Params extends ArgsValidator, Output = undefined> {
   body: <B extends ArgsValidator>(validators: B) => HttpRouteBuilder<SearchParams, B & Body, Params, Output>;
+  /**
+  * Attach a `Cache-Control` header to the response. Only meaningful when
+  * Workers Cache is enabled in `wrangler.jsonc` (`"cache": { "enabled": true }`).
+  */
+  cacheControl: (value: string) => HttpRouteBuilder<SearchParams, Body, Params, Output>;
+  /**
+  * Attach a `Cache-Tag` header to the response for tag-based purging via
+  * `ctx.cache.purge({ tags: [...] })`.
+  */
+  cacheTag: (value: string) => HttpRouteBuilder<SearchParams, Body, Params, Output>;
   handler: [Output] extends [undefined] ? <R>(handler: (options: HttpRouteHandlerOptions<SearchParams, Body, Params>) => Promise<R> | R) => LunoraRouteHandler : (handler: (options: HttpRouteHandlerOptions<SearchParams, Body, Params>) => Output | Promise<Output>) => LunoraRouteHandler;
   output: <V extends Validator>(validator: V) => HttpRouteBuilder<SearchParams, Body, Params, Infer<V>>;
   params: <P extends ArgsValidator>(validators: P) => HttpRouteBuilder<SearchParams, Body, P & Params, Output>;
@@ -533,6 +585,11 @@ interface HttpRouteBuilder<SearchParams extends ArgsValidator, Body extends Args
   * handler's yielded type.
   */
   stream: <R>(handler: (options: HttpStreamHandlerOptions<SearchParams, Params>) => AsyncGenerator<R, void, void> | AsyncIterable<R>) => LunoraRouteHandler;
+  /**
+  * Attach a `Vary` header to the response so Cloudflare stores separate
+  * cached variants per distinct value of the listed request headers.
+  */
+  vary: (value: string) => HttpRouteBuilder<SearchParams, Body, Params, Output>;
 }
 /** Opens a fresh {@link HttpRouteBuilder}. The `path` documents intent; hono owns the actual routing at mount. */
 type HttpRouteFactory = (path: string) => HttpRouteBuilder<EmptyArgs, EmptyArgs, EmptyArgs>;
@@ -828,6 +885,11 @@ interface MaskDatabase {
   }) => Promise<{
     deleted: number;
   }>;
+  deleteWhere?: (tableName: string, where: Record<string, unknown>, options?: {
+    limit?: number;
+  }) => Promise<{
+    deleted: number;
+  }>;
   findFirst: (tableName: string, args?: QueryArgs$1) => Promise<Record<string, unknown> | null>;
   findFirstOrThrow: (tableName: string, args?: QueryArgs$1) => Promise<Record<string, unknown>>;
   findMany: (tableName: string, args?: QueryArgs$1) => Promise<QueryPage$1>;
@@ -839,7 +901,8 @@ interface MaskDatabase {
   insert: (tableName: string, document: Record<string, unknown>) => Promise<string>;
   insertMany: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   lookupById?: (id: string, expectedTable?: string) => Promise<null | {
     row: Record<string, unknown>;
     tableName: string;
@@ -850,7 +913,17 @@ interface MaskDatabase {
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }) => Promise<void>;
+  }) => Promise<{
+    patched: number;
+  }>;
+  patchWhere?: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: {
+    limit?: number;
+  }) => Promise<{
+    patched: number;
+  }>;
   query: (tableName: string) => TableReaderLike$1;
   rank: (tableName: string, indexName: string, options: unknown) => Promise<null | {
     position: number;
@@ -1722,6 +1795,11 @@ interface DatabaseWriterLike {
   }, expectedTable?: string) => Promise<{
     deleted: number;
   }>;
+  deleteWhere?: (tableName: string, where: WhereInput, options?: {
+    limit?: number;
+  }) => Promise<{
+    deleted: number;
+  }>;
   findFirst: (tableName: string, args?: QueryArgs) => Promise<Record<string, unknown> | null>;
   findFirstOrThrow: (tableName: string, args?: QueryArgs) => Promise<Record<string, unknown>>;
   findMany: (tableName: string, args?: QueryArgs) => Promise<QueryPage>;
@@ -1738,7 +1816,8 @@ interface DatabaseWriterLike {
   insert: (tableName: string, document: Record<string, unknown>) => Promise<string>;
   insertMany: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   insertManyUnsafe: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     allowExplicitId?: boolean;
     limit?: number;
@@ -1761,7 +1840,17 @@ interface DatabaseWriterLike {
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }, expectedTable?: string) => Promise<void>;
+  }, expectedTable?: string) => Promise<{
+    patched: number;
+  }>;
+  patchWhere?: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: WhereInput;
+  }, options?: {
+    limit?: number;
+  }) => Promise<{
+    patched: number;
+  }>;
   query: (tableName: string) => TableReaderLike;
   /**
   * Rank a row within its partition. A position is a count-of-rows-before, so

package/dist/index.mjs

@@ -3,8 +3,8 @@ export { initLunora } from './packem_shared/initLunora-sQUqaejx.mjs';
 export { createSecrets } from './packem_shared/createSecrets-DwaR2rNG.mjs';
 export { LunoraEnvError, defineEnv, redactSecrets } from './packem_shared/LunoraEnvError-BGmd1Qs0.mjs';
 export { LunoraError } from './packem_shared/LunoraError-WbxmrpxR.mjs';
-export { bindOrm, bindTableFacade } from './packem_shared/bindOrm-CNXKgfUa.mjs';
-export { httpAction, httpRoute, httpRouter, isSafeHeaderValue, serveStorageObject } from './packem_shared/httpAction-C_L82dxR.mjs';
+export { bindOrm, bindTableFacade } from './packem_shared/bindOrm-Bfgl7f-Q.mjs';
+export { httpAction, httpRoute, httpRouter, isSafeHeaderValue, serveStorageObject } from './packem_shared/httpAction-DCXoYPIk.mjs';
 export { defineIdentity } from './packem_shared/defineIdentity-DiX4zM9x.mjs';
 export { onConnect, onDisconnect } from './packem_shared/onConnect-CIPXKPyw.mjs';
 export { defineMigration } from './packem_shared/defineMigration-Hx01yIht.mjs';
@@ -17,11 +17,11 @@ export { defineShape } from './packem_shared/defineShape-C5scNOrf.mjs';
 export { anyApi } from './types.mjs';
 export { cronJobs } from '@lunora/scheduler';
 export { ValidationError, v } from '@lunora/values';
-export { buildRlsReadRegistry, composeShapeReadWhere } from './packem_shared/buildRlsReadRegistry-DFBFLydB.mjs';
+export { buildRlsReadRegistry, composeShapeReadWhere } from './packem_shared/buildRlsReadRegistry-D54vUQe4.mjs';
 export { createPolicyDsl, definePermission, definePolicies, definePolicy, defineRole } from './packem_shared/createPolicyDsl-By3QB4he.mjs';
 export { defineStorageRule, defineStorageRules } from './packem_shared/defineStorageRule-B5nL4Z1P.mjs';
-export { mask } from './packem_shared/mask-Dc8G5Gl7.mjs';
-export { rls } from './packem_shared/rls-3sCJIH6F.mjs';
+export { mask } from './packem_shared/mask-BT1YgRbF.mjs';
+export { rls } from './packem_shared/rls-B_ZWgslr.mjs';
 export { storageRules } from './packem_shared/storageRules-6QxzDOcx.mjs';
 
 const VERSION = "0.0.0";

package/dist/packem_shared/{bindOrm-CNXKgfUa.mjs → bindOrm-Bfgl7f-Q.mjs}

@@ -44,15 +44,24 @@ const bindTableFacade = (writer, tableName) => {
     count: (where) => writer.count(tableName, where),
     delete: (id) => writer.delete(id, tableName),
     // `deleteMany`/`patchMany` forward the bound `tableName` as `expectedTable`
-    // (threaded through the writer + the RLS middleware's per-id gate) so every
-    // batched id is scoped to this table — the same IDOR guard the single-row
-    // `delete`/`patch` apply. `patchMany` maps the facade's `values` payload to
-    // the writer's `{ id, patch }` shape.
-    deleteMany: (ids, options) => {
-      if (writer.deleteMany === void 0) {
-        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.deleteMany is unavailable: this writer has no batch delete`);
+    // for id-based calls (threaded through the writer + the RLS middleware's
+    // per-id gate) so every batched id is scoped to this table — the same IDOR
+    // guard the single-row `delete`/`patch` apply. The where-based form routes
+    // through the structural writer's `deleteMany(tableName, { where })`.
+    // `patchMany` maps the facade's `values` payload to the writer's
+    // `{ id, patch }` shape.
+    deleteMany: (first, options) => {
+      if (Array.isArray(first)) {
+        if (writer.deleteMany === void 0) {
+          throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.deleteMany is unavailable: this writer has no batch delete`);
+        }
+        return writer.deleteMany(first, options, tableName);
       }
-      return writer.deleteMany(ids, options, tableName);
+      if (writer.deleteWhere === void 0) {
+        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.deleteMany({ where }) is unavailable: this writer has no where-based delete`);
+      }
+      const whereArgs = first;
+      return writer.deleteWhere(tableName, whereArgs.where, { limit: whereArgs.limit });
     },
     // `exists` reuses `findFirst` (RLS-filtered, indexed when a `.withIndex`-able
     // `where` is supplied) and only asks whether a row came back — no count scan.
@@ -72,17 +81,24 @@ const bindTableFacade = (writer, tableName) => {
       return writer.insertMany(tableName, documents, options);
     },
     patch: (id, patch) => writer.patch(id, patch, tableName),
-    patchMany: (patches, options) => {
-      if (writer.patchMany === void 0) {
-        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.patchMany is unavailable: this writer has no batch patch`);
+    patchMany: (first, options) => {
+      if (Array.isArray(first)) {
+        if (writer.patchMany === void 0) {
+          throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.patchMany is unavailable: this writer has no batch patch`);
+        }
+        return writer.patchMany(
+          first.map((entry) => {
+            return { id: entry.id, patch: entry.values };
+          }),
+          options,
+          tableName
+        );
+      }
+      if (writer.patchWhere === void 0) {
+        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.patchMany({ where, values }) is unavailable: this writer has no where-based patch`);
       }
-      return writer.patchMany(
-        patches.map((entry) => {
-          return { id: entry.id, patch: entry.values };
-        }),
-        options,
-        tableName
-      );
+      const whereArgs = first;
+      return writer.patchWhere(tableName, { patch: whereArgs.values, where: whereArgs.where }, { limit: whereArgs.limit });
     },
     rank: (indexName, options) => writer.rank(tableName, indexName, options),
     rankPage: (indexName, options) => writer.rankPage(tableName, indexName, options),

package/dist/packem_shared/{buildRlsReadRegistry-DFBFLydB.mjs → buildRlsReadRegistry-D54vUQe4.mjs}

@@ -1,4 +1,4 @@
-import { indexRolePermissions, computeReadBaseWhere, permissionName } from './rls-3sCJIH6F.mjs';
+import { indexRolePermissions, computeReadBaseWhere, permissionName } from './rls-B_ZWgslr.mjs';
 import { r as readRlsTag } from './policy-tag-DvpVH2tv.mjs';
 
 const FALSE_PREDICATE = { OR: [] };

package/dist/packem_shared/{httpAction-C_L82dxR.mjs → httpAction-DCXoYPIk.mjs}

@@ -126,7 +126,21 @@ const buildRouteHandler = (state, userHandler) => async (c) => {
     const body = Object.keys(state.body).length > 0 ? await parseBody(state.body, c) : {};
     const result = await userHandler({ body, ctx: context, params, searchParams });
     const payload = state.output ? applyOutput(state.output, result) : result;
-    return payload === void 0 ? new Response(null, { status: 204 }) : Response.json(payload);
+    const headers = {};
+    if (state.cacheControl) {
+      headers["cache-control"] = state.cacheControl;
+    }
+    if (state.cacheTag) {
+      headers["cache-tag"] = state.cacheTag;
+    }
+    if (state.vary) {
+      headers.vary = state.vary;
+    }
+    const hasCacheHeaders = Object.keys(headers).length > 0;
+    if (payload === void 0) {
+      return new Response(null, { headers: hasCacheHeaders ? headers : void 0, status: 204 });
+    }
+    return Response.json(payload, { headers: hasCacheHeaders ? headers : void 0 });
   } catch (error) {
     return errorResponse(error);
   }
@@ -202,25 +216,31 @@ const buildStreamHandler = (state, userHandler) => (
         }
       }
     });
-    return new Response(stream, {
-      headers: {
-        "cache-control": "no-cache, no-transform",
-        "content-type": "text/event-stream; charset=utf-8",
-        // Hint to proxies (including Cloudflare's own buffering layer)
-        // that this response must not be coalesced.
-        "x-accel-buffering": "no"
-      }
-    });
+    const headers = {
+      // SSE responses must stay uncacheable so proxies don't buffer or
+      // coalesce live frames. `cacheControl()` is intentionally ignored
+      // for stream() routes; `cacheTag`/`vary` are also omitted because
+      // they only make sense alongside a cacheable response.
+      "cache-control": "no-cache, no-transform",
+      "content-type": "text/event-stream; charset=utf-8",
+      // Hint to proxies (including Cloudflare's own buffering layer)
+      // that this response must not be coalesced.
+      "x-accel-buffering": "no"
+    };
+    return new Response(stream, { headers });
   }
 );
 const makeRouteBuilder = (state) => {
   return {
     body: (validators) => makeRouteBuilder({ ...state, body: { ...state.body, ...validators } }),
+    cacheControl: (value) => makeRouteBuilder({ ...state, cacheControl: value }),
+    cacheTag: (value) => makeRouteBuilder({ ...state, cacheTag: value }),
     handler: (userHandler) => buildRouteHandler(state, userHandler),
     output: (validator) => makeRouteBuilder({ ...state, output: validator }),
     params: (validators) => makeRouteBuilder({ ...state, params: { ...state.params, ...validators } }),
     searchParams: (validators) => makeRouteBuilder({ ...state, searchParams: { ...state.searchParams, ...validators } }),
-    stream: (userHandler) => buildStreamHandler(state, userHandler)
+    stream: (userHandler) => buildStreamHandler(state, userHandler),
+    vary: (value) => makeRouteBuilder({ ...state, vary: value })
   };
 };
 const makeRouteFactory = (method) => (path) => makeRouteBuilder({ body: {}, method, params: {}, path, searchParams: {} });

package/dist/packem_shared/{mask-Dc8G5Gl7.mjs → mask-BT1YgRbF.mjs}

@@ -1,5 +1,5 @@
 import { LunoraError } from './LunoraError-WbxmrpxR.mjs';
-import { bindTableFacade, bindOrm } from './bindOrm-CNXKgfUa.mjs';
+import { bindTableFacade, bindOrm } from './bindOrm-Bfgl7f-Q.mjs';
 
 const permissionName = (permission) => typeof permission === "string" ? permission : permission.name;
 const indexRolePermissions = (roles) => {

package/dist/packem_shared/{rls-3sCJIH6F.mjs → rls-B_ZWgslr.mjs}

@@ -1,5 +1,5 @@
 import { LunoraError } from './LunoraError-WbxmrpxR.mjs';
-import { bindTableFacade, bindOrm } from './bindOrm-CNXKgfUa.mjs';
+import { bindTableFacade, bindOrm } from './bindOrm-Bfgl7f-Q.mjs';
 import { t as tagRlsMiddleware } from './policy-tag-DvpVH2tv.mjs';
 
 const DEFAULT_BATCH_LIMIT = 500;
@@ -333,6 +333,16 @@ const wrapDatabase = (base, raw, perTable, context) => {
       }
       return { deleted: ids.length };
     },
+    async deleteWhere(tableName, where, options) {
+      const { baseWhere } = readBase(tableName);
+      const resolved = await route(tableName).findMany(tableName, {
+        baseWhere: mergeBaseWhere(where, baseWhere),
+        relationBaseWhere: relationReadFilter
+      });
+      const ids = resolved.page.map((row) => String(row["_id"]));
+      assertBatchLimit(ids.length, options?.limit, "deleteWhere");
+      return wrapped.deleteMany(ids, options);
+    },
     async findFirst(tableName, args) {
       const { baseWhere } = readBase(tableName);
       return route(tableName).findFirst(tableName, {
@@ -436,6 +446,19 @@ const wrapDatabase = (base, raw, perTable, context) => {
           expectedTable
         );
       }
+      return { patched: patches.length };
+    },
+    async patchWhere(tableName, args, options) {
+      const { baseWhere } = readBase(tableName);
+      const resolved = await route(tableName).findMany(tableName, {
+        baseWhere: mergeBaseWhere(args.where, baseWhere),
+        relationBaseWhere: relationReadFilter
+      });
+      const patches = resolved.page.map((row) => {
+        return { id: String(row["_id"]), patch: args.patch };
+      });
+      assertBatchLimit(patches.length, options?.limit, "patchWhere");
+      return wrapped.patchMany(patches, options);
     },
     query(tableName) {
       const { baseWhere } = readBase(tableName);

package/dist/rls/testing.mjs

@@ -1,4 +1,4 @@
-import { indexRolePermissions, computeReadBaseWhere, matchesWhere, evaluateWrite, permissionName } from '../packem_shared/rls-3sCJIH6F.mjs';
+import { indexRolePermissions, computeReadBaseWhere, matchesWhere, evaluateWrite, permissionName } from '../packem_shared/rls-B_ZWgslr.mjs';
 
 const expectPolicy = (policies, options = {}) => {
   const rolePermissions = indexRolePermissions(options.roles);

package/dist/types.d.mts

@@ -518,6 +518,16 @@ interface BatchWriteOptions {
   /** Reject the call when the batch size exceeds this value (default 500). */
   limit?: number;
 }
+/** Options accepted by {@link DatabaseWriter.insertMany} and the per-table facade. */
+interface InsertManyOptions extends BatchWriteOptions {
+  /**
+  * When `true`, a UNIQUE-constraint breach for a row resolves to `null`
+  * instead of throwing — the rest of the batch is still inserted. Skipped rows
+  * keep their input-order slot with `null` in the returned array. Mirrors
+  * better-drizzle's `createMany({ skipDuplicates: true })`.
+  */
+  skipDuplicates?: boolean;
+}
 interface DatabaseWriter extends DatabaseReader {
   delete: <T extends string>(id: Id<T>) => Promise<void>;
   /**
@@ -535,6 +545,18 @@ interface DatabaseWriter extends DatabaseReader {
     deleted: number;
   }>;
   /**
+  * Delete every row matching `where` in one call. Matching rows are resolved
+  * first, then each row is deleted through the single-row delete pipeline
+  * (triggers, companion sync, CDC, broadcast) so reactive subscriptions and
+  * search/aggregate companions stay correct.
+  *
+  * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
+  */
+  deleteWhere: (tableName: string, where: Record<string, unknown>, options?: BatchWriteOptions) => Promise<{
+    deleted: number;
+  }>;
+  /**
   * Insert a document, returning its server id.
   *
   * Pass `options.clientId` (a UUID) to key the row yourself — for an
@@ -551,12 +573,21 @@ interface DatabaseWriter extends DatabaseReader {
   * row gets defaults, validators, triggers, and a per-row RLS check — but the
   * caller pays one round-trip instead of N.
   *
+  * Pass `{ skipDuplicates: true }` to turn UNIQUE-constraint breaches into
+  * `null` results for that row instead of failing the whole batch; the rest of
+  * the batch is still inserted and order is preserved.
+  *
   * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
   * BEGIN/COMMIT span, so a mid-batch failure (an invalid or RLS-denied row)
   * rolls back the whole mutation. (In an action there is no transaction span,
   * so the prior inserts persist; the in-memory test harness mirrors the span.)
   */
-  insertMany: <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options?: BatchWriteOptions) => Promise<Id<T>[]>;
+  insertMany: {
+    <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options: BatchWriteOptions & {
+      skipDuplicates: true;
+    }): Promise<(Id<T> | null)[]>;
+    <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options?: InsertManyOptions): Promise<Id<T>[]>;
+  };
   /**
   * **Trusted** bulk insert: one multi-row `INSERT` that **skips per-row
   * `.check()` validators and before/after triggers** for throughput on data you
@@ -576,7 +607,8 @@ interface DatabaseWriter extends DatabaseReader {
   patch: <T extends string>(id: Id<T>, patch: Record<string, unknown>) => Promise<void>;
   /**
   * Patch many rows by id in one call. Each `{ id, patch }` is applied like a
-  * single `patch()` (per-row triggers + RLS).
+  * single `patch()` (per-row triggers + RLS). Returns the number of rows
+  * actually patched.
   *
   * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
   * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
@@ -586,7 +618,24 @@ interface DatabaseWriter extends DatabaseReader {
   patchMany: <T extends string>(patches: ReadonlyArray<{
     id: Id<T>;
     patch: Record<string, unknown>;
-  }>, options?: BatchWriteOptions) => Promise<void>;
+  }>, options?: BatchWriteOptions) => Promise<{
+    patched: number;
+  }>;
+  /**
+  * Patch every row matching `where` with the same `patch` in one call. The
+  * matching rows are resolved first, then each row is updated through the
+  * single-row patch pipeline (OCC, triggers, companion sync, CDC, broadcast)
+  * so reactive subscriptions and search/aggregate companions stay correct.
+  *
+  * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
+  */
+  patchWhere: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: BatchWriteOptions) => Promise<{
+    patched: number;
+  }>;
   replace: <T extends string>(id: Id<T>, document: Record<string, unknown>) => Promise<void>;
 }
 /** Authenticated identity surfaced into every context. */
@@ -690,6 +739,21 @@ interface Workflows {
   get: <Params = Record<string, unknown>>(name: string) => WorkflowHandle<Params>;
 }
 /**
+* Programmatic cache purge surface exposed on {@link ActionCtx}. Actions run
+* in the Worker (not the DO), so they can reach the Worker's `ctx.cache.purge`.
+* Queries and mutations do not expose this — they run inside the Durable Object.
+*/
+interface CachePurge {
+  /**
+  * Purge cached responses matching the given tags, or everything when
+  * `purgeEverything` is true. Only available in action handlers.
+  */
+  purge: (options: {
+    purgeEverything?: boolean;
+    tags?: string[];
+  }) => Promise<unknown>;
+}
+/**
 * Structural projection of workers-types' `SecretsStoreSecret` binding — the
 * per-secret `secrets_store_secrets[]` binding whose `.get()` resolves the
 * secret value (or throws if it does not exist). Mirrored structurally so the
@@ -1136,6 +1200,13 @@ interface MutationCtx {
 }
 interface ActionCtx {
   readonly auth: AuthState;
+  /**
+  * Programmatic Workers Cache purge; see {@link CachePurge}.
+  * **Action-only** — actions run in the Worker, which has a `cache` binding.
+  * Queries and mutations run inside the Durable Object and do not expose this.
+  * Optional at runtime because Workers Cache is only present when enabled.
+  */
+  readonly cache?: CachePurge;
   readonly db: DatabaseWriter;
   /**
   * The validated, typed environment. Populated only when the project declares
@@ -1178,4 +1249,4 @@ interface ActionCtx {
 */
 type AnyApi = Record<string, Record<string, RegisteredFunction<ArgsValidator, unknown, FunctionKind>>>;
 declare const anyApi: AnyApi;
-export { type ActionCtx, type AggregateIndexDefinition, type AggregateOp, type AnyApi, type ArgsValidator, type AuthState, type DatabaseReader, type DatabaseWriter, type DurableObjectJurisdiction, type ExternalSourceDefinition, type ExternalSourceMode, type ExternalSourceRefresh, type FunctionKind, type FunctionVisibility, type GlobalBackend, type IndexDefinition, type IndexRangeBuilder, type InferArgs, type LifecycleEvent, type LifecycleEventKind, type LunoraLogger, type MutationCtx, type OnDeleteAction, type PaginationOptions, type PaginationResult, type QueryCtx, type RankIndexDefinition, type RankSortKey, type ReadOnlyStorage, type RegisteredAction, type RegisteredFunction, type RegisteredLifecycleHook, type RegisteredMutation, type RegisteredQuery, type RegisteredStream, type RelationDefinition, type ScheduledFunctionDoc, type ScheduledJob, type Scheduler, type Schema, type SearchFilterBuilder, type SearchIndexDefinition, type Secrets, type SecretsStoreSecretLike, type ShardMode, type Storage, type StorageMetadata, type SystemDatabaseReader, type SystemDoc, type SystemQuery, type SystemTableName, type TableDefinition, type TableReader, type TableVectorIndex, type TriggerAggregateOptions, type TriggerBuilder, type TriggerCtx, type TriggerDatabase, type TriggerDefinition, type TriggerDeleteEvent, type TriggerEvent, type TriggerGroupByEntry, type TriggerGroupByOptions, type TriggerHandler, type TriggerInsertEvent, type TriggerOp, type TriggerQueryArgs, type TriggerQueryPage, type TriggerRankOptions, type TriggerRankPageOptions, type TriggerRankResult, type TriggerRow, type TriggerTiming, type TriggerUpdateEvent, type VectorEmbedder, type VectorIndexDefinition, type VectorMatch, type VectorMatches, type VectorMetric, type VectorQueryInput, type VectorRecord, type VectorSearch, type VectorSearchReader, type VectorUpsertInput, type WorkflowCreateOptions, type WorkflowHandle, type WorkflowInstance, type WorkflowInstanceStatus, type WorkflowStatusResult, type Workflows, anyApi };
+export { type ActionCtx, type AggregateIndexDefinition, type AggregateOp, type AnyApi, type ArgsValidator, type AuthState, type CachePurge, type DatabaseReader, type DatabaseWriter, type DurableObjectJurisdiction, type ExternalSourceDefinition, type ExternalSourceMode, type ExternalSourceRefresh, type FunctionKind, type FunctionVisibility, type GlobalBackend, type IndexDefinition, type IndexRangeBuilder, type InferArgs, type LifecycleEvent, type LifecycleEventKind, type LunoraLogger, type MutationCtx, type OnDeleteAction, type PaginationOptions, type PaginationResult, type QueryCtx, type RankIndexDefinition, type RankSortKey, type ReadOnlyStorage, type RegisteredAction, type RegisteredFunction, type RegisteredLifecycleHook, type RegisteredMutation, type RegisteredQuery, type RegisteredStream, type RelationDefinition, type ScheduledFunctionDoc, type ScheduledJob, type Scheduler, type Schema, type SearchFilterBuilder, type SearchIndexDefinition, type Secrets, type SecretsStoreSecretLike, type ShardMode, type Storage, type StorageMetadata, type SystemDatabaseReader, type SystemDoc, type SystemQuery, type SystemTableName, type TableDefinition, type TableReader, type TableVectorIndex, type TriggerAggregateOptions, type TriggerBuilder, type TriggerCtx, type TriggerDatabase, type TriggerDefinition, type TriggerDeleteEvent, type TriggerEvent, type TriggerGroupByEntry, type TriggerGroupByOptions, type TriggerHandler, type TriggerInsertEvent, type TriggerOp, type TriggerQueryArgs, type TriggerQueryPage, type TriggerRankOptions, type TriggerRankPageOptions, type TriggerRankResult, type TriggerRow, type TriggerTiming, type TriggerUpdateEvent, type VectorEmbedder, type VectorIndexDefinition, type VectorMatch, type VectorMatches, type VectorMetric, type VectorQueryInput, type VectorRecord, type VectorSearch, type VectorSearchReader, type VectorUpsertInput, type WorkflowCreateOptions, type WorkflowHandle, type WorkflowInstance, type WorkflowInstanceStatus, type WorkflowStatusResult, type Workflows, anyApi };

package/dist/types.d.ts

@@ -518,6 +518,16 @@ interface BatchWriteOptions {
   /** Reject the call when the batch size exceeds this value (default 500). */
   limit?: number;
 }
+/** Options accepted by {@link DatabaseWriter.insertMany} and the per-table facade. */
+interface InsertManyOptions extends BatchWriteOptions {
+  /**
+  * When `true`, a UNIQUE-constraint breach for a row resolves to `null`
+  * instead of throwing — the rest of the batch is still inserted. Skipped rows
+  * keep their input-order slot with `null` in the returned array. Mirrors
+  * better-drizzle's `createMany({ skipDuplicates: true })`.
+  */
+  skipDuplicates?: boolean;
+}
 interface DatabaseWriter extends DatabaseReader {
   delete: <T extends string>(id: Id<T>) => Promise<void>;
   /**
@@ -535,6 +545,18 @@ interface DatabaseWriter extends DatabaseReader {
     deleted: number;
   }>;
   /**
+  * Delete every row matching `where` in one call. Matching rows are resolved
+  * first, then each row is deleted through the single-row delete pipeline
+  * (triggers, companion sync, CDC, broadcast) so reactive subscriptions and
+  * search/aggregate companions stay correct.
+  *
+  * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
+  */
+  deleteWhere: (tableName: string, where: Record<string, unknown>, options?: BatchWriteOptions) => Promise<{
+    deleted: number;
+  }>;
+  /**
   * Insert a document, returning its server id.
   *
   * Pass `options.clientId` (a UUID) to key the row yourself — for an
@@ -551,12 +573,21 @@ interface DatabaseWriter extends DatabaseReader {
   * row gets defaults, validators, triggers, and a per-row RLS check — but the
   * caller pays one round-trip instead of N.
   *
+  * Pass `{ skipDuplicates: true }` to turn UNIQUE-constraint breaches into
+  * `null` results for that row instead of failing the whole batch; the rest of
+  * the batch is still inserted and order is preserved.
+  *
   * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
   * BEGIN/COMMIT span, so a mid-batch failure (an invalid or RLS-denied row)
   * rolls back the whole mutation. (In an action there is no transaction span,
   * so the prior inserts persist; the in-memory test harness mirrors the span.)
   */
-  insertMany: <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options?: BatchWriteOptions) => Promise<Id<T>[]>;
+  insertMany: {
+    <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options: BatchWriteOptions & {
+      skipDuplicates: true;
+    }): Promise<(Id<T> | null)[]>;
+    <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options?: InsertManyOptions): Promise<Id<T>[]>;
+  };
   /**
   * **Trusted** bulk insert: one multi-row `INSERT` that **skips per-row
   * `.check()` validators and before/after triggers** for throughput on data you
@@ -576,7 +607,8 @@ interface DatabaseWriter extends DatabaseReader {
   patch: <T extends string>(id: Id<T>, patch: Record<string, unknown>) => Promise<void>;
   /**
   * Patch many rows by id in one call. Each `{ id, patch }` is applied like a
-  * single `patch()` (per-row triggers + RLS).
+  * single `patch()` (per-row triggers + RLS). Returns the number of rows
+  * actually patched.
   *
   * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
   * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
@@ -586,7 +618,24 @@ interface DatabaseWriter extends DatabaseReader {
   patchMany: <T extends string>(patches: ReadonlyArray<{
     id: Id<T>;
     patch: Record<string, unknown>;
-  }>, options?: BatchWriteOptions) => Promise<void>;
+  }>, options?: BatchWriteOptions) => Promise<{
+    patched: number;
+  }>;
+  /**
+  * Patch every row matching `where` with the same `patch` in one call. The
+  * matching rows are resolved first, then each row is updated through the
+  * single-row patch pipeline (OCC, triggers, companion sync, CDC, broadcast)
+  * so reactive subscriptions and search/aggregate companions stay correct.
+  *
+  * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
+  */
+  patchWhere: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: BatchWriteOptions) => Promise<{
+    patched: number;
+  }>;
   replace: <T extends string>(id: Id<T>, document: Record<string, unknown>) => Promise<void>;
 }
 /** Authenticated identity surfaced into every context. */
@@ -690,6 +739,21 @@ interface Workflows {
   get: <Params = Record<string, unknown>>(name: string) => WorkflowHandle<Params>;
 }
 /**
+* Programmatic cache purge surface exposed on {@link ActionCtx}. Actions run
+* in the Worker (not the DO), so they can reach the Worker's `ctx.cache.purge`.
+* Queries and mutations do not expose this — they run inside the Durable Object.
+*/
+interface CachePurge {
+  /**
+  * Purge cached responses matching the given tags, or everything when
+  * `purgeEverything` is true. Only available in action handlers.
+  */
+  purge: (options: {
+    purgeEverything?: boolean;
+    tags?: string[];
+  }) => Promise<unknown>;
+}
+/**
 * Structural projection of workers-types' `SecretsStoreSecret` binding — the
 * per-secret `secrets_store_secrets[]` binding whose `.get()` resolves the
 * secret value (or throws if it does not exist). Mirrored structurally so the
@@ -1136,6 +1200,13 @@ interface MutationCtx {
 }
 interface ActionCtx {
   readonly auth: AuthState;
+  /**
+  * Programmatic Workers Cache purge; see {@link CachePurge}.
+  * **Action-only** — actions run in the Worker, which has a `cache` binding.
+  * Queries and mutations run inside the Durable Object and do not expose this.
+  * Optional at runtime because Workers Cache is only present when enabled.
+  */
+  readonly cache?: CachePurge;
   readonly db: DatabaseWriter;
   /**
   * The validated, typed environment. Populated only when the project declares
@@ -1178,4 +1249,4 @@ interface ActionCtx {
 */
 type AnyApi = Record<string, Record<string, RegisteredFunction<ArgsValidator, unknown, FunctionKind>>>;
 declare const anyApi: AnyApi;
-export { type ActionCtx, type AggregateIndexDefinition, type AggregateOp, type AnyApi, type ArgsValidator, type AuthState, type DatabaseReader, type DatabaseWriter, type DurableObjectJurisdiction, type ExternalSourceDefinition, type ExternalSourceMode, type ExternalSourceRefresh, type FunctionKind, type FunctionVisibility, type GlobalBackend, type IndexDefinition, type IndexRangeBuilder, type InferArgs, type LifecycleEvent, type LifecycleEventKind, type LunoraLogger, type MutationCtx, type OnDeleteAction, type PaginationOptions, type PaginationResult, type QueryCtx, type RankIndexDefinition, type RankSortKey, type ReadOnlyStorage, type RegisteredAction, type RegisteredFunction, type RegisteredLifecycleHook, type RegisteredMutation, type RegisteredQuery, type RegisteredStream, type RelationDefinition, type ScheduledFunctionDoc, type ScheduledJob, type Scheduler, type Schema, type SearchFilterBuilder, type SearchIndexDefinition, type Secrets, type SecretsStoreSecretLike, type ShardMode, type Storage, type StorageMetadata, type SystemDatabaseReader, type SystemDoc, type SystemQuery, type SystemTableName, type TableDefinition, type TableReader, type TableVectorIndex, type TriggerAggregateOptions, type TriggerBuilder, type TriggerCtx, type TriggerDatabase, type TriggerDefinition, type TriggerDeleteEvent, type TriggerEvent, type TriggerGroupByEntry, type TriggerGroupByOptions, type TriggerHandler, type TriggerInsertEvent, type TriggerOp, type TriggerQueryArgs, type TriggerQueryPage, type TriggerRankOptions, type TriggerRankPageOptions, type TriggerRankResult, type TriggerRow, type TriggerTiming, type TriggerUpdateEvent, type VectorEmbedder, type VectorIndexDefinition, type VectorMatch, type VectorMatches, type VectorMetric, type VectorQueryInput, type VectorRecord, type VectorSearch, type VectorSearchReader, type VectorUpsertInput, type WorkflowCreateOptions, type WorkflowHandle, type WorkflowInstance, type WorkflowInstanceStatus, type WorkflowStatusResult, type Workflows, anyApi };
+export { type ActionCtx, type AggregateIndexDefinition, type AggregateOp, type AnyApi, type ArgsValidator, type AuthState, type CachePurge, type DatabaseReader, type DatabaseWriter, type DurableObjectJurisdiction, type ExternalSourceDefinition, type ExternalSourceMode, type ExternalSourceRefresh, type FunctionKind, type FunctionVisibility, type GlobalBackend, type IndexDefinition, type IndexRangeBuilder, type InferArgs, type LifecycleEvent, type LifecycleEventKind, type LunoraLogger, type MutationCtx, type OnDeleteAction, type PaginationOptions, type PaginationResult, type QueryCtx, type RankIndexDefinition, type RankSortKey, type ReadOnlyStorage, type RegisteredAction, type RegisteredFunction, type RegisteredLifecycleHook, type RegisteredMutation, type RegisteredQuery, type RegisteredStream, type RelationDefinition, type ScheduledFunctionDoc, type ScheduledJob, type Scheduler, type Schema, type SearchFilterBuilder, type SearchIndexDefinition, type Secrets, type SecretsStoreSecretLike, type ShardMode, type Storage, type StorageMetadata, type SystemDatabaseReader, type SystemDoc, type SystemQuery, type SystemTableName, type TableDefinition, type TableReader, type TableVectorIndex, type TriggerAggregateOptions, type TriggerBuilder, type TriggerCtx, type TriggerDatabase, type TriggerDefinition, type TriggerDeleteEvent, type TriggerEvent, type TriggerGroupByEntry, type TriggerGroupByOptions, type TriggerHandler, type TriggerInsertEvent, type TriggerOp, type TriggerQueryArgs, type TriggerQueryPage, type TriggerRankOptions, type TriggerRankPageOptions, type TriggerRankResult, type TriggerRow, type TriggerTiming, type TriggerUpdateEvent, type VectorEmbedder, type VectorIndexDefinition, type VectorMatch, type VectorMatches, type VectorMetric, type VectorQueryInput, type VectorRecord, type VectorSearch, type VectorSearchReader, type VectorUpsertInput, type WorkflowCreateOptions, type WorkflowHandle, type WorkflowInstance, type WorkflowInstanceStatus, type WorkflowStatusResult, type Workflows, anyApi };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/server",
-  "version": "1.0.0-alpha.17",
+  "version": "1.0.0-alpha.19",
   "description": "Server primitives for Lunora: defineSchema, defineTable, query, mutation, and action",
   "keywords": [
     "backend",