@gaganref/confect-server 10.3.1-fork.4 → 10.3.1-fork.41

package/dist/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,sBAAsB,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,sBAAsB,MAAM,6BAA6B,CAAC"}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@gaganref/confect-server",
-  "version": "10.3.1-fork.4",
+  "version": "10.3.1-fork.41",
   "dependencies": {
     "@effect/ai-openai-compat": "4.0.4",
     "@effect/ai-openrouter": "4.0.4"
   },
   "peerDependencies": {
-    "@confect/core": "npm:@gaganref/confect-core@10.3.1-fork.4",
-    "@effect/platform-node": "^4.0.0",
-    "convex": "^1.45.0",
-    "effect": "^4.0.4"
+    "@confect/core": "npm:@gaganref/confect-core@10.3.1-fork.41",
+    "@effect/platform-node": ">=4.0.0 <4.1.0",
+    "convex": "^1.48.0",
+    "effect": ">=4.0.4 <4.1.0"
   },
   "description": "Backend bindings to the Convex platform",
   "author": "RJ Dellecese",

package/src/ActionCall.ts

@@ -0,0 +1,82 @@
+import * as ActionCall from "@confect/core/ActionCall";
+import * as Ref from "@confect/core/Ref";
+import type { FunctionReference } from "convex/server";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as ActionCtx from "./ActionCtx.js";
+import * as ActionRunner from "./ActionRunner.js";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as DataModel from "./DataModel.js";
+import type * as Handler from "./Handler.js";
+import * as MiddlewareImpl from "./MiddlewareImpl.js";
+import * as MutationRunner from "./MutationRunner.js";
+import * as QueryRunner from "./QueryRunner.js";
+import * as Scheduler from "./Scheduler.js";
+
+export class ActionCallAlreadyUsed extends Data.TaggedError(
+  "ActionCallAlreadyUsed",
+)<{}> {}
+export class ActionCallNotUsed extends Data.TaggedError(
+  "ActionCallNotUsed",
+)<{}> {}
+export class MissingFunctionType extends Data.TaggedError(
+  "MissingFunctionType",
+)<{}> {}
+export class NestedActionNotAllowed extends Data.TaggedError(
+  "NestedActionNotAllowed",
+)<{}> {}
+
+export class SchedulingNotAllowed extends Data.TaggedError(
+  "SchedulingNotAllowed",
+)<{}> {}
+
+export const layer = <S extends DatabaseSchema.AnyWithProps>(schema: S) =>
+  MiddlewareImpl.make(schema, ActionCall.Middleware, (effect) =>
+    Effect.gen(function* () {
+      const ctx = yield* ActionCtx.ActionCtx<
+        DataModel.ToConvex<DataModel.FromSchema<S>>,
+        DatabaseSchema.Scope<S>
+      >();
+      let claimed = false;
+      const call: ActionCall.Call = <
+        Target extends Ref.AnyQuery | Ref.AnyMutation,
+      >(
+        ref: Target,
+        ...args: Ref.OptionalArgs<NoInfer<Target>>
+      ) =>
+        Effect.suspend(() => {
+          if (claimed) return Effect.die(new ActionCallAlreadyUsed());
+          claimed = true;
+          if (ref.functionType !== "query" && ref.functionType !== "mutation")
+            return Effect.die(new MissingFunctionType());
+          return Ref.runWithCodec(
+            ref,
+            (args[0] ?? {}) as Ref.Args<Target>,
+            (native, encoded) =>
+              ref.functionType === "query"
+                ? ctx.runQuery(
+                    native as FunctionReference<"query">,
+                    encoded as never,
+                  )
+                : ctx.runMutation(
+                    native as FunctionReference<"mutation">,
+                    encoded as never,
+                  ),
+          );
+        });
+      return yield* effect.pipe(
+        Effect.provideService(ActionCall.ActionCall, call),
+        Effect.updateContext(
+          (context: Context.Context<Handler.ActionServices<S>>) =>
+            Context.omit(
+              QueryRunner.QueryRunner,
+              MutationRunner.MutationRunner,
+              ActionRunner.ActionRunner,
+              ActionCtx.ActionCtx(),
+              Scheduler.Scheduler,
+            )(context),
+        ),
+      );
+    }),
+  );

