@symbiote-native/engine 0.1.0

package/build/styles.d.ts

@@ -0,0 +1,220 @@
+import type { IColorValue } from './platform-color';
+export type IDimensionValue = number | string;
+export type IFlexAlign = 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'baseline';
+export type IFlexJustify = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+export type ITransformProp = {
+    translateX: number;
+} | {
+    translateY: number;
+} | {
+    scale: number;
+} | {
+    scaleX: number;
+} | {
+    scaleY: number;
+} | {
+    rotate: string;
+} | {
+    rotateX: string;
+} | {
+    rotateY: string;
+} | {
+    rotateZ: string;
+} | {
+    skewX: string;
+} | {
+    skewY: string;
+} | {
+    perspective: number;
+} | {
+    matrix: number[];
+};
+export interface IBoxShadowValue {
+    offsetX: number | string;
+    offsetY: number | string;
+    color?: IColorValue;
+    blurRadius?: number | string;
+    spreadDistance?: number | string;
+    inset?: boolean;
+}
+export interface IDropShadowValue {
+    offsetX: number | string;
+    offsetY: number | string;
+    standardDeviation?: number | string;
+    color?: IColorValue;
+}
+export type IFilterFunction = {
+    brightness: number | string;
+} | {
+    blur: number | string;
+} | {
+    contrast: number | string;
+} | {
+    grayscale: number | string;
+} | {
+    hueRotate: number | string;
+} | {
+    invert: number | string;
+} | {
+    opacity: number | string;
+} | {
+    saturate: number | string;
+} | {
+    sepia: number | string;
+} | {
+    dropShadow: IDropShadowValue | string;
+};
+export type IColorStopValue = {
+    color: IColorValue;
+    positions?: ReadonlyArray<string>;
+};
+export type ILinearGradientValue = {
+    type: 'linear-gradient';
+    direction?: string;
+    colorStops: ReadonlyArray<IColorStopValue>;
+};
+export type IRadialGradientPosition = {
+    top: number | string;
+    left: number | string;
+} | {
+    top: number | string;
+    right: number | string;
+} | {
+    bottom: number | string;
+    left: number | string;
+} | {
+    bottom: number | string;
+    right: number | string;
+};
+export type IRadialGradientShape = 'circle' | 'ellipse';
+export type IRadialGradientSize = 'closest-corner' | 'closest-side' | 'farthest-corner' | 'farthest-side' | {
+    x: string | number;
+    y: string | number;
+};
+export type IRadialGradientValue = {
+    type: 'radial-gradient';
+    shape?: IRadialGradientShape;
+    size?: IRadialGradientSize;
+    position?: IRadialGradientPosition;
+    colorStops: ReadonlyArray<IColorStopValue>;
+};
+export type IBackgroundImageValue = ILinearGradientValue | IRadialGradientValue;
+export type IBlendMode = 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity' | 'plus-lighter';
+export interface IViewStyle {
+    width?: IDimensionValue;
+    height?: IDimensionValue;
+    minWidth?: IDimensionValue;
+    minHeight?: IDimensionValue;
+    maxWidth?: IDimensionValue;
+    maxHeight?: IDimensionValue;
+    aspectRatio?: number | string;
+    flex?: number;
+    flexDirection?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+    flexWrap?: 'wrap' | 'nowrap' | 'wrap-reverse';
+    flexBasis?: IDimensionValue;
+    flexGrow?: number;
+    flexShrink?: number;
+    alignItems?: IFlexAlign;
+    alignSelf?: 'auto' | IFlexAlign;
+    alignContent?: IFlexJustify | 'stretch';
+    justifyContent?: IFlexJustify;
+    direction?: 'inherit' | 'ltr' | 'rtl';
+    gap?: number | string;
+    rowGap?: number | string;
+    columnGap?: number | string;
+    position?: 'absolute' | 'relative' | 'static';
+    top?: IDimensionValue;
+    right?: IDimensionValue;
+    bottom?: IDimensionValue;
+    left?: IDimensionValue;
+    start?: IDimensionValue;
+    end?: IDimensionValue;
+    zIndex?: number;
+    padding?: IDimensionValue;
+    paddingHorizontal?: IDimensionValue;
+    paddingVertical?: IDimensionValue;
+    paddingTop?: IDimensionValue;
+    paddingRight?: IDimensionValue;
+    paddingBottom?: IDimensionValue;
+    paddingLeft?: IDimensionValue;
+    paddingStart?: IDimensionValue;
+    paddingEnd?: IDimensionValue;
+    margin?: IDimensionValue;
+    marginHorizontal?: IDimensionValue;
+    marginVertical?: IDimensionValue;
+    marginTop?: IDimensionValue;
+    marginRight?: IDimensionValue;
+    marginBottom?: IDimensionValue;
+    marginLeft?: IDimensionValue;
+    marginStart?: IDimensionValue;
+    marginEnd?: IDimensionValue;
+    borderRadius?: number | string;
+    borderTopLeftRadius?: number | string;
+    borderTopRightRadius?: number | string;
+    borderBottomLeftRadius?: number | string;
+    borderBottomRightRadius?: number | string;
+    borderStartStartRadius?: number | string;
+    borderStartEndRadius?: number | string;
+    borderEndStartRadius?: number | string;
+    borderEndEndRadius?: number | string;
+    borderCurve?: 'circular' | 'continuous';
+    borderWidth?: number;
+    borderTopWidth?: number;
+    borderRightWidth?: number;
+    borderBottomWidth?: number;
+    borderLeftWidth?: number;
+    borderStartWidth?: number;
+    borderEndWidth?: number;
+    borderColor?: IColorValue;
+    borderTopColor?: IColorValue;
+    borderRightColor?: IColorValue;
+    borderBottomColor?: IColorValue;
+    borderLeftColor?: IColorValue;
+    borderStartColor?: IColorValue;
+    borderEndColor?: IColorValue;
+    borderStyle?: 'solid' | 'dotted' | 'dashed';
+    backgroundColor?: IColorValue;
+    opacity?: number;
+    overflow?: 'visible' | 'hidden' | 'scroll';
+    display?: 'none' | 'flex';
+    backfaceVisibility?: 'visible' | 'hidden';
+    shadowColor?: IColorValue;
+    shadowOffset?: {
+        width: number;
+        height: number;
+    };
+    shadowOpacity?: number;
+    shadowRadius?: number;
+    elevation?: number;
+    transform?: ITransformProp[];
+    transformOrigin?: [string | number, string | number, string | number] | string;
+    boxShadow?: IBoxShadowValue[] | string;
+    filter?: IFilterFunction[] | string;
+    experimental_backgroundImage?: IBackgroundImageValue[] | string;
+    mixBlendMode?: IBlendMode;
+}
+export interface ITextStyle extends IViewStyle {
+    color?: IColorValue;
+    fontFamily?: string;
+    fontSize?: number;
+    fontStyle?: 'normal' | 'italic';
+    fontWeight?: 'normal' | 'bold' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+    letterSpacing?: number;
+    lineHeight?: number;
+    textAlign?: 'auto' | 'left' | 'right' | 'center' | 'justify';
+    textAlignVertical?: 'auto' | 'top' | 'bottom' | 'center';
+    textTransform?: 'none' | 'capitalize' | 'uppercase' | 'lowercase';
+    textDecorationLine?: 'none' | 'underline' | 'line-through' | 'underline line-through';
+    textDecorationColor?: IColorValue;
+    textDecorationStyle?: 'solid' | 'double' | 'dotted' | 'dashed';
+    fontVariant?: string[];
+    writingDirection?: 'auto' | 'ltr' | 'rtl';
+    includeFontPadding?: boolean;
+}
+type IStyleFalsy = false | null | undefined | '';
+type IRecursiveArray<T> = ReadonlyArray<T | IRecursiveArray<T>>;
+export type IStyleProp<T> = T | IStyleFalsy | IRecursiveArray<T | IStyleFalsy>;
+export type INamedStyles<T> = {
+    [P in keyof T]: IViewStyle | ITextStyle;
+};
+export {};

