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

package/src/MutationCtx.ts

@@ -1,7 +1,7 @@
 import type * as IdScope from "@confect/core/IdScope";
 import type { GenericDataModel, GenericMutationCtx } 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 MutationCtxTag<

package/src/MutationRunner.ts

@@ -4,7 +4,7 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import type * as Schema from "effect/Schema";
-import * as MutationTransactionContext from "./MutationTransactionContext";
+import * as MutationTransactionContext from "./MutationTransactionContext.js";
 
 export type Options = MutationTransactionContext.MutationOptions;
 

package/src/MutationTransactionContext.ts

@@ -7,10 +7,10 @@ import type {
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import type { Options as MutationOptions } from "./QueryTransactionContext";
+import type { Options as MutationOptions } from "./QueryTransactionContext.js";
 
 export type { TransactionLimits } from "convex/server";
-export type { Options as MutationOptions } from "./QueryTransactionContext";
+export type { Options as MutationOptions } from "./QueryTransactionContext.js";
 export type QueryOptions = AdvancedRunQueryOptions;
 
 const make = (

package/src/OfficialComponent.ts

@@ -0,0 +1,151 @@
+import * as Ref from "@confect/core/Ref";
+import type {
+  DefaultFunctionArgs,
+  GenericActionCtx,
+  GenericDataModel,
+  GenericMutationCtx,
+  GenericQueryCtx,
+} from "convex/server";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as ActionCtx from "./ActionCtx.js";
+import type * as ActionRunner from "./ActionRunner.js";
+import * as MutationCtx from "./MutationCtx.js";
+import type * as MutationRunner from "./MutationRunner.js";
+import * as QueryCtx from "./QueryCtx.js";
+import type * as QueryRunner from "./QueryRunner.js";
+
+/**
+ * An official component's method rejected. `cause` is the rejection as thrown.
+ */
+export class ComponentCallFailed extends Schema.TaggedError<ComponentCallFailed>()(
+  "ComponentCallFailed",
+  { component: Schema.String, method: Schema.String, cause: Schema.Defect() },
+) {}
+
+declare const unsupported: unique symbol;
+type Unsupported = typeof unsupported;
+type Needs<Param> = [GenericActionCtx<GenericDataModel>] extends [Param]
+  ? [GenericMutationCtx<GenericDataModel>] extends [Param]
+    ? [GenericQueryCtx<GenericDataModel>] extends [Param]
+      ? QueryRunner.QueryRunner
+      : MutationRunner.MutationRunner
+    : [GenericQueryCtx<GenericDataModel>] extends [Param]
+      ? Unsupported
+      : ActionRunner.ActionRunner
+  : Unsupported;
+
+type Method<Official> = {
+  [K in keyof Official & string]: Official[K] extends (
+    ctx: infer Ctx,
+    ...args: infer _Args
+  ) => Promise<unknown>
+    ? Needs<Ctx> extends Unsupported
+      ? never
+      : K
+    : never;
+}[keyof Official & string];
+
+type Call<F> = F extends (
+  ctx: infer Ctx,
+  ...args: infer Args
+) => Promise<infer A>
+  ? (...args: Args) => Effect.Effect<A, never, Needs<Ctx>>
+  : never;
+
+type Lifted<Official> = <M extends Method<Official>>(
+  method: M,
+  ...args: Parameters<Call<Official[M]>>
+) => ReturnType<Call<Official[M]>>;
+
+/**
+ * Lift official promise methods, deriving each capability from its ctx
+ * parameter. A rejection is caller misuse, a limit or a platform fault rather
+ * than a domain fact, so it dies.
+ */
+export const make = <Official extends object>(
+  component: string,
+  official: Official,
+): Lifted<Official> => {
+  const context = Effect.gen(function* () {
+    const action = yield* Effect.serviceOption(
+      ActionCtx.ActionCtx<GenericDataModel>(),
+    );
+    if (Option.isSome(action)) return action.value;
+    const mutation = yield* Effect.serviceOption(
+      MutationCtx.MutationCtx<GenericDataModel>(),
+    );
+    if (Option.isSome(mutation)) return mutation.value;
+    const query = yield* Effect.serviceOption(
+      QueryCtx.QueryCtx<GenericDataModel>(),
+    );
+    if (Option.isSome(query)) return query.value;
+    return yield* Effect.die(
+      new Error(`${component} called outside a Confect handler`),
+    );
+  });
+  const call = Effect.fn(`${component}.call`)(function* (
+    method: Method<Official>,
+    ...args: unknown[]
+  ) {
+    const ctx = yield* context;
+    // Method selects promise methods whose first argument accepts a native handler context.
+    const invoke = official[method] as (
+      native: typeof ctx,
+      ...args: unknown[]
+    ) => Promise<unknown>;
+    return yield* Effect.tryPromise({
+      try: () => invoke.call(official, ctx, ...args),
+      catch: (cause) => ComponentCallFailed.make({ component, method, cause }),
+    }).pipe(Effect.orDie);
+  });
+  // Confect installs the native ctx with the runner capability inferred by Needs.
+  return call as unknown as Lifted<Official>;
+};
+
+/**
+ * A function reference with its encoded arguments, ready for an official method
+ * that takes both.
+ */
+export interface Fn<R extends Ref.Any> {
+  readonly reference: Ref.FunctionReference<R>;
+  readonly args: DefaultFunctionArgs;
+}
+
+/**
+ * Encode a ref's arguments through its codecs to the wire record an official
+ * method expects.
+ */
+export const encodeCall = <R extends Ref.Any>(
+  ref: R,
+  args: NoInfer<Ref.Args<R>>,
+): Effect.Effect<Fn<R>> =>
+  Ref.encodeArgs(ref, args).pipe(
+    Effect.flatMap(
+      Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown)),
+    ),
+    Effect.map((encoded) => ({
+      reference: Ref.getFunctionReference(ref),
+      args: encoded,
+    })),
+    Effect.orDie,
+  );
+
+/**
+ * Encode a callback's real field without fabricating the rest of its arguments.
+ */
+export const encodeField = <
+  R extends Ref.AnyConfect,
+  K extends keyof Ref.Args<R> & keyof Ref.ArgsFields<R>,
+>(
+  ref: R,
+  key: K,
+  value: NoInfer<Ref.Args<R>[K]>,
+): Effect.Effect<unknown> => {
+  const fields = ref.args.fields as Record<
+    keyof Ref.ArgsFields<R>,
+    Schema.Codec<unknown, unknown>
+  >;
+  return Schema.encodeUnknownEffect(fields[key])(value).pipe(Effect.orDie);
+};

