initial commit

.vscode/settings.json

···
+{
+	"editor.defaultFormatter": "denoland.vscode-deno",
+	"deno.enable": true
+}

.zed/settings.json

···
+// Folder-specific settings
+//
+// For a full list of overridable settings, and general information on folder-specific settings,
+// see the documentation: https://zed.dev/docs/configuring-zed#settings-files
+{
+	"lsp": {
+		"deno": {
+			"settings": {
+				"deno": {
+					"enable": true
+				}
+			}
+		}
+	},
+	"languages": {
+		"JavaScript": {
+			"language_servers": [
+				"deno",
+				"!typescript-language-server",
+				"!vtsls",
+				"!eslint"
+			],
+			"formatter": "language_server"
+		},
+		"TypeScript": {
+			"language_servers": [
+				"deno",
+				"!typescript-language-server",
+				"!vtsls",
+				"!eslint"
+			],
+			"formatter": "language_server"
+		},
+		"TSX": {
+			"language_servers": [
+				"deno",
+				"!typescript-language-server",
+				"!vtsls",
+				"!eslint"
+			],
+			"formatter": "language_server"
+		}
+	}
+}

LICENSE

···
+BSD Zero Clause License
+
+Copyright (c) 2025 Mary
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

README.md

···
+# protobuf
+
+protobuf codec with static type inference.
+
+```typescript
+import * as p from '@mary/protobuf';
+
+// basic usage
+{
+	const Person = p.message({
+		id: p.int64(),
+		name: p.string(),
+		email: p.optional(p.string()),
+		tags: p.repeated(p.string()),
+	}, {
+		id: 1,
+		name: 2,
+		email: 3,
+		tags: 4,
+	});
+
+	const person: p.InferInput<typeof Person> = {
+		id: 123n,
+		name: 'alice',
+		email: '[e-mail]',
+		tags: ['developer', 'rust'],
+	};
+
+	const encoded = p.encode(Person, person);
+	const decoded = p.decode(Person, encoded);
+	//    ^? p.InferOutput<typeof Person>
+
+	const result = p.tryDecode(Person, buffer);
+
+	if (result.ok) {
+		result.value;
+	} else {
+		result.message;
+		result.issues;
+	}
+}
+
+// nested and self-referential messages
+{
+	const Address = p.message({
+		street: p.string(),
+		city: p.string(),
+		zipCode: p.optional(p.string()),
+	}, {
+		street: 1,
+		city: 2,
+		zipCode: 3,
+	});
+
+	const Place = p.message({
+		name: p.string(),
+		address: Address,
+	}, {
+		name: 1,
+		address: 2,
+	});
+
+	const Node = p.message({
+		value: p.int32(),
+		get next() {
+			return p.optional(Node);
+		},
+	}, {
+		value: 1,
+		next: 2,
+	});
+}
+
+// maps
+{
+	const Scoreboard = p.message({
+		scores: p.map(p.string(), p.int32()),
+	}, {
+		scores: 1,
+	});
+
+	const data: p.InferInput<typeof Scoreboard> = {
+		scores: new Map([['alice', 100], ['bob', 95]]),
+	};
+}
+```
+
+## non-features
+
+- **enums support**: use `int32()` instead for open enums
+- **oneof support**: complicated, breaks self-referential messages
+- **extensions support**: not supported
+- **groups support**: use nested messages instead
+- **code generation**: no intent

deno.json

···
+{
+	"name": "@mary/protobuf",
+	"version": "0.1.0",
+	"license": "0BSD",
+	"exports": "./lib/mod.ts",
+	"imports": {
+		"@std/assert": "jsr:@std/assert@^1.0.13",
+		"nanoid": "npm:nanoid@^5.1.5"
+	},
+	"publish": {
+		"include": ["lib/", "LICENSE", "README.md", "deno.json"]
+	},
+	"fmt": {
+		"useTabs": true,
+		"indentWidth": 2,
+		"lineWidth": 110,
+		"semiColons": true,
+		"singleQuote": true
+	}
+}

deno.lock

···
+{
+  "version": "5",
+  "specifiers": {
+    "jsr:@std/assert@^1.0.13": "1.0.13",
+    "jsr:@std/internal@^1.0.6": "1.0.6",
+    "npm:nanoid@^5.1.5": "5.1.5"
+  },
+  "jsr": {
+    "@std/assert@1.0.13": {
+      "integrity": "ae0d31e41919b12c656c742b22522c32fb26ed0cba32975cb0de2a273cb68b29",
+      "dependencies": [
+        "jsr:@std/internal"
+      ]
+    },
+    "@std/internal@1.0.6": {
+      "integrity": "9533b128f230f73bd209408bb07a4b12f8d4255ab2a4d22a1fd6d87304aca9a4"
+    }
+  },
+  "npm": {
+    "nanoid@5.1.5": {
+      "integrity": "sha512-Ir/+ZpE9fDsNH0hQ3C68uyThDXzYcim2EqcZ8zn8Chtt1iylPT9xXJB0kPCnqzgcEGikO9RxSrh63MsmVCU7Fw==",
+      "bin": true
+    }
+  },
+  "workspace": {
+    "dependencies": [
+      "jsr:@std/assert@^1.0.13",
+      "npm:nanoid@^5.1.5"
+    ]
+  }
+}

lib/bitset.ts

···
+export type BitSet = number | number[];
+
+export const setBit = (bits: BitSet, index: number): BitSet => {
+	if (typeof bits !== 'number') {
+		const idx = index >> 5;
+
+		for (let i = bits.length; i <= idx; i++) {
+			bits.push(0);
+		}
+
+		bits[idx] |= 1 << index % 32;
+		return bits;
+	} else if (index < 32) {
+		return bits | (1 << index);
+	} else {
+		return setBit([bits, 0], index);
+	}
+};
+
+export const getBit = (bits: BitSet, index: number): number => {
+	if (typeof bits === 'number') {
+		return index < 32 ? (bits >>> index) & 1 : 0;
+	} else {
+		return (bits[index >> 5] >>> index % 32) & 1;
+	}
+};

lib/mod.test.ts

