@ogygie/generate 0.19.0 → 0.21.0

package/dist/{chunk-WVFHAPGC.js → chunk-ASXSTGY5.js}

@@ -3994,14 +3994,14 @@ function normalizedTypeOf(model) {
   return `${base}${model.nullable ? "?" : ""}`;
 }
 var HoleShapeSchema = z6.strictObject({
-  kind: z6.enum(["validate", "transform", "derive", "project", "view"]),
+  kind: z6.enum(["validate", "transform", "derive", "project", "view", "custom-view"]),
   /** Normalized types of the fields read, by position. */
   reads: z6.array(z6.string()),
   /** Transform only: normalized types of the columns, by position. */
   columns: z6.array(z6.string()),
   /** What the code the hole answers IS for the operation (`none` when the hole never refuses). */
   codeRole: z6.enum(["operation-refusal", "motif-rejection", "none"]),
-  /** `void` for a validate hole, `rows:<columns>` for a transform, the written type for a derive, `output` for a project, `view:<shape>` for a view. */
+  /** `void` for a validate hole, `rows:<columns>` for a transform, the written type for a derive, `output` for a project, `view:<shape>` for a view, `jsx` for the body of a custom view (D53). */
   returns: z6.string()
 });
 var HoleProvenanceSchema = z6.strictObject({
@@ -8928,10 +8928,13 @@ function customImportsLines(view, existing) {
   }
   return [`// @hole-imports ${view.hole.id}`, ...kept, `// @end-hole-imports ${view.hole.id}`];
 }
+function customViewPlaceholderLine(holeId) {
+  return `  return <p data-pattern="HoleUnfilled">{${quote(holeId)}}</p>;`;
+}
 function customBodyLines(view, existing) {
   const known = existing.get(view.hole.id);
   if (known !== void 0 && known.signature === customViewSignature(view) && known.body.trim() !== "") return known.body.split("\n");
-  return [`  return <p data-pattern="HoleUnfilled">{${quote(view.hole.id)}}</p>;`];
+  return [customViewPlaceholderLine(view.hole.id)];
 }
 function emitCustomView(plan, view, existing) {
   const sections = existing === null ? /* @__PURE__ */ new Map() : parseLogicSections(existing);
@@ -8997,7 +9000,8 @@ function emitScreenHoleDoc(plan, view) {
     "",
     "- Le corps, et les imports entre `// @hole-imports` et `// @end-hole-imports` (patterns, hooks de la feature), sont les seules parties du fichier qu'on \xE9crit ; le reste est r\xE9g\xE9n\xE9r\xE9 et compar\xE9.",
     "- Une \xE9criture passe par une action re\xE7ue (`MutationLike.mutate`), jamais par un hook ni une URL.",
-    "- Un placeholder `HoleUnfilled` reste visible tant que le corps n'est pas \xE9crit : le test de la vue est rouge jusque-l\xE0."
+    "- Un placeholder `HoleUnfilled` reste visible tant que le corps n'est pas \xE9crit : le test de la vue est rouge jusque-l\xE0.",
+    "- Un corps tir\xE9 par un mod\xE8le (`ogygie generate fill`) n'importe que depuis `react`, `@lingui/react/macro`, `@ogygie/ui` et ses entr\xE9es, le dossier `patterns/` du produit, une vue voisine ou `../queries.gen` ; ses classes viennent des tokens, jamais d'une valeur arbitraire ni d'une couleur en dur ; il est jug\xE9 par le test d'exemple ci-dessus puis par le rendu statique de l'\xE9tat nominal."
   );
 }
 
@@ -9849,20 +9853,20 @@ async function verifyGeneration(input) {
     const specPath = `${specsFolder}/${entry.path}`;
     const markdown = await input.repo.readFile(specPath);
     const first = checkSpec({ markdown, specPath, guards, generation: input.generation });
-    let report = first;
+    let report2 = first;
     const owner = ownerOf.get(specPath);
     const folder = owner?.folder;
     if (first.kind === "screen" && first.screen !== null && input.loadConsumed !== void 0) {
       const consumed = await input.loadConsumed(first.screen);
-      report = checkSpec({ markdown, specPath, guards, generation: input.generation, consumed });
-      if (report.ok && report.screen !== null && owner !== void 0 && folder !== void 0 && owner.appType === "front" && owner.appPath !== void 0 && input.generation !== null) {
+      report2 = checkSpec({ markdown, specPath, guards, generation: input.generation, consumed });
+      if (report2.ok && report2.screen !== null && owner !== void 0 && folder !== void 0 && owner.appType === "front" && owner.appPath !== void 0 && input.generation !== null) {
         const regenerated = await regenerateScreenAndCompare(input, {
           specPath,
           folder,
           appPath: owner.appPath,
           markdown,
-          block: report.screen,
-          behaviors: report.behaviors,
+          block: report2.screen,
+          behaviors: report2.behaviors,
           consumed,
           generation: input.generation
         });
@@ -9884,15 +9888,15 @@ async function verifyGeneration(input) {
           })
         );
       } else {
-        report = checkSpec({ markdown, specPath, guards, generation: input.generation, schemas });
-        if (report.ok && report.block !== null && input.generation !== null && input.apiAppPath !== void 0 && (input.tenantColumn !== void 0 || input.generation.target.tenancy === "none")) {
+        report2 = checkSpec({ markdown, specPath, guards, generation: input.generation, schemas });
+        if (report2.ok && report2.block !== null && input.generation !== null && input.apiAppPath !== void 0 && (input.tenantColumn !== void 0 || input.generation.target.tenancy === "none")) {
           const regenerated = await regenerateAndCompare(input, {
             specPath,
             folder,
             markdown,
             owner,
-            behaviors: report.behaviors,
-            block: report.block,
+            behaviors: report2.behaviors,
+            block: report2.block,
             schemas,
             generation: input.generation,
             apiAppPath: input.apiAppPath,
@@ -9903,8 +9907,8 @@ async function verifyGeneration(input) {
         }
       }
     }
-    specs.push({ specPath, generated: report.generated, tally: report.tally });
-    problems.push(...report.problems);
+    specs.push({ specPath, generated: report2.generated, tally: report2.tally });
+    problems.push(...report2.problems);
   }
   const generatedFiles = [];
   for (const directory of input.scanDirs) {
@@ -9991,24 +9995,38 @@ var BODY_BANS = [
   { pattern: /\beval\s*\(|\bnew Function\s*\(/u, rule: "aucune \xE9valuation dynamique" },
   { pattern: /\bnew Date\s*\(\s*\)|\bDate\.now\s*\(/u, rule: "l'horloge est un effet d\xE9clar\xE9 (clock), jamais lue \xE0 nu" }
 ];
-function forbiddenInBody(body) {
+function forbiddenInBody(body, bans = BODY_BANS) {
   const code = body.replace(/\/\*[\s\S]*?\*\//gu, "").replace(/(^|[^:])\/\/.*$/gmu, "$1");
-  return BODY_BANS.filter((ban) => ban.pattern.test(code)).map((ban) => ban.rule);
+  return bans.filter((ban) => ban.pattern.test(code)).map((ban) => ban.rule);
 }
 
 // src/fill/fill.ts
 var DEFAULT_FILL_OPTIONS = { candidates: 5, rounds: 2, libraryOnly: false };
-async function tryCandidate(deps, holeId, candidate, result) {
+function logicHoleRules(hole, plan, library) {
+  const signatureHash = signatureHashOf(signatureTextOf(hole, plan));
+  const shapeHash = shapeHashOf(shapeOfHole(hole, plan));
+  return {
+    isUnfilled: (body) => isTodoBody(body, hole.id),
+    bans: (body) => forbiddenInBody(body),
+    libraryCandidates() {
+      const exact = library.filter((entry) => entry.signatureHash === signatureHash);
+      const neighbours = neighboursOfShape(shapeHash, library, { hole: hole.id, feature: plan.featureId }).filter((entry) => !exact.includes(entry));
+      return [...exact, ...neighbours].slice(0, 5).map((entry) => ({ body: instantiateBody(entry.bodyTemplate, hole), origin: `library:${entry.signatureHash}`, model: null, usage: null }));
+    },
+    libraryEntryOf: (body, provenance) => libraryEntryOf(hole, plan, body, provenance)
+  };
+}
+async function tryCandidate(deps, input, candidate, result) {
   result.tried += 1;
-  const bans = forbiddenInBody(candidate.body);
+  const bans = input.rules.bans(candidate.body);
   if (bans.length > 0) {
     result.banned += 1;
-    deps.log(JSON.stringify({ action: "fill", hole: holeId, candidate: candidate.origin, outcome: "banned", rules: bans }));
+    deps.log(JSON.stringify({ action: "fill", hole: input.holeId, candidate: candidate.origin, outcome: "banned", rules: bans }));
     return false;
   }
-  await deps.writeBody(holeId, candidate.body);
-  const run = await deps.runHoleTest(holeId);
-  deps.log(JSON.stringify({ action: "fill", hole: holeId, candidate: candidate.origin, outcome: run.green ? "green" : "red" }));
+  await deps.writeBody(input.holeId, candidate.body);
+  const run = await deps.runHoleTest(input.holeId);
+  deps.log(JSON.stringify({ action: "fill", hole: input.holeId, candidate: candidate.origin, outcome: run.green ? "green" : "red" }));
   if (!run.green) result.lastRun = run.lines;
   return run.green;
 }
@@ -10018,39 +10036,33 @@ function accountUsage(result, candidates) {
   }
 }
 async function fillHole(input, deps, options = DEFAULT_FILL_OPTIONS) {
-  const { hole, plan } = input;
-  const result = { holeId: hole.id, outcome: "human", tried: 0, banned: 0, model: null, usage: [], lastRun: [] };
-  if (!isTodoBody(input.currentBody, hole.id)) {
+  const result = { holeId: input.holeId, outcome: "human", tried: 0, banned: 0, model: null, usage: [], lastRun: [] };
+  if (!input.rules.isUnfilled(input.currentBody)) {
     return { ...result, outcome: "already-filled" };
   }
   const retain = async (candidate, path) => {
-    const provenance = { hole: hole.id, repo: deps.repo, feature: plan.featureId, path, model: candidate.model, date: deps.today() };
-    await deps.recordLibrary(libraryEntryOf(hole, plan, candidate.body, provenance));
+    const provenance = { hole: input.holeId, repo: deps.repo, feature: input.featureId, path, model: candidate.model, date: deps.today() };
+    await deps.recordLibrary(input.rules.libraryEntryOf(candidate.body, provenance));
     return { ...result, outcome: path, model: candidate.model, lastRun: [] };
   };
-  const signatureHash = signatureHashOf(signatureTextOf(hole, plan));
-  const shapeHash = shapeHashOf(shapeOfHole(hole, plan));
-  const exact = input.library.filter((entry) => entry.signatureHash === signatureHash);
-  const neighbours = neighboursOfShape(shapeHash, input.library, { hole: hole.id, feature: plan.featureId }).filter((entry) => !exact.includes(entry));
-  for (const entry of [...exact, ...neighbours].slice(0, 5)) {
-    const candidate = { body: instantiateBody(entry.bodyTemplate, hole), origin: `library:${entry.signatureHash}`, model: null, usage: null };
-    if (await tryCandidate(deps, hole.id, candidate, result)) return retain(candidate, "library");
+  for (const candidate of input.rules.libraryCandidates()) {
+    if (await tryCandidate(deps, input, candidate, result)) return retain(candidate, "library");
   }
   if (options.libraryOnly) {
-    await deps.writeBody(hole.id, null);
+    await deps.writeBody(input.holeId, null);
     return result;
   }
   for (let round = 1; round <= options.rounds; round += 1) {
     const candidates = await deps.draw(input.context, options.candidates, round);
     accountUsage(result, candidates);
     for (const candidate of candidates) {
-      if (await tryCandidate(deps, hole.id, candidate, result)) return retain(candidate, round === 1 ? "draw:1" : "draw:2");
+      if (await tryCandidate(deps, input, candidate, result)) return retain(candidate, round === 1 ? "draw:1" : "draw:2");
     }
   }
   const escalated = await deps.escalate(input.context);
   accountUsage(result, [escalated]);
-  if (await tryCandidate(deps, hole.id, escalated, result)) return retain(escalated, "escalate");
-  await deps.writeBody(hole.id, null);
+  if (await tryCandidate(deps, input, escalated, result)) return retain(escalated, "escalate");
+  await deps.writeBody(input.holeId, null);
   return result;
 }
 async function fillFeature(inputs, deps, options = DEFAULT_FILL_OPTIONS) {
@@ -10059,7 +10071,7 @@ async function fillFeature(inputs, deps, options = DEFAULT_FILL_OPTIONS) {
   const attempted = results.filter((result) => result.outcome !== "already-filled");
   const escalated = attempted.filter((result) => result.outcome === "escalate" || result.outcome === "human").length;
   return {
-    featureId: inputs[0]?.plan.featureId ?? "",
+    featureId: inputs[0]?.featureId ?? "",
     results,
     filled: attempted.filter((result) => result.outcome !== "human").length,
     unfilled: attempted.filter((result) => result.outcome === "human").length,
@@ -10068,6 +10080,124 @@ async function fillFeature(inputs, deps, options = DEFAULT_FILL_OPTIONS) {
   };
 }
 
+// src/fill/view.ts
+var VIEW_PLACEHOLDER = 'data-pattern="HoleUnfilled"';
+function isUnfilledViewBody(body) {
+  return body.trim() === "" || body.includes(VIEW_PLACEHOLDER);
+}
+function splitViewCandidate(text) {
+  const lines = text.replace(/\r\n/gu, "\n").split("\n");
+  const imports = [];
+  let index = 0;
+  while (index < lines.length) {
+    const line = (lines[index] ?? "").trim();
+    if (line === "") {
+      index += 1;
+      continue;
+    }
+    if (!/^import\b/u.test(line)) break;
+    const statement = [line];
+    while (!(statement.at(-1) ?? "").trimEnd().endsWith(";") && index + 1 < lines.length && !/^import\b/u.test((lines[index + 1] ?? "").trim())) {
+      index += 1;
+      statement.push((lines[index] ?? "").trim());
+    }
+    imports.push(statement.join(" ").replace(/\s+/gu, " "));
+    index += 1;
+  }
+  return { imports, body: lines.slice(index).join("\n") };
+}
+function viewCandidateTextOf(parts) {
+  return parts.imports.length === 0 ? parts.body : `${parts.imports.join("\n")}
+${parts.body}`;
+}
+function extractViewCandidate(answer) {
+  const fenced = /```(?:tsx|ts|jsx|typescript)?\s*\n([\s\S]*?)\n```/u.exec(answer);
+  const parts = splitViewCandidate(fenced?.[1] ?? answer);
+  return viewCandidateTextOf({ imports: parts.imports, body: extractCandidateBody(parts.body) });
+}
+function isAllowedViewImportSource(source) {
+  if (source === "react" || source === "@lingui/react/macro" || source === "@ogygie/ui") return true;
+  if (source.startsWith("@ogygie/ui/")) return true;
+  if (/^\.{1,2}\/(?:\.\.\/)*patterns\/[^/]+$/u.test(source)) return true;
+  if (/^\.\/[^/]+$/u.test(source)) return true;
+  return source === "../queries.gen" || source === "../queries.gen.js";
+}
+function forbiddenInViewImports(imports) {
+  const rules = [];
+  for (const statement of imports) {
+    if (/^import\s+type\b/u.test(statement)) continue;
+    const source = /\bfrom\s+["']([^"']+)["']/u.exec(statement)?.[1] ?? /^import\s+["']([^"']+)["']/u.exec(statement)?.[1];
+    if (source === void 0) {
+      rules.push(`import illisible : ${statement}`);
+      continue;
+    }
+    if (!/\bfrom\s+/u.test(statement)) {
+      rules.push(`import d'effet interdit : ${source}`);
+      continue;
+    }
+    if (!isAllowedViewImportSource(source)) rules.push(`import hors du catalogue : ${source}`);
+  }
+  return rules;
+}
+var VIEW_BODY_BANS = [
+  ...BODY_BANS,
+  // Assembled from fragments: the repo's lint reads source text and would refuse the spelled-out word.
+  { pattern: new RegExp(["dangerously", "SetInnerHTML"].join(""), "u"), rule: "innerHTML interdit : l'\xE9chappement de React ne se d\xE9branche pas" },
+  { pattern: /\buse(?:Query|Mutation|QueryClient|SuspenseQuery|InfiniteQuery)\s*\(/u, rule: "aucun hook de donn\xE9es : la vue re\xE7oit ses donn\xE9es servies et ses actions en MutationLike" },
+  { pattern: /<(?:table|form)[\s>]/u, rule: "<table> et <form> nus interdits : DataTable et ContractForm sont les patterns" },
+  { pattern: /\bstyle=\{\{/u, rule: "style en ligne interdit : les tokens passent par les classes" },
+  { pattern: /\b[a-z][a-z0-9]*(?:-[a-z0-9]+)*-\[[^\]\n]+\]/u, rule: "valeur arbitraire interdite : les classes viennent des tokens" },
+  { pattern: /["'`][^"'`\n]*#[0-9a-fA-F]{3,8}\b[^"'`\n]*["'`]/u, rule: "couleur en dur interdite : les tokens passent par les classes" }
+];
+function forbiddenInViewCandidate(text) {
+  const parts = splitViewCandidate(text);
+  return [...forbiddenInViewImports(parts.imports), ...forbiddenInBody(parts.body, VIEW_BODY_BANS)];
+}
+function currentViewBody(file, holeId) {
+  return parseLogicSections(file).get(holeId)?.body ?? "";
+}
+function replaceViewSections(file, holeId, candidate) {
+  const parts = candidate === null ? { imports: [], body: customViewPlaceholderLine(holeId) } : splitViewCandidate(candidate);
+  const lines = file.split("\n");
+  const opening = lines.indexOf(`// @hole-imports ${holeId}`);
+  const closing = lines.indexOf(`// @end-hole-imports ${holeId}`);
+  if (opening === -1 || closing === -1 || closing < opening) {
+    throw new Error(`replaceViewSections: view ${holeId} has no import markers`);
+  }
+  const withImports = [...lines.slice(0, opening + 1), ...parts.imports, ...lines.slice(closing)].join("\n");
+  return replaceHoleBody(withImports, holeId, parts.body);
+}
+function customViewSignatureText(view) {
+  return [...customViewPropsLines(view), customViewSignature(view)].join("\n");
+}
+function customViewShapeOf(view) {
+  return {
+    kind: "custom-view",
+    reads: view.receives.map((field) => normalizedTypeOf(field.model)),
+    columns: view.actions.map((action) => action.operation.kind),
+    codeRole: "none",
+    returns: "jsx"
+  };
+}
+function customViewRules(view, plan, library) {
+  const signature = customViewSignatureText(view);
+  const signatureHash = signatureHashOf(signature);
+  const shape = customViewShapeOf(view);
+  const shapeHash = shapeHashOf(shape);
+  return {
+    isUnfilled: isUnfilledViewBody,
+    bans: forbiddenInViewCandidate,
+    libraryCandidates() {
+      const exact = library.filter((entry) => entry.signatureHash === signatureHash);
+      const neighbours = neighboursOfShape(shapeHash, library, { hole: view.hole.id, feature: plan.featureId }).filter((entry) => !exact.includes(entry));
+      return [...exact, ...neighbours].slice(0, 5).map((entry) => ({ body: entry.bodyTemplate, origin: `library:${entry.signatureHash}`, model: null, usage: null }));
+    },
+    libraryEntryOf(body, provenance) {
+      return { hole: view.hole.id, signature, signatureHash, shape, shapeHash, errorCode: "", bodyTemplate: body, provenance: [provenance] };
+    }
+  };
+}
+
 // src/fill/model-draw.ts
 var DEFAULT_FILL_MODELS = {
   spec: "claude-fable-5-1",
@@ -10087,16 +10217,35 @@ var HOLE_SYSTEM_PROMPT = [
   // Assembled from fragments: the repo's lint reads source text and would refuse the spelled-out words.
   `- no \`any\`, no \`@ts-${"ignore"}\`, no \`as unknown ${"as"}\`; identifiers and comments in English; two-space indentation.`
 ].join("\n");
-function createModelDrawer(client, models = DEFAULT_FILL_MODELS) {
+var VIEW_SYSTEM_PROMPT = [
+  "You write the BODY of ONE custom view of a React screen generated by the Ogygie framework. You receive the view's contract \u2014 its props (the served fields it receives, one MutationLike per action it may trigger), the example its test renders with the text fragments the render must carry, the spec lines it carries, conventions \u2014 and the catalogue of patterns the product owns. Nothing else.",
+  "",
+  "Answer in two parts, in this order, and nothing else: first the import statements the body needs (one per line, at column 0), then the body of the component \u2014 the lines between the signature's opening brace and the closing brace, two-space indented. No signature, no markers, no closing brace, no fences, no prose before or after.",
+  "",
+  "Imports come from a CLOSED catalogue: `react`, `@lingui/react/macro` (Trans, useLingui), `@ogygie/ui` and its entries (`@ogygie/ui/data-table`, `@ogygie/ui/contract-form`, `@ogygie/ui/variance-chart`), the product's patterns folder (a relative path ending in `patterns/<Name>`), a sibling view of the same screen (`./<Name>`), and the feature's own reads (`../queries.gen`). Any other source is refused before the test.",
+  "",
+  "Rules of a body:",
+  "- the view composes patterns: never a raw `<table>` or `<form>`, never innerHTML, never an inline `style`;",
+  "- it receives its data SERVED and its actions as MutationLike: no data hook, no fetch, no cache key, no `process`; a write goes through `mutate` of an action it received;",
+  "- every text a human reads is a `<Trans>` or a `t` template of the i18n macro; identifiers and comments in English;",
+  "- classes come from the product's tokens: no arbitrary value (`p-[13px]`), no hex colour;",
+  '- the root element is `<section data-view="<view id>">`; the example must render every fragment the test expects, in its text;',
+  // Assembled from fragments: the repo's lint reads source text and would refuse the spelled-out words.
+  `- no \`any\`, no \`@ts-${"ignore"}\`, no \`as unknown ${"as"}\`; a date is formatted from the served string, never from a clock read in the view.`
+].join("\n");
+var VIEW_DRAWER_OPTIONS = { system: VIEW_SYSTEM_PROMPT, extract: extractViewCandidate };
+function createModelDrawer(client, models = DEFAULT_FILL_MODELS, options = {}) {
+  const system = options.system ?? HOLE_SYSTEM_PROMPT;
+  const extract = options.extract ?? extractCandidateBody;
   async function one(model, context, origin) {
     const answer = await client.complete({
       model,
-      system: HOLE_SYSTEM_PROMPT,
+      system,
       messages: [{ role: "user", content: context }],
       maxTokens: 4e3,
       effort: "medium"
     });
-    return { body: extractCandidateBody(answer.text), origin, model: answer.model, usage: answer.usage };
+    return { body: extract(answer.text), origin, model: answer.model, usage: answer.usage };
   }
   return {
     async draw(context, n, round) {
@@ -10548,8 +10697,8 @@ async function loadConsumedFeatures(project, block) {
     if (owningApp === void 0) continue;
     const specAbsolute = join3(project.root, entry.spec);
     const markdown = existsSync2(specAbsolute) ? readFileSync3(specAbsolute, "utf8") : "";
-    const report = checkSpec({ markdown, specPath: entry.spec, generation: project.generation });
-    const featureBlock = report.kind === "feature" ? report.block : null;
+    const report2 = checkSpec({ markdown, specPath: entry.spec, generation: project.generation });
+    const featureBlock = report2.kind === "feature" ? report2.block : null;
     const schemasModule = featureBlock === null ? "schemas.ts" : featureBlock.contracts.module.replace(/^\.\//u, "");
     const schemas = await loader(`${owningApp.path}/${entry.folder}/${schemasModule}`);
     loaded.set(consumed.feature, {
@@ -10562,10 +10711,113 @@ async function loadConsumedFeatures(project, block) {
   return loaded;
 }
 
+// src/cli/generate-screen-command.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join4 } 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 screenPlanOf(project, featureId, out, command = "ogygie generate") {
+  const lookup = screenTargetOf(project, featureId);
+  if (!lookup.ok) {
+    out.error(formatProblem(lookup.problem));
+    return null;
+  }
+  const { target } = lookup;
+  const markdown = readFileSync4(join4(project.root, target.specPath), "utf8");
+  const first = checkSpec({ markdown, specPath: target.specPath, generation: target.generation });
+  if (first.kind !== "screen" || first.screen === null) {
+    for (const problem2 of first.problems) out.error(formatProblem(problem2));
+    out.error(`${command} \u2014 ${target.specPath} n'a pas de bloc # G\xE9n\xE9ration d'\xE9cran lisible (consumes, views, holes).`);
+    return null;
+  }
+  const loaded = await loadConsumedFeatures(project, first.screen);
+  const report2 = checkSpec({ markdown, specPath: target.specPath, generation: target.generation, consumed: loaded });
+  if (!report2.ok || report2.screen === null) {
+    for (const problem2 of report2.problems) out.error(formatProblem(problem2));
+    out.error(`${command} \u2014 ${report2.problems.length} probl\xE8me(s), rien n'est \xE9crit.`);
+    return null;
+  }
+  const plan = buildScreenPlan({
+    featureId,
+    folder: target.folder,
+    appPath: target.appPath,
+    specPath: target.specPath,
+    block: report2.screen,
+    consumed: consumedInputsOf(loaded),
+    front: target.front,
+    guards: target.generation.guards,
+    contractViolationCode: contractViolationCodeOf(target.generation.target),
+    generatorVersion: GENERATOR_VERSION,
+    behaviors: boundScreenBehaviorsOf(report2.behaviors)
+  });
+  return { plan, target, markdown, report: report2 };
+}
+async function runGenerateScreenCommand(project, featureId, out) {
+  const built = await screenPlanOf(project, featureId, out);
+  if (built === null) return 1;
+  const { plan, target, markdown, report: report2 } = built;
+  const started = performance.now();
+  const existingCustomViews = /* @__PURE__ */ new Map();
+  for (const view of plan.views) {
+    if (view.kind !== "custom") continue;
+    const path = join4(project.root, plan.folder, "views", `${view.componentName}.tsx`);
+    existingCustomViews.set(view.id, existsSync3(path) ? readFileSync4(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 = join4(project.root, file.path);
+    const exists = existsSync3(absolute);
+    emitted += file.content.split("\n").length - 1;
+    if (exists && readFileSync4(absolute, "utf8") === file.content) {
+      out.log(`  identique ${file.path}`);
+      continue;
+    }
+    mkdirSync(dirname2(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 = join4(project.root, bodyPath);
+  if (existsSync3(bodyAbsolute)) {
+    out.log(`  conserv\xE9  ${bodyPath} (corps \xE9crit, jamais compar\xE9 \u2014 D40)`);
+  } else {
+    mkdirSync(dirname2(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(join4(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), ${report2.tally.derivable} ligne(s) li\xE9e(s), ${report2.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/fill-command.ts
 import { spawnSync } from "node:child_process";
-import { appendFileSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync4, readdirSync as readdirSync2, writeFileSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join5 } from "node:path";
 
 // ../ogygie-core/src/model.ts
 function createMessagesClient(deps) {
@@ -10650,8 +10902,8 @@ function scrubbedEnvironment(env) {
   }
   return kept;
 }
-var vitestHoleRunner = ({ projectRoot, testPath, holeId }) => {
-  const result = spawnSync("pnpm", ["exec", "vitest", "run", testPath, "-t", holeId], {
+var vitestHoleRunner = ({ projectRoot, testPath, testName }) => {
+  const result = spawnSync("pnpm", ["exec", "vitest", "run", testPath, "-t", testName], {
     cwd: projectRoot,
     env: scrubbedEnvironment(process.env),
     encoding: "utf8"
@@ -10660,6 +10912,12 @@ var vitestHoleRunner = ({ projectRoot, testPath, holeId }) => {
 ${result.stderr ?? ""}`.split("\n").filter((line) => line.trim() !== "");
   return { green: result.status === 0, lines };
 };
+function viewExampleTestName(view) {
+  return `rend l'exemple de la vue custom ${view.id} (trou ${view.hole.id})`;
+}
+var NOMINAL_PREVIEW_TEST_NAME = "rend l'\xE9tat nominal";
+var FILL_NEEDS_OPERATOR_EXIT = 2;
+var PATTERN_CATALOGUE_PATH = "design/patterns.md";
 async function planOf(project, featureId, out) {
   const lookup = featureTargetOf(project, featureId);
   if (!lookup.ok) {
@@ -10667,7 +10925,7 @@ async function planOf(project, featureId, out) {
     return null;
   }
   const { target } = lookup;
-  const markdown = readFileSync4(join4(project.root, target.specPath), "utf8");
+  const markdown = readFileSync5(join5(project.root, target.specPath), "utf8");
   const firstPass = checkSpec({ markdown, specPath: target.specPath, generation: target.generation });
   if (firstPass.block === null) {
     for (const problem2 of firstPass.problems) out.error(formatProblem(problem2));
@@ -10680,89 +10938,57 @@ async function planOf(project, featureId, out) {
     out.error(`ogygie generate fill \u2014 ${modulePath} n'existe pas (D19 : schemas.ts est le premier geste humain).`);
     return null;
   }
-  const report = checkSpec({ markdown, specPath: target.specPath, generation: target.generation, schemas });
-  if (!report.ok || report.block === null) {
-    for (const problem2 of report.problems) out.error(formatProblem(problem2));
+  const report2 = checkSpec({ markdown, specPath: target.specPath, generation: target.generation, schemas });
+  if (!report2.ok || report2.block === null) {
+    for (const problem2 of report2.problems) out.error(formatProblem(problem2));
     return null;
   }
-  const migrationsDir = join4(project.root, target.appPath, target.generation.target.migrations);
+  const migrationsDir = join5(project.root, target.appPath, target.generation.target.migrations);
   const plan = buildFeaturePlan({
     featureId,
     folder: target.folder,
     appPath: target.appPath,
     specPath: target.specPath,
-    block: report.block,
+    block: report2.block,
     schemas,
     generation: target.generation,
     ...target.tenantColumn === void 0 ? {} : { tenantColumn: target.tenantColumn },
-    migrationFileName: migrationFileNameFor(existsSync3(migrationsDir) ? readdirSync2(migrationsDir) : [], report.block.contracts.table === void 0 ? featureId : tableNameOf(report.block.contracts.table)),
+    migrationFileName: migrationFileNameFor(existsSync4(migrationsDir) ? readdirSync2(migrationsDir) : [], report2.block.contracts.table === void 0 ? featureId : tableNameOf(report2.block.contracts.table)),
     generatorVersion: GENERATOR_VERSION,
-    behaviors: boundBehaviorsOf(report.behaviors)
+    behaviors: boundBehaviorsOf(report2.behaviors)
   });
   return { plan, folder: target.folder };
 }
 function recordLibraryEntry(libraryDir, entry) {
-  mkdirSync(libraryDir, { recursive: true });
-  const path = join4(libraryDir, libraryFileNameOf(entry));
-  if (!existsSync3(path)) {
-    writeFileSync(path, `${JSON.stringify(entry, null, 2)}
+  mkdirSync2(libraryDir, { recursive: true });
+  const path = join5(libraryDir, libraryFileNameOf(entry));
+  if (!existsSync4(path)) {
+    writeFileSync2(path, `${JSON.stringify(entry, null, 2)}
 `, "utf8");
     return "created";
   }
-  const existing = HoleLibraryEntrySchema.parse(JSON.parse(readFileSync4(path, "utf8")));
+  const existing = HoleLibraryEntrySchema.parse(JSON.parse(readFileSync5(path, "utf8")));
   const origin = entry.provenance[0];
   if (origin === void 0 || existing.provenance.some((known) => known.repo === origin.repo && known.feature === origin.feature && known.hole === origin.hole)) return "unchanged";
-  writeFileSync(path, `${JSON.stringify({ ...existing, provenance: [...existing.provenance, origin] }, null, 2)}
+  writeFileSync2(path, `${JSON.stringify({ ...existing, provenance: [...existing.provenance, origin] }, null, 2)}
 `, "utf8");
   return "extended";
 }
-async function runFillCommand(project, featureId, argv, out, deps = {}) {
-  if (featureId === void 0 || featureId === "") {
-    out.error("usage: ogygie generate fill <feature-id> [--candidates 5] [--rounds 2] [--draw <model>] [--escalate <model>] [--library-only]");
-    return 1;
-  }
+function wiringOf(project, featureId, argv, out, deps, kind) {
   const flags = parseFillFlags(argv);
-  const built = await planOf(project, featureId, out);
-  if (built === null) return 1;
-  const { plan, folder } = built;
-  const logicPath = join4(project.root, folder, "logic.ts");
-  if (!existsSync3(logicPath)) {
-    out.error(`ogygie generate fill \u2014 ${folder}/logic.ts n'existe pas : lancez \`ogygie generate generate ${featureId}\` d'abord.`);
-    return 1;
-  }
-  const testPath = `${folder}/holes.gen.test.ts`;
-  const sections = parseLogicSections(readFileSync4(logicPath, "utf8"));
-  const library = loadHolesLibrary(deps.libraryDir ?? HOLES_LIBRARY_DIR);
-  const inputs = plan.holes.filter((hole) => hole.kind !== "view").map((hole) => {
-    const contextPath = join4(project.root, folder, "holes", `${hole.id}.gen.md`);
-    return {
-      hole,
-      plan,
-      context: existsSync3(contextPath) ? readFileSync4(contextPath, "utf8") : `# ${hole.id}`,
-      currentBody: sections.get(hole.id)?.body ?? "",
-      library
-    };
-  });
-  if (inputs.length === 0) {
-    out.log(`ogygie generate fill \u2014 ${featureId} n'a aucun trou TypeScript : rien \xE0 remplir.`);
-    return 0;
-  }
   const modelApiKey = deps.modelApiKey ?? process.env["OGYGIE_MODEL_API_KEY"];
   const options = modelApiKey === void 0 ? { ...flags.options, libraryOnly: true } : flags.options;
   if (modelApiKey === void 0 && !flags.options.libraryOnly) {
     out.log("ogygie generate fill \u2014 OGYGIE_MODEL_API_KEY absente : biblioth\xE8que seule, aucun mod\xE8le appel\xE9.");
   }
-  const drawer = modelApiKey === void 0 ? null : createModelDrawer(createMessagesClient({ apiKey: modelApiKey, fetchImpl: deps.fetchImpl ?? fetch, credentialHint: "OGYGIE_MODEL_API_KEY" }), flags.models);
-  const runner = deps.runner ?? vitestHoleRunner;
-  const libraryDir = deps.libraryDir ?? HOLES_LIBRARY_DIR;
-  const fillDeps = {
-    async writeBody(holeId, body) {
-      const logic = readFileSync4(logicPath, "utf8");
-      writeFileSync(logicPath, replaceHoleBody(logic, holeId, body ?? `  return todo(${JSON.stringify(holeId)});`), "utf8");
-    },
-    async runHoleTest(holeId) {
-      return runner({ projectRoot: project.root, testPath, holeId });
-    },
+  const drawer = modelApiKey === void 0 ? null : createModelDrawer(createMessagesClient({ apiKey: modelApiKey, fetchImpl: deps.fetchImpl ?? fetch, credentialHint: "OGYGIE_MODEL_API_KEY" }), flags.models, kind === "view" ? VIEW_DRAWER_OPTIONS : {});
+  void project;
+  return { featureId, options, drawer, libraryDir: deps.libraryDir ?? HOLES_LIBRARY_DIR, deps, out };
+}
+function fillDepsOf(wiring, effects) {
+  const { drawer, out } = wiring;
+  return {
+    ...effects,
     async draw(context, n, round) {
       if (drawer === null) return [];
       return drawer.draw(context, n, round);
@@ -10772,20 +10998,22 @@ async function runFillCommand(project, featureId, argv, out, deps = {}) {
       return drawer.escalate(context);
     },
     async recordLibrary(entry) {
-      const outcome = recordLibraryEntry(libraryDir, entry);
+      const outcome = recordLibraryEntry(wiring.libraryDir, entry);
       out.log(`  biblioth\xE8que ${outcome === "created" ? "+" : outcome === "extended" ? "~" : "="} ${libraryFileNameOf(entry)} (${entry.hole})`);
     },
-    today: deps.today ?? (() => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)),
-    repo: deps.repo ?? process.env["GITHUB_REPOSITORY"] ?? "local",
+    today: wiring.deps.today ?? (() => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)),
+    repo: wiring.deps.repo ?? process.env["GITHUB_REPOSITORY"] ?? "local",
     log: (line) => out.log(`  ${line}`)
   };
-  const summary = await fillFeature(inputs, fillDeps, options);
+}
+function report(wiring, summary, label) {
+  const { out, featureId } = wiring;
   for (const result of summary.results) {
-    const label = result.outcome === "already-filled" ? "d\xE9j\xE0 rempli" : result.outcome === "human" ? "HUMAIN (todo)" : result.outcome;
-    out.log(`  ${result.holeId} \u2014 ${label}${result.model === null ? "" : ` par ${result.model}`}, ${result.tried} candidat(s) essay\xE9(s)${result.banned > 0 ? `, ${result.banned} interdit(s)` : ""}`);
+    const outcome = result.outcome === "already-filled" ? "d\xE9j\xE0 rempli" : result.outcome === "human" ? label.human : result.outcome;
+    out.log(`  ${result.holeId} \u2014 ${outcome}${result.model === null ? "" : ` par ${result.model}`}, ${result.tried} candidat(s) essay\xE9(s)${result.banned > 0 ? `, ${result.banned} interdit(s)` : ""}`);
     if (result.outcome === "human") for (const line of result.lastRun.slice(-8)) out.log(`      ${line}`);
   }
-  const summaryPath = deps.summaryPath ?? process.env["GITHUB_STEP_SUMMARY"];
+  const summaryPath = wiring.deps.summaryPath ?? process.env["GITHUB_STEP_SUMMARY"];
   if (summaryPath !== void 0 && summary.usage.length > 0) {
     const rows = summary.results.flatMap((result) => result.usage.map((usage) => `| ${result.holeId} | ${result.outcome} | ${usage.model} | ${usage.inputTokens} | ${usage.outputTokens} |`));
     appendFileSync(summaryPath, `
@@ -10799,10 +11027,119 @@ ${rows.join("\n")}
   const totalInput = summary.usage.reduce((sum, usage) => sum + usage.inputTokens, 0);
   const totalOutput = summary.usage.reduce((sum, usage) => sum + usage.outputTokens, 0);
   out.log(
-    `ogygie generate fill \u2014 ${featureId} : ${summary.filled} trou(s) rempli(s), ${summary.unfilled} laiss\xE9(s) \xE0 l'humain, ${summary.results.filter((result) => result.outcome === "already-filled").length} d\xE9j\xE0 rempli(s) ; ${summary.usage.length} appel(s) de mod\xE8le (${totalInput} jetons d'entr\xE9e, ${totalOutput} de sortie)${summary.holesTooBig ? " ; PLUS D'UN TROU SUR DIX a atteint l'escalade : trop gros, \xE0 scinder dans la spec (D24)" : ""}.`
+    `ogygie generate fill \u2014 ${featureId} : ${summary.filled} ${label.unit}(s) rempli(s), ${summary.unfilled} laiss\xE9(s) \xE0 l'humain, ${summary.results.filter((result) => result.outcome === "already-filled").length} d\xE9j\xE0 rempli(s) ; ${summary.usage.length} appel(s) de mod\xE8le (${totalInput} jetons d'entr\xE9e, ${totalOutput} de sortie)${summary.holesTooBig ? " ; PLUS D'UN TROU SUR DIX a atteint l'escalade : trop gros, \xE0 scinder dans la spec (D24)" : ""}.`
   );
+}
+async function fillLogicHoles(project, featureId, argv, out, deps) {
+  const built = await planOf(project, featureId, out);
+  if (built === null) return 1;
+  const { plan, folder } = built;
+  const logicPath = join5(project.root, folder, "logic.ts");
+  if (!existsSync4(logicPath)) {
+    out.error(`ogygie generate fill \u2014 ${folder}/logic.ts n'existe pas : lancez \`ogygie generate generate ${featureId}\` d'abord.`);
+    return 1;
+  }
+  const testPath = `${folder}/holes.gen.test.ts`;
+  const sections = parseLogicSections(readFileSync5(logicPath, "utf8"));
+  const wiring = wiringOf(project, featureId, argv, out, deps, "logic");
+  const library = loadHolesLibrary(wiring.libraryDir);
+  const inputs = plan.holes.filter((hole) => hole.kind !== "view").map((hole) => {
+    const contextPath = join5(project.root, folder, "holes", `${hole.id}.gen.md`);
+    return {
+      holeId: hole.id,
+      featureId: plan.featureId,
+      context: existsSync4(contextPath) ? readFileSync5(contextPath, "utf8") : `# ${hole.id}`,
+      currentBody: sections.get(hole.id)?.body ?? "",
+      rules: logicHoleRules(hole, plan, library)
+    };
+  });
+  if (inputs.length === 0) {
+    out.log(`ogygie generate fill \u2014 ${featureId} n'a aucun trou TypeScript : rien \xE0 remplir.`);
+    return 0;
+  }
+  const runner = deps.runner ?? vitestHoleRunner;
+  const fillDeps = fillDepsOf(wiring, {
+    async writeBody(holeId, body) {
+      const logic = readFileSync5(logicPath, "utf8");
+      writeFileSync2(logicPath, replaceHoleBody(logic, holeId, body ?? `  return todo(${JSON.stringify(holeId)});`), "utf8");
+    },
+    async runHoleTest(holeId) {
+      return runner({ projectRoot: project.root, testPath, testName: holeId });
+    }
+  });
+  const summary = await fillFeature(inputs, fillDeps, wiring.options);
+  report(wiring, summary, { unit: "trou", human: "HUMAIN (todo)" });
   return summary.unfilled === 0 ? 0 : 1;
 }
+function viewContextOf(projectRoot, plan, view) {
+  const docPath = join5(projectRoot, plan.folder, "holes", `${view.hole.id}.gen.md`);
+  const doc = existsSync4(docPath) ? readFileSync5(docPath, "utf8") : `# ${view.hole.id}`;
+  const cataloguePath = join5(projectRoot, PATTERN_CATALOGUE_PATH);
+  if (!existsSync4(cataloguePath)) return doc;
+  return `${doc.trimEnd()}
+
+## Catalogue des patterns du produit (${PATTERN_CATALOGUE_PATH})
+
+${readFileSync5(cataloguePath, "utf8").trimEnd()}
+`;
+}
+async function fillCustomViews(project, featureId, argv, out, deps) {
+  const built = await screenPlanOf(project, featureId, out, "ogygie generate fill");
+  if (built === null) return 1;
+  const { plan } = built;
+  const views = plan.views.filter((view) => view.kind === "custom");
+  if (views.length === 0) {
+    out.log(`ogygie generate fill \u2014 ${featureId} (\xE9cran) n'a aucune vue custom : rien \xE0 remplir.`);
+    return 0;
+  }
+  const fileOf2 = (view) => join5(project.root, plan.folder, "views", `${view.componentName}.tsx`);
+  for (const view of views) {
+    if (!existsSync4(fileOf2(view))) {
+      out.error(`ogygie generate fill \u2014 ${plan.folder}/views/${view.componentName}.tsx n'existe pas : lancez \`ogygie generate generate ${featureId}\` d'abord.`);
+      return 1;
+    }
+  }
+  const testPath = `${plan.folder}/${plan.screenName}.gen.test.tsx`;
+  const previewsPath = `${plan.folder}/${plan.screenName}${PREVIEWS_FILE_SUFFIX}`;
+  const judgesPreview = plan.front.tests === "static-render" && existsSync4(join5(project.root, previewsPath));
+  const wiring = wiringOf(project, featureId, argv, out, deps, "view");
+  const library = loadHolesLibrary(wiring.libraryDir);
+  const byHole = new Map(views.map((view) => [view.hole.id, view]));
+  const inputs = views.map((view) => ({
+    holeId: view.hole.id,
+    featureId: plan.featureId,
+    context: viewContextOf(project.root, plan, view),
+    currentBody: currentViewBody(readFileSync5(fileOf2(view), "utf8"), view.hole.id),
+    rules: customViewRules(view, plan, library)
+  }));
+  const runner = deps.runner ?? vitestHoleRunner;
+  const fillDeps = fillDepsOf(wiring, {
+    async writeBody(holeId, body) {
+      const view = byHole.get(holeId);
+      if (view === void 0) throw new Error(`fill: no custom view carries the hole ${holeId}`);
+      writeFileSync2(fileOf2(view), replaceViewSections(readFileSync5(fileOf2(view), "utf8"), holeId, body), "utf8");
+    },
+    async runHoleTest(holeId) {
+      const view = byHole.get(holeId);
+      if (view === void 0) throw new Error(`fill: no custom view carries the hole ${holeId}`);
+      const example = runner({ projectRoot: project.root, testPath, testName: viewExampleTestName(view) });
+      if (!example.green || !judgesPreview) return example;
+      const nominal = runner({ projectRoot: project.root, testPath: previewsPath, testName: NOMINAL_PREVIEW_TEST_NAME });
+      return { green: nominal.green, lines: [...example.lines, ...nominal.lines] };
+    }
+  });
+  out.log(`ogygie generate fill \u2014 ${featureId} (\xE9cran) : ${views.length} vue(s) custom, jug\xE9e(s) par le test d'exemple${judgesPreview ? " puis le rendu statique de l'\xE9tat nominal" : ""}.`);
+  const summary = await fillFeature(inputs, fillDeps, wiring.options);
+  report(wiring, summary, { unit: "corps de vue", human: "OP\xC9RATEUR (placeholder)" });
+  return summary.unfilled === 0 ? 0 : FILL_NEEDS_OPERATOR_EXIT;
+}
+async function runFillCommand(project, featureId, argv, out, deps = {}) {
+  if (featureId === void 0 || featureId === "") {
+    out.error("usage: ogygie generate fill <feature-id> [--candidates 5] [--rounds 2] [--draw <model>] [--escalate <model>] [--library-only]");
+    return 1;
+  }
+  return targetKindOf(project, featureId) === "screen" ? fillCustomViews(project, featureId, argv, out, deps) : fillLogicHoles(project, featureId, argv, out, deps);
+}
 
 export {
   ogygieError,
@@ -10969,10 +11306,27 @@ export {
   BODY_BANS,
   forbiddenInBody,
   DEFAULT_FILL_OPTIONS,
+  logicHoleRules,
   fillHole,
   fillFeature,
+  VIEW_PLACEHOLDER,
+  isUnfilledViewBody,
+  splitViewCandidate,
+  viewCandidateTextOf,
+  extractViewCandidate,
+  isAllowedViewImportSource,
+  forbiddenInViewImports,
+  VIEW_BODY_BANS,
+  forbiddenInViewCandidate,
+  currentViewBody,
+  replaceViewSections,
+  customViewSignatureText,
+  customViewShapeOf,
+  customViewRules,
   DEFAULT_FILL_MODELS,
   HOLE_SYSTEM_PROMPT,
+  VIEW_SYSTEM_PROMPT,
+  VIEW_DRAWER_OPTIONS,
   createModelDrawer,
   createMessagesClient,
   FeatureNameSchema,
@@ -10985,8 +11339,13 @@ export {
   targetKindOf,
   screenTargetOf,
   loadConsumedFeatures,
+  screenPlanOf,
+  runGenerateScreenCommand,
   parseFillFlags,
   scrubbedEnvironment,
+  viewExampleTestName,
+  NOMINAL_PREVIEW_TEST_NAME,
+  FILL_NEEDS_OPERATOR_EXIT,
   recordLibraryEntry,
   runFillCommand
 };