@colyseus/schema 5.0.14 → 5.0.20

package/build/types/HelperTypes.d.ts

@@ -9,10 +9,17 @@ import type { StreamSchema } from "./custom/StreamSchema.js";
 import type { FieldBuilder } from "./builder.js";
 export type Constructor<T = {}> = new (...args: any[]) => T;
 type PrimitiveStringToType<T> = T extends "string" ? string : T extends "number" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32" | "int64" | "uint64" | "float32" | "float64" ? number : T extends "boolean" ? boolean : T;
-export interface Collection<K = any, V = any, IT = V> {
+/**
+ * What the decoder callbacks accept as "a collection": the public shape, which
+ * a plain array satisfies too — `@type([X]) items: X[]` is a common way to
+ * declare a field. {@link Collection} is the runtime contract on top of it.
+ */
+export interface CollectionLike<K = any, V = any, IT = V> {
     [Symbol.iterator](): IterableIterator<IT>;
     forEach(callback: Function): void;
     entries(): IterableIterator<[K, V]>;
+}
+export interface Collection<K = any, V = any, IT = V> extends CollectionLike<K, V, IT> {
     /** See {@link $resyncPrune} — every collection kind must declare its resync-sweep semantics. */
     [$resyncPrune](visited: Set<number | string>, prune: (value: V, identity: number | string) => void, keep: (value: V) => void): void;
 }
@@ -69,35 +76,39 @@ export type InferValueType<T> = T extends FieldBuilder<infer V> ? V : T extends
 } ? StreamSchema<InstanceType<ChildType>> : T extends {
     stream: infer ChildType;
 } ? StreamSchema<ChildType> : T extends Constructor ? InstanceType<T> : T extends Record<string | number, string | number> ? T[keyof T] : T extends PrimitiveType ? T : never;
+type IsOptionalBuilderKey<T, K extends keyof T> = T[K] extends FieldBuilder<unknown, boolean, infer O extends boolean> ? O : false;
 type OptionalBuilderKeys<T> = {
-    [K in keyof T]: T[K] extends FieldBuilder<unknown, boolean, infer O extends boolean> ? (O extends true ? K : never) : never;
+    [K in keyof T]-?: IsOptionalBuilderKey<T, K> extends true ? K : never;
+}[keyof T];
+type RequiredBuilderKeys<T> = {
+    [K in keyof T]-?: IsOptionalBuilderKey<T, K> extends true ? never : K;
 }[keyof T];
-type RequiredBuilderKeys<T> = Exclude<keyof T, OptionalBuilderKeys<T>>;
 export type InferSchemaInstanceType<T> = {
     [K in RequiredBuilderKeys<T>]: T[K] extends FieldBuilder<any> ? InferValueType<T[K]> : T[K] extends (...args: any[]) => any ? (T[K] extends new (...args: any[]) => any ? InferValueType<T[K]> : T[K]) : InferValueType<T[K]>;
 } & {
     [K in OptionalBuilderKeys<T>]?: T[K] extends FieldBuilder<infer V> ? V : never;
 } & Schema;
-export type NonFunctionProps<T> = Omit<T, {
-    [K in keyof T]: T[K] extends Function ? K : never;
-}[keyof T]>;
+type DataKey<T, K extends keyof T> = K extends keyof Schema ? never : T[K] extends Function ? never : K;
 export type NonFunctionPropNames<T> = {
-    [K in keyof T]: T[K] extends Function ? never : K;
+    [K in keyof T]-?: DataKey<T, K>;
 }[keyof T];
 export type NonFunctionNonPrimitivePropNames<T> = {
-    [K in keyof T]: T[K] extends Function ? never : T[K] extends number | string | boolean ? never : K;
+    [K in keyof T]-?: [DataKey<T, K>] extends [never] ? never : T[K] extends number | string | boolean ? never : K;
 }[keyof T];
 type ToJSONValue<U> = U extends Schema ? ToJSON<U> : PrimitiveStringToType<U>;
 type ToJSONField<X> = X extends MapSchema<infer U> ? Record<string, ToJSONValue<U>> : X extends Map<string, infer U> ? Record<string, ToJSONValue<U>> : X extends ArraySchema<infer U> ? ToJSONValue<U>[] : X extends SetSchema<infer U> ? ToJSONValue<U>[] : X extends CollectionSchema<infer U> ? ToJSONValue<U>[] : X extends Schema ? ToJSON<X> : X;
