create-dig-app 0.1.1

package/lib/templates.js

@@ -0,0 +1,185 @@
+// The template registry — the single source of truth for what `create-dig-app` can scaffold.
+//
+// Each template is a directory under ../templates/<name>/ whose files are copied verbatim except for
+// `__PLACEHOLDER__` token substitution (see substitute.js). The metadata here drives:
+//   - the interactive picker + `--template` validation (templateNames / resolveTemplate),
+//   - the dig.toml the scaffolder writes (outputDir + buildCommand, which the SDK adapter and
+//     `digstore deploy` both read — see modules/dig-sdk/src/adapters/dig-toml.ts),
+//   - which templates wire @dignetwork/dig-sdk (wallet) vs stay dependency-light static sites.
+//
+// Templates are kept MINIMAL but real: each one `npm install`s and builds, and none bundles a heavy
+// framework footprint beyond what the framework itself requires.
+
+/**
+ * @typedef {("js"|"ts")} Lang A scaffold language: plain JavaScript or TypeScript.
+ */
+
+/**
+ * @typedef {Object} TemplateMeta
+ * @property {string} name        Template id (matches the directory name).
+ * @property {string} title       Short human title for the picker.
+ * @property {string} description One-line description for the picker + `--help`.
+ * @property {string} outputDir   The built-output dir digstore publishes (written into dig.toml).
+ * @property {string} buildCommand Build command digstore runs in CI (written into dig.toml).
+ * @property {boolean} wallet     True if the template wires @dignetwork/dig-sdk (ChiaProvider).
+ * @property {Lang[]} langs       Languages this template can be scaffolded in, in offer order.
+ *                                Always includes "js"; includes "ts" when a TypeScript variant
+ *                                exists under ../templates-ts/<name>/ (see {@link resolveLang}).
+ */
+
+// The default scaffold language. JS stays the default so existing invocations are unchanged.
+export const DEFAULT_LANG = "js";
+/** The languages a user may request, in offer order (also the interactive picker order). */
+export const LANGS = ["js", "ts"];
+
+/** @type {Record<string, TemplateMeta>} */
+export const TEMPLATES = {
+  // `static-site` has no build step (its "build" just copies src/ → public/), so there is no
+  // buildable JS to typecheck and therefore no TypeScript variant — it stays JS-only.
+  //
+  // Named `static-site` to align with the Rust `digstore new` template id of the same name, so the
+  // two front doors (JS `create-dig-app`, Rust `digstore new`) name the same starter identically.
+  // The legacy id `static` still works via TEMPLATE_ALIASES (a hidden back-compat alias).
+  "static-site": {
+    name: "static-site",
+    title: "Static site",
+    description: "Plain HTML/CSS/JS — zero build step, the lightest way to ship a site on DIG.",
+    outputDir: "public",
+    buildCommand: "npm run build",
+    wallet: false,
+    langs: ["js"],
+  },
+  "vite-react": {
+    name: "vite-react",
+    title: "Vite + React",
+    description: "A React SPA built with Vite — the fast default for an app frontend.",
+    outputDir: "dist",
+    buildCommand: "npm run build",
+    wallet: false,
+    langs: ["js", "ts"],
+  },
+  "next-static": {
+    name: "next-static",
+    title: "Next.js (static export)",
+    description: "Next.js exported to static files (output: 'export') — deployable as a DIG capsule.",
+    outputDir: "out",
+    buildCommand: "npm run build",
+    wallet: false,
+    langs: ["js", "ts"],
+  },
+  "nft-drop": {
+    name: "nft-drop",
+    title: "NFT drop",
+    description: "A wallet-connected NFT mint page, wired to @dignetwork/dig-sdk (no mint at scaffold).",
+    outputDir: "dist",
+    buildCommand: "npm run build",
+    wallet: true,
+    langs: ["js", "ts"],
+  },
+  // The NFT PROJECT starter (richer than nft-drop): a directory-structured collection workspace
+  // (images/ assets/ metadata/ licenses/) with dependency-free metadata/license/validate tooling
+  // that emits canonical CHIP-0007 metadata + the items.json manifest `digstore collection mint`
+  // consumes. JS-only: it is a content/asset workspace driven by Node scripts, not a typed app —
+  // there is no buildable app source to typecheck, so (like static-site) it offers no TS variant.
+  // `build` runs the validator (a pre-publish gate); the published capsule's content root is the
+  // project root (art + metadata + licenses all ship in the capsule).
+  "nft-collection": {
+    name: "nft-collection",
+    title: "NFT collection",
+    description: "An NFT collection workspace — art + CHIP-0007 metadata/license tooling for digstore collection mint.",
+    outputDir: ".",
+    buildCommand: "npm run build",
+    wallet: true,
+    langs: ["js"],
+  },
+  "dapp-window-chia": {
+    name: "dapp-window-chia",
+    title: "Wallet dapp (window.chia)",
+    description: "A dapp wired to the injected Chia wallet via ChiaProvider (window.chia → WalletConnect).",
+    outputDir: "dist",
+    buildCommand: "npm run build",
+    wallet: true,
+    langs: ["js", "ts"],
+  },
+};
+
+/**
+ * Normalize a user-supplied language token to a canonical {@link Lang}.
+ * Accepts the long and short forms: "ts"/"typescript" → "ts", "js"/"javascript" → "js".
+ * @param {string} raw
+ * @returns {Lang}
+ * @throws {Error} on an unrecognized value.
+ */
+export function normalizeLang(raw) {
+  const v = String(raw ?? "").trim().toLowerCase();
+  if (v === "ts" || v === "typescript") return "ts";
+  if (v === "js" || v === "javascript") return "js";
+  throw new Error(`Unknown --lang "${raw}". Use "js" (javascript) or "ts" (typescript).`);
+}
+
+/**
+ * Resolve the language a template will actually be scaffolded in: the requested language if the
+ * template offers it, otherwise the default ("js"). `static` has no TS variant, so requesting "ts"
+ * for it resolves back to "js" (the caller can compare requested vs. resolved to tell the user).
+ * @param {TemplateMeta} meta
+ * @param {Lang} [requested]
+ * @returns {Lang}
+ */
+export function resolveLang(meta, requested = DEFAULT_LANG) {
+  return meta.langs.includes(requested) ? requested : DEFAULT_LANG;
+}
+
+/**
+ * Hidden back-compat aliases: legacy/alternate template ids that resolve to a canonical one.
+ * Aliases are accepted by {@link resolveTemplate} (so old invocations keep working) but are NOT
+ * listed by {@link templateNames} (the picker, `--help`, and `--list-templates` show only the
+ * canonical names). Keep this MINIMAL — it exists only to avoid breaking existing scripts.
+ * @type {Record<string, string>}
+ */
+export const TEMPLATE_ALIASES = {
+  // Renamed `static` → `static-site` (2026) to match the Rust `digstore new` template id.
+  static: "static-site",
+};
+
+/** Raised when a requested template name is not in the registry. */
+export class UnknownTemplateError extends Error {
+  /** @param {string} requested */
+  constructor(requested) {
+    super(
+      `Unknown template "${requested}". Available: ${templateNames().join(", ")}.`,
+    );
+    this.name = "UnknownTemplateError";
+    this.requested = requested;
+  }
+}
+
+/** All canonical template ids, in registry (declaration) order. (Aliases are excluded.) */
+export function templateNames() {
+  return Object.keys(TEMPLATES);
+}
+
+/**
+ * Canonicalize a template id, resolving a hidden alias (e.g. `static` → `static-site`) to its
+ * canonical name. Unknown / non-alias names are returned unchanged (and rejected by
+ * {@link resolveTemplate}).
+ * @param {string} name
+ * @returns {string}
+ */
+export function canonicalTemplateName(name) {
+  return Object.prototype.hasOwnProperty.call(TEMPLATE_ALIASES, name)
+    ? TEMPLATE_ALIASES[name]
+    : name;
+}
+
+/**
+ * Resolve a template name (canonical or a hidden alias) to its metadata, or throw
+ * {@link UnknownTemplateError}.
+ * @param {string} name
+ * @returns {TemplateMeta}
+ */
+export function resolveTemplate(name) {
+  const canonical = name && canonicalTemplateName(name);
+  const meta = canonical && TEMPLATES[canonical];
+  if (!meta) throw new UnknownTemplateError(name);
+  return meta;
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "create-dig-app",
+  "version": "0.1.1",
+  "description": "Scaffold a wallet-wired, deployable DIG Network app — free, no mint. The JS front door for building dapps, frontends, and NFT collections on Chia.",
+  "license": "MIT",
+  "author": "DIG Network",
+  "type": "module",
+  "bin": {
+    "create-dig-app": "bin/create-dig-app.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DIG-Network/create-dig-app"
+  },
+  "homepage": "https://github.com/DIG-Network/create-dig-app#readme",
+  "bugs": {
+    "url": "https://github.com/DIG-Network/create-dig-app/issues"
+  },
+  "keywords": [
+    "dig",
+    "dig-network",
+    "chia",
+    "create-dig-app",
+    "scaffold",
+    "starter",
+    "template",
+    "dapp",
+    "nft",
+    "decentralized",
+    "wallet"
+  ],
+  "files": [
+    "bin",
+    "lib",
+    "templates",
+    "templates-ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test test/",
+    "coverage": "c8 node --test test/",
+    "start": "node bin/create-dig-app.js"
+  },
+  "devDependencies": {
+    "c8": "10.1.3"
+  }
+}

