@marimo-team/marimo-export 0.0.0 → 0.0.1

package/dist/export-6118xT3K.mjs

@@ -0,0 +1,823 @@
+import { c as isNotebookExportError, g as portableJsonObject, h as isStringValue, i as resolveOutputLoader, l as isCallableValue, m as isRecordValue, o as parseMediaType, p as isPropertyOwner, s as NotebookExportError } from "./loader-CDfnJ5Yb.mjs";
+import { a as parseStrictJson, n as compareUnicodeScalarStrings, r as parseExportIndex, t as canonicalJson } from "./schema-SJ_aIgcO.mjs";
+import { decode } from "@msgpack/msgpack";
+//#region src/abort.ts
+function isAbortError(cause) {
+	if (!isPropertyOwner(cause) || !("name" in cause)) return false;
+	try {
+		return cause.name === "AbortError";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/strict-msgpack.ts
+const decoder$1 = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+const MAX_DEPTH = 256;
+const MAX_VALUES = 1e5;
+function validateCanonicalMessagePack(bytes) {
+	const scanner = new MessagePackScanner(bytes);
+	scanner.value(0);
+	scanner.end();
+}
+var MessagePackScanner = class {
+	#bytes;
+	#view;
+	#offset = 0;
+	#values = 0;
+	constructor(bytes) {
+		this.#bytes = bytes;
+		this.#view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	}
+	value(depth) {
+		this.#values += 1;
+		if (this.#values > MAX_VALUES) throw new RangeError("MessagePack exceeds its value limit.");
+		if (depth > MAX_DEPTH) throw new RangeError("MessagePack exceeds its nesting limit.");
+		const head = this.u8();
+		if (head <= 127) return head;
+		if (head >= 224) return head - 256;
+		if (head >= 160 && head <= 191) return this.stringPayload(head & 31);
+		if (head >= 144 && head <= 159) return this.array(head & 15, depth);
+		if (head >= 128 && head <= 143) return this.map(head & 15, depth);
+		switch (head) {
+			case 192: return null;
+			case 194: return false;
+			case 195: return true;
+			case 196: return this.binary(this.u8());
+			case 197: {
+				const length = this.u16();
+				if (length <= 255) throw nonCanonical();
+				return this.binary(length);
+			}
+			case 198: {
+				const length = this.u32();
+				if (length <= 65535) throw nonCanonical();
+				return this.binary(length);
+			}
+			case 202: throw new RangeError("Canonical BlobAsset metadata uses float64.");
+			case 203: {
+				const value = this.f64();
+				if (!Number.isFinite(value)) throw new RangeError("MessagePack float must be finite.");
+				return value;
+			}
+			case 204: {
+				const value = this.u8();
+				if (value <= 127) throw nonCanonical();
+				return value;
+			}
+			case 205: {
+				const value = this.u16();
+				if (value <= 255) throw nonCanonical();
+				return value;
+			}
+			case 206: {
+				const value = this.u32();
+				if (value <= 65535) throw nonCanonical();
+				return value;
+			}
+			case 207: {
+				const value = this.u64();
+				if (value <= 4294967295n) throw nonCanonical();
+				return value;
+			}
+			case 208: {
+				const value = this.i8();
+				if (value >= -32) throw nonCanonical();
+				return value;
+			}
+			case 209: {
+				const value = this.i16();
+				if (value >= -128) throw nonCanonical();
+				return value;
+			}
+			case 210: {
+				const value = this.i32();
+				if (value >= -32768) throw nonCanonical();
+				return value;
+			}
+			case 211: {
+				const value = this.i64();
+				if (value >= -2147483648n) throw nonCanonical();
+				return value;
+			}
+			case 217: {
+				const length = this.u8();
+				if (length <= 31) throw nonCanonical();
+				return this.stringPayload(length);
+			}
+			case 218: {
+				const length = this.u16();
+				if (length <= 255) throw nonCanonical();
+				return this.stringPayload(length);
+			}
+			case 219: {
+				const length = this.u32();
+				if (length <= 65535) throw nonCanonical();
+				return this.stringPayload(length);
+			}
+			case 220: {
+				const length = this.u16();
+				if (length <= 15) throw nonCanonical();
+				return this.array(length, depth);
+			}
+			case 221: {
+				const length = this.u32();
+				if (length <= 65535) throw nonCanonical();
+				return this.array(length, depth);
+			}
+			case 222: {
+				const length = this.u16();
+				if (length <= 15) throw nonCanonical();
+				return this.map(length, depth);
+			}
+			case 223: {
+				const length = this.u32();
+				if (length <= 65535) throw nonCanonical();
+				return this.map(length, depth);
+			}
+			default: throw new RangeError("BlobAsset contains an unsupported MessagePack token.");
+		}
+	}
+	array(length, depth) {
+		const values = [];
+		for (let index = 0; index < length; index += 1) values.push(this.value(depth + 1));
+		return values;
+	}
+	map(length, depth) {
+		const values = /* @__PURE__ */ new Map();
+		for (let index = 0; index < length; index += 1) {
+			const key = this.value(depth + 1);
+			if (!isMessagePackString(key)) throw new RangeError("BlobAsset map keys must be strings.");
+			if (values.has(key)) throw new RangeError("BlobAsset map keys must be unique.");
+			values.set(key, this.value(depth + 1));
+		}
+		return values;
+	}
+	binary(length) {
+		return this.payload(length);
+	}
+	stringPayload(length) {
+		return decoder$1.decode(this.payload(length));
+	}
+	end() {
+		if (this.#offset !== this.#bytes.byteLength) throw new RangeError("BlobAsset MessagePack contains trailing data.");
+	}
+	payload(length) {
+		this.ensure(length);
+		const start = this.#offset;
+		this.#offset += length;
+		return this.#bytes.subarray(start, this.#offset);
+	}
+	u8() {
+		this.ensure(1);
+		return this.#view.getUint8(this.#offset++);
+	}
+	i8() {
+		this.ensure(1);
+		return this.#view.getInt8(this.#offset++);
+	}
+	u16() {
+		this.ensure(2);
+		const value = this.#view.getUint16(this.#offset);
+		this.#offset += 2;
+		return value;
+	}
+	i16() {
+		this.ensure(2);
+		const value = this.#view.getInt16(this.#offset);
+		this.#offset += 2;
+		return value;
+	}
+	u32() {
+		this.ensure(4);
+		const value = this.#view.getUint32(this.#offset);
+		this.#offset += 4;
+		return value;
+	}
+	i32() {
+		this.ensure(4);
+		const value = this.#view.getInt32(this.#offset);
+		this.#offset += 4;
+		return value;
+	}
+	u64() {
+		this.ensure(8);
+		const value = this.#view.getBigUint64(this.#offset);
+		this.#offset += 8;
+		return value;
+	}
+	i64() {
+		this.ensure(8);
+		const value = this.#view.getBigInt64(this.#offset);
+		this.#offset += 8;
+		return value;
+	}
+	f64() {
+		this.ensure(8);
+		const value = this.#view.getFloat64(this.#offset);
+		this.#offset += 8;
+		return value;
+	}
+	ensure(length) {
+		if (length > this.#bytes.byteLength - this.#offset) throw new RangeError("BlobAsset MessagePack is truncated.");
+	}
+};
+function isMessagePackString(value) {
+	return Object.prototype.toString.call(value) === "[object String]";
+}
+function nonCanonical() {
+	return /* @__PURE__ */ new RangeError("BlobAsset MessagePack is not canonical.");
+}
+//#endregion
+//#region src/blob-asset.ts
+const EXPECTED_FIELDS = [
+	"data",
+	"media_type",
+	"filename",
+	"metadata"
+];
+function decodeBlobAsset(bytes, descriptor) {
+	try {
+		validateCanonicalMessagePack(bytes);
+		const decoded = decode(bytes);
+		if (!isRecordValue(decoded)) throw new TypeError("BlobAsset must be a map.");
+		const fields = Object.keys(decoded);
+		if (fields.length !== EXPECTED_FIELDS.length || fields.some((field, index) => field !== EXPECTED_FIELDS[index])) throw new TypeError("BlobAsset must use the native four-field envelope.");
+		if (!("data" in decoded) || !(decoded.data instanceof Uint8Array)) throw new TypeError("BlobAsset.data must be binary.");
+		if (!("media_type" in decoded) || !isStringValue(decoded.media_type)) throw new TypeError("BlobAsset.media_type must be a string.");
+		const mediaType = parseMediaType(decoded.media_type);
+		if (!("filename" in decoded)) throw new TypeError("BlobAsset.filename must be present.");
+		const filename = decoded.filename;
+		if (filename !== null && !isStringValue(filename)) throw new TypeError("BlobAsset.filename must be a string or null.");
+		if (!("metadata" in decoded)) throw new TypeError("BlobAsset.metadata must be present.");
+		const metadata = portableJsonObject(decoded.metadata, "BlobAsset.metadata");
+		if (decoded.media_type !== descriptor.mediaType) throw new TypeError("BlobAsset.media_type does not match its descriptor.");
+		if (filename !== descriptor.filename) throw new TypeError("BlobAsset.filename does not match its descriptor.");
+		if (canonicalJson(metadata) !== canonicalJson(descriptor.metadata)) throw new TypeError("BlobAsset.metadata does not match its descriptor.");
+		return Object.freeze({
+			data: decoded.data,
+			mediaType,
+			filename,
+			metadata
+		});
+	} catch (error) {
+		if (isNotebookExportError(error) && error.code === "asset_invalid") throw error;
+		throw new NotebookExportError("asset_invalid", "BlobAsset envelope validation failed.", {
+			cause: error,
+			details: {
+				outputCodec: descriptor.codec,
+				mediaType: descriptor.mediaType
+			}
+		});
+	}
+}
+//#endregion
+//#region src/integrity.ts
+const NPY_MAGIC = new Uint8Array([
+	147,
+	78,
+	85,
+	77,
+	80,
+	89
+]);
+const ARROW_MAGIC = new TextEncoder().encode("ARROW1");
+const ARROW_CONTINUATION = new Uint8Array([
+	255,
+	255,
+	255,
+	255
+]);
+const ARROW_STREAM_END = new Uint8Array([
+	255,
+	255,
+	255,
+	255,
+	0,
+	0,
+	0,
+	0
+]);
+async function sha256Hex(bytes) {
+	const subtle = globalThis.crypto?.subtle;
+	if (subtle === void 0) throw new NotebookExportError("integrity_failed", "Export verification requires Web Crypto SHA-256.");
+	try {
+		const digest = await subtle.digest("SHA-256", new Uint8Array(bytes));
+		return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	} catch (error) {
+		throw new NotebookExportError("integrity_failed", "SHA-256 verification failed.", { cause: error });
+	}
+}
+async function verifyBytes(bytes, expected) {
+	if (bytes.byteLength !== expected.size) throw new NotebookExportError("integrity_failed", "Export asset size does not match.", { details: {
+		expectedSize: expected.size,
+		observedSize: bytes.byteLength
+	} });
+	const actual = await sha256Hex(bytes);
+	if (actual !== expected.sha256) throw new NotebookExportError("integrity_failed", "Export asset SHA-256 does not match.", { details: {
+		expectedSha256: expected.sha256,
+		observedSha256: actual
+	} });
+}
+function validateNativeFile(codec, bytes) {
+	if (codec === "numpy.npy.v1" && !hasBytes(bytes, NPY_MAGIC, 0)) throw new NotebookExportError("decode_failed", "NumPy asset has an invalid NPY header.");
+	if (codec === "apache.arrow.file.v1" && !isArrowFile(bytes) && !isArrowStream(bytes)) throw new NotebookExportError("decode_failed", "Arrow asset has invalid IPC framing.");
+}
+function isArrowFile(bytes) {
+	return bytes.byteLength >= 16 && hasBytes(bytes, ARROW_MAGIC, 0) && hasBytes(bytes, ARROW_MAGIC, bytes.byteLength - ARROW_MAGIC.byteLength);
+}
+function isArrowStream(bytes) {
+	return bytes.byteLength >= 16 && hasBytes(bytes, ARROW_CONTINUATION, 0) && hasBytes(bytes, ARROW_STREAM_END, bytes.byteLength - ARROW_STREAM_END.byteLength);
+}
+function hasBytes(value, expected, offset) {
+	if (offset < 0 || offset + expected.byteLength > value.byteLength) return false;
+	return expected.every((byte, index) => value[offset + index] === byte);
+}
+//#endregion
+//#region src/transport.ts
+const MAX_DIAGNOSTIC_PATH = 256;
+function normalizeBase(base) {
+	let url;
+	if (base instanceof URL) url = new URL(base.href);
+	else {
+		const documentBase = globalThis.document?.baseURI;
+		if (documentBase === void 0) try {
+			url = new URL(base);
+		} catch (error) {
+			throw new TypeError("A string export base must be absolute outside a document.", { cause: error });
+		}
+		else url = new URL(base, documentBase);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new TypeError("Export base URL must use HTTP or HTTPS.");
+	if (url.username !== "" || url.password !== "") throw new TypeError("Export base URL must not contain user information.");
+	if (url.hash !== "") throw new TypeError("Export base URL must not contain a fragment.");
+	if (!url.pathname.endsWith("/")) url.pathname += "/";
+	return url;
+}
+function resolveExportUrl(base, path) {
+	if (path.length === 0 || path.includes("?") || path.includes("#")) throw new TypeError("Export object path must be a non-empty path without a query or fragment.");
+	const normalized = base instanceof URL ? base : new URL(base);
+	const url = new URL(path, normalized);
+	url.search = normalized.search;
+	return url;
+}
+async function fetchBytes(fetcher, url, path, options) {
+	throwIfAborted$1(options.signal);
+	let response;
+	try {
+		const request = {};
+		if (options.cache !== void 0) request.cache = options.cache;
+		if (options.signal !== void 0) request.signal = options.signal;
+		response = await fetcher(url, request);
+	} catch (error) {
+		throwReadError(error, options.signal, path);
+	}
+	if (!response.ok) {
+		cancelBody(response, /* @__PURE__ */ new Error("Unsuccessful response"));
+		throw new NotebookExportError("read_failed", `Export file ${quotePath(path)} was not found.`, { details: {
+			path: boundedPath(path),
+			status: response.status
+		} });
+	}
+	const declared = decodedContentLength(response);
+	if (declared !== void 0) {
+		if (declared > options.maxBytes) {
+			cancelBody(response, /* @__PURE__ */ new Error("Response exceeds byte limit"));
+			throw limitError(path, options.maxBytes, declared);
+		}
+		if (options.expectedBytes !== void 0 && declared !== options.expectedBytes) {
+			cancelBody(response, /* @__PURE__ */ new Error("Response size differs from descriptor"));
+			throw new NotebookExportError("integrity_failed", `Export file ${quotePath(path)} has an unexpected declared size.`, { details: {
+				path: boundedPath(path),
+				expectedSize: options.expectedBytes,
+				observedSize: declared
+			} });
+		}
+	}
+	try {
+		const bytes = await readBody(response, path, options.maxBytes, options.signal);
+		if (options.expectedBytes !== void 0 && bytes.byteLength !== options.expectedBytes) throw new NotebookExportError("integrity_failed", `Export file ${quotePath(path)} has an unexpected size.`, { details: {
+			path: boundedPath(path),
+			expectedSize: options.expectedBytes,
+			observedSize: bytes.byteLength
+		} });
+		return bytes;
+	} catch (error) {
+		if (isNotebookExportError(error)) throw error;
+		throwReadError(error, options.signal, path);
+	}
+}
+async function readBody(response, path, maxBytes, signal) {
+	if (response.body === null) throw new NotebookExportError("read_failed", `Export file ${quotePath(path)} has no readable response body.`, { details: { path: boundedPath(path) } });
+	const reader = response.body.getReader();
+	let buffer = new Uint8Array(Math.min(65536, maxBytes));
+	let size = 0;
+	let pendingRead;
+	let deferredRelease = false;
+	try {
+		while (true) {
+			throwIfAborted$1(signal);
+			pendingRead = reader.read();
+			const next = await waitForRead(pendingRead, reader, signal);
+			pendingRead = void 0;
+			if (next.done) break;
+			const chunk = next.value;
+			if (chunk.byteLength > maxBytes - size) throw limitError(path, maxBytes, size + chunk.byteLength);
+			const required = size + chunk.byteLength;
+			if (required > buffer.byteLength) {
+				let capacity = Math.max(buffer.byteLength, 1);
+				while (capacity < required) capacity = Math.min(maxBytes, Math.max(required, capacity * 2));
+				const grown = new Uint8Array(capacity);
+				grown.set(buffer);
+				buffer = grown;
+			}
+			buffer.set(chunk, size);
+			size = required;
+		}
+	} catch (error) {
+		reader.cancel(error).catch(() => void 0);
+		if (pendingRead !== void 0) {
+			deferredRelease = true;
+			pendingRead.finally(() => {
+				reader.releaseLock();
+			}).catch(() => void 0);
+		}
+		throw error;
+	} finally {
+		if (!deferredRelease) reader.releaseLock();
+	}
+	throwIfAborted$1(signal);
+	return buffer.slice(0, size);
+}
+async function waitForRead(read, reader, signal) {
+	if (signal === void 0) return read;
+	throwIfAborted$1(signal);
+	let abort;
+	const aborted = new Promise((_resolve, reject) => {
+		abort = () => {
+			const error = new NotebookExportError("abort", "Export operation was aborted.", { cause: signal.reason });
+			reader.cancel(signal.reason).catch(() => void 0);
+			reject(error);
+		};
+		signal.addEventListener("abort", abort, { once: true });
+	});
+	try {
+		return await Promise.race([read, aborted]);
+	} finally {
+		if (abort !== void 0) signal.removeEventListener("abort", abort);
+	}
+}
+function decodedContentLength(response) {
+	const encoding = response.headers.get("Content-Encoding");
+	if (encoding !== null && encoding.trim().toLowerCase() !== "identity") return void 0;
+	const header = response.headers.get("Content-Length");
+	if (header === null || !/^\d+$/u.test(header)) return void 0;
+	const value = Number(header);
+	return Number.isSafeInteger(value) ? value : void 0;
+}
+function limitError(path, maxBytes, observed) {
+	return new NotebookExportError("read_limit_exceeded", `Export file ${quotePath(path)} exceeds its byte limit.`, { details: {
+		path: boundedPath(path),
+		maxBytes,
+		observedBytes: observed
+	} });
+}
+function throwIfAborted$1(signal) {
+	if (signal?.aborted) throw new NotebookExportError("abort", "Export operation was aborted.", { cause: signal.reason });
+}
+function throwReadError(cause, signal, path) {
+	if (signal?.aborted || isAbortError(cause)) throw new NotebookExportError("abort", "Export operation was aborted.", { cause });
+	throw new NotebookExportError("read_failed", `Failed to read export object ${quotePath(path)}.`, {
+		cause,
+		details: { path: boundedPath(path) }
+	});
+}
+function cancelBody(response, cause) {
+	if (response.body !== null) response.body.cancel(cause).catch(() => void 0);
+}
+function boundedPath(path) {
+	return path.length <= MAX_DIAGNOSTIC_PATH ? path : `${path.slice(0, 253)}...`;
+}
+function quotePath(path) {
+	return JSON.stringify(boundedPath(path));
+}
+//#endregion
+//#region src/export.ts
+const INDEX_MAX_BYTES = 16777216;
+const INDEX_MAX_VALUES = 2e6;
+const DEFAULT_ASSET_MAX_BYTES = 536870912;
+const HARD_ASSET_MAX_BYTES = 2147483647;
+const DEFAULT_VERIFY_MAX_BYTES = 2147483648;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+async function openExport(base, options = {}) {
+	throwIfAborted(options.signal);
+	const normalized = normalizeBase(base);
+	const fetcher = options.fetch ?? globalThis.fetch;
+	if (!isCallableValue(fetcher)) throw new TypeError("A fetch implementation is required.");
+	const bytes = await fetchBytes(fetcher, resolveExportUrl(normalized, "index.json"), "index.json", assetReadOptions(INDEX_MAX_BYTES, options.signal));
+	const wire = decodeCanonicalIndex(bytes);
+	const parsed = parseExportIndex(wire);
+	const identity = await sha256Hex(bytes);
+	await validateFingerprints(parsed, options.signal);
+	return new NotebookExportValue(normalized, identity, parsed, fetcher);
+}
+function decodeCanonicalIndex(bytes) {
+	let value;
+	try {
+		value = parseStrictJson(decoder.decode(bytes), INDEX_MAX_VALUES);
+	} catch (error) {
+		throw new NotebookExportError("export_invalid", "Export index must be strict UTF-8 JSON.", { cause: error });
+	}
+	let canonical;
+	try {
+		canonical = encoder.encode(canonicalJson(value));
+	} catch (error) {
+		if (isNotebookExportError(error)) throw error;
+		throw new NotebookExportError("export_invalid", "Export index JSON is invalid.", { cause: error });
+	}
+	if (!equalBytes(bytes, canonical)) throw new NotebookExportError("export_noncanonical", "Export index is not canonical JSON.");
+	return value;
+}
+async function validateFingerprints(index, signal) {
+	for (const [fingerprint, state] of Object.entries(index.states)) {
+		throwIfAborted(signal);
+		const actual = await sha256Hex(encoder.encode(canonicalJson(state.inputs)));
+		throwIfAborted(signal);
+		if (actual !== fingerprint) throw new NotebookExportError("export_invalid", `State fingerprint ${fingerprint} does not match its inputs.`, { details: { fingerprint } });
+	}
+}
+var NotebookExportValue = class {
+	#baseHref;
+	identity;
+	specSha256;
+	defaultState;
+	notebook;
+	producer;
+	inputNames;
+	controlBindings;
+	outputNames;
+	#states;
+	#statesByAlias;
+	#statesByInputs;
+	#reader;
+	constructor(base, identity, index, fetcher) {
+		this.#baseHref = base.href;
+		this.identity = identity;
+		this.specSha256 = index.specSha256;
+		this.notebook = index.notebook;
+		this.producer = index.producer;
+		this.inputNames = index.inputs;
+		this.controlBindings = index.controlBindings;
+		this.outputNames = index.outputs;
+		this.#reader = new AssetReader(this.#baseHref, fetcher);
+		const aliasesByFingerprint = new Map(Object.keys(index.states).map((fingerprint) => [fingerprint, []]));
+		for (const [alias, fingerprint] of Object.entries(index.aliases).sort(([left], [right]) => compareUnicodeScalarStrings(left, right))) aliasesByFingerprint.get(fingerprint).push(alias);
+		this.#states = Object.freeze(Object.entries(index.states).sort(([left], [right]) => compareUnicodeScalarStrings(left, right)).map(([fingerprint, state]) => new ExportStateValue(this, fingerprint, Object.freeze(aliasesByFingerprint.get(fingerprint)), state, this.#reader)));
+		const statesByFingerprint = new Map(this.#states.map((state) => [state.fingerprint, state]));
+		this.defaultState = statesByFingerprint.get(index.defaultState);
+		this.#statesByAlias = new Map(Object.entries(index.aliases).map(([alias, fingerprint]) => [alias, statesByFingerprint.get(fingerprint)]));
+		this.#statesByInputs = new Map(this.#states.map((state) => [canonicalJson(state.inputs), state]));
+		Object.freeze(this);
+	}
+	get base() {
+		return new URL(this.#baseHref);
+	}
+	states() {
+		return this.#states;
+	}
+	state(alias) {
+		const state = this.#statesByAlias.get(alias);
+		if (state === void 0) throw new NotebookExportError("state_not_found", `State alias ${JSON.stringify(alias)} was not found.`, { details: {
+			requested: String(alias).slice(0, 255),
+			available: [...this.#statesByAlias.keys()].slice(0, 16)
+		} });
+		return state;
+	}
+	resolve(inputs) {
+		const normalized = normalizeResolutionObject(inputs, "inputs");
+		requireCompleteInputs(normalized, this.inputNames);
+		return this.resolveNormalized(normalized);
+	}
+	resolveNormalized(inputs) {
+		const state = this.#statesByInputs.get(canonicalJson(inputs));
+		if (state === void 0) throw new NotebookExportError("state_unavailable", "The requested input vector is absent from this export.", { details: { fingerprint: "unavailable" } });
+		return state;
+	}
+	async verify(options = {}) {
+		const maxBytes = assetLimit(options.maxBytes);
+		const maxTotalBytes = totalLimit(options.maxTotalBytes);
+		const assets = uniqueAssets(this.#states);
+		const total = assets.reduce((sum, item) => sum + item.descriptor.asset.size, 0);
+		if (total > maxTotalBytes) throw new NotebookExportError("read_limit_exceeded", "Export assets exceed the verification byte limit.", { details: {
+			declaredBytes: total,
+			maxTotalBytes
+		} });
+		for (const item of assets) {
+			throwIfAborted(options.signal);
+			await this.#reader.payload(item.descriptor, assetReadOptions(maxBytes, options.signal));
+		}
+		return Object.freeze({
+			states: this.#states.length,
+			outputs: this.#states.length * this.outputNames.length,
+			assets: assets.length,
+			bytesVerified: total
+		});
+	}
+};
+var ExportStateValue = class {
+	notebookExport;
+	fingerprint;
+	aliases;
+	inputs;
+	#outputs;
+	#outputsByName;
+	constructor(notebookExport, fingerprint, aliases, state, reader) {
+		this.notebookExport = notebookExport;
+		this.fingerprint = fingerprint;
+		this.aliases = aliases;
+		this.inputs = state.inputs;
+		this.#outputs = Object.freeze(notebookExport.outputNames.map((outputName) => new ExportOutputValue(this, outputName, state.outputs[outputName], reader)));
+		this.#outputsByName = new Map(this.#outputs.map((output) => [output.name, output]));
+		Object.freeze(this);
+	}
+	outputs() {
+		return this.#outputs;
+	}
+	output(name) {
+		const output = this.#outputsByName.get(name);
+		if (output === void 0) throw new NotebookExportError("output_not_found", `Output ${JSON.stringify(name)} was not found.`, { details: {
+			requested: String(name).slice(0, 255),
+			available: this.#outputs.slice(0, 16).map((item) => item.name)
+		} });
+		return output;
+	}
+	resolve(patch) {
+		const normalized = normalizeResolutionObject(patch, "patch");
+		const keys = Object.keys(normalized);
+		if (keys.length === 0) return this;
+		const allowed = new Set(this.notebookExport.inputNames);
+		if (keys.some((key) => !allowed.has(key))) throw new NotebookExportError("state_input_invalid", "State patch contains an unknown input name.", { details: { keys: keys.slice(0, 16) } });
+		const merged = Object.freeze(Object.fromEntries(this.notebookExport.inputNames.map((name) => [name, Object.hasOwn(normalized, name) ? normalized[name] : this.inputs[name]])));
+		return this.notebookExport.resolveNormalized(merged);
+	}
+};
+var ExportOutputValue = class {
+	state;
+	name;
+	codec;
+	mediaType;
+	descriptor;
+	#reader;
+	constructor(state, name, descriptor, reader) {
+		this.state = state;
+		this.name = name;
+		this.codec = descriptor.codec;
+		this.mediaType = parseMediaType(descriptor.mediaType);
+		this.descriptor = descriptor;
+		this.#reader = reader;
+		Object.freeze(this);
+	}
+	async load(loader, options = {}) {
+		const selected = resolveOutputLoader(this, [anyOutputLoader(loader)]);
+		const payload = await this.#reader.payload(this.descriptor, assetReadOptions(assetLimit(options.maxBytes), options.signal));
+		throwIfAborted(options.signal);
+		const call = selectedLoader(selected);
+		try {
+			const input = {
+				descriptor: this.descriptor,
+				mediaType: this.mediaType,
+				payload
+			};
+			if (options.signal !== void 0) input.signal = options.signal;
+			return await waitForLoader(Promise.resolve(call.load(input)), options.signal);
+		} catch (error) {
+			throwLoaderError(error, options.signal, this);
+		}
+	}
+};
+var AssetReader = class {
+	#baseHref;
+	#fetch;
+	constructor(baseHref, fetcher) {
+		this.#baseHref = baseHref;
+		this.#fetch = fetcher;
+	}
+	async payload(descriptor, options) {
+		throwIfAborted(options.signal);
+		if (descriptor.codec === "marimo.scalar.v1") return descriptor.value;
+		if (descriptor.codec === "marimo.json.v1") return descriptor.value;
+		if (descriptor.asset.size > options.maxBytes) throw new NotebookExportError("read_limit_exceeded", "Export asset exceeds the caller byte limit.", { details: {
+			declaredBytes: descriptor.asset.size,
+			maxBytes: options.maxBytes
+		} });
+		const path = assetPath(descriptor.codec, descriptor.asset.sha256);
+		const fetchOptions = {
+			cache: "force-cache",
+			maxBytes: options.maxBytes,
+			expectedBytes: descriptor.asset.size
+		};
+		if (options.signal !== void 0) fetchOptions.signal = options.signal;
+		const bytes = await fetchBytes(this.#fetch, resolveExportUrl(this.#baseHref, path), path, fetchOptions);
+		throwIfAborted(options.signal);
+		await verifyBytes(bytes, descriptor.asset);
+		throwIfAborted(options.signal);
+		validateNativeFile(descriptor.codec, bytes);
+		if (descriptor.codec === "marimo.blob-asset.msgpack.v1") return decodeBlobAsset(bytes, descriptor);
+		return bytes;
+	}
+};
+function assetPath(codec, digest) {
+	return `assets/${digest}.${(() => {
+		if (codec === "marimo.output.v1") return "output.json";
+		if (codec === "marimo.cell.v1") return "cell.json";
+		if (codec === "numpy.npy.v1") return "npy";
+		if (codec === "apache.arrow.file.v1") return "arrow";
+		return "bin";
+	})()}`;
+}
+function uniqueAssets(states) {
+	const values = /* @__PURE__ */ new Map();
+	for (const state of states) for (const output of state.outputs()) {
+		if (output.descriptor.codec === "marimo.scalar.v1" || output.descriptor.codec === "marimo.json.v1") continue;
+		const descriptor = output.descriptor;
+		values.set(`${descriptor.codec}\0${descriptor.asset.sha256}`, { descriptor });
+	}
+	return Object.freeze([...values.values()]);
+}
+function normalizeResolutionObject(input, label) {
+	try {
+		return portableJsonObject(input, label);
+	} catch (error) {
+		throw new NotebookExportError("state_input_invalid", `State ${label} is invalid.`, { cause: error });
+	}
+}
+function requireCompleteInputs(inputs, names) {
+	const expected = new Set(names);
+	const keys = Object.keys(inputs);
+	if (keys.length !== names.length || keys.some((key) => !expected.has(key)) || names.some((name) => !Object.hasOwn(inputs, name))) throw new NotebookExportError("state_input_invalid", "State inputs must equal the export input name set.", { details: {
+		expected: names.slice(0, 16),
+		actual: keys.slice(0, 16)
+	} });
+}
+function assetLimit(value) {
+	if (value === void 0) return DEFAULT_ASSET_MAX_BYTES;
+	if (!Number.isSafeInteger(value) || value <= 0 || value > HARD_ASSET_MAX_BYTES) throw new TypeError(`maxBytes must be an integer from 1 through ${HARD_ASSET_MAX_BYTES}.`);
+	return value;
+}
+function totalLimit(value) {
+	if (value === void 0) return DEFAULT_VERIFY_MAX_BYTES;
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("maxTotalBytes must be a non-negative safe integer.");
+	return value;
+}
+async function waitForLoader(promise, signal) {
+	if (signal === void 0) return promise;
+	throwIfAborted(signal);
+	let abort;
+	const aborted = new Promise((_resolve, reject) => {
+		abort = () => reject(new NotebookExportError("abort", "Export output loading was aborted.", { cause: signal.reason }));
+		signal.addEventListener("abort", abort, { once: true });
+	});
+	try {
+		return await Promise.race([promise, aborted]);
+	} finally {
+		if (abort !== void 0) signal.removeEventListener("abort", abort);
+	}
+}
+function throwLoaderError(cause, signal, output) {
+	if (isNotebookExportError(cause)) throw cause;
+	if (signal?.aborted || isAbortError(cause)) throw new NotebookExportError("abort", "Export output loading was aborted.", { cause: signal?.aborted ? signal.reason : cause });
+	throw new NotebookExportError("decode_failed", "OutputLoader decoding failed.", {
+		cause,
+		details: {
+			output: output.name,
+			codec: output.codec,
+			mediaType: output.mediaType.raw
+		}
+	});
+}
+function assetReadOptions(maxBytes, signal) {
+	const options = { maxBytes };
+	if (signal !== void 0) options.signal = signal;
+	return options;
+}
+function selectedLoader(loader) {
+	return loader;
+}
+function anyOutputLoader(loader) {
+	return loader;
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new NotebookExportError("abort", "Export operation was aborted.", { cause: signal.reason });
+}
+function equalBytes(left, right) {
+	return left.byteLength === right.byteLength && left.every((byte, index) => byte === right[index]);
+}
+//#endregion
+export { normalizeBase as n, openExport as t };