@ogygie/generate 0.0.0-stage → 0.19.0

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

@@ -0,0 +1,239 @@
+/**
+ * @intent The `generation` block of `ogygie.manifest.json`: what is PRODUCT
+ * and not feature (DECISIONS.md D18, D33, D34). `target` says where and how a
+ * feature is emitted — database, tenancy, tests, migrations folder, column
+ * casing — and the `# Génération` block of a spec never knows it. A guard is a
+ * function `(app, request) → Promise<context>` exported by a module of the API
+ * app; the block names it (`module`, `export`), the type it returns when richer
+ * than the tenant context (`context`), the French case meaning « a session this
+ * guard accepts » (`valid.case`), other VALID sessions and their case
+ * (`variants[]`, another role) and every REFUSAL it can answer (`denials[]`:
+ * status, code, case phrase, `perFeature` when an operation may rename the
+ * code) — each with the test fixture that provokes it, exported by
+ * `fixturesModule`. `signature` names the function giving the signer of a
+ * signed write. `testBench` is the product's in-memory bench, `tenantTable`
+ * the table the tenant column references, `tenantContext` the product's alias
+ * of TenantContext — both required when `target.tenancy` is `column`.
+ * Declared once per product, never repeated spec by spec.
+ *
+ * The block is OPTIONAL and owned by this package: the core's manifest schema
+ * strips the keys it does not know, so a product declares it without any
+ * change to `@ogygie/core`.
+ */
+import { z } from "zod";
+import { type OgygieError } from "@ogygie/core/errors";
+/** A function exported by a module of the API app, path relative to the app folder. */
+export declare const ModuleExportSchema: z.ZodObject<{
+    module: z.ZodString;
+    export: z.ZodString;
+}, z.core.$strict>;
+export type ModuleExport = z.infer<typeof ModuleExportSchema>;
+/** A TYPE exported by a module of the API app. */
+export declare const ModuleTypeSchema: z.ZodObject<{
+    module: z.ZodString;
+    export: z.ZodString;
+}, z.core.$strict>;
+export type ModuleType = z.infer<typeof ModuleTypeSchema>;
+/** D33: the emission target of the product. */
+export declare const GenerationTargetSchema: z.ZodObject<{
+    database: z.ZodEnum<{
+        "postgres-drizzle": "postgres-drizzle";
+        "mssql-raw": "mssql-raw";
+    }>;
+    tenancy: z.ZodEnum<{
+        column: "column";
+        none: "none";
+    }>;
+    tests: z.ZodEnum<{
+        bench: "bench";
+        stub: "stub";
+    }>;
+    migrations: z.ZodString;
+    naming: z.ZodEnum<{
+        camel: "camel";
+        pascal: "pascal";
+    }>;
+    schema: z.ZodOptional<z.ZodString>;
+    validation: z.ZodOptional<z.ZodEnum<{
+        "type-provider": "type-provider";
+        "handler-parse": "handler-parse";
+    }>>;
+    contractViolationCode: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type GenerationTarget = z.infer<typeof GenerationTargetSchema>;
+export type ValidationMode = NonNullable<GenerationTarget["validation"]>;
+/** D37: the validation mode of a target, `type-provider` when it says nothing. */
+export declare function validationOf(target: Pick<GenerationTarget, "validation">): ValidationMode;
+/** D37: the code a target answers to a violated contract, the generator's word when it says nothing. */
+export declare function contractViolationCodeOf(target: Pick<GenerationTarget, "contractViolationCode"> | null | undefined): string;
+/**
+ * D43: the FRONT target of the product — how a screen (D41) is emitted and
+ * tested. `contracts` is the import specifier of a consumed feature's
+ * `schemas.ts` from the front, `{feature}` replaced by the feature id;
+ * `testBench` the function of the front app rendering an element under its
+ * providers (query client, i18n), path relative to the front app. Its shape
+ * follows `tests`: on `jsdom` the render of Testing Library, `(element) =>
+ * render`; on `static-render` (lot 4 M2) `(element, arrange?) => string` — a
+ * fresh query client that `arrange` fills before the element is rendered to
+ * HTML by `renderToStaticMarkup`, and the markup returned.
+ */
+export declare const FrontTargetSchema: z.ZodObject<{
+    tests: z.ZodEnum<{
+        jsdom: "jsdom";
+        "static-render": "static-render";
+    }>;
+    i18n: z.ZodEnum<{
+        lingui: "lingui";
+    }>;
+    router: z.ZodEnum<{
+        code: "code";
+        file: "file";
+    }>;
+    contracts: z.ZodString;
+    testBench: z.ZodObject<{
+        module: z.ZodString;
+        export: z.ZodString;
+    }, z.core.$strict>;
+    stylesheet: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FrontTarget = z.infer<typeof FrontTargetSchema>;
+export declare const GuardDenialSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    code: z.ZodString;
+    case: z.ZodString;
+    fixture: z.ZodString;
+    perFeature: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type GuardDenial = z.infer<typeof GuardDenialSchema>;
+/** D34: another VALID session — a role — whose case becomes a word of the vocabulary. */
+export declare const GuardVariantSchema: z.ZodObject<{
+    case: z.ZodString;
+    fixture: z.ZodString;
+}, z.core.$strict>;
+export type GuardVariant = z.infer<typeof GuardVariantSchema>;
+export declare const GuardRegistryEntrySchema: z.ZodObject<{
+    module: z.ZodString;
+    export: z.ZodString;
+    context: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        export: z.ZodString;
+    }, z.core.$strict>>;
+    valid: z.ZodObject<{
+        case: z.ZodString;
+        fixture: z.ZodString;
+    }, z.core.$strict>;
+    variants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        case: z.ZodString;
+        fixture: z.ZodString;
+    }, z.core.$strict>>>;
+    denials: z.ZodArray<z.ZodObject<{
+        status: z.ZodNumber;
+        code: z.ZodString;
+        case: z.ZodString;
+        fixture: z.ZodString;
+        perFeature: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    fixturesModule: z.ZodString;
+}, z.core.$strict>;
+export type GuardRegistryEntry = z.infer<typeof GuardRegistryEntrySchema>;
+export declare const ManifestGenerationSchema: z.ZodObject<{
+    target: z.ZodObject<{
+        database: z.ZodEnum<{
+            "postgres-drizzle": "postgres-drizzle";
+            "mssql-raw": "mssql-raw";
+        }>;
+        tenancy: z.ZodEnum<{
+            column: "column";
+            none: "none";
+        }>;
+        tests: z.ZodEnum<{
+            bench: "bench";
+            stub: "stub";
+        }>;
+        migrations: z.ZodString;
+        naming: z.ZodEnum<{
+            camel: "camel";
+            pascal: "pascal";
+        }>;
+        schema: z.ZodOptional<z.ZodString>;
+        validation: z.ZodOptional<z.ZodEnum<{
+            "type-provider": "type-provider";
+            "handler-parse": "handler-parse";
+        }>>;
+        contractViolationCode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    tenantTable: z.ZodOptional<z.ZodString>;
+    tenantContext: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        export: z.ZodString;
+    }, z.core.$strict>>;
+    databasePort: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        export: z.ZodString;
+    }, z.core.$strict>>;
+    signature: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        export: z.ZodString;
+    }, z.core.$strict>>;
+    testBench: z.ZodObject<{
+        module: z.ZodString;
+        export: z.ZodString;
+    }, z.core.$strict>;
+    guards: z.ZodRecord<z.ZodString, z.ZodObject<{
+        module: z.ZodString;
+        export: z.ZodString;
+        context: z.ZodOptional<z.ZodObject<{
+            module: z.ZodString;
+            export: z.ZodString;
+        }, z.core.$strict>>;
+        valid: z.ZodObject<{
+            case: z.ZodString;
+            fixture: z.ZodString;
+        }, z.core.$strict>;
+        variants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            case: z.ZodString;
+            fixture: z.ZodString;
+        }, z.core.$strict>>>;
+        denials: z.ZodArray<z.ZodObject<{
+            status: z.ZodNumber;
+            code: z.ZodString;
+            case: z.ZodString;
+            fixture: z.ZodString;
+            perFeature: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        fixturesModule: z.ZodString;
+    }, z.core.$strict>>;
+    front: z.ZodOptional<z.ZodObject<{
+        tests: z.ZodEnum<{
+            jsdom: "jsdom";
+            "static-render": "static-render";
+        }>;
+        i18n: z.ZodEnum<{
+            lingui: "lingui";
+        }>;
+        router: z.ZodEnum<{
+            code: "code";
+            file: "file";
+        }>;
+        contracts: z.ZodString;
+        testBench: z.ZodObject<{
+            module: z.ZodString;
+            export: z.ZodString;
+        }, z.core.$strict>;
+        stylesheet: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ManifestGeneration = z.infer<typeof ManifestGenerationSchema>;
+export type GuardRegistry = ManifestGeneration["guards"];
+export declare const EMPTY_GUARD_REGISTRY: GuardRegistry;
+/** `sans session` → `without:session` ; `avec x` or `x` → `with:x` — the binder's case keys. */
+export declare function caseKeyOfPhrase(phrase: string): string;
+export type ManifestGenerationRead = {
+    ok: true;
+    generation: ManifestGeneration | null;
+} | {
+    ok: false;
+    problems: OgygieError[];
+};
+/** Reads the block from the RAW manifest JSON (the core's parse would have stripped it). */
+export declare function readManifestGeneration(rawManifest: unknown, manifestPath?: string): ManifestGenerationRead;

package/dist/motif-catalog.d.ts

@@ -0,0 +1,175 @@
+/**
+ * @intent The CLOSED catalogue of motifs a spec may instantiate under the
+ * `motifs` key of its `# Génération` block (DECISIONS.md D25, D31): for each
+ * motif, its configuration schema, the methods it exposes to
+ * `operations[].uses` (and which operation kinds each method serves), the HTTP
+ * status every error it raises comes back with, and the VOCABULARY it lends
+ * to behavior lines (D20) — the cases and expectations a line may use and
+ * still be derived without a model. Everything here is DATA: the generation
+ * code of a motif lives next to the emitters, never in a product.
+ *
+ * Six motifs: the two of lot 1 (append-only rows superseded by key, the
+ * all-or-nothing import) and the four of lot 3 (D31) — a key taken once per
+ * tenant, a delete refused while something points at the row, the slot set or
+ * cleared idempotently, and the signature of every write. `signedWrite` is
+ * IMPLICIT: instantiated under `motifs`, it applies to every write operation
+ * without `uses`.
+ *
+ * Case and expectation phrases are French (a spec is for the humans of the
+ * project, AGENTS.md principle 8) and name the configured FIELDS, never a
+ * natural-language rendering of them: `supersedes d'un autre shareClass`,
+ * not « d'une autre classe » — the motif cannot guess the latter. They carry
+ * no word of any domain either: rows, couples, keys, files, references,
+ * slots (« cible ») and signatures, so that the same motif reads the same in
+ * every product.
+ */
+import { z } from "zod";
+/** A camelCase field of the resource schema. */
+export declare const FieldNameSchema: z.ZodString;
+/** A PascalCase exported Zod schema name, `Schema`-suffixed (AGENTS.md template 2). */
+export declare const SchemaNameSchema: z.ZodString;
+/** A camelCase identifier: operation id, hole id, guard name, slot or reference name. */
+export declare const IdentifierSchema: z.ZodString;
+/** A stable error code, the same shape OgygieError enforces. */
+export declare const ErrorCodeSchema: z.ZodString;
+/** The operation kinds the generator emits (D22, D28). */
+export declare const HTTP_OPERATION_KINDS: readonly ["read", "create", "import", "update", "setOrClear", "delete"];
+export type HttpOperationKind = (typeof HTTP_OPERATION_KINDS)[number];
+/** The kinds that write — what `signedWrite` applies to, what `respondsWith` is for. */
+export declare const WRITE_OPERATION_KINDS: readonly HttpOperationKind[];
+/** The kinds that address ONE row by its business key (D28). */
+export declare const KEYED_OPERATION_KINDS: readonly HttpOperationKind[];
+export declare const AppendOnlySupersedesConfigSchema: z.ZodObject<{
+    key: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    errors: z.ZodObject<{
+        duplicate: z.ZodString;
+        mismatch: z.ZodString;
+        alreadySuperseded: z.ZodString;
+        notFound: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AppendOnlySupersedesConfig = z.infer<typeof AppendOnlySupersedesConfigSchema>;
+export declare const AllOrNothingImportConfigSchema: z.ZodObject<{
+    rowSchema: z.ZodString;
+    applies: z.ZodString;
+    maxBytes: z.ZodNumber;
+    error: z.ZodString;
+}, z.core.$strict>;
+export type AllOrNothingImportConfig = z.infer<typeof AllOrNothingImportConfigSchema>;
+/** D31: the key is taken once per tenant — a unique index, a 409 on the doublon. */
+export declare const UniqueKeyConfigSchema: z.ZodObject<{
+    key: z.ZodArray<z.ZodString>;
+    error: z.ZodString;
+}, z.core.$strict>;
+export type UniqueKeyConfig = z.infer<typeof UniqueKeyConfigSchema>;
+/** D31: a delete refused while a declared reference points at the row — the count in `cause`. */
+export declare const RefuseWhenReferencedConfigSchema: z.ZodObject<{
+    reference: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strict>;
+export type RefuseWhenReferencedConfig = z.infer<typeof RefuseWhenReferencedConfigSchema>;
+/** D31: the slot rule — same value, nothing written and the signature untouched; null clears. */
+export declare const IdempotentSetOrClearConfigSchema: z.ZodObject<{
+    slot: z.ZodString;
+}, z.core.$strict>;
+export type IdempotentSetOrClearConfig = z.infer<typeof IdempotentSetOrClearConfigSchema>;
+/** D31: who and when on every write of the resource and its slots — IMPLICIT, no `uses`. */
+export declare const SignedWriteConfigSchema: z.ZodObject<{
+    by: z.ZodString;
+    at: z.ZodString;
+}, z.core.$strict>;
+export type SignedWriteConfig = z.infer<typeof SignedWriteConfigSchema>;
+/** One instance per motif and per feature: the keys ARE the motif names. */
+export declare const MotifsSchema: z.ZodObject<{
+    appendOnlySupersedes: z.ZodOptional<z.ZodObject<{
+        key: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        errors: z.ZodObject<{
+            duplicate: z.ZodString;
+            mismatch: z.ZodString;
+            alreadySuperseded: z.ZodString;
+            notFound: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    allOrNothingImport: z.ZodOptional<z.ZodObject<{
+        rowSchema: z.ZodString;
+        applies: z.ZodString;
+        maxBytes: z.ZodNumber;
+        error: z.ZodString;
+    }, z.core.$strict>>;
+    uniqueKey: z.ZodOptional<z.ZodObject<{
+        key: z.ZodArray<z.ZodString>;
+        error: z.ZodString;
+    }, z.core.$strict>>;
+    refuseWhenReferenced: z.ZodOptional<z.ZodObject<{
+        reference: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strict>>;
+    idempotentSetOrClear: z.ZodOptional<z.ZodObject<{
+        slot: z.ZodString;
+    }, z.core.$strict>>;
+    signedWrite: z.ZodOptional<z.ZodObject<{
+        by: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Motifs = z.infer<typeof MotifsSchema>;
+export type MotifName = keyof Motifs;
+export declare const MOTIF_NAMES: readonly MotifName[];
+export interface MotifMethodDescriptor {
+    readonly name: string;
+    /** The operation kinds this method may serve. */
+    readonly kinds: readonly HttpOperationKind[];
+}
+export interface MotifDescriptor {
+    /** True when `uses` must name a method (`<motif>.<method>`). */
+    readonly requiresMethod: boolean;
+    /** The kinds the motif serves when used without a method. */
+    readonly kinds: readonly HttpOperationKind[];
+    readonly methods: readonly MotifMethodDescriptor[];
+    /** True when the motif applies to every write of the feature without `uses` (signedWrite). */
+    readonly implicit: boolean;
+    /**
+     * D31 precision (2026-10-17): a motif admitted UNDER the D25 threshold on the
+     * authority of the lot 3 brief. `missing` names the occurrence that would
+     * make it a full motif; the flag goes away in one line the day a second
+     * repo uses it in a `delivered` feature. Nothing else of the catalogue
+     * treats it differently.
+     */
+    readonly provisional?: {
+        readonly missing: string;
+    };
+}
+export declare const MOTIF_CATALOG: Readonly<Record<MotifName, MotifDescriptor>>;
+/** The motifs admitted under the D25 threshold, each with the occurrence it still lacks. */
+export declare function provisionalMotifs(): Array<{
+    name: MotifName;
+    missing: string;
+}>;
+export declare function isMotifName(candidate: string): candidate is MotifName;
+/** `appendOnlySupersedes.insert` → motif + method ; `allOrNothingImport` → motif alone. */
+export declare function parseUses(uses: string): {
+    motif: string;
+    method: string | null;
+};
+/**
+ * The HTTP status each motif error comes back with, for the METHOD an
+ * operation uses — a read method raises nothing, `insert` raises the four
+ * errors of the append-only rule, a taken key and a referenced row are 409.
+ * The binder checks a line against it.
+ */
+export declare function motifErrorStatuses(motifs: Motifs, name: MotifName, method: string | null): ReadonlyMap<string, number>;
+/** The words a motif lends to the behavior lines of the operations using it (D20). */
+export interface MotifVocabulary {
+    /** `with:<phrase>` / `without:<phrase>` — the normalized case keys. */
+    readonly cases: readonly string[];
+    /** What may stand on the right of `<path> = …`. */
+    readonly namedValues: readonly string[];
+    /** Whole expectations without a path. */
+    readonly phrases: readonly string[];
+}
+/**
+ * Per METHOD, because a word only has a factory behind it where the method
+ * can produce the situation: `couple déjà en vigueur` is an `insert` case, a
+ * `latestPerKey` read cannot set it up.
+ */
+export declare function motifVocabulary(motifs: Motifs, name: MotifName, method: string | null): MotifVocabulary;

package/dist/package-root.d.ts

@@ -0,0 +1,5 @@
+export declare const PACKAGE_NAME = "@ogygie/generate";
+export declare function packageRootOf(moduleUrl: string): string;
+export declare const PACKAGE_ROOT: string;
+/** The version of the package as its package.json says — stamped in every `@generated` header, compared by `verify` (D27). */
+export declare const PACKAGE_VERSION: string;

package/dist/prompt-card.d.ts

@@ -0,0 +1,3 @@
+import { type ManifestGeneration } from "./manifest-generation.schema.js";
+/** The card, in the language of the brief: the model writes the block and the lines from it, the parser judges them. */
+export declare function generationGrammarCard(generation: ManifestGeneration | null): string;

package/dist/schema-checks.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @intent What the `# Génération` block can only be checked against WITH the
+ * schemas module (DECISIONS.md D19 — spec ogygie-generate B1): every schema
+ * name it cites exists; a hole reads fields its operation's input (or the
+ * import's row schema) has; columns, indexes, order, range, the contracts key
+ * and the motif keys name fields of the resource; the append-only motif finds
+ * `supersedes` and `supersededBy`; an import's input is the `{ csv }`
+ * envelope; every field a factory must populate is derivable or carries an
+ * example the schema accepts; the holes of one operation agree on the fields
+ * their accept examples share; every output can be mapped — a read's element
+ * COVERS the resource and adds only what the block declares (slot arrays,
+ * reference counts, view and project fields), a keyed write's input matches
+ * its kind (partial body, slot value, nothing), a derive writes a resource
+ * field the input does not carry, a signed resource carries its signature and
+ * so do its slots. Each refusal is `OGYGIE_GENERATION_BLOCK_INVALID` at its
+ * path — a schema field is addressed `<module>#<Schema>.<field>`.
+ */
+import { type OgygieError } from "@ogygie/core/errors";
+import { type GenerationBlock } from "./generation-block.schema.js";
+import { type FieldModel, type SchemaModels } from "./zod-introspection.js";
+export interface SchemaCheckInput {
+    block: GenerationBlock;
+    schemas: SchemaModels;
+    /** Spec path, relative to the repo root — the `file` of every refusal. */
+    specPath: string;
+}
+/** The collection of a read output: the ONE array field whose element covers the resource. */
+export declare function readCollectionOf(output: FieldModel, resource: FieldModel): {
+    collection: string;
+    element: FieldModel;
+} | null;
+export declare function checkBlockAgainstSchemas(input: SchemaCheckInput): OgygieError[];

package/dist/schemas/draft.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @intent The first `schemas.ts` of a NEW feature as a hole (DECISIONS.md
+ * D52): produced by the `spec` model from the spec alone — its block, its
+ * behaviours, its data contracts — and judged as a hole is, by the gates
+ * themselves: the module is pure (zod and sibling contracts, nothing else),
+ * every schema the block cites is exported, `check` passes against the
+ * introspected module, every example of the `holes` block parses against the
+ * fields it reads, and the external gates the command runs (typecheck, the
+ * purity of contracts) are green. Two attempts, the problems of the first fed
+ * to the second; then `needs-operator`. Nothing here reads a disk or calls a
+ * model: every effect is injected, so the decision is proven in memory and the
+ * real effects stay in the command. Once retained, the module belongs to the
+ * repo like `logic.ts` (D21): never regenerated (D19, amended in this one
+ * point).
+ */
+import type { GenerationBlock } from "../generation-block.schema.js";
+export declare const SCHEMAS_NEEDS_OPERATOR = "OGYGIE_SCHEMAS_NEEDS_OPERATOR";
+/** D52: two attempts, then the operator. */
+export declare const SCHEMAS_ATTEMPTS = 2;
+/** The stable instructions — the spec is the user turn. */
+export declare const SCHEMAS_SYSTEM_PROMPT: string;
+export interface SchemasCandidate {
+    source: string;
+    model: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+export interface SchemasJudgement {
+    /** Empty when the candidate passes every gate. */
+    problems: string[];
+}
+export interface SchemasDraftDeps {
+    /** One module from the `spec` model; `previous` carries the refused attempt and its problems. */
+    draw(previous: {
+        source: string;
+        problems: string[];
+    } | undefined): Promise<SchemasCandidate>;
+    /** Writes the candidate where the block expects it, then runs every gate; the problems name what refused it. */
+    judge(source: string, attempt: number): Promise<SchemasJudgement>;
+    /** Removes a refused candidate: nothing half-written stays on the branch. */
+    discard(): Promise<void>;
+    log(line: string): void;
+}
+export interface SchemasDraftResult {
+    outcome: "written" | "needs-operator";
+    attempts: number;
+    /** The problems of the LAST refused attempt — what the operator reads first. */
+    problems: string[];
+    model: string | null;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        model: string;
+    }[];
+}
+/** D52's loop: draw, judge, at most twice; the first green is written for good, the second red names the operator. */
+export declare function draftSchemas(deps: SchemasDraftDeps, attempts?: number): Promise<SchemasDraftResult>;
+/** The module in a model's answer: the first fenced block when there is one, otherwise the whole answer, trimmed, one final newline. */
+export declare function extractModuleSource(answer: string): string;
+/**
+ * What a contracts module may not carry — AGENTS.md's bans, and what the
+ * purity of contracts forbids (`verify-contracts`: zod and sibling contracts,
+ * nothing that runs). The banned words are ASSEMBLED from fragments: the
+ * repo's own lint reads source text.
+ */
+export declare function forbiddenInSchemas(source: string): string[];
+/** Every schema name the block cites, with where — what the module MUST export. */
+export declare function citedSchemaNamesOf(block: GenerationBlock): {
+    name: string;
+    role: string;
+}[];
+/**
+ * D52: every example of the `holes` block parsed by the schema it targets —
+ * field by field, against the input of the operation that lists the hole (the
+ * row schema of an import). A field the schema does not expose is a problem
+ * `check` names already; a field that refuses its example is named here.
+ */
+export declare function holeExampleProblems(block: GenerationBlock, moduleExports: Record<string, unknown>): string[];
+/**
+ * What the generated tests will hold the inputs to, checked before any test
+ * runs (épreuve pdlc 2026-10-29): an `update` input refuses an empty body —
+ * `.partial()` alone accepts `{}`, and the contract test of the operation
+ * expects a 400.
+ */
+export declare function writeInputProblems(block: GenerationBlock, moduleExports: Record<string, unknown>): string[];
+/**
+ * Every field of the resource must come from somewhere at a create (épreuve
+ * pdlc 2026-10-29): the create's input, a derive hole, the signature of a
+ * signed write, or the identity — a field nobody sends nor derives is a
+ * column the generated insert cannot fill, and the product's typecheck is
+ * the first to say so, too late.
+ */
+export declare function resourceCoverageProblems(block: GenerationBlock, moduleExports: Record<string, unknown>): string[];
+/** The schemas the block cites that the module does not export — the first thing a draft gets wrong. */
+export declare function missingExportsOf(block: GenerationBlock, exportedNames: readonly string[]): string[];
+export interface SchemasPromptInput {
+    featureId: string;
+    specPath: string;
+    /** Repo-relative path of the module to write. */
+    modulePath: string;
+    specMarkdown: string;
+    block: GenerationBlock;
+    previous: {
+        source: string;
+        problems: string[];
+    } | undefined;
+}
+/** The user turn: the spec whole, the names the block cites, the refused attempt when there is one. */
+export declare function buildSchemasPrompt(input: SchemasPromptInput): string;