react-native-gtkx 0.1.0-alpha.4 → 0.2.0-alpha.2

package/dist/mcp/tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.js","sourceRoot":"","sources":["../../src/mcp/tool.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,GAAG,CAAC,IAAY,EAAkB,EAAE,CAAC,CAAC;IACrD,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;CAClC,CAAC,CAAA;AAEF,MAAM,SAAS,GAAG,CAAC,IAAY,EAAkB,EAAE,CAAC,CAAC;IACnD,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IACjC,OAAO,EAAE,IAAI;CACd,CAAC,CAAA;AAEF,MAAM,aAAa,GAAG,CAAC,KAAc,EAAkB,EAAE,CACvD,SAAS,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;AAEnE,MAAM,OAAO,GAAG,CACd,OAAsE,EACtE,IAAyC,EACzB,EAAE;IAClB,IAAI,CAAC;QACH,OAAO,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,aAAa,CAAC,KAAK,CAAC,CAAA;IAC7B,CAAC;AACH,CAAC,CAAA;AAED;;sDAEsD;AACtD,MAAM,UAAU,GAAG,CACjB,IAAiB,EACX,EAAE,CAAC,IAAY,CAAA;AAEvB,MAAM,YAAY,GAAG,CAAC,MAAiB,EAAE,IAAU,EAAQ,EAAE;IAC3D,MAAM,QAAQ,GAAG,CAAC,CAAC,IAAyC,EAAE,EAAE,CAC9D,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAA4C,CAAA;IAEzE,MAAM,CAAC,YAAY,CACjB,IAAI,CAAC,IAAI,EACT;QACE,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,WAAW,EAAE;YACX,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,YAAY,EAAE,IAAI;YAClB,eAAe,EAAE,KAAK;YACtB,aAAa,EAAE,KAAK;SACrB;KACF,EACD,QAAQ,CACT,CAAA;AACH,CAAC,CAAA;AAED,OAAO,EACL,UAAU,EACV,YAAY,EACZ,WAAW,EACX,SAAS,GAGV,CAAA","sourcesContent":["// Small defineTool/registerTool helper over @modelcontextprotocol/sdk's\n// McpServer, in the same spirit as @gtkx/mcp's own src/tool.ts (a sibling\n// package in this monorepo's node_modules, studied as a reference) — but\n// written fresh: this server has no live-app connection to route errors\n// through, so there is no ProtocolError type to special-case, only plain\n// Error.\nimport type {\n  McpServer,\n  ToolCallback,\n} from \"@modelcontextprotocol/sdk/server/mcp.js\"\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\"\nimport type { z } from \"zod\"\n\ntype ToolArgs<Shape extends Record<string, z.ZodType>> = {\n  [K in keyof Shape]: z.output<Shape[K]>\n}\n\ntype Tool<Shape extends Record<string, z.ZodType> = Record<string, z.ZodType>> =\n  {\n    name: string\n    title: string\n    description: string\n    inputSchema: Shape\n    handler: (args: ToolArgs<Shape>) => CallToolResult\n  }\n\nconst textContent = (text: string): CallToolResult => ({\n  content: [{ type: \"text\", text }],\n})\n\nconst textError = (text: string): CallToolResult => ({\n  content: [{ type: \"text\", text }],\n  isError: true,\n})\n\nconst errorToResult = (error: unknown): CallToolResult =>\n  textError(error instanceof Error ? error.message : String(error))\n\nconst runTool = (\n  handler: (args: ToolArgs<Record<string, z.ZodType>>) => CallToolResult,\n  args: ToolArgs<Record<string, z.ZodType>>,\n): CallToolResult => {\n  try {\n    return handler(args)\n  } catch (error) {\n    return errorToResult(error)\n  }\n}\n\n/** Identity function with a narrower input type — keeps tool definitions\n * readable (named fields) while erasing the generic Shape at the call site,\n * matching the pattern registerTool below expects. */\nconst defineTool = <Shape extends Record<string, z.ZodType>>(\n  tool: Tool<Shape>,\n): Tool => tool as Tool\n\nconst registerTool = (server: McpServer, tool: Tool): void => {\n  const callback = ((args: ToolArgs<Record<string, z.ZodType>>) =>\n    runTool(tool.handler, args)) as ToolCallback<Record<string, z.ZodType>>\n\n  server.registerTool(\n    tool.name,\n    {\n      title: tool.title,\n      description: tool.description,\n      inputSchema: tool.inputSchema,\n      annotations: {\n        title: tool.title,\n        readOnlyHint: true,\n        destructiveHint: false,\n        openWorldHint: false,\n      },\n    },\n    callback,\n  )\n}\n\nexport {\n  defineTool,\n  registerTool,\n  textContent,\n  textError,\n  type Tool,\n  type ToolArgs,\n}\n"]}

package/dist/metro/index.js

@@ -31,11 +31,13 @@ export const HOST_MODULE_EXTERNALS = [
     "@gtkx/gi/gdk",
     "@gtkx/gi/gio",
     "@gtkx/gi/glib",
+    "@gtkx/gi/gobject",
     "@gtkx/gi/graphene",
     "@gtkx/gi/gsk",
     "@gtkx/gi/gtk",
     "@gtkx/gi/pango",
     "@gtkx/jsx/adw",
+    "@gtkx/jsx/gio",
     "@gtkx/jsx/gtk",
     "@gtkx/react",
     "@gtkx/react/internal",
@@ -96,6 +98,14 @@ export const withLinuxPlatform = (config, options = {}) => {
             moduleName.startsWith("react-native/")) {
             return fallback(context, moduleName.replace(/^react-native/, "react-native-gtkx"), platform);
         }
+        // Same alias, same guard shape, for the SVG compat subpath (see
+        // src/svg-compat/index.ts and the vite preset's rewriteReactNativeImport
+        // — kept in sync deliberately rather than sharing code, Metro and vite
+        // resolvers have never shared an implementation in this package).
+        if (moduleName === "react-native-svg" ||
+            moduleName.startsWith("react-native-svg/")) {
+            return fallback(context, moduleName.replace(/^react-native-svg/, "react-native-gtkx/svg"), platform);
+        }
         return fallback(context, moduleName, platform);
     };
     // The cast: T may carry narrower resolver/serializer types than the ones