package/templates/dapp-window-chia/README.md

@@ -0,0 +1,63 @@
+# __DISPLAY_NAME__
+
+A wallet-wired dapp for the **DIG Network** — connects the injected Chia wallet (`window.chia`) via
+`@dignetwork/dig-sdk`'s `ChiaProvider`, with a WalletConnect → Sage fallback.
+
+Scaffolded with `npm create dig-app` (template: `dapp-window-chia`).
+
+## Free until publish
+
+Scaffolding, building, previewing, and connecting a wallet cost **nothing**. There is **no mint, no
+chain, and no spend** when you create or run this project — you only spend **$DIG** the
+moment you publish a capsule with `digstore deploy`. *Iterate for free, publish when it's ready.*
+
+## How the wallet is wired
+
+`src/wallet.js` calls `ChiaProvider.connect({ mode: "auto" })`, which **prefers the injected DIG
+Browser wallet** (`window.chia`) and **falls back to WalletConnect → Sage**. In `digstore dev` an
+injected dev-shim `window.chia` is present, so the connect/read path runs locally — but the shim
+never fakes a signature; open the dapp in the **DIG Browser** (or connect a real wallet) to sign for
+real. See <https://github.com/DIG-Network/dig-sdk> for the full API.
+
+## Connect to Sage in a normal browser (WalletConnect)
+
+Outside the DIG Browser there is no injected `window.chia`, so the dapp connects to **Sage** (the
+main Chia wallet) over **WalletConnect**. This needs a free **project id**:
+
+1. Get one at **<https://cloud.reown.com>** (Reown, formerly WalletConnect Cloud).
+2. Copy `.env.example` to `.env` and set it:
+
+   ```sh
+   cp .env.example .env
+   # .env
+   VITE_WALLETCONNECT_PROJECT_ID=your_project_id_here
+   ```
+
+`@walletconnect/sign-client` is already a dependency, so once the project id is set, **Connect
+wallet** shows a pairing link/QR to approve in Sage and then displays your connected address. Leave
+`VITE_WALLETCONNECT_PROJECT_ID` blank to support only the injected DIG Browser wallet. (Never commit
+`.env` — only the placeholder `.env.example` is tracked.)
+
+## Develop
+
+```sh
+npm install
+npm run dev            # Vite dev server at http://localhost:5173
+npm run build          # production build -> dist/ (your content root)
+digstore dev           # preview on the real chia:// read path + dev wallet shim — FREE, no spend
+```
+
+## Publish (this is the only step that spends $DIG)
+
+```sh
+digstore deploy        # build + publish a capsule ($DIG + a small XCH fee)
+```
+
+## Deploy from CI
+
+Wire up push-to-deploy with the GitHub Action:
+<https://docs.dig.net/docs/digstore/cli/deploy-from-github-actions>.
+
+## Config
+
+`dig.toml` is the project manifest digstore reads (output dir, build command, default remote).

