@tinkerlandai/indiana-iam 0.5.0 → 0.6.0

package/src/generate.mjs

@@ -24,6 +24,8 @@ export async function analyzeSource({
   navigationPaths = [],
   entry,
   automaticAnchors = false,
+  platform = "web",
+  routerRoot,
 }) {
   root = await fs.realpath(root);
   return analyze({
@@ -34,6 +36,8 @@ export async function analyzeSource({
     navigationPaths,
     entry,
     automaticAnchors,
+    platform,
+    routerRoot,
   });
 }
 
@@ -50,6 +54,8 @@ export async function generateAppManifest({
   navigationPaths,
   entry,
   automaticAnchors = false,
+  platform,
+  routerRoot,
   releaseId,
   buildCss = [],
   publicAssets = [],
@@ -70,7 +76,11 @@ export async function generateAppManifest({
         navigationPaths,
         entry,
         automaticAnchors,
+        platform,
+        routerRoot,
       });
+  if (analysis && platform !== undefined && (analysis.app.platforms.length !== 1 || analysis.app.platforms[0] !== platform))
+    throw Error("Analyzed IAM belongs to another platform");
   for (const document of manifest.documents)
     if (document.domPayload) {
       Object.assign(document, documentDom(document));

package/src/index.d.ts

@@ -20,8 +20,12 @@ export type ValidationCounts = Record<string, unknown>;
 
 export type GenerateOptions = {
   root: string;
-  /** Browser entry relative to root. Defaults to the single module script in index.html. */
+  /** Web browser entry or single-root RN screen, relative to root. */
   entry?: string;
+  /** Defaults to web. RN/Expo artifacts are generated separately for ios and android. */
+  platform?: "web" | "ios" | "android";
+  /** Expo route root for a native platform; mutually exclusive with entry. */
+  routerRoot?: string;
   automaticAnchors?: boolean;
   /** A previous {@link analyzeSource} result; scanned again when omitted. */
   analysis?: AppManifest;
@@ -50,8 +54,12 @@ export type GeneratedAppManifest = {
 
 export declare function analyzeSource(options: {
   root: string;
-  /** Browser entry relative to root. Defaults to the single module script in index.html. */
+  /** Web browser entry or single-root RN screen, relative to root. */
   entry?: string;
+  /** Defaults to web. RN/Expo artifacts are generated separately for ios and android. */
+  platform?: "web" | "ios" | "android";
+  /** Expo route root for a native platform; mutually exclusive with entry. */
+  routerRoot?: string;
   automaticAnchors?: boolean;
   name?: string;
   repository?: string;
@@ -87,8 +95,12 @@ export type BuildLogger = Pick<Console, "log" | "warn">;
 export type BuildReleaseOptions = {
   strict?: boolean;
   logger?: BuildLogger;
-  /** Browser entry relative to root. Defaults to the single module script in index.html. */
+  /** Web browser entry or single-root RN screen, relative to root. */
   entry?: string;
+  /** Defaults to web. RN/Expo artifacts are generated separately for ios and android. */
+  platform?: "web" | "ios" | "android";
+  /** Expo route root for a native platform; mutually exclusive with entry. */
+  routerRoot?: string;
   automaticAnchors?: boolean;
 };
 export declare function prepareBuildRelease(
@@ -106,6 +118,7 @@ export declare function finishBuildRelease(
     omitSvgResources?: boolean;
     upload?: {
       apiKey?: string;
+      client?: string;
       baseUrl?: string;
       upload?: "production" | "always" | false;
       fetch?: typeof globalThis.fetch;

package/src/library-entry.mjs

@@ -19,7 +19,7 @@ export async function validateIamBytes(bytes) {
   const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
   const manifest = parseManifest(text);
   const validation = await validate(manifest);
-  if (manifest.coverage.runtimeObserved || manifest.app.platforms.length !== 1 || manifest.app.platforms[0] !== "web" || manifest.documents.some(d => d.kind !== "source_projection" || !['source_inferred','uncovered'].includes(d.evidence))) throw new Error("Only the Web source projection profile is admitted");
+  if (manifest.coverage.runtimeObserved || manifest.app.platforms.length !== 1 || !(manifest.app.platforms[0] === "web" || ["ios", "android"].includes(manifest.app.platforms[0]) && ["expo-router", "react-native"].includes(manifest.routing.framework)) || manifest.documents.some(d => d.kind !== "source_projection" || !['source_inferred','uncovered'].includes(d.evidence))) throw new Error("Only supported source projection profiles are admitted");
   return { manifest, validation, sha256: sha256(bytes), byteLength: bytes.byteLength };
 }
 /** Only a freshly authorized immutable ready fact from the trusted finalizer can use this path.
@@ -30,6 +30,7 @@ export async function readFinalizedIamBytes(bytes, fact) {
   if (stamp?.profile !== "bounded-web-preview" || stamp.runtimeVerified !== false || stamp.valid !== true || ![stamp.pages, stamp.components, stamp.elements, stamp.documents, stamp.concreteNodes].every(n => Number.isSafeInteger(n) && n >= 0) || typeof stamp.routeTree?.digest !== "string") return validateIamBytes(bytes);
   const manifest = parseManifest(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
   assertManifestShape(manifest);
+  if (["expo-router", "react-native"].includes(manifest.routing?.framework)) return validateIamBytes(bytes);
   if (manifest.format !== "indiana-app-manifest" || manifest.schemaVersion !== 2 || manifest.routeTree.schemaVersion !== 3 || manifest.coverage.runtimeObserved || manifest.app.platforms.length !== 1 || manifest.app.platforms[0] !== "web" || manifest.documents.some(d => d.kind !== "source_projection" || !["source_inferred", "uncovered"].includes(d.evidence)) || manifest.pages.length !== stamp.pages || manifest.documents.length !== stamp.documents || manifest.integrity.routeTreeDigest !== stamp.routeTree.digest) throw Error("Finalized IAM admission mismatch");
   const trusted = await loadTrustedRuntimes();
   for (const script of manifest.scripts ?? []) if (sha256(script.js) !== script.sha256 || script.scriptKey !== "script_" + script.sha256 || !trusted.includes(script.js)) throw Error("Finalized IAM runtime mismatch");

package/src/react-native-projection.mjs

@@ -0,0 +1,300 @@
+import path from "node:path";
+import { sensitiveName } from "./privacy.mjs";
+
+function imported(module, expression, ts) {
+  if (ts.isIdentifier(expression)) return module.imports.get(expression.text);
+  if (ts.isPropertyAccessExpression(expression)) {
+    const owner = imported(module, expression.expression, ts);
+    return owner
+      ? {
+          specifier: owner.specifier,
+          name:
+            owner.name === "*" || owner.name === "default"
+              ? expression.name.text
+              : owner.name + "." + expression.name.text,
+        }
+      : null;
+  }
+  return null;
+}
+
+/** Recognized RN constants only. Application functions, hooks and native modules are never invoked. */
+export function nativeExpression(
+  node,
+  module,
+  { ts, platform, evaluate, unknown, shadowed, gap },
+) {
+  let root = node;
+  while (ts.isPropertyAccessExpression(root) || ts.isCallExpression(root))
+    root = root.expression;
+  if (ts.isIdentifier(root) && shadowed(root.text)) return null;
+  const ref = imported(module, node, ts);
+  if (ref?.specifier === "react-native" && ref.name === "Platform.OS")
+    return { value: platform };
+  if (
+    ref?.specifier === "react-native" &&
+    ["StyleSheet.absoluteFill", "StyleSheet.absoluteFillObject"].includes(
+      ref.name,
+    )
+  )
+    return {
+      value: { position: "absolute", top: 0, right: 0, bottom: 0, left: 0 },
+    };
+  if (!ts.isCallExpression(node)) return null;
+  const call = imported(module, node.expression, ts);
+  if (call?.specifier === "react-native") {
+    if (call.name === "Platform.select" && node.arguments.length === 1) {
+      const choices = evaluate(node.arguments[0]);
+      if (!choices || typeof choices !== "object" || Array.isArray(choices))
+        return { value: unknown };
+      const key = [platform, "native", "default"].find((key) =>
+        Object.hasOwn(choices, key),
+      );
+      return { value: key ? choices[key] : undefined };
+    }
+    if (call.name === "StyleSheet.create" && node.arguments.length === 1)
+      return { value: evaluate(node.arguments[0]) };
+    if (call.name === "StyleSheet.flatten" && node.arguments.length === 1)
+      return { value: flattenNativeStyle(evaluate(node.arguments[0]), gap) };
+    if (call.name === "StyleSheet.compose" && node.arguments.length === 2)
+      return { value: flattenNativeStyle(node.arguments.map(evaluate), gap) };
+  }
+  if (
+    ts.isIdentifier(node.expression) &&
+    node.expression.text === "require" &&
+    !module.bindings.has("require") &&
+    !module.imports.has("require") &&
+    node.arguments.length === 1 &&
+    ts.isStringLiteral(node.arguments[0])
+  ) {
+    const specifier = node.arguments[0].text;
+    if (
+      !specifier.startsWith(".") ||
+      !/\.(?:png|jpe?g|webp|gif)$/i.test(specifier) ||
+      /[\\?#]/.test(specifier)
+    )
+      return null;
+    const file = path.posix.normalize(
+      path.posix.join(path.posix.dirname(module.file), specifier),
+    );
+    if (
+      !file.startsWith("../") &&
+      !file.split("/").some((part) => part.startsWith(".")) &&
+      !sensitiveName(file)
+    )
+      return { value: { uri: "/__iam_source__/" + file } };
+  }
+  return null;
+}
+
+export function flattenNativeStyle(value, gap, depth = 0) {
+  if (value === null || value === undefined || value === false) return {};
+  if (depth > 20) {
+    gap("Nested RN styles exceed the static projection depth");
+    return {};
+  }
+  if (Array.isArray(value))
+    return Object.assign(
+      {},
+      ...value.map((item) => flattenNativeStyle(item, gap, depth + 1)),
+    );
+  if (typeof value === "object") return value;
+  gap("Dynamic style IDs and values are not resolved");
+  return {};
+}
+
+const styleKeys = new Set(
+  "alignContent alignItems alignSelf aspectRatio backgroundColor borderBottomColor borderBottomLeftRadius borderBottomRightRadius borderBottomWidth borderColor borderLeftColor borderLeftWidth borderRadius borderRightColor borderRightWidth borderStyle borderTopColor borderTopLeftRadius borderTopRightRadius borderTopWidth borderWidth bottom color columnGap direction display flexBasis flexDirection flexGrow flexShrink flexWrap fontFamily fontSize fontStyle fontWeight gap height justifyContent left letterSpacing lineHeight margin marginBottom marginLeft marginRight marginTop maxHeight maxWidth minHeight minWidth opacity overflow padding paddingBottom paddingLeft paddingRight paddingTop position right rowGap textAlign textDecorationColor textDecorationLine top verticalAlign width zIndex".split(
+    " ",
+  ),
+);
+
+function projectStyle(value, gap) {
+  const result = {};
+  const aliases = {
+    marginHorizontal: ["marginLeft", "marginRight"],
+    marginVertical: ["marginTop", "marginBottom"],
+    paddingHorizontal: ["paddingLeft", "paddingRight"],
+    paddingVertical: ["paddingTop", "paddingBottom"],
+    marginStart: ["marginInlineStart"],
+    marginEnd: ["marginInlineEnd"],
+    paddingStart: ["paddingInlineStart"],
+    paddingEnd: ["paddingInlineEnd"],
+  };
+  for (const [key, raw] of Object.entries(flattenNativeStyle(value, gap))) {
+    if (
+      !["string", "number"].includes(typeof raw) ||
+      (typeof raw === "number" && !Number.isFinite(raw))
+    ) {
+      gap("Unresolved RN style: " + key);
+      continue;
+    }
+    if (key === "flex" && typeof raw === "number" && raw >= 0) {
+      Object.assign(result, {
+        flexGrow: raw,
+        flexShrink: raw ? 1 : 0,
+        ...(raw ? { flexBasis: 0 } : {}),
+      });
+      continue;
+    }
+    if (aliases[key]) {
+      for (const alias of aliases[key]) result[alias] = raw;
+      continue;
+    }
+    if (!styleKeys.has(key)) {
+      gap("Native style requires runtime layout: " + key);
+      continue;
+    }
+    result[key] =
+      key === "lineHeight" && typeof raw === "number" ? raw + "px" : raw;
+  }
+  return result;
+}
+
+/** Semantic HTML is an inert source preview, never a native view locator or executor. */
+export function nativePrimitive(module, tag, props, { platform, gap }) {
+  const [owner, ...members] = tag.split("."),
+    ref = module.imports.get(owner);
+  if (!ref) return null;
+  const namespace = ref.name === "*" || ref.name === "default";
+  const name = namespace ? members[0] : ref.name,
+    nested = members.length > (namespace ? 1 : 0);
+  if (ref.specifier === "expo-router") {
+    if (["Slot", "Stack", "Tabs", "Drawer"].includes(name))
+      return { outlet: !nested, ignore: nested };
+    if (name === "Redirect") {
+      gap(
+        "Native redirects are source declarations; they do not establish navigation state",
+      );
+      return { ignore: true };
+    }
+    if (name === "Link")
+      return {
+        tag: "a",
+        props: {
+          href: typeof props.href === "string" ? props.href : undefined,
+        },
+      };
+    return null;
+  }
+  if (nested) return null;
+  const safeArea =
+    ref.specifier === "react-native-safe-area-context" &&
+    ["SafeAreaView", "SafeAreaProvider"].includes(name);
+  const image = ref.specifier === "expo-image" && name === "Image";
+  if (ref.specifier !== "react-native" && !safeArea && !image) return null;
+  const tags = {
+    View: "div",
+    Text: "span",
+    Image: "img",
+    Pressable: "button",
+    TouchableOpacity: "button",
+    TouchableHighlight: "button",
+    TouchableWithoutFeedback: "button",
+    Button: "button",
+    TextInput: props.multiline === true ? "textarea" : "input",
+    ScrollView: "div",
+    SafeAreaView: "div",
+    SafeAreaProvider: "div",
+    KeyboardAvoidingView: "div",
+    Modal: "div",
+    ActivityIndicator: "span",
+  };
+  if (!tags[name]) {
+    gap("Unsupported native component: " + String(name));
+    return { tag: "div", props: { "data-iam-native-unobserved": name } };
+  }
+  const style = {
+    ...(name !== "Text" &&
+    !["Image", "TextInput", "Button", "ActivityIndicator"].includes(name)
+      ? {
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "stretch",
+          flexShrink: 0,
+        }
+      : {}),
+    boxSizing: "border-box",
+    ...projectStyle(props.style, gap),
+  };
+  const attributes = {
+    style,
+    "data-iam-native-component": name,
+    "data-iam-native-platform": platform,
+    ...(typeof props.testID === "string"
+      ? { "data-testid": props.testID }
+      : {}),
+    ...(typeof props.nativeID === "string" ? { id: props.nativeID } : {}),
+    ...(typeof props.accessibilityLabel === "string"
+      ? { "aria-label": props.accessibilityLabel }
+      : {}),
+  };
+  if (tags[name] === "button")
+    Object.assign(attributes, {
+      type: "button",
+      disabled: props.disabled === true,
+      style: {
+        font: "inherit",
+        padding: 0,
+        borderWidth: 0,
+        backgroundColor: "transparent",
+        ...style,
+      },
+    });
+  if (name === "Text") attributes.style = { whiteSpace: "pre-wrap", ...style };
+  const sensitive =
+    name === "TextInput" &&
+    props.secureTextEntry !== undefined &&
+    props.secureTextEntry !== false;
+  if (name === "TextInput")
+    Object.assign(attributes, {
+      type: sensitive ? "password" : "text",
+      readOnly: props.editable === false,
+      placeholder: props.placeholder,
+      value: props.value,
+      defaultValue: props.defaultValue,
+    });
+  if (name === "Image") {
+    attributes.src =
+      typeof props.source?.uri === "string"
+        ? props.source.uri
+        : typeof props.source === "string"
+          ? props.source
+          : undefined;
+    if (
+      props.resizeMode &&
+      ["contain", "cover", "stretch", "center"].includes(props.resizeMode)
+    )
+      style.objectFit = {
+        contain: "contain",
+        cover: "cover",
+        stretch: "fill",
+        center: "none",
+      }[props.resizeMode];
+    attributes.alt =
+      typeof props.accessibilityLabel === "string"
+        ? props.accessibilityLabel
+        : "";
+  }
+  if (name === "ScrollView") {
+    style.overflow = "auto";
+    if (props.horizontal === true) style.flexDirection = "row";
+    if (props.contentContainerStyle)
+      gap("ScrollView contentContainerStyle needs a native layout measurement");
+  }
+  if (name === "Modal") {
+    attributes.hidden = props.visible === false;
+    attributes.role = "dialog";
+    gap("Modal focus, stacking and native transitions are unobserved");
+  }
+  if (safeArea || name === "SafeAreaView" || name === "KeyboardAvoidingView")
+    gap("Safe-area and keyboard insets are unobserved");
+  return {
+    tag: tags[name],
+    props: attributes,
+    sensitive,
+    ...(name === "Button" && typeof props.title === "string"
+      ? { text: props.title }
+      : {}),
+  };
+}

package/src/react-native-routes.mjs

@@ -0,0 +1,182 @@
+import path from "node:path";
+import { compositionIdentity, flattenComposition } from "./render-index.mjs";
+
+const extensions = ["js", "jsx", "ts", "tsx"];
+
+/** Metro's default source extensions; explicit extensions remain explicit. No config is executed. */
+export function nativeModuleCandidates(stem, platform) {
+  if (/\.[cm]?[jt]sx?$/.test(stem)) return [stem];
+  const files = (base) =>
+    extensions.flatMap((ext) => [
+      `${base}.${platform}.${ext}`,
+      `${base}.native.${ext}`,
+      `${base}.${ext}`,
+    ]);
+  return [...files(stem), ...files(stem + "/index")];
+}
+
+/** File-based Expo pages and an explicitly selected single-root RN screen. */
+export function reactNativeRoutes({
+  modules,
+  platform,
+  entry,
+  routerRoot,
+  binding,
+  sourceLocation,
+  gap,
+}) {
+  const files = [...modules.keys()];
+  const selected = (stem) =>
+    nativeModuleCandidates(stem, platform).find((file) => modules.has(file));
+  const routeSources = [],
+    entries = [],
+    unsupported = [];
+  const add = (file, route, layers = []) => {
+    const module = modules.get(file),
+      ref = binding(module, module.defaultName);
+    const source = sourceLocation(
+      module,
+      module.source,
+      module.defaultName ?? "$uncovered-route",
+    );
+    const composition = { lane: ".", file, layers };
+    entries.push({
+      route,
+      sourceFile: file,
+      routeSource: source,
+      composition,
+      compositionKey: compositionIdentity(flattenComposition(composition)),
+      entryMode: "hard",
+      gaps: [],
+    });
+    routeSources.push({
+      path: route,
+      source,
+      componentFile: ref?.module.file ?? file,
+      componentSymbol: ref?.name ?? "$uncovered-route",
+    });
+  };
+  if (entry !== undefined) {
+    if (routerRoot !== undefined)
+      throw Error("Use an RN entry or an Expo routerRoot, not both");
+    if (
+      typeof entry !== "string" ||
+      !entry ||
+      entry.startsWith("/") ||
+      /[\\?#:]/.test(entry) ||
+      entry.split("/").some((part) => !part || part === "." || part === "..")
+    )
+      throw Error("RN entry must be a source path inside the scanned root");
+    const file = selected(entry.replace(/\.[cm]?[jt]sx?$/, ""));
+    if (!file) throw Error("RN entry is not a local source module");
+    add(file, "/");
+    gap(
+      "RN_SINGLE_SCREEN_ENTRY",
+      file,
+      "Only the selected screen is projected; React Navigation graphs and native back stacks are not inferred from component names",
+    );
+    return {
+      entries,
+      routeSources,
+      pageFiles: [file],
+      unsupported,
+      framework: "react-native",
+    };
+  }
+  if (
+    routerRoot !== undefined &&
+    (typeof routerRoot !== "string" ||
+      !routerRoot ||
+      routerRoot.startsWith("/") ||
+      /[\\?#:]/.test(routerRoot) ||
+      routerRoot
+        .split("/")
+        .some(
+          (part) =>
+            !part || part === "." || part === ".." || part.startsWith("."),
+        ))
+  )
+    throw Error("Expo routerRoot must be a directory inside the scanned root");
+  const roots = routerRoot
+    ? [routerRoot]
+    : ["app", "src/app"].filter((root) =>
+        files.some((file) => file.startsWith(root + "/")),
+      );
+  if (roots.length !== 1)
+    throw Error(
+      "Select one Expo routerRoot, or set entry for a single-root RN screen",
+    );
+  const root = roots[0],
+    prefix = root + "/";
+  const bases = files.filter(
+    (file) =>
+      file.startsWith(prefix) &&
+      /\.[jt]sx?$/.test(file) &&
+      !/\.(?:ios|android|native|web)\.[jt]sx?$/.test(file),
+  );
+  const seen = new Set();
+  for (const base of bases) {
+    const stem = base.replace(/\.[jt]sx?$/, "");
+    if (seen.has(stem)) continue;
+    seen.add(stem);
+    const file = selected(stem),
+      relative = stem.slice(prefix.length),
+      parts = relative.split("/");
+    if (parts.some((part) => part.startsWith("+") || part === "_layout"))
+      continue;
+    if (
+      parts.some(
+        (part) =>
+          /^\([^()]+,[^()]+\)$/.test(part) ||
+          (/[()]/.test(part) && !/^\([^()]+\)$/.test(part)),
+      )
+    ) {
+      unsupported.push({
+        file,
+        reason:
+          "Shared route groups and ambiguous native route compositions need an explicit adapter",
+      });
+      continue;
+    }
+    const segments = parts.filter((part) => !/^\([^()]+\)$/.test(part));
+    if (segments.at(-1) === "index") segments.pop();
+    const route = "/" + segments.join("/");
+    if (entries.some((item) => item.route === route))
+      throw Error("Ambiguous Expo route after removing groups: " + route);
+    const layers = [];
+    let directory = path.posix.dirname(stem);
+    while (directory === root || directory.startsWith(prefix)) {
+      // Expo requires a non-platform route/layout to establish universal route identity.
+      if (
+        extensions.some((ext) => modules.has(`${directory}/_layout.${ext}`))
+      ) {
+        const layout = selected(directory + "/_layout");
+        layers.push({ file: layout, slots: [] });
+      }
+      if (directory === root) break;
+      directory = path.posix.dirname(directory);
+    }
+    add(file, route, layers);
+  }
+  for (const file of files.filter(
+    (file) =>
+      file.startsWith(prefix) &&
+      /\.(?:ios|android|native|web)\.[jt]sx?$/.test(file),
+  )) {
+    const stem = file.replace(/\.(?:ios|android|native|web)\.[jt]sx?$/, "");
+    if (!extensions.some((ext) => modules.has(stem + "." + ext)))
+      gap(
+        "EXPO_PLATFORM_ROUTE_WITHOUT_BASE",
+        file,
+        "Platform-only files do not establish universal Expo routes; add a non-platform route module",
+      );
+  }
+  if (!entries.length) throw Error("No supported Expo routes under " + root);
+  return {
+    entries,
+    routeSources,
+    pageFiles: entries.map((item) => item.sourceFile),
+    unsupported,
+    framework: "expo-router",
+  };
+}

package/src/react-native.d.ts

@@ -0,0 +1,47 @@
+import type { BuildLogger } from "./index.js";
+
+export type ReactNativeIamOptions = {
+  root: string;
+  /** Generate one artifact per native platform, including its platform-specific source. */
+  platform: "ios" | "android";
+  /** Single exported RN screen, relative to root. Omit for Expo Router file routes. */
+  entry?: string;
+  /** Expo route directory; defaults to the sole app/ or src/app/ directory. */
+  routerRoot?: string;
+  name?: string;
+  strict?: boolean;
+  logger?: BuildLogger;
+};
+export type PreparedReactNativeIam = {
+  releaseId: string;
+  descriptorPath: string;
+  platform: "ios" | "android";
+};
+export declare function prepareReactNativeIam(
+  options: ReactNativeIamOptions,
+): Promise<PreparedReactNativeIam | null>;
+export declare function finishReactNativeIam(
+  options: ReactNativeIamOptions & {
+    releaseId: string;
+    /** Relative asset staging directory inside root. Package the descriptor with native release assets. */
+    bundleDirectory: string;
+    upload?: {
+      /** Disabled by default; explicitly enable only for an authorized upload. */
+      upload?: "production" | "always" | false;
+      apiKey?: string;
+      baseUrl?: string;
+      /** A fixed platform client; defaults to rn-ios / rn-android. */
+      client?: string;
+      fetch?: typeof globalThis.fetch;
+    };
+  },
+): Promise<
+  | (PreparedReactNativeIam & {
+      file: string;
+      digest: string;
+      bytes: number;
+      pages: number;
+      uploaded: Record<string, unknown> | null;
+    })
+  | null
+>;

package/src/react-native.mjs

@@ -0,0 +1,45 @@
+import { prepareBuildRelease, finishBuildRelease } from "./build.mjs";
+import { releasePath } from "./release-metadata.mjs";
+
+function nativeOptions(options) {
+  if (!["ios", "android"].includes(options?.platform))
+    throw new Error("React Native IAM requires platform ios or android");
+  return { ...options, automaticAnchors: false };
+}
+
+/** Source scan before bundling. Does not execute Expo, Metro, Babel or App modules. */
+export async function prepareReactNativeIam(options) {
+  const result = await prepareBuildRelease(nativeOptions(options));
+  return (
+    result && {
+      ...result,
+      descriptorPath: releasePath(result.releaseId),
+      platform: options.platform,
+    }
+  );
+}
+
+/** After JS bundling, before packaging native assets: verify source identity and write the descriptor. */
+export async function finishReactNativeIam(options) {
+  const { bundleDirectory, ...source } = nativeOptions(options);
+  if (typeof bundleDirectory !== "string" || !bundleDirectory)
+    throw new Error(
+      "React Native IAM requires an in-root bundleDirectory for release assets",
+    );
+  const result = await finishBuildRelease({
+    ...source,
+    publicDirectory: bundleDirectory,
+    upload: {
+      client: `rn-${options.platform}`,
+      upload: false,
+      ...options.upload,
+    },
+  });
+  return (
+    result && {
+      ...result,
+      descriptorPath: releasePath(result.releaseId),
+      platform: options.platform,
+    }
+  );
+}