effect-app 4.0.0-beta.266 → 4.0.0-beta.268

package/src/Schema/numbers.ts

@@ -13,9 +13,9 @@ import * as Effect from "effect/Effect"
 import * as S from "effect/Schema"
 import type * as SchemaAST from "effect/SchemaAST"
 import type { Simplify } from "effect/Types"
-import { type BrandedSchema, fromBrand, nominal } from "./brand.js"
-import { withDefaultMake } from "./ext.js"
-import { type B } from "./schema.js"
+import { type BrandedSchema, fromBrand, nominal } from "./brand.ts"
+import { withDefaultMake } from "./ext.ts"
+import { type B } from "./schema.ts"
 
 export interface PositiveIntBrand
   extends Simplify<B.Brand<"PositiveInt"> & NonNegativeIntBrand & PositiveNumberBrand>

package/src/Schema/phoneNumber.ts

@@ -2,10 +2,10 @@ import type { Refinement } from "effect-app/Function"
 import { isValidPhone } from "effect-app/validation"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
-import { withDefaultMake } from "./ext.js"
-import { Numbers } from "./FastCheck.js"
-import type { B } from "./schema.js"
-import type { NonEmptyStringBrand } from "./strings.js"
+import { withDefaultMake } from "./ext.ts"
+import { Numbers } from "./FastCheck.ts"
+import type { B } from "./schema.ts"
+import type { NonEmptyStringBrand } from "./strings.ts"
 
 export interface PhoneNumberBrand extends Simplify<B.Brand<"PhoneNumber"> & NonEmptyStringBrand> {}
 export type PhoneNumber = string & PhoneNumberBrand

package/src/Schema/strings.ts

@@ -2,8 +2,8 @@ import type * as B from "effect/Brand"
 import * as S from "effect/Schema"
 import type * as SchemaAST from "effect/SchemaAST"
 import type { Simplify } from "effect/Types"
-import { type BrandedSchema, fromBrand, nominal } from "./brand.js"
-import { withDefaultMake } from "./ext.js"
+import { type BrandedSchema, fromBrand, nominal } from "./brand.ts"
+import { withDefaultMake } from "./ext.ts"
 
 export type NonEmptyStringBrand = B.Brand<"NonEmptyString">
 export type NonEmptyString = string & NonEmptyStringBrand

package/src/Schema.ts

@@ -3,13 +3,13 @@ import * as SchemaAST from "effect/SchemaAST"
 import { type Simplify } from "effect/Struct"
 import type * as Tracer from "effect/Tracer"
 import type { RequiredKeys } from "effect/Types"
-import type { NonEmptyReadonlyArray } from "./Array.js"
-import { fakerArb } from "./faker.js"
-import { Email as EmailT, type Email as EmailType } from "./Schema/email.js"
-import { concurrencyUnbounded, withDefaultMake, withDefaultParseOptions } from "./Schema/ext.js"
-import { PhoneNumber as PhoneNumberT, type PhoneNumber as PhoneNumberType } from "./Schema/phoneNumber.js"
-import { type AST } from "./Schema/schema.js"
-import { copy, extendM, type StructuralCopyOrigin } from "./utils.js"
+import type { NonEmptyReadonlyArray } from "./Array.ts"
+import { fakerArb } from "./faker.ts"
+import { Email as EmailT, type Email as EmailType } from "./Schema/email.ts"
+import { concurrencyUnbounded, withDefaultMake, withDefaultParseOptions } from "./Schema/ext.ts"
+import { PhoneNumber as PhoneNumberT, type PhoneNumber as PhoneNumberType } from "./Schema/phoneNumber.ts"
+import { type AST } from "./Schema/schema.ts"
+import { copy, extendM, type StructuralCopyOrigin } from "./utils.ts"
 
 // ---------------------------------------------------------------------------
 // Default helpers — re-exported from effect/Schema
@@ -109,23 +109,23 @@ export { withDecodingDefaultTypeKey } from "effect/Schema"
 
 export * from "effect/Schema"
 
-export * from "./Schema/Class.js"
-export { Class, ErrorClass, Opaque, TaggedClass, TaggedErrorClass } from "./Schema/Class.js"
+export * from "./Schema/Class.ts"
+export { Class, ErrorClass, Opaque, TaggedClass, TaggedErrorClass } from "./Schema/Class.ts"
 
