@farm.js/core 0.1.61 → 0.1.62

package/dist/mobile.d.mts

@@ -0,0 +1,138 @@
+import { F as FarmMobileOS, R as ResolvedFarmMobileConfig, a as FarmMobileAppModules } from './config.d-qt-mE8O5.mjs';
+export { b as FarmMobileAppModuleSpec, c as FarmMobileBudgets, d as FarmMobileConfigInput, e as FarmMobileContext, f as FarmMobileModuleConfig, g as FarmMobileNativeAuto, h as FarmMobileNativeConfig, i as FarmMobileNativeEngine, j as FarmMobileNativeRouteConfig, k as FarmMobilePageConfig, l as FarmMobilePrefetch, m as FarmMobilePresentation, n as FarmMobileRouteConfig, o as FarmMobileRouteScreen, p as FarmMobileScreen, q as FarmMobileTab, r as FarmMobileUserConfig, s as FarmNativeMethod, t as FarmNativeProperty, u as FarmNativeType, v as FarmNativeWebSpec, w as ResolvedFarmMobileModuleConfig } from './config.d-qt-mE8O5.mjs';
+import { F as FarmMobileRouteManifest } from './routes.d-D1IrO9KK.mjs';
+export { a as FarmMobileRouteRule, b as FarmMobileShellManifest } from './routes.d-D1IrO9KK.mjs';
+import './types.d-C41ePjvP.mjs';
+import './generate-route-types.d-BoVDU8qX.mjs';
+import './layers.d-CcS42OGR.mjs';
+import 'rolldown/utils';
+import 'rolldown';
+
+/**
+ * `@farm.js/core/mobile`: the interface mobile shell packages (`@farm.js/mobile/android`, `/ios`)
+ * implement, and the types a page's `export const mobile` and a `mobile` block use. Types and an
+ * identity helper only; nothing here runs in a web build.
+ */
+
+/** A file a mobile shell generates, relative to the native project directory. */
+interface MobileGeneratedFile {
+    path: string;
+    /** Text, or bytes for binary files such as the Gradle wrapper jar. */
+    contents: string | Uint8Array;
+    /** Written with the executable bit, such as `gradlew`. */
+    executable?: boolean;
+}
+/**
+ * The React Native screens of a build (RFC 0004, 7.2). Absent when no route resolves to one, and
+ * then a shell adds no JS engine, dependency, or asset for them.
+ */
+interface MobileNativeScreens {
+    engine: "react-native";
+    /** The app's `react-native` version, which picks the native artifacts. */
+    reactNativeVersion: string;
+    /** The Hermes version that React Native release ships. */
+    hermesVersion: string;
+    /** Module ids with a React Native screen, such as `app/map`. */
+    modules: string[];
+    /** `farm build --mobile`: the screens' Hermes bytecode, bundled into the app. */
+    bundle?: string;
+    /**
+     * `farm build --mobile`: the directory of images and other files the screens `require()`, as
+     * Metro laid them out for the OS, copied into the app next to the bytecode. Absent when they
+     * import none; under `farm dev --mobile` Metro serves them.
+     */
+    assetsDir?: string;
+    /** `farm dev --mobile`: the Metro server the debug app loads the screens from. */
+    devServer?: {
+        port: number;
+        /** The entry's path from the app root without `.js`, such as `.farm/output/mobile/native/index`. */
+        mainModule: string;
+    };
+}
+/**
+ * The mobile client's content-hashed files, which a shell answers from the app instead of the
+ * network (RFC 0004, 7.2). Documents still come from `mobile.server`, which decides which client
+ * they load; a newer deployment references names the app does not have, and those load from
+ * the network.
+ */
+interface MobileBundledAssets {
+    /** The build's client output; each file is read from here. */
+    dir: string;
+    /** URL paths at the server origin, such as `/farm-mobile-client-h1a2b3c4d.js`, sorted. */
+    files: string[];
+    /** The mobile client entry among them. */
+    entry: string;
+}
+/**
+ * The page shells of `farm build --mobile` with `mobile.shells` (RFC 0004, 7.2): per route, the
+ * layouts around its `loading.tsx` as HTML with no scripts. `manifest.shells` maps routes to
+ * these files. Absent in dev, without `mobile.shells`, or when no route has one.
+ */
+interface MobilePageShells {
+    /** The mobile client entry they were rendered with; also `manifest.shells.client`. */
+    client: string;
+    /** Shell file per page route; also `manifest.shells.routes`. */
+    routes: Record<string, string>;
+    /** HTML by file name, such as `1a2b3c4d5e6f7a8b.html`. On iOS each stylesheet is inlined. */
+    files: Record<string, string>;
+}
+interface MobileShellContext {
+    /** App root. */
+    root: string;
+    os: FarmMobileOS;
+    /** `"dev"` for `farm dev --mobile`, `"build"` for `farm build --mobile`. */
+    command: "dev" | "build";
+    mobile: ResolvedFarmMobileConfig;
+    /** The app's basePath ("" or "/base"). */
+    basePath: string;
+    /**
+     * `auth.basePath` (such as `/api/auth`) when the app's top-level `auth` is enabled. Native
+     * screens sign in only to routes under it; without it the shell has no native sign-in.
+     */
+    authBasePath?: string;
+    /** The navigator manifest, also written to `.farm/output/mobile/farm-routes.json`. */
+    manifest: FarmMobileRouteManifest;
+    /** Directory the native project is written to, such as `.farm/output/mobile/android`. */
+    projectDir: string;
+    /** React Native screens, when at least one route resolves to one on this OS. */
+    native?: MobileNativeScreens;
+    /** `farm build --mobile`: the mobile client's files to bundle. Absent in dev. */
+    assets?: MobileBundledAssets;
+    /** `farm build --mobile` with `mobile.shells`: the page shells to bundle. */
+    shells?: MobilePageShells;
+    /** The app's own native modules in `src/native/`, when it has any. */
+    appModules?: FarmMobileAppModules;
+}
+interface MobilePackageContext extends MobileShellContext {
+    /** Directory for built apps (`.farm/output/mobile/dist`). */
+    distDir: string;
+}
+interface MobileRunResult {
+    /** True when the app was installed and opened on a device or emulator. */
+    launched: boolean;
+    /** What happened, or how to run the app when nothing was launched. */
+    message: string;
+}
+/** What a mobile shell export (such as `@farm.js/mobile/android`) default-exports. */
+interface MobileShell {
+    os: FarmMobileOS;
+    /** The native project, written into `projectDir` on every `farm dev|build --mobile`. */
+    generate(context: MobileShellContext): MobileGeneratedFile[] | Promise<MobileGeneratedFile[]>;
+    /**
+     * `farm dev --mobile`: build, install, and open the debug app when a device or emulator is
+     * connected. Resolves with `launched: false` and the next commands when none is.
+     */
+    run(context: MobileShellContext): Promise<MobileRunResult>;
+    /**
+     * Build an installable app from the generated project, such as a debug APK. `message` says
+     * what to do next, or why nothing was built (such as no Xcode for an iOS simulator app).
+     */
+    package(context: MobilePackageContext): Promise<{
+        files: string[];
+        message?: string;
+    }>;
+}
+/** Typed helper for mobile shell packages. */
+declare function defineMobileShell(shell: MobileShell): MobileShell;
+
+export { FarmMobileAppModules, FarmMobileOS, FarmMobileRouteManifest, type MobileBundledAssets, type MobileGeneratedFile, type MobileNativeScreens, type MobilePackageContext, type MobilePageShells, type MobileRunResult, type MobileShell, type MobileShellContext, ResolvedFarmMobileConfig, defineMobileShell };