package/dist/metro/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/metro/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Metro preset for the linux out-of-tree platform: wrap the app's Metro\n// config with `withLinuxPlatform` and the standard RN toolchain bundles for\n// `--platform linux`.\n//\n// What it does on top of RN defaults (validated by spike/rn-platform):\n//\n// 1. Adds \"linux\" to resolver.platforms (`.linux.tsx` extensions and\n//    Platform.OS come along with it).\n// 2. Redirects `react-native` (and subpaths) to `react-native-gtkx` — the\n//    out-of-tree npmPackageName declaration alone does not alias imports\n//    for `bundle`, the resolver has to.\n// 3. EXTERNALIZES host-side singletons. Unlike react-native-windows, whose\n//    native side lives outside the JS bundle by construction, our \"native\"\n//    is Node modules with NAPI bindings (@gtkx/*) plus yoga-layout's WASM —\n//    Metro cannot bundle those. react (and its jsx runtimes) must also stay\n//    host-side: the reconciler inside @gtkx/react and the app have to share\n//    one React instance. Every external resolves to a generated proxy that\n//    reads the real module from global.__hostModules — the run-linux host\n//    injects them before executing the bundle.\n// 4. Proxies Node builtins through the host's require: apps on this\n//    platform may use the whole Node API, it is a platform feature.\n// 5. Drops InitializeCore (RN's mobile environment polyfills): the runtime\n//    environment IS Node, the host provides everything.\nimport { mkdirSync, writeFileSync } from \"node:fs\"\nimport { builtinModules, isBuiltin } from \"node:module\"\nimport { join } from \"node:path\"\n\n/** Modules the run-linux host provides to the bundle at runtime. */\nexport const HOST_MODULE_EXTERNALS = [\n  \"@gtkx/css\",\n  \"@gtkx/gi/adw\",\n  \"@gtkx/gi/gdk\",\n  \"@gtkx/gi/gio\",\n  \"@gtkx/gi/glib\",\n  \"@gtkx/gi/graphene\",\n  \"@gtkx/gi/gsk\",\n  \"@gtkx/gi/gtk\",\n  \"@gtkx/gi/pango\",\n  \"@gtkx/jsx/adw\",\n  \"@gtkx/jsx/gtk\",\n  \"@gtkx/react\",\n  \"@gtkx/react/internal\",\n  \"@gtkx/runtime\",\n  \"react\",\n  \"react/jsx-runtime\",\n  \"react/jsx-dev-runtime\",\n  \"yoga-layout\",\n]\n\nexport const LINUX_PLATFORM = \"linux\"\n\n// Structural slices of Metro's config/resolution types: Metro is the app's\n// dependency, not ours — depending on its types here would pin versions.\nexport type MetroResolutionContext = {\n  resolveRequest: MetroResolver\n}\nexport type MetroResolution = { type: string; filePath?: string }\nexport type MetroResolver = (\n  context: MetroResolutionContext,\n  moduleName: string,\n  platform: string | null,\n) => MetroResolution\n\nexport type MetroLikeConfig = {\n  projectRoot?: string\n  resolver?: {\n    platforms?: readonly string[]\n    resolveRequest?: MetroResolver | null\n  }\n  serializer?: {\n    getModulesRunBeforeMainModule?: (entryFilePath: string) => string[]\n  }\n}\n\nexport type LinuxPlatformOptions = {\n  /** Extra host-provided modules to keep out of the bundle. */\n  externals?: readonly string[]\n  /** Proxy directory override (default: node_modules/.react-native-gtkx). */\n  proxyDir?: string\n}\n\nconst sanitize = (name: string): string => name.replace(/[@/:]/g, \"_\") + \".js\"\n\nconst hostModuleProxy = (name: string): string =>\n  // The run-linux host guarantees __hostModules before executing the bundle.\n  `module.exports = global.__hostModules[${JSON.stringify(name)}]\\n`\n\nconst builtinProxy = (name: string): string =>\n  `module.exports = global.__hostRequire(${JSON.stringify(name)})\\n`\n\n// Every proxy is generated eagerly when the config loads: Metro crawls the\n// file map before transforming, and files that appear mid-build lose the\n// race (\"Failed to get the SHA-1\"). The builtin list is finite, so the\n// whole proxy set can exist up front.\nconst generateProxies = (dir: string, externals: Set<string>): void => {\n  mkdirSync(dir, { recursive: true })\n  for (const name of externals) {\n    writeFileSync(join(dir, sanitize(name)), hostModuleProxy(name))\n  }\n  for (const bare of builtinModules) {\n    writeFileSync(join(dir, sanitize(bare)), builtinProxy(bare))\n    writeFileSync(\n      join(dir, sanitize(`node:${bare}`)),\n      builtinProxy(`node:${bare}`),\n    )\n  }\n}\n\nexport type LinuxPlatformConfig<T extends MetroLikeConfig> = T & {\n  resolver: {\n    platforms: string[]\n    resolveRequest: MetroResolver\n  }\n  serializer: {\n    getModulesRunBeforeMainModule: (entryFilePath: string) => string[]\n  }\n}\n\n/**\n * Wraps a Metro config (RN's getDefaultConfig output) with everything the\n * linux platform needs. Composes with an existing custom resolveRequest —\n * non-linux platforms fall through to it untouched.\n */\nexport const withLinuxPlatform = <T extends MetroLikeConfig>(\n  config: T,\n  options: LinuxPlatformOptions = {},\n): LinuxPlatformConfig<T> => {\n  const externals = new Set([\n    ...HOST_MODULE_EXTERNALS,\n    ...(options.externals ?? []),\n  ])\n  const proxyDir =\n    options.proxyDir ??\n    join(\n      config.projectRoot ?? process.cwd(),\n      \"node_modules\",\n      \".react-native-gtkx\",\n      \"metro-externals\",\n    )\n  generateProxies(proxyDir, externals)\n  const previousResolve = config.resolver?.resolveRequest ?? null\n\n  const fallback: MetroResolver = (context, moduleName, platform) =>\n    previousResolve\n      ? previousResolve(context, moduleName, platform)\n      : context.resolveRequest(context, moduleName, platform)\n\n  const resolveRequest: MetroResolver = (context, moduleName, platform) => {\n    if (platform !== LINUX_PLATFORM) {\n      return fallback(context, moduleName, platform)\n    }\n    if (externals.has(moduleName) || isBuiltin(moduleName)) {\n      return {\n        type: \"sourceFile\",\n        filePath: join(proxyDir, sanitize(moduleName)),\n      }\n    }\n    if (\n      moduleName === \"react-native\" ||\n      moduleName.startsWith(\"react-native/\")\n    ) {\n      return fallback(\n        context,\n        moduleName.replace(/^react-native/, \"react-native-gtkx\"),\n        platform,\n      )\n    }\n    return fallback(context, moduleName, platform)\n  }\n\n  // The cast: T may carry narrower resolver/serializer types than the ones\n  // rebuilt here — the runtime shape is a strict superset of both.\n  return {\n    ...config,\n    resolver: {\n      ...config.resolver,\n      platforms: [\n        ...new Set([...(config.resolver?.platforms ?? []), LINUX_PLATFORM]),\n      ],\n      resolveRequest,\n    },\n    serializer: {\n      ...config.serializer,\n      // RN prepends InitializeCore (Hermes Promise, nativeLoggingHook\n      // console...). Our runtime environment IS Node — nothing to\n      // initialize inside the bundle.\n      getModulesRunBeforeMainModule: () => [],\n    },\n  } as LinuxPlatformConfig<T>\n}\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/metro/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Metro preset for the linux out-of-tree platform: wrap the app's Metro\n// config with `withLinuxPlatform` and the standard RN toolchain bundles for\n// `--platform linux`.\n//\n// What it does on top of RN defaults (validated by spike/rn-platform):\n//\n// 1. Adds \"linux\" to resolver.platforms (`.linux.tsx` extensions and\n//    Platform.OS come along with it).\n// 2. Redirects `react-native` (and subpaths) to `react-native-gtkx` — the\n//    out-of-tree npmPackageName declaration alone does not alias imports\n//    for `bundle`, the resolver has to.\n// 3. EXTERNALIZES host-side singletons. Unlike react-native-windows, whose\n//    native side lives outside the JS bundle by construction, our \"native\"\n//    is Node modules with NAPI bindings (@gtkx/*) plus yoga-layout's WASM —\n//    Metro cannot bundle those. react (and its jsx runtimes) must also stay\n//    host-side: the reconciler inside @gtkx/react and the app have to share\n//    one React instance. Every external resolves to a generated proxy that\n//    reads the real module from global.__hostModules — the run-linux host\n//    injects them before executing the bundle.\n// 4. Proxies Node builtins through the host's require: apps on this\n//    platform may use the whole Node API, it is a platform feature.\n// 5. Drops InitializeCore (RN's mobile environment polyfills): the runtime\n//    environment IS Node, the host provides everything.\nimport { mkdirSync, writeFileSync } from \"node:fs\"\nimport { builtinModules, isBuiltin } from \"node:module\"\nimport { join } from \"node:path\"\n\n/** Modules the run-linux host provides to the bundle at runtime. */\nexport const HOST_MODULE_EXTERNALS = [\n  \"@gtkx/css\",\n  \"@gtkx/gi/adw\",\n  \"@gtkx/gi/gdk\",\n  \"@gtkx/gi/gio\",\n  \"@gtkx/gi/glib\",\n  \"@gtkx/gi/gobject\",\n  \"@gtkx/gi/graphene\",\n  \"@gtkx/gi/gsk\",\n  \"@gtkx/gi/gtk\",\n  \"@gtkx/gi/pango\",\n  \"@gtkx/jsx/adw\",\n  \"@gtkx/jsx/gio\",\n  \"@gtkx/jsx/gtk\",\n  \"@gtkx/react\",\n  \"@gtkx/react/internal\",\n  \"@gtkx/runtime\",\n  \"react\",\n  \"react/jsx-runtime\",\n  \"react/jsx-dev-runtime\",\n  \"yoga-layout\",\n]\n\nexport const LINUX_PLATFORM = \"linux\"\n\n// Structural slices of Metro's config/resolution types: Metro is the app's\n// dependency, not ours — depending on its types here would pin versions.\nexport type MetroResolutionContext = {\n  resolveRequest: MetroResolver\n}\nexport type MetroResolution = { type: string; filePath?: string }\nexport type MetroResolver = (\n  context: MetroResolutionContext,\n  moduleName: string,\n  platform: string | null,\n) => MetroResolution\n\nexport type MetroLikeConfig = {\n  projectRoot?: string\n  resolver?: {\n    platforms?: readonly string[]\n    resolveRequest?: MetroResolver | null\n  }\n  serializer?: {\n    getModulesRunBeforeMainModule?: (entryFilePath: string) => string[]\n  }\n}\n\nexport type LinuxPlatformOptions = {\n  /** Extra host-provided modules to keep out of the bundle. */\n  externals?: readonly string[]\n  /** Proxy directory override (default: node_modules/.react-native-gtkx). */\n  proxyDir?: string\n}\n\nconst sanitize = (name: string): string => name.replace(/[@/:]/g, \"_\") + \".js\"\n\nconst hostModuleProxy = (name: string): string =>\n  // The run-linux host guarantees __hostModules before executing the bundle.\n  `module.exports = global.__hostModules[${JSON.stringify(name)}]\\n`\n\nconst builtinProxy = (name: string): string =>\n  `module.exports = global.__hostRequire(${JSON.stringify(name)})\\n`\n\n// Every proxy is generated eagerly when the config loads: Metro crawls the\n// file map before transforming, and files that appear mid-build lose the\n// race (\"Failed to get the SHA-1\"). The builtin list is finite, so the\n// whole proxy set can exist up front.\nconst generateProxies = (dir: string, externals: Set<string>): void => {\n  mkdirSync(dir, { recursive: true })\n  for (const name of externals) {\n    writeFileSync(join(dir, sanitize(name)), hostModuleProxy(name))\n  }\n  for (const bare of builtinModules) {\n    writeFileSync(join(dir, sanitize(bare)), builtinProxy(bare))\n    writeFileSync(\n      join(dir, sanitize(`node:${bare}`)),\n      builtinProxy(`node:${bare}`),\n    )\n  }\n}\n\nexport type LinuxPlatformConfig<T extends MetroLikeConfig> = T & {\n  resolver: {\n    platforms: string[]\n    resolveRequest: MetroResolver\n  }\n  serializer: {\n    getModulesRunBeforeMainModule: (entryFilePath: string) => string[]\n  }\n}\n\n/**\n * Wraps a Metro config (RN's getDefaultConfig output) with everything the\n * linux platform needs. Composes with an existing custom resolveRequest —\n * non-linux platforms fall through to it untouched.\n */\nexport const withLinuxPlatform = <T extends MetroLikeConfig>(\n  config: T,\n  options: LinuxPlatformOptions = {},\n): LinuxPlatformConfig<T> => {\n  const externals = new Set([\n    ...HOST_MODULE_EXTERNALS,\n    ...(options.externals ?? []),\n  ])\n  const proxyDir =\n    options.proxyDir ??\n    join(\n      config.projectRoot ?? process.cwd(),\n      \"node_modules\",\n      \".react-native-gtkx\",\n      \"metro-externals\",\n    )\n  generateProxies(proxyDir, externals)\n  const previousResolve = config.resolver?.resolveRequest ?? null\n\n  const fallback: MetroResolver = (context, moduleName, platform) =>\n    previousResolve\n      ? previousResolve(context, moduleName, platform)\n      : context.resolveRequest(context, moduleName, platform)\n\n  const resolveRequest: MetroResolver = (context, moduleName, platform) => {\n    if (platform !== LINUX_PLATFORM) {\n      return fallback(context, moduleName, platform)\n    }\n    if (externals.has(moduleName) || isBuiltin(moduleName)) {\n      return {\n        type: \"sourceFile\",\n        filePath: join(proxyDir, sanitize(moduleName)),\n      }\n    }\n    if (\n      moduleName === \"react-native\" ||\n      moduleName.startsWith(\"react-native/\")\n    ) {\n      return fallback(\n        context,\n        moduleName.replace(/^react-native/, \"react-native-gtkx\"),\n        platform,\n      )\n    }\n    // Same alias, same guard shape, for the SVG compat subpath (see\n    // src/svg-compat/index.ts and the vite preset's rewriteReactNativeImport\n    // — kept in sync deliberately rather than sharing code, Metro and vite\n    // resolvers have never shared an implementation in this package).\n    if (\n      moduleName === \"react-native-svg\" ||\n      moduleName.startsWith(\"react-native-svg/\")\n    ) {\n      return fallback(\n        context,\n        moduleName.replace(/^react-native-svg/, \"react-native-gtkx/svg\"),\n        platform,\n      )\n    }\n    return fallback(context, moduleName, platform)\n  }\n\n  // The cast: T may carry narrower resolver/serializer types than the ones\n  // rebuilt here — the runtime shape is a strict superset of both.\n  return {\n    ...config,\n    resolver: {\n      ...config.resolver,\n      platforms: [\n        ...new Set([...(config.resolver?.platforms ?? []), LINUX_PLATFORM]),\n      ],\n      resolveRequest,\n    },\n    serializer: {\n      ...config.serializer,\n      // RN prepends InitializeCore (Hermes Promise, nativeLoggingHook\n      // console...). Our runtime environment IS Node — nothing to\n      // initialize inside the bundle.\n      getModulesRunBeforeMainModule: () => [],\n    },\n  } as LinuxPlatformConfig<T>\n}\n"]}