package/src/ActionCtx.ts

@@ -1,7 +1,7 @@
 import type * as IdScope from "@confect/core/IdScope";
 import type { GenericActionCtx, GenericDataModel } from "convex/server";
 import * as Context from "effect/Context";
-import type * as ComponentCtx from "./ComponentCtx";
+import type * as ComponentCtx from "./ComponentCtx.js";
 import * as Layer from "effect/Layer";
 
 export type ActionCtxTag<

package/src/AiGatewayDecisionClient.ts

@@ -2,14 +2,14 @@ import * as OpenRouterClient from "@effect/ai-openrouter/OpenRouterClient";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import type * as HttpClient from "effect/http/HttpClient";
-import * as InternalAiGatewayDecisionClient from "./internal/AiGatewayDecisionClient";
-import * as AiGatewayServiceToken from "./internal/AiGatewayServiceToken";
+import * as InternalAiGatewayDecisionClient from "./internal/AiGatewayDecisionClient.js";
+import * as AiGatewayServiceToken from "./internal/AiGatewayServiceToken.js";
 
 export {
   AiGatewayDisabled,
   AiGatewayError,
   AiGatewayUnavailable,
-} from "./internal/AiGatewayServiceToken";
+} from "./internal/AiGatewayServiceToken.js";
 
 /**
  * The client configured for Convex AI gateway decisions.

package/src/AiGatewayLanguageClient.ts

@@ -2,14 +2,14 @@ import * as OpenAiClient from "@effect/ai-openai-compat/OpenAiClient";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import type * as HttpClient from "effect/http/HttpClient";
-import * as InternalAiGatewayLanguageClient from "./internal/AiGatewayLanguageClient";
-import * as AiGatewayServiceToken from "./internal/AiGatewayServiceToken";
+import * as InternalAiGatewayLanguageClient from "./internal/AiGatewayLanguageClient.js";
+import * as AiGatewayServiceToken from "./internal/AiGatewayServiceToken.js";
 
 export {
   AiGatewayDisabled,
   AiGatewayError,
   AiGatewayUnavailable,
-} from "./internal/AiGatewayServiceToken";
+} from "./internal/AiGatewayServiceToken.js";
 
 /**
  * The client service configured for Convex AI gateway language models.

package/src/Auth.ts

@@ -1,4 +1,8 @@
-import type { Auth as ConvexAuth } from "convex/server";
+import type {
+  Auth as ConvexAuth,
+  MutationAuth as ConvexMutationAuth,
+  SignJwtOptions,
+} from "convex/server";
 import * as Context from "effect/Context";
 import { flow } from "effect/Function";
 import * as Effect from "effect/Effect";
@@ -6,7 +10,7 @@ import * as Layer from "effect/Layer";
 import * as Match from "effect/Match";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
-import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
 
 const make = (auth: ConvexAuth) => ({
   getUserIdentity: Effect.promise(() => auth.getUserIdentity()).pipe(
@@ -28,6 +32,24 @@ export class Auth extends Context.Service<Auth, ReturnType<typeof make>>()(
 
 export const layer = (auth: ConvexAuth) => Layer.succeed(Auth, make(auth));
 
+/**
+ * Mutation-only deployment signing, available in applications and components.
+ */
+export class MutationAuth extends Context.Service<
+  MutationAuth,
+  {
+    readonly signJwt: (options: SignJwtOptions) => Effect.Effect<string>;
+  }
+>()("@confect/server/Auth/MutationAuth") {}
+
+/**
+ * SDK rejections remain defects, as with the other native auth operations.
+ */
+export const mutationLayer = (auth: ConvexMutationAuth) =>
+  Layer.succeed(MutationAuth, {
+    signJwt: (options) => Effect.promise(() => auth.signJwt(options)),
+  });
+
 export type ForTarget<Target extends DatabaseSchema.Target> =
   Target["kind"] extends "component" ? never : Auth;
 