package/dist/mobile.d.ts

@@ -0,0 +1,138 @@
+import { F as FarmMobileOS, R as ResolvedFarmMobileConfig, a as FarmMobileAppModules } from './config.d-qt-mE8O5.js';
+export { b as FarmMobileAppModuleSpec, c as FarmMobileBudgets, d as FarmMobileConfigInput, e as FarmMobileContext, f as FarmMobileModuleConfig, g as FarmMobileNativeAuto, h as FarmMobileNativeConfig, i as FarmMobileNativeEngine, j as FarmMobileNativeRouteConfig, k as FarmMobilePageConfig, l as FarmMobilePrefetch, m as FarmMobilePresentation, n as FarmMobileRouteConfig, o as FarmMobileRouteScreen, p as FarmMobileScreen, q as FarmMobileTab, r as FarmMobileUserConfig, s as FarmNativeMethod, t as FarmNativeProperty, u as FarmNativeType, v as FarmNativeWebSpec, w as ResolvedFarmMobileModuleConfig } from './config.d-qt-mE8O5.js';
+import { F as FarmMobileRouteManifest } from './routes.d-BknKQcTu.js';
+export { a as FarmMobileRouteRule, b as FarmMobileShellManifest } from './routes.d-BknKQcTu.js';
+import './types.d-C41ePjvP.js';
+import './generate-route-types.d-BL2pq6xC.js';
+import './layers.d-CcS42OGR.js';
+import 'rolldown/utils';
+import 'rolldown';
+
+/**
+ * `@farm.js/core/mobile`: the interface mobile shell packages (`@farm.js/mobile/android`, `/ios`)
+ * implement, and the types a page's `export const mobile` and a `mobile` block use. Types and an
+ * identity helper only; nothing here runs in a web build.
+ */
+
+/** A file a mobile shell generates, relative to the native project directory. */
+interface MobileGeneratedFile {
+    path: string;
+    /** Text, or bytes for binary files such as the Gradle wrapper jar. */
+    contents: string | Uint8Array;
+    /** Written with the executable bit, such as `gradlew`. */
+    executable?: boolean;
+}
+/**
+ * The React Native screens of a build (RFC 0004, 7.2). Absent when no route resolves to one, and
+ * then a shell adds no JS engine, dependency, or asset for them.
+ */
+interface MobileNativeScreens {
+    engine: "react-native";
+    /** The app's `react-native` version, which picks the native artifacts. */
+    reactNativeVersion: string;
+    /** The Hermes version that React Native release ships. */
+    hermesVersion: string;
+    /** Module ids with a React Native screen, such as `app/map`. */
+    modules: string[];
+    /** `farm build --mobile`: the screens' Hermes bytecode, bundled into the app. */
+    bundle?: string;
+    /**
+     * `farm build --mobile`: the directory of images and other files the screens `require()`, as
+     * Metro laid them out for the OS, copied into the app next to the bytecode. Absent when they
+     * import none; under `farm dev --mobile` Metro serves them.
+     */
+    assetsDir?: string;
+    /** `farm dev --mobile`: the Metro server the debug app loads the screens from. */
+    devServer?: {
+        port: number;
+        /** The entry's path from the app root without `.js`, such as `.farm/output/mobile/native/index`. */
+        mainModule: string;
+    };
+}
+/**
+ * The mobile client's content-hashed files, which a shell answers from the app instead of the
+ * network (RFC 0004, 7.2). Documents still come from `mobile.server`, which decides which client
+ * they load; a newer deployment references names the app does not have, and those load from
+ * the network.
+ */
+interface MobileBundledAssets {
+    /** The build's client output; each file is read from here. */
+    dir: string;
+    /** URL paths at the server origin, such as `/farm-mobile-client-h1a2b3c4d.js`, sorted. */
+    files: string[];
+    /** The mobile client entry among them. */
+    entry: string;
+}
+/**
+ * The page shells of `farm build --mobile` with `mobile.shells` (RFC 0004, 7.2): per route, the
+ * layouts around its `loading.tsx` as HTML with no scripts. `manifest.shells` maps routes to
+ * these files. Absent in dev, without `mobile.shells`, or when no route has one.
+ */
+interface MobilePageShells {
+    /** The mobile client entry they were rendered with; also `manifest.shells.client`. */
+    client: string;
+    /** Shell file per page route; also `manifest.shells.routes`. */
+    routes: Record<string, string>;
+    /** HTML by file name, such as `1a2b3c4d5e6f7a8b.html`. On iOS each stylesheet is inlined. */
+    files: Record<string, string>;
+}
+interface MobileShellContext {
+    /** App root. */
+    root: string;
+    os: FarmMobileOS;
+    /** `"dev"` for `farm dev --mobile`, `"build"` for `farm build --mobile`. */
+    command: "dev" | "build";
+    mobile: ResolvedFarmMobileConfig;
+    /** The app's basePath ("" or "/base"). */
+    basePath: string;
+    /**
+     * `auth.basePath` (such as `/api/auth`) when the app's top-level `auth` is enabled. Native
+     * screens sign in only to routes under it; without it the shell has no native sign-in.
+     */
+    authBasePath?: string;
+    /** The navigator manifest, also written to `.farm/output/mobile/farm-routes.json`. */
+    manifest: FarmMobileRouteManifest;
+    /** Directory the native project is written to, such as `.farm/output/mobile/android`. */
+    projectDir: string;
+    /** React Native screens, when at least one route resolves to one on this OS. */
+    native?: MobileNativeScreens;
+    /** `farm build --mobile`: the mobile client's files to bundle. Absent in dev. */
+    assets?: MobileBundledAssets;
+    /** `farm build --mobile` with `mobile.shells`: the page shells to bundle. */
+    shells?: MobilePageShells;
+    /** The app's own native modules in `src/native/`, when it has any. */
+    appModules?: FarmMobileAppModules;
+}
+interface MobilePackageContext extends MobileShellContext {
+    /** Directory for built apps (`.farm/output/mobile/dist`). */
+    distDir: string;
+}
+interface MobileRunResult {
+    /** True when the app was installed and opened on a device or emulator. */
+    launched: boolean;
+    /** What happened, or how to run the app when nothing was launched. */
+    message: string;
+}
+/** What a mobile shell export (such as `@farm.js/mobile/android`) default-exports. */
+interface MobileShell {
+    os: FarmMobileOS;
+    /** The native project, written into `projectDir` on every `farm dev|build --mobile`. */
+    generate(context: MobileShellContext): MobileGeneratedFile[] | Promise<MobileGeneratedFile[]>;
+    /**
+     * `farm dev --mobile`: build, install, and open the debug app when a device or emulator is
+     * connected. Resolves with `launched: false` and the next commands when none is.
+     */
+    run(context: MobileShellContext): Promise<MobileRunResult>;
+    /**
+     * Build an installable app from the generated project, such as a debug APK. `message` says
+     * what to do next, or why nothing was built (such as no Xcode for an iOS simulator app).
+     */
+    package(context: MobilePackageContext): Promise<{
+        files: string[];
+        message?: string;
+    }>;
+}
+/** Typed helper for mobile shell packages. */
+declare function defineMobileShell(shell: MobileShell): MobileShell;
+
+export { FarmMobileAppModules, FarmMobileOS, FarmMobileRouteManifest, type MobileBundledAssets, type MobileGeneratedFile, type MobileNativeScreens, type MobilePackageContext, type MobilePageShells, type MobileRunResult, type MobileShell, type MobileShellContext, ResolvedFarmMobileConfig, defineMobileShell };

