@multiplatform.one/cli 6.4.3 → 6.7.0

package/templates/pieces/gnome/universal/apps/__NAME__/gnome/polyfills.ts

@@ -0,0 +1,10 @@
+// Browser-API polyfills for the GNOME target. MUST be the first import of
+// gnome/main.tsx: JS imports are hoisted, so first-import order is what
+// guarantees window/document/matchMedia/URL exist before Tamagui and the
+// RN-shaped dependencies probe for them at module-init time.
+//
+// The implementation is packaged — @react-gnome/react-native/polyfills
+// installs each global conditionally, so anything you define before this
+// import wins. Keep this file as the app's stable local import point.
+
+import "@react-gnome/react-native/polyfills";

package/templates/pieces/gnome/universal/apps/__NAME__/gnome/shims/components.ts

@@ -0,0 +1,36 @@
+// GNOME-target shim for @multiplatform.one/components.
+//
+// The real barrel re-exports the whole library, including modules that
+// pull expo-asset, @shopify/flash-list, @tanstack/react-virtual and
+// @phosphor-icons/react. Under GJS those fail at resolve or module-init
+// time — before a single widget is constructed.
+//
+// The scaffolded screens consume the page shell (Screen, EmptyState,
+// PageHeader, PageSection) plus the layout and text primitives the real
+// barrel gets from its trailing `export * from "tamagui"`. Re-export
+// exactly that. Add modules as your screens grow; a missing export is a
+// build error naming the symbol, which is the cheapest possible signal.
+//
+// Deep `…/src/*` paths rather than the bare package name: the bare name
+// is aliased to THIS file, so importing it here would loop.
+
+export * from "@multiplatform.one/components/src/layouts/page";
+
+export {
+  Button,
+  Card,
+  H1,
+  H2,
+  H3,
+  H4,
+  Image,
+  Paragraph,
+  ScrollView,
+  Separator,
+  SizableText,
+  Spinner,
+  Text,
+  XStack,
+  YStack,
+  isWeb,
+} from "../tamagui-barrel";

package/templates/pieces/gnome/universal/apps/__NAME__/gnome/shims/empty-module.ts

@@ -0,0 +1,28 @@
+// Stub for real-RN Flow internals and the expo surface, wired up by
+// vite.config.gnome.ts's stubRnLibraries plugin.
+//
+// Two ways they reach the graph: a dependency deep-imports
+// `react-native/Libraries/...` (slipping past the package-root alias),
+// and expo modules arrive through accidental native-condition resolution.
+// Neither has a GJS implementation, and RN's Flow sources cannot be
+// parsed by the bundler at all.
+//
+// The named exports exist so a destructuring import resolves rather than
+// throwing at module init — the call sites are all on paths this target
+// does not take.
+
+export default {};
+export const get = () => null;
+export const Platform = {
+  OS: "linux",
+  select: (o: Record<string, unknown>) => o.default ?? o.native,
+};
+export const NativeEventEmitter = class NativeEventEmitter {};
+export const EventEmitter = class EventEmitter {};
+export const NativeModule = class NativeModule {};
+export const SharedObject = class SharedObject {};
+export const SharedRef = class SharedRef {};
+export const CodedError = class CodedError extends Error {};
+export const UnavailabilityError = class UnavailabilityError extends Error {};
+export const requireNativeModule = () => ({});
+export const requireNativeViewManager = () => null;

package/templates/pieces/gnome/universal/apps/__NAME__/gnome/shims/forms.ts