···
+import {
+	assert,
+	assertAlmostEquals,
+	assertArrayIncludes,
+	assertEquals,
+	assertStringIncludes,
+	assertThrows,
+} from '@std/assert';
+import { nanoid } from 'nanoid/non-secure';
+
+import * as p from './mod.ts';
+
+// #region Primitive types
+
+Deno.test('string encoding/decoding', () => {
+	const Message = p.message({ text: p.string() }, { text: 1 });
+
+	const cases = [
+		'',
+		'hello world',
+		'hello 🚀',
+		'a'.repeat(1000),
+		'Café',
+		'おはようございます☀️',
+		'नमस्ते',
+		'Здравствуйте',
+		'你'.repeat(43),
+		'🌟'.repeat(32),
+		'🚀🌟💻',
+		'🏳️‍🌈🏳️‍⚧️',
+	];
+
+	for (const text of cases) {
+		const encoded = p.encode(Message, { text });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { text });
+	}
+});
+
+Deno.test('int32 encoding/decoding', () => {
+	const Message = p.message({ value: p.int32() }, { value: 1 });
+
+	const cases = [
+		0,
+		1,
+		-1,
+		127,
+		-128,
+		255,
+		-256,
+		32767,
+		-32768,
+		65535,
+		-65536,
+		2147483647, // max int32
+		-2147483648, // min int32
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('int64 encoding/decoding', () => {
+	const Message = p.message({ value: p.int64() }, { value: 1 });
+
+	const cases = [
+		0n,
+		1n,
+		-1n,
+		127n,
+		-128n,
+		9223372036854775807n, // max int64
+		-9223372036854775808n, // min int64
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('uint32 encoding/decoding', () => {
+	const Message = p.message({ value: p.uint32() }, { value: 1 });
+
+	const cases = [
+		0,
+		1,
+		127,
+		255,
+		32767,
+		65535,
+		2147483647,
+		4294967295, // max uint32
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('uint64 encoding/decoding', () => {
+	const Message = p.message({ value: p.uint64() }, { value: 1 });
+
+	const cases = [
+		0n,
+		1n,
+		127n,
+		255n,
+		18446744073709551615n, // max uint64
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('sint32 encoding/decoding (zigzag)', () => {
+	const schema = p.message({ value: p.sint32() }, { value: 1 });
+
+	const testCases = [
+		0,
+		1,
+		-1,
+		2,
+		-2,
+		127,
+		-128,
+		2147483647, // max int32
+		-2147483648, // min int32
+	];
+
+	for (const value of testCases) {
+		const encoded = p.encode(schema, { value });
+		const decoded = p.decode(schema, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('sint64 encoding/decoding (zigzag)', () => {
+	const Message = p.message({ value: p.sint64() }, { value: 1 });
+
+	const cases = [
+		0n,
+		1n,
+		-1n,
+		2n,
+		-2n,
+		127n,
+		-128n,
+		9223372036854775807n, // max int64
+		-9223372036854775808n, // min int64
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('float encoding/decoding', () => {
+	const Message = p.message({ value: p.float() }, { value: 1 });
+
+	const cases = [
+		0.0,
+		1.0,
+		-1.0,
+		3.14159,
+		-3.14159,
+		1.5e10,
+		-1.5e10,
+		3.4028235e38, // close to max float32
+		1.175494e-38, // close to min positive float32
+		Infinity,
+		-Infinity,
+		NaN,
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		// Special handling for infinity values
+		if (Number.isFinite(value)) {
+			// For finite values, check they're close due to float precision
+			// Use a more lenient tolerance for large numbers
+			const tolerance = Math.abs(value) > 1e9 ? Math.abs(value) * 1e-6 : 1e-6;
+
+			assertAlmostEquals(decoded.value, value, tolerance);
+		} else {
+			assertEquals(decoded.value, value);
+		}
+	}
+});
+
+Deno.test('double encoding/decoding', () => {
+	const Message = p.message({ value: p.double() }, { value: 1 });
+
+	const cases = [
+		0.0,
+		1.0,
+		-1.0,
+		3.141592653589793,
+		-3.141592653589793,
+		1.7976931348623157e+308, // close to max double
+		2.2250738585072014e-308, // close to min positive double
+		Infinity,
+		-Infinity,
+		NaN,
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('float range validation', () => {
+	const Message = p.message({ value: p.float() }, { value: 1 });
+
+	// Test values that should cause range errors
+	const invald = [
+		3.4028236e38, // slightly above max float32
+		-3.4028236e38, // slightly below min float32
+		1e39, // way above max float32
+		-1e39, // way below min float32
+	];
+
+	for (const value of invald) {
+		assertThrows(() => p.encode(Message, { value }), Error, 'invalid_range');
+	}
+
+	// Test edge values that should work
+	const valid = [
+		3.4028235e38, // max float32
+		-3.4028235e38, // min float32
+		1.175494e-38, // min positive float32
+		-1.175494e-38, // max negative float32
+		0, // zero
+		Infinity, // positive infinity
+		-Infinity, // negative infinity
+		NaN, // not a number
+	];
+
+	for (const value of valid) {
+		const encoded = p.encode(Message, { value });
+		void p.decode(Message, encoded);
+	}
+});
+
+Deno.test('double range validation', () => {
+	const Message = p.message({ value: p.double() }, { value: 1 });
+
+	// JavaScript's number type is already IEEE 754 double precision,
+	// so all numbers are valid for double. Test edge cases work correctly.
+	const cases = [
+		Number.MAX_VALUE, // max double
+		-Number.MAX_VALUE, // min double
+		Number.MIN_VALUE, // min positive double
+		-Number.MIN_VALUE, // max negative double
+		0, // zero
+		Infinity, // positive infinity
+		-Infinity, // negative infinity
+		NaN, // not a number
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		void p.decode(Message, encoded);
+	}
+});
+
+Deno.test('boolean encoding/decoding', () => {
+	const Message = p.message({ value: p.boolean() }, { value: 1 });
+
+	const cases = [true, false];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('bytes encoding/decoding', () => {
+	const Message = p.message({ data: p.bytes() }, { data: 1 });
+
+	const cases = [
+		Uint8Array.from([]),
+		Uint8Array.from([0]),
+		Uint8Array.from([1, 2, 3, 4, 5]),
+		Uint8Array.from([255, 254, 253]),
+		new Uint8Array(Array.from({ length: 1000 }, (_, i) => i % 256)), // large array
+	];
+
+	for (const data of cases) {
+		const encoded = p.encode(Message, { data });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { data });
+	}
+});
+
+Deno.test('fixed32 encoding/decoding', () => {
+	const Message = p.message({ value: p.fixed32() }, { value: 1 });
+
+	const cases = [
+		0,
+		1,
+		255,
+		65535,
+		4294967295, // max uint32
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('fixed64 encoding/decoding', () => {
+	const Message = p.message({ value: p.fixed64() }, { value: 1 });
+
+	const cases = [
+		0n,
+		1n,
+		255n,
+		65535n,
+		18446744073709551615n, // max uint64
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('sfixed32 encoding/decoding', () => {
+	const Message = p.message({ value: p.sfixed32() }, { value: 1 });
+
+	const cases = [
+		0,
+		1,
+		-1,
+		2147483647, // max int32
+		-2147483648, // min int32
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('sfixed64 encoding/decoding', () => {
+	const Message = p.message({ value: p.sfixed64() }, { value: 1 });
+
+	const cases = [
+		0n,
+		1n,
+		-1n,
+		9223372036854775807n, // max int64
+		-9223372036854775808n, // min int64
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+// #endregion
+
+// #region Complex types
+
+Deno.test('repeated fields', () => {
+	const Message = p.message({
+		numbers: p.repeated(p.int32()),
+		strings: p.repeated(p.string()),
+	}, {
+		numbers: 1,
+		strings: 2,
+	});
+
+	const cases = [
+		{
+			numbers: [],
+			strings: [],
+		},
+		{
+			numbers: [1],
+			strings: ['hello'],
+		},
+		{
+			numbers: [1, 2, 3, -1, -2],
+			strings: ['hello', 'world', ''],
+		},
+		{
+			numbers: Array.from({ length: 100 }, (_, i) => i),
+			strings: Array.from({ length: 100 }, (_, i) => `item${i}`),
+		},
+	];
+
+	for (const data of cases) {
+		const encoded = p.encode(Message, data);
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, data);
+	}
+});
+
+Deno.test('messages with optional fields', () => {
+	const Message = p.message({
+		required: p.string(),
+		withDefault: p.optional(p.string(), 'default_value'),
+		withFunctionDefault: p.optional(p.int32(), () => 42),
+		withoutDefault: p.optional(p.string()),
+	}, {
+		required: 1,
+		withDefault: 2,
+		withFunctionDefault: 3,
+		withoutDefault: 4,
+	});
+
+	{
+		const full = {
+			required: 'hello',
+			withDefault: 'custom',
+			withFunctionDefault: 99,
+			withoutDefault: 'present',
+		};
+
+		const encoded = p.encode(Message, full);
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, full);
+	}
+	{
+		const minimal = { required: 'hello' };
+
+		const encoded = p.encode(Message, minimal);
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, {
+			required: 'hello',
+			withDefault: 'default_value',
+			withFunctionDefault: 42,
+			// withoutDefault should be undefined (not present)
+		});
+	}
+
+	{
+		const partial = {
+			required: 'hello',
+			withDefault: 'custom_value',
+		};
+
+		const encoded = p.encode(Message, partial);
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, {
+			required: 'hello',
+			withDefault: 'custom_value',
+			withFunctionDefault: 42,
+			// withoutDefault should be undefined (not present)
+		});
+	}
+});
+
+Deno.test('empty messages', () => {
+	const Message = p.message({}, {});
+
+	const encoded = p.encode(Message, {});
+	const decoded = p.decode(Message, encoded);
+
+	assertEquals(decoded, {});
+});
+
+Deno.test('nested messages', () => {
+	const Address = p.message({
+		street: p.string(),
+		city: p.string(),
+		zipCode: p.optional(p.string()),
+	}, {
+		street: 1,
+		city: 2,
+		zipCode: 3,
+	});
+
+	const Person = p.message({
+		name: p.string(),
+		age: p.int32(),
+		address: Address,
+		addresses: p.repeated(Address),
+	}, {
+		name: 1,
+		age: 2,
+		address: 3,
+		addresses: 4,
+	});
+
+	const data = {
+		name: 'John Doe',
+		age: 30,
+		address: {
+			street: '123 Main St',
+			city: 'Anytown',
+			zipCode: '12345',
+		},
+		addresses: [
+			{
+				street: '456 Oak Ave',
+				city: 'Other City',
+			},
+			{
+				street: '789 Pine Rd',
+				city: 'Another City',
+				zipCode: '67890',
+			},
+		],
+	};
+
+	const encoded = p.encode(Person, data);
+	const decoded = p.decode(Person, encoded);
+
+	assertEquals(decoded, data);
+});
+
+Deno.test('self-referential messages', () => {
+	const Node = p.message({
+		value: p.int32(),
+		get next() {
+			return p.optional(Node);
+		},
+	}, {
+		value: 1,
+		next: 2,
+	});
+
+	{
+		const encoded = p.encode(Node, { value: 42 });
+		const decoded = p.decode(Node, encoded);
+
+		assertEquals(decoded, { value: 42 });
+	}
+
+	{
+		const encoded = p.encode(Node, { value: 1, next: { value: 2 } });
+		const decoded = p.decode(Node, encoded);
+
+		assertEquals(decoded, { value: 1, next: { value: 2 } });
+	}
+
+	{
+		const complex: p.InferInput<typeof Node> = {
+			value: 1,
+			next: {
+				value: 2,
+				next: {
+					value: 3,
+					next: {
+						value: 4,
+						next: {
+							value: 5,
+						},
+					},
+				},
+			},
+		};
+
+		const encoded = p.encode(Node, complex);
+		const decoded = p.decode(Node, encoded);
+
+		assertEquals(decoded, complex);
+	}
+});
+
+Deno.test('map type', () => {
+	const Person = p.message({
+		id: p.int32(),
+		name: p.string(),
+	}, {
+		id: 1,
+		name: 2,
+	});
+
+	const Message = p.message({
+		map: p.map(p.string(), Person),
+	}, {
+		map: 1,
+	});
+
+	const cases = [
+		new Map(),
+		new Map([['item1', { id: 1, name: 'first' }]]),
+		new Map([['item1', { id: 1, name: 'first' }], ['item2', { id: 2, name: 'second' }]]),
+	];
+
+	for (const map of cases) {
+		const encoded = p.encode(Message, { map });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { map });
+	}
+});
+
+Deno.test('Timestamp type', () => {
+	{
+		const encoded = p.encode(p.Timestamp, {});
+		const decoded = p.decode(p.Timestamp, encoded);
+
+		assertEquals(decoded, { seconds: 0n, nanos: 0 });
+	}
+
+	{
+		const data: p.InferInput<typeof p.Timestamp> = {
+			seconds: 1609459200n, // 2021-01-01 00:00:00 UTC
+			nanos: 123456789,
+		};
+
+		const encoded = p.encode(p.Timestamp, data);
+		const decoded = p.decode(p.Timestamp, encoded);
+
+		assertEquals(decoded, data);
+	}
+});
+
+Deno.test('Duration type', () => {
+	{
+		const data: p.InferInput<typeof p.Duration> = {
+			seconds: 3661n, // 1 hour, 1 minute, 1 second
+			nanos: 500000000, // 0.5 seconds
+		};
+
+		const encoded = p.encode(p.Duration, data);
+		const decoded = p.decode(p.Duration, encoded);
+
+		assertEquals(decoded, data);
+	}
+
+	{
+		const negative: p.InferInput<typeof p.Duration> = {
+			seconds: -30n,
+			nanos: -500000000,
+		};
+
+		const encoded = p.encode(p.Duration, negative);
+		const decoded = p.decode(p.Duration, encoded);
+
+		assertEquals(decoded, negative);
+	}
+});
+
+Deno.test('Any type', () => {
+	{
+		const messageSchema = p.message({ value: p.string() }, { value: 1 });
+
+		const data = {
+			typeUrl: 'type.googleapis.com/test.Message',
+			value: p.encode(messageSchema, { value: 'hello world' }),
+		};
+
+		const encoded = p.encode(p.Any, data);
+		const decoded = p.decode(p.Any, encoded);
+
+		assertEquals(decoded, data);
+	}
+
+	{
+		const encoded = p.encode(p.Any, {});
+		const decoded = p.decode(p.Any, encoded);
+
+		assertEquals(decoded, { typeUrl: '', value: new Uint8Array(0) });
+	}
+});
+
+// #endregion
+
+// #region Edge cases
+
+Deno.test('large varint values', () => {
+	const Message = p.message({ value: p.int32() }, { value: 1 });
+
+	// Test values that require multiple bytes in varint encoding
+	const cases = [
+		127, // 1 byte
+		128, // 2 bytes
+		16383, // 2 bytes
+		16384, // 3 bytes
+		2097151, // 3 bytes
+		2097152, // 4 bytes
+	];
+
+	for (const value of cases) {
+		const encoded = p.encode(Message, { value });
+		const decoded = p.decode(Message, encoded);
+
+		assertEquals(decoded, { value });
+	}
+});
+
+Deno.test('very large varint handling', () => {
+	const schema = p.message({ value: p.int32() }, { value: 1 });
+
+	// Create a very large varint that would overflow 32-bit int
+	// This represents 0xFFFFFFFF (4294967295) which should become -1 when cast to int32
+	const largeVarintData = Uint8Array.from([
+		8,
+		0xFF,
+		0xFF,
+		0xFF,
+		0xFF,
+		0x0F, // field 1: max uint32 value
+	]);
+
+	const decoded = p.decode(schema, largeVarintData);
+	assertEquals(decoded, { value: -1 }); // Should wrap around to -1
+});
+
+Deno.test('unknown field handling', () => {
+	const Message = p.message({ known: p.string() }, { known: 1 });
+
+	const buffer = Uint8Array.from([
+		10,
+		5,
+		72,
+		101,
+		108,
+		108,
+		111, // field 1: "Hello"
+		18,
+		4,
+		116,
+		101,
+		115,
+		116, // field 2: "test" (unknown)
+		26,
+		3,
+		98,
+		121,
+		101, // field 3: "bye" (unknown)
+	]);
+
+	const decoded = p.decode(Message, buffer);
+
+	assertEquals(decoded, { known: 'Hello' });
+});
+
+Deno.test('duplicate field handling', () => {
+	const Message = p.message({ value: p.int32() }, { value: 1 });
+
+	const buffer = Uint8Array.from([
+		8,
+		42, // field 1: value 42
+		8,
+		24, // field 1: value 24 (duplicate)
+	]);
+
+	const decoded = p.decode(Message, buffer);
+
+	assertEquals(decoded, { value: 24 });
+});
+
+Deno.test('encoding produces correct wire format', () => {
+	// Test that our encoding matches expected protobuf wire format
+	const schema = p.message({
+		a: p.int32(),
+		b: p.string(),
+	}, {
+		a: 1,
+		b: 2,
+	});
+
+	const encoded = p.encode(schema, { a: 150, b: 'testing' });
+
+	// Manual verification of wire format:
+	// Field 1 (a=150): tag=1<<3|0=8, value=150 (varint) = [8, 150, 1]
+	// Field 2 (b="testing"): tag=2<<3|2=18, length=7, "testing" = [18, 7, 116, 101, 115, 116, 105, 110, 103]
+
+	const expected = Uint8Array.from([
+		8,
+		150,
+		1, // field 1: int32 value 150
+		18,
+		7,
+		116,
+		101,
+		115,
+		116,
+		105,
+		110,
+		103, // field 2: string "testing"
+	]);
+
+	assertEquals(encoded, expected);
+});
+
+// #endregion
+
+// #region Input validation errors
+
+Deno.test('type validation errors during encoding', () => {
+	const StringMessage = p.message({ text: p.string() }, { text: 1 });
+	{
+		// @ts-expect-error: purposeful type error
+		const result = p.tryEncode(StringMessage, 123);
+
+		assert(!result.ok);
+		assertEquals(result.message, `invalid_type at . (expected object)`);
+	}
+
+	{
+		// @ts-expect-error: purposeful type error
+		const result = p.tryEncode(StringMessage, { text: 123 });
+
+		assert(!result.ok);
+		assertEquals(result.message, `invalid_type at .text (expected string)`);
+	}
+
+	const Int64Message = p.message({ value: p.int64() }, { value: 1 });
+	{
+		// @ts-expect-error: purposeful type error
+		const result = p.tryEncode(Int64Message, { value: 123 });
+
+		assert(!result.ok);
+		assertEquals(result.message, `invalid_type at .value (expected bigint)`);
+	}
+
+	const Uint64Message = p.message({ value: p.uint64() }, { value: 1 });
+	{
+		// @ts-expect-error: purposeful type error
+		const result = p.tryEncode(Uint64Message, { value: 123 });
+
+		assert(!result.ok);
+		assertEquals(result.message, `invalid_type at .value (expected bigint)`);
+	}
+});
+
+Deno.test('range validation for unsigned types', () => {
+	const Uint32Message = p.message({ value: p.uint32() }, { value: 1 });
+	const Uint64Message = p.message({ value: p.uint64() }, { value: 1 });
+	const Fixed32Message = p.message({ value: p.fixed32() }, { value: 1 });
+	const Fixed64Message = p.message({ value: p.fixed64() }, { value: 1 });
+
+	// uint32 range errors
+	assertThrows(() => p.encode(Uint32Message, { value: -1 }), p.ProtobufError);
+	assertThrows(() => p.encode(Uint32Message, { value: 4294967296 }), p.ProtobufError);
+
+	// uint64 range errors
+	assertThrows(() => p.encode(Uint64Message, { value: -1n }), p.ProtobufError);
+
+	// fixed32 range errors
+	assertThrows(() => p.encode(Fixed32Message, { value: -1 }), p.ProtobufError);
+	assertThrows(() => p.encode(Fixed32Message, { value: 4294967296 }), p.ProtobufError);
+
+	// fixed64 range errors
+	assertThrows(() => p.encode(Fixed64Message, { value: -1n }), p.ProtobufError);
+});
+
+// #endregion
+
+// #region Decoding validation errors
+
+Deno.test('invalid wire type handling', () => {
+	const Message = p.message({ text: p.string() }, { text: 1 });
+
+	// Manually create invalid wire data: field 1 with wire type 0 (varint) instead of 2 (length-delimited)
+	const invalidData = Uint8Array.from([
+		8,
+		72, // field 1, wire type 0, value 72
+	]);
+
+	assertThrows(() => p.decode(Message, invalidData), p.ProtobufError);
+
+	const result = p.tryDecode(Message, invalidData);
+	assert(!result.ok);
+
+	assertEquals(result.issues.length, 1);
+	const issue = result.issues[0];
+
+	assertEquals(issue.code, 'invalid_wire');
+	assertEquals(issue.path, ['text']);
+
+	if (issue.code === 'invalid_wire') {
+		assertEquals(issue.expected, 2); // string expects wire type 2
+	}
+
+	assertStringIncludes(result.message, 'invalid_wire at');
+	assertStringIncludes(result.message, 'expected wire type');
+	assertStringIncludes(result.message, 'text');
+});
+
+Deno.test('multiple validation errors', () => {
+	const Message = p.message({
+		field1: p.string(),
+		field2: p.int32(),
+		field3: p.bytes(),
+	}, {
+		field1: 1,
+		field2: 2,
+		field3: 3,
+	});
+
+	// Create data with wrong wire types for multiple fields
+	const invalidData = Uint8Array.from([
+		8,
+		72, // field 1, wire type 0 instead of 2
+		18,
+		1,
+		65, // field 2, wire type 2 instead of 0
+		24,
+		100, // field 3, wire type 0 instead of 2
+	]);
+
+	const result = p.tryDecode(Message, invalidData);
+	assert(!result.ok);
+
+	assertEquals(result.issues.length, 3); // field1, field2, and field3 have wrong wire types
+
+	const codes = result.issues.map((issue) => issue.code);
+	assert(codes.every((code) => code === 'invalid_wire'));
+
+	const fields = result.issues.map((issue) => issue.path[0]);
+	assertArrayIncludes(fields, ['field1', 'field2', 'field3']);
+
+	assertStringIncludes(result.message, '+2 other issue(s)');
+});
+
+Deno.test('missing required fields during decoding', () => {
+	const Message = p.message({
+		required1: p.string(),
+		required2: p.int32(),
+		optional: p.optional(p.string()),
+	}, {
+		required1: 1,
+		required2: 2,
+		optional: 3,
+	});
+
+	// Create a message missing required fields
+	const partialSchema = p.message({
+		optional: p.optional(p.string()),
+	}, {
+		optional: 3,
+	});
+
+	const encoded = p.encode(partialSchema, { optional: 'hello' });
+
+	const result = p.tryDecode(Message, encoded);
+	assert(!result.ok);
+
+	const issues = result.issues;
+	assertEquals(issues.length, 2);
+
+	const missingCodes = issues.map((issue) => issue.code);
+	assertArrayIncludes(missingCodes, ['missing_value', 'missing_value']);
+
+	const missingKeys = issues.map((issue) => issue.path.join('.'));
+	assertArrayIncludes(missingKeys, ['required1', 'required2']);
+});
+
+Deno.test('empty buffer handling', () => {
+	const Message = p.message({
+		required: p.string(),
+		optional: p.optional(p.string()),
+	}, {
+		required: 1,
+		optional: 2,
+	});
+
+	const emptyBuffer = new Uint8Array(0);
+
+	const result = p.tryDecode(Message, emptyBuffer);
+	assert(!result.ok);
+
+	assertEquals(result.issues.length, 1);
+	assertEquals(result.issues[0].code, 'missing_value');
+	assertEquals(result.issues[0].path, ['required']);
+});
+
+// #endregion
+
+// #region Buffer corruption and underrun
+
+Deno.test('corrupted data handling', () => {
+	const Message = p.message({ text: p.string() }, { text: 1 });
+
+	// Test with truncated data (incomplete varint)
+	const truncatedData = Uint8Array.from([10, 5, 72, 101]); // says length 5 but only has 2 bytes
+
+	assertThrows(() => p.decode(Message, truncatedData));
+});
+
+Deno.test('buffer underrun during decoding', () => {
+	const Message = p.message({ text: p.string() }, { text: 1 });
+
+	// Create a truncated buffer that claims to have more data than it actually has
+	// Wire format: tag (8=field 1, wire type 2) + length (5) + partial data (only 2 bytes instead of 5)
+	const truncatedBuffer = Uint8Array.from([
+		8 | 2, // tag: field 1, wire type 2 (length-delimited)
+		5, // length: claims 5 bytes follow
+		65,
+		66, // only 2 bytes: "AB"
+		// missing 3 bytes!
+	]);
+
+	const result = p.tryDecode(Message, truncatedBuffer);
+
+	assert(!result.ok);
+	assertEquals(result.message, `unexpected_eof at .text (unexpected end of input) (+1 other issue(s))`);
+});
+
+Deno.test('buffer underrun during varint reading', () => {
+	const Message = p.message({ value: p.int32() }, { value: 1 });
+
+	// Create a buffer with incomplete varint (continuation bit set but no more bytes)
+	const incompleteVarint = Uint8Array.from([
+		8, // tag: field 1, wire type 0 (varint)
+		0x80, // varint with continuation bit set, but no more bytes
+	]);
+
+	const result = p.tryDecode(Message, incompleteVarint);
+
+	assert(!result.ok);
+	assertEquals(result.message, `unexpected_eof at .value (unexpected end of input) (+1 other issue(s))`);
+});
+
+// #endregion
+
+// #region Performance tests
+
+Deno.test('round-trip consistency stress test', () => {
+	const Message = p.message({
+		id: p.int64(),
+		name: p.string(),
+		email: p.optional(p.string()),
+		tags: p.repeated(p.string()),
+		metadata: p.bytes(),
+		score: p.double(),
+		active: p.boolean(),
+	}, {
+		id: 1,
+		name: 2,
+		email: 3,
+		tags: 4,
+		metadata: 5,
+		score: 6,
+		active: 7,
+	});
+
+	// Generate random test data
+	for (let i = 0; i < 100; i++) {
+		const data = {
+			id: BigInt(Math.floor(Math.random() * 1000000)),
+			name: `user_${i}`,
+			email: Math.random() > 0.5 ? `user_${i}@example.com` : undefined,
+			tags: Array.from({ length: Math.floor(Math.random() * 5) }, (_, j) => `tag_${j}`),
+			metadata: new Uint8Array(
+				Array.from({ length: Math.floor(Math.random() * 20) }, () => Math.floor(Math.random() * 255)),
+			),
+			score: Math.random() * 100,
+			active: Math.random() > 0.5,
+		};
+
+		const encoded = p.encode(Message, data);
+		const decoded = p.decode(Message, encoded);
+
+		// `assertEquals` throws if properties aren't present entirely.
+		decoded.email ??= undefined;
+
+		assertEquals(decoded, data, `Failed for iteration ${i}`);
+	}
+});
+
+Deno.test('very large arrays', () => {
+	const Message = p.message({ strings: p.repeated(p.string()) }, { strings: 1 });
+
+	const strings = Array.from({ length: 10000 }, () => nanoid(8));
+
+	const encoded = p.encode(Message, { strings });
+	const decoded = p.decode(Message, encoded);
+
+	assertEquals(decoded, { strings });
+});
+
+Deno.test('large string handling', () => {
+	const Message = p.message({ text: p.string() }, { text: 1 });
+
+	const text = nanoid(1048576);
+
+	const encoded = p.encode(Message, { text });
+	const decoded = p.decode(Message, encoded);
+
+	assertEquals(decoded, { text });
+});
+
+Deno.test('large byte array handling', () => {
+	const Message = p.message({ data: p.bytes() }, { data: 1 });
+
+	const data = new Uint8Array(1024 * 1024);
+	for (let i = 0; i < data.length; i++) {
+		data[i] = Math.floor(Math.random() * 255);
+	}
+
+	const encoded = p.encode(Message, { data });
+	const decoded = p.decode(Message, encoded);
+
+	assertEquals(decoded, { data });
+});
+
+// #endregion

lib/mod.ts

···
+// deno-lint-ignore-file no-explicit-any
+
+import { type BitSet, getBit, setBit } from './bitset.ts';
+import { decodeUtf8, encodeUtf8Into, lazy, lazyProperty } from './utils.ts';
+
+const CHUNK_SIZE = 1024;
+
+type Identity<T> = T;
+type Flatten<T> = Identity<{ [K in keyof T]: T[K] }>;
+
+type WireType = 0 | 1 | 2 | 5;
+
+type Key = string | number;
+
+type InputType =
+	| 'array'
+	| 'bigint'
+	| 'boolean'
+	| 'bytes'
+	| 'map'
+	| 'number'
+	| 'object'
+	| 'string';
+
+type RangeType =
+	| 'float'
+	| 'int32'
+	| 'int64'
+	| 'uint32'
+	| 'uint64';
+
+// #region Schema issue types
+type IssueLeaf =
+	| { ok: false; code: 'unexpected_eof' }
+	| { ok: false; code: 'invalid_wire'; expected: WireType }
+	| { ok: false; code: 'missing_value' }
+	| { ok: false; code: 'invalid_type'; expected: InputType }
+	| { ok: false; code: 'invalid_range'; type: RangeType };
+
+type IssueTree =
+	| IssueLeaf
+	| { ok: false; code: 'prepend'; key: Key; tree: IssueTree }
+	| { ok: false; code: 'join'; left: IssueTree; right: IssueTree };
+
+export type Issue = Readonly<
+	| { code: 'unexpected_eof'; path: Key[] }
+	| { code: 'invalid_wire'; path: Key[]; expected: WireType }
+	| { code: 'missing_value'; path: Key[] }
+	| { code: 'invalid_type'; path: Key[]; expected: InputType }
+	| { code: 'invalid_range'; path: Key[]; type: RangeType }
+>;
+
+const EOF_ISSUE: IssueLeaf = { ok: false, code: 'unexpected_eof' };
+
+const ARRAY_TYPE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_type', expected: 'array' };
+const BIGINT_TYPE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_type', expected: 'bigint' };
+const BOOLEAN_TYPE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_type', expected: 'boolean' };
+const BYTES_TYPE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_type', expected: 'bytes' };
+const MAP_TYPE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_type', expected: 'map' };
+const NUMBER_TYPE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_type', expected: 'number' };
+const OBJECT_TYPE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_type', expected: 'object' };
+const STRING_TYPE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_type', expected: 'string' };
+
+const FLOAT_RANGE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_range', type: 'float' };
+const INT32_RANGE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_range', type: 'int32' };
+const INT64_RANGE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_range', type: 'int64' };
+const UINT32_RANGE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_range', type: 'uint32' };
+const UINT64_RANGE_ISSUE: IssueLeaf = { ok: false, code: 'invalid_range', type: 'uint64' };
+
+// #__NO_SIDE_EFFECTS__
+const joinIssues = (left: IssueTree | undefined, right: IssueTree): IssueTree => {
+	return left ? { ok: false, code: 'join', left, right } : right;
+};
+
+// #__NO_SIDE_EFFECTS__
+const prependPath = (key: Key, tree: IssueTree): IssueTree => {
+	return { ok: false, code: 'prepend', key, tree };
+};
+
+// #region Error formatting utilities
+
+const cloneIssueWithPath = (issue: IssueLeaf, path: Key[]): Issue => {
+	const { ok: _ok, ...clone } = issue;
+
+	return { ...clone, path };
+};
+
+const collectIssues = (tree: IssueTree, path: Key[] = [], issues: Issue[] = []): Issue[] => {
+	for (;;) {
+		switch (tree.code) {
+			case 'join': {
+				collectIssues(tree.left, path.slice(), issues);
+				tree = tree.right;
+				continue;
+			}
+			case 'prepend': {
+				path.push(tree.key);
+				tree = tree.tree;
+				continue;
+			}
+			default: {
+				issues.push(cloneIssueWithPath(tree, path));
+				return issues;
+			}
+		}
+	}
+};
+
+const countIssues = (tree: IssueTree): number => {
+	let count = 0;
+	for (;;) {
+		switch (tree.code) {
+			case 'join': {
+				count += countIssues(tree.left);
+				tree = tree.right;
+				continue;
+			}
+			case 'prepend': {
+				tree = tree.tree;
+				continue;
+			}
+			default: {
+				return count + 1;
+			}
+		}
+	}
+};
+
+const formatIssueTree = (tree: IssueTree): string => {
+	let path = '';
+	let count = 0;
+	for (;;) {
+		switch (tree.code) {
+			case 'join': {
+				count += countIssues(tree.right);
+				tree = tree.left;
+				continue;
+			}
+			case 'prepend': {
+				path += `.${tree.key}`;
+				tree = tree.tree;
+				continue;
+			}
+		}
+
+		break;
+	}
+
+	let message: string;
+	switch (tree.code) {
+		case 'missing_value':
+			message = 'required field is missing';
+			break;
+		case 'invalid_wire':
+			message = `expected wire type ${tree.expected}`;
+			break;
+		case 'unexpected_eof':
+			message = `unexpected end of input`;
+			break;
+		case 'invalid_type':
+			message = `expected ${tree.expected}`;
+			break;
+		case 'invalid_range':
+			message = `value out of range for ${tree.type}`;
+			break;
+		default:
+			message = 'unknown error';
+			break;
+	}
+
+	let msg = `${tree.code} at ${path || '.'} (${message})`;
+	if (count > 0) {
+		msg += ` (+${count} other issue(s))`;
+	}
+
+	return msg;
+};
+
+// #endregion
+
+// #region Result types
+
+export type Ok<T> = {
+	ok: true;
+	value: T;
+};
+export type Err = {
+	ok: false;
+	readonly message: string;
+	readonly issues: readonly Issue[];
+	throw(): never;
+};
+
+export type Result<T> = Ok<T> | Err;
+
+export class ProtobufError extends Error {
+	override readonly name = 'ProtobufError';
+
+	#issueTree: IssueTree;
+
+	constructor(issueTree: IssueTree) {
+		super();
+
+		this.#issueTree = issueTree;
+	}
+
+	override get message(): string {
+		return formatIssueTree(this.#issueTree);
+	}
+
+	get issues(): readonly Issue[] {
+		return collectIssues(this.#issueTree);
+	}
+}
+
+class ErrImpl implements Err {
+	readonly ok = false;
+
+	#issueTree: IssueTree;
+
+	constructor(issueTree: IssueTree) {
+		this.#issueTree = issueTree;
+	}
+
+	get message(): string {
+		return formatIssueTree(this.#issueTree);
+	}
+
+	get issues(): readonly Issue[] {
+		return collectIssues(this.#issueTree);
+	}
+
+	throw(): never {
+		throw new ProtobufError(this.#issueTree);
+	}
+}
+
+const createDecoderState = (buffer: Uint8Array): DecoderState => {
+	return {
+		b: buffer,
+		p: 0,
+		v: null,
+	};
+};
+
+const createEncoderState = (): EncoderState => {
+	return {
+		c: [],
+		b: new Uint8Array(CHUNK_SIZE),
+		v: null,
+		p: 0,
+		l: 0,
+	};
+};
+
+/**
+ * gracefully decode protobuf message
+ * @param schema message schema
+ * @param buffer byte array
+ * @returns decode result
+ */
+// #__NO_SIDE_EFFECTS__
+export const tryDecode = <TSchema extends MessageSchema>(
+	schema: TSchema,
+	buffer: Uint8Array,
+): Result<InferOutput<TSchema>> => {
+	const state = createDecoderState(buffer);
+
+	const result = schema['~~decode'](state, FLAG_EMPTY);
+
+	if (result.ok) {
+		return result as Ok<InferOutput<TSchema>>;
+	}
+
+	return new ErrImpl(result);
+};
+
+/**
+ * gracefully encode protobuf message
+ * @param schema message schema
+ * @param value JavaScript value
+ * @returns encode result
+ */
+// #__NO_SIDE_EFFECTS__
+export const tryEncode = <TSchema extends MessageSchema>(
+	schema: TSchema,
+	value: InferInput<TSchema>,
+): Result<Uint8Array> => {
+	const state = createEncoderState();
+
+	const result = schema['~~encode'](state, value);
+	if (result !== undefined) {
+		return new ErrImpl(result);
+	}
+
+	return { ok: true, value: finishEncode(state) };
+};
+
+/**
+ * decode protobuf message
+ * @param schema message schema
+ * @param buffer byte array
+ * @returns decoded JavaScript value
+ * @throws {ProtobufError} when decoding fails
+ */
+// #__NO_SIDE_EFFECTS__
+export const decode = <TSchema extends MessageSchema>(
+	schema: TSchema,
+	buffer: Uint8Array,
+): InferOutput<TSchema> => {
+	const state = createDecoderState(buffer);
+
+	const result = schema['~~decode'](state, FLAG_EMPTY);
+
+	if (result.ok) {
+		return result.value as InferOutput<TSchema>;
+	}
+
+	throw new ProtobufError(result);
+};
+
+/**
+ * encode protobuf message
+ * @param schema message schema
+ * @param value JavaScript value
+ * @returns encoded byte array
+ * @throws {ProtobufError} when encoding fails
+ */
+// #__NO_SIDE_EFFECTS__
+export const encode = <TSchema extends MessageSchema>(
+	schema: TSchema,
+	value: InferInput<TSchema>,
+): Uint8Array => {
+	const state = createEncoderState();
+
+	const result = schema['~~encode'](state, value);
+
+	if (result !== undefined) {
+		throw new ProtobufError(result);
+	}
+
+	return finishEncode(state);
+};
+
+// #region Raw decoders
+
+interface DecoderState {
+	b: Uint8Array;
+	p: number;
+	v: DataView | null;
+}
+
+const readVarint = (state: DecoderState): RawResult<number> => {
+	const buf = state.b;
+	let pos = state.p;
+
+	let result = 0;
+	let shift = 0;
+	let byte;
+
+	do {
+		if (pos >= buf.length) {
+			return EOF_ISSUE;
+		}
+		byte = buf[pos++];
+		result |= (byte & 0x7F) << shift;
+		shift += 7;
+	} while (byte & 0x80);
+
+	state.p = pos;
+	return { ok: true, value: result };
+};
+
+const readBytes = (state: DecoderState, length: number): RawResult<Uint8Array> => {
+	const buf = state.b;
+
+	const start = state.p;
+	const end = start + length;
+
+	if (end > buf.length) {
+		return EOF_ISSUE;
+	}
+
+	state.p = end;
+	return { ok: true, value: buf.subarray(start, end) };
+};
+
+const skipField = (state: DecoderState, wire: WireType): RawResult<void> => {
+	switch (wire) {
+		case 0: {
+			const result = readVarint(state);
+			if (!result.ok) {
+				return result;
+			}
+
+			break;
+		}
+		case 1: {
+			if (state.p + 8 > state.b.length) {
+				return EOF_ISSUE;
+			}
+
+			state.p += 8;
+			break;
+		}
+		case 2: {
+			const length = readVarint(state);
+			if (!length.ok) {
+				return length;
+			}
+
+			if (state.p + length.value > state.b.length) {
+				return EOF_ISSUE;
+			}
+
+			state.p += length.value;
+			break;
+		}
+		case 5: {
+			if (state.p + 4 > state.b.length) {
+				return EOF_ISSUE;
+			}
+
+			state.p += 4;
+			break;
+		}
+	}
+
+	return { ok: true, value: undefined };
+};
+
+// #region Raw encoders
+
+interface EncoderState {
+	c: Uint8Array[];
+	b: Uint8Array;
+	v: DataView | null;
+	p: number;
+	l: number;
+}
+
+const resizeIfNeeded = (state: EncoderState, needed: number): void => {
+	const buf = state.b;
+	const pos = state.p;
+
+	if (buf.byteLength < pos + needed) {
+		state.c.push(buf.subarray(0, pos));
+		state.l += pos;
+
+		state.b = new Uint8Array(Math.max(CHUNK_SIZE, needed));
+		state.v = null;
+		state.p = 0;
+	}
+};
+
+const writeVarint = (state: EncoderState, input: number | bigint): void => {
+	if (typeof input === 'bigint') {
+		resizeIfNeeded(state, 10);
+
+		// Handle negative BigInt values properly for two's complement
+		let n = input;
+		if (n < 0n) {
+			// Convert to unsigned representation for encoding
+			n = (1n << 64n) + n;
+		}
+
+		while (n >= 0x80n) {
+			state.b[state.p++] = Number(n & 0x7fn) | 0x80;
+			n >>= 7n;
+		}
+
+		state.b[state.p++] = Number(n);
+	} else {
+		resizeIfNeeded(state, 5);
+
+		let n = input >>> 0;
+		while (n >= 0x80) {
+			state.b[state.p++] = (n & 0x7f) | 0x80;
+			n >>>= 7;
+		}
+
+		state.b[state.p++] = n;
+	}
+};
+
+// Helper function to calculate varint length without encoding
+const getVarintLength = (value: number): number => {
+	if (value < 0x80) return 1;
+	if (value < 0x4000) return 2;
+	if (value < 0x200000) return 3;
+	if (value < 0x10000000) return 4;
+	return 5;
+};
+
+const writeBytes = (state: EncoderState, bytes: Uint8Array): void => {
+	resizeIfNeeded(state, bytes.length);
+
+	state.b.set(bytes, state.p);
+	state.p += bytes.length;
+};
+
+const finishEncode = (state: EncoderState): Uint8Array => {
+	const chunks = state.c;
+
+	if (chunks.length === 0) {
+		return state.b.subarray(0, state.p);
+	}
+
+	const buffer = new Uint8Array(state.l + state.p);
+
+	let written = 0;
+	for (let idx = 0, len = chunks.length; idx < len; idx++) {
+		const chunk = chunks[idx];
+
+		buffer.set(chunk, written);
+		written += chunk.length;
+	}
+
+	buffer.set(state.b.subarray(0, state.p), written);
+	return buffer;
+};
+
+// #endregion
+
+// #region Common utilities
+
+const getDataView = (state: EncoderState | DecoderState): DataView => {
+	return state.v ??= new DataView(state.b.buffer, state.b.byteOffset, state.b.byteLength);
+};
+
+// #endregion
+
+// #region Base schema
+
+// Private symbols meant to hold types
+declare const kType: unique symbol;
+type kType = typeof kType;
+
+// We need a special symbol to hold the types for objects due to their
+// recursive nature.
+declare const kObjectType: unique symbol;
+type kObjectType = typeof kObjectType;
+
+// None set
+export const FLAG_EMPTY = 0;
+// Don't continue validation if an error is encountered
+export const FLAG_ABORT_EARLY = 1 << 0;
+
+type RawResult<T = unknown> = Ok<T> | IssueTree;
+
+type Decoder = (this: void, state: DecoderState, flags: number) => RawResult;
+
+type Encoder = (this: void, state: EncoderState, input: unknown) => IssueTree | void;
+
+export interface BaseSchema<TInput = unknown, TOutput = TInput> {
+	readonly kind: 'schema';
+	readonly type: string;
+	readonly wire: WireType;
+	readonly '~decode': Decoder;
+	readonly '~encode': Encoder;
+
+	readonly [kType]?: { in: TInput; out: TOutput };
+}
+
+export type InferInput<T extends BaseSchema> = T extends { [kObjectType]?: any }
+	? NonNullable<T[kObjectType]>['in']
+	: NonNullable<T[kType]>['in'];
+
+export type InferOutput<T extends BaseSchema> = T extends { [kObjectType]?: any }
+	? NonNullable<T[kObjectType]>['out']
+	: NonNullable<T[kType]>['out'];
+
+// #region String schema
+export interface StringSchema extends BaseSchema<string> {
+	readonly type: 'string';
+	readonly wire: 2;
+}
+
+const STRING_SINGLETON: StringSchema = {
+	kind: 'schema',
+	type: 'string',
+	wire: 2,
+	'~decode'(state, _flags) {
+		const length = readVarint(state);
+		if (!length.ok) {
+			return length;
+		}
+
+		const bytes = readBytes(state, length.value);
+		if (!bytes.ok) {
+			return bytes;
+		}
+
+		return { ok: true, value: decodeUtf8(bytes.value) };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'string') {
+			return STRING_TYPE_ISSUE;
+		}
+
+		// 1. Estimate the length of the header based on the UTF-16 size of the string
+		// 2. Directly write the string at the estimated location, retrieving the actual length
+		// 3. Write the header now that the length is available
+		// 4. If the estimation was wrong, correct the placement of the string
+
+		// JS strings are UTF-16, worst case UTF-8 length is length * 3
+		const strLength = input.length;
+		resizeIfNeeded(state, strLength * 3 + 5); // +5 for max varint length
+
+		const estimatedHeaderSize = getVarintLength(strLength);
+		const estimatedPosition = state.p + estimatedHeaderSize;
+		const actualLength = encodeUtf8Into(state.b, input, estimatedPosition);
+
+		const actualHeaderSize = getVarintLength(actualLength);
+		if (estimatedHeaderSize !== actualHeaderSize) {
+			// Estimation was incorrect, move the bytes to the real place
+			state.b.copyWithin(state.p + actualHeaderSize, estimatedPosition, estimatedPosition + actualLength);
+		}
+
+		writeVarint(state, actualLength);
+		state.p += actualLength;
+	},
+};
+
+/**
+ * creates a string schema
+ * strings are encoded as UTF-8 with length-prefixed wire format
+ * @returns string schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const string = (): StringSchema => {
+	return STRING_SINGLETON;
+};
+
+// #region Bytes schema
+export interface BytesSchema extends BaseSchema<Uint8Array> {
+	readonly type: 'bytes';
+	readonly wire: 2;
+}
+
+const BYTES_SINGLETON: BytesSchema = {
+	kind: 'schema',
+	type: 'bytes',
+	wire: 2,
+	'~decode'(state, _flags) {
+		const length = readVarint(state);
+		if (!length.ok) {
+			return length;
+		}
+
+		return readBytes(state, length.value);
+	},
+	'~encode'(state, input) {
+		if (!(input instanceof Uint8Array)) {
+			return BYTES_TYPE_ISSUE;
+		}
+
+		resizeIfNeeded(state, 5 + input.length);
+		writeVarint(state, input.length);
+		writeBytes(state, input);
+	},
+};
+
+/**
+ * creates a bytes schema
+ * handles arbitrary binary data as Uint8Array with length-prefixed wire format
+ * @returns bytes schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const bytes = (): BytesSchema => {
+	return BYTES_SINGLETON;
+};
+
+// #region Boolean schema
+export interface BooleanSchema extends BaseSchema<boolean> {
+	readonly type: 'boolean';
+	readonly wire: 0;
+}
+
+const BOOLEAN_SINGLETON: BooleanSchema = {
+	kind: 'schema',
+	type: 'boolean',
+	wire: 0,
+	'~decode'(state, _flags) {
+		const result = readVarint(state);
+		if (!result.ok) {
+			return result;
+		}
+
+		return { ok: true, value: result.value !== 0 };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'boolean') {
+			return BOOLEAN_TYPE_ISSUE;
+		}
+
+		writeVarint(state, input ? 1 : 0);
+	},
+};
+
+/**
+ * creates a boolean schema
+ * booleans are encoded as varint (0 for false, 1 for true)
+ * @returns boolean schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const boolean = (): BooleanSchema => {
+	return BOOLEAN_SINGLETON;
+};
+
+// #region Double schema
+export interface DoubleSchema extends BaseSchema<number> {
+	readonly type: 'double';
+	readonly wire: 1;
+}
+
+const DOUBLE_SINGLETON: DoubleSchema = {
+	kind: 'schema',
+	type: 'double',
+	wire: 1,
+	'~decode'(state, _flags) {
+		const view = getDataView(state);
+		const value = view.getFloat64(state.p, true);
+
+		state.p += 8;
+		return { ok: true, value };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'number') {
+			return NUMBER_TYPE_ISSUE;
+		}
+
+		resizeIfNeeded(state, 8);
+
+		const view = getDataView(state);
+		view.setFloat64(state.p, input, true);
+
+		state.p += 8;
+	},
+};
+
+/**
+ * creates a double-precision floating point schema
+ * uses 64-bit IEEE 754 format, encoded as 8 bytes in little-endian
+ * @returns double schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const double = (): DoubleSchema => {
+	return DOUBLE_SINGLETON;
+};
+
+// #region Float schema
+export interface FloatSchema extends BaseSchema<number> {
+	readonly type: 'float';
+	readonly wire: 5;
+}
+
+const FLOAT_SINGLETON: FloatSchema = {
+	kind: 'schema',
+	type: 'float',
+	wire: 5,
+	'~decode'(state, _flags) {
+		const view = getDataView(state);
+		const value = view.getFloat32(state.p, true);
+
+		state.p += 4;
+		return { ok: true, value };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'number') {
+			return NUMBER_TYPE_ISSUE;
+		}
+		if (isFinite(input)) {
+			const abs = Math.abs(input);
+
+			if ((abs > 3.4028235e38 || (abs < 1.175494e-38 && input !== 0))) {
+				return FLOAT_RANGE_ISSUE;
+			}
+		}
+
+		resizeIfNeeded(state, 4);
+
+		const view = getDataView(state);
+		view.setFloat32(state.p, input, true);
+
+		state.p += 4;
+	},
+};
+
+/**
+ * creates a single-precision floating point schema
+ * uses 32-bit IEEE 754 format, encoded as 4 bytes in little-endian
+ * @returns float schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const float = (): FloatSchema => {
+	return FLOAT_SINGLETON;
+};
+
+// #region Int32 schema
+export interface Int32Schema extends BaseSchema<number> {
+	readonly type: 'int32';
+	readonly wire: 0;
+}
+
+const INT32_SINGLETON: Int32Schema = {
+	kind: 'schema',
+	type: 'int32',
+	wire: 0,
+	'~decode'(state, _flags) {
+		const result = readVarint(state);
+		if (!result.ok) {
+			return result;
+		}
+
+		// Read as unsigned, then convert to signed 32-bit (handling sign extension)
+		const value = result.value | 0;
+
+		return { ok: true, value };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'number') {
+			return NUMBER_TYPE_ISSUE;
+		}
+		if (input < -0x80000000 || input > 0x7fffffff) {
+			return INT32_RANGE_ISSUE;
+		}
+
+		const n = input | 0;
+
+		writeVarint(state, n);
+	},
+};
+
+/**
+ * creates a 32-bit signed integer schema
+ * uses varint encoding. values must be in range [-2^31, 2^31-1]
+ * @returns int32 schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const int32 = (): Int32Schema => {
+	return INT32_SINGLETON;
+};
+
+// #region Int64 schema
+export interface Int64Schema extends BaseSchema<bigint> {
+	readonly type: 'int64';
+	readonly wire: 0;
+}
+
+const INT64_SINGLETON: Int64Schema = {
+	kind: 'schema',
+	type: 'int64',
+	wire: 0,
+	'~decode'(state, _flags) {
+		const buf = state.b;
+		let pos = state.p;
+
+		let result = 0n;
+		let shift = 0n;
+		let byte;
+
+		do {
+			byte = buf[pos++];
+			result |= BigInt(byte & 0x7F) << shift;
+			shift += 7n;
+		} while (byte & 0x80);
+
+		state.p = pos;
+
+		// Convert from unsigned to signed (two's complement)
+		if (result >= (1n << 63n)) {
+			result = result - (1n << 64n);
+		}
+
+		return { ok: true, value: result };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'bigint') {
+			return BIGINT_TYPE_ISSUE;
+		}
+		if (input < -0x8000000000000000n || input > 0x7fffffffffffffffn) {
+			return INT64_RANGE_ISSUE;
+		}
+
+		// Convert signed to unsigned representation for wire format
+		let value = input;
+		if (input < 0n) {
+			value = input + 0x10000000000000000n;
+		}
+
+		writeVarint(state, value);
+	},
+};
+
+/**
+ * creates a 64-bit signed integer schema
+ * uses varint encoding. values must be in range [-2^63, 2^63-1]
+ * JavaScript values are represented as bigint
+ * @returns int64 schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const int64 = (): Int64Schema => {
+	return INT64_SINGLETON;
+};
+
+// #region Uint32 schema
+export interface Uint32Schema extends BaseSchema<number> {
+	readonly type: 'uint32';
+	readonly wire: 0;
+}
+
+const UINT32_SINGLETON: Uint32Schema = {
+	kind: 'schema',
+	type: 'uint32',
+	wire: 0,
+	'~decode'(state, _flags) {
+		const result = readVarint(state);
+		if (!result.ok) {
+			return result;
+		}
+
+		// Limit to unsigned 32-bit
+		const value = result.value >>> 0;
+
+		return { ok: true, value };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'number') {
+			return NUMBER_TYPE_ISSUE;
+		}
+		if (input < 0 || input > 0xffffffff) {
+			return UINT32_RANGE_ISSUE;
+		}
+
+		writeVarint(state, input >>> 0);
+	},
+};
+
+/**
+ * creates a 32-bit unsigned integer schema
+ * uses varint encoding. values must be in range [0, 2^32-1]
+ * @returns uint32 schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const uint32 = (): Uint32Schema => {
+	return UINT32_SINGLETON;
+};
+
+// #region Uint64 schema
+export interface Uint64Schema extends BaseSchema<bigint> {
+	readonly type: 'uint64';
+	readonly wire: 0;
+}
+
+const UINT64_SINGLETON: Uint64Schema = {
+	kind: 'schema',
+	type: 'uint64',
+	wire: 0,
+	'~decode'(state, _flags) {
+		const buf = state.b;
+		let pos = state.p;
+
+		let result = 0n;
+		let shift = 0n;
+		let byte;
+
+		do {
+			byte = buf[pos++];
+			result |= BigInt(byte & 0x7F) << shift;
+			shift += 7n;
+		} while (byte & 0x80);
+
+		state.p = pos;
+		return { ok: true, value: result };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'bigint') {
+			return BIGINT_TYPE_ISSUE;
+		}
+		if (input < 0n) {
+			return UINT64_RANGE_ISSUE;
+		}
+
+		writeVarint(state, input);
+	},
+};
+
+/**
+ * creates a 64-bit unsigned integer schema
+ * uses varint encoding. values must be in range [0, 2^64-1]
+ * JavaScript values are represented as bigint
+ * @returns uint64 schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const uint64 = (): Uint64Schema => {
+	return UINT64_SINGLETON;
+};
+
+// #region Sint32 schema (zigzag encoding)
+export interface Sint32Schema extends BaseSchema<number> {
+	readonly type: 'sint32';
+	readonly wire: 0;
+}
+
+const SINT32_SINGLETON: Sint32Schema = {
+	kind: 'schema',
+	type: 'sint32',
+	wire: 0,
+	'~decode'(state, _flags) {
+		const result = readVarint(state);
+		if (!result.ok) {
+			return result;
+		}
+
+		const n = result.value;
+		return { ok: true, value: (n >>> 1) ^ (-(n & 1)) };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'number') {
+			return NUMBER_TYPE_ISSUE;
+		}
+		if (input < -0x80000000 || input > 0x7fffffff) {
+			return INT32_RANGE_ISSUE;
+		}
+
+		const n = input | 0;
+
+		writeVarint(state, (n << 1) ^ (n >> 31));
+	},
+};
+
+/**
+ * creates a 32-bit signed integer schema
+ * uses zigzag encoding to efficiently encode negative numbers. values must be in range [-2^31, 2^31-1]
+ * @returns sint32 schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const sint32 = (): Sint32Schema => {
+	return SINT32_SINGLETON;
+};
+
+// #region Sint64 schema (zigzag encoding with BigInt)
+export interface Sint64Schema extends BaseSchema<bigint> {
+	readonly type: 'sint64';
+	readonly wire: 0;
+}
+
+const SINT64_SINGLETON: Sint64Schema = {
+	kind: 'schema',
+	type: 'sint64',
+	wire: 0,
+	'~decode'(state, _flags) {
+		const buf = state.b;
+		let pos = state.p;
+
+		let result = 0n;
+		let shift = 0n;
+		let byte;
+
+		do {
+			byte = buf[pos++];
+			result |= BigInt(byte & 0x7F) << shift;
+			shift += 7n;
+		} while (byte & 0x80);
+
+		state.p = pos;
+
+		return { ok: true, value: (result >> 1n) ^ (-(result & 1n)) };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'bigint') {
+			return BIGINT_TYPE_ISSUE;
+		}
+		if (input < -0x8000000000000000n || input > 0x7fffffffffffffffn) {
+			return INT64_RANGE_ISSUE;
+		}
+
+		writeVarint(state, (input << 1n) ^ (input >> 63n));
+	},
+};
+
+/**
+ * creates a 64-bit signed integer schema
+ * uses zigzag encoding to efficiently encode negative numbers. values must be in range [-2^63, 2^63-1]
+ * JavaScript values are represented as bigint
+ * @returns sint64 schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const sint64 = (): Sint64Schema => {
+	return SINT64_SINGLETON;
+};
+
+// #region Fixed32 schema
+export interface Fixed32Schema extends BaseSchema<number> {
+	readonly type: 'fixed32';
+	readonly wire: 5;
+}
+
+const FIXED32_SINGLETON: Fixed32Schema = {
+	kind: 'schema',
+	type: 'fixed32',
+	wire: 5,
+	'~decode'(state, _flags) {
+		const view = getDataView(state);
+		const value = view.getUint32(state.p, true);
+
+		state.p += 4;
+		return { ok: true, value };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'number') {
+			return NUMBER_TYPE_ISSUE;
+		}
+		if (input < 0 || input > 0xffffffff) {
+			return UINT32_RANGE_ISSUE;
+		}
+
+		resizeIfNeeded(state, 4);
+
+		const view = getDataView(state);
+		view.setUint32(state.p, input, true);
+
+		state.p += 4;
+	},
+};
+
+/**
+ * creates a 32-bit fixed-width unsigned integer schema.
+ * always uses exactly 4 bytes in little-endian format. values must be in range [0, 2^32-1]
+ * @returns fixed32 schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const fixed32 = (): Fixed32Schema => {
+	return FIXED32_SINGLETON;
+};
+
+// #region Fixed64 schema
+export interface Fixed64Schema extends BaseSchema<bigint> {
+	readonly type: 'fixed64';
+	readonly wire: 1;
+}
+
+const FIXED64_SINGLETON: Fixed64Schema = {
+	kind: 'schema',
+	type: 'fixed64',
+	wire: 1,
+	'~decode'(state, _flags) {
+		const view = getDataView(state);
+
+		// Read as two 32-bit values and combine into a BigInt
+		const lo = view.getUint32(state.p, true);
+		const hi = view.getUint32(state.p + 4, true);
+
+		state.p += 8;
+		return { ok: true, value: (BigInt(hi) << 32n) | BigInt(lo) };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'bigint') {
+			return BIGINT_TYPE_ISSUE;
+		}
+		if (input < 0n) {
+			return UINT64_RANGE_ISSUE;
+		}
+
+		resizeIfNeeded(state, 8);
+
+		const view = getDataView(state);
+
+		view.setUint32(state.p, Number(input & 0xffffffffn), true);
+		view.setUint32(state.p + 4, Number(input >> 32n), true);
+
+		state.p += 8;
+	},
+};
+
+/**
+ * creates a 64-bit fixed-width unsigned integer schema
+ * always uses exactly 8 bytes in little-endian format. values must be in range [0, 2^64-1]
+ * JavaScript values are represented as bigint
+ *
+ * @returns fixed64 schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const fixed64 = (): Fixed64Schema => {
+	return FIXED64_SINGLETON;
+};
+
+// #region Sfixed32 schema
+export interface Sfixed32Schema extends BaseSchema<number> {
+	readonly type: 'sfixed32';
+	readonly wire: 5;
+}
+
+const SFIXED32_SINGLETON: Sfixed32Schema = {
+	kind: 'schema',
+	type: 'sfixed32',
+	wire: 5,
+	'~decode'(state, _flags) {
+		const view = getDataView(state);
+		const value = view.getInt32(state.p, true);
+
+		state.p += 4;
+		return { ok: true, value };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'number') {
+			return NUMBER_TYPE_ISSUE;
+		}
+		if (input < -0x80000000 || input > 0x7fffffff) {
+			return INT32_RANGE_ISSUE;
+		}
+
+		resizeIfNeeded(state, 4);
+
+		const view = getDataView(state);
+		view.setInt32(state.p, input | 0, true);
+
+		state.p += 4;
+	},
+};
+
+/**
+ * creates a 32-bit fixed-width signed integer schema
+ * always uses exactly 4 bytes in little-endian format. values must be in range [-2^31, 2^31-1]
+ * @returns sfixed32 schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const sfixed32 = (): Sfixed32Schema => {
+	return SFIXED32_SINGLETON;
+};
+
+// #region Sfixed64 schema
+export interface Sfixed64Schema extends BaseSchema<bigint> {
+	readonly type: 'sfixed64';
+	readonly wire: 1;
+}
+
+const SFIXED64_SINGLETON: Sfixed64Schema = {
+	kind: 'schema',
+	type: 'sfixed64',
+	wire: 1,
+	'~decode'(state, _flags) {
+		const view = getDataView(state);
+
+		// Read as two 32-bit values and combine into a BigInt
+		const lo = view.getUint32(state.p, true);
+		const hi = view.getInt32(state.p + 4, true); // High bits should be signed
+
+		state.p += 8;
+
+		// Combine into a single signed 64-bit bigint
+		return { ok: true, value: (BigInt(hi) << 32n) | BigInt(lo) };
+	},
+	'~encode'(state, input) {
+		if (typeof input !== 'bigint') {
+			return BIGINT_TYPE_ISSUE;
+		}
+		if (input < -0x8000000000000000n || input > 0x7fffffffffffffffn) {
+			return INT64_RANGE_ISSUE;
+		}
+
+		resizeIfNeeded(state, 8);
+
+		const view = getDataView(state);
+
+		view.setUint32(state.p, Number(input & 0xffffffffn), true);
+		view.setInt32(state.p + 4, Number(input >> 32n), true);
+
+		state.p += 8;
+	},
+};
+
+/**
+ * creates a 64-bit fixed-width signed integer schema
+ * uses exactly 8 bytes in little-endian format. values must be in range [-2^63, 2^63-1]
+ * JavaScript values are represented as bigint
+ * @returns sfixed64 schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const sfixed64 = (): Sfixed64Schema => {
+	return SFIXED64_SINGLETON;
+};
+
+// #region Repeated schema
+export interface RepeatedSchema<TItem extends BaseSchema> extends BaseSchema<unknown[]> {
+	readonly type: 'repeated';
+	readonly wire: 2;
+	readonly item: TItem;
+
+	readonly [kObjectType]?: { in: InferInput<TItem>[]; out: InferOutput<TItem>[] };
+}
+
+/**
+ * creates a value array schema
+ * @param item item schema to repeat
+ * @returns repeated schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const repeated = <TItem extends BaseSchema>(item: TItem | (() => TItem)): RepeatedSchema<TItem> => {
+	const resolvedShape = lazy(() => {
+		return typeof item === 'function' ? item() : item;
+	});
+
+	return {
+		kind: 'schema',
+		type: 'repeated',
+		wire: 2,
+		get item() {
+			return lazyProperty(this, 'item', resolvedShape.value);
+		},
+		get '~decode'() {
+			const shape = resolvedShape.value;
+
+			const decoder: Decoder = (state, flags) => {
+				const length = readVarint(state);
+				if (!length.ok) {
+					return length;
+				}
+
+				const bytes = readBytes(state, length.value);
+				if (!bytes.ok) {
+					return bytes;
+				}
+
+				const children: DecoderState = {
+					b: bytes.value,
+					p: 0,
+					v: null,
+				};
+
+				const array: any[] = [];
+
+				let idx = 0;
+				let issues: IssueTree | undefined;
+
+				while (children.p < length.value) {
+					const r = shape['~decode'](children, flags);
+
+					if (r.ok) {
+						array.push(r.value);
+					} else {
+						issues = joinIssues(issues, prependPath(idx, r));
+
+						if (flags & FLAG_ABORT_EARLY) {
+							return issues;
+						}
+					}
+
+					idx++;
+				}
+
+				if (issues !== undefined) {
+					return issues;
+				}
+
+				return { ok: true, value: array };
+			};
+
+			return lazyProperty(this, '~decode', decoder);
+		},
+		get '~encode'() {
+			const shape = resolvedShape.value;
+
+			const encoder: Encoder = (state, input) => {
+				if (!Array.isArray(input)) {
+					return ARRAY_TYPE_ISSUE;
+				}
+
+				const children: EncoderState = {
+					c: [],
+					b: new Uint8Array(CHUNK_SIZE),
+					v: null,
+					p: 0,
+					l: 0,
+				};
+
+				for (let idx = 0, len = input.length; idx < len; idx++) {
+					const result = shape['~encode'](children, input[idx]);
+
+					if (result) {
+						return prependPath(idx, result);
+					}
+				}
+
+				const packed = finishEncode(children);
+
+				writeVarint(state, packed.length);
+				writeBytes(state, packed);
+			};
+
+			return lazyProperty(this, '~encode', encoder);
+		},
+	};
+};
+
+// #region Optional schema
+
+type DefaultValue<TItem extends BaseSchema> =
+	| InferOutput<TItem>
+	| (() => InferOutput<TItem>)
+	| undefined;
+
+type InferOptionalOutput<
+	TItem extends BaseSchema,
+	TDefault extends DefaultValue<TItem>,
+> = undefined extends TDefault ? InferOutput<TItem> | undefined : InferOutput<TItem>;
+
+export interface OptionalSchema<
+	TItem extends BaseSchema = BaseSchema,
+	TDefault extends DefaultValue<TItem> = DefaultValue<TItem>,
+> extends BaseSchema<InferInput<TItem> | undefined, InferOptionalOutput<TItem, TDefault>> {
+	readonly type: 'optional';
+	readonly wrapped: TItem;
+	readonly default: TDefault;
+}
+
+/**
+ * creates an optional field schema
+ * @param wrapped schema to make optional
+ * @param defaultValue default value when the field is not present
+ * @returns optional field schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const optional: {
+	<TItem extends BaseSchema>(wrapped: TItem): OptionalSchema<TItem, undefined>;
+	<TItem extends BaseSchema, TDefault extends DefaultValue<TItem>>(
+		wrapped: TItem,
+		defaultValue: TDefault,
+	): OptionalSchema<TItem, TDefault>;
+} = (wrapped: BaseSchema, defaultValue?: any): OptionalSchema<any, any> => {
+	return {
+		kind: 'schema',
+		type: 'optional',
+		wrapped: wrapped,
+		default: defaultValue,
+		wire: wrapped.wire,
+		'~decode'(state, flags) {
+			return wrapped['~decode'](state, flags);
+		},
+		'~encode'(state, input) {
+			return wrapped['~encode'](state, input);
+		},
+	};
+};
+
+const isOptionalSchema = (schema: BaseSchema): schema is OptionalSchema<any> => {
+	return schema.type === 'optional';
+};
+
+// #region Message schema
+
+export type LooseMessageShape = Record<string, any>;
+export type MessageShape = Record<string, BaseSchema>;
+
+export type OptionalObjectInputKeys<TShape extends MessageShape> = {
+	[Key in keyof TShape]: TShape[Key] extends OptionalSchema<any, any> ? Key : never;
+}[keyof TShape];
+
+export type OptionalObjectOutputKeys<TShape extends MessageShape> = {
+	[Key in keyof TShape]: TShape[Key] extends OptionalSchema<any, infer Default>
+		? undefined extends Default ? Key
+		: never
+		: never;
+}[keyof TShape];
+
+type InferMessageInput<TShape extends MessageShape> = Flatten<
+	& {
+		-readonly [Key in Exclude<keyof TShape, OptionalObjectInputKeys<TShape>>]: InferInput<
+			TShape[Key]
+		>;
+	}
+	& {
+		-readonly [Key in OptionalObjectInputKeys<TShape>]?: InferInput<TShape[Key]>;
+	}
+>;
+
+type InferMessageOutput<TShape extends MessageShape> = Flatten<
+	& {
+		-readonly [Key in Exclude<keyof TShape, OptionalObjectOutputKeys<TShape>>]: InferOutput<
+			TShape[Key]
+		>;
+	}
+	& {
+		-readonly [Key in OptionalObjectOutputKeys<TShape>]?: InferOutput<TShape[Key]>;
+	}
+>;
+
+export interface MessageSchema<
+	TShape extends LooseMessageShape = LooseMessageShape,
+	TTags extends Record<keyof TShape, number> = Record<keyof TShape, number>,
+> extends BaseSchema<Record<string, unknown>> {
+	readonly type: 'message';
+	readonly wire: 2;
+	readonly shape: Readonly<TShape>;
+	readonly tags: Readonly<TTags>;
+
+	readonly '~~decode': Decoder;
+	readonly '~~encode': Encoder;
+
+	readonly [kObjectType]?: { in: InferMessageInput<TShape>; out: InferMessageOutput<TShape> };
+}
+
+interface MessageEntry {
+	key: string;
+
+	schema: BaseSchema;
+	tag: number;
+	wire: WireType;
+
+	optional: boolean;
+
+	wireIssue: IssueTree;
+	missingIssue: IssueTree;
+}
+
+const ISSUE_MISSING: IssueLeaf = {
+	ok: false,
+	code: 'missing_value',
+};
+
+const set = (obj: Record<string, unknown>, key: string, value: unknown): void => {
+	if (key === '__proto__') {
+		Object.defineProperty(obj, key, { value });
+	} else {
+		obj[key] = value;
+	}
+};
+
+/**
+ * creates a structured message schema
+ * @param shape message shape
+ * @param tags fields mapped to tag numbers
+ * @returns structured message schema
+ */
+// #__NO_SIDE_EFFECTS__
+export const message = <TShape extends LooseMessageShape, TTags extends Record<keyof TShape, number>>(
+	shape: TShape,
+	tags: TTags,
+): MessageSchema<TShape, TTags> => {
+	const resolvedEntries = lazy((): Record<number, MessageEntry> => {
+		const resolved: Record<number, MessageEntry> = {};
+		const obj = shape as MessageShape;
+
+		for (const key in obj) {
+			const schema = obj[key];
+			const tag = tags[key];
+
+			resolved[tag] = {
+				key: key,
+				schema: schema,
+				tag: tag,
+				wire: schema.wire,
+				optional: isOptionalSchema(schema),
+				wireIssue: prependPath(key, { ok: false, code: 'invalid_wire', expected: schema.wire }),
+				missingIssue: prependPath(key, ISSUE_MISSING),
+			};
+		}
+
+		return resolved;
+	});
+
+	return {
+		kind: 'schema',
+		type: 'message',
+		wire: 2,
+		tags: tags,
+		get shape() {
+			// if we just return the shape as is then it wouldn't be the same exact
+			// shape when getters are present.
+			const resolved = resolvedEntries.value;
+			const obj: any = {};
+
+			for (const index in resolved) {
+				const entry = resolved[index];
+				obj[entry.key] = entry.schema;
+			}
+
+			return lazyProperty(this, 'shape', obj as TShape);
+		},
+
+		get '~~decode'() {
+			const shape = resolvedEntries.value;
+			const len = Object.keys(shape).length;
+
+			const decoder: Decoder = (state, flags) => {
+				let seenBits: BitSet = 0;
+				let seenCount = 0;
+
+				const obj: Record<string, unknown> = {};
+				let issues: IssueTree | undefined;
+
+				const end = state.b.length;
+				while (state.p < end) {
+					const prelude = readVarint(state);
+					if (!prelude.ok) {
+						issues = joinIssues(issues, prelude);
+						if (flags & FLAG_ABORT_EARLY) {
+							return issues;
+						}
+
+						break;
+					}
+
+					const magic = prelude.value;
+					const tag = magic >> 3;
+					const wire = (magic & 0x7) as WireType;
+
+					const entry = shape[tag];
+
+					// We don't know what this tag is, skip
+					if (!entry) {
+						const result = skipField(state, wire);
+						if (!result.ok) {
+							issues = joinIssues(issues, result);
+							if (flags & FLAG_ABORT_EARLY) {
+								return issues;
+							}
+
+							break;
+						}
+						continue;
+					}
+
+					// We've not seen this tag before
+					if (!getBit(seenBits, tag)) {
+						seenBits = setBit(seenBits, tag);
+						seenCount++;
+					}
+
+					// It doesn't match with our wire, file an issue
+					if (entry.wire !== wire) {
+						issues = joinIssues(issues, entry.wireIssue);
+						if (flags & FLAG_ABORT_EARLY) {
+							return issues;
+						}
+
+						const skip = skipField(state, wire);
+						if (!skip.ok) {
+							issues = joinIssues(issues, prependPath(entry.key, skip));
+							if (flags & FLAG_ABORT_EARLY) {
+								return issues;
+							}
+
+							break;
+						}
+
+						continue;
+					}
+
+					// Decode the value
+					const result = entry.schema['~decode'](state, flags);
+
+					// Failed to decode, file an issue
+					if (!result.ok) {
+						issues = joinIssues(issues, prependPath(entry.key, result));
+						if (flags & FLAG_ABORT_EARLY) {
+							return issues;
+						}
+
+						continue;
+					}
+
+					/*#__INLINE__*/ set(obj, entry.key, result.value);
+				}
+
+				if (seenCount < len) {
+					for (const strtag in shape) {
+						const entry = shape[strtag];
+
+						if (!getBit(seenBits, entry.tag)) {
+							if (entry.optional) {
+								const schema = entry.schema as OptionalSchema;
+
+								let defaultValue = schema.default;
+								if (defaultValue !== undefined) {
+									if (typeof defaultValue === 'function') {
+										defaultValue = defaultValue();
+									}
+
+									/*#__INLINE__*/ set(obj, entry.key, defaultValue);
+								}
+							} else {
+								issues = joinIssues(issues, entry.missingIssue);
+
+								if (flags & FLAG_ABORT_EARLY) {
+									return issues;
+								}
+							}
+						}
+					}
+				}
+
+				if (issues !== undefined) {
+					return issues;
+				}
+
+				return { ok: true, value: obj };
+			};
+
+			return lazyProperty(this, '~~decode', decoder);
+		},
+		get '~decode'() {
+			const raw = this['~~decode'];
+
+			const decoder: Decoder = (state, flags) => {
+				const length = readVarint(state);
+				if (!length.ok) {
+					return length;
+				}
+
+				const bytes = readBytes(state, length.value);
+				if (!bytes.ok) {
+					return bytes;
+				}
+
+				const child: DecoderState = {
+					b: bytes.value,
+					p: 0,
+					v: null,
+				};
+
+				return raw(child, flags);
+			};
+
+			return lazyProperty(this, '~decode', decoder);
+		},
+		get '~~encode'() {
+			const shape = resolvedEntries.value;
+
+			const encoder: Encoder = (state, input) => {
+				if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+					return OBJECT_TYPE_ISSUE;
+				}
+
+				const obj = input as Record<string, unknown>;
+
+				for (const tag in shape) {
+					const entry = shape[tag];
+					const fieldValue = obj[entry.key];
+
+					if (entry.optional && fieldValue === undefined) {
+						continue;
+					}
+
+					writeVarint(state, (entry.tag << 3) | entry.wire);
+
+					const result = entry.schema['~encode'](state, fieldValue);
+
+					if (result) {
+						return prependPath(entry.key, result);
+					}
+				}
+			};
+
+			return lazyProperty(this, '~~encode', encoder);
+		},
+		get '~encode'() {
+			const raw = this['~~encode'];
+
+			const encoder: Encoder = (state, input) => {
+				const children: EncoderState = {
+					c: [],
+					b: new Uint8Array(CHUNK_SIZE),
+					v: null,
+					p: 0,
+					l: 0,
+				};
+
+				const result = raw(children, input);
+				if (result) {
+					return result;
+				}
+
+				const chunk = finishEncode(children);
+
+				writeVarint(state, chunk.length);
+				writeBytes(state, chunk);
+			};
+
+			return lazyProperty(this, '~encode', encoder);
+		},
+	};
+};
+
+// #endregion
+
+// #region Map schema
+export type MapKeySchema =
+	| BooleanSchema
+	| Fixed32Schema
+	| Fixed64Schema
+	| Int32Schema
+	| Int64Schema
+	| Sint32Schema
+	| Sint64Schema
+	| StringSchema
+	| Uint32Schema
+	| Uint64Schema;
+
+export type MapValueSchema = BaseSchema;
+
+export interface MapSchema<TKey extends MapKeySchema, TValue extends MapValueSchema>
+	extends BaseSchema<unknown[]> {
+	readonly type: 'map';
+	readonly wire: 2;
+	readonly key: TKey;
+	readonly value: TValue;
+
+	readonly [kObjectType]?: {
+		in: Map<InferInput<TKey>, InferInput<TValue>>;
+		out: Map<InferOutput<TKey>, InferOutput<TValue>>;
+	};
+}
+
+/**
+ * creates a key-value map schema
+ * @param key schema for map keys
+ * @param value schema for map values
+ * @returns map schema
+ */
+export const map = <TKey extends MapKeySchema, TValue extends MapValueSchema>(
+	key: TKey,
+	value: TValue,
+): MapSchema<TKey, TValue> => {
+	const Schema = repeated(message({ key, value }, { key: 1, value: 2 }));
+
+	type Entry = { key: TKey; value: TValue };
+
+	return {
+		kind: 'schema',
+		type: 'map',
+		wire: 2,
+		key,
+		value,
+		get '~decode'() {
+			const decoder: Decoder = (state, flags) => {
+				const result = Schema['~decode'](state, flags);
+				if (!result.ok) {
+					return result;
+				}
+
+				const map = new Map();
+
+				const entries = result.value as Entry[];
+				for (let idx = 0, len = entries.length; idx < len; idx++) {
+					const entry = entries[idx];
+					map.set(entry.key, entry.value);
+				}
+
+				return { ok: true, value: map };
+			};
+
+			return lazyProperty(this, '~decode', decoder);
+		},
+		get '~encode'() {
+			const encoder: Encoder = (state, input) => {
+				if (!(input instanceof Map)) {
+					return MAP_TYPE_ISSUE;
+				}
+
+				const entries: Entry[] = [];
+				for (const [key, value] of input) {
+					entries.push({ key, value });
+				}
+
+				return Schema['~encode'](state, entries);
+			};
+
+			return lazyProperty(this, '~encode', encoder);
+		},
+	};
+};
+
+// #endregion
+
+// #region Well-known types
+
+/**
+ * represents a point in time independent of any time zone or local calendar,
+ * encoded as a count of seconds and fractions of seconds at nanosecond
+ * resolution.
+ */
+export const Timestamp = /*#__PURE__*/ message({
+	seconds: /*#__PURE__*/ optional(/*#__PURE__*/ int64(), 0n),
+	nanos: /*#__PURE__*/ optional(/*#__PURE__*/ int32(), 0),
+}, {
+	seconds: 1,
+	nanos: 2,
+});
+
+/**
+ * represents a signed, fixed-length span of time represented as a count of
+ * seconds and fractions of seconds at nanosecond resolution.
+ */
+export const Duration = /*#__PURE__*/ message({
+	seconds: /*#__PURE__*/ optional(/*#__PURE__*/ int64(), 0n),
+	nanos: /*#__PURE__*/ optional(/*#__PURE__*/ int32(), 0),
+}, {
+	seconds: 1,
+	nanos: 2,
+});
+
+/**
+ * contains an arbitrary serialized protocol buffer message along with a URL
+ * that describes the type of the serialized message.
+ */
+export const Any = /*#__PURE__*/ message({
+	typeUrl: /*#__PURE__*/ optional(/*#__PURE__*/ string(), ''),
+	value: /*#__PURE__*/ optional(/*#__PURE__*/ bytes(), /*#__PURE__*/ new Uint8Array(0)),
+}, {
+	typeUrl: 1,
+	value: 2,
+});
+
+// #endregion

lib/utils.ts

···
+// #__NO_SIDE_EFFECTS__
+export const lazyProperty = <T>(obj: object, prop: string | number | symbol, value: T): T => {
+	Object.defineProperty(obj, prop, { value });
+	return value;
+};
+
+// #__NO_SIDE_EFFECTS__
+export const lazy = <T>(getter: () => T): { readonly value: T } => {
+	return {
+		get value() {
+			const value = getter();
+			return lazyProperty(this, 'value', value);
+		},
+	};
+};
+
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+const fromCharCode = String.fromCharCode;
+
+export const decodeUtf8 = (from: Uint8Array, offset?: number, length?: number): string => {
+	let buffer: Uint8Array;
+
+	if (offset === undefined) {
+		buffer = from;
+	} else if (length === undefined) {
+		buffer = from.subarray(offset);
+	} else {
+		buffer = from.subarray(offset, offset + length);
+	}
+
+	const end = buffer.length;
+	if (end > 24) {
+		return textDecoder.decode(buffer);
+	}
+
+	{
+		let str = '';
+		let idx = 0;
+
+		for (; idx + 3 < end; idx += 4) {
+			const a = buffer[idx];
+			const b = buffer[idx + 1];
+			const c = buffer[idx + 2];
+			const d = buffer[idx + 3];
+
+			if ((a | b | c | d) & 0x80) {
+				return str + textDecoder.decode(buffer.subarray(idx));
+			}
+
+			str += fromCharCode(a, b, c, d);
+		}
+
+		for (; idx < end; idx++) {
+			const x = buffer[idx];
+
+			if (x & 0x80) {
+				return str + textDecoder.decode(buffer.subarray(idx));
+			}
+
+			str += fromCharCode(x);
+		}
+
+		return str;
+	}
+};
+
+export const encodeUtf8Into = (to: Uint8Array, str: string, offset?: number, length?: number): number => {
+	let buffer: Uint8Array;
+
+	if (offset === undefined) {
+		buffer = to;
+	} else if (length === undefined) {
+		buffer = to.subarray(offset);
+	} else {
+		buffer = to.subarray(offset, offset + length);
+	}
+
+	const result = textEncoder.encodeInto(str, buffer);
+
+	return result.written || 0;
+};