kitcn 0.25.0 → 0.25.2

package/dist/{procedure-name-B09-cf1-.d.ts → procedure-name-l2YusEZI.d.ts}

@@ -1,10 +1,10 @@
-import { t as VRequired } from "./validators-V4eM2-Jg.js";
+import { t as VRequired } from "./validators-wOIjhkfN.js";
 import { A as HttpProcedureBuilderDef, D as HttpHandlerOpts, L as DataTransformerOptions, N as ProcedureMeta, O as HttpMethod, W as getTransformer, _ as CRPCHttpRouter, f as InferHttpInput, k as HttpProcedure, p as InferHttpOutput, y as HttpRouterRecord } from "./http-types-90mapMP9.js";
 import { g as UnsetMarker, i as IntersectIfDefined, o as MiddlewareBuilder, p as Overwrite$1, s as MiddlewareFunction, t as AnyMiddleware } from "./types-eNzQmbqM.js";
 import { ConvexError, GenericId, GenericValidator, ObjectType, OptionalProperty, PropertyValidators, VAny, VArray, VBoolean, VBytes, VFloat64, VId, VInt64, VLiteral, VNull, VObject, VOptional, VRecord, VString, VUnion, Validator, Value as Value$1 } from "convex/values";
 import { ActionBuilder, ArgsArrayToObject, DefaultFunctionArgs, FunctionReference, FunctionReturnType, FunctionVisibility, GenericActionCtx, GenericDataModel, GenericMutationCtx, GenericQueryCtx, MutationBuilder, QueryBuilder, RegisteredAction, RegisteredMutation, RegisteredQuery, TableNamesInDataModel } from "convex/server";
-import { z } from "zod";
-import * as z$1 from "zod/v4";
+import * as z$1 from "zod";
+import * as z$2 from "zod/v4";
 import * as zCore from "zod/v4/core";
 
 //#region src/internal/upstream/index.d.ts
@@ -264,7 +264,7 @@ declare function zCustomAction<CustomArgsValidator extends PropertyValidators, C
  */
 declare const zid: <DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel> = TableNamesInDataModel<DataModel>>(tableName: TableName) => Zid<TableName>;
 /** The type of Convex validators in Zod */
-type Zid<TableName extends string> = z$1.ZodCustom<GenericId<TableName>> & zCore.$ZodRecordKey;
+type Zid<TableName extends string> = z$2.ZodCustom<GenericId<TableName>> & zCore.$ZodRecordKey;
 /**
  * Useful to get the input context type for a custom function using Zod.
  */
@@ -490,7 +490,7 @@ declare function withSystemFields<Table extends string, T extends {
   [key: string]: zCore.$ZodType;
 }>(tableName: Table, zObject: T): T & {
   _id: Zid<Table>;
-  _creationTime: z$1.ZodNumber;
+  _creationTime: z$2.ZodNumber;
 };
 /**
  * A builder that customizes a Convex function, whether or not it validates
@@ -534,7 +534,7 @@ type Returns<T> = Promise<NullToUndefinedOrNull<T>> | NullToUndefinedOrNull<T>;
 type ReturnValueInput<ReturnsValidator extends zCore.$ZodType | ZodFields | void> = [ReturnsValidator] extends [zCore.$ZodType] ? Returns<zCore.input<ReturnsValidator>> : [ReturnsValidator] extends [ZodFields] ? Returns<zCore.input<zCore.$ZodObject<ReturnsValidator>>> : any;
 type ReturnValueOutput<ReturnsValidator extends zCore.$ZodType | ZodFields | void> = [ReturnsValidator] extends [zCore.$ZodType] ? Returns<zCore.output<ReturnsValidator>> : [ReturnsValidator] extends [ZodFields] ? Returns<zCore.output<zCore.$ZodObject<ReturnsValidator, zCore.$strict>>> : any;
 type ReturnValueForHandler<ReturnsValidator extends zCore.$ZodType | ZodFields | void, SkipZodReturnsValidation extends boolean> = SkipZodReturnsValidation extends true ? ReturnValueOutput<ReturnsValidator> : ReturnValueInput<ReturnsValidator>;
-type ArgsInput<ArgsValidator extends ZodFields | zCore.$ZodObject<any> | void> = [ArgsValidator] extends [zCore.$ZodObject<any>] ? [zCore.input<ArgsValidator>] : ArgsValidator extends Record<string, never> ? [{}] : [ArgsValidator] extends [Record<string, z$1.ZodTypeAny>] ? [zCore.input<zCore.$ZodObject<ArgsValidator, zCore.$strict>>] : OneArgArray;
+type ArgsInput<ArgsValidator extends ZodFields | zCore.$ZodObject<any> | void> = [ArgsValidator] extends [zCore.$ZodObject<any>] ? [zCore.input<ArgsValidator>] : ArgsValidator extends Record<string, never> ? [{}] : [ArgsValidator] extends [Record<string, z$2.ZodTypeAny>] ? [zCore.input<zCore.$ZodObject<ArgsValidator, zCore.$strict>>] : OneArgArray;
 type ArgsOutput<ArgsValidator extends ZodFields | zCore.$ZodObject<any> | void> = [ArgsValidator] extends [zCore.$ZodObject<any>] ? [zCore.output<ArgsValidator>] : [ArgsValidator] extends [ZodFields] ? [zCore.output<zCore.$ZodObject<ArgsValidator, zCore.$strict>>] : OneArgArray;
 type Overwrite<T, U> = Omit<T, keyof U> & U;
 type OneArgArray<ArgsObject extends DefaultFunctionArgs = DefaultFunctionArgs> = [ArgsObject];
@@ -567,11 +567,14 @@ type IsUnknownOrAny<T> = 0 extends 1 & T ? true : unknown extends T ? true : fal
  * ZodValidatorFromConvex<typeof v.string()> // → z.ZodString
  * ```
  */
-type ZodValidatorFromConvex<V extends GenericValidator> = V extends Validator<any, 'optional', any> ? z$1.ZodOptional<ZodFromValidatorBase<VRequired<V>>> : ZodFromValidatorBase<V>;
-type ZodFromValidatorBase<V extends GenericValidator> = V extends VId<infer Type> ? Zid<TableNameFromType<NotUndefined<Type>>> : V extends VString<infer T> ? BrandIfBranded<T, z$1.ZodString> : V extends VFloat64<infer T> ? BrandIfBranded<T, z$1.ZodNumber> : V extends VInt64<any> ? z$1.ZodBigInt : V extends VBoolean<any> ? z$1.ZodBoolean : V extends VNull<any> ? z$1.ZodNull : V extends VArray<any, infer Element> ? Element extends VArray<any, any> ? z$1.ZodArray<zCore.SomeType> : z$1.ZodArray<ZodFromValidatorBase<Element>> : V extends VObject<any, infer Fields extends Record<string, GenericValidator>> ? z$1.ZodObject<ZodShapeFromConvexObject<Fields>, zCore.$strict> : V extends VBytes<any, any> ? never : V extends VLiteral<infer T extends zCore.util.Literal, OptionalProperty> ? z$1.ZodLiteral<NotUndefined<T>> : V extends VRecord<any, infer Key, infer Value, OptionalProperty, any> ? z$1.ZodRecord<ZodFromStringValidator<Key>, ZodFromValidatorBase<Value>> : V extends VUnion<any, [], OptionalProperty, any> ? z$1.ZodNever : V extends VUnion<any, [infer I extends GenericValidator], OptionalProperty, any> ? ZodValidatorFromConvex<I> : V extends VUnion<any, [infer A extends GenericValidator, ...infer Rest extends GenericValidator[]], OptionalProperty, any> ? z$1.ZodUnion<readonly [ZodValidatorFromConvex<A>, ...{ [K in keyof Rest]: ZodValidatorFromConvex<Rest[K]> }]> : V extends VAny<any, OptionalProperty, any> ? z$1.ZodAny : never;
+type ZodValidatorFromConvex<V extends GenericValidator> = V extends Validator<any, 'optional', any> ? z$2.ZodOptional<ZodFromValidatorBase<VRequired<V>>> : ZodFromValidatorBase<V>;
+type ZodFromValidatorBase<V extends GenericValidator> = V extends VId<infer Type> ? Zid<TableNameFromType<NotUndefined<Type>>> : V extends VString<infer T> ? BrandIfBranded<T, z$2.ZodString> : V extends VFloat64<infer T> ? BrandIfBranded<T, z$2.ZodNumber> : V extends VInt64<any> ? z$2.ZodBigInt : V extends {
+  readonly kind: 'commitTs';
+  readonly type: infer Type;
+} ? z$2.ZodType<NotUndefined<Type>> : V extends VBoolean<any> ? z$2.ZodBoolean : V extends VNull<any> ? z$2.ZodNull : V extends VArray<any, infer Element> ? Element extends VArray<any, any> ? z$2.ZodArray<zCore.SomeType> : z$2.ZodArray<ZodFromValidatorBase<Element>> : V extends VObject<any, infer Fields extends Record<string, GenericValidator>> ? z$2.ZodObject<ZodShapeFromConvexObject<Fields>, zCore.$strict> : V extends VBytes<any, any> ? never : V extends VLiteral<infer T extends zCore.util.Literal, OptionalProperty> ? z$2.ZodLiteral<NotUndefined<T>> : V extends VRecord<any, infer Key, infer Value, OptionalProperty, any> ? z$2.ZodRecord<ZodFromStringValidator<Key>, ZodFromValidatorBase<Value>> : V extends VUnion<any, [], OptionalProperty, any> ? z$2.ZodNever : V extends VUnion<any, [infer I extends GenericValidator], OptionalProperty, any> ? ZodValidatorFromConvex<I> : V extends VUnion<any, [infer A extends GenericValidator, ...infer Rest extends GenericValidator[]], OptionalProperty, any> ? z$2.ZodUnion<readonly [ZodValidatorFromConvex<A>, ...{ [K in keyof Rest]: ZodValidatorFromConvex<Rest[K]> }]> : V extends VAny<any, OptionalProperty, any> ? z$2.ZodAny : never;
 type BrandIfBranded<InnerType, Validator extends zCore.SomeType> = InnerType extends zCore.$brand<infer Brand> ? zCore.$ZodBranded<Validator, Brand> : Validator;
 type StringValidator = Validator<string, 'required', any>;
