@symbiote-native/engine 0.1.6 → 0.2.0

package/build/style-registry/index.js

@@ -11,11 +11,27 @@
 // can write EITHER `class="sectionLabel"` OR `class="section-label"` - resolveOne below
 // falls back to the kebab->camel form on a miss, since authors don't reliably write the
 // exact camelCase key.
-// Compound lookup tries every ordering of 2-4 space-separated class parts joined by
-// '.' (e.g. "btn primary" -> "btn.primary" / "primary.btn") before falling back to a
-// per-class merge, mirroring CSS compound-selector registration (`.btn.primary { }`).
+// Compound lookup tries every ordering of 2-4 space-separated class parts (e.g. "btn primary"
+// -> "btnPrimary" / "primaryBtn"), mirroring CSS compound-selector registration
+// (`.btn.primary { }`), and layers whatever it finds ON TOP of the per-class merge.
 const COMPOUND_MIN_PARTS = 2;
 const COMPOUND_MAX_PARTS = 4;
+// A scope suffix as the `<style scoped>` compilers emit it: `card__data-v-1a2b3c4d` (Vue) or
+// `card__svelte-1a2b3c4d` (Svelte), the hash being css-parser's base36 hashFilePath. Matched by
+// SHAPE, never by "there is a `__` somewhere in the name" — a BEM class (`card__title`) must
+// never be read as a scoped `card`, which would silently merge the block's styles into the
+// element's.
+const SCOPE_SEPARATOR = '__';
+const SCOPE_SUFFIX_PATTERN = /^(?:data-v|svelte)-[0-9a-z]+$/;
+function splitScopedToken(token) {
+    const separator = token.lastIndexOf(SCOPE_SEPARATOR);
+    if (separator <= 0)
+        return null;
+    const scope = token.slice(separator + SCOPE_SEPARATOR.length);
+    if (!SCOPE_SUFFIX_PATTERN.test(scope))
+        return null;
+    return { base: token.slice(0, separator), scope };
+}
 const globalStyles = new Map();
 // Called by generated code from side-effect style imports. Last import wins on a
 // name collision, matching CSS cascade behavior.