package/build/styles.js

@@ -0,0 +1,7 @@
+// 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.
+export {};

package/build/surface.d.ts

@@ -0,0 +1,16 @@
+import type { IRootTag } from './fabric';
+import type { ISymbioteNode } from './node';
+export declare class SymbioteSurface {
+    readonly rootTag: IRootTag;
+    readonly children: ISymbioteNode[];
+    private commitScheduled;
+    constructor(rootTag: IRootTag);
+    appendChild(child: ISymbioteNode): void;
+    insertBefore(child: ISymbioteNode, beforeChild: ISymbioteNode): void;
+    removeChild(child: ISymbioteNode): void;
+    clear(): void;
+    commit(): void;
+    requestCommit(): void;
+    private detach;
+}
+export declare function createSurface(rootTag: IRootTag): SymbioteSurface;

package/build/surface.js

@@ -0,0 +1,67 @@
+// A surface is one mounted root: it owns the rootTag handed down by the native
+// Fabric host and the list of top-level retained nodes. Adapters mutate it and
+// ask it to commit; the surface coalesces commits and drives the engine.
+import { commitChildren } from './commit';
+import { dlog } from './debug';
+import { installEventHandler } from './events';
+export class SymbioteSurface {
+    rootTag;
+    children = [];
+    commitScheduled = false;
+    constructor(rootTag) {
+        this.rootTag = rootTag;
+    }
+    appendChild(child) {
+        this.detach(child);
+        child.parent = undefined;
+        this.children.push(child);
+    }
+    insertBefore(child, beforeChild) {
+        this.detach(child);
+        child.parent = undefined;
+        const index = this.children.indexOf(beforeChild);
+        this.children.splice(index < 0 ? this.children.length : index, 0, child);
+    }
+    removeChild(child) {
+        const index = this.children.indexOf(child);
+        if (index >= 0)
+            this.children.splice(index, 1);
+    }
+    clear() {
+        this.children.length = 0;
+    }
+    // Synchronous commit: used by React's resetAfterCommit, which already
+    // batches per logical update.
+    commit() {
+        commitChildren(this.rootTag, this.children);
+    }
+    // Coalesced commit: for reactive frameworks that emit many mutations per
+    // tick. Collapses to a single completeRoot at the microtask boundary.
+    requestCommit() {
+        if (this.commitScheduled)
+            return;
+        this.commitScheduled = true;
+        queueMicrotask(() => {
+            this.commitScheduled = false;
+            this.commit();
+        });
+    }
+    detach(child) {
+        const parent = child.parent;
+        if (parent) {
+            const index = parent.children.indexOf(child);
+            if (index >= 0)
+                parent.children.splice(index, 1);
+            child.parent = undefined;
+            return;
+        }
+        const topIndex = this.children.indexOf(child);
+        if (topIndex >= 0)
+            this.children.splice(topIndex, 1);
+    }
+}
+export function createSurface(rootTag) {
+    installEventHandler();
+    dlog(`surface created root=${rootTag}`);
+    return new SymbioteSurface(rootTag);
+}

