@ogygie/generate 0.0.0-stage → 0.20.0

package/dist/hole-shape.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import type { FeaturePlan, HolePlan } from "./emit/plan.js";
+import type { FieldModel } from "./zod-introspection.js";
+/** A field type without its name: what the shape compares. */
+export declare function normalizedTypeOf(model: FieldModel): string;
+export declare const HoleShapeSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        transform: "transform";
+        validate: "validate";
+        derive: "derive";
+        project: "project";
+        view: "view";
+    }>;
+    reads: z.ZodArray<z.ZodString>;
+    columns: z.ZodArray<z.ZodString>;
+    codeRole: z.ZodEnum<{
+        none: "none";
+        "operation-refusal": "operation-refusal";
+        "motif-rejection": "motif-rejection";
+    }>;
+    returns: z.ZodString;
+}, z.core.$strict>;
+export type HoleShape = z.infer<typeof HoleShapeSchema>;
+export declare const HoleProvenanceSchema: z.ZodObject<{
+    hole: z.ZodString;
+    repo: z.ZodString;
+    feature: z.ZodString;
+    path: z.ZodEnum<{
+        library: "library";
+        "draw:1": "draw:1";
+        "draw:2": "draw:2";
+        escalate: "escalate";
+        human: "human";
+    }>;
+    model: z.ZodNullable<z.ZodString>;
+    date: z.ZodISODate;
+}, z.core.$strict>;
+export type HoleProvenance = z.infer<typeof HoleProvenanceSchema>;
+export declare const HoleLibraryEntrySchema: z.ZodObject<{
+    hole: z.ZodString;
+    signature: z.ZodString;
+    signatureHash: z.ZodString;
+    shape: z.ZodObject<{
+        kind: z.ZodEnum<{
+            transform: "transform";
+            validate: "validate";
+            derive: "derive";
+            project: "project";
+            view: "view";
+        }>;
+        reads: z.ZodArray<z.ZodString>;
+        columns: z.ZodArray<z.ZodString>;
+        codeRole: z.ZodEnum<{
+            none: "none";
+            "operation-refusal": "operation-refusal";
+            "motif-rejection": "motif-rejection";
+        }>;
+        returns: z.ZodString;
+    }, z.core.$strict>;
+    shapeHash: z.ZodString;
+    errorCode: z.ZodString;
+    bodyTemplate: z.ZodString;
+    provenance: z.ZodArray<z.ZodObject<{
+        hole: z.ZodString;
+        repo: z.ZodString;
+        feature: z.ZodString;
+        path: z.ZodEnum<{
+            library: "library";
+            "draw:1": "draw:1";
+            "draw:2": "draw:2";
+            escalate: "escalate";
+            human: "human";
+        }>;
+        model: z.ZodNullable<z.ZodString>;
+        date: z.ZodISODate;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HoleLibraryEntry = z.infer<typeof HoleLibraryEntrySchema>;
+export declare function shapeOfHole(hole: HolePlan, plan: FeaturePlan): HoleShape;
+export declare function shapeHashOf(shape: HoleShape): string;
+/** The literal signature: from `export function` to the opening brace included, as logic.ts carries it (a view: its SQL columns). */
+export declare function signatureTextOf(hole: HolePlan, plan?: FeaturePlan): string;
+export declare function signatureHashOf(signature: string): string;
+/** The body with the feature's names replaced by placeholders, longest names first so a name never eats another. */
+export declare function bodyTemplateOf(body: string, hole: HolePlan): string;
+/** The reverse of `bodyTemplateOf`: a template instantiated for a hole — lot 2 bis uses it, defined here with its inverse. */
+export declare function instantiateBody(template: string, hole: HolePlan): string;
+/** The code a hole answers, when it answers one. */
+export declare function errorCodeOf(hole: HolePlan): string | null;
+export declare function libraryEntryOf(hole: HolePlan, plan: FeaturePlan, body: string, provenance: HoleProvenance): HoleLibraryEntry;
+/** Entries of the same shape that are not this very hole of this very feature. */
+export declare function neighboursOfShape(shapeHash: string, library: readonly HoleLibraryEntry[], self: {
+    hole: string;
+    feature: string;
+}): HoleLibraryEntry[];
+/** The library shipped with this package: every entry, sorted by file name for determinism. */
+export declare const HOLES_LIBRARY_DIR: string;
+export declare function loadHolesLibrary(directory?: string): HoleLibraryEntry[];
+/** The file name of an entry: its signature hash, so the same signature always lands in the same file. */
+export declare function libraryFileNameOf(entry: HoleLibraryEntry): string;

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @intent Public surface of `@ogygie/generate`, lot 1: read a spec's
+ * `# Génération` block, parse and bind its behavior lines, report. The
+ * generation itself (files, holes, library) is lot 2 and will be exported
+ * from here when it exists — nothing is exported before it is real.
+ */
+export { bindBehavior, BEHAVIOR_UNBOUND, type BindingContext, type BindingOutcome, } from "./behavior-binding.js";
+export { isLiteralValue, parseBehavior, parseExpectation, OPENING_KEYWORD, type BehaviorCase, type BehaviorExpectation, type BehaviorOutcome, type BehaviorParseResult, type ParsedBehavior, } from "./behavior-grammar.js";
+export { checkSpec, type CheckSpecInput, type CheckSpecReport, type CheckTally, type CheckedBehavior } from "./check-spec.js";
+export { GENERATION_BLOCK_INVALID, GENERATION_BLOCK_KEYS, GenerationBlockSchema, HoleSchema, OperationSchema, SUCCESS_STATUS_BY_KIND, HOLE_KIND_SERVES, METHOD_BY_KIND, acceptExamplesOf, isHttpOperation, isKeyedOperation, isWriteOperation, parseGenerationBlock, pathParametersOf, validateGenerationBlock, type BlockLocation, type DeriveHole, type GenerationBlock, type GenerationBlockParse, type Hole, type HttpOperation, type KeyedOperation, type Operation, type ProjectHole, type ReadOperation, type Reference, type Slot, type TransformHole, type ValidateHole, type ViewHole, type WriteOperation, AdoptedColumnSchema, AlterStepSchema, TableDeclarationSchema, TableRefSchema, parentKeyFieldOf, tableNameOf, tableRefOf, type AdoptedColumn, type AlterStep, type TableDeclaration, type TableRef, } from "./generation-block.schema.js";
+export { EMPTY_GUARD_REGISTRY, GenerationTargetSchema, GuardDenialSchema, GuardRegistryEntrySchema, GuardVariantSchema, ManifestGenerationSchema, ModuleExportSchema, ModuleTypeSchema, caseKeyOfPhrase, readManifestGeneration, type GenerationTarget, type GuardDenial, type GuardRegistry, type GuardRegistryEntry, type GuardVariant, type ManifestGeneration, type ModuleExport, type ModuleType, contractViolationCodeOf, validationOf, type ValidationMode, } from "./manifest-generation.schema.js";
+export { checkBlockAgainstSchemas, type SchemaCheckInput } from "./schema-checks.js";
+export { fieldNamesOf, hasSameFieldsAs, invalidSampleOf, modelOf, modelsOfModule, sampleOf, type FieldModel, type InvalidSampleResult, type SampleResult, type SchemaModel, type SchemaModels, } from "./zod-introspection.js";
+export { HTTP_OPERATION_KINDS, KEYED_OPERATION_KINDS, MOTIF_CATALOG, MOTIF_NAMES, MotifsSchema, WRITE_OPERATION_KINDS, motifErrorStatuses, motifVocabulary, parseUses, provisionalMotifs, type HttpOperationKind, type MotifName, type Motifs, } from "./motif-catalog.js";
+export { extractBehaviorParagraphs, extractGenerationSection, splitTopLevelSections, type BehaviorParagraph, type GenerationSectionLookup, type SpecSection, } from "./spec-sections.js";
+export { CONTRACT_VALIDATION_FAILED, vocabularyOf, type OperationVocabulary } from "./vocabulary.js";
+export { GENERATED_DRIFT, GENERATED_HEADER, GENERATOR_VERSION, verifyGeneration, type GeneratedFileClaim, type SpecOwnerFolder, type VerifiedSpec, type VerifyGenerationInput, type VerifyGenerationReport, } from "./verify-generation.js";
+export { buildFeaturePlan, type DeriveHolePlan, type ElementPlan, type FeaturePlan, type FeaturePlanInput, type HolePlan, type OperationPlan, type ProjectHolePlan, type ReferencePlan, type SlotPlan, type TablePlan, type TransformHolePlan, type ValidateHolePlan, type ViewHolePlan, } from "./emit/plan.js";
+export { GENERATED_FEATURE_FILES, generateFeature, migrationFileNameFor, type GenerateOptions, type GeneratedFile, } from "./generate-feature.js";
+export { HOLES_LIBRARY_DIR, HoleLibraryEntrySchema, HoleProvenanceSchema, HoleShapeSchema, bodyTemplateOf, instantiateBody, libraryEntryOf, libraryFileNameOf, loadHolesLibrary, neighboursOfShape, normalizedTypeOf, shapeHashOf, shapeOfHole, signatureHashOf, signatureTextOf, type HoleLibraryEntry, type HoleProvenance, type HoleShape, } from "./hole-shape.js";
+export { bodyLinesFor, effectParameterLines, holeSignatureLines, isAsyncHole, parseLogicSections, type LogicSection } from "./emit/runtime.js";
+export { ownedTables, tablesOf, viewBodiesOf } from "./emit/db.js";
+export { deepOverlay } from "./emit/hole-tests.js";
+export { readCollectionOf } from "./schema-checks.js";
+export { deniedCodeOf } from "./vocabulary.js";
+export { boundBehaviorsOf } from "./verify-generation.js";
+export { applyManifestEntry, intentForManifest, intentOfSpec, manifestEntryDrift, manifestEntryOf, routeDescriptionOf, serializeManifest, type ApplyManifestEntryResult, type DeclaredManifestEntry, type GeneratedManifestEntry, type ManifestEntryField, type ManifestRouteEntry, } from "./emit/manifest-entry.js";
+export { CONTRACTS_SECTION_TITLE, SPEC_GENERATED_END, applySpecContracts, emitSpecContracts, extractSpecContracts, refusalsOf, specGeneratedStart, type ApplySpecContractsResult, type SpecGeneratedBlock, } from "./emit/spec-contracts.js";
+export { ConsumedFeatureSchema, CustomViewSchema, FormViewSchema, ListViewSchema, SCREEN_BLOCK_KEYS, ScreenBlockSchema, ScreenHoleSchema, ViewSchema, consumerOf, parseScreenBlock, primaryViewOf, validateScreenBlock, type ConsumedFeature, type CustomView, type FormView, type ListView, type ScreenBlock, type ScreenBlockParse, type ScreenHole, type View, } from "./screen-block.schema.js";
+export { blockKindOf, blockProblemOf, readYamlBlock, type YamlBlockRead } from "./generation-block.schema.js";
+export { SCREEN_SUBJECT, parseScreenBehavior, type ParsedScreenBehavior, type ScreenCase, type ScreenParseResult } from "./screen-grammar.js";
+export { FORM_RENDERS, FORM_STATES, READ_RENDERS, READ_STATES, bindScreenBehavior, screenCaseKey, screenVocabularyOf, type ScreenBindingContext, type ScreenBindingOutcome, type ScreenVocabulary, } from "./screen-vocabulary.js";
+export { checkScreenBlock, elementFieldsOf, type ConsumedFeatureCheckInput, type ScreenCheckInput } from "./screen-checks.js";
+export { buildScreenPlan, distinctSampleOf, labelOf, type BoundScreenBehaviorInput, type ConsumedFeatureInput, type ConsumedRoute, type CustomViewPlan, type FormViewPlan, type ListViewPlan, type ScreenBehaviorPlan, type ScreenOperationPlan, type ScreenPlan, type ScreenPlanInput, type ViewFieldPlan, type ViewPlan, } from "./emit/screen-plan.js";
+export { generateScreen, screenBodyDefault, screenBodyPath, type GenerateScreenOptions } from "./generate-screen.js";
+export { emitScreenSpecContracts } from "./emit/screen/spec-contracts.js";
+export { applyGeneratedContracts } from "./emit/spec-contracts.js";
+export { boundScreenBehaviorsOf, type LoadedConsumedForVerify } from "./verify-generation.js";
+export { FrontTargetSchema, type FrontTarget } from "./manifest-generation.schema.js";
+export { DERIVED_READ_GUARD, consumableOperationsOf, derivedReadsOf, readIdOfInputSchema } from "./consumed-feature.js";
+export { fillHole, fillFeature, DEFAULT_FILL_OPTIONS, type Candidate, type FillDeps, type FillOptions, type HoleFillInput, type HoleFillResult, type FeatureFillSummary } from "./fill/fill.js";
+export { replaceHoleBody, extractCandidateBody, forbiddenInBody, isTodoBody, BODY_BANS } from "./fill/body.js";
+export { createModelDrawer, DEFAULT_FILL_MODELS, HOLE_SYSTEM_PROMPT, type FillModels, type ModelDrawer } from "./fill/model-draw.js";
+export { recordLibraryEntry, scrubbedEnvironment, parseFillFlags } from "./cli/fill-command.js";
+export { generationGrammarCard } from "./prompt-card.js";

package/dist/index.js

@@ -0,0 +1,401 @@
+import {
+  AdoptedColumnSchema,
+  AlterStepSchema,
+  BEHAVIOR_UNBOUND,
+  BODY_BANS,
+  CONTRACTS_SECTION_TITLE,
+  CONTRACT_VALIDATION_FAILED,
+  ConsumedFeatureSchema,
+  CustomViewSchema,
+  DEFAULT_FILL_MODELS,
+  DEFAULT_FILL_OPTIONS,
+  DERIVED_READ_GUARD,
+  EMPTY_GUARD_REGISTRY,
+  FORM_RENDERS,
+  FORM_STATES,
+  FormViewSchema,
+  FrontTargetSchema,
+  GENERATED_DRIFT,
+  GENERATED_FEATURE_FILES,
+  GENERATED_HEADER,
+  GENERATION_BLOCK_INVALID,
+  GENERATION_BLOCK_KEYS,
+  GENERATOR_VERSION,
+  GENERIC_CASES,
+  GenerationBlockSchema,
+  GenerationTargetSchema,
+  GuardDenialSchema,
+  GuardRegistryEntrySchema,
+  GuardVariantSchema,
+  HOLES_LIBRARY_DIR,
+  HOLE_KIND_SERVES,
+  HOLE_SYSTEM_PROMPT,
+  HTTP_OPERATION_KINDS,
+  HoleLibraryEntrySchema,
+  HoleProvenanceSchema,
+  HoleSchema,
+  HoleShapeSchema,
+  KEYED_OPERATION_KINDS,
+  ListViewSchema,
+  METHOD_BY_KIND,
+  MOTIF_CATALOG,
+  MOTIF_NAMES,
+  ManifestGenerationSchema,
+  ModuleExportSchema,
+  ModuleTypeSchema,
+  MotifsSchema,
+  OPENING_KEYWORD,
+  OperationSchema,
+  READ_RENDERS,
+  READ_STATES,
+  SCREEN_BLOCK_KEYS,
+  SCREEN_SUBJECT,
+  SPEC_GENERATED_END,
+  SUCCESS_STATUS_BY_KIND,
+  ScreenBlockSchema,
+  ScreenHoleSchema,
+  TableDeclarationSchema,
+  TableRefSchema,
+  ViewSchema,
+  WRITE_OPERATION_KINDS,
+  acceptExamplesOf,
+  applyGeneratedContracts,
+  applyManifestEntry,
+  applySpecContracts,
+  bindBehavior,
+  bindScreenBehavior,
+  blockKindOf,
+  blockProblemOf,
+  bodyLinesFor,
+  bodyTemplateOf,
+  boundBehaviorsOf,
+  boundScreenBehaviorsOf,
+  buildFeaturePlan,
+  buildScreenPlan,
+  caseKeyOfPhrase,
+  checkBlockAgainstSchemas,
+  checkScreenBlock,
+  checkSpec,
+  consumableOperationsOf,
+  consumerOf,
+  contractViolationCodeOf,
+  createModelDrawer,
+  deepOverlay,
+  deniedCodeOf,
+  derivedReadsOf,
+  distinctSampleOf,
+  effectParameterLines,
+  elementFieldsOf,
+  emitScreenSpecContracts,
+  emitSpecContracts,
+  extractBehaviorParagraphs,
+  extractCandidateBody,
+  extractGenerationSection,
+  extractSpecContracts,
+  fieldNamesOf,
+  fillFeature,
+  fillHole,
+  forbiddenInBody,
+  generateFeature,
+  generateScreen,
+  hasSameFieldsAs,
+  holeSignatureLines,
+  instantiateBody,
+  intentForManifest,
+  intentOfSpec,
+  invalidSampleOf,
+  isAsyncHole,
+  isHttpOperation,
+  isKeyedOperation,
+  isLiteralValue,
+  isTodoBody,
+  isWriteOperation,
+  labelOf,
+  libraryEntryOf,
+  libraryFileNameOf,
+  loadHolesLibrary,
+  manifestEntryDrift,
+  manifestEntryOf,
+  migrationFileNameFor,
+  modelOf,
+  modelsOfModule,
+  motifErrorStatuses,
+  motifVocabulary,
+  neighboursOfShape,
+  normalizedTypeOf,
+  ownedTables,
+  parentKeyFieldOf,
+  parseBehavior,
+  parseExpectation,
+  parseFillFlags,
+  parseGenerationBlock,
+  parseLogicSections,
+  parseScreenBehavior,
+  parseScreenBlock,
+  parseUses,
+  pathParametersOf,
+  primaryViewOf,
+  provisionalMotifs,
+  readCollectionOf,
+  readIdOfInputSchema,
+  readManifestGeneration,
+  readYamlBlock,
+  recordLibraryEntry,
+  refusalsOf,
+  replaceHoleBody,
+  routeDescriptionOf,
+  sampleOf,
+  screenBodyDefault,
+  screenBodyPath,
+  screenCaseKey,
+  screenVocabularyOf,
+  scrubbedEnvironment,
+  serializeManifest,
+  shapeHashOf,
+  shapeOfHole,
+  signatureHashOf,
+  signatureTextOf,
+  specGeneratedStart,
+  splitTopLevelSections,
+  tableNameOf,
+  tableRefOf,
+  tablesOf,
+  validateGenerationBlock,
+  validateScreenBlock,
+  validationOf,
+  verifyGeneration,
+  viewBodiesOf,
+  vocabularyOf
+} from "./chunk-WVFHAPGC.js";
+
+// src/prompt-card.ts
+var phrase = (caseKey) => caseKey.replace(/^with:/u, "avec ").replace(/^without:/u, "sans ");
+function guardLines(generation) {
+  if (generation === null || Object.keys(generation.guards).length === 0) return ["- (aucun guard d\xE9clar\xE9 au manifeste : la spec ne peut nommer aucune op\xE9ration HTTP)"];
+  return Object.entries(generation.guards).map(([name, guard]) => {
+    const variants = (guard.variants ?? []).map((variant) => `\xAB avec ${variant.case} \xBB`).join(", ");
+    const denials = guard.denials.map((denial) => `\xAB ${denial.case} \xBB \u2192 ${denial.status} ${denial.code}${denial.perFeature === true ? " (rempla\xE7able par guardDeniedCode)" : ""}`).join(" ; ");
+    return `- \`${name}\` : cas valide \xAB avec ${guard.valid.case} \xBB${variants === "" ? "" : `, variantes ${variants}`} ; refus ${denials}`;
+  });
+}
+function targetLines(generation) {
+  if (generation === null) return ["- aucun bloc `generation` au manifeste : n'\xE9cris PAS de section `# G\xE9n\xE9ration`."];
+  const { target } = 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\`).`);
+  return lines;
+}
+function generationGrammarCard(generation) {
+  const motifs = Object.entries(MOTIF_CATALOG).map(([name, descriptor]) => `\`${name}\`${descriptor.kinds.length === 0 ? "" : ` (${descriptor.kinds.join(", ")})`}${descriptor.provisional === void 0 ? "" : " \u2014 provisoire"}`);
+  const holeKinds = Object.entries(HOLE_KIND_SERVES).map(([kind, serves]) => `\`${kind}\` (sert ${serves.join(", ")})`);
+  const operationKinds = Object.entries(METHOD_BY_KIND).map(([kind, method]) => `\`${kind}\` (${method}, succ\xE8s ${SUCCESS_STATUS_BY_KIND[kind]})`);
+  return [
+    "G\xC9N\xC9RATION (section `# G\xE9n\xE9ration`, facultative) :",
+    "Une spec qui porte `# G\xE9n\xE9ration` est G\xC9N\xC9R\xC9E : routes, base, tests et \xE9crans se d\xE9rivent sans mod\xE8le ; ce qui se pense devient un TROU typ\xE9, rempli ensuite. Alors ses `# Comportements` s'\xE9crivent dans la GRAMMAIRE FERM\xC9E ci-dessous, jamais au format \xC9TANT DONN\xC9 / QUAND / ALORS. Sans `# G\xE9n\xE9ration`, garde le format en trois lignes.",
+    "",
+    `Bloc d'une FEATURE API \u2014 un seul bloc \`\`\`yaml, cl\xE9s ${GENERATION_BLOCK_KEYS.map((key) => `\`${key}\``).join(", ")} :`,
+    '- `contracts: { module: ./schemas.ts, resource: <Nom>Schema, table: snake_case, key?: champ (cl\xE9 m\xE9tier des \xE9critures par cl\xE9), columns?: { champ: "type" } }` \u2014 les sch\xE9mas sont des NOMS (suffixe Schema), jamais du code ; `columns` est FACULTATIF et ne force un type que quand le sch\xE9ma ne suffit pas, parmi la liste ferm\xE9e `text`, `integer`, `bigint`, `boolean`, `date`, `timestamptz`, `uuid`, `jsonb`, `numeric(p,s)`, `varchar(n)`, `char(n)` (jamais un type SQL Server, jamais `not null` : la cible traduit) ; `id` n\'est jamais une cl\xE9 ni une colonne d\xE9clar\xE9e.',
+    `- \`operations\` : ${operationKinds.join(", ")} ; chaque op\xE9ration : \`{ id: camelCase, kind, method, path: /api/\u2026, guard: <un guard ci-dessous>, input: <Nom>Schema, output: <Nom>Schema, holes?: [ids], respondsWith?: <lecture du bloc>, invalidates?: [racine-kebab] }\` ; une \xE9criture par cl\xE9 ajoute \`by: <cl\xE9>\` et \`notFound: CODE\`, son path finit par \`/:<cl\xE9>\`.`,
+    `- \`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\`.`,
+    "",
+    "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>]]`",
+    `- cas g\xE9n\xE9riques : ${GENERIC_CASES.map((key) => `\xAB ${phrase(key)} \xBB`).join(", ")} (\xAB entr\xE9e invalide \xBB = un champ requis absent) ; lecture : \xAB avec lignes \xBB, \xAB sans ligne \xBB ; \xE9criture par cl\xE9 : \xAB avec <cl\xE9> inconnu \xBB ; \`uniqueKey\` : \xAB avec <cl\xE9> d\xE9j\xE0 pris \xBB ; \`refuseWhenReferenced\` : \xAB sans r\xE9f\xE9rence \xBB, \xAB avec ligne r\xE9f\xE9renc\xE9e \xBB.`,
+    "- guards du produit (leurs cas, leurs refus) :",
+    ...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(", ")}.`,
+    "",
+    "Cible du produit :",
+    ...targetLines(generation),
+    "",
+    "Exemple minimal d'une feature :",
+    "```yaml",
+    "contracts: { module: ./schemas.ts, resource: OrderSchema, table: orders, key: code }",
+    "operations:",
+    "  - { id: listAll, kind: read, method: GET, path: /api/orders, guard: <guard>, input: ListOrdersInputSchema, output: ListOrdersOutputSchema, orderBy: [placedOn, desc] }",
+    "  - { id: create, kind: create, method: POST, path: /api/orders, guard: <guard>, input: CreateOrderInputSchema, output: ListOrdersOutputSchema, holes: [deriveOrderCode], respondsWith: listAll, invalidates: [orders] }",
+    "motifs: {}",
+    "holes:",
+    '  - { id: deriveOrderCode, kind: derive, reads: [label], writes: code, error: ORDER_LABEL_INVALID, effects: [], examples: { accept: [{ input: { label: "First order" }, output: "first-order" }], reject: { input: { label: "###" } } } }',
+    "```",
+    "- \xC9TANT DONN\xC9 listAll avec lignes ALORS 200 et orders = lignes, ordre placedOn desc",
+    "- \xC9TANT DONN\xC9 create avec entr\xE9e valide ALORS 201 et created.code = code d\xE9riv\xE9, liste \xE0 jour [hole:deriveOrderCode]",
+    "- \xC9TANT DONN\xC9 create avec entr\xE9e invalide ALORS 400 CONTRACT_VALIDATION_FAILED et suggestedFix"
+  ].join("\n");
+}
+export {
+  AdoptedColumnSchema,
+  AlterStepSchema,
+  BEHAVIOR_UNBOUND,
+  BODY_BANS,
+  CONTRACTS_SECTION_TITLE,
+  CONTRACT_VALIDATION_FAILED,
+  ConsumedFeatureSchema,
+  CustomViewSchema,
+  DEFAULT_FILL_MODELS,
+  DEFAULT_FILL_OPTIONS,
+  DERIVED_READ_GUARD,
+  EMPTY_GUARD_REGISTRY,
+  FORM_RENDERS,
+  FORM_STATES,
+  FormViewSchema,
+  FrontTargetSchema,
+  GENERATED_DRIFT,
+  GENERATED_FEATURE_FILES,
+  GENERATED_HEADER,
+  GENERATION_BLOCK_INVALID,
+  GENERATION_BLOCK_KEYS,
+  GENERATOR_VERSION,
+  GenerationBlockSchema,
+  GenerationTargetSchema,
+  GuardDenialSchema,
+  GuardRegistryEntrySchema,
+  GuardVariantSchema,
+  HOLES_LIBRARY_DIR,
+  HOLE_KIND_SERVES,
+  HOLE_SYSTEM_PROMPT,
+  HTTP_OPERATION_KINDS,
+  HoleLibraryEntrySchema,
+  HoleProvenanceSchema,
+  HoleSchema,
+  HoleShapeSchema,
+  KEYED_OPERATION_KINDS,
+  ListViewSchema,
+  METHOD_BY_KIND,
+  MOTIF_CATALOG,
+  MOTIF_NAMES,
+  ManifestGenerationSchema,
+  ModuleExportSchema,
+  ModuleTypeSchema,
+  MotifsSchema,
+  OPENING_KEYWORD,
+  OperationSchema,
+  READ_RENDERS,
+  READ_STATES,
+  SCREEN_BLOCK_KEYS,
+  SCREEN_SUBJECT,
+  SPEC_GENERATED_END,
+  SUCCESS_STATUS_BY_KIND,
+  ScreenBlockSchema,
+  ScreenHoleSchema,
+  TableDeclarationSchema,
+  TableRefSchema,
+  ViewSchema,
+  WRITE_OPERATION_KINDS,
+  acceptExamplesOf,
+  applyGeneratedContracts,
+  applyManifestEntry,
+  applySpecContracts,
+  bindBehavior,
+  bindScreenBehavior,
+  blockKindOf,
+  blockProblemOf,
+  bodyLinesFor,
+  bodyTemplateOf,
+  boundBehaviorsOf,
+  boundScreenBehaviorsOf,
+  buildFeaturePlan,
+  buildScreenPlan,
+  caseKeyOfPhrase,
+  checkBlockAgainstSchemas,
+  checkScreenBlock,
+  checkSpec,
+  consumableOperationsOf,
+  consumerOf,
+  contractViolationCodeOf,
+  createModelDrawer,
+  deepOverlay,
+  deniedCodeOf,
+  derivedReadsOf,
+  distinctSampleOf,
+  effectParameterLines,
+  elementFieldsOf,
+  emitScreenSpecContracts,
+  emitSpecContracts,
+  extractBehaviorParagraphs,
+  extractCandidateBody,
+  extractGenerationSection,
+  extractSpecContracts,
+  fieldNamesOf,
+  fillFeature,
+  fillHole,
+  forbiddenInBody,
+  generateFeature,
+  generateScreen,
+  generationGrammarCard,
+  hasSameFieldsAs,
+  holeSignatureLines,
+  instantiateBody,
+  intentForManifest,
+  intentOfSpec,
+  invalidSampleOf,
+  isAsyncHole,
+  isHttpOperation,
+  isKeyedOperation,
+  isLiteralValue,
+  isTodoBody,
+  isWriteOperation,
+  labelOf,
+  libraryEntryOf,
+  libraryFileNameOf,
+  loadHolesLibrary,
+  manifestEntryDrift,
+  manifestEntryOf,
+  migrationFileNameFor,
+  modelOf,
+  modelsOfModule,
+  motifErrorStatuses,
+  motifVocabulary,
+  neighboursOfShape,
+  normalizedTypeOf,
+  ownedTables,
+  parentKeyFieldOf,
+  parseBehavior,
+  parseExpectation,
+  parseFillFlags,
+  parseGenerationBlock,
+  parseLogicSections,
+  parseScreenBehavior,
+  parseScreenBlock,
+  parseUses,
+  pathParametersOf,
+  primaryViewOf,
+  provisionalMotifs,
+  readCollectionOf,
+  readIdOfInputSchema,
+  readManifestGeneration,
+  readYamlBlock,
+  recordLibraryEntry,
+  refusalsOf,
+  replaceHoleBody,
+  routeDescriptionOf,
+  sampleOf,
+  screenBodyDefault,
+  screenBodyPath,
+  screenCaseKey,
+  screenVocabularyOf,
+  scrubbedEnvironment,
+  serializeManifest,
+  shapeHashOf,
+  shapeOfHole,
+  signatureHashOf,
+  signatureTextOf,
+  specGeneratedStart,
+  splitTopLevelSections,
+  tableNameOf,
+  tableRefOf,
+  tablesOf,
+  validateGenerationBlock,
+  validateScreenBlock,
+  validationOf,
+  verifyGeneration,
+  viewBodiesOf,
+  vocabularyOf
+};