@@ -0,0 +1,18 @@
+// GNOME-target shim for @multiplatform.one/forms.
+//
+// The real barrel reaches the whole field library, and with it phosphor
+// icons, lucide and the expo surface (camera for the barcode field, the
+// linear-gradient for the colour picker). None of those resolve under
+// GJS.
+//
+// Re-export the fields the starter ContactForm uses, through deep
+// `…/src/*` paths — the bare package name is aliased to this file.
+// Adding a field is one line here plus, usually, one granular @tamagui/*
+// export in ../tamagui-barrel.ts.
+
+export { Button } from "@multiplatform.one/forms/src/Button";
+export type { ButtonProps } from "@multiplatform.one/forms/src/Button";
+export { Input } from "@multiplatform.one/forms/src/fields/Input";
+export { TextArea } from "@multiplatform.one/forms/src/fields/TextArea";
+export { Spinner } from "@multiplatform.one/forms/src/Spinner";
+export { zIndex } from "@multiplatform.one/forms/src/shared/zIndex";

package/templates/pieces/gnome/universal/apps/__NAME__/gnome/shims/one.ts

@@ -0,0 +1,89 @@
+// GNOME-target shim for the `one` router package.
+//
+// One's file router never mounts under GJS: its native path goes through
+// react-navigation and react-native-screens, which need the RN fabric
+// renderer. So the router API the screens call is backed instead by the
+// framework's navigator seam (@multiplatform.one/router/seam), which
+// vite.config.gnome.ts resolves to the navigator source alone — the seam
+// barrel also exports a DOM host that has no GJS story.
+//
+// DEGRADATION IS DELIBERATE. gnome/main.tsx renders one screen with no
+// Adw.NavigationView attached, so the navigator is unconfigured: pushes
+// are ignored and Link renders its children in place. Attach a
+// NavigationView host and the same calls become real push/pop with the
+// window back button, Escape and swipe-back all working. Nothing here
+// changes when you do.
+
+import {
+  hrefToString,
+  stackNavigator,
+  useNavState,
+  useRouteParams,
+  type Href,
+  type NavParams,
+} from "@multiplatform.one/router/seam";
+import type { ReactNode } from "react";
+import { createElement } from "react";
+import { View } from "../tamagui-barrel";
+
+// One's router object is referentially stable — consumers put it in
+// useEffect and useCallback dependency arrays, so this one must be too.
+const ROUTER = {
+  push: (href: Href) => stackNavigator.push(href),
+  replace: (href: Href) => stackNavigator.replace(href),
+  back: () => stackNavigator.back(),
+  setParams: (params: NavParams) => stackNavigator.setParams(params),
+};
+
+export function useRouter(): typeof ROUTER {
+  return ROUTER;
+}
+
+export function usePathname(): string {
+  return useNavState().pathname;
+}
+
+export function useParams(): NavParams {
+  return useRouteParams();
+}
+
+export function useLocalSearchParams(): NavParams {
+  return useRouteParams();
+}
+
+export interface LinkProps {
+  href?: Href;
+  children?: ReactNode;
+  [key: string]: unknown;
+}
+
+export function Link({ href, children }: LinkProps): ReactNode {
+  if (!href) return children ?? null;
+  return createElement(
+    View as never,
+    {
+      cursor: "pointer",
+      onPress: () => stackNavigator.push(href),
+      testID: `link:${hrefToString(href)}`,
+    } as never,
+    children,
+  );
+}
+
+/** One renders the active child route into a layout's <Slot />. Under the
+ *  seam every route is its own Adw.NavigationPage mounted by the
+ *  navigation host, so a layout contributes chrome only and this renders
+ *  nothing by design. */
+export function Slot(): null {
+  return null;
+}
+
+/** One's history-nav guard. There is no browser history to block here, so
+ *  this always reports unblocked. Shape matches One's return value. */
+export function useBlocker(): {
+  state: "unblocked" | "blocked" | "proceeding";
+  proceed: () => void;
+  reset: () => void;
+} {
+  return { state: "unblocked", proceed: () => {}, reset: () => {} };
+}

package/templates/pieces/gnome/universal/apps/__NAME__/gnome/shims/theme.ts

