@ogygie/generate 0.20.0 → 0.22.0

package/dist/cli/fill-command.d.ts

@@ -1,3 +1,4 @@
+import type { CustomViewPlan, ScreenPlan } from "../emit/screen-plan.js";
 import { type HoleLibraryEntry } from "../hole-shape.js";
 import { type FillOptions } from "../fill/fill.js";
 import { type FillModels } from "../fill/model-draw.js";
@@ -12,17 +13,26 @@ export declare function parseFillFlags(argv: readonly string[]): FillCommandFlag
 /** The variables a subprocess that runs a candidate body may see: the path to its tools, its home, nothing that is a secret. */
 export declare function scrubbedEnvironment(env: Readonly<Record<string, string | undefined>>): Record<string, string>;
 export interface HoleTestRunner {
+    /** Runs the tests of `testPath` whose name contains `testName` — a hole id, or the title of a view's example test. */
     (input: {
         projectRoot: string;
         testPath: string;
-        holeId: string;
+        testName: string;
     }): {
         green: boolean;
         lines: string[];
     };
 }
-/** The real runner: the product's Vitest on the hole's own describe, in a process that holds no secret. */
+/** The real runner: the product's Vitest on the named tests, in a process that holds no secret. */
 export declare const vitestHoleRunner: HoleTestRunner;