package/templates/dapp-window-chia/_env.example

@@ -0,0 +1,7 @@
+# WalletConnect Cloud / Reown project id — enables the WalletConnect → Sage fallback so this dapp
+# connects to Sage (the main Chia wallet) in a normal browser, not just the DIG Browser.
+#
+# Get a free project id at https://cloud.reown.com (formerly WalletConnect Cloud). Copy this file to
+# `.env` (or `.env.local`) and paste your id. Leave it blank to support ONLY the injected DIG Browser
+# wallet (window.chia) — the app still builds and runs; the WC fallback is just disabled.
+VITE_WALLETCONNECT_PROJECT_ID=

package/templates/dapp-window-chia/_gitignore

@@ -0,0 +1,10 @@
+node_modules/
+dist/
+.dig/
+.DS_Store
+*.log
+
+# Local env (e.g. your WalletConnect projectId) — never commit secrets; .env.example is committed.
+.env
+.env.local
+.env.*.local

package/templates/dapp-window-chia/dig.toml

@@ -0,0 +1,17 @@
+# dig.toml — the project manifest digstore (and the DIG SDK adapters) read.
+# Keys are kebab-case (snake_case also accepted). See:
+#   https://docs.dig.net/docs/digstore/cli/deploy-from-github-actions
+#
+# Everything here is LOCAL config. Scaffolding, building, and `digstore dev` cost nothing —
+# you only spend $DIG when you run `digstore deploy` to publish a capsule.
+
+# Vite emits the production build to dist/ — the content root digstore publishes.
+output-dir = "__OUTPUT_DIR__"
+
+# The command digstore runs to build before publishing (used by `digstore deploy` / CI).
+build-command = "__BUILD_COMMAND__"
+
+# Default remote a `digstore deploy` pushes to (resolves to your store after your first publish).
+remote = "origin"
+
+# network = "mainnet"

