@fougere/cli 0.12.5-alpha.0 → 0.12.6-alpha.0

package/fronds/analysis/handlers/FreezeHandler.ts

@@ -1,183 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { Bundle, lowerFirst, type SchemaBundle, type SchemaView, type SetDiff } from '@fougere/schema';
-import ProjectScan from '../services/ProjectScan.js';
-import { VERSIONS, chainOf } from '../versions.js';
-import type Freeze from '../entities/Freeze.js';
-
-export interface FreezeInspection {
-  version: string;
-  /** The version this one follows, or absent when it is the first. */
-  previous?: string;
-  entities: string[];
-  /** What the step contains — absent when there is nothing before to step from. */
-  step?: SetDiff;
-  /** Per entity, the pairs the calculation refuses to decide. Empty means it was written. */
-  ambiguous: Record<string, { removed: string; added: string }[]>;
-  /** Whether anything reached the disk — false while a question stands. */
-  written: boolean;
-}
-
-/**
- * Freezing a version — the artefact three readers share.
- *
- * A snapshot alone loses the INTENT (a field gone plus a field appeared cannot be told
- * from a rename), and a step alone corrupts in silence. Both are written, and replaying
- * the step over the previous snapshot must reproduce this one — which is what catches a
- * missing step or a hand-edited file.
- *
- * Nothing is written while an ambiguity stands: the only information the code does not
- * hold is what the person who made the change meant, and this is the one place asking
- * for it is justified.
- */
-export default class FreezeHandler {
-  constructor(private projectScan: ProjectScan) {}
-
-  /**
-   * Record this version — or report what stops it, having written nothing.
-   *
-   * One op and not two: it is idempotent while it refuses, so a caller settles the
-   * ambiguities and calls again with `renamed`. Splitting it would let a caller write
-   * a version it never inspected.
-   *
-   * `json` is the presentation's, so it is not part of what this operation receives.
-   */
-  async execute(input: Omit<Freeze, 'json'> & { renamed?: Record<string, Record<string, string>> }): Promise<FreezeInspection> {
-    const fronds = await this.read(input);
-    const version = input.version;
-    const entities = fronds.flatMap(({ bundle }) => Object.keys(bundle.$defs ?? {}));
-    // Two entrances, one map: what the entities declare, and what a caller answered.
-    // The answer wins — it is the later word on a question the declaration left open.
-    const renamed = settled(fronds.map(({ declared }) => declared), input.renamed ?? {});
-
-    // Every frond is inspected before ANY of them writes: a question standing in one
-    // frond must not leave the others recorded, or a second run cuts half a version.
-    const inspected = fronds.map(({ path, bundle, previous }) => ({
-      path,
-      bundle,
-      previous,
-      step: previous
-        ? Bundle.fromDescriptor(previous.bundle).diff(Bundle.fromDescriptor(bundle), { renamed })
-        : undefined,
-    }));
-
-    const ambiguous: FreezeInspection['ambiguous'] = {};
-    for (const { step } of inspected) {
-      for (const [name, answer] of Object.entries(step?.entities ?? {})) {
-        if (answer.ambiguous.length > 0) ambiguous[name] = answer.ambiguous;
-      }
-    }
-    // Nothing on disk while a question stands. The only information the code does not
-    // hold is what the person who made the change meant.
-    if (Object.keys(ambiguous).length > 0) {
-      return { version, previous: previousName(inspected), entities, step: merge(inspected), ambiguous, written: false };
-    }
-
-    for (const { path, bundle, previous, step } of inspected) {
-      await this.record(path, version, bundle);
-      if (!previous || !step) continue;
-      // `previous` is recorded rather than re-derived: the chain is a fact of the moment
-      // this version was cut, and a later sort of directory names is not that fact.
-      await writeFile(
-        join(path, VERSIONS, version, 'from.json'),
-        `${JSON.stringify({ previous: previous.name, renamed, ...step }, null, 2)}\n`,
-      );
-    }
-
-    return { version, previous: previousName(inspected), entities, step: merge(inspected), ambiguous: {}, written: true };
-  }
-
-  private async record(root: string, version: string, bundle: SchemaBundle): Promise<void> {
-    const directory = join(root, VERSIONS, version);
-    await mkdir(directory, { recursive: true });
-    await writeFile(join(directory, 'shape.json'), `${JSON.stringify(bundle, null, 2)}\n`);
-  }
-
-  /**
-   * Today's shapes and the version before them, one entry per frond.
-   *
-   * `Fronds.schemas()` is deliberately flat — a fact heard in one frond is declared in
-   * another — so the per-frond map is built here, where the question IS per frond.
-   */
-  private async read(input: Omit<Freeze, 'json'>) {
-    const scan = await this.projectScan.at(input.root ?? undefined);
-
-    return Promise.all(
-      scan.fronds
-        .filter((frond) => frond.entities.length > 0)
-        .map(async (frond) => ({
-          path: frond.source.path,
-          bundle: Bundle.fromSchemas(
-            Object.fromEntries(frond.entities.map((e) => [e.name, e.entityClass])),
-          ).descriptor,
-          declared: declaredRenames(frond.entities),
-          previous: await previousOf(frond.source.path, input.version),
-        })),
-    );
-  }
-}
-
-type Inspected = { previous?: { name: string }; step?: SetDiff };
-
-/**
- * What the entities state about themselves — `previous` says what a field WAS, while
- * `Bundle.diff` reads old to new, so the pair is turned around here and nowhere else.
- */
-function declaredRenames(
-  entities: readonly { name: string; entityClass: unknown }[],
-): Record<string, Record<string, string>> {
-  const out: Record<string, Record<string, string>> = {};
-  for (const { name, entityClass } of entities) {
-    const previous = (entityClass as SchemaView).previous;
-    // Keyed as `Bundle.fromSchemas` keys `$defs`, which is what `Bundle.diff` reads. Spelling the
-    // convention a second way here is the defect this repo has already recorded twice.
-    const key = lowerFirst(name);
-    if (previous) out[key] = Object.fromEntries(Object.entries(previous).map(([now, was]) => [was, now]));
-  }
-
-  return out;
-}
-
-/** Every source of an answer, folded per entity — later sources win field by field. */
-function settled(
-  sources: readonly Record<string, Record<string, string>>[],
-  answers: Record<string, Record<string, string>>,
-): Record<string, Record<string, string>> {
-  const out: Record<string, Record<string, string>> = {};
-  for (const source of [...sources, answers]) {
-    for (const [entity, pairs] of Object.entries(source)) out[entity] = { ...out[entity], ...pairs };
-  }
-
-  return out;
-}
-
-/** The version every frond steps from. They are cut together, so they agree. */
-function previousName(inspected: readonly Inspected[]): string | undefined {
-  return inspected.find(({ previous }) => previous)?.previous?.name;
-}
-
-/**
- * One report out of several fronds — entity names are unique across a scan, so the
- * union loses nothing. Writing stays per frond; only the telling is gathered.
- */
-function merge(inspected: readonly Inspected[]): SetDiff | undefined {
-  const steps = inspected.map(({ step }) => step).filter((step): step is SetDiff => Boolean(step));
-  if (steps.length === 0) return undefined;
-
-  return {
-    entities: Object.assign({}, ...steps.map((step) => step.entities)),
-    entitiesAdded: steps.flatMap((step) => step.entitiesAdded),
-    entitiesRemoved: steps.flatMap((step) => step.entitiesRemoved),
-  };
-}
-
-/** The version this one steps from: the tip of the chain, the links read rather than sorted. */
-async function previousOf(root: string, version: string): Promise<{ name: string; bundle: SchemaBundle } | undefined> {
-  const chain = (await chainOf(root)).filter((cut) => cut.name !== version);
-  const last = chain.at(-1)?.name;
-  if (!last) return undefined;
-
-  const raw = await readFile(join(root, VERSIONS, last, 'shape.json'), 'utf8').catch(() => undefined);
-
-  return raw ? { name: last, bundle: JSON.parse(raw) as SchemaBundle } : undefined;
-}

