@fougere/cli 0.2.0-alpha.2 → 0.3.0-alpha.0

package/fronds/analysis/handlers/FreezeHandler.ts

@@ -0,0 +1,172 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { describeSet, diffSet, registrationKeyOf, type SchemaBundle, 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, Array<{ 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.
+   */
+  async execute(input: Freeze & { 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 ? diffSet(previous.bundle, 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: Freeze) {
+    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: describeSet(Object.fromEntries(frond.entities.map((e) => [e.name, e.entityClass]))),
+          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
+ * `diff` reads old → new, so the pair is turned around here and nowhere else.
+ */
+function declaredRenames(
+  entities: ReadonlyArray<{ 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 { previous?: Record<string, string> }).previous;
+    // Keyed as `describeSet` keys `$defs`, which is what `diffSet` reads. Spelling the
+    // convention a second way here is the defect this repo has already recorded twice.
+    const key = registrationKeyOf(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: ReadonlyArray<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/MigrateHandler.ts

@@ -0,0 +1,97 @@
+import { loadConfig } from '@fougere/core/node';
+import { resolveStorage } from '@fougere/defaults';
+import { actualState, desiredTables, planStep, collapseChain, applyStep, type Plan, type 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. */
+  async execute(input: Migrate): 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);
+    const storage = resolveStorage(config.db ?? {});
+    if (!storage.db) {
+      return {
+        chain: versionsOf(steps),
+        changes: [],
+        refusals: [{ entity: '*', field: '*', reason: 'no `db` in fougere.config.ts — nothing to migrate' }],
+        ran: [],
+      };
+    }
+
+    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: ReadonlyArray<{ 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<Array<{ 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,4 +1,7 @@
-import { scanProject, frondAliases, setModuleLoader, type ScanResult } from '@fougere/core';
+import { type FougereConfig, type ScanResult } from '@fougere/core';
+import {
+  scanProject, frondAliases, setModuleLoader, loadConfig, resolveConventions,
+} from '@fougere/core/node';
 import { resolve } from 'node:path';
 
 /**
@@ -18,18 +21,31 @@ export default class ProjectScan {
   private cwd = process.cwd();
 
   /** Scan the project at `root`, relative to where the command was invoked. */
-  async at(root?: string): Promise<ScanResult & { root: string }> {
+  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');
-    // `@frond/<name>` 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.
-    const jiti = createJiti(import.meta.url, { interopDefault: true, alias: await frondAliases(target) });
-    setModuleLoader((filePath) => jiti.import(filePath) as Promise<Record<string, unknown>>);
+    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>>);
+    };
 
-    return { root: target, ...(await scanProject(target)) };
+    /**
+     * 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));
+
+    return { root: target, config, ...(await scanProject(target, undefined, conventions)) };
   }
 }

package/fronds/analysis/versions.ts

@@ -0,0 +1,58 @@
+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/Grant.ts

@@ -0,0 +1,6 @@
+import { entity, text } from "@fougere/schema";
+
+/** `fougere grant <frond>` — vouch for one frond, so any receiver admits it. */
+export default class Grant extends entity({
+  frond: text({ min: 1, description: "Frond to vouch for" }),
+}) {}

package/fronds/scaffold/entities/Keys.ts

@@ -0,0 +1,4 @@
+import { entity } from "@fougere/schema";
+
+/** `fougere keys` — create the root this system's grants are signed by. Once. */
+export default class Keys extends entity({}) {}

package/fronds/scaffold/entities/Serve.ts

@@ -1,7 +1,8 @@
-import { entity, text, number, optional } from "@fougere/schema";
+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/handlers/BuildFrondHandler.ts

@@ -1,10 +1,7 @@
 import { execSync } from 'node:child_process';
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync } from 'node:fs';
 import { join, basename } from 'node:path';
-
-function capitalize(s: string): string {
-  return s[0].toUpperCase() + s.slice(1);
-}
+import { loadConfig, resolveConventions, frondPackage } from '@fougere/core/node';
 
 export default class BuildFrondHandler {
   // cwd is ambient in a CLI — not a DI service (the container resolves by type).
@@ -12,15 +9,16 @@ export default class BuildFrondHandler {
 
   /** Build a frond into a standalone deployable package. */
   async execute(input: { name: string }): Promise<{ path: string; entities: string[] }> {
-    const frondDir = join(this.cwd, 'fronds', input.name);
+    const conventions = resolveConventions((await loadConfig(this.cwd)).conventions);
+    const frondDir = join(this.cwd, conventions.fronds, input.name);
 
     if (!existsSync(frondDir)) {
       throw new Error(`Frond '${input.name}' not found at ${frondDir}`);
     }
 
-    const entitiesDir = join(frondDir, 'entities');
+    const entitiesDir = join(frondDir, conventions.dirs.entities);
     if (!existsSync(entitiesDir)) {
-      throw new Error(`No entities/ directory in frond '${input.name}'`);
+      throw new Error(`No ${conventions.dirs.entities}/ directory in frond '${input.name}'`);
     }
 
     // Discover entity files
@@ -36,7 +34,7 @@ export default class BuildFrondHandler {
 
     // Generate barrel index.ts
     const indexLines = entityNames.map(
-      (name) => `export { default as ${name} } from './entities/${name}.js';`,
+      (name) => `export { default as ${name} } from './${conventions.dirs.entities}/${name}.js';`,
     );
     writeFileSync(join(frondDir, 'index.ts'), indexLines.join('\n') + '\n');
 
@@ -53,7 +51,7 @@ export default class BuildFrondHandler {
         esModuleInterop: true,
         skipLibCheck: true,
       },
-      include: ['index.ts', 'entities/**/*.ts'],
+      include: ['index.ts', `${conventions.dirs.entities}/**/*.ts`],
     };
 
     const tsconfigPath = join(frondDir, 'tsconfig.build.json');
@@ -69,16 +67,16 @@ export default class BuildFrondHandler {
     const pkgPath = join(frondDir, 'package.json');
     const pkg = existsSync(pkgPath)
       ? JSON.parse(readFileSync(pkgPath, 'utf-8'))
-      : { name: `@frond/${input.name}`, version: '0.0.1', type: 'module' };
+      : { name: frondPackage(input.name, conventions), version: '0.0.1', type: 'module' };
 
     pkg.exports = {
       '.': {
         types: './dist/index.d.ts',
         default: './dist/index.js',
       },
-      './entities/*': {
-        types: './dist/entities/*.d.ts',
-        default: './dist/entities/*.js',
+      [`./${conventions.dirs.entities}/*`]: {
+        types: `./dist/${conventions.dirs.entities}/*.d.ts`,
+        default: `./dist/${conventions.dirs.entities}/*.js`,
       },
       './package.json': './package.json',
     };

package/fronds/scaffold/handlers/GrantHandler.ts

@@ -0,0 +1,8 @@
+/**
+ * The work lives in app/commands/GrantCommand (it prints secrets). This handler
+ * exists only so the runner registers the `grant` subcommand.
+ */
+export default class GrantHandler {
+  /** Bind a frond's name to a fresh key, signed by the root. */
+  async execute(): Promise<void> {}
+}

package/fronds/scaffold/handlers/KeysHandler.ts

@@ -0,0 +1,8 @@
+/**
+ * The work lives in app/commands/KeysCommand (it writes the root key). This
+ * handler exists only so the runner registers the `keys` subcommand.
+ */
+export default class KeysHandler {
+  /** Create the root key a split deployment's grants are signed by. */
+  async execute(): Promise<void> {}
+}

package/fronds/scaffold/handlers/SyncHandler.ts

@@ -4,7 +4,10 @@ import { entitySourceOf, facadeTypeSourceOf, type SchemaDescriptor } from '@foug
 // The card's shape is declared once, in core, and imported here. A private copy of it
 // lived in this file and went stale the day an op stopped being a bare name: nothing
 // compared the copy to the original, so the drift cost nothing until someone read it.
-import type { IdentityCard } from '@fougere/core';
+import { assertIdentityCard, type IdentityCard } from '@fougere/core';
+import {
+  type Conventions, loadConfig, resolveConventions, frondPackage,
+} from '@fougere/core/node';
 
 function assertSafeName(kind: string, name: string): void {
   if (typeof name !== 'string' || !/^[A-Za-z_$][A-Za-z0-9_$-]*$/.test(name)) {
@@ -67,18 +70,12 @@ function assertEntry(kind: string, frondName: string, entry: { name: string; sch
 }
 
 function identityCardOf(value: unknown): IdentityCard {
-  if (!value || typeof value !== 'object' || !Array.isArray((value as IdentityCard).fronds)) {
-    throw new Error('Remote rpc.discover returned an invalid identity card');
-  }
-  const card = value as IdentityCard;
+  // The card's own shape is judged by the package that declares it — `fronds`, and each
+  // frond's `doors`. What stays here is what only a writer of files needs: a name safe to
+  // become one, and the descriptor a class is generated from.
+  const card = assertIdentityCard(value, 'Remote rpc.discover');
   for (const frond of card.fronds) {
-    if (!frond || typeof frond !== 'object') {
-      throw new Error('Remote rpc.discover returned an invalid frond entry');
-    }
     assertSafeName('frond', frond.name);
-    if (!Array.isArray(frond.doors)) {
-      throw new Error(`Remote frond '${frond.name}' has no valid doors array`);
-    }
     // Absent rather than empty is tolerated: a host older than the fact list says nothing
     // about facts, and refusing it would break sync against every previous version for a
     // feature the consumer may not use.
@@ -129,9 +126,15 @@ export default class SyncHandler {
       throw new Error(`Frond '${input.name}' not found on ${baseUrl}. Available: ${card.fronds.map((f) => f.name).join(', ')}`);
     }
 
+    // The consumer's own convention: a synced frond is laid out like the ones they wrote,
+    // and the export map below is what makes `@fronds/<name>/<dir>/X.js` resolve.
+    const conventions = resolveConventions((await loadConfig(this.cwd)).conventions);
+    const entities = conventions.dirs.entities;
+    const handlers = conventions.dirs.handlers;
+
     const frondDir = join(this.cwd, '.fougere', 'remotes', input.name);
-    const entitiesDir = join(frondDir, 'entities');
-    const handlersDir = join(frondDir, 'handlers');
+    const entitiesDir = join(frondDir, entities);
+    const handlersDir = join(frondDir, handlers);
     mkdirSync(entitiesDir, { recursive: true });
     mkdirSync(handlersDir, { recursive: true });
 
@@ -229,21 +232,21 @@ export default class SyncHandler {
     // One binding carries the value AND the type, because a class is both — the pair of
     // re-exports that stood here was the price of declaring them separately.
     const indexLines = [...generated].flatMap(([name, { row, door }]) => [
-      ...(row ? [`export { default as ${name} } from './entities/${name}.js';`] : []),
-      ...(door ? [`export type { ${name}Handler } from './handlers/${name}Handler.js';`] : []),
+      ...(row ? [`export { default as ${name} } from './${entities}/${name}.js';`] : []),
+      ...(door ? [`export type { ${name}Handler } from './${handlers}/${name}Handler.js';`] : []),
     ]);
     writeFileSync(join(frondDir, 'index.ts'), indexLines.join('\n') + '\n');
 
     // Package.json
     writeFileSync(join(frondDir, 'package.json'), JSON.stringify({
-      name: `@frond/${input.name}`,
+      name: frondPackage(input.name, conventions),
       version: '0.0.0-synced',
       type: 'module',
       fougere: { frond: input.name, synced: true, source: baseUrl },
       exports: {
         '.': './index.ts',
-        './entities/*': './entities/*.ts',
-        './handlers/*': './handlers/*.ts',
+        [`./${entities}/*`]: `./${entities}/*.ts`,
+        [`./${handlers}/*`]: `./${handlers}/*.ts`,
         './package.json': './package.json',
       },
     }, null, 2) + '\n');
@@ -252,14 +255,14 @@ export default class SyncHandler {
     this.updateRemotesRegistry(input.name, baseUrl, frondDir);
 
     // Update tsconfig paths if tsconfig.json exists (non-Nuxt projects)
-    this.updateTsconfigPaths(input.name, frondDir);
+    this.updateTsconfigPaths(input.name, frondDir, conventions);
 
     /**
      * What the host no longer serves stops being importable here.
      *
      * The barrel is rewritten every run, so a dropped entity loses its export on its own
      * — but the FILE stayed, and the generated `package.json` exports `'./entities/*'` as
-     * a wildcard, so `@frond/blog/entities/Ticket.js` kept resolving to a class nothing
+     * a wildcard, so `@fronds/blog/entities/Ticket.js` kept resolving to a class nothing
      * behind it answers for. The consumer compiles, its local judge accepts, and the call
      * comes back NOT_FOUND at the door — or never leaves, because the page dropped the
      * call and kept the type.
@@ -304,8 +307,8 @@ export default class SyncHandler {
     writeFileSync(registryPath, JSON.stringify(registry, null, 2) + '\n');
   }
 
-  /** Add @frond/{name} to tsconfig paths if tsconfig.json exists. */
-  private updateTsconfigPaths(name: string, localPath: string): void {
+  /** Add the frond's scoped name to tsconfig paths if tsconfig.json exists. */
+  private updateTsconfigPaths(name: string, localPath: string, conventions: Conventions): void {
     const tsconfigPath = join(this.cwd, 'tsconfig.json');
     if (!existsSync(tsconfigPath)) return;
 
@@ -320,8 +323,8 @@ export default class SyncHandler {
       tsconfig.compilerOptions.paths ??= {};
 
       const relative = localPath.replace(this.cwd, '.').replace(/\\/g, '/');
-      tsconfig.compilerOptions.paths[`@frond/${name}`] = [`${relative}/index.ts`];
-      tsconfig.compilerOptions.paths[`@frond/${name}/*`] = [`${relative}/*`];
+      tsconfig.compilerOptions.paths[frondPackage(name, conventions)] = [`${relative}/index.ts`];
+      tsconfig.compilerOptions.paths[`${frondPackage(name, conventions)}/*`] = [`${relative}/*`];
 
       writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + '\n');
     } catch { /* tsconfig parse error — skip */ }