package/templates/dapp-window-chia/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>__DISPLAY_NAME__</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

package/templates/dapp-window-chia/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "__APP_NAME__",
+  "version": "0.0.0",
+  "private": true,
+  "description": "__DISPLAY_NAME__ — a wallet-wired dapp on the DIG Network (window.chia via ChiaProvider).",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@dignetwork/dig-sdk": "__SDK_VERSION__",
+    "@walletconnect/sign-client": "^2.11.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.4",
+    "vite": "^5.4.11",
+    "vite-plugin-top-level-await": "^1.4.4",
+    "vite-plugin-wasm": "^3.3.0"
+  }
+}

package/templates/dapp-window-chia/src/App.jsx

@@ -0,0 +1,91 @@
+import { useState } from "react";
+import { connectWallet } from "./wallet.js";
+
+export default function App() {
+  const [provider, setProvider] = useState(null);
+  const [address, setAddress] = useState("");
+  const [error, setError] = useState("");
+  const [busy, setBusy] = useState(false);
+  // The WalletConnect pairing URI (only set during the WC → Sage fallback). Render it as a copy-link
+  // / QR / deep link so the user can approve the connection in Sage.
+  const [wcUri, setWcUri] = useState("");
+
+  async function onConnect() {
+    setError("");
+    setWcUri("");
+    setBusy(true);
+    try {
+      // Works in both worlds: injected window.chia when present (DIG Browser / extension), otherwise
+      // WalletConnect → Sage. `onUri` fires only on the WC path, with the pairing URI to show.
+      const p = await connectWallet({ onUri: (uri) => setWcUri(uri) });
+      setProvider(p);
+      setAddress(await p.getAddress());
+    } catch (e) {
+      setError(e?.message ?? String(e));
+    } finally {
+      setBusy(false);
+      setWcUri(""); // pairing complete (or failed) — drop the URI
+    }
+  }
+
+  async function onSign() {
+    setError("");
+    try {
+      // The dev-shim wallet (in `digstore dev`) does NOT sign — open in the DIG Browser or connect a
+      // real wallet (e.g. Sage over WalletConnect) to produce a real signature.
+      const { signature } = await provider.signMessage("Login to __DISPLAY_NAME__");
+      alert("Signature: " + signature.slice(0, 24) + "…");
+    } catch (e) {
+      setError(e?.message ?? String(e));
+    }
+  }
+
+  return (
+    <main className="wrap">
+      <h1>__DISPLAY_NAME__</h1>
+      <p>
+        A wallet-wired dapp on the <strong>DIG Network</strong>. Your wallet is your account — no
+        email, no password.
+      </p>
+      <p className="muted">
+        Connecting and previewing are <strong>free</strong>. There is no mint, no chain, and no spend
+        here — you only spend $DIG when you publish with <code>digstore deploy</code>.
+      </p>
+
+      {address ? (
+        <div className="card">
+          <div className="row">
+            <span className="muted">Connected via</span>
+            <strong>{provider?.backend}</strong>
+          </div>
+          <div className="row">
+            <span className="muted">Address</span>
+            <code>{address}</code>
+          </div>
+          <button onClick={onSign}>Sign a login message</button>
+        </div>
+      ) : (
+        <button onClick={onConnect} disabled={busy}>
+          {busy ? "Connecting…" : "Connect wallet"}
+        </button>
+      )}
+
+      {wcUri && (
+        <div className="card">
+          <p className="muted">
+            Scan or open this in <strong>Sage</strong> to connect (WalletConnect):
+          </p>
+          <code>{wcUri}</code>
+          <button onClick={() => navigator.clipboard?.writeText(wcUri)}>Copy pairing link</button>
+        </div>
+      )}
+
+      {error && <p className="error">{error}</p>}
+
+      <pre>
+        <code>{`digstore dev      # preview + dev wallet shim, free
+digstore deploy   # publish a capsule ($DIG)`}</code>
+      </pre>
+    </main>
+  );
+}