package/fronds/analysis/handlers/GraphHandler.ts

@@ -1,38 +0,0 @@
-import {
-  buildGraph, declaredTopologyOf, suggestSplit,
-  type DeclaredTopology, type EntityNode, type DomainCluster,
-} from '@fougere/core';
-import ProjectScan from '../services/ProjectScan.js';
-import { remotesOf } from '@fougere/core/node';
-
-export interface GraphResult {
-  /** How many fronds the scan found — the descriptors themselves hold classes, which no
-   * operation answers: a reader outside this process would receive the husk JSON makes of them. */
-  totalFronds: number;
-  /** Where the fronds run and which reaches which — the same picture, one altitude up. */
-  declared: DeclaredTopology;
-  nodes: Record<string, EntityNode>;
-  clusters: DomainCluster[];
-  totalEntities: number;
-  totalRefs: number;
-}
-
-export default class GraphHandler {
-  constructor(private projectScan: ProjectScan) {}
-
-  /** Report how a workspace's fronds and entities reference each other. */
-  async execute(input: { root?: string; minEntities?: number }): Promise<GraphResult> {
-    const { fronds, config } = await this.projectScan.at(input.root);
-    const nodes = buildGraph(fronds);
-    const clusters = suggestSplit(nodes);
-
-    return {
-      totalFronds: fronds.length,
-      declared: declaredTopologyOf({ fronds, remotes: remotesOf(config) }),
-      nodes: Object.fromEntries(nodes),
-      clusters,
-      totalEntities: nodes.size,
-      totalRefs: [...nodes.values()].reduce((sum, n) => sum + n.refs.length, 0),
-    };
-  }
-}

