create-astrale-domain 0.2.13 → 0.3.0-beta.10

package/README.md

@@ -0,0 +1,12 @@
+# `create-astrale-domain`
+
+Official scaffolder for a new Astrale Domain project.
+
+During the SDK beta program, generate a project from the beta cohort explicitly:
+
+```bash
+npx -y create-astrale-domain@beta my-domain --yes
+```
+
+The generated project must resolve the SDK and deployment adapters from npm; it must not retain
+workspace links or repository-only source paths.

package/dist/index.js

@@ -779,28 +779,25 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 import { existsSync as existsSync2 } from "node:fs";
 import { delimiter, join as join2, relative as relative2, resolve as resolve2 } from "node:path";
 
-// src/scaffold.ts
+// src/scaffold/index.ts
 import { existsSync, readFileSync } from "node:fs";
 import { cp, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 var require2 = createRequire(import.meta.url);
 var HERE = dirname(fileURLToPath(import.meta.url));
-var WORKSPACE_ROOT = join(HERE, "..", "..", "..");
+var CREATE_PACKAGE_ROOT = owningPackageRoot(HERE, "create-astrale-domain");
+var SDK_ROOT = sdkCheckoutRoot(CREATE_PACKAGE_ROOT);
 var ORIGIN_PLACEHOLDER = "astrale-domain.example.dev";
 var INSTANCE_PLACEHOLDER = "my-instance-slug";
-var LINK_TARGETS = {
-  "@astrale-os/sdk": "sdk",
-  "@astrale-os/adapter-cloudflare": "sdk/adapter-cloudflare",
-  "@astrale-os/adapter-astrale": "sdk/adapter-astrale",
-  "@astrale-os/kernel-core": "kernel/core",
-  "@astrale-os/kernel-dsl": "kernel/dsl",
-  // The client SPA consumes the React shell surface directly.
-  "@astrale-os/shell": "shell/packages/shell",
-  "@astrale-os/shell-react": "shell/packages/shell-react"
-};
-var BODY_PACKAGE = "@astrale-os/adapter-cloudflare";
+var LINK_PACKAGES = /* @__PURE__ */ new Set([
+  "@astrale-os/sdk",
+  "@astrale-os/adapter-cloudflare",
+  "@astrale-os/adapter-astrale",
+  "@astrale-os/shell",
+  "@astrale-os/shell-react"
+]);
 var ADAPTER_PACKAGES = {
   astrale: "@astrale-os/adapter-astrale",
   cloudflare: "@astrale-os/adapter-cloudflare"
@@ -816,46 +813,68 @@ function errorText(err) {
   if (err instanceof Error) return err.message;
   return err === void 0 ? "" : String(err);
 }
-function errorReport(err) {
-  if (!(err instanceof Error)) return String(err);
-  const cause = err.cause;
+function errorReport(error) {
+  if (!(error instanceof Error)) return String(error);
+  const cause = error.cause;
   if (cause !== void 0) {
     const causeText = cause instanceof Error ? cause.message : String(cause);
-    if (causeText && !err.message.includes(causeText)) {
-      return `${err.message}
+    if (causeText && !error.message.includes(causeText)) {
+      return `${error.message}
    \u21B3 caused by: ${causeText}`;
     }
   }
-  return err.message;
+  return error.message;
 }
-function packageRoot(pkg) {
-  const direct = resolveModule(`${pkg}/package.json`);
+function packageRoot(packageName) {
+  const workspace = workspacePackageRoot(packageName);
+  if (workspace !== void 0) return workspace;
+  const direct = resolveModule(`${packageName}/package.json`);
   if ("path" in direct) return dirname(direct.path);
-  const entry = resolveModule(pkg);
-  if ("path" in entry) {
-    let dir = dirname(entry.path);
-    for (; ; ) {
-      const candidate = join(dir, "package.json");
-      if (existsSync(candidate)) {
-        try {
-          const parsed = JSON.parse(readFileSync(candidate, "utf-8"));
-          if (parsed.name === pkg) return dir;
-        } catch {
-        }
+  const reason = errorText(direct.error);
+  throw new Error(
+    `Could not locate ${packageName}/package.json \u2014 install a release exposing its package metadata.` + (reason ? ` The module resolver failed: ${reason}` : ""),
+    direct.error === void 0 ? void 0 : { cause: direct.error }
+  );
+}
+function workspacePackageRoot(packageName) {
+  if (SDK_ROOT === void 0) return void 0;
+  const candidates = {
+    "@astrale-os/sdk": SDK_ROOT,
+    "@astrale-os/adapter-astrale": join(SDK_ROOT, "adapter-astrale"),
+    "@astrale-os/adapter-cloudflare": join(SDK_ROOT, "adapter-cloudflare"),
+    "create-astrale-domain": join(SDK_ROOT, "create-astrale-domain")
+  };
+  const candidate = candidates[packageName];
+  if (candidate === void 0 || !existsSync(join(candidate, "package.json"))) return void 0;
+  return candidate;
+}
+function owningPackageRoot(start, name) {
+  let directory = start;
+  for (; ; ) {
+    const manifest = join(directory, "package.json");
+    if (existsSync(manifest)) {
+      try {
+        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+        if (parsed.name === name) return directory;
+      } catch {
       }
-      const parent = dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
     }
-    throw new Error(
-      `Could not locate the ${pkg} package.json (its entry resolved at ${entry.path}, but no ancestor package.json declares "name": "${pkg}").`
-    );
+    const parent = dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  throw new Error(`Could not locate the ${name} package root from ${start}.`);
+}
+function sdkCheckoutRoot(createRoot) {
+  const candidate = dirname(createRoot);
+  const manifest = join(candidate, "package.json");
+  if (!existsSync(manifest)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+    return parsed.name === "@astrale-os/sdk" ? candidate : void 0;
+  } catch {
+    return void 0;
   }
-  const reason = errorText(entry.error);
-  throw new Error(
-    `Could not locate the ${pkg} package \u2014 is it installed? (run your package manager's install)` + (reason ? ` The module resolver failed: ${reason}` : ""),
-    entry.error === void 0 ? void 0 : { cause: entry.error }
-  );
 }
 function installedPackageRange(pkg) {
   const manifestPath = join(packageRoot(pkg), "package.json");
@@ -874,19 +893,22 @@ function installedPackageRange(pkg) {
 function templateDir(pkg) {
   return join(packageRoot(pkg), "template");
 }
-async function scaffold(opts) {
-  const preExisting = existsSync(opts.dir);
+function bodyTemplateDir() {
+  return join(CREATE_PACKAGE_ROOT, "template");
+}
+async function scaffold(options) {
+  const preExisting = existsSync(options.dir);
   try {
-    await writeProject(opts);
+    await writeProject(options);
   } catch (err) {
-    if (!preExisting && existsSync(opts.dir)) {
-      await rm(opts.dir, { recursive: true, force: true });
+    if (!preExisting && existsSync(options.dir)) {
+      await rm(options.dir, { recursive: true, force: true });
     }
     throw err;
   }
 }
 async function writeProject(opts) {
-  const src = templateDir(BODY_PACKAGE);
+  const src = bodyTemplateDir();
   if (!existsSync(src)) {
     throw new Error(`Template not found at ${src}.`);
   }
@@ -896,15 +918,15 @@ async function writeProject(opts) {
   }
   await cp(src, opts.dir, {
     recursive: true,
-    filter: (s) => !/\/(node_modules|\.agents|\.astrale|\.dist|\.domain-studio|dist-client|\.wrangler|pnpm-lock\.yaml|\.DS_Store)(\/|$)/.test(
+    filter: (s) => !/\/(node_modules|client|\.agents|\.astrale|\.dist|\.domain-studio|\.variants|\.wrangler|pnpm-lock\.yaml|\.DS_Store)(\/|$)/.test(
       `/${relative(src, s)}`
     )
   });
-  await materializeGitignores(opts.dir);
+  await materializeFrontend(opts, src);
+  await materializeGitignores(opts.dir, opts.frontend);
   await materializeAdapter(opts);
   await stampOrigin(opts.dir, opts.origin);
   await rewritePackageJson(opts.dir, opts.name, opts.link);
-  await rewriteWorkspaceMember(join(opts.dir, "client", "package.json"), opts.link);
   if (opts.link) await writeLinkedZodOverride(opts.dir);
   else await writeReleaseAgePolicy(opts.dir);
   await writeFile(
@@ -912,8 +934,8 @@ async function writeProject(opts) {
     "# Dev secrets \u2014 the ENTIRE file is injected into the local runtime by `pnpm dev`.\n# Gitignored. See .env.example.\n"
   );
 }
-async function materializeGitignores(dir) {
-  for (const path of [join(dir, ".gitignore"), join(dir, "client", ".gitignore")]) {
+async function materializeGitignores(dir, frontend) {
+  for (const path of [join(dir, ".gitignore")]) {
     const packagedPath = `${path}.template`;
     if (existsSync(packagedPath)) {
       await rename(packagedPath, path);
@@ -921,6 +943,49 @@ async function materializeGitignores(dir) {
       throw new Error(`Template is missing packaged Git ignore file ${packagedPath}.`);
     }
   }
+  void frontend;
+}
+async function materializeFrontend(opts, template) {
+  const variant = join(template, ".variants", opts.frontend);
+  if (!existsSync(variant)) throw new Error(`Frontend template not found at ${variant}.`);
+  await cp(variant, opts.dir, { recursive: true });
+  const path = join(opts.dir, "package.json");
+  const pkg = JSON.parse(await readFile(path, "utf-8"));
+  pkg.dependencies ??= {};
+  pkg.devDependencies ??= {};
+  pkg.scripts ??= {};
+  if (opts.frontend === "react") {
+    Object.assign(pkg.dependencies, {
+      "@astrale-os/shell": ">=0.3.8-beta.2 <1.0.0",
+      "@astrale-os/shell-react": ">=0.2.10-beta.2 <1.0.0",
+      "@tanstack/react-router": "~1.131.0",
+      react: "^19.2.0",
+      "react-dom": "^19.2.0"
+    });
+    Object.assign(pkg.devDependencies, {
+      "@tailwindcss/vite": "^4.0.6",
+      "@tanstack/router-plugin": "~1.131.0",
+      "@types/react": "^19.2.0",
+      "@types/react-dom": "^19.2.0",
+      "@vitejs/plugin-react": "^5.0.4",
+      tailwindcss: "^4.0.6",
+      vite: "^7.1.7"
+    });
+  } else if (opts.frontend === "custom") {
+    pkg.devDependencies.vite = "^7.1.7";
+  }
+  if (opts.frontend !== "none") {
+    pkg.scripts["frontend:dev"] = "vite";
+    pkg.scripts["frontend:build"] = "vite build";
+  }
+  pkg.dependencies = sorted(pkg.dependencies);
+  pkg.devDependencies = sorted(pkg.devDependencies);
+  await writeFile(path, JSON.stringify(pkg, null, 2) + "\n");
+}
+function sorted(values) {
+  return Object.fromEntries(
+    Object.entries(values).sort(([left], [right]) => left.localeCompare(right))
+  );
 }
 function assertSafeToDelete(dir) {
   const target = resolve(dir);
@@ -932,40 +997,34 @@ function assertSafeToDelete(dir) {
   }
 }
 async function stampOrigin(dir, origin) {
-  const schemaIndex = join(dir, "schema", "index.ts");
+  const schemaIndex = join(dir, "schema", "application", "index.ts");
   await replaceInFile(schemaIndex, ORIGIN_PLACEHOLDER, origin);
   const config = join(dir, "astrale.config.ts");
   await replaceInFile(config, ORIGIN_PLACEHOLDER, origin);
 }
 async function materializeAdapter(opts) {
-  if (opts.adapter !== "astrale") return;
   const config = join(opts.dir, "astrale.config.ts");
-  await cp(join(templateDir(ADAPTER_PACKAGES.astrale), "astrale.config.ts"), config);
-  await setAdapterDep(opts.dir, "@astrale-os/adapter-cloudflare", "@astrale-os/adapter-astrale");
+  await cp(join(templateDir(ADAPTER_PACKAGES[opts.adapter]), "astrale.config.ts"), config);
+  if (opts.adapter === "cloudflare") return;
+  await addManagedAdapterDep(opts.dir);
   if (opts.instance) await replaceInFile(config, `'${INSTANCE_PLACEHOLDER}'`, `'${opts.instance}'`);
 }
-async function setAdapterDep(dir, from, to) {
+async function addManagedAdapterDep(dir) {
   const path = join(dir, "package.json");
   const pkg = JSON.parse(await readFile(path, "utf-8"));
-  if (!pkg.dependencies || !(from in pkg.dependencies)) {
+  if (!pkg.dependencies || !("@astrale-os/adapter-cloudflare" in pkg.dependencies)) {
     throw new Error(
-      `Could not materialize ${to}: the scaffold body does not declare its ${from} dependency.`
+      "Could not materialize @astrale-os/adapter-astrale: the scaffold body does not declare its @astrale-os/adapter-cloudflare Worker runtime dependency."
     );
   }
-  const range = installedPackageRange(to);
-  delete pkg.dependencies[from];
-  pkg.dependencies[to] = range;
+  pkg.dependencies["@astrale-os/adapter-astrale"] = installedPackageRange(
+    "@astrale-os/adapter-astrale"
+  );
   pkg.dependencies = Object.fromEntries(
     Object.entries(pkg.dependencies).sort(([a], [b3]) => a.localeCompare(b3))
   );
   await writeFile(path, JSON.stringify(pkg, null, 2) + "\n");
 }
-async function rewriteWorkspaceMember(pkgPath, link) {
-  if (!existsSync(pkgPath)) return;
-  const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
-  const changed = rewriteAstraleDeps(pkg, link);
-  if (changed) await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-}
 async function rewritePackageJson(dir, name, link) {
   const path = join(dir, "package.json");
   const pkg = JSON.parse(await readFile(path, "utf-8"));
@@ -979,8 +1038,8 @@ function rewriteAstraleDeps(pkg, link) {
   for (const group of [pkg.dependencies, pkg.devDependencies]) {
     if (!group) continue;
     for (const dep of Object.keys(group)) {
-      if (!dep.startsWith("@astrale-os/") || !LINK_TARGETS[dep]) continue;
-      const next = `link:${join(WORKSPACE_ROOT, LINK_TARGETS[dep])}`;
+      if (!LINK_PACKAGES.has(dep)) continue;
+      const next = `link:${localPackageRoot(dep)}`;
       if (group[dep] !== next) {
         group[dep] = next;
         changed = true;
@@ -1024,7 +1083,8 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function sdkZodVersion() {
-  const sdkRequire = createRequire(join(WORKSPACE_ROOT, "sdk", "package.json"));
+  if (SDK_ROOT === void 0) throw new Error("Local SDK checkout is unavailable.");
+  const sdkRequire = createRequire(join(SDK_ROOT, "package.json"));
   const pkg = sdkRequire("zod/package.json");
   return pkg.version;
 }
@@ -1035,7 +1095,32 @@ async function replaceInFile(path, from, to) {
   if (next !== text) await writeFile(path, next);
 }
 function workspaceAvailable() {
-  return existsSync(join(WORKSPACE_ROOT, "sdk", "package.json"));
+  if (SDK_ROOT === void 0) return false;
+  try {
+    for (const dependency of LINK_PACKAGES) localPackageRoot(dependency);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function localPackageRoot(dependency) {
+  if (SDK_ROOT !== void 0) {
+    const local = dependency === "@astrale-os/sdk" ? SDK_ROOT : dependency === "@astrale-os/adapter-cloudflare" ? join(SDK_ROOT, "adapter-cloudflare") : dependency === "@astrale-os/adapter-astrale" ? join(SDK_ROOT, "adapter-astrale") : void 0;
+    if (local !== void 0 && existsSync(join(local, "package.json"))) return local;
+  }
+  const resolved = resolveModule(`${dependency}/package.json`);
+  if ("path" in resolved) {
+    const installed = dirname(resolved.path);
+    if (!installed.split(sep).includes("node_modules")) return installed;
+  }
+  if ((dependency === "@astrale-os/shell" || dependency === "@astrale-os/shell-react") && SDK_ROOT !== void 0) {
+    const packageDirectory = dependency === "@astrale-os/shell" ? "shell" : "shell-react";
+    for (const base of [dirname(SDK_ROOT), dirname(dirname(SDK_ROOT))]) {
+      const candidate = join(base, "shell", "packages", packageDirectory);
+      if (existsSync(join(candidate, "package.json"))) return candidate;
+    }
+  }
+  throw new Error(`No active source package is available for ${dependency}.`);
 }
 
 // src/index.ts
@@ -1061,6 +1146,23 @@ var ADAPTERS = [
   },
   { value: "custom", label: "Custom", hint: "bring your own adapter (soon)", enabled: false }
 ];
+var FRONTENDS = [
+  {
+    value: "react",
+    label: "React",
+    hint: "managed shell integration with typed View component coordinates"
+  },
+  {
+    value: "custom",
+    label: "Custom",
+    hint: "framework-neutral frontend artifact with a minimal Vite application"
+  },
+  {
+    value: "none",
+    label: "None",
+    hint: "callable Domain only; no Views or browser assets"
+  }
+];
 async function main() {
   const argv = process.argv.slice(2);
   const flags = parseFlags(argv);
@@ -1109,6 +1211,23 @@ async function main() {
     xe(`The "${adapter}" adapter is not available yet \u2014 use "astrale" or "cloudflare".`);
     return 1;
   }
+  let frontend = flags.frontend;
+  if (!frontend) {
+    if (headless) frontend = "react";
+    else {
+      const answer = await ve({
+        message: "Frontend",
+        initialValue: "react",
+        options: [...FRONTENDS]
+      });
+      if (pD(answer)) return bail();
+      frontend = answer;
+    }
+  }
+  if (frontend !== "react" && frontend !== "custom" && frontend !== "none") {
+    xe(`Unknown frontend "${frontend}" \u2014 use "react", "custom", or "none".`);
+    return 1;
+  }
   const instance = flags.instance;
   if (instance !== void 0 && !isValidSlug(instance)) {
     xe(`Invalid --instance "${instance}". Use lowercase letters, digits, dots and dashes.`);
@@ -1151,6 +1270,7 @@ async function main() {
       name: slug,
       origin,
       adapter,
+      frontend,
       instance,
       link
     });
@@ -1220,6 +1340,7 @@ function parseFlags(argv) {
     else if (a === "--link") flags.link = true;
     else if (a === "--no-link") flags.link = false;
     else if (a === "--adapter") flags.adapter = argv[++i];
+    else if (a === "--frontend") flags.frontend = argv[++i];
     else if (a === "--pm") flags.pm = argv[++i];
     else if (a === "--dir") flags.dir = argv[++i];
     else if (a === "--origin") flags.origin = argv[++i];
@@ -1242,6 +1363,7 @@ Arguments:
 
 Options:
   --adapter <id>      deployment adapter \u2014 astrale (managed, default) | cloudflare
+  --frontend <id>     react (default) | custom | none
   --instance <slug>   target instance for managed deploys (astrale adapter)
   --pm <pm>           pnpm | npm | yarn | bun   (default: detected, else pnpm)
   --dir <path>        target directory   (default: ./<slug>)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-astrale-domain",
-  "version": "0.2.13",
+  "version": "0.3.0-beta.10",
   "description": "Scaffold a standalone Astrale domain — npm create astrale-domain",
   "keywords": [
     "astrale",
@@ -14,13 +14,16 @@
     "create-astrale-domain": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "template",
+    "!template/node_modules",
+    "!template/pnpm-lock.yaml"
   ],
   "type": "module",
   "dependencies": {
     "@clack/prompts": "^0.11.0",
-    "@astrale-os/adapter-astrale": "^0.4.1",
-    "@astrale-os/adapter-cloudflare": "^0.4.10"
+    "@astrale-os/adapter-astrale": "^0.5.0-beta.10",
+    "@astrale-os/adapter-cloudflare": "^0.5.0-beta.17"
   },
   "devDependencies": {
     "@astrale-os/ox": ">=0.1.0 <1.0.0",
@@ -30,7 +33,8 @@
     "oxfmt": "0.52.0",
     "oxlint": "latest",
     "typescript": "~6.0.1-rc",
-    "vitest": "^3.0.0"
+    "vitest": "^3.0.0",
+    "@astrale-os/sdk": "^0.5.0-beta.14"
   },
   "engines": {
     "node": ">=22"
@@ -39,6 +43,7 @@
     "build": "node scripts/build.mjs",
     "typecheck": "tsgo --noEmit",
     "test": "vitest run",
+    "test:generated": "node scripts/verify-generated.mjs",
     "lint": "oxlint .",
     "format": "pnpm exec oxfmt --write ."
   }

package/template/.env.example

@@ -0,0 +1,9 @@
+# Secrets for an env live in `.env.<env>` (e.g. .env.dev, .env.prod), pointed at
+# by `secrets:` in astrale.config.ts. The ENTIRE file is treated as secrets:
+# injected into the local runtime in dev, pushed to the Worker secret store in
+# prod. These files are gitignored — copy this to `.env.dev` and fill in.
+#
+# Add one line per secret required by an Integration. Declare the corresponding
+# binding on `ApplicationEnvironment` in `implementation.ts`. For example:
+#
+# EXAMPLE_API_KEY=sk-...

package/template/.gitignore.template

@@ -0,0 +1,17 @@
+# Deps
+node_modules/
+
+# Generated plumbing (worker entry, wrangler config, identity, spec)
+.astrale/
+.domain-studio/.cache/
+
+# Worker dev + build artifacts
+.dev.vars
+.wrangler/
+.dist/
+dist/
+
+# Secrets — every .env.<env> is gitignored; .env.example is the only one tracked
+.env
+.env.*
+!.env.example

package/template/.variants/custom/README.md

@@ -0,0 +1,20 @@
+# Astrale Domain
+
+This project uses the framework-neutral frontend escape hatch. `views/routes.ts` binds declared
+Views to a `frontendArtifact`; `vite.config.ts` owns the ordinary Vite root you can replace with any
+framework; `ui/` owns presentation assets. The starter route uses `handshake: 'none'`, so it mounts
+as a plain hosted app. Change that route to `handshake: 'shell'` only after your browser entrypoint
+boots the Shell protocol.
+
+```text
+schema/             public Domain contract, including View declarations
+implementation.ts   schema, callable handlers, and frontend composition
+views/routes.ts      framework-neutral artifact and routes
+views/app/           fully author-owned browser application
+ui/                  presentation tokens and styles
+tests/               cross-layer executable journeys
+```
+
+Run `pnpm dev` for local delivery and `pnpm build` to build both the Worker and browser assets.
+Domain projects intentionally own no `.spec` trees and import authoring contracts only through
+semantic `@astrale-os/sdk/*` subpaths.

package/template/.variants/custom/implementation.ts

@@ -0,0 +1,14 @@
+import { defineDomain, type DomainHandlers } from '@astrale-os/sdk'
+
+import { schema } from '#schema'
+import { frontend } from '#views'
+
+export interface ApplicationEnvironment {}
+
+const handlers = {
+  functions: {},
+  classes: {},
+  interfaces: {},
+} satisfies DomainHandlers<typeof schema, ApplicationEnvironment>
+
+export const domain = defineDomain({ schema, handlers, frontend })

package/template/.variants/custom/schema/application/index.ts

@@ -0,0 +1,10 @@
+import { defineSchema, view } from '@astrale-os/sdk/schema'
+
+export const schema = defineSchema('astrale-domain.example.dev', {
+  interfaces: {},
+  classes: {},
+  functions: {},
+  views: {
+    application: view({ target: 'domain' }),
+  },
+})

package/template/.variants/custom/ui/application/index.ts

@@ -0,0 +1,2 @@
+/** Framework-neutral presentation tokens and styles for the application. */
+export const applicationTheme = Object.freeze({ accent: '#e3b866' })

package/template/.variants/custom/ui/application/styles.css

@@ -0,0 +1,27 @@
+:root {
+  color: #f5f3ed;
+  background: #171714;
+  font-family: Inter, ui-sans-serif, system-ui, sans-serif;
+}
+
+body {
+  box-sizing: border-box;
+  display: grid;
+  min-height: 100vh;
+  align-content: center;
+  max-width: 64rem;
+  padding: 4rem;
+  margin: 0 auto;
+}
+
+h1 {
+  margin: 0;
+  font-size: clamp(3rem, 9vw, 7rem);
+  line-height: 0.92;
+}
+
+.application-eyebrow {
+  color: #e3b866;
+  font-family: ui-monospace, monospace;
+  text-transform: uppercase;
+}

package/template/.variants/custom/ui/application/styles.d.ts

@@ -0,0 +1 @@
+declare module '*.css' {}

package/template/.variants/custom/ui/index.ts

@@ -0,0 +1 @@
+export { applicationTheme } from './application/index.js'

package/template/.variants/custom/views/app/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.0" />
+    <title>Astrale Domain</title>
+  </head>
+  <body>
+    <main id="application">Loading…</main>
+    <script type="module" src="/main.ts"></script>
+  </body>
+</html>

package/template/.variants/custom/views/app/main.ts

@@ -0,0 +1,10 @@
+import '../../ui/application/styles.css'
+
+const application = document.querySelector<HTMLElement>('#application')
+if (application === null) throw new Error('Custom frontend root #application is missing.')
+
+application.innerHTML = `
+  <p class="application-eyebrow">Custom frontend</p>
+  <h1>Ready to build.</h1>
+  <p>Replace views/app with any framework while preserving views/application/routes.ts.</p>
+`

package/template/.variants/custom/views/application/__tests__/routes.test.ts

@@ -0,0 +1,7 @@
+import { frontend } from '../routes.js'
+
+describe('application View routes', () => {
+  it('owns the generated application entrypoint', () => {
+    expect(frontend.entrypoint).toBe('application')
+  })
+})

package/template/.variants/custom/views/application/routes.ts

@@ -0,0 +1,12 @@
+import { frontendArtifact, viteFrontend } from '@astrale-os/sdk/view'
+
+import { schema } from '#schema'
+
+/** Framework-neutral escape hatch: swap Vite or the browser implementation without changing Views. */
+export const frontend = frontendArtifact({
+  schema,
+  source: viteFrontend(),
+  routes: {
+    application: { handshake: 'none' },
+  },
+})

package/template/.variants/custom/views/index.ts

@@ -0,0 +1 @@
+export { frontend } from './application/routes.js'

package/template/.variants/custom/vite.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  root: 'views/app',
+  build: {
+    outDir: '../../dist/frontend',
+    emptyOutDir: true,
+  },
+})