@@ -0,0 +1,25 @@
+// GNOME-target shim for @multiplatform.one/theme.
+//
+// The real barrel re-exports devtools, cookie and audit modules whose
+// graphs reach react-dom/server, react-cookie, node:fs and
+// @multiplatform.one/platform (→ expo-constants). None of that belongs in
+// a GJS bundle, and several fail at module init.
+//
+// Re-export only the pure theme-building and knob-resolution subgraph:
+// @package/themes needs the theme builders and fonts, and the page-shell
+// components need the knob resolver.
+//
+// Deep `…/src/*` paths rather than the bare package name, which is
+// aliased to this file and would loop.
+
+export * from "@multiplatform.one/theme/src/font";
+export * from "@multiplatform.one/theme/src/theme/createDefaultThemeConfig";
+export * from "@multiplatform.one/theme/src/theme/createThemes";
+export * from "@multiplatform.one/theme/src/theme/intents";
+export * from "@multiplatform.one/theme/src/theme/knobs";
+export * from "@multiplatform.one/theme/src/theme/PresetContext";
+export * from "@multiplatform.one/theme/src/theme/presets";
+export * from "@multiplatform.one/theme/src/theme/recipes";
+export * from "@multiplatform.one/theme/src/theme/resolveKnobs";
+export * from "@multiplatform.one/theme/src/theme/shared";
+export * from "@multiplatform.one/theme/src/theme/useResolvedKnobs";

package/templates/pieces/gnome/universal/apps/__NAME__/gnome/tamagui-barrel.ts

@@ -0,0 +1,77 @@
+// Resolution target for the `tamagui` meta-package on the GNOME target.
+//
+// vite.config.gnome.ts aliases `tamagui` here. The full meta-barrel drags
+// web-only components into the GJS bundle, so re-export only the granular
+// @tamagui/* packages this app's graph actually reaches.
+//
+// KEEP THIS MINIMAL, AND EXTEND DELIBERATELY. Every extra granular
+// package widens the module graph, and some widen it off a cliff:
+// @tamagui/popover pulls @tamagui/portal, which requires
+// react-native/Libraries/* — real RN's Flow sources, which the bundler
+// cannot parse. When a screen needs a component, add it here and rebuild;
+// a missing export fails loudly at build time, which is the point.
+
+export {
+  createFont,
+  createStyledContext,
+  createTamagui,
+  getConfig,
+  getTokenValue,
+  getTokens,
+  getVariable,
+  getVariableValue,
+  isWeb,
+  styled,
+  TamaguiProvider,
+  Text,
+  Theme,
+  useDidFinishSSR,
+  useEvent,
+  useMedia,
+  useProps,
+  useStyle,
+  useTheme,
+  useThemeName,
+  View,
+  withStaticProperties,
+} from "@tamagui/core";
+export { H1, H2, H3, H4, H5, H6, Paragraph, SizableText } from "@tamagui/text";
+export { ThemeableStack, XStack, YStack, ZStack } from "@tamagui/stacks";
+export { ScrollView } from "@tamagui/scroll-view";
+export { Separator } from "@tamagui/separator";
+export { Spacer } from "@tamagui/spacer";
+export { Spinner } from "@tamagui/spinner";
+export { Card } from "@tamagui/card";
+export { Image } from "@tamagui/image";
+
+// Starter form (features/__NAME__/src/ContactForm.tsx). Each stays inside
+// the core + stacks + helpers subgraph — verified free of
+// react-native/Libraries deep imports.
+export { Button } from "@tamagui/button";
+export { Form } from "@tamagui/form";
+export { Input, TextArea } from "@tamagui/input";
+export { Label } from "@tamagui/label";
+export { getFontSize } from "@tamagui/font-size";
+export { useComposedRefs } from "@tamagui/compose-refs";
+export { useControllableState } from "@tamagui/use-controllable-state";
+export { useWindowDimensions } from "@tamagui/use-window-dimensions";
+
+// Type-only names referenced by `import type { … } from "tamagui"` across
+// the workspace. Erased at build time; listed for tsc and editors.
+export type {
+  ColorTokens,
+  CreateTamaguiProps,
+  FontSizeTokens,
+  GenericFont,
+  GetProps,
+  ScrollViewProps,
+  SizeTokens,
+  TamaguiElement,
+  TextProps,
+  ThemeName,
+  ViewProps,
+} from "@tamagui/core";
+export type { StackProps, XStackProps, YStackProps } from "@tamagui/stacks";
+export type { ButtonProps } from "@tamagui/button";
+export type { InputProps } from "@tamagui/input";
+export type { LabelProps } from "@tamagui/label";