package/dist/mobile.mjs

@@ -0,0 +1,9 @@
+import "./chunk-Y6FXYEAI.mjs";
+
+// src/mobile/index.ts
+function defineMobileShell(shell) {
+  return shell;
+}
+export {
+  defineMobileShell
+};

package/dist/modules-KOKD4XS6.mjs

@@ -0,0 +1,13 @@
+import {
+  readFarmMobileWebModules,
+  resolveFarmMobileModules,
+  scanFarmMobileAppModules
+} from "./chunk-5Y22WNTO.mjs";
+import "./chunk-43V3ANPQ.mjs";
+import "./chunk-UB7RVEMX.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  readFarmMobileWebModules,
+  resolveFarmMobileModules,
+  scanFarmMobileAppModules
+};

package/dist/modules-QTP7WJPD.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkJ3GFOQOLcjs = require('./chunk-J3GFOQOL.cjs');
+require('./chunk-SVXOCTQ2.cjs');
+require('./chunk-YKHRCY4T.cjs');
+require('./chunk-BTZ5O6VM.cjs');
+
+
+
+
+exports.readFarmMobileWebModules = _chunkJ3GFOQOLcjs.readFarmMobileWebModules; exports.resolveFarmMobileModules = _chunkJ3GFOQOLcjs.resolveFarmMobileModules; exports.scanFarmMobileAppModules = _chunkJ3GFOQOLcjs.scanFarmMobileAppModules;

