@colyseus/schema 4.0.26 → 4.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/schema",
-  "version": "4.0.26",
+  "version": "4.0.28",
   "description": "Binary state serializer with delta encoding for games",
   "type": "module",
   "bin": {
@@ -82,7 +82,12 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "typescript": "^5.0.0 || ^6.0.0"
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   },
   "c8": {
     "include": [

package/src/codegen/cli.ts

@@ -1,7 +1,7 @@
 import argv from "./argv.js";
 import { generate, generators } from "./api.js";
 
-function displayHelp() {
+function displayHelp(exitCode: number = 0) {
     console.log(`\nschema-codegen [path/to/Schema.ts]
 
 Usage (C#/Unity)
@@ -22,7 +22,7 @@ ${Object.
 Optional:
     --namespace: generate namespace on output code
     --decorator: custom name for @type decorator to scan for`);
-    process.exit();
+    process.exit(exitCode);
 }
 
 const args = argv(process.argv.slice(2));
@@ -39,7 +39,7 @@ for (let target in generators) {
 
 if (!args.output) {
     console.error("You must provide a valid --output directory.");
-    displayHelp();
+    displayHelp(1);
 }
 
 try {
@@ -55,5 +55,5 @@ try {
 } catch (e) {
     console.error(e.message);
     console.error(e.stack);
-    displayHelp();
+    displayHelp(1);
 }

package/src/codegen/parser.ts

@@ -339,6 +339,14 @@ export function parseFiles(
     decoratorName: string = "type",
     context: Context = new Context()
 ) {
+    if (typeof ts.createSourceFile !== "function") {
+        // typescript@7+ (native) no longer ships the JS compiler API
+        throw new Error(
+            `schema-codegen requires the TypeScript compiler API, which the installed "typescript@${(ts as any).version}" package does not provide.\n` +
+            `TypeScript 7+ no longer ships the JS compiler API — install typescript 5.x or 6.x (e.g. \`npm install --save-dev typescript@6\`) to use schema-codegen.`
+        );
+    }
+
     /**
      * Re-set globalContext for each test case
      */
@@ -389,7 +397,8 @@ export function parseFiles(
 
                 break;
             } catch (e) {
-                // console.log(`${fileNameAlternatives[i]} => ${e.message}`);
+                // only swallow fs errors (ENOENT/EISDIR) while probing alternatives
+                if (!e?.code) { throw e; }
             }
         }
 

package/src/encoder/Encoder.ts

@@ -126,36 +126,23 @@ export class Encoder<T extends Schema = any> {
             }
         }
 
-        if (it.offset > buffer.byteLength) {
-            // we can assume that n + 1 BUFFER_SIZE will suffice given that we are likely done with encoding at this point
-            // multiples of BUFFER_SIZE are faster to allocate than arbitrary sizes
-            const newSize = Math.ceil(it.offset / Encoder.BUFFER_SIZE) * Encoder.BUFFER_SIZE;
+        if (it.offset <= buffer.byteLength) {
+            return buffer.subarray(0, it.offset);
+        }
+
+        // Overflowed: grow and re-encode. Reuse the same iterator so `it.offset`
+        // ends accurate — a fresh one strands it at the overflow value and
+        // corrupts the next view's `viewOffset` in a multi-view encode.
+        buffer = this.ensureCapacity(buffer, it.offset);
 
-            console.warn(`@colyseus/schema buffer overflow. Encoded state is higher than default BUFFER_SIZE. Use the following to increase default BUFFER_SIZE:
+        console.warn(`@colyseus/schema buffer overflow. Encoded state is higher than default BUFFER_SIZE. Use the following to increase default BUFFER_SIZE:
 
     import { Encoder } from "@colyseus/schema";
-    Encoder.BUFFER_SIZE = ${Math.round(newSize / 1024)} * 1024; // ${Math.round(newSize / 1024)} KB
+    Encoder.BUFFER_SIZE = ${Math.round(buffer.byteLength / 1024)} * 1024; // ${Math.round(buffer.byteLength / 1024)} KB
 `);
 
-            //
-            // resize buffer and re-encode (TODO: can we avoid re-encoding here?)
-            // -> No we probably can't unless we catch the need for resize before encoding which is likely more computationally expensive than resizing on demand
-            //
-            const newBuffer = new Uint8Array(newSize);
-            newBuffer.set(buffer); // copy previous encoding steps beyond the initialOffset
-            buffer = newBuffer;
-
-            // assign resized buffer to local sharedBuffer
-            if (buffer === this.sharedBuffer) {
-                this.sharedBuffer = buffer;
-            }
-
-            return this.encode({ offset: initialOffset }, view, buffer, changeSetName, isEncodeAll);
-
-        } else {
-
-            return buffer.subarray(0, it.offset);
-        }
+        it.offset = initialOffset;
+        return this.encode(it, view, buffer, changeSetName, isEncodeAll);
     }
 
     encodeAll(
@@ -173,8 +160,8 @@ export class Encoder<T extends Schema = any> {
     ) {
         const viewOffset = it.offset;
 
-        // try to encode "filtered" changes
-        this.encode(it, view, bytes, "allFilteredChanges", true, viewOffset);
+        // encode() may reallocate the buffer — keep its return, not the stale `bytes`.
+        bytes = this.encode(it, view, bytes, "allFilteredChanges", true, viewOffset);
 
         return concatBytes(
             bytes.subarray(0, sharedOffset),
@@ -182,6 +169,16 @@ export class Encoder<T extends Schema = any> {
         );
     }
 
+    /** Grow `buffer` to keep BUFFER_SIZE free bytes past `offset`, preserving `[0, offset)`. */
+    protected ensureCapacity(buffer: Uint8Array, offset: number): Uint8Array {
+        if (offset + Encoder.BUFFER_SIZE <= buffer.byteLength) { return buffer; }
+        const size = Math.ceil((offset + Encoder.BUFFER_SIZE) / Encoder.BUFFER_SIZE) * Encoder.BUFFER_SIZE;
+        const grown = new Uint8Array(size);
+        grown.set(buffer.subarray(0, offset));
+        if (buffer === this.sharedBuffer) { this.sharedBuffer = grown; }
+        return grown;
+    }
+
     encodeView(
         view: StateView,
         sharedOffset: number,
@@ -232,6 +229,10 @@ export class Encoder<T extends Schema = any> {
             const encoder = ctor[$encoder];
             const metadata = ctor[Symbol.metadata];
 
+            // These writes are unguarded and unrecoverable (view.changes is cleared
+            // below), so unlike encode() they can't re-encode on overflow — grow ahead.
+            bytes = this.ensureCapacity(bytes, it.offset);
+
             bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
             encode.number(bytes, ref[$refId], it);
 
@@ -255,8 +256,10 @@ export class Encoder<T extends Schema = any> {
         view.changes.clear();
         view.changesOutOfOrder = false;
 
-        // try to encode "filtered" changes
-        this.encode(it, view, bytes, "filteredChanges", false, viewOffset);
+        // encode() may reallocate the buffer — keep its return, not the stale `bytes`.
+        // Anchor the re-encode at the current offset (default), not `viewOffset`: a
+        // resize must not clobber the view.changes already written at [viewOffset, ).
+        bytes = this.encode(it, view, bytes, "filteredChanges", false);
 
         return concatBytes(
             bytes.subarray(0, sharedOffset),