@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/providers-WtiSuxFu.js

@@ -0,0 +1,365 @@
+import { a as ArtefactIntegrityError } from "./errors-DSq5wUwt.js";
+import { i as accManifest, n as loadCircuitAssets, r as loadVerifierKey, t as UnknownCircuitError } from "./artefact-loader-Dik4HIfv.js";
+//#region ../../packages/contract/passport/src/value-objects/acc-address.vo.ts
+/** Types a string as an Account Custody Contract address. It checks nothing. */
+const AccAddress = (value) => value;
+//#endregion
+//#region ../../packages/module/passport-account/src/infra/network-id.ts
+/**
+* Applies the Midnight network id the rest of the Midnight libraries read
+* from module-global state. Address formats and transaction binding depend
+* on it, and every wallet or contract operation throws until it is set, so
+* each entry point into a chain flow applies it before doing any work.
+* Setting the same id again is harmless; a different id replaces the
+* previous one, which is why one network config owns the value.
+*/
+const applyNetworkId = async (networkId) => {
+	const { setNetworkId } = await import("@midnight-ntwrk/midnight-js-network-id");
+	setNetworkId(networkId);
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/infra/http-prover.ts
+/**
+* Thrown when the proof server rejects a request or does not answer before
+* the timeout. `status` carries the HTTP status code of the final response;
+* it is undefined when the request timed out before any response arrived.
+*/
+var ProofServerError = class extends Error {
+	code = "proof-server";
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+		this.name = "ProofServerError";
+	}
+};
+/**
+* Thrown when the ledger asks for the circuit of a contract the client holds
+* no key material for, for example a contract the account's circuits call.
+* Without it the proof server would receive the request with no circuit IR
+* and answer a bare 400.
+*/
+var UnresolvedContractCircuitError = class extends Error {
+	code = "unresolved-contract-circuit";
+	constructor(contractAddress, circuit, verifierKeyHash) {
+		super(`No key material for circuit "${circuit}" of contract ${contractAddress}${verifierKeyHash === void 0 ? "" : ` (vk=${verifierKeyHash})`}: the prover only resolves the Account Custody Contract circuits listed in its manifest.`);
+		this.contractAddress = contractAddress;
+		this.circuit = circuit;
+		this.verifierKeyHash = verifierKeyHash;
+		this.name = "UnresolvedContractCircuitError";
+	}
+};
+/**
+* Canonical contract key location: `contract:<address>/<circuit>?vk=<hash>`.
+* The ledger stamps every contract call's proof preimage with this form;
+* the vk query pin is the sha256 of the verifier key the chain expects.
+*/
+const CANONICAL_KEY_LOCATION = /^contract:([0-9a-f]+)\/([^?]+)(?:\?vk=([0-9a-f]+))?$/;
+/**
+* The default {@link KeyMaterialResolver}: maps a key location onto the
+* Account Custody Contract manifest and downloads that circuit's prover
+* key, verifier key, and IR through {@link loadCircuitAssets}, so every
+* byte is verified against the manifest's sha256 pins. Canonical contract
+* locations resolve by circuit name, and their embedded vk pin must match
+* the manifest's, so proving against a drifted artefact fails before the
+* proof server is asked. A canonical contract location whose circuit the
+* manifest does not list, such as a circuit of a contract the account
+* calls, throws {@link UnresolvedContractCircuitError}. Any other unlisted location
+* resolves to undefined (a protocol builtin the proof server supplies
+* itself).
+*/
+const createManifestKeyMaterialResolver = ({ artefactUrl, fetchBytes, manifest = accManifest }) => {
+	const entries = Object.values(manifest.circuits);
+	return async (keyLocation) => {
+		const canonical = CANONICAL_KEY_LOCATION.exec(keyLocation);
+		const circuitName = canonical ? canonical[2] : keyLocation;
+		const vkPin = canonical?.[3];
+		const entry = entries.find((candidate) => candidate.keyLocation === keyLocation || candidate.name === circuitName);
+		if (!entry) {
+			if (canonical) throw new UnresolvedContractCircuitError(canonical[1], canonical[2], vkPin);
+			return;
+		}
+		if (vkPin !== void 0 && vkPin !== entry.verifierKeySha256) throw new ArtefactIntegrityError(`verifier key pin mismatch for ${entry.name}: the chain expects ${vkPin}, the manifest pins ${entry.verifierKeySha256}`);
+		const assets = await loadCircuitAssets({
+			artefactUrl,
+			circuit: entry.name,
+			fetchBytes,
+			manifest
+		});
+		return {
+			proverKey: assets.proverKey,
+			verifierKey: assets.verifierKey,
+			ir: assets.zkir
+		};
+	};
+};
+/** Proving a circuit call can legitimately take minutes on large circuits. */
+const TIMEOUT_MS = 3e5;
+/** A 500/503 is transient (proof server busy or restarting); one retry. */
+const RETRYABLE_STATUSES = new Set([500, 503]);
+const defaultFetchBytes$1 = async (url) => {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Artefact download failed: url="${url}", status="${response.status} ${response.statusText}"`);
+	return new Uint8Array(await response.arrayBuffer());
+};
+/**
+* A {@link PassportProver} over the Midnight proof server's HTTP API,
+* wire-compatible with the stock midnight-js client: the key location is
+* resolved client-side to the circuit's key material (prover key and IR),
+* the serialized preimage plus that material is framed with the protocol
+* payload codecs, and the framed bytes are POSTed to /prove and /check as
+* application/octet-stream with nothing else. A location the resolver
+* does not know travels without key material; the proof server supplies
+* the protocol builtin keys itself. The protocol codec loads lazily so
+* platforms only pay for it when a proof is actually requested.
+*
+* @param baseUrl - The proof server's URL; requests go to `<baseUrl>/prove`
+*   and `<baseUrl>/check`.
+* @param options - Where key material comes from, and the transports. It
+*   throws without `resolveKeyMaterial` or an `artefactUrl`.
+*/
+const createHttpProver = (baseUrl, options = {}) => {
+	const fetchHttp = options.fetchHttp ?? globalThis.fetch;
+	const resolveKeyMaterial = options.resolveKeyMaterial ?? (options.artefactUrl === void 0 ? void 0 : createManifestKeyMaterialResolver({
+		artefactUrl: options.artefactUrl,
+		fetchBytes: options.fetchBytes ?? defaultFetchBytes$1
+	}));
+	if (!resolveKeyMaterial) throw new Error("createHttpProver needs resolveKeyMaterial or an artefactUrl for the default manifest resolver.");
+	const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+	const loadPayloadCodec = async () => import("@midnight-ntwrk/midnight-js-protocol/ledger");
+	const request = async (url, payload) => {
+		const controller = new AbortController();
+		const timer = setTimeout(() => {
+			controller.abort();
+		}, TIMEOUT_MS);
+		try {
+			return await fetchHttp(url, {
+				method: "POST",
+				headers: { "Content-Type": "application/octet-stream" },
+				body: payload,
+				signal: controller.signal
+			});
+		} catch (error) {
+			if (controller.signal.aborted) throw new ProofServerError(`Proof server request timed out after ${TIMEOUT_MS}ms: ${url}`);
+			throw error;
+		} finally {
+			clearTimeout(timer);
+		}
+	};
+	const post = async (path, payload) => {
+		const url = `${base}${path}`;
+		for (let attempt = 0;; attempt++) {
+			const response = await request(url, payload);
+			if (response.ok) return new Uint8Array(await response.arrayBuffer());
+			if (attempt === 0 && RETRYABLE_STATUSES.has(response.status)) continue;
+			throw new ProofServerError(`Proof server request failed: url="${url}", status="${response.status} ${response.statusText}"`, response.status);
+		}
+	};
+	return {
+		prove: async (preimage, keyLocation, overwriteBindingInput) => {
+			const [{ createProvingPayload }, keyMaterial] = await Promise.all([loadPayloadCodec(), resolveKeyMaterial(keyLocation)]);
+			return post("/prove", createProvingPayload(preimage, overwriteBindingInput, keyMaterial));
+		},
+		check: async (preimage, keyLocation) => {
+			const [{ createCheckPayload }, keyMaterial] = await Promise.all([loadPayloadCodec(), resolveKeyMaterial(keyLocation)]);
+			return post("/check", createCheckPayload(preimage, keyMaterial?.ir));
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/infra/providers.ts
+/**
+* The ledger era every provider seam serves. The framework reads it before
+* an operation starts and refuses a provider set that cannot carry a
+* transaction end to end, so a mismatch fails before any proof is paid for.
+*/
+const SERVED_ERAS = ["v9"];
+const v9 = (tx) => ({
+	version: "v9",
+	tx
+});
+const ZSWAP_SEED_LENGTH = 32;
+const defaultRandomBytes = (length) => crypto.getRandomValues(new Uint8Array(length));
+const defaultFetchBytes = async (url) => {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Artefact download failed: url="${url}", status="${response.status} ${response.statusText}"`);
+	return new Uint8Array(await response.arrayBuffer());
+};
+/**
+* In-memory {@link AccProviders}.privateStateProvider. The account private
+* state only needs to outlive one deploy-and-activate flow, so nothing is
+* written to disk; contract-address scoping is a no-op because each flow
+* gets its own provider instance.
+*/
+const createInMemoryPrivateStateProvider = () => {
+	const privateStates = /* @__PURE__ */ new Map();
+	const signingKeys = /* @__PURE__ */ new Map();
+	return {
+		setContractAddress: (_address) => void 0,
+		set: async (privateStateId, state) => {
+			privateStates.set(privateStateId, state);
+		},
+		get: async (privateStateId) => privateStates.get(privateStateId) ?? null,
+		remove: async (privateStateId) => {
+			privateStates.delete(privateStateId);
+		},
+		clear: async () => {
+			privateStates.clear();
+		},
+		setSigningKey: async (address, key) => {
+			signingKeys.set(address, key);
+		},
+		getSigningKey: async (address) => signingKeys.get(address) ?? null,
+		removeSigningKey: async (address) => {
+			signingKeys.delete(address);
+		},
+		clearSigningKeys: async () => {
+			signingKeys.clear();
+		}
+	};
+};
+/**
+* Assembles the midnight-js providers {@link deployAccount} runs through,
+* swapping the platform seams in where the stock providers would expect a
+* full wallet:
+*
+* - zkConfigProvider downloads ZK assets through {@link loadCircuitAssets},
+*   so every byte is verified against the manifest's sha256 pins. A
+*   verifier key asked for alone is downloaded alone, so deploying an
+*   account fetches no prover key it does not prove with. A circuit this
+*   module never proves, such as a secp256k1 grant withdrawal, has no
+*   manifest entry: its verifier key asked for alone is verified against
+*   the contract's own expected pin, and it is skipped when verifier keys
+*   are listed.
+* - proofProvider adapts the {@link PassportProver} to the ledger's
+*   circuit-level proving interface.
+* - walletProvider delegates balancing to the {@link FeeSponsor}; the user
+*   holds no tokens, so the sponsor covers every fee. Its Zswap keys are
+*   ephemeral, generated per flow: the transactions move no coins, the
+*   keys only satisfy transaction construction and are discarded with the
+*   providers.
+* - midnightProvider submits each finalized transaction over the node RPC
+*   relay, opening and closing a connection per submission.
+*
+* `onStage` reports the proving and sponsoring stages as they start, so
+* the caller can surface flow progress that otherwise happens inside
+* midnight-js calls.
+*/
+const createMidnightProviders = async ({ network, prover, sponsor, fetchBytes = defaultFetchBytes, manifest = accManifest, onStage, randomBytes = defaultRandomBytes, createPublicDataProvider, createSubmissionService }) => {
+	await applyNetworkId(network.networkId);
+	const ledger = await import("@midnightntwrk/ledger-v9");
+	const zswapKeys = ledger.ZswapSecretKeys.fromSeed(randomBytes(ZSWAP_SEED_LENGTH));
+	const coinPublicKey = zswapKeys.coinPublicKey;
+	const encryptionPublicKey = zswapKeys.encryptionPublicKey;
+	zswapKeys.clear();
+	const assetCache = /* @__PURE__ */ new Map();
+	const circuitAssets = async (circuit) => {
+		let assets = assetCache.get(circuit);
+		if (!assets) {
+			assets = loadCircuitAssets({
+				artefactUrl: network.artefactUrl,
+				circuit,
+				fetchBytes,
+				manifest
+			});
+			assetCache.set(circuit, assets);
+		}
+		return assets;
+	};
+	const isPinnedCircuit = (circuitId) => circuitId in manifest.circuits;
+	const verifierKeyCache = /* @__PURE__ */ new Map();
+	const verifierKeyPin = async (circuitId) => {
+		if (isPinnedCircuit(circuitId)) return manifest.circuits[circuitId].verifierKeySha256;
+		const { expectedVk } = await import("./acc-module-Cmj8EsIb.js").then((n) => n.n);
+		const expectedSha256 = expectedVk[circuitId];
+		if (!expectedSha256) throw new UnknownCircuitError(circuitId);
+		return expectedSha256;
+	};
+	const verifierKey = async (circuitId) => {
+		const cachedAssets = isPinnedCircuit(circuitId) ? assetCache.get(circuitId) : void 0;
+		if (cachedAssets) return (await cachedAssets).verifierKey;
+		let key = verifierKeyCache.get(circuitId);
+		if (!key) {
+			key = (async () => {
+				const expectedSha256 = await verifierKeyPin(circuitId);
+				return loadVerifierKey({
+					artefactUrl: network.artefactUrl,
+					circuit: circuitId,
+					fetchBytes,
+					expectedSha256
+				});
+			})();
+			verifierKeyCache.set(circuitId, key);
+		}
+		return key;
+	};
+	const zkConfigProvider = {
+		getZKIR: async (circuitId) => (await circuitAssets(circuitId)).zkir,
+		getProverKey: async (circuitId) => (await circuitAssets(circuitId)).proverKey,
+		getVerifierKey: async (circuitId) => verifierKey(circuitId),
+		getVerifierKeys: async (circuitIds) => Promise.all(circuitIds.filter((circuitId) => isPinnedCircuit(circuitId)).map(async (circuitId) => [circuitId, await verifierKey(circuitId)])),
+		get: async (circuitId) => ({
+			circuitId,
+			...await circuitAssets(circuitId)
+		})
+	};
+	const resolveKeyMaterial = createManifestKeyMaterialResolver({
+		artefactUrl: network.artefactUrl,
+		fetchBytes,
+		manifest
+	});
+	const provingProvider = {
+		prove: async (preimage, keyLocation, overwriteBindingInput) => prover.prove(preimage, keyLocation, overwriteBindingInput),
+		check: async (preimage, keyLocation) => ledger.parseCheckResult(await prover.check(preimage, keyLocation)),
+		lookupKey: async (keyLocation) => resolveKeyMaterial(keyLocation)
+	};
+	const proofProvider = {
+		supportedEras: SERVED_ERAS,
+		proveTx: async ({ tx }) => {
+			onStage?.("proving");
+			return v9(await tx.prove(provingProvider, ledger.CostModel.initialCostModel()));
+		}
+	};
+	const walletProvider = {
+		supportedEras: SERVED_ERAS,
+		getCoinPublicKey: () => coinPublicKey,
+		getEncryptionPublicKey: () => encryptionPublicKey,
+		balanceTx: async ({ tx }) => {
+			onStage?.("sponsoring");
+			const balanced = await sponsor.balanceAndSign(tx.serialize());
+			return v9(ledger.Transaction.deserialize("signature", "proof", "binding", balanced));
+		}
+	};
+	const defaultSubmissionService = async () => {
+		const { createNodeRelaySubmissionService } = await import("./node-relay-h4i5IlAQ.js");
+		return createNodeRelaySubmissionService(network.nodeUrl);
+	};
+	const midnightProvider = {
+		supportedEras: SERVED_ERAS,
+		submitTx: async ({ tx }) => {
+			const service = await (createSubmissionService ?? defaultSubmissionService)();
+			try {
+				await service.submitTransaction(tx, "InBlock");
+				return tx.identifiers().at(-1);
+			} finally {
+				await service.close();
+			}
+		}
+	};
+	const defaultPublicDataProvider = async () => {
+		const { indexerPublicDataProvider } = await import("@midnight-ntwrk/midnight-js-indexer-public-data-provider");
+		return indexerPublicDataProvider({
+			queryURL: network.indexerUrl,
+			subscriptionURL: network.indexerWsUrl
+		});
+	};
+	return {
+		publicDataProvider: await (createPublicDataProvider ?? defaultPublicDataProvider)(),
+		zkConfigProvider,
+		proofProvider,
+		privateStateProvider: createInMemoryPrivateStateProvider(),
+		walletProvider,
+		midnightProvider
+	};
+};
+//#endregion
+export { AccAddress as i, createHttpProver as n, applyNetworkId as r, createMidnightProviders as t };