package/build/tags.d.ts

@@ -0,0 +1 @@
+export declare function nextTag(): number;

package/build/tags.js

@@ -0,0 +1,10 @@
+// Fabric reactTags are caller-allocated: even numbers (odd-mod-10 is reserved
+// for root tags). A tag is minted once when a node is first created and then
+// stays with it across clone-on-write commits (the clone keeps the family), so
+// this counter only ever moves forward: one tag per node, not per commit.
+let next = 2;
+export function nextTag() {
+    const tag = next;
+    next += 2;
+    return tag;
+}

package/build/text-input-state.d.ts

@@ -0,0 +1,5 @@
+import type { ISymbioteNode } from './node';
+export declare function currentlyFocusedInput(): ISymbioteNode | null;
+export declare function setInputFocused(node: ISymbioteNode): void;
+export declare function setInputBlurred(node: ISymbioteNode): void;
+export declare function blurTextInput(node: ISymbioteNode | null): void;

package/build/text-input-state.js

@@ -0,0 +1,29 @@
+// Mirrors RN's TextInput/TextInputState: the single currently-focused input, tracked
+// JS-side because native exposes no focus getter. TextInput reports focus/blur here so
+// Keyboard.dismiss can blur whatever holds focus without a ref, exactly how RN's
+// dismissKeyboard() works (blurTextInput(currentlyFocusedInput())).
+import { dispatchViewCommand } from './commit';
+import { dlog } from './debug';
+let currentlyFocused = null;
+// The input that last reported focus and hasn't reported blur, or null.
+export function currentlyFocusedInput() {
+    return currentlyFocused;
+}
+// TextInput's focus event reports the node here; its blur event clears it (only if it
+// is still the current one; a later input may have taken focus in between).
+export function setInputFocused(node) {
+    currentlyFocused = node;
+}
+export function setInputBlurred(node) {
+    if (currentlyFocused === node)
+        currentlyFocused = null;
+}
+// Imperative blur: drive the native `blur` view command and drop the tracked focus.
+// Used by TextInput.blur() and Keyboard.dismiss().
+export function blurTextInput(node) {
+    if (node === null)
+        return;
+    dlog('TextInputState.blurTextInput -> blur command');
+    dispatchViewCommand(node, 'blur', []);
+    setInputBlurred(node);
+}

