@symbiote-native/asset 0.1.0

package/build-ngc/core/local-assets.js

@@ -0,0 +1,17 @@
+// Ported verbatim from expo-asset/src/LocalAssets.ts (sdk-57). localAssets comes from
+// expo-updates (classic-updates/Expo-Go asset overrides) via platform-utils.ts — always `{}`
+// in a bare app that ships neither, so this always falls through to null there.
+import { getLocalAssets } from './platform-utils';
+const localAssets = getLocalAssets();
+export function getLocalAssetUri(hash, type) {
+    const localAssetsKey = hash;
+    const legacyLocalAssetsKey = `${hash}.${type ?? ''}`;
+    if (localAssetsKey in localAssets) {
+        return localAssets[localAssetsKey] ?? null;
+    }
+    if (legacyLocalAssetsKey in localAssets) {
+        return localAssets[legacyLocalAssetsKey] ?? null;
+    }
+    return null;
+}
+//# sourceMappingURL=local-assets.js.map

package/build-ngc/core/local-assets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-assets.js","sourceRoot":"","sources":["../../src/core/local-assets.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,6FAA6F;AAC7F,gFAAgF;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;AAErC,MAAM,UAAU,gBAAgB,CAC9B,IAAY,EACZ,IAAmB;IAEnB,MAAM,cAAc,GAAG,IAAI,CAAC;IAC5B,MAAM,oBAAoB,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,CAAC;IAErD,IAAI,cAAc,IAAI,WAAW,EAAE,CAAC;QAClC,OAAO,WAAW,CAAC,cAAc,CAAC,IAAI,IAAI,CAAC;IAC7C,CAAC;IACD,IAAI,oBAAoB,IAAI,WAAW,EAAE,CAAC;QACxC,OAAO,WAAW,CAAC,oBAAoB,CAAC,IAAI,IAAI,CAAC;IACnD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/build-ngc/core/native-module.d.ts

@@ -0,0 +1,4 @@
+export type INativeAssetModule = {
+    downloadAsync(url: string, md5Hash: string | null, type: string): Promise<string>;
+};
+export declare const expoAsset: INativeAssetModule;

package/build-ngc/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+export const expoAsset = requireNativeModule('ExpoAsset');
+//# sourceMappingURL=native-module.js.map

package/build-ngc/core/native-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAUxD,MAAM,CAAC,MAAM,SAAS,GAAG,mBAAmB,CAAqB,WAAW,CAAC,CAAC"}

package/build-ngc/core/platform-utils.d.ts

@@ -0,0 +1,5 @@
+import Constants from 'expo-constants';
+export declare const IS_ENV_WITH_LOCAL_ASSETS: boolean;
+export declare function getLocalAssets(): Record<string, string>;
+export declare function getManifest2(): typeof Constants.__unsafeNoWarnManifest2;
+export declare const manifestBaseUrl: string | null;

package/build-ngc/core/platform-utils.js

@@ -0,0 +1,29 @@
+// Ported from expo-asset/src/PlatformUtils.ts (sdk-57) — real logic, not a stub. Every check
+// here (ExpoGo/expo-updates native modules, the classic-updates manifest) naturally resolves to
+// "absent" in a bare app that ships neither, matching upstream's own designed fallback.
+import Constants from 'expo-constants';
+import { requireNativeModule, requireOptionalNativeModule, } from 'expo-modules-core';
+import { getManifestBaseUrl } from './asset-uris';
+const ExpoUpdates = requireOptionalNativeModule('ExpoUpdates');
+function isRunningInExpoGo() {
+    try {
+        return requireNativeModule('ExpoGo') != null;
+    }
+    catch {
+        return false;
+    }
+}
+const expoUpdatesIsInstalledAndEnabled = !!ExpoUpdates?.isEnabled;
+const expoUpdatesIsUsingEmbeddedAssets = ExpoUpdates?.isUsingEmbeddedAssets;
+const shouldUseUpdatesAssetResolution = expoUpdatesIsInstalledAndEnabled && !expoUpdatesIsUsingEmbeddedAssets;
+export const IS_ENV_WITH_LOCAL_ASSETS = isRunningInExpoGo() || shouldUseUpdatesAssetResolution;
+export function getLocalAssets() {
+    return ExpoUpdates?.localAssets ?? {};
+}
+export function getManifest2() {
+    return Constants.__unsafeNoWarnManifest2;
+}
+export const manifestBaseUrl = Constants.experienceUrl
+    ? getManifestBaseUrl(Constants.experienceUrl)
+    : null;
+//# sourceMappingURL=platform-utils.js.map

