@statewalker/webrun-biscuit 0.1.0

package/dist/index.js

@@ -0,0 +1,3130 @@
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { p256 } from "@noble/curves/nist.js";
+//#region src/crypto.ts
+/**
+* Biscuit cryptography: chained block signatures, sealing, third-party
+* (external) signatures. Ed25519 and ECDSA/secp256r1, per SPECIFICATIONS.md.
+*/
+var SignatureError = class extends Error {};
+const ALG_ED25519 = 0;
+const ALG_SECP256R1 = 1;
+function concat(...parts) {
+	const len = parts.reduce((a, p) => a + p.length, 0);
+	const out = new Uint8Array(len);
+	let o = 0;
+	for (const p of parts) {
+		out.set(p, o);
+		o += p.length;
+	}
+	return out;
+}
+const ascii = (s) => Uint8Array.from(s, (c) => c.charCodeAt(0));
+const bytesEqual = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+/** little-endian i32, as used for algorithm ids and payload versions */
+function le32(n) {
+	const b = /* @__PURE__ */ new Uint8Array(4);
+	new DataView(b.buffer).setInt32(0, n, true);
+	return b;
+}
+function verifySignature(key, payload, sig) {
+	try {
+		if (key.algorithm === ALG_ED25519) return ed25519.verify(sig, payload, key.key);
+		if (key.algorithm === ALG_SECP256R1) return p256.verify(sig, payload, key.key, {
+			format: "der",
+			prehash: true,
+			lowS: false
+		});
+		return false;
+	} catch {
+		return false;
+	}
+}
+function publicKeyFromSecret(secret, algorithm) {
+	if (algorithm === ALG_ED25519) return ed25519.getPublicKey(secret);
+	if (algorithm === ALG_SECP256R1) return p256.getPublicKey(secret, true);
+	throw new SignatureError(`unknown algorithm ${algorithm}`);
+}
+function blockPayloadV0(data, nextKey, externalSig) {
+	return concat(data, externalSig ?? /* @__PURE__ */ new Uint8Array(0), le32(nextKey.algorithm), nextKey.key);
+}
+function authorityPayloadV1(data, nextKey, version) {
+	return concat(ascii("\0BLOCK\0\0VERSION\0"), le32(version), ascii("\0PAYLOAD\0"), data, ascii("\0ALGORITHM\0"), le32(nextKey.algorithm), ascii("\0NEXTKEY\0"), nextKey.key);
+}
+function blockPayloadV1(data, nextKey, externalSig, previousSignature, version) {
+	return concat(ascii("\0BLOCK\0\0VERSION\0"), le32(version), ascii("\0PAYLOAD\0"), data, ascii("\0ALGORITHM\0"), le32(nextKey.algorithm), ascii("\0NEXTKEY\0"), nextKey.key, ascii("\0PREVSIG\0"), previousSignature, ...externalSig ? [ascii("\0EXTERNALSIG\0"), externalSig] : []);
+}
+function externalPayloadV1(data, previousSignature, version) {
+	return concat(ascii("\0EXTERNAL\0\0VERSION\0"), le32(version), ascii("\0PAYLOAD\0"), data, ascii("\0PREVSIG\0"), previousSignature);
+}
+function sealPayloadV0(block) {
+	return concat(block.block, le32(block.nextKey.algorithm), block.nextKey.key, block.signature);
+}
+function sign(payload, secret, algorithm) {
+	if (algorithm === ALG_ED25519) return ed25519.sign(payload, secret);
+	if (algorithm === ALG_SECP256R1) return p256.sign(payload, secret, {
+		format: "der",
+		prehash: true
+	});
+	throw new SignatureError(`unknown algorithm ${algorithm}`);
+}
+/** a fresh keypair for the given algorithm */
+function generateKeypair(algorithm = 0) {
+	const secretKey = algorithm === ALG_ED25519 ? ed25519.utils.randomSecretKey() : p256.utils.randomSecretKey();
+	return {
+		secretKey,
+		publicKey: publicKeyFromSecret(secretKey, algorithm)
+	};
+}
+/** Verifies the full signature chain and the proof. Throws on failure. */
+function verifyToken(token, rootPublicKey, rootAlgorithm = 0) {
+	const root = {
+		algorithm: rootAlgorithm,
+		key: rootPublicKey
+	};
+	if (token.authority.externalSignature) throw new SignatureError("the authority block must not carry an external signature");
+	const authVersion = token.authority.version ?? 0;
+	if (!verifySignature(root, authVersion === 0 ? blockPayloadV0(token.authority.block, token.authority.nextKey) : authVersion === 1 ? authorityPayloadV1(token.authority.block, token.authority.nextKey, authVersion) : (() => {
+		throw new SignatureError(`unsupported block version ${authVersion}`);
+	})(), token.authority.signature)) throw new SignatureError("invalid authority block signature");
+	let currentKey = token.authority.nextKey;
+	let previousSignature = token.authority.signature;
+	for (const block of token.blocks) {
+		const version = block.version ?? 0;
+		const externalSig = block.externalSignature?.signature;
+		let payload;
+		if (version === 0) payload = blockPayloadV0(block.block, block.nextKey, externalSig);
+		else if (version === 1) payload = blockPayloadV1(block.block, block.nextKey, externalSig, previousSignature, version);
+		else throw new SignatureError(`unsupported block version ${version}`);
+		if (!verifySignature(currentKey, payload, block.signature)) throw new SignatureError("invalid block signature");
+		if (block.externalSignature) {
+			if (version !== 1) throw new SignatureError("unsupported third party block version");
+			const ext = externalPayloadV1(block.block, previousSignature, version);
+			if (!verifySignature(block.externalSignature.publicKey, ext, block.externalSignature.signature)) throw new SignatureError("invalid external signature");
+		}
+		currentKey = block.nextKey;
+		previousSignature = block.signature;
+	}
+	if (token.proof.kind === "nextSecret") {
+		const derived = publicKeyFromSecret(token.proof.value, currentKey.algorithm);
+		if (!bytesEqual(derived, currentKey.key)) throw new SignatureError("the last public key does not match the private key");
+	} else {
+		const last = token.blocks.length ? token.blocks[token.blocks.length - 1] : token.authority;
+		if (!verifySignature(currentKey, sealPayloadV0(last), token.proof.value)) throw new SignatureError("invalid seal signature");
+	}
+}
+/** Revocation identifier of each block: its signature bytes. */
+function revocationIds(token) {
+	return [token.authority, ...token.blocks].map((b) => b.signature);
+}
+//#endregion
+//#region src/datalog.ts
+/**
+* Biscuit Datalog: term model, fact/rule evaluation with origin tracking, and
+* the stack-based expression virtual machine.
+*/
+const AUTHORIZER = 4294967295;
+const hex$2 = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+/** Canonical string key: JS Map/Set are reference-keyed, so every structural
+*  comparison and every de-duplication in the engine goes through this. */
+function termKey(t) {
+	switch (t.t) {
+		case "var": return `v${t.v}`;
+		case "int": return `i${t.v}`;
+		case "str": return `s${t.v.length}:${t.v}`;
+		case "date": return `d${t.v}`;
+		case "bytes": return `b${hex$2(t.v)}`;
+		case "bool": return t.v ? "T" : "F";
+		case "null": return "N";
+		case "set": return `S[${t.v.map(termKey).sort().join(",")}]`;
+		case "array": return `A[${t.v.map(termKey).join(",")}]`;
+		case "map": return `M[${t.v.map(([k, v]) => `${mapKeyKey(k)}=>${termKey(v)}`).sort().join(",")}]`;
+	}
+}
+const mapKeyKey = (k) => k.t === "int" ? `i${k.v}` : `s${k.v.length}:${k.v}`;
+const termEq = (a, b) => termKey(a) === termKey(b);
+/** de-duplicated, deterministically ordered set contents */
+function normalizeSet(items) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const i of items) seen.set(termKey(i), i);
+	return [...seen.entries()].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0).map((e) => e[1]);
+}
+const factKey = (f) => `${f.predicate.name}/${f.predicate.terms.length}(${f.predicate.terms.map(termKey).join(",")})`;
+var Origin = class Origin {
+	ids;
+	constructor(ids = []) {
+		this.ids = ids;
+	}
+	static of(...ids) {
+		return new Origin([...new Set(ids)].sort((a, b) => a - b));
+	}
+	union(other) {
+		return Origin.of(...this.ids, ...other.ids);
+	}
+	with(id) {
+		return Origin.of(...this.ids, id);
+	}
+	get key() {
+		return this.ids.join(",");
+	}
+};
+var TrustedOrigins = class TrustedOrigins {
+	set;
+	constructor(ids) {
+		this.set = new Set(ids);
+	}
+	static default() {
+		return new TrustedOrigins([AUTHORIZER, 0]);
+	}
+	/** the trusted set is a superset of the fact's origin */
+	contains(origin) {
+		for (const id of origin.ids) if (!this.set.has(id)) return false;
+		return true;
+	}
+	get key() {
+		return [...this.set].sort((a, b) => a - b).join(",");
+	}
+	/** the trusted block ids, for deriving a new set from this one */
+	ids() {
+		return this.set;
+	}
+};
+function trustedOriginsFromScopes(ruleScopes, defaults, currentBlock, publicKeyToBlockIds) {
+	if (ruleScopes.length === 0) {
+		const ids = new Set(defaults.ids());
+		ids.add(currentBlock);
+		ids.add(AUTHORIZER);
+		return new TrustedOrigins(ids);
+	}
+	const ids = /* @__PURE__ */ new Set([AUTHORIZER, currentBlock]);
+	for (const scope of ruleScopes) if (scope.kind === "authority") ids.add(0);
+	else if (scope.kind === "previous") {
+		if (currentBlock !== 4294967295) for (let i = 0; i <= currentBlock; i++) ids.add(i);
+	} else for (const id of publicKeyToBlockIds.get(scope.key) ?? []) ids.add(id);
+	return new TrustedOrigins(ids);
+}
+var ExecutionError = class extends Error {
+	kind;
+	constructor(kind, message) {
+		super(message ?? kind);
+		this.kind = kind;
+	}
+};
+const U = {
+	Negate: 0,
+	Parens: 1,
+	Length: 2,
+	TypeOf: 3,
+	Ffi: 4
+};
+const B = {
+	LessThan: 0,
+	GreaterThan: 1,
+	LessOrEqual: 2,
+	GreaterOrEqual: 3,
+	Equal: 4,
+	Contains: 5,
+	Prefix: 6,
+	Suffix: 7,
+	Regex: 8,
+	Add: 9,
+	Sub: 10,
+	Mul: 11,
+	Div: 12,
+	And: 13,
+	Or: 14,
+	Intersection: 15,
+	Union: 16,
+	BitwiseAnd: 17,
+	BitwiseOr: 18,
+	BitwiseXor: 19,
+	NotEqual: 20,
+	HeterogeneousEqual: 21,
+	HeterogeneousNotEqual: 22,
+	LazyAnd: 23,
+	LazyOr: 24,
+	All: 25,
+	Any: 26,
+	Get: 27,
+	Ffi: 28,
+	TryOr: 29
+};
+const BinaryOp = B;
+const UnaryOp = U;
+const I64_MIN = -(2n ** 63n);
+const I64_MAX = 2n ** 63n - 1n;
+function checkedI64(v) {
+	if (v < I64_MIN || v > I64_MAX) throw new ExecutionError("Overflow");
+	return {
+		t: "int",
+		v
+	};
+}
+const utf8len = (s) => new TextEncoder().encode(s).length;
+function typeName(t) {
+	switch (t.t) {
+		case "int": return "integer";
+		case "str": return "string";
+		case "date": return "date";
+		case "bytes": return "bytes";
+		case "bool": return "bool";
+		case "set": return "set";
+		case "null": return "null";
+		case "array": return "array";
+		case "map": return "map";
+		default: throw new ExecutionError("InvalidType");
+	}
+}
+function unary(op, ffi, v, externs) {
+	switch (op) {
+		case U.Negate:
+			if (v.t !== "bool") throw new ExecutionError("InvalidType");
+			return {
+				t: "bool",
+				v: !v.v
+			};
+		case U.Parens: return v;
+		case U.Length:
+			if (v.t === "str") return {
+				t: "int",
+				v: BigInt(utf8len(v.v))
+			};
+			if (v.t === "bytes") return {
+				t: "int",
+				v: BigInt(v.v.length)
+			};
+			if (v.t === "set" || v.t === "array" || v.t === "map") return {
+				t: "int",
+				v: BigInt(v.v.length)
+			};
+			throw new ExecutionError("InvalidType");
+		case U.TypeOf: return {
+			t: "str",
+			v: typeName(v)
+		};
+		case U.Ffi: {
+			const f = externs.get(ffi);
+			if (!f) throw new ExecutionError("UndefinedExtern", ffi);
+			return f(v);
+		}
+		default: throw new ExecutionError("InvalidType");
+	}
+}
+function setContains(set, value) {
+	const k = termKey(value);
+	return set.some((t) => termKey(t) === k);
+}
+function binary(op, ffi, l, r, externs) {
+	const bool = (v) => ({
+		t: "bool",
+		v
+	});
+	const strictEqable = l.t === r.t && l.t !== "var" || l.t === "set" && r.t === "set" || l.t === "map" && r.t === "map";
+	switch (op) {
+		case B.LessThan:
+		case B.GreaterThan:
+		case B.LessOrEqual:
+		case B.GreaterOrEqual: {
+			if (!(l.t === "int" && r.t === "int" || l.t === "date" && r.t === "date")) throw new ExecutionError("InvalidType");
+			const a = l.v;
+			const b = r.v;
+			return bool(op === B.LessThan ? a < b : op === B.GreaterThan ? a > b : op === B.LessOrEqual ? a <= b : a >= b);
+		}
+		case B.Equal:
+		case B.NotEqual: {
+			if (!strictEqable) throw new ExecutionError("InvalidType");
+			const eq = termEq(l, r);
+			return bool(op === B.Equal ? eq : !eq);
+		}
+		case B.HeterogeneousEqual: return bool(l.t === r.t && termEq(l, r));
+		case B.HeterogeneousNotEqual: return bool(!(l.t === r.t && termEq(l, r)));
+		case B.Add:
+			if (l.t === "int" && r.t === "int") return checkedI64(l.v + r.v);
+			if (l.t === "str" && r.t === "str") return {
+				t: "str",
+				v: l.v + r.v
+			};
+			throw new ExecutionError("InvalidType");
+		case B.Sub:
+			if (l.t !== "int" || r.t !== "int") throw new ExecutionError("InvalidType");
+			return checkedI64(l.v - r.v);
+		case B.Mul:
+			if (l.t !== "int" || r.t !== "int") throw new ExecutionError("InvalidType");
+			return checkedI64(l.v * r.v);
+		case B.Div:
+			if (l.t !== "int" || r.t !== "int") throw new ExecutionError("InvalidType");
+			if (r.v === 0n) throw new ExecutionError("DivideByZero");
+			return checkedI64(l.v / r.v);
+		case B.BitwiseAnd:
+			if (l.t !== "int" || r.t !== "int") throw new ExecutionError("InvalidType");
+			return {
+				t: "int",
+				v: BigInt.asIntN(64, l.v & r.v)
+			};
+		case B.BitwiseOr:
+			if (l.t !== "int" || r.t !== "int") throw new ExecutionError("InvalidType");
+			return {
+				t: "int",
+				v: BigInt.asIntN(64, l.v | r.v)
+			};
+		case B.BitwiseXor:
+			if (l.t !== "int" || r.t !== "int") throw new ExecutionError("InvalidType");
+			return {
+				t: "int",
+				v: BigInt.asIntN(64, l.v ^ r.v)
+			};
+		case B.And:
+			if (l.t !== "bool" || r.t !== "bool") throw new ExecutionError("InvalidType");
+			return bool(l.v && r.v);
+		case B.Or:
+			if (l.t !== "bool" || r.t !== "bool") throw new ExecutionError("InvalidType");
+			return bool(l.v || r.v);
+		case B.Prefix:
+			if (l.t === "str" && r.t === "str") return bool(l.v.startsWith(r.v));
+			if (l.t === "array" && r.t === "array") return bool(r.v.every((x, i) => i < l.v.length && termEq(l.v[i], x)));
+			throw new ExecutionError("InvalidType");
+		case B.Suffix:
+			if (l.t === "str" && r.t === "str") return bool(l.v.endsWith(r.v));
+			if (l.t === "array" && r.t === "array") {
+				const off = l.v.length - r.v.length;
+				return bool(off >= 0 && r.v.every((x, i) => termEq(l.v[off + i], x)));
+			}
+			throw new ExecutionError("InvalidType");
+		case B.Regex:
+			if (l.t !== "str" || r.t !== "str") throw new ExecutionError("InvalidType");
+			try {
+				return bool(new RegExp(r.v).test(l.v));
+			} catch {
+				return bool(false);
+			}
+		case B.Contains:
+			if (l.t === "str" && r.t === "str") return bool(l.v.includes(r.v));
+			if (l.t === "set" && r.t === "set") return bool(r.v.every((x) => setContains(l.v, x)));
+			if (l.t === "set") return bool(setContains(l.v, r));
+			if (l.t === "array") return bool(setContains(l.v, r));
+			if (l.t === "map") return bool(l.v.some(([k]) => r.t === "int" ? k.t === "int" && k.v === r.v : r.t === "str" && k.t === "str" && k.v === r.v));
+			throw new ExecutionError("InvalidType");
+		case B.Intersection:
+			if (l.t !== "set" || r.t !== "set") throw new ExecutionError("InvalidType");
+			return {
+				t: "set",
+				v: normalizeSet(l.v.filter((x) => setContains(r.v, x)))
+			};
+		case B.Union:
+			if (l.t !== "set" || r.t !== "set") throw new ExecutionError("InvalidType");
+			return {
+				t: "set",
+				v: normalizeSet([...l.v, ...r.v])
+			};
+		case B.Get:
+			if (l.t === "array" && r.t === "int") {
+				const i = r.v < 0n || r.v >= BigInt(l.v.length) ? -1 : Number(r.v);
+				return i < 0 ? { t: "null" } : l.v[i];
+			}
+			if (l.t === "map" && (r.t === "int" || r.t === "str")) {
+				const found = l.v.find(([k]) => r.t === "int" ? k.t === "int" && k.v === r.v : k.t === "str" && k.v === r.v);
+				return found ? found[1] : { t: "null" };
+			}
+			throw new ExecutionError("InvalidType");
+		case B.Ffi: {
+			const f = externs.get(ffi);
+			if (!f) throw new ExecutionError("UndefinedExtern", ffi);
+			return f(l, r);
+		}
+		default: throw new ExecutionError("InvalidType");
+	}
+}
+function evaluateExpression(ops, values, externs = /* @__PURE__ */ new Map()) {
+	const stack = [];
+	for (const op of ops) switch (op.kind) {
+		case "value":
+			if (op.value.t === "var") {
+				const bound = values.get(op.value.v);
+				if (bound === void 0) throw new ExecutionError("UnknownVariable", String(op.value.v));
+				stack.push({
+					s: "term",
+					v: bound
+				});
+			} else stack.push({
+				s: "term",
+				v: op.value
+			});
+			break;
+		case "unary": {
+			const a = stack.pop();
+			if (!a || a.s !== "term") throw new ExecutionError("InvalidStack");
+			stack.push({
+				s: "term",
+				v: unary(op.op, op.ffi, a.v, externs)
+			});
+			break;
+		}
+		case "closure":
+			stack.push({
+				s: "closure",
+				params: op.params,
+				ops: op.ops
+			});
+			break;
+		case "binary": {
+			const right = stack.pop();
+			const left = stack.pop();
+			if (!right || !left) throw new ExecutionError("InvalidStack");
+			if (right.s === "term" && left.s === "term") stack.push({
+				s: "term",
+				v: binary(op.op, op.ffi, left.v, right.v, externs)
+			});
+			else {
+				const closure = right.s === "closure" ? right : left.s === "closure" ? left : null;
+				const term = right.s === "term" ? right : left.s === "term" ? left : null;
+				if (!closure || !term) throw new ExecutionError("InvalidStack");
+				for (const p of closure.params) if (values.has(p)) throw new ExecutionError("ShadowedVariable", String(p));
+				stack.push({
+					s: "term",
+					v: evaluateWithClosure(op.op, term.v, closure.ops, closure.params, values, externs)
+				});
+			}
+			break;
+		}
+	}
+	if (stack.length !== 1) throw new ExecutionError("InvalidStack");
+	const top = stack[0];
+	if (top.s !== "term") throw new ExecutionError("InvalidStack");
+	return top.v;
+}
+function evaluateWithClosure(op, left, ops, params, values, externs) {
+	if (op === B.TryOr && params.length === 0) try {
+		return evaluateExpression(ops, values, externs);
+	} catch {
+		return left;
+	}
+	if ((op === B.LazyOr || op === B.LazyAnd) && params.length === 0) {
+		if (left.t !== "bool") throw new ExecutionError("InvalidType");
+		if (op === B.LazyOr && left.v) return {
+			t: "bool",
+			v: true
+		};
+		if (op === B.LazyAnd && !left.v) return {
+			t: "bool",
+			v: false
+		};
+		return evaluateExpression(ops, values, externs);
+	}
+	if ((op === B.All || op === B.Any) && params.length === 1) {
+		const param = params[0];
+		let items;
+		if (left.t === "set" || left.t === "array") items = left.v;
+		else if (left.t === "map") items = left.v.map(([k, v]) => ({
+			t: "array",
+			v: [k.t === "int" ? {
+				t: "int",
+				v: k.v
+			} : {
+				t: "str",
+				v: k.v
+			}, v]
+		}));
+		else throw new ExecutionError("InvalidType");
+		const wanted = op === B.All;
+		for (const item of items) {
+			const scoped = new Map(values);
+			scoped.set(param, item);
+			const res = evaluateExpression(ops, scoped, externs);
+			if (res.t !== "bool") throw new ExecutionError("InvalidType");
+			if (res.v !== wanted) return {
+				t: "bool",
+				v: !wanted
+			};
+		}
+		return {
+			t: "bool",
+			v: wanted
+		};
+	}
+	throw new ExecutionError("InvalidType");
+}
+/**
+* Note the divergence: the reference defaults `max_time` to **1 millisecond**,
+* which is unreachably tight for a cold JS engine and would make ordinary
+* tokens fail non-deterministically. 1 second is generous by comparison, so a
+* caller exposed to untrusted tokens should lower it deliberately rather than
+* rely on this default as a denial-of-service bound.
+*/
+const DEFAULT_LIMITS = {
+	maxFacts: 1e3,
+	maxIterations: 100,
+	maxTimeMs: 1e3
+};
+function matchPredicate(rule, fact) {
+	if (rule.name !== fact.name || rule.terms.length !== fact.terms.length) return false;
+	for (let i = 0; i < rule.terms.length; i++) {
+		const rt = rule.terms[i];
+		const ft = fact.terms[i];
+		if (ft.t === "var") return false;
+		if (rt.t === "var") continue;
+		if (rt.t !== ft.t || !termEq(rt, ft)) return false;
+	}
+	return true;
+}
+function variablesOf(rule) {
+	const out = /* @__PURE__ */ new Set();
+	for (const p of rule.body) for (const t of p.terms) if (t.t === "var") out.add(t.v);
+	return out;
+}
+/** backtracking join over the rule body, mirroring Rust's CombineIt */
+function* combine(predicates, facts, bindings, variables) {
+	if (predicates.length === 0) {
+		for (const v of variables) if (!bindings.has(v)) return;
+		yield [Origin.of(), new Map(bindings)];
+		return;
+	}
+	const [head, ...rest] = predicates;
+	for (const [origin, fact] of facts.get(`${head.name}/${head.terms.length}`) ?? []) {
+		if (!matchPredicate(head, fact.predicate)) continue;
+		const next = new Map(bindings);
+		let ok = true;
+		for (let i = 0; i < head.terms.length; i++) {
+			const rt = head.terms[i];
+			if (rt.t !== "var") continue;
+			const existing = next.get(rt.v);
+			if (existing === void 0) next.set(rt.v, fact.predicate.terms[i]);
+			else if (!termEq(existing, fact.predicate.terms[i])) {
+				ok = false;
+				break;
+			}
+		}
+		if (!ok) continue;
+		for (const [subOrigin, result] of combine(rest, facts, next, variables)) yield [subOrigin.union(origin), result];
+	}
+}
+var World = class {
+	/** facts indexed by origin key */
+	facts = /* @__PURE__ */ new Map();
+	rules = [];
+	externs = /* @__PURE__ */ new Map();
+	iterations = 0;
+	generation = 0;
+	indexCache = /* @__PURE__ */ new Map();
+	addFact(origin, fact) {
+		let bucket = this.facts.get(origin.key);
+		if (!bucket) {
+			bucket = {
+				origin,
+				items: /* @__PURE__ */ new Map()
+			};
+			this.facts.set(origin.key, bucket);
+		}
+		const key = factKey(fact);
+		if (!bucket.items.has(key)) {
+			bucket.items.set(key, fact);
+			this.generation++;
+		}
+	}
+	addRule(origin, trusted, rule) {
+		this.rules.push({
+			origin,
+			trusted,
+			rule
+		});
+	}
+	factCount() {
+		let n = 0;
+		for (const b of this.facts.values()) n += b.items.size;
+		return n;
+	}
+	visible(trusted) {
+		const cached = this.indexCache.get(trusted.key);
+		if (cached && cached.generation === this.generation) return cached.index;
+		const index = /* @__PURE__ */ new Map();
+		for (const bucket of this.facts.values()) {
+			if (!trusted.contains(bucket.origin)) continue;
+			for (const f of bucket.items.values()) {
+				const key = `${f.predicate.name}/${f.predicate.terms.length}`;
+				const list = index.get(key);
+				if (list) list.push([bucket.origin, f]);
+				else index.set(key, [[bucket.origin, f]]);
+			}
+		}
+		this.indexCache.set(trusted.key, {
+			generation: this.generation,
+			index
+		});
+		return index;
+	}
+	/** naive fixpoint: apply every rule until no new fact appears */
+	run(limits = DEFAULT_LIMITS) {
+		const deadline = Date.now() + limits.maxTimeMs;
+		let index = 0;
+		for (;;) {
+			const generated = [];
+			for (const { origin, trusted, rule } of this.rules) {
+				const facts = this.visible(trusted);
+				for (const [o, f] of this.apply(rule, facts, origin)) generated.push([o, f]);
+			}
+			const before = this.factCount();
+			for (const [o, f] of generated) this.addFact(o, f);
+			if (this.factCount() === before) break;
+			index++;
+			if (index === limits.maxIterations) throw new ExecutionError("TooManyIterations");
+			if (this.factCount() >= limits.maxFacts) throw new ExecutionError("TooManyFacts");
+			if (Date.now() >= deadline) throw new ExecutionError("Timeout");
+		}
+		this.iterations += index;
+	}
+	*apply(rule, facts, ruleOrigin) {
+		const variables = variablesOf(rule);
+		for (const [origin, bindings] of combine(rule.body, facts, /* @__PURE__ */ new Map(), variables)) {
+			let pass = true;
+			for (const ops of rule.expressions) {
+				const res = evaluateExpression(ops, bindings, this.externs);
+				if (res.t !== "bool") throw new ExecutionError("InvalidType");
+				if (!res.v) {
+					pass = false;
+					break;
+				}
+			}
+			if (!pass) continue;
+			const terms = [];
+			let complete = true;
+			for (const t of rule.head.terms) if (t.t === "var") {
+				const bound = bindings.get(t.v);
+				if (bound === void 0) {
+					complete = false;
+					break;
+				}
+				terms.push(bound);
+			} else terms.push(t);
+			if (!complete) continue;
+			yield [origin.with(ruleOrigin), { predicate: {
+				name: rule.head.name,
+				terms
+			} }];
+		}
+	}
+	/** `check if` / policies: does at least one combination match? */
+	queryMatch(rule, origin, trusted) {
+		for (const _ of this.apply(rule, this.visible(trusted), origin)) return true;
+		return false;
+	}
+	/** `check all`: every matching combination must satisfy the expressions */
+	queryMatchAll(rule, trusted) {
+		const variables = variablesOf(rule);
+		let found = false;
+		for (const [, bindings] of combine(rule.body, this.visible(trusted), /* @__PURE__ */ new Map(), variables)) {
+			found = true;
+			for (const ops of rule.expressions) {
+				const res = evaluateExpression(ops, bindings, this.externs);
+				if (res.t !== "bool") throw new ExecutionError("InvalidType");
+				if (!res.v) return false;
+			}
+		}
+		return found;
+	}
+};
+//#endregion
+//#region src/parser.ts
+/**
+* Parser for the Biscuit Datalog text syntax (SPECIFICATIONS.md grammar).
+* Hand-written recursive descent + precedence climbing; expressions are
+* compiled straight to the opcode form the VM executes.
+*/
+var ParseError = class extends Error {};
+const NAME_START = /[\p{L}]/u;
+const NAME_CHAR = /[\p{L}\p{N}_:]/u;
+var Parser = class {
+	src;
+	i = 0;
+	vars;
+	constructor(src, vars) {
+		this.src = src;
+		this.vars = vars ?? /* @__PURE__ */ new Map();
+	}
+	/** id -> name, for printing rules back out */
+	variableNames() {
+		const out = /* @__PURE__ */ new Map();
+		for (const [name, id] of this.vars) out.set(id, name);
+		return out;
+	}
+	varId(name) {
+		let id = this.vars.get(name);
+		if (id === void 0) {
+			id = this.vars.size + 1;
+			this.vars.set(name, id);
+		}
+		return id;
+	}
+	ws() {
+		for (;;) {
+			while (this.i < this.src.length && /\s/.test(this.src[this.i])) this.i++;
+			if (this.src.startsWith("//", this.i)) {
+				const nl = this.src.indexOf("\n", this.i);
+				this.i = nl === -1 ? this.src.length : nl + 1;
+				continue;
+			}
+			if (this.src.startsWith("/*", this.i)) {
+				const end = this.src.indexOf("*/", this.i);
+				this.i = end === -1 ? this.src.length : end + 2;
+				continue;
+			}
+			return;
+		}
+	}
+	get eof() {
+		this.ws();
+		return this.i >= this.src.length;
+	}
+	peek(s) {
+		this.ws();
+		return this.src.startsWith(s, this.i);
+	}
+	eat(s) {
+		if (!this.peek(s)) return false;
+		this.i += s.length;
+		return true;
+	}
+	expect(s) {
+		if (!this.eat(s)) throw new ParseError(`expected "${s}" at offset ${this.i}`);
+	}
+	/** keyword: matches only if not followed by a name character */
+	keyword(k) {
+		this.ws();
+		if (!this.src.startsWith(k, this.i)) return false;
+		const after = this.src[this.i + k.length];
+		if (after !== void 0 && NAME_CHAR.test(after)) return false;
+		this.i += k.length;
+		return true;
+	}
+	/** variable names, unlike predicate names, may start with a digit ($0) */
+	variableName() {
+		this.ws();
+		const start = this.i;
+		while (this.i < this.src.length && NAME_CHAR.test(this.src[this.i])) this.i++;
+		if (this.i === start) throw new ParseError(`expected a variable name at offset ${this.i}`);
+		return this.src.slice(start, this.i);
+	}
+	name() {
+		this.ws();
+		const start = this.i;
+		if (this.i >= this.src.length || !NAME_START.test(this.src[this.i])) throw new ParseError(`expected a name at offset ${this.i}`);
+		this.i++;
+		while (this.i < this.src.length && NAME_CHAR.test(this.src[this.i])) this.i++;
+		return this.src.slice(start, this.i);
+	}
+	string() {
+		this.expect("\"");
+		let out = "";
+		for (;;) {
+			if (this.i >= this.src.length) throw new ParseError("unterminated string");
+			const c = this.src[this.i++];
+			if (c === "\"") return out;
+			if (c !== "\\") {
+				out += c;
+				continue;
+			}
+			const e = this.src[this.i++];
+			if (e === "n") out += "\n";
+			else if (e === "t") out += "	";
+			else if (e === "r") out += "\r";
+			else if (e === "0") out += "\0";
+			else if (e === "\"") out += "\"";
+			else if (e === "\\") out += "\\";
+			else if (e === "u") {
+				const m = /^\{([0-9a-fA-F]+)\}/.exec(this.src.slice(this.i));
+				if (m) {
+					out += String.fromCodePoint(parseInt(m[1], 16));
+					this.i += m[0].length;
+				} else {
+					out += String.fromCharCode(parseInt(this.src.substr(this.i, 4), 16));
+					this.i += 4;
+				}
+			} else out += e;
+		}
+	}
+	tryDate() {
+		this.ws();
+		const m = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})/.exec(this.src.slice(this.i));
+		if (!m) return null;
+		const ms = Date.parse(m[0]);
+		if (Number.isNaN(ms)) throw new ParseError(`invalid date ${m[0]}`);
+		this.i += m[0].length;
+		return BigInt(Math.floor(ms / 1e3));
+	}
+	/** a term that may be a variable (rule/check context) */
+	term(allowVariables = true) {
+		this.ws();
+		const date = this.tryDate();
+		if (date !== null) return {
+			t: "date",
+			v: date
+		};
+		if (this.peek("\"")) return {
+			t: "str",
+			v: this.string()
+		};
+		if (this.eat("$")) {
+			if (!allowVariables) throw new ParseError("variables are not allowed in facts");
+			return {
+				t: "var",
+				v: this.varId(this.variableName())
+			};
+		}
+		if (this.keyword("true")) return {
+			t: "bool",
+			v: true
+		};
+		if (this.keyword("false")) return {
+			t: "bool",
+			v: false
+		};
+		if (this.keyword("null")) return { t: "null" };
+		if (this.peek("hex:")) {
+			this.i += 4;
+			const start = this.i;
+			while (this.i < this.src.length && /[0-9a-fA-F]/.test(this.src[this.i])) this.i++;
+			const h = this.src.slice(start, this.i);
+			if (h.length % 2) throw new ParseError("odd-length hex literal");
+			const bytes = new Uint8Array(h.length / 2);
+			for (let j = 0; j < bytes.length; j++) bytes[j] = parseInt(h.substr(j * 2, 2), 16);
+			return {
+				t: "bytes",
+				v: bytes
+			};
+		}
+		if (this.peek("[")) return this.array(allowVariables);
+		if (this.peek("{")) return this.setOrMap(allowVariables);
+		const m = /^-?\d+/.exec(this.src.slice(this.i));
+		if (m) {
+			this.i += m[0].length;
+			return {
+				t: "int",
+				v: BigInt(m[0])
+			};
+		}
+		throw new ParseError(`unexpected term at offset ${this.i}: ${this.src.slice(this.i, this.i + 20)}`);
+	}
+	array(allowVariables) {
+		this.expect("[");
+		const items = [];
+		if (this.eat("]")) return {
+			t: "array",
+			v: items
+		};
+		do
+			items.push(this.term(allowVariables));
+		while (this.eat(","));
+		this.expect("]");
+		return {
+			t: "array",
+			v: items
+		};
+	}
+	setOrMap(allowVariables) {
+		this.expect("{");
+		if (this.eat(",")) {
+			this.expect("}");
+			return {
+				t: "set",
+				v: []
+			};
+		}
+		if (this.eat("}")) return {
+			t: "map",
+			v: []
+		};
+		const first = this.term(allowVariables);
+		if (this.eat(":")) {
+			const entries = [[this.asMapKey(first), this.term(allowVariables)]];
+			while (this.eat(",")) {
+				if (this.peek("}")) break;
+				const k = this.asMapKey(this.term(allowVariables));
+				this.expect(":");
+				entries.push([k, this.term(allowVariables)]);
+			}
+			this.expect("}");
+			return {
+				t: "map",
+				v: entries
+			};
+		}
+		const items = [first];
+		while (this.eat(",")) {
+			if (this.peek("}")) break;
+			items.push(this.term(allowVariables));
+		}
+		this.expect("}");
+		return {
+			t: "set",
+			v: normalizeSet(items)
+		};
+	}
+	asMapKey(t) {
+		if (t.t === "int") return {
+			t: "int",
+			v: t.v
+		};
+		if (t.t === "str") return {
+			t: "str",
+			v: t.v
+		};
+		throw new ParseError("map keys must be integers or strings");
+	}
+	predicate(allowVariables = true) {
+		const name = this.name();
+		this.expect("(");
+		const terms = [];
+		if (!this.peek(")")) do
+			terms.push(this.term(allowVariables));
+		while (this.eat(","));
+		this.expect(")");
+		return {
+			name,
+			terms
+		};
+	}
+	/** precedence climbing; each level returns opcodes in postfix order */
+	expression() {
+		return this.orExpr();
+	}
+	orExpr() {
+		let left = this.andExpr();
+		while (this.peek("||")) {
+			this.i += 2;
+			const right = this.andExpr();
+			left = [
+				...left,
+				{
+					kind: "closure",
+					params: [],
+					ops: right
+				},
+				{
+					kind: "binary",
+					op: BinaryOp.LazyOr
+				}
+			];
+		}
+		return left;
+	}
+	andExpr() {
+		let left = this.comparison();
+		while (this.peek("&&")) {
+			this.i += 2;
+			const right = this.comparison();
+			left = [
+				...left,
+				{
+					kind: "closure",
+					params: [],
+					ops: right
+				},
+				{
+					kind: "binary",
+					op: BinaryOp.LazyAnd
+				}
+			];
+		}
+		return left;
+	}
+	comparison() {
+		const left = this.bitXor();
+		for (const [tok, op] of [
+			["<=", BinaryOp.LessOrEqual],
+			[">=", BinaryOp.GreaterOrEqual],
+			["===", BinaryOp.Equal],
+			["!==", BinaryOp.NotEqual],
+			["==", BinaryOp.HeterogeneousEqual],
+			["!=", BinaryOp.HeterogeneousNotEqual],
+			["<", BinaryOp.LessThan],
+			[">", BinaryOp.GreaterThan]
+		]) if (this.peekOperator(tok)) {
+			this.i += tok.length;
+			const right = this.bitXor();
+			return [
+				...left,
+				...right,
+				{
+					kind: "binary",
+					op
+				}
+			];
+		}
+		return left;
+	}
+	/** avoids matching "==" when the source really has "===" */
+	peekOperator(tok) {
+		this.ws();
+		if (!this.src.startsWith(tok, this.i)) return false;
+		const next = this.src[this.i + tok.length];
+		if ((tok === "==" || tok === "!=") && next === "=") return false;
+		if ((tok === "<" || tok === ">") && next === "=") return false;
+		return true;
+	}
+	bitXor() {
+		let left = this.bitOr();
+		while (this.peekOperator("^")) {
+			this.i += 1;
+			left = [
+				...left,
+				...this.bitOr(),
+				{
+					kind: "binary",
+					op: BinaryOp.BitwiseXor
+				}
+			];
+		}
+		return left;
+	}
+	bitOr() {
+		let left = this.bitAnd();
+		while (this.peek("|") && !this.peek("||")) {
+			this.i += 1;
+			left = [
+				...left,
+				...this.bitAnd(),
+				{
+					kind: "binary",
+					op: BinaryOp.BitwiseOr
+				}
+			];
+		}
+		return left;
+	}
+	bitAnd() {
+		let left = this.additive();
+		while (this.peek("&") && !this.peek("&&")) {
+			this.i += 1;
+			left = [
+				...left,
+				...this.additive(),
+				{
+					kind: "binary",
+					op: BinaryOp.BitwiseAnd
+				}
+			];
+		}
+		return left;
+	}
+	additive() {
+		let left = this.multiplicative();
+		for (;;) if (this.peekSign("+")) {
+			this.i += 1;
+			left = [
+				...left,
+				...this.multiplicative(),
+				{
+					kind: "binary",
+					op: BinaryOp.Add
+				}
+			];
+		} else if (this.peekSign("-")) {
+			this.i += 1;
+			left = [
+				...left,
+				...this.multiplicative(),
+				{
+					kind: "binary",
+					op: BinaryOp.Sub
+				}
+			];
+		} else return left;
+	}
+	/** `-` starts a negative literal only when it is not an infix position */
+	peekSign(tok) {
+		this.ws();
+		return this.src.startsWith(tok, this.i);
+	}
+	multiplicative() {
+		let left = this.unary();
+		for (;;) if (this.peek("*")) {
+			this.i += 1;
+			left = [
+				...left,
+				...this.unary(),
+				{
+					kind: "binary",
+					op: BinaryOp.Mul
+				}
+			];
+		} else if (this.peek("/")) {
+			this.i += 1;
+			left = [
+				...left,
+				...this.unary(),
+				{
+					kind: "binary",
+					op: BinaryOp.Div
+				}
+			];
+		} else return left;
+	}
+	unary() {
+		if (this.eat("!")) return [...this.unary(), {
+			kind: "unary",
+			op: UnaryOp.Negate
+		}];
+		return this.methods(this.primary());
+	}
+	primary() {
+		this.ws();
+		if (this.peek("(")) {
+			this.i += 1;
+			const inner = this.expression();
+			this.expect(")");
+			return inner;
+		}
+		return [{
+			kind: "value",
+			value: this.term()
+		}];
+	}
+	methods(target) {
+		let out = target;
+		while (this.peek(".")) {
+			this.i += 1;
+			if (this.peek("extern::")) {
+				this.i += 8;
+				const fn = this.name();
+				this.expect("(");
+				if (this.eat(")")) out = [...out, {
+					kind: "unary",
+					op: UnaryOp.Ffi,
+					ffi: fn
+				}];
+				else {
+					const arg = this.expression();
+					this.expect(")");
+					out = [
+						...out,
+						...arg,
+						{
+							kind: "binary",
+							op: BinaryOp.Ffi,
+							ffi: fn
+						}
+					];
+				}
+				continue;
+			}
+			const method = this.name();
+			this.expect("(");
+			switch (method) {
+				case "length":
+					this.expect(")");
+					out = [...out, {
+						kind: "unary",
+						op: UnaryOp.Length
+					}];
+					break;
+				case "type":
+					this.expect(")");
+					out = [...out, {
+						kind: "unary",
+						op: UnaryOp.TypeOf
+					}];
+					break;
+				case "any":
+				case "all": {
+					const closure = this.closure();
+					this.expect(")");
+					out = [
+						...out,
+						closure,
+						{
+							kind: "binary",
+							op: method === "any" ? BinaryOp.Any : BinaryOp.All
+						}
+					];
+					break;
+				}
+				case "try_or": {
+					const fallback = this.expression();
+					this.expect(")");
+					out = [
+						{
+							kind: "closure",
+							params: [],
+							ops: out
+						},
+						...fallback,
+						{
+							kind: "binary",
+							op: BinaryOp.TryOr
+						}
+					];
+					break;
+				}
+				default: {
+					const arg = this.expression();
+					this.expect(")");
+					const op = {
+						contains: BinaryOp.Contains,
+						starts_with: BinaryOp.Prefix,
+						ends_with: BinaryOp.Suffix,
+						matches: BinaryOp.Regex,
+						intersection: BinaryOp.Intersection,
+						union: BinaryOp.Union,
+						get: BinaryOp.Get
+					}[method];
+					if (op === void 0) throw new ParseError(`unknown method ${method}`);
+					out = [
+						...out,
+						...arg,
+						{
+							kind: "binary",
+							op
+						}
+					];
+				}
+			}
+		}
+		return out;
+	}
+	closure() {
+		const params = [];
+		this.ws();
+		if (this.eat("(")) this.expect(")");
+		else do {
+			this.expect("$");
+			params.push(this.varId(this.variableName()));
+		} while (this.eat(","));
+		this.expect("->");
+		return {
+			kind: "closure",
+			params,
+			ops: this.expression()
+		};
+	}
+	scopes() {
+		const out = [];
+		do {
+			this.ws();
+			if (this.keyword("authority")) out.push({ kind: "authority" });
+			else if (this.keyword("previous")) out.push({ kind: "previous" });
+			else {
+				const alg = this.name();
+				this.expect("/");
+				const start = this.i;
+				while (this.i < this.src.length && /[0-9a-fA-F]/.test(this.src[this.i])) this.i++;
+				out.push({
+					kind: "publicKey",
+					key: `${alg}/${this.src.slice(start, this.i).toLowerCase()}`
+				});
+			}
+		} while (this.eat(","));
+		return out;
+	}
+	/** body of a rule / check / policy: predicates, expressions, trusting */
+	ruleBody() {
+		const body = [];
+		const expressions = [];
+		let scopes = [];
+		do {
+			this.ws();
+			if (this.keyword("trusting")) {
+				scopes = this.scopes();
+				break;
+			}
+			const save = this.i;
+			const asPredicate = this.tryPredicate();
+			if (asPredicate) body.push(asPredicate);
+			else {
+				this.i = save;
+				expressions.push(this.expression());
+			}
+			this.ws();
+			if (this.keyword("trusting")) {
+				scopes = this.scopes();
+				break;
+			}
+		} while (this.eat(","));
+		return {
+			body,
+			expressions,
+			scopes
+		};
+	}
+	/** a predicate is only a predicate if nothing operator-like follows it */
+	tryPredicate() {
+		const save = this.i;
+		try {
+			this.ws();
+			if (!NAME_START.test(this.src[this.i] ?? "")) return null;
+			const p = this.predicate();
+			this.ws();
+			const rest = this.src.slice(this.i);
+			if (rest === "" || /^[,;)]/.test(rest) || /^(or|trusting)\b/.test(rest)) return p;
+			this.i = save;
+			return null;
+		} catch {
+			this.i = save;
+			return null;
+		}
+	}
+	queries() {
+		const out = [];
+		do {
+			const { body, expressions, scopes } = this.ruleBody();
+			out.push({
+				head: {
+					name: "query",
+					terms: []
+				},
+				body,
+				expressions,
+				scopes
+			});
+		} while (this.keyword("or"));
+		return out;
+	}
+	statement() {
+		this.ws();
+		if (this.keyword("check")) {
+			let kind;
+			if (this.keyword("if")) kind = "one";
+			else if (this.keyword("all")) kind = "all";
+			else throw new ParseError("expected \"if\" or \"all\" after \"check\"");
+			return {
+				k: "check",
+				check: {
+					queries: this.queries(),
+					kind
+				}
+			};
+		}
+		if (this.keyword("reject")) {
+			if (!this.keyword("if")) throw new ParseError("expected \"if\" after \"reject\"");
+			return {
+				k: "check",
+				check: {
+					queries: this.queries(),
+					kind: "reject"
+				}
+			};
+		}
+		if (this.keyword("allow")) {
+			if (!this.keyword("if")) throw new ParseError("expected \"if\" after \"allow\"");
+			return {
+				k: "policy",
+				kind: "allow",
+				queries: this.queries()
+			};
+		}
+		if (this.keyword("deny")) {
+			if (!this.keyword("if")) throw new ParseError("expected \"if\" after \"deny\"");
+			return {
+				k: "policy",
+				kind: "deny",
+				queries: this.queries()
+			};
+		}
+		if (this.keyword("trusting")) return {
+			k: "blockScope",
+			scopes: this.scopes()
+		};
+		const head = this.predicate();
+		this.ws();
+		if (this.eat("<-")) {
+			const { body, expressions, scopes } = this.ruleBody();
+			return {
+				k: "rule",
+				rule: {
+					head,
+					body,
+					expressions,
+					scopes
+				}
+			};
+		}
+		if (head.terms.some((t) => t.t === "var")) throw new ParseError("a fact cannot contain variables");
+		return {
+			k: "fact",
+			fact: { predicate: head }
+		};
+	}
+	parse() {
+		const out = [];
+		while (!this.eof) {
+			out.push(this.statement());
+			this.ws();
+			this.expect(";");
+		}
+		return out;
+	}
+};
+//#endregion
+//#region src/print.ts
+/** Datalog pretty-printer (used for error messages and world snapshots). */
+const hex$1 = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+/** Datalog string literal: only the quote and the backslash are escaped.
+*  Control characters are emitted raw, unlike JSON.stringify. */
+const quote = (v) => `"${v.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+function printTerm(t, varName) {
+	switch (t.t) {
+		case "var": return `$${varName(t.v)}`;
+		case "int": return t.v.toString();
+		case "str": return quote(t.v);
+		case "date": return (/* @__PURE__ */ new Date(Number(t.v) * 1e3)).toISOString().replace(".000Z", "Z");
+		case "bytes": return `hex:${hex$1(t.v)}`;
+		case "bool": return t.v ? "true" : "false";
+		case "null": return "null";
+		case "set": return t.v.length === 0 ? "{,}" : `{${t.v.map((x) => printTerm(x, varName)).join(", ")}}`;
+		case "array": return `[${t.v.map((x) => printTerm(x, varName)).join(", ")}]`;
+		case "map": return t.v.length === 0 ? "{}" : `{${t.v.map(([k, v]) => `${k.t === "int" ? k.v : quote(k.v)}: ${printTerm(v, varName)}`).join(", ")}}`;
+	}
+}
+const printPredicate = (p, varName) => `${p.name}(${p.terms.map((t) => printTerm(t, varName)).join(", ")})`;
+const UNARY = {
+	[UnaryOp.Negate]: (a) => `!${a}`,
+	[UnaryOp.Parens]: (a) => `(${a})`,
+	[UnaryOp.Length]: (a) => `${a}.length()`,
+	[UnaryOp.TypeOf]: (a) => `${a}.type()`
+};
+const BINARY = {
+	[BinaryOp.LessThan]: (a, b) => `${a} < ${b}`,
+	[BinaryOp.GreaterThan]: (a, b) => `${a} > ${b}`,
+	[BinaryOp.LessOrEqual]: (a, b) => `${a} <= ${b}`,
+	[BinaryOp.GreaterOrEqual]: (a, b) => `${a} >= ${b}`,
+	[BinaryOp.Equal]: (a, b) => `${a} === ${b}`,
+	[BinaryOp.NotEqual]: (a, b) => `${a} !== ${b}`,
+	[BinaryOp.HeterogeneousEqual]: (a, b) => `${a} == ${b}`,
+	[BinaryOp.HeterogeneousNotEqual]: (a, b) => `${a} != ${b}`,
+	[BinaryOp.Contains]: (a, b) => `${a}.contains(${b})`,
+	[BinaryOp.Prefix]: (a, b) => `${a}.starts_with(${b})`,
+	[BinaryOp.Suffix]: (a, b) => `${a}.ends_with(${b})`,
+	[BinaryOp.Regex]: (a, b) => `${a}.matches(${b})`,
+	[BinaryOp.Add]: (a, b) => `${a} + ${b}`,
+	[BinaryOp.Sub]: (a, b) => `${a} - ${b}`,
+	[BinaryOp.Mul]: (a, b) => `${a} * ${b}`,
+	[BinaryOp.Div]: (a, b) => `${a} / ${b}`,
+	[BinaryOp.And]: (a, b) => `${a} &&! ${b}`,
+	[BinaryOp.Or]: (a, b) => `${a} ||! ${b}`,
+	[BinaryOp.Intersection]: (a, b) => `${a}.intersection(${b})`,
+	[BinaryOp.Union]: (a, b) => `${a}.union(${b})`,
+	[BinaryOp.BitwiseAnd]: (a, b) => `${a} & ${b}`,
+	[BinaryOp.BitwiseOr]: (a, b) => `${a} | ${b}`,
+	[BinaryOp.BitwiseXor]: (a, b) => `${a} ^ ${b}`,
+	[BinaryOp.LazyAnd]: (a, b) => `${a} && ${b}`,
+	[BinaryOp.LazyOr]: (a, b) => `${a} || ${b}`,
+	[BinaryOp.All]: (a, b) => `${a}.all(${b})`,
+	[BinaryOp.Any]: (a, b) => `${a}.any(${b})`,
+	[BinaryOp.Get]: (a, b) => `${a}.get(${b})`,
+	[BinaryOp.TryOr]: (a, b) => `${a}.try_or(${b})`
+};
+function printExpression(ops, varName) {
+	const stack = [];
+	for (const op of ops) if (op.kind === "value") stack.push(printTerm(op.value, varName));
+	else if (op.kind === "closure") stack.push(`${op.params.map((p) => `$${varName(p)}`).join(", ")}${op.params.length ? " -> " : ""}${printExpression(op.ops, varName)}`);
+	else if (op.kind === "unary") {
+		const a = stack.pop() ?? "";
+		stack.push(op.ffi ? `${a}.extern::${op.ffi}()` : UNARY[op.op]?.(a) ?? a);
+	} else {
+		const b = stack.pop() ?? "";
+		const a = stack.pop() ?? "";
+		stack.push(op.ffi ? `${a}.extern::${op.ffi}(${b})` : BINARY[op.op]?.(a, b) ?? `${a} ? ${b}`);
+	}
+	return stack.join(" ");
+}
+function printScopes(scopes) {
+	if (scopes.length === 0) return "";
+	return ` trusting ${scopes.map((s) => s.kind === "authority" ? "authority" : s.kind === "previous" ? "previous" : s.key).join(", ")}`;
+}
+/** the body of a rule, check or policy: predicates, then expressions */
+function printQuery(r, varName) {
+	return [...r.body.map((p) => printPredicate(p, varName)), ...r.expressions.map((e) => printExpression(e, varName))].join(", ") + printScopes(r.scopes);
+}
+function printCheck(c, varName) {
+	return (c.kind === "all" ? "check all " : c.kind === "reject" ? "reject if " : "check if ") + c.queries.map((q) => printQuery(q, varName)).join(" or ");
+}
+function printPolicy(kind, queries, varName) {
+	return `${kind} if ` + queries.map((q) => printQuery(q, varName)).join(" or ");
+}
+function printRule(r, varName) {
+	const parts = [...r.body.map((p) => printPredicate(p, varName)), ...r.expressions.map((e) => printExpression(e, varName))];
+	return `${printPredicate(r.head, varName)} <- ${parts.join(", ")}` + printScopes(r.scopes);
+}
+//#endregion
+//#region src/proto.ts
+/**
+* Strict proto2 codec for the Biscuit schema.
+*
+* Written against src/schema.proto. Unlike a generated codec it: decodes
+* int64/uint64 as BigInt, tracks proto2 `optional` presence, validates UTF-8
+* strictly, and rejects unknown fields, wrong wire types and missing
+* `required` fields.
+*/
+var ProtoError = class extends Error {};
+const utf8 = new TextDecoder("utf-8", { fatal: true });
+const utf8enc = new TextEncoder();
+var Reader = class Reader {
+	buf;
+	end;
+	pos;
+	constructor(buf, pos = 0, end = buf.length) {
+		this.buf = buf;
+		this.end = end;
+		this.pos = pos;
+	}
+	get done() {
+		return this.pos >= this.end;
+	}
+	byte() {
+		if (this.pos >= this.end) throw new ProtoError("unexpected end of buffer");
+		return this.buf[this.pos++];
+	}
+	varint() {
+		let result = 0n;
+		let shift = 0n;
+		let b;
+		do {
+			if (shift > 63n) throw new ProtoError("varint overflow");
+			b = this.byte();
+			result |= BigInt(b & 127) << shift;
+			shift += 7n;
+		} while (b & 128);
+		return BigInt.asUintN(64, result);
+	}
+	varintNum() {
+		const v = this.varint();
+		if (v > BigInt(Number.MAX_SAFE_INTEGER)) throw new ProtoError("varint too large for a number");
+		return Number(v);
+	}
+	bytes() {
+		const len = this.varintNum();
+		if (this.pos + len > this.end) throw new ProtoError("length-delimited field overruns buffer");
+		const out = this.buf.subarray(this.pos, this.pos + len);
+		this.pos += len;
+		return out;
+	}
+	string() {
+		try {
+			return utf8.decode(this.bytes());
+		} catch {
+			throw new ProtoError("invalid UTF-8 in string field");
+		}
+	}
+	sub() {
+		const b = this.bytes();
+		return new Reader(b, 0, b.length);
+	}
+};
+function readFields(r, handler) {
+	while (!r.done) {
+		const tag = r.varintNum();
+		const field = tag >> 3;
+		const wire = tag & 7;
+		if (field === 0) throw new ProtoError("invalid field number 0");
+		handler(field, wire, r);
+	}
+}
+function expect(wire, want, field) {
+	if (wire !== want) throw new ProtoError(`wrong wire type ${wire} for field ${field}`);
+}
+function required(v, name) {
+	if (v === void 0) throw new ProtoError(`missing required field ${name}`);
+	return v;
+}
+var Writer = class Writer {
+	buf = /* @__PURE__ */ new Uint8Array(256);
+	pos = 0;
+	grow(n) {
+		if (this.pos + n <= this.buf.length) return;
+		let len = this.buf.length;
+		while (len < this.pos + n) len *= 2;
+		const next = new Uint8Array(len);
+		next.set(this.buf.subarray(0, this.pos));
+		this.buf = next;
+	}
+	varint(v) {
+		let x = BigInt.asUintN(64, BigInt(v));
+		this.grow(10);
+		do {
+			let b = Number(x & 127n);
+			x >>= 7n;
+			if (x) b |= 128;
+			this.buf[this.pos++] = b;
+		} while (x);
+	}
+	tag(field, wire) {
+		this.varint(field << 3 | wire);
+	}
+	varintField(field, v) {
+		this.tag(field, 0);
+		this.varint(v);
+	}
+	bytesField(field, v) {
+		this.tag(field, 2);
+		this.varint(v.length);
+		this.grow(v.length);
+		this.buf.set(v, this.pos);
+		this.pos += v.length;
+	}
+	stringField(field, v) {
+		this.bytesField(field, utf8enc.encode(v));
+	}
+	messageField(field, write, v) {
+		const w = new Writer();
+		write(v, w);
+		this.bytesField(field, w.finish());
+	}
+	finish() {
+		return this.buf.slice(0, this.pos);
+	}
+};
+function readPublicKey(r) {
+	let algorithm;
+	let key;
+	readFields(r, (f, w, rr) => {
+		if (f === 1) {
+			expect(w, 0, f);
+			algorithm = rr.varintNum();
+		} else if (f === 2) {
+			expect(w, 2, f);
+			key = rr.bytes();
+		} else throw new ProtoError(`unknown field ${f} in PublicKey`);
+	});
+	const alg = required(algorithm, "PublicKey.algorithm");
+	if (alg !== 0 && alg !== 1) throw new ProtoError(`unknown signature algorithm ${alg}`);
+	return {
+		algorithm: alg,
+		key: required(key, "PublicKey.key")
+	};
+}
+function readExternalSignature(r) {
+	let signature;
+	let publicKey;
+	readFields(r, (f, w, rr) => {
+		if (f === 1) {
+			expect(w, 2, f);
+			signature = rr.bytes();
+		} else if (f === 2) {
+			expect(w, 2, f);
+			publicKey = readPublicKey(rr.sub());
+		} else throw new ProtoError(`unknown field ${f} in ExternalSignature`);
+	});
+	return {
+		signature: required(signature, "ExternalSignature.signature"),
+		publicKey: required(publicKey, "ExternalSignature.publicKey")
+	};
+}
+function readSignedBlock(r) {
+	const out = {};
+	readFields(r, (f, w, rr) => {
+		if (f === 1) {
+			expect(w, 2, f);
+			out.block = rr.bytes();
+		} else if (f === 2) {
+			expect(w, 2, f);
+			out.nextKey = readPublicKey(rr.sub());
+		} else if (f === 3) {
+			expect(w, 2, f);
+			out.signature = rr.bytes();
+		} else if (f === 4) {
+			expect(w, 2, f);
+			out.externalSignature = readExternalSignature(rr.sub());
+		} else if (f === 5) {
+			expect(w, 0, f);
+			out.version = rr.varintNum();
+		} else throw new ProtoError(`unknown field ${f} in SignedBlock`);
+	});
+	return {
+		block: required(out.block, "SignedBlock.block"),
+		nextKey: required(out.nextKey, "SignedBlock.nextKey"),
+		signature: required(out.signature, "SignedBlock.signature"),
+		externalSignature: out.externalSignature,
+		version: out.version
+	};
+}
+function decodeBiscuit(buf) {
+	const r = new Reader(buf);
+	let rootKeyId;
+	let authority;
+	const blocks = [];
+	let proof;
+	readFields(r, (f, w, rr) => {
+		if (f === 1) {
+			expect(w, 0, f);
+			rootKeyId = rr.varintNum();
+		} else if (f === 2) {
+			expect(w, 2, f);
+			authority = readSignedBlock(rr.sub());
+		} else if (f === 3) {
+			expect(w, 2, f);
+			blocks.push(readSignedBlock(rr.sub()));
+		} else if (f === 4) {
+			expect(w, 2, f);
+			readFields(rr.sub(), (pf, pw, pr) => {
+				if (pf === 1) {
+					expect(pw, 2, pf);
+					proof = {
+						kind: "nextSecret",
+						value: pr.bytes()
+					};
+				} else if (pf === 2) {
+					expect(pw, 2, pf);
+					proof = {
+						kind: "finalSignature",
+						value: pr.bytes()
+					};
+				} else throw new ProtoError(`unknown field ${pf} in Proof`);
+			});
+		} else throw new ProtoError(`unknown field ${f} in Biscuit`);
+	});
+	return {
+		rootKeyId,
+		authority: required(authority, "Biscuit.authority"),
+		blocks,
+		proof: required(proof, "Biscuit.proof")
+	};
+}
+function readTerm(r) {
+	let out;
+	readFields(r, (f, w, rr) => {
+		switch (f) {
+			case 1:
+				expect(w, 0, f);
+				out = {
+					kind: "variable",
+					value: rr.varintNum()
+				};
+				break;
+			case 2:
+				expect(w, 0, f);
+				out = {
+					kind: "integer",
+					value: BigInt.asIntN(64, rr.varint())
+				};
+				break;
+			case 3:
+				expect(w, 0, f);
+				out = {
+					kind: "string",
+					value: rr.varintNum()
+				};
+				break;
+			case 4:
+				expect(w, 0, f);
+				out = {
+					kind: "date",
+					value: rr.varint()
+				};
+				break;
+			case 5:
+				expect(w, 2, f);
+				out = {
+					kind: "bytes",
+					value: rr.bytes()
+				};
+				break;
+			case 6:
+				expect(w, 0, f);
+				out = {
+					kind: "bool",
+					value: rr.varintNum() !== 0
+				};
+				break;
+			case 7: {
+				expect(w, 2, f);
+				const set = [];
+				readFields(rr.sub(), (sf, sw, sr) => {
+					if (sf !== 1) throw new ProtoError(`unknown field ${sf} in TermSet`);
+					expect(sw, 2, sf);
+					set.push(readTerm(sr.sub()));
+				});
+				out = {
+					kind: "set",
+					value: set
+				};
+				break;
+			}
+			case 8:
+				expect(w, 2, f);
+				rr.bytes();
+				out = { kind: "null" };
+				break;
+			case 9: {
+				expect(w, 2, f);
+				const arr = [];
+				readFields(rr.sub(), (af, aw, ar) => {
+					if (af !== 1) throw new ProtoError(`unknown field ${af} in Array`);
+					expect(aw, 2, af);
+					arr.push(readTerm(ar.sub()));
+				});
+				out = {
+					kind: "array",
+					value: arr
+				};
+				break;
+			}
+			case 10: {
+				expect(w, 2, f);
+				const entries = [];
+				readFields(rr.sub(), (mf, mw, mr) => {
+					if (mf !== 1) throw new ProtoError(`unknown field ${mf} in Map`);
+					expect(mw, 2, mf);
+					entries.push(readMapEntry(mr.sub()));
+				});
+				out = {
+					kind: "map",
+					value: entries
+				};
+				break;
+			}
+			default: throw new ProtoError(`unknown field ${f} in Term`);
+		}
+	});
+	return required(out, "Term.Content");
+}
+function readMapEntry(r) {
+	let key;
+	let value;
+	readFields(r, (f, w, rr) => {
+		if (f === 1) {
+			expect(w, 2, f);
+			readFields(rr.sub(), (kf, kw, kr) => {
+				if (kf === 1) {
+					expect(kw, 0, kf);
+					key = {
+						kind: "integer",
+						value: BigInt.asIntN(64, kr.varint())
+					};
+				} else if (kf === 2) {
+					expect(kw, 0, kf);
+					key = {
+						kind: "string",
+						value: kr.varintNum()
+					};
+				} else throw new ProtoError(`unknown field ${kf} in MapKey`);
+			});
+		} else if (f === 2) {
+			expect(w, 2, f);
+			value = readTerm(rr.sub());
+		} else throw new ProtoError(`unknown field ${f} in MapEntry`);
+	});
+	return {
+		key: required(key, "MapEntry.key"),
+		value: required(value, "MapEntry.value")
+	};
+}
+function readPredicate(r) {
+	let name;
+	const terms = [];
+	readFields(r, (f, w, rr) => {
+		if (f === 1) {
+			expect(w, 0, f);
+			name = rr.varintNum();
+		} else if (f === 2) {
+			expect(w, 2, f);
+			terms.push(readTerm(rr.sub()));
+		} else throw new ProtoError(`unknown field ${f} in Predicate`);
+	});
+	return {
+		name: required(name, "Predicate.name"),
+		terms
+	};
+}
+function readOp(r) {
+	let out;
+	readFields(r, (f, w, rr) => {
+		if (f === 1) {
+			expect(w, 2, f);
+			out = {
+				kind: "value",
+				value: readTerm(rr.sub())
+			};
+		} else if (f === 2 || f === 3) {
+			expect(w, 2, f);
+			let op;
+			let ffiName;
+			readFields(rr.sub(), (of_, ow, or_) => {
+				if (of_ === 1) {
+					expect(ow, 0, of_);
+					op = or_.varintNum();
+				} else if (of_ === 2) {
+					expect(ow, 0, of_);
+					ffiName = or_.varintNum();
+				} else throw new ProtoError(`unknown field ${of_} in Op`);
+			});
+			out = {
+				kind: f === 2 ? "unary" : "binary",
+				op: required(op, "Op.kind"),
+				ffiName
+			};
+		} else if (f === 4) {
+			expect(w, 2, f);
+			const params = [];
+			const ops = [];
+			readFields(rr.sub(), (cf, cw, cr) => {
+				if (cf === 1) {
+					if (cw === 0) params.push(cr.varintNum());
+					else if (cw === 2) {
+						const packed = cr.sub();
+						while (!packed.done) params.push(packed.varintNum());
+					} else throw new ProtoError("bad wire type for OpClosure.params");
+				} else if (cf === 2) {
+					expect(cw, 2, cf);
+					ops.push(readOp(cr.sub()));
+				} else throw new ProtoError(`unknown field ${cf} in OpClosure`);
+			});
+			out = {
+				kind: "closure",
+				params,
+				ops
+			};
+		} else throw new ProtoError(`unknown field ${f} in Op`);
+	});
+	return required(out, "Op.Content");
+}
+function readScope(r) {
+	let out;
+	readFields(r, (f, w, rr) => {
+		if (f === 1) {
+			expect(w, 0, f);
+			const v = rr.varintNum();
+			if (v !== 0 && v !== 1) throw new ProtoError(`unknown scope type ${v}`);
+			out = {
+				kind: "type",
+				value: v
+			};
+		} else if (f === 2) {
+			expect(w, 0, f);
+			out = {
+				kind: "publicKey",
+				value: Number(BigInt.asIntN(64, rr.varint()))
+			};
+		} else throw new ProtoError(`unknown field ${f} in Scope`);
+	});
+	return required(out, "Scope.Content");
+}
+function readRule(r) {
+	let head;
+	const body = [];
+	const expressions = [];
+	const scope = [];
+	readFields(r, (f, w, rr) => {
+		if (f === 1) {
+			expect(w, 2, f);
+			head = readPredicate(rr.sub());
+		} else if (f === 2) {
+			expect(w, 2, f);
+			body.push(readPredicate(rr.sub()));
+		} else if (f === 3) {
+			expect(w, 2, f);
+			const ops = [];
+			readFields(rr.sub(), (ef, ew, er) => {
+				if (ef !== 1) throw new ProtoError(`unknown field ${ef} in Expression`);
+				expect(ew, 2, ef);
+				ops.push(readOp(er.sub()));
+			});
+			expressions.push(ops);
+		} else if (f === 4) {
+			expect(w, 2, f);
+			scope.push(readScope(rr.sub()));
+		} else throw new ProtoError(`unknown field ${f} in Rule`);
+	});
+	return {
+		head: required(head, "Rule.head"),
+		body,
+		expressions,
+		scope
+	};
+}
+function decodeBlock(buf) {
+	const out = {
+		symbols: [],
+		facts: [],
+		rules: [],
+		checks: [],
+		scope: [],
+		publicKeys: []
+	};
+	readFields(new Reader(buf), (f, w, rr) => {
+		switch (f) {
+			case 1:
+				expect(w, 2, f);
+				out.symbols.push(rr.string());
+				break;
+			case 2:
+				expect(w, 2, f);
+				out.context = rr.string();
+				break;
+			case 3:
+				expect(w, 0, f);
+				out.version = rr.varintNum();
+				break;
+			case 4: {
+				expect(w, 2, f);
+				let pred;
+				readFields(rr.sub(), (ff, fw, fr) => {
+					if (ff !== 1) throw new ProtoError(`unknown field ${ff} in Fact`);
+					expect(fw, 2, ff);
+					pred = readPredicate(fr.sub());
+				});
+				out.facts.push(required(pred, "Fact.predicate"));
+				break;
+			}
+			case 5:
+				expect(w, 2, f);
+				out.rules.push(readRule(rr.sub()));
+				break;
+			case 6: {
+				expect(w, 2, f);
+				const queries = [];
+				let kind;
+				readFields(rr.sub(), (cf, cw, cr) => {
+					if (cf === 1) {
+						expect(cw, 2, cf);
+						queries.push(readRule(cr.sub()));
+					} else if (cf === 2) {
+						expect(cw, 0, cf);
+						kind = cr.varintNum();
+					} else throw new ProtoError(`unknown field ${cf} in Check`);
+				});
+				if (kind !== void 0 && kind !== 0 && kind !== 1 && kind !== 2) throw new ProtoError(`unknown check kind ${kind}`);
+				out.checks.push({
+					queries,
+					kind
+				});
+				break;
+			}
+			case 7:
+				expect(w, 2, f);
+				out.scope.push(readScope(rr.sub()));
+				break;
+			case 8:
+				expect(w, 2, f);
+				out.publicKeys.push(readPublicKey(rr.sub()));
+				break;
+			default: throw new ProtoError(`unknown field ${f} in Block`);
+		}
+	});
+	return out;
+}
+function writePublicKey(v, w) {
+	w.varintField(1, v.algorithm);
+	w.bytesField(2, v.key);
+}
+function writeSignedBlock(v, w) {
+	w.bytesField(1, v.block);
+	w.messageField(2, writePublicKey, v.nextKey);
+	w.bytesField(3, v.signature);
+	if (v.externalSignature !== void 0) w.messageField(4, (e, ww) => {
+		ww.bytesField(1, e.signature);
+		ww.messageField(2, writePublicKey, e.publicKey);
+	}, v.externalSignature);
+	if (v.version !== void 0) w.varintField(5, v.version);
+}
+function encodeBiscuit(v) {
+	const w = new Writer();
+	if (v.rootKeyId !== void 0) w.varintField(1, v.rootKeyId);
+	w.messageField(2, writeSignedBlock, v.authority);
+	for (const b of v.blocks) w.messageField(3, writeSignedBlock, b);
+	w.messageField(4, (p, ww) => ww.bytesField(p.kind === "nextSecret" ? 1 : 2, p.value), v.proof);
+	return w.finish();
+}
+function writeTerm(t, w) {
+	switch (t.kind) {
+		case "variable":
+			w.varintField(1, t.value);
+			break;
+		case "integer":
+			w.varintField(2, t.value);
+			break;
+		case "string":
+			w.varintField(3, t.value);
+			break;
+		case "date":
+			w.varintField(4, t.value);
+			break;
+		case "bytes":
+			w.bytesField(5, t.value);
+			break;
+		case "bool":
+			w.varintField(6, t.value ? 1 : 0);
+			break;
+		case "set":
+			w.messageField(7, (items, ww) => {
+				for (const i of items) ww.messageField(1, writeTerm, i);
+			}, t.value);
+			break;
+		case "null":
+			w.bytesField(8, /* @__PURE__ */ new Uint8Array(0));
+			break;
+		case "array":
+			w.messageField(9, (items, ww) => {
+				for (const i of items) ww.messageField(1, writeTerm, i);
+			}, t.value);
+			break;
+		case "map": w.messageField(10, (entries, ww) => {
+			for (const e of entries) ww.messageField(1, (en, w3) => {
+				w3.messageField(1, (k, w4) => w4.varintField(k.kind === "integer" ? 1 : 2, k.value), en.key);
+				w3.messageField(2, writeTerm, en.value);
+			}, e);
+		}, t.value);
+	}
+}
+function writePredicate(p, w) {
+	w.varintField(1, p.name);
+	for (const t of p.terms) w.messageField(2, writeTerm, t);
+}
+function writeOp(op, w) {
+	switch (op.kind) {
+		case "value":
+			w.messageField(1, writeTerm, op.value);
+			break;
+		case "unary":
+		case "binary":
+			w.messageField(op.kind === "unary" ? 2 : 3, (o, ww) => {
+				ww.varintField(1, o.op);
+				if (o.ffiName !== void 0) ww.varintField(2, o.ffiName);
+			}, op);
+			break;
+		case "closure": w.messageField(4, (c, ww) => {
+			for (const p of c.params) ww.varintField(1, p);
+			for (const o of c.ops) ww.messageField(2, writeOp, o);
+		}, op);
+	}
+}
+function writeScope(s, w) {
+	w.varintField(s.kind === "type" ? 1 : 2, s.value);
+}
+function writeRule(r, w) {
+	w.messageField(1, writePredicate, r.head);
+	for (const p of r.body) w.messageField(2, writePredicate, p);
+	for (const e of r.expressions) w.messageField(3, (ops, ww) => {
+		for (const o of ops) ww.messageField(1, writeOp, o);
+	}, e);
+	for (const s of r.scope) w.messageField(4, writeScope, s);
+}
+function encodeBlock(b) {
+	const w = new Writer();
+	for (const s of b.symbols) w.stringField(1, s);
+	if (b.context !== void 0) w.stringField(2, b.context);
+	if (b.version !== void 0) w.varintField(3, b.version);
+	for (const f of b.facts) w.messageField(4, (p, ww) => ww.messageField(1, writePredicate, p), f);
+	for (const r of b.rules) w.messageField(5, writeRule, r);
+	for (const c of b.checks) w.messageField(6, (ch, ww) => {
+		for (const q of ch.queries) ww.messageField(1, writeRule, q);
+		if (ch.kind !== void 0) ww.varintField(2, ch.kind);
+	}, c);
+	for (const s of b.scope) w.messageField(7, writeScope, s);
+	for (const k of b.publicKeys) w.messageField(8, writePublicKey, k);
+	return w.finish();
+}
+//#endregion
+//#region src/version.ts
+/**
+* Datalog block versioning.
+*
+* Every block declares the Datalog version it was generated at. An
+* implementation must reject versions outside the supported window, and must
+* reject a block that uses a feature newer than the version it declares —
+* otherwise a token could smuggle newer semantics past an older verifier.
+*
+* Mirrors `get_schema_version` / `check_compatibility` in the reference
+* implementation (biscuit-auth `src/datalog/mod.rs`).
+*/
+const MIN_SCHEMA_VERSION = 3;
+const MAX_SCHEMA_VERSION = 6;
+const DATALOG_3_1 = 4;
+const DATALOG_3_2 = 5;
+const DATALOG_3_3 = 6;
+var VersionError = class extends Error {};
+/** null, or a set containing null — arrays and maps are deliberately not
+*  flagged here, matching the reference implementation */
+const isV33Term = (t) => t.t === "null" || t.t === "set" && t.v.some((x) => x.t === "null");
+const hasV33Predicate = (p) => p.terms.some(isV33Term);
+const hasV31Op = (expressions) => expressions.some((ops) => ops.some((op) => op.kind === "binary" && (op.op === BinaryOp.BitwiseAnd || op.op === BinaryOp.BitwiseOr || op.op === BinaryOp.BitwiseXor || op.op === BinaryOp.NotEqual)));
+const hasV33Op = (expressions) => expressions.some((ops) => ops.some((op) => {
+	if (op.kind === "value") return isV33Term(op.value);
+	if (op.kind === "closure") return true;
+	if (op.kind === "unary") return op.op === UnaryOp.TypeOf || op.op === UnaryOp.Ffi;
+	return op.op === BinaryOp.HeterogeneousEqual || op.op === BinaryOp.HeterogeneousNotEqual || op.op === BinaryOp.LazyAnd || op.op === BinaryOp.LazyOr || op.op === BinaryOp.All || op.op === BinaryOp.Any || op.op === BinaryOp.Ffi;
+}));
+function blockFeatures(c) {
+	const queries = c.checks.flatMap((ch) => ch.queries);
+	const scopes = c.scopes.length > 0 || c.rules.some((r) => r.scopes.length > 0) || queries.some((q) => q.scopes.length > 0);
+	const checkAll = c.checks.some((ch) => ch.kind === "all");
+	let v33 = c.checks.some((ch) => ch.kind === "reject");
+	const v31 = c.rules.some((r) => hasV31Op(r.expressions)) || queries.some((q) => hasV31Op(q.expressions));
+	if (!v33) v33 = c.rules.some((r) => hasV33Predicate(r.head) || r.body.some(hasV33Predicate) || hasV33Op(r.expressions)) || queries.some((q) => q.body.some(hasV33Predicate) || hasV33Op(q.expressions));
+	if (!v33) v33 = c.facts.some((f) => hasV33Predicate(f.predicate));
+	return {
+		scopes,
+		v31,
+		checkAll,
+		v33
+	};
+}
+/** the lowest version that can legally carry this block's content */
+function requiredVersion(c) {
+	const f = blockFeatures(c);
+	if (f.v33) return 6;
+	if (f.scopes || f.v31 || f.checkAll) return 4;
+	return 3;
+}
+/**
+* Rejects a block whose declared version is out of range, or which uses a
+* feature newer than that version. `rawChecks` is needed because the gate on
+* check kinds distinguishes an absent kind from an explicit `One`.
+*/
+function validateBlockVersion(declared, rawChecks, hasExternalKey, content) {
+	const version = declared ?? 0;
+	if (version < 3 || version > 6) throw new VersionError(`unsupported datalog version ${version}: supported versions are 3 to 6`);
+	if (version < 6) for (const c of rawChecks) {
+		if (version < 4 && c.kind !== void 0) throw new VersionError("check kinds are only supported on datalog v3.1+ blocks");
+		if (version < 6 && c.kind === 2) throw new VersionError("reject if is only supported in datalog v3.3+");
+	}
+	if (version < 5 && hasExternalKey) throw new VersionError("third-party blocks are only supported in datalog v3.2+");
+	const f = blockFeatures(content);
+	if (version < 4) {
+		if (f.scopes) throw new VersionError("scopes are only supported in datalog v3.1+");
+		if (f.v31) throw new VersionError("bitwise operators and != are only supported in datalog v3.1+");
+		if (f.checkAll) throw new VersionError("check all is only supported in datalog v3.1+");
+	} else if (version < 6 && f.v33) throw new VersionError("maps, arrays, null, closures are only supported in datalog v3.3+");
+}
+//#endregion
+//#region src/authorizer.ts
+/**
+* Turns a serialized token plus authorizer code into an authorization result,
+* mirroring the evaluation order of the reference implementation.
+*/
+const DEFAULT_SYMBOLS = [
+	"read",
+	"write",
+	"resource",
+	"operation",
+	"right",
+	"time",
+	"role",
+	"owner",
+	"tenant",
+	"namespace",
+	"user",
+	"team",
+	"service",
+	"admin",
+	"email",
+	"group",
+	"member",
+	"ip_address",
+	"client",
+	"client_ip",
+	"domain",
+	"path",
+	"version",
+	"cluster",
+	"node",
+	"hostname",
+	"nonce",
+	"query"
+];
+const OFFSET$1 = 1024;
+var TokenError = class extends Error {
+	kind;
+	constructor(kind, message) {
+		super(message);
+		this.kind = kind;
+	}
+};
+const hex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+const keyString = (algorithm, key) => `${algorithm === 0 ? "ed25519" : "secp256r1"}/${hex(key)}`;
+var Symbols = class {
+	table;
+	keys;
+	constructor(table, keys) {
+		this.table = table;
+		this.keys = keys;
+	}
+	get(index) {
+		if (index < OFFSET$1) {
+			const s = DEFAULT_SYMBOLS[index];
+			if (s === void 0) throw new TokenError("Symbol", `unknown default symbol ${index}`);
+			return s;
+		}
+		const s = this.table[index - OFFSET$1];
+		if (s === void 0) throw new TokenError("Symbol", `unknown symbol ${index}`);
+		return s;
+	}
+	publicKey(index) {
+		const k = this.keys[index];
+		if (k === void 0) throw new TokenError("Symbol", `unknown public key ${index}`);
+		return k;
+	}
+};
+function convTerm(t, s) {
+	switch (t.kind) {
+		case "variable": return {
+			t: "var",
+			v: t.value
+		};
+		case "integer": return {
+			t: "int",
+			v: t.value
+		};
+		case "string": return {
+			t: "str",
+			v: s.get(t.value)
+		};
+		case "date": return {
+			t: "date",
+			v: t.value
+		};
+		case "bytes": return {
+			t: "bytes",
+			v: t.value
+		};
+		case "bool": return {
+			t: "bool",
+			v: t.value
+		};
+		case "null": return { t: "null" };
+		case "set": return {
+			t: "set",
+			v: normalizeSet(t.value.map((x) => convTerm(x, s)))
+		};
+		case "array": return {
+			t: "array",
+			v: t.value.map((x) => convTerm(x, s))
+		};
+		case "map": return {
+			t: "map",
+			v: t.value.map((e) => [e.key.kind === "integer" ? {
+				t: "int",
+				v: e.key.value
+			} : {
+				t: "str",
+				v: s.get(e.key.value)
+			}, convTerm(e.value, s)])
+		};
+	}
+}
+const convPredicate = (p, s) => ({
+	name: s.get(p.name),
+	terms: p.terms.map((t) => convTerm(t, s))
+});
+function convOps(ops, s) {
+	return ops.map((op) => {
+		switch (op.kind) {
+			case "value": return {
+				kind: "value",
+				value: convTerm(op.value, s)
+			};
+			case "unary": return {
+				kind: "unary",
+				op: op.op,
+				ffi: op.ffiName !== void 0 ? s.get(op.ffiName) : void 0
+			};
+			case "binary": return {
+				kind: "binary",
+				op: op.op,
+				ffi: op.ffiName !== void 0 ? s.get(op.ffiName) : void 0
+			};
+			case "closure": return {
+				kind: "closure",
+				params: op.params,
+				ops: convOps(op.ops, s)
+			};
+			default: throw new ProtoError(`unknown expression op kind ${op.kind}`);
+		}
+	});
+}
+const convScope = (sc, s) => sc.kind === "type" ? sc.value === 0 ? { kind: "authority" } : { kind: "previous" } : {
+	kind: "publicKey",
+	key: s.publicKey(sc.value)
+};
+const convRule = (r, s) => ({
+	head: convPredicate(r.head, s),
+	body: r.body.map((p) => convPredicate(p, s)),
+	expressions: r.expressions.map((e) => convOps(e, s)),
+	scopes: r.scope.map((sc) => convScope(sc, s))
+});
+function convBlock(b, s, externalKey) {
+	const varNames = /* @__PURE__ */ new Map();
+	const collectTerm = (t) => {
+		if (t.kind === "variable") varNames.set(t.value, s.get(t.value));
+		else if (t.kind === "set" || t.kind === "array") t.value.forEach(collectTerm);
+		else if (t.kind === "map") t.value.forEach((e) => {
+			collectTerm(e.value);
+		});
+	};
+	const collectOps = (ops) => {
+		for (const op of ops) if (op.kind === "value") collectTerm(op.value);
+		else if (op.kind === "closure") {
+			for (const param of op.params) varNames.set(param, s.get(param));
+			collectOps(op.ops);
+		}
+	};
+	const collect = (r) => {
+		for (const p of [r.head, ...r.body]) p.terms.forEach(collectTerm);
+		r.expressions.forEach(collectOps);
+	};
+	for (const r of b.rules) collect(r);
+	for (const c of b.checks) for (const q of c.queries) collect(q);
+	return {
+		varNames,
+		facts: b.facts.map((f) => ({ predicate: convPredicate(f, s) })),
+		rules: b.rules.map((r) => convRule(r, s)),
+		checks: b.checks.map((c) => ({
+			queries: c.queries.map((q) => convRule(q, s)),
+			kind: c.kind === 1 ? "all" : c.kind === 2 ? "reject" : "one"
+		})),
+		scopes: b.scope.map((sc) => convScope(sc, s)),
+		externalKey
+	};
+}
+function loadToken(bytes, rootPublicKey, rootAlgorithm = 0) {
+	const token = decodeBiscuit(bytes);
+	verifyToken(token, rootPublicKey, rootAlgorithm);
+	const signed = [token.authority, ...token.blocks];
+	const decoded = signed.map((sb) => decodeBlock(sb.block));
+	const globalSymbols = [];
+	const globalKeys = [];
+	const extend = (list, items) => {
+		for (const i of items) if (!list.includes(i)) list.push(i);
+	};
+	const blocks = [];
+	const publicKeyToBlockIds = /* @__PURE__ */ new Map();
+	for (let id = 0; id < decoded.length; id++) {
+		const raw = decoded[id];
+		const ext = signed[id].externalSignature;
+		const externalKey = ext ? keyString(ext.publicKey.algorithm, ext.publicKey.key) : void 0;
+		const blockKeys = raw.publicKeys.map((k) => keyString(k.algorithm, k.key));
+		if (externalKey === void 0) {
+			for (const sym of raw.symbols) {
+				if (globalSymbols.includes(sym)) throw new TokenError("Format", "symbol table overlap");
+				globalSymbols.push(sym);
+			}
+			extend(globalKeys, blockKeys);
+			const block = convBlock(raw, new Symbols(globalSymbols, globalKeys), void 0);
+			validateBlockVersion(raw.version, raw.checks, false, block);
+			blocks.push(block);
+		} else {
+			const block = convBlock(raw, new Symbols(raw.symbols, blockKeys), externalKey);
+			validateBlockVersion(raw.version, raw.checks, true, block);
+			blocks.push(block);
+			extend(globalKeys, blockKeys);
+			const ids = publicKeyToBlockIds.get(externalKey) ?? [];
+			ids.push(id);
+			publicKeyToBlockIds.set(externalKey, ids);
+		}
+	}
+	return {
+		blocks,
+		publicKeyToBlockIds,
+		revocationIds: revocationIds(token).map(hex),
+		rootKeyId: token.rootKeyId
+	};
+}
+/**
+* Reads the key identifier from a token **without verifying it**, so a caller
+* can choose which root key to verify against. The token is untrusted at this
+* point: the id is a hint, not a claim.
+*/
+function peekRootKeyId(bytes) {
+	return decodeBiscuit(bytes).rootKeyId;
+}
+/** a block rule whose head uses a variable the body never binds is invalid */
+function headVariablesAreBound(rule) {
+	const bound = /* @__PURE__ */ new Set();
+	for (const p of rule.body) for (const t of p.terms) if (t.t === "var") bound.add(t.v);
+	return rule.head.terms.every((t) => t.t !== "var" || bound.has(t.v));
+}
+function parseAuthorizer(src) {
+	const out = {
+		facts: [],
+		rules: [],
+		checks: [],
+		policies: [],
+		scopes: [],
+		varNames: /* @__PURE__ */ new Map()
+	};
+	const parser = new Parser(src);
+	const statements = parser.parse();
+	out.varNames = parser.variableNames();
+	for (const st of statements) if (st.k === "fact") out.facts.push(st.fact);
+	else if (st.k === "rule") out.rules.push(st.rule);
+	else if (st.k === "check") out.checks.push(st.check);
+	else if (st.k === "policy") out.policies.push({
+		kind: st.kind,
+		queries: st.queries
+	});
+	else out.scopes.push(...st.scopes);
+	return out;
+}
+function authorize(token, authorizerSrc, options = {}) {
+	return authorizeDetailed(token, authorizerSrc, options).result;
+}
+const EMPTY_WORLD = {
+	facts: [],
+	rules: [],
+	checks: [],
+	policies: []
+};
+/** Same as `authorize`, and also returns the post-run world, in the shape the
+*  official sample corpus records it. */
+function authorizeDetailed(token, authorizerSrc, options = {}) {
+	const limits = options.limits ?? DEFAULT_LIMITS;
+	let code;
+	try {
+		code = parseAuthorizer(authorizerSrc);
+	} catch (e) {
+		return {
+			result: {
+				kind: "format",
+				error: e.message
+			},
+			world: EMPTY_WORLD
+		};
+	}
+	const world = new World();
+	if (options.externs) world.externs = options.externs;
+	const keys = token.publicKeyToBlockIds;
+	const blockTrusted = [];
+	for (let id = 0; id < token.blocks.length; id++) {
+		const block = token.blocks[id];
+		const trusted = trustedOriginsFromScopes(block.scopes, TrustedOrigins.default(), id, keys);
+		blockTrusted.push(trusted);
+		const origin = Origin.of(id);
+		for (const f of block.facts) world.addFact(origin, f);
+		for (const r of block.rules) {
+			if (!headVariablesAreBound(r)) return {
+				result: {
+					kind: "invalidBlockRule",
+					blockId: 0,
+					rule: printRule(r, (v) => block.varNames.get(v) ?? String(v))
+				},
+				world: EMPTY_WORLD
+			};
+			world.addRule(id, trustedOriginsFromScopes(r.scopes, trusted, id, keys), r);
+		}
+	}
+	const authorizerTrusted = trustedOriginsFromScopes(code.scopes, TrustedOrigins.default(), AUTHORIZER, keys);
+	const authorizerOrigin = Origin.of(AUTHORIZER);
+	for (const f of code.facts) world.addFact(authorizerOrigin, f);
+	for (const r of code.rules) world.addRule(AUTHORIZER, trustedOriginsFromScopes(r.scopes, authorizerTrusted, AUTHORIZER, keys), r);
+	const name = (id) => id === 4294967295 ? (v) => code.varNames.get(v) ?? String(v) : (v) => token.blocks[id]?.varNames.get(v) ?? String(v);
+	const blockId = (id) => id === 4294967295 ? null : id;
+	const AUTHORIZER_U64 = Number(18446744073709551615n);
+	const ruleOrigin = (id) => id === 4294967295 ? AUTHORIZER_U64 : id;
+	const snapshot = () => {
+		const factGroups = [...world.facts.values()].filter((b) => b.items.size > 0).map((b) => ({
+			origin: b.origin.ids.map(blockId).sort((x, y) => (x ?? -1) - (y ?? -1)),
+			facts: [...b.items.values()].map((f) => printPredicate(f.predicate, () => "?")).sort()
+		})).sort((a, x) => compareOrigins(a.origin, x.origin));
+		const ruleGroups = /* @__PURE__ */ new Map();
+		for (const { origin, rule } of world.rules) {
+			const list = ruleGroups.get(origin) ?? [];
+			list.push(printRule(rule, name(origin)));
+			ruleGroups.set(origin, list);
+		}
+		const checkGroups = [];
+		code.checks.forEach((c) => {
+			const entry = checkGroups.find((g) => g.origin === AUTHORIZER_U64);
+			const text = printCheck(c, name(AUTHORIZER));
+			if (entry) entry.checks.push(text);
+			else checkGroups.push({
+				origin: AUTHORIZER_U64,
+				checks: [text]
+			});
+		});
+		token.blocks.forEach((b, id) => {
+			if (b.checks.length === 0) return;
+			checkGroups.push({
+				origin: id,
+				checks: b.checks.map((c) => printCheck(c, name(id)))
+			});
+		});
+		return {
+			facts: factGroups,
+			rules: [...ruleGroups.entries()].map(([origin, rules]) => ({
+				origin: ruleOrigin(origin),
+				rules: rules.sort()
+			})).sort((a, b) => (a.origin ?? -1) - (b.origin ?? -1)),
+			checks: checkGroups.sort((a, b) => (a.origin ?? -1) - (b.origin ?? -1)),
+			policies: code.policies.map((p) => printPolicy(p.kind, p.queries, name(AUTHORIZER)))
+		};
+	};
+	try {
+		world.run(limits);
+	} catch (e) {
+		if (e instanceof ExecutionError) return {
+			result: {
+				kind: "execution",
+				error: e.kind
+			},
+			world: snapshot()
+		};
+		throw e;
+	}
+	const errors = [];
+	const runCheck = (check, blockId, defaults) => {
+		for (const query of check.queries) {
+			const trusted = trustedOriginsFromScopes(query.scopes, defaults, blockId, keys);
+			if (check.kind === "all" ? world.queryMatchAll(query, trusted) : check.kind === "reject" ? !world.queryMatch(query, blockId, trusted) : world.queryMatch(query, blockId, trusted)) return true;
+		}
+		return false;
+	};
+	try {
+		code.checks.forEach((check, i) => {
+			if (!runCheck(check, 4294967295, authorizerTrusted)) errors.push({
+				source: "authorizer",
+				checkId: i
+			});
+		});
+		token.blocks[0]?.checks.forEach((check, j) => {
+			if (!runCheck(check, 0, blockTrusted[0])) errors.push({
+				source: "block",
+				blockId: 0,
+				checkId: j
+			});
+		});
+		let policyResult = null;
+		outer: for (const [i, policy] of code.policies.entries()) for (const query of policy.queries) {
+			const trusted = trustedOriginsFromScopes(query.scopes, authorizerTrusted, AUTHORIZER, keys);
+			if (world.queryMatch(query, 4294967295, trusted)) {
+				policyResult = policy.kind === "allow" ? { allow: i } : { deny: i };
+				break outer;
+			}
+		}
+		for (let id = 1; id < token.blocks.length; id++) token.blocks[id].checks.forEach((check, j) => {
+			if (!runCheck(check, id, blockTrusted[id])) errors.push({
+				source: "block",
+				blockId: id,
+				checkId: j
+			});
+		});
+		return {
+			result: policyResult === null ? {
+				kind: "noMatchingPolicy",
+				checks: errors
+			} : "allow" in policyResult && errors.length === 0 ? {
+				kind: "ok",
+				policy: policyResult.allow
+			} : {
+				kind: "unauthorized",
+				policy: policyResult,
+				checks: errors
+			},
+			world: snapshot()
+		};
+	} catch (e) {
+		if (e instanceof ExecutionError) return {
+			result: {
+				kind: "execution",
+				error: e.kind
+			},
+			world: snapshot()
+		};
+		throw e;
+	}
+}
+function compareOrigins(a, b) {
+	for (let i = 0; i < Math.max(a.length, b.length); i++) {
+		const x = a[i] === void 0 ? -Infinity : a[i] ?? -1;
+		const y = b[i] === void 0 ? -Infinity : b[i] ?? -1;
+		if (x !== y) return x - y;
+	}
+	return 0;
+}
+//#endregion
+//#region src/base64.ts
+/** URL-safe base64 without padding, the wire form of a Biscuit token.
+*  Implemented directly so the library stays runtime-agnostic (no Buffer,
+*  no atob/btoa). */
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+const REVERSE = new Map([...ALPHABET].map((c, i) => [c, i]));
+REVERSE.set("+", 62);
+REVERSE.set("/", 63);
+function toBase64(bytes) {
+	let out = "";
+	for (let i = 0; i < bytes.length; i += 3) {
+		const b0 = bytes[i];
+		const b1 = bytes[i + 1];
+		const b2 = bytes[i + 2];
+		out += ALPHABET[b0 >> 2];
+		out += ALPHABET[(b0 & 3) << 4 | (b1 ?? 0) >> 4];
+		if (b1 === void 0) break;
+		out += ALPHABET[(b1 & 15) << 2 | (b2 ?? 0) >> 6];
+		if (b2 === void 0) break;
+		out += ALPHABET[b2 & 63];
+	}
+	return out;
+}
+function fromBase64(text) {
+	const s = text.trim().replace(/=+$/, "");
+	const out = new Uint8Array(Math.floor(s.length * 3 / 4));
+	let o = 0;
+	let acc = 0;
+	let bits = 0;
+	for (const c of s) {
+		const v = REVERSE.get(c);
+		if (v === void 0) throw new Error(`invalid base64 character ${JSON.stringify(c)}`);
+		acc = acc << 6 | v;
+		bits += 6;
+		if (bits >= 8) {
+			bits -= 8;
+			out[o++] = acc >> bits & 255;
+		}
+	}
+	return out.subarray(0, o);
+}
+//#endregion
+//#region src/builder.ts
+/**
+* The write path: minting tokens, attenuating them with extra blocks, and
+* sealing them. New blocks are signed with signature payload version 1, and
+* declare the lowest Datalog version their content legally requires.
+*/
+const SIGNATURE_VERSION = 1;
+const OFFSET = 1024;
+var BuilderError = class extends Error {};
+var SymbolWriter = class {
+	known;
+	knownKeys;
+	/** symbols added by this block, in insertion order */
+	added = [];
+	addedKeys = [];
+	constructor(known = [], knownKeys = []) {
+		this.known = known;
+		this.knownKeys = knownKeys;
+	}
+	insert(s) {
+		const d = DEFAULT_SYMBOLS.indexOf(s);
+		if (d >= 0) return d;
+		const k = this.known.indexOf(s);
+		if (k >= 0) return OFFSET + k;
+		let i = this.added.indexOf(s);
+		if (i < 0) i = this.added.push(s) - 1;
+		return OFFSET + this.known.length + i;
+	}
+	insertKey(key) {
+		const k = this.knownKeys.indexOf(key);
+		if (k >= 0) return k;
+		let i = this.addedKeys.indexOf(key);
+		if (i < 0) i = this.addedKeys.push(key) - 1;
+		return this.knownKeys.length + i;
+	}
+};
+const parseKeyString = (key) => {
+	const [alg, h] = key.split("/");
+	const bytes = new Uint8Array(h.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(h.substr(i * 2, 2), 16);
+	return {
+		algorithm: alg === "secp256r1" ? 1 : 0,
+		key: bytes
+	};
+};
+function toTerm(t, w) {
+	switch (t.t) {
+		case "var": return {
+			kind: "variable",
+			value: t.v
+		};
+		case "int": return {
+			kind: "integer",
+			value: t.v
+		};
+		case "str": return {
+			kind: "string",
+			value: w.insert(t.v)
+		};
+		case "date": return {
+			kind: "date",
+			value: t.v
+		};
+		case "bytes": return {
+			kind: "bytes",
+			value: t.v
+		};
+		case "bool": return {
+			kind: "bool",
+			value: t.v
+		};
+		case "null": return { kind: "null" };
+		case "set": return {
+			kind: "set",
+			value: t.v.map((x) => toTerm(x, w))
+		};
+		case "array": return {
+			kind: "array",
+			value: t.v.map((x) => toTerm(x, w))
+		};
+		case "map": return {
+			kind: "map",
+			value: t.v.map((e) => ({
+				key: e[0].t === "int" ? {
+					kind: "integer",
+					value: e[0].v
+				} : {
+					kind: "string",
+					value: w.insert(e[0].v)
+				},
+				value: toTerm(e[1], w)
+			}))
+		};
+	}
+}
+const toPredicate = (p, w) => ({
+	name: w.insert(p.name),
+	terms: p.terms.map((t) => toTerm(t, w))
+});
+const toOps = (ops, w) => ops.map((op) => {
+	switch (op.kind) {
+		case "value": return {
+			kind: "value",
+			value: toTerm(op.value, w)
+		};
+		case "unary": return {
+			kind: "unary",
+			op: op.op,
+			ffiName: op.ffi ? w.insert(op.ffi) : void 0
+		};
+		case "binary": return {
+			kind: "binary",
+			op: op.op,
+			ffiName: op.ffi ? w.insert(op.ffi) : void 0
+		};
+		case "closure": return {
+			kind: "closure",
+			params: op.params,
+			ops: toOps(op.ops, w)
+		};
+		default: throw new Error(`unknown expression op kind ${op.kind}`);
+	}
+});
+const toScope = (s, w) => s.kind === "authority" ? {
+	kind: "type",
+	value: 0
+} : s.kind === "previous" ? {
+	kind: "type",
+	value: 1
+} : {
+	kind: "publicKey",
+	value: w.insertKey(s.key)
+};
+const toRule = (r, w) => ({
+	head: toPredicate(r.head, w),
+	body: r.body.map((p) => toPredicate(p, w)),
+	expressions: r.expressions.map((e) => toOps(e, w)),
+	scope: r.scopes.map((s) => toScope(s, w))
+});
+function buildBlockMsg(content, knownSymbols = [], knownKeys = [], minVersion = 0) {
+	const w = new SymbolWriter(knownSymbols, knownKeys);
+	const facts = content.facts.map((f) => toPredicate(f.predicate, w));
+	const rules = content.rules.map((r) => toRule(r, w));
+	const checks = content.checks.map((c) => ({
+		queries: c.queries.map((q) => toRule(q, w)),
+		kind: c.kind === "all" ? 1 : c.kind === "reject" ? 2 : void 0
+	}));
+	const scope = content.scopes.map((s) => toScope(s, w));
+	return {
+		symbols: w.added,
+		version: Math.max(requiredVersion(content), minVersion),
+		facts,
+		rules,
+		checks,
+		scope,
+		publicKeys: w.addedKeys.map(parseKeyString)
+	};
+}
+const contentFromCode = (code) => {
+	const parsed = parseAuthorizer(code);
+	if (parsed.policies.length) throw new BuilderError("allow/deny policies belong to the authorizer, not to a block");
+	return {
+		facts: parsed.facts,
+		rules: parsed.rules,
+		checks: parsed.checks,
+		scopes: parsed.scopes
+	};
+};
+function knownTables(token) {
+	const symbols = [];
+	const keys = [];
+	const signed = [token.authority, ...token.blocks];
+	for (const sb of signed) {
+		const b = decodeBlock(sb.block);
+		if (!sb.externalSignature) symbols.push(...b.symbols);
+		for (const k of b.publicKeys) {
+			const s = `${k.algorithm === 1 ? "secp256r1" : "ed25519"}/${Array.from(k.key, (x) => x.toString(16).padStart(2, "0")).join("")}`;
+			if (!keys.includes(s)) keys.push(s);
+		}
+	}
+	return {
+		symbols,
+		keys
+	};
+}
+/** Mint a new token whose authority block holds `code`. */
+function buildToken(rootSecret, code, options = {}) {
+	const algorithm = options.algorithm ?? 0;
+	const blockBytes = encodeBlock(buildBlockMsg(typeof code === "string" ? contentFromCode(code) : code));
+	const next = options.nextKeypair ?? generateKeypair(algorithm);
+	const nextKey = {
+		algorithm,
+		key: next.publicKey
+	};
+	const signature = sign(authorityPayloadV1(blockBytes, nextKey, SIGNATURE_VERSION), rootSecret, algorithm);
+	return encodeBiscuit({
+		rootKeyId: options.rootKeyId,
+		authority: {
+			block: blockBytes,
+			nextKey,
+			signature,
+			version: SIGNATURE_VERSION
+		},
+		blocks: [],
+		proof: {
+			kind: "nextSecret",
+			value: next.secretKey
+		}
+	});
+}
+/** Append an attenuation block. Uses the token's own proof secret to sign. */
+function attenuate(tokenBytes, code, options = {}) {
+	const token = decodeBiscuit(tokenBytes);
+	if (token.proof.kind !== "nextSecret") throw new BuilderError("the token is sealed and cannot be attenuated");
+	const algorithm = options.algorithm ?? 0;
+	const currentSecret = token.proof.value;
+	const previous = token.blocks.length ? token.blocks[token.blocks.length - 1] : token.authority;
+	const currentAlgorithm = previous.nextKey.algorithm;
+	const tables = knownTables(token);
+	const blockBytes = encodeBlock(buildBlockMsg(typeof code === "string" ? contentFromCode(code) : code, tables.symbols, tables.keys));
+	const next = options.nextKeypair ?? generateKeypair(algorithm);
+	const nextKey = {
+		algorithm,
+		key: next.publicKey
+	};
+	const signature = sign(blockPayloadV1(blockBytes, nextKey, void 0, previous.signature, SIGNATURE_VERSION), currentSecret, currentAlgorithm);
+	token.blocks.push({
+		block: blockBytes,
+		nextKey,
+		signature,
+		version: SIGNATURE_VERSION
+	});
+	token.proof = {
+		kind: "nextSecret",
+		value: next.secretKey
+	};
+	return encodeBiscuit(token);
+}
+/** Seal a token so no further block can be appended. */
+function sealToken(tokenBytes) {
+	const token = decodeBiscuit(tokenBytes);
+	if (token.proof.kind !== "nextSecret") return tokenBytes;
+	const last = token.blocks.length ? token.blocks[token.blocks.length - 1] : token.authority;
+	token.proof = {
+		kind: "finalSignature",
+		value: sign(sealPayloadV0(last), token.proof.value, last.nextKey.algorithm)
+	};
+	return encodeBiscuit(token);
+}
+/** What a token holder sends to a third party that will sign a block. */
+function thirdPartyRequest(tokenBytes) {
+	const token = decodeBiscuit(tokenBytes);
+	return { previousSignature: (token.blocks.length ? token.blocks[token.blocks.length - 1] : token.authority).signature };
+}
+/** The third party builds and signs a block without holding the token. */
+function thirdPartyBlock(request, externalSecret, code, algorithm = 0) {
+	const blockBytes = encodeBlock(buildBlockMsg(typeof code === "string" ? contentFromCode(code) : code, [], [], 5));
+	return {
+		block: blockBytes,
+		signature: sign(externalPayloadV1(blockBytes, request.previousSignature, SIGNATURE_VERSION), externalSecret, algorithm),
+		publicKey: {
+			algorithm,
+			key: publicKeyFromSecret(externalSecret, algorithm)
+		}
+	};
+}
+/** The token holder appends a block signed by a third party. */
+function appendThirdParty(tokenBytes, response, options = {}) {
+	const token = decodeBiscuit(tokenBytes);
+	if (token.proof.kind !== "nextSecret") throw new BuilderError("the token is sealed and cannot be attenuated");
+	const previous = token.blocks.length ? token.blocks[token.blocks.length - 1] : token.authority;
+	const algorithm = options.algorithm ?? 0;
+	const next = options.nextKeypair ?? generateKeypair(algorithm);
+	const nextKey = {
+		algorithm,
+		key: next.publicKey
+	};
+	const signature = sign(blockPayloadV1(response.block, nextKey, response.signature, previous.signature, SIGNATURE_VERSION), token.proof.value, previous.nextKey.algorithm);
+	token.blocks.push({
+		block: response.block,
+		nextKey,
+		signature,
+		externalSignature: {
+			signature: response.signature,
+			publicKey: response.publicKey
+		},
+		version: SIGNATURE_VERSION
+	});
+	token.proof = {
+		kind: "nextSecret",
+		value: next.secretKey
+	};
+	return encodeBiscuit(token);
+}
+//#endregion
+//#region src/index.ts
+/**
+* biscuit-ts — pure TypeScript Biscuit tokens.
+*
+*   const root = generateKeypair();
+*   const token = Biscuit.build(root.secretKey, 'user("alice");');
+*   const text  = token.toBase64();
+*   const ok    = Biscuit.fromBase64(text).verify(root.publicKey).authorize('allow if user("alice");');
+*/
+/** An unverified token: it can be attenuated and re-serialized. */
+var Biscuit = class Biscuit {
+	bytes;
+	constructor(bytes) {
+		this.bytes = bytes;
+	}
+	static build(rootSecret, code, options) {
+		return new Biscuit(buildToken(rootSecret, code, options));
+	}
+	static fromBytes(bytes) {
+		return new Biscuit(bytes);
+	}
+	static fromBase64(text) {
+		return new Biscuit(fromBase64(text));
+	}
+	attenuate(code, options) {
+		return new Biscuit(attenuate(this.bytes, code, options));
+	}
+	appendThirdParty(response, options) {
+		return new Biscuit(appendThirdParty(this.bytes, response, options));
+	}
+	thirdPartyRequest() {
+		return thirdPartyRequest(this.bytes);
+	}
+	seal() {
+		return new Biscuit(sealToken(this.bytes));
+	}
+	toBase64() {
+		return toBase64(this.bytes);
+	}
+	/** Verify the signature chain. Throws if the token is not authentic. */
+	verify(rootPublicKey, rootAlgorithm = 0) {
+		return new VerifiedBiscuit(loadToken(this.bytes, rootPublicKey, rootAlgorithm), this.bytes);
+	}
+};
+/** A token whose signature chain has been checked against a root key. */
+var VerifiedBiscuit = class {
+	token;
+	bytes;
+	constructor(token, bytes) {
+		this.token = token;
+		this.bytes = bytes;
+	}
+	get revocationIds() {
+		return this.token.revocationIds;
+	}
+	/** the issuer's key identifier, when the token carries one */
+	get rootKeyId() {
+		return this.token.rootKeyId;
+	}
+	authorize(authorizerCode, options) {
+		return authorize(this.token, authorizerCode, options);
+	}
+};
+//#endregion
+export { Biscuit, BuilderError, DATALOG_3_1, DATALOG_3_2, DATALOG_3_3, DEFAULT_SYMBOLS, ExecutionError, MAX_SCHEMA_VERSION, MIN_SCHEMA_VERSION, ParseError, ProtoError, SignatureError, TokenError, VerifiedBiscuit, VersionError, appendThirdParty, attenuate, authorize, authorizeDetailed, blockFeatures, buildBlockMsg, buildToken, fromBase64, generateKeypair, loadToken, parseAuthorizer, peekRootKeyId, requiredVersion, sealToken, thirdPartyBlock, thirdPartyRequest, toBase64, validateBlockVersion };