package/build/toast-android/index.d.ts

@@ -0,0 +1,10 @@
+export declare const ToastAndroid: {
+    SHORT: number;
+    LONG: number;
+    TOP: number;
+    BOTTOM: number;
+    CENTER: number;
+    show(message: string, duration: number): void;
+    showWithGravity(message: string, duration: number, gravity: number): void;
+    showWithGravityAndOffset(message: string, duration: number, gravity: number, xOffset: number, yOffset: number): void;
+};

package/build/toast-android/index.js

@@ -0,0 +1,108 @@
+// ToastAndroid module: pops a brief Android system toast from JS. Mirrors RN's
+// Libraries/Components/ToastAndroid/ToastAndroid.android.js: `show` takes a message
+// and a duration; `showWithGravity` adds a layout gravity; `showWithGravityAndOffset`
+// adds an x/y pixel offset. No Fabric view, pure JS->native.
+//
+// symbiote is iOS-first and this is an Android-only module. RN's iOS fallback
+// (ToastAndroid.ios.js) throws "not supported"; we prefer a no-op + dlog so a
+// cross-platform smoke never crashes when the native module is absent.
+//
+// The native contract is confirmed from RN's TurboModule spec at
+// specs_DEPRECATED/modules/INativeToastAndroid.js:
+//   getConstants(): { SHORT, LONG, TOP, BOTTOM, CENTER }
+//   show(message: string, duration: number)
+//   showWithGravity(message: string, duration: number, gravity: number)
+//   showWithGravityAndOffset(message, duration, gravity, xOffset, yOffset)
+import { dlog } from '../debug';
+import { getNativeModule } from '../native-modules';
+// 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`. Per the symbiote invariant, a module name is
+// only provable on a real host (a headless fake answers to any name); this Android
+// name is device-verify-pending. See .docs/native-module-platform-routing.md.
+const TOAST_MODULE = 'ToastAndroid';
+// Conventional RN values for SHORT/LONG/TOP/BOTTOM/CENTER. On a real device the
+// numbers come from native getConstants() (resolved below); these are the fallbacks
+// that keep the constants object populated headless and on a host without the module.
+const FALLBACK_CONSTANTS = {
+    SHORT: 0,
+    LONG: 1,
+    TOP: 48,
+    BOTTOM: 80,
+    CENTER: 17,
+};
+// Lazily resolved so importing this module has no native side effect.
+let toastModule;
+function getModule() {
+    if (toastModule === undefined) {
+        toastModule = getNativeModule(TOAST_MODULE);
+        dlog(`ToastAndroid: ToastAndroid module ${toastModule ? 'resolved' : 'NOT resolved (null)'}`);
+    }
+    return toastModule;
+}
+// Read a single numeric constant from the native getConstants() payload, narrowing
+// with a `typeof` guard (no cast) and falling back to the conventional RN value when
+// the module or the key is absent.
+function readConstant(raw, key) {
+    const value = raw[key];
+    return typeof value === 'number' ? value : FALLBACK_CONSTANTS[key];
+}
+// Resolve the constants once: real numbers from native on a device, fallbacks
+// otherwise. Always returns a fully-populated object so the constants are never
+// undefined, even headless.
+function resolveConstants() {
+    const module = getModule();
+    if (module === null) {
+        dlog('ToastAndroid: constants from fallbacks (native module unavailable)');
+        return { ...FALLBACK_CONSTANTS };
+    }
+    const raw = module.getConstants();
+    return {
+        SHORT: readConstant(raw, 'SHORT'),
+        LONG: readConstant(raw, 'LONG'),
+        TOP: readConstant(raw, 'TOP'),
+        BOTTOM: readConstant(raw, 'BOTTOM'),
+        CENTER: readConstant(raw, 'CENTER'),
+    };
+}
+const constants = resolveConstants();
+export const ToastAndroid = {
+    // Toast duration constants.
+    SHORT: constants.SHORT,
+    LONG: constants.LONG,
+    // Toast gravity constants.
+    TOP: constants.TOP,
+    BOTTOM: constants.BOTTOM,
+    CENTER: constants.CENTER,
+    // Show a toast with the given message and duration. Degrades to a no-op (logged)
+    // when the module is absent; a missing optional native module must never throw.
+    show(message, duration) {
+        const module = getModule();
+        if (module === null) {
+            dlog('ToastAndroid.show -> ToastAndroid native module unavailable, no-op');
+            return;
+        }
+        dlog(`ToastAndroid.show -> "${message}" (${duration})`);
+        module.show(message, duration);
+    },
+    // Show a toast at the given layout gravity (TOP / BOTTOM / CENTER).
+    showWithGravity(message, duration, gravity) {
+        const module = getModule();
+        if (module === null) {
+            dlog('ToastAndroid.showWithGravity -> ToastAndroid native module unavailable, no-op');
+            return;
+        }
+        dlog(`ToastAndroid.showWithGravity -> "${message}" (${duration}, gravity=${gravity})`);
+        module.showWithGravity(message, duration, gravity);
+    },
+    // Show a toast at the given gravity, offset by xOffset/yOffset pixels.
+    showWithGravityAndOffset(message, duration, gravity, xOffset, yOffset) {
+        const module = getModule();
+        if (module === null) {
+            dlog('ToastAndroid.showWithGravityAndOffset -> ToastAndroid native module unavailable, no-op');
+            return;
+        }
+        dlog(`ToastAndroid.showWithGravityAndOffset -> "${message}" (${duration}, gravity=${gravity}, ${xOffset}, ${yOffset})`);
+        module.showWithGravityAndOffset(message, duration, gravity, xOffset, yOffset);
+    },
+};