package/dist/redacted-BmE2aXqr.js

@@ -0,0 +1,81 @@
+import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-yNxN4d5E.js";
+//#region ../../packages/lib/util-redacted/src/redacted.ts
+init__polyfill_buffer_patch();
+const RedactedSymbol = Symbol.for("@lace/Redacted");
+const InspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+const RedactedTagKey = "__redacted";
+const RedactedValueKey = "__redactedValue";
+const redactedString = () => "[REDACTED]";
+const decorateObject = (value) => {
+	Object.defineProperties(value, {
+		_tag: {
+			value: "Redacted",
+			configurable: true,
+			enumerable: true
+		},
+		[RedactedSymbol]: {
+			value,
+			configurable: true
+		},
+		[RedactedTagKey]: {
+			value: true,
+			configurable: true,
+			enumerable: true
+		},
+		toString: {
+			value: redactedString,
+			configurable: true
+		},
+		toJSON: {
+			value: redactedString,
+			configurable: true
+		},
+		[InspectSymbol]: {
+			value: redactedString,
+			configurable: true
+		}
+	});
+	return value;
+};
+const make = (value) => {
+	if (typeof value === "object" && value !== null) return decorateObject(value);
+	return {
+		_tag: "Redacted",
+		[RedactedSymbol]: value,
+		[RedactedTagKey]: true,
+		[RedactedValueKey]: value,
+		toString: redactedString,
+		toJSON: redactedString,
+		[InspectSymbol]: redactedString
+	};
+};
+const value = (self) => {
+	if (RedactedSymbol in self) return self[RedactedSymbol];
+	if (RedactedValueKey in self) return self[RedactedValueKey];
+	return self;
+};
+const unsafeWipe = (self) => {
+	const current = value(self);
+	if (current instanceof Uint8Array) current.fill(0);
+	else if (typeof import_buffer.Buffer !== "undefined" && import_buffer.Buffer.isBuffer(current)) current.fill(0);
+	delete self[RedactedSymbol];
+	delete self[RedactedValueKey];
+};
+const isRedacted = (value) => typeof value === "object" && value !== null && ("_tag" in value && value._tag === "Redacted" || RedactedTagKey in value);
+const filterRedacted = (value) => {
+	if (isRedacted(value)) return "[REDACTED]";
+	if (typeof value !== "object" || value === null) return value;
+	if (Array.isArray(value)) return value.map(filterRedacted);
+	const filtered = {};
+	for (const key in value) filtered[key] = filterRedacted(value[key]);
+	return filtered;
+};
+const Redacted = {
+	make,
+	value,
+	unsafeWipe,
+	isRedacted,
+	filterRedacted
+};
+//#endregion
+export { Redacted as t };

