@symbiote-native/engine 1.2.0 → 1.3.1

package/build/settings/index.ios.js

@@ -0,0 +1,122 @@
+// Settings module: reads/writes the app's persisted defaults (iOS NSUserDefaults
+// via the native SettingsManager). A JS-side snapshot seeded from the native module
+// constants answers `get`; `set` writes through to native and updates the snapshot;
+// `watchKeys`/`clearWatch` are a pure-JS subscription registry that fires when a
+// watched key's value changes. Native re-broadcasts external edits through the
+// device event `settingsUpdated`, which feeds the same change->fire path. Mirrors
+// RN's Libraries/Settings/Settings.ios.js, iOS surface only.
+import { installDeviceEventHub, NativeEventEmitter, } from '../native-events.js';
+import { getNativeModule } from '../native-modules/index.js';
+import { dlog } from '../debug.js';
+import { isRecord } from '../type-guards.js';
+// The iOS native module name RN registers this under. NOTE: this is the name the
+// iOS JS wrapper resolves via `TurboModuleRegistry.getEnforcing('SettingsManager')`.
+// The spec filename is `INativeSettingsManager`. A module name is only provable on a
+// real host (a headless fake answers to any name); this iOS name is device-verify-pending.
+const SETTINGS_MODULE = 'SettingsManager';
+// The device event native emits when the app's defaults change out from under JS
+// (e.g. a Settings.bundle edit). Its payload is a record of changed key->value.
+const SETTINGS_UPDATED_EVENT = 'settingsUpdated';
+// watchIds are handed out as the registry index, so the first watcher is 0. A
+// cleared slot keeps its index (the array never shrinks) so later ids stay stable.
+const FIRST_WATCH_ID = 0;
+// Lazily resolved so importing this module has no native side effect. `null` when
+// the module isn't linked (headless): the snapshot then starts empty and `set`
+// updates only JS state + fires watchers.
+let settingsModule;
+function getModule() {
+    if (settingsModule === undefined) {
+        settingsModule = getNativeModule(SETTINGS_MODULE);
+        dlog(`Settings: module ${settingsModule ? 'resolved' : 'NOT resolved (null)'}`);
+    }
+    return settingsModule;
+}
+// The JS-side mirror of native defaults: seeded once from the module constants,
+// kept in sync by `set` and by the `settingsUpdated` device event.
+let snapshot;
+function getSnapshot() {
+    if (snapshot === undefined) {
+        const module = getModule();
+        const constants = module?.getConstants().settings;
+        snapshot = isRecord(constants) ? { ...constants } : {};
+        dlog(`Settings: snapshot seeded with ${Object.keys(snapshot).length} key(s)`);
+    }
+    return snapshot;
+}
+const subscriptions = [];
+// Fire every watcher whose key set covers `key`. Called only for keys that changed.
+function fireWatchers(key) {
+    for (const sub of subscriptions) {
+        if (sub.callback !== null && sub.keys.includes(key))
+            sub.callback();
+    }
+}
+// Fold a batch of new values into the snapshot, firing watchers for each key whose
+// value actually changed. Shared by `set` (JS-originated) and the device event
+// (native-originated), matching RN's `_sendObservations`.
+function applyChanges(values) {
+    const current = getSnapshot();
+    for (const key of Object.keys(values)) {
+        const next = values[key];
+        const didChange = current[key] !== next;
+        current[key] = next;
+        if (didChange)
+            fireWatchers(key);
+    }
+}
+let emitter;
+// Subscribe to native's `settingsUpdated` so external edits flow into the snapshot.
+// WHY lazy + module-gated: importing this file must have no native side effect, and
+// with no native module there is nothing native to observe, so a headless run that
+// never installs the device hub doesn't crash. Idempotent.
+function subscribeToNative() {
+    if (emitter !== undefined)
+        return;
+    const module = getModule();
+    if (module === null)
+        return;
+    installDeviceEventHub();
+    emitter = new NativeEventEmitter(module);
+    emitter.addListener(SETTINGS_UPDATED_EVENT, payload => {
+        if (!isRecord(payload))
+            return;
+        applyChanges(payload);
+    });
+}
+class SettingsImpl {
+    // Read the current value for `key` from the JS snapshot. `undefined` if unset.
+    get(key) {
+        subscribeToNative();
+        return getSnapshot()[key];
+    }
+    // Persist `settings` to native, update the snapshot, and fire watchers for the
+    // keys that changed. Without a native module (headless) only JS state updates.
+    set(settings) {
+        subscribeToNative();
+        const module = getModule();
+        if (module === null) {
+            dlog('Settings.set -> no module (JS snapshot + watchers only)');
+        }
+        else {
+            module.setValues(settings);
+        }
+        applyChanges(settings);
+    }
+    // Register a watcher for one or more keys. Returns a numeric watchId (the registry
+    // index) to pass to `clearWatch`.
+    watchKeys(keys, callback) {
+        subscribeToNative();
+        const watched = typeof keys === 'string' ? [keys] : keys;
+        const watchId = subscriptions.length + FIRST_WATCH_ID;
+        subscriptions.push({ keys: watched, callback });
+        return watchId;
+    }
+    // Disarm the watcher with the given id. Its slot is emptied (kept, not removed) so
+    // every other watchId stays valid.
+    clearWatch(watchId) {
+        if (watchId >= FIRST_WATCH_ID && watchId < subscriptions.length) {
+            subscriptions[watchId] = { keys: [], callback: null };
+        }
+    }
+}
+export const Settings = new SettingsImpl();

