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

package/src/RequestContext.ts

@@ -1,7 +1,7 @@
-import * as Context from "./Context.js"
-import { UserProfileId } from "./ids.js"
-import * as S from "./Schema.js"
-import { NonEmptyString255 } from "./Schema.js"
+import * as Context from "./Context.ts"
+import { UserProfileId } from "./ids.ts"
+import * as S from "./Schema.ts"
+import { NonEmptyString255 } from "./Schema.ts"
 
 export const Locale = S.Literals(["en", "de"])
 export type Locale = typeof Locale.Type

package/src/Schema/Class.ts

@@ -5,9 +5,9 @@ import * as Option from "effect/Option"
 import * as S from "effect/Schema"
 import * as SchemaAST from "effect/SchemaAST"
 import * as SchemaIssue from "effect/SchemaIssue"
-import { copyOrigin } from "../utils.js"
-import { concurrencyUnbounded } from "./ext.js"
-import * as SchemaParser from "./SchemaParser.js"
+import { copyOrigin } from "../utils.ts"
+import { concurrencyUnbounded } from "./ext.ts"
+import * as SchemaParser from "./SchemaParser.ts"
 
 type ClassAnnotations<Self> = S.Annotations.Declaration<Self, readonly [any]>
 
@@ -91,7 +91,7 @@ function makeRelaxedDeclaration(
  * @example
  * ```ts
  * import * as Schema from "effect/Schema"
- * import { Class } from "./Class.js"
+ * import { Class } from "./Class.ts"
  *
  * class A extends Class<A>("A")({ a: Schema.String }) {}
  *
@@ -160,7 +160,7 @@ export const Class: <Self = never, Encoded = ExtendedSchemaNoEncoded, Brand = {}
  * @example
  * ```ts
  * import * as Schema from "effect/Schema"
- * import { TaggedClass } from "./Class.js"
+ * import { TaggedClass } from "./Class.ts"
  *
  * class Circle extends TaggedClass<Circle>()("Circle", {
  *   radius: Schema.Number

package/src/Schema/SchemaParser.ts

@@ -1,5 +1,5 @@
 import * as SchemaParser from "effect/SchemaParser"
-import { withDefaultParseOptions } from "./ext.js"
+import { withDefaultParseOptions } from "./ext.ts"
 
 export * from "effect/SchemaParser"
 

package/src/Schema/SpecialOpenApi.ts

@@ -12,14 +12,14 @@
  *
  * ```ts
  * import { OpenApi } from "effect/unstable"
- * import { deduplicateOpenApiSchemas } from "./SpecialOpenApi.js"
+ * import { deduplicateOpenApiSchemas } from "./SpecialOpenApi.ts"
  *
  * const api = HttpApi.make("myApi")
  *   .pipe(HttpApi.annotateContext(OpenApi.annotations({ transform: deduplicateOpenApiSchemas })))
  * ```
  */
 
-import { postProcessJsonSchema } from "./SpecialJsonSchema.js"
+import { postProcessJsonSchema } from "./SpecialJsonSchema.ts"
 
 /**
  * Deduplicates `components.schemas` entries in an OpenAPI spec.

package/src/Schema/email.ts

@@ -2,8 +2,8 @@ import type { Refinement } from "effect-app/Function"
 import { isValidEmail } from "effect-app/validation"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
-import type { B } from "./schema.js"
-import type { NonEmptyStringBrand } from "./strings.js"
+import type { B } from "./schema.ts"
+import type { NonEmptyStringBrand } from "./strings.ts"
 
 export interface EmailBrand extends Simplify<NonEmptyStringBrand & B.Brand<"Email">> {}
 

package/src/Schema/ext.ts

@@ -40,10 +40,10 @@ import { isDateValid } from "effect/Schema"
 import type * as SchemaAST from "effect/SchemaAST"
 import * as SchemaIssue from "effect/SchemaIssue"
 import * as SchemaTransformation from "effect/SchemaTransformation"
-import { type NonEmptyReadonlyArray } from "../Array.js"
-import * as Context from "../Context.js"
-import { extendM, typedKeysOf } from "../utils.js"
-import { type AST } from "./schema.js"
+import { type NonEmptyReadonlyArray } from "../Array.ts"
+import * as Context from "../Context.ts"
+import { extendM, typedKeysOf } from "../utils.ts"
+import { type AST } from "./schema.ts"
 
 type ProvidedCodec<Self extends S.Top, R> = S.Codec<
   Self["Type"],

package/src/Schema/moreStrings.ts

@@ -18,10 +18,10 @@ import type * as SchemaAST from "effect/SchemaAST"
 import type { Simplify } from "effect/Types"
 import { customRandom, nanoid, urlAlphabet } from "nanoid"
 import validator from "validator"
-import { type BrandedSchema, fromBrand, nominal } from "./brand.js"
-import { withDefaultMake } from "./ext.js"
-import { type B as SchemaB } from "./schema.js"
-import type { NonEmptyString255Brand, NonEmptyStringBrand } from "./strings.js"
+import { type BrandedSchema, fromBrand, nominal } from "./brand.ts"
+import { withDefaultMake } from "./ext.ts"
+import { type B as SchemaB } from "./schema.ts"
+import type { NonEmptyString255Brand, NonEmptyStringBrand } from "./strings.ts"
 
 const nonEmptyString = S.NonEmptyString
 

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 { DatabaseError, 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,

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 {

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"