package/build/vibration/index.android.d.ts

@@ -0,0 +1,2 @@
+export type { INativeVibration, IVibrationStatic } from './shared';
+export declare const Vibration: import("./shared").IVibrationStatic;

package/build/vibration/index.android.js

@@ -0,0 +1,18 @@
+// 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.
+//
+// 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
+// bridgeless resolution log there can prove the name. See
+// .docs/native-module-platform-routing.md.
+import { createVibration } from './shared';
+// RN encodes "do not repeat" as -1 and "repeat from start" as 0 in vibrateByPattern.
+const REPEAT_NONE = -1;
+const REPEAT_FROM_START = 0;
+export const Vibration = createVibration({
+    vibratePattern: (module, pattern, repeat) => {
+        module.vibrateByPattern(pattern, repeat ? REPEAT_FROM_START : REPEAT_NONE);
+    },
+});

package/build/vibration/index.d.ts

@@ -0,0 +1 @@
+export * from './index.ios';

package/build/vibration/index.ios.d.ts

@@ -0,0 +1,2 @@
+export type { INativeVibration, IVibrationStatic } from './shared';
+export declare const Vibration: import("./shared").IVibrationStatic;

package/build/vibration/index.ios.js

@@ -0,0 +1,54 @@
+// Vibration (iOS build). iOS has no native pattern scheduler, so per RN's Vibration.js we
+// walk the segments JS-side with setTimeout (buzz, wait, buzz, …), looping when `repeat`.
+// Everything else (the single-number buzz, cancel, the module resolver) is the shared
+// core. Metro picks this file on an iOS host; the base vibration.ts re-exports it for
+// web/headless.
+import { createVibration, DEFAULT_VIBRATION_LENGTH } from './shared';
+// JS scheduler state, mirroring RN's _vibrating / _id. `scheduleId` guards against a
+// stale timer from a previous run firing into a new one.
+let vibrating = false;
+let scheduleId = 0;
+// Walk one pattern step: buzz, then arm the next step (or repeat / stop). Bails if
+// vibration was canceled (vibrating=false) or superseded by a newer run (id mismatch).
+function vibrateScheduler(module, id, pattern, repeat, nextIndex) {
+    if (!vibrating || id !== scheduleId) {
+        return;
+    }
+    module.vibrate(DEFAULT_VIBRATION_LENGTH);
+    let index = nextIndex;
+    if (index >= pattern.length) {
+        if (repeat) {
+            index = 0;
+        }
+        else {
+            vibrating = false;
+            return;
+        }
+    }
+    setTimeout(() => vibrateScheduler(module, id, pattern, repeat, index + 1), pattern[index]);
+}
+// iOS pattern entry point: a leading 0 means "buzz immediately", otherwise the first
+// entry is the initial wait before the first buzz.
+function vibratePattern(module, inputPattern, repeat) {
+    if (vibrating) {
+        return;
+    }
+    vibrating = true;
+    let pattern = inputPattern;
+    if (pattern[0] === 0) {
+        module.vibrate(DEFAULT_VIBRATION_LENGTH);
+        pattern = pattern.slice(1);
+    }
+    if (pattern.length === 0) {
+        vibrating = false;
+        return;
+    }
+    setTimeout(() => vibrateScheduler(module, ++scheduleId, pattern, repeat, 1), pattern[0]);
+}
+export const Vibration = createVibration({
+    vibratePattern,
+    // cancel stops the JS scheduler: the next tick sees vibrating=false and bails.
+    stopPattern: () => {
+        vibrating = false;
+    },
+});