package/dist/navigation/index.d.ts

@@ -1,30 +1,64 @@
-import { type NavigationProp, type ParamListBase, type RouteProp, type StackNavigationState } from "@react-navigation/native";
+import { type NavigationProp, type NavigatorTypeBagBase, type NavigatorTypeBagFor, type ParamListBase, type RouteProp, type StackNavigationState, type TypedNavigator } from "@react-navigation/native";
 import { type ComponentType, type ReactNode } from "react";
 import type { HeaderButton } from "./sidebar";
 export type StackNavigationOptions = {
-    /** HeaderBar title; defaults to the route name. */
+    /** AdwHeaderBar title; defaults to the route name. */
     title?: string;
-    /** Render the Adwaita HeaderBar for this screen (default true). */
+    /** Render the Adwaitan AdwHeaderBar for this screen (default true). */
     headerShown?: boolean;
-    /** Buttons packed at the end of this screen's HeaderBar (see
+    /** Buttons packed at the end of this screen's AdwHeaderBar (see
      *  HeaderButton); screens usually set them via navigation.setOptions. */
     headerButtons?: HeaderButton[];
-    /** RN content packed at the start of the HeaderBar (an intrinsic-size
+    /** RN content packed at the start of the AdwHeaderBar (an intrinsic-size
      *  layout root: the content's Yoga size IS the slot size). */
     headerLeft?: () => ReactNode;
-    /** RN content packed at the end of the HeaderBar, before headerButtons. */
+    /** RN content packed at the end of the AdwHeaderBar, before headerButtons. */
     headerRight?: () => ReactNode;
     /** false disables the native back button, Escape and the back gesture
      *  for this screen (the page's Adwaita can-pop). Programmatic goBack
      *  still works. Also the mechanism behind usePreventRemove. */
     gestureEnabled?: boolean;
+    /**
+     * `"none"` turns transitions off; any other value (including the
+     * `@react-navigation/native-stack` style names like `"slide_from_bottom"`
+     * or `"fade"`) turns them on. GTK has exactly one transition style, so a
+     * specific requested type cannot be honored — only whether to animate at
+     * all can be. Requesting a specific (non-`"default"`) type still animates,
+     * with the standard Adwaita transition, and warns once in development.
+     * Read from whichever screen is currently on top of the visible stack, so
+     * setting it uniformly via `screenOptions` is the reliable way to use it —
+     * see docs/api.md.
+     */
+    animation?: string;
+};
+export type StackNavigationEventMap = {
+    /** Fires when a push/pop/replace transition starts, once per involved
+     *  route (not once per gesture or user tap). */
+    transitionStart: {
+        data: {
+            closing: boolean;
+        };
+    };
+    /** Fires when the transition settles, driven by the page's own real
+     *  `shown`/`hidden` AdwNavigationPage signal (see docs/api.md and the
+     *  primitive's beginTransition) — not a timer, except as a fallback for
+     *  the rare cases where neither signal arrives. Native pops (back
+     *  button, Escape, back gesture) do not fire this at all today — see
+     *  docs/api.md. */
+    transitionEnd: {
+        data: {
+            closing: boolean;
+        };
+    };
 };
 type StackNavigatorProps = {
     initialRouteName?: string;
     screenOptions?: StackNavigationOptions;
     children: ReactNode;
 };