-type ZodFromStringValidator<V extends StringValidator> = V extends VId<GenericId<infer TableName extends string>> ? Zid<TableName> : V extends VString<infer T, any> ? BrandIfBranded<T, z$1.ZodString> : V extends VLiteral<infer Literal extends string> ? z$1.ZodLiteral<Literal> : V extends VUnion<any, [], any, any> ? z$1.ZodNever : V extends VUnion<any, [infer I extends GenericValidator], any, any> ? ZodFromStringValidator<I> : V extends VUnion<any, [infer A extends GenericValidator, ...infer Rest extends GenericValidator[]], any, any> ? z$1.ZodUnion<readonly [ZodFromStringValidator<A>, ...{ [K in keyof Rest]: ZodFromStringValidator<Rest[K]> }]> : never;
+type ZodFromStringValidator<V extends StringValidator> = V extends VId<GenericId<infer TableName extends string>> ? Zid<TableName> : V extends VString<infer T, any> ? BrandIfBranded<T, z$2.ZodString> : V extends VLiteral<infer Literal extends string> ? z$2.ZodLiteral<Literal> : V extends VUnion<any, [], any, any> ? z$2.ZodNever : V extends VUnion<any, [infer I extends GenericValidator], any, any> ? ZodFromStringValidator<I> : V extends VUnion<any, [infer A extends GenericValidator, ...infer Rest extends GenericValidator[]], any, any> ? z$2.ZodUnion<readonly [ZodFromStringValidator<A>, ...{ [K in keyof Rest]: ZodFromStringValidator<Rest[K]> }]> : never;
 type ZodShapeFromConvexObject<Fields extends Record<string, GenericValidator>> = Fields extends infer F ? { [K in keyof F]: F[K] extends GenericValidator ? ZodValidatorFromConvex<F[K]> : never } : never;
 type NotUndefined<T> = Exclude<T, undefined>;
 type TableNameFromType<T> = T extends GenericId<infer TableName> ? TableName : string;
@@ -588,16 +591,16 @@ declare function handleHttpError(error: unknown): Response;
  * - Factory function creates implementation objects
  * - This preserves literal types like 'GET' through method chains
  */