package/build/settings/index.js

@@ -1,122 +1,3 @@
-// Settings module: reads/writes the app's persisted defaults (iOS NSUserDefaults
-// via the native SettingsManager). A JS-side snapshot seeded from the native module
-// constants answers `get`; `set` writes through to native and updates the snapshot;
-// `watchKeys`/`clearWatch` are a pure-JS subscription registry that fires when a
-// watched key's value changes. Native re-broadcasts external edits through the
-// device event `settingsUpdated`, which feeds the same change->fire path. Mirrors
-// RN's Libraries/Settings/Settings.ios.js, iOS surface only.
-import { installDeviceEventHub, NativeEventEmitter, } from '../native-events.js';
-import { getNativeModule } from '../native-modules/index.js';
-import { dlog } from '../debug.js';
-import { isRecord } from '../type-guards.js';
-// The iOS native module name RN registers this under. NOTE: this is the name the
-// iOS JS wrapper resolves via `TurboModuleRegistry.getEnforcing('SettingsManager')`.
-// The spec filename is `INativeSettingsManager`. A module name is only provable on a
-// real host (a headless fake answers to any name); this iOS name is device-verify-pending.
-const SETTINGS_MODULE = 'SettingsManager';
-// The device event native emits when the app's defaults change out from under JS
-// (e.g. a Settings.bundle edit). Its payload is a record of changed key->value.
-const SETTINGS_UPDATED_EVENT = 'settingsUpdated';
-// watchIds are handed out as the registry index, so the first watcher is 0. A
-// cleared slot keeps its index (the array never shrinks) so later ids stay stable.
-const FIRST_WATCH_ID = 0;
-// Lazily resolved so importing this module has no native side effect. `null` when
-// the module isn't linked (headless): the snapshot then starts empty and `set`
-// updates only JS state + fires watchers.
-let settingsModule;
-function getModule() {
-    if (settingsModule === undefined) {
-        settingsModule = getNativeModule(SETTINGS_MODULE);
-        dlog(`Settings: module ${settingsModule ? 'resolved' : 'NOT resolved (null)'}`);
-    }
-    return settingsModule;
-}
-// The JS-side mirror of native defaults: seeded once from the module constants,
-// kept in sync by `set` and by the `settingsUpdated` device event.
-let snapshot;
-function getSnapshot() {
-    if (snapshot === undefined) {
-        const module = getModule();
-        const constants = module?.getConstants().settings;
-        snapshot = isRecord(constants) ? { ...constants } : {};
-        dlog(`Settings: snapshot seeded with ${Object.keys(snapshot).length} key(s)`);
-    }
-    return snapshot;
-}
-const subscriptions = [];
-// Fire every watcher whose key set covers `key`. Called only for keys that changed.
-function fireWatchers(key) {
-    for (const sub of subscriptions) {
-        if (sub.callback !== null && sub.keys.includes(key))
-            sub.callback();
-    }
-}
-// Fold a batch of new values into the snapshot, firing watchers for each key whose
-// value actually changed. Shared by `set` (JS-originated) and the device event
-// (native-originated), matching RN's `_sendObservations`.
-function applyChanges(values) {
-    const current = getSnapshot();
-    for (const key of Object.keys(values)) {
-        const next = values[key];
-        const didChange = current[key] !== next;
-        current[key] = next;
-        if (didChange)
-            fireWatchers(key);
-    }
-}
-let emitter;
-// Subscribe to native's `settingsUpdated` so external edits flow into the snapshot.
-// WHY lazy + module-gated: importing this file must have no native side effect, and
-// with no native module there is nothing native to observe, so a headless run that
-// never installs the device hub doesn't crash. Idempotent.
-function subscribeToNative() {
-    if (emitter !== undefined)
-        return;
-    const module = getModule();
-    if (module === null)
-        return;
-    installDeviceEventHub();
-    emitter = new NativeEventEmitter(module);
-    emitter.addListener(SETTINGS_UPDATED_EVENT, payload => {
-        if (!isRecord(payload))
-            return;
-        applyChanges(payload);
-    });
-}
-class SettingsImpl {
-    // Read the current value for `key` from the JS snapshot. `undefined` if unset.
-    get(key) {
-        subscribeToNative();
-        return getSnapshot()[key];
-    }
-    // Persist `settings` to native, update the snapshot, and fire watchers for the
-    // keys that changed. Without a native module (headless) only JS state updates.
-    set(settings) {
-        subscribeToNative();
-        const module = getModule();
-        if (module === null) {
-            dlog('Settings.set -> no module (JS snapshot + watchers only)');
-        }
-        else {
-            module.setValues(settings);
-        }
-        applyChanges(settings);
-    }
-    // Register a watcher for one or more keys. Returns a numeric watchId (the registry
-    // index) to pass to `clearWatch`.
-    watchKeys(keys, callback) {
-        subscribeToNative();
-        const watched = typeof keys === 'string' ? [keys] : keys;
-        const watchId = subscriptions.length + FIRST_WATCH_ID;
-        subscriptions.push({ keys: watched, callback });
-        return watchId;
-    }
-    // Disarm the watcher with the given id. Its slot is emptied (kept, not removed) so
-    // every other watchId stays valid.
-    clearWatch(watchId) {
-        if (watchId >= FIRST_WATCH_ID && watchId < subscriptions.length) {
-            subscriptions[watchId] = { keys: [], callback: null };
-        }
-    }
-}
-export const Settings = new SettingsImpl();
+// Settings: base / headless build. Metro picks index.ios.ts / index.android.ts on a device; off
+// those, the iOS build (the SettingsManager-backed one) is the default.
+export * from './index.ios.js';