-export type StackNavigationHelpers<ParamList extends ParamListBase = ParamListBase, RouteName extends keyof ParamList = keyof ParamList> = NavigationProp<ParamList, RouteName, undefined, StackNavigationState<ParamList>, StackNavigationOptions>;
+declare const StackNavigator: ({ initialRouteName, screenOptions, children, }: StackNavigatorProps) => React.JSX.Element;
+export { createSidebarNavigator, type HeaderButton, type SidebarNavigationEventMap, type SidebarNavigationHelpers, type SidebarNavigationOptions, type SidebarScreenConfig, type SidebarScreenProps, type TypedSidebarNavigator, } from "./sidebar";
+export type StackNavigationHelpers<ParamList extends ParamListBase = ParamListBase, RouteName extends keyof ParamList = keyof ParamList> = NavigationProp<ParamList, RouteName, StackNavigationState<ParamList>, StackNavigationOptions, StackNavigationEventMap>;
 export type StackScreenProps<ParamList extends ParamListBase = ParamListBase, RouteName extends keyof ParamList = keyof ParamList> = {
     route: RouteProp<ParamList, RouteName>;
     navigation: StackNavigationHelpers<ParamList, RouteName>;
@@ -35,10 +69,13 @@ export type StackScreenConfig<ParamList extends ParamListBase, RouteName extends
     options?: StackNavigationOptions | ((props: StackScreenProps<ParamList, RouteName>) => StackNavigationOptions);
     initialParams?: Partial<ParamList[RouteName]>;
 };