package/build-ngc/core/platform-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-utils.js","sourceRoot":"","sources":["../../src/core/platform-utils.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,gGAAgG;AAChG,wFAAwF;AACxF,OAAO,SAAS,MAAM,gBAAgB,CAAC;AACvC,OAAO,EACL,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAQlD,MAAM,WAAW,GACf,2BAA2B,CAAqB,aAAa,CAAC,CAAC;AAEjE,SAAS,iBAAiB;IACxB,IAAI,CAAC;QACH,OAAO,mBAAmB,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC;IAC/C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,MAAM,gCAAgC,GAAG,CAAC,CAAC,WAAW,EAAE,SAAS,CAAC;AAClE,MAAM,gCAAgC,GAAG,WAAW,EAAE,qBAAqB,CAAC;AAC5E,MAAM,+BAA+B,GACnC,gCAAgC,IAAI,CAAC,gCAAgC,CAAC;AAExE,MAAM,CAAC,MAAM,wBAAwB,GACnC,iBAAiB,EAAE,IAAI,+BAA+B,CAAC;AAEzD,MAAM,UAAU,cAAc;IAC5B,OAAO,WAAW,EAAE,WAAW,IAAI,EAAE,CAAC;AACxC,CAAC;AAED,MAAM,UAAU,YAAY;IAC1B,OAAO,SAAS,CAAC,uBAAuB,CAAC;AAC3C,CAAC;AAED,MAAM,CAAC,MAAM,eAAe,GAAG,SAAS,CAAC,aAAa;IACpD,CAAC,CAAC,kBAAkB,CAAC,SAAS,CAAC,aAAa,CAAC;IAC7C,CAAC,CAAC,IAAI,CAAC"}

package/native-link.json