package/fronds/analysis/handlers/LoadHandler.ts

@@ -1,44 +0,0 @@
-import { loadScript, reachableOps } from '@fougere/testing/load';
-import { writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import ProjectScan from '../services/ProjectScan.js';
-import { remotesOf } from '@fougere/core/node';
-
-export interface LoadScenario {
-  /** Where it was written, or `null` when it was only printed. */
-  file: string | null;
-  facade: string;
-  /** Every operation the scenario calls, in the order it lists them. */
-  operations: string[];
-  script: string;
-}
-
-/**
- * A load scenario, written from what the project serves.
- *
- * Read from the SCAN rather than a boot: an app that boots runs its migrations and plants its
- * seeds, and a command that describes a project has no business writing to its database.
- */
-export default class LoadHandler {
-  constructor(private projectScan: ProjectScan) {}
-
-  /** Generate a k6 scenario covering every operation the default facade answers. */
-  async execute(input: { root?: string; facade?: string; out?: string }): Promise<LoadScenario> {
-    const { root, fronds, config } = await this.projectScan.at(input.root);
-    const facade = input.facade?.trim() || undefined;
-    // The topology statement travels with it: an op that crosses a process is not held to the
-    // same figure as one that never leaves, and `remotes:` is what says which is which.
-    const remotes = remotesOf(config);
-    const script = loadScript({ fronds }, { ...(facade ? { facade } : {}), remotes });
-
-    const file = input.out === undefined ? join(root, 'load.js') : input.out || null;
-    if (file) await writeFile(file, script, 'utf8');
-
-    return {
-      file,
-      facade: facade ?? 'http://127.0.0.1:3000/_fougere/call',
-      operations: reachableOps({ fronds }, {}, remotes).map((one) => one.method),
-      script,
-    };
-  }
-}

package/fronds/analysis/handlers/MigrateHandler.ts

@@ -1,110 +0,0 @@
-import { loadConfig } from '@fougere/core/node';
-import { resolveStorage } from '@fougere/defaults';
-import type { Plan, StepChange } from '@fougere/adapter-sql';
-import type { SetDiff } from '@fougere/schema';
-import ProjectScan from '../services/ProjectScan.js';
-import { chainOf } from '../versions.js';
-import type Migrate from '../entities/Migrate.js';
-
-export interface MigrationPlan {
-  /** Versions whose step was read, oldest first. */
-  chain: string[];
-  changes: StepChange[];
-  refusals: Plan['refusals'];
-  /** The statements actually run — empty unless `apply` was asked for. */
-  ran: string[];
-}
-
-/**
- * Catching the database up with the frozen chain.
- *
- * Every step is replayed in order and what has already happened is SKIPPED, read off the
- * columns themselves rather than a ledger of applied migrations. That is what makes the
- * chain safe to replay whole: nothing here has to know which version the database sits
- * at, and a column renamed by hand is seen rather than contradicted.
- *
- * The additive pass is not repeated here — a boot already creates missing tables and
- * columns. What this adds is the half that touches live data, and only what a human
- * declared at `fougere freeze`.
- */
-export default class MigrateHandler {
-  constructor(private projectScan: ProjectScan) {}
-
-  /**
-   * Realise the frozen steps this database has not caught up with.
-   *
-   * `json` is the presentation's, so it is not part of what this operation receives.
-   */
-  async execute(input: Omit<Migrate, 'json'>): Promise<MigrationPlan> {
-    const scan = await this.projectScan.at(input.root ?? undefined);
-    const perFrond = await Promise.all(scan.fronds.map((frond) => stepsOf(frond.source.path)));
-    const steps = perFrond.flat();
-    if (steps.length === 0) return { chain: [], changes: [], refusals: [], ran: [] };
-
-    const config = await loadConfig(scan.root);
-    // `fougere migrate --root ../app` read that project's config and planned against a
-    // database beside the CLI's own directory — the loudest form of this bug.
-    const storage = resolveStorage(config.db ?? {}, undefined, scan.root);
-    if (!storage.db) {
-      return {
-        chain: versionsOf(steps),
-        changes: [],
-        refusals: [{ entity: '*', field: '*', reason: 'no `db` in fougere.config.ts — nothing to migrate' }],
-        ran: [],
-      };
-    }
-
-    // Resolved from the project rather than named in this package's dependencies:
-    // `@fougere/adapter-sql` declares `better-sqlite3`, so a CLI depending on it installs
-    // 26 MB of native module into every `npm create fougere`. A project that migrates
-    // declares the adapter itself, which is where this resolves from.
-    const { actualState, desiredTables, planStep, collapseChain, applyStep } = await import('@fougere/adapter-sql');
-
-    const tables = desiredTables(scan as never);
-    // Each frond's chain is composed on its own — its versions are its own line — and the
-    // results are gathered by SOURCE, because an engine is what a statement runs against.
-    const composed = collapseChain(perFrond.map((chain) => collapseChain(chain.map(({ step }) => step))));
-    const sourceOf = storage.sourceOf ?? (() => 'db');
-
-    const changes: StepChange[] = [];
-    const refusals: Plan['refusals'] = [];
-    const ran: string[] = [];
-    for (const source of storage.sources?.() ?? ['db']) {
-      const db = (source === 'db' ? storage.db : storage.dbOf?.(source)) as Parameters<typeof actualState>[0];
-      if (!db) continue;
-
-      const mine = onSource(composed, source, sourceOf);
-      if (Object.keys(mine.entities).length === 0) continue;
-
-      const plan = planStep(mine, tables, { actual: await actualState(db) });
-      changes.push(...plan.changes);
-      refusals.push(...plan.refusals);
-      // Held back: a refusal anywhere stops every engine, for the reason it stops every
-      // statement — half a chain is worse across two engines than within one.
-      if (input.apply && refusals.length === 0) ran.push(...(await applyStep(plan, db)));
-    }
-
-    return { chain: versionsOf(steps), changes, refusals, ran: refusals.length > 0 ? [] : ran };
-  }
-}
-
-/** The versions read, oldest first and each named once however many fronds cut it. */
-function versionsOf(steps: readonly { version: string }[]): string[] {
-  return [...new Set(steps.map(({ version }) => version))].sort((a, b) => a.localeCompare(b, 'en', { numeric: true }));
-}
-
-/** The part of a step whose entities live on one engine. */
-function onSource(step: SetDiff, source: string, sourceOf: (entity: string) => string): SetDiff {
-  return {
-    ...step,
-    entities: Object.fromEntries(Object.entries(step.entities).filter(([entity]) => sourceOf(entity) === source)),
-  };
-}
-
-/** Every recorded step, oldest first — the chain composes, so it is replayed whole. */
-async function stepsOf(frondPath: string): Promise<{ version: string; step: SetDiff }[]> {
-  const chain = await chainOf(frondPath);
-
-  // The first version has a shape and no step — there was nothing before it to move from.
-  return chain.flatMap(({ name, step }) => (step ? [{ version: name, step }] : []));
-}

package/fronds/analysis/services/ProjectScan.ts

@@ -1,55 +0,0 @@
-import { type FougereConfig, type ScanResult } from '@fougere/core';
-import { scanProject, frondAliases } from '@fougere/compiler';
-import { nested, resolveConventions } from '@fougere/core';
-import { setModuleLoader, loadConfig } from '@fougere/core/node';
-import { resolve } from 'node:path';
-
-/**
- * Read a target project without booting it — what every analysis command needs first.
- *
- * `graph` and `check` had the same five lines each: resolve the root against the
- * CLI's cwd, install a jiti loader so the scan can import TypeScript sources, scan.
- * Two copies of one gesture, and the second was written by copying the first.
- *
- * Not a boot: `bootApp` runs migrations and seeds, so an analysis command
- * that booted would write to the target's database. The cost is stated rather than
- * hidden, though — the scan IMPORTS the modules it reads, so a frond's top-level
- * code runs. "No application cycle, no database", not "no side effect".
- */
-export default class ProjectScan {
-  // cwd is ambient in a CLI — not a DI service (the container resolves by type).
-  private cwd = process.cwd();
-
-  /** Scan the project at `root`, relative to where the command was invoked. */
-  async at(root?: string): Promise<ScanResult & { root: string; config: FougereConfig }> {
-    const target = resolve(this.cwd, root || '.');
-
-    // The scan reads `.ts` sources; the default loader is a plain `import`, which
-    // cannot. Installed once per call because the loader is module-global — the
-    // CLI's own app was loaded with its own, and this replaces it for the target.
-    const { createJiti } = await import('jiti');
-    const install = (alias?: Record<string, string>): void => {
-      const jiti = createJiti(import.meta.url, { interopDefault: true, ...(alias ? { alias } : {}) });
-      setModuleLoader((filePath) => jiti.import(filePath) as Promise<Record<string, unknown>>);
-    };
-
-    /**
-     * The config is read BEFORE the aliases, because it names the scope they are built
-     * from. Safe because nothing in `fougere.config.ts` may import `@fronds/*` — the one
-     * import that would need the name to read the file that declares it.
-     */
-    install();
-    const config = await loadConfig(target);
-    const conventions = resolveConventions(config.conventions);
-
-    // The scope is the framework's own convention; the loader has to know it, or a frond
-    // naming its neighbour is unreadable to the very tool that checks it.
-    install(await frondAliases(target, conventions));
-
-    const scanned = await scanProject(target, undefined, conventions);
-
-    // A scan reads the disk, and the disk is flat: who inherits from whom is in the config.
-    // Stamped here so every reader of a project gets what a boot would have given it.
-    return { root: target, config, ...scanned, fronds: nested(scanned.fronds, config.fronds) };
-  }
-}

package/fronds/analysis/versions.ts

@@ -1,59 +0,0 @@
-import { readFile, readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { SetDiff } from '@fougere/schema';
-
-/**
- * Where a FROND keeps what its shapes used to be — beside `entities/`, not under a dot.
- * Written by `fougere freeze`, replayed by `fougere migrate`.
- */
-export const VERSIONS = 'versions';
-
-/** One cut version: its name, and the step that reached it — absent on the first. */
-export interface Version {
-  name: string;
-  step?: SetDiff & { previous?: string };
-}
-
-/**
- * The versions a frond has cut, oldest first — read by FOLLOWING each step's `previous`.
- *
- * That link is the fact recorded the day the version was cut. Sorting directory names is
- * a guess about the same fact, and a hotfix cut after a later version orders it wrong.
- */
-export async function chainOf(frondPath: string): Promise<Version[]> {
-  const directory = join(frondPath, VERSIONS);
-  const found = await readdir(directory, { withFileTypes: true }).catch(() => []);
-  const names = found.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  if (names.length === 0) return [];
-
-  const steps = new Map<string, Version['step']>();
-  for (const name of names) {
-    const raw = await readFile(join(directory, name, 'from.json'), 'utf8').catch(() => undefined);
-    steps.set(name, raw ? (JSON.parse(raw) as Version['step']) : undefined);
-  }
-
-  const roots = names.filter((name) => steps.get(name)?.previous === undefined);
-  if (roots.length !== 1) {
-    const said = roots.length === 0 ? 'none starts it' : `${roots.join(', ')} each start one`;
-    throw new Error(`${directory}: a frond's versions are ONE line and ${said}.`);
-  }
-
-  const next = new Map<string, string>();
-  for (const [name, step] of steps) if (step?.previous !== undefined) next.set(step.previous, name);
-
-  const chain: Version[] = [];
-  const seen = new Set<string>();
-  for (let at: string | undefined = roots[0]; at !== undefined && !seen.has(at); at = next.get(at)) {
-    seen.add(at);
-    chain.push({ name: at, step: steps.get(at) });
-  }
-
-  // One check for every way the links fail to be a line: a fork (two versions claiming
-  // the same `previous`), a cycle, or a step naming a version that is not there.
-  const adrift = names.filter((name) => !seen.has(name));
-  if (adrift.length > 0) {
-    throw new Error(`${directory}: ${adrift.join(', ')} follow no version in the chain that starts at ${roots[0]}.`);
-  }
-
-  return chain;
-}

package/fronds/scaffold/entities/BuildFrond.ts

@@ -1,5 +0,0 @@
-import { entity, text } from '@fougere/schema';
-
-export default class BuildFrond extends entity({
-  frond: text({ description: 'Frond name to build (e.g. blog)' }),
-}) {}

package/fronds/scaffold/entities/Completion.ts

@@ -1,5 +0,0 @@
-import { entity, oneOf } from '@fougere/schema';
-
-export default class Completion extends entity({
-  shell: oneOf('zsh', 'bash', { description: 'Shell type (default: auto-detect)' }),
-}) {}

package/fronds/scaffold/entities/New.ts

@@ -1,19 +0,0 @@
-import { entity, text, bool } from "@fougere/schema";
-
-/**
- * `fougere new [name]` — the workspace composer.
- *
- * Guided when it has a TTY and nothing to compose from; stated when `--frond` or
- * `--app` is given, which is the only form a script, a CI job or an agent can drive.
- * `--bare` is the third: the empty shell, nothing composed. `--flat` is the fourth, and
- * it selects a SHAPE rather than a composition: one app that is its own domain.
- */
-export default class New extends entity({
-  name: text({ description: "Workspace name" }),
-  force: bool({ description: "Overwrite existing directory", default: false }),
-  bare: bool({ description: "Skip the guided flow — just the empty shell", default: false }),
-  flat: bool({ description: "One domain: no fronds/ — the app root is the frond", default: false }),
-  local: bool({ description: "Link @fougere/* to this monorepo (dev — installs offline)", default: false }),
-  frond: text({ description: "Fronds to add, no prompt — 'blog' or 'blog:shop', comma-separated", default: "" }),
-  app: text({ description: "Apps to add, no prompt — 'nuxt' or 'nuxt:web', comma-separated", default: "" }),
-}) {}

package/fronds/scaffold/entities/Serve.ts

@@ -1,8 +0,0 @@
-import { entity, text, number, bool, optional } from "@fougere/schema";
-
-/** `fougere serve <frond>` — run one frond alone in its own process (JSON-RPC over HTTP). */
-export default class Serve extends entity({
-  frond: text({ min: 1, description: "Frond to host in its own process" }),
-  port: optional(number({ description: "Port to listen on (default 4100)" })),
-  watch: optional(bool({ description: "Rebuild the app when the frond changes" })),
-}) {}

package/fronds/scaffold/entities/Sync.ts

@@ -1,6 +0,0 @@
-import { entity, text } from '@fougere/schema';
-
-export default class Sync extends entity({
-  frond: text({ description: 'Frond name to sync (e.g. blog)' }),
-  from: text({ description: 'Remote URL (e.g. http://blog-service:3000)' }),
-}) {}

package/fronds/scaffold/handlers/BuildFrondHandler.ts

@@ -1,96 +0,0 @@
-import { execSync } from 'node:child_process';
-import { existsSync, writeFileSync, readFileSync, readdirSync, unlinkSync } from 'node:fs';
-import { join, basename } from 'node:path';
-import { resolveConventions, frondPackage } from '@fougere/core';
-import { loadConfig } from '@fougere/core/node';
-
-export default class BuildFrondHandler {
-  // cwd is ambient in a CLI — not a DI service (the container resolves by type).
-  private cwd = process.cwd();
-
-  /** Build a frond into a standalone deployable package. */
-  async execute(input: { frond: string }): Promise<{ path: string; entities: string[] }> {
-    const conventions = resolveConventions((await loadConfig(this.cwd)).conventions);
-    const frondDir = join(this.cwd, conventions.fronds, input.frond);
-
-    if (!existsSync(frondDir)) {
-      throw new Error(`Frond '${input.frond}' not found at ${frondDir}`);
-    }
-
-    const entitiesDir = join(frondDir, conventions.dirs.entities);
-    if (!existsSync(entitiesDir)) {
-      throw new Error(`No ${conventions.dirs.entities}/ directory in frond '${input.frond}'`);
-    }
-
-    // Discover entity files
-    const entityFiles = readdirSync(entitiesDir)
-      .filter((f) => f.endsWith('.ts') && !f.endsWith('.d.ts'))
-      .sort();
-
-    if (entityFiles.length === 0) {
-      throw new Error(`No .ts files in ${entitiesDir}`);
-    }
-
-    const entityNames = entityFiles.map((f) => basename(f, '.ts'));
-
-    // Generate barrel index.ts
-    const indexLines = entityNames.map(
-      (name) => `export { default as ${name} } from './${conventions.dirs.entities}/${name}.js';`,
-    );
-    writeFileSync(join(frondDir, 'index.ts'), indexLines.join('\n') + '\n');
-
-    // Generate tsconfig.build.json
-    const tsconfig = {
-      compilerOptions: {
-        target: 'ES2022',
-        module: 'Node16',
-        moduleResolution: 'Node16',
-        declaration: true,
-        outDir: './dist',
-        rootDir: '.',
-        strict: true,
-        esModuleInterop: true,
-        skipLibCheck: true,
-      },
-      include: ['index.ts', `${conventions.dirs.entities}/**/*.ts`],
-    };
-
-    const tsconfigPath = join(frondDir, 'tsconfig.build.json');
-    writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2));
-
-    try {
-      execSync('npx tsc -p tsconfig.build.json', { cwd: frondDir, stdio: 'inherit' });
-    } finally {
-      try { unlinkSync(tsconfigPath); } catch { /* ignore */ }
-    }
-
-    // Update package.json
-    const pkgPath = join(frondDir, 'package.json');
-    const pkg = existsSync(pkgPath)
-      ? JSON.parse(readFileSync(pkgPath, 'utf-8'))
-      : { name: frondPackage(input.frond, conventions), version: '0.0.1', type: 'module' };
-
-    pkg.exports = {
-      '.': {
-        types: './dist/index.d.ts',
-        default: './dist/index.js',
-      },
-      [`./${conventions.dirs.entities}/*`]: {
-        types: `./dist/${conventions.dirs.entities}/*.d.ts`,
-        default: `./dist/${conventions.dirs.entities}/*.js`,
-      },
-      './package.json': './package.json',
-    };
-
-    // Only publish dist + package.json
-    pkg.files = ['dist', 'package.json'];
-
-    // Ensure peerDependencies on @fougere/schema
-    pkg.peerDependencies ??= {};
-    pkg.peerDependencies['@fougere/schema'] ??= '*';
-
-    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
-
-    return { path: join(frondDir, 'dist'), entities: entityNames };
-  }
-}