package/templates/dapp-window-chia/src/main.jsx

@@ -0,0 +1,10 @@
+import React from "react";
+import { createRoot } from "react-dom/client";
+import App from "./App.jsx";
+import "./styles.css";
+
+createRoot(document.getElementById("root")).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);

package/templates/dapp-window-chia/src/styles.css

@@ -0,0 +1,71 @@
+:root {
+  color-scheme: light dark;
+  --fg: #0f172a;
+  --muted: #64748b;
+  --bg: #f8fafc;
+  --error: #dc2626;
+
+  /* DIG brand accent — violet -> magenta (SYSTEM.md visual theme; matches dig.net/hub/status). */
+  --dig-violet: #5800D6;
+  --dig-magenta: #FF00DE;
+  --accent: var(--dig-violet);
+  --grad-brand: linear-gradient(115deg, #5800D6 0%, #FF00DE 100%);
+
+  /* DIG brand fonts — named first, system stack as the offline/no-fetch fallback so a scaffolded
+     capsule never depends on an external font host (keeps the site self-contained + offline-safe). */
+  --dig-font: "Space Grotesk", "Segoe UI", system-ui, -apple-system, Roboto, sans-serif;
+  --dig-mono: "Space Mono", ui-monospace, SFMono-Regular, Menlo, monospace;
+}
+@media (prefers-color-scheme: dark) {
+  :root { --fg: #e2e8f0; --muted: #94a3b8; --bg: #0b1120; }
+}
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  min-height: 100vh;
+  display: grid;
+  place-items: center;
+  font: 16px/1.6 var(--dig-font);
+  color: var(--fg);
+  background: var(--bg);
+}
+.wrap { max-width: 42rem; padding: 2rem; }
+h1 {
+  font-size: 2.25rem;
+  margin: 0 0 0.5rem;
+  font-weight: 700;
+  background: var(--grad-brand);
+  -webkit-background-clip: text;
+  background-clip: text;
+  color: transparent;
+}
+.muted { color: var(--muted); }
+.error { color: var(--error); }
+button {
+  font: inherit;
+  padding: 0.6rem 1.1rem;
+  border: 0;
+  border-radius: 0.5rem;
+  background: var(--grad-brand);
+  color: white;
+  cursor: pointer;
+}
+button:disabled { opacity: 0.6; cursor: default; }
+.card {
+  margin: 1rem 0;
+  padding: 1rem;
+  border-radius: 0.75rem;
+  background: rgba(127, 127, 127, 0.12);
+  display: grid;
+  gap: 0.5rem;
+}
+.row { display: flex; gap: 0.75rem; align-items: baseline; flex-wrap: wrap; }
+code { font-family: var(--dig-mono); word-break: break-all; }
+pre {
+  font-family: var(--dig-mono);
+  margin-top: 1.5rem;
+  background: rgba(127, 127, 127, 0.12);
+  padding: 1rem;
+  border-radius: 0.5rem;
+  overflow-x: auto;
+}

package/templates/dapp-window-chia/src/wallet.js

@@ -0,0 +1,47 @@
+// Wallet wiring via @dignetwork/dig-sdk.
+//
+// ChiaProvider gives this dapp a Chia wallet for free: it PREFERS the injected DIG Browser wallet
+// (window.chia) and falls back to WalletConnect → Sage (the main Chia wallet) so the dapp connects
+// in a normal browser too. In `digstore dev` an injected dev-shim window.chia is present, so the
+// connect/read path runs end-to-end locally (read methods only — the shim never fakes a signature).
+// See https://github.com/DIG-Network/dig-sdk for the full API.
+
+import { ChiaProvider } from "@dignetwork/dig-sdk";
+
+// WalletConnect Cloud / Reown project id, read from the build-time env (see .env.example). When set,
+// it enables the WalletConnect → Sage fallback for browsers without the injected DIG wallet. Get a
+// free project id at https://cloud.reown.com (formerly WalletConnect Cloud).
+const WALLETCONNECT_PROJECT_ID = import.meta.env.VITE_WALLETCONNECT_PROJECT_ID ?? "";
+
+/**
+ * Connect a wallet. `mode: "auto"` prefers the injected DIG Browser wallet (window.chia) and falls
+ * back to WalletConnect → Sage when a project id is configured. The SDK drives its
+ * `WalletConnectTransport` under the hood (CHIP-0002 over the relay) — we never hand-roll WC.
+ *
+ * @param {{ onUri?: (uri: string) => void }} [hooks] `onUri` receives the WalletConnect pairing URI
+ *   so the UI can render a QR / copy-link / deep link to Sage during the fallback.
+ * @returns {Promise<import("@dignetwork/dig-sdk").ChiaProvider>}
+ */
+export async function connectWallet(hooks = {}) {
+  return ChiaProvider.connect({
+    mode: "auto", // prefer injected window.chia; fall back to WalletConnect → Sage if configured
+    chain: "chia:mainnet", // CAIP-2 chain the SDK expects (Chia mainnet)
+    walletConnect: WALLETCONNECT_PROJECT_ID
+      ? {
+          projectId: WALLETCONNECT_PROJECT_ID,
+          metadata: {
+            name: "__DISPLAY_NAME__",
+            description: "Built with create-dig-app + @dignetwork/dig-sdk",
+            url: typeof window !== "undefined" ? window.location.origin : "https://example.on.dig.net",
+            icons: [],
+          },
+          onUri: hooks.onUri, // render this URI as a QR / copy-link for the Sage fallback
+        }
+      : undefined,
+  });
+}
+
+/** True when the WalletConnect → Sage fallback is configured (a project id is set). */
+export function isWalletConnectConfigured() {
+  return Boolean(WALLETCONNECT_PROJECT_ID);
+}

package/templates/dapp-window-chia/vite.config.js

@@ -0,0 +1,14 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import wasm from "vite-plugin-wasm";
+import topLevelAwait from "vite-plugin-top-level-await";
+
+// The SDK transitively loads the CHIP-0035 spend builder (@dignetwork/dig-sdk →
+// chip35-dl-coin-wasm), a WebAssembly module with top-level await, so we enable the wasm +
+// top-level-await plugins. Relative base so the built dapp works from any path on a
+// *.on.dig.net subdomain (and chia://).
+export default defineConfig({
+  base: "./",
+  plugins: [react(), wasm(), topLevelAwait()],
+  build: { outDir: "dist" },
+});

package/templates/next-static/README.md

@@ -0,0 +1,41 @@
+# __DISPLAY_NAME__
+
+A Next.js static-export site for the **DIG Network** — deployed to a network no host can read,
+change, or take down.
+
+Scaffolded with `npm create dig-app` (template: `next-static`).
+
+> This template uses `output: 'export'` (`next.config.mjs`). A DIG capsule is a **blind static
+> host** — there is no Next.js server at runtime, so use static-export-compatible features only.
+
+## Free until publish
+
+Scaffolding, building, and previewing cost **nothing**. There is **no mint, no chain, and no spend**
+when you create or run this project — you only spend **$DIG** the moment you publish a
+capsule with `digstore deploy`. *Iterate for free, publish when it's ready.*
+
+## Develop
+
+```sh
+npm install
+npm run dev            # Next dev server at http://localhost:3000
+npm run build          # static export -> out/ (your content root)
+digstore dev           # preview on the real chia:// read path — FREE, no chain, no spend
+```
+
+## Publish (this is the only step that spends $DIG)
+
+```sh
+digstore deploy        # build + publish a capsule ($DIG + a small XCH fee)
+```
+
+Your site goes live at its `*.on.dig.net` address. Re-run `digstore deploy` to ship an update.
+
+## Deploy from CI
+
+Wire up push-to-deploy with the GitHub Action:
+<https://docs.dig.net/docs/digstore/cli/deploy-from-github-actions>.
+
+## Config
+
+`dig.toml` is the project manifest digstore reads (output dir, build command, default remote).

package/templates/next-static/_gitignore

@@ -0,0 +1,6 @@
+node_modules/
+.next/
+out/
+.dig/
+.DS_Store
+*.log