peachsim 0.1.527

package/dist-lib/metro-fingerprint-registry.cjs

@@ -0,0 +1,186 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/metro-fingerprint-registry.ts
+var metro_fingerprint_registry_exports = {};
+__export(metro_fingerprint_registry_exports, {
+  RNX_METRO_FINGERPRINT_MAX_PAYLOAD_BYTES: () => RNX_METRO_FINGERPRINT_MAX_PAYLOAD_BYTES,
+  RNX_METRO_FINGERPRINT_MAX_POINTER_BYTES: () => RNX_METRO_FINGERPRINT_MAX_POINTER_BYTES,
+  RNX_METRO_FINGERPRINT_POINTER_PATH: () => RNX_METRO_FINGERPRINT_POINTER_PATH,
+  RNX_METRO_FINGERPRINT_SCHEMA_VERSION: () => RNX_METRO_FINGERPRINT_SCHEMA_VERSION,
+  parseRNXMetroFingerprintPointer: () => parseRNXMetroFingerprintPointer,
+  parseRNXMetroFingerprintRegistry: () => parseRNXMetroFingerprintRegistry
+});
+module.exports = __toCommonJS(metro_fingerprint_registry_exports);
+var RNX_METRO_FINGERPRINT_SCHEMA_VERSION = 2;
+var RNX_METRO_FINGERPRINT_POINTER_PATH = "/compile/metro-fingerprints.json";
+var RNX_METRO_FINGERPRINT_MAX_POINTER_BYTES = 16 * 1024;
+var RNX_METRO_FINGERPRINT_MAX_PAYLOAD_BYTES = 8 * 1024 * 1024;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSha256(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function readStringArray(value) {
+  if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) {
+    return null;
+  }
+  const entries = [...value];
+  if (new Set(entries).size !== entries.length || entries.some((entry, index) => index > 0 && entries[index - 1] >= entry)) {
+    return null;
+  }
+  return entries;
+}
+function parseRNXMetroFingerprintPointer(value) {
+  if (!isRecord(value)) return null;
+  const { schemaVersion, revision, integrity, bytes, payloadUrl } = value;
+  if (schemaVersion !== RNX_METRO_FINGERPRINT_SCHEMA_VERSION || !isSha256(revision) || !isSha256(integrity) || typeof bytes !== "number" || !Number.isSafeInteger(bytes) || bytes < 1 || typeof payloadUrl !== "string" || payloadUrl.length === 0) {
+    return null;
+  }
+  return { schemaVersion, revision, integrity, bytes, payloadUrl };
+}
+function parseRNXMetroFingerprintRegistry(value) {
+  if (!isRecord(value)) return null;
+  const { schemaVersion, revision } = value;
+  if (schemaVersion !== RNX_METRO_FINGERPRINT_SCHEMA_VERSION || !isSha256(revision) || !Array.isArray(value.atoms) || !Array.isArray(value.templates) || !isRecord(value.candidatesByFactoryDigest) || !isRecord(value.candidatesByDiscriminator)) {
+    return null;
+  }
+  const atoms = [];
+  for (const atomValue of value.atoms) {
+    if (!isRecord(atomValue)) return null;
+    const exports2 = readStringArray(atomValue.exports);
+    const literals = readStringArray(atomValue.literals);
+    if (typeof atomValue.key !== "string" || atomValue.key.length === 0 || !exports2 || !literals || typeof atomValue.dependencyArity !== "number" || !Number.isSafeInteger(atomValue.dependencyArity) || atomValue.dependencyArity < 0 || !isSha256(atomValue.factoryDigest)) {
+      return null;
+    }
+    atoms.push({
+      key: atomValue.key,
+      exports: exports2,
+      literals,
+      dependencyArity: atomValue.dependencyArity,
+      factoryDigest: atomValue.factoryDigest
+    });
+  }
+  const templates = [];
+  for (const templateValue of value.templates) {
+    if (!isRecord(templateValue) || typeof templateValue.packageName !== "string" || templateValue.packageName.length === 0 || typeof templateValue.packageVersion !== "string" || templateValue.packageVersion.length === 0 || !isSha256(templateValue.sourceIntegrity) || typeof templateValue.profile !== "string" || templateValue.profile.length === 0 || templateValue.platform !== "ios" && templateValue.platform !== "android" || !Array.isArray(templateValue.nodes) || templateValue.nodes.length === 0 || !Array.isArray(templateValue.roots) || templateValue.roots.length === 0) {
+      return null;
+    }
+    const nodes = [];
+    for (const nodeValue of templateValue.nodes) {
+      if (!isRecord(nodeValue) || typeof nodeValue.atom !== "number" || !Number.isSafeInteger(nodeValue.atom) || nodeValue.atom < 0 || nodeValue.atom >= atoms.length || !Array.isArray(nodeValue.internalDependencies) || nodeValue.landmarkPath !== void 0 && (typeof nodeValue.landmarkPath !== "string" || nodeValue.landmarkPath.length === 0)) {
+        return null;
+      }
+      const internalDependencies = [];
+      const positions = /* @__PURE__ */ new Set();
+      for (const edgeValue of nodeValue.internalDependencies) {
+        if (!isRecord(edgeValue) || typeof edgeValue.position !== "number" || !Number.isSafeInteger(edgeValue.position) || edgeValue.position < 0 || positions.has(edgeValue.position) || typeof edgeValue.node !== "number" || !Number.isSafeInteger(edgeValue.node) || edgeValue.node < 0 || edgeValue.node >= templateValue.nodes.length) {
+          return null;
+        }
+        positions.add(edgeValue.position);
+        internalDependencies.push({
+          position: edgeValue.position,
+          node: edgeValue.node
+        });
+      }
+      internalDependencies.sort((left, right) => left.position - right.position);
+      nodes.push({
+        atom: nodeValue.atom,
+        internalDependencies,
+        ...typeof nodeValue.landmarkPath === "string" ? { landmarkPath: nodeValue.landmarkPath } : {}
+      });
+    }
+    const roots = [];
+    for (const rootValue of templateValue.roots) {
+      if (!isRecord(rootValue) || typeof rootValue.node !== "number" || !Number.isSafeInteger(rootValue.node) || rootValue.node < 0 || rootValue.node >= nodes.length || !nodes[rootValue.node].landmarkPath) {
+        return null;
+      }
+      roots.push({ node: rootValue.node });
+    }
+    templates.push({
+      packageName: templateValue.packageName,
+      packageVersion: templateValue.packageVersion,
+      sourceIntegrity: templateValue.sourceIntegrity,
+      profile: templateValue.profile,
+      platform: templateValue.platform,
+      nodes,
+      roots
+    });
+  }
+  const candidatesByFactoryDigest = {};
+  for (const [factoryDigest, candidateValues] of Object.entries(
+    value.candidatesByFactoryDigest
+  )) {
+    if (!isSha256(factoryDigest) || !Array.isArray(candidateValues)) return null;
+    const candidates = [];
+    for (const candidateValue of candidateValues) {
+      if (!isRecord(candidateValue) || typeof candidateValue.template !== "number" || !Number.isSafeInteger(candidateValue.template) || candidateValue.template < 0 || candidateValue.template >= templates.length || typeof candidateValue.root !== "number" || !Number.isSafeInteger(candidateValue.root) || candidateValue.root < 0 || candidateValue.root >= templates[candidateValue.template].roots.length) {
+        return null;
+      }
+      const template = templates[candidateValue.template];
+      const root = template.roots[candidateValue.root];
+      if (atoms[template.nodes[root.node].atom].factoryDigest !== factoryDigest) {
+        return null;
+      }
+      candidates.push({
+        template: candidateValue.template,
+        root: candidateValue.root
+      });
+    }
+    candidatesByFactoryDigest[factoryDigest] = candidates;
+  }
+  const candidatesByDiscriminator = {};
+  for (const [discriminator, candidateValues] of Object.entries(
+    value.candidatesByDiscriminator
+  )) {
+    if (!/^(?:e|l|ea|la|el|ela):[a-f0-9]{16}$/.test(discriminator)) return null;
+    if (!Array.isArray(candidateValues) || candidateValues.length === 0) return null;
+    const candidates = [];
+    for (const candidateValue of candidateValues) {
+      if (!isRecord(candidateValue) || typeof candidateValue.template !== "number" || !Number.isSafeInteger(candidateValue.template) || candidateValue.template < 0 || candidateValue.template >= templates.length || typeof candidateValue.root !== "number" || !Number.isSafeInteger(candidateValue.root) || candidateValue.root < 0 || candidateValue.root >= templates[candidateValue.template].roots.length) {
+        return null;
+      }
+      candidates.push({
+        template: candidateValue.template,
+        root: candidateValue.root
+      });
+    }
+    candidatesByDiscriminator[discriminator] = candidates;
+  }
+  return {
+    schemaVersion,
+    revision,
+    atoms,
+    templates,
+    candidatesByFactoryDigest,
+    candidatesByDiscriminator
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RNX_METRO_FINGERPRINT_MAX_PAYLOAD_BYTES,
+  RNX_METRO_FINGERPRINT_MAX_POINTER_BYTES,
+  RNX_METRO_FINGERPRINT_POINTER_PATH,
+  RNX_METRO_FINGERPRINT_SCHEMA_VERSION,
+  parseRNXMetroFingerprintPointer,
+  parseRNXMetroFingerprintRegistry
+});