-export type TypedStackNavigator<ParamList extends ParamListBase> = {
-    Navigator: ComponentType<StackNavigatorProps>;
-    Screen: <RouteName extends keyof ParamList>(props: StackScreenConfig<ParamList, RouteName>) => null;
-};
+interface StackTypeBag extends NavigatorTypeBagBase {
+    ParamList: ParamListBase;
+    State: StackNavigationState<ParamListBase>;
+    ScreenOptions: StackNavigationOptions;
+    EventMap: StackNavigationEventMap;
+    ActionHelpers: Record<string, () => void>;
+    Navigator: typeof StackNavigator;
+}
+export type TypedStackNavigator<ParamList extends ParamListBase> = TypedNavigator<NavigatorTypeBagFor<StackTypeBag, ParamList>, undefined>;
 export declare const createStackNavigator: <ParamList extends ParamListBase = ParamListBase>() => TypedStackNavigator<ParamList>;
-export { createSidebarNavigator, type HeaderButton, type SidebarNavigationOptions, type SidebarScreenConfig, type SidebarScreenProps, type TypedSidebarNavigator, } from "./sidebar";
-export { CommonActions, NavigationContainer, StackActions, useFocusEffect, useIsFocused, useNavigation, useNavigationContainerRef, usePreventRemove, useRoute, } from "@react-navigation/native";

package/dist/navigation/index.js

@@ -1,26 +1,27 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 // react-native-gtkx/navigation — a react-navigation stack navigator backed
-// by Adw.NavigationView. The model mirrors @react-navigation/native-stack
-// on iOS (UINavigationController): react-navigation state is the source of
-// truth, the native view is imperatively synced to it, and NATIVE pops (the
-// Adwaita back button, Escape, the back gesture) are reported back through
-// the "popped" signal.
+// by the Adw.NavigationView primitive from react-native-gtkx/adwaita.
 //
-// Sync protocol (the two directions must not echo each other):
-// - state → view: an effect diffs the synced tag stack against
-//   state.routes and drives pushByTag / popToTag / replaceWithTags. Pages
-//   are declarative children keyed by route.key, so the widgets exist
-//   before the effect runs.
-// - view → state: "popped" fires for EVERY popped page, ours and the
-//   user's. The discriminator is the state itself: a tag that is still in
-//   state.routes means the user popped the view (dispatch POP); a tag
-//   already gone from state means the pop was state-driven — ignore.
+// This file is an ADAPTER and nothing else. Every widget concern — diffing
+// the tag stack into pushes and pops, holding a popped page alive until its
+// exit animation ends, bracketing transitions — lives in the primitive. What
+// stays here is exactly the react-navigation half:
+//
+// - state → the ordered tags handed to NavigationStack (route keys);
+// - a native pop (back button, Escape, back gesture) → StackActions.pop,
+//   but only when the tag is still in state, otherwise the pop was one WE
+//   caused and echoing it would double-pop;
+// - descriptors → page titles, header content and canPop;
+// - unknown-option warnings.
+//
+// The same split as @react-navigation/native-stack over react-native-screens.
+// If you do not want a router, use the primitive directly.
 import { createNavigatorFactory, StackActions, StackRouter, useNavigationBuilder, usePreventRemoveContext, } from "@react-navigation/native";
-import { useCallback, useEffect, useRef, useState, } from "react";
-import { InteractionManager } from "../apis/interaction-manager";
+import { useEffect, useRef } from "react";
 import { getActiveChrome } from "../components/app-registry";