+/** The title of a custom view's example test, as `<Ecran>.gen.test.tsx` emits it — up to the fragments, which Vitest matches as a prefix. */
+export declare function viewExampleTestName(view: CustomViewPlan): string;
+/** The title of the nominal page in `<Ecran>.previews.gen.test.tsx` — the static render a view candidate must survive (D53). */
+export declare const NOMINAL_PREVIEW_TEST_NAME = "rend l'\u00E9tat nominal";
+/** The exit code of `fill` when the body of a custom view stays unfilled: the operator's, and the `speculate` job labels the pull request. */
+export declare const FILL_NEEDS_OPERATOR_EXIT = 2;
+/** The product's pattern catalogue, when it keeps one where the starter does — the matter a view candidate composes from (D53). */
+export declare const PATTERN_CATALOGUE_PATH = "design/patterns.md";
 export interface FillCommandDeps {
     runner?: HoleTestRunner;
     /** The model key — absent, the command fills from the library alone and says so. */
@@ -36,4 +46,6 @@ export interface FillCommandDeps {
 }
 /** An entry recorded in the library: a new file, or the provenance of an existing one extended. */
 export declare function recordLibraryEntry(libraryDir: string, entry: HoleLibraryEntry): "created" | "extended" | "unchanged";
+/** The context a view candidate is drawn on: the view's hole doc, then the product's pattern catalogue when the repo keeps one (D53). */
+export declare function viewContextOf(projectRoot: string, plan: ScreenPlan, view: CustomViewPlan): string;
 export declare function runFillCommand(project: GenerateProject, featureId: string | undefined, argv: readonly string[], out: CommandOutput, deps?: FillCommandDeps): Promise<number>;

package/dist/cli/generate-screen-command.d.ts

@@ -1,6 +1,15 @@
-import { type ConsumedFeatureInput } from "../emit/screen-plan.js";
+import { type CheckSpecReport } from "../check-spec.js";
+import { type ConsumedFeatureInput, type ScreenPlan } from "../emit/screen-plan.js";
 import type { CommandOutput } from "./output.js";
-import { type GenerateProject, type LoadedConsumedFeature } from "./project.js";
+import { type GenerateProject, type LoadedConsumedFeature, type ScreenTarget } from "./project.js";
 /** The consumed features a plan can be built on: every one with its schemas — with or without a block (D41 precision) — `check` refused the rest. */
 export declare function consumedInputsOf(loaded: ReadonlyMap<string, LoadedConsumedFeature>): ConsumedFeatureInput[];
+export interface ScreenPlanLookup {
+    plan: ScreenPlan;
+    target: ScreenTarget;
+    markdown: string;
+    report: CheckSpecReport;
+}
+/** The plan of a screen as `generate` builds it — the spec checked with its consumed features — or null, the problems printed; `fill` builds on the same plan (D53). */
+export declare function screenPlanOf(project: GenerateProject, featureId: string, out: CommandOutput, command?: string): Promise<ScreenPlanLookup | null>;
 export declare function runGenerateScreenCommand(project: GenerateProject, featureId: string, out: CommandOutput): Promise<number>;

package/dist/cli/run.js

@@ -6,22 +6,16 @@ import {
   MANIFEST_FILE,
   PREVIEWS_FILE_SUFFIX,
   acceptExamplesOf,
-  applyGeneratedContracts,
   applyManifestEntry,
   applySpecContracts,
   boundBehaviorsOf,
-  boundScreenBehaviorsOf,
   buildFeaturePlan,
-  buildScreenPlan,
   checkSpec,
-  contractViolationCodeOf,
   createMessagesClient,
-  emitScreenSpecContracts,
   entryStatusForSpec,
   featureTargetOf,
   formatProblem,
   generateFeature,
-  generateScreen,
   importProductModule,
   intentForManifest,
   intentOfSpec,
@@ -33,9 +27,8 @@ import {
   ogygieError,
   pascalCaseOf,
   runFillCommand,
+  runGenerateScreenCommand,
   schemaModelsLoader,
-  screenBodyDefault,
-  screenBodyPath,
   screenTargetOf,
   scrubbedEnvironment,
   serializeManifest,
@@ -43,7 +36,7 @@ import {
   targetKindOf,
   throwOgygieError,
   verifyGeneration
-} from "../chunk-WVFHAPGC.js";
+} from "../chunk-ASXSTGY5.js";
 
 // src/cli/check-command.ts
 import { existsSync, readFileSync, readdirSync } from "node:fs";
@@ -107,9 +100,9 @@ async function runCheckCommand(project, featureId, out) {
 }
 
 // src/cli/generate-command.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
-import { performance as performance2 } from "node:perf_hooks";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { performance } from "node:perf_hooks";
 
 // ../ogygie-core/src/spec.schema.ts
 import { z } from "zod";
@@ -246,103 +239,6 @@ function compositionOfSpec(content) {
   return COMPOSITION_LINE.exec(section)?.[1] ?? null;
 }
 
-// src/cli/generate-screen-command.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import { dirname, join as join2 } from "node:path";
-import { performance } from "node:perf_hooks";
-function consumedInputsOf(loaded) {
-  const inputs = [];
-  for (const feature of loaded.values()) {
-    if (feature.schemas === null) continue;
-    inputs.push({ featureId: feature.featureId, block: feature.block, schemas: feature.schemas, routes: feature.routes });
-  }
-  return inputs;
-}
-async function runGenerateScreenCommand(project, featureId, out) {
-  const lookup = screenTargetOf(project, featureId);
-  if (!lookup.ok) {
-    out.error(formatProblem(lookup.problem));
-    return 1;
-  }
-  const { target } = lookup;
-  const markdown = readFileSync2(join2(project.root, target.specPath), "utf8");
-  const first = checkSpec({ markdown, specPath: target.specPath, generation: target.generation });
-  if (first.kind !== "screen" || first.screen === null) {
-    for (const problem of first.problems) out.error(formatProblem(problem));
-    out.error(`ogygie generate \u2014 ${target.specPath} n'a pas de bloc # G\xE9n\xE9ration d'\xE9cran lisible (consumes, views, holes).`);
-    return 1;
-  }
-  const loaded = await loadConsumedFeatures(project, first.screen);
-  const report = checkSpec({ markdown, specPath: target.specPath, generation: target.generation, consumed: loaded });
-  if (!report.ok || report.screen === null) {
-    for (const problem of report.problems) out.error(formatProblem(problem));
-    out.error(`ogygie generate \u2014 ${report.problems.length} probl\xE8me(s), rien n'est \xE9crit.`);
-    return 1;
-  }
-  const started = performance.now();
-  const plan = buildScreenPlan({
-    featureId,
-    folder: target.folder,
-    appPath: target.appPath,
-    specPath: target.specPath,
-    block: report.screen,
-    consumed: consumedInputsOf(loaded),
-    front: target.front,
-    guards: target.generation.guards,
-    contractViolationCode: contractViolationCodeOf(target.generation.target),
-    generatorVersion: GENERATOR_VERSION,
-    behaviors: boundScreenBehaviorsOf(report.behaviors)
-  });
-  const existingCustomViews = /* @__PURE__ */ new Map();
-  for (const view of plan.views) {
-    if (view.kind !== "custom") continue;
-    const path = join2(project.root, plan.folder, "views", `${view.componentName}.tsx`);
-    existingCustomViews.set(view.id, existsSync2(path) ? readFileSync2(path, "utf8") : null);
-  }
-  const files = generateScreen(plan, { existingCustomViews });
-  const specContracts = applyGeneratedContracts(markdown, emitScreenSpecContracts(plan), GENERATOR_VERSION);
-  const elapsedMs = Math.round(performance.now() - started);
-  let written = 0;
-  let emitted = 0;
-  for (const file of files) {
-    const absolute = join2(project.root, file.path);
-    const exists = existsSync2(absolute);
-    emitted += file.content.split("\n").length - 1;
-    if (exists && readFileSync2(absolute, "utf8") === file.content) {
-      out.log(`  identique ${file.path}`);
-      continue;
-    }
-    mkdirSync(dirname(absolute), { recursive: true });
-    writeFileSync(absolute, file.content, "utf8");
-    written += 1;
-    out.log(`  ${exists ? "r\xE9\xE9crit  " : "\xE9crit    "} ${file.path}`);
-  }
-  const bodyPath = screenBodyPath(plan);
-  const bodyAbsolute = join2(project.root, bodyPath);
-  if (existsSync2(bodyAbsolute)) {
-    out.log(`  conserv\xE9  ${bodyPath} (corps \xE9crit, jamais compar\xE9 \u2014 D40)`);
-  } else {
-    mkdirSync(dirname(bodyAbsolute), { recursive: true });
-    writeFileSync(bodyAbsolute, screenBodyDefault(plan), "utf8");
-    written += 1;
-    out.log(`  \xE9crit     ${bodyPath} (corps par d\xE9faut, une fois : le v\xF4tre d\xE9sormais \u2014 D40)`);
-  }
-  if (specContracts.outcome === "section-missing") {
-    out.error(`ogygie generate \u2014 ${target.specPath} n'a pas de section # Contrats de donn\xE9es, le bloc g\xE9n\xE9r\xE9 n'a nulle part o\xF9 aller (section obligatoire, verify-specs).`);
-    return 1;
-  }
-  if (specContracts.outcome === "unchanged") {
-    out.log(`  identique ${target.specPath} \u203A bloc @generated de # Contrats de donn\xE9es`);
-  } else {
-    writeFileSync(join2(project.root, target.specPath), specContracts.markdown, "utf8");
-    out.log(`  ${specContracts.outcome === "inserted" ? "ins\xE9r\xE9   " : "r\xE9\xE9crit  "} ${target.specPath} \u203A bloc @generated de # Contrats de donn\xE9es`);
-  }
-  out.log(
-    `ogygie generate \u2014 ${featureId} (\xE9cran) : ${files.length} fichier(s) \xE9mis en ${elapsedMs} ms (${emitted} lignes \xE9mises, bloc de la spec compris), ${written} \xE9crit(s), ${report.tally.derivable} ligne(s) li\xE9e(s), ${report.tally.hole} port\xE9e(s) par un trou ; ${plan.views.filter((view) => view.kind === "custom").length} vue(s) custom sur ${plan.views.length}.`
-  );
-  return 0;
-}
-
 // src/cli/generate-command.ts
 function generatedFeatureIdsOf(project) {
   const kinds = [];
@@ -350,9 +246,9 @@ function generatedFeatureIdsOf(project) {
     if (feature.spec === null) continue;
     const kind = targetKindOf(project, feature.name);
     if (kind === null) continue;
-    const specPath = join3(project.root, feature.spec);
-    if (!existsSync3(specPath)) continue;
-    const first = checkSpec({ markdown: readFileSync3(specPath, "utf8"), specPath: feature.spec, generation: project.generation });
+    const specPath = join2(project.root, feature.spec);
+    if (!existsSync2(specPath)) continue;
+    const first = checkSpec({ markdown: readFileSync2(specPath, "utf8"), specPath: feature.spec, generation: project.generation });
     if (kind === "feature" ? first.block !== null : first.screen !== null) kinds.push({ id: feature.name, kind });
   }
   return [...kinds.filter((entry) => entry.kind === "feature"), ...kinds.filter((entry) => entry.kind === "screen")].map((entry) => entry.id);
@@ -393,7 +289,7 @@ async function runGenerateFeatureCommand(project, featureId, out) {
     return 1;
   }
   const { target } = lookup;
-  const markdown = readFileSync3(join3(project.root, target.specPath), "utf8");
+  const markdown = readFileSync2(join2(project.root, target.specPath), "utf8");
   const firstPass = checkSpec({ markdown, specPath: target.specPath, generation: target.generation });
   if (firstPass.block === null) {
     for (const problem of firstPass.problems) out.error(formatProblem(problem));
@@ -412,9 +308,9 @@ async function runGenerateFeatureCommand(project, featureId, out) {
     out.error(`ogygie generate \u2014 ${report.problems.length} probl\xE8me(s), rien n'est \xE9crit.`);
     return 1;
   }
-  const started = performance2.now();
-  const migrationsDir = join3(project.root, target.appPath, target.generation.target.migrations);
-  const existingMigrations = existsSync3(migrationsDir) ? readdirSync2(migrationsDir) : [];
+  const started = performance.now();
+  const migrationsDir = join2(project.root, target.appPath, target.generation.target.migrations);
+  const existingMigrations = existsSync2(migrationsDir) ? readdirSync2(migrationsDir) : [];
   const plan = buildFeaturePlan({
     featureId,
     folder: target.folder,
@@ -428,33 +324,33 @@ async function runGenerateFeatureCommand(project, featureId, out) {
     generatorVersion: GENERATOR_VERSION,
     behaviors: boundBehaviorsOf(report.behaviors)
   });
-  const logicPath = join3(project.root, target.folder, "logic.ts");
-  const existingLogic = existsSync3(logicPath) ? readFileSync3(logicPath, "utf8") : null;
-  const migrationPath = join3(project.root, plan.migrationPath);
-  const existingMigration = existsSync3(migrationPath) ? readFileSync3(migrationPath, "utf8") : null;
+  const logicPath = join2(project.root, target.folder, "logic.ts");
+  const existingLogic = existsSync2(logicPath) ? readFileSync2(logicPath, "utf8") : null;
+  const migrationPath = join2(project.root, plan.migrationPath);
+  const existingMigration = existsSync2(migrationPath) ? readFileSync2(migrationPath, "utf8") : null;
   const files = generateFeature(plan, { existingLogic, existingMigration, library: loadHolesLibrary() });
   const manifestEntry = applyManifestEntry(project.rawManifest, plan, intentOfSpec(markdown), entryStatusForSpec(parseSpecDocument(markdown).frontmatter?.status));
   const specContracts = applySpecContracts(markdown, plan);
-  const elapsedMs = Math.round(performance2.now() - started);
+  const elapsedMs = Math.round(performance.now() - started);
   let written = 0;
   let emitted = 0;
   for (const file of files) {
-    const absolute = join3(project.root, file.path);
-    const exists = existsSync3(absolute);
+    const absolute = join2(project.root, file.path);
+    const exists = existsSync2(absolute);
     emitted += file.content.split("\n").length - 1;
-    if (exists && readFileSync3(absolute, "utf8") === file.content) {
+    if (exists && readFileSync2(absolute, "utf8") === file.content) {
       out.log(`  identique ${file.path}`);
       continue;
     }
-    mkdirSync2(dirname2(absolute), { recursive: true });
-    writeFileSync2(absolute, file.content, "utf8");
+    mkdirSync(dirname(absolute), { recursive: true });
+    writeFileSync(absolute, file.content, "utf8");
     written += 1;
     out.log(`  ${exists ? "r\xE9\xE9crit  " : "\xE9crit    "} ${file.path}`);
   }
   if (manifestEntry.outcome === "unchanged") {
     out.log(`  identique ${MANIFEST_FILE} \u203A features[${featureId}].routes, dbTables`);
   } else {
-    writeFileSync2(join3(project.root, MANIFEST_FILE), serializeManifest(manifestEntry.manifest), "utf8");
+    writeFileSync(join2(project.root, MANIFEST_FILE), serializeManifest(manifestEntry.manifest), "utf8");
     out.log(
       `  ${manifestEntry.outcome === "created" ? "ajout\xE9e  " : "r\xE9\xE9crite "} ${MANIFEST_FILE} \u203A features[${featureId}] (${plan.operations.length} route(s), ${1 + plan.slots.length + plan.references.filter((reference) => reference.table !== null).length} table(s)${manifestEntry.outcome === "created" ? `, status ${entryStatusForSpec(parseSpecDocument(markdown).frontmatter?.status)} : \xE0 vous de dire delivered` : ""})`
     );
@@ -467,7 +363,7 @@ async function runGenerateFeatureCommand(project, featureId, out) {
     out.log(`  identique ${target.specPath} \u203A bloc @generated de # Contrats de donn\xE9es`);
   } else {
     const addedLines = specContracts.markdown.split("\n").length - markdown.split("\n").length;
-    writeFileSync2(join3(project.root, target.specPath), specContracts.markdown, "utf8");
+    writeFileSync(join2(project.root, target.specPath), specContracts.markdown, "utf8");
     out.log(
       `  ${specContracts.outcome === "inserted" ? "ins\xE9r\xE9   " : "r\xE9\xE9crit  "} ${target.specPath} \u203A bloc @generated de # Contrats de donn\xE9es${specContracts.outcome === "inserted" ? ` (+${addedLines} lignes)` : ""}`
     );
@@ -480,8 +376,8 @@ async function runGenerateFeatureCommand(project, featureId, out) {
 
 // src/cli/preview-command.ts
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3 } from "node:fs";
+import { join as join3 } from "node:path";
 var PREVIEWS_ROOT = "previews";
 function previewsDirOf(featureId, composition) {
   return composition === null ? `${PREVIEWS_ROOT}/${featureId}` : `${PREVIEWS_ROOT}/${featureId}/${composition}`;
@@ -512,29 +408,29 @@ async function runPreviewCommand(project, featureId, out, runner = vitestPreview
     return 0;
   }
   const testPath = `${target.folder}/${pascalCaseOf(featureId)}Screen${PREVIEWS_FILE_SUFFIX}`;
-  if (!existsSync4(join4(project.root, testPath))) {
+  if (!existsSync3(join3(project.root, testPath))) {
     out.error(`ogygie generate preview \u2014 ${testPath} n'existe pas : lancez \`ogygie generate generate ${featureId}\` d'abord, le test des aper\xE7us est \xE9mis avec l'\xE9cran.`);
     return 1;
   }
-  const specAbsolute = join4(project.root, target.specPath);
-  const composition = existsSync4(specAbsolute) ? compositionOfSpec(readFileSync4(specAbsolute, "utf8")) : null;
+  const specAbsolute = join3(project.root, target.specPath);
+  const composition = existsSync3(specAbsolute) ? compositionOfSpec(readFileSync3(specAbsolute, "utf8")) : null;
   const relativeDir = previewsDirOf(featureId, composition);
-  const outDir = join4(project.root, relativeDir);
+  const outDir = join3(project.root, relativeDir);
   const run = runner({ projectRoot: project.root, testPath, outDir });
   for (const line of run.lines) out.log(`  ${line}`);
   if (run.code !== 0) {
     out.error(`ogygie generate preview \u2014 le rendu des aper\xE7us de ${featureId} a \xE9chou\xE9 (code ${run.code}) : rien n'est publi\xE9 tant qu'un \xE9tat ne rend pas.`);
     return run.code;
   }
-  const pages = existsSync4(outDir) ? readdirSync3(outDir).filter((name) => name.endsWith(".html")).sort() : [];
+  const pages = existsSync3(outDir) ? readdirSync3(outDir).filter((name) => name.endsWith(".html")).sort() : [];
   out.log(`ogygie generate preview \u2014 ${featureId} : ${pages.length} page(s) dans ${relativeDir}/ (${pages.map((name) => name.replace(/\.html$/u, "")).join(", ")})${composition === null ? "" : ` \u2014 composition ${composition}`}.`);
   return pages.length === 0 ? 1 : 0;
 }
 
 // src/cli/schemas-command.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
+import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/schemas/draft.ts
@@ -753,9 +649,9 @@ function featureFolderFor(project, featureId) {
   return `${common}/${featureId}`;
 }
 function availableGateScripts(projectRoot) {
-  const path = join5(projectRoot, "package.json");
-  if (!existsSync5(path)) return [];
-  const scripts = JSON.parse(readFileSync5(path, "utf8")).scripts ?? {};
+  const path = join4(projectRoot, "package.json");
+  if (!existsSync4(path)) return [];
+  const scripts = JSON.parse(readFileSync4(path, "utf8")).scripts ?? {};
   return SCHEMAS_GATE_SCRIPTS.filter((script) => script in scripts);
 }
 async function runSchemasCommand(project, featureId, argv, out, deps = {}) {
@@ -765,8 +661,8 @@ async function runSchemasCommand(project, featureId, argv, out, deps = {}) {
   }
   const onMap = project.manifest.features.find((feature) => feature.name === featureId);
   const specPath = onMap?.spec ?? `${project.specsFolder.replace(/\/+$/u, "")}/${featureId}.spec.md`;
-  const specAbsolute = join5(project.root, specPath);
-  if (!existsSync5(specAbsolute)) {
+  const specAbsolute = join4(project.root, specPath);
+  if (!existsSync4(specAbsolute)) {
     out.error(formatProblem(ogygieError({ code: "OGYGIE_GENERATE_PROJECT_INVALID", message: `No spec carries the feature "${featureId}".`, file: specPath, cause: `${specPath} does not exist`, suggestedFix: "Write the spec first: a schemas module derives from a spec, never the reverse." })));
     return 1;
   }
@@ -774,7 +670,7 @@ async function runSchemasCommand(project, featureId, argv, out, deps = {}) {
     out.error(formatProblem(ogygieError({ code: "OGYGIE_GENERATE_PROJECT_INVALID", message: `The feature "${featureId}" cannot be generated from this map.`, file: MANIFEST_FILE, cause: project.apiApp === void 0 ? "apps[] has no entry with type=api" : "the manifest declares no generation block", suggestedFix: "Declare the api app and the `generation` block in the manifest." })));
     return 1;
   }
-  const markdown = readFileSync5(specAbsolute, "utf8");
+  const markdown = readFileSync4(specAbsolute, "utf8");
   const first = checkSpec({ markdown, specPath, generation: project.generation });
   if (first.kind !== "feature" || first.block === null) {
     out.log(`ogygie generate schemas \u2014 ${specPath} ${first.kind === "screen" ? "est un \xE9cran : ses contrats sont ceux des features qu'il consomme" : "n'a pas de bloc # G\xE9n\xE9ration de feature"}, rien \xE0 \xE9crire.`);
@@ -783,8 +679,8 @@ async function runSchemasCommand(project, featureId, argv, out, deps = {}) {
   const block = first.block;
   const folder = onMap === void 0 ? `${project.apiApp.path}/${featureFolderFor(project, featureId)}` : `${project.apiApp.path}/${onMap.folder}`;
   const modulePath = `${folder}/${block.contracts.module.replace(/^\.\//u, "")}`;
-  const moduleAbsolute = join5(project.root, modulePath);
-  if (existsSync5(moduleAbsolute)) {
+  const moduleAbsolute = join4(project.root, modulePath);
+  if (existsSync4(moduleAbsolute)) {
     out.log(`ogygie generate schemas \u2014 ${modulePath} existe : il appartient au repo, jamais r\xE9g\xE9n\xE9r\xE9 (D52).`);
     return 0;
   }
@@ -810,8 +706,8 @@ async function runSchemasCommand(project, featureId, argv, out, deps = {}) {
       return { source: extractModuleSource(answer.text), model: answer.model, usage: answer.usage };
     },
     async judge(source, attempt) {
-      mkdirSync3(dirname3(moduleAbsolute), { recursive: true });
-      writeFileSync3(moduleAbsolute, source, "utf8");
+      mkdirSync2(dirname2(moduleAbsolute), { recursive: true });
+      writeFileSync2(moduleAbsolute, source, "utf8");
       let moduleExports;
       try {
         moduleExports = await importProductModule(`${pathToFileURL(moduleAbsolute).href}?attempt=${attempt}`);
@@ -872,7 +768,7 @@ ${rows.join("\n")}
     raw["features"] = features;
     const status = entryStatusForSpec(parseSpecDocument(markdown).frontmatter?.status);
     features.push({ name: featureId, intent: intentForManifest(intentOfSpec(markdown), specPath), folder: featureFolderFor(project, featureId), spec: specPath, routes: [], dbTables: [], dependsOn: [], status });
-    writeFileSync3(join5(project.root, MANIFEST_FILE), serializeManifest(raw), "utf8");
+    writeFileSync2(join4(project.root, MANIFEST_FILE), serializeManifest(raw), "utf8");
     out.log(`  ajout\xE9e  ${MANIFEST_FILE} \u203A features[${featureId}] (routes et tables viendront de \`generate\`, status ${status}${status === "skeleton" ? " tant que la spec est draft" : ""})`);
   }
   out.log(`ogygie generate schemas \u2014 ${featureId} : module \xE9crit en ${result.attempts} tentative(s) par ${result.model ?? "?"}, ${result.usage.length} appel(s) de mod\xE8le (${totalInput} jetons d'entr\xE9e, ${totalOutput} de sortie) ; commit\xE9 une fois, jamais r\xE9g\xE9n\xE9r\xE9 (D52).`);
@@ -880,11 +776,11 @@ ${rows.join("\n")}
 }
 
 // src/cli/verify-command.ts
-import { performance as performance3 } from "node:perf_hooks";
+import { performance as performance2 } from "node:perf_hooks";
 
 // ../ogygie-core/src/repo-adapter.ts
 import { readFile as readFileFromDisk, readdir, realpath, stat } from "node:fs/promises";
-import { isAbsolute, join as join6, resolve, sep } from "node:path";
+import { isAbsolute, join as join5, resolve, sep } from "node:path";
 import { z as z2 } from "zod";
 var RepoFileEntrySchema = z2.object({
   /** Path relative to the LISTED directory, "/" separated, never absolute. */
@@ -946,16 +842,16 @@ async function listFilesRecursively(absoluteDir, prefix) {
     const relativePath = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) {
       if (isSkippedDirectory(entry.name)) continue;
-      files.push(...await listFilesRecursively(join6(absoluteDir, entry.name), relativePath));
+      files.push(...await listFilesRecursively(join5(absoluteDir, entry.name), relativePath));
     } else if (entry.isFile()) {
-      const stats = await stat(join6(absoluteDir, entry.name));
+      const stats = await stat(join5(absoluteDir, entry.name));
       files.push({ path: relativePath, sizeBytes: stats.size });
     }
   }
   return files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
 }
 async function resolveGitDirs(rootDir) {
-  const dotGit = join6(rootDir, ".git");
+  const dotGit = join5(rootDir, ".git");
   let gitDir;
   try {
     const stats = await stat(dotGit);
@@ -971,7 +867,7 @@ async function resolveGitDirs(rootDir) {
     return null;
   }
   try {
-    const commonPointer = (await readFileFromDisk(join6(gitDir, "commondir"), "utf8")).trim();
+    const commonPointer = (await readFileFromDisk(join5(gitDir, "commondir"), "utf8")).trim();
     return { gitDir, commonDir: isAbsolute(commonPointer) ? commonPointer : resolve(gitDir, commonPointer) };
   } catch {
     return { gitDir, commonDir: gitDir };
@@ -980,13 +876,13 @@ async function resolveGitDirs(rootDir) {
 async function readRefSha(dirs, refName) {
   for (const base of [dirs.gitDir, dirs.commonDir]) {
     try {
-      const sha = (await readFileFromDisk(join6(base, refName), "utf8")).trim();
+      const sha = (await readFileFromDisk(join5(base, refName), "utf8")).trim();
       if (sha !== "") return sha;
     } catch {
     }
   }
   try {
-    const packed = await readFileFromDisk(join6(dirs.commonDir, "packed-refs"), "utf8");
+    const packed = await readFileFromDisk(join5(dirs.commonDir, "packed-refs"), "utf8");
     for (const line of packed.split("\n")) {
       if (line.startsWith("#") || line.startsWith("^")) continue;
       const [sha, name] = line.trim().split(" ");
@@ -1034,7 +930,7 @@ function createFilesystemRepoAdapter(rootDir) {
       if (dirs === null) return null;
       let head;
       try {
-        head = (await readFileFromDisk(join6(dirs.gitDir, "HEAD"), "utf8")).trim();
+        head = (await readFileFromDisk(join5(dirs.gitDir, "HEAD"), "utf8")).trim();
       } catch {
         return null;
       }
@@ -1046,7 +942,7 @@ function createFilesystemRepoAdapter(rootDir) {
 
 // src/cli/verify-command.ts
 async function runVerifyCommand(project, out) {
-  const started = performance3.now();
+  const started = performance2.now();
   const report = await verifyGeneration({
     repo: createFilesystemRepoAdapter(project.root),
     specsFolder: project.specsFolder,
@@ -1059,7 +955,7 @@ async function runVerifyCommand(project, out) {
     library: loadHolesLibrary(),
     loadConsumed: (block) => loadConsumedFeatures(project, block)
   });
-  const elapsedMs = Math.round(performance3.now() - started);
+  const elapsedMs = Math.round(performance2.now() - started);
   if (!report.ok) {
     for (const problem of report.problems) out.error(formatProblem(problem));
     out.error(`

package/dist/emit/screen/views.d.ts

@@ -7,4 +7,6 @@ export declare function customViewPropsLines(view: CustomViewPlan): string[];
 export declare function customViewSignature(view: CustomViewPlan): string;
 /** The imports a custom view's body needs — written between `// @hole-imports` markers, kept verbatim at regeneration: a body composes patterns and hooks the generator cannot foresee (astorg-ai-pdlc, lot 4 M3). */
 export declare function customImportsLines(view: CustomViewPlan, existing: string | null): string[];
+/** The visible placeholder of a view nobody wrote yet — what `fill` looks for, and puts back when every candidate is red (D53). */
+export declare function customViewPlaceholderLine(holeId: string): string;
 export declare function emitCustomView(plan: ScreenPlan, view: CustomViewPlan, existing: string | null): string;

package/dist/fill/body.d.ts

@@ -22,5 +22,5 @@ export interface BodyBan {
     rule: string;
 }
 export declare const BODY_BANS: readonly BodyBan[];
-/** The rules a body breaks — empty when it may be tested. */
-export declare function forbiddenInBody(body: string): string[];
+/** The rules a body breaks — empty when it may be tested; a view hands its own bans (fill/view.ts). */
+export declare function forbiddenInBody(body: string, bans?: readonly BodyBan[]): string[];

package/dist/fill/fill.d.ts

@@ -9,6 +9,13 @@
  * proven in memory and the real effects (vitest in a subprocess, the Messages
  * client of the core) stay in the command.
  *
+ * The decision is the same for the two kinds of hole the framework has — a
+ * logic hole of D23 in `logic.ts`, and the body of a custom view of D53 in
+ * `views/<Vue>.tsx` — and what differs between them is a set of RULES handed
+ * with the input: what an unfilled body looks like, what a candidate may not
+ * carry, what the library offers for this hole, and how a retained body is
+ * recorded. `logicHoleRules` is the first set; `fill/view.ts` the second.
+ *
  * The threshold of D24 is counted, not enforced: a feature whose holes reach
  * escalation more than one in ten is said to have holes too big for a model —
  * the spec splits them, nobody raises a model.
@@ -53,14 +60,28 @@ export interface FillDeps {
     repo: string;
     log(line: string): void;
 }
+/** What distinguishes one kind of hole from another under the same decision (D24). */
+export interface HoleFillRules {
+    /** Whether a body is still the generator's — `todo(...)` for a logic hole, the placeholder for a view. */
+    isUnfilled(body: string): boolean;
+    /** The rules a candidate breaks before any test — empty when it may be tested. */
+    bans(body: string): string[];
+    /** What the library offers for this hole, in order — the same signature first, then the same shape — at most five. */
+    libraryCandidates(): Candidate[];
+    /** The entry a retained body makes, with its provenance. */
+    libraryEntryOf(body: string, provenance: HoleProvenance): HoleLibraryEntry;
+}
+/** The rules of a logic hole of D23: `todo` is unfilled, the bans of a pure body, the library by signature then by shape with the template instantiated. */
+export declare function logicHoleRules(hole: HolePlan, plan: FeaturePlan, library: readonly HoleLibraryEntry[]): HoleFillRules;
 export interface HoleFillInput {
-    hole: HolePlan;
-    plan: FeaturePlan;
+    holeId: string;
+    /** The feature (or screen) the hole belongs to — the provenance names it. */
+    featureId: string;
     /** `holes/<id>.gen.md`, the one context a model gets. */
     context: string;
-    /** What logic.ts holds for this hole now. */
+    /** What the file holds for this hole now. */
     currentBody: string;
-    library: readonly HoleLibraryEntry[];
+    rules: HoleFillRules;
 }
 export interface HoleFillResult {
     holeId: string;
@@ -78,7 +99,7 @@ export interface HoleFillResult {
     /** The runner's last lines when nothing was green — what a human reads first. */
     lastRun: string[];
 }
-/** Fills ONE hole along D24's order; the body ends written (green) or back to `todo`. */
+/** Fills ONE hole along D24's order; the body ends written (green) or back to the generator's. */
 export declare function fillHole(input: HoleFillInput, deps: FillDeps, options?: FillOptions): Promise<HoleFillResult>;
 export interface FeatureFillSummary {
     featureId: string;
@@ -93,5 +114,5 @@ export interface FeatureFillSummary {
         model: string;
     }[];
 }
-/** Fills every `todo` hole of a feature, one after the other (one logic.ts, one test file). */
+/** Fills every unfilled hole of a feature, one after the other (one file written at a time, one test file). */
 export declare function fillFeature(inputs: readonly HoleFillInput[], deps: FillDeps, options?: FillOptions): Promise<FeatureFillSummary>;

package/dist/fill/model-draw.d.ts

@@ -5,7 +5,9 @@
  * package's single configuration (`models: { spec, escalate, draw }`), with
  * D24's defaults, overridable by the command's flags; `draw` may name a local
  * Ollama model behind an OpenAI-compatible base, which is the operator's
- * call, not this module's.
+ * call, not this module's. Two kinds of hole, two sets of instructions and
+ * two extractions: the body of a logic hole (D23), the imports and body of a
+ * custom view (D53, `fill/view.ts`).
  */
 import type { ModelClient } from "@ogygie/core/model";
 import type { Candidate } from "./fill.js";
@@ -18,8 +20,18 @@ export interface FillModels {
 export declare const DEFAULT_FILL_MODELS: FillModels;
 /** The stable instructions — cached by the model side; the hole's context is the user turn. */
 export declare const HOLE_SYSTEM_PROMPT: string;
+/** The instructions for the body of a custom view (D53): the same contract-only diet, a closed catalogue, the tokens. */
+export declare const VIEW_SYSTEM_PROMPT: string;
 export interface ModelDrawer {
     draw(context: string, n: number, round: number): Promise<Candidate[]>;
     escalate(context: string): Promise<Candidate>;
 }
-export declare function createModelDrawer(client: ModelClient, models?: FillModels): ModelDrawer;
+export interface ModelDrawerOptions {
+    /** The stable instructions of this kind of hole — a logic body by default. */
+    system?: string;
+    /** How a candidate is read out of an answer — a logic body by default. */
+    extract?: (answer: string) => string;
+}
+/** The drawer of a logic hole's body (D23), or of a custom view's body when given `VIEW_DRAWER_OPTIONS` (D53). */
+export declare const VIEW_DRAWER_OPTIONS: ModelDrawerOptions;
+export declare function createModelDrawer(client: ModelClient, models?: FillModels, options?: ModelDrawerOptions): ModelDrawer;