package/build/share/index.android.js

@@ -9,47 +9,24 @@
 // name, so it is only proven on a real Android host (a bridgeless resolution log there).
 import { dlog } from '../debug.js';
 import { getNativeModule } from '../native-modules/index.js';
-import { validateContent, shareActions, SHARED_ACTION, DISMISSED_ACTION, } from './shared.js';
+import { assertShareArgs, invariant, shareActions } from './shared.js';
 const SHARE_MODULE = 'ShareModule';
-// ShareModule.share resolves an untyped value at the native boundary; narrow it before
-// reading `action` (no `as`).
-function isShareResult(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'action' in value &&
-        typeof value.action === 'string');
-}
 export const Share = {
     ...shareActions,
-    // Open the Android share dialog for `content`. Resolves with the user's action
-    // (Android always resolves sharedAction); rejects on invalid content, an unexpected
-    // native result, or a missing module (explicit reject, never a hung Promise).
+    // Share.js's Android branch: every check is a synchronous invariant, and the native result
+    // passes through untouched under `activityType: null`.
     share(content, options = {}) {
-        const invalid = validateContent(content);
-        if (invalid !== null) {
-            dlog(`Share.share -> invalid content: ${invalid.message}`);
-            return Promise.reject(invalid);
-        }
+        assertShareArgs(content, options);
         dlog('Share.share (android)');
         const shareModule = getNativeModule(SHARE_MODULE);
-        if (shareModule === null) {
-            dlog(`Share: "${SHARE_MODULE}" unresolved`);
-            return Promise.reject(new Error('Share: ShareModule native module unavailable'));
-        }
+        invariant(shareModule !== null, 'ShareModule should be registered on Android.');
+        invariant(content.title == null || typeof content.title === 'string', 'Invalid title: title should be a string.');
         const newContent = {
             title: content.title,
             message: typeof content.message === 'string' ? content.message : undefined,
         };
-        return shareModule.share(newContent, options.dialogTitle).then(result => {
-            if (!isShareResult(result)) {
-                dlog('Share.share -> android result missing action');
-                throw new Error('Share: ShareModule returned an unexpected result');
-            }
-            dlog(`Share.share -> android action=${result.action}`);
-            return {
-                action: result.action === DISMISSED_ACTION ? DISMISSED_ACTION : SHARED_ACTION,
-                activityType: null,
-            };
-        });
+        return shareModule
+            .share(newContent, options.dialogTitle)
+            .then(result => ({ activityType: null, ...result }));
     },
 };

