@gaganref/confect-core 10.3.1-fork.2 → 10.3.1-fork.21

package/src/Auth.ts

@@ -1,7 +1,7 @@
 import type { AuthProvider } from "convex/server";
 import * as Predicate from "effect/Predicate";
-import type * as App from "./App";
-import type { TypeError } from "./Types";
+import type * as App from "./App.js";
+import type { TypeError } from "./Types.js";
 
 const TypeId = "~@confect/core/Auth";
 const SiteUrlTypeId = "~@confect/core/Auth/SiteUrl";

package/src/Callback.ts

@@ -6,9 +6,9 @@ import type {
 import * as Predicate from "effect/Predicate";
 import * as Schema from "effect/Schema";
 import * as SchemaGetter from "effect/SchemaGetter";
-import * as FunctionProvenance from "./FunctionProvenance";
-import * as Ref from "./Ref";
-import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
+import * as FunctionProvenance from "./FunctionProvenance.js";
+import * as Ref from "./Ref.js";
+import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType.js";
 
 export const TypeId = "~@confect/core/Callback";
 export type TypeId = typeof TypeId;

package/src/Component.ts

@@ -7,17 +7,17 @@ import { memoize, pipe } from "effect/Function";
 import * as Match from "effect/Match";
 import * as Record from "effect/Record";
 import * as Schema from "effect/Schema";
-import type * as FunctionProvenance from "./FunctionProvenance";
-import type * as FunctionSpec from "./FunctionSpec";
-import * as GenericId from "./GenericId";
-import type * as GroupSpec from "./GroupSpec";
-import * as IdScope from "./IdScope";
-import * as Lazy from "./Lazy";
-import type * as MiddlewareSpec from "./MiddlewareSpec";
-import * as Ref from "./Ref";
-import type * as Refs from "./Refs";
-import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
-import * as Spec from "./Spec";
+import type * as FunctionProvenance from "./FunctionProvenance.js";
+import type * as FunctionSpec from "./FunctionSpec.js";
+import * as GenericId from "./GenericId.js";
+import type * as GroupSpec from "./GroupSpec.js";
+import * as IdScope from "./IdScope.js";
+import * as Lazy from "./Lazy.js";
+import type * as MiddlewareSpec from "./MiddlewareSpec.js";
+import * as Ref from "./Ref.js";
+import type * as Refs from "./Refs.js";
+import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType.js";
+import * as Spec from "./Spec.js";
 
 export class EmptyComponentScopeError extends Data.TaggedError(
   "EmptyComponentScopeError",

package/src/FunctionProvenance.ts

@@ -1,9 +1,9 @@
 import type { DefaultFunctionArgs } from "convex/server";
 import * as Data from "effect/Data";
 import * as Schema from "effect/Schema";
-import * as Lazy from "./Lazy";
-import * as PaginationOptions from "./PaginationOptions";
-import * as PaginationResult from "./PaginationResult";
+import * as Lazy from "./Lazy.js";
+import * as PaginationOptions from "./PaginationOptions.js";
+import * as PaginationResult from "./PaginationResult.js";
 
 /**
  * A field map accepted as Confect function args. Restricting each field to a

package/src/FunctionSpec.ts

@@ -1,4 +1,4 @@
-import type * as MiddlewareAttachment from "./MiddlewareAttachment";
+import type * as MiddlewareAttachment from "./MiddlewareAttachment.js";
 import type {
   DefaultFunctionArgs,
   FunctionType,
@@ -9,10 +9,11 @@ import type {
 } from "convex/server";
 import type * as Schema from "effect/Schema";
 import * as Predicate from "effect/Predicate";
-import * as FunctionProvenance from "./FunctionProvenance";
-import { validateConfectFunctionIdentifier } from "./Identifier";
-import type * as MiddlewareSpec from "./MiddlewareSpec";
-import * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
+import * as FunctionProvenance from "./FunctionProvenance.js";
+import { validateConfectFunctionIdentifier } from "./Identifier.js";
+import * as MiddlewareSpec from "./MiddlewareSpec.js";
+import type * as Profile from "./Profile.js";
+import * as RuntimeAndFunctionType from "./RuntimeAndFunctionType.js";
 
 export const TypeId = "~@confect/core/FunctionSpec";
 export type TypeId = typeof TypeId;
@@ -69,6 +70,78 @@ export interface Builder<
   >;
 }
 
+export interface DescribedBuilder<
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+  Name_ extends string,
+  FunctionProvenance_ extends FunctionProvenance.FunctionProvenance,
+  MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec = never,
+> extends Builder<
+  RuntimeAndFunctionType_,
+  FunctionVisibility_,
+  Name_,
+  FunctionProvenance_,
+  MiddlewareSpecs_
+> {
+  readonly description?: string;
+
+  middleware<MiddlewareSpec_ extends MiddlewareSpec.AnyMiddlewareSpec>(
+    middlewareSpec: MiddlewareSpec_ &
+      MiddlewareSpec.ValidateFunctionAttach<
+        MiddlewareSpec_,
+        RuntimeAndFunctionType_,
+        FunctionProvenance_,
+        MiddlewareSpecs_
+      >,
+    ...options: MiddlewareAttachment.Args<NoInfer<MiddlewareSpec_>>
+  ): DescribedBuilder<
+    RuntimeAndFunctionType_,
+    FunctionVisibility_,
+    Name_,
+    FunctionProvenance_,
+    MiddlewareSpecs_ | MiddlewareSpec_
+  >;
+}
+
+/**
+ * A spec built through {@link extend}, keeping its fields through middleware.
+ */
+export interface ExtendedBuilder<
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+  Name_ extends string,
+  FunctionProvenance_ extends FunctionProvenance.FunctionProvenance,
+  MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec,
+  Fields_,
+> extends Builder<
+  RuntimeAndFunctionType_,
+  FunctionVisibility_,
+  Name_,
+  FunctionProvenance_,
+  MiddlewareSpecs_
+> {
+  readonly description?: string;
+  readonly fields: Fields_;
+
+  middleware<MiddlewareSpec_ extends MiddlewareSpec.AnyMiddlewareSpec>(
+    middlewareSpec: MiddlewareSpec_ &
+      MiddlewareSpec.ValidateFunctionAttach<
+        MiddlewareSpec_,
+        RuntimeAndFunctionType_,
+        FunctionProvenance_,
+        MiddlewareSpecs_
+      >,
+    ...options: MiddlewareAttachment.Args<NoInfer<MiddlewareSpec_>>
+  ): ExtendedBuilder<
+    RuntimeAndFunctionType_,
+    FunctionVisibility_,
+    Name_,
+    FunctionProvenance_,
+    MiddlewareSpecs_ | MiddlewareSpec_,
+    Fields_
+  >;
+}
+
 export interface Any {
   readonly [TypeId]: TypeId;
 }
@@ -79,7 +152,10 @@ export interface AnyWithProps extends FunctionSpec<
   string,
   FunctionProvenance.FunctionProvenance,
   MiddlewareSpec.AnyMiddlewareSpec
-> {}
+> {
+  readonly description?: string;
+  readonly fields?: object;
+}
 
 export interface AnyConfect extends FunctionSpec<
   RuntimeAndFunctionType.RuntimeAndFunctionType,
@@ -326,6 +402,8 @@ const Proto = {
       runtimeAndFunctionType: this.runtimeAndFunctionType,
       functionVisibility: this.functionVisibility,
       name: this.name,
+      ...("description" in this ? { description: this.description } : {}),
+      ...("fields" in this ? { fields: this.fields } : {}),
       functionProvenance: this.functionProvenance,
       middlewareAttachments: [
         ...this.middlewareAttachments,
@@ -336,6 +414,7 @@ const Proto = {
 } satisfies ThisType<AnyWithProps>;
 
 interface Options {
+  readonly description?: string;
   readonly name: string;
   readonly args?: () => FunctionProvenance.ArgsFields;
   readonly returns: () => Schema.Codec<any, any>;
@@ -356,6 +435,7 @@ const make = <
     Error_ extends Schema.Codec<any, any> = never,
   >(options: {
     name: Name_;
+    description?: never;
     args: () => ArgsFields_;
     returns: () => Returns_;
     error?: () => Error_;
@@ -371,6 +451,7 @@ const make = <
     Error_ extends Schema.Codec<any, any> = never,
   >(options: {
     name: Name_;
+    description?: never;
     args?: never;
     returns: () => Returns_;
     error?: () => Error_;
@@ -380,13 +461,47 @@ const make = <
     Name_,
     FunctionProvenance.Confect<{}, Returns_, Error_>
   >;
-  function makeSpec({ name, args, returns, error }: Options) {
+  function makeSpec<
+    const Name_ extends string,
+    const ArgsFields_ extends FunctionProvenance.ArgsFields,
+    Returns_ extends Schema.Codec<any, any>,
+    Error_ extends Schema.Codec<any, any> = never,
+  >(options: {
+    name: Name_;
+    description?: FunctionVisibility_ extends "public" ? string : never;
+    args: () => ArgsFields_;
+    returns: () => Returns_;
+    error?: () => Error_;
+  }): DescribedBuilder<
+    RuntimeAndFunctionType_,
+    FunctionVisibility_,
+    Name_,
+    FunctionProvenance.Confect<ArgsFields_, Returns_, Error_>
+  >;
+  function makeSpec<
+    const Name_ extends string,
+    Returns_ extends Schema.Codec<any, any>,
+    Error_ extends Schema.Codec<any, any> = never,
+  >(options: {
+    name: Name_;
+    description?: FunctionVisibility_ extends "public" ? string : never;
+    args?: never;
+    returns: () => Returns_;
+    error?: () => Error_;
+  }): DescribedBuilder<
+    RuntimeAndFunctionType_,
+    FunctionVisibility_,
+    Name_,
+    FunctionProvenance.Confect<{}, Returns_, Error_>
+  >;
+  function makeSpec({ name, description, args, returns, error }: Options) {
     validateConfectFunctionIdentifier(name);
 
     return Object.assign(Object.create(Proto), {
       runtimeAndFunctionType,
       functionVisibility,
       name,
+      ...(description === undefined ? {} : { description }),
       functionProvenance:
         args === undefined
           ? FunctionProvenance.Confect(() => ({}), returns, error)
@@ -411,6 +526,7 @@ type ForbidPaginationOpts<
   : unknown;
 
 interface PaginatedOptions {
+  readonly description?: string;
   readonly name: string;
   readonly args?: () => FunctionProvenance.ArgsFields;
   readonly item: () => Schema.Codec<any, any>;
@@ -431,6 +547,7 @@ const makePaginated = <
     Error_ extends Schema.Codec<any, any> = never,
   >(options: {
     name: Name_;
+    description?: never;
     args: () => UserArgsFields_ & ForbidPaginationOpts<UserArgsFields_>;
     item: () => Item_;
     error?: () => Error_;
@@ -446,6 +563,7 @@ const makePaginated = <
     Error_ extends Schema.Codec<any, any> = never,
   >(options: {
     name: Name_;
+    description?: never;
     args?: never;
     item: () => Item_;
     error?: () => Error_;
@@ -455,13 +573,53 @@ const makePaginated = <
     Name_,
     FunctionProvenance.ConfectPaginated<{}, Item_, Error_>
   >;
-  function makeSpec({ name, args, item, error }: PaginatedOptions) {
+  function makeSpec<
+    const Name_ extends string,
+    const UserArgsFields_ extends FunctionProvenance.ArgsFields,
+    Item_ extends Schema.Codec<any, any>,
+    Error_ extends Schema.Codec<any, any> = never,
+  >(options: {
+    name: Name_;
+    description?: FunctionVisibility_ extends "public" ? string : never;
+    args: () => UserArgsFields_ & ForbidPaginationOpts<UserArgsFields_>;
+    item: () => Item_;
+    error?: () => Error_;
+  }): DescribedBuilder<
+    RuntimeAndFunctionType_,
+    FunctionVisibility_,
+    Name_,
+    FunctionProvenance.ConfectPaginated<UserArgsFields_, Item_, Error_>
+  >;
+  function makeSpec<
+    const Name_ extends string,
+    Item_ extends Schema.Codec<any, any>,
+    Error_ extends Schema.Codec<any, any> = never,
+  >(options: {
+    name: Name_;
+    description?: FunctionVisibility_ extends "public" ? string : never;
+    args?: never;
+    item: () => Item_;
+    error?: () => Error_;
+  }): DescribedBuilder<
+    RuntimeAndFunctionType_,
+    FunctionVisibility_,
+    Name_,
+    FunctionProvenance.ConfectPaginated<{}, Item_, Error_>
+  >;
+  function makeSpec({
+    name,
+    description,
+    args,
+    item,
+    error,
+  }: PaginatedOptions) {
     validateConfectFunctionIdentifier(name);
 
     return Object.assign(Object.create(Proto), {
       runtimeAndFunctionType,
       functionVisibility,
       name,
+      ...(description === undefined ? {} : { description }),
       functionProvenance:
         args === undefined
           ? FunctionProvenance.ConfectPaginated(() => ({}), item, error)
@@ -509,6 +667,254 @@ export const internalNodeAction = make(
   "internal",
 );
 
+type OptionlessMiddlewareSpec = MiddlewareSpec.AnyMiddlewareSpec & {
+  readonly "~Options": never;
+};
+
+type BuilderOption =
+  | "name"
+  | "description"
+  | "args"
+  | "returns"
+  | "item"
+  | "error";
+
+/**
+ * Refuses fields named after a builder option, which the builder would read as
+ * that option. The conditional keeps the mapped type out of a builder call's
+ * inference, which would otherwise widen the function's name to `string` when
+ * reporting the error.
+ */
+type OptionFree<Type> = [keyof Type & BuilderOption] extends [never]
+  ? unknown
+  : { readonly [Option in keyof Type & BuilderOption]: never };
+
+/**
+ * A function's fields, checked once applied, since a profile's field type can
+ * branch on the function's name.
+ */
+type CheckedFields<Type> = Type & OptionFree<Type>;
+
+type NotRepeated<
+  Middleware_,
+  Inherited extends MiddlewareSpec.AnyMiddlewareSpec,
+> = Middleware_ extends {
+  readonly key: infer Key extends MiddlewareSpec.Key<Inherited>;
+}
+  ? MiddlewareSpec.AttachmentError<`Middleware "${Key}" is already attached by this profile`>
+  : Middleware_;
+
+/**
+ * Refuses a middleware without options that an earlier layer attached, as it is
+ * attached at most once; one with options may repeat. Each member of an
+ * element's union is checked, so an array typed `(A | B)[]` is refused when
+ * either was attached.
+ */
+type NotInherited<
+  Middleware_ extends ReadonlyArray<unknown>,
+  Inherited extends MiddlewareSpec.AnyMiddlewareSpec,
+> = {
+  readonly [Index in keyof Middleware_]: NotRepeated<
+    Middleware_[Index],
+    Inherited
+  >;
+};
+
+/**
+ * A profile's middleware: a spec without options, or an attachment.
+ */
+type ProfileMiddleware<FieldsType> =
+  | OptionlessMiddlewareSpec
+  | Profile.Attachment<MiddlewareSpec.AnyMiddlewareSpec, FieldsType>;
+
+type SpecOf<Middleware_> =
+  Middleware_ extends Profile.Attachment<infer MiddlewareSpec_, any>
+    ? MiddlewareSpec_
+    : Extract<Middleware_, MiddlewareSpec.AnyMiddlewareSpec>;
+
+/**
+ * `never` when a profile middleware does not declare the function type.
+ */
+type Declared<
+  MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec,
+  FunctionType_ extends FunctionType,
+  Make,
+> = [
+  MiddlewareSpecs_ extends unknown
+    ? FunctionType_ extends MiddlewareSpec.FunctionTypes<MiddlewareSpecs_>
+      ? never
+      : MiddlewareSpecs_
+    : never,
+] extends [never]
+  ? Make
+  : never;
+
+type ExtendedMake<
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  Fields_ extends Profile.Fields,
+  MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec,
+> = Declared<
+  MiddlewareSpecs_,
+  RuntimeAndFunctionType_["functionType"],
+  <
+    const Name_ extends string,
+    const ArgsFields_ extends FunctionProvenance.ArgsFields = {},
+    Returns_ extends Schema.Codec<any, any> = never,
+    Error_ extends Schema.Codec<any, any> = never,
+  >(
+    options: {
+      readonly name: Name_;
+      readonly description?: string;
+      readonly args?: () => ArgsFields_;
+      readonly returns: () => Returns_;
+      readonly error?: () => Error_;
+    } & NoInfer<CheckedFields<Profile.Apply<Fields_, Name_, ArgsFields_>>>,
+  ) => ExtendedBuilder<
+    RuntimeAndFunctionType_,
+    "public",
+    Name_,
+    FunctionProvenance.Confect<ArgsFields_, Returns_, Error_>,
+    MiddlewareSpecs_,
+    Profile.Apply<Fields_, Name_, ArgsFields_>
+  >
+>;
+
+type ExtendedMakePaginated<
+  Fields_ extends Profile.Fields,
+  MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec,
+> = Declared<
+  MiddlewareSpecs_,
+  "query",
+  <
+    const Name_ extends string,
+    const UserArgsFields_ extends FunctionProvenance.ArgsFields = {},
+    Item_ extends Schema.Codec<any, any> = never,
+    Error_ extends Schema.Codec<any, any> = never,
+  >(
+    options: {
+      readonly name: Name_;
+      readonly description?: string;
+      readonly args?: () => UserArgsFields_ &
+        ForbidPaginationOpts<UserArgsFields_>;
+      readonly item: () => Item_;
+      readonly error?: () => Error_;
+    } & NoInfer<CheckedFields<Profile.Apply<Fields_, Name_, UserArgsFields_>>>,
+  ) => ExtendedBuilder<
+    RuntimeAndFunctionType.ConvexQuery,
+    "public",
+    Name_,
+    FunctionProvenance.ConfectPaginated<UserArgsFields_, Item_, Error_>,
+    MiddlewareSpecs_,
+    Profile.Apply<Fields_, Name_, UserArgsFields_>
+  >
+>;
+
+interface ExtendedRuntimes {
+  readonly publicQuery: RuntimeAndFunctionType.ConvexQuery;
+  readonly publicMutation: RuntimeAndFunctionType.ConvexMutation;
+  readonly publicAction: RuntimeAndFunctionType.ConvexAction;
+  readonly publicNodeAction: RuntimeAndFunctionType.NodeAction;
+}
+
+/**
+ * A profile's five public builders and its own `extend`.
+ */
+export type Extended<
+  Fields_ extends Profile.Fields,
+  MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec,
+> = {
+  readonly [Builder_ in keyof ExtendedRuntimes]: ExtendedMake<
+    ExtendedRuntimes[Builder_],
+    Fields_,
+    MiddlewareSpecs_
+  >;
+} & {
+  readonly publicPaginatedQuery: ExtendedMakePaginated<
+    Fields_,
+    MiddlewareSpecs_
+  >;
+  /**
+   * Require more fields and attach more middleware after this profile's.
+   */
+  extend<Extension extends Profile.Fields = Profile.NoFields>(): <
+    const Middleware_ extends ReadonlyArray<
+      ProfileMiddleware<
+        Profile.Apply<Profile.Both<Fields_, Extension>, string, any>
+      >
+    >,
+  >(
+    config: {
+      readonly middleware: Middleware_ &
+        NotInherited<Middleware_, MiddlewareSpecs_>;
+    } & OptionFree<Extension["Type"]>,
+  ) => Extended<
+    Profile.Both<Fields_, Extension>,
+    MiddlewareSpecs_ | SpecOf<Middleware_[number]>
+  >;
+};
+
+const makeExtended = (
+  middleware: ReadonlyArray<ProfileMiddleware<any>>,
+): Extended<any, any> => {
+  // `OptionFree` keeps option names out of the fields; this split is the
+  // runtime's fallback.
+  const extended =
+    (makeSpec: (options: never) => object): any =>
+    ({
+      name,
+      description,
+      args,
+      returns,
+      item,
+      error,
+      ...fields
+    }: Record<string, unknown>) =>
+      middleware.reduce(
+        (spec: any, entry) =>
+          MiddlewareSpec.isMiddlewareSpec(entry)
+            ? spec.middleware(entry)
+            : spec.middleware(
+                entry.spec,
+                entry.options({
+                  name,
+                  args: args ?? (() => ({})),
+                  fields,
+                } as Profile.Info<unknown>),
+              ),
+        Object.assign(
+          makeSpec({ name, description, args, returns, item, error } as never),
+          { fields },
+        ),
+      );
+
+  return {
+    publicQuery: extended(publicQuery),
+    publicMutation: extended(publicMutation),
+    publicAction: extended(publicAction),
+    publicNodeAction: extended(publicNodeAction),
+    publicPaginatedQuery: extended(publicPaginatedQuery),
+    extend: () => (config) =>
+      makeExtended([...middleware, ...config.middleware]),
+  };
+};
+
+/**
+ * Public builders whose specs require and keep `Fields_`, with `middleware`.
+ */
+export const extend =
+  <Fields_ extends Profile.Fields = Profile.NoFields>() =>
+  <
+    const Middleware_ extends ReadonlyArray<
+      ProfileMiddleware<Profile.Apply<Fields_, string, any>>
+    >,
+  >(
+    config: { readonly middleware: Middleware_ } & OptionFree<Fields_["Type"]>,
+  ) =>
+    makeExtended(config.middleware) as Extended<
+      Fields_,
+      SpecOf<Middleware_[number]>
+    >;
+
 type MatchingRegisteredFunction<
   RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
   FunctionVisibility_ extends FunctionVisibility,

package/src/GenericId.ts

@@ -5,8 +5,8 @@ import * as Match from "effect/Match";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
-import * as IdScope from "./IdScope";
-import type * as Ref from "./Ref";
+import * as IdScope from "./IdScope.js";
+import type * as Ref from "./Ref.js";
 
 const ConvexId = "~@confect/core/ConvexId";
 const ConvexIdScope = "~@confect/core/ConvexIdScope";

package/src/GroupPath.ts

@@ -1,4 +1,4 @@
-import type * as GroupSpec from "./GroupSpec";
+import type * as GroupSpec from "./GroupSpec.js";
 
 /**
  * Recursively generates paths for a group and its nested groups.

package/src/GroupSpec.ts

@@ -1,11 +1,11 @@
-import * as MiddlewareAttachment from "./MiddlewareAttachment";
+import * as MiddlewareAttachment from "./MiddlewareAttachment.js";
 import * as Predicate from "effect/Predicate";
 import * as Record from "effect/Record";
 import * as Result from "effect/Result";
-import type * as FunctionSpec from "./FunctionSpec";
-import type * as MiddlewareSpec from "./MiddlewareSpec";
-import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
-import { validateConfectFunctionIdentifier } from "./Identifier";
+import type * as FunctionSpec from "./FunctionSpec.js";
+import type * as MiddlewareSpec from "./MiddlewareSpec.js";
+import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType.js";
+import { validateConfectFunctionIdentifier } from "./Identifier.js";
 
 export const TypeId = "~@confect/core/GroupSpec";
 export type TypeId = typeof TypeId;

package/src/Http.ts

@@ -8,7 +8,7 @@ import type * as HttpApi from "effect/http-api/HttpApi";
 import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
 import type * as HttpApiGroup from "effect/http-api/HttpApiGroup";
 import * as HttpApiScalar from "effect/http-api/HttpApiScalar";
-import * as App from "./App";
+import * as App from "./App.js";
 
 const TypeId = "~@confect/core/Http";
 

package/src/Manifest.ts

@@ -1,5 +1,5 @@
 import type * as Redacted from "effect/Redacted";
-import type * as Env from "./Env";
+import type * as Env from "./Env.js";
 
 /**
  * The shape of `confect/_generated/manifest.ts`: plain data with no imports,

package/src/MiddlewareAttachment.ts

@@ -1,7 +1,7 @@
 import * as Data from "effect/Data";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import type * as MiddlewareSpec from "./MiddlewareSpec";
+import type * as MiddlewareSpec from "./MiddlewareSpec.js";
 
 export type MiddlewareAttachment<
   MiddlewareSpec_ extends MiddlewareSpec.AnyMiddlewareSpec =

package/src/MiddlewareSpec.ts

@@ -3,10 +3,10 @@ import type * as Effect from "effect/Effect";
 import * as Predicate from "effect/Predicate";
 import type * as Schema from "effect/Schema";
 import type { unhandled } from "effect/Types";
-import type * as FunctionProvenance from "./FunctionProvenance";
-import type * as FunctionSpec from "./FunctionSpec";
-import * as Lazy from "./Lazy";
-import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
+import type * as FunctionProvenance from "./FunctionProvenance.js";
+import type * as FunctionSpec from "./FunctionSpec.js";
+import * as Lazy from "./Lazy.js";
+import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType.js";
 
 export const TypeId = "~@confect/core/MiddlewareSpec";
 export type TypeId = typeof TypeId;