+type IsOptionalKey<T, K extends keyof T> = undefined extends {} ? ({} extends Pick<T, K> ? true : false) : (undefined extends T[K] ? true : false);
+type ToJSONRequiredKeys<T> = {
+    [K in keyof T]-?: [DataKey<T, K>] extends [never] ? never : IsOptionalKey<T, K> extends true ? never : K;
+}[keyof T];
 type ToJSONOptionalKeys<T> = {
-    [K in keyof T]-?: undefined extends {} ? ({} extends Pick<T, K> ? K : never) : (undefined extends T[K] ? K : never);
+    [K in keyof T]-?: [DataKey<T, K>] extends [never] ? never : IsOptionalKey<T, K> extends true ? K : never;
 }[keyof T];
-type ToJSONRequiredKeys<T> = Exclude<keyof T, ToJSONOptionalKeys<T>>;
-export type ToJSON<T> = NonFunctionProps<{
+export type ToJSON<T> = {
     [K in ToJSONRequiredKeys<T>]: ToJSONField<T[K]>;
 } & {
     [K in ToJSONOptionalKeys<T>]?: ToJSONField<Exclude<T[K], undefined>>;
-}>;
+};
 /**
  * The plain DATA shape of a Schema instance type `T`: its synchronized fields
  * with all `Schema` machinery stripped (`assign`, `clone`, `toJSON`, the
@@ -116,8 +127,7 @@ export type ToJSON<T> = NonFunctionProps<{
  *
  * Unlike {@link ToJSON} (a recursive *serialization* shape), this is a flat
  * structural projection: nested Schema / collection fields keep their instance
- * types, and it does not retain the non-method `Schema` members that `ToJSON`'s
- * `NonFunctionProps` pass leaves behind.
+ * types.
  */
 export type Data<T> = Omit<T, keyof Schema>;
 export type IsNever<T> = [T] extends [never] ? true : false;

package/build/types/TypeContext.d.ts

@@ -5,18 +5,6 @@ export declare class TypeContext {
     };
     schemas: Map<typeof Schema, number>;
     hasFilters: boolean;
-    parentFiltered: {
-        [typeIdAndParentIndex: string]: boolean;
-    };
-    /**
-     * True iff `parentFiltered` has at least one entry. Flipped on by
-     * `registerFilteredByParent` and read in `checkInheritedFlags` as a
-     * cheap gate to skip the string-keyed `parentFiltered[key]` lookup
-     * when no class has registered filter inheritance via ancestry — the
-     * common case when @view tags exist only on sibling fields, not
-     * along any attachment chain.
-     */
-    hasParentFilteredEntries: boolean;
     /**
      * For inheritance support
      * Keeps track of which classes extends which. (parent -> children)
@@ -31,10 +19,5 @@ export declare class TypeContext {
     add(schema: typeof Schema, typeid?: number): boolean;
     getTypeId(klass: typeof Schema): number;
     private discoverTypes;
-    /**
-     * Keep track of which classes have filters applied.
-     * Format: `${typeid}-${parentTypeid}-${parentIndex}`
-     */
-    private registerFilteredByParent;
     debug(): string;
 }

package/build/types/builder.d.ts

@@ -213,26 +213,22 @@ interface PrimitiveFactory<TBase> {
     (): FieldBuilder<TBase>;
     <T extends TBase>(): FieldBuilder<T>;
 }