package/build/share/index.ios.js

@@ -7,39 +7,38 @@
 import { dlog } from '../debug.js';
 import { getNativeModule } from '../native-modules/index.js';
 import { ACTION_SHEET_MANAGER, } from '../action-sheet-ios/index.js';
-import { validateContent, shareActions, SHARED_ACTION, DISMISSED_ACTION, } from './shared.js';
+import { isProcessableColor, processColor } from '../platform-color';
+import { assertShareArgs, invariant, shareActions, SHARED_ACTION, DISMISSED_ACTION, } from './shared.js';
 export const Share = {
     ...shareActions,
     // Open the iOS share sheet for `content`. Resolves with the user's action
     // (sharedAction / dismissedAction); rejects on invalid content, a native failure,
     // or a missing module (explicit reject rather than a Promise that never settles).
     share(content, options = {}) {
-        const invalid = validateContent(content);
-        if (invalid !== null) {
-            dlog(`Share.share -> invalid content: ${invalid.message}`);
-            return Promise.reject(invalid);
-        }
+        assertShareArgs(content, options);
         dlog('Share.share (ios)');
-        const manager = getNativeModule(ACTION_SHEET_MANAGER);
-        if (manager === null) {
-            dlog(`Share: "${ACTION_SHEET_MANAGER}" unresolved`);
-            return Promise.reject(new Error('Share: ActionSheetManager native module unavailable'));
-        }
+        // Share.js's iOS branch: both invariants run INSIDE the executor, so they reject.
         return new Promise((resolve, reject) => {
+            const tintColor = isProcessableColor(options.tintColor)
+                ? processColor(options.tintColor)
+                : undefined;
+            invariant(tintColor == null || typeof tintColor === 'number', 'Unexpected color given for options.tintColor');
+            const manager = getNativeModule(ACTION_SHEET_MANAGER);
+            invariant(manager !== null, 'NativeActionSheetManager is not registered on iOS, but it should be.');
             manager.showShareActionSheetWithOptions({
                 message: typeof content.message === 'string' ? content.message : undefined,
                 url: typeof content.url === 'string' ? content.url : undefined,
                 subject: options.subject,
-                tintColor: options.tintColor,
-                anchor: options.anchor,
+                tintColor: typeof tintColor === 'number' ? tintColor : undefined,
+                anchor: typeof options.anchor === 'number' ? options.anchor : undefined,
                 excludedActivityTypes: options.excludedActivityTypes,
             }, error => {
                 dlog('Share.share -> failure');
-                reject(new Error(error.message));
+                reject(error);
             }, (completed, activityType) => {
                 dlog(`Share.share -> success completed=${completed}`);
                 resolve(completed
-                    ? { action: SHARED_ACTION, activityType: activityType ?? null }
+                    ? { action: SHARED_ACTION, activityType }
                     : { action: DISMISSED_ACTION, activityType: null });
             });
         });

package/build/share/shared.d.ts

@@ -1,3 +1,5 @@
+import { invariant } from '../invariant';
+export { invariant };
 export type IShareContent = {
     title?: string;
     url: string;
@@ -17,7 +19,7 @@ export interface IShareOptions {
 export declare const SHARED_ACTION = "sharedAction";
 export declare const DISMISSED_ACTION = "dismissedAction";
 export interface IShareAction {
-    action: typeof SHARED_ACTION | typeof DISMISSED_ACTION;
+    action: string;
     activityType?: string | null;
 }
 export interface IShareStatic {
@@ -29,4 +31,4 @@ export declare const shareActions: {
     sharedAction: typeof SHARED_ACTION;
     dismissedAction: typeof DISMISSED_ACTION;
 };
-export declare function validateContent(content: IShareContent): Error | null;
+export declare function assertShareArgs(content: IShareContent, options: IShareOptions): void;

package/build/share/shared.js

@@ -7,6 +7,8 @@
 // Metro selects the platform file on a real host (share.android.ts > share.ts); the base
 // share.ts re-exports the iOS build for web/headless. There is no runtime `Platform.OS`
 // read: the filename is the selector.
+import { invariant } from '../invariant.js';
+export { invariant };
 // RN's Share action constants (RN Share.js ~173/179). These back the documented
 // `result.action === Share.dismissedAction` pattern. True statically-known literals,
 // so CONSTANT_CASE; the public fields (Share.sharedAction / Share.dismissedAction) are
@@ -19,14 +21,9 @@ export const shareActions = {
     sharedAction: SHARED_ACTION,
     dismissedAction: DISMISSED_ACTION,
 };
-// RN's invariant: return an Error (caller rejects rather than throws) so a bad call
-// can't unmount the tree on device. Shared because the rule is identical per platform.
-export function validateContent(content) {
-    if (typeof content !== 'object' || content === null) {
-        return new Error('Content to share must be a valid object');
-    }
-    if (typeof content.url !== 'string' && typeof content.message !== 'string') {
-        return new Error('At least one of URL or message is required');
-    }
-    return null;
+// Share.js's three shared invariants, checked before any promise exists on both platforms.
+export function assertShareArgs(content, options) {
+    invariant(typeof content === 'object' && content !== null, 'Content to share must be a valid object');
+    invariant(typeof content.url === 'string' || typeof content.message === 'string', 'At least one of URL or message is required');
+    invariant(typeof options === 'object' && options !== null, 'Options must be a valid object');
 }

package/build/status-bar/index.android.js

@@ -11,7 +11,7 @@
 // on device: show/hide + light/dark text survive the relayout without blanking.
 import { getNativeModule } from '../native-modules/index.js';
 import { dlog } from '../debug.js';
-import { processColor } from '../platform-color/index.js';
+import { processColor } from '../platform-color';
 import { STATUS_BAR_MANAGER, } from './shared.js';
 // processColor returns `unknown` (its result is platform-dependent); narrow to the
 // number Fabric/native expects, like RN's invariant before setColor. A non-number

package/build/status-bar/index.ios.js

@@ -17,9 +17,10 @@ import { STATUS_BAR_MANAGER, STATIC_HIDE_TRANSITION, hideTransition, } from './s
 // __turboModuleProxy is installed. Non-enforcing: a declarative StatusBar must NOT crash the
 // whole render if the module can't resolve.
 //
-// Simplification vs RN: RN maintains a prop-merge stack so nested StatusBars compose
-// (deepest/last wins); we direct-apply a single component's props, which is correct for one
-// StatusBar and a fine first cut.
+// TODO(rn-parity): each StatusBar applies its props directly. RN keeps a stack instead:
+// `_propsStack` over `_defaultProps`, unmount restores the previous entry, one batched native
+// update, public push/pop/replaceStackEntry, `showHideTransition`, and static setters that warn
+// on the wrong platform. Port it for both platforms and all 5 adapters.
 export function applyStatusBarProps(props) {
     const { barStyle, hidden, animated = false, networkActivityIndicatorVisible, } = props;
     const manager = getNativeModule(STATUS_BAR_MANAGER);

package/build/structured-style.d.ts

@@ -1,10 +1 @@
-/**
- * A style value with its structured keys resolved — the same value by identity when there was
- * nothing to resolve, which is nearly always.
- *
- * Accepts what a style slot can hold: one object, or a (nested) array of them. An array is not
- * memoized — `pushClassStyle` mints a fresh one on every publish, so a cache keyed on it could
- * never hit; its ENTRIES carry the memo instead, and the original array comes back untouched when
- * none of them moved.
- */
 export declare function resolveStructuredStyle(style: unknown): unknown;

package/build/structured-style.js

@@ -1,22 +1,12 @@
 // The ten style keys RN parses in JS before native, and the one place they are resolved.
-//
-// WHY THEY RUN AT WRITE TIME AND NOT AT PAYLOAD-BUILD TIME. On a device the payload is built by
-// `core/engine/cpp/SymbioteFabricProps.cpp`, which does not carry these — they are pure JS. So a
-// `boxShadow: '0 2px 4px #000'` resolved only inside `fabric-props.ts` is resolved only headless,
-// and the device gets the raw CSS string. Fabric's C++ parses a style string ONLY under
-// `enableNativeCSSParsing()`, which defaults to FALSE, so the declaration is dropped in silence:
-// no warning, no wrong value, just a gradient or a shadow that is not there. Resolving on the way
-// IN puts the structured value in `node.props` itself, which is the one thing both payload builders
-// read.
-//
-// This is the same move `configPayloadFold` makes for a third-party view's own processors, one
-// layer down: anything the C++ half cannot do has to happen before the C++ half sees the value.
-//
-// IDENTITY IS PART OF THE CONTRACT. A style object that needs nothing comes back BY IDENTITY, and
-// so does an array whose every entry did. The host's `OP_SET_PROP` skips a same-identity write, and
-// `pushClassStyle` compares what it is about to publish against what it published last — hand
-// either of them a fresh object per write and an unchanged style becomes a write and a dirty node
-// on every render.
+// They run at write time, not payload-build time: SymbioteFabricProps.cpp doesn't carry these
+// processors, so resolving only in fabric-props.ts leaves the device its raw CSS string, silently
+// dropped (C++ parses a style string only under enableNativeCSSParsing, default false).
+// Same move `configPayloadFold` makes for a third-party view's own processors: anything the C++
+// half can't do has to happen before the C++ half sees the value.
+// Identity is part of the contract: an object/array needing no resolution comes back by identity,
+// since OP_SET_PROP skips a same-identity write and pushClassStyle diffs by reference — a fresh
+// object per call would turn an unchanged style into a write and a dirty node every render.
 import { processAspectRatio } from './process-aspect-ratio.js';
 import { processBackgroundImage } from './process-background-image/index.js';
 import { processBackgroundPosition, processBackgroundRepeat, processBackgroundSize, } from './process-background-longhands.js';
@@ -80,10 +70,9 @@ function asFontVariantInput(value) {
         return value.filter(isString);
     return '';
 }
-// transform accepts a CSS string (processTransform parses it) or an array of single-key
-// transform records (the hot animated / sticky-header path). A non-string non-array value is NOT
-// dropped: it may already be processed, so it passes through verbatim rather than being coerced to
-// [] (which would erase a valid transform).
+// transform accepts a CSS string or an array of single-key records (the hot animated /
+// sticky-header path). A non-string non-array value passes through verbatim — it may already be
+// processed, so coercing it to [] would erase a valid transform.
 function processTransformValue(value) {
     if (typeof value === 'string')
         return processTransform(value);
@@ -154,15 +143,11 @@ function resolveRecord(style) {
     resolvedStyles.set(style, answer);
     return answer;
 }
-/**
- * A style value with its structured keys resolved — the same value by identity when there was
- * nothing to resolve, which is nearly always.
- *
- * Accepts what a style slot can hold: one object, or a (nested) array of them. An array is not
- * memoized — `pushClassStyle` mints a fresh one on every publish, so a cache keyed on it could
- * never hit; its ENTRIES carry the memo instead, and the original array comes back untouched when
- * none of them moved.
- */
+// A style value with its structured keys resolved — same value by identity when nothing needed
+// resolving, which is nearly always.
+// Accepts one object or a (nested) array of them. An array itself isn't memoized (pushClassStyle
+// mints a fresh one per publish, so a cache keyed on it would never hit); its entries carry the
+// memo instead.
 export function resolveStructuredStyle(style) {
     if (Array.isArray(style)) {
         let out;

package/build/styles.js

@@ -1,7 +1,4 @@
-// The typed style surface (ViewStyle / TextStyle and friends). Maps onto Yoga layout
-// props and RN's view/text props, which Fabric's C++ reads off the props payload.
-// A correctly-typed subset of RN's StyleSheet surface (see
-// react-native/Libraries/StyleSheet/StyleSheetTypes): the load-bearing layout / box /
-// shadow / transform / text props, not the full surface. Agnostic types, so they
-// live in the engine next to the style processors; every adapter re-exports them.
+// The typed style surface (ViewStyle/TextStyle and friends). Maps onto Yoga layout props and RN's
+// view/text props, which Fabric's C++ reads off the props payload. A correctly-typed subset of
+// RN's StyleSheet surface — agnostic types, so every adapter re-exports them from the engine.
 export {};

package/build/surface.d.ts

@@ -6,38 +6,12 @@ export declare class SymbioteSurface {
     private readonly node;
     private commitScheduled;
     constructor(rootTag: IRootTag);
-    /**
-     * Every OTHER live surface, so one commit names every root — see `commitSurfaceOps`.
-     *
-     * Static because it reads a sibling instance's private handle, which only a member of this class
-     * may do. One surface — the universal case — allocates nothing.
-     *
-     * `self` may already be OUT of the registry: a teardown unregisters and then commits, and that
-     * commit is the one carrying the removals. So the fast path cannot be a size check — with one
-     * live surface left, `size === 1` means either "only me" or "only the other one", and taking the
-     * shortcut on the second reading is how a surface loses the very batch that empties it.
-     */
     private static others;
-    /**
-     * The top-level nodes, asked of the host.
-     *
-     * A getter rather than an array this class maintains: a second copy of a child list is the thing
-     * this design removes, and `nextSiblingOf` (host-access.ts) needs the same answer the host gives
-     * for a parented node.
-     */
     get children(): readonly ISymbioteNode[];
     appendChild(child: ISymbioteNode): void;
     insertBefore(child: ISymbioteNode, beforeChild: ISymbioteNode): void;
     removeChild(child: ISymbioteNode): void;
     clear(): void;
-    /**
-     * Release every host behavior still standing under this surface, at unmount.
-     *
-     * The sweep above cannot answer this: it only sees nodes a `removeChild` NOMINATED, and an
-     * unmount removes nothing — the adapter drops the whole surface. Without it every node keeps its
-     * `afterCommit` registration and its timers, and a restarted surface's commits drain the dead
-     * one's hooks forever.
-     */
     teardown(): void;
     commit(): void;
     requestCommit(): void;