package/dist-lib/metro-fingerprint-registry.mjs

@@ -0,0 +1,156 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+
+// src/metro-fingerprint-registry.ts
+var RNX_METRO_FINGERPRINT_SCHEMA_VERSION = 2;
+var RNX_METRO_FINGERPRINT_POINTER_PATH = "/compile/metro-fingerprints.json";
+var RNX_METRO_FINGERPRINT_MAX_POINTER_BYTES = 16 * 1024;
+var RNX_METRO_FINGERPRINT_MAX_PAYLOAD_BYTES = 8 * 1024 * 1024;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSha256(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function readStringArray(value) {
+  if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) {
+    return null;
+  }
+  const entries = [...value];
+  if (new Set(entries).size !== entries.length || entries.some((entry, index) => index > 0 && entries[index - 1] >= entry)) {
+    return null;
+  }
+  return entries;
+}
+function parseRNXMetroFingerprintPointer(value) {
+  if (!isRecord(value)) return null;
+  const { schemaVersion, revision, integrity, bytes, payloadUrl } = value;
+  if (schemaVersion !== RNX_METRO_FINGERPRINT_SCHEMA_VERSION || !isSha256(revision) || !isSha256(integrity) || typeof bytes !== "number" || !Number.isSafeInteger(bytes) || bytes < 1 || typeof payloadUrl !== "string" || payloadUrl.length === 0) {
+    return null;
+  }
+  return { schemaVersion, revision, integrity, bytes, payloadUrl };
+}
+function parseRNXMetroFingerprintRegistry(value) {
+  if (!isRecord(value)) return null;
+  const { schemaVersion, revision } = value;
+  if (schemaVersion !== RNX_METRO_FINGERPRINT_SCHEMA_VERSION || !isSha256(revision) || !Array.isArray(value.atoms) || !Array.isArray(value.templates) || !isRecord(value.candidatesByFactoryDigest) || !isRecord(value.candidatesByDiscriminator)) {
+    return null;
+  }
+  const atoms = [];
+  for (const atomValue of value.atoms) {
+    if (!isRecord(atomValue)) return null;
+    const exports = readStringArray(atomValue.exports);
+    const literals = readStringArray(atomValue.literals);
+    if (typeof atomValue.key !== "string" || atomValue.key.length === 0 || !exports || !literals || typeof atomValue.dependencyArity !== "number" || !Number.isSafeInteger(atomValue.dependencyArity) || atomValue.dependencyArity < 0 || !isSha256(atomValue.factoryDigest)) {
+      return null;
+    }
+    atoms.push({
+      key: atomValue.key,
+      exports,
+      literals,
+      dependencyArity: atomValue.dependencyArity,
+      factoryDigest: atomValue.factoryDigest
+    });
+  }
+  const templates = [];
+  for (const templateValue of value.templates) {
+    if (!isRecord(templateValue) || typeof templateValue.packageName !== "string" || templateValue.packageName.length === 0 || typeof templateValue.packageVersion !== "string" || templateValue.packageVersion.length === 0 || !isSha256(templateValue.sourceIntegrity) || typeof templateValue.profile !== "string" || templateValue.profile.length === 0 || templateValue.platform !== "ios" && templateValue.platform !== "android" || !Array.isArray(templateValue.nodes) || templateValue.nodes.length === 0 || !Array.isArray(templateValue.roots) || templateValue.roots.length === 0) {
+      return null;
+    }
+    const nodes = [];
+    for (const nodeValue of templateValue.nodes) {
+      if (!isRecord(nodeValue) || typeof nodeValue.atom !== "number" || !Number.isSafeInteger(nodeValue.atom) || nodeValue.atom < 0 || nodeValue.atom >= atoms.length || !Array.isArray(nodeValue.internalDependencies) || nodeValue.landmarkPath !== void 0 && (typeof nodeValue.landmarkPath !== "string" || nodeValue.landmarkPath.length === 0)) {
+        return null;
+      }
+      const internalDependencies = [];
+      const positions = /* @__PURE__ */ new Set();
+      for (const edgeValue of nodeValue.internalDependencies) {
+        if (!isRecord(edgeValue) || typeof edgeValue.position !== "number" || !Number.isSafeInteger(edgeValue.position) || edgeValue.position < 0 || positions.has(edgeValue.position) || typeof edgeValue.node !== "number" || !Number.isSafeInteger(edgeValue.node) || edgeValue.node < 0 || edgeValue.node >= templateValue.nodes.length) {
+          return null;
+        }
+        positions.add(edgeValue.position);
+        internalDependencies.push({
+          position: edgeValue.position,
+          node: edgeValue.node
+        });
+      }
+      internalDependencies.sort((left, right) => left.position - right.position);
+      nodes.push({
+        atom: nodeValue.atom,
+        internalDependencies,
+        ...typeof nodeValue.landmarkPath === "string" ? { landmarkPath: nodeValue.landmarkPath } : {}
+      });
+    }
+    const roots = [];
+    for (const rootValue of templateValue.roots) {
+      if (!isRecord(rootValue) || typeof rootValue.node !== "number" || !Number.isSafeInteger(rootValue.node) || rootValue.node < 0 || rootValue.node >= nodes.length || !nodes[rootValue.node].landmarkPath) {
+        return null;
+      }
+      roots.push({ node: rootValue.node });
+    }
+    templates.push({
+      packageName: templateValue.packageName,
+      packageVersion: templateValue.packageVersion,
+      sourceIntegrity: templateValue.sourceIntegrity,
+      profile: templateValue.profile,
+      platform: templateValue.platform,
+      nodes,
+      roots
+    });
+  }
+  const candidatesByFactoryDigest = {};
+  for (const [factoryDigest, candidateValues] of Object.entries(
+    value.candidatesByFactoryDigest
+  )) {
+    if (!isSha256(factoryDigest) || !Array.isArray(candidateValues)) return null;
+    const candidates = [];
+    for (const candidateValue of candidateValues) {
+      if (!isRecord(candidateValue) || typeof candidateValue.template !== "number" || !Number.isSafeInteger(candidateValue.template) || candidateValue.template < 0 || candidateValue.template >= templates.length || typeof candidateValue.root !== "number" || !Number.isSafeInteger(candidateValue.root) || candidateValue.root < 0 || candidateValue.root >= templates[candidateValue.template].roots.length) {
+        return null;
+      }
+      const template = templates[candidateValue.template];
+      const root = template.roots[candidateValue.root];
+      if (atoms[template.nodes[root.node].atom].factoryDigest !== factoryDigest) {
+        return null;
+      }
+      candidates.push({
+        template: candidateValue.template,
+        root: candidateValue.root
+      });
+    }
+    candidatesByFactoryDigest[factoryDigest] = candidates;
+  }
+  const candidatesByDiscriminator = {};
+  for (const [discriminator, candidateValues] of Object.entries(
+    value.candidatesByDiscriminator
+  )) {
+    if (!/^(?:e|l|ea|la|el|ela):[a-f0-9]{16}$/.test(discriminator)) return null;
+    if (!Array.isArray(candidateValues) || candidateValues.length === 0) return null;
+    const candidates = [];
+    for (const candidateValue of candidateValues) {
+      if (!isRecord(candidateValue) || typeof candidateValue.template !== "number" || !Number.isSafeInteger(candidateValue.template) || candidateValue.template < 0 || candidateValue.template >= templates.length || typeof candidateValue.root !== "number" || !Number.isSafeInteger(candidateValue.root) || candidateValue.root < 0 || candidateValue.root >= templates[candidateValue.template].roots.length) {
+        return null;
+      }
+      candidates.push({
+        template: candidateValue.template,
+        root: candidateValue.root
+      });
+    }
+    candidatesByDiscriminator[discriminator] = candidates;
+  }
+  return {
+    schemaVersion,
+    revision,
+    atoms,
+    templates,
+    candidatesByFactoryDigest,
+    candidatesByDiscriminator
+  };
+}
+export {
+  RNX_METRO_FINGERPRINT_MAX_PAYLOAD_BYTES,
+  RNX_METRO_FINGERPRINT_MAX_POINTER_BYTES,
+  RNX_METRO_FINGERPRINT_POINTER_PATH,
+  RNX_METRO_FINGERPRINT_SCHEMA_VERSION,
+  parseRNXMetroFingerprintPointer,
+  parseRNXMetroFingerprintRegistry
+};

