@symbiote-native/asset 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,198 @@
+# @symbiote-native/asset
+
+Turn `require('./logo.png')` (or a plain URI) into a local file: download it once, read
+`localUri`, reuse it. One API for every [SymbioteNative](../../README.md) adapter (React, Vue,
+Svelte, Solid and Angular).
+
+It wraps [`expo-asset`](https://github.com/expo/expo/tree/main/packages/expo-asset): an `Asset`
+instance resolved from a `require()` module id or URI, downloaded to a cache file. Built mainly so
+[`@symbiote-native/font`](../font) can accept the same `number`/`Asset` font-source forms as
+upstream `expo-font`; usable standalone too. Same recipe as
+[`@symbiote-native/network`](../network), an `expo-modules-core`-based wrapper (see the
+`symbiote-expo-native-module` project skill for the full mechanism).
+
+## Install
+
+**New app:**
+
+```bash
+npx @symbiote-native/cli new my-app --asset
+```
+
+**Existing SymbioteNative app:**
+
+```bash
+npx @symbiote-native/cli add --asset
+```
+
+Either way: installs `@symbiote-native/asset` and wires the native autolinking automatically -
+see [`@symbiote-native/cli`](../cli).
+
+<details>
+<summary>Manual install (no CLI - installing and wiring native autolinking by hand)</summary>
+
+```bash
+npm install @symbiote-native/asset
+```
+
+`expo-asset`, `expo-modules-core`, `expo-constants`, and `@react-native/assets-registry` come
+along as regular dependencies, pinned to exact versions - never install `expo-asset` yourself, and
+never add the `expo` meta-package to this project.
+
+### Required one-time step: native autolinking wiring
+
+Same one-time step as every other `expo-modules-core` package this project ships - see
+[`@symbiote-native/network`'s README](../network/README.md#required-one-time-step-native-autolinking-wiring)
+and the `symbiote-expo-native-module` project skill. `native-link.json` registers one Android
+module (`AssetModule` → `ExpoAsset`); iOS needs no manifest entry, it autolinks via
+`use_expo_modules!`.
+
+No platform permission string is needed - asset resolution and caching reads no protected system
+state on either platform.
+
+</details>
+
+## Shape
+
+```
+src/core/               asset.ts - the Asset class (fromModule/fromMetadata/fromURI/loadAsync/
+                        downloadAsync). asset-sources.ts - selectAssetSource/resolveUri (scale
+                        pick, manifest2 dev-server resolution). asset-uris.ts -
+                        getFilename/getFileExtension/getManifestBaseUrl. local-assets.ts -
+                        getLocalAssetUri (Expo Go / expo-updates embedded assets).
+                        platform-utils.ts - IS_ENV_WITH_LOCAL_ASSETS + the manifest/Constants
+                        reads. asset-fx.ts - registers the Image custom source transformer as a
+                        module-load side effect. native-module.ts resolves ExpoAsset through
+                        expo-modules-core's requireNativeModule.
+src/react/hooks/        @symbiote-native/asset/react   - useAssets
+src/vue/composables/    @symbiote-native/asset/vue     - useAssets (same name)
+src/svelte/runes/       @symbiote-native/asset/svelte  - useAssets (same name)
+src/solid/primitives/   @symbiote-native/asset/solid   - createAssets (Solid reserves `use*` for
+                        consuming existing state)
+src/angular/services/   @symbiote-native/asset/angular - AssetsService (`.connect()` returns a
+                        Signal pair)
+```
+
+Each adapter's hook/composable/rune/primitive/service is a thin lifecycle wrapper over
+`Asset.loadAsync`, matching upstream's own `useAssets` hook contract (loads once on mount).
+
+## Use it
+
+```tsx
+// React
+import { useAssets } from '@symbiote-native/asset/react';
+
+function Logo() {
+  const [assets, error] = useAssets(require('./assets/logo.png'));
+  return assets ? <image source={{ uri: assets[0].localUri ?? undefined }} /> : null;
+}
+```
+
+```vue
+<!-- Vue -->
+<script setup lang="ts">
+import { useAssets } from '@symbiote-native/asset/vue';
+
+const { assets, error } = useAssets(require('./assets/logo.png'));
+</script>
+<template>
+  <image v-if="assets" :source="{ uri: assets[0].localUri ?? undefined }" />
+</template>
+```
+
+```svelte
+<!-- Svelte -->
+<script lang="ts">
+  import { useAssets } from '@symbiote-native/asset/svelte';
+
+  const { assets, error } = useAssets(require('./assets/logo.png'));
+</script>
+
+{#if assets}
+  <image source={{ uri: assets[0].localUri ?? undefined }} />
+{/if}
+```
+
+```ts
+// Angular
+import { Component, inject } from '@angular/core';
+import { SYMBIOTE_ELEMENTS } from '@symbiote-native/angular';
+import { AssetsService } from '@symbiote-native/asset/angular';
+
+@Component({
+  standalone: true,
+  imports: [SYMBIOTE_ELEMENTS],
+  template: `@if (assets.assets(); as loaded) {
+    <image [source]="{ uri: loaded[0].localUri ?? undefined }" />
+  }`,
+})
+export class Logo {
+  readonly assets = inject(AssetsService).connect(require('./assets/logo.png'));
+}
+```
+
+```tsx
+// Solid - the accessor is CALLED; a Solid component body runs once.
+import { createAssets } from '@symbiote-native/asset/solid';
+
+function Logo() {
+  const { assets } = createAssets(require('./assets/logo.png'));
+  const loaded = () => assets()?.[0];
+  return loaded() ? (
+    <image source={{ uri: loaded()!.localUri ?? undefined }} />
+  ) : null;
+}
+```
+
+## API
+
+```ts
+Asset.fromModule(virtualAssetModule: number | string | { uri: string; width: number; height: number }): Asset
+Asset.fromMetadata(meta: AssetMetadata): Asset
+Asset.fromURI(uri: string): Asset
+Asset.loadAsync(moduleId: number | number[] | string | string[]): Promise<Asset[]>
+asset.downloadAsync(): Promise<Asset>
+```
+
+Plus `AssetDescriptor`, `AssetMetadata`, `AssetSource` - hand-ported from upstream's `Asset.ts`/
+`AssetSources.ts`. `useAssets`/`createAssets` accept `number | number[]` only, matching upstream's
+own `AssetHooks.ts` (narrower than `Asset.loadAsync`'s own `string`/`string[]` forms).
+
+## Full parity - Expo Go / expo-updates code paths included
+
+Every native-side upstream module is ported, including the Expo Go / classic-updates /
+`expo-updates` branches (`getLocalAssetUri` reading `ExpoUpdates.localAssets`, `AssetSources.ts`'s
+manifest2 dev-server resolution, `Asset.fx.ts`'s custom `Image` source-transformer registration).
+This repo ships neither Expo Go nor `expo-updates`, so `IS_ENV_WITH_LOCAL_ASSETS` is always `false`
+in practice and those branches sit naturally inert - real, tested code (see
+`platform-utils.test.ts`, `asset-fx.test.ts`, `local-assets.test.ts`), not stubs. If a consuming
+app ever installs `expo-updates` itself, this package picks it up automatically, same as upstream.
+
+## Not ported
+
+- **The `expo-asset` config plugin.** It links files into the native project from `app.json`; this
+  repo runs no Expo prebuild step. Bundle files with `require()` through Metro and add unusual
+  extensions to `assetExts` in the Metro config.
+- **The web platform** - no `ImageAssets`/browser `Image()` probing; only the native path is
+  ported (same convention as every other package in this repo - see the root `CLAUDE.md`).
+
+## Common questions
+
+- **`localUri` is `null`.** It is `null` until the asset is downloaded: read it after
+  `Asset.loadAsync` or `downloadAsync` resolves.
+- **Preload several assets.** `await Asset.loadAsync([require('./a.png'), require('./b.png')])`.
+- **Where does the file go?** The app's cache directory; the OS may remove it later.
+- **Does the hook reload for a new module id?** No, it loads once on mount, like upstream.
+
+Sources: [Expo docs: Asset](https://docs.expo.dev/versions/latest/sdk/asset/),
+[expo/expo#8222](https://github.com/expo/expo/pull/8222).
+
+## Test it
+
+No Fabric/Descriptor angle at all - every function here is a pure async-function surface over the
+`Asset` class, never a view. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution (`src/core/{asset,asset-sources,asset-uris,local-assets,
+platform-utils,asset-fx}.test.ts`, `src/{react,vue,svelte,solid,angular}/**/*.test.{ts,tsx}`) - no
+`installFabric()`, no ViewConfig.
+
+The `AssetScreen` in the `examples/expo-*` apps carries the on-device verification.

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { AssetsService } from './services/assets.service';
+export * from '../core';

package/build/angular/index.js

@@ -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/index.js';
+export * from '../core/index.js';

package/build/angular/services/assets.service/index.d.ts

@@ -0,0 +1,8 @@
+import { type Signal } from '@angular/core';
+import { Asset } from '../../../core';
+export declare class AssetsService {
+    connect(moduleIds: number | number[]): {
+        assets: Signal<Asset[] | undefined>;
+        error: Signal<Error | undefined>;
+    };
+}

package/build/angular/services/assets.service/index.js

@@ -0,0 +1,64 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { Injectable, signal } from '@angular/core';
+import { Asset } from '../../../core/index.js';
+// 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')])`.
+let AssetsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var AssetsService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            AssetsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        connect(moduleIds) {
+            const assets = signal(undefined);
+            const error = signal(undefined);
+            Asset.loadAsync(moduleIds)
+                .then(loaded => assets.set(loaded))
+                .catch((err) => error.set(err));
+            return { assets: assets.asReadonly(), error: error.asReadonly() };
+        }
+    };
+    return AssetsService = _classThis;
+})();
+export { AssetsService };

package/build/core/asset-fx.d.ts

@@ -0,0 +1 @@
+export {};

package/build/core/asset-fx.js

@@ -0,0 +1,24 @@
+// 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, {} from 'react-native/Libraries/Image/resolveAssetSource';
+import { Asset, ANDROID_EMBEDDED_URL_BASE_RESOURCE } from './asset.js';
+import { IS_ENV_WITH_LOCAL_ASSETS } from './platform-utils.js';
+const expoAssetTransformer = 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/build/core/asset-sources.d.ts

@@ -0,0 +1,13 @@
+import type { PackagerAsset } from '@react-native/assets-registry/registry';
+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 declare function resolveUri(uri: string): string;
+export declare function selectAssetSource(meta: AssetMetadata): AssetSource;

package/build/core/asset-sources.js

@@ -0,0 +1,50 @@
+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.js';
+/** Resolves a relative asset URI against the classic-updates manifest base, if any. */
+export function resolveUri(uri) {
+    return manifestBaseUrl ? new URL(uri, manifestBaseUrl).href : uri;
+}
+export function selectAssetSource(meta) {
+    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/build/core/asset-uris.d.ts

@@ -0,0 +1,3 @@
+export declare function getFilename(url: string): string;
+export declare function getFileExtension(url: string): string;
+export declare function getManifestBaseUrl(manifestUrl: string): string;

package/build/core/asset-uris.js

@@ -0,0 +1,33 @@
+// Ported from expo-asset/src/AssetUris.ts (sdk-57).
+function isDevBuild() {
+    return Boolean(globalThis.__DEV__);
+}
+function getBasename(pathname) {
+    return pathname.substring(pathname.lastIndexOf('/') + 1);
+}
+export function getFilename(url) {
+    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) {
+    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) {
+    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/build/core/asset.d.ts

@@ -0,0 +1,35 @@
+import { type AssetMetadata } from './asset-sources';
+export declare 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;
+};
+/** A locally- or remotely-sourced asset: metadata plus loading/caching facilities. */
+export declare class Asset {
+    private static byHash;
+    private static byUri;
+    name: string;
+    readonly type: string;
+    readonly hash: string | null;
+    readonly uri: string;
+    localUri: string | null;
+    width: number | null;
+    height: number | null;
+    downloaded: boolean;
+    private downloading;
+    private downloadCallbacks;
+    constructor({ name, type, hash, uri, width, height, }: AssetDescriptor);
+    static loadAsync(moduleId: number | number[] | string | string[]): Promise<Asset[]>;
+    static fromModule(virtualAssetModule: number | string | {
+        uri: string;
+        width: number;
+        height: number;
+    }): Asset;
+    static fromMetadata(meta: AssetMetadata): Asset;
+    static fromURI(uri: string): Asset;
+    downloadAsync(): Promise<this>;
+}

package/build/core/asset.js

@@ -0,0 +1,158 @@
+// 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 { selectAssetSource } from './asset-sources.js';
+import { getFileExtension } from './asset-uris.js';
+import { getLocalAssetUri } from './local-assets.js';
+import { expoAsset } from './native-module.js';
+import { IS_ENV_WITH_LOCAL_ASSETS } from './platform-utils.js';
+export const ANDROID_EMBEDDED_URL_BASE_RESOURCE = 'file:///android_res/';
+/** A locally- or remotely-sourced asset: metadata plus loading/caching facilities. */
+export class Asset {
+    static byHash = {};
+    static byUri = {};
+    name;
+    type;
+    hash = null;
+    uri;
+    localUri = null;
+    width = null;
+    height = null;
+    downloaded = false;
+    downloading = false;
+    downloadCallbacks = [];
+    constructor({ name, type, hash = null, uri, width, height, }) {
+        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) {
+        const moduleIds = Array.isArray(moduleId) ? moduleId : [moduleId];
+        return Promise.all(moduleIds.map(id => Asset.fromModule(id).downloadAsync()));
+    }
+    static fromModule(virtualAssetModule) {
+        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) {
+        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) {
+        const existing = Asset.byUri[uri];
+        if (existing)
+            return existing;
+        let type;
+        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() {
+        if (this.downloaded)
+            return this;
+        if (this.downloading) {
+            await new Promise((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/build/core/index.d.ts

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

package/build/core/index.js

@@ -0,0 +1,2 @@
+import './asset-fx.js';
+export { Asset, ANDROID_EMBEDDED_URL_BASE_RESOURCE, } from './asset.js';

package/build/core/local-assets.d.ts

@@ -0,0 +1 @@
+export declare function getLocalAssetUri(hash: string, type: string | null): string | null;

package/build/core/local-assets.js

@@ -0,0 +1,16 @@
+// 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.js';
+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;
+}

package/build/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;