@@ -0,0 +1,12 @@
+{
+  "android": {
+    "gradleProjectName": "expo-asset",
+    "modules": [
+      {
+        "importPath": "expo.modules.asset.AssetModule",
+        "className": "AssetModule",
+        "nativeName": "ExpoAsset"
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,151 @@
+{
+  "name": "@symbiote-native/asset",
+  "version": "0.1.0",
+  "description": "expo-asset wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, Svelte, Solid, and Angular adapters. Resolves bundled/remote assets by require() module id or URI, and downloads them to a local cache file.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
+    "directory": "packages/asset"
+  },
+  "homepage": "https://github.com/OneEyed1366/symbiote-native/tree/master/packages/asset#readme",
+  "bugs": {
+    "url": "https://github.com/OneEyed1366/symbiote-native/issues"
+  },
+  "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "keywords": [
+    "react-native",
+    "symbiote-native",
+    "expo-asset",
+    "react",
+    "vue",
+    "svelte",
+    "solid",
+    "angular",
+    "asset"
+  ],
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./svelte": {
+      "types": "./build/svelte/index.d.ts",
+      "default": "./build/svelte/index.js"
+    },
+    "./solid": {
+      "types": "./build/solid/index.d.ts",
+      "default": "./build/solid/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc",
+    "native-link.json",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*",
+    "!src/**/*.detox.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "expo-asset": "57.0.18",
+    "expo-modules-core": "57.0.20",
+    "expo-constants": "57.0.19",
+    "@react-native/assets-registry": "0.86.0"
+  },
+  "peerDependencies": {
+    "@angular/core": ">=20",
+    "@vue/runtime-core": "^3.5.13",
+    "react": ">=19.0.0",
+    "react-native": ">=0.86",
+    "solid-js": ">=1.9.0",
+    "svelte": ">=5.56.0",
+    "vue": ">=3.5.0",
+    "@symbiote-native/engine": "^1.4.0",
+    "@symbiote-native/angular": "^3.1.3",
+    "@symbiote-native/react": "^3.1.0",
+    "@symbiote-native/solid": "^3.0.5",
+    "@symbiote-native/svelte": "^3.0.5",
+    "@symbiote-native/vue": "^3.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/solid": {
+      "optional": true
+    },
+    "@symbiote-native/svelte": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "~22.0.8",
+    "@angular/compiler-cli": "~22.0.8",
+    "@angular/core": "~22.0.8",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "solid-js": "^1.9.14",
+    "svelte": "^5.56.0",
+    "typescript": "~6.0.0",
+    "@symbiote-native/angular": "3.1.3",
+    "@symbiote-native/react": "3.1.0",
+    "@symbiote-native/solid": "3.0.5",
+    "@symbiote-native/svelte": "3.0.5",
+    "@symbiote-native/engine": "1.4.0",
+    "@symbiote-native/vue": "3.1.0",
+    "@symbiote-native/test-utils": "0.4.5"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
+  }
+}

package/src/angular/index.ts

@@ -0,0 +1,4 @@
+// AssetsService is the Angular-only lifecycle half; the Asset class and loading logic all live
+// in core, shared with React/Vue/Svelte/Solid.
+export { AssetsService } from './services/assets.service';
+export * from '../core';

package/src/angular/services/assets.service/index.ts

@@ -0,0 +1,21 @@
+import { Injectable, signal, type Signal } from '@angular/core';
+import { Asset } from '../../../core';
+
+// Angular twin of React's useAssets hook and Vue's useAssets composable — connect(ids) returns
+// a Signal pair, e.g. `readonly assets = inject(AssetsService).connect([require('./a.jpg')])`.
+@Injectable({ providedIn: 'root' })
+export class AssetsService {
+  connect(moduleIds: number | number[]): {
+    assets: Signal<Asset[] | undefined>;
+    error: Signal<Error | undefined>;
+  } {
+    const assets = signal<Asset[] | undefined>(undefined);
+    const error = signal<Error | undefined>(undefined);
+
+    Asset.loadAsync(moduleIds)
+      .then(loaded => assets.set(loaded))
+      .catch((err: Error) => error.set(err));
+
+    return { assets: assets.asReadonly(), error: error.asReadonly() };
+  }
+}

package/src/core/asset-fx.ts

@@ -0,0 +1,30 @@
+// Ported from expo-asset/src/Asset.fx.ts (sdk-57). Overrides RN's own Image asset resolution
+// for a classic-updates/Expo-Go env — a no-op import in a bare app (IS_ENV_WITH_LOCAL_ASSETS
+// is false), imported for its side effect from core/index.ts, matching upstream's own index.ts.
+import resolveAssetSource, {
+  type ICustomSourceTransformer,
+} from 'react-native/Libraries/Image/resolveAssetSource';
+
+import { Asset, ANDROID_EMBEDDED_URL_BASE_RESOURCE } from './asset';
+import { IS_ENV_WITH_LOCAL_ASSETS } from './platform-utils';
+
+const expoAssetTransformer: ICustomSourceTransformer = resolver => {
+  try {
+    if ('fileHashes' in resolver.asset && resolver.asset.fileHashes) {
+      const asset = Asset.fromMetadata(resolver.asset);
+      if (asset.uri.startsWith(ANDROID_EMBEDDED_URL_BASE_RESOURCE)) {
+        return resolver.resourceIdentifierWithoutScale();
+      }
+      return resolver.fromSource(
+        asset.downloaded && asset.localUri ? asset.localUri : asset.uri,
+      );
+    }
+    return resolver.defaultAsset();
+  } catch {
+    return resolver.defaultAsset();
+  }
+};
+
+if (IS_ENV_WITH_LOCAL_ASSETS) {
+  resolveAssetSource.setCustomSourceTransformer?.(expoAssetTransformer);
+}

package/src/core/asset-sources.ts

@@ -0,0 +1,80 @@
+// Ported from expo-asset/src/AssetSources.ts (sdk-57) — full parity, manifest2 branch included.
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./ts-declarations/react-native-assets.d.ts" />
+import type { PackagerAsset } from '@react-native/assets-registry/registry';
+import { Platform } from 'expo-modules-core';
+import { NativeModules, PixelRatio } from 'react-native';
+import AssetSourceResolver from 'react-native/Libraries/Image/AssetSourceResolver';
+
+import { getManifest2, manifestBaseUrl } from './platform-utils';
+
+export type AssetMetadata = Pick<
+  PackagerAsset,
+  | 'httpServerLocation'
+  | 'name'
+  | 'hash'
+  | 'type'
+  | 'scales'
+  | 'width'
+  | 'height'
+> & {
+  uri?: string;
+  fileHashes?: string[];
+  fileUris?: string[];
+};
+
+export type AssetSource = { uri: string; hash: string };
+
+/** Resolves a relative asset URI against the classic-updates manifest base, if any. */
+export function resolveUri(uri: string): string {
+  return manifestBaseUrl ? new URL(uri, manifestBaseUrl).href : uri;
+}
+
+export function selectAssetSource(meta: AssetMetadata): AssetSource {
+  const scale = AssetSourceResolver.pickScale(meta.scales, PixelRatio.get());
+  const index = meta.scales.findIndex(s => s === scale);
+  const hash = meta.fileHashes?.[index] ?? meta.fileHashes?.[0] ?? meta.hash;
+
+  const uri = meta.fileUris
+    ? (meta.fileUris[index] ?? meta.fileUris[0])
+    : meta.uri;
+  if (uri) {
+    return { uri: resolveUri(uri), hash };
+  }
+
+  const fileScale = scale === 1 ? '' : `@${scale}x`;
+  const fileExtension = meta.type ? `.${encodeURIComponent(meta.type)}` : '';
+  const suffix = `/${encodeURIComponent(meta.name)}${fileScale}${fileExtension}`;
+  const params = new URLSearchParams({
+    platform: Platform.OS,
+    hash: meta.hash,
+  });
+
+  if (/^https?:\/\//.test(meta.httpServerLocation)) {
+    return { uri: meta.httpServerLocation + suffix + '?' + params, hash };
+  }
+
+  const manifest2 = getManifest2();
+  const scheme = manifestBaseUrl?.startsWith('https://')
+    ? 'https://'
+    : 'http://';
+  const devServerUrl = manifest2?.extra?.expoGo?.developer
+    ? scheme + manifest2.extra.expoGo.debuggerHost
+    : null;
+  if (devServerUrl) {
+    const baseUrl = new URL(meta.httpServerLocation + suffix, devServerUrl);
+    baseUrl.searchParams.set('platform', Platform.OS);
+    baseUrl.searchParams.set('hash', meta.hash);
+    return { uri: baseUrl.href, hash };
+  }
+
+  if (NativeModules['ExponentKernel']) {
+    return {
+      uri: `https://classic-assets.eascdn.net/~assets/${encodeURIComponent(hash)}`,
+      hash,
+    };
+  }
+
+  // Locally available on disk (classic-updates embedded asset): no remote URL to build.
+  return { uri: '', hash };
+}

package/src/core/asset-uris.ts

@@ -0,0 +1,51 @@
+// Ported from expo-asset/src/AssetUris.ts (sdk-57).
+
+// Read via globalThis, matching packages/background-task's own __DEV__ convention (no ambient
+// declare — react-native is a peer, never imported here).
+type IDevGlobal = { __DEV__?: boolean };
+function isDevBuild(): boolean {
+  return Boolean((globalThis as IDevGlobal).__DEV__);
+}
+
+function getBasename(pathname: string): string {
+  return pathname.substring(pathname.lastIndexOf('/') + 1);
+}
+
+export function getFilename(url: string): string {
+  const { pathname, searchParams } = new URL(url, 'https://e');
+
+  if (isDevBuild() && searchParams.has('unstable_path')) {
+    const encodedFilePath = decodeURIComponent(
+      searchParams.get('unstable_path')!,
+    );
+    return getBasename(encodedFilePath);
+  }
+
+  return getBasename(pathname);
+}
+
+export function getFileExtension(url: string): string {
+  const filename = getFilename(url);
+  const dotIndex = filename.lastIndexOf('.');
+  return dotIndex > 0 ? filename.substring(dotIndex) : '';
+}
+
+// Rebuilds the URL from parts rather than mutating `protocol`/`pathname` in place: react-native's
+// own global.d.ts types those fields readonly (its URL polyfill's actual shape), conflicting with
+// @types/node's writable declaration wherever both are ambient — same net result either way.
+export function getManifestBaseUrl(manifestUrl: string): string {
+  const urlObject = new URL(manifestUrl);
+
+  const protocol =
+    urlObject.protocol === 'exp:'
+      ? 'http:'
+      : urlObject.protocol === 'exps:'
+        ? 'https:'
+        : urlObject.protocol;
+  const directory = urlObject.pathname.substring(
+    0,
+    urlObject.pathname.lastIndexOf('/') + 1,
+  );
+
+  return `${protocol}//${urlObject.host}${directory}`;
+}

package/src/core/asset.ts

@@ -0,0 +1,212 @@
+// Ported from expo-asset/src/Asset.ts (sdk-57), native-only, no Expo Go/expo-updates.
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./ts-declarations/react-native-assets.d.ts" />
+import { getAssetByID } from '@react-native/assets-registry/registry';
+import { Platform } from 'expo-modules-core';
+import resolveAssetSource from 'react-native/Libraries/Image/resolveAssetSource';
+
+import { type AssetMetadata, selectAssetSource } from './asset-sources';
+import { getFileExtension } from './asset-uris';
+import { getLocalAssetUri } from './local-assets';
+import { expoAsset } from './native-module';
+import { IS_ENV_WITH_LOCAL_ASSETS } from './platform-utils';
+
+export const ANDROID_EMBEDDED_URL_BASE_RESOURCE = 'file:///android_res/';
+
+export type AssetDescriptor = {
+  name: string;
+  type: string;
+  hash?: string | null;
+  uri: string;
+  width?: number | null;
+  height?: number | null;
+};
+
+type IDownloadPromiseCallbacks = {
+  resolve: () => void;
+  reject: (error: Error) => void;
+};
+
+/** A locally- or remotely-sourced asset: metadata plus loading/caching facilities. */
+export class Asset {
+  private static byHash: Record<string, Asset | undefined> = {};
+  private static byUri: Record<string, Asset | undefined> = {};
+
+  public name: string;
+  public readonly type: string;
+  public readonly hash: string | null = null;
+  public readonly uri: string;
+  public localUri: string | null = null;
+  public width: number | null = null;
+  public height: number | null = null;
+  public downloaded: boolean = false;
+
+  private downloading: boolean = false;
+  private downloadCallbacks: IDownloadPromiseCallbacks[] = [];
+
+  constructor({
+    name,
+    type,
+    hash = null,
+    uri,
+    width,
+    height,
+  }: AssetDescriptor) {
+    this.name = name;
+    this.type = type;
+    this.hash = hash;
+    this.uri = uri;
+
+    if (typeof width === 'number') this.width = width;
+    if (typeof height === 'number') this.height = height;
+
+    if (hash) {
+      this.localUri = getLocalAssetUri(hash, type);
+      if (this.localUri?.startsWith(ANDROID_EMBEDDED_URL_BASE_RESOURCE)) {
+        this.uri = this.localUri;
+        this.localUri = null;
+      } else if (this.localUri) {
+        this.downloaded = true;
+      }
+    }
+  }
+
+  static loadAsync(
+    moduleId: number | number[] | string | string[],
+  ): Promise<Asset[]> {
+    const moduleIds = Array.isArray(moduleId) ? moduleId : [moduleId];
+    return Promise.all(
+      moduleIds.map(id => Asset.fromModule(id).downloadAsync()),
+    );
+  }
+
+  static fromModule(
+    virtualAssetModule:
+      number | string | { uri: string; width: number; height: number },
+  ): Asset {
+    if (typeof virtualAssetModule === 'string') {
+      return Asset.fromURI(virtualAssetModule);
+    }
+    if (
+      typeof virtualAssetModule === 'object' &&
+      'uri' in virtualAssetModule &&
+      typeof virtualAssetModule.uri === 'string'
+    ) {
+      const extension = getFileExtension(virtualAssetModule.uri);
+      return new Asset({
+        name: '',
+        type: extension.startsWith('.') ? extension.substring(1) : extension,
+        hash: null,
+        uri: virtualAssetModule.uri,
+        width: virtualAssetModule.width,
+        height: virtualAssetModule.height,
+      });
+    }
+
+    const meta = getAssetByID(virtualAssetModule);
+    if (!meta) {
+      throw new Error(
+        `Module "${virtualAssetModule}" is missing from the asset registry`,
+      );
+    }
+
+    // Outside a managed (Expo Go / expo-updates) env, the moduleId is needed because
+    // resolveAssetSource depends on it — a classic-updates env resolves by hash instead.
+    if (!IS_ENV_WITH_LOCAL_ASSETS) {
+      const resolved = resolveAssetSource(virtualAssetModule);
+      if (!resolved) {
+        throw new Error(
+          `Module "${virtualAssetModule}" could not be resolved to an asset source`,
+        );
+      }
+
+      const asset = new Asset({
+        name: meta.name,
+        type: meta.type,
+        hash: meta.hash,
+        uri: resolved.uri,
+        width: meta.width,
+        height: meta.height,
+      });
+
+      // Android drawable resource names (no scheme) are already usable directly, same as RN's
+      // own Image component backward-compat handling.
+      if (
+        Platform.OS === 'android' &&
+        !resolved.uri.includes(':') &&
+        (meta.width || meta.height)
+      ) {
+        asset.localUri = asset.uri;
+        asset.downloaded = true;
+      }
+
+      Asset.byHash[meta.hash] = asset;
+      return asset;
+    }
+
+    return Asset.fromMetadata(meta);
+  }
+
+  static fromMetadata(meta: AssetMetadata): Asset {
+    const existing = Asset.byHash[meta.hash];
+    if (existing) return existing;
+
+    const { uri, hash } = selectAssetSource(meta);
+    const asset = new Asset({
+      name: meta.name,
+      type: meta.type,
+      hash,
+      uri,
+      width: meta.width,
+      height: meta.height,
+    });
+    Asset.byHash[meta.hash] = asset;
+    return asset;
+  }
+
+  static fromURI(uri: string): Asset {
+    const existing = Asset.byUri[uri];
+    if (existing) return existing;
+
+    let type: string;
+    if (uri.indexOf(';base64') > -1) {
+      type = uri.split(';')[0]?.split('/')[1] ?? '';
+    } else {
+      const extension = getFileExtension(uri);
+      type = extension.startsWith('.') ? extension.substring(1) : extension;
+    }
+
+    const asset = new Asset({ name: '', type, hash: null, uri });
+    Asset.byUri[uri] = asset;
+    return asset;
+  }
+
+  async downloadAsync(): Promise<this> {
+    if (this.downloaded) return this;
+    if (this.downloading) {
+      await new Promise<void>((resolve, reject) => {
+        this.downloadCallbacks.push({ resolve, reject });
+      });
+      return this;
+    }
+    this.downloading = true;
+
+    try {
+      this.localUri = await expoAsset.downloadAsync(
+        this.uri,
+        this.hash,
+        this.type,
+      );
+      this.downloaded = true;
+      this.downloadCallbacks.forEach(({ resolve }) => resolve());
+    } catch (error) {
+      const reason = error instanceof Error ? error : new Error(String(error));
+      this.downloadCallbacks.forEach(({ reject }) => reject(reason));
+      throw reason;
+    } finally {
+      this.downloading = false;
+      this.downloadCallbacks = [];
+    }
+    return this;
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,8 @@
+import './asset-fx';
+
+export {
+  Asset,
+  ANDROID_EMBEDDED_URL_BASE_RESOURCE,
+  type AssetDescriptor,
+} from './asset';
+export type { AssetMetadata, AssetSource } from './asset-sources';

package/src/core/local-assets.ts

@@ -0,0 +1,22 @@
+// Ported verbatim from expo-asset/src/LocalAssets.ts (sdk-57). localAssets comes from
+// expo-updates (classic-updates/Expo-Go asset overrides) via platform-utils.ts — always `{}`
+// in a bare app that ships neither, so this always falls through to null there.
+import { getLocalAssets } from './platform-utils';
+
+const localAssets = getLocalAssets();
+
+export function getLocalAssetUri(
+  hash: string,
+  type: string | null,
+): string | null {
+  const localAssetsKey = hash;
+  const legacyLocalAssetsKey = `${hash}.${type ?? ''}`;
+
+  if (localAssetsKey in localAssets) {
+    return localAssets[localAssetsKey] ?? null;
+  }
+  if (legacyLocalAssetsKey in localAssets) {
+    return localAssets[legacyLocalAssetsKey] ?? null;
+  }
+  return null;
+}