package/dist-lib/metro-production-bundle.cjs

@@ -0,0 +1,329 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/metro-production-bundle.ts
+var metro_production_bundle_exports = {};
+__export(metro_production_bundle_exports, {
+  RNX_METRO_MODULE_IDENTITY_VERSION: () => RNX_METRO_MODULE_IDENTITY_VERSION,
+  appendRNXMetroModuleIdentityFooter: () => appendRNXMetroModuleIdentityFooter,
+  createRNXMetroModuleIdentityFooter: () => createRNXMetroModuleIdentityFooter,
+  detachRNXMetroSourceMapUrl: () => detachRNXMetroSourceMapUrl,
+  readRNXMetroBundleLayout: () => readRNXMetroBundleLayout,
+  readRNXMetroModuleIdentity: () => readRNXMetroModuleIdentity,
+  toRNXDevelopmentBundleUrl: () => toRNXDevelopmentBundleUrl,
+  toRNXProductionBundleUrl: () => toRNXProductionBundleUrl,
+  validateRNXMetroModuleIdentity: () => validateRNXMetroModuleIdentity,
+  validateRNXMetroModulePaths: () => validateRNXMetroModulePaths
+});
+module.exports = __toCommonJS(metro_production_bundle_exports);
+var RNXSIM_METRO_MODULE_PATHS_PREFIX = "globalThis.__sootsimModulePaths=";
+var RNX_METRO_MODULE_IDENTITY_VERSION = 2;
+function toRNXProductionBundleUrl(bundleUrl) {
+  const relative = bundleUrl.startsWith("/");
+  const url = new URL(bundleUrl, "http://rnxsim.local");
+  url.searchParams.set("dev", "false");
+  url.searchParams.set("hot", "false");
+  url.searchParams.set("minify", "true");
+  return relative ? `${url.pathname}${url.search}${url.hash}` : url.toString();
+}
+function toRNXDevelopmentBundleUrl(bundleUrl) {
+  const relative = bundleUrl.startsWith("/");
+  const url = new URL(bundleUrl, "http://rnxsim.local");
+  url.searchParams.set("dev", "true");
+  url.searchParams.set("hot", "false");
+  url.searchParams.set("minify", "false");
+  return relative ? `${url.pathname}${url.search}${url.hash}` : url.toString();
+}
+var RNXSIM_METRO_SOURCE_MAP_COMMENT = "//# sourceMappingURL=";
+function detachRNXMetroSourceMapUrl(bundleText) {
+  const trimmedEnd = bundleText.replace(/\s+$/, "");
+  const commentStart = trimmedEnd.lastIndexOf(`
+${RNXSIM_METRO_SOURCE_MAP_COMMENT}`);
+  if (commentStart < 0) return { source: bundleText, sourceMappingUrl: null };
+  const url = trimmedEnd.slice(commentStart + 1 + RNXSIM_METRO_SOURCE_MAP_COMMENT.length);
+  if (url.includes("\n")) return { source: bundleText, sourceMappingUrl: null };
+  return { source: trimmedEnd.slice(0, commentStart), sourceMappingUrl: url };
+}
+function createRNXMetroModuleIdentityFooter(identity) {
+  const payload = JSON.stringify(identity).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029").replace(/<\//g, "<\\/");
+  return `
+${RNXSIM_METRO_MODULE_PATHS_PREFIX}${payload};`;
+}
+function appendRNXMetroModuleIdentityFooter(bundleText, identity) {
+  const footer = createRNXMetroModuleIdentityFooter(identity);
+  const detached = detachRNXMetroSourceMapUrl(bundleText);
+  return detached.sourceMappingUrl === null ? bundleText + footer : `${detached.source}${footer}
+${RNXSIM_METRO_SOURCE_MAP_COMMENT}${detached.sourceMappingUrl}`;
+}
+function readRNXMetroModuleIdentity(bundleText) {
+  const detached = detachRNXMetroSourceMapUrl(bundleText);
+  const withoutMap = detached.source;
+  const footerPrefix = `
+${RNXSIM_METRO_MODULE_PATHS_PREFIX}`;
+  const footerStart = withoutMap.lastIndexOf(footerPrefix);
+  if (footerStart < 0) return null;
+  if (!withoutMap.endsWith(";")) {
+    throw new Error("Metro module identity footer is truncated");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(withoutMap.slice(footerStart + footerPrefix.length, -1));
+  } catch {
+    throw new Error("Metro module identity footer is not valid JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("Metro module identity footer is malformed");
+  }
+  const version = Reflect.get(parsed, "version");
+  if (version === void 0) {
+    const modulePaths2 = Object.fromEntries(
+      Object.entries(parsed).map(([moduleId, modulePath]) => {
+        if (typeof modulePath !== "string") {
+          throw new Error(`Metro module identity has an invalid path for ${moduleId}`);
+        }
+        return [moduleId, modulePath];
+      })
+    );
+    return {
+      source: withoutMap.slice(0, footerStart),
+      version: RNX_METRO_MODULE_IDENTITY_VERSION,
+      identitySource: "rnx-plugin",
+      modulePaths: modulePaths2,
+      logicalSpecifiers: {},
+      sourceMappingUrl: detached.sourceMappingUrl
+    };
+  }
+  const identitySource = Reflect.get(parsed, "identitySource");
+  const parsedModulePaths = Reflect.get(parsed, "modulePaths");
+  const parsedLogicalSpecifiers = Reflect.get(parsed, "logicalSpecifiers");
+  if (version !== RNX_METRO_MODULE_IDENTITY_VERSION || identitySource !== "rnx-plugin" && identitySource !== "contrast-bundler" && identitySource !== "metro-source-map" || typeof parsedModulePaths !== "object" || parsedModulePaths === null || Array.isArray(parsedModulePaths) || typeof parsedLogicalSpecifiers !== "object" || parsedLogicalSpecifiers === null || Array.isArray(parsedLogicalSpecifiers)) {
+    throw new Error("Metro module identity footer is malformed");
+  }
+  const modulePaths = Object.fromEntries(
+    Object.entries(parsedModulePaths).map(([moduleId, modulePath]) => {
+      if (typeof modulePath !== "string") {
+        throw new Error(`Metro module identity has an invalid path for ${moduleId}`);
+      }
+      return [moduleId, modulePath];
+    })
+  );
+  const logicalSpecifiers = Object.fromEntries(
+    Object.entries(parsedLogicalSpecifiers).map(([moduleId, specifiers]) => {
+      if (!Array.isArray(specifiers) || specifiers.length === 0 || !specifiers.every(
+        (specifier) => typeof specifier === "string" && specifier.length > 0
+      )) {
+        throw new Error(`Metro module identity has invalid specifiers for ${moduleId}`);
+      }
+      const unique = [...new Set(specifiers)].sort(
+        (left, right) => left.localeCompare(right)
+      );
+      if (unique.length !== specifiers.length) {
+        throw new Error(`Metro module identity repeats a specifier for ${moduleId}`);
+      }
+      return [moduleId, unique];
+    })
+  );
+  return {
+    source: withoutMap.slice(0, footerStart),
+    version,
+    identitySource,
+    modulePaths,
+    logicalSpecifiers,
+    sourceMappingUrl: detached.sourceMappingUrl
+  };
+}
+function readStringLiteralStart(source, start, end) {
+  const quote = source[end];
+  if (quote !== '"' && quote !== "'") return -1;
+  for (let index = end - 1; index > start; index--) {
+    if (source[index] !== quote) continue;
+    let backslashes = 0;
+    while (index - 1 - backslashes > start && source[index - 1 - backslashes] === "\\") {
+      backslashes++;
+    }
+    if (backslashes % 2 === 0) return index;
+  }
+  return -1;
+}
+function readDefineTail(source, start, end) {
+  let cursor = end;
+  while (cursor > start && (source[cursor] === " " || source[cursor] === "\n" || source[cursor] === "	" || source[cursor] === ";")) {
+    cursor--;
+  }
+  if (source[cursor] !== ")") return null;
+  cursor--;
+  while (cursor > start && /\s/.test(source[cursor])) cursor--;
+  let verboseNameStart;
+  let verboseNameEnd;
+  if (source[cursor] === '"' || source[cursor] === "'") {
+    const literalStart = readStringLiteralStart(source, start, cursor);
+    if (literalStart < 0) return null;
+    verboseNameStart = literalStart;
+    verboseNameEnd = cursor + 1;
+    cursor = literalStart - 1;
+    while (cursor > start && /\s/.test(source[cursor])) cursor--;
+    if (source[cursor] !== ",") return null;
+    cursor--;
+    while (cursor > start && /\s/.test(source[cursor])) cursor--;
+  }
+  if (source[cursor] !== "]") return null;
+  const dependenciesEnd = cursor + 1;
+  let depth = 1;
+  cursor--;
+  while (cursor > start && depth > 0) {
+    const character = source[cursor];
+    if (character === "]") depth++;
+    else if (character === "[") depth--;
+    if (depth === 0) break;
+    cursor--;
+  }
+  if (depth !== 0) return null;
+  const dependenciesStart = cursor;
+  let idEnd = cursor - 1;
+  while (idEnd > start && /\s/.test(source[idEnd])) idEnd--;
+  if (source[idEnd] !== ",") return null;
+  let idStart = idEnd;
+  while (idStart > start && /[0-9a-fA-FxX.+-]/.test(source[idStart - 1])) idStart--;
+  const literal = source.slice(idStart, idEnd);
+  if (!/^-?(?:0[xXbBoO][0-9a-fA-F]+|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)$/.test(literal)) {
+    return null;
+  }
+  const moduleId = Number(literal);
+  if (!Number.isSafeInteger(moduleId)) return null;
+  let factoryEnd = idStart - 1;
+  while (factoryEnd > start && /\s/.test(source[factoryEnd])) factoryEnd--;
+  if (source[factoryEnd] !== ",") return null;
+  return {
+    moduleId,
+    factoryEnd,
+    dependenciesStart,
+    dependenciesEnd,
+    verboseNameStart,
+    verboseNameEnd
+  };
+}
+function readRNXMetroBundleLayout(source) {
+  const lineOffsets = [0];
+  for (let index = 0; index < source.length; index++) {
+    if (source.charCodeAt(index) === 10) lineOffsets.push(index + 1);
+  }
+  const boundaries = [];
+  for (let lineIndex = 0; lineIndex < lineOffsets.length; lineIndex++) {
+    const start = lineOffsets[lineIndex];
+    if (source.startsWith("__d(", start) || source.startsWith("__r(", start)) {
+      boundaries.push(lineIndex);
+    }
+  }
+  const statements = [];
+  let moduleIdFailures = 0;
+  for (let index = 0; index < boundaries.length; index++) {
+    const lineIndex = boundaries[index];
+    const start = lineOffsets[lineIndex];
+    const nextLineIndex = boundaries[index + 1];
+    const endLineIndex = nextLineIndex !== void 0 ? nextLineIndex - 1 : lineOffsets.length - 1;
+    const end = nextLineIndex !== void 0 ? lineOffsets[nextLineIndex] : source.length;
+    if (!source.startsWith("__d(", start)) {
+      statements.push({ kind: "run", start, end, lineIndex, endLineIndex });
+      continue;
+    }
+    const tail = readDefineTail(source, start, end - 1);
+    if (!tail) {
+      moduleIdFailures++;
+      continue;
+    }
+    statements.push({
+      kind: "define",
+      moduleId: tail.moduleId,
+      start,
+      end,
+      lineIndex,
+      endLineIndex,
+      factory: { start: start + "__d(".length, end: tail.factoryEnd },
+      dependencies: { start: tail.dependenciesStart, end: tail.dependenciesEnd },
+      ...tail.verboseNameStart !== void 0 && tail.verboseNameEnd !== void 0 ? { verboseName: { start: tail.verboseNameStart, end: tail.verboseNameEnd } } : {}
+    });
+  }
+  return {
+    prelude: source.slice(
+      0,
+      boundaries.length > 0 ? lineOffsets[boundaries[0]] : source.length
+    ),
+    statements,
+    moduleIdFailures
+  };
+}
+function validateRNXMetroModulePaths(source, modulePaths) {
+  const layout = readRNXMetroBundleLayout(source);
+  if (layout.moduleIdFailures > 0) {
+    throw new Error(
+      `Metro module identity could not read ${layout.moduleIdFailures} module IDs`
+    );
+  }
+  const definedIds = /* @__PURE__ */ new Set();
+  for (const statement of layout.statements) {
+    if (statement.kind !== "define") continue;
+    if (definedIds.has(statement.moduleId)) {
+      throw new Error(`Metro module identity has duplicate module ${statement.moduleId}`);
+    }
+    definedIds.add(statement.moduleId);
+    if (!Object.prototype.hasOwnProperty.call(modulePaths, String(statement.moduleId))) {
+      throw new Error(`Metro module identity is missing ${statement.moduleId}`);
+    }
+  }
+  if (definedIds.size === 0) {
+    throw new Error("Metro module identity found no canonical JavaScript modules");
+  }
+  for (const [key, modulePath] of Object.entries(modulePaths)) {
+    const moduleId = Number(key);
+    if (!Number.isSafeInteger(moduleId) || String(moduleId) !== key) {
+      throw new Error(`Metro module identity has invalid module ID ${key}`);
+    }
+    if (typeof modulePath !== "string" || modulePath.length === 0) {
+      throw new Error(`Metro module identity has no path for ${key}`);
+    }
+    if (!definedIds.has(moduleId)) {
+      throw new Error(`Metro module identity has no module ${key}`);
+    }
+  }
+}
+function validateRNXMetroModuleIdentity(identity) {
+  validateRNXMetroModulePaths(identity.source, identity.modulePaths);
+  for (const moduleId of Object.keys(identity.logicalSpecifiers)) {
+    if (!Object.prototype.hasOwnProperty.call(identity.modulePaths, moduleId)) {
+      throw new Error(
+        `Metro module identity has logical specifiers for unknown module ${moduleId}`
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RNX_METRO_MODULE_IDENTITY_VERSION,
+  appendRNXMetroModuleIdentityFooter,
+  createRNXMetroModuleIdentityFooter,
+  detachRNXMetroSourceMapUrl,
+  readRNXMetroBundleLayout,
+  readRNXMetroModuleIdentity,
+  toRNXDevelopmentBundleUrl,
+  toRNXProductionBundleUrl,
+  validateRNXMetroModuleIdentity,
+  validateRNXMetroModulePaths
+});