@ogygie/generate 0.22.0 → 0.24.0

package/dist/cli/extension-registries.d.ts

@@ -0,0 +1,9 @@
+import type { ExtensionContribution } from "../emit/screen/extensions.js";
+import type { CommandOutput } from "./output.js";
+import { type GenerateProject } from "./project.js";
+/** Every screen of the map that mounts on a point, with what the registry needs of it. */
+export declare function mountedScreensOf(project: GenerateProject): Array<ExtensionContribution & {
+    point: string;
+}>;
+/** Writes the registry of the given points (every declared point when `pointIds` is undefined); says what moved. Code 1 when a point names no front app. */
+export declare function writeExtensionRegistries(project: GenerateProject, out: CommandOutput, pointIds?: readonly string[]): number;

package/dist/cli/run.js

@@ -35,8 +35,9 @@ import {
   tableNameOf,
   targetKindOf,
   throwOgygieError,
-  verifyGeneration
-} from "../chunk-ASXSTGY5.js";
+  verifyGeneration,
+  writeExtensionRegistries
+} from "../chunk-ZPRW6QDW.js";
 
 // src/cli/check-command.ts
 import { existsSync, readFileSync, readdirSync } from "node:fs";
@@ -256,26 +257,29 @@ function generatedFeatureIdsOf(project) {
 async function runGenerateAllCommand(project, out) {
   const ids = generatedFeatureIdsOf(project);
   if (ids.length === 0) {
+    const registries2 = writeExtensionRegistries(project, out);
     out.log("ogygie generate --all \u2014 aucune spec de la carte ne porte de bloc # G\xE9n\xE9ration, rien \xE0 r\xE9g\xE9n\xE9rer.");
-    return 0;
+    return registries2;
   }
   const refused = [];
   let current = project;
   for (const [index, id] of ids.entries()) {
     if (index > 0) {
-      const reloaded = loadGenerateProject(project.root);
-      if (!reloaded.ok) {
-        for (const problem of reloaded.problems) out.error(formatProblem(problem));
+      const reloaded2 = loadGenerateProject(project.root);
+      if (!reloaded2.ok) {
+        for (const problem of reloaded2.problems) out.error(formatProblem(problem));
         out.error(`ogygie generate --all \u2014 le projet ne se relit plus apr\xE8s ${ids[index - 1]}, arr\xEAt.`);
         return 1;
       }
-      current = reloaded.project;
+      current = reloaded2.project;
     }
     const code = await runGenerateFeatureCommand(current, id, out);
     if (code !== 0) refused.push(id);
   }
+  const reloaded = loadGenerateProject(project.root);
+  const registries = reloaded.ok ? writeExtensionRegistries(reloaded.project, out) : 1;
   out.log(`ogygie generate --all \u2014 ${ids.length} spec(s) g\xE9n\xE9r\xE9e(s) de la carte : ${ids.length - refused.length} r\xE9g\xE9n\xE9r\xE9e(s)${refused.length === 0 ? "" : `, ${refused.length} refus\xE9e(s) (${refused.join(", ")})`}.`);
-  return refused.length === 0 ? 0 : 1;
+  return refused.length === 0 && registries === 0 ? 0 : 1;
 }
 async function runGenerateFeatureCommand(project, featureId, out) {
   if (featureId === void 0 || featureId === "") {
@@ -953,7 +957,8 @@ async function runVerifyCommand(project, out) {
     ...project.apiApp === void 0 ? {} : { apiAppPath: project.apiApp.path },
     ...project.manifest.tenancy === void 0 ? {} : { tenantColumn: project.manifest.tenancy.column },
     library: loadHolesLibrary(),
-    loadConsumed: (block) => loadConsumedFeatures(project, block)
+    loadConsumed: (block) => loadConsumedFeatures(project, block),
+    frontApps: project.manifest.apps.filter((app) => app.type === "front").map((app) => ({ name: app.name, path: app.path }))
   });
   const elapsedMs = Math.round(performance2.now() - started);
   if (!report.ok) {

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

@@ -0,0 +1,10 @@
+/**
+ * @intent Emits `content/<id>.gen.ts` of a screen (D56): one content list of
+ * the block — the MATERIAL of a rubric, written in the spec in the product's
+ * source language — as a typed constant the content view renders. Plain text
+ * and one optional link per entry, exactly as the spec wrote them: a change of
+ * wording is a change of the spec, regenerated, never an edit here.
+ */
+import type { ContentListPlan, ScreenPlan } from "../screen-plan.js";
+export declare function contentFilePath(list: ContentListPlan): string;
+export declare function emitContentList(plan: ScreenPlan, list: ContentListPlan): string;

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

@@ -0,0 +1,18 @@
+import type { ExtensionPoint } from "../../manifest-generation.schema.js";
+export declare const EXTENSION_REGISTRY_FILE = "extensions.gen.ts";
+export interface ExtensionContribution {
+    /** The mounted screen's feature id, its folder relative to the repo root, and the id of its contribution on the point. */
+    featureId: string;
+    folder: string;
+    mountId: string;
+}
+export interface ExtensionRegistryInput {
+    point: ExtensionPoint;
+    /** The host screen's folder, relative to the repo root (`<front app>/<point.folder>`). */
+    hostFolder: string;
+    contributions: readonly ExtensionContribution[];
+    generatorVersion: string;
+}
+/** Repo-relative path of a point's registry. */
+export declare function extensionRegistryPath(appPath: string, point: ExtensionPoint): string;
+export declare function emitExtensionRegistry(input: ExtensionRegistryInput): string;

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

@@ -1,6 +1,8 @@
-import type { CustomViewPlan, FormViewPlan, ListViewPlan, ScreenPlan } from "../screen-plan.js";
+import type { ContentViewPlan, CustomViewPlan, FormViewPlan, ListViewPlan, ScreenPlan } from "../screen-plan.js";
 export declare function emitListView(plan: ScreenPlan, view: ListViewPlan): string;
 export declare function emitFormView(plan: ScreenPlan, view: FormViewPlan): string;
+/** D56: a content view — a DisclosureList over the constant of its list; the link label is the one text of the view, translated here; no operation, no fetch. */
+export declare function emitContentView(plan: ScreenPlan, view: ContentViewPlan): string;
 /** The props of a custom view: the received fields of the output, and one MutationLike per action. */
 export declare function customViewPropsLines(view: CustomViewPlan): string[];
 /** The signature line of a custom view — what the markers protect and compare. */

package/dist/emit/screen-plan.d.ts

@@ -1,8 +1,8 @@
 import { type ConsumedRoute } from "../consumed-feature.js";
-import type { GuardDenial, GuardRegistry, FrontTarget } from "../manifest-generation.schema.js";
+import type { GuardDenial, GuardRegistry, FrontTarget, ExtensionPoint } from "../manifest-generation.schema.js";
 import { type GenerationBlock, type HttpOperation } from "../generation-block.schema.js";
 import type { HttpOperationKind } from "../motif-catalog.js";
-import { type CustomView, type FormView, type ListView, type ScreenBlock, type ScreenHole } from "../screen-block.schema.js";
+import { type CustomView, type FormView, type ListView, type ScreenBlock, type ScreenHole, type ContentEntry, type ContentView, isOperationView } from "../screen-block.schema.js";
 import type { ParsedScreenBehavior } from "../screen-grammar.js";
 import { type FieldModel, type SchemaModels } from "../zod-introspection.js";
 export type { ConsumedRoute };
@@ -128,7 +128,20 @@ export interface CustomViewPlan {
     /** The output overlaid by the hole's example — what its test renders. */
     exampleInput: unknown;
 }
-export type ViewPlan = ListViewPlan | FormViewPlan | CustomViewPlan;
+/** A content list of the block (D56): what `content/<id>.gen.ts` exports. */
+export interface ContentListPlan {
+    id: string;
+    /** `faqEntries` → `FAQ_ENTRIES`, the exported constant. */
+    constName: string;
+    entries: ContentEntry[];
+}
+export interface ContentViewPlan {
+    kind: "content";
+    id: string;
+    componentName: string;
+    list: ContentListPlan;
+}
+export type ViewPlan = ListViewPlan | FormViewPlan | CustomViewPlan | ContentViewPlan;
 export interface ScreenBehaviorPlan {
     raw: string;
     behavior: ParsedScreenBehavior;
@@ -151,8 +164,15 @@ export interface ScreenPlan {
     bodyName: string;
     propsName: string;
     routeFactoryName: string;
-    /** The read the container's ScreenState waits for. */
-    primary: ListViewPlan | CustomViewPlan;
+    /** The read the container's ScreenState waits for — null for a screen of content alone (D56): the container renders the body directly. */
+    primary: ListViewPlan | CustomViewPlan | null;
+    /** The content lists of the block, in order (D56). */
+    contentLists: ContentListPlan[];
+    /** D56: the extension point the screen mounts on, and the id of its contribution there — null when the screen has a route or mounts nowhere. */
+    mount: {
+        point: ExtensionPoint;
+        id: string;
+    } | null;
     operations: ScreenOperationPlan[];
     reads: ScreenOperationPlan[];
     writes: ScreenOperationPlan[];
@@ -183,5 +203,8 @@ export interface ScreenPlan {
 export declare function labelOf(fieldName: string): string;
 /** A distinct sample of a model at `variant`: uuids and dates differ by variant so two rows never share a key. */
 export declare function distinctSampleOf(model: FieldModel, variant: number): unknown;
+/** `faqEntries` → `FAQ_ENTRIES`. */
+export declare function contentConstNameOf(listId: string): string;
 export declare function buildScreenPlan(input: ScreenPlanInput): ScreenPlan;
-export type { CustomView, FormView, ListView };
+export type { ContentView, CustomView, FormView, ListView };
+export { isOperationView };

package/dist/generation-block.schema.d.ts

@@ -1273,7 +1273,7 @@ export type YamlBlockRead = {
 };
 /** Reads the YAML text of a `# Génération` block into a raw value — one refusal per YAML error, at its line. */
 export declare function readYamlBlock(yamlText: string, location: BlockLocation): YamlBlockRead;
-/** D41: a raw block is a SCREEN block when it carries `consumes` — a feature block carries `contracts`; `check` refuses a block that carries both or neither. */
+/** D41: a raw block is a SCREEN block when it carries `consumes` or `views` (a content screen consumes nothing, D56) — a feature block carries `contracts`; `check` refuses a block that carries both or neither. */
 export declare function blockKindOf(raw: unknown): "feature" | "screen" | "both" | "neither";
 /** Reads the YAML text of the block, then validates it. */
 export declare function parseGenerationBlock(yamlText: string, location: BlockLocation): GenerationBlockParse;

package/dist/index.js

@@ -3,6 +3,8 @@ import {
   AlterStepSchema,
   BEHAVIOR_UNBOUND,
   BODY_BANS,
+  CONTENT_RENDERS,
+  CONTENT_STATES,
   CONTRACTS_SECTION_TITLE,
   CONTRACT_VALIDATION_FAILED,
   ConsumedFeatureSchema,
@@ -187,7 +189,7 @@ import {
   viewCandidateTextOf,
   viewExampleTestName,
   vocabularyOf
-} from "./chunk-ASXSTGY5.js";
+} from "./chunk-ZPRW6QDW.js";
 
 // src/prompt-card.ts
 var phrase = (caseKey) => caseKey.replace(/^with:/u, "avec ").replace(/^without:/u, "sans ");
@@ -205,7 +207,13 @@ function targetLines(generation) {
   const lines = [`- base ${target.database}, tenancy ${target.tenancy}, tests ${target.tests}, colonnes en ${target.naming} ; code d'un contrat viol\xE9 : ${contractViolationCodeOf(target)} (\xE9cris CONTRACT_VALIDATION_FAILED dans les lignes, il d\xE9signe ce code).`];
   if (target.database === "mssql-raw") lines.push("- cette cible n'\xE9met ni `import` ni `appendOnlySupersedes` ni `allOrNothingImport` : lectures, create, update, setOrClear, delete et les quatre autres motifs.");
   if (generation.front === void 0) lines.push("- aucune cible `front` : pas de spec d'\xE9cran (bloc `consumes`), seulement des features API.");
-  else lines.push(`- cible front ${generation.front.tests} : une spec d'\xE9cran est possible (bloc \`consumes\`).`);
+  else {
+    lines.push(`- cible front ${generation.front.tests} : une spec d'\xE9cran est possible (bloc \`consumes\`, ou \`views\` de contenu seules).`);
+    const points = generation.front.extensionPoints ?? [];
+    lines.push(
+      points.length === 0 ? "- aucun point d'extension d\xE9clar\xE9 : un \xE9cran nouveau a sa `route`, jamais `mounts`." : `- points d'extension o\xF9 un \xE9cran peut se MONTER au lieu d'avoir une route (\`mounts: { point, id }\`) : ${points.map((point) => `\`${point.id}\` (${point.kind}, \xE9cran h\xF4te \`${point.folder}\`)`).join(", ")} \u2014 un onglet de plus dans un \xE9cran existant se d\xE9clare ainsi.`
+    );
+  }
   return lines;
 }
 function generationGrammarCard(generation) {
@@ -222,7 +230,7 @@ function generationGrammarCard(generation) {
     `- \`motifs\` : ${motifs.join(", ")} \u2014 une instance par motif, et SEULEMENT si une op\xE9ration l'emploie (\`uses: <motif>\` sur l'op\xE9ration, sauf \`signedWrite\` qui s'applique \xE0 toutes les \xE9critures) ; sinon \`motifs: {}\`.`,
     `- \`holes\` : ${holeKinds.join(", ")} ; un trou \`validate\` = \`{ id, kind: validate, reads: [champs de l'entr\xE9e], error: CODE, effects: [] | [clock], suggestedFix: true, examples: { accept: {\u2026}, reject: {\u2026} } }\` ; un \`derive\` = \`{ id, kind: derive, reads, writes: <champ de la ressource>, error: CODE, effects: [], examples: { accept: [{ input, output }], reject: { input } } }\`. Les exemples sont OBLIGATOIRES ; une date d'exemple se rapporte au 2026-01-01 (horloge fig\xE9e des tests).`,
     "",
-    `Bloc d'un \xC9CRAN \u2014 cl\xE9s ${SCREEN_BLOCK_KEYS.map((key) => `\`${key}\``).join(", ")} : \`consumes: [{ feature, operations: [ids] }]\` (features DE LA CARTE), \`views: [{ id, kind: list, operation: <lecture> } | { id, kind: form, operation: <\xE9criture>, fields: [champs] } | { id, kind: custom, operation, hole }]\`, \`holes: [{ id, receives: [champs de la sortie], actions: [\xE9critures], examples: { input, renders: ["texte"] } }]\`, \`route?: /chemin\`.`,
+    `Bloc d'un \xC9CRAN \u2014 cl\xE9s ${SCREEN_BLOCK_KEYS.map((key) => `\`${key}\``).join(", ")} : \`consumes: [{ feature, operations: [ids] }]\` (features DE LA CARTE ; vide ou absent quand toutes les vues sont de contenu), \`views: [{ id, kind: list, operation: <lecture> } | { id, kind: form, operation: <\xE9criture>, fields: [champs] } | { id, kind: custom, operation, hole } | { id, kind: content, content: <id d'une liste> }]\`, \`holes: [{ id, receives: [champs de la sortie], actions: [\xE9critures], examples: { input, renders: ["texte"] } }]\`, \`content: [{ id: camelCase, entries: [{ id: kebab-case, title, body, href? }] }]\` (la MATI\xC8RE d'une rubrique \u2014 une aide, une FAQ : du texte brut \xE9crit ici m\xEAme, dans la langue source du produit, un lien au plus par entr\xE9e, jamais un libell\xE9 d'interface), et UNE des deux : \`route?: /chemin\` (une page) ou \`mounts?: { point, id }\` (un emplacement d'un \xE9cran existant, parmi les points d'extension de la cible ci-dessous).`,
     "",
     "Les LIGNES de comportement (une par puce, deux lignes au plus, recoll\xE9es) :",
     "`- \xC9TANT DONN\xC9 <op\xE9ration> avec <cas>[, (avec|sans) <cas>]* ALORS <statut> [<CODE>] [et <attendu>[, <attendu>]*] [[hole:<id>]]`",
@@ -231,7 +239,7 @@ function generationGrammarCard(generation) {
     ...guardLines(generation),
     "- statut : le code HTTP (200 pour une lecture, 201 pour create, 200 pour update) ou le refus (400 avec le code du trou ou CONTRACT_VALIDATION_FAILED, 401/403 du guard, 404 du notFound, 409 d'un motif).",
     "- attendus : `<collection> = lignes`, `<collection> = []`, `ordre <champ> asc|desc`, `updated.<champ> = cl\xE9 vis\xE9e`, `champs envoy\xE9s \xE9crits`, `liste \xE0 jour`, `suggestedFix`, `rien n'est \xE9crit`, `<writes> d\xE9riv\xE9` ; TOUT mot hors de cette liste \u2014 une valeur qu'un trou calcule (`created.<champ d\xE9riv\xE9> = \u2026`), un refus qu'un trou d\xE9cide \u2014 nomme son trou en fin de ligne : `[hole:<id>]`, sinon la ligne est refus\xE9e (OGYGIE_BEHAVIOR_UNBOUND).",
-    `- \xE9cran : \`- \xC9TANT DONN\xC9 <vue|\xE9cran> avec <\xE9tat> ALORS <rendu>\` ; \xE9tats ${[...READ_STATES, ...FORM_STATES].map((key) => `\xAB ${phrase(key)} \xBB`).join(", ")} ; rendus ${[...READ_RENDERS, ...FORM_RENDERS].map((render) => `\xAB ${render} \xBB`).join(", ")}.`,
+    `- \xE9cran : \`- \xC9TANT DONN\xC9 <vue|\xE9cran> avec <\xE9tat> ALORS <rendu>\` ; \xE9tats ${[...READ_STATES, ...FORM_STATES].map((key) => `\xAB ${phrase(key)} \xBB`).join(", ")} ; rendus ${[...READ_RENDERS, ...FORM_RENDERS].map((render) => `\xAB ${render} \xBB`).join(", ")} ; une vue \`content\` : \xE9tat ${CONTENT_STATES.map((key) => `\xAB ${phrase(key)} \xBB`).join(", ")}, rendus ${CONTENT_RENDERS.map((render) => `\xAB ${render} \xBB`).join(", ")}, \xAB ancre <id d'entr\xE9e> \xBB.`,
     "",
     "Cible du produit :",
     ...targetLines(generation),

package/dist/manifest-generation.schema.d.ts

@@ -95,8 +95,15 @@ export declare const FrontTargetSchema: z.ZodObject<{
         export: z.ZodString;
     }, z.core.$strict>;
     stylesheet: z.ZodOptional<z.ZodString>;
+    extensionPoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"tab">;
+        folder: z.ZodString;
+        app: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type FrontTarget = z.infer<typeof FrontTargetSchema>;
+export type ExtensionPoint = NonNullable<FrontTarget["extensionPoints"]>[number];
 export declare const GuardDenialSchema: z.ZodObject<{
     status: z.ZodNumber;
     code: z.ZodString;
@@ -221,6 +228,12 @@ export declare const ManifestGenerationSchema: z.ZodObject<{
             export: z.ZodString;
         }, z.core.$strict>;
         stylesheet: z.ZodOptional<z.ZodString>;
+        extensionPoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodLiteral<"tab">;
+            folder: z.ZodString;
+            app: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ManifestGeneration = z.infer<typeof ManifestGenerationSchema>;

package/dist/screen-block.schema.d.ts

@@ -2,9 +2,12 @@
  * @intent Zod schema AND parser of the `# Génération` block of a SCREEN spec
  * (DECISIONS.md D41): one fenced YAML block, three keys — `consumes` (the API
  * features and the operations the screen uses), `views` (`list`, `form`,
- * `custom`, each on ONE operation) and `holes` (the custom views: what they
- * receive, which writes they may trigger, what their render must show) — plus
- * an OPTIONAL `route`, the path the screen mounts on. What the shape alone
+ * `custom`, each on ONE operation, or `content`, on a content list) and
+ * `holes` (the custom views: what they receive, which writes they may trigger,
+ * what their render must show) — plus an OPTIONAL `route`, the path the screen
+ * mounts on, and, since D56, `content` (lists of entries, the material of a
+ * rubric) and `mounts` (an extension point of a host screen, exclusive of
+ * `route`). A screen whose every view is content consumes nothing. What the shape alone
  * cannot check — do the operations exist in the consumed blocks, are the
  * fields of the output or the input — is `screen-checks.ts`, which needs the
  * consumed features; this module checks the block against itself and refuses
@@ -14,7 +17,7 @@
 import { z } from "zod";
 import type { OgygieError } from "@ogygie/core/errors";
 import { type BlockLocation } from "./generation-block.schema.js";
-export declare const SCREEN_BLOCK_KEYS: readonly ["route", "consumes", "views", "holes"];
+export declare const SCREEN_BLOCK_KEYS: readonly ["route", "mounts", "consumes", "content", "views", "holes"];
 /** A feature id of the map, kebab-case (French ids allowed, as everywhere). */
 export declare const FeatureIdSchema: z.ZodString;
 /** A front path: `/`, `/rates`, `/settings/archetypes` — no parameter in M1. */
@@ -50,6 +53,12 @@ export declare const CustomViewSchema: z.ZodObject<{
     id: z.ZodString;
     operation: z.ZodString;
 }, z.core.$strict>;
+/** A view of CONTENT (D56): a DisclosureList over one of the block's content lists — no operation. */
+export declare const ContentViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"content">;
+    content: z.ZodString;
+}, z.core.$strict>;
 export declare const ViewSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"list">;
     fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -70,6 +79,10 @@ export declare const ViewSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     hole: z.ZodString;
     id: z.ZodString;
     operation: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"content">;
+    content: z.ZodString;
 }, z.core.$strict>], "kind">;
 export type View = z.infer<typeof ViewSchema>;
 export type ListView = Extract<View, {
@@ -81,6 +94,38 @@ export type FormView = Extract<View, {
 export type CustomView = Extract<View, {
     kind: "custom";
 }>;
+export type ContentView = Extract<View, {
+    kind: "content";
+}>;
+/** A view bound to an operation — every kind but content. */
+export type OperationView = ListView | FormView | CustomView;
+export declare const isOperationView: (view: View) => view is OperationView;
+/** An entry of a content list (D56): plain text in the product's source language, one optional link; the id anchors it. */
+export declare const ContentEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    body: z.ZodString;
+    href: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ContentEntry = z.infer<typeof ContentEntrySchema>;
+export declare const ContentListSchema: z.ZodObject<{
+    id: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        body: z.ZodString;
+        href: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ContentList = z.infer<typeof ContentListSchema>;
+/** The id of an extension point, as the manifest's front target declares it: `fiche-societe.tabs`. */
+export declare const ExtensionPointIdSchema: z.ZodString;
+/** D56: where a screen mounts instead of a route — a point of a host screen, and the id of this contribution there. */
+export declare const MountSchema: z.ZodObject<{
+    point: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strict>;
+export type Mount = z.infer<typeof MountSchema>;
 export declare const ScreenHoleSchema: z.ZodObject<{
     id: z.ZodString;
     receives: z.ZodArray<z.ZodString>;
@@ -93,10 +138,23 @@ export declare const ScreenHoleSchema: z.ZodObject<{
 export type ScreenHole = z.infer<typeof ScreenHoleSchema>;
 export declare const ScreenBlockSchema: z.ZodObject<{
     route: z.ZodOptional<z.ZodString>;
-    consumes: z.ZodArray<z.ZodObject<{
+    mounts: z.ZodOptional<z.ZodObject<{
+        point: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    consumes: z.ZodDefault<z.ZodArray<z.ZodObject<{
         feature: z.ZodString;
         operations: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    content: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        entries: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            body: z.ZodString;
+            href: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
     views: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"list">;
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -117,6 +175,10 @@ export declare const ScreenBlockSchema: z.ZodObject<{
         hole: z.ZodString;
         id: z.ZodString;
         operation: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"content">;
+        content: z.ZodString;
     }, z.core.$strict>], "kind">>;
     holes: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -142,5 +204,5 @@ export declare function validateScreenBlock(raw: unknown, location: BlockLocatio
 export declare function parseScreenBlock(yamlText: string, location: BlockLocation): ScreenBlockParse;
 /** The consumed feature an operation belongs to, or null when the block does not consume it. */
 export declare function consumerOf(block: ScreenBlock, operationId: string): ConsumedFeature | null;
-/** The read whose output the screen's ScreenState waits for: the first list or custom view (D40). */
+/** The read whose output the screen's ScreenState waits for: the first list or custom view (D40) — a content view (D56) waits for nothing. */
 export declare function primaryViewOf(block: ScreenBlock): ListView | CustomView | null;

package/dist/screen-checks.d.ts

@@ -12,7 +12,8 @@
 import { type OgygieError } from "@ogygie/core/errors";
 import { type ConsumedRoute } from "./consumed-feature.js";
 import { type GenerationBlock } from "./generation-block.schema.js";
-import type { ScreenBlock } from "./screen-block.schema.js";
+import type { FrontTarget } from "./manifest-generation.schema.js";
+import { type ScreenBlock } from "./screen-block.schema.js";
 import type { FieldModel, SchemaModels } from "./zod-introspection.js";
 export interface ConsumedFeatureCheckInput {
     featureId: string;
@@ -28,6 +29,10 @@ export interface ScreenCheckInput {
     specPath: string;
     /** The consumed features, as the project resolved them — absent when the map does not know the feature. */
     consumed: ReadonlyMap<string, ConsumedFeatureCheckInput>;
+    /** The front target of the manifest, when known: its extension points are what `mounts.point` may name (D56). */
+    front?: FrontTarget | null;
+    /** Only the mount is checked (the consumed features were not resolved). */
+    mountOnly?: boolean;
 }
 /** The element fields of a read output — the one array of objects it carries. */
 export declare function elementFieldsOf(outputModel: FieldModel | undefined): string[] | null;

package/dist/screen-vocabulary.d.ts

@@ -6,8 +6,10 @@
  * the error banner, the access explanation, the empty state, the rows, their
  * order; a `form` view speaks of a valid or invalid form, of a refused write,
  * and renders the write it triggers, the error sentences, or nothing written.
- * A line whose every word is in here is derived without a model; a word
- * outside it needs a hole — a custom view.
+ * A `content` view (D56) speaks of its one state — with content — and renders
+ * its entries, folded, each under its anchor. A line whose every word is in
+ * here is derived without a model; a word outside it needs a hole — a custom
+ * view.
  */
 import { type OgygieError } from "@ogygie/core/errors";
 import { type ScreenParseResult } from "./screen-grammar.js";
@@ -21,6 +23,8 @@ export declare const READ_STATES: readonly ["with:chargement", "with:erreur", "w
 export declare const READ_RENDERS: readonly ["squelette", "bandeau d'erreur", "explication d'accès", "état vide", "lignes"];
 export declare const FORM_STATES: readonly ["with:formulaire valide", "with:formulaire invalide", "with:écriture refusée"];
 export declare const FORM_RENDERS: readonly ["phrases d'erreur", "rien n'est écrit", "bandeau d'erreur"];
+export declare const CONTENT_STATES: readonly ["with:contenu"];
+export declare const CONTENT_RENDERS: readonly ["entrées", "repliées"];
 export declare function screenCaseKey(polarity: "with" | "without", phrase: string): string;
 /** What a line may say of a view — the whole screen speaks like its primary read view. */
 export declare function screenVocabularyOf(view: View | null, block: ScreenBlock, sortableFields?: readonly string[]): ScreenVocabulary;

package/dist/verify-generation.d.ts

@@ -6,10 +6,14 @@ import type { HoleLibraryEntry } from "./hole-shape.js";
 import { type ManifestGeneration } from "./manifest-generation.schema.js";
 import { type DeclaredManifestEntry } from "./emit/manifest-entry.js";
 import type { SchemaModels } from "./zod-introspection.js";
+import { type ExtensionContribution } from "./emit/screen/extensions.js";
+import type { GeneratedFile } from "./generate-feature.js";
 import type { ScreenBlock } from "./screen-block.schema.js";
 import type { ConsumedFeatureCheckInput } from "./screen-checks.js";
 import { type ParsedScreenBehavior } from "./screen-grammar.js";
 export declare const GENERATED_DRIFT = "OGYGIE_GENERATED_DRIFT";
+/** D56: an extension point declared at the manifest whose host folder never imports its registry. */
+export declare const EXTENSION_POINT_UNWIRED = "OGYGIE_EXTENSION_POINT_UNWIRED";
 /** The version every emitted header carries — the package's own, so a bump of the lockstep is a drift every product regenerates (D27). */
 export declare const GENERATOR_VERSION: string;
 /**
@@ -22,6 +26,8 @@ export declare function normalizeForComparison(text: string): string;
 export declare const GENERATED_HEADER: RegExp;
 /** A feature of the map that owns a spec: where its code lives. */
 export interface SpecOwnerFolder {
+    /** The feature id of the map entry (D56: a mounted screen contributes under it). */
+    featureId?: string;
     specPath: string;
     /** Folder of the feature, relative to the repo root. */
     folder: string;
@@ -53,7 +59,51 @@ export interface VerifyGenerationInput {
     apiAppPath?: string;
     /** D41: resolves the features a screen block consumes (their block, schemas and routes); absent, no screen is regenerated. */
     loadConsumed?: (block: ScreenBlock) => Promise<ReadonlyMap<string, LoadedConsumedForVerify>>;
+    /** D56: the front apps of the map (name → path), where the extension points' host folders live; absent, no registry is verified. */
+    frontApps?: ReadonlyArray<{
+        name: string;
+        path: string;
+    }>;
 }
+/** D56: the repo-relative host folder of an extension point — the one front app, or the one the point names. */
+export declare function extensionHostAppPathOf(point: {
+    app?: string | undefined;
+}, frontApps: ReadonlyArray<{
+    name: string;
+    path: string;
+}>): string | null;
+/** D56: the registry of every declared point — one file each, empty when nothing mounts — from the screens that mount (their feature id, folder and mount id). */
+export declare function extensionRegistriesOf(input: {
+    points: ReadonlyArray<{
+        id: string;
+        kind: "tab";
+        folder: string;
+        app?: string | undefined;
+    }>;
+    frontApps: ReadonlyArray<{
+        name: string;
+        path: string;
+    }>;
+    mounted: ReadonlyArray<ExtensionContribution & {
+        point: string;
+    }>;
+    generatorVersion: string;
+}): Array<{
+    point: {
+        id: string;
+        kind: "tab";
+        folder: string;
+        app?: string | undefined;
+    };
+    hostFolder: string;
+    file: GeneratedFile;
+} | {
+    point: {
+        id: string;
+    };
+    hostFolder: null;
+    file: null;
+}>;
 export interface VerifiedSpec {
     specPath: string;
     generated: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogygie/generate",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Ogygie generator: reads the `# Génération` block of a spec and its schemas.ts, derives everything deterministic without a model (routes, pipeline, database, factories, tests, screens, previews), fills the typed holes of logic.ts by library, draw and escalation, and draws the first schemas.ts of a new feature — judged by the gates. Sixth package of the lockstep (D55).",
   "license": "MIT",
   "type": "module",
@@ -29,7 +29,7 @@
     }
   },
   "dependencies": {
-    "@ogygie/core": "0.22.0",
+    "@ogygie/core": "0.24.0",
     "tsx": "^4.20.0",
     "yaml": "^2.9.0",
     "zod": "^4.0.0"
@@ -38,7 +38,7 @@
     "@lingui/babel-plugin-lingui-macro": "^5.9.5",
     "@lingui/core": "^5.9.5",
     "@lingui/react": "^5.9.5",
-    "@ogygie/ui": "0.22.0",
+    "@ogygie/ui": "0.24.0",
     "@starter/api": "0.1.0",
     "@tanstack/react-query": "^5.102.2",
     "@tanstack/react-router": "^1.170.32",