package/dist/native-server-fn-handler-GLRHAYWV.mjs

@@ -0,0 +1,28 @@
+import {
+  createFarmNativeServerFnPlugin,
+  handleFarmNativeServerFnRequest
+} from "./chunk-XCXHQBMM.mjs";
+import "./chunk-QTD6EMN2.mjs";
+import {
+  FARM_NATIVE_SERVER_FN_PATH,
+  FARM_NATIVE_SERVER_FN_PLUGIN
+} from "./chunk-L4RTTTVE.mjs";
+import "./chunk-E46NXBNJ.mjs";
+import "./chunk-RLEALQEN.mjs";
+import "./chunk-QSTRBKHZ.mjs";
+import "./chunk-2DA7CLY7.mjs";
+import "./chunk-QDWMCFTH.mjs";
+import "./chunk-D2LCAV6L.mjs";
+import "./chunk-M25IONJP.mjs";
+import "./chunk-GLOICKDO.mjs";
+import "./chunk-AZQXXXDX.mjs";
+import "./chunk-JNYFXL7X.mjs";
+import "./chunk-VIXTAVEA.mjs";
+import "./chunk-AYP2YFVN.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  FARM_NATIVE_SERVER_FN_PATH,
+  FARM_NATIVE_SERVER_FN_PLUGIN,
+  createFarmNativeServerFnPlugin,
+  handleFarmNativeServerFnRequest
+};