-export { fromBrand, nominal } from "./Schema/brand.js"
-export { Array, Boolean, Date, DateFromString, DateValid, Finite, Literals, NullOr, Number, ReadonlyMap, ReadonlySet } from "./Schema/ext.js"
-export { Int, NonNegativeInt } from "./Schema/numbers.js"
+export { fromBrand, nominal } from "./Schema/brand.ts"
+export { Array, Boolean, Date, DateFromString, DateValid, Finite, Literals, NullOr, Number, ReadonlyMap, ReadonlySet } from "./Schema/ext.ts"
+export { Int, NonNegativeInt } from "./Schema/numbers.ts"
 
-export * from "./Schema/email.js"
-export * from "./Schema/ext.js"
-export * from "./Schema/moreStrings.js"
-export * from "./Schema/numbers.js"
-export * from "./Schema/phoneNumber.js"
-export * from "./Schema/schema.js"
-export * from "./Schema/SpecialJsonSchema.js"
-export * from "./Schema/SpecialOpenApi.js"
-export * from "./Schema/strings.js"
-export { NonEmptyString } from "./Schema/strings.js"
+export * from "./Schema/email.ts"
+export * from "./Schema/ext.ts"
+export * from "./Schema/moreStrings.ts"
+export * from "./Schema/numbers.ts"
+export * from "./Schema/phoneNumber.ts"
+export * from "./Schema/schema.ts"
+export * from "./Schema/SpecialJsonSchema.ts"
+export * from "./Schema/SpecialOpenApi.ts"
+export * from "./Schema/strings.ts"
+export { NonEmptyString } from "./Schema/strings.ts"
 
 export * as SchemaIssue from "effect/SchemaIssue"
 
@@ -133,7 +133,7 @@ export const decodeEffectConcurrently: typeof S.decodeEffect = withDefaultParseO
 export const decodeUnknownEffectConcurrently: typeof S.decodeUnknownEffect = withDefaultParseOptions(
   S.decodeUnknownEffect
 )
-export * as SchemaParser from "./Schema/SchemaParser.js"
+export * as SchemaParser from "./Schema/SchemaParser.ts"
 
 export { Void as Void_ } from "effect/Schema"
 

package/src/Set.ts

@@ -6,7 +6,7 @@ import * as Option from "effect/Option"
 import type * as Order from "effect/Order"
 import { not } from "effect/Predicate"
 import type * as Result from "effect/Result"