package/src/OrderedQuery.ts

@@ -10,10 +10,10 @@ import { identity, pipe } from "effect/Function";
 import type { Option } from "effect";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import * as Document from "./Document";
-import type * as TableInfo from "./TableInfo";
-import type * as Table from "./Table";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import * as Document from "./Document.js";
+import type * as TableInfo from "./TableInfo.js";
+import type * as Table from "./Table.js";
 
 type NativePaginate<TableInfo_ extends TableInfo.AnyWithProps, Doc> = (
   options: PaginationOptions,

package/src/QueryCtx.ts

@@ -1,7 +1,7 @@
 import type * as IdScope from "@confect/core/IdScope";
 import type { GenericDataModel, GenericQueryCtx } 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 QueryCtxTag<

package/src/QueryInitializer.ts

@@ -28,15 +28,15 @@ import type {
   BaseDatabaseReader,
   IndexFieldTypesForEq,
 } from "@confect/core/Types";
-import type * as DataModel from "./DataModel";
-import type * as DatabaseSchema from "./DatabaseSchema";
-import * as Document from "./Document";
-import * as OrderedQuery from "./OrderedQuery";
-import * as QueryStream from "./QueryStream";
-import type * as QueryStreamKeyLabels from "./QueryStreamKeyLabels";
-import * as QueryStreamIndexRange from "./QueryStreamIndexRange";
-import type { QueryStreamOrderDirection as OrderDirection } from "./QueryStreamOrderDirection";
-import type * as Table from "./Table";
+import type * as DataModel from "./DataModel.js";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import * as Document from "./Document.js";
+import * as OrderedQuery from "./OrderedQuery.js";
+import * as QueryStream from "./QueryStream.js";
+import type * as QueryStreamKeyLabels from "./QueryStreamKeyLabels.js";
+import * as QueryStreamIndexRange from "./QueryStreamIndexRange.js";
+import type { QueryStreamOrderDirection as OrderDirection } from "./QueryStreamOrderDirection.js";
+import type * as Table from "./Table.js";
 
 type ConvexTableInfoFor<
   DataModel_ extends DataModel.AnyWithProps,

package/src/QueryRunner.ts

@@ -4,8 +4,8 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import type * as Schema from "effect/Schema";
-import * as MutationTransactionContext from "./MutationTransactionContext";
-import * as QueryTransactionContext from "./QueryTransactionContext";
+import * as MutationTransactionContext from "./MutationTransactionContext.js";
+import * as QueryTransactionContext from "./QueryTransactionContext.js";
 
 export type Options = MutationTransactionContext.QueryOptions;
 

package/src/QueryStream.ts

@@ -55,22 +55,31 @@ import * as String from "effect/String";
 import * as Result from "effect/Result";
 import * as Tuple from "effect/Tuple";
 import type * as Types from "effect/Types";
-import * as Document from "./Document";
-import type * as Table from "./Table";
-import * as QueryStreamCursor from "./QueryStreamCursor";
-import * as QueryStreamKeyLabels from "./QueryStreamKeyLabels";
-import * as QueryStreamKeyLayout from "./QueryStreamKeyLayout";
-import * as QueryStreamOrderDirection from "./QueryStreamOrderDirection";
-import * as QueryStreamKeyValues from "./QueryStreamKeyValues";
-import * as QueryStreamIndexPrefix from "./QueryStreamIndexPrefix";
-import * as QueryStreamKey from "./QueryStreamKey";
-import * as QueryStreamKeyBounds from "./QueryStreamKeyBounds";
-import * as QueryStreamIndexRange from "./QueryStreamIndexRange";
-import * as QueryStreamPagination from "./QueryStreamPagination";
-import * as QueryStreamReadBudget from "./QueryStreamReadBudget";
+import * as Document from "./Document.js";
+import type * as Table from "./Table.js";
+import * as QueryStreamCursor from "./QueryStreamCursor.js";
+import * as QueryStreamKeyLabels from "./QueryStreamKeyLabels.js";
+import * as QueryStreamKeyLayout from "./QueryStreamKeyLayout.js";
+import * as QueryStreamOrderDirection from "./QueryStreamOrderDirection.js";
+import * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
+import * as QueryStreamIndexPrefix from "./QueryStreamIndexPrefix.js";
+import * as QueryStreamKey from "./QueryStreamKey.js";
+import * as QueryStreamKeyBounds from "./QueryStreamKeyBounds.js";
+import * as QueryStreamIndexRange from "./QueryStreamIndexRange.js";
+import * as QueryStreamPagination from "./QueryStreamPagination.js";
+import * as QueryStreamReadBudget from "./QueryStreamReadBudget.js";
 
 /**
- * A page exhausted its read budget without a safe logical continuation.
+ * Default physical row budget for `paginate` and `collect`. Supply an explicit
+ * `maximumRowsRead` to override it. Plain Effect Stream consumers use their
+ * enclosing budget and remain unlimited when none is provided.
+ *
+ * @experimental
+ */
+export const DEFAULT_MAXIMUM_ROWS_READ = 2_000;
+
+/**
+ * A query stream exhausted its read budget before its consumer could finish.
  *
  * @experimental
  */
@@ -79,7 +88,7 @@ export class ReadBudgetExceededError extends Schema.TaggedError<ReadBudgetExceed
   { rowsRead: Schema.Natural, bytesRead: Schema.Natural },
 ) {
   override get message() {
-    return "The read budget was exhausted before a safe page boundary; increase the budget or simplify the query";
+    return "The read budget was exhausted before the query stream completed; increase the budget or simplify the query";
   }
 }
 