-import { IntrinsicRoot, NestedRoot } from "../components/root";
-import { AdwHeaderBar, AdwNavigationPage, AdwNavigationView, AdwToolbarView, GtkButton, } from "../gtkx/bridge/index";
+import { AdwHeaderBar, AdwToolbarView } from "../adw";
+import { HeaderSlotContent, NavigationStack, NavigationStackPage, SlotContent, } from "../common";
+import { GtkButton } from "../gtkx/bridge/index";
 import { warnIgnoredOptions } from "./option-warnings";
 const STACK_OPTION_KEYS = new Set([
     "title",
@@ -29,6 +30,7 @@ const STACK_OPTION_KEYS = new Set([
     "headerLeft",
     "headerRight",
     "gestureEnabled",
+    "animation",
 ]);
 const StackNavigator = ({ initialRouteName, screenOptions, children, }) => {
     const { state, descriptors, navigation, NavigationContent } = useNavigationBuilder(StackRouter, {
@@ -36,12 +38,47 @@ const StackNavigator = ({ initialRouteName, screenOptions, children, }) => {
         screenOptions,
         children,
     });
-    const viewRef = useRef(null);
+    // React Navigation 8: `state.routes` is no longer just the visible stack —
+    // it is active routes followed by retained routes (closing, kept mounted
+    // for `inactiveBehavior`) and preloaded routes (`navigation.preload()`,
+    // not yet navigated to), all concatenated, with the focused/visible tail
+    // ending at `state.index` (see StackRouter's `getStateWithRoutes`: `routes:
+    // activeRoutes.concat(retainedRoutes, preloadedRoutes)`, `index:
+    // activeRoutes.length - 1`). Handing the whole array to NavigationStack
+    // would push a preloaded screen onto the widget as if it were a real page
+    // the user navigated to. Only the active slice is the visible stack.
+    const visibleRoutes = state.routes.slice(0, state.index + 1);
+    const visibleKeys = visibleRoutes.map((route) => route.key);
+    // GTK has exactly one transition style and one animate-transitions switch
+    // for the whole view — there is no per-route knob to hand it. The screen
+    // actually being navigated TO is the natural read of "the currently
+    // relevant animation option": for a push, that is the new top of stack;
+    // for a pop, the screen the pop reveals. An app that sets `animation`
+    // uniformly through `screenOptions` (the common case for "turn animation
+    // off entirely") gets the same value everywhere, so this only matters
+    // when different screens genuinely disagree.
+    const activeRouteKey = visibleKeys[visibleKeys.length - 1];
+    const activeDescriptor = activeRouteKey
+        ? descriptors[activeRouteKey]
+        : undefined;
+    const animateTransitions = activeDescriptor?.options.animation !== "none";
     useEffect(() => {
         for (const route of state.routes) {
             const descriptor = descriptors[route.key];
             if (descriptor) {
                 warnIgnoredOptions("createStackNavigator", descriptor.options, STACK_OPTION_KEYS);
+                const { animation } = descriptor.options;
+                // "animation" itself is in STACK_OPTION_KEYS above (it IS honored,
+                // collapsed to a boolean), so the call above never flags it. A
+                // specific requested type — anything but "none" (handled) or
+                // "default" (not a specific request) — is a separate, narrower
+                // complaint, forced through the same verdict lookup and the same
+                // once-per-navigator-per-key dedupe with an empty supported set.
+                if (animation !== undefined &&
+                    animation !== "none" &&
+                    animation !== "default") {
+                    warnIgnoredOptions("createStackNavigator", { animation }, new Set());
+                }
             }
         }
     }, [state, descriptors]);
@@ -51,127 +88,129 @@ const StackNavigator = ({ initialRouteName, screenOptions, children, }) => {
             console.warn('[react-native-gtkx/navigation] the app runs with the default window chrome — pages bring their own HeaderBars, so you will see a doubled titlebar. Pass chrome: "content" to AppRegistry.runApplication.');
         }
     }, []);
-    // Mirror of the view's visible stack (route keys), maintained by the sync
-    // effect and by the popped handler — the two never race: GTK signals run
-    // synchronously inside the very push/pop calls the effect makes.
-    const syncedRef = useRef([]);
-    // Pop ANIMATION support: react-navigation drops a popped route from state
-    // immediately, but Adwaita still animates the page out (~200 ms). Pages
-    // therefore render from renderedKeys — live routes plus closing pages —
-    // and a closing page leaves only on its "hidden" signal (the end of the
-    // transition). Its content renders from a snapshot cached while live.
-    const [renderedKeys, setRenderedKeys] = useState(() => state.routes.map((route) => route.key));
-    const liveKeys = state.routes.map((route) => route.key);
-    const missingKeys = liveKeys.filter((key) => !renderedKeys.includes(key));
-    if (missingKeys.length > 0) {
-        // The sanctioned derive-state-during-render pattern: a new route must be
-        // in renderedKeys within the same commit its page is pushed.
-        setRenderedKeys([...renderedKeys, ...missingKeys]);
-    }
-    // A state-held stable Map (not a ref): the render path reads it for
-    // closing pages, and the react-hooks/refs rule rightly bans render-time
-    // ref reads.
-    const [snapshots] = useState(() => new Map());
-    useEffect(() => {
-        for (const route of state.routes) {
-            const descriptor = descriptors[route.key];
-            if (descriptor) {
-                snapshots.set(route.key, {
-                    name: route.name,
-                    options: descriptor.options,
-                    element: _jsx(NestedRoot, { children: descriptor.render() }),
-                });
-            }
+    // `navigation` is identity-stable across renders (react-navigation builder
+    // contract) and getState() always reads the live state — no ref needed.
+    const handlePopped = (tag) => {
+        if (navigation.getState().routes.some((route) => route.key === tag)) {
+            // Still in state, so the WIDGET popped on its own: follow in state.
+            navigation.dispatch(StackActions.pop());
         }
-    });
-    const handleHidden = useCallback((key) => {
-        // "hidden" also fires for a live page covered by a push — only pages
-        // gone from state are actually closing.
-        if (navigation.getState().routes.some((route) => route.key === key)) {
-            return;
+        // Otherwise state dropped the route first and the primitive is merely
+        // reporting the animation we asked for. Nothing to do.
+    };
+    // transitionStart/transitionEnd: translates NavigationStack's primitive
+    // callbacks into react-navigation's own per-route events, matching
+    // @react-navigation/stack and @react-navigation/native-stack's v8
+    // behavior byte for byte (verified against their source, not docs — see
+    // 007.md): a route that just became visible fires `closing: false`, a
+    // route that just left the visible stack fires `closing: true`, and a
+    // route whose visibility did not change (e.g. covered by a push) gets
+    // neither event.
+    //
+    // The start and end sides deliberately use TWO DIFFERENT primitive
+    // signals, not the same onTransitionStart/onTransitionEnd pair for both:
+    //
+    // - transitionStart (both directions) rides onTransitionStart, a
+    //   view-level "a transition just began" signal with no per-route
+    //   identity — the adapter supplies that identity itself by diffing
+    //   visibleKeys against the previous render's visible keys.
+    // - transitionEnd for an OPENING route also rides the view-level
+    //   onTransitionEnd, itself driven by the pushed page's own real "shown"
+    //   signal (transitionDuration only as a fallback — see docs/api.md and
+    //   the primitive's beginTransition): the pushed screen stays mounted
+    //   indefinitely once it is the active page, so nothing about that is
+    //   unsafe here either way.
+    // - transitionEnd for a CLOSING route rides onPageClosed instead, fired
+    //   PER TAG when that page's exit actually finishes (a real GTK
+    //   "hidden" signal when available, the primitive's own timer as
+    //   fallback). This was not a style choice: routing the closing side
+    //   through the generic view-level timer was tried first and is wrong
+    //   whenever the real close finishes before the fixed transitionDuration
+    //   default (guaranteed in headless test environments with animations
+    //   disabled, and possible on a real desktop too) — the closing screen's
+    //   React component has already unmounted (and unsubscribed its
+    //   listeners) by the time the generic, one-size-fits-all timer gets
+    //   around to firing, so the event never reaches anyone. onPageClosed
+    //   fires synchronously before React commits that unmount, so the
+    //   listener is still there to receive it.
+    //
+    // previousVisibleKeysRef is compared by CONTENT, not a call-count flag:
+    // NavigationStack's sync effect can call beginTransition() (hence
+    // onTransitionStart) more than once for one state update — e.g. popping
+    // back past two routes and pushing two new ones in the same dispatch
+    // calls it three times — and every one of those calls closes over the
+    // SAME visibleKeys for this render. Diffing against the ref and only
+    // then updating it makes every call after the first a no-op (the ref
+    // already equals visibleKeys), without a manual "already handling a
+    // transition" flag that would also incorrectly swallow a second,
+    // genuinely separate transition starting before the first one settles.
+    const previousVisibleKeysRef = useRef(visibleKeys);
+    const pendingOpeningEndRef = useRef([]);
+    // Tags this adapter itself put in flight via transitionStart(closing:
+    // true) — NOT every tag onPageClosed ever reports. A native pop (back
+    // button, Escape, back gesture) also eventually drops its tag through
+    // the exact same primitive mechanism, but never called beginTransition()
+    // (see the primitive: a native pop's own handlePopped reconciles
+    // syncedRef directly, so the sync effect finds nothing left to push or
+    // pop once react-navigation's state catches up) — so it never got a
+    // transitionStart either. Without this guard, handlePageClosed would
+    // emit a transitionEnd with no matching transitionStart for every native
+    // pop, which is worse than emitting neither: a listener would see an
+    // end event out of nowhere. Documented as Known limitation #2 in 007.md
+    // — native pops fire neither event today.
+    const pendingClosingRef = useRef(new Set());
+    const emitTransitionEvent = (type, keys, closing) => {
+        for (const key of keys) {
+            navigation.emit({ type, data: { closing }, target: key });
         }
-        snapshots.delete(key);
-        setRenderedKeys((keys) => keys.filter((rendered) => rendered !== key));
-    }, [navigation, snapshots]);
-    // "hidden" delivery is not guaranteed in every environment (headless
-    // compositors with animations disabled never emit it) — a timer slightly
-    // longer than the Adwaita transition is the fallback; handleHidden is
-    // idempotent, whichever fires first wins.
-    const scheduleRetainedRemoval = useCallback((key) => {
-        setTimeout(() => handleHidden(key), 400);
-    }, [handleHidden]);
-    // Bracket every view transition with an InteractionManager handle so
-    // runAfterInteractions-scheduled work (a screen's own data load / heavy
-    // render) waits for the slide to finish instead of stealing its frames.
-    // The handle is opened when the sync effect mutates the view and cleared
-    // one transition-length later; overlapping transitions reference-count.
-    const beginTransition = useCallback(() => {
-        const handle = InteractionManager.createInteractionHandle();
-        setTimeout(() => InteractionManager.clearInteractionHandle(handle), 400);
-    }, []);
-    useEffect(() => {
-        const view = viewRef.current;
-        if (!view) {
+    };
+    const handleTransitionStart = () => {
+        const previous = previousVisibleKeysRef.current;
+        if (previous.length === visibleKeys.length &&
+            previous.every((key, index) => key === visibleKeys[index])) {
+            // A duplicate beginTransition() call for the same commit (see
+            // above) — already diffed by an earlier call this render.
             return;
         }
-        const target = state.routes.map((route) => route.key);
-        if (syncedRef.current.length === 0 && target.length > 0) {
-            // First mount: NavigationView shows the first added page by itself.
-            syncedRef.current = target.slice(0, 1);
+        const opening = visibleKeys.filter((key) => !previous.includes(key));
+        const closing = previous.filter((key) => !visibleKeys.includes(key));
+        previousVisibleKeysRef.current = visibleKeys;
+        pendingOpeningEndRef.current.push(...opening);
+        for (const key of closing) {
+            pendingClosingRef.current.add(key);
         }
-        let common = 0;
-        while (common < syncedRef.current.length &&
-            common < target.length &&
-            syncedRef.current[common] === target[common]) {
-            common += 1;
-        }
-        if (common === 0 && syncedRef.current[0] !== target[0]) {
-            // The stack root changed (reset): swap the whole visible stack.
-            const leaving = syncedRef.current.filter((key) => !target.includes(key));
-            syncedRef.current = [...target];
-            beginTransition();
-            view.replaceWithTags(target);
-            for (const key of leaving) {
-                scheduleRetainedRemoval(key);
-            }
+        emitTransitionEvent("transitionStart", opening, false);
+        emitTransitionEvent("transitionStart", closing, true);
+    };
+    // Drains whatever opening keys are pending rather than trusting call
+    // count, for the same reason handleTransitionStart diffs by content: a
+    // compound update's several onTransitionEnd calls (one per
+    // beginTransition() above) all land at essentially the same moment, so
+    // the first one emits everything queued and the rest find nothing left
+    // to drain. Closing keys are NOT handled here — see handlePageClosed.
+    const handleTransitionEnd = () => {
+        const opening = pendingOpeningEndRef.current;
+        if (opening.length === 0) {
             return;
         }
-        if (syncedRef.current.length > common) {
-            const anchor = target[common - 1];
-            const leaving = syncedRef.current.slice(common);
-            syncedRef.current = syncedRef.current.slice(0, common);
-            if (anchor !== undefined) {
-                beginTransition();
-                view.popToTag(anchor);
-            }
-            for (const key of leaving) {
-                scheduleRetainedRemoval(key);
-            }
-        }
-        for (let index = syncedRef.current.length; index < target.length; index += 1) {
-            const key = target[index];
-            syncedRef.current.push(key);
-            beginTransition();
-            view.pushByTag(key);
-        }
-    }, [state, scheduleRetainedRemoval, beginTransition]);
-    // `navigation` is identity-stable across renders (react-navigation
-    // builder contract) and getState() always reads the live state — the
-    // closure needs no ref indirection.
-    const handlePopped = (page) => {
-        const tag = page?.getTag();
-        if (!tag) {
+        pendingOpeningEndRef.current = [];
+        emitTransitionEvent("transitionEnd", opening, false);
+    };
+    const handlePageClosed = (tag) => {
+        if (!pendingClosingRef.current.has(tag)) {
+            // Not a tag this adapter put in flight (a native pop, or a stray
+            // call) — no transitionStart was ever emitted for it, so no
+            // transitionEnd either.
             return;
         }
-        syncedRef.current = syncedRef.current.filter((key) => key !== tag);
-        const current = navigation.getState();
-        if (current.routes.some((route) => route.key === tag)) {
-            // The view popped on its own (back button / gesture): follow in state.
-            navigation.dispatch(StackActions.pop());
-        }
-        scheduleRetainedRemoval(tag);
+        pendingClosingRef.current.delete(tag);
+        navigation.emit({
+            type: "transitionEnd",
+            data: { closing: true },
+            target: tag,
+        });
     };
-    return (_jsx(NavigationContent, { children: _jsx(StackView, { viewRef: viewRef, renderedKeys: renderedKeys, routeKeys: state.routes.map((route) => route.key), descriptors: descriptors, snapshots: snapshots, onPopped: handlePopped, onHidden: handleHidden }) }));
+    return (_jsx(NavigationContent, { children: _jsx(StackView, { routeKeys: visibleKeys, descriptors: descriptors, animateTransitions: animateTransitions, onPopped: handlePopped, onTransitionStart: handleTransitionStart, onTransitionEnd: handleTransitionEnd, onPageClosed: handlePageClosed }) }));
 };
 // The page list lives inside NavigationContent so it can read the
 // prevent-remove context (which useNavigationBuilder only provides to
@@ -181,36 +220,32 @@ const StackNavigator = ({ initialRouteName, screenOptions, children, }) => {
 // programmatic goBack still pops (once the app lifts the prevention, e.g.
 // after its own confirmation dialog). This is why a native pop can never
 // race react-navigation state for these routes.
-const StackView = ({ viewRef, renderedKeys, routeKeys, descriptors, snapshots, onPopped, onHidden, }) => {
+const StackView = ({ routeKeys, descriptors, animateTransitions, onPopped, onTransitionStart, onTransitionEnd, onPageClosed, }) => {
     const { preventedRoutes } = usePreventRemoveContext();
-    return (_jsx(AdwNavigationView, { ref: viewRef, onPopped: (page) => onPopped(page), children: renderedKeys.map((key) => {
-            const isLive = routeKeys.includes(key);
-            const descriptor = isLive
-                ? descriptors[key]
-                : undefined;
-            const snapshot = snapshots.get(key);
-            const options = descriptor?.options ?? snapshot?.options ?? {};
+    return (_jsx(NavigationStack, { stack: routeKeys, animateTransitions: animateTransitions, onPopped: onPopped, onTransitionStart: onTransitionStart, onTransitionEnd: onTransitionEnd, onPageClosed: onPageClosed, children: routeKeys.map((key) => {
+            const descriptor = descriptors[key];
+            if (!descriptor) {
+                return null;
+            }
+            const options = descriptor.options;
             const headerShown = options.headerShown ?? true;
             const canPop = options.gestureEnabled !== false &&
                 !preventedRoutes[key]?.preventRemove;
-            const content = descriptor ? (_jsx(NestedRoot, { children: descriptor.render() })) : ((snapshot?.element ?? null));
-            return (_jsx(AdwNavigationPage, { tag: key, 
-                // Never the route key — that is an internal identifier, and
-                // it would end up in the window title under content chrome.
-                title: options.title ?? descriptor?.route.name ?? snapshot?.name ?? key, canPop: canPop, onHidden: () => onHidden(key), children: headerShown ? (_jsx(AdwToolbarView, { topBar: _jsx(AdwHeaderBar, { start: options.headerLeft ? (_jsx(IntrinsicRoot, { children: options.headerLeft() })) : undefined, end: [
+            const content = _jsx(SlotContent, { children: descriptor.render() });
+            return (_jsx(NavigationStackPage, { tag: key, 
+                // Never the route key — that is an internal identifier, and it
+                // would end up in the window title under content chrome.
+                title: options.title ?? descriptor.route.name, canPop: canPop, children: headerShown ? (_jsx(AdwToolbarView, { topBar: _jsx(AdwHeaderBar, { start: options.headerLeft ? (_jsx(HeaderSlotContent, { children: options.headerLeft() })) : undefined, end: [
                             ...(options.headerRight
                                 ? [
-                                    _jsx(IntrinsicRoot, { children: options.headerRight() }, "header-right"),
+                                    _jsx(HeaderSlotContent, { children: options.headerRight() }, "header-right"),
                                 ]
                                 : []),
                             ...(options.headerButtons?.map((button) => (_jsx(GtkButton, { iconName: button.icon, tooltipText: button.tooltip, onClicked: button.onPress }, button.id))) ?? []),
                         ] }), children: content })) : (content) }, key));
         }) }));
 };
+export { createSidebarNavigator, } from "./sidebar";
 const stackFactory = createNavigatorFactory(StackNavigator);
 export const createStackNavigator = () => stackFactory();
-export { createSidebarNavigator, } from "./sidebar";
-// The rest of the react-navigation surface apps need, so a linux app can
-// import everything from one place.
-export { CommonActions, NavigationContainer, StackActions, useFocusEffect, useIsFocused, useNavigation, useNavigationContainerRef, usePreventRemove, useRoute, } from "@react-navigation/native";
 //# sourceMappingURL=index.js.map