-import { identity, pipe, type Predicate, type Refinement, tuple } from "./Function.js"
+import { identity, pipe, type Predicate, type Refinement, tuple } from "./Function.ts"
 
 export function find_<A, B extends A>(
   as: ReadonlySet<A>,

package/src/Store.ts

@@ -2,17 +2,17 @@
 import * as Data from "effect/Data"
 import type * as Redacted from "effect/Redacted"
 import * as Semaphore from "effect/Semaphore"
-import type { NonEmptyReadonlyArray } from "./Array.js"
-import type { OptimisticConcurrencyException } from "./client/errors.js"
-import * as Context from "./Context.js"
-import * as Effect from "./Effect.js"
-import * as Layer from "./Layer.js"
-import type { FilterResult } from "./Model/filter/filterApi.js"
-import type { FieldValues } from "./Model/filter/types.js"
-import type { FieldPath } from "./Model/filter/types/path/index.js"
-import type { AggregateIrExpression, ComputedProjectionIrExpression, RawQuery } from "./Model/query.js"
-import type * as Option from "./Option.js"
-import { NonEmptyString255 } from "./Schema.js"
+import type { NonEmptyReadonlyArray } from "./Array.ts"
+import type { DatabaseError, OptimisticConcurrencyException } from "./client/errors.ts"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
+import type { FilterResult } from "./Model/filter/filterApi.ts"
+import type { FieldValues } from "./Model/filter/types.ts"
+import type { FieldPath } from "./Model/filter/types/path/index.ts"
+import type { AggregateIrExpression, ComputedProjectionIrExpression, RawQuery } from "./Model/query.ts"
+import type * as Option from "./Option.ts"
+import { NonEmptyString255 } from "./Schema.ts"
 
 /**
  * Adapter-neutral unique-key definition for stores that support unique indexes,
@@ -99,30 +99,30 @@ export interface FilterArgs<Encoded extends FieldValues, U extends keyof Encoded
 
 export type FilterFunc<Encoded extends FieldValues> = <U extends keyof Encoded = never>(
   args: FilterArgs<Encoded, U>
-) => Effect.Effect<(U extends undefined ? Encoded : Pick<Encoded, U>)[]>
+) => Effect.Effect<(U extends undefined ? Encoded : Pick<Encoded, U>)[], DatabaseError>
 
 export interface Store<
   IdKey extends keyof Encoded,
   Encoded extends FieldValues,
   PM extends PersistenceModelType<Encoded> = PersistenceModelType<Encoded>
 > {
-  all: Effect.Effect<PM[]>
+  all: Effect.Effect<PM[], DatabaseError>
   filter: FilterFunc<Encoded>
-  find: (id: Encoded[IdKey]) => Effect.Effect<Option.Option<PM>>
-  set: (e: PM) => Effect.Effect<PM, OptimisticConcurrencyException>
+  find: (id: Encoded[IdKey]) => Effect.Effect<Option.Option<PM>, DatabaseError>
+  set: (e: PM) => Effect.Effect<PM, OptimisticConcurrencyException | DatabaseError>
   batchSet: (
     items: NonEmptyReadonlyArray<PM>
-  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
+  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException | DatabaseError>
   bulkSet: (
     items: NonEmptyReadonlyArray<PM>
-  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
-  batchRemove: (ids: NonEmptyReadonlyArray<Encoded[IdKey]>, partitionKey?: string) => Effect.Effect<void>
-  queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[]>
+  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException | DatabaseError>
+  batchRemove: (ids: NonEmptyReadonlyArray<Encoded[IdKey]>, partitionKey?: string) => Effect.Effect<void, DatabaseError>
+  queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[], DatabaseError>
   /**
    * Explicitly seed a namespace. Primary is seeded eagerly on initialization.
    * Non-primary namespaces must be seeded explicitly before use.
    */
-  seedNamespace: (namespace: string) => Effect.Effect<void>
+  seedNamespace: (namespace: string) => Effect.Effect<void, DatabaseError>
 }
 
 export class StoreMaker extends Context.Opaque<StoreMaker, {

package/src/_ext/Array.ts

@@ -1,7 +1,7 @@
 import * as Chunk from "effect-app/Chunk"
 import * as Effect from "effect-app/Effect"
 import * as Equal from "effect/Equal"
-import { NotFoundError } from "../client/errors.js"
+import { NotFoundError } from "../client/errors.ts"
 
 function getFirstBy<A, Type extends string>(
   a: Iterable<A>,

package/src/client/InvalidationKeys.ts

@@ -1,7 +1,7 @@
 import * as Ref from "effect/Ref"
-import * as Context from "../Context.js"
-import * as Effect from "../Effect.js"
-import type { InvalidationKey } from "../rpc/Invalidation.js"
+import * as Context from "../Context.ts"
+import * as Effect from "../Effect.ts"
+import type { InvalidationKey } from "../rpc/Invalidation.ts"
 
 export type { InvalidationKey }
 /** Shape of the per-mutation service that accumulates server-provided invalidation keys. */

package/src/client/apiClientFactory.ts

@@ -8,15 +8,15 @@ import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import * as Struct from "effect/Struct"
 import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/unstable/rpc"
-import * as Config from "../Config.js"
-import * as Context from "../Context.js"
-import * as Effect from "../Effect.js"
-import { HttpClient, HttpClientRequest } from "../http.js"
-import { Invalidation } from "../rpc.js"
-import type * as S from "../Schema.js"
-import { typedKeysOf, typedValuesOf } from "../utils.js"
-import type { Client, ClientForOptions, ExtractModuleName, RequestsAny } from "./clientFor.js"
-import { InvalidationKeysFromServer } from "./InvalidationKeys.js"
+import * as Config from "../Config.ts"
+import * as Context from "../Context.ts"
+import * as Effect from "../Effect.ts"
+import { HttpClient, HttpClientRequest } from "../http.ts"
+import { Invalidation } from "../rpc.ts"
+import type * as S from "../Schema.ts"
+import { typedKeysOf, typedValuesOf } from "../utils.ts"
+import type { Client, ClientForOptions, ExtractModuleName, RequestsAny } from "./clientFor.ts"
+import { InvalidationKeysFromServer } from "./InvalidationKeys.ts"
 
 export interface ApiConfig {
   url: string

package/src/client/clientFor.ts

@@ -5,9 +5,9 @@ import * as Record from "effect/Record"
 import type * as Stream from "effect/Stream"
 import type { Path } from "path-parser"
 import qs from "query-string"
-import type * as Effect from "../Effect.js"
-import type * as S from "../Schema.js"
-import { type Req } from "./apiClientFactory.js"
+import type * as Effect from "../Effect.ts"
+import type * as S from "../Schema.ts"
+import { type Req } from "./apiClientFactory.ts"
 
 export function makePathWithQuery(
   path: Path,

package/src/client/errors.ts

@@ -1,7 +1,7 @@
 /** @effect-diagnostics overriddenSchemaConstructor:skip-file */
 import { TaggedErrorClass } from "effect-app/Schema"
 import * as Cause from "effect/Cause"
-import * as S from "../Schema.js"
+import * as S from "../Schema.ts"
 
 export const tryToJson = (error: unknown) => {
   try {
@@ -157,6 +157,45 @@ export class OptimisticConcurrencyException extends TaggedErrorClass<OptimisticC
   }
 }
 
+/**
+ * Raised by a store adapter when a database operation fails for an
+ * infrastructure reason (request timeout, throttle, 5xx, dropped socket, or any
+ * non-conflict error). Distinct from `OptimisticConcurrencyException`, which is
+ * an expected etag conflict.
+ *
+ * `transient` is set by the adapter for failures worth retrying (timeout /
+ * throttle / 5xx / network). `cause` is the underlying adapter error, carried
+ * through a `Defect` schema so it serializes (an `Error` encodes to
+ * `{ name, message, cause }`) instead of breaking JSON encoding of the channel.
+ *
+ * Treated by the api/client/FE machinery like an unexpected (500-class) error.
+ */
+export class DatabaseError extends TaggedErrorClass<DatabaseError>()(
+  "DatabaseError",
+  {
+    message: S.String,
+    transient: S.Boolean,
+    cause: S.optional(S.Defect())
+  }
+) {
+  constructor(
+    args: { message?: string; transient?: boolean; cause?: unknown },
+    disableValidation?: boolean
+  ) {
+    super(
+      {
+        message: args.message ?? "Database operation failed",
+        transient: args.transient ?? false,
+        cause: args.cause
+      },
+      disableValidation as any
+    )
+  }
+  override toString() {
+    return `DatabaseError: ${this.message}`
+  }
+}
+
 const MutationOnlyErrors = [
   InvalidStateError,
   OptimisticConcurrencyException
@@ -168,7 +207,8 @@ const GeneralErrors = [
   LoginError,
   UnauthorizedError,
   ValidationError,
-  ServiceUnavailableError
+  ServiceUnavailableError,
+  DatabaseError
 ] as const
 
 export const SupportedErrors = S.Union([

package/src/client/makeClient.ts

@@ -1,9 +1,9 @@
 import type * as Exit from "effect/Exit"
 import * as SchemaTransformation from "effect/SchemaTransformation"
-import { type GetContextConfig, type RpcContextMap } from "../rpc/RpcContextMap.js"
-import * as S from "../Schema.js"
-import { AST } from "../Schema.js"
-import type { ClientForOptions } from "./clientFor.js"
+import { type GetContextConfig, type RpcContextMap } from "../rpc/RpcContextMap.ts"
+import * as S from "../Schema.ts"
+import { AST } from "../Schema.ts"
+import type { ClientForOptions } from "./clientFor.ts"
 
 /**
  * Minimal structural shape for an rpc-client middleware tag.

package/src/http/Request.ts

@@ -1,7 +1,7 @@
 import * as Option from "effect/Option"
 import type { HttpClientResponse } from "effect/unstable/http/HttpClientResponse"
-import * as Effect from "../Effect.js"
-import { HttpClient, HttpClientError, HttpClientRequest, HttpHeaders } from "./internal/lib.js"
+import * as Effect from "../Effect.ts"
+import { HttpClient, HttpClientError, HttpClientRequest, HttpHeaders } from "./internal/lib.ts"
 
 export interface ResponseWithBody<A> extends Pick<HttpClientResponse, "headers" | "status" | "remoteAddress"> {
   readonly body: A

package/src/http.ts

@@ -1 +1 @@
-export * from "./http/internal/lib.js"
+export * from "./http/internal/lib.ts"

package/src/ids.ts

@@ -2,8 +2,8 @@ import { brandedStringId, type Codec, NonEmptyString255, StringId, type StringId
 import type { B } from "effect-app/Schema/schema"
 import * as Effect from "effect/Effect"
 import type { Simplify } from "effect/Types"
-import * as S from "./Schema.js"
-import { extendM } from "./utils.js"
+import * as S from "./Schema.ts"
+import { extendM } from "./utils.ts"
 
 export interface RequestIdBrand extends StringIdBrand {
   readonly RequestId: unique symbol

package/src/index.ts

@@ -1,27 +1,27 @@
 // eslint-disable-next-line import/no-unassigned-import
-import "./builtin.js"
+import "./builtin.ts"
 
-export * as Fnc from "./Function.js"
-export * as Utils from "./utils.js"
+export * as Fnc from "./Function.ts"
+export * as Utils from "./utils.ts"
 
-export * as Array from "./Array.js"
-export * as Config from "./Config.js"
-export * as ConfigProvider from "./ConfigProvider.js"
-export * as Context from "./Context.js"
-export * as Effect from "./Effect.js"
-export * as Layer from "./Layer.js"
-export * as Model from "./Model.js"
-export * as NonEmptySet from "./NonEmptySet.js"
-export * as Set from "./Set.js"
-export * as Store from "./Store.js"
+export * as Array from "./Array.ts"
+export * as Config from "./Config.ts"
+export * as ConfigProvider from "./ConfigProvider.ts"
+export * as Context from "./Context.ts"
+export * as Effect from "./Effect.ts"
+export * as Layer from "./Layer.ts"
+export * as Model from "./Model.ts"
+export * as NonEmptySet from "./NonEmptySet.ts"
+export * as Set from "./Set.ts"
+export * as Store from "./Store.ts"
 
-export { type NonEmptyArray, type NonEmptyReadonlyArray } from "./Array.js"
+export { type NonEmptyArray, type NonEmptyReadonlyArray } from "./Array.ts"
 
 export * from "effect"
 
-export type * as Types from "./Types.js"
+export type * as Types from "./Types.ts"
 
-export * as SecretURL from "./Config/SecretURL.js"
-export * as RpcX from "./rpc.js"
-export * as S from "./Schema.js"
-export { copy } from "./utils.js"
+export * as SecretURL from "./Config/SecretURL.ts"
+export * as RpcX from "./rpc.ts"
+export * as S from "./Schema.ts"
+export { copy } from "./utils.ts"

package/src/middleware.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import * as Context from "effect-app/Context"
-import { RpcMiddleware } from "./rpc.js"
+import { RpcMiddleware } from "./rpc.ts"
 
 export class DevMode extends Context.Reference("DevMode", { defaultValue: () => false }) {}
 

package/src/rpc/Invalidation.ts

@@ -1,9 +1,9 @@
 import * as Ref from "effect/Ref"
 import { Rpc } from "effect/unstable/rpc"
-import { type ClientForOptions, makeQueryKey } from "../client/clientFor.js"
-import * as Context from "../Context.js"
-import * as Effect from "../Effect.js"
-import * as S from "../Schema.js"
+import { type ClientForOptions, makeQueryKey } from "../client/clientFor.ts"
+import * as Context from "../Context.ts"
+import * as Effect from "../Effect.ts"
+import * as S from "../Schema.ts"
 
 /**
  * Shorthand for a handler-derived invalidation key.
@@ -111,7 +111,7 @@ export type StreamFailureChunk<E> = { readonly _tag: "error"; readonly error: E;
  * ```ts
  * import { makeQueryKey } from "effect-app/client"
  * import { Invalidation } from "effect-app/rpc"
- * import * as UserRsc from "../User/index.js"  // separate module to avoid circular deps
+ * import * as UserRsc from "../User/index.ts"  // separate module to avoid circular deps
  *
  * class UpdateProfile extends Rpc.make("UpdateProfile", { ... })
  *   .annotate(Invalidation.Invalidates, [makeQueryKey(UserRsc.GetMe), makeQueryKey(UserRsc.GetProfile)]) {}
@@ -160,8 +160,8 @@ export interface InvalidationSetService {
  * ```ts
  * import * as Effect from "effect/Effect"
  * import { Invalidation } from "effect-app/rpc"
- * import * as CartRsc from "../Cart/queries.js"
- * import * as UserRsc from "../User/queries.js"
+ * import * as CartRsc from "../Cart/queries.ts"
+ * import * as UserRsc from "../User/queries.ts"
  *
  * const handler = Effect.fnUntraced(function*(req: UpdateCartRequest) {
  *   const cart = yield* CartRepo.save(req.cart)

package/src/rpc/MiddlewareMaker.ts

@@ -7,12 +7,12 @@ import type * as Scope from "effect/Scope"
 import { type Simplify } from "effect/Types"
 import { Rpc, type RpcGroup, type RpcSchema } from "effect/unstable/rpc"
 import { type HandlersFrom } from "effect/unstable/rpc/RpcGroup"
-import * as Context from "../Context.js"
-import { PreludeLogger } from "../logger.js"
-import { type TypeTestId } from "../TypeTest.js"
-import { type GetContextConfig, type RequestContextMapTagAny, type RpcContextMap } from "./RpcContextMap.js"
-import { type AddMiddleware, type AnyDynamic, type RpcDynamic, type RpcMiddlewareV4, type TagClassAny } from "./RpcMiddleware.js"
-import * as RpcMiddlewareX from "./RpcMiddleware.js"
+import * as Context from "../Context.ts"
+import { PreludeLogger } from "../logger.ts"
+import { type TypeTestId } from "../TypeTest.ts"
+import { type GetContextConfig, type RequestContextMapTagAny, type RpcContextMap } from "./RpcContextMap.ts"
+import { type AddMiddleware, type AnyDynamic, type RpcDynamic, type RpcMiddlewareV4, type TagClassAny } from "./RpcMiddleware.ts"
+import * as RpcMiddlewareX from "./RpcMiddleware.ts"
 
 // adapter for effect/rpc v3 middleware provides. (in effect-smol (v4), it's just a Service Identifier, no tags.)
 // hm?

package/src/rpc/RpcContextMap.ts

@@ -4,8 +4,8 @@
 
 import type * as S from "effect/Schema"
 import { type AnyWithProps } from "effect/unstable/rpc/Rpc"
-import * as Context from "../Context.js"
-import { type RpcDynamic } from "./RpcMiddleware.js"
+import * as Context from "../Context.ts"
+import { type RpcDynamic } from "./RpcMiddleware.ts"
 
 type Values<T extends Record<any, any>> = T[keyof T]
 

package/src/rpc/RpcMiddleware.ts

@@ -8,8 +8,8 @@ import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import { type Rpc, RpcMiddleware } from "effect/unstable/rpc"
 import { type TypeId } from "effect/unstable/rpc/RpcMiddleware"
-import type * as Context from "../Context.js"
-import { type GetEffectContext, type RpcContextMap } from "./RpcContextMap.js"
+import type * as Context from "../Context.ts"
+import { type GetEffectContext, type RpcContextMap } from "./RpcContextMap.ts"
 
 export type RpcMiddlewareV4<Provides, E, Requires> = RpcMiddleware.RpcMiddleware<Provides, E, Requires>
 

package/src/rpc.ts

@@ -1,4 +1,4 @@
-export * as Invalidation from "./rpc/Invalidation.js"
-export * as MiddlewareMaker from "./rpc/MiddlewareMaker.js"
-export * as RpcContextMap from "./rpc/RpcContextMap.js"
-export * as RpcMiddleware from "./rpc/RpcMiddleware.js"
+export * as Invalidation from "./rpc/Invalidation.ts"
+export * as MiddlewareMaker from "./rpc/MiddlewareMaker.ts"
+export * as RpcContextMap from "./rpc/RpcContextMap.ts"
+export * as RpcMiddleware from "./rpc/RpcMiddleware.ts"

package/src/runtime.ts

@@ -2,10 +2,10 @@ import * as Exit from "effect/Exit"
 import { flow } from "effect/Function"
 import * as Logger from "effect/Logger"
 import * as ManagedRuntime from "effect/ManagedRuntime"
-import { CauseException } from "./client/errors.js"
-import { type Context } from "./Context.js"
-import * as Effect from "./Effect.js"
-import * as Layer from "./Layer.js"
+import { CauseException } from "./client/errors.ts"
+import { type Context } from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
 
 export const makeAppRuntime = Effect.fnUntraced(function*<A, E>(layer: Layer.Layer<A, E>) {
   const l = layer.pipe(

package/src/setupRequest.ts

@@ -1,11 +1,11 @@
 import * as Tracer from "effect/Tracer"
 import { SqlClient } from "effect/unstable/sql"
-import * as Effect from "./Effect.js"
-import * as Layer from "./Layer.js"
-import * as Option from "./Option.js"
-import { LocaleRef, RequestContext, spanAttributes } from "./RequestContext.js"
-import { NonEmptyString255 } from "./Schema.js"
-import { ContextMapContainer, storeId } from "./Store.js"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
+import * as Option from "./Option.ts"
+import { LocaleRef, RequestContext, spanAttributes } from "./RequestContext.ts"
+import { NonEmptyString255 } from "./Schema.ts"
+import { ContextMapContainer, storeId } from "./Store.ts"
 
 const withSqlTransaction = <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   Effect.serviceOption(SqlClient.SqlClient).pipe(

package/src/toast.ts

@@ -1,7 +1,7 @@
-import * as Context from "./Context.js"
-import { accessEffectFn } from "./Context.js"
-import * as Effect from "./Effect.js"
-import * as Option from "./Option.js"
+import * as Context from "./Context.ts"
+import { accessEffectFn } from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Option from "./Option.ts"
 
 export type ToastId = string | number
 export type ToastOpts = { id?: ToastId; timeout?: number; groupId?: string; requestId?: string }

package/src/transform.ts

@@ -2,7 +2,7 @@
 import type { NonEmptyReadonlyArray } from "effect/Array"
 import * as Option from "effect/Option"
 import type { Misc, Union } from "ts-toolbelt"
-import type * as SET from "./Set.js"
+import type * as SET from "./Set.ts"
 
 // type SomeObject = {
 //   0: Option.Option<string>

package/src/utils/logger.ts

@@ -3,7 +3,7 @@
 
 import * as Effect from "effect/Effect"
 import type * as LogLevel from "effect/LogLevel"
-import * as Context from "../Context.js"
+import * as Context from "../Context.ts"
 
 type Levels = "info" | "debug" | "warn" | "error"
 

package/src/utils.ts

@@ -10,8 +10,8 @@ import * as Option from "effect/Option"
 import { isFunction } from "effect/Predicate"
 import * as Record from "effect/Record"
 import * as Result from "effect/Result"
-import { identity, pipe } from "./Function.js"
-import type { DeepMutable, Equals, Mutable } from "./Types.js"
+import { identity, pipe } from "./Function.ts"
+import type { DeepMutable, Equals, Mutable } from "./Types.ts"
 
 // codegen:start {preset: barrel, include: ./utils/*.ts, nodir: false }
 export * from "./utils/effectify.ts"

package/src/validation.ts

@@ -1,4 +1,4 @@
-import type { Predicate } from "./Function.js"
+import type { Predicate } from "./Function.ts"
 
 export const all_ = <T>(v: T, ...a: Predicate<T>[]) => !a.some((x) => !x(v))
 export const all = <T>(...a: Predicate<T>[]) => (v: T) => all_(v, ...a)
@@ -15,4 +15,4 @@ export const min = (min: number) => {
   return (v: { length: number }) => f(v.length)
 }
 
-export * from "./validation/validators.js"
+export * from "./validation/validators.ts"

package/src/withToast.ts

@@ -1,12 +1,12 @@
 import * as Cause from "effect/Cause"
 import * as Fiber from "effect/Fiber"
-import * as Context from "./Context.js"
-import * as Effect from "./Effect.js"
-import * as Layer from "./Layer.js"
-import type * as Option from "./Option.js"
-import * as S from "./Schema.js"
-import { CurrentToastId, Toast, type ToastId } from "./toast.js"
-import { wrapEffect } from "./utils.js"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
+import type * as Option from "./Option.ts"
+import * as S from "./Schema.ts"
+import { CurrentToastId, Toast, type ToastId } from "./toast.ts"
+import { wrapEffect } from "./utils.ts"
 
 export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, SucR, ErrR> {
   stableToastId?: undefined | string | ((...args: Args) => string | undefined)