package/dist/redacted-CRZJLS3w.cjs

@@ -0,0 +1,86 @@
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+//#region ../../packages/lib/util-redacted/src/redacted.ts
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+const RedactedSymbol = Symbol.for("@lace/Redacted");
+const InspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+const RedactedTagKey = "__redacted";
+const RedactedValueKey = "__redactedValue";
+const redactedString = () => "[REDACTED]";
+const decorateObject = (value) => {
+	Object.defineProperties(value, {
+		_tag: {
+			value: "Redacted",
+			configurable: true,
+			enumerable: true
+		},
+		[RedactedSymbol]: {
+			value,
+			configurable: true
+		},
+		[RedactedTagKey]: {
+			value: true,
+			configurable: true,
+			enumerable: true
+		},
+		toString: {
+			value: redactedString,
+			configurable: true
+		},
+		toJSON: {
+			value: redactedString,
+			configurable: true
+		},
+		[InspectSymbol]: {
+			value: redactedString,
+			configurable: true
+		}
+	});
+	return value;
+};
+const make = (value) => {
+	if (typeof value === "object" && value !== null) return decorateObject(value);
+	return {
+		_tag: "Redacted",
+		[RedactedSymbol]: value,
+		[RedactedTagKey]: true,
+		[RedactedValueKey]: value,
+		toString: redactedString,
+		toJSON: redactedString,
+		[InspectSymbol]: redactedString
+	};
+};
+const value = (self) => {
+	if (RedactedSymbol in self) return self[RedactedSymbol];
+	if (RedactedValueKey in self) return self[RedactedValueKey];
+	return self;
+};
+const unsafeWipe = (self) => {
+	const current = value(self);
+	if (current instanceof Uint8Array) current.fill(0);
+	else if (typeof require__polyfill_buffer_patch.import_buffer.Buffer !== "undefined" && require__polyfill_buffer_patch.import_buffer.Buffer.isBuffer(current)) current.fill(0);
+	delete self[RedactedSymbol];
+	delete self[RedactedValueKey];
+};
+const isRedacted = (value) => typeof value === "object" && value !== null && ("_tag" in value && value._tag === "Redacted" || RedactedTagKey in value);
+const filterRedacted = (value) => {
+	if (isRedacted(value)) return "[REDACTED]";
+	if (typeof value !== "object" || value === null) return value;
+	if (Array.isArray(value)) return value.map(filterRedacted);
+	const filtered = {};
+	for (const key in value) filtered[key] = filterRedacted(value[key]);
+	return filtered;
+};
+const Redacted = {
+	make,
+	value,
+	unsafeWipe,
+	isRedacted,
+	filterRedacted
+};
+//#endregion
+Object.defineProperty(exports, "Redacted", {
+	enumerable: true,
+	get: function() {
+		return Redacted;
+	}
+});