@@ -165,14 +174,14 @@ export class MissingReversalRecipeError extends Data.TaggedError(
 export {
   EmptyInitialPageError,
   InvalidPageSizeError,
-} from "./QueryStreamPagination";
+} from "./QueryStreamPagination.js";
 
 /**
  * Invalid numeric read limits.
  *
  * @experimental
  */
-export { InvalidReadLimitError } from "./QueryStreamReadBudget";
+export { InvalidReadLimitError } from "./QueryStreamReadBudget.js";
 
 /**
  * Runtime identifier used to distinguish query streams from plain streams.
@@ -441,6 +450,89 @@ export const empty =
     return make(orderDirection);
   };
 
+/**
+ * A deferred stream's resolved direction or layout differs from its
+ * declaration. The check runs on consumption, before the resolved source is
+ * pulled.
+ *
+ * @experimental
+ */
+export class DeferredStreamMismatchError extends Data.TaggedError(
+  "DeferredStreamMismatchError",
+)<{
+  readonly expectedOrderDirection: QueryStreamOrderDirection.QueryStreamOrderDirection;
+  readonly actualOrderDirection: QueryStreamOrderDirection.QueryStreamOrderDirection;
+  readonly expectedKeyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout;
+  readonly actualKeyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout;
+}> {}
+
+/**
+ * Defer an effect that checks access or constructs a query stream until it is
+ * pulled. Supply its layout and direction without reading documents. This lets
+ * `flatMap` build and narrow an inner stream before running its checks.
+ *
+ * The effect runs afresh on each consumption, seek, or reversal. Failures and
+ * service requirements are preserved. Its stream must match the declared layout
+ * and direction, or consumption dies with `DeferredStreamMismatchError`.
+ *
+ * @experimental
+ */
+export const defer = <
+  Doc,
+  KeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels,
+  OrderDirection extends QueryStreamOrderDirection.QueryStreamOrderDirection,
+  E = never,
+  R = never,
+  E2 = never,
+  R2 = never,
+>(
+  options: {
+    readonly keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout<KeyLabels>;
+    readonly orderDirection: OrderDirection;
+  },
+  make: Effect.Effect<
+    QueryStream<Doc, KeyLabels, NoInfer<OrderDirection>, E, R>,
+    E2,
+    R2
+  >,
+): QueryStream<Doc, KeyLabels, OrderDirection, E | E2, R | R2> => {
+  const checked = Effect.map(make, (stream) => {
+    if (
+      stream.orderDirection !== options.orderDirection ||
+      !QueryStreamKeyLayout.Equivalence(stream.keyLayout, options.keyLayout)
+    ) {
+      throw new DeferredStreamMismatchError({
+        expectedOrderDirection: options.orderDirection,
+        actualOrderDirection: stream.orderDirection,
+        expectedKeyLayout: options.keyLayout,
+        actualKeyLayout: stream.keyLayout,
+      });
+    }
+    return stream;
+  });
+  return new QueryStream(
+    options.orderDirection,
+    options.keyLayout,
+    Stream.unwrap(Effect.map(checked, (stream) => stream.annotated)),
+    undefined,
+    (bounds) =>
+      defer(
+        options,
+        Effect.map(checked, (stream) => narrowByParsedBounds(stream, bounds)),
+      ),
+    () =>
+      defer(
+        {
+          ...options,
+          orderDirection: QueryStreamOrderDirection.flip(
+            options.orderDirection,
+          ),
+        },
+        Effect.map(checked, reverse),
+      ),
+  );
+};
+
 // -----------------------------------------------------------------------------
 // Constructors
 // -----------------------------------------------------------------------------
