catalyst-core 0.3.0-beta.5 → 0.3.0-canary.2

package/dist/native/bridge/errors.js

@@ -3,172 +3,87 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.translateError = exports.isDevelopment = exports.createStandardError = exports.ERROR_DEFINITIONS = exports.ERROR_CODES = exports.ERROR_CATEGORIES = void 0;
+exports.translateError = exports.isDevelopment = exports.createStandardError = exports.ERROR_CODES = void 0;
+var _index = require("../../errors/index.js");
 /**
  * Standardized Error System for Catalyst Framework
  * Translates native errors into web developer-friendly messages
+ *
+ * Codes/definitions now live in ../../errors/registry.js as RUNTIME-NATIVE-xxx
+ * (shared taxonomy across CLI/build/server/native, see RFC #155). This module
+ * keeps its own ERROR_CODES map for backwards-compatible imports, aliased to
+ * the shared codes, plus the native-error string-sniffing logic in
+ * translateError(), which is the one piece of real value here.
  */
 
-// Error categories for logical grouping
-const ERROR_CATEGORIES = exports.ERROR_CATEGORIES = {
-  PERMISSION: "PERMISSION",
-  NETWORK: "NETWORK",
-  FILE_SYSTEM: "FILE_SYSTEM",
-  USER_ACTION: "USER_ACTION",
-  VALIDATION: "VALIDATION",
-  SYSTEM: "SYSTEM",
-  UNKNOWN: "UNKNOWN"
-};
-
-// Standardized error codes
+// Backwards-compatible local names, aliased to the shared RUNTIME-NATIVE-xxx codes.
 const ERROR_CODES = exports.ERROR_CODES = {
-  // Permission errors
-  PERMISSION_DENIED: "PERMISSION_DENIED",
-  PERMISSION_REQUIRED: "PERMISSION_REQUIRED",
-  // Network errors
-  NETWORK_UNAVAILABLE: "NETWORK_UNAVAILABLE",
-  DOWNLOAD_FAILED: "DOWNLOAD_FAILED",
-  // File system errors
-  FILE_NOT_FOUND: "FILE_NOT_FOUND",
-  FILE_TOO_LARGE: "FILE_TOO_LARGE",
-  STORAGE_FULL: "STORAGE_FULL",
-  FILE_CORRUPTED: "FILE_CORRUPTED",
-  // User action errors
-  OPERATION_CANCELLED: "OPERATION_CANCELLED",
-  NO_FILE_SELECTED: "NO_FILE_SELECTED",
-  // Validation errors
-  INVALID_FILE_TYPE: "INVALID_FILE_TYPE",
-  INVALID_PARAMETERS: "INVALID_PARAMETERS",
-  // System errors
-  BRIDGE_UNAVAILABLE: "BRIDGE_UNAVAILABLE",
-  FEATURE_UNSUPPORTED: "FEATURE_UNSUPPORTED",
-  INTERNAL_ERROR: "INTERNAL_ERROR",
-  // Camera specific errors
-  CAMERA_UNAVAILABLE: "CAMERA_UNAVAILABLE",
-  CAMERA_IN_USE: "CAMERA_IN_USE"
+  PERMISSION_DENIED: _index.ERROR_CODES.RUNTIME_NATIVE_PERMISSION_DENIED,
+  PERMISSION_REQUIRED: _index.ERROR_CODES.RUNTIME_NATIVE_PERMISSION_REQUIRED,
+  NETWORK_UNAVAILABLE: _index.ERROR_CODES.RUNTIME_NATIVE_NETWORK_UNAVAILABLE,
+  DOWNLOAD_FAILED: _index.ERROR_CODES.RUNTIME_NATIVE_DOWNLOAD_FAILED,
+  FILE_NOT_FOUND: _index.ERROR_CODES.RUNTIME_NATIVE_FILE_NOT_FOUND,
+  FILE_TOO_LARGE: _index.ERROR_CODES.RUNTIME_NATIVE_FILE_TOO_LARGE,
+  STORAGE_FULL: _index.ERROR_CODES.RUNTIME_NATIVE_STORAGE_FULL,
+  FILE_CORRUPTED: _index.ERROR_CODES.RUNTIME_NATIVE_FILE_CORRUPTED,
+  OPERATION_CANCELLED: _index.ERROR_CODES.RUNTIME_NATIVE_OPERATION_CANCELLED,
+  NO_FILE_SELECTED: _index.ERROR_CODES.RUNTIME_NATIVE_NO_FILE_SELECTED,
+  INVALID_FILE_TYPE: _index.ERROR_CODES.RUNTIME_NATIVE_INVALID_FILE_TYPE,
+  INVALID_PARAMETERS: _index.ERROR_CODES.RUNTIME_NATIVE_INVALID_PARAMETERS,
+  BRIDGE_UNAVAILABLE: _index.ERROR_CODES.RUNTIME_NATIVE_BRIDGE_UNAVAILABLE,
+  FEATURE_UNSUPPORTED: _index.ERROR_CODES.RUNTIME_NATIVE_FEATURE_UNSUPPORTED,
+  INTERNAL_ERROR: _index.ERROR_CODES.RUNTIME_NATIVE_INTERNAL_ERROR,
+  CAMERA_UNAVAILABLE: _index.ERROR_CODES.RUNTIME_NATIVE_CAMERA_UNAVAILABLE,
+  CAMERA_IN_USE: _index.ERROR_CODES.RUNTIME_NATIVE_CAMERA_IN_USE
 };
 