package/src/ComponentCtx.ts

@@ -17,7 +17,7 @@ import type {
   VectorIndexNames,
   VectorSearchQuery,
 } from "convex/server";
-import type { PatchValue } from "./DatabaseWriter";
+import type { PatchValue } from "./DatabaseWriter.js";
 
 /**
  * Distinguishes raw component services from structurally compatible app ctxs.

package/src/ConvexFunctionDefinitions.ts

@@ -3,14 +3,14 @@ import * as Match from "effect/Match";
 import * as Record from "effect/Record";
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import type * as FunctionSpec from "@confect/core/FunctionSpec";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import type * as GroupImpl from "./GroupImpl";
-import * as GroupRegistry from "./GroupRegistry";
-import * as FunctionRegistryItem from "./FunctionRegistryItem";
-import * as RegisteredConvexFunction from "./RegisteredConvexFunction";
-import type * as RegisteredFunctions from "./RegisteredFunctions";
-import * as ResolvedMiddleware from "./ResolvedMiddleware";
-import { mapLeaves } from "./internal/utils";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as GroupImpl from "./GroupImpl.js";
+import * as GroupRegistry from "./GroupRegistry.js";
+import * as FunctionRegistryItem from "./FunctionRegistryItem.js";
+import * as RegisteredConvexFunction from "./RegisteredConvexFunction.js";
+import type * as RegisteredFunctions from "./RegisteredFunctions.js";
+import * as ResolvedMiddleware from "./ResolvedMiddleware.js";
+import { mapLeaves } from "./internal/utils.js";
 
 export interface Definitions {
   readonly [name: string]: RegisteredConvexFunction.Definition | Definitions;
@@ -63,7 +63,7 @@ export const buildForGroup = <Group extends GroupSpec.AnyWithProps>(
   databaseSchema: DatabaseSchema.AnyWithProps,
   groupLayer: Layer.Layer<GroupImpl.GroupImpl<"Finalized">>,
 ): ForGroup<Group> => {
-  const { functionRegistryItems, middlewareRegistryItems } =
+  const { functionRegistryItems, middlewareRegistryItems, observability } =
     GroupRegistry.make(groupLayer);
   return mapLeaves<
     FunctionRegistryItem.AnyWithProps,
@@ -83,6 +83,7 @@ export const buildForGroup = <Group extends GroupSpec.AnyWithProps>(
             databaseSchema,
             confect,
             ResolvedMiddleware.resolve(confect, middlewareRegistryItems),
+            observability,
           ),
         ),
         Match.exhaustive,

package/src/CronJobs.ts

@@ -11,7 +11,7 @@ import * as Option from "effect/Option";
 import * as Order from "effect/Order";
 import * as Predicate from "effect/Predicate";
 import * as Record from "effect/Record";
-import type * as CronJob from "./CronJob";
+import type * as CronJob from "./CronJob.js";
 
 export const TypeId = "~@confect/server/CronJobs";
 export type TypeId = typeof TypeId;

package/src/DataModel.ts

@@ -1,6 +1,6 @@
-import type * as DatabaseSchema from "./DatabaseSchema";
-import type * as Table from "./Table";
-import type * as TableInfo from "./TableInfo";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as Table from "./Table.js";
+import type * as TableInfo from "./TableInfo.js";
 import type * as GenericId from "@confect/core/GenericId";
 
 export declare const TypeId: "~@confect/server/DataModel";

package/src/DatabaseReader.ts

@@ -2,10 +2,10 @@ import type { GenericDatabaseReader } from "convex/server";
 import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
 import type { BaseDatabaseReader } from "@confect/core/Types";
-import * as DatabaseSchema from "./DatabaseSchema";
-import type * as DataModel from "./DataModel";
-import * as QueryInitializer from "./QueryInitializer";
-import * as Table from "./Table";
+import * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as DataModel from "./DataModel.js";
+import * as QueryInitializer from "./QueryInitializer.js";
+import * as Table from "./Table.js";
 
 type IncludedTables<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> =
   | DatabaseSchema.Tables<DatabaseSchema_>

package/src/DatabaseSchema.ts

@@ -3,7 +3,7 @@ import * as Data from "effect/Data";
 import * as Result from "effect/Result";
 import * as Predicate from "effect/Predicate";
 import * as Record from "effect/Record";
-import type * as Table from "./Table";
+import type * as Table from "./Table.js";
 
 export class EmptyDatabaseScopeError extends Data.TaggedError(
   "EmptyDatabaseScopeError",

package/src/DatabaseWriter.ts

@@ -10,13 +10,16 @@ import { pipe } from "effect/Function";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
 import * as Record from "effect/Record";
-import * as DatabaseSchema from "./DatabaseSchema";
-import type * as DataModel from "./DataModel";
-import type { DocumentByName as DocumentByName_ } from "./DataModel";
-import * as Document from "./Document";
-import * as QueryInitializer from "./QueryInitializer";
-import type * as Table from "./Table";
+import * as Result from "effect/Result";
+import * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as DataModel from "./DataModel.js";
+import type { DocumentByName as DocumentByName_ } from "./DataModel.js";
+import * as Document from "./Document.js";
+import * as DocumentPatch from "./internal/DocumentPatch.js";
+import * as QueryInitializer from "./QueryInitializer.js";
+import type * as Table from "./Table.js";
 
 /**
  * The argument accepted by `patch`: like `Partial<Doc>` without system fields,
@@ -97,11 +100,54 @@ export type DatabaseWriterTag<
   DatabaseWriterService<DatabaseSchema_, Docs>
 >;
 
+/**
+ * Decoded documents surrounding one successful write.
+ */
+export type Change<S extends DatabaseSchema.AnyWithProps> = {
+  [Name in DataModel.TableNames<DataModel.FromSchema<S>>]: {
+    readonly tableName: Name;
+  } & (
+    | {
+        readonly operation: "insert";
+        readonly oldDoc: null;
+        readonly newDoc: DocumentByName_<DataModel.FromSchema<S>, Name>;
+      }
+    | {
+        readonly operation: "update";
+        readonly oldDoc: DocumentByName_<DataModel.FromSchema<S>, Name>;
+        readonly newDoc: DocumentByName_<DataModel.FromSchema<S>, Name>;
+      }
+    | {
+        readonly operation: "delete";
+        readonly oldDoc: DocumentByName_<DataModel.FromSchema<S>, Name>;
+        readonly newDoc: null;
+      }
+  );
+}[DataModel.TableNames<DataModel.FromSchema<S>>];
+
+/**
+ * Runs after the write, in its transaction. A defect aborts the mutation.
+ *
+ * Only writes through this writer are observed. Raw `ctx.db`, `MutationCtx`
+ * writes and a second `DatabaseWriter.make` bypass the hook, so a host that
+ * relies on it keeps raw writers out of its functions. Component writers and
+ * nested `runMutation` calls each need their own hook installation.
+ *
+ * Concurrent writes to one document (for example under `Effect.all`) can
+ * interleave the read-write-read steps. Await them sequentially when the hook
+ * needs exact per-write snapshots. The writer takes no lock, because a hook
+ * that writes through the same writer would deadlock under one.
+ */
+export type Hook<S extends DatabaseSchema.AnyWithProps> = (
+  change: Change<S>,
+) => Effect.Effect<void>;
+
 export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
   databaseSchema: DatabaseSchema_,
   convexDatabaseWriter: GenericDatabaseWriter<
     DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
   >,