package/dist/native-server-fn-handler-J5MYRXN6.cjs

@@ -0,0 +1,28 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkLEJDW34Dcjs = require('./chunk-LEJDW34D.cjs');
+require('./chunk-YN6BHOYY.cjs');
+
+
+
+var _chunk4EBC7EMWcjs = require('./chunk-4EBC7EMW.cjs');
+require('./chunk-4P5634G6.cjs');
+require('./chunk-DMAP4RND.cjs');
+require('./chunk-FEFCISOX.cjs');
+require('./chunk-EVIWKPJV.cjs');
+require('./chunk-CFG4QERR.cjs');
+require('./chunk-JYT7AN37.cjs');
+require('./chunk-AOKXITZ6.cjs');
+require('./chunk-DXUXQP2T.cjs');
+require('./chunk-UZCMMJJT.cjs');
+require('./chunk-7JUIK547.cjs');
+require('./chunk-3BIASUGR.cjs');
+require('./chunk-YTVSWXEZ.cjs');
+require('./chunk-BTZ5O6VM.cjs');
+
+
+
+
+
+exports.FARM_NATIVE_SERVER_FN_PATH = _chunk4EBC7EMWcjs.FARM_NATIVE_SERVER_FN_PATH; exports.FARM_NATIVE_SERVER_FN_PLUGIN = _chunk4EBC7EMWcjs.FARM_NATIVE_SERVER_FN_PLUGIN; exports.createFarmNativeServerFnPlugin = _chunkLEJDW34Dcjs.createFarmNativeServerFnPlugin; exports.handleFarmNativeServerFnRequest = _chunkLEJDW34Dcjs.handleFarmNativeServerFnRequest;

package/dist/native-specs-5OLED4MM.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkSVXOCTQ2cjs = require('./chunk-SVXOCTQ2.cjs');
+require('./chunk-BTZ5O6VM.cjs');
+
+
+
+
+
+
+exports.createFarmNativeModuleTypeDeclarations = _chunkSVXOCTQ2cjs.createFarmNativeModuleTypeDeclarations; exports.hasFarmNativeCodegen = _chunkSVXOCTQ2cjs.hasFarmNativeCodegen; exports.readFarmNativeWebSpec = _chunkSVXOCTQ2cjs.readFarmNativeWebSpec; exports.renderFarmNativeMethod = _chunkSVXOCTQ2cjs.renderFarmNativeMethod; exports.renderFarmNativeType = _chunkSVXOCTQ2cjs.renderFarmNativeType;

package/dist/native-specs-LDV6IZ4N.mjs

@@ -0,0 +1,15 @@
+import {
+  createFarmNativeModuleTypeDeclarations,
+  hasFarmNativeCodegen,
+  readFarmNativeWebSpec,
+  renderFarmNativeMethod,
+  renderFarmNativeType
+} from "./chunk-43V3ANPQ.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  createFarmNativeModuleTypeDeclarations,
+  hasFarmNativeCodegen,
+  readFarmNativeWebSpec,
+  renderFarmNativeMethod,
+  renderFarmNativeType
+};

package/dist/native-tree-AS5L3ID3.mjs

