@marimo-team/marimo-export 0.0.0 → 0.0.2

package/dist/schema-SJ_aIgcO.mjs

@@ -0,0 +1,713 @@
+import { _ as portableJsonValue, c as isNotebookExportError, d as isJsonNumber, f as isJsonString, g as portableJsonObject, m as isRecordValue, o as parseMediaType, s as NotebookExportError, u as isJsonBoolean, v as MAX_JSON_VALUES } from "./loader-CDfnJ5Yb.mjs";
+//#region ../portable-json/src/parse.ts
+const MAX_JSON_NUMBER_LEXEME_BYTES = 1024;
+/** Parse one JSON value while rejecting duplicate object keys at every depth. */
+function parseStrictJson(text, maximumValues) {
+	const scanner = new JsonScanner(text, jsonValueLimit(maximumValues));
+	scanner.value(0);
+	scanner.whitespace();
+	if (!scanner.done) scanner.fail("Unexpected content after the JSON value");
+	return JSON.parse(text);
+}
+/** Parse strict JSON and return a detached portable value. */
+function parsePortableJson(text) {
+	return portableJsonValue(parseStrictJson(text, MAX_JSON_VALUES));
+}
+var JsonScanner = class {
+	#maximumValues;
+	#text;
+	#offset = 0;
+	#values = 0;
+	constructor(text, maximumValues) {
+		this.#text = text;
+		this.#maximumValues = maximumValues;
+	}
+	get done() {
+		return this.#offset === this.#text.length;
+	}
+	whitespace() {
+		while (this.#offset < this.#text.length) {
+			const code = this.#text.charCodeAt(this.#offset);
+			if (code !== 32 && code !== 9 && code !== 10 && code !== 13) return;
+			this.#offset += 1;
+		}
+	}
+	value(depth) {
+		this.countValue();
+		if (depth > 256) this.fail("JSON exceeds the maximum nesting depth");
+		this.whitespace();
+		const token = this.#text[this.#offset];
+		if (token === "{") {
+			this.object(depth);
+			return;
+		}
+		if (token === "[") {
+			this.array(depth);
+			return;
+		}
+		if (token === "\"") {
+			this.string(false);
+			return;
+		}
+		if (token === "t") {
+			this.literal("true");
+			return;
+		}
+		if (token === "f") {
+			this.literal("false");
+			return;
+		}
+		if (token === "n") {
+			this.literal("null");
+			return;
+		}
+		this.number();
+	}
+	object(depth) {
+		this.#offset += 1;
+		this.whitespace();
+		if (this.consume("}")) return;
+		const keys = /* @__PURE__ */ new Set();
+		while (true) {
+			this.whitespace();
+			if (this.#text[this.#offset] !== "\"") this.fail("Object keys must be strings");
+			this.countValue();
+			const key = this.string(true);
+			if (key === void 0) this.fail("Object keys must be strings");
+			if (keys.has(key)) this.fail(`Duplicate object key ${quoteJsonDiagnostic(key)}`);
+			keys.add(key);
+			this.whitespace();
+			if (!this.consume(":")) this.fail("Expected ':' after an object key");
+			this.value(depth + 1);
+			this.whitespace();
+			if (this.consume("}")) return;
+			if (!this.consume(",")) this.fail("Expected ',' or '}' in an object");
+		}
+	}
+	array(depth) {
+		this.#offset += 1;
+		this.whitespace();
+		if (this.consume("]")) return;
+		while (true) {
+			this.value(depth + 1);
+			this.whitespace();
+			if (this.consume("]")) return;
+			if (!this.consume(",")) this.fail("Expected ',' or ']' in an array");
+		}
+	}
+	string(decode) {
+		const start = this.#offset;
+		this.#offset += 1;
+		while (this.#offset < this.#text.length) {
+			const code = this.#text.charCodeAt(this.#offset);
+			if (code === 34) {
+				this.#offset += 1;
+				if (!decode) return void 0;
+				return JSON.parse(this.#text.slice(start, this.#offset));
+			}
+			if (code < 32) this.fail("Unescaped control character in a string");
+			if (code === 92) {
+				this.#offset += 1;
+				const escape = this.#text[this.#offset];
+				if (escape === "u") {
+					const digits = this.#text.slice(this.#offset + 1, this.#offset + 5);
+					if (!/^[0-9a-fA-F]{4}$/.test(digits)) this.fail("Invalid Unicode escape");
+					this.#offset += 5;
+					continue;
+				}
+				if (escape === void 0 || !"\"\\/bfnrt".includes(escape)) this.fail("Invalid string escape");
+			}
+			this.#offset += 1;
+		}
+		this.fail("Unterminated string");
+	}
+	number() {
+		const start = this.#offset;
+		if (this.#text[this.#offset] === "-") this.#advanceNumber(start);
+		const first = this.#text[this.#offset];
+		if (first === "0") this.#advanceNumber(start);
+		else if (first !== void 0 && first >= "1" && first <= "9") do
+			this.#advanceNumber(start);
+		while (isDigit(this.#text[this.#offset]));
+		else this.fail("Expected a JSON value");
+		if (this.#text[this.#offset] === ".") {
+			this.#advanceNumber(start);
+			if (!isDigit(this.#text[this.#offset])) this.fail("Expected a digit after the decimal point");
+			do
+				this.#advanceNumber(start);
+			while (isDigit(this.#text[this.#offset]));
+		}
+		if (this.#text[this.#offset] === "e" || this.#text[this.#offset] === "E") {
+			this.#advanceNumber(start);
+			if (this.#text[this.#offset] === "+" || this.#text[this.#offset] === "-") this.#advanceNumber(start);
+			if (!isDigit(this.#text[this.#offset])) this.fail("Expected an exponent digit");
+			do
+				this.#advanceNumber(start);
+			while (isDigit(this.#text[this.#offset]));
+		}
+		const value = this.#text.slice(start, this.#offset);
+		if (value.includes(".") || /[eE]/u.test(value)) {
+			const converted = Number(value);
+			if (!decimalLexemeIsIntegral(value) && Number.isInteger(converted)) this.fail("JSON number loses its fractional component as a JavaScript number");
+		}
+	}
+	#advanceNumber(start) {
+		this.#offset += 1;
+		if (this.#offset - start > MAX_JSON_NUMBER_LEXEME_BYTES) this.fail("JSON number exceeds the maximum lexeme length");
+	}
+	literal(value) {
+		if (!this.#text.startsWith(value, this.#offset)) this.fail(`Expected ${value}`);
+		this.#offset += value.length;
+	}
+	consume(value) {
+		if (this.#text[this.#offset] !== value) return false;
+		this.#offset += 1;
+		return true;
+	}
+	countValue() {
+		this.#values += 1;
+		if (this.#values > this.#maximumValues) this.fail("JSON exceeds the maximum value count");
+	}
+	fail(message) {
+		throw new SyntaxError(`${message} at character ${this.#offset}.`);
+	}
+};
+function decimalLexemeIsIntegral(value) {
+	let unsigned = value[0] === "-" ? value.slice(1) : value;
+	let exponent = 0;
+	const exponentIndex = unsigned.search(/[eE]/u);
+	if (exponentIndex >= 0) {
+		exponent = Number(unsigned.slice(exponentIndex + 1));
+		unsigned = unsigned.slice(0, exponentIndex);
+	}
+	const decimalIndex = unsigned.indexOf(".");
+	const fractionDigits = decimalIndex < 0 ? 0 : unsigned.length - decimalIndex - 1;
+	const digits = decimalIndex < 0 ? unsigned : `${unsigned.slice(0, decimalIndex)}${unsigned.slice(decimalIndex + 1)}`;
+	if (/^0+$/u.test(digits)) return true;
+	const trailingZeros = countTrailingZeros(digits);
+	return exponent - fractionDigits + trailingZeros >= 0;
+}
+function isDigit(value) {
+	return value !== void 0 && value >= "0" && value <= "9";
+}
+function countTrailingZeros(value) {
+	let count = 0;
+	for (let index = value.length - 1; index >= 0 && value[index] === "0"; index -= 1) count += 1;
+	return count;
+}
+function quoteJsonDiagnostic(value) {
+	const bodyLimit = 251;
+	let body = "";
+	let truncated = false;
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		let token;
+		if (codeUnit === 34 || codeUnit === 92) token = `\\${value[index]}`;
+		else if (codeUnit <= 31 || codeUnit >= 127 && codeUnit <= 159 || codeUnit >= 55296 && codeUnit <= 57343) {
+			if (codeUnit >= 55296 && codeUnit <= 56319 && index + 1 < value.length && value.charCodeAt(index + 1) >= 56320 && value.charCodeAt(index + 1) <= 57343) {
+				token = value.slice(index, index + 2);
+				index += 1;
+			} else token = `\\u${codeUnit.toString(16).padStart(4, "0")}`;
+		} else token = value[index];
+		if (body.length + token.length > bodyLimit) {
+			truncated = true;
+			break;
+		}
+		body += token;
+	}
+	return `"${body}${truncated ? "..." : ""}"`;
+}
+function jsonValueLimit(input) {
+	if (input === void 0) return MAX_JSON_VALUES;
+	if (!Number.isSafeInteger(input) || input <= 0) throw new TypeError("JSON value limits must be positive safe integers.");
+	return input;
+}
+//#endregion
+//#region src/schema.ts
+const encoder = new TextEncoder();
+const SHA256 = /^[0-9a-f]{64}$/u;
+const BIGINT = /^(?:0|-[1-9][0-9]*|[1-9][0-9]*)$/u;
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+const MAX_EXPORT_NAME_BYTES = 255;
+const MAX_CONTROL_ID_BYTES = 1024;
+const MAX_CONTROL_PATH_STEPS = 256;
+const MAX_PROVENANCE_BYTES = 2048;
+const MAX_ASSET_SIZE = 2147483647;
+const MAX_METADATA_BYTES = 262144;
+const WINDOWS_RESERVED = /[<>:"/\\|?*]/u;
+const WINDOWS_DEVICE = /^(?:CON|CONIN\$|CONOUT\$|PRN|AUX|NUL|COM[1-9¹²³]|LPT[1-9¹²³])$/iu;
+const EDGE_WHITESPACE = /* @__PURE__ */ new Set([
+	9,
+	10,
+	11,
+	12,
+	13,
+	28,
+	29,
+	30,
+	31,
+	32,
+	133,
+	160,
+	5760,
+	8192,
+	8193,
+	8194,
+	8195,
+	8196,
+	8197,
+	8198,
+	8199,
+	8200,
+	8201,
+	8202,
+	8232,
+	8233,
+	8239,
+	8287,
+	12288,
+	65279
+]);
+function parseExportIndex(input) {
+	try {
+		const root = strictRecord(portableJsonObject(input, "export"), "export", [
+			"aliases",
+			"control_bindings",
+			"default_state",
+			"inputs",
+			"notebook",
+			"outputs",
+			"producer",
+			"schema",
+			"spec_sha256",
+			"states"
+		]);
+		literal(root.schema, "marimo-export.export.v1", "export.schema");
+		const specSha256 = digest(root.spec_sha256, "export.spec_sha256");
+		const defaultState = digest(root.default_state, "export.default_state");
+		const notebook = parseNotebook(root.notebook);
+		const producer = parseProducer(root.producer);
+		const inputs = opaqueNameArray(root.inputs, "export.inputs");
+		const outputs = nameArray(root.outputs, "export.outputs", true);
+		const inputSet = new Set(inputs);
+		const controlBindingRecord = record(root.control_bindings, "export.control_bindings");
+		const controlBindings = Object.freeze(Object.fromEntries(Object.entries(controlBindingRecord).map(([objectId, binding]) => {
+			const controlId = boundedPrintable(objectId, "export.control_bindings key", MAX_CONTROL_ID_BYTES);
+			return [controlId, parseControlBinding(binding, `export.control_bindings[${JSON.stringify(controlId)}]`, inputSet)];
+		})));
+		const outputSet = new Set(outputs);
+		const statesRecord = record(root.states, "export.states");
+		if (Object.keys(statesRecord).length === 0) fail("export.states must not be empty");
+		const states = Object.freeze(Object.fromEntries(Object.entries(statesRecord).map(([key, value]) => {
+			const fingerprint = digest(key, "export.states key");
+			const path = `export.states[${JSON.stringify(fingerprint)}]`;
+			const state = strictRecord(value, path, ["inputs", "outputs"]);
+			const stateInputs = portableJsonObject(state.inputs, `${path}.inputs`);
+			requireExactKeys(stateInputs, inputSet, `${path}.inputs`);
+			const outputRecord = record(state.outputs, `${path}.outputs`);
+			requireExactKeys(outputRecord, outputSet, `${path}.outputs`);
+			const parsedOutputs = Object.freeze(Object.fromEntries(Object.entries(outputRecord).map(([outputName, descriptor]) => [exportName(outputName, `${path}.outputs key`), parseDescriptor(descriptor, outputName)])));
+			return [fingerprint, Object.freeze({
+				inputs: stateInputs,
+				outputs: parsedOutputs
+			})];
+		})));
+		const aliasesRecord = record(root.aliases, "export.aliases");
+		const aliases = Object.freeze(Object.fromEntries(Object.entries(aliasesRecord).map(([name, value]) => {
+			const alias = exportName(name, "export.aliases key");
+			const fingerprint = digest(value, `export.aliases[${JSON.stringify(alias)}]`);
+			if (!Object.hasOwn(states, fingerprint)) fail(`export.aliases[${JSON.stringify(alias)}] references an unknown state fingerprint`);
+			return [alias, fingerprint];
+		})));
+		if (!Object.hasOwn(states, defaultState)) fail("export.default_state must reference a declared state fingerprint");
+		validateRepresentations(states, outputs);
+		validateAssets(states);
+		return Object.freeze({
+			specSha256,
+			defaultState,
+			notebook,
+			producer,
+			inputs,
+			controlBindings,
+			outputs,
+			aliases,
+			states
+		});
+	} catch (error) {
+		if (isNotebookExportError(error)) throw error;
+		throw new NotebookExportError("export_invalid", boundedMessage(error), { cause: error });
+	}
+}
+function parseNotebook(input) {
+	const value = strictRecord(input, "export.notebook", ["document_sha256", "filename"]);
+	const filename = value.filename === null ? null : portableBasename(value.filename, "export.notebook.filename");
+	return Object.freeze({
+		filename,
+		documentSha256: digest(value.document_sha256, "export.notebook.document_sha256")
+	});
+}
+function parseProducer(input) {
+	const value = strictRecord(input, "export.producer", [
+		"implementation_sha256",
+		"marimo",
+		"marimo_export"
+	]);
+	return Object.freeze({
+		implementationSha256: digest(value.implementation_sha256, "export.producer.implementation_sha256"),
+		marimo: boundedPrintable(value.marimo, "export.producer.marimo", MAX_EXPORT_NAME_BYTES),
+		marimoExport: boundedPrintable(value.marimo_export, "export.producer.marimo_export", MAX_EXPORT_NAME_BYTES)
+	});
+}
+function parseControlBinding(input, path, inputNames) {
+	const value = strictRecord(input, path, ["input", "path"]);
+	const inputName = opaqueInputName(value.input, `${path}.input`);
+	if (!inputNames.has(inputName)) fail(`${path}.input must name a declared input`);
+	if (!Array.isArray(value.path) || value.path.length > MAX_CONTROL_PATH_STEPS) fail(`${path}.path must be an array of at most ${MAX_CONTROL_PATH_STEPS} steps`);
+	return Object.freeze({
+		input: inputName,
+		path: Object.freeze(value.path.map((step, index) => parseControlPathStep(step, `${path}.path[${index}]`)))
+	});
+}
+function parseControlPathStep(input, path) {
+	const value = record(input, path);
+	if (value.kind === "element") {
+		exactFields(value, ["kind"], path);
+		return Object.freeze({ kind: "element" });
+	}
+	if (value.kind === "index") {
+		exactFields(value, ["kind", "value"], path);
+		if (!isJsonNumber(value.value) || !Number.isSafeInteger(value.value) || value.value < 0) fail(`${path}.value must be a nonnegative safe integer`);
+		return Object.freeze({
+			kind: "index",
+			value: value.value
+		});
+	}
+	if (value.kind === "key") {
+		exactFields(value, ["kind", "value"], path);
+		if (!isJsonString(value.value)) fail(`${path}.value must be a string`);
+		unicodeScalar(value.value, `${path}.value`);
+		if (encoder.encode(value.value).byteLength > MAX_CONTROL_ID_BYTES) fail(`${path}.value exceeds ${MAX_CONTROL_ID_BYTES} UTF-8 bytes`);
+		return Object.freeze({
+			kind: "key",
+			value: value.value
+		});
+	}
+	fail(`${path}.kind must be index, key, or element`);
+}
+function parseDescriptor(input, outputName) {
+	const value = record(input, `output ${JSON.stringify(outputName)}`);
+	const codec = value.codec;
+	if (codec === "marimo.scalar.v1") return parseScalar(value, outputName);
+	if (codec === "marimo.json.v1") return parseJson(value, outputName);
+	if (codec === "marimo.output.v1") return parseMarimoOutput(value, outputName);
+	if (codec === "marimo.cell.v1") return parseMarimoCell(value, outputName);
+	if (codec === "numpy.npy.v1") return parseNumpy(value, outputName);
+	if (codec === "apache.arrow.file.v1") return parseArrow(value, outputName);
+	if (codec === "marimo.blob-asset.msgpack.v1") return parseBlobAsset(value, outputName);
+	fail(`output ${JSON.stringify(outputName)} has an unknown codec`);
+}
+function parseJson(value, outputName) {
+	const path = `output ${JSON.stringify(outputName)}`;
+	exactFields(value, [
+		"codec",
+		"media_type",
+		"provenance",
+		"value"
+	], path);
+	literal(value.media_type, "application/vnd.marimo.json.v1+json", `${path}.media_type`);
+	return Object.freeze({
+		codec: "marimo.json.v1",
+		mediaType: "application/vnd.marimo.json.v1+json",
+		provenance: parseProvenance(value.provenance, path),
+		value: portableJsonValue(value.value, `${path}.value`)
+	});
+}
+function parseMarimoOutput(value, outputName) {
+	const path = `output ${JSON.stringify(outputName)}`;
+	exactFields(value, [
+		"asset",
+		"codec",
+		"media_type",
+		"provenance"
+	], path);
+	literal(value.media_type, "application/vnd.marimo.output.v1+json", `${path}.media_type`);
+	return Object.freeze({
+		codec: "marimo.output.v1",
+		mediaType: "application/vnd.marimo.output.v1+json",
+		provenance: parseProvenance(value.provenance, path),
+		asset: parseAsset(value.asset, path)
+	});
+}
+function parseMarimoCell(value, outputName) {
+	const path = `output ${JSON.stringify(outputName)}`;
+	exactFields(value, [
+		"asset",
+		"codec",
+		"media_type",
+		"provenance"
+	], path);
+	literal(value.media_type, "application/vnd.marimo.cell.v1+json", `${path}.media_type`);
+	return Object.freeze({
+		codec: "marimo.cell.v1",
+		mediaType: "application/vnd.marimo.cell.v1+json",
+		provenance: parseProvenance(value.provenance, path),
+		asset: parseAsset(value.asset, path)
+	});
+}
+function parseScalar(value, outputName) {
+	const path = `output ${JSON.stringify(outputName)}`;
+	exactFields(value, [
+		"codec",
+		"media_type",
+		"provenance",
+		"value"
+	], path);
+	literal(value.media_type, "application/vnd.marimo.scalar.v1+json", `${path}.media_type`);
+	const provenance = parseProvenance(value.provenance, path);
+	return Object.freeze({
+		codec: "marimo.scalar.v1",
+		mediaType: "application/vnd.marimo.scalar.v1+json",
+		provenance,
+		value: parseScalarValue(value.value)
+	});
+}
+function parseNumpy(value, outputName) {
+	const path = `output ${JSON.stringify(outputName)}`;
+	exactFields(value, [
+		"asset",
+		"codec",
+		"media_type",
+		"provenance"
+	], path);
+	literal(value.media_type, "application/x-npy", `${path}.media_type`);
+	return Object.freeze({
+		codec: "numpy.npy.v1",
+		mediaType: "application/x-npy",
+		provenance: parseProvenance(value.provenance, path),
+		asset: parseAsset(value.asset, path)
+	});
+}
+function parseArrow(value, outputName) {
+	const path = `output ${JSON.stringify(outputName)}`;
+	exactFields(value, [
+		"asset",
+		"codec",
+		"media_type",
+		"provenance"
+	], path);
+	literal(value.media_type, "application/vnd.apache.arrow.file", `${path}.media_type`);
+	return Object.freeze({
+		codec: "apache.arrow.file.v1",
+		mediaType: "application/vnd.apache.arrow.file",
+		provenance: parseProvenance(value.provenance, path),
+		asset: parseAsset(value.asset, path)
+	});
+}
+function parseBlobAsset(value, outputName) {
+	const path = `output ${JSON.stringify(outputName)}`;
+	exactFields(value, [
+		"asset",
+		"codec",
+		"filename",
+		"media_type",
+		"metadata",
+		"provenance"
+	], path);
+	if (!isJsonString(value.media_type)) fail(`${path}.media_type must be a string`);
+	parseMediaType(value.media_type);
+	const filename = value.filename === null ? null : portableBasename(value.filename, `${path}.filename`);
+	const metadata = portableJsonObject(value.metadata, `${path}.metadata`);
+	if (encoder.encode(canonicalJson(metadata)).byteLength > MAX_METADATA_BYTES) fail(`${path}.metadata exceeds ${MAX_METADATA_BYTES} canonical JSON bytes`);
+	return Object.freeze({
+		codec: "marimo.blob-asset.msgpack.v1",
+		mediaType: value.media_type,
+		filename,
+		metadata,
+		provenance: parseProvenance(value.provenance, path),
+		asset: parseAsset(value.asset, path)
+	});
+}
+function parseProvenance(input, parent) {
+	const path = `${parent}.provenance`;
+	const value = strictRecord(input, path, ["python_type"]);
+	return Object.freeze({ pythonType: boundedPrintable(value.python_type, `${path}.python_type`, MAX_PROVENANCE_BYTES) });
+}
+function parseAsset(input, parent) {
+	const path = `${parent}.asset`;
+	const value = strictRecord(input, path, ["sha256", "size"]);
+	if (!isJsonNumber(value.size) || !Number.isInteger(value.size) || value.size < 1 || value.size > MAX_ASSET_SIZE) fail(`${path}.size must be an integer from 1 through ${MAX_ASSET_SIZE}`);
+	return Object.freeze({
+		sha256: digest(value.sha256, `${path}.sha256`),
+		size: value.size
+	});
+}
+function parseScalarValue(input) {
+	if (input === null) return null;
+	if (isJsonBoolean(input) || isJsonString(input)) return input;
+	if (isJsonNumber(input)) {
+		if (Number.isInteger(input) && !Number.isSafeInteger(input)) fail("untagged scalar integer exceeds the safe integer range");
+		return input;
+	}
+	const value = strictRecord(input, "scalar.value", ["type", "value"]);
+	if (value.type === "bigint") {
+		if (!isJsonString(value.value) || !BIGINT.test(value.value)) fail("tagged bigint has an invalid decimal value");
+		const result = BigInt(value.value);
+		if (result >= -BigInt(MAX_SAFE_INTEGER) && result <= BigInt(MAX_SAFE_INTEGER)) fail("tagged bigint must lie outside the safe integer range");
+		return result;
+	}
+	if (value.type === "float") {
+		if (value.value === "nan") return NaN;
+		if (value.value === "infinity") return Number.POSITIVE_INFINITY;
+		if (value.value === "-infinity") return Number.NEGATIVE_INFINITY;
+		if (value.value === "negative-zero") return -0;
+		fail("tagged float has an invalid value");
+	}
+	fail("scalar tag type must be bigint or float");
+}
+function validateRepresentations(states, outputNames) {
+	const representations = /* @__PURE__ */ new Map();
+	for (const state of Object.values(states)) for (const name of outputNames) {
+		const descriptor = state.outputs[name];
+		const representation = `${descriptor.codec}\0${descriptor.mediaType}`;
+		const previous = representations.get(name);
+		if (previous !== void 0 && previous !== representation) throw new NotebookExportError("output_representation_changed", `Output ${JSON.stringify(name)} changes codec or media type across states.`, { details: { output: name } });
+		representations.set(name, representation);
+	}
+}
+function validateAssets(states) {
+	const assets = /* @__PURE__ */ new Map();
+	let total = 0;
+	for (const state of Object.values(states)) for (const descriptor of Object.values(state.outputs)) {
+		if (descriptor.codec === "marimo.scalar.v1" || descriptor.codec === "marimo.json.v1") continue;
+		const identity = `${descriptor.codec}\0${descriptor.asset.sha256}`;
+		const facts = descriptor.codec === "marimo.blob-asset.msgpack.v1" ? `${descriptor.asset.size}\0${descriptor.mediaType}\0${descriptor.filename ?? ""}\0${canonicalJson(descriptor.metadata)}` : `${descriptor.asset.size}\0${descriptor.mediaType}`;
+		const previous = assets.get(identity);
+		if (previous !== void 0 && previous !== facts) fail(`asset ${descriptor.asset.sha256} has conflicting descriptor facts`);
+		if (previous === void 0) {
+			assets.set(identity, facts);
+			total += descriptor.asset.size;
+			if (!Number.isSafeInteger(total)) fail("aggregate unique asset size exceeds the safe range");
+		}
+	}
+}
+function canonicalJson(value) {
+	if (value === null || isJsonBoolean(value)) return JSON.stringify(value);
+	if (isJsonString(value)) {
+		unicodeScalar(value, "canonical JSON string");
+		return JSON.stringify(value);
+	}
+	if (isJsonNumber(value)) {
+		if (!Number.isFinite(value)) fail("canonical JSON number must be finite");
+		return JSON.stringify(Object.is(value, -0) ? 0 : value);
+	}
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (!isJsonObject(value)) fail("canonical JSON object must use string keys");
+	const keys = Object.keys(value);
+	keys.forEach((key) => unicodeScalar(key, "canonical JSON key"));
+	return `{${keys.sort(compareUnicodeScalarStrings).map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+}
+function compareUnicodeScalarStrings(left, right) {
+	const leftPoints = left[Symbol.iterator]();
+	const rightPoints = right[Symbol.iterator]();
+	while (true) {
+		const a = leftPoints.next();
+		const b = rightPoints.next();
+		if (a.done || b.done) {
+			if (a.done && b.done) return 0;
+			return a.done ? -1 : 1;
+		}
+		const difference = a.value.codePointAt(0) - b.value.codePointAt(0);
+		if (difference !== 0) return difference;
+	}
+}
+function strictRecord(input, path, fields) {
+	const value = record(input, path);
+	exactFields(value, fields, path);
+	return value;
+}
+function record(input, path) {
+	if (!isJsonObject(input)) fail(`${path} must be an object`);
+	return input;
+}
+function exactFields(value, fields, path) {
+	const expected = new Set(fields);
+	const actual = Object.keys(value);
+	const missing = fields.filter((field) => !Object.hasOwn(value, field));
+	const extra = actual.filter((field) => !expected.has(field));
+	if (missing.length > 0) fail(`${path} is missing fields: ${missing.slice(0, 8).join(", ")}`);
+	if (extra.length > 0) fail(`${path} has unknown fields: ${extra.slice(0, 8).join(", ")}`);
+}
+function requireExactKeys(value, expected, path) {
+	const keys = Object.keys(value);
+	const missing = [...expected].filter((key) => !Object.hasOwn(value, key));
+	const extra = keys.filter((key) => !expected.has(key));
+	if (missing.length > 0 || extra.length > 0) fail(`${path} must match the root name set`);
+}
+function nameArray(input, path, nonempty) {
+	if (!Array.isArray(input)) fail(`${path} must be an array`);
+	const values = input.map((name, index) => exportName(name, `${path}[${index}]`));
+	if (nonempty && values.length === 0) fail(`${path} must not be empty`);
+	if (new Set(values).size !== values.length) fail(`${path} must contain unique names`);
+	return Object.freeze(values);
+}
+function opaqueNameArray(input, path) {
+	if (!Array.isArray(input)) fail(`${path} must be an array`);
+	const values = input.map((name, index) => opaqueInputName(name, `${path}[${index}]`));
+	if (new Set(values).size !== values.length) fail(`${path} must contain unique names`);
+	return Object.freeze(values);
+}
+function opaqueInputName(input, path) {
+	if (!isJsonString(input)) fail(`${path} must be a string`);
+	unicodeScalar(input, path);
+	if (input.length === 0 || encoder.encode(input).byteLength > MAX_EXPORT_NAME_BYTES) fail(`${path} must be a bounded nonempty UTF-8 string`);
+	return input;
+}
+function exportName(input, path) {
+	return boundedPrintable(input, path, MAX_EXPORT_NAME_BYTES);
+}
+function boundedPrintable(input, path, maxBytes) {
+	if (!isJsonString(input)) fail(`${path} must be a string`);
+	unicodeScalar(input, path);
+	if (input.length === 0 || hasEdgeWhitespace(input) || hasControl(input) || encoder.encode(input).byteLength > maxBytes) fail(`${path} must be a bounded printable string`);
+	return input;
+}
+function hasEdgeWhitespace(value) {
+	return EDGE_WHITESPACE.has(value.charCodeAt(0)) || EDGE_WHITESPACE.has(value.charCodeAt(value.length - 1));
+}
+function portableBasename(input, path) {
+	if (!isJsonString(input)) fail(`${path} must be a string`);
+	unicodeScalar(input, path);
+	const stem = input.split(".", 1)[0].replace(/[ .]+$/u, "");
+	if (input.length === 0 || input === "." || input === ".." || hasEdgeWhitespace(input) || input.endsWith(".") || hasControl(input) || WINDOWS_RESERVED.test(input) || WINDOWS_DEVICE.test(stem) || encoder.encode(input).byteLength > MAX_EXPORT_NAME_BYTES) fail(`${path} must be a portable basename`);
+	return input;
+}
+function digest(input, path) {
+	if (!isJsonString(input) || !SHA256.test(input)) fail(`${path} must be a lowercase SHA-256 digest`);
+	return input;
+}
+function literal(input, expected, path) {
+	if (input !== expected) fail(`${path} must be ${JSON.stringify(expected)}`);
+	return expected;
+}
+function unicodeScalar(value, path) {
+	if (/[\ud800-\udfff]/u.test(value)) fail(`${path} must contain Unicode scalar values`);
+}
+function hasControl(value) {
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if (codeUnit < 32 || codeUnit === 127) return true;
+	}
+	return false;
+}
+function boundedMessage(cause) {
+	const source = cause instanceof Error ? cause.message : "Export index validation failed.";
+	return `Invalid export index: ${source.length > 2048 ? `${source.slice(0, 2045)}...` : source}`;
+}
+function isJsonObject(value) {
+	return isRecordValue(value);
+}
+function fail(message) {
+	throw new NotebookExportError("export_invalid", message.length > 2048 ? `${message.slice(0, 2045)}...` : message);
+}
+//#endregion
+export { parseStrictJson as a, parsePortableJson as i, compareUnicodeScalarStrings as n, parseExportIndex as r, canonicalJson as t };