@confect/server 9.0.0-next.5 → 9.0.0-next.7

package/dist/RegisteredConvexFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredConvexFunction.d.ts","names":[],"sources":["../src/RegisteredConvexFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiCa,IAAA,gBAAqB,uBAAA,YAChC,GAAA,EAAK,IAAA;EACL,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA;AAAA,cAkLU,aAAA,kBAAgC,YAAA,EAC3C,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,kBAAA,CAAmB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAAS,KAAA,CAAA,KAAA,CAAA,eAAA,GAAA,MAAA;0BAAA,kBAAA,CAAA,WAAA;;;;;;;;;;;;;;;;;;;;;;KAoB/D,gBAAA,gBAAgC,YAAA,IACxC,cAAA,CAA8B,MAAA,IAC9B,cAAA,CAA8B,MAAA,IAC9B,MAAA,GACA,WAAA,GACA,eAAA,GACA,eAAA,GACA,WAAA,GACA,cAAA,GACA,WAAA,CAAwB,QAAA,CAAmB,UAAA,CAAqB,MAAA"}
+{"version":3,"file":"RegisteredConvexFunction.d.ts","names":[],"sources":["../src/RegisteredConvexFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgCa,IAAA,GACX,cAAA,EAAgB,YAAA;EAChB,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA;AAAA,cAkLU,aAAA,kBAAgC,YAAA,EAC3C,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,kBAAA,CAAmB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAAS,KAAA,CAAA,KAAA;0BAAlD,kBAAA,CAAA,WAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoBb,gBAAA,gBAAgC,YAAA,IACxC,cAAA,CAA8B,MAAA,IAC9B,cAAA,CAA8B,MAAA,IAC9B,MAAA,GACA,WAAA,GACA,eAAA,GACA,eAAA,GACA,WAAA,GACA,cAAA,GACA,WAAA,CAAwB,QAAA,CAAmB,UAAA,CAAqB,MAAA"}

package/dist/RegisteredConvexFunction.js

@@ -20,11 +20,11 @@ var RegisteredConvexFunction_exports = /* @__PURE__ */ __exportAll({
 	make: () => make,
 	mutationLayer: () => mutationLayer
 });
-const make = (api, { functionSpec, handler }) => Match.value(functionSpec.functionProvenance).pipe(Match.tag("Convex", () => handler), Match.tag("Confect", () => {
+const make = (databaseSchema, { functionSpec, handler }) => Match.value(functionSpec.functionProvenance).pipe(Match.tag("Convex", () => handler), Match.tag("Confect", () => {
 	const { functionVisibility, functionProvenance } = functionSpec;
 	return Match.value(functionSpec.runtimeAndFunctionType.functionType).pipe(Match.when("query", () => {
 		return Match.value(functionVisibility).pipe(Match.when("public", () => queryGeneric), Match.when("internal", () => internalQueryGeneric), Match.exhaustive)(queryFunction({
-			databaseSchema: api.databaseSchema,
+			databaseSchema,
 			args: functionProvenance.args,
 			returns: functionProvenance.returns,
 			error: functionProvenance.error,
@@ -32,14 +32,14 @@ const make = (api, { functionSpec, handler }) => Match.value(functionSpec.functi
 		}));
 	}), Match.when("mutation", () => {
 		return Match.value(functionVisibility).pipe(Match.when("public", () => mutationGeneric), Match.when("internal", () => internalMutationGeneric), Match.exhaustive)(mutationFunction({
-			databaseSchema: api.databaseSchema,
+			databaseSchema,
 			args: functionProvenance.args,
 			returns: functionProvenance.returns,
 			error: functionProvenance.error,
 			handler
 		}));
 	}), Match.when("action", () => {
-		return Match.value(functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(convexActionFunction(api.databaseSchema, {
+		return Match.value(functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(convexActionFunction(databaseSchema, {
 			args: functionProvenance.args,
 			returns: functionProvenance.returns,
 			error: functionProvenance.error,

package/dist/RegisteredConvexFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredConvexFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","DatabaseReader.layer","Auth.layer","StorageReader","QueryRunner.layer","QueryCtx.QueryCtx","ConvexConfigProvider.make","RegisteredFunction.runHandlerPromise","DatabaseWriter.layer","Scheduler.layer","StorageWriter","MutationRunner.layer","MutationCtx.MutationCtx","RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredConvexFunction.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  type GenericMutationCtx,\n  type GenericQueryCtx,\n  internalActionGeneric,\n  internalMutationGeneric,\n  internalQueryGeneric,\n  mutationGeneric,\n  queryGeneric,\n} from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { Clock, Effect, Layer, Match, pipe, Schema } from \"effect\";\nimport type * as Api from \"./Api\";\nimport * as Auth from \"./Auth\";\nimport * as ConvexConfigProvider from \"./ConvexConfigProvider\";\nimport * as DatabaseReader from \"./DatabaseReader\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as DatabaseWriter from \"./DatabaseWriter\";\nimport type * as DataModel from \"./DataModel\";\nimport type * as Handler from \"./Handler\";\nimport * as MutationCtx from \"./MutationCtx\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryCtx from \"./QueryCtx\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport { StorageReader } from \"./StorageReader\";\nimport { StorageWriter } from \"./StorageWriter\";\n\nexport const make = <Api_ extends Api.AnyWithPropsWithRuntime<\"Convex\">>(\n  api: Api_,\n  { functionSpec, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.Any =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", () => handler as RegisteredFunction.Any),\n    Match.tag(\"Confect\", () => {\n      const { functionVisibility, functionProvenance } =\n        functionSpec as FunctionSpec.AnyConfect;\n\n      return Match.value(functionSpec.runtimeAndFunctionType.functionType).pipe(\n        Match.when(\"query\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => queryGeneric),\n            Match.when(\"internal\", () => internalQueryGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            queryFunction({\n              databaseSchema: api.databaseSchema,\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.when(\"mutation\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => mutationGeneric),\n            Match.when(\"internal\", () => internalMutationGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            mutationFunction({\n              databaseSchema: api.databaseSchema,\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.when(\"action\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => actionGeneric),\n            Match.when(\"internal\", () => internalActionGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            convexActionFunction(api.databaseSchema, {\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.exhaustive,\n      );\n    }),\n    Match.exhaustive,\n  );\n\n/**\n * Convex's query cache is invalidated by any Date.now() call during handler\n * execution. Effect's unsafeFork calls Date.now() when constructing a\n * FiberId.Runtime, which trips the cache for every confect-wrapped query. We\n * stub Date.now to 0 for the span of the handler; queries are forbidden from\n * relying on real time for correctness anyway.\n *\n * Users who explicitly want the real timestamp can still reach it via Effect's\n * Clock service (Clock.currentTimeMillis/Clock.currentTimeNanos). We provide a\n * Clock whose user-facing Effects call realDateNow (Convex's tracker) directly,\n * making Clock an explicit opt-in to cache invalidation. The unsafe methods\n * used internally by Effect (logging, span events, scheduler) return constants\n * so they never touch the tracker—caching is not broken by default.\n */\nconst unpatchedClock = (realDateNow: () => number): Clock.Clock => {\n  const defaultClock = Clock.make();\n  return {\n    ...defaultClock,\n    unsafeCurrentTimeMillis: () => 0,\n    unsafeCurrentTimeNanos: () => 0n,\n    currentTimeMillis: Effect.sync(() => realDateNow()),\n    currentTimeNanos: Effect.sync(() => BigInt(realDateNow()) * 1_000_000n),\n  };\n};\n\nconst withStubbedDateNow = async <T>(\n  queryHandler: (clock: Clock.Clock) => Promise<T>,\n): Promise<T> => {\n  const realDateNow = Date.now;\n  const clock = unpatchedClock(realDateNow);\n  Date.now = () => 0;\n  try {\n    return await queryHandler(clock);\n  } finally {\n    Date.now = realDateNow;\n  }\n};\n\nconst queryFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  databaseSchema,\n  args,\n  returns,\n  error,\n  handler,\n}: {\n  databaseSchema: DatabaseSchema_;\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  error: Schema.Schema<Error, Value> | undefined;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<\n    Returns,\n    E,\n    | DatabaseReader.DatabaseReader<DatabaseSchema_>\n    | Auth.Auth\n    | StorageReader\n    | QueryRunner.QueryRunner\n    | QueryCtx.QueryCtx<\n        DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n      >\n  >;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericQueryCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    withStubbedDateNow((clock) =>\n      Effect.gen(function* () {\n        const decodedArgs = yield* pipe(\n          actualArgs,\n          Schema.decode(args),\n          Effect.orDie,\n        );\n        const decodedReturns = yield* handler(decodedArgs).pipe(\n          Effect.provide(\n            Layer.mergeAll(\n              DatabaseReader.layer(databaseSchema, ctx.db),\n              Auth.layer(ctx.auth),\n              StorageReader.layer(ctx.storage),\n              QueryRunner.layer(ctx.runQuery),\n              Layer.succeed(\n                QueryCtx.QueryCtx<\n                  DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n                >(),\n                ctx,\n              ),\n              Layer.setConfigProvider(ConvexConfigProvider.make()),\n            ),\n          ),\n        );\n        return yield* pipe(\n          decodedReturns,\n          Schema.encode(returns),\n          Effect.orDie,\n        );\n      }).pipe(\n        Effect.withClock(clock),\n        RegisteredFunction.runHandlerPromise(error),\n      ),\n    ),\n});\n\nexport const mutationLayer = <Schema extends DatabaseSchema.AnyWithProps>(\n  schema: Schema,\n  ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n) =>\n  Layer.mergeAll(\n    DatabaseReader.layer(schema, ctx.db),\n    DatabaseWriter.layer(schema, ctx.db),\n    Auth.layer(ctx.auth),\n    Scheduler.layer(ctx.scheduler),\n    StorageReader.layer(ctx.storage),\n    StorageWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    Layer.succeed(\n      MutationCtx.MutationCtx<\n        DataModel.ToConvex<DataModel.FromSchema<Schema>>\n      >(),\n      ctx,\n    ),\n    Layer.setConfigProvider(ConvexConfigProvider.make()),\n  );\n\nexport type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =\n  | DatabaseReader.DatabaseReader<Schema>\n  | DatabaseWriter.DatabaseWriter<Schema>\n  | Auth.Auth\n  | Scheduler.Scheduler\n  | StorageReader\n  | StorageWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;\n\nconst mutationFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  databaseSchema,\n  args,\n  returns,\n  error,\n  handler,\n}: {\n  databaseSchema: DatabaseSchema_;\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  error: Schema.Schema<Error, Value> | undefined;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<Returns, E, MutationServices<DatabaseSchema_>>;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericMutationCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    Effect.gen(function* () {\n      const decodedArgs = yield* pipe(\n        actualArgs,\n        Schema.decode(args),\n        Effect.orDie,\n      );\n      const decodedReturns = yield* handler(decodedArgs).pipe(\n        Effect.provide(mutationLayer(databaseSchema, ctx)),\n      );\n      return yield* pipe(decodedReturns, Schema.encode(returns), Effect.orDie);\n    }).pipe(RegisteredFunction.runHandlerPromise(error)),\n});\n\nconst convexActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    error,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    error: Schema.Schema.AnyNoContext | undefined;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      RegisteredFunction.ActionServices<DatabaseSchema_>\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    error,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(schema, ctx),\n        Layer.setConfigProvider(ConvexConfigProvider.make()),\n      ),\n  });\n"],"mappings":"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"}
+{"version":3,"file":"RegisteredConvexFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","DatabaseReader.layer","Auth.layer","StorageReader","QueryRunner.layer","QueryCtx.QueryCtx","ConvexConfigProvider.make","RegisteredFunction.runHandlerPromise","DatabaseWriter.layer","Scheduler.layer","StorageWriter","MutationRunner.layer","MutationCtx.MutationCtx","RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredConvexFunction.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  type GenericMutationCtx,\n  type GenericQueryCtx,\n  internalActionGeneric,\n  internalMutationGeneric,\n  internalQueryGeneric,\n  mutationGeneric,\n  queryGeneric,\n} from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { Clock, Effect, Layer, Match, pipe, Schema } from \"effect\";\nimport * as Auth from \"./Auth\";\nimport * as ConvexConfigProvider from \"./ConvexConfigProvider\";\nimport * as DatabaseReader from \"./DatabaseReader\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as DatabaseWriter from \"./DatabaseWriter\";\nimport type * as DataModel from \"./DataModel\";\nimport type * as Handler from \"./Handler\";\nimport * as MutationCtx from \"./MutationCtx\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryCtx from \"./QueryCtx\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport { StorageReader } from \"./StorageReader\";\nimport { StorageWriter } from \"./StorageWriter\";\n\nexport const make = (\n  databaseSchema: DatabaseSchema.AnyWithProps,\n  { functionSpec, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.Any =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", () => handler as RegisteredFunction.Any),\n    Match.tag(\"Confect\", () => {\n      const { functionVisibility, functionProvenance } =\n        functionSpec as FunctionSpec.AnyConfect;\n\n      return Match.value(functionSpec.runtimeAndFunctionType.functionType).pipe(\n        Match.when(\"query\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => queryGeneric),\n            Match.when(\"internal\", () => internalQueryGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            queryFunction({\n              databaseSchema,\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.when(\"mutation\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => mutationGeneric),\n            Match.when(\"internal\", () => internalMutationGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            mutationFunction({\n              databaseSchema,\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.when(\"action\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => actionGeneric),\n            Match.when(\"internal\", () => internalActionGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            convexActionFunction(databaseSchema, {\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.exhaustive,\n      );\n    }),\n    Match.exhaustive,\n  );\n\n/**\n * Convex's query cache is invalidated by any Date.now() call during handler\n * execution. Effect's unsafeFork calls Date.now() when constructing a\n * FiberId.Runtime, which trips the cache for every confect-wrapped query. We\n * stub Date.now to 0 for the span of the handler; queries are forbidden from\n * relying on real time for correctness anyway.\n *\n * Users who explicitly want the real timestamp can still reach it via Effect's\n * Clock service (Clock.currentTimeMillis/Clock.currentTimeNanos). We provide a\n * Clock whose user-facing Effects call realDateNow (Convex's tracker) directly,\n * making Clock an explicit opt-in to cache invalidation. The unsafe methods\n * used internally by Effect (logging, span events, scheduler) return constants\n * so they never touch the tracker—caching is not broken by default.\n */\nconst unpatchedClock = (realDateNow: () => number): Clock.Clock => {\n  const defaultClock = Clock.make();\n  return {\n    ...defaultClock,\n    unsafeCurrentTimeMillis: () => 0,\n    unsafeCurrentTimeNanos: () => 0n,\n    currentTimeMillis: Effect.sync(() => realDateNow()),\n    currentTimeNanos: Effect.sync(() => BigInt(realDateNow()) * 1_000_000n),\n  };\n};\n\nconst withStubbedDateNow = async <T>(\n  queryHandler: (clock: Clock.Clock) => Promise<T>,\n): Promise<T> => {\n  const realDateNow = Date.now;\n  const clock = unpatchedClock(realDateNow);\n  Date.now = () => 0;\n  try {\n    return await queryHandler(clock);\n  } finally {\n    Date.now = realDateNow;\n  }\n};\n\nconst queryFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  databaseSchema,\n  args,\n  returns,\n  error,\n  handler,\n}: {\n  databaseSchema: DatabaseSchema_;\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  error: Schema.Schema<Error, Value> | undefined;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<\n    Returns,\n    E,\n    | DatabaseReader.DatabaseReader<DatabaseSchema_>\n    | Auth.Auth\n    | StorageReader\n    | QueryRunner.QueryRunner\n    | QueryCtx.QueryCtx<\n        DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n      >\n  >;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericQueryCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    withStubbedDateNow((clock) =>\n      Effect.gen(function* () {\n        const decodedArgs = yield* pipe(\n          actualArgs,\n          Schema.decode(args),\n          Effect.orDie,\n        );\n        const decodedReturns = yield* handler(decodedArgs).pipe(\n          Effect.provide(\n            Layer.mergeAll(\n              DatabaseReader.layer(databaseSchema, ctx.db),\n              Auth.layer(ctx.auth),\n              StorageReader.layer(ctx.storage),\n              QueryRunner.layer(ctx.runQuery),\n              Layer.succeed(\n                QueryCtx.QueryCtx<\n                  DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n                >(),\n                ctx,\n              ),\n              Layer.setConfigProvider(ConvexConfigProvider.make()),\n            ),\n          ),\n        );\n        return yield* pipe(\n          decodedReturns,\n          Schema.encode(returns),\n          Effect.orDie,\n        );\n      }).pipe(\n        Effect.withClock(clock),\n        RegisteredFunction.runHandlerPromise(error),\n      ),\n    ),\n});\n\nexport const mutationLayer = <Schema extends DatabaseSchema.AnyWithProps>(\n  schema: Schema,\n  ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n) =>\n  Layer.mergeAll(\n    DatabaseReader.layer(schema, ctx.db),\n    DatabaseWriter.layer(schema, ctx.db),\n    Auth.layer(ctx.auth),\n    Scheduler.layer(ctx.scheduler),\n    StorageReader.layer(ctx.storage),\n    StorageWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    Layer.succeed(\n      MutationCtx.MutationCtx<\n        DataModel.ToConvex<DataModel.FromSchema<Schema>>\n      >(),\n      ctx,\n    ),\n    Layer.setConfigProvider(ConvexConfigProvider.make()),\n  );\n\nexport type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =\n  | DatabaseReader.DatabaseReader<Schema>\n  | DatabaseWriter.DatabaseWriter<Schema>\n  | Auth.Auth\n  | Scheduler.Scheduler\n  | StorageReader\n  | StorageWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;\n\nconst mutationFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  databaseSchema,\n  args,\n  returns,\n  error,\n  handler,\n}: {\n  databaseSchema: DatabaseSchema_;\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  error: Schema.Schema<Error, Value> | undefined;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<Returns, E, MutationServices<DatabaseSchema_>>;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericMutationCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    Effect.gen(function* () {\n      const decodedArgs = yield* pipe(\n        actualArgs,\n        Schema.decode(args),\n        Effect.orDie,\n      );\n      const decodedReturns = yield* handler(decodedArgs).pipe(\n        Effect.provide(mutationLayer(databaseSchema, ctx)),\n      );\n      return yield* pipe(decodedReturns, Schema.encode(returns), Effect.orDie);\n    }).pipe(RegisteredFunction.runHandlerPromise(error)),\n});\n\nconst convexActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    error,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    error: Schema.Schema.AnyNoContext | undefined;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      RegisteredFunction.ActionServices<DatabaseSchema_>\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    error,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(schema, ctx),\n        Layer.setConfigProvider(ConvexConfigProvider.make()),\n      ),\n  });\n"],"mappings":"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"}

package/dist/RegisteredFunction.d.ts

@@ -1,7 +1,7 @@
 import { ActionCtx } from "./ActionCtx.js";
 import { ActionRunner } from "./ActionRunner.js";
-import { AnyWithProps } from "./DatabaseSchema.js";
 import { Auth as Auth$1 } from "./Auth.js";
+import { AnyWithProps } from "./DatabaseSchema.js";
 import { FromSchema, TableNames, ToConvex } from "./DataModel.js";
 import { MutationRunner } from "./MutationRunner.js";
 import { QueryRunner } from "./QueryRunner.js";
@@ -70,10 +70,10 @@ declare const actionFunctionBase: <Schema extends AnyWithProps, Args, ConvexArgs
   handler: (ctx: GenericActionCtx<ToConvex<FromSchema<Schema>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
 };
 type ActionServices<DatabaseSchema_ extends AnyWithProps> = Scheduler$1 | Auth$1 | StorageReader$1 | StorageWriter$1 | StorageActionWriter$1 | QueryRunner | MutationRunner | ActionRunner | VectorSearch<FromSchema<DatabaseSchema_>> | ActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>;
-declare const actionLayer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<(<Action extends _confect_core_Ref0.AnyAction>(action: Action, ...args: _confect_core_Ref0.OptionalArgs<Action>) => Effect.Effect<_confect_core_Ref0.Returns<Action>, _confect_core_Ref0.Error<Action> | effect_ParseResult0.ParseError>) | StorageActionWriter$1 | StorageWriter$1 | Auth$1 | GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>> | {
+declare const actionLayer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<(<Action extends _confect_core_Ref0.AnyAction>(action: Action, ...args: _confect_core_Ref0.OptionalArgs<Action>) => Effect.Effect<_confect_core_Ref0.Returns<Action>, _confect_core_Ref0.Error<Action> | effect_ParseResult0.ParseError>) | GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>> | {
   runAfter: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(delay: effect_Duration0.Duration, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
   runAt: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(dateTime: effect_DateTime0.DateTime, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-} | StorageReader$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, ...args: _confect_core_Ref0.OptionalArgs<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, _confect_core_Ref0.Error<Query> | effect_ParseResult0.ParseError>) | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, ...args: _confect_core_Ref0.OptionalArgs<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, _confect_core_Ref0.Error<Mutation> | effect_ParseResult0.ParseError>) | (<TableName extends TableNames<FromSchema<DatabaseSchema_>>, IndexName extends keyof convex_server0.VectorIndexes<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>>(tableName: TableName, indexName: IndexName, query: {
+} | Auth$1 | StorageReader$1 | StorageWriter$1 | StorageActionWriter$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, ...args: _confect_core_Ref0.OptionalArgs<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, _confect_core_Ref0.Error<Query> | effect_ParseResult0.ParseError>) | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, ...args: _confect_core_Ref0.OptionalArgs<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, _confect_core_Ref0.Error<Mutation> | effect_ParseResult0.ParseError>) | (<TableName extends TableNames<FromSchema<DatabaseSchema_>>, IndexName extends keyof convex_server0.VectorIndexes<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>>(tableName: TableName, indexName: IndexName, query: {
   vector: number[];
   limit?: number;
   filter?: (q: convex_server0.VectorFilterBuilder<convex_server0.DocumentByInfo<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>, convex_server0.NamedVectorIndex<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>, IndexName>>) => convex_server0.FilterExpression<boolean>;

package/dist/RegisteredFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunction.d.ts","names":[],"sources":["../src/RegisteredFunction.ts"],"mappings":"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"}
+{"version":3,"file":"RegisteredFunction.d.ts","names":[],"sources":["../src/RegisteredFunction.ts"],"mappings":"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"}

package/dist/RegisteredFunctions.d.ts

@@ -1,33 +1,57 @@
-import { AnyWithProps as AnyWithProps$1 } from "./Api.js";
+import { AnyWithProps as AnyWithProps$1 } from "./DatabaseSchema.js";
 import { Any, RegisteredFunction } from "./RegisteredFunction.js";
 import { GroupImpl } from "./GroupImpl.js";
 import { AnyWithProps as AnyWithProps$2 } from "./RegistryItem.js";
 import { Layer, Types } from "effect";
+import * as FunctionSpec from "@confect/core/FunctionSpec";
 import * as GroupSpec from "@confect/core/GroupSpec";
 import * as Spec from "@confect/core/Spec";
-import * as FunctionSpec from "@confect/core/FunctionSpec";
 
 //#region src/RegisteredFunctions.d.ts
 declare namespace RegisteredFunctions_d_exports {
-  export { AnyWithProps, ForGroupPath, RegisteredFunctions, buildForGroup };
+  export { AnyWithProps, RegisteredFunctions, RegisteredFunctionsForGroupSpec, buildForGroup };
 }
 type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> = Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;
-type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = { [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<Groups, GroupName> extends infer Group extends GroupSpec.AnyWithProps ? GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps ? Types.Simplify<RegisteredFunctionsHelper<SubGroups> & { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps ? RegisteredFunction<FunctionSpec_> : never }> : { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps ? RegisteredFunction<FunctionSpec_> : never } : never };
+type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = { [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<Groups, GroupName> extends infer Group extends GroupSpec.AnyWithProps ? RegisteredFunctionsForGroupSpec<Group> : never };
+/** The `RegisteredFunction` record for a group's own declared functions. */
+type RegisteredFunctionsOf<Group extends GroupSpec.AnyWithProps> = { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps ? RegisteredFunction<FunctionSpec_> : never };
+/**
+ * The registered-functions record for a single group, derived from the group's
+ * own `GroupSpec`: its declared functions, plus any nested subgroups it carries
+ * directly. This is the node that `buildForGroup` returns — computed from the
+ * leaf `GroupSpec` itself rather than by navigating the project-wide assembled
+ * `Spec` to a dot-path, so the per-group registry's type depends only on its
+ * own leaf. For the filesystem layout a leaf `GroupSpec` carries no subgroups
+ * (subdirectory children are assembled separately into `_generated/spec.ts`),
+ * so this resolves to just the leaf's functions.
+ */
+type RegisteredFunctionsForGroupSpec<Group extends GroupSpec.AnyWithProps> = GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps ? Types.Simplify<RegisteredFunctionsHelper<SubGroups> & RegisteredFunctionsOf<Group>> : RegisteredFunctionsOf<Group>;
 interface AnyWithProps {
   readonly [key: string]: Any | AnyWithProps;
 }
-type RegisteredFunctionsAtPath<Tree, Path extends string> = Path extends `${infer Head}.${infer Tail}` ? Head extends keyof Tree ? Tree[Head] extends AnyWithProps ? RegisteredFunctionsAtPath<Tree[Head], Tail> : never : never : Path extends keyof Tree ? Tree[Path] : never;
-type ForGroupPath<Spec_ extends Spec.AnyWithProps, Path extends string> = RegisteredFunctionsAtPath<RegisteredFunctions<Spec_>, Path>;
 /**
  * Build the registered Convex functions for a single group from its finalized
  * `GroupImpl` layer.
  *
- * The `groupLayer` parameter requires `GroupImpl<string, "Finalized">`, so
- * impls that were never piped through `GroupImpl.finalize` (and impls with
- * unmet `FunctionImpl` requirements, which cannot be finalized) are rejected
- * at the codegen boundary, not just deep inside Convex at runtime.
+ * The `groupLayer` parameter requires `GroupImpl<"Finalized">`, so impls that
+ * were never piped through `GroupImpl.finalize` (and impls with unmet
+ * `FunctionImpl` requirements, which cannot be finalized) are rejected at the
+ * codegen boundary, not just deep inside Convex at runtime.
+ *
+ * The group layer is built with a fresh, isolated `Registry` (rather than the
+ * globally-cached default `Context.Reference`), so each `FunctionImpl.make`
+ * registers under its flat, single-segment function-name key without colliding
+ * with any other group built in the same process — the built registry holds
+ * exactly this group's functions at the top level.
+ *
+ * Only the runtime `databaseSchema` value is needed at runtime (it is forwarded
+ * to `makeRegisteredFunction` to build each function's ctx services); the
+ * group's `GroupSpec` is supplied purely as the `Group` type parameter to shape
+ * the returned record. The generated caller passes it explicitly and imports
+ * the leaf spec type-only (`typeof import("…/<group>.spec")["default"]`), so a
+ * function's bundle never imports a spec module at runtime.
  */
-declare const buildForGroup: <Api_ extends AnyWithProps$1, const GroupPath_ extends string>(api: Api_, groupPath: GroupPath_, groupLayer: Layer.Layer<GroupImpl<string, "Finalized">>, makeRegisteredFunction: (api: Api_, registryItem: AnyWithProps$2) => Any) => ForGroupPath<Api_["spec"], GroupPath_>;
+declare const buildForGroup: <Group extends GroupSpec.AnyWithProps>(databaseSchema: AnyWithProps$1, groupLayer: Layer.Layer<GroupImpl<"Finalized">>, makeRegisteredFunction: (databaseSchema: AnyWithProps$1, registryItem: AnyWithProps$2) => Any) => RegisteredFunctionsForGroupSpec<Group>;
 //#endregion
-export { AnyWithProps, ForGroupPath, RegisteredFunctions, RegisteredFunctions_d_exports, buildForGroup };
+export { AnyWithProps, RegisteredFunctions, RegisteredFunctionsForGroupSpec, RegisteredFunctions_d_exports, buildForGroup };
 //# sourceMappingURL=RegisteredFunctions.d.ts.map

package/dist/RegisteredFunctions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunctions.d.ts","names":[],"sources":["../src/RegisteredFunctions.ts"],"mappings":";;;;;;;;;;;;;KAqBY,mBAAA,eAAkC,IAAA,CAAK,YAAA,IACjD,KAAA,CAAM,QAAA,CAAS,yBAAA,CAA0B,IAAA,CAAK,MAAA,CAAO,KAAA;AAAA,KAElD,yBAAA,gBAAyC,SAAA,CAAU,YAAA,oBACxC,SAAA,CAAU,IAAA,CAAK,MAAA,IAAU,SAAA,CAAU,QAAA,CAC/C,MAAA,EACA,SAAA,8BAC4B,SAAA,CAAU,YAAA,GACpC,SAAA,CAAU,MAAA,CAAO,KAAA,kCACf,SAAA,CAAU,YAAA,GACV,KAAA,CAAM,QAAA,CACJ,yBAAA,CAA0B,SAAA,uBACP,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,sCACoC,YAAA,CAAa,YAAA,GAC/C,kBAAA,CAAsC,aAAA,kCAK3B,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,sCACoC,YAAA,CAAa,YAAA,GAC/C,kBAAA,CAAsC,aAAA;AAAA,UAMnC,YAAA;EAAA,UACL,GAAA,WAAc,GAAA,GAAyB,YAAA;AAAA;AAAA,KAG9C,yBAAA,8BAGD,IAAA,yCACA,IAAA,eAAmB,IAAA,GACjB,IAAA,CAAK,IAAA,UAAc,YAAA,GACjB,yBAAA,CAA0B,IAAA,CAAK,IAAA,GAAO,IAAA,oBAG1C,IAAA,eAAmB,IAAA,GACjB,IAAA,CAAK,IAAA;AAAA,KAGC,YAAA,eACI,IAAA,CAAK,YAAA,yBAEjB,yBAAA,CAA0B,mBAAA,CAAoB,KAAA,GAAQ,IAAA;;;;;;;;;;cAW7C,aAAA,gBACE,cAAA,mCAGb,GAAA,EAAK,IAAA,EACL,SAAA,EAAW,UAAA,EACX,UAAA,EAAY,KAAA,CAAM,KAAA,CAAM,SAAA,wBACxB,sBAAA,GACE,GAAA,EAAK,IAAA,EACL,YAAA,EAAc,cAAA,KACX,GAAA,KACJ,YAAA,CAAa,IAAA,UAAc,UAAA"}
+{"version":3,"file":"RegisteredFunctions.d.ts","names":[],"sources":["../src/RegisteredFunctions.ts"],"mappings":";;;;;;;;;;;;;KAWY,mBAAA,eAAkC,IAAA,CAAK,YAAA,IACjD,KAAA,CAAM,QAAA,CAAS,yBAAA,CAA0B,IAAA,CAAK,MAAA,CAAO,KAAA;AAAA,KAElD,yBAAA,gBAAyC,SAAA,CAAU,YAAA,oBACxC,SAAA,CAAU,IAAA,CAAK,MAAA,IAAU,SAAA,CAAU,QAAA,CAC/C,MAAA,EACA,SAAA,8BAC4B,SAAA,CAAU,YAAA,GACpC,+BAAA,CAAgC,KAAA;;KAKjC,qBAAA,eAAoC,SAAA,CAAU,YAAA,uBAChC,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,sCACoC,YAAA,CAAa,YAAA,GAC/C,kBAAA,CAAsC,aAAA;;AApB5C;;;;;;;;;KAkCY,+BAAA,eACI,SAAA,CAAU,YAAA,IAExB,SAAA,CAAU,MAAA,CAAO,KAAA,kCAAuC,SAAA,CAAU,YAAA,GAC9D,KAAA,CAAM,QAAA,CACJ,yBAAA,CAA0B,SAAA,IAAa,qBAAA,CAAsB,KAAA,KAE/D,qBAAA,CAAsB,KAAA;AAAA,UAEX,YAAA;EAAA,UACL,GAAA,WAAc,GAAA,GAAyB,YAAA;AAAA;;;;;;;;;AA3Ca;;;;;;;;;;;;;;cAoEnD,aAAA,iBAA+B,SAAA,CAAU,YAAA,EACpD,cAAA,EAAgB,cAAA,EAChB,UAAA,EAAY,KAAA,CAAM,KAAA,CAAM,SAAA,gBACxB,sBAAA,GACE,cAAA,EAAgB,cAAA,EAChB,YAAA,EAAc,cAAA,KACX,GAAA,KACJ,+BAAA,CAAgC,KAAA"}

package/dist/RegisteredFunctions.js

@@ -1,7 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { mapLeaves } from "./internal/utils.js";
 import { isRegistryItem } from "./RegistryItem.js";
-import { Array, Effect, Option, Predicate, Ref, String, pipe } from "effect";
+import { Effect, Ref } from "effect";
 import * as Registry from "@confect/core/Registry";
 
 //#region src/RegisteredFunctions.ts
@@ -10,17 +10,29 @@ var RegisteredFunctions_exports = /* @__PURE__ */ __exportAll({ buildForGroup: (
 * Build the registered Convex functions for a single group from its finalized
 * `GroupImpl` layer.
 *
-* The `groupLayer` parameter requires `GroupImpl<string, "Finalized">`, so
-* impls that were never piped through `GroupImpl.finalize` (and impls with
-* unmet `FunctionImpl` requirements, which cannot be finalized) are rejected
-* at the codegen boundary, not just deep inside Convex at runtime.
+* The `groupLayer` parameter requires `GroupImpl<"Finalized">`, so impls that
+* were never piped through `GroupImpl.finalize` (and impls with unmet
+* `FunctionImpl` requirements, which cannot be finalized) are rejected at the
+* codegen boundary, not just deep inside Convex at runtime.
+*
+* The group layer is built with a fresh, isolated `Registry` (rather than the
+* globally-cached default `Context.Reference`), so each `FunctionImpl.make`
+* registers under its flat, single-segment function-name key without colliding
+* with any other group built in the same process — the built registry holds
+* exactly this group's functions at the top level.
+*
+* Only the runtime `databaseSchema` value is needed at runtime (it is forwarded
+* to `makeRegisteredFunction` to build each function's ctx services); the
+* group's `GroupSpec` is supplied purely as the `Group` type parameter to shape
+* the returned record. The generated caller passes it explicitly and imports
+* the leaf spec type-only (`typeof import("…/<group>.spec")["default"]`), so a
+* function's bundle never imports a spec module at runtime.
 */
-const buildForGroup = (api, groupPath, groupLayer, makeRegisteredFunction) => {
-	const registeredFunctions = mapLeaves(Effect.gen(function* () {
+const buildForGroup = (databaseSchema, groupLayer, makeRegisteredFunction) => {
+	return mapLeaves(Effect.gen(function* () {
 		const registry = yield* Registry.Registry;
 		return yield* Ref.get(registry);
-	}).pipe(Effect.provide(groupLayer), Effect.runSync), isRegistryItem, (registryItem) => makeRegisteredFunction(api, registryItem));
-	return pipe(String.split(groupPath, "."), Array.reduce(Option.some(registeredFunctions), (currentNode, segment) => currentNode.pipe(Option.filter(Predicate.isRecord), Option.flatMap((nodeRecord) => segment in nodeRecord ? Option.some(nodeRecord[segment]) : Option.none()))), Option.getOrThrowWith(() => /* @__PURE__ */ new Error(`No functions registered for group path "${groupPath}"`)));
+	}).pipe(Effect.provide(groupLayer), Effect.provideService(Registry.Registry, Ref.unsafeMake({})), Effect.runSync), isRegistryItem, (registryItem) => makeRegisteredFunction(databaseSchema, registryItem));
 };
 
 //#endregion

package/dist/RegisteredFunctions.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunctions.js","names":["RegistryItem.isRegistryItem"],"sources":["../src/RegisteredFunctions.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport * as Registry from \"@confect/core/Registry\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport {\n  Array,\n  Effect,\n  type Layer,\n  Option,\n  pipe,\n  Predicate,\n  Ref,\n  String,\n  type Types,\n} from \"effect\";\nimport type * as Api from \"./Api\";\nimport type * as GroupImpl from \"./GroupImpl\";\nimport { mapLeaves } from \"./internal/utils\";\nimport type * as RegisteredFunction from \"./RegisteredFunction\";\nimport * as RegistryItem from \"./RegistryItem\";\n\nexport type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =\n  Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;\n\ntype RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? GroupSpec.Groups<Group> extends infer SubGroups extends\n        GroupSpec.AnyWithProps\n      ? Types.Simplify<\n          RegisteredFunctionsHelper<SubGroups> & {\n            [FunctionName in FunctionSpec.Name<\n              GroupSpec.Functions<Group>\n            >]: FunctionSpec.WithName<\n              GroupSpec.Functions<Group>,\n              FunctionName\n            > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps\n              ? RegisteredFunction.RegisteredFunction<FunctionSpec_>\n              : never;\n          }\n        >\n      : {\n          [FunctionName in FunctionSpec.Name<\n            GroupSpec.Functions<Group>\n          >]: FunctionSpec.WithName<\n            GroupSpec.Functions<Group>,\n            FunctionName\n          > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps\n            ? RegisteredFunction.RegisteredFunction<FunctionSpec_>\n            : never;\n        }\n    : never;\n};\n\nexport interface AnyWithProps {\n  readonly [key: string]: RegisteredFunction.Any | AnyWithProps;\n}\n\ntype RegisteredFunctionsAtPath<\n  Tree,\n  Path extends string,\n> = Path extends `${infer Head}.${infer Tail}`\n  ? Head extends keyof Tree\n    ? Tree[Head] extends AnyWithProps\n      ? RegisteredFunctionsAtPath<Tree[Head], Tail>\n      : never\n    : never\n  : Path extends keyof Tree\n    ? Tree[Path]\n    : never;\n\nexport type ForGroupPath<\n  Spec_ extends Spec.AnyWithProps,\n  Path extends string,\n> = RegisteredFunctionsAtPath<RegisteredFunctions<Spec_>, Path>;\n\n/**\n * Build the registered Convex functions for a single group from its finalized\n * `GroupImpl` layer.\n *\n * The `groupLayer` parameter requires `GroupImpl<string, \"Finalized\">`, so\n * impls that were never piped through `GroupImpl.finalize` (and impls with\n * unmet `FunctionImpl` requirements, which cannot be finalized) are rejected\n * at the codegen boundary, not just deep inside Convex at runtime.\n */\nexport const buildForGroup = <\n  Api_ extends Api.AnyWithProps,\n  const GroupPath_ extends string,\n>(\n  api: Api_,\n  groupPath: GroupPath_,\n  groupLayer: Layer.Layer<GroupImpl.GroupImpl<string, \"Finalized\">>,\n  makeRegisteredFunction: (\n    api: Api_,\n    registryItem: RegistryItem.AnyWithProps,\n  ) => RegisteredFunction.Any,\n): ForGroupPath<Api_[\"spec\"], GroupPath_> => {\n  const registryItems = Effect.gen(function* () {\n    const registry = yield* Registry.Registry;\n    return yield* Ref.get(registry);\n  }).pipe(Effect.provide(groupLayer), Effect.runSync);\n\n  const registeredFunctions = mapLeaves<\n    RegistryItem.AnyWithProps,\n    RegisteredFunction.Any\n  >(\n    registryItems as { [key: string]: RegistryItem.AnyWithProps },\n    RegistryItem.isRegistryItem,\n    (registryItem) => makeRegisteredFunction(api, registryItem),\n  );\n\n  return pipe(\n    String.split(groupPath, \".\"),\n    Array.reduce(\n      Option.some<unknown>(registeredFunctions),\n      (currentNode, segment) =>\n        currentNode.pipe(\n          Option.filter(Predicate.isRecord),\n          Option.flatMap((nodeRecord) =>\n            segment in nodeRecord\n              ? Option.some(nodeRecord[segment])\n              : Option.none(),\n          ),\n        ),\n    ),\n    Option.getOrThrowWith(\n      () => new Error(`No functions registered for group path \"${groupPath}\"`),\n    ),\n  ) as ForGroupPath<Api_[\"spec\"], GroupPath_>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAuFA,MAAa,iBAIX,KACA,WACA,YACA,2BAI2C;CAM3C,MAAM,sBAAsB,UALN,OAAO,IAAI,aAAa;EAC5C,MAAM,WAAW,OAAO,SAAS;AACjC,SAAO,OAAO,IAAI,IAAI,SAAS;GAC/B,CAAC,KAAK,OAAO,QAAQ,WAAW,EAAE,OAAO,QAAQ,EAOjDA,iBACC,iBAAiB,uBAAuB,KAAK,aAAa,CAC5D;AAED,QAAO,KACL,OAAO,MAAM,WAAW,IAAI,EAC5B,MAAM,OACJ,OAAO,KAAc,oBAAoB,GACxC,aAAa,YACZ,YAAY,KACV,OAAO,OAAO,UAAU,SAAS,EACjC,OAAO,SAAS,eACd,WAAW,aACP,OAAO,KAAK,WAAW,SAAS,GAChC,OAAO,MAAM,CAClB,CACF,CACJ,EACD,OAAO,qCACC,IAAI,MAAM,2CAA2C,UAAU,GAAG,CACzE,CACF"}
+{"version":3,"file":"RegisteredFunctions.js","names":["RegistryItem.isRegistryItem"],"sources":["../src/RegisteredFunctions.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport * as Registry from \"@confect/core/Registry\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport { Effect, type Layer, Ref, type Types } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as GroupImpl from \"./GroupImpl\";\nimport { mapLeaves } from \"./internal/utils\";\nimport type * as RegisteredFunction from \"./RegisteredFunction\";\nimport * as RegistryItem from \"./RegistryItem\";\n\nexport type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =\n  Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;\n\ntype RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? RegisteredFunctionsForGroupSpec<Group>\n    : never;\n};\n\n/** The `RegisteredFunction` record for a group's own declared functions. */\ntype RegisteredFunctionsOf<Group extends GroupSpec.AnyWithProps> = {\n  [FunctionName in FunctionSpec.Name<\n    GroupSpec.Functions<Group>\n  >]: FunctionSpec.WithName<\n    GroupSpec.Functions<Group>,\n    FunctionName\n  > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps\n    ? RegisteredFunction.RegisteredFunction<FunctionSpec_>\n    : never;\n};\n\n/**\n * The registered-functions record for a single group, derived from the group's\n * own `GroupSpec`: its declared functions, plus any nested subgroups it carries\n * directly. This is the node that `buildForGroup` returns — computed from the\n * leaf `GroupSpec` itself rather than by navigating the project-wide assembled\n * `Spec` to a dot-path, so the per-group registry's type depends only on its\n * own leaf. For the filesystem layout a leaf `GroupSpec` carries no subgroups\n * (subdirectory children are assembled separately into `_generated/spec.ts`),\n * so this resolves to just the leaf's functions.\n */\nexport type RegisteredFunctionsForGroupSpec<\n  Group extends GroupSpec.AnyWithProps,\n> =\n  GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps\n    ? Types.Simplify<\n        RegisteredFunctionsHelper<SubGroups> & RegisteredFunctionsOf<Group>\n      >\n    : RegisteredFunctionsOf<Group>;\n\nexport interface AnyWithProps {\n  readonly [key: string]: RegisteredFunction.Any | AnyWithProps;\n}\n\n/**\n * Build the registered Convex functions for a single group from its finalized\n * `GroupImpl` layer.\n *\n * The `groupLayer` parameter requires `GroupImpl<\"Finalized\">`, so impls that\n * were never piped through `GroupImpl.finalize` (and impls with unmet\n * `FunctionImpl` requirements, which cannot be finalized) are rejected at the\n * codegen boundary, not just deep inside Convex at runtime.\n *\n * The group layer is built with a fresh, isolated `Registry` (rather than the\n * globally-cached default `Context.Reference`), so each `FunctionImpl.make`\n * registers under its flat, single-segment function-name key without colliding\n * with any other group built in the same process — the built registry holds\n * exactly this group's functions at the top level.\n *\n * Only the runtime `databaseSchema` value is needed at runtime (it is forwarded\n * to `makeRegisteredFunction` to build each function's ctx services); the\n * group's `GroupSpec` is supplied purely as the `Group` type parameter to shape\n * the returned record. The generated caller passes it explicitly and imports\n * the leaf spec type-only (`typeof import(\"…/<group>.spec\")[\"default\"]`), so a\n * function's bundle never imports a spec module at runtime.\n */\nexport const buildForGroup = <Group extends GroupSpec.AnyWithProps>(\n  databaseSchema: DatabaseSchema.AnyWithProps,\n  groupLayer: Layer.Layer<GroupImpl.GroupImpl<\"Finalized\">>,\n  makeRegisteredFunction: (\n    databaseSchema: DatabaseSchema.AnyWithProps,\n    registryItem: RegistryItem.AnyWithProps,\n  ) => RegisteredFunction.Any,\n): RegisteredFunctionsForGroupSpec<Group> => {\n  const registryItems = Effect.gen(function* () {\n    const registry = yield* Registry.Registry;\n    return yield* Ref.get(registry);\n  }).pipe(\n    Effect.provide(groupLayer),\n    Effect.provideService(\n      Registry.Registry,\n      Ref.unsafeMake<Registry.RegistryItems>({}),\n    ),\n    Effect.runSync,\n  );\n\n  return mapLeaves<RegistryItem.AnyWithProps, RegisteredFunction.Any>(\n    registryItems as { [key: string]: RegistryItem.AnyWithProps },\n    RegistryItem.isRegistryItem,\n    (registryItem) => makeRegisteredFunction(databaseSchema, registryItem),\n  ) as RegisteredFunctionsForGroupSpec<Group>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,MAAa,iBACX,gBACA,YACA,2BAI2C;AAa3C,QAAO,UAZe,OAAO,IAAI,aAAa;EAC5C,MAAM,WAAW,OAAO,SAAS;AACjC,SAAO,OAAO,IAAI,IAAI,SAAS;GAC/B,CAAC,KACD,OAAO,QAAQ,WAAW,EAC1B,OAAO,eACL,SAAS,UACT,IAAI,WAAmC,EAAE,CAAC,CAC3C,EACD,OAAO,QACR,EAICA,iBACC,iBAAiB,uBAAuB,gBAAgB,aAAa,CACvE"}

package/dist/RegisteredNodeFunction.d.ts

@@ -1,15 +1,15 @@
-import { AnyWithPropsWithRuntime } from "./Api.js";
+import { AnyWithProps } from "./DatabaseSchema.js";
 import { Any } from "./RegisteredFunction.js";
-import { AnyWithProps } from "./RegistryItem.js";
+import { AnyWithProps as AnyWithProps$1 } from "./RegistryItem.js";
 
 //#region src/RegisteredNodeFunction.d.ts
 declare namespace RegisteredNodeFunction_d_exports {
   export { make };
 }
-declare const make: <Api_ extends AnyWithPropsWithRuntime<"Node">>(api: Api_, {
+declare const make: (databaseSchema: AnyWithProps, {
   functionSpec,
   handler
-}: AnyWithProps) => Any;
+}: AnyWithProps$1) => Any;
 //#endregion
 export { RegisteredNodeFunction_d_exports, make };
 //# sourceMappingURL=RegisteredNodeFunction.d.ts.map

package/dist/RegisteredNodeFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredNodeFunction.d.ts","names":[],"sources":["../src/RegisteredNodeFunction.ts"],"mappings":";;;;;;;;cAea,IAAA,gBAAqB,uBAAA,UAChC,GAAA,EAAK,IAAA;EACL,YAAA;EAAA;AAAA,GAA2B,YAAA,KAC1B,GAAA"}
+{"version":3,"file":"RegisteredNodeFunction.d.ts","names":[],"sources":["../src/RegisteredNodeFunction.ts"],"mappings":";;;;;;;;cAca,IAAA,GACX,cAAA,EAAgB,YAAA;EAChB,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA"}

package/dist/RegisteredNodeFunction.js

@@ -6,9 +6,9 @@ import { NodeContext } from "@effect/platform-node";
 
 //#region src/RegisteredNodeFunction.ts
 var RegisteredNodeFunction_exports = /* @__PURE__ */ __exportAll({ make: () => make });
-const make = (api, { functionSpec, handler }) => Match.value(functionSpec.functionProvenance).pipe(Match.tag("Convex", () => handler), Match.tag("Confect", () => {
+const make = (databaseSchema, { functionSpec, handler }) => Match.value(functionSpec.functionProvenance).pipe(Match.tag("Convex", () => handler), Match.tag("Confect", () => {
 	const { functionVisibility, functionProvenance } = functionSpec;
-	return Match.value(functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(nodeActionFunction(api.databaseSchema, {
+	return Match.value(functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(nodeActionFunction(databaseSchema, {
 		args: functionProvenance.args,
 		returns: functionProvenance.returns,
 		error: functionProvenance.error,

package/dist/RegisteredNodeFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredNodeFunction.js","names":["RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredNodeFunction.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport { NodeContext } from \"@effect/platform-node\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  internalActionGeneric,\n} from \"convex/server\";\nimport type { Effect } from \"effect\";\nimport { Layer, Match, type Schema } from \"effect\";\nimport type * as Api from \"./Api\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as Handler from \"./Handler\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\n\nexport const make = <Api_ extends Api.AnyWithPropsWithRuntime<\"Node\">>(\n  api: Api_,\n  { functionSpec, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.Any =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", () => handler as RegisteredFunction.Any),\n    Match.tag(\"Confect\", () => {\n      const { functionVisibility, functionProvenance } =\n        functionSpec as FunctionSpec.AnyConfect;\n\n      const genericFunction = Match.value(functionVisibility).pipe(\n        Match.when(\"public\", () => actionGeneric),\n        Match.when(\"internal\", () => internalActionGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        nodeActionFunction(api.databaseSchema, {\n          args: functionProvenance.args,\n          returns: functionProvenance.returns,\n          error: functionProvenance.error,\n          handler: handler as Handler.AnyConfectProvenance,\n        }),\n      );\n    }),\n    Match.exhaustive,\n  );\n\nconst nodeActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  databaseSchema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    error,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    error: Schema.Schema.AnyNoContext | undefined;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | RegisteredFunction.ActionServices<DatabaseSchema_>\n      | NodeContext.NodeContext\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    error,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(databaseSchema, ctx),\n        NodeContext.layer,\n      ),\n  });\n"],"mappings":";;;;;;;;AAeA,MAAa,QACX,KACA,EAAE,cAAc,cAEhB,MAAM,MAAM,aAAa,mBAAmB,CAAC,KAC3C,MAAM,IAAI,gBAAgB,QAAkC,EAC5D,MAAM,IAAI,iBAAiB;CACzB,MAAM,EAAE,oBAAoB,uBAC1B;AAQF,QANwB,MAAM,MAAM,mBAAmB,CAAC,KACtD,MAAM,KAAK,gBAAgB,cAAc,EACzC,MAAM,KAAK,kBAAkB,sBAAsB,EACnD,MAAM,WACP,CAGC,mBAAmB,IAAI,gBAAgB;EACrC,MAAM,mBAAmB;EACzB,SAAS,mBAAmB;EAC5B,OAAO,mBAAmB;EACjB;EACV,CAAC,CACH;EACD,EACF,MAAM,WACP;AAEH,MAAM,sBAQJ,gBACA,EACE,MACA,SACA,OACA,cAeFA,mBAAsC;CACpC;CACA;CACA;CACA;CACA,cAAc,QACZ,MAAM,SACJC,YAA+B,gBAAgB,IAAI,EACnD,YAAY,MACb;CACJ,CAAC"}
+{"version":3,"file":"RegisteredNodeFunction.js","names":["RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredNodeFunction.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport { NodeContext } from \"@effect/platform-node\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  internalActionGeneric,\n} from \"convex/server\";\nimport type { Effect } from \"effect\";\nimport { Layer, Match, type Schema } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as Handler from \"./Handler\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\n\nexport const make = (\n  databaseSchema: DatabaseSchema.AnyWithProps,\n  { functionSpec, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.Any =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", () => handler as RegisteredFunction.Any),\n    Match.tag(\"Confect\", () => {\n      const { functionVisibility, functionProvenance } =\n        functionSpec as FunctionSpec.AnyConfect;\n\n      const genericFunction = Match.value(functionVisibility).pipe(\n        Match.when(\"public\", () => actionGeneric),\n        Match.when(\"internal\", () => internalActionGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        nodeActionFunction(databaseSchema, {\n          args: functionProvenance.args,\n          returns: functionProvenance.returns,\n          error: functionProvenance.error,\n          handler: handler as Handler.AnyConfectProvenance,\n        }),\n      );\n    }),\n    Match.exhaustive,\n  );\n\nconst nodeActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  databaseSchema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    error,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    error: Schema.Schema.AnyNoContext | undefined;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | RegisteredFunction.ActionServices<DatabaseSchema_>\n      | NodeContext.NodeContext\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    error,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(databaseSchema, ctx),\n        NodeContext.layer,\n      ),\n  });\n"],"mappings":";;;;;;;;AAcA,MAAa,QACX,gBACA,EAAE,cAAc,cAEhB,MAAM,MAAM,aAAa,mBAAmB,CAAC,KAC3C,MAAM,IAAI,gBAAgB,QAAkC,EAC5D,MAAM,IAAI,iBAAiB;CACzB,MAAM,EAAE,oBAAoB,uBAC1B;AAQF,QANwB,MAAM,MAAM,mBAAmB,CAAC,KACtD,MAAM,KAAK,gBAAgB,cAAc,EACzC,MAAM,KAAK,kBAAkB,sBAAsB,EACnD,MAAM,WACP,CAGC,mBAAmB,gBAAgB;EACjC,MAAM,mBAAmB;EACzB,SAAS,mBAAmB;EAC5B,OAAO,mBAAmB;EACjB;EACV,CAAC,CACH;EACD,EACF,MAAM,WACP;AAEH,MAAM,sBAQJ,gBACA,EACE,MACA,SACA,OACA,cAeFA,mBAAsC;CACpC;CACA;CACA;CACA;CACA,cAAc,QACZ,MAAM,SACJC,YAA+B,gBAAgB,IAAI,EACnD,YAAY,MACb;CACJ,CAAC"}

package/dist/Table.d.ts

@@ -7,33 +7,44 @@ import { GenericValidator, Validator } from "convex/values";
 
 //#region src/Table.d.ts
 declare namespace Table_d_exports {
-  export { Any, AnyWithProps, Doc, Fields, Indexes, Name, SearchIndexes, SystemTables, Table, TableSchema, TableValidator, TablesRecord, TypeId, VectorIndexes, WithName, isTable, make, scheduledFunctionsTable, storageTable, systemTables };
+  export { Any, AnyWithProps, Doc, Fields, Indexes, Name, SearchIndexes, SystemTables, Table, TableSchema, TableValidator, TablesRecord, TypeId, UnnamedAny, UnnamedAnyWithProps, UnnamedTable, VectorIndexes, WithName, isTable, isUnnamedTable, make, scheduledFunctionsTable, storageTable, systemTables };
 }
 declare const TypeId = "@confect/server/Table";
 type TypeId = typeof TypeId;
 declare const isTable: (u: unknown) => u is Any;
+declare const isUnnamedTable: (u: unknown) => u is UnnamedAny;
 interface Table<Name_ extends string, TableSchema_ extends Schema.Schema.AnyNoContext, TableValidator_ extends GenericValidator = TableSchemaToTableValidator<TableSchema_>, Indexes_ extends GenericTableIndexes = {}, SearchIndexes_ extends GenericTableSearchIndexes = {}, VectorIndexes_ extends GenericTableVectorIndexes = {}> {
   readonly [TypeId]: TypeId;
+  readonly tableName: Name_;
   readonly tableDefinition: TableDefinition<TableValidator_, Indexes_, SearchIndexes_, VectorIndexes_>;
-  readonly name: Name_;
   readonly Fields: TableSchema_;
   readonly Doc: SystemFields$1.ExtendWithSystemFields<Name_, TableSchema_>;
   readonly indexes: Indexes_;
-  index<IndexName extends string, FirstFieldPath extends ExtractFieldPaths<TableValidator_>, RestFieldPaths extends ExtractFieldPaths<TableValidator_>[]>(name: IndexName, fields: [FirstFieldPath, ...RestFieldPaths]): Table<Name_, TableSchema_, TableValidator_, Expand<Indexes_ & Record<IndexName, [FirstFieldPath, ...RestFieldPaths, IndexTiebreakerField]>>, SearchIndexes_, VectorIndexes_>;
-  searchIndex<IndexName extends string, SearchField extends ExtractFieldPaths<TableValidator_>, FilterFields extends ExtractFieldPaths<TableValidator_> = never>(name: IndexName, indexConfig: Expand<SearchIndexConfig<SearchField, FilterFields>>): Table<Name_, TableSchema_, TableValidator_, Indexes_, Expand<SearchIndexes_ & Record<IndexName, {
+}
+interface Any {
+  readonly [TypeId]: TypeId;
+  readonly tableName: string;
+}
+type AnyWithProps = Table<any, Schema.Schema.AnyNoContext, GenericValidator, GenericTableIndexes, GenericTableSearchIndexes, GenericTableVectorIndexes>;
+interface UnnamedTable<TableSchema_ extends Schema.Schema.AnyNoContext, TableValidator_ extends GenericValidator = TableSchemaToTableValidator<TableSchema_>, Indexes_ extends GenericTableIndexes = {}, SearchIndexes_ extends GenericTableSearchIndexes = {}, VectorIndexes_ extends GenericTableVectorIndexes = {}> {
+  <const Name_ extends string>(tableName: Name_): Table<Name_, TableSchema_, TableValidator_, Indexes_, SearchIndexes_, VectorIndexes_>;
+  readonly [TypeId]: TypeId;
+  readonly indexes: Indexes_;
+  index<IndexName extends string, FirstFieldPath extends ExtractFieldPaths<TableValidator_>, RestFieldPaths extends ExtractFieldPaths<TableValidator_>[]>(name: IndexName, fields: [FirstFieldPath, ...RestFieldPaths]): UnnamedTable<TableSchema_, TableValidator_, Expand<Indexes_ & Record<IndexName, [FirstFieldPath, ...RestFieldPaths, IndexTiebreakerField]>>, SearchIndexes_, VectorIndexes_>;
+  searchIndex<IndexName extends string, SearchField extends ExtractFieldPaths<TableValidator_>, FilterFields extends ExtractFieldPaths<TableValidator_> = never>(name: IndexName, indexConfig: Expand<SearchIndexConfig<SearchField, FilterFields>>): UnnamedTable<TableSchema_, TableValidator_, Indexes_, Expand<SearchIndexes_ & Record<IndexName, {
     searchField: SearchField;
     filterFields: FilterFields;
   }>>, VectorIndexes_>;
-  vectorIndex<IndexName extends string, VectorField extends ExtractFieldPaths<TableValidator_>, FilterFields extends ExtractFieldPaths<TableValidator_> = never>(name: IndexName, indexConfig: Expand<VectorIndexConfig<VectorField, FilterFields>>): Table<Name_, TableSchema_, TableValidator_, Indexes_, SearchIndexes_, Expand<VectorIndexes_ & Record<IndexName, {
+  vectorIndex<IndexName extends string, VectorField extends ExtractFieldPaths<TableValidator_>, FilterFields extends ExtractFieldPaths<TableValidator_> = never>(name: IndexName, indexConfig: Expand<VectorIndexConfig<VectorField, FilterFields>>): UnnamedTable<TableSchema_, TableValidator_, Indexes_, SearchIndexes_, Expand<VectorIndexes_ & Record<IndexName, {
     vectorField: VectorField;
     dimensions: number;
     filterFields: FilterFields;
   }>>>;
 }
-interface Any {
+interface UnnamedAny {
   readonly [TypeId]: TypeId;
 }
-type AnyWithProps = Table<any, Schema.Schema.AnyNoContext, GenericValidator, GenericTableIndexes, GenericTableSearchIndexes, GenericTableVectorIndexes>;
+type UnnamedAnyWithProps = UnnamedTable<Schema.Schema.AnyNoContext, GenericValidator, GenericTableIndexes, GenericTableSearchIndexes, GenericTableVectorIndexes>;
 type Name<TableDef extends AnyWithProps> = TableDef extends Table<infer TableName, infer _TableSchema, infer _TableValidator, infer _Indexes, infer _SearchIndexes, infer _VectorIndexes> ? TableName & string : never;
 type TableSchema<TableDef extends AnyWithProps> = TableDef extends Table<infer _TableName, infer TableSchema_, infer _TableValidator, infer _Indexes, infer _SearchIndexes, infer _VectorIndexes> ? TableSchema_ : never;
 type TableValidator<TableDef extends AnyWithProps> = TableDef extends Table<infer _TableName, infer _TableSchema, infer TableValidator_, infer _Indexes, infer _SearchIndexes, infer _VectorIndexes> ? TableValidator_ : never;
@@ -43,13 +54,10 @@ type VectorIndexes<TableDef extends AnyWithProps> = TableDef extends Table<infer
 type Doc<TableDef extends AnyWithProps> = TableDef extends Table<infer TableName, infer TableSchema_, infer _TableValidator, infer _Indexes, infer _SearchIndexes, infer _VectorIndexes> ? SystemFields$1.ExtendWithSystemFields<TableName, TableSchema_> : never;
 type Fields<TableDef extends AnyWithProps> = TableDef extends Table<infer _TableName, infer TableSchema_, infer _TableValidator, infer _Indexes, infer _SearchIndexes, infer _VectorIndexes> ? TableSchema_ : never;
 type WithName<TableDef extends AnyWithProps, Name_ extends string> = TableDef extends {
-  readonly name: Name_;
+  readonly tableName: Name_;
 } ? TableDef : never;
 type TablesRecord<Tables extends AnyWithProps> = { readonly [TableName_ in Name<Tables>]: WithName<Tables, TableName_> };
-/**
- * Create a table.
- */
-declare const make: <const Name_ extends string, TableSchema_ extends Schema.Schema.AnyNoContext, TableValidator_ extends GenericValidator = TableSchemaToTableValidator<TableSchema_>, Indexes_ extends GenericTableIndexes = {}, SearchIndexes_ extends GenericTableSearchIndexes = {}, VectorIndexes_ extends GenericTableVectorIndexes = {}>(name: Name_, fields: TableSchema_) => Table<Name_, TableSchema_, TableValidator_, Indexes_, SearchIndexes_, VectorIndexes_>;
+declare const make: <const TableSchema_ extends Schema.Schema.AnyNoContext>(lazyFields: () => TableSchema_) => UnnamedTable<TableSchema_, TableSchemaToTableValidator<TableSchema_>>;
 declare const scheduledFunctionsTable: Table<"_scheduled_functions", Schema.Struct<{
   name: typeof Schema.String;
   args: Schema.Array$<typeof Schema.Any>;
@@ -70,8 +78,8 @@ declare const scheduledFunctionsTable: Table<"_scheduled_functions", Schema.Stru
     kind: Schema.Literal<["canceled"]>;
   }>]>;
 }>, convex_values0.VObject<{
-  name: string;
   args: any[];
+  name: string;
   scheduledTime: number;
   state: {
     kind: "pending";
@@ -80,15 +88,15 @@ declare const scheduledFunctionsTable: Table<"_scheduled_functions", Schema.Stru
   } | {
     kind: "success";
   } | {
-    kind: "failed";
     error: string;
+    kind: "failed";
   } | {
     kind: "canceled";
   };
   completedTime?: number;
 }, {
-  name: convex_values0.VString<string, "required">;
   args: convex_values0.VArray<any[], convex_values0.VAny<any, "required", string>, "required">;
+  name: convex_values0.VString<string, "required">;
   scheduledTime: convex_values0.VFloat64<number, "required">;
   state: convex_values0.VUnion<{
     kind: "pending";
@@ -97,8 +105,8 @@ declare const scheduledFunctionsTable: Table<"_scheduled_functions", Schema.Stru
   } | {
     kind: "success";
   } | {
-    kind: "failed";
     error: string;
+    kind: "failed";
   } | {
     kind: "canceled";
   }, [convex_values0.VObject<{
@@ -114,18 +122,18 @@ declare const scheduledFunctionsTable: Table<"_scheduled_functions", Schema.Stru
   }, {
     kind: convex_values0.VLiteral<"success", "required">;
   }, "required", "kind">, convex_values0.VObject<{
-    kind: "failed";
     error: string;
+    kind: "failed";
   }, {
-    kind: convex_values0.VLiteral<"failed", "required">;
     error: convex_values0.VString<string, "required">;
-  }, "required", "kind" | "error">, convex_values0.VObject<{
+    kind: convex_values0.VLiteral<"failed", "required">;
+  }, "required", "error" | "kind">, convex_values0.VObject<{
     kind: "canceled";
   }, {
     kind: convex_values0.VLiteral<"canceled", "required">;
-  }, "required", "kind">], "required", "kind" | "error">;
+  }, "required", "kind">], "required", "error" | "kind">;
   completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-}, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>;
+}, "required", "args" | "name" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>;
 declare const storageTable: Table<"_storage", Schema.Struct<{
   sha256: typeof Schema.String;
   size: typeof Schema.Number;
@@ -162,8 +170,8 @@ declare const systemTables: {
       kind: Schema.Literal<["canceled"]>;
     }>]>;
   }>, convex_values0.VObject<{
-    name: string;
     args: any[];
+    name: string;
     scheduledTime: number;
     state: {
       kind: "pending";
@@ -172,15 +180,15 @@ declare const systemTables: {
     } | {
       kind: "success";
     } | {
-      kind: "failed";
       error: string;
+      kind: "failed";
     } | {
       kind: "canceled";
     };
     completedTime?: number;
   }, {
-    name: convex_values0.VString<string, "required">;
     args: convex_values0.VArray<any[], convex_values0.VAny<any, "required", string>, "required">;
+    name: convex_values0.VString<string, "required">;
     scheduledTime: convex_values0.VFloat64<number, "required">;
     state: convex_values0.VUnion<{
       kind: "pending";
@@ -189,8 +197,8 @@ declare const systemTables: {
     } | {
       kind: "success";
     } | {
-      kind: "failed";
       error: string;
+      kind: "failed";
     } | {
       kind: "canceled";
     }, [convex_values0.VObject<{
@@ -206,18 +214,18 @@ declare const systemTables: {
     }, {
       kind: convex_values0.VLiteral<"success", "required">;
     }, "required", "kind">, convex_values0.VObject<{
-      kind: "failed";
       error: string;
+      kind: "failed";
     }, {
-      kind: convex_values0.VLiteral<"failed", "required">;
       error: convex_values0.VString<string, "required">;
-    }, "required", "kind" | "error">, convex_values0.VObject<{
+      kind: convex_values0.VLiteral<"failed", "required">;
+    }, "required", "error" | "kind">, convex_values0.VObject<{
       kind: "canceled";
     }, {
       kind: convex_values0.VLiteral<"canceled", "required">;
-    }, "required", "kind">], "required", "kind" | "error">;
+    }, "required", "kind">], "required", "error" | "kind">;
     completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-  }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>;
+  }, "required", "args" | "name" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>;
   readonly _storage: Table<"_storage", Schema.Struct<{
     sha256: typeof Schema.String;
     size: typeof Schema.Number;
@@ -243,5 +251,5 @@ type SystemTables = typeof scheduledFunctionsTable | typeof storageTable;
  */
 type ExtractFieldPaths<T extends Validator<any, any, any>> = T["fieldPaths"] | keyof SystemFields;
 //#endregion
-export { Any, AnyWithProps, Doc, Fields, Indexes, Name, SearchIndexes, SystemTables, Table, TableSchema, TableValidator, Table_d_exports, TablesRecord, TypeId, VectorIndexes, WithName, isTable, make, scheduledFunctionsTable, storageTable, systemTables };
+export { Any, AnyWithProps, Doc, Fields, Indexes, Name, SearchIndexes, SystemTables, Table, TableSchema, TableValidator, Table_d_exports, TablesRecord, TypeId, UnnamedAny, UnnamedAnyWithProps, UnnamedTable, VectorIndexes, WithName, isTable, isUnnamedTable, make, scheduledFunctionsTable, storageTable, systemTables };
 //# sourceMappingURL=Table.d.ts.map

package/dist/Table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Table.d.ts","names":[],"sources":["../src/Table.ts"],"mappings":"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"}
+{"version":3,"file":"Table.d.ts","names":[],"sources":["../src/Table.ts"],"mappings":"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"}