+  hook?: Hook<DatabaseSchema_>,
 ): DatabaseWriterService<DatabaseSchema_> => {
   type DataModel_ = DataModel.FromSchema<DatabaseSchema_>;
 
@@ -131,38 +177,108 @@ export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
       return id as unknown as DataModel.Id<DataModel_, TableName>;
     });
 
+    // A codec whose encoding spans fields cannot encode a patch on its own, so
+    // the patch is merged into the decoded document and the result replaces it.
+    const replacePatched = (
+      id: DataModel.Id<DataModel_, TableName>,
+      patchedValues: PatchValue<
+        Document.WithoutSystemFields<DocumentByName_<DataModel_, TableName>>
+      >,
+    ) =>
+      Effect.gen(function* () {
+        const originalDecodedDoc = yield* QueryInitializer.getById<
+          Table.AnyWithProps,
+          TableName
+        >(
+          convexDatabaseWriter as any,
+          tableDef,
+        )(id as unknown as GenericId<TableName>);
+
+        const updatedEncodedDoc = yield* pipe(
+          patchedValues,
+          Record.reduce(originalDecodedDoc, (acc, value, key) =>
+            value === undefined
+              ? Record.remove(acc, key)
+              : Record.set(acc, key, value),
+          ),
+          Document.encode(tableDef),
+        );
+
+        yield* Effect.promise(() =>
+          convexDatabaseWriter.replace(
+            id as unknown as GenericId<TableName>,
+            updatedEncodedDoc as Expand<
+              BetterOmit<
+                DocumentByName<DataModel.ToConvex<DataModel_>, TableName>,
+                "_creationTime" | "_id"
+              >
+            >,
+          ),
+        );
+      });
+
     const patch = Effect.fn("DatabaseWriter.patch")(function* (
       id: DataModel.Id<DataModel_, TableName>,
       patchedValues: PatchValue<
         Document.WithoutSystemFields<DocumentByName_<DataModel_, TableName>>
       >,
     ) {
-      const originalDecodedDoc = yield* QueryInitializer.getById<
-        Table.AnyWithProps,
-        TableName
-      >(
-        convexDatabaseWriter as any,
-        tableDef,
-      )(id as unknown as GenericId<TableName>);
+      const encodePatch = DocumentPatch.encoder(tableDef);
+      if (encodePatch === undefined) {
+        return yield* replacePatched(id, patchedValues);
+      }
 
-      const updatedEncodedDoc = yield* pipe(
-        patchedValues,
-        Record.reduce(originalDecodedDoc, (acc, value, key) =>
-          value === undefined
-            ? Record.remove(acc, key)
-            : Record.set(acc, key, value),
+      const storedDoc = yield* pipe(
+        Effect.promise(() =>
+          convexDatabaseWriter.get(id as unknown as GenericId<TableName>),
+        ),
+        Effect.andThen((value) =>
+          Effect.fromResult(
+            Result.fromNullishOr(
+              value,
+              () =>
+                new QueryInitializer.GetByIdFailure({
+                  tableName,
+                  id,
+                }),
+            ),
+          ),
+        ),
+      );
+      // The patch must encode and the patched document must decode. When
+      // either fails, the stored document decides whose fault that is.
+      const encodedPatch = yield* pipe(
+        encodePatch(patchedValues),
+        Effect.mapError(({ message }) => message),
+        Effect.tap((delta) =>
+          pipe(
+            { ...storedDoc, ...delta },
+            Record.filter(Predicate.isNotUndefined),
+            Document.decode(tableDef),
+            Effect.mapError(({ parseError }) => parseError),
+          ),
+        ),
+        Effect.catch((parseError) =>
+          pipe(
+            Document.decode(storedDoc, tableDef),
+            Effect.andThen(
+              Effect.fail(
+                new Document.DocumentEncodeError({
+                  tableName,
+                  id,
+                  parseError,
+                }),
+              ),
+            ),
+          ),
         ),
-        Document.encode(tableDef),
       );
 
       yield* Effect.promise(() =>
-        convexDatabaseWriter.replace(
+        convexDatabaseWriter.patch(
           id as unknown as GenericId<TableName>,
-          updatedEncodedDoc as Expand<
-            BetterOmit<
-              DocumentByName<DataModel.ToConvex<DataModel_>, TableName>,
-              "_creationTime" | "_id"
-            >
+          encodedPatch as Partial<
+            DocumentByName<DataModel.ToConvex<DataModel_>, TableName>
           >,
         ),
       );
@@ -194,11 +310,52 @@ export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
         convexDatabaseWriter.delete(id as unknown as GenericId<TableName>),
       );
 
+    const accessor = { insert, patch, replace, delete: delete_ };
+    if (hook === undefined) return accessor;
+
+    const read = (id: DataModel.Id<DataModel_, TableName>) =>
+      QueryInitializer.getById<Table.AnyWithProps, TableName>(
+        convexDatabaseWriter as any,
+        tableDef,
+      )(id as unknown as GenericId<TableName>);
+    const notify = (
+      operation: "insert" | "update" | "delete",
+      oldDoc: unknown,
+      newDoc: unknown,
+    ) =>
+      hook({ tableName, operation, oldDoc, newDoc } as Change<DatabaseSchema_>);
+    const update =
+      <A extends ReadonlyArray<unknown>, E, BeforeError>(
+        before: (
+          id: DataModel.Id<DataModel_, TableName>,
+        ) => Effect.Effect<unknown, BeforeError>,
+        write: (
+          id: DataModel.Id<DataModel_, TableName>,
+          ...args: A
+        ) => Effect.Effect<void, E>,
+      ) =>
+      (id: DataModel.Id<DataModel_, TableName>, ...args: A) =>
+        Effect.gen(function* () {
+          const oldDoc = yield* before(id);
+          yield* write(id, ...args);
+          yield* notify("update", oldDoc, yield* read(id).pipe(Effect.orDie));
+        });
+
     return {
-      insert,
-      patch,
-      replace,
-      delete: delete_,
+      insert: (document: Parameters<typeof insert>[0]) =>
+        Effect.gen(function* () {
+          const id = yield* insert(document);
+          yield* notify("insert", null, yield* read(id).pipe(Effect.orDie));
+          return id;
+        }),
+      patch: update(read, patch),
+      replace: update((id) => read(id).pipe(Effect.orDie), replace),
+      delete: (id: DataModel.Id<DataModel_, TableName>) =>
+        Effect.gen(function* () {
+          const oldDoc = yield* read(id).pipe(Effect.orDie);
+          yield* delete_(id);
+          yield* notify("delete", oldDoc, null);
+        }),
     };
   };
 
@@ -225,8 +382,9 @@ export const layer = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
   convexDatabaseWriter: GenericDatabaseWriter<
     DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
   >,
+  hook?: Hook<DatabaseSchema_>,
 ) =>
   Layer.succeed(
     DatabaseWriter<DatabaseSchema_>(),
-    make(databaseSchema, convexDatabaseWriter),
+    make(databaseSchema, convexDatabaseWriter, hook),
   );

package/src/Document.ts

@@ -4,10 +4,10 @@ import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Schema from "effect/Schema";
 import type { ReadonlyRecord } from "effect/Record";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import type * as DataModel from "./DataModel";
-import type * as TableInfo from "./TableInfo";
-import type * as Table from "./Table";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as DataModel from "./DataModel.js";
+import type * as TableInfo from "./TableInfo.js";
+import type * as Table from "./Table.js";
 
 export type Document<
   Schema_ extends DatabaseSchema.AnyWithProps,

package/src/FunctionImpl.ts

@@ -1,15 +1,15 @@
 import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import type * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
-import * as Registry from "./Registry";
+import * as Registry from "./Registry.js";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Ref from "effect/Ref";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import type * as Handler from "./Handler";
-import { setNestedProperty } from "./internal/utils";
-import * as FunctionRegistryItem from "./FunctionRegistryItem";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as Handler from "./Handler.js";
+import { setNestedProperty } from "./internal/utils.js";
+import * as FunctionRegistryItem from "./FunctionRegistryItem.js";
 
 export interface FunctionImpl<Name_ extends string> {
   readonly name: Name_;

package/src/FunctionRegistryItem.ts

@@ -5,7 +5,7 @@ import type { FunctionType, FunctionVisibility } from "convex/server";
 import * as Match from "effect/Match";
 import * as Predicate from "effect/Predicate";
 import type * as Schema from "effect/Schema";
-import type * as Handler from "./Handler";
+import type * as Handler from "./Handler.js";
 
 export const TypeId = "~@confect/server/FunctionRegistryItem";
 export type TypeId = typeof TypeId;