@@ -49,18 +65,28 @@ export function resolveClassName(className) {
     const trimmed = className.trim();
     if (!trimmed)
         return {};
-    const exactMatch = globalStyles.get(trimmed) ?? globalStyles.get(kebabToCamel(trimmed));
+    const parts = trimmed.split(/\s+/).filter(Boolean);
+    // A single token is nothing but the exact-match lookup, so it goes through resolveOne, which
+    // adds the scoped-token base layering below. A multi-token string still tries the whole string
+    // as one key first — `$style.card`-style output arrives pre-resolved and must not be split.
+    if (parts.length <= 1)
+        return resolveOne(trimmed);
+    const exactMatch = lookupKey(trimmed);
     if (exactMatch)
         return exactMatch;
-    const parts = trimmed.split(/\s+/).filter(Boolean);
+    const merged = parts.reduce((acc, cls) => {
+        return { ...acc, ...resolveOne(cls) };
+    }, {});
+    // A compound rule LAYERS OVER the single-class rules rather than replacing them, matching the
+    // cascade: `.card { padding: 8; background: white }` + `.card.big { padding: 16 }` on
+    // `class="card big"` is padding 16 AND background white. Returning the compound alone (what
+    // this did before) silently dropped every property the compound did not itself restate.
     if (parts.length >= COMPOUND_MIN_PARTS && parts.length <= COMPOUND_MAX_PARTS) {
         const compound = tryCompoundLookup(parts);
         if (compound)
-            return compound;
+            return { ...merged, ...compound };
     }
-    return parts.reduce((acc, cls) => {
-        return { ...acc, ...resolveOne(cls) };
-    }, {});
+    return merged;
 }
 function generateCompoundPermutations(parts) {
     if (parts.length < COMPOUND_MIN_PARTS)
@@ -73,13 +99,13 @@ function generateCompoundPermutations(parts) {
 }
 function generateKPermutations(parts, size) {
     if (size === 0)
-        return [''];
+        return [[]];
     if (parts.length === 0)
         return [];
     const result = [];
     function helper(current, remaining, depth) {
         if (depth === size) {
-            result.push(toCompoundKey(current));
+            result.push(current);
             return;
         }
         for (let i = 0; i < remaining.length; i++) {
@@ -113,16 +139,69 @@ export function kebabToCamel(value) {
 function tryCompoundLookup(parts) {
     if (parts.length < COMPOUND_MIN_PARTS)
         return null;
-    for (const compound of generateCompoundPermutations(parts)) {
-        const style = globalStyles.get(compound);
-        if (style)
-            return style;
+    for (const subset of generateCompoundPermutations(parts)) {
+        for (const key of compoundKeysFor(subset)) {
+            const style = globalStyles.get(key);
+            if (style)
+                return style;
+        }
     }
     return null;
 }
+function compoundKeysFor(subset) {
+    const scoped = scopedCompoundKey(subset);
+    return scoped === null ? [toCompoundKey(subset)] : [toCompoundKey(subset), scoped];
+}
+// The scope suffix is appended per TOKEN in the markup (`class="card__svelte-h big__svelte-h"`)
+// but appears ONCE, at the end, in the registered key a compound rule produces
+// (`.card.big` -> `cardBig__svelte-h`) — the compiler collapses the selector to one name and
+// suffixes that. Those two operations do not commute, so the key built from the raw tokens
+// (`card__svelte-hBig__svelte-h`) can never match and every scoped compound rule was dead.
+// Rebuild the key the way registration did: strip the suffix, join the bases, re-append once.
+//
+// An UNSCOPED token in the subset contributes its own name and no scope, rather than aborting.
+// That is the `:global()` case, and it is why a partial `:global()` reaches the markup it was
+// written for: `.card :global(.reset)` registers the key `cardReset`, which the scoper suffixes
+// as a whole (the escape hatch exempts the `reset` MARKUP TOKEN, not the collapsed key), while
+// the element carries `card__svelte-h reset`. The same shape covers a class handed down from a
+// parent component, which likewise arrives unsuffixed.
+//
+// Widening, stated so it stays deliberate: a fully-scoped `.card.reset` collapses to that same
+// key, so an element carrying a FOREIGN `reset` now matches a rule the author scoped to their
+// own. The key format cannot tell the two apart — telling them apart needs a registry indexed by
+// token set, with per-token scope. The scopes still have to agree: two tokens from two different
+// components have no single suffix to factor out and stay unmatched.
+function scopedCompoundKey(subset) {
+    const bases = [];
+    let scope;
+    for (const token of subset) {
+        const split = splitScopedToken(token);
+        if (split === null) {
+            bases.push(token);
+            continue;
+        }
+        if (scope !== undefined && split.scope !== scope)
+            return null;
+        scope = split.scope;
+        bases.push(split.base);
+    }
+    return scope === undefined ? null : toCompoundKey(bases) + SCOPE_SEPARATOR + scope;
+}
+// A scoped token layers over its own unscoped name: on the web the element carries BOTH classes
+// (`class="card svelte-h"`), so a global `.card` in App.css still applies underneath the
+// component's `<style>` rule. Rewriting `card` -> `card__svelte-h` here is how the scope is
+// expressed instead of a second class, so the base has to be re-consulted explicitly or that
+// global rule silently disappears the moment a component defines a class of the same name.
 function resolveOne(name) {
     const trimmed = name.trim();
     if (!trimmed)
         return {};
-    return globalStyles.get(trimmed) ?? globalStyles.get(kebabToCamel(trimmed)) ?? {};
+    const scoped = lookupKey(trimmed);
+    const split = splitScopedToken(trimmed);
+    if (split === null)
+        return scoped ?? {};
+    return { ...lookupKey(split.base), ...scoped };
+}
+function lookupKey(name) {
+    return globalStyles.get(name) ?? globalStyles.get(kebabToCamel(name));
 }

package/build/style-sheet/index.js

@@ -5,7 +5,7 @@
 // constants. The typed ViewStyle/TextStyle live next door in styles.ts, so `create`
 // is typed against them like RN's, not left generic over a plain Record.
 import { dlog } from '../debug.js';
-import { getNativeModule } from '../native-modules.js';
+import { getNativeModule } from '../native-modules/index.js';
 import { flattenStyle } from '../style/index.js';
 // RN's hairline factor: a "1 physical pixel" line is ~0.4 logical px, rounded to the
 // nearest device pixel. Named so the 0.4 isn't a bare magic number (RN source uses
@@ -49,8 +49,10 @@ const absoluteFill = Object.freeze({
     top: 0,
     bottom: 0,
 });
-// RN's composeStyles: falsy left → right, falsy right → left, else the pair [a, b]
-// (which flatten later collapses, later keys winning).
+// RN's composeStyles: a null/undefined side yields the other, else the pair [a, b]
+// (which flatten later collapses, later keys winning). The test is null/undefined, NOT
+// falsy - compose(0, y) returns [0, y], matching react-native's own
+// src/private/styles/composeStyles.js, which branches on `== null`.
 function compose(style1, style2) {
     if (style1 === null || style1 === undefined)
         return style2;

package/build/surface.js

@@ -62,6 +62,7 @@ export class SymbioteSurface {
 }
 export function createSurface(rootTag) {
     installEventHandler();
+    const surface = new SymbioteSurface(rootTag);
     dlog(`surface created root=${rootTag}`);
-    return new SymbioteSurface(rootTag);
+    return surface;
 }

package/build/toast-android/index.js

@@ -14,7 +14,7 @@
 //   showWithGravity(message: string, duration: number, gravity: number)
 //   showWithGravityAndOffset(message, duration, gravity, xOffset, yOffset)
 import { dlog } from '../debug.js';
-import { getNativeModule } from '../native-modules.js';
+import { getNativeModule } from '../native-modules/index.js';
 // The native module name RN registers this under. NOTE: this is the name the spec
 // resolves via `TurboModuleRegistry.getEnforcing<Spec>('ToastAndroid')`, NOT the
 // spec filename `INativeToastAndroid`. A module name is only provable on a real

package/build/vibration/index.android.js

@@ -1,7 +1,6 @@
 // Vibration: Android build. Android has a native pattern scheduler, so the whole pattern
-// goes to native `vibrateByPattern(pattern, repeat)`: RN encodes "do not repeat" as -1
-// and "repeat from start" as 0. Everything else is the shared core. Metro picks this file
-// on an Android host.
+// goes to native `vibrateByPattern(pattern, repeat)` (repeat encoding below). Everything
+// else is the shared core. Metro picks this file on an Android host.
 //
 // device-verify-pending: the `Vibration` name and the `vibrateByPattern` routing are
 // confirmed from RN source but not yet exercised on a real Android host: only a

package/build/vibration/shared.js

@@ -16,7 +16,7 @@
 // the base vibration.ts re-exports the iOS build for web/headless. There is no runtime
 // `Platform.OS` read; the filename is the selector. No Fabric view, pure JS->native.
 import { dlog } from '../debug.js';
-import { getNativeModule } from '../native-modules.js';
+import { getNativeModule } from '../native-modules/index.js';
 const VIBRATION_MODULE = 'Vibration';
 // RN's _default_vibration_length: the single-buzz duration when no pattern is given,
 // and the per-segment buzz length the iOS scheduler emits between waits.

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@symbiote-native/engine",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "SymbioteNative's retained shadow-tree engine — clone-on-write commit path + event normalization over React Native Fabric, shared by every framework adapter.",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
@@ -32,7 +33,7 @@
     "react-native": ">=0.86"
   },
   "devDependencies": {
-    "@symbiote-native/test-utils": "0.1.5"
+    "@symbiote-native/test-utils": "0.1.6"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/build/animated/interpolation-node.d.ts

@@ -1,15 +0,0 @@
-import { AnimatedNode, AnimatedWithChildren } from './graph';
-import { type IInterpolationConfig } from './interpolation';
-import type { INativeNodeConfig, IPlatformConfig } from './native/native-animated';
-export declare class AnimatedInterpolation extends AnimatedWithChildren {
-    private readonly parent;
-    private readonly config;
-    private interpolation;
-    constructor(parent: AnimatedNode, config: IInterpolationConfig);
-    private getInterpolation;
-    __getValue(): number | string;
-    __attach(): void;
-    __detach(): void;
-    __makeNative(platformConfig?: IPlatformConfig): void;
-    __getNativeConfig(): INativeNodeConfig;
-}

package/build/animated/interpolation-node.js

@@ -1,58 +0,0 @@
-// AnimatedInterpolation: a graph node that maps its parent's numeric value
-// through an interpolation. Ported from RN's AnimatedInterpolation.js: numeric,
-// string-with-units, and color output ranges (the value graph; native config
-// removed). Platform (Native) colors stay out of scope, color.ts defers them.
-import { AnimatedNode, AnimatedWithChildren, registerInterpolationFactory } from './graph.js';
-import { checkValidRanges, createInterpolation } from './interpolation.js';
-export class AnimatedInterpolation extends AnimatedWithChildren {
-    parent;
-    config;
-    interpolation;
-    constructor(parent, config) {
-        super();
-        this.parent = parent;
-        this.config = config;
-        // Validate eagerly so a bad range fails at construction, not first frame.
-        checkValidRanges(config.inputRange, config.outputRange);
-    }
-    getInterpolation() {
-        if (this.interpolation === undefined) {
-            this.interpolation = createInterpolation(this.config);
-        }
-        return this.interpolation;
-    }
-    __getValue() {
-        const parentValue = this.parent.__getValue();
-        if (typeof parentValue !== 'number') {
-            throw new Error('Cannot interpolate an input which is not a number');
-        }
-        return this.getInterpolation()(parentValue);
-    }
-    __attach() {
-        this.parent.__addChild(this);
-        super.__attach();
-    }
-    __detach() {
-        this.parent.__removeChild(this);
-        super.__detach();
-    }
-    // Make the upstream value native first, so the parent->interpolation edge can be
-    // wired when this node is reached from a leaf rather than from the value.
-    __makeNative(platformConfig) {
-        this.parent.__makeNative(platformConfig);
-        super.__makeNative(platformConfig);
-    }
-    __getNativeConfig() {
-        return {
-            type: 'interpolation',
-            inputRange: this.config.inputRange,
-            outputRange: this.config.outputRange,
-            extrapolateLeft: this.config.extrapolateLeft ?? this.config.extrapolate ?? 'extend',
-            extrapolateRight: this.config.extrapolateRight ?? this.config.extrapolate ?? 'extend',
-        };
-    }
-}
-// Hand graph.ts's AnimatedNode.interpolate() the real constructor at module load,
-// so every node subclass's base-class interpolate() produces an actual
-// AnimatedInterpolation without graph.ts ever value-importing this module.
-registerInterpolationFactory((parent, config) => new AnimatedInterpolation(parent, config));

package/build/image-loader/index.d.ts

@@ -1,24 +0,0 @@
-import { type IImageSourceProp } from '../image-source-resolver';
-export type IImageSize = {
-    width: number;
-    height: number;
-};
-export type IImageCacheStatus = 'memory' | 'disk' | 'disk/memory';
-type ISizeSuccess = (width: number, height: number) => void;
-type ISizeFailure = (error: unknown) => void;
-declare function getSize(uri: string, success?: ISizeSuccess, failure?: ISizeFailure): Promise<IImageSize>;
-declare function getSizeWithHeaders(uri: string, headers: Record<string, string>, success?: ISizeSuccess, failure?: ISizeFailure): Promise<IImageSize>;
-declare function prefetch(uri: string, callback?: (requestId: number) => void): Promise<boolean>;
-declare function abortPrefetch(requestId: number): void;
-declare function queryCache(uris: string[]): Promise<Record<string, IImageCacheStatus>>;
-declare function resolveAssetSource(source: IImageSourceProp): unknown;
-export type IImageStatics = {
-    getSize: typeof getSize;
-    getSizeWithHeaders: typeof getSizeWithHeaders;
-    prefetch: typeof prefetch;
-    abortPrefetch: typeof abortPrefetch;
-    queryCache: typeof queryCache;
-    resolveAssetSource: typeof resolveAssetSource;
-};
-export declare const imageStatics: IImageStatics;
-export {};

package/build/image-loader/index.js

@@ -1,175 +0,0 @@
-// Image static methods (RN's Image.getSize / prefetch / queryCache / etc).
-//
-// These mirror RN's iOS Image statics (Libraries/Image/Image.ios.js), which delegate to the
-// `ImageLoader` native (Turbo)Module declared in NativeImageLoaderIOS.js. The Android spec
-// (NativeImageLoaderAndroid.js) registers under the SAME module name ('ImageLoader'), so this
-// stays a flat, non-platform-split module - only the Android prefetch call signature differs (a
-// second `requestId` arg), branched on Platform.OS below, not on module name. NOTE the asymmetry
-// in the iOS spec: `getSize` resolves a `[width, height]` ARRAY, while `getSizeWithHeaders`
-// resolves a `{width, height}` OBJECT, both are guarded below before reading. The native result
-// crosses the I/O boundary as `unknown`; we never cast it, we narrow its shape.
-//
-// This is a stateful, native-bridge-touching imperative module (module-level ImageLoader cache +
-// prefetch requestId counter) with no view of its own - it belongs in @symbiote-native/engine
-// alongside Alert/Share, not in a view/render-*.ts file (whose contract is zero state / zero
-// native bridge).
-import { dlog } from '../debug.js';
-import { resolveImageSource } from '../image-source-resolver.js';
-import { getNativeModule } from '../native-modules.js';
-import { Platform } from '../platform';
-import { isNumber } from '../type-guards.js';
-// The iOS native module name RN registers this under (NativeImageLoaderIOS.js resolves
-// `TurboModuleRegistry.getEnforcing<Spec>('ImageLoader')`). A module name like this is only
-// provable on a real host - a headless fake answers to any name - so this iOS name is
-// device-verify-pending.
-const IMAGE_LOADER_MODULE = 'ImageLoader';
-let imageLoaderModule;
-function getImageLoader() {
-    if (imageLoaderModule === undefined) {
-        imageLoaderModule = getNativeModule(IMAGE_LOADER_MODULE);
-        dlog(`Image: ImageLoader module ${imageLoaderModule ? 'resolved' : 'NOT resolved (null)'}`);
-    }
-    return imageLoaderModule;
-}
-// Narrow native's getSize result. The spec resolves a `[width, height]` array, but tolerate a
-// `{width, height}` object too (getSizeWithHeaders uses that shape).
-function toImageSize(result) {
-    if (Array.isArray(result) && isNumber(result[0]) && isNumber(result[1])) {
-        return { width: result[0], height: result[1] };
-    }
-    if (typeof result === 'object' && result !== null) {
-        const width = Reflect.get(result, 'width');
-        const height = Reflect.get(result, 'height');
-        if (isNumber(width) && isNumber(height))
-            return { width, height };
-    }
-    throw new Error(`Image: unexpected size result from native: ${JSON.stringify(result)}`);
-}
-function requireLoader(method) {
-    const loader = getImageLoader();
-    if (loader === null) {
-        throw new Error(`Image.${method}: ImageLoader native module is not available ` +
-            '(running headless or not linked on this host).');
-    }
-    return loader;
-}
-// Resolve image dimensions, optionally via success/failure callbacks. Always returns the Promise
-// too (RN returns void when a callback is passed, but a promise-and-callback shape is friendlier
-// and a strict superset).
-function getSize(uri, success, failure) {
-    const promise = Promise.resolve()
-        .then(() => requireLoader('getSize').getSize(uri))
-        .then(toImageSize);
-    if (typeof success === 'function') {
-        promise
-            .then(size => success(size.width, size.height))
-            .catch((error) => {
-            if (typeof failure === 'function')
-                failure(error);
-            else
-                dlog(`Image.getSize failed for ${uri}: ${String(error)}`);
-        });
-    }
-    return promise;
-}
-function getSizeWithHeaders(uri, headers, success, failure) {
-    const promise = Promise.resolve()
-        .then(() => requireLoader('getSizeWithHeaders').getSizeWithHeaders(uri, headers))
-        .then(toImageSize);
-    if (typeof success === 'function') {
-        promise
-            .then(size => success(size.width, size.height))
-            .catch((error) => {
-            if (typeof failure === 'function')
-                failure(error);
-            else
-                dlog(`Image.getSizeWithHeaders failed for ${uri}: ${String(error)}`);
-        });
-    }
-    return promise;
-}
-// Android keys an in-flight prefetch by a monotonic requestId (so abortRequest can cancel it);
-// RN's Image.android.js generates the same way. iOS ignores the arg.
-let prefetchRequestId = 0;
-// Download a remote image into the disk cache. Resolves to whether it succeeded. `callback`
-// receives the requestId (RN's Image.android.js shape) so the caller can later pass it to
-// abortPrefetch.
-async function prefetch(uri, callback) {
-    prefetchRequestId += 1;
-    const requestId = prefetchRequestId;
-    if (typeof callback === 'function')
-        callback(requestId);
-    const loader = requireLoader('prefetch');
-    return (Promise.resolve()
-        // Android's prefetchImage keys an abortable request on requestId; iOS takes ONLY the uri and
-        // throws on an extra arg (bridgeless TurboModule arg-count check). Match RN's per-platform call.
-        .then(() => Platform.OS === 'android'
-        ? loader.prefetchImage(uri, requestId)
-        : loader.prefetchImage(uri))
-        .then(result => result === true)
-        .catch((error) => {
-        dlog(`Image.prefetch failed for ${uri}: ${String(error)}`);
-        throw error;
-    }));
-}
-// Cancel an in-flight prefetch by the requestId prefetch handed back. Android only (mirrors
-// Image.android.js -> NativeImageLoaderAndroid.abortRequest); a missing abortRequest (iOS,
-// headless) is a no-op rather than a throw.
-function abortPrefetch(requestId) {
-    const loader = getImageLoader();
-    if (loader === null || typeof loader.abortRequest !== 'function') {
-        dlog(`Image.abortPrefetch(${requestId}): no abortRequest on this host, ignoring`);
-        return;
-    }
-    loader.abortRequest(requestId);
-}
-// Narrow native's queryCache result: an object mapping each known uri to its cache status.
-// Unknown statuses are dropped rather than trusted blindly.
-const CACHE_STATUS = {
-    memory: 'memory',
-    disk: 'disk',
-    'disk/memory': 'disk/memory',
-};
-function toCacheRecord(result) {
-    const record = {};
-    if (typeof result !== 'object' || result === null)
-        return record;
-    for (const key of Object.keys(result)) {
-        const value = Reflect.get(result, key);
-        if (typeof value === 'string' && Object.hasOwn(CACHE_STATUS, value)) {
-            record[key] = CACHE_STATUS[value];
-        }
-    }
-    return record;
-}
-async function queryCache(uris) {
-    return Promise.resolve()
-        .then(() => {
-        const loader = requireLoader('queryCache');
-        // The native queryCache never rejects (RCTImageLoader resolves getImageCacheStatus), so a
-        // rejection here is a JS/native boundary fault: log whether the method is even callable and
-        // the arg shape, to tell "not a function" (interop gap) from a marshalling reject.
-        dlog(`Image.queryCache: typeof loader.queryCache=${typeof loader.queryCache} uris=${uris.length}`);
-        return loader.queryCache(uris);
-    })
-        .then(toCacheRecord)
-        .catch((error) => {
-        dlog(`Image.queryCache failed: ${String(error)}`);
-        throw error;
-    });
-}
-// PURE JS: run the currently-installed source resolver (the same machinery the Image component
-// uses via resolveImageSource). RN's resolveAssetSource turns a require() asset id into
-// {uri, scale, ...}; the app injects the real one with setImageSourceResolver, and this exposes
-// its output to callers directly.
-function resolveAssetSource(source) {
-    return resolveImageSource(source);
-}
-export const imageStatics = {
-    getSize,
-    getSizeWithHeaders,
-    prefetch,
-    abortPrefetch,
-    queryCache,
-    resolveAssetSource,
-};

package/build/image-source-resolver/index.d.ts

@@ -1,9 +0,0 @@
-export declare function setImageSourceResolver(resolve: (source: unknown) => unknown): void;
-export declare function resolveImageSource(source: unknown): unknown;
-export type IImageSource = {
-    uri?: string;
-    scale?: number;
-    width?: number;
-    height?: number;
-};
-export type IImageSourceProp = IImageSource | IImageSource[] | number;

package/build/image-source-resolver/index.js

@@ -1,16 +0,0 @@
-// Image source resolution seam: require('./x.png') asset ids and {uri} sources are resolved by
-// RN's own resolveAssetSource before reaching the shared render fn. The actual resolution is
-// RN-platform-specific, so it is injected here rather than imported, mirroring platform-color.ts's
-// processColor seam - this keeps @symbiote-native/components free of a react-native dependency (and
-// the headless harness working). BOTH the pure renderImage view (@symbiote-native/components) and
-// this package's own image-loader statics (resolveAssetSource) call resolveImageSource; neither
-// reaches into the mutable resolver directly.
-let sourceResolver = source => source;
-export function setImageSourceResolver(resolve) {
-    sourceResolver = resolve;
-}
-// Public mirror of RN's Image.resolveAssetSource: run a source through the injected resolver.
-// Headless (no resolver wired) it is the identity, so smokes see the input unchanged.
-export function resolveImageSource(source) {
-    return sourceResolver(source);
-}

package/build/native-modules.d.ts

@@ -1,18 +0,0 @@
-import { NativeEventEmitter } from './native-events';
-declare global {
-    var __turboModuleProxy: (<T>(name: string) => T | null) | undefined;
-    var nativeModuleProxy: Record<string, unknown> | undefined;
-}
-export declare function getNativeModule<T>(name: string): T | null;
-export declare function getEnforcingNativeModule<T>(name: string): T;
-export interface IDeviceEventModuleConfig<TModule> {
-    moduleName: string;
-    moduleLogPrefix: string;
-    bindModuleToEmitter?: boolean;
-    onEmitterCreated?: (emitter: NativeEventEmitter, module: TModule | null) => void;
-}
-export interface IDeviceEventModule<TModule> {
-    getModule(): TModule | null;
-    getEmitter(): NativeEventEmitter;
-}
-export declare function createDeviceEventModule<TModule>(config: IDeviceEventModuleConfig<TModule>): IDeviceEventModule<TModule>;