-export type ChildType = RawPrimitiveType | Constructor<Schema> | FieldBuilder<any>;
+export type ChildType = RawPrimitiveType | Constructor<Schema>;
 interface ArrayFactory {
     <C extends Constructor<Schema>>(child: C): FieldBuilder<ArraySchema<InstanceType<C>>, true, false>;
     <P extends RawPrimitiveType>(child: P): FieldBuilder<ArraySchema<InferValueType<P>>, true, false>;
-    <V>(child: FieldBuilder<V>): FieldBuilder<ArraySchema<V>, true, false>;
 }
 interface MapFactory {
     <C extends Constructor<Schema>>(child: C): FieldBuilder<MapSchema<InstanceType<C>>, true, false>;
     <P extends RawPrimitiveType>(child: P): FieldBuilder<MapSchema<InferValueType<P>>, true, false>;
-    <V>(child: FieldBuilder<V>): FieldBuilder<MapSchema<V>, true, false>;
 }
 interface SetFactory {
     <C extends Constructor<Schema>>(child: C): FieldBuilder<SetSchema<InstanceType<C>>, true, false>;
     <P extends RawPrimitiveType>(child: P): FieldBuilder<SetSchema<InferValueType<P>>, true, false>;
-    <V>(child: FieldBuilder<V>): FieldBuilder<SetSchema<V>, true, false>;
 }
 interface CollectionFactory {
     <C extends Constructor<Schema>>(child: C): FieldBuilder<CollectionSchema<InstanceType<C>>, true, false>;
     <P extends RawPrimitiveType>(child: P): FieldBuilder<CollectionSchema<InferValueType<P>>, true, false>;
-    <V>(child: FieldBuilder<V>): FieldBuilder<CollectionSchema<V>, true, false>;
 }
 interface StreamFactory {
     <C extends Constructor<Schema>>(child: C): FieldBuilder<StreamSchema<InstanceType<C>>, true, false>;

package/build/types/symbols.d.ts

@@ -80,6 +80,7 @@ export declare const $viewFieldIndexes = "~__viewFieldIndexes";
 export declare const $fieldIndexesByViewTag = "$__fieldIndexesByViewTag";
 export declare const $unreliableFieldIndexes = "~__unreliableFieldIndexes";
 export declare const $patchOnlyFieldIndexes = "~__patchOnlyFieldIndexes";
+export declare const $fullSyncSkipIndexes = "~__fullSyncSkipIndexes";
 export declare const $fullStateOnlyFieldIndexes = "~__fullStateOnlyFieldIndexes";
 export declare const $streamFieldIndexes = "~__streamFieldIndexes";
 export declare const $streamPriorities = "~__streamPriorities";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@colyseus/schema",
-  "version": "5.0.14",
-  "description": "Binary state serializer with delta encoding for games",
+  "version": "5.0.20",
+  "description": "Automatic state replication for multiplayer games. Mutate plain objects, and every client gets a live, typed mirror through delta encoding.",
   "type": "module",
   "bin": {
     "schema-codegen": "bin/schema-codegen",
@@ -14,13 +14,13 @@
     "bench:gate": "node bench/run.mjs --assert --samples 3 --filter gate",
     "profile:cpu": "node bench/profile.mjs --cpu",
     "profile:heap": "node bench/profile.mjs --heap",
-    "build": "tsc -p tsconfig.build.json && rollup -c rollup.config.mjs",
-    "watch": "tsc -p tsconfig.build.json -w",
-    "typecheck:build": "tsc -p tsconfig.build.json --noEmit",
+    "build": "node node_modules/typescript/bin/tsc -p tsconfig.build.json && rollup -c rollup.config.mjs",
+    "watch": "node node_modules/typescript/bin/tsc -p tsconfig.build.json -w",
+    "typecheck:build": "node node_modules/typescript/bin/tsc -p tsconfig.build.json --noEmit",
     "test": "npm run test:types && tsx --tsconfig tsconfig.test.json ./node_modules/mocha/bin/mocha.js \"test/*.test.ts\" \"test/**/*.test.ts\"",
-    "test:types": "tsc -p tsconfig.build.json && tsc -p tsconfig.types.json && tsc -p tsconfig.types-nostrict.json",
+    "test:types": "node node_modules/typescript/bin/tsc -p tsconfig.build.json && node test/types/run.mjs typescript typescript-7",
     "test:exports": "node test/verify-exports.mjs",
-    "typecheck": "tsc -p tsconfig.test.json",
+    "typecheck": "node node_modules/typescript/bin/tsc -p tsconfig.test.json",
     "coverage": "c8 npm run test",
     "generate-test-1": "bin/schema-codegen test-external/PrimitiveTypes.ts --namespace SchemaTest.PrimitiveTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/PrimitiveTypes",
     "generate-test-2": "bin/schema-codegen test-external/ChildSchemaTypes.ts --namespace SchemaTest.ChildSchemaTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/ChildSchemaTypes",
@@ -94,7 +94,8 @@
     "source-map-support": "^0.5.13",
     "tslib": "^2.1.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "typescript-7": "npm:typescript@^7.0.2"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"

package/src/Metadata.ts

@@ -1,7 +1,7 @@
 import { DefinitionType, getPropertyDescriptor } from "./annotations.js";
 import { Schema } from "./Schema.js";
 import { getType, registeredTypes, TypeDefinition } from "./types/registry.js";
-import { $decoder, $descriptors, $encoder, $encoders, $fieldIndexesByViewTag, $numFields, $refTypeFieldIndexes, $fullStateOnlyFieldIndexes, $streamFieldIndexes, $streamPriorities, $track, $patchOnlyFieldIndexes, $unreliableFieldIndexes, $viewFieldIndexes } from "./types/symbols.js";
+import { $decoder, $descriptors, $encoder, $encoders, $fieldIndexesByViewTag, $numFields, $refTypeFieldIndexes, $fullStateOnlyFieldIndexes, $fullSyncSkipIndexes, $streamFieldIndexes, $streamPriorities, $track, $patchOnlyFieldIndexes, $unreliableFieldIndexes, $viewFieldIndexes } from "./types/symbols.js";
 import { ARRAY_STREAM_NOT_SUPPORTED } from "./encoder/streaming.js";
 import { encode } from "./encoding/encode.js";
 import { TypeContext } from "./types/TypeContext.js";
@@ -37,6 +37,8 @@ export type Metadata =
     { [$refTypeFieldIndexes]: number[]; } & // all field indexes containing Ref types (Schema, ArraySchema, MapSchema, etc)
     { [$unreliableFieldIndexes]: number[]; } & // all field indexes tagged with @unreliable
     { [$patchOnlyFieldIndexes]: number[]; } & // all field indexes tagged with @patchOnly (not persisted to snapshots)
+    { [$fullSyncSkipIndexes]: number[]; } & // @patchOnly ∪ @deprecated() — never read during full sync
+
     { [$fullStateOnlyFieldIndexes]: number[]; } & // all field indexes tagged @fullStateOnly / .fullStateOnly() (not tracked after assignment)
     { [$streamFieldIndexes]: number[]; } & // all field indexes holding a t.stream(...) collection
     { [$streamPriorities]: { [field: number]: (view: any, element: any) => number }; } & // per-stream-field priority callback declared at schema definition time
@@ -113,6 +115,30 @@ function isTSEnum(_enum: any) {
     return false;
 }
 
+// Copied parent → subclass on Metadata.initialize, so each class owns its list.
+const INHERITED_ARRAY_KEYS = [
+    $refTypeFieldIndexes,
+    $unreliableFieldIndexes,
+    $patchOnlyFieldIndexes,
+    $fullSyncSkipIndexes,
+    $fullStateOnlyFieldIndexes,
+    $streamFieldIndexes,
+    $encoders,
+];
+
+/** Append to a non-enumerable metadata index list, creating it on first use. */
+function pushIndexList(metadata: any, key: string, index: number) {
+    if (!metadata[key]) {
+        Object.defineProperty(metadata, key, {
+            value: [],
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+    }
+    metadata[key].push(index);
+}
+
 export const Metadata = {
 
     addField(metadata: any, index: number, name: string, type: DefinitionType, descriptor?: PropertyDescriptor) {
@@ -302,15 +328,26 @@ export const Metadata = {
         }
         metadata[index].patchOnly = true;
 
-        if (!metadata[$patchOnlyFieldIndexes]) {
-            Object.defineProperty(metadata, $patchOnlyFieldIndexes, {
-                value: [],
-                enumerable: false,
-                configurable: true,
-                writable: true,
-            });
-        }
-        metadata[$patchOnlyFieldIndexes].push(index);
+        pushIndexList(metadata, $patchOnlyFieldIndexes, index);
+        pushIndexList(metadata, $fullSyncSkipIndexes, index); // not persisted to snapshots
+    },
+
+    /**
+     * `@deprecated()` bookkeeping: the field keeps its wire index (so peers
+     * that still carry it stay compatible) but is excluded from full sync —
+     * its accessor may throw — and hidden from `for..in` consumers.
+     */
+    setDeprecated(metadata: Metadata, fieldName: string) {
+        const index = metadata[fieldName];
+        metadata[index].deprecated = true;
+
+        pushIndexList(metadata, $fullSyncSkipIndexes, index);
+
+        Object.defineProperty(metadata, index, {
+            value: metadata[index],
+            enumerable: false,
+            configurable: true
+        });
     },
 
     setFullStateOnly(metadata: Metadata, fieldName: string) {
@@ -324,15 +361,7 @@ export const Metadata = {
         }
         metadata[index].fullStateOnly = true;
 
-        if (!metadata[$fullStateOnlyFieldIndexes]) {
-            Object.defineProperty(metadata, $fullStateOnlyFieldIndexes, {
-                value: [],
-                enumerable: false,
-                configurable: true,
-                writable: true,
-            });
-        }
-        metadata[$fullStateOnlyFieldIndexes].push(index);
+        pushIndexList(metadata, $fullStateOnlyFieldIndexes, index);
     },
 
     setStream(metadata: Metadata, fieldName: string) {
@@ -510,54 +539,17 @@ export const Metadata = {
                     });
                 }
 
-                // $refTypeFieldIndexes
-                if (parentMetadata[$refTypeFieldIndexes] !== undefined) {
-                    Object.defineProperty(metadata, $refTypeFieldIndexes, {
-                        value: [...parentMetadata[$refTypeFieldIndexes]],
-                        enumerable: false,
-                        configurable: true,
-                        writable: true,
-                    });
-                }
-
-                // $unreliableFieldIndexes
-                if (parentMetadata[$unreliableFieldIndexes] !== undefined) {
-                    Object.defineProperty(metadata, $unreliableFieldIndexes, {
-                        value: [...parentMetadata[$unreliableFieldIndexes]],
-                        enumerable: false,
-                        configurable: true,
-                        writable: true,
-                    });
-                }
-
-                // $patchOnlyFieldIndexes
-                if (parentMetadata[$patchOnlyFieldIndexes] !== undefined) {
-                    Object.defineProperty(metadata, $patchOnlyFieldIndexes, {
-                        value: [...parentMetadata[$patchOnlyFieldIndexes]],
-                        enumerable: false,
-                        configurable: true,
-                        writable: true,
-                    });
-                }
-
-                // $fullStateOnlyFieldIndexes
-                if (parentMetadata[$fullStateOnlyFieldIndexes] !== undefined) {
-                    Object.defineProperty(metadata, $fullStateOnlyFieldIndexes, {
-                        value: [...parentMetadata[$fullStateOnlyFieldIndexes]],
-                        enumerable: false,
-                        configurable: true,
-                        writable: true,
-                    });
-                }
-
-                // $streamFieldIndexes
-                if (parentMetadata[$streamFieldIndexes] !== undefined) {
-                    Object.defineProperty(metadata, $streamFieldIndexes, {
-                        value: [...parentMetadata[$streamFieldIndexes]],
-                        enumerable: false,
-                        configurable: true,
-                        writable: true,
-                    });
+                // per-class arrays the subclass extends independently
+                for (const key of INHERITED_ARRAY_KEYS) {
+                    const list = parentMetadata[key] as unknown as any[] | undefined;
+                    if (list !== undefined) {
+                        Object.defineProperty(metadata, key, {
+                            value: [...list],
+                            enumerable: false,
+                            configurable: true,
+                            writable: true,
+                        });
+                    }
                 }
 
                 // $descriptors
@@ -567,16 +559,6 @@ export const Metadata = {
                     configurable: true,
                     writable: true,
                 });
-
-                // $encoders
-                if (parentMetadata[$encoders] !== undefined) {
-                    Object.defineProperty(metadata, $encoders, {
-                        value: [...parentMetadata[$encoders]],
-                        enumerable: false,
-                        configurable: true,
-                        writable: true,
-                    });
-                }
             }
         }
 

package/src/Reflection.ts

@@ -149,9 +149,15 @@ Reflection.encode = function (encoder: Encoder, it: Iterator = { offset: 0 }) {
         // if metadata is the same reference as the parent class - it means the class has no own metadata
         //
         if (metadata !== inheritFrom[Symbol.metadata]) {
-            for (const fieldIndex in metadata) {
-                const index = Number(fieldIndex);
-                const fieldName = metadata[index].name;
+            // Walk by index rather than `for…in`: `@deprecated()` makes its
+            // metadata slot non-enumerable, and dropping it from the payload
+            // shifts every later field down one wire index on the peer.
+            const numFields = (metadata[$numFields] ?? -1) as number;
+            for (let index = 0; index <= numFields; index++) {
+                const field = metadata[index];
+                if (field === undefined) { continue; }
+
+                const fieldName = field.name;
 
                 // skip fields from parent classes
                 if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
@@ -163,8 +169,6 @@ Reflection.encode = function (encoder: Encoder, it: Iterator = { offset: 0 }) {
 
                 let fieldType: string;
 
-                const field = metadata[index];
-
                 if (typeof (field.type) === "string") {
                     fieldType = field.type;
 

package/src/annotations.ts

@@ -477,12 +477,27 @@ function makeCollectionSetter(
 
         if (value !== undefined && value !== null) {
             // automatic Array → ArraySchema / Map → MapSchema conversion.
+            // `$childType` goes on before populating — push()/set() gate
+            // their `assertInstanceType` on it.
             if (isArrayKlass && !(value instanceof ArraySchema)) {
-                value = new ArraySchema(...value);
+                const array: any = new ArraySchema();
+                array[$childType] = type;
+                array.push(...value);
+                value = array;
+
             } else if (isMapKlass && !(value instanceof MapSchema)) {
-                value = new MapSchema(value);
+                const map: any = new MapSchema();
+                map[$childType] = type;
+                if (value instanceof Map) {
+                    value.forEach((v, k) => map.set(k, v));
+                } else {
+                    for (const k in value) { map.set(k, value[k]); }
+                }
+                value = map;
+
+            } else {
+                value[$childType] = type;
             }
-            value[$childType] = type;
 
             const changeTree = this[$changes];
             const ctor = this.constructor as typeof Schema;
@@ -569,9 +584,7 @@ export function getPropertyDescriptor(
 export function deprecated(throws: boolean = true): PropertyDecorator {
     return function (klass: typeof Schema, field: string) {
         const metadata = Metadata.initialize(klass.constructor as typeof Schema);
-        const fieldIndex = metadata[field];
-
-        metadata[fieldIndex].deprecated = true;
+        Metadata.setDeprecated(metadata, field);
 
         if (throws) {
             metadata[$descriptors] ??= {};
@@ -584,13 +597,6 @@ export function deprecated(throws: boolean = true): PropertyDecorator {
             // Override accessor on the prototype so deprecated throws at access.
             Object.defineProperty(klass, field, metadata[$descriptors][field]);
         }
-
-        // flag metadata[field] as non-enumerable
-        Object.defineProperty(metadata, fieldIndex, {
-            value: metadata[fieldIndex],
-            enumerable: false,
-            configurable: true
-        });
     }
 }
 
@@ -662,9 +668,13 @@ type HasExplicitInit<T> = T extends { initialize: (...args: infer P) => void }
  */
 export type FieldsAndMethods = Record<string, FieldBuilder<any, boolean, boolean> | (new (...args: any[]) => Schema) | Function>;
 
+// One spelling for every site that names the instance — identical
+// instantiations compare by identity, not structurally.
+type SchemaInstance<T, P extends typeof Schema> = InferSchemaInstanceType<T> & InstanceType<P>;
+
 export interface SchemaWithExtends<T, P extends typeof Schema> {
     extend: <T2 extends FieldsAndMethods = FieldsAndMethods>(
-        fields: T2 & ThisType<InferSchemaInstanceType<T & T2>>,
+        fields: T2 & ThisType<SchemaInstance<T & T2, P>>,
         name?: string,
     ) => SchemaWithExtendsConstructor<T & T2, ExtractInitProps<T & T2>, P>;
 }
@@ -686,7 +696,7 @@ export interface SchemaWithExtendsConstructor<
     InitProps,
     P extends typeof Schema
 > extends SchemaWithExtends<T, P> {
-    '~type': InferSchemaInstanceType<T>;
+    '~type': SchemaInstance<T, P>;
     // Constructor signature:
     //  - InitProps = never (zero-arg initialize): no args.
     //  - InitProps is a tuple (multi-arg initialize): spread it.
@@ -702,8 +712,8 @@ export interface SchemaWithExtendsConstructor<
         : HasExplicitInit<T> extends true ? [InitProps]
         : IsInitPropsRequired<T> extends true ? ([] | [InitProps])
         : [InitProps?]
-    ): InferSchemaInstanceType<T> & InstanceType<P>;
-    prototype: InferSchemaInstanceType<T> & InstanceType<P> & {
+    ): SchemaInstance<T, P>;
+    prototype: SchemaInstance<T, P> & {
         initialize(...args: [InitProps] extends [never] ? [] : InitProps extends readonly any[] ? InitProps : [InitProps]): void;
     };
 }
@@ -749,7 +759,7 @@ export function schema<
     T extends FieldsAndMethods,
     P extends typeof Schema = typeof Schema
 >(
-    fieldsAndMethods: T & ThisType<InferSchemaInstanceType<T>>,
+    fieldsAndMethods: T & ThisType<SchemaInstance<T, P>>,
     name?: string,
     inherits: P = Schema as P,
 ): SchemaWithExtendsConstructor<T, ExtractInitProps<T>, P> {

package/src/codegen/api.ts

@@ -24,6 +24,8 @@ export interface GenerateOptions {
     decorator?: string;
     namespace?: string;
     bundle?: boolean;
+    /** Overrides the nearest-tsconfig lookup used to resolve import path aliases. */
+    tsconfig?: string;
 }
 
 export function generate(targetId: string, options: GenerateOptions) {
@@ -53,7 +55,7 @@ export function generate(targetId: string, options: GenerateOptions) {
         return acc;
     }, [])
 
-    const structures = parseFiles(options.files, options.decorator);
+    const structures = parseFiles(options.files, options.decorator, undefined, { tsconfig: options.tsconfig });
 
     // Post-process classes before generating
     structures.classes.forEach(klass => klass.postProcessing());

package/src/codegen/cli.ts

@@ -21,7 +21,9 @@ ${Object.
 
 Optional:
     --namespace: generate namespace on output code
-    --decorator: custom name for @type decorator to scan for`);
+    --decorator: custom name for @type decorator to scan for
+    --tsconfig: tsconfig.json to resolve import path aliases with
+                (default: nearest tsconfig.json/jsconfig.json above each source file)`);
     process.exit(exitCode);
 }
 
@@ -49,7 +51,8 @@ try {
         decorator: args.decorator,
         output: args.output,
         namespace: args.namespace,
-        bundle: args.bundle
+        bundle: args.bundle,
+        tsconfig: args.tsconfig,
     });
 
 } catch (e) {