@fougere/cli 0.1.0-alpha.0

package/templates/apps/nuxt/app/app.vue

@@ -0,0 +1,25 @@
+<template>
+  <NuxtPage />
+</template>
+
+<style>
+:root { --fg: #1a1a1a; --muted: #6b7280; --border: #e5e7eb; --accent: #2563eb; }
+* { box-sizing: border-box; }
+body { margin: 0; font-family: system-ui, -apple-system, sans-serif; color: var(--fg); line-height: 1.6; }
+.wrap { max-width: 720px; margin: 3rem auto; padding: 0 1.5rem; }
+a { color: var(--accent); text-decoration: none; }
+a:hover { text-decoration: underline; }
+h1 { font-size: 1.6rem; margin-bottom: 0.25rem; }
+code { background: #f3f4f6; padding: 0.1rem 0.35rem; border-radius: 4px; font-size: 0.9em; }
+table { width: 100%; border-collapse: collapse; margin-top: 1rem; }
+th, td { text-align: left; padding: 0.6rem 0.5rem; border-bottom: 1px solid var(--border); }
+th { font-size: 0.72rem; text-transform: uppercase; letter-spacing: 0.03em; color: var(--muted); }
+label { display: block; font-size: 0.85rem; margin: 0.9rem 0 0.3rem; color: var(--muted); }
+input, textarea { width: 100%; padding: 0.5rem 0.6rem; border: 1px solid var(--border); border-radius: 6px; font: inherit; }
+button { padding: 0.5rem 0.9rem; border: 0; border-radius: 6px; background: var(--accent); color: #fff; font: inherit; cursor: pointer; }
+button:disabled { opacity: 0.5; cursor: default; }
+.badge { font-size: 0.72rem; padding: 0.15rem 0.55rem; border-radius: 999px; background: #f3f4f6; color: var(--muted); }
+.badge.published { background: #dcfce7; color: #166534; }
+.muted { color: var(--muted); }
+.err { color: #b91c1c; font-size: 0.9rem; }
+</style>

package/templates/apps/nuxt/app/pages/index.vue

@@ -0,0 +1,33 @@
+<script setup lang="ts">
+// The four primitives are auto-imported by @fougere/nuxt — no import line to write.
+// They take an ENTITY, so this page names none: what is composed here is yours, and a
+// scaffold that guessed at an entity shipped a page that could not run.
+//
+//   import Post from '@frond/<your-frond>/entities/Post'
+//   const { items, loading } = await useQuery(Post, 'list')
+//   const { values, errors, submit } = useFormFor(Post)
+//   const { execute } = useCommand(Post, 'publish')
+const { user } = useCurrentUser();
+</script>
+
+<template>
+  <main class="wrap">
+    <h1>🌿 Fougere</h1>
+    <p class="muted">
+      The app boots, the fronds are scanned, the surface is mounted. Write a page against
+      one of your entities — the commented block in this file is the whole API.
+    </p>
+    <p class="muted">Reader: <strong>{{ user?.name ?? 'nobody' }}</strong></p>
+    <p class="muted">What to write, and why: <code>CLAUDE.md</code> at the workspace root.</p>
+  </main>
+</template>
+
+<style>
+:root { --fg: #1a1a1a; --muted: #6b7280; }
+* { box-sizing: border-box; }
+body { margin: 0; font-family: system-ui, -apple-system, sans-serif; color: var(--fg); line-height: 1.6; }
+.wrap { max-width: 720px; margin: 3rem auto; padding: 0 1.5rem; }
+h1 { font-size: 1.6rem; margin-bottom: 0.25rem; }
+code { background: #f3f4f6; padding: 0.1rem 0.35rem; border-radius: 4px; font-size: 0.9em; }
+.muted { color: var(--muted); }
+</style>

package/templates/apps/nuxt/nuxt.config.ts

@@ -0,0 +1,6 @@
+export default defineNuxtConfig({
+  modules: ['@fougere/nuxt'],
+  // Fronds are shared at the workspace root, two levels up from apps/<name>.
+  fougere: { root: '../..' },
+  compatibilityDate: '2026-07-20',
+});

package/templates/apps/nuxt/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "fougere-app",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "nuxt dev",
+    "build": "nuxt build"
+  },
+  "dependencies": {
+    "@fougere/core": "latest",
+    "@fougere/nuxt": "latest",
+    "@fougere/schema": "latest",
+    "@fougere/runtime": "latest",
+    "@fougere/container-fougere": "latest",
+    "better-sqlite3": "^12.8.0",
+    "kysely": "^0.28.17",
+    "nuxt": "^4.5.1"
+  }
+}

package/templates/apps/nuxt/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./.nuxt/tsconfig.json"
+}

package/templates/blog/app/pages/index.vue

@@ -0,0 +1,12 @@
+<template>
+  <main class="wrap">
+    <h1>🌿 blog</h1>
+    <p>A Fougère frond: one entity (<code>Post</code>), its contracts, and a business operation. Everything below is derived from it.</p>
+    <p>
+      <NuxtLink to="/posts">Published</NuxtLink> ·
+      <NuxtLink to="/posts/manage">Drafts &amp; publishing</NuxtLink> ·
+      <NuxtLink to="/posts/new">New draft</NuxtLink>
+    </p>
+    <p class="muted">The loop: create a draft → it stays private → publish it (a judged operation, not a field write) → it appears in the published list, live.</p>
+  </main>
+</template>

package/templates/blog/app/pages/posts/index.vue

@@ -0,0 +1,21 @@
+<script setup lang="ts">
+import Post from '@frond/blog/entities/Post';
+
+interface Card { id: string; title: string; status: string }
+const { items: posts, loading, error } = await useQuery<Card>(Post, 'published');
+</script>
+
+<template>
+  <main class="wrap">
+    <p><NuxtLink to="/">← home</NuxtLink></p>
+    <h1>Published posts</h1>
+    <p v-if="loading" class="muted">Loading…</p>
+    <p v-else-if="error" class="err">{{ error.message }}</p>
+    <p v-else-if="!posts.length" class="muted">
+      Nothing published yet. <NuxtLink to="/posts/manage">Publish a draft →</NuxtLink>
+    </p>
+    <ul v-else>
+      <li v-for="p in posts" :key="p.id">{{ p.title }}</li>
+    </ul>
+  </main>
+</template>

package/templates/blog/app/pages/posts/manage.vue

@@ -0,0 +1,47 @@
+<script setup lang="ts">
+import Post from '@frond/blog/entities/Post';
+
+interface Row { id: string; title: string; status: 'draft' | 'published' }
+const { items: posts, loading } = await useQuery<Row>(Post, 'list');
+const publish = useCommand(Post, 'publish');
+const failed = ref('');
+
+async function doPublish(id: string) {
+  failed.value = '';
+  try {
+    await publish.execute({ params: { id } });
+  } catch (e: any) {
+    failed.value = e?.message ?? 'Publish failed';
+  }
+}
+</script>
+
+<template>
+  <main class="wrap">
+    <p><NuxtLink to="/">← home</NuxtLink></p>
+    <h1>Drafts &amp; publishing</h1>
+    <p><NuxtLink to="/posts/new">+ New draft</NuxtLink></p>
+    <p v-if="failed" class="err">{{ failed }}</p>
+    <p v-if="loading" class="muted">Loading…</p>
+    <p v-else-if="!posts.length" class="muted">
+      No posts yet — <NuxtLink to="/posts/new">create one</NuxtLink>, it starts as a draft.
+    </p>
+    <table v-else>
+      <thead><tr><th>Title</th><th>Status</th><th></th></tr></thead>
+      <tbody>
+        <tr v-for="p in posts" :key="p.id">
+          <td>{{ p.title }}</td>
+          <td><span class="badge" :class="{ published: p.status === 'published' }">{{ p.status }}</span></td>
+          <td style="text-align: right">
+            <button v-if="p.status === 'draft'" :disabled="publish.loading.value" @click="doPublish(p.id)">
+              Publish
+            </button>
+          </td>
+        </tr>
+      </tbody>
+    </table>
+    <p class="muted" style="margin-top: 1rem">
+      Publishing revalidates the list automatically — the badge flips without a reload.
+    </p>
+  </main>
+</template>

package/templates/blog/app/pages/posts/new.vue

@@ -0,0 +1,34 @@
+<script setup lang="ts">
+import Post from '@frond/blog/entities/Post';
+
+const { values, errors, submit, loading, error } = useFormFor(Post);
+
+async function onSubmit() {
+  if (await submit()) navigateTo('/posts/manage');
+}
+</script>
+
+<template>
+  <main class="wrap">
+    <p><NuxtLink to="/posts/manage">← drafts</NuxtLink></p>
+    <h1>New draft</h1>
+    <p class="muted">
+      Created as a <span class="badge">draft</span>. You own the title and body —
+      <code>status</code> is the server's.
+    </p>
+    <form @submit.prevent="onSubmit">
+      <label>Title</label>
+      <input v-model="values.title" placeholder="Post title" autofocus />
+      <p v-if="errors.title" class="err">{{ errors.title }}</p>
+
+      <label>Body</label>
+      <textarea v-model="values.body" rows="8" placeholder="Write your post…"></textarea>
+      <p v-if="errors.body" class="err">{{ errors.body }}</p>
+
+      <p v-if="error" class="err">{{ error.message }}</p>
+      <p style="margin-top: 1rem">
+        <button type="submit" :disabled="loading">Create draft</button>
+      </p>
+    </form>
+  </main>
+</template>

package/templates/blog/fronds/blog/entities/Post.ts

@@ -0,0 +1,12 @@
+import { entity, primary, text, auto, oneOf, readOnly } from '@fougere/schema';
+
+export default class Post extends entity({
+  id: primary(),
+  title: text({ min: 1, max: 200 }),
+  body: text(),
+  createdAt: auto(),
+  // Server-owned: a post is born a draft and flipped by the publish
+  // operation, never by a client writing the field. readOnly closes
+  // the inbound door — the field is projected out, never accepted in.
+  status: readOnly(oneOf('draft', 'published', { default: 'draft' })),
+}) {}

package/templates/blog/fronds/blog/handlers/PostHandler.ts

@@ -0,0 +1,35 @@
+import { Crud, FougereError, ErrorCode } from '@fougere/core';
+import Post from '../entities/Post.js';
+
+// An Output contract — a read projection of the entity, declared once.
+// The Input contract needs no class here: it is the entity's own input
+// projection ('status' is readOnly), which useFormFor(Post) renders.
+export class PostCard extends Post.pick('id', 'title', 'status') {}
+
+// Crud(Post) gives list/create/update/delete for free — the accelerator.
+// 'publish' is the real business contract: a state transition that judges
+// before it realises — an operation, not a field write. The golden path.
+export default class PostHandler extends Crud(Post) {
+  /**
+   * The draft→published transition. Judge: exists, draft only.
+   * Realise: the server flips the owned field.
+   */
+  async publish(id: string): Promise<Post> {
+    const post = await this.orm.findById(id);
+    if (!post) {
+      throw new FougereError({ code: ErrorCode.NOT_FOUND, message: `Post '${id}' not found`, entity: 'post', operation: 'publish' });
+    }
+    if ((post as { status?: string }).status === 'published') {
+      throw new FougereError({ code: ErrorCode.CONFLICT, message: 'Already published', entity: 'post', operation: 'publish' });
+    }
+    return this.orm.update(id, { status: 'published' });
+  }
+
+  /** Only published posts exist for the outside world, projected to the card. */
+  async published(): Promise<PostCard[]> {
+    const all = await this.orm.list();
+    return all
+      .filter((p) => (p as { status?: string }).status === 'published')
+      .map((p) => ({ id: String(p.id), title: String(p.title), status: 'published' })) as PostCard[];
+  }
+}

package/templates/blog/fronds/blog/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@frond/blog",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    "./entities/*.js": "./entities/*.ts",
+    "./entities/*": "./entities/*.ts",
+    "./package.json": "./package.json"
+  }
+}

package/templates/flat/CLAUDE.md

@@ -0,0 +1,65 @@
+# Working in this application
+
+Built with **Fougere**. This file is read by coding agents before they touch anything — it states
+the few facts that change what they should write.
+
+## One declaration, everything derives
+
+A field belongs to its entity and to nowhere else. Adding it there alone produces the SQL column,
+the validation, the input contract, the write and the output shape. Additive storage changes need no
+hand-written migration; renames, removals and type changes still do. No DTO or permitted-params list
+needs to stay in step.
+
+```ts
+// entities/Product.ts — and nothing else
+sku: text({ min: 3, max: 32 }),
+```
+
+Two consequences worth stating, because they are what makes it hold:
+
+- **An input view derives from the entity** — `Order.omit('id', 'status').extend({ items })`, never
+  a parallel entity that repeats the same fields. A field added to the entity is then accepted
+  without touching the view.
+- **A handler writes what the input carries** (`{ ...attributes }`), it does not enumerate its
+  fields — otherwise a new field is judged, then silently not written.
+
+If you are about to write the same constraint in two places, you have missed the derivation.
+
+## A surface is a door, never a logic
+
+Every door goes through the handler **façade**, which is the judge: validation, unknown-key refusal,
+collectors. A resolver or route you wire yourself against the ORM — or worse, against the database —
+is a second door with no judge behind it, and the rules declared in the entities stop applying there.
+
+Before adding a surface, reach for its **projection**:
+
+| surface | the call |
+|---|---|
+| REST | `generateRoutes(app)` then `registerRoutes(router, routes)` — `@fougere/schema-rest` |
+| GraphQL | `registerAll(builder, app)` then `registerGraphQL(router, builder.toSchema())` — `@fougere/schema-graphql` |
+
+Hand-writing the types (`buildSchema`, raw SDL, one Pothos resolver per field) rebuilds what the
+projection already derives, and drops the judge on the way. `registerType` / `registerOperations`
+exist to add what a projection cannot derive — never to replace it.
+
+## Reading data
+
+`EntityOrm`, injected by type, is the only data access:
+
+```
+list(options?)        every row — `options.where` filters, plus paging and sorting
+findById(id)          one row by id
+findBy(criteria)      one row by criteria      — findBy({ email })
+findAllBy(criteria)   every row of a criteria  — findAllBy({ order_id }) IS a one-to-many relation
+create / update / delete
+```
+
+Read a relation with `findAllBy`. Never read a whole table to filter it in memory.
+
+## Checking your work
+
+```bash
+npx tsc -p tsconfig.frond.json    # the compiler — free, immediate, and it catches most of it
+```
+
+Run it. It is the first judge, and the cheapest.

package/templates/flat/_gitignore

@@ -0,0 +1,6 @@
+node_modules
+.nuxt
+.output
+.data
+dist
+*.log

package/templates/flat/app/app.vue

@@ -0,0 +1,25 @@
+<template>
+  <NuxtPage />
+</template>
+
+<style>
+:root { --fg: #1a1a1a; --muted: #6b7280; --border: #e5e7eb; --accent: #2563eb; }
+* { box-sizing: border-box; }
+body { margin: 0; font-family: system-ui, -apple-system, sans-serif; color: var(--fg); line-height: 1.6; }
+.wrap { max-width: 720px; margin: 3rem auto; padding: 0 1.5rem; }
+a { color: var(--accent); text-decoration: none; }
+a:hover { text-decoration: underline; }
+h1 { font-size: 1.6rem; margin-bottom: 0.25rem; }
+code { background: #f3f4f6; padding: 0.1rem 0.35rem; border-radius: 4px; font-size: 0.9em; }
+table { width: 100%; border-collapse: collapse; margin-top: 1rem; }
+th, td { text-align: left; padding: 0.6rem 0.5rem; border-bottom: 1px solid var(--border); }
+th { font-size: 0.72rem; text-transform: uppercase; letter-spacing: 0.03em; color: var(--muted); }
+label { display: block; font-size: 0.85rem; margin: 0.9rem 0 0.3rem; color: var(--muted); }
+input, textarea { width: 100%; padding: 0.5rem 0.6rem; border: 1px solid var(--border); border-radius: 6px; font: inherit; }
+button { padding: 0.5rem 0.9rem; border: 0; border-radius: 6px; background: var(--accent); color: #fff; font: inherit; cursor: pointer; }
+button:disabled { opacity: 0.5; cursor: default; }
+.badge { font-size: 0.72rem; padding: 0.15rem 0.55rem; border-radius: 999px; background: #f3f4f6; color: var(--muted); }
+.badge.published { background: #dcfce7; color: #166534; }
+.muted { color: var(--muted); }
+.err { color: #b91c1c; font-size: 0.9rem; }
+</style>

package/templates/flat/app/pages/index.vue

@@ -0,0 +1,7 @@
+<template>
+  <main class="wrap">
+    <h1>🌿 Fougère</h1>
+    <p>Your project is running.</p>
+    <p class="muted">Edit <code>entities/</code> and <code>handlers/</code> — they are scanned and projected automatically.</p>
+  </main>
+</template>

package/templates/flat/fougere.config.ts

@@ -0,0 +1,7 @@
+import type { FougereConfig } from '@fougere/core';
+
+export default {
+  // File-backed on purpose: your data must survive dev reloads and deploys.
+  // Lives under .data/ (gitignored) — the single writable-state dir.
+  db: { dialect: 'sqlite', path: '.data/app.db' },
+} satisfies FougereConfig;

package/templates/flat/nuxt.config.ts

@@ -0,0 +1,4 @@
+export default defineNuxtConfig({
+  modules: ['@fougere/nuxt'],
+  compatibilityDate: '2026-07-20',
+});

package/templates/flat/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "fougere-app",
+  "private": true,
+  "type": "module",
+  "packageManager": "pnpm@11.20.0",
+  "scripts": {
+    "dev": "nuxt dev",
+    "build": "nuxt build",
+    "typecheck": "tsc -p tsconfig.frond.json"
+  },
+  "dependencies": {
+    "@fougere/core": "latest",
+    "@fougere/nuxt": "latest",
+    "@fougere/schema": "latest",
+    "@fougere/runtime": "latest",
+    "@fougere/container-fougere": "latest",
+    "better-sqlite3": "^12.8.0",
+    "kysely": "^0.28.17",
+    "nuxt": "^4.5.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.15"
+  }
+}

package/templates/flat/pnpm-workspace.yaml

@@ -0,0 +1,6 @@
+packages: []
+
+# pnpm 11 requires native build permissions in the workspace configuration.
+allowBuilds:
+  better-sqlite3: true
+  esbuild: true

package/templates/flat/tsconfig.frond.json

@@ -0,0 +1,25 @@
+{
+  // The domain typechecks on its own, without Nuxt and without `.nuxt/tsconfig.json`.
+  // `include` names the convention directories rather than `["."]`, which would swallow
+  // `app/` and `nuxt.config.ts` — the whole point being that the domain does not need them.
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "lib": ["ESNext"],
+    "types": ["node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": [
+    "entities",
+    "handlers",
+    "presenters",
+    "collectors",
+    "seeds",
+    "services",
+    "repositories"
+  ]
+}

package/templates/flat/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./.nuxt/tsconfig.json"
+}

package/templates/frond/CLAUDE.md

@@ -0,0 +1,65 @@
+# Working in this application
+
+Built with **Fougere**. This file is read by coding agents before they touch anything — it states
+the few facts that change what they should write.
+
+## One declaration, everything derives
+
+A field belongs to its entity and to nowhere else. Adding it there alone produces the SQL column,
+the validation, the input contract, the write and the output shape. Additive storage changes need no
+hand-written migration; renames, removals and type changes still do. No DTO or permitted-params list
+needs to stay in step.
+
+```ts
+// fronds/<frond>/entities/Product.ts — and nothing else
+sku: text({ min: 3, max: 32 }),
+```
+
+Two consequences worth stating, because they are what makes it hold:
+
+- **An input view derives from the entity** — `Order.omit('id', 'status').extend({ items })`, never
+  a parallel entity that repeats the same fields. A field added to the entity is then accepted
+  without touching the view.
+- **A handler writes what the input carries** (`{ ...attributes }`), it does not enumerate its
+  fields — otherwise a new field is judged, then silently not written.
+
+If you are about to write the same constraint in two places, you have missed the derivation.
+
+## A surface is a door, never a logic
+
+Every door goes through the handler **façade**, which is the judge: validation, unknown-key refusal,
+collectors. A resolver or route you wire yourself against the ORM — or worse, against the database —
+is a second door with no judge behind it, and the rules declared in the entities stop applying there.
+
+Before adding a surface, reach for its **projection**:
+
+| surface | the call |
+|---|---|
+| REST | `generateRoutes(app)` then `registerRoutes(router, routes)` — `@fougere/schema-rest` |
+| GraphQL | `registerAll(builder, app)` then `registerGraphQL(router, builder.toSchema())` — `@fougere/schema-graphql` |
+
+Hand-writing the types (`buildSchema`, raw SDL, one Pothos resolver per field) rebuilds what the
+projection already derives, and drops the judge on the way. `registerType` / `registerOperations`
+exist to add what a projection cannot derive — never to replace it.
+
+## Reading data
+
+`EntityOrm`, injected by type, is the only data access:
+
+```
+list(options?)        every row — `options.where` filters, plus paging and sorting
+findById(id)          one row by id
+findBy(criteria)      one row by criteria      — findBy({ email })
+findAllBy(criteria)   every row of a criteria  — findAllBy({ order_id }) IS a one-to-many relation
+create / update / delete
+```
+
+Read a relation with `findAllBy`. Never read a whole table to filter it in memory.
+
+## Checking your work
+
+```bash
+npx tsc -p fronds --noEmit    # the compiler — free, immediate, and it catches most of it
+```
+
+Run it. It is the first judge, and the cheapest.

package/templates/frond/_gitignore

@@ -0,0 +1,4 @@
+node_modules
+.data
+dist
+*.log

package/templates/frond/fougere.config.ts

@@ -0,0 +1,5 @@
+import type { FougereConfig } from '@fougere/core';
+
+export default {
+  db: { dialect: 'sqlite', path: '.data/app.db' },
+} satisfies FougereConfig;

package/templates/frond/fronds/__name__/entities/Post.ts

@@ -0,0 +1,10 @@
+import { entity, primary, text, auto, oneOf, readOnly } from '@fougere/schema';
+
+export default class Post extends entity({
+  id: primary(),
+  title: text({ min: 1, max: 200 }),
+  body: text(),
+  createdAt: auto(),
+  // Server-owned: born a draft, flipped by the publish operation.
+  status: readOnly(oneOf('draft', 'published', { default: 'draft' })),
+}) {}

package/templates/frond/fronds/__name__/handlers/PostHandler.ts

@@ -0,0 +1,26 @@
+import { Crud, FougereError, ErrorCode } from '@fougere/core';
+import Post from '../entities/Post.js';
+
+export class PostCard extends Post.pick('id', 'title', 'status') {}
+
+export default class PostHandler extends Crud(Post) {
+  /** The draft→published transition — an operation, not a field write. */
+  async publish(id: string): Promise<Post> {
+    const post = await this.orm.findById(id);
+    if (!post) {
+      throw new FougereError({ code: ErrorCode.NOT_FOUND, message: `Post '${id}' not found`, entity: 'post', operation: 'publish' });
+    }
+    if ((post as { status?: string }).status === 'published') {
+      throw new FougereError({ code: ErrorCode.CONFLICT, message: 'Already published', entity: 'post', operation: 'publish' });
+    }
+    return this.orm.update(id, { status: 'published' });
+  }
+
+  /** Only published posts, projected to the card. */
+  async published(): Promise<PostCard[]> {
+    const all = await this.orm.list();
+    return all
+      .filter((p) => (p as { status?: string }).status === 'published')
+      .map((p) => ({ id: String(p.id), title: String(p.title), status: 'published' })) as PostCard[];
+  }
+}

package/templates/frond/fronds/__name__/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@frond/__name__",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    "./entities/*.js": "./entities/*.ts",
+    "./entities/*": "./entities/*.ts",
+    "./package.json": "./package.json"
+  }
+}

package/templates/frond/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "fougere-frond",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "serve": "node serve.mjs"
+  },
+  "dependencies": {
+    "@fougere/core": "latest",
+    "@fougere/schema": "latest",
+    "@fougere/runtime": "latest",
+    "@fougere/container-fougere": "latest",
+    "@fougere/transport-http": "latest",
+    "better-sqlite3": "^12.8.0",
+    "kysely": "^0.28.17",
+    "jiti": "^2.4.2"
+  }
+}

package/templates/frond/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+packages:
+  - fronds/*

package/templates/frond/serve.mjs

@@ -0,0 +1,25 @@
+/**
+ * This frond, alone in its own process — the gradient's third freedom.
+ *
+ * An app in another repo consumes it with one line:
+ *   remotes: { <frond>: 'http://127.0.0.1:4000' }
+ * and pulls its contract with:
+ *   fougere sync <frond> --from http://127.0.0.1:4000
+ * Nothing in the frond changes — only where it runs.
+ */
+import { createJiti } from 'jiti';
+import { createLocalRunner, setModuleLoader, Logger } from '@fougere/core';
+import { bootAppFromConfig } from '@fougere/runtime';
+import { serve } from '@fougere/transport-http';
+
+const jiti = createJiti(import.meta.url, { interopDefault: true });
+setModuleLoader((filePath) => jiti.import(filePath));
+
+const log = new Logger('frond-host');
+
+// `topology: false` — this process *is* the frond, it doesn't route back out.
+// Storage comes from fougere.config.ts; this host names no engine.
+const app = await bootAppFromConfig(process.cwd(), { topology: false });
+
+const { port } = await serve(createLocalRunner(app), { port: Number(process.env.PORT ?? 4000) });
+log.info(`frond served — POST http://127.0.0.1:${port}/_fougere/call`);

package/templates/fronds/blank/entities/Item.ts

@@ -0,0 +1,8 @@
+import { entity, primary, text, auto } from '@fougere/schema';
+
+/** Rename it, then declare your fields — this is the whole shape of an entity. */
+export default class Item extends entity({
+  id: primary(),
+  name: text({ min: 1, max: 200 }),
+  createdAt: auto(),
+}) {}