@hpx7/delta-pack-cli 0.1.4 → 0.2.1

package/dist/index.js

@@ -8003,38 +8003,6 @@ var require_dist = __commonJS((exports) => {
   exports.visit = visit.visit;
   exports.visitAsync = visit.visitAsync;
 });
-// package.json
-var package_default = {
-  name: "@hpx7/delta-pack-cli",
-  version: "0.1.4",
-  license: "MIT",
-  author: "hpx7",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/hpx7/delta-pack.git",
-    directory: "cli"
-  },
-  type: "module",
-  bin: {
-    "delta-pack": "dist/index.js"
-  },
-  files: [
-    "dist"
-  ],
-  scripts: {
-    build: "bun build src/index.ts --outdir dist --target node",
-    test: "bun test"
-  },
-  dependencies: {
-    "@hpx7/delta-pack": "^0.2.3"
-  },
-  devDependencies: {
-    "@types/bun": "latest"
-  }
-};
-
-// src/commands/generate.ts
-import { readFile as readFile2 } from "node:fs/promises";
 
 // node_modules/@hpx7/delta-pack/dist/unified.js
 var SCHEMA_TYPE = "deltapack:schemaType";
@@ -8080,7 +8048,7 @@ function isPrimitiveOrEnum(type) {
   if (type.type === "reference") {
     return isPrimitiveOrEnum(type.ref);
   }
-  return type.type === "string" || type.type === "int" || type.type === "uint" || type.type === "float" || type.type === "boolean" || type.type === "enum";
+  return type.type === "string" || type.type === "int" || type.type === "float" || type.type === "boolean" || type.type === "enum";
 }
 function StringType() {
   return createUnifiedType({ type: "string" });
@@ -8088,11 +8056,18 @@ function StringType() {
 function BooleanType() {
   return createUnifiedType({ type: "boolean" });
 }
-function IntType() {
-  return createUnifiedType({ type: "int" });
-}
-function UIntType() {
-  return createUnifiedType({ type: "uint" });
+function IntType(options) {
+  const min = options?.min != null ? typeof options.min === "string" ? parseInt(options.min) : options.min : undefined;
+  const max = options?.max != null ? typeof options.max === "string" ? parseInt(options.max) : options.max : undefined;
+  if (max != null && min != null && min > max) {
+    throw new Error(`Invalid int range: min (${min}) > max (${max})`);
+  }
+  const type = { type: "int" };
+  if (min != null)
+    type.min = min;
+  if (max != null)
+    type.max = max;
+  return createUnifiedType(type);
 }
 function FloatType(options) {
   if (typeof options?.precision === "number") {
@@ -8137,7 +8112,8 @@ function SelfReferenceType() {
   return createUnifiedType({ type: "self-reference" });
 }
 function EnumType(name, options) {
-  return { type: "enum", options, name };
+  const numBits = options.length <= 1 ? 1 : Math.ceil(Math.log2(options.length));
+  return { type: "enum", options, name, numBits };
 }
 function ObjectType(name, properties) {
   const cleanProperties = {};
@@ -8154,11 +8130,161 @@ function UnionType(name, options) {
       classes: options
     };
   }
-  return { type: "union", options, name };
+  const numBits = options.length <= 1 ? 1 : Math.ceil(Math.log2(options.length));
+  return { type: "union", options, name, numBits };
 }
 // node_modules/@hpx7/delta-pack/dist/decorator.js
 var import_reflect_metadata = __toESM(require_Reflect(), 1);
 
+// node_modules/@hpx7/delta-pack/dist/helpers.js
+var FLOAT_EPSILON = 0.001;
+function parseString(x) {
+  if (typeof x !== "string") {
+    throw new Error(`Invalid string: ${x}`);
+  }
+  return x;
+}
+function parseInt2(x, min, max) {
+  if (typeof x === "string") {
+    x = Number(x);
+  }
+  if (typeof x !== "number" || !Number.isInteger(x)) {
+    throw new Error(`Invalid int: ${x}`);
+  }
+  if (min != null && x < min) {
+    throw new Error(`Value ${x} below minimum ${min}`);
+  }
+  if (max != null && x > max) {
+    throw new Error(`Value ${x} above maximum ${max}`);
+  }
+  return x;
+}
+function parseFloat2(x) {
+  if (typeof x === "string") {
+    x = Number(x);
+  }
+  if (typeof x !== "number" || Number.isNaN(x) || !Number.isFinite(x)) {
+    throw new Error(`Invalid float: ${x}`);
+  }
+  return x;
+}
+function parseBoolean(x) {
+  if (x === "true") {
+    return true;
+  }
+  if (x === "false") {
+    return false;
+  }
+  if (typeof x !== "boolean") {
+    throw new Error(`Invalid boolean: ${x}`);
+  }
+  return x;
+}
+function parseEnum(x, enumObj) {
+  if (typeof x !== "string" || !(x in enumObj)) {
+    throw new Error(`Invalid enum: ${x}`);
+  }
+  return x;
+}
+function parseOptional(x, innerParse) {
+  if (x == null) {
+    return;
+  }
+  try {
+    return innerParse(x);
+  } catch (err) {
+    throw new Error(`Invalid optional: ${x}`, { cause: err });
+  }
+}
+function parseArray(x, innerParse) {
+  if (!Array.isArray(x)) {
+    throw new Error(`Invalid array, got ${typeof x}`);
+  }
+  return x.map((y, i) => {
+    try {
+      return innerParse(y);
+    } catch (err) {
+      throw new Error(`Invalid array element at index ${i}: ${y}`, { cause: err });
+    }
+  });
+}
+function parseRecord(x, innerKeyParse, innerValParse) {
+  if (typeof x !== "object" || x == null) {
+    throw new Error(`Invalid record, got ${typeof x}`);
+  }
+  const proto = Object.getPrototypeOf(x);
+  if (proto === Object.prototype || proto == null) {
+    x = new Map(Object.entries(x));
+  }
+  if (!(x instanceof Map)) {
+    throw new Error(`Invalid record, got ${typeof x}`);
+  }
+  const result = new Map;
+  for (const [key, val] of x) {
+    try {
+      result.set(innerKeyParse(key), innerValParse(val));
+    } catch (err) {
+      throw new Error(`Invalid record element (${key}, ${val})`, { cause: err });
+    }
+  }
+  return result;
+}
+function tryParseField(parseFn, key) {
+  try {
+    return parseFn();
+  } catch (err) {
+    throw new Error(`Invalid field ${key}`, { cause: err });
+  }
+}
+function equalsFloat(a, b) {
+  return Math.abs(a - b) < FLOAT_EPSILON;
+}
+function equalsFloatQuantized(a, b, precision) {
+  return Math.round(a / precision) === Math.round(b / precision);
+}
+function equalsArray(a, b, equals) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0;i < a.length; i++) {
+    if (!equals(a[i], b[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+function equalsRecord(a, b, keyEquals, valueEquals) {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const [aKey, aVal] of a) {
+    let found = false;
+    for (const [bKey, bVal] of b) {
+      if (keyEquals(aKey, bKey)) {
+        if (!valueEquals(aVal, bVal)) {
+          return false;
+        }
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      return false;
+    }
+  }
+  return true;
+}
+function mapValues(obj, fn) {
+  return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value, key)]));
+}
+function mapToObject(map, valueToObject) {
+  const obj = {};
+  map.forEach((value, key) => {
+    obj[String(key)] = valueToObject(value);
+  });
+  return obj;
+}
+
 // node_modules/bin-serde/lib/utf8-buffer.js
 var textDecoder = new TextDecoder;
 var hasBuffer = typeof Buffer !== "undefined";
@@ -8449,7 +8575,7 @@ class Reader {
   }
 }
 
-// node_modules/@hpx7/delta-pack/dist/helpers.js
+// node_modules/@hpx7/delta-pack/dist/encoder.js
 var import_utf8_buffer_size2 = __toESM(require_utf8_buffer_size_umd(), 1);
 
 // node_modules/@hpx7/delta-pack/dist/rle.js
@@ -8522,20 +8648,28 @@ function rleEncode(bits, writer) {
 }
 function rleDecode(buf) {
   const { value: numBits, bytesRead: varintLen } = readReverseUVarint(buf);
-  if (numBits === 0) {
-    return [];
-  }
   const numRleBytes = Math.ceil(numBits / 8);
   let bytePos = buf.length - varintLen - numRleBytes;
   let currentByte = 0;
   let bitPos = 8;
-  let bitsRead = 0;
+  let currentValue = readBit();
+  let runRemaining = decodeRunLength();
+  function decodeRunLength() {
+    if (!readBit())
+      return 1;
+    if (!readBit())
+      return readBits(1) + 2;
+    if (!readBit())
+      return readBits(1) + 4;
+    if (!readBit())
+      return readBits(3) + 6;
+    return readBits(8) + 14;
+  }
   function readBit() {
     if (bitPos === 8) {
       currentByte = buf[bytePos++];
       bitPos = 0;
     }
-    bitsRead++;
     return (currentByte >> bitPos++ & 1) === 1;
   }
   function readBits(numBits2) {
@@ -8547,35 +8681,14 @@ function rleDecode(buf) {
     }
     return val;
   }
-  const bits = [];
-  let last = readBit();
-  while (bitsRead < numBits) {
-    if (!readBit()) {
-      bits.push(last);
-    } else if (!readBit()) {
-      const count = readBits(1) + 2;
-      for (let i = 0;i < count; i++) {
-        bits.push(last);
-      }
-    } else if (!readBit()) {
-      const count = readBits(1) + 4;
-      for (let i = 0;i < count; i++) {
-        bits.push(last);
-      }
-    } else if (!readBit()) {
-      const count = readBits(3) + 6;
-      for (let i = 0;i < count; i++) {
-        bits.push(last);
-      }
-    } else {
-      const count = readBits(8) + 14;
-      for (let i = 0;i < count; i++) {
-        bits.push(last);
-      }
+  return () => {
+    if (runRemaining === 0) {
+      currentValue = !currentValue;
+      runRemaining = decodeRunLength();
     }
-    last = !last;
-  }
-  return bits;
+    runRemaining--;
+    return currentValue;
+  };
 }
 function writeReverseUVarint(writer, val) {
   if (val < 128) {
@@ -8597,9 +8710,7 @@ function readReverseUVarint(buf) {
   throw new Error("Invalid varint");
 }
 
-// node_modules/@hpx7/delta-pack/dist/helpers.js
-var FLOAT_EPSILON = 0.001;
-
+// node_modules/@hpx7/delta-pack/dist/encoder.js
 class Encoder {
   dict = [];
   bits = [];
@@ -8622,8 +8733,11 @@ class Encoder {
   pushInt(val) {
     this.writer.writeVarint(val);
   }
-  pushUInt(val) {
-    this.writer.writeUVarint(val);
+  pushBoundedInt(val, min) {
+    this.writer.writeUVarint(val - min);
+  }
+  pushBoundedIntDiff(a, b, min) {
+    this.pushUIntDiff(a - min, b - min);
   }
   pushFloat(val) {
     this.writer.writeFloat(val);
@@ -8634,6 +8748,11 @@ class Encoder {
   pushBoolean(val) {
     this.bits.push(val);
   }
+  pushEnum(val, numBits) {
+    for (let i = numBits - 1;i >= 0; i--) {
+      this.bits.push((val >> i & 1) === 1);
+    }
+  }
   pushOptional(val, innerWrite) {
     this.pushBoolean(val != null);
     if (val != null) {
@@ -8641,13 +8760,13 @@ class Encoder {
     }
   }
   pushArray(val, innerWrite) {
-    this.pushUInt(val.length);
+    this.writer.writeUVarint(val.length);
     for (const item of val) {
       innerWrite(item);
     }
   }
   pushRecord(val, innerKeyWrite, innerValWrite) {
-    this.pushUInt(val.size);
+    this.writer.writeUVarint(val.size);
     for (const [key, value] of val) {
       innerKeyWrite(key);
       innerValWrite(value);
@@ -8668,12 +8787,6 @@ class Encoder {
       this.pushInt(b);
     }
   }
-  pushUIntDiff(a, b) {
-    this.pushBoolean(a !== b);
-    if (a !== b) {
-      this.pushUInt(b);
-    }
-  }
   pushFloatDiff(a, b) {
     const changed = !equalsFloat(a, b);
     this.pushBoolean(changed);
@@ -8687,6 +8800,12 @@ class Encoder {
   pushBooleanDiff(a, b) {
     this.pushBoolean(a !== b);
   }
+  pushEnumDiff(a, b, numBits) {
+    this.pushBoolean(a !== b);
+    if (a !== b) {
+      this.pushEnum(b, numBits);
+    }
+  }
   pushOptionalDiffPrimitive(a, b, encode) {
     if (a == null) {
       this.pushBoolean(b != null);
@@ -8724,7 +8843,7 @@ class Encoder {
     if (!changed) {
       return;
     }
-    this.pushUInt(b.length);
+    this.writer.writeUVarint(b.length);
     const minLen = Math.min(a.length, b.length);
     for (let i = 0;i < minLen; i++) {
       const elementChanged = dirty != null ? dirty.has(i) : !equals(a[i], b[i]);
@@ -8777,18 +8896,18 @@ class Encoder {
       });
     }
     if (a.size > 0) {
-      this.pushUInt(deletions.length);
+      this.writer.writeUVarint(deletions.length);
       deletions.forEach((idx) => {
-        this.pushUInt(idx);
+        this.writer.writeUVarint(idx);
       });
-      this.pushUInt(updates.length);
+      this.writer.writeUVarint(updates.length);
       updates.forEach((idx) => {
-        this.pushUInt(idx);
+        this.writer.writeUVarint(idx);
         const key = orderedKeys[idx];
         encodeDiff(a.get(key), b.get(key));
       });
     }
-    this.pushUInt(additions.length);
+    this.writer.writeUVarint(additions.length);
     additions.forEach(([key, val]) => {
       encodeKey(key);
       encodeVal(val);
@@ -8798,15 +8917,21 @@ class Encoder {
     rleEncode(this.bits, this.writer);
     return this.writer.toBuffer();
   }
+  pushUIntDiff(a, b) {
+    this.pushBoolean(a !== b);
+    if (a !== b) {
+      this.writer.writeUVarint(b);
+    }
+  }
 }
 
+// node_modules/@hpx7/delta-pack/dist/decoder.js
 class Decoder {
   dict = [];
-  bitsIdx = 0;
-  bits;
+  nextBit;
   reader;
   constructor(buf) {
-    this.bits = rleDecode(buf);
+    this.nextBit = rleDecode(buf);
     this.reader = new Reader(buf);
   }
   nextString() {
@@ -8824,8 +8949,11 @@ class Decoder {
   nextInt() {
     return this.reader.readVarint();
   }
-  nextUInt() {
-    return this.reader.readUVarint();
+  nextBoundedInt(min) {
+    return this.reader.readUVarint() + min;
+  }
+  nextBoundedIntDiff(a, min) {
+    return this.nextUIntDiff(a - min) + min;
   }
   nextFloat() {
     return this.reader.readFloat();
@@ -8834,13 +8962,20 @@ class Decoder {
     return this.nextInt() * precision;
   }
   nextBoolean() {
-    return this.bits[this.bitsIdx++];
+    return this.nextBit();
+  }
+  nextEnum(numBits) {
+    let val = 0;
+    for (let i = 0;i < numBits; i++) {
+      val = val << 1 | (this.nextBit() ? 1 : 0);
+    }
+    return val;
   }
   nextOptional(innerRead) {
     return this.nextBoolean() ? innerRead() : undefined;
   }
   nextArray(innerRead) {
-    const len = this.nextUInt();
+    const len = this.reader.readUVarint();
     const arr = new Array(len);
     for (let i = 0;i < len; i++) {
       arr[i] = innerRead();
@@ -8848,7 +8983,7 @@ class Decoder {
     return arr;
   }
   nextRecord(innerKeyRead, innerValRead) {
-    const len = this.nextUInt();
+    const len = this.reader.readUVarint();
     const obj = new Map;
     for (let i = 0;i < len; i++) {
       obj.set(innerKeyRead(), innerValRead());
@@ -8866,10 +9001,6 @@ class Decoder {
     const changed = this.nextBoolean();
     return changed ? this.nextInt() : a;
   }
-  nextUIntDiff(a) {
-    const changed = this.nextBoolean();
-    return changed ? this.nextUInt() : a;
-  }
   nextFloatDiff(a) {
     const changed = this.nextBoolean();
     return changed ? this.nextFloat() : a;
@@ -8882,6 +9013,10 @@ class Decoder {
     const changed = this.nextBoolean();
     return changed ? !a : a;
   }
+  nextEnumDiff(a, numBits) {
+    const changed = this.nextBoolean();
+    return changed ? this.nextEnum(numBits) : a;
+  }
   nextOptionalDiffPrimitive(obj, decode) {
     if (obj == null) {
       const present = this.nextBoolean();
@@ -8909,7 +9044,7 @@ class Decoder {
     if (!changed) {
       return arr;
     }
-    const newLen = this.nextUInt();
+    const newLen = this.reader.readUVarint();
     const newArr = [];
     const minLen = Math.min(arr.length, newLen);
     for (let i = 0;i < minLen; i++) {
@@ -8929,18 +9064,18 @@ class Decoder {
     const result = new Map(obj);
     const orderedKeys = [...obj.keys()].sort();
     if (obj.size > 0) {
-      const numDeletions = this.nextUInt();
+      const numDeletions = this.reader.readUVarint();
       for (let i = 0;i < numDeletions; i++) {
-        const key = orderedKeys[this.nextUInt()];
+        const key = orderedKeys[this.reader.readUVarint()];
         result.delete(key);
       }
-      const numUpdates = this.nextUInt();
+      const numUpdates = this.reader.readUVarint();
       for (let i = 0;i < numUpdates; i++) {
-        const key = orderedKeys[this.nextUInt()];
+        const key = orderedKeys[this.reader.readUVarint()];
         result.set(key, decodeDiff(result.get(key)));
       }
     }
-    const numAdditions = this.nextUInt();
+    const numAdditions = this.reader.readUVarint();
     for (let i = 0;i < numAdditions; i++) {
       const key = decodeKey();
       const val = decodeVal();
@@ -8948,172 +9083,25 @@ class Decoder {
     }
     return result;
   }
-}
-function parseString(x) {
-  if (typeof x !== "string") {
-    throw new Error(`Invalid string: ${x}`);
-  }
-  return x;
-}
-function parseInt2(x) {
-  if (typeof x === "string") {
-    x = Number(x);
-  }
-  if (typeof x !== "number" || !Number.isInteger(x)) {
-    throw new Error(`Invalid int: ${x}`);
-  }
-  return x;
-}
-function parseUInt(x) {
-  if (typeof x === "string") {
-    x = Number(x);
-  }
-  if (typeof x !== "number" || !Number.isInteger(x) || x < 0) {
-    throw new Error(`Invalid uint: ${x}`);
-  }
-  return x;
-}
-function parseFloat2(x) {
-  if (typeof x === "string") {
-    x = Number(x);
-  }
-  if (typeof x !== "number" || Number.isNaN(x) || !Number.isFinite(x)) {
-    throw new Error(`Invalid float: ${x}`);
+  nextUIntDiff(a) {
+    const changed = this.nextBoolean();
+    return changed ? this.reader.readUVarint() : a;
   }
-  return x;
 }
-function parseBoolean(x) {
-  if (x === "true") {
-    return true;
-  }
-  if (x === "false") {
-    return false;
+
+// node_modules/@hpx7/delta-pack/dist/interpreter.js
+function load(rootType) {
+  function prop(obj, key) {
+    return obj[key];
   }
-  if (typeof x !== "boolean") {
-    throw new Error(`Invalid boolean: ${x}`);
-  }
-  return x;
-}
-function parseEnum(x, enumObj) {
-  if (typeof x !== "string" || !(x in enumObj)) {
-    throw new Error(`Invalid enum: ${x}`);
-  }
-  return x;
-}
-function parseOptional(x, innerParse) {
-  if (x == null) {
-    return;
-  }
-  try {
-    return innerParse(x);
-  } catch (err) {
-    throw new Error(`Invalid optional: ${x}`, { cause: err });
-  }
-}
-function parseArray(x, innerParse) {
-  if (!Array.isArray(x)) {
-    throw new Error(`Invalid array, got ${typeof x}`);
-  }
-  return x.map((y, i) => {
-    try {
-      return innerParse(y);
-    } catch (err) {
-      throw new Error(`Invalid array element at index ${i}: ${y}`, { cause: err });
-    }
-  });
-}
-function parseRecord(x, innerKeyParse, innerValParse) {
-  if (typeof x !== "object" || x == null) {
-    throw new Error(`Invalid record, got ${typeof x}`);
-  }
-  const proto = Object.getPrototypeOf(x);
-  if (proto === Object.prototype || proto === null) {
-    x = new Map(Object.entries(x));
-  }
-  if (!(x instanceof Map)) {
-    throw new Error(`Invalid record, got ${typeof x}`);
-  }
-  const result = new Map;
-  for (const [key, val] of x) {
-    try {
-      result.set(innerKeyParse(key), innerValParse(val));
-    } catch (err) {
-      throw new Error(`Invalid record element (${key}, ${val})`, { cause: err });
-    }
-  }
-  return result;
-}
-function tryParseField(parseFn, key) {
-  try {
-    return parseFn();
-  } catch (err) {
-    throw new Error(`Invalid field ${key}`, { cause: err });
-  }
-}
-function equalsFloat(a, b) {
-  return Math.abs(a - b) < FLOAT_EPSILON;
-}
-function equalsFloatQuantized(a, b, precision) {
-  return Math.round(a / precision) === Math.round(b / precision);
-}
-function equalsArray(a, b, equals) {
-  if (a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0;i < a.length; i++) {
-    if (!equals(a[i], b[i])) {
-      return false;
-    }
-  }
-  return true;
-}
-function equalsRecord(a, b, keyEquals, valueEquals) {
-  if (a.size !== b.size) {
-    return false;
-  }
-  for (const [aKey, aVal] of a) {
-    let found = false;
-    for (const [bKey, bVal] of b) {
-      if (keyEquals(aKey, bKey)) {
-        if (!valueEquals(aVal, bVal)) {
-          return false;
-        }
-        found = true;
-        break;
-      }
-    }
-    if (!found) {
-      return false;
-    }
-  }
-  return true;
-}
-function mapValues(obj, fn) {
-  return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value, key)]));
-}
-function mapToObject(map, valueToObject) {
-  const obj = {};
-  map.forEach((value, key) => {
-    obj[String(key)] = valueToObject(value);
-  });
-  return obj;
-}
-
-// node_modules/@hpx7/delta-pack/dist/interpreter.js
-function load(rootType) {
-  function prop(obj, key) {
-    return obj[key];
-  }
-  function enumIndices(options) {
-    return Object.fromEntries(options.map((opt, i) => [opt, i]));
+  function enumIndices(options) {
+    return Object.fromEntries(options.map((opt, i) => [opt, i]));
   }
   function _fromJson(objVal, objType, parent) {
     if (objType.type === "string") {
       return parseString(objVal);
     } else if (objType.type === "int") {
-      return parseInt2(objVal);
-    } else if (objType.type === "uint") {
-      return parseUInt(objVal);
+      return parseInt2(objVal, objType.min, objType.max);
     } else if (objType.type === "float") {
       return parseFloat2(objVal);
     } else if (objType.type === "boolean") {
@@ -9168,7 +9156,7 @@ function load(rootType) {
     throw new Error(`Unknown type: ${objType}`);
   }
   function _toJson(objVal, objType, parent) {
-    if (objType.type === "string" || objType.type === "int" || objType.type === "uint" || objType.type === "float" || objType.type === "boolean" || objType.type === "enum") {
+    if (objType.type === "string" || objType.type === "int" || objType.type === "float" || objType.type === "boolean" || objType.type === "enum") {
       return objVal;
     } else if (objType.type === "reference") {
       return _toJson(objVal, objType.ref, objType.ref);
@@ -9211,9 +9199,12 @@ function load(rootType) {
     if (objType.type === "string") {
       encoder.pushString(objVal);
     } else if (objType.type === "int") {
-      encoder.pushInt(objVal);
-    } else if (objType.type === "uint") {
-      encoder.pushUInt(objVal);
+      const val = objVal;
+      if (objType.min != null) {
+        encoder.pushBoundedInt(val, objType.min);
+      } else {
+        encoder.pushInt(val);
+      }
     } else if (objType.type === "float") {
       if (objType.precision) {
         encoder.pushFloatQuantized(objVal, objType.precision);
@@ -9223,7 +9214,7 @@ function load(rootType) {
     } else if (objType.type === "boolean") {
       encoder.pushBoolean(objVal);
     } else if (objType.type === "enum") {
-      encoder.pushUInt(enumIndices(objType.options)[objVal]);
+      encoder.pushEnum(enumIndices(objType.options)[objVal], objType.numBits);
     } else if (objType.type === "reference") {
       _encode(objVal, objType.ref, encoder, objType.ref);
     } else if (objType.type === "self-reference") {
@@ -9245,7 +9236,7 @@ function load(rootType) {
         throw new Error(`Unknown union variant: ${union.type}`);
       }
       const variant = objType.options[variantIndex];
-      encoder.pushUInt(variantIndex);
+      encoder.pushEnum(variantIndex, objType.numBits);
       _encode(union.val, variant, encoder, variant);
     } else if (objType.type === "optional") {
       encoder.pushOptional(objVal, (val) => _encode(val, objType.value, encoder, parent));
@@ -9255,9 +9246,11 @@ function load(rootType) {
     if (objType.type === "string") {
       return decoder.nextString();
     } else if (objType.type === "int") {
-      return decoder.nextInt();
-    } else if (objType.type === "uint") {
-      return decoder.nextUInt();
+      if (objType.min != null) {
+        return decoder.nextBoundedInt(objType.min);
+      } else {
+        return decoder.nextInt();
+      }
     } else if (objType.type === "float") {
       if (objType.precision) {
         return decoder.nextFloatQuantized(objType.precision);
@@ -9267,7 +9260,7 @@ function load(rootType) {
     } else if (objType.type === "boolean") {
       return decoder.nextBoolean();
     } else if (objType.type === "enum") {
-      return objType.options[decoder.nextUInt()];
+      return objType.options[decoder.nextEnum(objType.numBits)];
     } else if (objType.type === "reference") {
       return _decode(objType.ref, decoder, objType.ref);
     } else if (objType.type === "self-reference") {
@@ -9279,23 +9272,11 @@ function load(rootType) {
       }
       return result;
     } else if (objType.type === "array") {
-      const length = decoder.nextUInt();
-      const arr = [];
-      for (let i = 0;i < length; i++) {
-        arr.push(_decode(objType.value, decoder, parent));
-      }
-      return arr;
+      return decoder.nextArray(() => _decode(objType.value, decoder, parent));
     } else if (objType.type === "record") {
-      const size = decoder.nextUInt();
-      const map = new Map;
-      for (let i = 0;i < size; i++) {
-        const key = _decode(objType.key, decoder, parent);
-        const val = _decode(objType.value, decoder, parent);
-        map.set(key, val);
-      }
-      return map;
+      return decoder.nextRecord(() => _decode(objType.key, decoder, parent), () => _decode(objType.value, decoder, parent));
     } else if (objType.type === "union") {
-      const variantIndex = decoder.nextUInt();
+      const variantIndex = decoder.nextEnum(objType.numBits);
       const variant = objType.options[variantIndex];
       if (!variant) {
         throw new Error(`Invalid union variant index: ${variantIndex}`);
@@ -9310,7 +9291,7 @@ function load(rootType) {
     throw new Error(`Unknown type: ${objType}`);
   }
   function _equals(a, b, objType, parent) {
-    if (objType.type === "string" || objType.type === "int" || objType.type === "uint") {
+    if (objType.type === "string" || objType.type === "int") {
       return a === b;
     } else if (objType.type === "float") {
       if (objType.precision) {
@@ -9376,7 +9357,7 @@ function load(rootType) {
     return true;
   }
   function _clone(obj, objType, parent) {
-    if (objType.type === "string" || objType.type === "int" || objType.type === "uint" || objType.type === "float" || objType.type === "boolean" || objType.type === "enum") {
+    if (objType.type === "string" || objType.type === "int" || objType.type === "float" || objType.type === "boolean" || objType.type === "enum") {
       return obj;
     } else if (objType.type === "reference") {
       return _clone(obj, objType.ref, objType.ref);
@@ -9419,9 +9400,11 @@ function load(rootType) {
     if (objType.type === "string") {
       encoder.pushStringDiff(a, b);
     } else if (objType.type === "int") {
-      encoder.pushIntDiff(a, b);
-    } else if (objType.type === "uint") {
-      encoder.pushUIntDiff(a, b);
+      if (objType.min != null) {
+        encoder.pushBoundedIntDiff(a, b, objType.min);
+      } else {
+        encoder.pushIntDiff(a, b);
+      }
     } else if (objType.type === "float") {
       if (objType.precision) {
         return encoder.pushFloatQuantizedDiff(a, b, objType.precision);
@@ -9432,7 +9415,7 @@ function load(rootType) {
       encoder.pushBooleanDiff(a, b);
     } else if (objType.type === "enum") {
       const indices = enumIndices(objType.options);
-      encoder.pushUIntDiff(indices[a], indices[b]);
+      encoder.pushEnumDiff(indices[a], indices[b], objType.numBits);
     } else if (objType.type === "reference") {
       _encodeDiff(a, b, objType.ref, encoder, objType.ref);
     } else if (objType.type === "self-reference") {
@@ -9465,7 +9448,7 @@ function load(rootType) {
         encoder.pushBoolean(false);
         const variantIndex = objType.options.findIndex((v) => v.name === unionB.type);
         const variant = objType.options[variantIndex];
-        encoder.pushUInt(variantIndex);
+        encoder.pushEnum(variantIndex, objType.numBits);
         _encode(unionB.val, variant, encoder, variant);
       } else {
         encoder.pushBoolean(true);
@@ -9485,9 +9468,11 @@ function load(rootType) {
     if (objType.type === "string") {
       return decoder.nextStringDiff(a);
     } else if (objType.type === "int") {
-      return decoder.nextIntDiff(a);
-    } else if (objType.type === "uint") {
-      return decoder.nextUIntDiff(a);
+      if (objType.min != null) {
+        return decoder.nextBoundedIntDiff(a, objType.min);
+      } else {
+        return decoder.nextIntDiff(a);
+      }
     } else if (objType.type === "float") {
       if (objType.precision) {
         return decoder.nextFloatQuantizedDiff(a, objType.precision);
@@ -9497,7 +9482,7 @@ function load(rootType) {
     } else if (objType.type === "boolean") {
       return decoder.nextBoolean() ? !a : a;
     } else if (objType.type === "enum") {
-      const newIdx = decoder.nextUIntDiff(enumIndices(objType.options)[a]);
+      const newIdx = decoder.nextEnumDiff(enumIndices(objType.options)[a], objType.numBits);
       return objType.options[newIdx];
     } else if (objType.type === "reference") {
       return _decodeDiff(a, objType.ref, decoder, objType.ref);
@@ -9522,7 +9507,7 @@ function load(rootType) {
       const unionA = a;
       const sameType = decoder.nextBoolean();
       if (!sameType) {
-        const variantIndex = decoder.nextUInt();
+        const variantIndex = decoder.nextEnum(objType.numBits);
         const variant = objType.options[variantIndex];
         if (!variant) {
           throw new Error(`Invalid union variant index: ${variantIndex}`);
@@ -9620,10 +9605,16 @@ function parseSchemaYml(yamlContent) {
         return RecordType(keyType, valueType);
       } else if (value.startsWith("string")) {
         return StringType();
-      } else if (value.startsWith("int")) {
-        return IntType();
       } else if (value.startsWith("uint")) {
-        return UIntType();
+        const params = parseParams(value, "uint");
+        const max = params["max"];
+        if (max != null) {
+          return IntType({ min: params["min"] ?? 0, max });
+        }
+        return IntType({ min: params["min"] ?? 0 });
+      } else if (value.startsWith("int")) {
+        const params = parseParams(value, "int");
+        return IntType(params);
       } else if (value.startsWith("float")) {
         const params = parseParams(value, "float");
         return FloatType(params);
@@ -9712,15 +9703,790 @@ function parseParams(value, typeName) {
   }
   return params;
 }
-// node_modules/@hpx7/delta-pack/dist/codegen.js
-function codegenTypescript(schema) {
-  return renderSchema(schema);
+// src/codegen/csharp.ts
+function codegenCsharp(schema2, namespace = "Generated") {
+  return renderSchema(schema2, namespace);
 }
-function renderSchema(schema) {
+function renderSchema(schema2, namespace) {
   let currentTypeName;
-  return `import * as _ from "@hpx7/delta-pack/helpers";
+  function qualifyType(typeName) {
+    return `${namespace}.${typeName}`;
+  }
+  const variantToUnion = new Map;
+  for (const [name, type] of Object.entries(schema2)) {
+    if (type.type === "union") {
+      for (const option of type.options) {
+        variantToUnion.set(option.name, name);
+      }
+    }
+  }
+  const enums = [];
+  const classes = [];
+  for (const [name, type] of Object.entries(schema2)) {
+    currentTypeName = name;
+    if (type.type === "enum") {
+      enums.push(renderEnum(name, type.options));
+    } else if (type.type === "object") {
+      const baseClass = variantToUnion.get(name);
+      classes.push(renderObject(name, type.properties, baseClass));
+    } else if (type.type === "union") {
+      classes.push(renderUnion(name, type.options, type.numBits));
+    }
+  }
+  return `// Auto-generated by DeltaPack - do not edit
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using DeltaPack;
+
+namespace ${namespace}
+{
+${[...enums, ...classes].join(`
+
+`)}
+}
+`;
+  function renderEnum(name, options) {
+    const enumValues = options.map((opt, i) => `        ${toPascalCase(opt)} = ${i}`).join(`,
+`);
+    return `    public enum ${name}
+    {
+${enumValues}
+    }`;
+  }
+  function renderObject(name, properties, baseClass) {
+    const props = Object.entries(properties);
+    const isVariant = baseClass != null;
+    const typeProperty = isVariant ? `        public override string Type => "${name}";
+
+` : "";
+    const propertyLines = props.map(([propName, propType]) => {
+      const csType = renderTypeArg(propType, propName);
+      if (propType.type === "boolean" || propType.type === "optional" || propType.type === "int" || propType.type === "float") {
+        return `        public ${csType} ${toPascalCase(propName)} { get; set; }`;
+      }
+      const defaultVal = renderDefault(propType, propName);
+      return `        public ${csType} ${toPascalCase(propName)} { get; set; } = ${defaultVal};`;
+    }).join(`
+`);
+    const newModifier = isVariant ? "new " : "";
+    const defaultMethod = `        public static ${newModifier}${name} Default() => new ${name}();`;
+    const fromJsonBody = props.map(([propName, propType]) => {
+      if (propType.type === "optional") {
+        const varName = `${propName}El`;
+        return `                ${toPascalCase(propName)} = json.TryGetProperty("${propName}", out var ${varName}) ? ${renderFromJson(propType, propName, varName)} : null,`;
+      }
+      return `                ${toPascalCase(propName)} = ${renderFromJson(propType, propName, `json.GetProperty("${propName}")`)},`;
+    }).join(`
+`);
+    const fromJsonMethod = `        public static ${newModifier}${name} FromJson(JsonElement json)
+        {
+            return new ${name}
+            {
+${fromJsonBody}
+            };
+        }`;
+    const toJsonBody = props.map(([propName, propType]) => {
+      if (propType.type === "optional") {
+        const nullCheck = isValueType(propType.value) ? `obj.${toPascalCase(propName)}.HasValue` : `obj.${toPascalCase(propName)} != null`;
+        return `            if (${nullCheck}) result["${propName}"] = ${renderToJson(propType, propName, `obj.${toPascalCase(propName)}`)};`;
+      }
+      return `            result["${propName}"] = ${renderToJson(propType, propName, `obj.${toPascalCase(propName)}`)};`;
+    }).join(`
+`);
+    const toJsonMethod = `        public static JsonObject ToJson(${name} obj)
+        {
+            var result = new JsonObject();
+${toJsonBody}
+            return result;
+        }`;
+    const cloneBody = props.map(([propName, propType]) => {
+      return `                ${toPascalCase(propName)} = ${renderClone(propType, propName, `obj.${toPascalCase(propName)}`)},`;
+    }).join(`
+`);
+    const cloneMethod = `        public static ${name} Clone(${name} obj)
+        {
+            return new ${name}
+            {
+${cloneBody}
+            };
+        }`;
+    const equalsBody = props.map(([propName, propType]) => {
+      return renderEquals(propType, propName, `a.${toPascalCase(propName)}`, `b.${toPascalCase(propName)}`);
+    });
+    const equalsMethod = `        public static bool Equals(${name} a, ${name} b)
+        {
+            return ${equalsBody.length > 0 ? equalsBody.join(` &&
+                `) : "true"};
+        }`;
+    const encodeMethod = `        public static byte[] Encode(${name} obj)
+        {
+            var encoder = new Encoder();
+            EncodeInternal(obj, encoder);
+            return encoder.ToBuffer();
+        }`;
+    const encodeInternalBody = props.map(([propName, propType]) => {
+      return `            ${renderEncode(propType, propName, `obj.${toPascalCase(propName)}`)};`;
+    }).join(`
+`);
+    const encodeInternalMethod = `        internal static void EncodeInternal(${name} obj, Encoder encoder)
+        {
+${encodeInternalBody}
+        }`;
+    const encodeDiffMethod = `        public static byte[] EncodeDiff(${name} a, ${name} b)
+        {
+            var encoder = new Encoder();
+            EncodeDiffInternal(a, b, encoder);
+            return encoder.ToBuffer();
+        }`;
+    const encodeDiffInternalBody = props.map(([propName, propType]) => {
+      const encoded = renderEncodeDiff(propType, propName, `a.${toPascalCase(propName)}`, `b.${toPascalCase(propName)}`);
+      const suffix = encoded.trimStart().startsWith("{") ? "" : ";";
+      return `            ${encoded}${suffix}`;
+    }).join(`
+`);
+    const encodeDiffInternalMethod = `        internal static void EncodeDiffInternal(${name} a, ${name} b, Encoder encoder)
+        {
+            var changed = !Equals(a, b);
+            encoder.PushBoolean(changed);
+            if (!changed) return;
+${encodeDiffInternalBody}
+        }`;
+    const decodeMethod = `        public static ${newModifier}${name} Decode(byte[] buf)
+        {
+            var decoder = new Decoder(buf);
+            return DecodeInternal(decoder);
+        }`;
+    const decodeInternalBody = props.map(([propName, propType]) => {
+      return `                ${toPascalCase(propName)} = ${renderDecode(propType, propName)},`;
+    }).join(`
+`);
+    const decodeInternalMethod = `        internal static ${newModifier}${name} DecodeInternal(Decoder decoder)
+        {
+            return new ${name}
+            {
+${decodeInternalBody}
+            };
+        }`;
+    const decodeDiffMethod = `        public static ${name} DecodeDiff(${name} obj, byte[] diff)
+        {
+            var decoder = new Decoder(diff);
+            return DecodeDiffInternal(obj, decoder);
+        }`;
+    const decodeDiffInternalBody = props.map(([propName, propType]) => {
+      return `                ${toPascalCase(propName)} = ${renderDecodeDiff(propType, propName, `obj.${toPascalCase(propName)}`)},`;
+    }).join(`
+`);
+    const decodeDiffInternalMethod = `        internal static ${name} DecodeDiffInternal(${name} obj, Decoder decoder)
+        {
+            var changed = decoder.NextBoolean();
+            if (!changed) return obj;
+            return new ${name}
+            {
+${decodeDiffInternalBody}
+            };
+        }`;
+    const classDeclaration = baseClass ? `    public class ${name} : ${baseClass}` : `    public class ${name}`;
+    return `${classDeclaration}
+    {
+${typeProperty}${propertyLines}
+
+${defaultMethod}
+
+${fromJsonMethod}
+
+${toJsonMethod}
+
+${cloneMethod}
+
+${equalsMethod}
+
+${encodeMethod}
+
+${encodeInternalMethod}
+
+${encodeDiffMethod}
+
+${encodeDiffInternalMethod}
+
+${decodeMethod}
+
+${decodeInternalMethod}
 
-${Object.entries(schema).map(([name, type]) => {
+${decodeDiffMethod}
+
+${decodeDiffInternalMethod}
+    }`;
+  }
+  function renderUnion(name, options, numBits) {
+    const fromJsonCases = options.map((opt, i) => {
+      const variantName = opt.name;
+      return `${i > 0 ? "                else " : "                "}if (typeName == "${variantName}") return ${variantName}.FromJson(val);`;
+    }).join(`
+`);
+    const fromJsonCasesProp = options.map((opt, i) => {
+      const variantName = opt.name;
+      return `${i > 0 ? "                else " : "                "}if (typeName == "${variantName}") return ${variantName}.FromJson(valProp);`;
+    }).join(`
+`);
+    const encodeCases = options.map((opt, i) => {
+      const variantName = opt.name;
+      const varName = toCamelCase(variantName);
+      return `            ${i > 0 ? "else " : ""}if (obj is ${variantName} ${varName})
+            {
+                encoder.PushEnum(${i}, ${numBits});
+                ${variantName}.EncodeInternal(${varName}, encoder);
+            }`;
+    }).join(`
+`);
+    const decodeCases = options.map((opt, i) => {
+      const variantName = opt.name;
+      return `            ${i > 0 ? "else " : ""}if (type == ${i}) return ${variantName}.DecodeInternal(decoder);`;
+    }).join(`
+`);
+    const encodeDiffCases = options.map((opt, i) => {
+      const variantName = opt.name;
+      const varName = toCamelCase(variantName);
+      return `            ${i > 0 ? "else " : ""}if (b is ${variantName} ${varName}B)
+            {
+                if (a is ${variantName} ${varName}A)
+                {
+                    ${variantName}.EncodeDiffInternal(${varName}A, ${varName}B, encoder);
+                }
+                else
+                {
+                    encoder.PushEnum(${i}, ${numBits});
+                    ${variantName}.EncodeInternal(${varName}B, encoder);
+                }
+            }`;
+    }).join(`
+`);
+    const decodeDiffSameTypeCases = options.map((opt, i) => {
+      const variantName = opt.name;
+      const varName = toCamelCase(variantName);
+      return `                ${i > 0 ? "else " : ""}if (obj is ${variantName} ${varName}) return ${variantName}.DecodeDiffInternal(${varName}, decoder);`;
+    }).join(`
+`);
+    const decodeDiffNewTypeCases = options.map((opt, i) => {
+      const variantName = opt.name;
+      return `                ${i > 0 ? "else " : ""}if (type == ${i}) return ${variantName}.DecodeInternal(decoder);`;
+    }).join(`
+`);
+    const equalsCases = options.map((opt, i) => {
+      const variantName = opt.name;
+      const varName = toCamelCase(variantName);
+      return `            ${i > 0 ? "else " : ""}if (a is ${variantName} ${varName}A && b is ${variantName} ${varName}B) return ${variantName}.Equals(${varName}A, ${varName}B);`;
+    }).join(`
+`);
+    const cloneCases = options.map((opt, i) => {
+      const variantName = opt.name;
+      const varName = toCamelCase(variantName);
+      return `            ${i > 0 ? "else " : ""}if (obj is ${variantName} ${varName}) return ${variantName}.Clone(${varName});`;
+    }).join(`
+`);
+    const toJsonCases = options.map((opt, i) => {
+      const variantName = opt.name;
+      const varName = toCamelCase(variantName);
+      return `            ${i > 0 ? "else " : ""}if (obj is ${variantName} ${varName}) return new JsonObject { ["${variantName}"] = ${variantName}.ToJson(${varName}) };`;
+    }).join(`
+`);
+    const baseClass = `    public abstract class ${name}
+    {
+        public abstract string Type { get; }
+
+        public static ${name} Default() => ${options[0].name}.Default();
+
+        public static ${name} FromJson(JsonElement json)
+        {
+            if (json.TryGetProperty("type", out var typeEl) && json.TryGetProperty("val", out var val))
+            {
+                var typeName = typeEl.GetString();
+${fromJsonCases}
+                throw new InvalidOperationException($"Unknown ${name} type: {typeName}");
+            }
+            // Protobuf format: { "TypeName": {...} }
+            var prop = json.EnumerateObject().FirstOrDefault();
+            if (prop.Value.ValueKind != JsonValueKind.Undefined)
+            {
+                var typeName = prop.Name;
+                var valProp = prop.Value;
+${fromJsonCasesProp}
+            }
+            throw new InvalidOperationException("Invalid ${name} format");
+        }
+
+        public static JsonObject ToJson(${name} obj)
+        {
+${toJsonCases}
+            throw new InvalidOperationException($"Unknown ${name} type: {obj.Type}");
+        }
+
+        public static ${name} Clone(${name} obj)
+        {
+${cloneCases}
+            throw new InvalidOperationException($"Unknown ${name} type: {obj.Type}");
+        }
+
+        public static bool Equals(${name} a, ${name} b)
+        {
+            if (a.Type != b.Type) return false;
+${equalsCases}
+            return false;
+        }
+
+        public static byte[] Encode(${name} obj)
+        {
+            var encoder = new Encoder();
+            EncodeInternal(obj, encoder);
+            return encoder.ToBuffer();
+        }
+
+        internal static void EncodeInternal(${name} obj, Encoder encoder)
+        {
+${encodeCases}
+        }
+
+        public static byte[] EncodeDiff(${name} a, ${name} b)
+        {
+            var encoder = new Encoder();
+            EncodeDiffInternal(a, b, encoder);
+            return encoder.ToBuffer();
+        }
+
+        internal static void EncodeDiffInternal(${name} a, ${name} b, Encoder encoder)
+        {
+            encoder.PushBoolean(a.Type == b.Type);
+${encodeDiffCases}
+        }
+
+        public static ${name} Decode(byte[] buf)
+        {
+            var decoder = new Decoder(buf);
+            return DecodeInternal(decoder);
+        }
+
+        internal static ${name} DecodeInternal(Decoder decoder)
+        {
+            var type = decoder.NextEnum(${numBits});
+${decodeCases}
+            throw new InvalidOperationException("Invalid ${name} union");
+        }
+
+        public static ${name} DecodeDiff(${name} obj, byte[] diff)
+        {
+            var decoder = new Decoder(diff);
+            return DecodeDiffInternal(obj, decoder);
+        }
+
+        internal static ${name} DecodeDiffInternal(${name} obj, Decoder decoder)
+        {
+            var isSameType = decoder.NextBoolean();
+            if (isSameType)
+            {
+${decodeDiffSameTypeCases}
+                throw new InvalidOperationException("Invalid ${name} diff");
+            }
+            else
+            {
+                var type = decoder.NextEnum(${numBits});
+${decodeDiffNewTypeCases}
+                throw new InvalidOperationException("Invalid ${name} diff");
+            }
+        }
+    }`;
+    return baseClass;
+  }
+  function renderTypeArg(type, name) {
+    if (type.type === "string") {
+      return "string";
+    } else if (type.type === "int") {
+      return "long";
+    } else if (type.type === "float") {
+      return "float";
+    } else if (type.type === "boolean") {
+      return "bool";
+    } else if (type.type === "enum") {
+      return type.name;
+    } else if (type.type === "array") {
+      return `List<${renderTypeArg(type.value, name)}>`;
+    } else if (type.type === "optional") {
+      const inner = renderTypeArg(type.value, name);
+      if (isValueType(type.value)) {
+        return `${inner}?`;
+      }
+      return `${inner}?`;
+    } else if (type.type === "record") {
+      return `Dictionary<${renderTypeArg(type.key, name)}, ${renderTypeArg(type.value, name)}>`;
+    } else if (type.type === "reference") {
+      return type.ref.name;
+    } else if (type.type === "self-reference") {
+      return currentTypeName;
+    }
+    return "object";
+  }
+  function isValueType(type) {
+    if (type.type === "reference") {
+      return isValueType(type.ref);
+    }
+    return type.type === "int" || type.type === "float" || type.type === "boolean" || type.type === "enum";
+  }
+  function renderDefault(type, name) {
+    if (type.type === "string") {
+      return '""';
+    } else if (type.type === "int") {
+      return "0";
+    } else if (type.type === "float") {
+      return "0f";
+    } else if (type.type === "boolean") {
+      return "false";
+    } else if (type.type === "enum") {
+      return `${type.name}.${toPascalCase(type.options[0])}`;
+    } else if (type.type === "array") {
+      return `new List<${renderTypeArg(type.value, name)}>()`;
+    } else if (type.type === "optional") {
+      return "null";
+    } else if (type.type === "record") {
+      return `new Dictionary<${renderTypeArg(type.key, name)}, ${renderTypeArg(type.value, name)}>()`;
+    } else if (type.type === "reference") {
+      return renderDefault(type.ref, type.ref.name);
+    } else if (type.type === "self-reference") {
+      return `${qualifyType(currentTypeName)}.Default()`;
+    }
+    return `${qualifyType(name)}.Default()`;
+  }
+  function renderFromJson(type, name, key) {
+    if (type.type === "string") {
+      return `${key}.GetString() ?? ""`;
+    } else if (type.type === "int") {
+      return `${key}.GetInt64()`;
+    } else if (type.type === "float") {
+      return `${key}.GetSingle()`;
+    } else if (type.type === "boolean") {
+      return `${key}.GetBoolean()`;
+    } else if (type.type === "enum") {
+      return `Enum.Parse<${type.name}>(${key}.GetString()!, true)`;
+    } else if (type.type === "array") {
+      return `${key}.EnumerateArray().Select(x => ${renderFromJson(type.value, name, "x")}).ToList()`;
+    } else if (type.type === "optional") {
+      return `${key}.ValueKind == JsonValueKind.Null ? null : ${renderFromJson(type.value, name, key)}`;
+    } else if (type.type === "record") {
+      if (type.key.type === "string") {
+        return `${key}.EnumerateObject().ToDictionary(p => p.Name, p => ${renderFromJson(type.value, name, "p.Value")})`;
+      } else {
+        return `${key}.EnumerateObject().ToDictionary(p => long.Parse(p.Name), p => ${renderFromJson(type.value, name, "p.Value")})`;
+      }
+    } else if (type.type === "reference") {
+      return renderFromJson(type.ref, type.ref.name, key);
+    } else if (type.type === "self-reference") {
+      return `${qualifyType(currentTypeName)}.FromJson(${key})`;
+    }
+    return `${qualifyType(name)}.FromJson(${key})`;
+  }
+  function renderToJson(type, name, key) {
+    if (type.type === "string" || type.type === "int" || type.type === "float" || type.type === "boolean") {
+      return key;
+    } else if (type.type === "enum") {
+      return `${key}.ToString()`;
+    } else if (type.type === "array") {
+      const innerJson = renderToJson(type.value, name, "x");
+      return `new JsonArray(${key}.Select(x => (JsonNode?)${innerJson}).ToArray())`;
+    } else if (type.type === "optional") {
+      return renderToJson(type.value, name, key);
+    } else if (type.type === "record") {
+      if (type.key.type === "string") {
+        return `new JsonObject(${key}.Select(kvp => new KeyValuePair<string, JsonNode?>(kvp.Key, ${renderToJson(type.value, name, "kvp.Value")})))`;
+      } else {
+        return `new JsonObject(${key}.Select(kvp => new KeyValuePair<string, JsonNode?>(kvp.Key.ToString(), ${renderToJson(type.value, name, "kvp.Value")})))`;
+      }
+    } else if (type.type === "reference") {
+      return renderToJson(type.ref, type.ref.name, key);
+    } else if (type.type === "self-reference") {
+      return `${qualifyType(currentTypeName)}.ToJson(${key})`;
+    }
+    if (type.type === "union") {
+      return `${qualifyType(type.name)}.ToJson(${key})`;
+    }
+    return `${qualifyType(name)}.ToJson(${key})`;
+  }
+  function renderClone(type, name, key) {
+    if (type.type === "string" || type.type === "int" || type.type === "float" || type.type === "boolean" || type.type === "enum") {
+      return key;
+    } else if (type.type === "array") {
+      if (isPrimitiveOrEnum(type.value)) {
+        return `new List<${renderTypeArg(type.value, name)}>(${key})`;
+      }
+      return `${key}.Select(x => ${renderClone(type.value, name, "x")}).ToList()`;
+    } else if (type.type === "optional") {
+      if (isPrimitiveOrEnum(type.value)) {
+        return key;
+      }
+      return `${key} != null ? ${renderClone(type.value, name, key)} : null`;
+    } else if (type.type === "record") {
+      if (isPrimitiveOrEnum(type.value)) {
+        return `new Dictionary<${renderTypeArg(type.key, name)}, ${renderTypeArg(type.value, name)}>(${key})`;
+      }
+      return `${key}.ToDictionary(kvp => kvp.Key, kvp => ${renderClone(type.value, name, "kvp.Value")})`;
+    } else if (type.type === "reference") {
+      return renderClone(type.ref, type.ref.name, key);
+    } else if (type.type === "self-reference") {
+      return `${qualifyType(currentTypeName)}.Clone(${key})`;
+    }
+    if (type.type === "union") {
+      return `${qualifyType(type.name)}.Clone(${key})`;
+    }
+    return `${qualifyType(name)}.Clone(${key})`;
+  }
+  function renderEquals(type, name, keyA, keyB) {
+    if (type.type === "string" || type.type === "int" || type.type === "boolean" || type.type === "enum") {
+      return `${keyA} == ${keyB}`;
+    } else if (type.type === "float") {
+      if (type.precision) {
+        return `Math.Abs(${keyA} - ${keyB}) < ${type.precision / 2}f`;
+      }
+      return `${keyA} == ${keyB}`;
+    } else if (type.type === "array") {
+      return `${keyA}.Count == ${keyB}.Count && ${keyA}.Zip(${keyB}).All(pair => ${renderEquals(type.value, name, "pair.First", "pair.Second")})`;
+    } else if (type.type === "optional") {
+      if (isValueType(type.value) || isPrimitiveOrEnum(type.value)) {
+        return `${keyA} == ${keyB}`;
+      }
+      return `(${keyA} == null && ${keyB} == null || ${keyA} != null && ${keyB} != null && ${renderEquals(type.value, name, keyA, keyB)})`;
+    } else if (type.type === "record") {
+      return `${keyA}.Count == ${keyB}.Count && ${keyA}.All(kvp => ${keyB}.TryGetValue(kvp.Key, out var v) && ${renderEquals(type.value, name, "kvp.Value", "v")})`;
+    } else if (type.type === "reference") {
+      return renderEquals(type.ref, type.ref.name, keyA, keyB);
+    } else if (type.type === "self-reference") {
+      return `${qualifyType(currentTypeName)}.Equals(${keyA}, ${keyB})`;
+    }
+    if (type.type === "union") {
+      return `${qualifyType(type.name)}.Equals(${keyA}, ${keyB})`;
+    }
+    return `${qualifyType(name)}.Equals(${keyA}, ${keyB})`;
+  }
+  function renderEncode(type, name, key) {
+    if (type.type === "string") {
+      return `encoder.PushString(${key})`;
+    } else if (type.type === "int") {
+      if (type.min != null) {
+        return `encoder.PushBoundedInt(${key}, ${type.min})`;
+      }
+      return `encoder.PushInt(${key})`;
+    } else if (type.type === "float") {
+      if (type.precision) {
+        return `encoder.PushFloatQuantized(${key}, ${type.precision}f)`;
+      }
+      return `encoder.PushFloat(${key})`;
+    } else if (type.type === "boolean") {
+      return `encoder.PushBoolean(${key})`;
+    } else if (type.type === "enum") {
+      return `encoder.PushEnum((int)${key}, ${type.numBits})`;
+    } else if (type.type === "array") {
+      return `encoder.PushArray(${key}, x => ${renderEncode(type.value, name, "x")})`;
+    } else if (type.type === "optional") {
+      if (isValueType(type.value)) {
+        const innerEncode = renderEncode(type.value, name, `${key}.Value`);
+        return `encoder.PushBoolean(${key}.HasValue);
+            if (${key}.HasValue) ${innerEncode}`;
+      }
+      return `encoder.PushOptional(${key}, x => ${renderEncode(type.value, name, "x")})`;
+    } else if (type.type === "record") {
+      const encodeKey = renderEncode(type.key, name, "x");
+      const encodeVal = renderEncode(type.value, name, "x");
+      return `encoder.PushRecord(${key}, x => ${encodeKey}, x => ${encodeVal})`;
+    } else if (type.type === "reference") {
+      return renderEncode(type.ref, type.ref.name, key);
+    } else if (type.type === "self-reference") {
+      return `${qualifyType(currentTypeName)}.EncodeInternal(${key}, encoder)`;
+    }
+    if (type.type === "union") {
+      return `${qualifyType(type.name)}.EncodeInternal(${key}, encoder)`;
+    }
+    return `${qualifyType(name)}.EncodeInternal(${key}, encoder)`;
+  }
+  function renderDecode(type, name) {
+    if (type.type === "string") {
+      return `decoder.NextString()`;
+    } else if (type.type === "int") {
+      if (type.min != null) {
+        return `decoder.NextBoundedInt(${type.min})`;
+      }
+      return `decoder.NextInt()`;
+    } else if (type.type === "float") {
+      if (type.precision) {
+        return `decoder.NextFloatQuantized(${type.precision}f)`;
+      }
+      return `decoder.NextFloat()`;
+    } else if (type.type === "boolean") {
+      return `decoder.NextBoolean()`;
+    } else if (type.type === "enum") {
+      return `(${type.name})decoder.NextEnum(${type.numBits})`;
+    } else if (type.type === "array") {
+      return `decoder.NextArray(() => ${renderDecode(type.value, name)})`;
+    } else if (type.type === "optional") {
+      if (isValueType(type.value)) {
+        const csType = renderTypeArg(type.value, name);
+        const innerType = type.value.type === "reference" ? type.value.ref : type.value;
+        if (innerType.type === "enum") {
+          return `decoder.NextBoolean() ? (${csType}?)decoder.NextEnum(${innerType.numBits}) : null`;
+        }
+        const innerDecode = renderDecode(type.value, name);
+        return `decoder.NextBoolean() ? (${csType}?)${innerDecode} : null`;
+      }
+      return `decoder.NextOptional(() => ${renderDecode(type.value, name)})`;
+    } else if (type.type === "record") {
+      const decodeKey = renderDecode(type.key, name);
+      const decodeVal = renderDecode(type.value, name);
+      return `decoder.NextRecord(() => ${decodeKey}, () => ${decodeVal})`;
+    } else if (type.type === "reference") {
+      return renderDecode(type.ref, type.ref.name);
+    } else if (type.type === "self-reference") {
+      return `${qualifyType(currentTypeName)}.DecodeInternal(decoder)`;
+    }
+    if (type.type === "union") {
+      return `${qualifyType(type.name)}.DecodeInternal(decoder)`;
+    }
+    return `${qualifyType(name)}.DecodeInternal(decoder)`;
+  }
+  function renderEncodeDiff(type, name, keyA, keyB) {
+    if (type.type === "string") {
+      return `encoder.PushStringDiff(${keyA}, ${keyB})`;
+    } else if (type.type === "int") {
+      if (type.min != null) {
+        return `encoder.PushBoundedIntDiff(${keyA}, ${keyB}, ${type.min})`;
+      }
+      return `encoder.PushIntDiff(${keyA}, ${keyB})`;
+    } else if (type.type === "float") {
+      if (type.precision) {
+        return `encoder.PushFloatQuantizedDiff(${keyA}, ${keyB}, ${type.precision}f)`;
+      }
+      return `encoder.PushFloatDiff(${keyA}, ${keyB})`;
+    } else if (type.type === "boolean") {
+      return `encoder.PushBooleanDiff(${keyA}, ${keyB})`;
+    } else if (type.type === "enum") {
+      return `encoder.PushEnumDiff((int)${keyA}, (int)${keyB}, ${type.numBits})`;
+    } else if (type.type === "array") {
+      const elemType = renderTypeArg(type.value, name);
+      const equalsFn = renderEquals(type.value, name, "x", "y");
+      const encodeFn = renderEncode(type.value, name, "x");
+      const encodeDiffFn = renderEncodeDiff(type.value, name, "x", "y");
+      return `encoder.PushArrayDiff<${elemType}>(${keyA}, ${keyB}, (x, y) => ${equalsFn}, x => ${encodeFn}, (x, y) => ${encodeDiffFn})`;
+    } else if (type.type === "optional") {
+      const elemType = renderTypeArg(type.value, name);
+      const encodeFn = renderEncode(type.value, name, "x");
+      if (isValueType(type.value)) {
+        const innerEncode = renderEncode(type.value, name, `${keyB}.Value`);
+        return `{
+                var eq = ${keyA} == ${keyB};
+                encoder.PushBoolean(!eq);
+                if (!eq)
+                {
+                    encoder.PushBoolean(${keyB}.HasValue);
+                    if (${keyB}.HasValue) ${innerEncode};
+                }
+            }`;
+      }
+      if (isPrimitiveOrEnum(type.value)) {
+        return `encoder.PushOptionalDiffPrimitive<${elemType}>(${keyA}, ${keyB}, x => ${encodeFn})`;
+      } else {
+        const encodeDiffFn = renderEncodeDiff(type.value, name, "x", "y");
+        return `encoder.PushOptionalDiff<${elemType}>(${keyA}, ${keyB}, x => ${encodeFn}, (x, y) => ${encodeDiffFn})`;
+      }
+    } else if (type.type === "record") {
+      const keyType = renderTypeArg(type.key, name);
+      const valType = renderTypeArg(type.value, name);
+      const equalsFn = renderEquals(type.value, name, "x", "y");
+      const encodeKeyFn = renderEncode(type.key, name, "x");
+      const encodeValFn = renderEncode(type.value, name, "x");
+      const encodeDiffFn = renderEncodeDiff(type.value, name, "x", "y");
+      return `encoder.PushRecordDiff<${keyType}, ${valType}>(${keyA}, ${keyB}, (x, y) => ${equalsFn}, x => ${encodeKeyFn}, x => ${encodeValFn}, (x, y) => ${encodeDiffFn})`;
+    } else if (type.type === "reference") {
+      return renderEncodeDiff(type.ref, type.ref.name, keyA, keyB);
+    } else if (type.type === "self-reference") {
+      return `${qualifyType(currentTypeName)}.EncodeDiffInternal(${keyA}, ${keyB}, encoder)`;
+    }
+    if (type.type === "union") {
+      return `${qualifyType(type.name)}.EncodeDiffInternal(${keyA}, ${keyB}, encoder)`;
+    }
+    return `${qualifyType(name)}.EncodeDiffInternal(${keyA}, ${keyB}, encoder)`;
+  }
+  function renderDecodeDiff(type, name, key) {
+    if (type.type === "string") {
+      return `decoder.NextStringDiff(${key})`;
+    } else if (type.type === "int") {
+      if (type.min != null) {
+        return `decoder.NextBoundedIntDiff(${key}, ${type.min})`;
+      }
+      return `decoder.NextIntDiff(${key})`;
+    } else if (type.type === "float") {
+      if (type.precision) {
+        return `decoder.NextFloatQuantizedDiff(${key}, ${type.precision}f)`;
+      }
+      return `decoder.NextFloatDiff(${key})`;
+    } else if (type.type === "boolean") {
+      return `decoder.NextBooleanDiff(${key})`;
+    } else if (type.type === "enum") {
+      return `(${type.name})decoder.NextEnumDiff((int)${key}, ${type.numBits})`;
+    } else if (type.type === "array") {
+      const elemType = renderTypeArg(type.value, name);
+      const decodeFn = renderDecode(type.value, name);
+      const decodeDiffFn = renderDecodeDiff(type.value, name, "x");
+      return `decoder.NextArrayDiff<${elemType}>(${key}, () => ${decodeFn}, x => ${decodeDiffFn})`;
+    } else if (type.type === "optional") {
+      const elemType = renderTypeArg(type.value, name);
+      const decodeFn = renderDecode(type.value, name);
+      if (isValueType(type.value)) {
+        const innerType = type.value.type === "reference" ? type.value.ref : type.value;
+        if (innerType.type === "enum") {
+          return `decoder.NextBoolean() ? (decoder.NextBoolean() ? (${elemType}?)decoder.NextEnum(${innerType.numBits}) : null) : ${key}`;
+        }
+        return `decoder.NextBoolean() ? (decoder.NextBoolean() ? (${elemType}?)${decodeFn} : null) : ${key}`;
+      }
+      if (isPrimitiveOrEnum(type.value)) {
+        return `decoder.NextOptionalDiffPrimitive<${elemType}>(${key}, () => ${decodeFn})`;
+      } else {
+        const decodeDiffFn = renderDecodeDiff(type.value, name, "x");
+        return `decoder.NextOptionalDiff<${elemType}>(${key}, () => ${decodeFn}, x => ${decodeDiffFn})`;
+      }
+    } else if (type.type === "record") {
+      const keyType = renderTypeArg(type.key, name);
+      const valType = renderTypeArg(type.value, name);
+      const decodeKeyFn = renderDecode(type.key, name);
+      const decodeValFn = renderDecode(type.value, name);
+      const decodeDiffFn = renderDecodeDiff(type.value, name, "x");
+      return `decoder.NextRecordDiff<${keyType}, ${valType}>(${key}, () => ${decodeKeyFn}, () => ${decodeValFn}, x => ${decodeDiffFn})`;
+    } else if (type.type === "reference") {
+      return renderDecodeDiff(type.ref, type.ref.name, key);
+    } else if (type.type === "self-reference") {
+      return `${qualifyType(currentTypeName)}.DecodeDiffInternal(${key}, decoder)`;
+    }
+    if (type.type === "union") {
+      return `${qualifyType(type.name)}.DecodeDiffInternal(${key}, decoder)`;
+    }
+    return `${qualifyType(name)}.DecodeDiffInternal(${key}, decoder)`;
+  }
+}
+function toPascalCase(str) {
+  if (!str)
+    return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function toCamelCase(str) {
+  if (!str)
+    return str;
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+// src/codegen/typescript.ts
+function codegenTypescript(schema2) {
+  return renderSchema2(schema2);
+}
+function renderSchema2(schema2) {
+  let currentTypeName;
+  return `import * as _ from "@hpx7/delta-pack";
+
+${Object.entries(schema2).map(([name, type]) => {
     currentTypeName = name;
     if (type.type === "enum") {
       return `
@@ -9732,7 +10498,7 @@ export type ${name} = ${type.options.map((option) => `"${option}"`).join(" | ")}
   }).join(`
 `)}
 
-${Object.entries(schema).map(([name, type]) => {
+${Object.entries(schema2).map(([name, type]) => {
     currentTypeName = name;
     if (type.type === "enum") {
       return `
@@ -9944,7 +10710,7 @@ export const ${name} = {
   _encode(obj: ${name}, encoder: _.Encoder): void {
     ${type.options.map((option, i) => {
         return `${i > 0 ? "else " : ""}if (obj.type === "${option.name}") {
-      encoder.pushUInt(${i});
+      encoder.pushEnum(${i}, ${type.numBits});
       ${renderEncode(option, option.name, "obj.val")};
     }`;
       }).join(`
@@ -9962,7 +10728,7 @@ export const ${name} = {
       if (a.type === "${option.name}") {
         ${renderEncodeDiff(option, option.name, "a.val", "b.val")};
       } else {
-        encoder.pushUInt(${i});
+        encoder.pushEnum(${i}, ${type.numBits});
         ${renderEncode(option, option.name, "b.val")};
       }
     }`;
@@ -9973,7 +10739,7 @@ export const ${name} = {
     return ${name}._decode(new _.Decoder(input));
   },
   _decode(decoder: _.Decoder): ${name} {
-    const type = decoder.nextUInt();
+    const type = decoder.nextEnum(${type.numBits});
     ${type.options.map((option, i) => {
         return `${i > 0 ? "else " : ""}if (type === ${i}) {
       return { type: "${option.name}", val: ${renderDecode(option, option.name, "obj.val")} };
@@ -10000,7 +10766,7 @@ export const ${name} = {
       `)}
       throw new Error("Invalid union diff");
     } else {
-      const type = decoder.nextUInt();
+      const type = decoder.nextEnum(${type.numBits});
       ${type.options.map((option, i) => {
         return `${i > 0 ? "else " : ""}if (type === ${i}) {
         return {
@@ -10038,7 +10804,7 @@ export const ${name} = {
       return `Map<${renderTypeArg(type.key, name)}, ${renderTypeArg(type.value, name)}> & { _dirty?: Set<${renderTypeArg(type.key, name)}> }`;
     } else if (type.type === "reference") {
       return type.ref.name;
-    } else if (type.type === "int" || type.type === "uint" || type.type === "float") {
+    } else if (type.type === "int" || type.type === "float") {
       return "number";
     } else if (type.type === "self-reference") {
       return currentTypeName;
@@ -10058,8 +10824,6 @@ export const ${name} = {
       return '""';
     } else if (type.type === "int") {
       return "0";
-    } else if (type.type === "uint") {
-      return "0";
     } else if (type.type === "float") {
       return "0.0";
     } else if (type.type === "boolean") {
@@ -10085,9 +10849,13 @@ export const ${name} = {
     } else if (type.type === "string") {
       return `_.parseString(${key})`;
     } else if (type.type === "int") {
+      if (type.max != null) {
+        return `_.parseInt(${key}, ${type.min}, ${type.max})`;
+      }
+      if (type.min != null) {
+        return `_.parseInt(${key}, ${type.min})`;
+      }
       return `_.parseInt(${key})`;
-    } else if (type.type === "uint") {
-      return `_.parseUInt(${key})`;
     } else if (type.type === "float") {
       return `_.parseFloat(${key})`;
     } else if (type.type === "boolean") {
@@ -10108,7 +10876,7 @@ export const ${name} = {
       return `_.mapToObject(${key}, (x) => ${renderToJson(type.value, name, "x")})`;
     } else if (type.type === "reference") {
       return renderToJson(type.ref, type.ref.name, key);
-    } else if (type.type === "string" || type.type === "int" || type.type === "uint" || type.type === "float" || type.type === "boolean" || type.type === "enum") {
+    } else if (type.type === "string" || type.type === "int" || type.type === "float" || type.type === "boolean" || type.type === "enum") {
       return `${key}`;
     } else if (type.type === "self-reference") {
       return `${currentTypeName}.toJson(${key})`;
@@ -10125,7 +10893,7 @@ export const ${name} = {
       return `new Map([...${key}].map(([k, v]) => [k, ${valueFn}]))`;
     } else if (type.type === "reference") {
       return renderClone(type.ref, type.ref.name, key);
-    } else if (type.type === "string" || type.type === "int" || type.type === "uint" || type.type === "float" || type.type === "boolean" || type.type === "enum") {
+    } else if (type.type === "string" || type.type === "int" || type.type === "float" || type.type === "boolean" || type.type === "enum") {
       return `${key}`;
     } else if (type.type === "self-reference") {
       return `${currentTypeName}.clone(${key})`;
@@ -10148,7 +10916,7 @@ export const ${name} = {
         return `_.equalsFloatQuantized(${keyA}, ${keyB}, ${type.precision})`;
       }
       return `_.equalsFloat(${keyA}, ${keyB})`;
-    } else if (type.type === "string" || type.type === "int" || type.type === "uint" || type.type === "boolean" || type.type === "enum") {
+    } else if (type.type === "string" || type.type === "int" || type.type === "boolean" || type.type === "enum") {
       return `${keyA} === ${keyB}`;
     } else if (type.type === "self-reference") {
       return `${currentTypeName}.equals(${keyA}, ${keyB})`;
@@ -10169,9 +10937,10 @@ export const ${name} = {
     } else if (type.type === "string") {
       return `encoder.pushString(${key})`;
     } else if (type.type === "int") {
+      if (type.min != null) {
+        return `encoder.pushBoundedInt(${key}, ${type.min})`;
+      }
       return `encoder.pushInt(${key})`;
-    } else if (type.type === "uint") {
-      return `encoder.pushUInt(${key})`;
     } else if (type.type === "float") {
       if (type.precision) {
         return `encoder.pushFloatQuantized(${key}, ${type.precision})`;
@@ -10180,7 +10949,7 @@ export const ${name} = {
     } else if (type.type === "boolean") {
       return `encoder.pushBoolean(${key})`;
     } else if (type.type === "enum") {
-      return `encoder.pushUInt(${name}[${key}])`;
+      return `encoder.pushEnum(${name}[${key}], ${type.numBits})`;
     } else if (type.type === "self-reference") {
       return `${currentTypeName}._encode(${key}, encoder)`;
     }
@@ -10200,9 +10969,10 @@ export const ${name} = {
     } else if (type.type === "string") {
       return `decoder.nextString()`;
     } else if (type.type === "int") {
+      if (type.min != null) {
+        return `decoder.nextBoundedInt(${type.min})`;
+      }
       return `decoder.nextInt()`;
-    } else if (type.type === "uint") {
-      return `decoder.nextUInt()`;
     } else if (type.type === "float") {
       if (type.precision) {
         return `decoder.nextFloatQuantized(${type.precision})`;
@@ -10211,7 +10981,7 @@ export const ${name} = {
     } else if (type.type === "boolean") {
       return `decoder.nextBoolean()`;
     } else if (type.type === "enum") {
-      return `(${name} as any)[decoder.nextUInt()]`;
+      return `(${name} as any)[decoder.nextEnum(${type.numBits})]`;
     } else if (type.type === "self-reference") {
       return `${currentTypeName}._decode(decoder)`;
     }
@@ -10268,9 +11038,10 @@ export const ${name} = {
     } else if (type.type === "string") {
       return `encoder.pushStringDiff(${keyA}, ${keyB})`;
     } else if (type.type === "int") {
+      if (type.min != null) {
+        return `encoder.pushBoundedIntDiff(${keyA}, ${keyB}, ${type.min})`;
+      }
       return `encoder.pushIntDiff(${keyA}, ${keyB})`;
-    } else if (type.type === "uint") {
-      return `encoder.pushUIntDiff(${keyA}, ${keyB})`;
     } else if (type.type === "float") {
       if (type.precision) {
         return `encoder.pushFloatQuantizedDiff(${keyA}, ${keyB}, ${type.precision})`;
@@ -10279,7 +11050,7 @@ export const ${name} = {
     } else if (type.type === "boolean") {
       return `encoder.pushBooleanDiff(${keyA}, ${keyB})`;
     } else if (type.type === "enum") {
-      return `encoder.pushUIntDiff(${name}[${keyA}], ${name}[${keyB}])`;
+      return `encoder.pushEnumDiff(${name}[${keyA}], ${name}[${keyB}], ${type.numBits})`;
     } else if (type.type === "self-reference") {
       return `${currentTypeName}._encodeDiff(${keyA}, ${keyB}, encoder)`;
     }
@@ -10328,9 +11099,10 @@ export const ${name} = {
     } else if (type.type === "string") {
       return `decoder.nextStringDiff(${key})`;
     } else if (type.type === "int") {
+      if (type.min != null) {
+        return `decoder.nextBoundedIntDiff(${key}, ${type.min})`;
+      }
       return `decoder.nextIntDiff(${key})`;
-    } else if (type.type === "uint") {
-      return `decoder.nextUIntDiff(${key})`;
     } else if (type.type === "float") {
       if (type.precision) {
         return `decoder.nextFloatQuantizedDiff(${key}, ${type.precision})`;
@@ -10339,13 +11111,66 @@ export const ${name} = {
     } else if (type.type === "boolean") {
       return `decoder.nextBooleanDiff(${key})`;
     } else if (type.type === "enum") {
-      return `(${name} as any)[decoder.nextUIntDiff((${name} as any)[${key}])]`;
+      return `(${name} as any)[decoder.nextEnumDiff((${name} as any)[${key}], ${type.numBits})]`;
     } else if (type.type === "self-reference") {
       return `${currentTypeName}._decodeDiff(${key}, decoder)`;
     }
     return `${name}._decodeDiff(${key}, decoder)`;
   }
 }
+
+// src/codegen/index.ts
+var languages = {
+  typescript: codegenTypescript,
+  ts: codegenTypescript,
+  csharp: codegenCsharp,
+  cs: codegenCsharp
+};
+// package.json
+var package_default = {
+  name: "@hpx7/delta-pack-cli",
+  version: "0.2.1",
+  license: "MIT",
+  author: "hpx7",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/hpx7/delta-pack.git",
+    directory: "cli"
+  },
+  type: "module",
+  bin: {
+    "delta-pack": "dist/index.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./codegen": {
+      types: "./dist/codegen/index.d.ts",
+      default: "./dist/codegen/index.js"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "bun build src/index.ts src/codegen/index.ts --outdir dist --target node && tsc",
+    test: "bun test"
+  },
+  dependencies: {
+    "@hpx7/delta-pack": "^0.2.5",
+    yaml: "^2.3.4"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    typescript: "^5.0.0"
+  }
+};
+
+// src/commands/generate.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
 // src/utils/io.ts
 import { readFile, writeFile } from "node:fs/promises";
 async function readInput(path) {
@@ -10391,18 +11216,12 @@ async function generate(schemaPath, flags) {
   }
   const content = await readFile2(schemaPath, "utf-8");
   const schema2 = parseSchemaYml(content);
-  let code;
-  switch (lang) {
-    case "typescript":
-    case "ts":
-      code = codegenTypescript(schema2);
-      break;
-    case "csharp":
-    case "cs":
-      throw new ArgError("generate: C# codegen not yet implemented");
-    default:
-      throw new ArgError(`generate: unknown language '${lang}'`);
+  const codegen = languages[lang];
+  if (!codegen) {
+    throw new ArgError(`generate: unknown language '${lang}'`);
   }
+  const ns = flags.get("n") ?? flags.get("namespace");
+  const code = codegen(schema2, typeof ns === "string" ? ns : undefined);
   await writeOutput(output === true ? undefined : output, code);
 }