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

package/src/Model/query/new-kid-interpreter.ts

@@ -3,15 +3,15 @@
 import { identity, pipe } from "effect/Function"
 import * as Match from "effect/Match"
 import * as SchemaAST from "effect/SchemaAST"
-import * as Array from "../../Array.js"
-import { toNonEmptyArray } from "../../Array.js"
-import * as Option from "../../Option.js"
-import * as S from "../../Schema.js"
-import { dropUndefinedT } from "../../utils.js"
-import type { FilterResult } from "../filter/filterApi.js"
-import type { FieldValues } from "../filter/types.js"
-import type { FieldPath } from "../filter/types/path/eager.js"
-import { make, type Q, type QAll } from "../query/dsl.js"
+import * as Array from "../../Array.ts"
+import { toNonEmptyArray } from "../../Array.ts"
+import * as Option from "../../Option.ts"
+import * as S from "../../Schema.ts"
+import { dropUndefinedT } from "../../utils.ts"
+import type { FilterResult } from "../filter/filterApi.ts"
+import type { FieldValues } from "../filter/types.ts"
+import type { FieldPath } from "../filter/types/path/eager.ts"
+import { make, type Q, type QAll } from "../query/dsl.ts"
 
 export type AggregateIrExpression =
   | { readonly _tag: "agg-count" }

package/src/Model/query.ts

