yaver-feedback-react-native 0.9.10 → 0.9.12

package/dist/AuthOverlay.js

@@ -46,6 +46,8 @@ const AuthOverlay = () => {
     const [pickerVisible, setPickerVisible] = (0, react_1.useState)(false);
     const [token, setToken] = (0, react_1.useState)(null);
     const activeOverlayRef = (0, react_1.useRef)('none');
+    const onboarding = YaverFeedback_1.YaverFeedback.getDogfoodOnboarding();
+    const dogfoodLabel = onboarding?.projectName || onboarding?.label || 'this app';
     const openLogin = (0, react_1.useCallback)(() => {
         activeOverlayRef.current = 'login';
         setPickerVisible(false);
@@ -120,10 +122,10 @@ const AuthOverlay = () => {
     };
     return (<>
       <react_native_1.Modal visible={loginVisible} animationType="slide" presentationStyle="fullScreen" onRequestClose={closeAll}>
-        <LoginScreen_1.YaverLoginScreen onLoggedIn={handleLoggedIn} onCancel={closeAll}/>
+        <LoginScreen_1.YaverLoginScreen onLoggedIn={handleLoggedIn} onCancel={closeAll} subtitle={onboarding ? `Sign in to set up ${dogfoodLabel} Dogfood` : undefined}/>
       </react_native_1.Modal>
       <react_native_1.Modal visible={pickerVisible && !!token} animationType="slide" presentationStyle="fullScreen" onRequestClose={closeAll}>
-        {token && (<MachinePickerScreen_1.YaverMachinePickerScreen token={token} currentDeviceId={YaverFeedback_1.YaverFeedback.getConfig()?.preferredDeviceId} onPick={handleDevicePicked} onCancel={closeAll}/>)}
+        {token && (<MachinePickerScreen_1.YaverMachinePickerScreen token={token} currentDeviceId={YaverFeedback_1.YaverFeedback.getConfig()?.preferredDeviceId} title={onboarding ? `Choose a machine for ${dogfoodLabel}` : undefined} onPick={handleDevicePicked} onCancel={closeAll}/>)}
       </react_native_1.Modal>
     </>);
 };

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,6 +36,12 @@ 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;
@@ -40,6 +53,19 @@ export declare function defaultDogfoodLane(framework: string, capabilities?: {
     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,6 +15,7 @@ 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. */
@@ -49,6 +50,26 @@ function defaultDogfoodLane(framework, capabilities = {}) {
         || 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) {
         super(failure.error);
@@ -173,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)
@@ -201,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({
@@ -218,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;

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>);
         })}