package/templates/pieces/gnome/universal/apps/__NAME__/package.json.partial

@@ -0,0 +1,18 @@
+{
+  "scripts": {
+    "build:gnome": "vite build --config vite.config.gnome.ts",
+    "gnome": "pnpm build:gnome && gjs -m ./dist/gnome/main.js interactive",
+    "gnome:capture": "pnpm build:gnome && gjs -m ./dist/gnome/main.js"
+  },
+  "dependencies": {
+    "@react-gnome/animation": "^0.1.0",
+    "@react-gnome/react-native": "^0.1.0",
+    "@react-gnome/react-native-svg": "^0.1.0",
+    "@react-gnome/renderer": "^0.1.0",
+    "@react-gnome/tamagui": "^0.1.0"
+  },
+  "devDependencies": {
+    "@multiplatform.one/vite-plugin-gnome": "__MPO_VERSION__",
+    "@react-gnome/vite-plugin": "^0.1.0"
+  }
+}

package/templates/pieces/gnome/universal/apps/__NAME__/vite.config.gnome.ts

@@ -0,0 +1,124 @@
+// Vite config for the GNOME (GTK4 / GJS / libadwaita) target.
+//
+// Builds gnome/main.tsx into dist/gnome/main.js, runnable with:
+//
+//   pnpm gnome            # interactive window
+//   pnpm gnome:capture    # render, save a PNG, quit
+//
+// THIS IS NOT A VARIANT OF THE WEB BUILD. The web target is One (file
+// router, SSR, react-native-web); this one is a plain Vite library build
+// whose output GJS executes directly, rendering REAL GTK4 widgets through
+// react-gnome — no webview, no DOM. That is the whole difference from the
+// tauri piece, which ships the web build inside a system webview.
+//
+// The generic react-gnome settings (aliases, conditions, define, React
+// dedupe, .native.* extensions) come from @react-gnome/vite-plugin; the
+// Tamagui-under-GJS bundle patches come from
+// @multiplatform.one/vite-plugin-gnome.
+
+import { tamaguiLinkedAliases, tamaguiPlugin } from "@multiplatform.one/vite-plugin-gnome";
+import {
+  gnomeConditions,
+  gnomeDedupe,
+  gnomeDefine,
+  gnomeExtensions,
+  gnomeLinkedAliases,
+} from "@react-gnome/vite-plugin";
+import react from "@vitejs/plugin-react";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import type { Plugin } from "vite";
+import { defineConfig } from "vite";
+
+const require = createRequire(import.meta.url);
+const nodeEnv = process.env.RGN_PROD === "1" ? "production" : "development";
+const gnomeDir = resolve(import.meta.dirname, "gnome");
+
+/** Directory a package resolves to, so aliases point at THIS app's
+ *  installed copy. pnpm's store layout means a bare package name resolved
+ *  from a file outside this app (a linked workspace source, a hoisted
+ *  @tamagui/*) can miss these — absolute paths cannot. */
+function pkgDir(id: string): string {
+  return dirname(require.resolve(`${id}/package.json`));
+}
+
+/** Stub real-RN Flow internals and the expo surface. A dependency that
+ *  deep-imports `react-native/Libraries/...` slips past the package-root
+ *  alias, and the bundler cannot parse RN's Flow sources; expo modules
+ *  arrive through accidental native-condition resolution and have no GJS
+ *  implementation at all. */
+const stubRnLibraries: Plugin = {
+  name: "gnome-stub-rn-libraries",
+  enforce: "pre",
+  resolveId(id) {
+    const stub =
+      id.includes("react-native/Libraries/") ||
+      id.includes("NativeComponentRegistry") ||
+      id.startsWith("expo-") ||
+      id.includes("expo-modules-core");
+    if (stub) return resolve(gnomeDir, "shims/empty-module.ts");
+  },
+};
+
+export default defineConfig({
+  // Don't copy public/ (web favicons) or the generated tamagui.css into
+  // the GJS bundle directory.
+  publicDir: false,
+  plugins: [stubRnLibraries, react(), tamaguiPlugin],
+  resolve: {
+    conditions: [...gnomeConditions],
+    alias: [
+      ...gnomeLinkedAliases(resolve(import.meta.dirname, "node_modules/@react-gnome")),
+      // `tamagui` meta-package → a lean barrel re-exporting only the
+      // granular @tamagui/* packages this app's graph reaches. The full
+      // meta-barrel drags web-only components into the GJS bundle.
+      ...tamaguiLinkedAliases({ tamaguiBarrel: resolve(gnomeDir, "tamagui-barrel.ts") }),
+      // Barrels narrowed for GJS — see gnome/shims/*.ts for what each
+      // one drops and why. Exact-name regexes so the shims' own deep
+      // `…/src/*` imports don't loop back through the alias.
+      {
+        find: /^@multiplatform\.one\/components$/,
+        replacement: resolve(gnomeDir, "shims/components.ts"),
+      },
+      { find: /^@multiplatform\.one\/theme$/, replacement: resolve(gnomeDir, "shims/theme.ts") },
+      { find: /^@multiplatform\.one\/forms$/, replacement: resolve(gnomeDir, "shims/forms.ts") },
+      // One's file router never mounts on GJS (react-native-screens is a
+      // native-fabric dead end). The shim backs the router API the
+      // screens consume with the framework's navigator seam.
+      { find: /^one$/, replacement: resolve(gnomeDir, "shims/one.ts") },
+      // The seam BARREL also exports the DOM host and the One adapter,
+      // whose @vxrn/color-scheme import has no GJS story. Resolve the
+      // navigator source alone.
+      {
+        find: /^@multiplatform\.one\/router\/seam$/,
+        replacement: resolve(pkgDir("@multiplatform.one/router"), "src/seam/navigator.ts"),
+      },
+    ],
+    // One React instance. The @react-gnome packages carry their own react
+    // and react-reconciler copies; dedupe forces every import (including
+    // react-reconciler's CJS require) to this app's root.
+    dedupe: [...gnomeDedupe],
+    // Metro-style resolution: prefer `.native.*` so platform-split
+    // modules pick their native variant under GNOME.
+    extensions: [...gnomeExtensions],
+  },
+  define: gnomeDefine(nodeEnv),
+  build: {
+    target: "esnext",
+    outDir: "dist/gnome",
+    emptyOutDir: true,
+    // GJS reads the bundle directly — keep it readable and mapped, since
+    // a stack trace here is the only debugger you get.
+    minify: false,
+    sourcemap: "inline",
+    lib: {
+      entry: resolve(gnomeDir, "main.tsx"),
+      formats: ["es"],
+      fileName: () => "main.js",
+    },
+    rollupOptions: {
+      // GJS provides these; bundling them is not possible.
+      external: [/^gi:\/\//, "system", "console", "cairo"],
+    },
+  },
+});

package/templates/pieces/gnome/universal/gitignore.partial

@@ -0,0 +1,3 @@
+
+# GNOME target (mpo init --gnome)
+apps/__NAME__/dist/gnome

package/templates/pieces/gnome/universal/package.json.partial

@@ -0,0 +1,6 @@
+{
+  "scripts": {
+    "gnome": "pnpm --filter @app/__NAME__ gnome",
+    "gnome:capture": "pnpm --filter @app/__NAME__ gnome:capture"
+  }
+}

package/templates/pieces/keycloak/universal/README.md.partial

@@ -0,0 +1,19 @@
+## Keycloak auth (`mpo init --keycloak`)
+
+`apps/__NAME__/src/app.ts` wires `createApp({ keycloak: … })`: the
+`KeycloakProvider` mounts when `KEYCLOAK_ENABLED=1` and reads
+`KEYCLOAK_BASE_URL` / `KEYCLOAK_REALM` / `KEYCLOAK_CLIENT_ID` /
+`KEYCLOAK_PUBLIC_CLIENT_ID` (all `public` env keys in
+`packages/config/config.json`, loaded from `.env` — start from
+`.env.example`).
+
+Run a dev auth server with docker:
+
+```bash
+docker compose -f docker/compose.keycloak.yaml up -d
+```
+
+First boot imports `docker/keycloak/realm.json`: realm `__NAME__` with the
+two clients above and a `dev` / `dev` user. The admin console lives at
+http://localhost:8080/auth (admin / admin) — manage users, clients, and
+flows there, or edit the realm import stub and recreate the volume.

package/templates/pieces/keycloak/universal/docker/compose.keycloak.yaml

@@ -0,0 +1,27 @@
+# Dev Keycloak for __NAME__ (mpo init --keycloak).
+#
+#   docker compose -f docker/compose.keycloak.yaml up -d
+#
+# start-dev uses the embedded dev database (persisted in the named volume)
+# and imports docker/keycloak/realm.json on first boot — realm "__NAME__"
+# with the clients the KEYCLOAK_* env keys reference, plus a dev/dev user.
+# Admin console: http://localhost:8080/auth (admin/admin).
+services:
+  keycloak:
+    image: quay.io/keycloak/keycloak:26.6
+    command:
+      - start-dev
+      - --import-realm
+    environment:
+      KC_BOOTSTRAP_ADMIN_USERNAME: admin
+      KC_BOOTSTRAP_ADMIN_PASSWORD: admin
+      # /auth keeps parity with KEYCLOAK_BASE_URL (and reverse-proxy setups).
+      KC_HTTP_RELATIVE_PATH: /auth
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./keycloak/realm.json:/opt/keycloak/data/import/realm.json:ro
+      - keycloak:/opt/keycloak/data/h2
+
+volumes:
+  keycloak: {}

package/templates/pieces/keycloak/universal/docker/keycloak/realm.json

@@ -0,0 +1,43 @@
+{
+  "realm": "__NAME__",
+  "enabled": true,
+  "sslRequired": "none",
+  "registrationAllowed": true,
+  "clients": [
+    {
+      "clientId": "__NAME__",
+      "name": "__NAME_PASCAL__ (confidential)",
+      "enabled": true,
+      "protocol": "openid-connect",
+      "publicClient": false,
+      "secret": "__NAME__-dev-secret",
+      "standardFlowEnabled": true,
+      "directAccessGrantsEnabled": true,
+      "serviceAccountsEnabled": true,
+      "redirectUris": ["http://localhost:3456/*"],
+      "webOrigins": ["http://localhost:3456"]
+    },
+    {
+      "clientId": "__NAME__-public",
+      "name": "__NAME_PASCAL__ (public)",
+      "enabled": true,
+      "protocol": "openid-connect",
+      "publicClient": true,
+      "standardFlowEnabled": true,
+      "directAccessGrantsEnabled": true,
+      "redirectUris": ["http://localhost:3456/*"],
+      "webOrigins": ["http://localhost:3456"]
+    }
+  ],
+  "users": [
+    {
+      "username": "dev",
+      "enabled": true,
+      "emailVerified": true,
+      "email": "dev@__NAME__.localhost",
+      "firstName": "Dev",
+      "lastName": "User",
+      "credentials": [{ "type": "password", "value": "dev", "temporary": false }]
+    }
+  ]
+}

package/templates/pieces/keycloak/universal/env.example.partial

@@ -0,0 +1,9 @@
+# Keycloak auth (mpo init --keycloak) — copy to .env. KEYCLOAK_ENABLED=1
+# mounts the KeycloakProvider wired in apps/__NAME__/src/app.ts; the other
+# keys must match the realm import (docker/keycloak/realm.json).
+KEYCLOAK_ENABLED=1
+# Auth server base URL (docker/compose.keycloak.yaml serves /auth on :8080).
+KEYCLOAK_BASE_URL=http://localhost:8080/auth
+KEYCLOAK_REALM=__NAME__
+KEYCLOAK_CLIENT_ID=__NAME__
+KEYCLOAK_PUBLIC_CLIENT_ID=__NAME__-public

package/templates/pieces/keycloak/universal/packages/config/config.json.partial

@@ -0,0 +1,9 @@
+{
+  "public": [
+    "KEYCLOAK_ENABLED",
+    "KEYCLOAK_BASE_URL",
+    "KEYCLOAK_REALM",
+    "KEYCLOAK_CLIENT_ID",
+    "KEYCLOAK_PUBLIC_CLIENT_ID"
+  ]
+}

package/templates/pieces/tauri/universal/README.md.partial

@@ -0,0 +1,18 @@
+## Desktop app (`mpo init --tauri`)
+
+`apps/__NAME__/src-tauri/` is a minimal [Tauri v2](https://tauri.app) shell
+around the web app. It needs the platform prerequisites (Rust toolchain +
+system webview libraries): https://tauri.app/start/prerequisites/
+
+```bash
+pnpm tauri:dev     # dev window against the vite dev server (:3456)
+pnpm tauri:build   # bundle installers (runs pnpm build first)
+```
+
+`tauri:dev` starts `pnpm dev` for you (beforeDevCommand) and opens the
+window once http://localhost:3456 responds. Note the web build is an SSR
+One app: `tauri:build` embeds `apps/__NAME__/dist` as-is, which suits a
+static/SPA export — point `frontendDist` (src-tauri/tauri.conf.json) at
+your static output, or keep the desktop shell against a served URL.
+Regenerate icons from your own artwork with
+`pnpm --filter @app/__NAME__ tauri icon <path/to/icon.png>`.

package/templates/pieces/tauri/universal/apps/__NAME__/package.json.partial

@@ -0,0 +1,10 @@
+{
+  "scripts": {
+    "tauri": "tauri",
+    "tauri:dev": "tauri dev",
+    "tauri:build": "tauri build"
+  },
+  "devDependencies": {
+    "@tauri-apps/cli": "^2.11.0"
+  }
+}

package/templates/pieces/tauri/universal/apps/__NAME__/src-tauri/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "__NAME__"
+version = "0.0.0"
+description = "__NAME__ desktop application"
+edition = "2021"
+
+[lib]
+name = "app_lib"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+tauri = { version = "2", features = [] }
+tauri-plugin-log = "2"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+log = "0.4"
+
+[profile.release]
+panic = "abort"
+codegen-units = 1
+lto = true
+opt-level = "s"
+strip = true

package/templates/pieces/tauri/universal/apps/__NAME__/src-tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

package/templates/pieces/tauri/universal/apps/__NAME__/src-tauri/capabilities/default.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "main-capability",
+  "description": "Capability for the main window",
+  "windows": ["main"],
+  "permissions": ["core:default"]
+}

package/templates/pieces/tauri/universal/apps/__NAME__/src-tauri/src/lib.rs

@@ -0,0 +1,14 @@
+//! __NAME__ Tauri application library. Register #[tauri::command] functions
+//! here (and in the invoke_handler) as the desktop app grows.
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    tauri::Builder::default()
+        .plugin(
+            tauri_plugin_log::Builder::new()
+                .level(log::LevelFilter::Info)
+                .build(),
+        )
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}