package/dist/{retry-config-DC5IMaH7.cjs → retry-config-BaCfVC1H.cjs}

@@ -1,5 +1,5 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_is_retriable_error = require("./is-retriable-error-CeeuHqDa.cjs");
+const require_is_retriable_error = require("./is-retriable-error-Dpt860if.cjs");
 //#region ../../node_modules/backoff-rxjs/dist/utils.js
 var require_utils = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{retry-config-BcUmMS--.js → retry-config-Dmgt28wM.js}

@@ -1,4 +1,4 @@
-import { t as isRetriableError } from "./is-retriable-error-BU0e3hVI.js";
+import { t as isRetriableError } from "./is-retriable-error-BUiVJDwH.js";
 import { concatMap, defer, iif, retryWhen, tap, throwError, timer } from "rxjs";
 //#region ../../node_modules/backoff-rxjs/dist/esm5/utils.js
 function getDelay(backoffDelay, maxInterval) {

package/dist/safe-buffer-B_vMqJWU.js

@@ -0,0 +1,43 @@
+import { i as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-OvD0k9op.js";
+import { r as init__polyfill_buffer_patch, t as _polyfill_buffer_patch_exports } from "./_polyfill-buffer-patch-yNxN4d5E.js";
+//#region ../../node_modules/safe-buffer/index.js
+var require_safe_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+	var buffer = (init__polyfill_buffer_patch(), __toCommonJS(_polyfill_buffer_patch_exports));
+	var Buffer = buffer.Buffer;
+	function copyProps(src, dst) {
+		for (var key in src) dst[key] = src[key];
+	}
+	if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
+	else {
+		copyProps(buffer, exports);
+		exports.Buffer = SafeBuffer;
+	}
+	function SafeBuffer(arg, encodingOrOffset, length) {
+		return Buffer(arg, encodingOrOffset, length);
+	}
+	SafeBuffer.prototype = Object.create(Buffer.prototype);
+	copyProps(Buffer, SafeBuffer);
+	SafeBuffer.from = function(arg, encodingOrOffset, length) {
+		if (typeof arg === "number") throw new TypeError("Argument must not be a number");
+		return Buffer(arg, encodingOrOffset, length);
+	};
+	SafeBuffer.alloc = function(size, fill, encoding) {
+		if (typeof size !== "number") throw new TypeError("Argument must be a number");
+		var buf = Buffer(size);
+		if (fill !== void 0) if (typeof encoding === "string") buf.fill(fill, encoding);
+		else buf.fill(fill);
+		else buf.fill(0);
+		return buf;
+	};
+	SafeBuffer.allocUnsafe = function(size) {
+		if (typeof size !== "number") throw new TypeError("Argument must be a number");
+		return Buffer(size);
+	};
+	SafeBuffer.allocUnsafeSlow = function(size) {
+		if (typeof size !== "number") throw new TypeError("Argument must be a number");
+		return buffer.SlowBuffer(size);
+	};
+}));
+//#endregion
+export { require_safe_buffer as t };