@@ -0,0 +1,27 @@
+import {
+  createFarmNativeTree,
+  createFarmNativeTreeResponse,
+  farmRequestWantsNativeTree,
+  readFarmPageStylesheets
+} from "./chunk-IOF4KXMP.mjs";
+import "./chunk-JCEFKP5M.mjs";
+import {
+  FARM_NATIVE_TREE_CONTENT_TYPE
+} from "./chunk-LLZSYFOM.mjs";
+import "./chunk-YSXTNSXS.mjs";
+import "./chunk-C7GJDVN4.mjs";
+import "./chunk-2DA7CLY7.mjs";
+import "./chunk-2I6PUKWJ.mjs";
+import "./chunk-GUZC226X.mjs";
+import "./chunk-W6QLRQ3V.mjs";
+import "./chunk-LM55GS4R.mjs";
+import "./chunk-SF3JB56B.mjs";
+import "./chunk-AYP2YFVN.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  FARM_NATIVE_TREE_CONTENT_TYPE,
+  createFarmNativeTree,
+  createFarmNativeTreeResponse,
+  farmRequestWantsNativeTree,
+  readFarmPageStylesheets
+};

package/dist/native-tree-Z2WYUJEV.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkGVOMPU3Ycjs = require('./chunk-GVOMPU3Y.cjs');
+require('./chunk-V727H3RI.cjs');
+
+
+var _chunk3HLQTOVUcjs = require('./chunk-3HLQTOVU.cjs');
+require('./chunk-LT4VAF5Z.cjs');
+require('./chunk-LRB5OVRT.cjs');
+require('./chunk-EVIWKPJV.cjs');
+require('./chunk-2OF5RPVU.cjs');
+require('./chunk-CA7DNRHO.cjs');
+require('./chunk-PMJSG4JS.cjs');
+require('./chunk-A25FXJ7D.cjs');
+require('./chunk-D22BUQKW.cjs');
+require('./chunk-YTVSWXEZ.cjs');
+require('./chunk-BTZ5O6VM.cjs');
+
+
+
+
+
+
+exports.FARM_NATIVE_TREE_CONTENT_TYPE = _chunk3HLQTOVUcjs.FARM_NATIVE_TREE_CONTENT_TYPE; exports.createFarmNativeTree = _chunkGVOMPU3Ycjs.createFarmNativeTree; exports.createFarmNativeTreeResponse = _chunkGVOMPU3Ycjs.createFarmNativeTreeResponse; exports.farmRequestWantsNativeTree = _chunkGVOMPU3Ycjs.farmRequestWantsNativeTree; exports.readFarmPageStylesheets = _chunkGVOMPU3Ycjs.readFarmPageStylesheets;

package/dist/native.cjs

@@ -0,0 +1,87 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }require('./chunk-BTZ5O6VM.cjs');
+
+// src/native.ts
+var UNAVAILABLE = "native_unavailable";
+var NativeUnavailableError = class extends Error {
+  constructor(module, method, options) {
+    super(
+      `native.${module}.${method}() is not available here. Web screens reach a native module only inside the mobile shell, when mobile.modules.${module}.web is true in farm.config.ts. Check native.${module}.available() first, and show the web alternative when it is false.`
+    );
+    this.name = "NativeUnavailableError";
+    this.code = UNAVAILABLE;
+    this.module = module;
+    this.method = method;
+    this.cause = _optionalChain([options, 'optionalAccess', _ => _.cause]);
+  }
+};
+var NativeCallError = class extends Error {
+  constructor(module, method, code, message, options) {
+    super(`native.${module}.${method}() failed (${code}): ${message}`);
+    this.name = "NativeCallError";
+    this.cause = _optionalChain([options, 'optionalAccess', _2 => _2.cause]);
+    this.code = code;
+    this.module = module;
+    this.method = method;
+  }
+};
+function bridge() {
+  const candidate = globalThis.__farmBridge;
+  return candidate && typeof candidate.call === "function" && typeof candidate.has === "function" ? candidate : void 0;
+}
+function isAvailable(module) {
+  return _optionalChain([bridge, 'call', _3 => _3(), 'optionalAccess', _4 => _4.has, 'call', _5 => _5(module)]) === true;
+}
+async function invoke(module, method, input) {
+  const shell = bridge();
+  if (!shell || !shell.has(module)) throw new NativeUnavailableError(module, method);
+  const args = [...input];
+  while (args.length > 0 && args[args.length - 1] === void 0) args.pop();
+  try {
+    return await shell.call(module, method, args);
+  } catch (error) {
+    const code = _optionalChain([error, 'optionalAccess', _6 => _6.code]);
+    if (code === UNAVAILABLE) throw new NativeUnavailableError(module, method, { cause: error });
+    throw new NativeCallError(
+      module,
+      method,
+      typeof code === "string" && code ? code : "native_error",
+      String(_nullishCoalesce(_optionalChain([error, 'optionalAccess', _7 => _7.message]), () => ( error))),
+      { cause: error }
+    );
+  }
+}
+var RESERVED = /* @__PURE__ */ new Set(["then", "toJSON", "constructor", "$$typeof"]);
+function createModule(module) {
+  const methods = /* @__PURE__ */ new Map();
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, method) {
+      if (typeof method !== "string" || RESERVED.has(method)) return void 0;
+      let fn = methods.get(method);
+      if (!fn) {
+        fn = method === "available" ? () => isAvailable(module) : (...args) => invoke(module, method, args);
+        methods.set(method, fn);
+      }
+      return fn;
+    }
+  });
+}
+function createNative() {
+  const modules = /* @__PURE__ */ new Map();
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, module) {
+      if (typeof module !== "string" || RESERVED.has(module)) return void 0;
+      let entry = modules.get(module);
+      if (!entry) {
+        entry = createModule(module);
+        modules.set(module, entry);
+      }
+      return entry;
+    }
+  });
+}
+var native = /* @__PURE__ */ createNative();
+
+
+
+
+exports.NativeCallError = NativeCallError; exports.NativeUnavailableError = NativeUnavailableError; exports.native = native;

