yaver-feedback-react-native 0.9.9 → 0.9.11

package/app.plugin.js

@@ -227,7 +227,9 @@ function withYaverAppDelegateHook(config) {
     // Existing consumers may already have the hot-reload hook from an older
     // SDK. Still apply newer, independently-versioned native contracts.
     if (contents.includes("YaverHotReload")) {
-      config.modResults.contents = patchDogfoodAppShortcut(contents);
+      config.modResults.contents = patchDogfoodAppShortcut(
+        patchHotReloadBootConfirmation(contents)
+      );
       return config;
     }
 
@@ -273,20 +275,14 @@ function withYaverAppDelegateHook(config) {
       name: Notification.Name("YaverHotReloadBundle"),
       object: nil
     )
-    // Crash-revert safety net: clear the boot-attempt counter once
-    // RN renders its first frame, OR after 10 s of uptime — whichever
-    // fires first. If neither fires (bundle crashes before render),
-    // YaverHotReload.bundleURL() will eventually revert to the
-    // TestFlight-installed bundle after 3 failed boots. See
-    // YaverHotReload.swift for the full state machine.
+    // Crash-revert safety net: only a real first React frame confirms boot.
+    // Uptime is not success: JS can fail while the native process remains
+    // alive on its launch screen indefinitely.
     NotificationCenter.default.addObserver(
       forName: NSNotification.Name(rawValue: "RCTContentDidAppearNotification"),
       object: nil,
       queue: .main
     ) { _ in YaverHotReload.markBootSuccessful() }
-    DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
-      YaverHotReload.markBootSuccessful()
-    }
   }
 
   @objc private func yaverHandleHotReload(_ notification: Notification) {
@@ -374,6 +370,23 @@ function withYaverAppDelegateHook(config) {
   });
 }
 
+/** Upgrade an already-generated AppDelegate from the pre-0.9.10 boot guard.
+ * Older plugins treated ten seconds of process uptime as a successful React
+ * boot. A JS exception can leave that process alive on the native splash, so
+ * the timer reset the crash counter forever and prevented bundle rollback. */
+function patchHotReloadBootConfirmation(contents) {
+  let patched = contents;
+  patched = patched.replace(
+    /    \/\/ Crash-revert safety net: clear the boot-attempt counter once\n    \/\/ RN renders its first frame, OR after 10 s of uptime — whichever\n    \/\/ fires first\. If neither fires \(bundle crashes before render\),\n    \/\/ YaverHotReload\.bundleURL\(\) will eventually revert to the\n    \/\/ TestFlight-installed bundle after 3 failed boots\. See\n    \/\/ YaverHotReload\.swift for the full state machine\./,
+    `    // Crash-revert safety net: only a real first React frame confirms boot.\n    // Uptime is not success: JS can fail while the native process remains\n    // alive on its launch screen indefinitely.`
+  );
+  patched = patched.replace(
+    /    DispatchQueue\.main\.asyncAfter\(deadline: \.now\(\) \+ 10\) \{\n      YaverHotReload\.markBootSuccessful\(\)\n    \}\n?/g,
+    ""
+  );
+  return patched;
+}
+
 /** Wire the dynamic iOS Home Screen shortcut into the SDK native module.
  * The shortcut itself is created at runtime only after backend ACL success;
  * this hook merely consumes a user-selected action on warm/cold launch. */
