@gaganref/confect-core 10.3.1-fork.3 → 10.3.1-fork.30

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,
@@ -7,12 +7,13 @@ import type {
   RegisteredMutation,
   RegisteredQuery,
 } from "convex/server";
-import type * as Schema from "effect/Schema";
+import * 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: Profile.Info<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,348 @@ export const internalNodeAction = make(
   "internal",
 );
 
+type OptionlessMiddlewareSpec = MiddlewareSpec.AnyMiddlewareSpec & {
+  readonly "~Options": never;
+};
+
+type BuilderOption =
+  | "name"
+  | "description"
+  | "args"
+  | "returns"
+  | "item"
+  | "error";
+
+/**
+ * Only a required description string may name a builder option. The builder
+ * reads it 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 as Option extends "description"
+          ? Type[Option] extends string
+            ? string extends Type[Option]
+              ? never
+              : Option
+            : Option
+          : Option
+      ]: 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 Wrapped<
+  Layers extends ReadonlyArray<Profile.Transforms>,
+  Key extends keyof Profile.Transforms,
+  Input,
+> = Layers extends readonly [
+  infer First extends Profile.Transforms,
+  ...infer Rest extends ReadonlyArray<Profile.Transforms>,
+]
+  ? Wrapped<
+      Rest,
+      Key,
+      Key extends keyof First
+        ? [Input] extends [never]
+          ? Key extends "error"
+            ? Profile.Transform<First[Key], typeof Schema.Never>
+            : never
+          : Profile.Transform<First[Key], Input>
+        : Input
+    >
+  : Input;
+
+type UserArgs<A> = [A] extends [never] ? {} : A;
+
+type ExtendedMake<
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  Fields_ extends Profile.Fields,
+  MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec,
+  Layers extends ReadonlyArray<Profile.Transforms>,
+> = Declared<
+  MiddlewareSpecs_,
+  RuntimeAndFunctionType_["functionType"],
+  <
+    const Name_ extends string,
+    const ArgsFields_ extends FunctionProvenance.ArgsFields = never,
+    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_, UserArgs<ArgsFields_>>>
+    >,
+  ) => ExtendedBuilder<
+    RuntimeAndFunctionType_,
+    "public",
+    Name_,
+    FunctionProvenance.Confect<
+      UserArgs<Wrapped<Layers, "args", ArgsFields_>>,
+      Wrapped<Layers, "returns", Returns_>,
+      Wrapped<Layers, "error", Error_>
+    >,
+    MiddlewareSpecs_,
+    Profile.Apply<Fields_, Name_, UserArgs<ArgsFields_>>
+  >
+>;
+
+type ExtendedMakePaginated<
+  Fields_ extends Profile.Fields,
+  MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec,
+  Layers extends ReadonlyArray<Profile.Transforms>,
+> = Declared<
+  MiddlewareSpecs_,
+  "query",
+  <
+    const Name_ extends string,
+    const UserArgsFields_ extends FunctionProvenance.ArgsFields = never,
+    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_, UserArgs<UserArgsFields_>>>
+    >,
+  ) => ExtendedBuilder<
+    RuntimeAndFunctionType.ConvexQuery,
+    "public",
+    Name_,
+    FunctionProvenance.ConfectPaginated<
+      UserArgs<Wrapped<Layers, "args", UserArgsFields_>>,
+      Wrapped<Layers, "item", Item_>,
+      Wrapped<Layers, "error", Error_>
+    >,
+    MiddlewareSpecs_,
+    Profile.Apply<Fields_, Name_, UserArgs<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,
+  Layers extends ReadonlyArray<Profile.Transforms> = [],
+> = {
+  readonly [Builder_ in keyof ExtendedRuntimes]: ExtendedMake<
+    ExtendedRuntimes[Builder_],
+    Fields_,
+    MiddlewareSpecs_,
+    Layers
+  >;
+} & {
+  readonly publicPaginatedQuery: ExtendedMakePaginated<
+    Fields_,
+    MiddlewareSpecs_,
+    Layers
+  >;
+  /**
+   * Require more fields and attach more middleware after this profile's.
+   */
+  extend<
+    Extension extends Profile.Fields = Profile.NoFields,
+    Transforms extends Profile.Transforms = {},
+  >(): <
+    const Middleware_ extends ReadonlyArray<
+      ProfileMiddleware<
+        Profile.Apply<Profile.Both<Fields_, Extension>, string, any>
+      >
+    >,
+  >(
+    config: {
+      readonly middleware: Middleware_ &
+        NotInherited<Middleware_, MiddlewareSpecs_>;
+    } & OptionFree<Extension["Type"]> &
+      Profile.SchemaConfig<
+        Transforms,
+        Profile.Apply<Profile.Both<Fields_, Extension>, string, any>
+      >,
+  ) => Extended<
+    Profile.Both<Fields_, Extension>,
+    MiddlewareSpecs_ | SpecOf<Middleware_[number]>,
+    [...Layers, Transforms]
+  >;
+};
+
+type RuntimeWrappers = Partial<
+  Record<
+    keyof Profile.Transforms,
+    (thunk: () => any, info: Profile.Info<any>) => () => any
+  >
+>;
+
+const makeExtended = (
+  middleware: ReadonlyArray<ProfileMiddleware<any>>,
+  schemas: ReadonlyArray<RuntimeWrappers> = [],
+): Extended<any, any> => {
+  const extended =
+    (makeSpec: (options: never) => object, paginated = false): any =>
+    ({
+      name,
+      description,
+      args,
+      returns,
+      item,
+      error,
+      ...fields
+    }: Record<string, unknown>) => {
+      const info = {
+        name,
+        ...(description === undefined ? {} : { description }),
+        args: args ?? (() => ({})),
+        fields,
+      } as Profile.Info<unknown>;
+      const thunks = {
+        args,
+        returns: paginated ? undefined : returns,
+        item: paginated ? item : undefined,
+        error,
+      } as Partial<Record<keyof Profile.Transforms, () => any>>;
+      for (const wrappers of schemas) {
+        for (const key of ["args", "returns", "item", "error"] as const) {
+          const wrap = wrappers[key];
+          const thunk =
+            thunks[key] ?? (key === "error" ? () => Schema.Never : undefined);
+          if (wrap !== undefined && thunk !== undefined) {
+            thunks[key] = () => wrap(thunk, info)();
+          }
+        }
+      }
+      return middleware.reduce(
+        (spec: any, entry) =>
+          MiddlewareSpec.isMiddlewareSpec(entry)
+            ? spec.middleware(entry)
+            : spec.middleware(entry.spec, entry.options(info)),
+        Object.assign(makeSpec({ name, description, ...thunks } as never), {
+          fields,
+        }),
+      );
+    };
+
+  return {
+    publicQuery: extended(publicQuery),
+    publicMutation: extended(publicMutation),
+    publicAction: extended(publicAction),
+    publicNodeAction: extended(publicNodeAction),
+    publicPaginatedQuery: extended(publicPaginatedQuery, true),
+    extend:
+      () =>
+      (config: {
+        middleware: ReadonlyArray<ProfileMiddleware<any>>;
+        schemas?: RuntimeWrappers;
+      }) =>
+        makeExtended(
+          [...middleware, ...config.middleware],
+          [...schemas, config.schemas ?? {}],
+        ),
+  };
+};
+
+/**
+ * Public builders whose specs require and keep `Fields_`, with `middleware`.
+ */
+export const extend =
+  <
+    Fields_ extends Profile.Fields = Profile.NoFields,
+    Transforms extends Profile.Transforms = {},
+  >() =>
+  <
+    const Middleware_ extends ReadonlyArray<
+      ProfileMiddleware<Profile.Apply<Fields_, string, any>>
+    >,
+  >(
+    config: {
+      readonly middleware: Middleware_;
+    } & OptionFree<Fields_["Type"]> &
+      Profile.SchemaConfig<Transforms, Profile.Apply<Fields_, string, any>>,
+  ) =>
+    makeExtended(config.middleware, [config.schemas ?? {}]) as Extended<
+      Fields_,
+      SpecOf<Middleware_[number]>,
+      [Transforms]
+    >;
+
 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;