-interface HttpProcedureBuilder<TInitialCtx, TCtx, TInput extends UnsetMarker | z.ZodTypeAny = UnsetMarker, TOutput extends UnsetMarker | z.ZodTypeAny = UnsetMarker, TParams extends UnsetMarker | z.ZodTypeAny = UnsetMarker, TQuery extends UnsetMarker | z.ZodTypeAny = UnsetMarker, TMeta extends ProcedureMeta = ProcedureMeta, TMethod extends HttpMethod = HttpMethod, TForm extends UnsetMarker | z.ZodTypeAny = UnsetMarker> {
+interface HttpProcedureBuilder<TInitialCtx, TCtx, TInput extends UnsetMarker | z$1.ZodTypeAny = UnsetMarker, TOutput extends UnsetMarker | z$1.ZodTypeAny = UnsetMarker, TParams extends UnsetMarker | z$1.ZodTypeAny = UnsetMarker, TQuery extends UnsetMarker | z$1.ZodTypeAny = UnsetMarker, TMeta extends ProcedureMeta = ProcedureMeta, TMethod extends HttpMethod = HttpMethod, TForm extends UnsetMarker | z$1.ZodTypeAny = UnsetMarker> {
   _def: HttpProcedureBuilderDef<TCtx, TInput, TOutput, TParams, TQuery, TMeta, TMethod, TForm>;
   /** DELETE endpoint (Hono-style) */
   delete(path: string): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TParams, TQuery, TMeta, 'DELETE', TForm>;
   /** Define form data schema (for multipart/form-data uploads) */
-  form<TSchema extends z.ZodTypeAny>(schema: TSchema): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TParams, TQuery, TMeta, TMethod, TSchema>;
+  form<TSchema extends z$1.ZodTypeAny>(schema: TSchema): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TParams, TQuery, TMeta, TMethod, TSchema>;
   /** GET endpoint (Hono-style) */
   get(path: string): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TParams, TQuery, TMeta, 'GET', TForm>;
   /** Define request body schema (for POST/PUT/PATCH) */
-  input<TSchema extends z.ZodTypeAny>(schema: TSchema): HttpProcedureBuilder<TInitialCtx, TCtx, TSchema, TOutput, TParams, TQuery, TMeta, TMethod, TForm>;
+  input<TSchema extends z$1.ZodTypeAny>(schema: TSchema): HttpProcedureBuilder<TInitialCtx, TCtx, TSchema, TOutput, TParams, TQuery, TMeta, TMethod, TForm>;
   /** Set procedure metadata (shallow merged when chained) */
   meta(value: TMeta): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TParams, TQuery, TMeta, TMethod, TForm>;
   /**
@@ -605,13 +608,13 @@ interface HttpProcedureBuilder<TInitialCtx, TCtx, TInput extends UnsetMarker | z
    * Handler receives Hono Context `c` for Response helpers (c.json, c.body, c.text).
    * Return Response for custom responses, or plain object for auto JSON serialization.
    */
-  mutation<TResult>(handler: (opts: HttpHandlerOpts<TCtx, TInput, TParams, TQuery, TForm>) => Promise<Response | (TOutput extends z.ZodTypeAny ? z.infer<TOutput> : TResult)>): HttpProcedure<TInput, TOutput, TParams, TQuery, TMethod, TForm>;
+  mutation<TResult>(handler: (opts: HttpHandlerOpts<TCtx, TInput, TParams, TQuery, TForm>) => Promise<Response | (TOutput extends z$1.ZodTypeAny ? z$1.infer<TOutput> : TResult)>): HttpProcedure<TInput, TOutput, TParams, TQuery, TMethod, TForm>;
   /** Set a server-only procedure name for middleware/logging */
   name(value: string): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TParams, TQuery, TMeta, TMethod, TForm>;
   /** Define response schema */
-  output<TSchema extends z.ZodTypeAny>(schema: TSchema): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TSchema, TParams, TQuery, TMeta, TMethod, TForm>;
+  output<TSchema extends z$1.ZodTypeAny>(schema: TSchema): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TSchema, TParams, TQuery, TMeta, TMethod, TForm>;
   /** Define path parameter schema (for :param in path) */
-  params<TSchema extends z.ZodTypeAny>(schema: TSchema): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TSchema, TQuery, TMeta, TMethod, TForm>;
+  params<TSchema extends z$1.ZodTypeAny>(schema: TSchema): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TSchema, TQuery, TMeta, TMethod, TForm>;
   /** PATCH endpoint (Hono-style) */
   patch(path: string): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TParams, TQuery, TMeta, 'PATCH', TForm>;
   /** POST endpoint (Hono-style) */
@@ -623,11 +626,11 @@ interface HttpProcedureBuilder<TInitialCtx, TCtx, TInput extends UnsetMarker | z
    * Handler receives Hono Context `c` for Response helpers (c.json, c.body, c.text).
    * Return Response for custom responses, or plain object for auto JSON serialization.
    */
-  query<TResult>(handler: (opts: HttpHandlerOpts<TCtx, TInput, TParams, TQuery, TForm>) => Promise<Response | (TOutput extends z.ZodTypeAny ? z.infer<TOutput> : TResult)>): HttpProcedure<TInput, TOutput, TParams, TQuery, TMethod, TForm>;
+  query<TResult>(handler: (opts: HttpHandlerOpts<TCtx, TInput, TParams, TQuery, TForm>) => Promise<Response | (TOutput extends z$1.ZodTypeAny ? z$1.infer<TOutput> : TResult)>): HttpProcedure<TInput, TOutput, TParams, TQuery, TMethod, TForm>;
   /** Define the route path and HTTP method */
   route<M extends HttpMethod>(path: string, method: M): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TParams, TQuery, TMeta, M, TForm>;
   /** Define query parameter schema (?key=value) */
-  searchParams<TSchema extends z.ZodTypeAny>(schema: TSchema): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TParams, TSchema, TMeta, TMethod, TForm>;
+  searchParams<TSchema extends z$1.ZodTypeAny>(schema: TSchema): HttpProcedureBuilder<TInitialCtx, TCtx, TInput, TOutput, TParams, TSchema, TMeta, TMethod, TForm>;
   /** Add middleware to the procedure */
   use<$ContextOverridesOut extends object>(middlewareOrBuilder: MiddlewareFunction<TCtx, TMeta, UnsetMarker, $ContextOverridesOut, unknown> | MiddlewareBuilder<any, // Allow reusable middleware with any context
   TMeta, $ContextOverridesOut, unknown>): HttpProcedureBuilder<TInitialCtx, Overwrite$1<TCtx, $ContextOverridesOut>, TInput, TOutput, TParams, TQuery, TMeta, TMethod, TForm>;
@@ -648,32 +651,32 @@ declare function createHttpProcedureBuilder<TCtx, TMeta extends ProcedureMeta>(c
  * After .paginated() applies defaults, cursor and limit are always defined.
  * The actual runtime schema uses .default() and .transform() for validation.
  */
-declare const paginatedSchemaForTypes: z.ZodObject<{
-  cursor: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-  limit: z.ZodNumber;
-}, z.core.$strip>;
+declare const paginatedSchemaForTypes: z$1.ZodObject<{
+  cursor: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNull]>;
+  limit: z$1.ZodNumber;
+}, z$1.core.$strip>;
 /** Paginated schema type - both cursor and limit are required after .paginated() */
 type PaginatedInputSchema = typeof paginatedSchemaForTypes;
 /** Paginated schema type for external callers - both fields are optional due defaults. */
-declare const paginatedSchemaForClientTypes: z.ZodObject<{
-  cursor: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
-  limit: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
+declare const paginatedSchemaForClientTypes: z$1.ZodObject<{
+  cursor: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNull]>>;
+  limit: z$1.ZodOptional<z$1.ZodNumber>;
+}, z$1.core.$strip>;
 type PaginatedClientInputSchema = typeof paginatedSchemaForClientTypes;
 /**
  * Infer input type from ZodObject schema (for handlers)
  */
-type InferInput<T> = T extends UnsetMarker ? Record<string, never> : T extends z.ZodObject<any> ? z.infer<T> : never;
+type InferInput<T> = T extends UnsetMarker ? Record<string, never> : T extends z$1.ZodObject<any> ? z$1.infer<T> : never;
 /**
  * Infer raw client input before defaults/transforms.
  * Used for generated API arg typing.
  */
-type InferClientInput<T> = T extends UnsetMarker ? Record<string, never> : T extends z.ZodObject<any> ? z.input<T> : never;
+type InferClientInput<T> = T extends UnsetMarker ? Record<string, never> : T extends z$1.ZodObject<any> ? z$1.input<T> : never;
 /**
  * Infer input type for middleware (returns unknown for UnsetMarker, matching tRPC)
  * Middleware before .input() receives unknown input
  */
-type InferMiddlewareInput<T> = T extends UnsetMarker ? unknown : T extends z.ZodObject<any> ? z.infer<T> : unknown;
+type InferMiddlewareInput<T> = T extends UnsetMarker ? unknown : T extends z$1.ZodObject<any> ? z$1.infer<T> : unknown;
 /**
  * Static-only type hint attached to cRPC exports.
  *
@@ -753,8 +756,8 @@ type ProcedureBuilderDef<TMeta = object> = {
    * (`.refine()`, `.superRefine()`, strict/catchall) only survive on the
    * schema itself.
    */
-  inputSchemas: z.ZodObject<any>[];
-  outputSchema?: z.ZodTypeAny;
+  inputSchemas: z$1.ZodObject<any>[];
+  outputSchema?: z$1.ZodTypeAny;
   meta?: TMeta;
   procedureName?: string;
   functionConfig: InternalFunctionConfig; /** Whether this procedure uses internal function (not exposed to clients) */
@@ -770,15 +773,15 @@ type ProcedureBuilderDef<TMeta = object> = {
  * @typeParam TOutput - Output schema (starts as UnsetMarker)
  * @typeParam TMeta - Procedure metadata type
  */
-declare class ProcedureBuilder<TBaseCtx, _TContext, TContextOverrides extends UnsetMarker | object = UnsetMarker, TInput extends UnsetMarker | z.ZodObject<any> = UnsetMarker, TOutput extends UnsetMarker | z.ZodTypeAny = UnsetMarker, TMeta extends object = object> {
+declare class ProcedureBuilder<TBaseCtx, _TContext, TContextOverrides extends UnsetMarker | object = UnsetMarker, TInput extends UnsetMarker | z$1.ZodObject<any> = UnsetMarker, TOutput extends UnsetMarker | z$1.ZodTypeAny = UnsetMarker, TMeta extends object = object> {
   protected readonly _def: ProcedureBuilderDef<TMeta>;
   constructor(def: ProcedureBuilderDef<TMeta>);
   /** Add middleware that transforms the context - to be overridden by subclasses */
   protected _use<$ContextOverridesOut>(middlewareOrBuilder: MiddlewareFunction<TBaseCtx, TMeta, TContextOverrides, $ContextOverridesOut> | MiddlewareBuilder<TBaseCtx, TMeta, $ContextOverridesOut>): ProcedureBuilderDef<TMeta>;
   /** Define input schema (chainable - schemas are merged) - to be overridden by subclasses */
-  protected _input<TNewInput extends z.ZodObject<any>>(schema: TNewInput): ProcedureBuilderDef<TMeta>;
+  protected _input<TNewInput extends z$1.ZodObject<any>>(schema: TNewInput): ProcedureBuilderDef<TMeta>;
   /** Define output schema - to be overridden by subclasses */
-  protected _output<TNewOutput extends z.ZodTypeAny>(schema: TNewOutput): ProcedureBuilderDef<TMeta>;
+  protected _output<TNewOutput extends z$1.ZodTypeAny>(schema: TNewOutput): ProcedureBuilderDef<TMeta>;
   /** Set procedure metadata (shallow merged when chained) - to be overridden by subclasses */
   protected _meta(value: TMeta): ProcedureBuilderDef<TMeta>;
   /** Set server-only procedure name for middleware/logging */
@@ -791,7 +794,7 @@ declare class ProcedureBuilder<TBaseCtx, _TContext, TContextOverrides extends Un
  * Query-specific procedure builder
  * Only exposes .query() and .internalQuery() methods
  */
-declare class QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides extends UnsetMarker | object = UnsetMarker, TInput extends UnsetMarker | z.ZodObject<any> = UnsetMarker, TClientInput extends UnsetMarker | z.ZodObject<any> = TInput, TOutput extends UnsetMarker | z.ZodTypeAny = UnsetMarker, TMeta extends object = object> extends ProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TOutput, TMeta> {
+declare class QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides extends UnsetMarker | object = UnsetMarker, TInput extends UnsetMarker | z$1.ZodObject<any> = UnsetMarker, TClientInput extends UnsetMarker | z$1.ZodObject<any> = TInput, TOutput extends UnsetMarker | z$1.ZodTypeAny = UnsetMarker, TMeta extends object = object> extends ProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TOutput, TMeta> {
   /**
    * Add middleware that transforms the context
    * Middleware receives typed input if called after .input(), unknown otherwise
@@ -804,7 +807,7 @@ declare class QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides extend
   /** Set a server-only procedure name for middleware/logging */
   name(value: string): QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TClientInput, TOutput, TMeta>;
   /** Define input schema (chainable - schemas are merged) */
-  input<TNewInput extends z.ZodObject<any>>(schema: TNewInput): QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides, IntersectIfDefined<TInput, TNewInput>, IntersectIfDefined<TClientInput, TNewInput>, TOutput, TMeta>;
+  input<TNewInput extends z$1.ZodObject<any>>(schema: TNewInput): QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides, IntersectIfDefined<TInput, TNewInput>, IntersectIfDefined<TClientInput, TNewInput>, TOutput, TMeta>;
   /**
    * Add pagination input (chainable before .query())
    *
@@ -814,21 +817,21 @@ declare class QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides extend
    * @param opts.limit - Default/max items per page
    * @param opts.item - Zod schema for each item in the page array
    */
-  paginated<TItem extends z.ZodTypeAny>(opts: {
+  paginated<TItem extends z$1.ZodTypeAny>(opts: {
     limit: number;
     item: TItem;
-  }): QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides, IntersectIfDefined<TInput, PaginatedInputSchema>, IntersectIfDefined<TClientInput, PaginatedClientInputSchema>, z.ZodObject<{
-    continueCursor: z.ZodUnion<[z.ZodString, z.ZodNull]>;
-    isDone: z.ZodBoolean;
-    page: z.ZodArray<TItem>;
+  }): QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides, IntersectIfDefined<TInput, PaginatedInputSchema>, IntersectIfDefined<TClientInput, PaginatedClientInputSchema>, z$1.ZodObject<{
+    continueCursor: z$1.ZodUnion<[z$1.ZodString, z$1.ZodNull]>;
+    isDone: z$1.ZodBoolean;
+    page: z$1.ZodArray<TItem>;
   }>, TMeta>;
   /** Define output schema */
-  output<TNewOutput extends z.ZodTypeAny>(schema: TNewOutput): QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TClientInput, TNewOutput, TMeta>;
+  output<TNewOutput extends z$1.ZodTypeAny>(schema: TNewOutput): QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TClientInput, TNewOutput, TMeta>;
   /** Create a query */
   query<TResult>(handler: (opts: {
     ctx: Overwrite$1<TContext, TContextOverrides>;
     input: InferInput<TInput>;
-  }) => Promise<TOutput extends z.ZodTypeAny ? z.input<TOutput> : TResult>): Record<string, unknown> & CRPCFunctionTypeHint<InferClientInput<TClientInput>, TOutput extends z.ZodTypeAny ? z.output<TOutput> : TResult>;
+  }) => Promise<TOutput extends z$1.ZodTypeAny ? z$1.input<TOutput> : TResult>): Record<string, unknown> & CRPCFunctionTypeHint<InferClientInput<TClientInput>, TOutput extends z$1.ZodTypeAny ? z$1.output<TOutput> : TResult>;
   /** Mark as internal - returns chainable builder using internal function */
   internal(): QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TClientInput, TOutput, TMeta>;
 }
@@ -836,7 +839,7 @@ declare class QueryProcedureBuilder<TBaseCtx, TContext, TContextOverrides extend
  * Mutation-specific procedure builder
  * Only exposes .mutation() and .internalMutation() methods
  */
-declare class MutationProcedureBuilder<TBaseCtx, TContext, TContextOverrides extends UnsetMarker | object = UnsetMarker, TInput extends UnsetMarker | z.ZodObject<any> = UnsetMarker, TOutput extends UnsetMarker | z.ZodTypeAny = UnsetMarker, TMeta extends object = object> extends ProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TOutput, TMeta> {
+declare class MutationProcedureBuilder<TBaseCtx, TContext, TContextOverrides extends UnsetMarker | object = UnsetMarker, TInput extends UnsetMarker | z$1.ZodObject<any> = UnsetMarker, TOutput extends UnsetMarker | z$1.ZodTypeAny = UnsetMarker, TMeta extends object = object> extends ProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TOutput, TMeta> {
   /**
    * Add middleware that transforms the context
    * Middleware receives typed input if called after .input(), unknown otherwise
@@ -849,14 +852,14 @@ declare class MutationProcedureBuilder<TBaseCtx, TContext, TContextOverrides ext
   /** Set a server-only procedure name for middleware/logging */
   name(value: string): MutationProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TOutput, TMeta>;
   /** Define input schema (chainable - schemas are merged) */
-  input<TNewInput extends z.ZodObject<any>>(schema: TNewInput): MutationProcedureBuilder<TBaseCtx, TContext, TContextOverrides, IntersectIfDefined<TInput, TNewInput>, TOutput, TMeta>;
+  input<TNewInput extends z$1.ZodObject<any>>(schema: TNewInput): MutationProcedureBuilder<TBaseCtx, TContext, TContextOverrides, IntersectIfDefined<TInput, TNewInput>, TOutput, TMeta>;
   /** Define output schema */
-  output<TNewOutput extends z.ZodTypeAny>(schema: TNewOutput): MutationProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TNewOutput, TMeta>;
+  output<TNewOutput extends z$1.ZodTypeAny>(schema: TNewOutput): MutationProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TNewOutput, TMeta>;
   /** Create a mutation */
   mutation<TResult>(handler: (opts: {
     ctx: Overwrite$1<TContext, TContextOverrides>;
     input: InferInput<TInput>;
-  }) => Promise<TOutput extends z.ZodTypeAny ? z.input<TOutput> : TResult>): Record<string, unknown> & CRPCFunctionTypeHint<InferClientInput<TInput>, TOutput extends z.ZodTypeAny ? z.output<TOutput> : TResult>;
+  }) => Promise<TOutput extends z$1.ZodTypeAny ? z$1.input<TOutput> : TResult>): Record<string, unknown> & CRPCFunctionTypeHint<InferClientInput<TInput>, TOutput extends z$1.ZodTypeAny ? z$1.output<TOutput> : TResult>;
   /** Mark as internal - returns chainable builder using internal function */
   internal(): MutationProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TOutput, TMeta>;
 }
@@ -864,7 +867,7 @@ declare class MutationProcedureBuilder<TBaseCtx, TContext, TContextOverrides ext
  * Action-specific procedure builder
  * Only exposes .action() and .internalAction() methods
  */
-declare class ActionProcedureBuilder<TBaseCtx, TContext, TContextOverrides extends UnsetMarker | object = UnsetMarker, TInput extends UnsetMarker | z.ZodObject<any> = UnsetMarker, TOutput extends UnsetMarker | z.ZodTypeAny = UnsetMarker, TMeta extends object = object> extends ProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TOutput, TMeta> {
+declare class ActionProcedureBuilder<TBaseCtx, TContext, TContextOverrides extends UnsetMarker | object = UnsetMarker, TInput extends UnsetMarker | z$1.ZodObject<any> = UnsetMarker, TOutput extends UnsetMarker | z$1.ZodTypeAny = UnsetMarker, TMeta extends object = object> extends ProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TOutput, TMeta> {
   /** Add middleware that transforms the context - $ContextOverridesOut is inferred from next() */
   use<$ContextOverridesOut extends object>(middlewareOrBuilder: MiddlewareFunction<Overwrite$1<TContext, TContextOverrides>, TMeta, TContextOverrides, $ContextOverridesOut, InferMiddlewareInput<TInput>> | MiddlewareBuilder<any, // Allow reusable middleware with any context
   TMeta, $ContextOverridesOut, InferMiddlewareInput<TInput>>): ActionProcedureBuilder<TBaseCtx, TContext, Overwrite$1<TContextOverrides, $ContextOverridesOut>, TInput, TOutput, TMeta>;
@@ -873,14 +876,14 @@ declare class ActionProcedureBuilder<TBaseCtx, TContext, TContextOverrides exten
   /** Set a server-only procedure name for middleware/logging */
   name(value: string): ActionProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TOutput, TMeta>;
   /** Define input schema (chainable - schemas are merged) */
-  input<TNewInput extends z.ZodObject<any>>(schema: TNewInput): ActionProcedureBuilder<TBaseCtx, TContext, TContextOverrides, IntersectIfDefined<TInput, TNewInput>, TOutput, TMeta>;
+  input<TNewInput extends z$1.ZodObject<any>>(schema: TNewInput): ActionProcedureBuilder<TBaseCtx, TContext, TContextOverrides, IntersectIfDefined<TInput, TNewInput>, TOutput, TMeta>;
   /** Define output schema */
-  output<TNewOutput extends z.ZodTypeAny>(schema: TNewOutput): ActionProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TNewOutput, TMeta>;
+  output<TNewOutput extends z$1.ZodTypeAny>(schema: TNewOutput): ActionProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TNewOutput, TMeta>;
   /** Create an action */
   action<TResult>(handler: (opts: {
     ctx: Overwrite$1<TContext, TContextOverrides>;
     input: InferInput<TInput>;
-  }) => Promise<TOutput extends z.ZodTypeAny ? z.input<TOutput> : TResult>): Record<string, unknown> & CRPCFunctionTypeHint<InferClientInput<TInput>, TOutput extends z.ZodTypeAny ? z.output<TOutput> : TResult>;
+  }) => Promise<TOutput extends z$1.ZodTypeAny ? z$1.input<TOutput> : TResult>): Record<string, unknown> & CRPCFunctionTypeHint<InferClientInput<TInput>, TOutput extends z$1.ZodTypeAny ? z$1.output<TOutput> : TResult>;
   /** Mark as internal - returns chainable builder using internal function */
   internal(): ActionProcedureBuilder<TBaseCtx, TContext, TContextOverrides, TInput, TOutput, TMeta>;
 }