@@ -1,5 +1,5 @@
-export * from "./query/dsl.js"
-export * from "./query/new-kid-interpreter.js"
+export * from "./query/dsl.ts"
+export * from "./query/new-kid-interpreter.ts"
 
 export interface RawQuery<Encoded, Out> {
   cosmos: (vals: { name: string }) => {

package/src/Model.ts

@@ -1,4 +1,4 @@
-export * from "./Model/dsl.js"
-export * as Q from "./Model/query.js"
-export { makeRepo } from "./Model/Repository.js"
-export { type RegisteredRepository, RepositoryRegistry, RepositoryRegistryLive } from "./Model/Repository.js"
+export * from "./Model/dsl.ts"
+export * as Q from "./Model/query.ts"
+export { makeRepo } from "./Model/Repository.ts"
+export { type RegisteredRepository, RepositoryRegistry, RepositoryRegistryLive } from "./Model/Repository.ts"

package/src/NonEmptySet.ts

@@ -2,8 +2,8 @@ import type { NonEmptyReadonlyArray } from "effect/Array"
 import type * as Equivalence from "effect/Equivalence"
 import * as Option from "effect/Option"
 import type * as Order from "effect/Order"
-import { flow, pipe } from "./Function.js"
-import { filter_, filterMap, filterMap_, fromArray as fromArrayOriginal, insert as insertOriginal, insert_ as insert_Original, map, map_, reduce, reduce_, remove, remove_, type Set, toArray as toArrayOriginal } from "./Set.js"
+import { flow, pipe } from "./Function.ts"
+import { filter_, filterMap, filterMap_, fromArray as fromArrayOriginal, insert as insertOriginal, insert_ as insert_Original, map, map_, reduce, reduce_, remove, remove_, type Set, toArray as toArrayOriginal } from "./Set.ts"
 
 export interface NonEmptyBrand {
   readonly NonEmpty: unique symbol
@@ -89,4 +89,4 @@ export function fromSet<A>(set: Set<A>) {
 }
 
 // TODO
-export * from "./Set.js"
+export * from "./Set.ts"

package/src/Option.ts

@@ -3,7 +3,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 // eslint-disable-next-line import/no-unassigned-import
-import "./builtin.js"
+import "./builtin.ts"
 import { getOrUndefined as value, type Some } from "effect/Option"
 import * as Option from "effect/Option"
 

package/src/Pure.ts

@@ -3,8 +3,8 @@ import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Result from "effect/Result"
-import * as Context from "./Context.js"
-import { tuple } from "./Function.js"
+import * as Context from "./Context.ts"
+import { tuple } from "./Function.ts"
 
 const S1 = Symbol()
 const S2 = Symbol()

package/src/QueueMaker.ts

@@ -1,7 +1,7 @@
 import type * as Scope from "effect/Scope"
-import type { NonEmptyReadonlyArray } from "./Array.js"
-import type * as Effect from "./Effect.js"
-import { RequestContext } from "./RequestContext.js"
+import type { NonEmptyReadonlyArray } from "./Array.ts"
+import type * as Effect from "./Effect.ts"
+import { RequestContext } from "./RequestContext.ts"
 
 export interface QueueBase<Evt, DrainEvt> {
   drain: <DrainE, DrainR>(

package/src/RequestContext.ts

@@ -1,17 +1,14 @@
-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
 
 export class LocaleRef extends Context.Reference("Locale", { defaultValue: (): Locale => "en" }) {}
 
-export class RequestContext extends S.Opaque<
-  RequestContext,
-  RequestContext.Encoded
->()(S.Struct({
+class _RequestContext extends S.Opaque<_RequestContext>()(S.Struct({
   span: S.Struct({
     traceId: S.String,
     spanId: S.String,
@@ -34,6 +31,17 @@ export class RequestContext extends S.Opaque<
   }
 }
 
+// codegen:start {preset: modelFacade, className: _RequestContext, schema: S}
+// eslint-disable-next-line typescript/no-unsafe-declaration-merging
+export class RequestContext extends S.OpaqueFacadeClass<
+  RequestContext,
+  RequestContext.Encoded,
+  RequestContext.Make,
+  RequestContext.DecodingServices,
+  RequestContext.EncodingServices
+>()(_RequestContext) {}
+// codegen:end
+
 export const spanAttributes = (ctx: Pick<RequestContext, "locale" | "namespace"> & Partial<RequestContext>) => ({
   "code.function.name": ctx.name,
   "app.locale": ctx.locale,
@@ -52,10 +60,35 @@ export const spanAttributes = (ctx: Pick<RequestContext, "locale" | "namespace">
     : {})
 })
 
-// codegen:start {preset: model}
+// codegen:start {preset: model, static: true, facade: true}
 //
+export interface RequestContext {
+  readonly span: { readonly traceId: string; readonly spanId: string; readonly sampled: boolean }
+  readonly name: S.NonEmptyString255
+  readonly locale: "en" | "de"
+  readonly namespace: S.NonEmptyString255
+  readonly sourceId?: undefined | S.NonEmptyString255
+  readonly userProfile?: undefined | { readonly sub: UserProfileId }
+}
 export namespace RequestContext {
-  export interface Encoded extends S.StructNestedEncoded<typeof RequestContext> {}
+  export interface Encoded {
+    readonly span: { readonly traceId: string; readonly spanId: string; readonly sampled: boolean }
+    readonly name: string
+    readonly locale: "en" | "de"
+    readonly namespace: string
+    readonly sourceId?: undefined | string
+    readonly userProfile?: undefined | { readonly sub: string }
+  }
+  export interface Make {
+    readonly span: { readonly traceId: string; readonly spanId: string; readonly sampled: boolean }
+    readonly name: S.NonEmptyString255
+    readonly locale: "en" | "de"
+    readonly namespace: S.NonEmptyString255
+    readonly sourceId?: undefined | S.NonEmptyString255
+    readonly userProfile?: undefined | { readonly sub: UserProfileId }
+  }
+  export type DecodingServices = never
+  export type EncodingServices = never
 }
 //
 // codegen:end

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
@@ -309,3 +309,245 @@ export interface Opaque<Self, Encoded, SchemaS extends S.Top, Brand>
 export const Opaque: <Self, Encoded = ExtendedSchemaNoEncoded, Brand = {}>() => <S extends S.Top>(
   schema: S
 ) => Opaque<Self, Encoded, S, Brand> & Omit<S, keyof S.Top> = S.Opaque as any
+
+/**
+ * Like {@link Opaque}, but the class **instance type is exactly `Self`** (the supplied
+ * decoded `Type`) instead of the structurally-computed `struct["Type"] & Brand`.
+ *
+ * Stock `Opaque` types the instance as `struct["Type"] & Brand` and only overrides the
+ * schema's `Type`/`Encoded` *members* with `Self`/`Encoded`. So `make`/`copy`/consumers
+ * still resolve the struct's mapped `Type`. With a codegen-supplied pre-expanded literal
+ * `Type` interface, `OpaqueType` lets all of those resolve a single **named** interface
+ * (resolved once per checker) instead of re-deriving the mapped `Type` — cutting
+ * instantiation on `Type`-touching consumers.
+ *
+ * Use with `class X extends OpaqueType<X.Type, X.Encoded>()(struct) {}` where `X.Type`
+ * and `X.Encoded` are generated literal interfaces (see `@effect-app/eslint-codegen-model`,
+ * `static` + `type` mode).
+ *
+ * KNOWN GAP — **no branding**: the instance type is a plain structural `Self`, so opaque
+ * types of identical shape are mutually assignable. (Stock `Opaque` is also structural by
+ * default — `Brand` defaults to `{}` — so this only differs if you passed a non-default
+ * `Brand`.) Re-introducing a nominal brand on top of a supplied `Self` (e.g. branding the
+ * generated `Type` interface) is not yet implemented.
+ *
+ * NOTE: only `Type` (via `Self`) and `Encoded` are supplied statically here; `make`'s input
+ * (`~type.make.in`) and other derived members are still computed from the struct. See
+ * a future `OpaqueShape`-style helper if those also need to be supplied.
+ */
+export interface OpaqueType<Self, Encoded, SchemaS extends S.Top, Brand>
+  extends S.Opaque<Self, ExtendedSchema<SchemaS, Encoded>, Brand>
+{
+  new(_: never): Self
+}
+
+export const OpaqueType: <Self, Encoded = ExtendedSchemaNoEncoded, Brand = {}>() => <S extends S.Top>(
+  schema: S
+) => OpaqueType<Self, Encoded, S, Brand> & Omit<S, keyof S.Top> = S.Opaque as any
+
+// Override both the `Encoded` and make-input (`~type.make.in`) members in one go,
+// like `ExtendedSchema` does for `Encoded` alone.
+type ExtendedShape<SchemaS extends S.Top, Encoded, MakeIn> =
+  & Omit<SchemaS, "Encoded" | "~type.make.in">
+  & { readonly Encoded: Encoded; readonly "~type.make.in": MakeIn }
+
+type OpaqueFacadeConstructorArgs<MakeIn> = {} extends MakeIn ? [props?: MakeIn, options?: S.MakeOptions]
+  : [props: MakeIn, options?: S.MakeOptions]
+
+// Only the codec channels are required. `copy`/`fields`/`mapFields` are NOT
+// required here: transformed schemas (`.pipe(S.encodeKeys/annotate/filter/...)`)
+// don't expose them at the static level, and requiring them would reject those
+// models from facading. When present they still flow through via
+// `OpaqueFacadeStatics`; when absent the facade simply doesn't offer them.
+type OpaqueFacadeInput<DecodingServices, EncodingServices> = S.Top & {
+  readonly DecodingServices: DecodingServices
+  readonly EncodingServices: EncodingServices
+}
+
+// Carry the schema's own statics, dropping the generic `S.Top` machinery and
+// `prototype`. EXCEPT `to`: models compose each other via `X.to.fields` /
+// `X.to.copy` at definition time, so it must survive on the facade.
+type OpaqueFacadeStatics<SchemaS extends S.Top> = Omit<SchemaS, Exclude<keyof S.Top, "to"> | "prototype">
+
+/**
+ * Like {@link OpaqueType}, but ALSO supplies a static **make-input** shape, so
+ * `make`/`copy` resolve a named `MakeIn` interface instead of re-deriving the struct's
+ * mapped `~type.make.in`. Use with codegen-supplied `X.Type` / `X.Encoded` / `X.Make`:
+ *
+ * ```ts
+ * class X extends OpaqueShape<X.Type, X.Encoded, X.Make>()(struct) {}
+ * ```
+ *
+ * `decode`/`encode` already use the supplied `Type`/`Encoded` (they read the schema's
+ * `Type`/`Encoded` members, which are `Self`/`Encoded` here) — no separate override needed.
+ *
+ * NOTE — measured gain is modest (~5%): the struct passed to the wrapper is still
+ * constructed in full (definition cost dominates); the static shapes only cheapen
+ * consumer-side reads of `Type`/`Encoded`/`MakeIn`. Same `no-branding` gap as
+ * {@link OpaqueType}.
+ */
+export interface OpaqueShape<Self, Encoded, MakeIn, SchemaS extends S.Top, Brand>
+  extends S.Opaque<Self, ExtendedShape<SchemaS, Encoded, MakeIn>, Brand>
+{
+  new(_: never): Self
+}
+
+export const OpaqueShape: <Self, Encoded, MakeIn, Brand = {}>() => <S extends S.Top>(
+  schema: S
+) => OpaqueShape<Self, Encoded, MakeIn, S, Brand> & Omit<S, keyof S.Top> = S.Opaque as any
+
+/**
+ * Shallow public view for generated model facades.
+ *
+ * The runtime value can still be the full private schema class, but emitted
+ * declarations expose only named `Type` / `Encoded` / `Make` interfaces and a
+ * small static surface. This keeps downstream project references from pulling
+ * the private struct field map back through `typeof Model`.
+ */
+export interface OpaqueFacade<
+  Self,
+  Encoded,
+  MakeIn,
+  DecodingServices = never,
+  EncodingServices = DecodingServices,
+  Brand = {}
+> extends
+  S.Bottom<
+    Self,
+    Encoded,
+    DecodingServices,
+    EncodingServices,
+    SchemaAST.AST,
+    S.Codec<Self, Encoded, DecodingServices, EncodingServices>,
+    MakeIn,
+    Self,
+    readonly [],
+    MakeIn
+  >
+{
+  new(...args: OpaqueFacadeConstructorArgs<MakeIn>): Self & Brand
+  readonly copy: ReturnType<typeof copyOrigin<new(_: MakeIn) => Self>>
+  // NOTE: `fields` / `mapFields` are intentionally NOT redeclared here. They are
+  // carried (precise) from the underlying schema via `OpaqueFacadeStatics`. A wide
+  // `mapFields(f: (fields: S.Struct.Fields) => To)` override would win overload
+  // resolution and erase field precision in `Q.project(X.mapFields(...))`.
+}
+
+export function OpaqueFacade<
+  Self,
+  Encoded,
+  MakeIn,
+  DecodingServices = never,
+  EncodingServices = DecodingServices,
+  Brand = {}
+>() {
+  return <SchemaS extends OpaqueFacadeInput<DecodingServices, EncodingServices>>(
+    schema: SchemaS
+  ): OpaqueFacade<Self, Encoded, MakeIn, DecodingServices, EncodingServices, Brand> & OpaqueFacadeStatics<SchemaS> =>
+    schema as SchemaS & OpaqueFacade<Self, Encoded, MakeIn, DecodingServices, EncodingServices, Brand>
+}
+
+export interface OpaqueFacadeClass<
+  Self,
+  Encoded,
+  MakeIn,
+  DecodingServices = never,
+  EncodingServices = DecodingServices,
+  Brand = {}
+> extends
+  S.Bottom<
+    Self,
+    Encoded,
+    DecodingServices,
+    EncodingServices,
+    SchemaAST.AST,
+    S.Codec<Self, Encoded, DecodingServices, EncodingServices>,
+    MakeIn,
+    Self,
+    readonly [],
+    MakeIn
+  >
+{
+  new(...args: OpaqueFacadeConstructorArgs<MakeIn>): Brand
+  readonly copy: ReturnType<typeof copyOrigin<new(_: MakeIn) => Self>>
+  // NOTE: `fields` / `mapFields` intentionally not redeclared — carried precise
+  // from the underlying schema via `OpaqueFacadeStatics` (see OpaqueFacade above).
+}
+
+export function OpaqueFacadeClass<
+  Self,
+  Encoded,
+  MakeIn,
+  DecodingServices = never,
+  EncodingServices = DecodingServices,
+  Brand = {}
+>() {
+  return <SchemaS extends OpaqueFacadeInput<DecodingServices, EncodingServices>>(
+    schema: SchemaS
+  ):
+    & OpaqueFacadeClass<Self, Encoded, MakeIn, DecodingServices, EncodingServices, Brand>
+    & OpaqueFacadeStatics<SchemaS> =>
+  {
+    // Make the result constructable (like `S.Opaque`), so the private `_X` may be a
+    // plain `S.Struct`/`S.TaggedStruct` (lighter type) — not only an `S.Opaque` class —
+    // while `export class X extends ...(_X)` still works.
+    class Facade {}
+    return Object.setPrototypeOf(Facade, schema)
+  }
+}
+
+/**
+ * Like {@link OpaqueFacadeClass}, but for error models (`TaggedErrorClass` /
+ * `ErrorClass`). The decoded instance type carries `Cause.YieldableError`, so
+ * `yield* new MyError(...)`, `Effect.fail(myError)`, and `instanceof` all keep
+ * working through the facade — the runtime `_X` is the real error class (the
+ * facade `X extends ...(_X)` inherits its prototype), and the type reflects it.
+ * Nothing is lost vs the underlying error class.
+ */
+export interface OpaqueErrorFacadeClass<
+  Self,
+  Encoded,
+  MakeIn,
+  DecodingServices = never,
+  EncodingServices = DecodingServices,
+  Brand = {}
+> extends
+  S.Bottom<
+    Self,
+    Encoded,
+    DecodingServices,
+    EncodingServices,
+    SchemaAST.AST,
+    S.Codec<Self, Encoded, DecodingServices, EncodingServices>,
+    MakeIn,
+    Self,
+    readonly [],
+    MakeIn
+  >
+{
+  // YieldableError (not Self) on the constructed instance — like OpaqueFacadeClass's
+  // `new(): Brand`, the data type comes from the declaration-merged `interface X`,
+  // so `Self` must NOT appear here (would recurse). Merging `X & YieldableError`
+  // makes `yield* new X()` / `Effect.fail` / `instanceof` work without losing data.
+  new(...args: OpaqueFacadeConstructorArgs<MakeIn>): Cause.YieldableError & Brand
+  readonly copy: ReturnType<typeof copyOrigin<new(_: MakeIn) => Self>>
+}
+
+export function OpaqueErrorFacadeClass<
+  Self,
+  Encoded,
+  MakeIn,
+  DecodingServices = never,
+  EncodingServices = DecodingServices,
+  Brand = {}
+>() {
+  return <SchemaS extends OpaqueFacadeInput<DecodingServices, EncodingServices>>(
+    schema: SchemaS
+  ):
+    & OpaqueErrorFacadeClass<Self, Encoded, MakeIn, DecodingServices, EncodingServices, Brand>
+    & OpaqueFacadeStatics<SchemaS> =>
+  {
+    class Facade {}
+    return Object.setPrototypeOf(Facade, schema)
+  }
+}

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, OpaqueErrorFacadeClass, OpaqueFacade, OpaqueFacadeClass, OpaqueShape, OpaqueType, 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>,