-// Error definitions with user-friendly messages and recovery actions
-const ERROR_DEFINITIONS = exports.ERROR_DEFINITIONS = {
-  [ERROR_CODES.PERMISSION_DENIED]: {
-    category: ERROR_CATEGORIES.PERMISSION,
-    defaultMessage: "Permission denied",
-    defaultDetails: "Required permission was not granted by the user",
-    recoverable: true,
-    suggestedAction: "Grant permission in device settings and try again"
-  },
-  [ERROR_CODES.PERMISSION_REQUIRED]: {
-    category: ERROR_CATEGORIES.PERMISSION,
-    defaultMessage: "Permission required",
-    defaultDetails: "This operation requires additional permissions",
-    recoverable: true,
-    suggestedAction: "Grant the required permission to continue"
-  },
-  [ERROR_CODES.NETWORK_UNAVAILABLE]: {
-    category: ERROR_CATEGORIES.NETWORK,
-    defaultMessage: "No internet connection",
-    defaultDetails: "Network connection is required for this operation",
-    recoverable: true,
-    suggestedAction: "Check your internet connection and try again"
-  },
-  [ERROR_CODES.FILE_NOT_FOUND]: {
-    category: ERROR_CATEGORIES.FILE_SYSTEM,
-    defaultMessage: "File not found",
-    defaultDetails: "The requested file could not be located",
-    recoverable: false,
-    suggestedAction: "The file may have been moved or deleted"
-  },
-  [ERROR_CODES.FILE_TOO_LARGE]: {
-    category: ERROR_CATEGORIES.VALIDATION,
-    defaultMessage: "File too large",
-    defaultDetails: "File exceeds the maximum size limit",
-    recoverable: true,
-    suggestedAction: "Choose a smaller file or compress the current file"
-  },
-  [ERROR_CODES.STORAGE_FULL]: {
-    category: ERROR_CATEGORIES.FILE_SYSTEM,
-    defaultMessage: "Storage full",
-    defaultDetails: "Device storage is full and cannot save the file",
-    recoverable: true,
-    suggestedAction: "Free up some storage space and try again"
-  },
-  [ERROR_CODES.OPERATION_CANCELLED]: {
-    category: ERROR_CATEGORIES.USER_ACTION,
-    defaultMessage: "Operation cancelled",
-    defaultDetails: "The operation was cancelled by the user",
-    recoverable: true,
-    suggestedAction: "Try again if you want to complete the operation"
-  },
-  [ERROR_CODES.INVALID_FILE_TYPE]: {
-    category: ERROR_CATEGORIES.VALIDATION,
-    defaultMessage: "Invalid file type",
-    defaultDetails: "The selected file type is not supported",
-    recoverable: true,
-    suggestedAction: "Choose a file with a supported format"
-  },
-  [ERROR_CODES.BRIDGE_UNAVAILABLE]: {
-    category: ERROR_CATEGORIES.SYSTEM,
-    defaultMessage: "Native feature unavailable",
-    defaultDetails: "The native bridge is not available or not initialized",
-    recoverable: false,
-    suggestedAction: "Use web fallback if available"
-  },
-  [ERROR_CODES.FEATURE_UNSUPPORTED]: {
-    category: ERROR_CATEGORIES.SYSTEM,
-    defaultMessage: "Feature not supported",
-    defaultDetails: "This feature is not supported on the current platform",
-    recoverable: false,
-    suggestedAction: "Try using an alternative method or device"
-  },
-  [ERROR_CODES.CAMERA_UNAVAILABLE]: {
-    category: ERROR_CATEGORIES.SYSTEM,
-    defaultMessage: "Camera unavailable",
-    defaultDetails: "Camera hardware is not available or accessible",
-    recoverable: false,
-    suggestedAction: "Check if your device has a camera and try again"
-  },
-  [ERROR_CODES.CAMERA_IN_USE]: {
-    category: ERROR_CATEGORIES.SYSTEM,
-    defaultMessage: "Camera in use",
-    defaultDetails: "Camera is being used by another application",
-    recoverable: true,
-    suggestedAction: "Close other camera apps and try again"
-  },
-  [ERROR_CODES.INTERNAL_ERROR]: {
-    category: ERROR_CATEGORIES.UNKNOWN,
-    defaultMessage: "An unexpected error occurred",
-    defaultDetails: "An internal error occurred while processing the request",
-    recoverable: true,
-    suggestedAction: "Try again or contact support if the problem persists"
-  }
-};
+/** One of the {@link ERROR_CODES} values — a shared `RUNTIME-NATIVE-xxx` code. */
+
+/**
+ * Broad grouping an error code belongs to.
+ *
+ * Categories are owned by the shared registry (`../../errors/registry.js`) and
+ * are the code's prefix — every code this module aliases is `"RUNTIME-NATIVE"`.
+ * `"UNKNOWN"` is what the registry substitutes for a code it does not own.
+ */
+
+/**
+ * The error object every hook reports through its `error` key.
+ *
+ * Now an alias of the shared {@link CatalystError} (a real `Error` subclass)
+ * rather than a plain object literal: the shared error system owns the shape.
+ * Compared with the pre-merge local shape, `message`/`details`/`code` survive,
+ * `category` is a registry category string, `action` is now `suggestedAction`,
+ * `nativeError` is now the standard `cause`, and `recoverable`/`timestamp` are
+ * gone — the registry does not track recoverability, and verbose/debug
+ * formatting stamps its own timestamp at print time.
+ *
+ * Two hooks predate this contract and still report a plain string: `error` on
+ * `useDeviceInfo` and `useNetworkStatus` stays a string until 2.0.
+ */
 
 /**
- * Create a standardized error object
- * @param {string} code - Error code from ERROR_CODES
- * @param {string} userMessage - Custom user-friendly message (optional)
- * @param {any} nativeError - Original native error for debugging
- * @param {string} customDetails - Custom details (optional)
- * @returns {Object} Standardized error object
+ * Create a standardized error object (CatalystError instance) for a
+ * RUNTIME-NATIVE-xxx code, with the native error attached as `cause`.
+ *
+ * @param code - Error code from ERROR_CODES
+ * @param userMessage - Custom user-friendly message (optional)
+ * @param nativeError - Original native error for debugging
+ * @param customDetails - Custom details (optional)
+ * @returns Standardized error object
  */
 const createStandardError = (code, userMessage = null, nativeError = null, customDetails = null) => {
-  const errorInfo = ERROR_DEFINITIONS[code] || ERROR_DEFINITIONS[ERROR_CODES.INTERNAL_ERROR];
-  return {
-    code,
-    category: errorInfo.category,
-    message: userMessage || errorInfo.defaultMessage,
-    details: customDetails || errorInfo.defaultDetails,
-    recoverable: errorInfo.recoverable,
-    action: errorInfo.suggestedAction,
-    nativeError: nativeError,
-    timestamp: new Date().toISOString()
-  };
+  return (0, _index.createError)(code, {
+    message: userMessage,
+    details: customDetails,
+    cause: nativeError
+  });
 };
 
 /**
  * Translate native error to standardized error
- * @param {any} nativeError - Native error from Android/iOS
- * @returns {Object} Standardized error object
+ * @param nativeError - Native error from Android/iOS
+ * @returns Standardized error object
  */
 exports.createStandardError = createStandardError;
 const translateError = nativeError => {
@@ -254,7 +169,7 @@ const translateError = nativeError => {
 
 /**
  * Check if development mode is enabled
- * @returns {boolean} True if in development mode
+ * @returns True if in development mode
  */
 exports.translateError = translateError;
 const isDevelopment = () => {

package/dist/native/bridge/hooks/index.d.ts

@@ -0,0 +1,13 @@
+export { useAI } from "./useAI.js";
+export { useGoogleSignIn } from "./useGoogleSignIn.js";
+export { useCamera, requestCameraPermission, useCameraPermission } from "./useCamera.js";
+export { useIntent } from "./useIntent.js";
+export { useFilePicker } from "./useFilePicker.js";
+export { useHapticFeedback, requestHapticFeedback } from "./useHapticFeedback.js";
+export { useNotification, useNotificationPermission, requestNotificationPermission, } from "./useNotification.js";
+export { useNetworkStatus } from "./useNetworkStatus.js";
+export { useDeviceInfo } from "./useDeviceInfo.js";
+export { useDataProtection } from "./useDataProtection.js";
+export { useSafeArea } from "./useSafeArea.js";
+export { useVideoStream } from "./useVideoStream.js";
+export { useNativeTransition } from "./useNativeTransition.js";

package/dist/native/bridge/hooks/index.js

@@ -21,12 +21,6 @@ Object.defineProperty(exports, "requestNotificationPermission", {
     return _useNotification.requestNotificationPermission;
   }
 });
-Object.defineProperty(exports, "sanitizeFilePickerOptions", {
-  enumerable: true,
-  get: function () {
-    return _useFilePicker.sanitizeFilePickerOptions;
-  }
-});
 Object.defineProperty(exports, "useAI", {
   enumerable: true,
   get: function () {

package/dist/native/bridge/hooks/useAI.d.ts

@@ -0,0 +1 @@
+export declare function useAI(options?: any): any;

package/dist/native/bridge/hooks/useAI.js

@@ -45,6 +45,8 @@ const _pkg = typeof window !== "undefined" && (typeof __CATALYST_PACKAGES__ ===
 // provider: "transformers" → useWebAI   (catalyst-ai)
 //           "native"       → useNativeAI (catalyst-ai, falls back to useCloudAI if bridge unavailable)
 //           anything else  → useCloudAI  (catalyst-ai, default)
+// The shape of this hook is owned by the catalyst-ai package and sits outside
+// the native hook contract entirely, so its options and result stay loose here.
 function useAI(options = {}) {
   const {
     provider
@@ -82,7 +84,7 @@ function emptyHook() {
     metrics: null,
     isLocal: false,
     isNative: false,
-    isWeb: false,
+    isWeb: true,
     generate: () => {},
     cancel: () => {},
     reset: () => {},

package/dist/native/bridge/hooks/useCamera.d.ts

@@ -0,0 +1,86 @@
+import type { HookProgress, HookState, WebFallbackOptions, WebFallbackState } from "../useBaseHook.js";
+/** A captured photo, however it reached the web layer. */
+export interface CapturedPhoto {
+    /** Displayable source for the image. */
+    fileSrc: string;
+    /** Name the file was given. */
+    fileName: string;
+    /** Size in bytes, or 0 when the native side did not report it. */
+    size: number;
+    /** MIME type of the image. */
+    mimeType: string;
+    /** How the payload crossed the bridge. */
+    transport: string;
+    /** What produced the photo. */
+    source: string;
+}
+/** What {@link useCamera} returns. Wraps one operation: capturing a photo. */
+export interface UseCameraResult extends HookState<CapturedPhoto>, WebFallbackState {
+    /** Progress of the in-flight capture, or null under SSR. */
+    progress: HookProgress | null;
+    /** Capture a photo. The canonical action. */
+    takePhoto: () => void;
+    /** Alias of `takePhoto`, named to match the shared hook contract. */
+    execute: () => void;
+    /** Drop the captured photo and any error. */
+    clear: () => void;
+    /** Drop the current error, keeping any photo. */
+    clearError: () => void;
+    /** Native camera permission status, or null on web. */
+    permission: string | null;
+    /**
+     * The captured photo.
+     *
+     * @deprecated Use `data` instead. `photo` is a deprecated alias kept for
+     * backward compatibility and will be removed at 2.0.
+     */
+    photo: CapturedPhoto | null;
+    /**
+     * True while a capture is in flight.
+     *
+     * @deprecated Use `loading` instead. `isLoading` is a deprecated alias kept
+     * for backward compatibility and will be removed at 2.0.
+     */
+    isLoading: boolean;
+    /**
+     * Drop the captured photo and any error.
+     *
+     * @deprecated Use `clear` instead. `clearPhoto` is a deprecated alias kept
+     * for backward compatibility and will be removed at 2.0.
+     */
+    clearPhoto: () => void;
+}
+export declare const useCamera: ({ webFallback }?: WebFallbackOptions) => UseCameraResult;
+export declare const requestCameraPermission: () => Promise<any>;
+/**
+ * What {@link useCameraPermission} returns.
+ *
+ * Gained `loading`, `data`, `error`, `execute`, `isNative` and `isWeb` when the
+ * hook surface was made consistent; the older key for each is kept as an alias.
+ */
+export interface UseCameraPermissionResult extends HookState<string>, WebFallbackState {
+    /** Request camera access. The canonical action. */
+    execute: () => Promise<void> | void;
+    /**
+     * The permission status.
+     *
+     * @deprecated Use `data` instead. `permission` is a deprecated alias kept
+     * for backward compatibility and will be removed at 2.0.
+     */
+    permission: string | null;
+    /**
+     * True while the permission state is resolving.
+     *
+     * @deprecated Use `loading` instead. `isLoading` is a deprecated alias kept
+     * for backward compatibility and will be removed at 2.0.
+     */
+    isLoading: boolean;
+    /**
+     * Request camera access.
+     *
+     * @deprecated Use `execute` instead. `request` is a deprecated alias kept
+     * for backward compatibility and will be removed at 2.0.
+     */
+    request: () => Promise<void> | void;
+}
+export declare const useCameraPermission: ({ webFallback }?: WebFallbackOptions) => UseCameraPermissionResult;

package/dist/native/bridge/hooks/useCamera.js

@@ -7,10 +7,15 @@ exports.useCameraPermission = exports.useCamera = exports.requestCameraPermissio
 var _react = require("react");
 var _NativeBridge = _interopRequireDefault(require("../utils/NativeBridge.js"));
 var _NativeInterfaces = require("../constants/NativeInterfaces.js");
+var _errors = require("../errors.js");
 var _useBaseHook = require("../useBaseHook.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /* eslint-disable react-compiler/react-compiler, react-hooks/exhaustive-deps */
 
+/** A captured photo, however it reached the web layer. */
+
+/** What {@link useCamera} returns. Wraps one operation: capturing a photo. */
+
 const useCamera = ({
   webFallback
 } = {}) => {
@@ -212,6 +217,13 @@ const requestCameraPermission = () => {
     }
   });
 };
+
+/**
+ * What {@link useCameraPermission} returns.
+ *
+ * Gained `loading`, `data`, `error`, `execute`, `isNative` and `isWeb` when the
+ * hook surface was made consistent; the older key for each is kept as an alias.
+ */
 exports.requestCameraPermission = requestCameraPermission;
 const useCameraPermission = ({
   webFallback
@@ -225,6 +237,7 @@ const useCameraPermission = ({
   const webFallbackDisabled = isWeb && !webFallbackResolved;
   const [permission, setPermission] = (0, _react.useState)(null);
   const [isLoading, setIsLoading] = (0, _react.useState)(true);
+  const [error, setError] = (0, _react.useState)(null);
   const permResultRef = (0, _react.useRef)(null);
   (0, _react.useEffect)(() => {
     if (typeof window === "undefined") {
@@ -277,9 +290,10 @@ const useCameraPermission = ({
           console.log("📷 Camera permission status updated:", data);
         });
         _NativeBridge.default.camera.requestPermission();
-      } catch (error) {
-        console.error("📷 Error requesting camera permission:", error);
+      } catch (err) {
+        console.error("📷 Error requesting camera permission:", err);
         setPermission(_NativeInterfaces.PERMISSION_STATUS.DENIED);
+        setError((0, _errors.createStandardError)(_errors.ERROR_CODES.PERMISSION_DENIED, "Camera permission denied", err));
         setIsLoading(false);
       }
     };
@@ -298,13 +312,16 @@ const useCameraPermission = ({
     if (!navigator.mediaDevices?.getUserMedia) return;
     try {
       setIsLoading(true);
+      setError(null);
       const stream = await navigator.mediaDevices.getUserMedia({
         video: true,
         audio: false
       });
       stream.getTracks().forEach(t => t.stop());
-    } catch (_) {
-      // Ignore — the permission state change fires via permResultRef.current.onchange
+    } catch (err) {
+      // Permission state change still fires via permResultRef.current.onchange;
+      // surface the rejection as a standard error for callers reading `error`.
+      setError((0, _errors.createStandardError)(_errors.ERROR_CODES.PERMISSION_DENIED, "Camera access denied", err));
     }
 
     // Re-query to get the authoritative state after the prompt
@@ -332,7 +349,13 @@ const useCameraPermission = ({
       webFallbackActive: false,
       webFallbackDisabled: false,
       setWebFallback: () => {},
-      request: () => {}
+      request: () => {},
+      loading: false,
+      data: null,
+      error: null,
+      execute: () => {},
+      isNative: false,
+      isWeb: true
     };
   }
   return {
@@ -341,7 +364,13 @@ const useCameraPermission = ({
     webFallbackActive,
     webFallbackDisabled,
     setWebFallback,
-    request
+    request,
+    loading: isLoading,
+    data: permission,
+    error,
+    execute: request,
+    isNative: !isWeb,
+    isWeb
   };
 };
 exports.useCameraPermission = useCameraPermission;

package/dist/native/bridge/hooks/useDataProtection.d.ts

@@ -0,0 +1,17 @@
+import type { WebFallbackOptions } from "../useBaseHook.js";
+export declare const useDataProtection: ({ webFallback }?: WebFallbackOptions) => {
+    data: any;
+    loading: boolean;
+    progress: import("../useBaseHook.js").HookProgress;
+    error: any;
+    isWeb: boolean;
+    isNative: boolean;
+    webFallbackActive: boolean;
+    webFallbackDisabled: boolean;
+    setWebFallback: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    clear: () => void;
+    clearError: () => void;
+    screenSecure: boolean;
+    setScreenSecure: (enable: any) => void;
+    clearWebData: () => void;
+};

package/dist/native/bridge/hooks/useDeviceInfo.d.ts

@@ -0,0 +1,34 @@
+import type { HookEnvironment, WebFallbackOptions, WebFallbackState } from "../useBaseHook.js";
+/** Device details reported by the native host, or derived from browser APIs on web. */
+export interface DeviceInfo {
+    model: string;
+    manufacturer: string;
+    platform: string;
+    screenWidth: number;
+    screenHeight: number;
+    screenDensity: number;
+    appInfo: any;
+}
+/** What {@link useDeviceInfo} returns. Read-only: no action functions. */
+export interface UseDeviceInfoResult extends HookEnvironment, WebFallbackState {
+    /** The device details, or null until they resolve. */
+    data: DeviceInfo | null;
+    /**
+     * The device details.
+     *
+     * @deprecated Use `data` instead. `deviceInfo` is a deprecated alias kept
+     * for backward compatibility and will be removed at 2.0.
+     */
+    deviceInfo: DeviceInfo | null;
+    /** True while the device details are being fetched. */
+    loading: boolean;
+    /**
+     * The failure message, or null.
+     *
+     * Note this is a plain string rather than a standard error object. That is
+     * a known inconsistency with the rest of the hook contract, and it stays a
+     * string until 2.0.
+     */
+    error: string | null;
+}
+export declare const useDeviceInfo: ({ webFallback }?: WebFallbackOptions) => UseDeviceInfoResult;

package/dist/native/bridge/hooks/useDeviceInfo.js

@@ -9,6 +9,10 @@ var _NativeBridge = _interopRequireDefault(require("../utils/NativeBridge.js"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /* eslint-disable react-compiler/react-compiler, react-hooks/exhaustive-deps */
 
+/** Device details reported by the native host, or derived from browser APIs on web. */
+
+/** What {@link useDeviceInfo} returns. Read-only: no action functions. */
+
 const useDeviceInfo = ({
   webFallback
 } = {}) => {
@@ -59,6 +63,7 @@ const useDeviceInfo = ({
   }, [webFallbackDisabled]);
   return {
     deviceInfo,
+    data: deviceInfo,
     loading,
     error,
     isNative,

package/dist/native/bridge/hooks/useFilePicker.d.ts

@@ -0,0 +1,53 @@
+import type { HookProgress, HookState, WebFallbackOptions, WebFallbackState } from "../useBaseHook.js";
+export declare const sanitizeFilePickerOptions: (input: any) => any;
+/**
+ * What {@link useFilePicker} returns. Wraps one operation: picking a file.
+ *
+ * The web-fallback keys are declared required: every client branch returns
+ * them, and consumers should not have to null-check keys that never miss at
+ * runtime. The SSR stub under-delivers on this shape (it omits
+ * `webFallbackActive`, `webFallbackDisabled` and `setWebFallback`) and is cast
+ * below — reconciling the stub itself is a behavior change that belongs to the
+ * freeze, not to this conversion.
+ */
+export interface UseFilePickerResult extends HookState, WebFallbackState {
+    /** Progress of the in-flight pick, or null under SSR. */
+    progress: HookProgress | null;
+    /** Open the file picker. The canonical action. */
+    pickFile: (input?: any) => void;
+    /** Alias of `pickFile`, named to match the shared hook contract. */
+    execute: (input?: any) => void;
+    /** Drop the picked files, the cached File objects and any error. */
+    clear: () => void;
+    /** Drop the current error, keeping any data. */
+    clearError: () => void;
+    /** Materialize the picked file as a `File`. */
+    getFileObject: (...args: any[]) => Promise<any>;
+    /** Materialize every picked file as a `File`. */
+    getAllFileObjects: (...args: any[]) => Promise<any>;
+    /** Whether the current file's transport supports `File` creation. */
+    canCreateFileObject: boolean;
+    /** Per-file view of `canCreateFileObject`. */
+    canCreateFileObjects: any[];
+    /** First picked file, or null. */
+    selectedFile: any;
+    /** Every picked file. */
+    selectedFiles: any[];
+    /** The current phase of the pick, or null when idle. */
+    processingState: string | null;
+    /**
+     * True while a pick is in flight.
+     *
+     * @deprecated Use `loading` instead. `isLoading` is a deprecated alias kept
+     * for backward compatibility and will be removed at 2.0.
+     */
+    isLoading: boolean;
+    /**
+     * Drop the picked files and any error.
+     *
+     * @deprecated Use `clear` instead. `clearFile` is a deprecated alias kept
+     * for backward compatibility and will be removed at 2.0.
+     */
+    clearFile: () => void;
+}
+export declare const useFilePicker: ({ webFallback }?: WebFallbackOptions) => UseFilePickerResult;

package/dist/native/bridge/hooks/useFilePicker.js

@@ -150,6 +150,18 @@ const mapStateToProgress = state => {
     message: `File picker: ${rawState}...`
   };
 };
+
+/**
+ * What {@link useFilePicker} returns. Wraps one operation: picking a file.
+ *
+ * The web-fallback keys are declared required: every client branch returns
+ * them, and consumers should not have to null-check keys that never miss at
+ * runtime. The SSR stub under-delivers on this shape (it omits
+ * `webFallbackActive`, `webFallbackDisabled` and `setWebFallback`) and is cast
+ * below — reconciling the stub itself is a behavior change that belongs to the
+ * freeze, not to this conversion.
+ */
+
 const useFilePicker = ({
   webFallback
 } = {}) => {
@@ -207,6 +219,7 @@ const useFilePicker = ({
   }, [base]);
   const webFiles = (0, _react.useMemo)(() => extractFiles(base.data), [base.data]);
   if (typeof window === "undefined") {
+    // The stub under-delivers on UseFilePickerResult (no web-fallback keys).
     return SSR_FILE_PICKER_STUB;
   }
   if (base.webFallbackDisabled) {

package/dist/native/bridge/hooks/useGoogleSignIn.d.ts

@@ -0,0 +1,12 @@
+export declare const useGoogleSignIn: (defaultOptions?: {}) => {
+    data: any;
+    loading: boolean;
+    progress: import("../useBaseHook.js").HookProgress;
+    error: any;
+    isWeb: boolean;
+    isNative: boolean;
+    signIn: (options?: {}) => void;
+    execute: (options?: {}) => void;
+    clear: () => void;
+    clearError: () => void;
+};