@trylimbo/sdk-plugin-mxf 0.1.0-canary.100

package/gen/ffi/index.js

@@ -0,0 +1,2686 @@
+import { a as __toESM, i as __require, n as __esmMin, r as __exportAll, t as __commonJSMin } from "./rolldown-runtime.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region ../../../../../node_modules/tsdown/esm-shims.js
+var getFilename, getDirname, __dirname;
+var init_esm_shims = __esmMin((() => {
+	getFilename = () => fileURLToPath(import.meta.url);
+	getDirname = () => path.dirname(getFilename());
+	__dirname = /* @__PURE__ */ getDirname();
+}));
+//#endregion
+//#region ../../../../../node_modules/@ubjs/node/index.js
+var require_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	init_esm_shims();
+	const { existsSync, readFileSync } = __require("fs");
+	const { join: join$1 } = __require("path");
+	const { platform, arch } = process;
+	let nativeBinding = null;
+	let localFileExisted = false;
+	let loadError = null;
+	function isMusl() {
+		if (!process.report || typeof process.report.getReport !== "function") try {
+			const lddPath = __require("child_process").execSync("which ldd").toString().trim();
+			return readFileSync(lddPath, "utf8").includes("musl");
+		} catch (e) {
+			return true;
+		}
+		else {
+			const { glibcVersionRuntime } = process.report.getReport().header;
+			return !glibcVersionRuntime;
+		}
+	}
+	switch (platform) {
+		case "android":
+			switch (arch) {
+				case "arm64":
+					localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.android-arm64.node"));
+					try {
+						if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.android-arm64.node");
+						else nativeBinding = __require("@ubjs/node-android-arm64");
+					} catch (e) {
+						loadError = e;
+					}
+					break;
+				case "arm":
+					localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.android-arm-eabi.node"));
+					try {
+						if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.android-arm-eabi.node");
+						else nativeBinding = __require("@ubjs/node-android-arm-eabi");
+					} catch (e) {
+						loadError = e;
+					}
+					break;
+				default: throw new Error(`Unsupported architecture on Android ${arch}`);
+			}
+			break;
+		case "win32":
+			switch (arch) {
+				case "x64":
+					localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.win32-x64-msvc.node"));
+					try {
+						if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.win32-x64-msvc.node");
+						else nativeBinding = __require("@ubjs/node-win32-x64-msvc");
+					} catch (e) {
+						loadError = e;
+					}
+					break;
+				case "ia32":
+					localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.win32-ia32-msvc.node"));
+					try {
+						if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.win32-ia32-msvc.node");
+						else nativeBinding = __require("@ubjs/node-win32-ia32-msvc");
+					} catch (e) {
+						loadError = e;
+					}
+					break;
+				case "arm64":
+					localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.win32-arm64-msvc.node"));
+					try {
+						if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.win32-arm64-msvc.node");
+						else nativeBinding = __require("@ubjs/node-win32-arm64-msvc");
+					} catch (e) {
+						loadError = e;
+					}
+					break;
+				default: throw new Error(`Unsupported architecture on Windows: ${arch}`);
+			}
+			break;
+		case "darwin":
+			localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.darwin-universal.node"));
+			try {
+				if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.darwin-universal.node");
+				else nativeBinding = __require("@ubjs/node-darwin-universal");
+				break;
+			} catch {}
+			switch (arch) {
+				case "x64":
+					localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.darwin-x64.node"));
+					try {
+						if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.darwin-x64.node");
+						else nativeBinding = __require("@ubjs/node-darwin-x64");
+					} catch (e) {
+						loadError = e;
+					}
+					break;
+				case "arm64":
+					localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.darwin-arm64.node"));
+					try {
+						if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.darwin-arm64.node");
+						else nativeBinding = __require("@ubjs/node-darwin-arm64");
+					} catch (e) {
+						loadError = e;
+					}
+					break;
+				default: throw new Error(`Unsupported architecture on macOS: ${arch}`);
+			}
+			break;
+		case "freebsd":
+			if (arch !== "x64") throw new Error(`Unsupported architecture on FreeBSD: ${arch}`);
+			localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.freebsd-x64.node"));
+			try {
+				if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.freebsd-x64.node");
+				else nativeBinding = __require("@ubjs/node-freebsd-x64");
+			} catch (e) {
+				loadError = e;
+			}
+			break;
+		case "linux":
+			switch (arch) {
+				case "x64":
+					if (isMusl()) {
+						localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.linux-x64-musl.node"));
+						try {
+							if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.linux-x64-musl.node");
+							else nativeBinding = __require("@ubjs/node-linux-x64-musl");
+						} catch (e) {
+							loadError = e;
+						}
+					} else {
+						localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.linux-x64-gnu.node"));
+						try {
+							if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.linux-x64-gnu.node");
+							else nativeBinding = __require("@ubjs/node-linux-x64-gnu");
+						} catch (e) {
+							loadError = e;
+						}
+					}
+					break;
+				case "arm64":
+					if (isMusl()) {
+						localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.linux-arm64-musl.node"));
+						try {
+							if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.linux-arm64-musl.node");
+							else nativeBinding = __require("@ubjs/node-linux-arm64-musl");
+						} catch (e) {
+							loadError = e;
+						}
+					} else {
+						localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.linux-arm64-gnu.node"));
+						try {
+							if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.linux-arm64-gnu.node");
+							else nativeBinding = __require("@ubjs/node-linux-arm64-gnu");
+						} catch (e) {
+							loadError = e;
+						}
+					}
+					break;
+				case "arm":
+					if (isMusl()) {
+						localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.linux-arm-musleabihf.node"));
+						try {
+							if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.linux-arm-musleabihf.node");
+							else nativeBinding = __require("@ubjs/node-linux-arm-musleabihf");
+						} catch (e) {
+							loadError = e;
+						}
+					} else {
+						localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.linux-arm-gnueabihf.node"));
+						try {
+							if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.linux-arm-gnueabihf.node");
+							else nativeBinding = __require("@ubjs/node-linux-arm-gnueabihf");
+						} catch (e) {
+							loadError = e;
+						}
+					}
+					break;
+				case "riscv64":
+					if (isMusl()) {
+						localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.linux-riscv64-musl.node"));
+						try {
+							if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.linux-riscv64-musl.node");
+							else nativeBinding = __require("@ubjs/node-linux-riscv64-musl");
+						} catch (e) {
+							loadError = e;
+						}
+					} else {
+						localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.linux-riscv64-gnu.node"));
+						try {
+							if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.linux-riscv64-gnu.node");
+							else nativeBinding = __require("@ubjs/node-linux-riscv64-gnu");
+						} catch (e) {
+							loadError = e;
+						}
+					}
+					break;
+				case "s390x":
+					localFileExisted = existsSync(join$1(__dirname, "uniffi-runtime-napi.linux-s390x-gnu.node"));
+					try {
+						if (localFileExisted) nativeBinding = __require("./uniffi-runtime-napi.linux-s390x-gnu.node");
+						else nativeBinding = __require("@ubjs/node-linux-s390x-gnu");
+					} catch (e) {
+						loadError = e;
+					}
+					break;
+				default: throw new Error(`Unsupported architecture on Linux: ${arch}`);
+			}
+			break;
+		default: throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
+	}
+	if (!nativeBinding) {
+		if (loadError) throw loadError;
+		throw new Error(`Failed to load native binding`);
+	}
+	const { UniffiNativeModule } = nativeBinding;
+	module.exports.UniffiNativeModule = UniffiNativeModule;
+}));
+//#endregion
+//#region ../../../../../node_modules/@ubjs/node/typescript/dist/resolve-lib.js
+var require_resolve_lib = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ResolveLibPathError = void 0;
+	exports.detectTripleForTesting = detectTripleForTesting;
+	exports.resolveLibPath = resolveLibPath;
+	exports.setDetectTripleForTesting = setDetectTripleForTesting;
+	const node_fs_1 = __require("node:fs");
+	const node_module_1 = __require("node:module");
+	const node_path_1 = __require("node:path");
+	const node_url_1 = __require("node:url");
+	function detectNodeTriple(proc) {
+		const { platform, arch } = proc;
+		if (platform === "darwin" && arch === "arm64") return "darwin-arm64";
+		if (platform === "darwin" && arch === "x64") return "darwin-x64";
+		if (platform === "linux" && (arch === "x64" || arch === "arm64")) return `linux-${arch}-${proc.report?.getReport()?.header?.glibcVersionRuntime !== void 0 ? "gnu" : "musl"}`;
+		if (platform === "win32" && (arch === "x64" || arch === "arm64")) return `win32-${arch}-msvc`;
+		throw new Error(`Unsupported platform/arch combination: ${platform}/${arch}. Supported: darwin-{arm64,x64}, linux-{x64,arm64}-{gnu,musl}, win32-{x64,arm64}-msvc.`);
+	}
+	function detectCargoTriple(proc) {
+		const { platform, arch } = proc;
+		const llvmArch = {
+			arm64: "aarch64",
+			x64: "x86_64"
+		}[arch];
+		if (llvmArch === void 0) throw new Error(`Unsupported platform/arch combination: ${platform}/${arch}. Supported arches: arm64, x64.`);
+		if (platform === "darwin") return `${llvmArch}-apple-darwin`;
+		if (platform === "linux") return `${llvmArch}-unknown-linux-${proc.report?.getReport()?.header?.glibcVersionRuntime !== void 0 ? "gnu" : "musl"}`;
+		if (platform === "win32") return `${llvmArch}-pc-windows-msvc`;
+		throw new Error(`Unsupported platform/arch combination: ${platform}/${arch}. Supported: darwin, linux, win32.`);
+	}
+	function detectTriple(proc, style) {
+		return style === "node" ? detectNodeTriple(proc) : detectCargoTriple(proc);
+	}
+	/** Test-only export. Do not use from production code. */
+	function detectTripleForTesting(proc, style = "cargo") {
+		return detectTriple(proc, style);
+	}
+	var ResolveLibPathError = class extends Error {
+		mode;
+		crateName;
+		attempted;
+		cause;
+		constructor(args) {
+			super(args.message);
+			this.name = "ResolveLibPathError";
+			this.mode = args.mode;
+			this.crateName = args.crateName;
+			this.attempted = args.attempted;
+			if (args.cause !== void 0) this.cause = args.cause;
+		}
+	};
+	exports.ResolveLibPathError = ResolveLibPathError;
+	function callerDir(callerUrl) {
+		const path = callerUrl.startsWith("file://") ? (0, node_url_1.fileURLToPath)(callerUrl) : callerUrl;
+		return (0, node_path_1.dirname)(path);
+	}
+	function libFileName(crateName, platform) {
+		if (platform === "win32") return `${crateName}.dll`;
+		return `lib${crateName}.${platform === "darwin" ? "dylib" : "so"}`;
+	}
+	function resolveLibPath(opts) {
+		if ("override" in opts && opts.override !== void 0) return resolveOverride(opts.crateName, opts.override);
+		if ("npmPackageBase" in opts && opts.npmPackageBase !== void 0) return resolveNpmPackage(opts.crateName, opts.callerUrl, opts.npmPackageBase, opts.tripleStyle ?? "cargo");
+		return resolveColocated(opts.crateName, opts.callerUrl);
+	}
+	function resolveColocated(crateName, callerUrl) {
+		const candidate = (0, node_path_1.join)(callerDir(callerUrl), libFileName(crateName, process.platform));
+		if (!(0, node_fs_1.existsSync)(candidate)) throw new ResolveLibPathError({
+			message: `Could not find lib for crate "${crateName}" colocated with caller. Looked for: ${candidate}.`,
+			mode: "colocated",
+			crateName,
+			attempted: [candidate]
+		});
+		return candidate;
+	}
+	function resolveOverride(crateName, path) {
+		if (!(0, node_path_1.isAbsolute)(path)) throw new ResolveLibPathError({
+			message: `Override path must be absolute; got "${path}".`,
+			mode: "override",
+			crateName,
+			attempted: [path]
+		});
+		if (!(0, node_fs_1.existsSync)(path)) throw new ResolveLibPathError({
+			message: `Override path "${path}" for crate "${crateName}" does not exist.`,
+			mode: "override",
+			crateName,
+			attempted: [path]
+		});
+		return path;
+	}
+	let _detectTripleImpl = (style) => detectTriple(process, style);
+	/** Test-only seam to override triple detection. Returns the previous impl. */
+	function setDetectTripleForTesting(fn) {
+		const prev = _detectTripleImpl;
+		_detectTripleImpl = fn;
+		return prev;
+	}
+	function resolveNpmPackage(crateName, callerUrl, npmPackageBase, tripleStyle) {
+		const triple = _detectTripleImpl(tripleStyle);
+		const pkgName = `${npmPackageBase}${triple}`;
+		const require_ = (0, node_module_1.createRequire)(callerUrl);
+		let pkgJsonPath;
+		try {
+			pkgJsonPath = require_.resolve(`${pkgName}/package.json`);
+		} catch (cause) {
+			throw new ResolveLibPathError({
+				message: `Could not find platform package for crate "${crateName}": tried "${pkgName}". Detected platform: ${triple}. Either the package is not installed (run npm install) or this platform is not in the published matrix.`,
+				mode: "npmPackageBase",
+				crateName,
+				attempted: [pkgName],
+				cause
+			});
+		}
+		const binaryPath = (0, node_path_1.join)((0, node_path_1.dirname)(pkgJsonPath), libFileName(crateName, process.platform));
+		if (!(0, node_fs_1.existsSync)(binaryPath)) throw new ResolveLibPathError({
+			message: `Platform package "${pkgName}" is installed but does not contain "${libFileName(crateName, process.platform)}" — package layout is malformed.`,
+			mode: "npmPackageBase",
+			crateName,
+			attempted: [binaryPath]
+		});
+		return binaryPath;
+	}
+}));
+//#endregion
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/symbols.js
+var import_lib = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { copyFileSync, mkdtempSync, rmSync } = __require("node:fs");
+	const { tmpdir } = __require("node:os");
+	const { basename, dirname, join } = __require("node:path");
+	const { isMainThread, threadId } = __require("node:worker_threads");
+	const native = require_node();
+	const { resolveLibPath, ResolveLibPathError } = require_resolve_lib();
+	function perRealmCopy(source) {
+		const name = `.uniffi-realm-${process.pid}-${threadId}-${basename(source)}`;
+		const candidates = [() => ({ copy: join(dirname(source), name) }), () => {
+			const dir = mkdtempSync(join(tmpdir(), "uniffi-realm-"));
+			return {
+				copy: join(dir, basename(source)),
+				dir
+			};
+		}];
+		const failures = [];
+		for (const candidate of candidates) {
+			let copy;
+			let dir;
+			try {
+				({copy, dir} = candidate());
+				copyFileSync(source, copy);
+			} catch (cause) {
+				failures.push(`${copy ?? "(could not create a directory)"}: ${String(cause)}`);
+				continue;
+			}
+			const settled = copy;
+			const remove = () => {
+				try {
+					rmSync(settled, { force: true });
+				} catch {}
+				if (dir !== void 0) try {
+					rmSync(dir, {
+						recursive: true,
+						force: true
+					});
+				} catch {}
+			};
+			queueMicrotask(remove);
+			process.on("exit", remove);
+			return settled;
+		}
+		throw new Error(`uniffi: a worker thread needs its own copy of ${source}, and nowhere was writable.\n` + failures.map((failure) => `  tried ${failure}`).join("\n") + "\nMake the package directory writable or set TMPDIR to an executable writable directory.");
+	}
+	module.exports = {
+		...native,
+		resolveLibPath: isMainThread ? resolveLibPath : (options) => perRealmCopy(resolveLibPath(options)),
+		ResolveLibPathError,
+		FfiType: {
+			UInt8: { tag: "UInt8" },
+			Int8: { tag: "Int8" },
+			UInt16: { tag: "UInt16" },
+			Int16: { tag: "Int16" },
+			UInt32: { tag: "UInt32" },
+			Int32: { tag: "Int32" },
+			UInt64: { tag: "UInt64" },
+			Int64: { tag: "Int64" },
+			Float32: { tag: "Float32" },
+			Float64: { tag: "Float64" },
+			Handle: { tag: "Handle" },
+			RustBuffer: { tag: "RustBuffer" },
+			ForeignBytes: { tag: "ForeignBytes" },
+			RustCallStatus: { tag: "RustCallStatus" },
+			VoidPointer: { tag: "VoidPointer" },
+			Void: { tag: "Void" },
+			Callback: (name) => ({
+				tag: "Callback",
+				name
+			}),
+			Struct: (name) => ({
+				tag: "Struct",
+				name
+			}),
+			Reference: (inner) => ({
+				tag: "Reference",
+				inner
+			}),
+			MutReference: (inner) => ({
+				tag: "MutReference",
+				inner
+			})
+		}
+	};
+})))());
+/**
+* A destructor guard object is created for every
+* `interface` object.
+*
+* It corresponds to the `DestructibleObject` in C++, which
+* uses a C++ destructor to simulate the JS garbage collector.
+*
+* The implementation is in {@link RustArcPtr.h}.
+*/
+const destructorGuardSymbol = Symbol.for("destructor");
+/**
+* The `bigint` pointer corresponding to the Rust memory address
+* of the native peer.
+*/
+const pointerLiteralSymbol = Symbol.for("pointer");
+/**
+* The `string` name of the object, enum or error class.
+*
+* This drives the `instanceOf` method implementations.
+*/
+const uniffiTypeNameSymbol = Symbol.for("typeName");
+//#endregion
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/errors.js
+var UniffiError = class extends Error {
+	constructor(enumTypeName, variantName, message) {
+		super(createErrorMessage(enumTypeName, variantName, message));
+	}
+	static instanceOf(obj) {
+		return obj[uniffiTypeNameSymbol] !== void 0 && obj instanceof Error;
+	}
+};
+function createErrorMessage(typeName, variantName, message) {
+	const prefix = `${typeName}.${variantName}`;
+	if (message) return `${prefix}: ${message}`;
+	else return prefix;
+}
+const UniffiInternalError = (() => {
+	class NumberOverflow extends Error {
+		constructor() {
+			super("Cannot convert a large BigInt into a number");
+		}
+	}
+	class DateTimeOverflow extends Error {
+		constructor() {
+			super("Date overflowed passed maximum number of ms passed the epoch");
+		}
+	}
+	class BufferOverflow extends Error {
+		constructor() {
+			super("Reading the requested value would read past the end of the buffer");
+		}
+	}
+	class IncompleteData extends Error {
+		constructor() {
+			super("The buffer still has data after lifting its containing value");
+		}
+	}
+	class AbortError extends Error {
+		constructor() {
+			super("A Rust future was aborted");
+			this.name = "AbortError";
+		}
+	}
+	class UnexpectedEnumCase extends Error {
+		constructor() {
+			super("Raw enum value doesn't match any cases");
+		}
+	}
+	class UnexpectedNullPointer extends Error {
+		constructor() {
+			super("Raw pointer value was null");
+		}
+	}
+	class UnexpectedRustCallStatusCode extends Error {
+		constructor() {
+			super("Unexpected UniffiRustCallStatus code");
+		}
+	}
+	class UnexpectedRustCallError extends Error {
+		constructor() {
+			super("CALL_ERROR but no errorClass specified");
+		}
+	}
+	class UnexpectedStaleHandle extends Error {
+		constructor() {
+			super("The object is no longer in the handle map, likely because of a hot-reload");
+		}
+	}
+	class ContractVersionMismatch extends Error {
+		constructor(rustVersion, bindingsVersion) {
+			super(`Incompatible versions of uniffi were used to build the JS (${bindingsVersion}) from the Rust (${rustVersion})`);
+		}
+	}
+	class ApiChecksumMismatch extends Error {
+		constructor(func) {
+			super(`FFI function ${func} has a checksum mismatch; this may signify previously undetected incompatible Uniffi versions`);
+		}
+	}
+	class RustPanic extends Error {
+		constructor(message) {
+			super(message);
+		}
+	}
+	class Unimplemented extends Error {
+		constructor(message) {
+			super(message);
+		}
+	}
+	return {
+		ApiChecksumMismatch,
+		NumberOverflow,
+		DateTimeOverflow,
+		BufferOverflow,
+		ContractVersionMismatch,
+		IncompleteData,
+		AbortError,
+		UnexpectedEnumCase,
+		UnexpectedNullPointer,
+		UnexpectedRustCallStatusCode,
+		UnexpectedRustCallError,
+		UnexpectedStaleHandle,
+		RustPanic,
+		Unimplemented
+	};
+})();
+const emptyStringLifter = (bytes) => "An error occurred decoding a string";
+var UniffiRustCaller = class {
+	statusConstructor;
+	constructor(statusConstructor) {
+		this.statusConstructor = statusConstructor;
+	}
+	rustCall(caller, liftString = emptyStringLifter) {
+		return this.makeRustCall(caller, liftString);
+	}
+	rustCallWithError(errorHandler, caller, liftString = emptyStringLifter) {
+		return this.makeRustCall(caller, liftString, errorHandler);
+	}
+	createCallStatus() {
+		return this.statusConstructor();
+	}
+	createErrorStatus(code, errorBuf) {
+		const status = this.statusConstructor();
+		status.code = code;
+		status.errorBuf = errorBuf;
+		return status;
+	}
+	makeRustCall(caller, liftString, errorHandler) {
+		const callStatus = this.statusConstructor();
+		let returnedVal = caller(callStatus);
+		uniffiCheckCallStatus(callStatus, liftString, errorHandler);
+		return returnedVal;
+	}
+};
+function uniffiCheckCallStatus(callStatus, liftString, errorHandler) {
+	switch (callStatus.code) {
+		case 0: return;
+		case 1: {
+			const errorBuf = callStatus.errorBuf;
+			if (errorBuf) {
+				if (errorHandler) throw errorHandler(errorBuf);
+			}
+			throw new UniffiInternalError.UnexpectedRustCallError();
+		}
+		case 2: {
+			const errorBuf = callStatus.errorBuf;
+			if (errorBuf) {
+				if (errorBuf.byteLength > 0) throw new UniffiInternalError.RustPanic(liftString(errorBuf));
+			}
+			throw new UniffiInternalError.RustPanic("Rust panic");
+		}
+		case 3: throw new UniffiInternalError.AbortError();
+		default: throw new UniffiInternalError.UnexpectedRustCallStatusCode();
+	}
+}
+//#endregion
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/handle-map.js
+const defaultUniffiHandle = BigInt("0");
+var UniffiHandleMap = class {
+	map = /* @__PURE__ */ new Map();
+	currentHandle = BigInt(1);
+	insert(value) {
+		const handle = this.currentHandle;
+		this.map.set(handle, value);
+		this.currentHandle += BigInt(2);
+		return handle;
+	}
+	get(handle) {
+		const obj = this.map.get(handle);
+		if (obj === void 0) throw new UniffiInternalError.UnexpectedStaleHandle();
+		return obj;
+	}
+	/**
+	* Creates a second handle pointing to the same object. Rust calls this (via
+	* `CallbackInterfaceClone`) when it clones an Arc holding a foreign-implemented
+	* trait object, so two Arc references can exist with independent lifetimes.
+	*
+	* This clones the *handle*, not the object itself. Both handles resolve to the
+	* same JS object reference, and removing either handle does not affect the other.
+	*/
+	clone(handle) {
+		const obj = this.map.get(handle);
+		if (obj === void 0) throw new UniffiInternalError.UnexpectedStaleHandle();
+		return this.insert(obj);
+	}
+	remove(handle) {
+		const obj = this.map.get(handle);
+		if (obj !== void 0) this.map.delete(handle);
+		return obj;
+	}
+	has(handle) {
+		return this.map.has(handle);
+	}
+	get size() {
+		return this.map.size;
+	}
+};
+//#endregion
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/async-callbacks.js
+const UNIFFI_FOREIGN_FUTURE_HANDLE_MAP = new UniffiHandleMap();
+function uniffiTraitInterfaceCallAsyncWithError(makeCall, handleSuccess, handleError, isErrorType, lowerError, lowerString, alloc) {
+	const settledHolder = { settled: false };
+	const abortController = new AbortController();
+	const promiseHelper = {
+		abortController,
+		settledHolder,
+		promise: makeCall(abortController.signal).finally(() => settledHolder.settled = true).then(handleSuccess, (error) => {
+			let message = error.message ? error.message : error.toString();
+			if (isErrorType(error)) try {
+				handleError(1, lowerError(error, alloc));
+				return;
+			} catch (e) {
+				message = `Error handling error "${e}", originally: "${message}"`;
+			}
+			handleError(2, lowerString(message, alloc));
+		})
+	};
+	return {
+		handle: UNIFFI_FOREIGN_FUTURE_HANDLE_MAP.insert(promiseHelper),
+		free: uniffiForeignFutureFree
+	};
+}
+function uniffiForeignFutureFree(handle) {
+	const helper = UNIFFI_FOREIGN_FUTURE_HANDLE_MAP.remove(handle);
+	if (helper?.settledHolder.settled === false) helper.abortController.abort();
+}
+//#endregion
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/async-rust-call.js
+const UNIFFI_RUST_FUTURE_POLL_READY = 0;
+/**
+* This method calls an asynchronous method on the Rust side.
+*
+* It manages the impedence mismatch between JS promises and Rust futures.
+*
+* @param rustFutureFunc calls the Rust client side code. Uniffi machinery gives back
+*  a handle to the Rust future.
+* @param pollFunc is then called periodically. This sends a JS callback, and the RustFuture handle
+*  to Rust. In practice, this poll is implemented as a Promise, which the callback resolves.
+* @param cancelFunc is currently unexposed to client code.
+* @param completeFunc once the Rust future polls as complete, the completeFunc is called to get
+*  the result and any errors that were encountered.
+* @param freeFunc is finally called with the Rust future handle to drop the now complete Rust
+*  future.
+*/
+async function uniffiRustCallAsync(rustCaller, rustFutureFunc, pollFunc, cancelFunc, completeFunc, freeFunc, liftFunc, liftString, asyncOpts, errorHandler) {
+	if (asyncOpts?.signal.aborted === true) return Promise.reject(new UniffiInternalError.AbortError());
+	const rustFuture = rustFutureFunc();
+	const abortFunc = createAbortFunction(rustFuture, cancelFunc);
+	asyncOpts?.signal.addEventListener("abort", abortFunc);
+	const keepAlive = typeof setTimeout === "function" ? setTimeout(() => {}, 2147483647) : void 0;
+	try {
+		let pollResult;
+		do
+			pollResult = await pollRust((handle) => {
+				pollFunc(rustFuture, uniffiFutureContinuationCallback, handle);
+			});
+		while (pollResult !== UNIFFI_RUST_FUTURE_POLL_READY);
+		return liftFunc(rustCaller.makeRustCall((status) => completeFunc(rustFuture, status), liftString, errorHandler));
+	} finally {
+		if (keepAlive !== void 0) clearTimeout(keepAlive);
+		asyncOpts?.signal.removeEventListener("abort", abortFunc);
+		freeFunc(rustFuture);
+	}
+}
+const UNIFFI_RUST_FUTURE_RESOLVER_MAP = new UniffiHandleMap();
+async function pollRust(pollFunc) {
+	return new Promise((resolve) => {
+		pollFunc(UNIFFI_RUST_FUTURE_RESOLVER_MAP.insert(resolve));
+	});
+}
+function createAbortFunction(rustFuture, cancelFunc) {
+	return () => cancelFunc(rustFuture);
+}
+const uniffiFutureContinuationCallback = (handle, pollResult) => {
+	const resolve = UNIFFI_RUST_FUTURE_RESOLVER_MAP.remove(handle);
+	if (resolve) resolve(pollResult);
+};
+//#endregion
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/cursor.js
+/**
+* Positional reader/writer over an `ArrayBuffer` slice with monomorphic typed
+* accessors. One `DataView` and one `Uint8Array` are built at construction and
+* reused for every primitive operation — no per-read DataView allocation, no
+* function-pointer dispatch.
+*
+* Big-endian on the wire (matches the UniFFI RustBuffer wire format).
+*/
+var Cursor = class Cursor {
+	dv;
+	u8;
+	start;
+	end;
+	pos;
+	constructor(buffer, offset, length) {
+		this.dv = new DataView(buffer, offset, length);
+		this.u8 = new Uint8Array(buffer, offset, length);
+		this.start = offset;
+		this.end = offset + length;
+		this.pos = 0;
+	}
+	static fromUint8Array(view) {
+		return new Cursor(view.buffer, view.byteOffset, view.byteLength);
+	}
+	remaining() {
+		return this.end - this.start - this.pos;
+	}
+	skip(n) {
+		this.boundsCheck(n);
+		this.pos += n;
+	}
+	readU8() {
+		this.boundsCheck(1);
+		const v = this.dv.getUint8(this.pos);
+		this.pos += 1;
+		return v;
+	}
+	readI8() {
+		this.boundsCheck(1);
+		const v = this.dv.getInt8(this.pos);
+		this.pos += 1;
+		return v;
+	}
+	readU16() {
+		this.boundsCheck(2);
+		const v = this.dv.getUint16(this.pos);
+		this.pos += 2;
+		return v;
+	}
+	readI16() {
+		this.boundsCheck(2);
+		const v = this.dv.getInt16(this.pos);
+		this.pos += 2;
+		return v;
+	}
+	readU32() {
+		this.boundsCheck(4);
+		const v = this.dv.getUint32(this.pos);
+		this.pos += 4;
+		return v;
+	}
+	readI32() {
+		this.boundsCheck(4);
+		const v = this.dv.getInt32(this.pos);
+		this.pos += 4;
+		return v;
+	}
+	readU64() {
+		this.boundsCheck(8);
+		const v = this.dv.getBigUint64(this.pos);
+		this.pos += 8;
+		return v;
+	}
+	readI64() {
+		this.boundsCheck(8);
+		const v = this.dv.getBigInt64(this.pos);
+		this.pos += 8;
+		return v;
+	}
+	readF32() {
+		this.boundsCheck(4);
+		const v = this.dv.getFloat32(this.pos);
+		this.pos += 4;
+		return v;
+	}
+	readF64() {
+		this.boundsCheck(8);
+		const v = this.dv.getFloat64(this.pos);
+		this.pos += 8;
+		return v;
+	}
+	readBool() {
+		return this.readU8() !== 0;
+	}
+	writeU8(v) {
+		this.boundsCheck(1);
+		this.dv.setUint8(this.pos, v);
+		this.pos += 1;
+	}
+	writeI8(v) {
+		this.boundsCheck(1);
+		this.dv.setInt8(this.pos, v);
+		this.pos += 1;
+	}
+	writeU16(v) {
+		this.boundsCheck(2);
+		this.dv.setUint16(this.pos, v);
+		this.pos += 2;
+	}
+	writeI16(v) {
+		this.boundsCheck(2);
+		this.dv.setInt16(this.pos, v);
+		this.pos += 2;
+	}
+	writeU32(v) {
+		this.boundsCheck(4);
+		this.dv.setUint32(this.pos, v);
+		this.pos += 4;
+	}
+	writeI32(v) {
+		this.boundsCheck(4);
+		this.dv.setInt32(this.pos, v);
+		this.pos += 4;
+	}
+	writeU64(v) {
+		this.boundsCheck(8);
+		this.dv.setBigUint64(this.pos, v);
+		this.pos += 8;
+	}
+	writeI64(v) {
+		this.boundsCheck(8);
+		this.dv.setBigInt64(this.pos, v);
+		this.pos += 8;
+	}
+	writeF32(v) {
+		this.boundsCheck(4);
+		this.dv.setFloat32(this.pos, v);
+		this.pos += 4;
+	}
+	writeF64(v) {
+		this.boundsCheck(8);
+		this.dv.setFloat64(this.pos, v);
+		this.pos += 8;
+	}
+	writeBool(v) {
+		this.writeU8(v ? 1 : 0);
+	}
+	readBytes(len) {
+		this.boundsCheck(len);
+		const start = this.start + this.pos;
+		const out = new Uint8Array(this.u8.buffer.slice(start, start + len));
+		this.pos += len;
+		return out;
+	}
+	readArrayBuffer(len) {
+		this.boundsCheck(len);
+		const start = this.start + this.pos;
+		const out = this.u8.buffer.slice(start, start + len);
+		this.pos += len;
+		return out;
+	}
+	writeBytes(src) {
+		this.boundsCheck(src.byteLength);
+		this.u8.set(src, this.pos);
+		this.pos += src.byteLength;
+	}
+	boundsCheck(n) {
+		if (this.pos + n > this.end - this.start) throw new UniffiInternalError.BufferOverflow();
+	}
+};
+//#endregion
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/ffi-converters.js
+var AbstractFfiConverterByteArray = class {
+	lift(value) {
+		const c = Cursor.fromUint8Array(value);
+		return this.readFromCursor(c);
+	}
+	lower(value, alloc) {
+		const view = alloc(this.allocationSize(value));
+		const c = Cursor.fromUint8Array(view);
+		this.writeIntoCursor(value, c);
+		return view;
+	}
+};
+/**
+* Build a primitive `FfiConverter` whose hot path delegates straight into
+* Cursor's monomorphic typed accessors. The returned object is a plain
+* module-level value (not a class instance) — V8 can inline `lift`/`lower`
+* trivially, and `readFromCursor`/`writeIntoCursor` are direct references
+* to the Cursor method wrappers (no per-call function-pointer dispatch via
+* the old `FfiConverterNumber(reader, writer, byteSize)` closure shape).
+*/
+function makePrimitive(read, write, byteSize) {
+	return {
+		lift: (v) => v,
+		lower: (v, _alloc) => v,
+		allocationSize: (_v) => byteSize,
+		readFromCursor: read,
+		writeIntoCursor: write
+	};
+}
+const FfiConverterUInt32 = makePrimitive((c) => c.readU32(), (v, c) => c.writeU32(v), 4);
+const FfiConverterUInt64 = makePrimitive((c) => c.readU64(), (v, c) => c.writeU64(v), 8);
+(() => {
+	const msPerSecBigInt = BigInt("1000");
+	const nanosPerMs = 1e6;
+	class FFIConverter extends AbstractFfiConverterByteArray {
+		readFromCursor(c) {
+			const secsBigInt = c.readU64();
+			const nanos = c.readU32();
+			const ms = Number(secsBigInt * msPerSecBigInt);
+			if (ms === Number.POSITIVE_INFINITY || ms === Number.NEGATIVE_INFINITY) throw new UniffiInternalError.NumberOverflow();
+			return ms + nanos / nanosPerMs;
+		}
+		writeIntoCursor(value, c) {
+			const ms = value.valueOf();
+			const secsBigInt = BigInt(Math.trunc(ms)) / msPerSecBigInt;
+			const remainingNanos = ms % 1e3 * nanosPerMs;
+			c.writeU64(secsBigInt);
+			c.writeU32(remainingNanos);
+		}
+		allocationSize(_value) {
+			return 12;
+		}
+	}
+	return new FFIConverter();
+})();
+(() => {
+	const msPerSecBigInt = BigInt("1000");
+	const nanosPerMs = 1e6;
+	const msPerSec = 1e3;
+	function safeDate(ms) {
+		if (Math.abs(ms) > 864e13) throw new UniffiInternalError.DateTimeOverflow();
+		return new Date(ms);
+	}
+	class FFIConverter extends AbstractFfiConverterByteArray {
+		readFromCursor(c) {
+			const secsBigInt = c.readI64();
+			const nanos = c.readU32();
+			const ms = Number(secsBigInt * msPerSecBigInt);
+			if (ms >= 0) return safeDate(ms + nanos / nanosPerMs);
+			else return safeDate(ms - nanos / nanosPerMs);
+		}
+		writeIntoCursor(value, c) {
+			const ms = value.valueOf();
+			const secsBigInt = BigInt(Math.trunc(ms / msPerSec));
+			const remainingNanos = Math.abs(ms % msPerSec * nanosPerMs);
+			c.writeI64(secsBigInt);
+			c.writeU32(remainingNanos);
+		}
+		allocationSize(_value) {
+			return 12;
+		}
+	}
+	return new FFIConverter();
+})();
+var FfiConverterOptional = class extends AbstractFfiConverterByteArray {
+	itemConverter;
+	constructor(itemConverter) {
+		super();
+		this.itemConverter = itemConverter;
+	}
+	readFromCursor(c) {
+		return c.readU8() === 0 ? void 0 : this.itemConverter.readFromCursor(c);
+	}
+	writeIntoCursor(value, c) {
+		if (value === void 0) {
+			c.writeU8(0);
+			return;
+		}
+		c.writeU8(1);
+		this.itemConverter.writeIntoCursor(value, c);
+	}
+	allocationSize(value) {
+		return 1 + (value === void 0 ? 0 : this.itemConverter.allocationSize(value));
+	}
+};
+var FfiConverterArray = class extends AbstractFfiConverterByteArray {
+	itemConverter;
+	constructor(itemConverter) {
+		super();
+		this.itemConverter = itemConverter;
+	}
+	readFromCursor(c) {
+		const size = c.readI32();
+		const array = new Array(size);
+		for (let i = 0; i < size; i++) array[i] = this.itemConverter.readFromCursor(c);
+		return array;
+	}
+	writeIntoCursor(array, c) {
+		c.writeI32(array.length);
+		for (const item of array) this.itemConverter.writeIntoCursor(item, c);
+	}
+	allocationSize(array) {
+		let size = 4;
+		for (const item of array) size += this.itemConverter.allocationSize(item);
+		return size;
+	}
+};
+var FfiConverterMap = class extends AbstractFfiConverterByteArray {
+	keyConverter;
+	valueConverter;
+	constructor(keyConverter, valueConverter) {
+		super();
+		this.keyConverter = keyConverter;
+		this.valueConverter = valueConverter;
+	}
+	readFromCursor(c) {
+		const size = c.readI32();
+		const map = /* @__PURE__ */ new Map();
+		for (let i = 0; i < size; i++) map.set(this.keyConverter.readFromCursor(c), this.valueConverter.readFromCursor(c));
+		return map;
+	}
+	writeIntoCursor(map, c) {
+		c.writeI32(map.size);
+		for (const [k, v] of map.entries()) {
+			this.keyConverter.writeIntoCursor(k, c);
+			this.valueConverter.writeIntoCursor(v, c);
+		}
+	}
+	allocationSize(map) {
+		let size = 4;
+		for (const [k, v] of map.entries()) size += this.keyConverter.allocationSize(k) + this.valueConverter.allocationSize(v);
+		return size;
+	}
+};
+const FfiConverterArrayBuffer = (() => {
+	class FFIConverter extends AbstractFfiConverterByteArray {
+		readFromCursor(c) {
+			const length = c.readI32();
+			return c.readArrayBuffer(length);
+		}
+		writeIntoCursor(value, c) {
+			c.writeI32(value.byteLength);
+			c.writeBytes(new Uint8Array(value));
+		}
+		allocationSize(value) {
+			return 4 + value.byteLength;
+		}
+	}
+	return new FFIConverter();
+})();
+(() => {
+	class FFIConverter extends AbstractFfiConverterByteArray {
+		readFromCursor(c) {
+			const length = c.readI32();
+			return c.readBytes(length);
+		}
+		writeIntoCursor(value, c) {
+			c.writeI32(value.byteLength);
+			c.writeBytes(value);
+		}
+		allocationSize(value) {
+			return 4 + value.byteLength;
+		}
+	}
+	return new FFIConverter();
+})();
+function uniffiCreateFfiConverterString(converter) {
+	class FFIConverter {
+		lift(value) {
+			return converter.bytesToString(value);
+		}
+		lower(value, _alloc) {
+			return converter.stringToBytes(value);
+		}
+		readFromCursor(c) {
+			const length = c.readI32();
+			if (converter.readStringFromBuffer) {
+				const buf = { arrayBuffer: c.u8.buffer };
+				const offset = c.start + c.pos;
+				c.pos += length;
+				return converter.readStringFromBuffer(buf, offset, length);
+			}
+			const bytes = c.readBytes(length);
+			return converter.bytesToString(bytes);
+		}
+		writeIntoCursor(value, c) {
+			if (converter.writeStringIntoBuffer) {
+				const lengthPos = c.pos;
+				c.pos += 4;
+				const dataOffset = c.start + c.pos;
+				const buf = { arrayBuffer: c.u8.buffer };
+				const bytesWritten = converter.writeStringIntoBuffer(value, buf, dataOffset);
+				c.dv.setInt32(lengthPos, bytesWritten);
+				c.pos += bytesWritten;
+				return;
+			}
+			const bytes = converter.stringToBytes(value);
+			c.writeI32(bytes.byteLength);
+			c.writeBytes(bytes);
+		}
+		allocationSize(value) {
+			return 4 + converter.stringByteLength(value);
+		}
+	}
+	return new FFIConverter();
+}
+//#endregion
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/callbacks.js
+const handleConverter = FfiConverterUInt64;
+var FfiConverterCallback = class {
+	handleMap;
+	constructor(handleMap = new UniffiHandleMap()) {
+		this.handleMap = handleMap;
+	}
+	lift(value) {
+		return this.handleMap.get(value);
+	}
+	lower(value, _alloc) {
+		return this.handleMap.insert(value);
+	}
+	readFromCursor(c) {
+		return this.lift(handleConverter.readFromCursor(c));
+	}
+	writeIntoCursor(value, c) {
+		handleConverter.writeIntoCursor(this.handleMap.insert(value), c);
+	}
+	allocationSize(value) {
+		return handleConverter.allocationSize(defaultUniffiHandle);
+	}
+	clone(handle) {
+		return this.handleMap.clone(handle);
+	}
+	drop(handle) {
+		return this.handleMap.remove(handle);
+	}
+};
+//#endregion
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/objects.js
+/**
+* Marker interface for all `interface` objects that cross the FFI.
+* Reminder: `interface` objects have methods written in Rust.
+*
+* This typesscript interface contains the unffi methods that are needed to make
+* the FFI work. It should shrink to zero methods.
+*/
+var UniffiAbstractObject = class {
+	/**
+	* A convenience method to use this object, then destroy it after its use.
+	* @param block
+	* @returns
+	*/
+	uniffiUse(block) {
+		const v = block(this);
+		this.uniffiDestroy();
+		return v;
+	}
+};
+const pointerConverter = FfiConverterUInt64;
+const dummyPointer = BigInt("0");
+/**
+* An FfiConverter for an object.
+*/
+var FfiConverterObject = class {
+	factory;
+	constructor(factory) {
+		this.factory = factory;
+	}
+	lift(value) {
+		return this.factory.create(value);
+	}
+	lower(value, _alloc) {
+		return this.lowerHandle(value);
+	}
+	readFromCursor(c) {
+		return this.lift(pointerConverter.readFromCursor(c));
+	}
+	writeIntoCursor(value, c) {
+		pointerConverter.writeIntoCursor(this.lowerHandle(value), c);
+	}
+	lowerHandle(value) {
+		if (this.factory.isConcreteType(value)) return this.factory.clonePointer(value);
+		else throw new Error("Cannot lower this object to a pointer");
+	}
+	allocationSize(value) {
+		return pointerConverter.allocationSize(dummyPointer);
+	}
+};
+//#endregion
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/records.js
+/**
+* @param defaults function that returns the defaults of the record. This is done as a function rather than a literal so
+* that the defaults are calculated lazily, i.e. after everything has been declared.
+* @returns a function to create a new {T} with a partial that requires at least the missing keys to be present.
+*/
+const uniffiCreateRecord = (defaults) => {
+	return (partial) => Object.freeze({
+		...defaults(),
+		...partial
+	});
+};
+//#endregion
+//#region ../../../../../target/trylimbo/codegen/ffi-trylimbo_plugin_mxf/trylimbo_plugin_mxf-ffi.ts
+const { UniffiNativeModule, FfiType, resolveLibPath } = import_lib.default;
+const DEFINITIONS = {
+	symbols: {
+		rustbuffer_alloc: "ffi_trylimbo_plugin_mxf_rustbuffer_alloc",
+		rustbuffer_free: "ffi_trylimbo_plugin_mxf_rustbuffer_free",
+		rustbuffer_from_bytes: "ffi_trylimbo_plugin_mxf_rustbuffer_from_bytes"
+	},
+	functions: {
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_u8": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_u8": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_u8": {
+			args: [FfiType.Handle],
+			ret: FfiType.UInt8,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_u8": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_i8": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_i8": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_i8": {
+			args: [FfiType.Handle],
+			ret: FfiType.Int8,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_i8": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_u16": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_u16": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_u16": {
+			args: [FfiType.Handle],
+			ret: FfiType.UInt16,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_u16": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_i16": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_i16": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_i16": {
+			args: [FfiType.Handle],
+			ret: FfiType.Int16,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_i16": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_u32": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_u32": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_u32": {
+			args: [FfiType.Handle],
+			ret: FfiType.UInt32,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_u32": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_i32": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_i32": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_i32": {
+			args: [FfiType.Handle],
+			ret: FfiType.Int32,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_i32": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_u64": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_u64": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_u64": {
+			args: [FfiType.Handle],
+			ret: FfiType.Handle,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_u64": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_i64": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_i64": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_i64": {
+			args: [FfiType.Handle],
+			ret: FfiType.Int64,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_i64": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_f32": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_f32": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_f32": {
+			args: [FfiType.Handle],
+			ret: FfiType.Float32,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_f32": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_f64": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_f64": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_f64": {
+			args: [FfiType.Handle],
+			ret: FfiType.Float64,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_f64": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_rust_buffer": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_rust_buffer": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_rust_buffer": {
+			args: [FfiType.Handle],
+			ret: FfiType.RustBuffer,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_rust_buffer": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_poll_void": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("RustFutureContinuationCallback"),
+				FfiType.Handle
+			],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_cancel_void": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_complete_void": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: true
+		},
+		"ffi_trylimbo_plugin_mxf_rust_future_free_void": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_clone_mxfauthor": {
+			args: [FfiType.Handle],
+			ret: FfiType.Handle,
+			hasRustCallStatus: true
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_free_mxfauthor": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: true
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_clone_mxfplugin": {
+			args: [FfiType.Handle],
+			ret: FfiType.Handle,
+			hasRustCallStatus: true
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_free_mxfplugin": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: true
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_init_callback_vtable_rangesink": {
+			args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceTrylimboPluginMxfRangeSink"))],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_init_callback_vtable_rangesource": {
+			args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceTrylimboPluginMxfRangeSource"))],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_constructor_mxfauthor_new": {
+			args: [],
+			ret: FfiType.Handle,
+			hasRustCallStatus: true
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_method_mxfauthor_locate": {
+			args: [FfiType.Handle, FfiType.Handle],
+			ret: FfiType.Handle,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_method_mxfauthor_media_types": {
+			args: [FfiType.Handle],
+			ret: FfiType.RustBuffer,
+			hasRustCallStatus: true
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_method_mxfauthor_reserve_slot": {
+			args: [
+				FfiType.Handle,
+				FfiType.Handle,
+				FfiType.UInt64
+			],
+			ret: FfiType.Handle,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_method_mxfauthor_sniff": {
+			args: [FfiType.Handle, FfiType.Handle],
+			ret: FfiType.Handle,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_constructor_mxfplugin_new": {
+			args: [],
+			ret: FfiType.Handle,
+			hasRustCallStatus: true
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_method_mxfplugin_locate": {
+			args: [FfiType.Handle, FfiType.Handle],
+			ret: FfiType.Handle,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_method_mxfplugin_media_types": {
+			args: [FfiType.Handle],
+			ret: FfiType.RustBuffer,
+			hasRustCallStatus: true
+		},
+		"uniffi_trylimbo_plugin_mxf_fn_method_mxfplugin_sniff": {
+			args: [FfiType.Handle, FfiType.Handle],
+			ret: FfiType.Handle,
+			hasRustCallStatus: false
+		},
+		"ffi_trylimbo_plugin_mxf_uniffi_contract_version": {
+			args: [],
+			ret: FfiType.UInt32,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_checksum_constructor_mxfauthor_new": {
+			args: [],
+			ret: FfiType.UInt16,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_locate": {
+			args: [],
+			ret: FfiType.UInt16,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_media_types": {
+			args: [],
+			ret: FfiType.UInt16,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_reserve_slot": {
+			args: [],
+			ret: FfiType.UInt16,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_sniff": {
+			args: [],
+			ret: FfiType.UInt16,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_checksum_constructor_mxfplugin_new": {
+			args: [],
+			ret: FfiType.UInt16,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_checksum_method_mxfplugin_locate": {
+			args: [],
+			ret: FfiType.UInt16,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_checksum_method_mxfplugin_media_types": {
+			args: [],
+			ret: FfiType.UInt16,
+			hasRustCallStatus: false
+		},
+		"uniffi_trylimbo_plugin_mxf_checksum_method_mxfplugin_sniff": {
+			args: [],
+			ret: FfiType.UInt16,
+			hasRustCallStatus: false
+		}
+	},
+	callbacks: {
+		"RustFutureContinuationCallback": {
+			args: [FfiType.Handle, FfiType.Int8],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ForeignFutureDroppedCallback": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"ForeignFutureCompleteu64": {
+			args: [FfiType.Handle, FfiType.Struct("ForeignFutureResultU64")],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"CallbackInterfaceTrylimboPluginMxfRangeSinkMethod0": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("ForeignFutureCompleteu64"),
+				FfiType.Handle
+			],
+			ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+			hasRustCallStatus: false,
+			outReturn: true
+		},
+		"ForeignFutureCompleterust_buffer": {
+			args: [FfiType.Handle, FfiType.Struct("ForeignFutureResultRustBuffer")],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"CallbackInterfaceTrylimboPluginMxfRangeSinkMethod1": {
+			args: [
+				FfiType.Handle,
+				FfiType.UInt64,
+				FfiType.UInt32,
+				FfiType.Callback("ForeignFutureCompleterust_buffer"),
+				FfiType.Handle
+			],
+			ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+			hasRustCallStatus: false,
+			outReturn: true
+		},
+		"ForeignFutureCompletevoid": {
+			args: [FfiType.Handle, FfiType.Struct("ForeignFutureResultVoid")],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"CallbackInterfaceTrylimboPluginMxfRangeSinkMethod2": {
+			args: [
+				FfiType.Handle,
+				FfiType.UInt64,
+				FfiType.RustBuffer,
+				FfiType.Callback("ForeignFutureCompletevoid"),
+				FfiType.Handle
+			],
+			ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+			hasRustCallStatus: false,
+			outReturn: true
+		},
+		"CallbackInterfaceTrylimboPluginMxfRangeSinkMethod3": {
+			args: [
+				FfiType.Handle,
+				FfiType.UInt64,
+				FfiType.Callback("ForeignFutureCompletevoid"),
+				FfiType.Handle
+			],
+			ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+			hasRustCallStatus: false,
+			outReturn: true
+		},
+		"CallbackInterfaceCloneTrylimboPluginMxf_RangeSink": {
+			args: [FfiType.Handle],
+			ret: FfiType.Handle,
+			hasRustCallStatus: false
+		},
+		"CallbackInterfaceFreeTrylimboPluginMxf_RangeSink": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		},
+		"CallbackInterfaceTrylimboPluginMxfRangeSourceMethod0": {
+			args: [
+				FfiType.Handle,
+				FfiType.Callback("ForeignFutureCompleteu64"),
+				FfiType.Handle
+			],
+			ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+			hasRustCallStatus: false,
+			outReturn: true
+		},
+		"CallbackInterfaceTrylimboPluginMxfRangeSourceMethod1": {
+			args: [
+				FfiType.Handle,
+				FfiType.UInt64,
+				FfiType.UInt32,
+				FfiType.Callback("ForeignFutureCompleterust_buffer"),
+				FfiType.Handle
+			],
+			ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+			hasRustCallStatus: false,
+			outReturn: true
+		},
+		"CallbackInterfaceCloneTrylimboPluginMxf_RangeSource": {
+			args: [FfiType.Handle],
+			ret: FfiType.Handle,
+			hasRustCallStatus: false
+		},
+		"CallbackInterfaceFreeTrylimboPluginMxf_RangeSource": {
+			args: [FfiType.Handle],
+			ret: FfiType.Void,
+			hasRustCallStatus: false
+		}
+	},
+	structs: {
+		"ForeignFutureDroppedCallbackStruct": [{
+			name: "handle",
+			type: FfiType.Handle
+		}, {
+			name: "free",
+			type: FfiType.Callback("ForeignFutureDroppedCallback")
+		}],
+		"ForeignFutureResultU64": [{
+			name: "return_value",
+			type: FfiType.UInt64
+		}, {
+			name: "call_status",
+			type: FfiType.RustCallStatus
+		}],
+		"ForeignFutureResultRustBuffer": [{
+			name: "return_value",
+			type: FfiType.RustBuffer
+		}, {
+			name: "call_status",
+			type: FfiType.RustCallStatus
+		}],
+		"ForeignFutureResultVoid": [{
+			name: "call_status",
+			type: FfiType.RustCallStatus
+		}],
+		"VTableCallbackInterfaceTrylimboPluginMxfRangeSink": [
+			{
+				name: "uniffi_free",
+				type: FfiType.Callback("CallbackInterfaceFreeTrylimboPluginMxf_RangeSink")
+			},
+			{
+				name: "uniffi_clone",
+				type: FfiType.Callback("CallbackInterfaceCloneTrylimboPluginMxf_RangeSink")
+			},
+			{
+				name: "length",
+				type: FfiType.Callback("CallbackInterfaceTrylimboPluginMxfRangeSinkMethod0")
+			},
+			{
+				name: "read_at",
+				type: FfiType.Callback("CallbackInterfaceTrylimboPluginMxfRangeSinkMethod1")
+			},
+			{
+				name: "write_at",
+				type: FfiType.Callback("CallbackInterfaceTrylimboPluginMxfRangeSinkMethod2")
+			},
+			{
+				name: "set_length",
+				type: FfiType.Callback("CallbackInterfaceTrylimboPluginMxfRangeSinkMethod3")
+			}
+		],
+		"VTableCallbackInterfaceTrylimboPluginMxfRangeSource": [
+			{
+				name: "uniffi_free",
+				type: FfiType.Callback("CallbackInterfaceFreeTrylimboPluginMxf_RangeSource")
+			},
+			{
+				name: "uniffi_clone",
+				type: FfiType.Callback("CallbackInterfaceCloneTrylimboPluginMxf_RangeSource")
+			},
+			{
+				name: "length",
+				type: FfiType.Callback("CallbackInterfaceTrylimboPluginMxfRangeSourceMethod0")
+			},
+			{
+				name: "read_at",
+				type: FfiType.Callback("CallbackInterfaceTrylimboPluginMxfRangeSourceMethod1")
+			}
+		]
+	}
+};
+let _nativeModule;
+const getter = () => {
+	if (!_nativeModule) {
+		const libPath = resolveLibPath({
+			crateName: "trylimbo_plugin_mxf",
+			callerUrl: import.meta.url,
+			npmPackageBase: "@trylimbo/sdk-plugin-mxf-",
+			tripleStyle: "node"
+		});
+		_nativeModule = UniffiNativeModule.open(libPath).register(DEFINITIONS);
+	}
+	return _nativeModule;
+};
+//#endregion
+//#region ../../../../../target/trylimbo/codegen/ffi-trylimbo_plugin_mxf/trylimbo_plugin_mxf.ts
+var trylimbo_plugin_mxf_exports = /* @__PURE__ */ __exportAll({
+	Code: () => Code,
+	FieldViolation: () => FieldViolation,
+	MxfAuthor: () => MxfAuthor,
+	MxfPlugin: () => MxfPlugin,
+	Region: () => Region,
+	SdkError: () => SdkError,
+	SdkError_Tags: () => SdkError_Tags,
+	default: () => trylimbo_plugin_mxf_default
+});
+const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
+const uniffiIsDebug = typeof process !== "object" || process?.env?.NODE_ENV !== "production" || false;
+const FfiConverterString = uniffiCreateFfiConverterString((() => {
+	const encoder = new TextEncoder();
+	const decoder = new TextDecoder();
+	return {
+		stringToBytes: (s) => encoder.encode(s),
+		bytesToString: (ab) => decoder.decode(ab),
+		stringByteLength: (s) => encoder.encode(s).byteLength,
+		writeStringIntoBuffer: (s, buf, offset) => {
+			const view = new Uint8Array(buf.arrayBuffer, offset, buf.arrayBuffer.byteLength - offset);
+			return encoder.encodeInto(s, view).written;
+		},
+		readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length))
+	};
+})());
+/**
+* Generated factory for {@link FieldViolation} record objects.
+*/
+const FieldViolation = (() => {
+	const defaults = () => ({});
+	const create = (() => {
+		return uniffiCreateRecord(defaults);
+	})();
+	return Object.freeze({
+		create,
+		new: create,
+		defaults: () => Object.freeze(defaults())
+	});
+})();
+const FfiConverterTypeFieldViolation = (() => {
+	class FFIConverter extends AbstractFfiConverterByteArray {
+		readFromCursor(c) {
+			return {
+				field: FfiConverterString.readFromCursor(c),
+				description: FfiConverterString.readFromCursor(c),
+				reason: FfiConverterString.readFromCursor(c)
+			};
+		}
+		writeIntoCursor(value, c) {
+			FfiConverterString.writeIntoCursor(value.field, c);
+			FfiConverterString.writeIntoCursor(value.description, c);
+			FfiConverterString.writeIntoCursor(value.reason, c);
+		}
+		allocationSize(value) {
+			return FfiConverterString.allocationSize(value.field) + FfiConverterString.allocationSize(value.description) + FfiConverterString.allocationSize(value.reason);
+		}
+	}
+	return new FFIConverter();
+})();
+/**
+* Generated factory for {@link Region} record objects.
+*/
+const Region = (() => {
+	const defaults = () => ({});
+	const create = (() => {
+		return uniffiCreateRecord(defaults);
+	})();
+	return Object.freeze({
+		create,
+		new: create,
+		defaults: () => Object.freeze(defaults())
+	});
+})();
+const FfiConverterTypeRegion = (() => {
+	class FFIConverter extends AbstractFfiConverterByteArray {
+		readFromCursor(c) {
+			return {
+				offset: FfiConverterUInt64.readFromCursor(c),
+				length: FfiConverterUInt64.readFromCursor(c)
+			};
+		}
+		writeIntoCursor(value, c) {
+			FfiConverterUInt64.writeIntoCursor(value.offset, c);
+			FfiConverterUInt64.writeIntoCursor(value.length, c);
+		}
+		allocationSize(value) {
+			return FfiConverterUInt64.allocationSize(value.offset) + FfiConverterUInt64.allocationSize(value.length);
+		}
+	}
+	return new FFIConverter();
+})();
+/**
+* A canonical gRPC/Connect status code: the coarse, closed failure class.
+*
+* The wasm lane projects this as the Connect `snake_case` string, so a consumer
+* narrows on `err.code === "resource_exhausted"`; the native lane projects an enum.
+*/
+let Code = /* @__PURE__ */ function(Code) {
+	Code[Code["Canceled"] = 0] = "Canceled";
+	Code[Code["Unknown"] = 1] = "Unknown";
+	Code[Code["InvalidArgument"] = 2] = "InvalidArgument";
+	Code[Code["DeadlineExceeded"] = 3] = "DeadlineExceeded";
+	Code[Code["NotFound"] = 4] = "NotFound";
+	Code[Code["AlreadyExists"] = 5] = "AlreadyExists";
+	Code[Code["PermissionDenied"] = 6] = "PermissionDenied";
+	Code[Code["ResourceExhausted"] = 7] = "ResourceExhausted";
+	Code[Code["FailedPrecondition"] = 8] = "FailedPrecondition";
+	Code[Code["Aborted"] = 9] = "Aborted";
+	Code[Code["OutOfRange"] = 10] = "OutOfRange";
+	Code[Code["Unimplemented"] = 11] = "Unimplemented";
+	Code[Code["Internal"] = 12] = "Internal";
+	Code[Code["Unavailable"] = 13] = "Unavailable";
+	Code[Code["DataLoss"] = 14] = "DataLoss";
+	Code[Code["Unauthenticated"] = 15] = "Unauthenticated";
+	return Code;
+}({});
+const FfiConverterTypeCode = (() => {
+	class FFIConverter extends AbstractFfiConverterByteArray {
+		readFromCursor(c) {
+			switch (c.readI32()) {
+				case 1: return 0;
+				case 2: return 1;
+				case 3: return 2;
+				case 4: return 3;
+				case 5: return 4;
+				case 6: return 5;
+				case 7: return 6;
+				case 8: return 7;
+				case 9: return 8;
+				case 10: return 9;
+				case 11: return 10;
+				case 12: return 11;
+				case 13: return 12;
+				case 14: return 13;
+				case 15: return 14;
+				case 16: return 15;
+				default: throw new UniffiInternalError.UnexpectedEnumCase();
+			}
+		}
+		writeIntoCursor(value, c) {
+			switch (value) {
+				case 0: return c.writeI32(1);
+				case 1: return c.writeI32(2);
+				case 2: return c.writeI32(3);
+				case 3: return c.writeI32(4);
+				case 4: return c.writeI32(5);
+				case 5: return c.writeI32(6);
+				case 6: return c.writeI32(7);
+				case 7: return c.writeI32(8);
+				case 8: return c.writeI32(9);
+				case 9: return c.writeI32(10);
+				case 10: return c.writeI32(11);
+				case 11: return c.writeI32(12);
+				case 12: return c.writeI32(13);
+				case 13: return c.writeI32(14);
+				case 14: return c.writeI32(15);
+				case 15: return c.writeI32(16);
+			}
+		}
+		allocationSize(value) {
+			return 4;
+		}
+	}
+	return new FFIConverter();
+})();
+let SdkError_Tags = /* @__PURE__ */ function(SdkError_Tags) {
+	SdkError_Tags["Reason"] = "Reason";
+	SdkError_Tags["Invalid"] = "Invalid";
+	SdkError_Tags["Status"] = "Status";
+	return SdkError_Tags;
+}({});
+/**
+* The error every SDK call throws: a decoded `google.rpc.Status`, discriminated
+* as a semantic reason, a request validation, or a bare status. `code` and `message`
+* are common to every variant.
+*/
+const SdkError = (() => {
+	/**
+	* A semantic fault carrying a `google.rpc.ErrorInfo` reason.
+	*/
+	class Reason_ extends UniffiError {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "SdkError";
+		tag = "Reason";
+		inner;
+		constructor(inner) {
+			super("SdkError", "Reason");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new Reason_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "Reason";
+		}
+		static hasInner(obj) {
+			return Reason_.instanceOf(obj);
+		}
+		static getInner(obj) {
+			return obj.inner;
+		}
+	}
+	/**
+	* A request-validation fault: `google.rpc.BadRequest`.
+	*/
+	class Invalid_ extends UniffiError {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "SdkError";
+		tag = "Invalid";
+		inner;
+		constructor(inner) {
+			super("SdkError", "Invalid");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new Invalid_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "Invalid";
+		}
+		static hasInner(obj) {
+			return Invalid_.instanceOf(obj);
+		}
+		static getInner(obj) {
+			return obj.inner;
+		}
+	}
+	/**
+	* A status with no structured detail: a transport fault or a bare server status.
+	*/
+	class Status_ extends UniffiError {
+		/**
+		* @private
+		* This field is private and should not be used, use `tag` instead.
+		*/
+		[uniffiTypeNameSymbol] = "SdkError";
+		tag = "Status";
+		inner;
+		constructor(inner) {
+			super("SdkError", "Status");
+			this.inner = Object.freeze(inner);
+		}
+		static new(inner) {
+			return new Status_(inner);
+		}
+		static instanceOf(obj) {
+			return obj.tag === "Status";
+		}
+		static hasInner(obj) {
+			return Status_.instanceOf(obj);
+		}
+		static getInner(obj) {
+			return obj.inner;
+		}
+	}
+	function instanceOf(obj) {
+		return obj[uniffiTypeNameSymbol] === "SdkError";
+	}
+	return Object.freeze({
+		instanceOf,
+		Reason: Reason_,
+		Invalid: Invalid_,
+		Status: Status_
+	});
+})();
+const FfiConverterTypeSdkError = (() => {
+	class FFIConverter extends AbstractFfiConverterByteArray {
+		readFromCursor(c) {
+			switch (c.readI32()) {
+				case 1: return new SdkError.Reason({
+					code: FfiConverterTypeCode.readFromCursor(c),
+					message: FfiConverterString.readFromCursor(c),
+					reason: FfiConverterString.readFromCursor(c),
+					domain: FfiConverterString.readFromCursor(c),
+					metadata: FfiConverterMapStringString.readFromCursor(c)
+				});
+				case 2: return new SdkError.Invalid({
+					code: FfiConverterTypeCode.readFromCursor(c),
+					message: FfiConverterString.readFromCursor(c),
+					fieldViolations: FfiConverterSequenceTypeFieldViolation.readFromCursor(c)
+				});
+				case 3: return new SdkError.Status({
+					code: FfiConverterTypeCode.readFromCursor(c),
+					message: FfiConverterString.readFromCursor(c)
+				});
+				default: throw new UniffiInternalError.UnexpectedEnumCase();
+			}
+		}
+		writeIntoCursor(value, c) {
+			switch (value.tag) {
+				case "Reason": {
+					c.writeI32(1);
+					const inner = value.inner;
+					FfiConverterTypeCode.writeIntoCursor(inner.code, c);
+					FfiConverterString.writeIntoCursor(inner.message, c);
+					FfiConverterString.writeIntoCursor(inner.reason, c);
+					FfiConverterString.writeIntoCursor(inner.domain, c);
+					FfiConverterMapStringString.writeIntoCursor(inner.metadata, c);
+					return;
+				}
+				case "Invalid": {
+					c.writeI32(2);
+					const inner = value.inner;
+					FfiConverterTypeCode.writeIntoCursor(inner.code, c);
+					FfiConverterString.writeIntoCursor(inner.message, c);
+					FfiConverterSequenceTypeFieldViolation.writeIntoCursor(inner.fieldViolations, c);
+					return;
+				}
+				case "Status": {
+					c.writeI32(3);
+					const inner = value.inner;
+					FfiConverterTypeCode.writeIntoCursor(inner.code, c);
+					FfiConverterString.writeIntoCursor(inner.message, c);
+					return;
+				}
+				default: throw new UniffiInternalError.UnexpectedEnumCase();
+			}
+		}
+		allocationSize(value) {
+			switch (value.tag) {
+				case "Reason": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterTypeCode.allocationSize(inner.code);
+					size += FfiConverterString.allocationSize(inner.message);
+					size += FfiConverterString.allocationSize(inner.reason);
+					size += FfiConverterString.allocationSize(inner.domain);
+					size += FfiConverterMapStringString.allocationSize(inner.metadata);
+					return size;
+				}
+				case "Invalid": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterTypeCode.allocationSize(inner.code);
+					size += FfiConverterString.allocationSize(inner.message);
+					size += FfiConverterSequenceTypeFieldViolation.allocationSize(inner.fieldViolations);
+					return size;
+				}
+				case "Status": {
+					const inner = value.inner;
+					let size = 4;
+					size += FfiConverterTypeCode.allocationSize(inner.code);
+					size += FfiConverterString.allocationSize(inner.message);
+					return size;
+				}
+				default: throw new UniffiInternalError.UnexpectedEnumCase();
+			}
+		}
+	}
+	return new FFIConverter();
+})();
+const uniffiCallbackInterfaceRangeSource = {
+	vtable: {
+		length: (uniffiHandle, uniffiFutureCallback, uniffiCallbackData) => {
+			const uniffiMakeCall = async (signal) => {
+				return await FfiConverterTypeRangeSource.lift(uniffiHandle).length({ signal });
+			};
+			const uniffiHandleSuccess = (returnValue) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+					return_value: FfiConverterUInt64.lower(returnValue, getter().rustbuffer_alloc),
+					call_status: uniffiCaller.createCallStatus()
+				});
+			};
+			const uniffiHandleError = (code, errorBuf) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+					return_value: BigInt(0),
+					call_status: uniffiCaller.createErrorStatus(code, errorBuf)
+				});
+			};
+			return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
+		},
+		read_at: (uniffiHandle, offset, length, uniffiFutureCallback, uniffiCallbackData) => {
+			const uniffiMakeCall = async (signal) => {
+				return await FfiConverterTypeRangeSource.lift(uniffiHandle).readAt(FfiConverterUInt64.lift(offset), FfiConverterUInt32.lift(length), { signal });
+			};
+			const uniffiHandleSuccess = (returnValue) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+					return_value: FfiConverterArrayBuffer.lower(returnValue, getter().rustbuffer_alloc),
+					call_status: uniffiCaller.createCallStatus()
+				});
+			};
+			const uniffiHandleError = (code, errorBuf) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+					return_value: /* @__PURE__ */ new Uint8Array(0),
+					call_status: uniffiCaller.createErrorStatus(code, errorBuf)
+				});
+			};
+			return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
+		},
+		uniffi_free: (uniffiHandle) => {
+			FfiConverterTypeRangeSource.drop(uniffiHandle);
+		},
+		uniffi_clone: (uniffiHandle) => {
+			return FfiConverterTypeRangeSource.clone(uniffiHandle);
+		}
+	},
+	register: () => {
+		getter().uniffi_trylimbo_plugin_mxf_fn_init_callback_vtable_rangesource(uniffiCallbackInterfaceRangeSource.vtable);
+	}
+};
+const FfiConverterTypeRangeSource = new FfiConverterCallback();
+const uniffiCallbackInterfaceRangeSink = {
+	vtable: {
+		length: (uniffiHandle, uniffiFutureCallback, uniffiCallbackData) => {
+			const uniffiMakeCall = async (signal) => {
+				return await FfiConverterTypeRangeSink.lift(uniffiHandle).length({ signal });
+			};
+			const uniffiHandleSuccess = (returnValue) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+					return_value: FfiConverterUInt64.lower(returnValue, getter().rustbuffer_alloc),
+					call_status: uniffiCaller.createCallStatus()
+				});
+			};
+			const uniffiHandleError = (code, errorBuf) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+					return_value: BigInt(0),
+					call_status: uniffiCaller.createErrorStatus(code, errorBuf)
+				});
+			};
+			return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
+		},
+		read_at: (uniffiHandle, offset, length, uniffiFutureCallback, uniffiCallbackData) => {
+			const uniffiMakeCall = async (signal) => {
+				return await FfiConverterTypeRangeSink.lift(uniffiHandle).readAt(FfiConverterUInt64.lift(offset), FfiConverterUInt32.lift(length), { signal });
+			};
+			const uniffiHandleSuccess = (returnValue) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+					return_value: FfiConverterArrayBuffer.lower(returnValue, getter().rustbuffer_alloc),
+					call_status: uniffiCaller.createCallStatus()
+				});
+			};
+			const uniffiHandleError = (code, errorBuf) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+					return_value: /* @__PURE__ */ new Uint8Array(0),
+					call_status: uniffiCaller.createErrorStatus(code, errorBuf)
+				});
+			};
+			return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
+		},
+		write_at: (uniffiHandle, offset, data, uniffiFutureCallback, uniffiCallbackData) => {
+			const uniffiMakeCall = async (signal) => {
+				return await FfiConverterTypeRangeSink.lift(uniffiHandle).writeAt(FfiConverterUInt64.lift(offset), FfiConverterArrayBuffer.lift(data), { signal });
+			};
+			const uniffiHandleSuccess = (returnValue) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, { call_status: uniffiCaller.createCallStatus() });
+			};
+			const uniffiHandleError = (code, errorBuf) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, { call_status: uniffiCaller.createErrorStatus(code, errorBuf) });
+			};
+			return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
+		},
+		set_length: (uniffiHandle, length, uniffiFutureCallback, uniffiCallbackData) => {
+			const uniffiMakeCall = async (signal) => {
+				return await FfiConverterTypeRangeSink.lift(uniffiHandle).setLength(FfiConverterUInt64.lift(length), { signal });
+			};
+			const uniffiHandleSuccess = (returnValue) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, { call_status: uniffiCaller.createCallStatus() });
+			};
+			const uniffiHandleError = (code, errorBuf) => {
+				uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, { call_status: uniffiCaller.createErrorStatus(code, errorBuf) });
+			};
+			return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
+		},
+		uniffi_free: (uniffiHandle) => {
+			FfiConverterTypeRangeSink.drop(uniffiHandle);
+		},
+		uniffi_clone: (uniffiHandle) => {
+			return FfiConverterTypeRangeSink.clone(uniffiHandle);
+		}
+	},
+	register: () => {
+		getter().uniffi_trylimbo_plugin_mxf_fn_init_callback_vtable_rangesink(uniffiCallbackInterfaceRangeSink.vtable);
+	}
+};
+const FfiConverterTypeRangeSink = new FfiConverterCallback();
+/**
+* MXF slot authoring, as the object a host registers on the issuer's `PluginRegistry`.
+*
+* The four methods mirror the issuer's `PluginAuthor` exactly. They are declared flat,
+* because UniFFI has no trait inheritance for foreign callbacks, so the generated binding
+* satisfies that interface as-is, with nothing in between.
+*/
+var MxfAuthor = class extends UniffiAbstractObject {
+	[uniffiTypeNameSymbol] = "MxfAuthor";
+	[destructorGuardSymbol];
+	[pointerLiteralSymbol];
+	constructor() {
+		super();
+		const pointer = uniffiCaller.rustCall((callStatus) => {
+			return getter().uniffi_trylimbo_plugin_mxf_fn_constructor_mxfauthor_new(callStatus);
+		}, FfiConverterString.lift.bind(FfiConverterString));
+		this[pointerLiteralSymbol] = pointer;
+		this[destructorGuardSymbol] = uniffiTypeMxfAuthorObjectFactory.bless(pointer);
+	}
+	/**
+	* The manifest window(s), or empty when the asset carries none. Byte-identical whether
+	* the slot is empty, filled or zeroed: the SDK round-trips this and fails the sign if
+	* it drifts.
+	*
+	* # Errors
+	*
+	* [`SdkError`] when the source cannot be read or the MXF structure is malformed.
+	*/
+	async locate(src, asyncOpts_) {
+		const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
+		try {
+			return await uniffiRustCallAsync(uniffiCaller, () => {
+				return getter().uniffi_trylimbo_plugin_mxf_fn_method_mxfauthor_locate(uniffiTypeMxfAuthorObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(src, getter().rustbuffer_alloc));
+			}, getter().ffi_trylimbo_plugin_mxf_rust_future_poll_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_complete_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_free_rust_buffer, (__rb) => {
+				try {
+					return FfiConverterSequenceTypeRegion.lift(__rb);
+				} finally {
+					getter().rustbuffer_free(__rb);
+				}
+			}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
+		} catch (__error) {
+			if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
+			throw __error;
+		}
+	}
+	/**
+	* The media types this plugin owns. The SDK asserts any `sniff` result is a member.
+	*/
+	mediaTypes() {
+		const __rb = uniffiCaller.rustCall((callStatus) => {
+			return getter().uniffi_trylimbo_plugin_mxf_fn_method_mxfauthor_media_types(uniffiTypeMxfAuthorObjectFactory.clonePointer(this), callStatus);
+		}, FfiConverterString.lift.bind(FfiConverterString));
+		try {
+			return FfiConverterSequenceString.lift(__rb);
+		} finally {
+			getter().rustbuffer_free(__rb);
+		}
+	}
+	/**
+	* Reserve `reserve` bytes of manifest slot by writing MXF structure through `dst`, and
+	* return exactly where it landed. Never embeds: the SDK writes the signed manifest into
+	* the returned regions.
+	*
+	* # Errors
+	*
+	* [`SdkError`] when the sink cannot be written or `reserve` exceeds a `u32` slot.
+	*/
+	async reserveSlot(dst, reserve, asyncOpts_) {
+		const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
+		try {
+			return await uniffiRustCallAsync(uniffiCaller, () => {
+				return getter().uniffi_trylimbo_plugin_mxf_fn_method_mxfauthor_reserve_slot(uniffiTypeMxfAuthorObjectFactory.clonePointer(this), FfiConverterTypeRangeSink.lower(dst, getter().rustbuffer_alloc), FfiConverterUInt64.lower(reserve, getter().rustbuffer_alloc));
+			}, getter().ffi_trylimbo_plugin_mxf_rust_future_poll_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_complete_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_free_rust_buffer, (__rb) => {
+				try {
+					return FfiConverterSequenceTypeRegion.lift(__rb);
+				} finally {
+					getter().rustbuffer_free(__rb);
+				}
+			}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
+		} catch (__error) {
+			if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
+			throw __error;
+		}
+	}
+	/**
+	* Recognize MXF from the real bytes, or `None` to decline.
+	*
+	* # Errors
+	*
+	* [`SdkError`] when the source cannot be read.
+	*/
+	async sniff(src, asyncOpts_) {
+		const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
+		try {
+			return await uniffiRustCallAsync(uniffiCaller, () => {
+				return getter().uniffi_trylimbo_plugin_mxf_fn_method_mxfauthor_sniff(uniffiTypeMxfAuthorObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(src, getter().rustbuffer_alloc));
+			}, getter().ffi_trylimbo_plugin_mxf_rust_future_poll_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_complete_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_free_rust_buffer, (__rb) => {
+				try {
+					return FfiConverterOptionalString.lift(__rb);
+				} finally {
+					getter().rustbuffer_free(__rb);
+				}
+			}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
+		} catch (__error) {
+			if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
+			throw __error;
+		}
+	}
+	uniffiDestroy() {
+		const ptr = this[destructorGuardSymbol];
+		if (ptr !== void 0) {
+			const pointer = uniffiTypeMxfAuthorObjectFactory.pointer(this);
+			uniffiTypeMxfAuthorObjectFactory.freePointer(pointer);
+			uniffiTypeMxfAuthorObjectFactory.unbless(ptr);
+			delete this[destructorGuardSymbol];
+		}
+	}
+	static instanceOf(obj_) {
+		return uniffiTypeMxfAuthorObjectFactory.isConcreteType(obj_);
+	}
+};
+const uniffiTypeMxfAuthorObjectFactory = (() => {
+	const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
+		uniffiTypeMxfAuthorObjectFactory.freePointer(heldValue);
+	}) : null;
+	return {
+		create(pointer) {
+			const instance = Object.create(MxfAuthor.prototype);
+			instance[pointerLiteralSymbol] = pointer;
+			instance[destructorGuardSymbol] = this.bless(pointer);
+			instance[uniffiTypeNameSymbol] = "MxfAuthor";
+			return instance;
+		},
+		bless(p) {
+			const ptr = {
+				p,
+				markDestroyed: () => void 0
+			};
+			if (registry) registry.register(ptr, p, ptr);
+			return ptr;
+		},
+		unbless(ptr_) {
+			if (registry) registry.unregister(ptr_);
+		},
+		pointer(obj_) {
+			if (obj_[destructorGuardSymbol] === void 0) throw new UniffiInternalError.UnexpectedNullPointer();
+			return obj_[pointerLiteralSymbol];
+		},
+		clonePointer(obj_) {
+			const pointer = this.pointer(obj_);
+			return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_plugin_mxf_fn_clone_mxfauthor(pointer, callStatus), FfiConverterString.lift);
+		},
+		freePointer(pointer) {
+			uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_plugin_mxf_fn_free_mxfauthor(pointer, callStatus), FfiConverterString.lift);
+		},
+		isConcreteType(obj_) {
+			return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "MxfAuthor";
+		}
+	};
+})();
+const FfiConverterTypeMxfAuthor = new FfiConverterObject(uniffiTypeMxfAuthorObjectFactory);
+/**
+* MXF reading, as the object a host registers on the verifier's `PluginRegistry`.
+*
+* The three methods mirror the verifier's `PluginRead` exactly, so the generated binding
+* satisfies that interface as-is. Carries no libMXF++: locating a slot is pure Rust.
+*/
+var MxfPlugin = class extends UniffiAbstractObject {
+	[uniffiTypeNameSymbol] = "MxfPlugin";
+	[destructorGuardSymbol];
+	[pointerLiteralSymbol];
+	constructor() {
+		super();
+		const pointer = uniffiCaller.rustCall((callStatus) => {
+			return getter().uniffi_trylimbo_plugin_mxf_fn_constructor_mxfplugin_new(callStatus);
+		}, FfiConverterString.lift.bind(FfiConverterString));
+		this[pointerLiteralSymbol] = pointer;
+		this[destructorGuardSymbol] = uniffiTypeMxfPluginObjectFactory.bless(pointer);
+	}
+	/**
+	* The manifest window(s), or empty when the asset carries none. What the verifier hashes
+	* around: everything reported here is excluded from the signed content hash.
+	*
+	* # Errors
+	*
+	* [`SdkError`] when the source cannot be read or the MXF structure is malformed.
+	*/
+	async locate(src, asyncOpts_) {
+		const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
+		try {
+			return await uniffiRustCallAsync(uniffiCaller, () => {
+				return getter().uniffi_trylimbo_plugin_mxf_fn_method_mxfplugin_locate(uniffiTypeMxfPluginObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(src, getter().rustbuffer_alloc));
+			}, getter().ffi_trylimbo_plugin_mxf_rust_future_poll_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_complete_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_free_rust_buffer, (__rb) => {
+				try {
+					return FfiConverterSequenceTypeRegion.lift(__rb);
+				} finally {
+					getter().rustbuffer_free(__rb);
+				}
+			}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
+		} catch (__error) {
+			if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
+			throw __error;
+		}
+	}
+	/**
+	* The media types this plugin owns. The SDK asserts any `sniff` result is a member.
+	*/
+	mediaTypes() {
+		const __rb = uniffiCaller.rustCall((callStatus) => {
+			return getter().uniffi_trylimbo_plugin_mxf_fn_method_mxfplugin_media_types(uniffiTypeMxfPluginObjectFactory.clonePointer(this), callStatus);
+		}, FfiConverterString.lift.bind(FfiConverterString));
+		try {
+			return FfiConverterSequenceString.lift(__rb);
+		} finally {
+			getter().rustbuffer_free(__rb);
+		}
+	}
+	/**
+	* Recognize MXF from the real bytes, or `None` to decline.
+	*
+	* # Errors
+	*
+	* [`SdkError`] when the source cannot be read.
+	*/
+	async sniff(src, asyncOpts_) {
+		const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
+		try {
+			return await uniffiRustCallAsync(uniffiCaller, () => {
+				return getter().uniffi_trylimbo_plugin_mxf_fn_method_mxfplugin_sniff(uniffiTypeMxfPluginObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(src, getter().rustbuffer_alloc));
+			}, getter().ffi_trylimbo_plugin_mxf_rust_future_poll_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_complete_rust_buffer, getter().ffi_trylimbo_plugin_mxf_rust_future_free_rust_buffer, (__rb) => {
+				try {
+					return FfiConverterOptionalString.lift(__rb);
+				} finally {
+					getter().rustbuffer_free(__rb);
+				}
+			}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
+		} catch (__error) {
+			if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
+			throw __error;
+		}
+	}
+	uniffiDestroy() {
+		const ptr = this[destructorGuardSymbol];
+		if (ptr !== void 0) {
+			const pointer = uniffiTypeMxfPluginObjectFactory.pointer(this);
+			uniffiTypeMxfPluginObjectFactory.freePointer(pointer);
+			uniffiTypeMxfPluginObjectFactory.unbless(ptr);
+			delete this[destructorGuardSymbol];
+		}
+	}
+	static instanceOf(obj_) {
+		return uniffiTypeMxfPluginObjectFactory.isConcreteType(obj_);
+	}
+};
+const uniffiTypeMxfPluginObjectFactory = (() => {
+	const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
+		uniffiTypeMxfPluginObjectFactory.freePointer(heldValue);
+	}) : null;
+	return {
+		create(pointer) {
+			const instance = Object.create(MxfPlugin.prototype);
+			instance[pointerLiteralSymbol] = pointer;
+			instance[destructorGuardSymbol] = this.bless(pointer);
+			instance[uniffiTypeNameSymbol] = "MxfPlugin";
+			return instance;
+		},
+		bless(p) {
+			const ptr = {
+				p,
+				markDestroyed: () => void 0
+			};
+			if (registry) registry.register(ptr, p, ptr);
+			return ptr;
+		},
+		unbless(ptr_) {
+			if (registry) registry.unregister(ptr_);
+		},
+		pointer(obj_) {
+			if (obj_[destructorGuardSymbol] === void 0) throw new UniffiInternalError.UnexpectedNullPointer();
+			return obj_[pointerLiteralSymbol];
+		},
+		clonePointer(obj_) {
+			const pointer = this.pointer(obj_);
+			return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_plugin_mxf_fn_clone_mxfplugin(pointer, callStatus), FfiConverterString.lift);
+		},
+		freePointer(pointer) {
+			uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_plugin_mxf_fn_free_mxfplugin(pointer, callStatus), FfiConverterString.lift);
+		},
+		isConcreteType(obj_) {
+			return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "MxfPlugin";
+		}
+	};
+})();
+const FfiConverterTypeMxfPlugin = new FfiConverterObject(uniffiTypeMxfPluginObjectFactory);
+const FfiConverterMapStringString = new FfiConverterMap(FfiConverterString, FfiConverterString);
+const FfiConverterSequenceTypeFieldViolation = new FfiConverterArray(FfiConverterTypeFieldViolation);
+const FfiConverterSequenceTypeRegion = new FfiConverterArray(FfiConverterTypeRegion);
+const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+/**
+* This should be called before anything else.
+*
+* It is likely that this is being done for you by the library's `index.ts`.
+*
+* It checks versions of uniffi between when the Rust scaffolding was generated
+* and when the bindings were generated.
+*
+* It also initializes the machinery to enable Rust to talk back to Javascript.
+*/
+function uniffiEnsureInitialized() {
+	const bindingsContractVersion = 30;
+	const scaffoldingContractVersion = getter().ffi_trylimbo_plugin_mxf_uniffi_contract_version();
+	if (bindingsContractVersion !== scaffoldingContractVersion) throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+	if (getter().uniffi_trylimbo_plugin_mxf_checksum_constructor_mxfauthor_new() !== 26244) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_plugin_mxf_checksum_constructor_mxfauthor_new");
+	if (getter().uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_locate() !== 45199) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_locate");
+	if (getter().uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_media_types() !== 26985) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_media_types");
+	if (getter().uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_reserve_slot() !== 48309) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_reserve_slot");
+	if (getter().uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_sniff() !== 42367) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_plugin_mxf_checksum_method_mxfauthor_sniff");
+	if (getter().uniffi_trylimbo_plugin_mxf_checksum_constructor_mxfplugin_new() !== 63791) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_plugin_mxf_checksum_constructor_mxfplugin_new");
+	if (getter().uniffi_trylimbo_plugin_mxf_checksum_method_mxfplugin_locate() !== 1210) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_plugin_mxf_checksum_method_mxfplugin_locate");
+	if (getter().uniffi_trylimbo_plugin_mxf_checksum_method_mxfplugin_media_types() !== 44782) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_plugin_mxf_checksum_method_mxfplugin_media_types");
+	if (getter().uniffi_trylimbo_plugin_mxf_checksum_method_mxfplugin_sniff() !== 48535) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_plugin_mxf_checksum_method_mxfplugin_sniff");
+	uniffiCallbackInterfaceRangeSource.register();
+	uniffiCallbackInterfaceRangeSink.register();
+}
+var trylimbo_plugin_mxf_default = Object.freeze({
+	initialize: uniffiEnsureInitialized,
+	converters: {
+		FfiConverterTypeCode,
+		FfiConverterTypeFieldViolation,
+		FfiConverterTypeMxfAuthor,
+		FfiConverterTypeMxfPlugin,
+		FfiConverterTypeRegion,
+		FfiConverterTypeSdkError
+	}
+});
+//#endregion
+//#region ../../../../../target/trylimbo/codegen/ffi-trylimbo_plugin_mxf/index.ts
+let initialized = false;
+if (!initialized) {
+	trylimbo_plugin_mxf_default.initialize();
+	initialized = true;
+}
+async function uniffiInitAsync() {}
+var ffi_trylimbo_plugin_mxf_default = { trylimbo_plugin_mxf: trylimbo_plugin_mxf_exports };
+//#endregion
+export { Code, FieldViolation, MxfAuthor, MxfPlugin, Region, SdkError, SdkError_Tags, ffi_trylimbo_plugin_mxf_default as default, uniffiInitAsync };