package/build/vibration/index.js

@@ -0,0 +1,6 @@
+// Vibration: base / default build (web, headless tsx, any target without a dedicated
+// platform file). Metro overrides this with vibration.ios.ts / vibration.android.ts on a
+// real iOS/Android host; off those, the iOS build is the fallback (its Vibration module
+// resolves null elsewhere → graceful no-op). The barrel imports './vibration', which
+// resolves here under tsc/tsx and to the platform file under Metro. See ADR 0019.
+export * from './index.ios';

package/build/vibration/shared.d.ts

@@ -0,0 +1,15 @@
+export declare const DEFAULT_VIBRATION_LENGTH = 400;
+export interface INativeVibration {
+    vibrate(pattern: number): void;
+    vibrateByPattern(pattern: number[], repeat: number): void;
+    cancel(): void;
+}
+export interface IVibrationStatic {
+    vibrate(pattern?: number | number[], repeat?: boolean): void;
+    cancel(): void;
+}
+export interface IVibrationPlatform {
+    vibratePattern(module: INativeVibration, pattern: number[], repeat: boolean): void;
+    stopPattern?(): void;
+}
+export declare function createVibration(platform: IVibrationPlatform): IVibrationStatic;

package/build/vibration/shared.js

@@ -0,0 +1,68 @@
+// Shared core of the Vibration module, everything that does NOT differ by platform:
+// the public contract, the lazy native-module resolver, the single-number `vibrate`
+// path, and `cancel`. The per-platform files (vibration.ios.ts / vibration.android.ts)
+// supply ONLY what genuinely diverges (how an array PATTERN is walked) and hand it to
+// `createVibration`. Mirrors RN's Libraries/Vibration/Vibration.js: a number is a single
+// buzz, an array is a pattern.
+//
+// Native module name is `Vibration` on BOTH iOS and Android (see
+// .docs/native-module-platform-routing.md), so unlike Linking the module name is shared,
+// not divergent. The TurboModule spec lives at specs_DEPRECATED/modules/INativeVibration.js:
+//   vibrate(pattern: number)
+//   vibrateByPattern(pattern: number[], repeat: number)
+//   cancel()
+//
+// Metro selects the platform file on a real host (vibration.android.ts > vibration.ts);
+// the base vibration.ts re-exports the iOS build for web/headless. There is no runtime
+// `Platform.OS` read; the filename is the selector. See ADR 0019. No Fabric view,
+// pure JS->native.
+import { dlog } from '../debug';
+import { getNativeModule } from '../native-modules';
+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.
+export const DEFAULT_VIBRATION_LENGTH = 400;
+// Build a platform's Vibration from its array-pattern strategy. Each call owns its own
+// lazy module cache, so importing both platform builds in a smoke keeps them independent.
+// On a real host only one platform file is ever bundled.
+export function createVibration(platform) {
+    let vibrationModule;
+    function getModule() {
+        if (vibrationModule === undefined) {
+            vibrationModule = getNativeModule(VIBRATION_MODULE);
+            dlog(`Vibration: Vibration module ${vibrationModule ? 'resolved' : 'NOT resolved (null)'}`);
+        }
+        return vibrationModule;
+    }
+    return {
+        // Trigger a vibration. A number is a single buzz of that many ms; an array is a
+        // pattern delegated to the platform strategy. Degrades to a no-op (logged) when the
+        // module is absent; a missing optional native module must never throw on a device.
+        vibrate(pattern = DEFAULT_VIBRATION_LENGTH, repeat = false) {
+            const module = getModule();
+            if (module === null) {
+                dlog('Vibration.vibrate -> Vibration native module unavailable, no-op');
+                return;
+            }
+            if (typeof pattern === 'number') {
+                dlog(`Vibration.vibrate -> ${pattern}ms`);
+                module.vibrate(pattern);
+                return;
+            }
+            dlog(`Vibration.vibrate -> pattern[${pattern.length}], repeat=${repeat}`);
+            platform.vibratePattern(module, pattern, repeat);
+        },
+        // Stop an ongoing vibration. The iOS scheduler bails on its next tick once it clears
+        // its own JS state (stopPattern); both platforms then tell native to cancel.
+        cancel() {
+            const module = getModule();
+            if (module === null) {
+                dlog('Vibration.cancel -> Vibration native module unavailable, no-op');
+                return;
+            }
+            dlog('Vibration.cancel');
+            platform.stopPattern?.();
+            module.cancel();
+        },
+    };
+}

package/build/view-config.d.ts

@@ -0,0 +1 @@
+export declare function isEventFor(component: string, listenerName: string): boolean;