package/dist/native.d.mts

@@ -0,0 +1,72 @@
+/**
+ * `@farm.js/core/native`: web screens call the app's own native modules (RFC 0004, 7.5).
+ *
+ * ```ts
+ * import { native } from "@farm.js/core/native";
+ *
+ * if (native.Device.available()) console.log(await native.Device.model());
+ * ```
+ *
+ * A call goes through the mobile shell's bridge, which checks the arguments against the module's
+ * Codegen spec, to the module's Kotlin or Objective-C++ class. Only modules with
+ * `mobile.modules.<name>.web: true` are reachable, and only their methods that return a Promise.
+ * In a browser, during server rendering, or in a shell without the module, every call rejects with
+ * `NativeUnavailableError`. Nothing here imports React Native.
+ */
+/**
+ * The app's native modules, keyed by the name each spec registers. `src/farm.d.ts` fills this in
+ * from the Codegen specs in `src/native/` (`NativeDevice.ts` registers `"Device"`).
+ */
+interface FarmNativeModules {
+}
+/** One module as web screens see it: its Promise methods, and `available()`. */
+type FarmNativeModule<Methods> = Methods & {
+    /**
+     * True inside the mobile shell when this build registered the module for web screens. Check it
+     * before calling, and show the web alternative when it is false.
+     */
+    available(): boolean;
+};
+type FarmNative = {
+    readonly [Name in keyof FarmNativeModules]: FarmNativeModule<FarmNativeModules[Name]>;
+};
+/**
+ * A call that cannot reach the module: outside the mobile shell, during server rendering, or in a
+ * shell built without the module for web screens (on iOS, also an app without a React Native
+ * screen). `native.<module>.available()` is false in each of these cases.
+ */
+declare class NativeUnavailableError extends Error {
+    name: string;
+    readonly code = "native_unavailable";
+    readonly module: string;
+    readonly method: string;
+    /** The shell's own rejection, when the bridge answered. */
+    readonly cause: unknown;
+    constructor(module: string, method: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * A call the shell or the module rejected. `code` is the module's own rejection code, or one of
+ * the shell's: `invalid_args` (the arguments do not match the spec, and the module never ran),
+ * `unknown_method` (no Promise method of that name in the spec), or `native_error` (the module
+ * threw).
+ */
+declare class NativeCallError extends Error {
+    name: string;
+    readonly code: string;
+    readonly module: string;
+    readonly method: string;
+    /** The bridge's rejection. */
+    readonly cause: unknown;
+    constructor(module: string, method: string, code: string, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * The app's native modules for web screens: `native.Device.model()` calls the `Device` module's
+ * `model` method in the shell, and `native.Device.available()` says whether it can.
+ */
+declare const native: FarmNative;
+
+export { type FarmNative, type FarmNativeModule, type FarmNativeModules, NativeCallError, NativeUnavailableError, native };