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

package/dist/utils.js

@@ -106,9 +106,10 @@ resultSelector) {
     if (!descriptor) {
         descriptor = Object.getOwnPropertyDescriptor(target, key);
         if (!descriptor) {
-            const e = new Error("@LazyGetter is unable to determine the property descriptor");
-            e.$target = target;
-            e.$key = key;
+            const e = Object.assign(new Error("@LazyGetter is unable to determine the property descriptor"), {
+                $key: key,
+                $target: target
+            });
             throw e;
         }
     }
@@ -163,16 +164,16 @@ target, key, isStatic, enumerable, originalMethod, thisArg, args, setProto, make
 export function LazyGetter(setProto = false, makeNonConfigurable = false, resultSelector = defaultFilter) {
     let desc;
     let prop;
-    let args = null;
+    let args;
     let isLegacy;
     function decorator(targetOrDesc, key, descriptor) {
-        // eslint-disable-next-line prefer-rest-params
-        args = arguments;
+        args = [targetOrDesc, key, descriptor];
         if (key === undefined) {
             if (typeof desc === "undefined") {
+                const newDescriptor = targetOrDesc;
                 isLegacy = false;
-                prop = targetOrDesc.key;
-                desc = Object.assign({}, targetOrDesc.descriptor
+                prop = newDescriptor.key;
+                desc = Object.assign({}, newDescriptor.descriptor
                     /* istanbul ignore next */ || targetOrDesc);
             }
             return decorateNew(targetOrDesc, setProto, makeNonConfigurable, resultSelector);
@@ -196,11 +197,14 @@ export function LazyGetter(setProto = false, makeNonConfigurable = false, result
             if (!desc) {
                 throw new Error("Unable to restore descriptor. Did you remember to apply your decorator to a method?");
             }
+            if (!args) {
+                throw new Error("Unable to restore descriptor before applying the decorator.");
+            }
             // Restore descriptor to its original state
             Object.defineProperty(on, prop, desc);
-            // eslint-disable-next-line prefer-spread
             const ret = decorator.apply(null, args);
-            Object.defineProperty(on, prop, isLegacy ? ret : ret.descriptor || ret);
+            const restoredDescriptor = isLegacy ? ret : "descriptor" in ret && ret.descriptor ? ret.descriptor : ret;
+            Object.defineProperty(on, prop, restoredDescriptor);
         };
     return decorator;
 }
@@ -398,4 +402,4 @@ const genConstructor = (function* () { }).constructor;
  * @since 3.11.0
  */
 export const isGeneratorFunction = (u) => isFunction(u) && u.constructor === genConstructor;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-app",
-  "version": "4.0.0-beta.268",
+  "version": "4.0.0-beta.269",
   "license": "MIT",
   "type": "module",
   "dependencies": {

package/src/Model/filter/types/path/eager.ts

@@ -44,7 +44,7 @@ export type Path<T, Seen = never> = T extends ReadonlyArray<infer V> ? IsTuple<T
  */
 export type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>
 
-export namespace PathRecursionTests {
+{
   // Regression: self-referential types must terminate instead of blowing past
   // TS's instantiation limit (TS2589). `JsonLike` mirrors effect's `Json` — the
   // encoded form of `Schema.Defect()` — whose `{ [x: string]: Json }` index
@@ -57,12 +57,14 @@ export namespace PathRecursionTests {
     | null
     | ReadonlyArray<JsonLike>
     | { readonly [x: string]: JsonLike }
-  export type _RawDefect = Path<{ id: string; raw: JsonLike }>
-  export type _NestedDefect = Path<{ a: { b: { error: { raw: JsonLike } } } }>
-  export type _ArrayOfDefect = Path<{ items: ReadonlyArray<{ raw: JsonLike }> }>
+  type _RawDefect = Path<{ id: string; raw: JsonLike }>
+  type _NestedDefect = Path<{ a: { b: { error: { raw: JsonLike } } } }>
+  type _ArrayOfDefect = Path<{ items: ReadonlyArray<{ raw: JsonLike }> }>
   // finite paths are still produced
   expectTypeOf<"id">().toExtend<_RawDefect>()
   expectTypeOf<"raw">().toExtend<_RawDefect>()
+  expectTypeOf<"a.b.error.raw">().toExtend<_NestedDefect>()
+  expectTypeOf<`items.${number}.raw`>().toExtend<_ArrayOfDefect>()
 }
 
 /**
@@ -191,7 +193,7 @@ export type RefineFieldPathValue<
   Exclde extends boolean = false
 > = EraseNeverContainingUnionElements<RefinePathValue<TFieldValues, TFieldPath, X, Exclde>>
 
-export namespace RefinePathValueTests {
+{
   type test1 = RefineFieldPathValue<{ a: { b: "tag1"; v1: string } | { b: "tag2"; v2: number } }, "a.b", "tag1">
   expectTypeOf<test1>().toEqualTypeOf<{ a: { b: "tag1"; v1: string } }>()
 
@@ -259,7 +261,7 @@ export namespace RefinePathValueTests {
   }>()
 }
 
-export namespace SetFieldPathValueTests {
+{
   type test1 = SetFieldPathValue<{ foo: { bar: string[] } }, `foo.bar`, boolean>
   expectTypeOf<test1>().toEqualTypeOf<{ foo: { bar: boolean } }>()
 

package/src/RequestContext.ts

@@ -8,10 +8,7 @@ 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

@@ -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.ts

@@ -110,7 +110,7 @@ export { withDecodingDefaultTypeKey } from "effect/Schema"
 export * from "effect/Schema"
 
 export * from "./Schema/Class.ts"
-export { Class, ErrorClass, Opaque, TaggedClass, TaggedErrorClass } 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.ts"
 export { Array, Boolean, Date, DateFromString, DateValid, Finite, Literals, NullOr, Number, ReadonlyMap, ReadonlySet } from "./Schema/ext.ts"

package/src/client/errors.ts

@@ -243,11 +243,16 @@ export const silenceError = (e: Record<PropertyKey, any>) => {
 }
 
 export class CauseException<E> extends Error {
-  constructor(readonly originalCause: Cause.Cause<E>, readonly _tag: string) {
+  readonly originalCause: Cause.Cause<E>
+  readonly _tag: string
+
+  constructor(originalCause: Cause.Cause<E>, _tag: string) {
     const limit = Error.stackTraceLimit
     Error.stackTraceLimit = 0
     super()
     Error.stackTraceLimit = limit
+    this.originalCause = originalCause
+    this._tag = _tag
     this.cause = Cause.squash(originalCause)
     // v4: makeFiberFailure removed — use Cause.prettyErrors instead
     const errors = Cause.prettyErrors(originalCause)

package/src/utils.ts

@@ -228,7 +228,7 @@ function decorateNew(
 function decorateLegacy(
   target: any,
   key: PropertyKey,
-  descriptor: PropertyDescriptor,
+  descriptor: PropertyDescriptor | undefined,
   setProto: boolean,
   makeNonConfigurable: boolean,
   // tslint:enable:bool-param-default
@@ -236,11 +236,12 @@ function decorateLegacy(
 ): PropertyDescriptor {
   /* istanbul ignore if */
   if (!descriptor) {
-    descriptor = <any> Object.getOwnPropertyDescriptor(target, key)
+    descriptor = Object.getOwnPropertyDescriptor(target, key)
     if (!descriptor) {
-      const e = new Error("@LazyGetter is unable to determine the property descriptor")
-      ;(<any> e).$target = target
-      ;(<any> e).$key = key
+      const e = Object.assign(new Error("@LazyGetter is unable to determine the property descriptor"), {
+        $key: key,
+        $target: target
+      })
       throw e
     }
   }
@@ -295,7 +296,7 @@ function defaultFilter(): boolean {
 
 function validateAndExtractMethodFromDescriptor(desc: PropertyDescriptor): Function {
   // eslint-disable-next-line @typescript-eslint/unbound-method
-  const originalMethod = <Function> desc.get
+  const originalMethod = desc.get
 
   if (!originalMethod) {
     throw new Error("@LazyGetter can only decorate getters!")
@@ -318,7 +319,7 @@ function getterCommon( // tslint:disable-line:parameters-max-number
   makeNonConfigurable: boolean,
   resultSelector: ResultSelectorFn
 ): any {
-  const value = originalMethod.apply(thisArg, <any> args)
+  const value = originalMethod.apply(thisArg, args)
 
   if (resultSelector(value)) {
     const newDescriptor: PropertyDescriptor = {
@@ -353,23 +354,23 @@ export function LazyGetter(
 ): MethodDecorator & ResettableDescriptor {
   let desc: PropertyDescriptor
   let prop: PropertyKey
-  let args: IArguments = <any> null
+  let args: [targetOrDesc: any, key: PropertyKey | undefined, descriptor: PropertyDescriptor | undefined] | undefined
   let isLegacy: boolean
 
   function decorator(
     targetOrDesc: any,
-    key: PropertyKey,
-    descriptor: PropertyDescriptor
+    key: PropertyKey | undefined,
+    descriptor: PropertyDescriptor | undefined
   ): DecoratorReturn {
-    // eslint-disable-next-line prefer-rest-params
-    args = arguments
+    args = [targetOrDesc, key, descriptor]
     if (key === undefined) {
       if (typeof desc === "undefined") {
+        const newDescriptor = targetOrDesc as NewDescriptor
         isLegacy = false
-        prop = (<NewDescriptor> targetOrDesc).key
+        prop = newDescriptor.key
         desc = Object.assign(
           {},
-          (<NewDescriptor> targetOrDesc).descriptor
+          newDescriptor.descriptor
             /* istanbul ignore next */ || targetOrDesc
         )
       }
@@ -411,11 +412,14 @@ export function LazyGetter(
           "Unable to restore descriptor. Did you remember to apply your decorator to a method?"
         )
       }
+      if (!args) {
+        throw new Error("Unable to restore descriptor before applying the decorator.")
+      }
       // Restore descriptor to its original state
       Object.defineProperty(on, prop, desc)
-      // eslint-disable-next-line prefer-spread
-      const ret: any = decorator.apply(null, <any> args)
-      Object.defineProperty(on, prop, isLegacy ? ret : ret.descriptor || ret)
+      const ret = decorator.apply(null, args)
+      const restoredDescriptor = isLegacy ? ret : "descriptor" in ret && ret.descriptor ? ret.descriptor : ret
+      Object.defineProperty(on, prop, restoredDescriptor)
     }
 
   return decorator

package/tsconfig.json

@@ -34,6 +34,7 @@
     "moduleResolution": "Node16",
     "noErrorTruncation": true,
     "forceConsistentCasingInFileNames": true,
+    "erasableSyntaxOnly": true,
     "rewriteRelativeImportExtensions": true,
     "allowImportingTsExtensions": true,
     "types": [