@@ -820,6 +833,7 @@ const yaverFeedbackPlugin = createRunOncePlugin(
 // config-plugin seam catches template drift before a consumer discovers it in
 // an archive build.
 yaverFeedbackPlugin.__test = {
+  patchHotReloadBootConfirmation,
   patchDogfoodAppShortcut,
   patchDogfoodSceneDelegate,
   findAppDelegateClassClose,

package/dist/DogfoodRuntime.d.ts

@@ -17,6 +17,13 @@ export interface DogfoodProject {
     workDir: string;
     framework: string;
     lane: DogfoodLane;
+    /**
+     * Optional automatic recovery lane. The shared onboarding flow uses the
+     * browser lane here when a user prefers Hermes or WebRTC for a project that
+     * can also render in a browser. The failed preferred attempt remains in the
+     * live console; the fallback is never silent.
+     */
+    fallbackLane?: DogfoodLane;
     /** Optional source URL for drivers that can clone missing source. */
     repositoryUrl?: string;
     /** Optional native target from /remote-runtime/capabilities for WebRTC. */
@@ -29,12 +36,36 @@ export interface DogfoodLaneOption {
     default: boolean;
     reason?: string;
 }
+export interface DogfoodLanePlan {
+    preferred: DogfoodLane;
+    /** Browser is the cheap, portable recovery lane for RN/Expo/Flutter/web. */
+    fallback?: DogfoodLane;
+    options: DogfoodLaneOption[];
+}
 /** One framework-to-lane matrix for Yaver and third-party consumers. */
 export declare function dogfoodLaneOptions(framework: string, capabilities?: {
     nativeRuntimeAvailable?: boolean;
+    browserRuntimeAvailable?: boolean;
     selfDevelopment?: boolean;
 }): DogfoodLaneOption[];
-export declare function defaultDogfoodLane(framework: string): DogfoodLane;
+export declare function defaultDogfoodLane(framework: string, capabilities?: {
+    nativeRuntimeAvailable?: boolean;
+    browserRuntimeAvailable?: boolean;
+    selfDevelopment?: boolean;
+}): DogfoodLane;
+/**
+ * Resolve one ordered lane policy for Yaver and embedded SDK hosts.
+ *
+ * Browser is the onboarding default for browser-capable React Native, Expo,
+ * Flutter, and web projects. When the user explicitly prefers Hermes or
+ * WebRTC, browser becomes the automatic second attempt. Native-only projects
+ * remain WebRTC-only and never advertise a browser recovery they cannot run.
+ */
+export declare function dogfoodLanePlan(framework: string, capabilities?: {
+    nativeRuntimeAvailable?: boolean;
+    browserRuntimeAvailable?: boolean;
+    selfDevelopment?: boolean;
+}, preferred?: DogfoodLane | null): DogfoodLanePlan;
 export interface DogfoodLogLine {
     text: string;
     at: number;

package/dist/DogfoodRuntime.js

@@ -15,13 +15,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DogfoodController = exports.dogfoodLogLinesFromDevEvent = exports.DogfoodRuntimeError = void 0;
 exports.dogfoodLaneOptions = dogfoodLaneOptions;
 exports.defaultDogfoodLane = defaultDogfoodLane;
+exports.dogfoodLanePlan = dogfoodLanePlan;
 exports.validateDogfoodProject = validateDogfoodProject;
 exports.runtimeLogLinesFromDevEvent = runtimeLogLinesFromDevEvent;
 /** One framework-to-lane matrix for Yaver and third-party consumers. */
 function dogfoodLaneOptions(framework, capabilities = {}) {
     const normalized = String(framework || '').trim().toLowerCase();
     const reactNative = normalized === 'expo' || normalized === 'react-native';
-    const browserCapable = reactNative || [
+    // The framework matrix is the safe default. A positively detected browser
+    // target may add an exception (for example SwiftWasm/Tokamak), but a missing
+    // browser binary must not incorrectly remove RN/Flutter's browser build lane.
+    const browserCapable = capabilities.browserRuntimeAvailable === true || reactNative || [
         'flutter', 'web', 'next', 'nextjs', 'vite', 'remix', 'svelte', 'vue', 'angular',
     ].includes(normalized);
     const nativeAvailable = capabilities.nativeRuntimeAvailable === true;
@@ -40,8 +44,31 @@ function dogfoodLaneOptions(framework, capabilities = {}) {
         },
     ];
 }
-function defaultDogfoodLane(framework) {
-    return dogfoodLaneOptions(framework).find((option) => option.default && option.supported)?.lane || 'browser';
+function defaultDogfoodLane(framework, capabilities = {}) {
+    const options = dogfoodLaneOptions(framework, capabilities);
+    return options.find((option) => option.default && option.supported)?.lane
+        || options.find((option) => option.supported)?.lane
+        || 'browser';
+}
+/**
+ * Resolve one ordered lane policy for Yaver and embedded SDK hosts.
+ *
+ * Browser is the onboarding default for browser-capable React Native, Expo,
+ * Flutter, and web projects. When the user explicitly prefers Hermes or
+ * WebRTC, browser becomes the automatic second attempt. Native-only projects
+ * remain WebRTC-only and never advertise a browser recovery they cannot run.
+ */
+function dogfoodLanePlan(framework, capabilities = {}, preferred) {
+    const options = dogfoodLaneOptions(framework, capabilities);
+    const supported = (lane) => !!lane && options.some((option) => option.lane === lane && option.supported);
+    const resolved = supported(preferred)
+        ? preferred
+        : defaultDogfoodLane(framework, capabilities);
+    return {
+        preferred: resolved,
+        fallback: resolved !== 'browser' && supported('browser') ? 'browser' : undefined,
+        options,
+    };
 }
 class DogfoodRuntimeError extends Error {
     constructor(failure) {
@@ -167,8 +194,8 @@ class DogfoodController {
             phase: 'preparing', attempt, project: this.project,
             message: `Preparing ${this.project.name}…`, logs: [], startedAt: Date.now(),
         });
-        const context = {
-            project: this.project,
+        const makeContext = (project) => ({
+            project,
             attempt,
             log: (line) => {
                 if (generation !== this.generation)
@@ -195,16 +222,69 @@ class DogfoodController {
                 this.cleanups.set(generation, owned);
             },
             isCurrent: () => generation === this.generation,
-        };
+        });
+        let activeProject = this.project;
+        let context = makeContext(activeProject);
         try {
-            await this.driver.prepare?.(context);
-            if (!context.isCurrent())
-                throw new DogfoodRuntimeError({
-                    code: 'DOGFOOD_ATTEMPT_REPLACED', error: 'A newer Dogfood attempt replaced this one.',
-                    remedy: 'Wait for the newer attempt.', retryable: true,
+            const start = async () => {
+                await this.driver.prepare?.(context);
+                if (!context.isCurrent())
+                    throw new DogfoodRuntimeError({
+                        code: 'DOGFOOD_ATTEMPT_REPLACED', error: 'A newer Dogfood attempt replaced this one.',
+                        remedy: 'Wait for the newer attempt.', retryable: true,
+                    });
+                context.setPhase('starting', `Starting ${activeProject.name} on the ${activeProject.lane} lane…`);
+                return this.driver.start(context);
+            };
+            let result;
+            try {
+                result = await start();
+            }
+            catch (primaryError) {
+                const primaryFailure = failureFrom(primaryError);
+                const fallbackLane = activeProject.fallbackLane;
+                const mayFallback = !!fallbackLane
+                    && fallbackLane !== activeProject.lane
+                    && primaryFailure.retryable
+                    && primaryFailure.code !== 'DOGFOOD_ATTEMPT_REPLACED';
+                if (!mayFallback)
+                    throw primaryError;
+                await this.runCleanups('all', generation);
+                const fallbackProject = {
+                    ...activeProject,
+                    lane: fallbackLane,
+                    fallbackLane: undefined,
+                };
+                const fallbackInvalid = validateDogfoodProject(fallbackProject);
+                if (fallbackInvalid)
+                    throw primaryError;
+                const fallbackLine = {
+                    text: `[fallback] ${activeProject.lane} failed (${primaryFailure.code}); trying ${fallbackLane}`,
+                    at: Date.now(),
+                    stream: 'system',
+                };
+                activeProject = fallbackProject;
+                this.replace({
+                    ...this.state,
+                    project: activeProject,
+                    phase: 'preparing',
+                    message: `Recovering ${activeProject.name} in the ${fallbackLane} lane…`,
+                    logs: [...this.state.logs, fallbackLine].slice(-this.maxLogLines),
+                    lastOutputAt: fallbackLine.at,
+                    failure: undefined,
                 });
-            context.setPhase('starting', `Starting ${this.project.name} on the ${this.project.lane} lane…`);
-            const result = await this.driver.start(context);
+                context = makeContext(activeProject);
+                result = await start();
+                result = {
+                    ...result,
+                    metadata: {
+                        ...result.metadata,
+                        preferredLane: this.project.lane,
+                        fallbackFrom: this.project.lane,
+                        fallbackReason: primaryFailure.code,
+                    },
+                };
+            }
             if (!context.isCurrent()) {
                 await this.runCleanups('all', generation);
                 throw new DogfoodRuntimeError({
@@ -212,7 +292,7 @@ class DogfoodController {
                     remedy: 'Wait for the newer attempt.', retryable: true,
                 });
             }
-            this.replace({ ...this.state, phase: 'ready', message: `${this.project.name} is ready`, result, failure: undefined });
+            this.replace({ ...this.state, project: activeProject, phase: 'ready', message: `${activeProject.name} is ready`, result, failure: undefined });
             return result;
         }
         catch (error) {

package/dist/DogfoodSessionUi.d.ts

@@ -32,6 +32,7 @@ export declare const DogfoodStatusRail: React.FC<{
 export declare const DogfoodLanePicker: React.FC<{
     options: readonly DogfoodLaneOption[];
     selected: DogfoodLane;
+    fallbackLane?: DogfoodLane;
     onSelect: (lane: DogfoodLane) => void;
     colors?: Partial<DogfoodUiColors>;
     showUnsupportedReasons?: boolean;
@@ -40,6 +41,7 @@ export declare const DogfoodLanePicker: React.FC<{
  * Logs; Hermes/WebRTC use the same lifecycle and failure/remedy treatment. */
 export declare const DogfoodLiveConsole: React.FC<{
     lane: DogfoodLane;
+    sourceLabel?: string;
     phase: DogfoodPhase;
     message: string;
     logs: readonly DogfoodLogLine[];

package/dist/DogfoodSessionUi.js

@@ -54,7 +54,7 @@ const DogfoodStatusRail = ({ steps, colors: colorOverrides }) => {
 };
 exports.DogfoodStatusRail = DogfoodStatusRail;
 /** One lane selector and one default policy across Yaver, SFMG, and Talos. */
-const DogfoodLanePicker = ({ options, selected, onSelect, colors: colorOverrides, showUnsupportedReasons = true }) => {
+const DogfoodLanePicker = ({ options, selected, fallbackLane, onSelect, colors: colorOverrides, showUnsupportedReasons = true }) => {
     const colors = resolvedColors(colorOverrides);
     return (<react_native_1.View accessibilityRole="radiogroup" accessibilityLabel="Dogfood runtime lane">
       <react_native_1.View style={styles.choiceRow}>
@@ -69,7 +69,8 @@ const DogfoodLanePicker = ({ options, selected, onSelect, colors: colorOverrides
                     },
                 ]}>
               <react_native_1.Text style={[styles.choiceText, { color: colors.text }, active && styles.choiceTextActive]}>
-                {option.label}{option.default ? ' · default' : ''}
+                {option.label}
+                {active ? ' · preferred' : fallbackLane === option.lane ? ' · automatic fallback' : option.default ? ' · default' : ''}
               </react_native_1.Text>
             </react_native_1.Pressable>);
         })}
@@ -91,15 +92,17 @@ function runtimeTone(phase, colors) {
 }
 /** Shared second-stage live console. Browser lane deliberately names Browser
  * Logs; Hermes/WebRTC use the same lifecycle and failure/remedy treatment. */
-const DogfoodLiveConsole = ({ lane, phase, message, logs, failure, maxLines = 80, colors: colorOverrides, renderText }) => {
+const DogfoodLiveConsole = ({ lane, sourceLabel, phase, message, logs, failure, maxLines = 80, colors: colorOverrides, renderText }) => {
     const colors = resolvedColors(colorOverrides);
     const text = logs.slice(-maxLines).map((line) => line.text).join('\n');
     const title = lane === 'browser' ? 'Browser Logs' : lane === 'hermes' ? 'Hermes Logs' : 'WebRTC Logs';
-    return (<react_native_1.View style={[styles.console, { backgroundColor: colors.console, borderColor: colors.border }]} accessibilityLabel={title}>
+    const accessibleTitle = sourceLabel ? `${title} · ${sourceLabel}` : title;
+    return (<react_native_1.View style={[styles.console, { backgroundColor: colors.console, borderColor: colors.border }]} accessibilityLabel={accessibleTitle}>
       <react_native_1.View style={styles.consoleHeader}>
         <react_native_1.View style={[styles.statusDot, { backgroundColor: runtimeTone(phase, colors) }]}/>
         <react_native_1.Text style={[styles.consoleTitle, { color: colors.text }]}>{title}</react_native_1.Text>
       </react_native_1.View>
+      {sourceLabel ? <react_native_1.Text style={[styles.consoleSource, { color: colors.muted }]}>Source · {sourceLabel}</react_native_1.Text> : null}
       <react_native_1.Text style={[styles.consoleStatus, { color: colors.muted }]}>{message}</react_native_1.Text>
       {text ? (renderText ? renderText(text) : <react_native_1.Text selectable style={[styles.consoleText, { color: colors.text }]}>{text}</react_native_1.Text>) : (<react_native_1.Text style={[styles.consoleEmpty, { color: colors.muted }]}>Waiting for the first line from the remote PC…</react_native_1.Text>)}
       {failure ? (<react_native_1.View style={[styles.failure, { borderColor: colors.blocked }]}>
@@ -126,6 +129,7 @@ const styles = react_native_1.StyleSheet.create({
     console: { width: '100%', maxHeight: 320, overflow: 'hidden', marginTop: 10, borderWidth: 1, borderRadius: 10, padding: 11, gap: 7 },
     consoleHeader: { flexDirection: 'row', alignItems: 'center', gap: 7 },
     consoleTitle: { fontSize: 12, fontWeight: '800' },
+    consoleSource: { fontSize: 10, lineHeight: 14 },
     consoleStatus: { fontSize: 11, lineHeight: 16 },
     consoleText: { fontFamily: 'monospace', fontSize: 10, lineHeight: 15 },
     consoleEmpty: { fontSize: 10, fontStyle: 'italic' },