@@ -1130,14 +1133,14 @@ declare function createCallerFactory<TApi extends Record<string, unknown>>(opts:
 //#endregion
 //#region src/server/env.d.ts
 type RuntimeEnv = Record<string, string | undefined>;
-type CreateEnvOptions<TSchema extends z.ZodObject<z.ZodRawShape>> = {
+type CreateEnvOptions<TSchema extends z$1.ZodObject<z$1.ZodRawShape>> = {
   cache?: boolean;
   codegenFallback?: boolean;
   readOptionalRuntimeEnv?: readonly string[];
   runtimeEnv?: RuntimeEnv;
   schema: TSchema;
 };
-declare function createEnv<TSchema extends z.ZodObject<z.ZodRawShape>>(options: CreateEnvOptions<TSchema>): () => z.infer<TSchema>;
+declare function createEnv<TSchema extends z$1.ZodObject<z$1.ZodRawShape>>(options: CreateEnvOptions<TSchema>): () => z$1.infer<TSchema>;
 //#endregion
 //#region src/server/error.d.ts
 /** JSON-RPC 2.0 error codes (tRPC-style) */

package/dist/ratelimit/index.js

@@ -1,6 +1,6 @@
 import { u as requireMutationCtx } from "../api-entry-CkDpGYVg.js";
-import { _ as CRPCError } from "../builder-1Vx-tEnS.js";
-import { t as definePlugin } from "../middleware-cJDRHTRY.js";
+import { _ as CRPCError } from "../builder-DoeyW4Vq.js";
+import { t as definePlugin } from "../middleware-DIj-bwVi.js";
 import { v } from "convex/values";
 import { mutationGeneric, queryGeneric } from "convex/server";
 

package/dist/{runtime-DfGsZtx3.js → runtime-BdqTbgKh.js}

@@ -1,8 +1,11 @@
-import { A as integer, C as index, M as custom, O as text, t as convexTable } from "./table-rmJm5Qio.js";
-import { t as id } from "./id-Bibg34Yb.js";
+import { A as integer, C as index, M as custom, O as text, t as convexTable } from "./table-CX2lnX7e.js";
+import { t as id } from "./id-CuSfWa5q.js";
 import { ConvexError, convexToJson, jsonToConvex, v } from "convex/values";
 
 //#region src/aggregate-core/compare.ts
+function isCommitTsPlaceholder(value) {
+	return Object.getPrototypeOf(value)?.constructor?.name === "CommitTsPlaceholder";
+}
 function compareValues$1(k1, k2) {
 	return compareAsTuples(makeComparable(k1), makeComparable(k2));
 }
@@ -35,7 +38,10 @@ function makeComparable(v) {
 	if (typeof v === "string") return [5, v];
 	if (v instanceof ArrayBuffer) return [6, Array.from(new Uint8Array(v)).map(makeComparable)];
 	if (Array.isArray(v)) return [7, v.map(makeComparable)];
-	return [8, Object.keys(v).sort().map((k) => [k, v[k]]).map(makeComparable)];
+	if (isCommitTsPlaceholder(v)) throw new Error("Commit timestamp placeholders cannot be compared before commit.");
+	const keys = Object.keys(v).sort();
+	const record = v;
+	return [8, keys.map((k) => [k, record[k]]).map(makeComparable)];
 }
 
 //#endregion

package/dist/{schema-Besl-rpv.js → schema-D8sVYuYO.js}

@@ -1,7 +1,7 @@
-import { A as integer, C as index, N as json, O as text, P as objectOf, _ as TableDeleteConfig, a as Columns, j as arrayOf, s as OrmContext, t as convexTable, v as TableName, y as TablePolymorphic } from "./table-rmJm5Qio.js";
-import { t as id } from "./id-Bibg34Yb.js";
+import { A as integer, C as index, N as json, O as text, P as objectOf, _ as TableDeleteConfig, a as Columns, j as arrayOf, s as OrmContext, t as convexTable, v as TableName, y as TablePolymorphic } from "./table-CX2lnX7e.js";
+import { t as id } from "./id-CuSfWa5q.js";
 import { C as matchLikePattern, _ as isFieldReference, d as filterValueInList, f as filterValuesEqual, u as fieldRef } from "./filter-expression-Dydt8wS0.js";
-import { t as defineSchemaExtension } from "./extensions-DzjCJXYl.js";
+import { t as defineSchemaExtension } from "./extensions-Blzsyekm.js";
 
 //#region src/orm/timestamp-mode.ts
 const PUBLIC_CREATED_AT_FIELD = "createdAt";
@@ -92,21 +92,21 @@ function findRelationIndex(table, columns, relationName, targetTableName, strict
 }
 
 //#endregion
-//#region src/orm/write-fanout.ts
+//#region src/internal/concurrency.ts
 /**
-* Shared primitives for fanning out independent writes.
+* Bounded-concurrency fan-out, shared by the ORM write path, relation loading
+* and the CLI's entry-point analyzer.
 *
-* Deliberately dependency-free: `mutation-utils`, `lifecycle` and `query` all
-* import it, and Convex bundles every static import of a function entry.
+* Deliberately dependency-free: ORM callers reach it from a Convex function
+* entry, and Convex bundles every static import of an entry.
 */
-const ORMLIFECYCLE_HOOKED_TABLES = Symbol.for("kitcn:OrmLifecycleHookedTables");
-/** Matches the ORM's relation-loading default. */
-const DEFAULT_WRITE_FANOUT_CONCURRENCY = 25;
 /**
 * Runs `worker` over `items` with at most `limit` in flight. Results keep input
-* order. Unbounded `Promise.all` is not an option here: a fan-out is bounded
-* only by `mutationMaxRows` (10,000), and that many simultaneous in-flight
-* syscalls is its own failure mode.
+* order, so callers can rely on a stable mapping back to `items`.
+*
+* Unbounded `Promise.all` is not an option for the ORM caller: a fan-out is
+* bounded only by `mutationMaxRows` (10,000), and that many simultaneous
+* in-flight syscalls is its own failure mode.
 */
 async function mapWithConcurrency(items, limit, worker) {
 	if (items.length === 0) return [];
@@ -124,6 +124,20 @@ async function mapWithConcurrency(items, limit, worker) {
 	await Promise.all(Array.from({ length: width }, () => runWorker()));
 	return results;
 }
+
+//#endregion
+//#region src/orm/write-fanout.ts
+/**
+* Lifecycle bookkeeping for the ORM write path.
+*
+* Deliberately dependency-free: `mutation-utils`, `lifecycle` and `query` all
+* import it, and Convex bundles every static import of a function entry. The
+* bounded fan-out primitive itself lives in `internal/concurrency` so the CLI
+* can share it without dragging this module in.
+*/
+const ORMLIFECYCLE_HOOKED_TABLES = Symbol.for("kitcn:OrmLifecycleHookedTables");
+/** Matches the ORM's relation-loading default. */
+const DEFAULT_WRITE_FANOUT_CONCURRENCY = 25;
 /**
 * Records which tables the lifecycle writer intercepts, so write fan-out can
 * see it without importing `lifecycle` (which would close an import cycle
@@ -1408,4 +1422,4 @@ function aggregateExtension() {
 }
 
 //#endregion
-export { serializeFilterExpression as $, ensureNonNullValues as A, getMutationExecutionMode as B, deserializeFilterExpression as C, enforcePolymorphicWrite as D, enforceForeignKeys as E, getChecks as F, getUniqueIndexes as G, getTableColumns as H, getColumnName as I, normalizeDateFieldsForWrite as J, hardDeleteRow as K, getForeignKeys as L, evaluateCheckConstraintTriState as M, evaluateFilter as N, enforceUniqueIndexes as O, extractPrimaryIdLookup as P, selectReturningRowWithHydration as Q, getMutationAsyncDelayMs as R, decodeUndefinedDeep as S, enforceCheckConstraints as T, getTableDeleteConfig as U, getOrmContext as V, getTableName as W, patchReferencingRows as X, normalizeTemporalComparableValue as Y, resolveOrmRuntimeDefaults as Z, applyIncomingForeignKeyActionsOnUpdate as _, usesSystemCreatedAtAlias as _t, aggregateExtension as a, markLifecycleHookedTables as at, collectMutationRowsBounded as b, AGGREGATE_ERROR as c, findSearchIndexByName as ct, createCountError as d, getIndexes as dt, softDeleteRow as et, createError as f, getRankIndexes as ft, applyIncomingForeignKeyActionsOnDelete as g, PUBLIC_CREATED_AT_FIELD as gt, applyDefaults as h, INTERNAL_CREATION_TIME_FIELD as ht, AGGREGATE_STATE_TABLE as i, mapWithConcurrency as it, ensureNullableColumns as j, ensureDefaultColumns as k, COUNT_ERROR as l, findVectorIndexByName as lt, ensureCountAllowedForRls as m, CREATED_AT_MIGRATION_MESSAGE as mt, AGGREGATE_EXTREMA_TABLE as n, takeRowsWithinByteBudget as nt, getAggregateIndexDefinitions as o, findIndexForColumns as ot, ensureAggregateAllowedForRls as p, resolveIndexOrderPushdown as pt, hydrateDateFieldsForRead as q, AGGREGATE_MEMBER_TABLE as r, toConvexFilter as rt, getRankIndexDefinitions as s, findRelationIndex as st, AGGREGATE_BUCKET_TABLE as t, splitReturningSelection as tt, createAggregateError as u, getAggregateIndexes as ut, buildForeignKeyGraph as v, encodeUndefinedDeep as w, collectPrimaryIdLookupRows as x, canUsePrimaryIdLookupCursor as y, getMutationCollectionLimits as z };
+export { serializeFilterExpression as $, ensureNonNullValues as A, getMutationExecutionMode as B, deserializeFilterExpression as C, enforcePolymorphicWrite as D, enforceForeignKeys as E, getChecks as F, getUniqueIndexes as G, getTableColumns as H, getColumnName as I, normalizeDateFieldsForWrite as J, hardDeleteRow as K, getForeignKeys as L, evaluateCheckConstraintTriState as M, evaluateFilter as N, enforceUniqueIndexes as O, extractPrimaryIdLookup as P, selectReturningRowWithHydration as Q, getMutationAsyncDelayMs as R, decodeUndefinedDeep as S, enforceCheckConstraints as T, getTableDeleteConfig as U, getOrmContext as V, getTableName as W, patchReferencingRows as X, normalizeTemporalComparableValue as Y, resolveOrmRuntimeDefaults as Z, applyIncomingForeignKeyActionsOnUpdate as _, PUBLIC_CREATED_AT_FIELD as _t, aggregateExtension as a, markLifecycleHookedTables as at, collectMutationRowsBounded as b, AGGREGATE_ERROR as c, findRelationIndex as ct, createCountError as d, getAggregateIndexes as dt, softDeleteRow as et, createError as f, getIndexes as ft, applyIncomingForeignKeyActionsOnDelete as g, INTERNAL_CREATION_TIME_FIELD as gt, applyDefaults as h, CREATED_AT_MIGRATION_MESSAGE as ht, AGGREGATE_STATE_TABLE as i, hasLifecycleHooks as it, ensureNullableColumns as j, ensureDefaultColumns as k, COUNT_ERROR as l, findSearchIndexByName as lt, ensureCountAllowedForRls as m, resolveIndexOrderPushdown as mt, AGGREGATE_EXTREMA_TABLE as n, takeRowsWithinByteBudget as nt, getAggregateIndexDefinitions as o, mapWithConcurrency as ot, ensureAggregateAllowedForRls as p, getRankIndexes as pt, hydrateDateFieldsForRead as q, AGGREGATE_MEMBER_TABLE as r, toConvexFilter as rt, getRankIndexDefinitions as s, findIndexForColumns as st, AGGREGATE_BUCKET_TABLE as t, splitReturningSelection as tt, createAggregateError as u, findVectorIndexByName as ut, buildForeignKeyGraph as v, usesSystemCreatedAtAlias as vt, encodeUndefinedDeep as w, collectPrimaryIdLookupRows as x, canUsePrimaryIdLookupCursor as y, getMutationCollectionLimits as z };

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as ActionProcedureBuilder, A as CRPCError, B as RuntimeEnv, C as createProcedureHandlerFactory, Ct as zCustomQuery, D as WithHttpRouter, Dt as zodToConvex, E as typedProcedureResolver, Et as zodOutputToConvexFields, F as getCRPCErrorFromUnknown, G as createLazyCaller, H as ConvexContext, I as getHTTPStatusCodeFromError, J as ServerCaller, K as CallerMeta, L as isCRPCError, M as CRPCErrorData, N as CRPC_ERROR_CODES_BY_KEY, O as inferApiInputs, Ot as zodToConvexFields, P as CRPC_ERROR_CODE_TO_HTTP, Q as getGeneratedValue, R as toCRPCError, S as createProcedureCallerFactory, St as zCustomMutation, T as getGeneratedFunctionReference, Tt as zodOutputToConvex, U as createCallerFactory, V as createEnv, W as LazyCaller, X as createApiLeaf, Y as createServerCaller, Z as createGeneratedFunctionReference, _ as ProcedureSchedulableCallerFromRegistry, _t as ZodValidatorFromConvex, a as CreateProcedureCallerFactoryOptions, at as initCRPC, b as createGenericCallerFactory, bt as withSystemFields, c as GeneratedRegistryCallerFactory, ct as extractPathParams, d as GeneratedRegistryHandlerForContext, dt as ConvexValidatorFromZod, et as CRPCFunctionTypeHint, f as ProcedureActionCallerFromRegistry, ft as ConvexValidatorFromZodOutput, g as ProcedureFromFunctionReference, gt as ZodFromValidatorBase, h as ProcedureDefinition, ht as Zid, i as registerProcedureNameLookup, it as createMiddlewareFactory, j as CRPCErrorCode, k as inferApiOutputs, l as GeneratedRegistryCallerForContext, lt as handleHttpError, m as ProcedureCallerFromRegistry, mt as ZCustomCtx, n as ProcedureNameLookup, nt as ProcedureBuilder, o as GeneratedProcedureRegistry, ot as HttpProcedureBuilder, p as ProcedureCaller, pt as CustomBuilder, q as CallerOpts, r as inferProcedureNameFromCallsite, rt as QueryProcedureBuilder, s as GeneratedProcedureRegistryEntry, st as createHttpProcedureBuilder, t as ProcedureNameEntry, tt as MutationProcedureBuilder, u as GeneratedRegistryHandlerFactory, ut as matchPathParams, v as ProcedureScheduleCallerFromRegistry, vt as convexToZod, w as defineProcedure, wt as zid, x as createGenericHandlerFactory, xt as zCustomAction, y as createGeneratedRegistryRuntime, yt as convexToZodFields, z as CreateEnvOptions } from "../procedure-name-B09-cf1-.js";
+import { $ as ActionProcedureBuilder, A as CRPCError, B as RuntimeEnv, C as createProcedureHandlerFactory, Ct as zCustomQuery, D as WithHttpRouter, Dt as zodToConvex, E as typedProcedureResolver, Et as zodOutputToConvexFields, F as getCRPCErrorFromUnknown, G as createLazyCaller, H as ConvexContext, I as getHTTPStatusCodeFromError, J as ServerCaller, K as CallerMeta, L as isCRPCError, M as CRPCErrorData, N as CRPC_ERROR_CODES_BY_KEY, O as inferApiInputs, Ot as zodToConvexFields, P as CRPC_ERROR_CODE_TO_HTTP, Q as getGeneratedValue, R as toCRPCError, S as createProcedureCallerFactory, St as zCustomMutation, T as getGeneratedFunctionReference, Tt as zodOutputToConvex, U as createCallerFactory, V as createEnv, W as LazyCaller, X as createApiLeaf, Y as createServerCaller, Z as createGeneratedFunctionReference, _ as ProcedureSchedulableCallerFromRegistry, _t as ZodValidatorFromConvex, a as CreateProcedureCallerFactoryOptions, at as initCRPC, b as createGenericCallerFactory, bt as withSystemFields, c as GeneratedRegistryCallerFactory, ct as extractPathParams, d as GeneratedRegistryHandlerForContext, dt as ConvexValidatorFromZod, et as CRPCFunctionTypeHint, f as ProcedureActionCallerFromRegistry, ft as ConvexValidatorFromZodOutput, g as ProcedureFromFunctionReference, gt as ZodFromValidatorBase, h as ProcedureDefinition, ht as Zid, i as registerProcedureNameLookup, it as createMiddlewareFactory, j as CRPCErrorCode, k as inferApiOutputs, l as GeneratedRegistryCallerForContext, lt as handleHttpError, m as ProcedureCallerFromRegistry, mt as ZCustomCtx, n as ProcedureNameLookup, nt as ProcedureBuilder, o as GeneratedProcedureRegistry, ot as HttpProcedureBuilder, p as ProcedureCaller, pt as CustomBuilder, q as CallerOpts, r as inferProcedureNameFromCallsite, rt as QueryProcedureBuilder, s as GeneratedProcedureRegistryEntry, st as createHttpProcedureBuilder, t as ProcedureNameEntry, tt as MutationProcedureBuilder, u as GeneratedRegistryHandlerFactory, ut as matchPathParams, v as ProcedureScheduleCallerFromRegistry, vt as convexToZod, w as defineProcedure, wt as zid, x as createGenericHandlerFactory, xt as zCustomAction, y as createGeneratedRegistryRuntime, yt as convexToZodFields, z as CreateEnvOptions } from "../procedure-name-l2YusEZI.js";
 import { A as HttpProcedureBuilderDef, C as extractRouteMap, D as HttpHandlerOpts, E as HttpActionHandler, M as InferHttpInput, N as ProcedureMeta, O as HttpMethod, S as createHttpRouterFactory, T as HttpActionConstructor, _ as CRPCHttpRouter, b as HttpRouterWithHono, j as HttpRouteDefinition, k as HttpProcedure, v as HttpRouterDef, w as CRPCHonoHandler, x as createHttpRouter, y as HttpRouterRecord } from "../http-types-90mapMP9.js";
 import { a as MergeZodObjects, c as MiddlewareMarker, d as MiddlewareProcedureType, f as MiddlewareResult, g as UnsetMarker, h as Simplify, i as IntersectIfDefined, l as MiddlewareNext, m as ResolveIfSet, n as AnyMiddlewareBuilder, o as MiddlewareBuilder, p as Overwrite, r as GetRawInputFn, s as MiddlewareFunction, t as AnyMiddleware, u as MiddlewareProcedureInfo } from "../types-eNzQmbqM.js";
 import { a as isMutationCtx, c as isSchedulerCtx, d as requireQueryCtx, f as requireRunMutationCtx, i as isActionCtx, l as requireActionCtx, n as RunMutationCtx, o as isQueryCtx, p as requireSchedulerCtx, r as SchedulerCtx, s as isRunMutationCtx, t as GenericCtx, u as requireMutationCtx } from "../context-utils-DwZ3Cam1.js";

package/dist/server/index.js

@@ -1,6 +1,6 @@
 import { a as isMutationCtx, c as isSchedulerCtx, d as requireQueryCtx, f as requireRunMutationCtx, i as isActionCtx, l as requireActionCtx, n as createGeneratedFunctionReference, o as isQueryCtx, p as requireSchedulerCtx, r as getGeneratedValue, s as isRunMutationCtx, t as createApiLeaf, u as requireMutationCtx } from "../api-entry-CkDpGYVg.js";
 import { n as createLazyCaller, r as createServerCaller, t as createCallerFactory } from "../caller-factory-Dd3H7j3V.js";
-import { A as zid, C as toCRPCError, D as zCustomAction, E as withSystemFields, M as zodOutputToConvexFields, N as zodToConvex, O as zCustomMutation, P as zodToConvexFields, S as isCRPCError, T as convexToZodFields, _ as CRPCError, a as createMiddlewareFactory, b as getCRPCErrorFromUnknown, c as registerProcedureNameLookup, d as createHttpRouterFactory, f as extractRouteMap, g as matchPathParams, h as handleHttpError, i as QueryProcedureBuilder, j as zodOutputToConvex, k as zCustomQuery, l as HttpRouterWithHono, m as extractPathParams, n as MutationProcedureBuilder, o as initCRPC, p as createHttpProcedureBuilder, r as ProcedureBuilder, s as inferProcedureNameFromCallsite, t as ActionProcedureBuilder, u as createHttpRouter, v as CRPC_ERROR_CODES_BY_KEY, w as convexToZod, x as getHTTPStatusCodeFromError, y as CRPC_ERROR_CODE_TO_HTTP } from "../builder-1Vx-tEnS.js";
-import { a as createProcedureHandlerFactory, c as typedProcedureResolver, i as createProcedureCallerFactory, l as createEnv, n as createGenericCallerFactory, o as defineProcedure, r as createGenericHandlerFactory, s as getGeneratedFunctionReference, t as createGeneratedRegistryRuntime } from "../procedure-caller-DIzXfX2E.js";
+import { A as zid, C as toCRPCError, D as zCustomAction, E as withSystemFields, M as zodOutputToConvexFields, N as zodToConvex, O as zCustomMutation, P as zodToConvexFields, S as isCRPCError, T as convexToZodFields, _ as CRPCError, a as createMiddlewareFactory, b as getCRPCErrorFromUnknown, c as registerProcedureNameLookup, d as createHttpRouterFactory, f as extractRouteMap, g as matchPathParams, h as handleHttpError, i as QueryProcedureBuilder, j as zodOutputToConvex, k as zCustomQuery, l as HttpRouterWithHono, m as extractPathParams, n as MutationProcedureBuilder, o as initCRPC, p as createHttpProcedureBuilder, r as ProcedureBuilder, s as inferProcedureNameFromCallsite, t as ActionProcedureBuilder, u as createHttpRouter, v as CRPC_ERROR_CODES_BY_KEY, w as convexToZod, x as getHTTPStatusCodeFromError, y as CRPC_ERROR_CODE_TO_HTTP } from "../builder-DoeyW4Vq.js";
+import { a as createProcedureHandlerFactory, c as typedProcedureResolver, i as createProcedureCallerFactory, l as createEnv, n as createGenericCallerFactory, o as defineProcedure, r as createGenericHandlerFactory, s as getGeneratedFunctionReference, t as createGeneratedRegistryRuntime } from "../procedure-caller-Dxae9DW5.js";
 
 export { ActionProcedureBuilder, CRPCError, CRPC_ERROR_CODES_BY_KEY, CRPC_ERROR_CODE_TO_HTTP, HttpRouterWithHono, MutationProcedureBuilder, ProcedureBuilder, QueryProcedureBuilder, convexToZod, convexToZodFields, createApiLeaf, createCallerFactory, createEnv, createGeneratedFunctionReference, createGeneratedRegistryRuntime, createGenericCallerFactory, createGenericHandlerFactory, createHttpProcedureBuilder, createHttpRouter, createHttpRouterFactory, createLazyCaller, createMiddlewareFactory, createProcedureCallerFactory, createProcedureHandlerFactory, createServerCaller, defineProcedure, extractPathParams, extractRouteMap, getCRPCErrorFromUnknown, getGeneratedFunctionReference, getGeneratedValue, getHTTPStatusCodeFromError, handleHttpError, inferProcedureNameFromCallsite, initCRPC, isActionCtx, isCRPCError, isMutationCtx, isQueryCtx, isRunMutationCtx, isSchedulerCtx, matchPathParams, registerProcedureNameLookup, requireActionCtx, requireMutationCtx, requireQueryCtx, requireRunMutationCtx, requireSchedulerCtx, toCRPCError, typedProcedureResolver, withSystemFields, zCustomAction, zCustomMutation, zCustomQuery, zid, zodOutputToConvex, zodOutputToConvexFields, zodToConvex, zodToConvexFields };

package/dist/{table-rmJm5Qio.js → table-CX2lnX7e.js}

@@ -1,4 +1,4 @@
-import { o as vRequired } from "./validators-Dmbhsd3U.js";
+import { o as vRequired } from "./validators-CIoUYCqO.js";
 import { v } from "convex/values";
 
 //#region src/orm/builders/column-builder.ts

package/dist/{validators-Dmbhsd3U.js → validators-CIoUYCqO.js}

@@ -180,6 +180,7 @@ function vRequired(validator) {
 		case "string": return v.string();
 		case "float64": return v.float64();
 		case "int64": return v.int64();
+		case "commitTs": return v.commitTs();
 		case "boolean": return v.boolean();
 		case "null": return v.null();
 		case "any": return v.any();

package/dist/{validators-V4eM2-Jg.d.ts → validators-wOIjhkfN.d.ts}

@@ -83,6 +83,12 @@ type NotUndefined<T> = Exclude<T, undefined>;
  * type RequiredString = VRequired<OptionalString>; // VString<string, "required">
  * ```
  */
-type VRequired<T extends Validator<any, OptionalProperty, any>> = T extends VId<infer Type, OptionalProperty> ? VId<NotUndefined<Type>, 'required'> : T extends VString<infer Type, OptionalProperty> ? VString<NotUndefined<Type>, 'required'> : T extends VFloat64<infer Type, OptionalProperty> ? VFloat64<NotUndefined<Type>, 'required'> : T extends VInt64<infer Type, OptionalProperty> ? VInt64<NotUndefined<Type>, 'required'> : T extends VBoolean<infer Type, OptionalProperty> ? VBoolean<NotUndefined<Type>, 'required'> : T extends VNull<infer Type, OptionalProperty> ? VNull<NotUndefined<Type>, 'required'> : T extends VAny<infer Type, OptionalProperty> ? VAny<NotUndefined<Type>, 'required'> : T extends VLiteral<infer Type, OptionalProperty> ? VLiteral<NotUndefined<Type>, 'required'> : T extends VBytes<infer Type, OptionalProperty> ? VBytes<NotUndefined<Type>, 'required'> : T extends VObject<infer Type, infer Fields, OptionalProperty, infer FieldPaths> ? VObject<NotUndefined<Type>, Fields, 'required', FieldPaths> : T extends VArray<infer Type, infer Element, OptionalProperty> ? VArray<NotUndefined<Type>, Element, 'required'> : T extends VRecord<infer Type, infer Key, infer Value, OptionalProperty, infer FieldPaths> ? VRecord<NotUndefined<Type>, Key, Value, 'required', FieldPaths> : T extends VUnion<infer Type, infer Members, OptionalProperty, infer FieldPaths> ? VUnion<NotUndefined<Type>, Members, 'required', FieldPaths> : never;
+type VRequired<T extends Validator<any, OptionalProperty, any>> = T extends VId<infer Type, OptionalProperty> ? VId<NotUndefined<Type>, 'required'> : T extends VString<infer Type, OptionalProperty> ? VString<NotUndefined<Type>, 'required'> : T extends VFloat64<infer Type, OptionalProperty> ? VFloat64<NotUndefined<Type>, 'required'> : T extends VInt64<infer Type, OptionalProperty> ? VInt64<NotUndefined<Type>, 'required'> : T extends {
+  readonly kind: 'commitTs';
+  readonly type: infer Type;
+} ? Omit<T, 'isOptional' | 'type'> & {
+  readonly isOptional: 'required';
+  readonly type: NotUndefined<Type>;
+} : T extends VBoolean<infer Type, OptionalProperty> ? VBoolean<NotUndefined<Type>, 'required'> : T extends VNull<infer Type, OptionalProperty> ? VNull<NotUndefined<Type>, 'required'> : T extends VAny<infer Type, OptionalProperty> ? VAny<NotUndefined<Type>, 'required'> : T extends VLiteral<infer Type, OptionalProperty> ? VLiteral<NotUndefined<Type>, 'required'> : T extends VBytes<infer Type, OptionalProperty> ? VBytes<NotUndefined<Type>, 'required'> : T extends VObject<infer Type, infer Fields, OptionalProperty, infer FieldPaths> ? VObject<NotUndefined<Type>, Fields, 'required', FieldPaths> : T extends VArray<infer Type, infer Element, OptionalProperty> ? VArray<NotUndefined<Type>, Element, 'required'> : T extends VRecord<infer Type, infer Key, infer Value, OptionalProperty, infer FieldPaths> ? VRecord<NotUndefined<Type>, Key, Value, 'required', FieldPaths> : T extends VUnion<infer Type, infer Members, OptionalProperty, infer FieldPaths> ? VUnion<NotUndefined<Type>, Members, 'required', FieldPaths> : never;
 //#endregion
 export { pretendRequired as i, deprecated as n, pretend as r, VRequired as t };

package/dist/watcher.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as generateMeta, d as PARSE_SNAPSHOT_SUFFIX, i as resolveConfiguredBackend, n as withLocalCodegenEnv, o as getConvexConfig, r as loadCliConfig, u as logger } from "./local-env-Du24tdbp.mjs";
+import { a as generateMeta, d as PARSE_SNAPSHOT_SUFFIX, i as resolveConfiguredBackend, n as withLocalCodegenEnv, o as getConvexConfig, r as loadCliConfig, u as logger } from "./local-env-Dkh4a_BK.mjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";