package/dist/safe-buffer-DYOwEfHB.cjs

@@ -0,0 +1,48 @@
+const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+//#region ../../node_modules/safe-buffer/index.js
+var require_safe_buffer = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+	var buffer = (require__polyfill_buffer_patch.init__polyfill_buffer_patch(), require_rolldown_runtime.__toCommonJS(require__polyfill_buffer_patch._polyfill_buffer_patch_exports));
+	var Buffer = buffer.Buffer;
+	function copyProps(src, dst) {
+		for (var key in src) dst[key] = src[key];
+	}
+	if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
+	else {
+		copyProps(buffer, exports);
+		exports.Buffer = SafeBuffer;
+	}
+	function SafeBuffer(arg, encodingOrOffset, length) {
+		return Buffer(arg, encodingOrOffset, length);
+	}
+	SafeBuffer.prototype = Object.create(Buffer.prototype);
+	copyProps(Buffer, SafeBuffer);
+	SafeBuffer.from = function(arg, encodingOrOffset, length) {
+		if (typeof arg === "number") throw new TypeError("Argument must not be a number");
+		return Buffer(arg, encodingOrOffset, length);
+	};
+	SafeBuffer.alloc = function(size, fill, encoding) {
+		if (typeof size !== "number") throw new TypeError("Argument must be a number");
+		var buf = Buffer(size);
+		if (fill !== void 0) if (typeof encoding === "string") buf.fill(fill, encoding);
+		else buf.fill(fill);
+		else buf.fill(0);
+		return buf;
+	};
+	SafeBuffer.allocUnsafe = function(size) {
+		if (typeof size !== "number") throw new TypeError("Argument must be a number");
+		return Buffer(size);
+	};
+	SafeBuffer.allocUnsafeSlow = function(size) {
+		if (typeof size !== "number") throw new TypeError("Argument must be a number");
+		return buffer.SlowBuffer(size);
+	};
+}));
+//#endregion
+Object.defineProperty(exports, "require_safe_buffer", {
+	enumerable: true,
+	get: function() {
+		return require_safe_buffer;
+	}
+});