@@ -2140,6 +2232,98 @@ const narrowInMemory = <
 // Sinks
 // -----------------------------------------------------------------------------
 
+/**
+ * Read limits for `collect`. These count underlying index reads, including
+ * filtered rows and join inputs, rather than just emitted values. At either
+ * limit, one extra row may be read to distinguish completion from an overrun;
+ * it counts toward reported reads but is never emitted. This also applies at
+ * zero, so an empty stream completes under a zero budget.
+ *
+ * @experimental
+ */
+export interface CollectOptions {
+  readonly maximumRowsRead?: number;
+  readonly maximumBytesRead?: number;
+}
+
+/**
+ * Collect the whole query stream or fail with `ReadBudgetExceededError` when a
+ * read budget stops it. No partial array reaches the caller. Arbitrary I/O in
+ * callbacks is not counted. Use `paginate` for data that can grow without
+ * bound.
+ *
+ * With explicit options, each run gets a fresh budget. Without options, use the
+ * enclosing budget if present, or the default row budget.
+ *
+ * @experimental
+ */
+export const collect: {
+  (
+    options?: CollectOptions,
+  ): <Doc, KeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels, E, R>(
+    self: QueryStream<
+      Doc,
+      KeyLabels,
+      QueryStreamOrderDirection.QueryStreamOrderDirection,
+      E,
+      R
+    >,
+  ) => Effect.Effect<Array<Doc>, E | ReadBudgetExceededError, R>;
+  <Doc, KeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels, E, R>(
+    self: QueryStream<
+      Doc,
+      KeyLabels,
+      QueryStreamOrderDirection.QueryStreamOrderDirection,
+      E,
+      R
+    >,
+    options?: CollectOptions,
+  ): Effect.Effect<Array<Doc>, E | ReadBudgetExceededError, R>;
+} = dual(
+  (args) => isQueryStream(args[0]),
+  Effect.fn("QueryStream.collect")(function* <
+    Doc,
+    KeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels,
+    E,
+    R,
+  >(
+    self: QueryStream<
+      Doc,
+      KeyLabels,
+      QueryStreamOrderDirection.QueryStreamOrderDirection,
+      E,
+      R
+    >,
+    options?: CollectOptions,
+  ) {
+    const makeBudget = Schema.decodeEffect(QueryStreamReadBudget.Limits)({
+      maximumRowsRead: DEFAULT_MAXIMUM_ROWS_READ,
+      ...options,
+    }).pipe(
+      Effect.catchTag("SchemaError", (cause) =>
+        Effect.die(new QueryStreamReadBudget.InvalidReadLimitError({ cause })),
+      ),
+      Effect.flatMap(QueryStreamReadBudget.make),
+    );
+    const budget = yield* options === undefined
+      ? Effect.serviceOption(QueryStreamReadBudget.QueryStreamReadBudget).pipe(
+          Effect.flatMap(
+            Option.match({ onNone: () => makeBudget, onSome: Effect.succeed }),
+          ),
+        )
+      : makeBudget;
+    const rows = yield* Stream.runCollect(self.toStream()).pipe(
+      Effect.provideService(
+        QueryStreamReadBudget.QueryStreamReadBudget,
+        budget,
+      ),
+    );
+    if (yield* budget.isStopped)
+      return yield* new ReadBudgetExceededError(yield* budget.getReadCounts);
+    return rows;
+  }),
+);
+
 /**
  * `unique` found at least two emitted values. Narrow the query if at most one
  * value was expected, or use another consumer to handle multiple results.
@@ -2200,11 +2384,16 @@ export const unique = Effect.fn("QueryStream.unique")(
  * - `endCursor`: optional inclusive boundary returned by a previous page. Pins
  *   the page to a key range regardless of how many values it holds.
  * - `maximumRowsRead`: optional budget for physical document reads from
- *   underlying query-stream indexes, including filtered documents.
+ *   underlying query-stream indexes, including filtered documents. Defaults to
+ *   2,000; an explicit limit overrides the default.
  * - `maximumBytesRead`: optional budget charging estimated document size on every
  *   read, not Convex's exact billed bytes. The final document can take the
  *   total over the limit because its size is known only after reading it.
  *
+ * At either read limit, including zero, one extra row may be read to
+ * distinguish completion from an overrun. It is counted but never emitted. An
+ * empty stream completes under a zero budget.
+ *
  * With `numItems: 0`, an existing cursor is returned unchanged with an empty
  * page and `isDone: false`; a null cursor dies with `EmptyInitialPageError`.
  *
@@ -2396,7 +2585,7 @@ export const paginate: {
           () => QueryStreamPagination.initial<Doc>(),
           (state) => state._tag === "Reading",
           (state, { doc, keyValues }: Element<Doc>) =>
-            Effect.map(readBudget.isExhausted, (hitLimit) =>
+            Effect.map(readBudget.isStopped, (hitLimit) =>
               QueryStreamPagination.record(
                 request,
                 state,
@@ -2463,7 +2652,10 @@ export const paginate: {
       Effect.provideServiceEffect(
         effect,
         QueryStreamReadBudget.QueryStreamReadBudget,
-        Schema.decodeEffect(QueryStreamReadBudget.Limits)(options).pipe(
+        Schema.decodeEffect(QueryStreamReadBudget.Limits)({
+          maximumRowsRead: DEFAULT_MAXIMUM_ROWS_READ,
+          ...options,
+        }).pipe(
           Effect.catchTag("SchemaError", (cause) =>
             Effect.die(
               new QueryStreamReadBudget.InvalidReadLimitError({ cause }),

package/src/QueryStreamCursor.ts

@@ -1,12 +1,12 @@
 import * as Array from "effect/Array";
 import * as Effect from "effect/Effect";
-import * as QueryStreamKey from "./QueryStreamKey";
+import * as QueryStreamKey from "./QueryStreamKey.js";
 import * as SchemaIssue from "effect/SchemaIssue";
 import * as Match from "effect/Match";
 import * as Schema from "effect/Schema";
 import * as SchemaGetter from "effect/SchemaGetter";
-import * as QueryStreamKeyLayout from "./QueryStreamKeyLayout";
-import * as QueryStreamKeyValues from "./QueryStreamKeyValues";
+import * as QueryStreamKeyLayout from "./QueryStreamKeyLayout.js";
+import * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
 
 // Serialized labels are a cursor boundary representation. They include every
 // runtime position but do not preserve implicitness.

package/src/QueryStreamIndexPrefix.ts

@@ -1,8 +1,8 @@
 import * as Array from "effect/Array";
 import * as Data from "effect/Data";
 import * as Result from "effect/Result";
-import type * as QueryStreamKey from "./QueryStreamKey";
-import type * as QueryStreamKeyValues from "./QueryStreamKeyValues";
+import type * as QueryStreamKey from "./QueryStreamKey.js";
+import type * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
 
 const TypeId = "~@confect/server/QueryStreamIndexPrefix";
 

package/src/QueryStreamIndexRange.ts

@@ -11,10 +11,10 @@ import * as Match from "effect/Match";
 import * as Option from "effect/Option";
 import * as Result from "effect/Result";
 import type * as Types from "effect/Types";
-import * as QueryStreamIndexPrefix from "./QueryStreamIndexPrefix";
-import * as QueryStreamKeyBounds from "./QueryStreamKeyBounds";
-import * as QueryStreamKeyValues from "./QueryStreamKeyValues";
-import type * as QueryStreamOrderDirection from "./QueryStreamOrderDirection";
+import * as QueryStreamIndexPrefix from "./QueryStreamIndexPrefix.js";
+import * as QueryStreamKeyBounds from "./QueryStreamKeyBounds.js";
+import * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
+import type * as QueryStreamOrderDirection from "./QueryStreamOrderDirection.js";
 
 type Head<FieldPaths extends ReadonlyArray<string>> =
   FieldPaths extends readonly [infer H extends string, ...ReadonlyArray<string>]

package/src/QueryStreamKey.ts

@@ -1,8 +1,8 @@
 import * as Data from "effect/Data";
 import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
-import * as QueryStreamKeyLayout from "./QueryStreamKeyLayout";
-import type * as QueryStreamKeyValues from "./QueryStreamKeyValues";
+import * as QueryStreamKeyLayout from "./QueryStreamKeyLayout.js";
+import type * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
 
 const TypeId = "~@confect/server/QueryStreamKey";
 

package/src/QueryStreamKeyBounds.ts

@@ -3,9 +3,9 @@ import * as Data from "effect/Data";
 import * as Option from "effect/Option";
 import * as Order from "effect/Order";
 import * as Result from "effect/Result";
-import * as QueryStreamKey from "./QueryStreamKey";
-import * as QueryStreamKeyLayout from "./QueryStreamKeyLayout";
-import * as QueryStreamKeyValues from "./QueryStreamKeyValues";
+import * as QueryStreamKey from "./QueryStreamKey.js";
+import * as QueryStreamKeyLayout from "./QueryStreamKeyLayout.js";
+import * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
 
 // A bound's key may be a *prefix* of the full key: bounding by `["a"]` means
 // bounding by the whole family of keys that start with `"a"`. To compare

package/src/QueryStreamKeyLayout.ts

@@ -6,7 +6,7 @@ import * as Option from "effect/Option";
 import * as Result from "effect/Result";
 import type * as Types from "effect/Types";
 
-import * as QueryStreamKeyLabels from "./QueryStreamKeyLabels";
+import * as QueryStreamKeyLabels from "./QueryStreamKeyLabels.js";
 
 /**
  * One runtime position of a stream key. Explicit IDs and their aliases are

package/src/QueryStreamKeyValues.ts

@@ -12,7 +12,7 @@ import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import * as SchemaGetter from "effect/SchemaGetter";
 import * as SchemaIssue from "effect/SchemaIssue";
-import type * as QueryStreamOrderDirection from "./QueryStreamOrderDirection";
+import type * as QueryStreamOrderDirection from "./QueryStreamOrderDirection.js";
 
 const UNDEFINED_SENTINEL = { $undefined: true } as const;
 const KeyValue = Schema.Json.pipe(

package/src/QueryStreamPagination.ts

@@ -4,8 +4,8 @@ import * as Match from "effect/Match";
 import * as Option from "effect/Option";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import type * as QueryStreamKey from "./QueryStreamKey";
-import * as QueryStreamKeyValues from "./QueryStreamKeyValues";
+import type * as QueryStreamKey from "./QueryStreamKey.js";
+import * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
 
 const PageSize = Schema.Natural.pipe(
   Schema.brand("~@confect/server/QueryStreamPagination/PageSize"),