@ogygie/generate 0.0.0-stage → 0.19.0

package/dist/emit/plan.d.ts

@@ -0,0 +1,428 @@
+/**
+ * @intent The FEATURE PLAN: everything the emitters need, resolved once from
+ * the `# Génération` block, the introspected schemas (D19), the manifest's
+ * `generation` block and the feature's place on the map — names, columns,
+ * operations with their models and holes, motif instances, the guard imports.
+ * Pure derivation: the same inputs always yield the same plan, and every
+ * emitter reads the plan only, never the block or the schemas directly.
+ * What the block or the schemas cannot answer was refused by `check` before
+ * this runs; the plan therefore throws only on an invariant `check` already
+ * guarantees.
+ */
+import { type DeriveHole, type GenerationBlock, type HttpOperation, type ProjectHole, type TransformHole, type ValidateHole, type ViewHole } from "../generation-block.schema.js";
+import type { ParsedBehavior } from "../behavior-grammar.js";
+import { type GenerationTarget, type GuardRegistryEntry, type ManifestGeneration, type ValidationMode } from "../manifest-generation.schema.js";
+import { type HttpOperationKind, type Motifs } from "../motif-catalog.js";
+import { type FieldModel, type SchemaModels } from "../zod-introspection.js";
+export interface FeaturePlanInput {
+    featureId: string;
+    /** Folder of the feature, relative to the repo root. */
+    folder: string;
+    /** Path of the API app, relative to the repo root. */
+    appPath: string;
+    specPath: string;
+    block: GenerationBlock;
+    schemas: SchemaModels;
+    generation: ManifestGeneration;
+    /** SQL tenant column (`workspace_id`), from the manifest's `tenancy.column` — absent for a target without tenant (D33). */
+    tenantColumn?: string;
+    /** File name of the migration, resolved by the caller (stable across regenerations). */
+    migrationFileName: string;
+    generatorVersion: string;
+    /** The behavior lines of the spec, parsed and bound by `check` (D20): one generated test each. */
+    behaviors: readonly BoundBehaviorInput[];
+}
+/** What `check` established about one behavior line: parsed, and either derivable or carried by a hole. */
+export interface BoundBehaviorInput {
+    behavior: ParsedBehavior;
+    status: "derivable" | "hole";
+}
+export interface BehaviorPlan {
+    raw: string;
+    operation: OperationPlan;
+    behavior: ParsedBehavior;
+    /** The hole carrying the line, when its case or expectation is outside the vocabulary. */
+    hole: HolePlan | null;
+}
+export interface ColumnPlan {
+    /** TS key on the Drizzle table and the row, e.g. `effectiveDate`. */
+    key: string;
+    /** Logical column name (camelCase): the key, unless an adopted table renames it (D36). SQL Server renders it PascalCase, Postgres snake_case. */
+    columnName: string;
+    /** SQL column name, e.g. `effective_date`. */
+    sqlName: string;
+    /** Drizzle builder expression, e.g. `date("effective_date")`. */
+    drizzle: string;
+    /** SQL type, e.g. `date`, `numeric(12,4)`, `text`. */
+    sqlType: string;
+    nullable: boolean;
+    /** Extra SQL clauses: `check (...)`, references, defaults. */
+    sqlClauses: string[];
+    /** The resource field model behind it (null for the tenant column). */
+    model: FieldModel | null;
+}
+export interface ResourceFieldPlan {
+    name: string;
+    model: FieldModel;
+    /** `row.createdAt.toISOString()` for a datetime, `row.x` otherwise. */
+    dtoExpression: string;
+}
+export interface ValidateHolePlan {
+    kind: "validate";
+    id: string;
+    hole: ValidateHole;
+    /** Fields the hole reads, in declared order. */
+    reads: string[];
+    /** The input type the reads are picked from, e.g. `CreateRateInput`. */
+    inputTypeName: string;
+    errorCode: string;
+    accepts: Record<string, unknown>[];
+    reject: Record<string, unknown>;
+}
+export interface TransformHolePlan {
+    kind: "transform";
+    id: string;
+    hole: TransformHole;
+    columns: string[];
+    /** The code the operation's import motif answers — the hole's own, or the motif's. */
+    errorCode: string;
+    /** `ParseRateCsvRow` — the row type the hole returns. */
+    rowTypeName: string;
+}
+/** D32: computes ONE resource field from the input before persistence. */
+export interface DeriveHolePlan {
+    kind: "derive";
+    id: string;
+    hole: DeriveHole;
+    reads: string[];
+    writes: string;
+    /** The input type the reads are picked from, e.g. `CreateGradeInput`. */
+    inputTypeName: string;
+    /** The model of the written field — the `T` of HoleResult<T, Code>. */
+    writesModel: FieldModel;
+    /** The operation's 400 when the derivation refuses; null when the hole never refuses. */
+    errorCode: string | null;
+    accepts: Array<{
+        input: Record<string, unknown>;
+        output: unknown;
+    }>;
+    reject: Record<string, unknown> | null;
+}
+/** D32: shapes the output of a read by caller — receives the guard's context (without its db) and the computed output. */
+export interface ProjectHolePlan {
+    kind: "project";
+    id: string;
+    hole: ProjectHole;
+    /** The context fields the hole reads — its first parameter is `Pick<ProjectionContext, reads>`. */
+    reads: string[];
+    writes: string[];
+    /** The read's output type, e.g. `ListGradesOutput`. */
+    outputTypeName: string;
+    accepts: Array<{
+        context: Record<string, unknown>;
+        input: unknown;
+        output: unknown;
+    }>;
+}
+/** D32: a computation the database does — SQL in the migration, read by the repository as a read-only table. */
+export interface ViewHolePlan {
+    kind: "view";
+    id: string;
+    hole: ViewHole;
+    /** SQL name of the view. */
+    name: string;
+    /** Drizzle constant of its read-only mapping, e.g. `gradeAxisTargets`. */
+    tsName: string;
+    rowType: string;
+    writes: string;
+    /** `array`: one view row per item of the element's array field; `scalar`: one row per resource row. */
+    shape: "array" | "scalar";
+    writesModel: FieldModel;
+    /** The columns the SQL must produce: tenant column, parent key, then the item fields (array) or the value (scalar). */
+    columns: ColumnPlan[];
+    from: string[];
+}
+export type HolePlan = ValidateHolePlan | TransformHolePlan | DeriveHolePlan | ProjectHolePlan | ViewHolePlan;
+/** D36: one replayable step of the bounded ALTER an adopted table receives. */
+export type AlterPlan = {
+    kind: "dropCheck";
+    name: string;
+} | {
+    kind: "addCheck";
+    name: string;
+    column: ColumnPlan;
+} | {
+    kind: "addForeignKey";
+    name: string;
+    columns: ColumnPlan[];
+    references: {
+        table: string;
+        columns: ColumnPlan[];
+    };
+    onDelete: "cascade" | "restrict";
+} | {
+    kind: "addColumn";
+    name: string;
+    column: ColumnPlan;
+};
+export interface TablePlan {
+    sqlName: string;
+    tsName: string;
+    rowType: string;
+    newType: string;
+    /** D36: `owned` — created and owned by the generator; `adopted` — exists in the product, declared shape, never created. */
+    mode: "owned" | "adopted";
+    /** Whether the table has the `id` column; without it the key is the row's identity (D36). */
+    hasId: boolean;
+    /** SQL columns of the primary key when there is no id column (tenant column first); empty otherwise. */
+    primaryKey: string[];
+    /** D36: the bounded ALTER of an adopted table, in declaration order; empty for an owned table. */
+    alter: AlterPlan[];
+    columns: ColumnPlan[];
+    /** Secondary indexes as SQL column lists, tenant column prefixed. */
+    indexes: Array<{
+        name: string;
+        columns: string[];
+    }>;
+    /** Unique indexes (a partial one carries its `where`). */
+    uniques: Array<{
+        name: string;
+        columns: string[];
+        where: string | null;
+    }>;
+    /** Composite foreign keys, SQL columns on both sides. */
+    foreignKeys: Array<{
+        name: string;
+        columns: string[];
+        references: {
+            table: string;
+            columns: string[];
+        };
+        onDelete: "cascade" | "restrict";
+    }>;
+}
+/** D28: a detail table of values by composite key (resource key, slot key). */
+export interface SlotPlan {
+    name: string;
+    schemaName: string;
+    typeName: string;
+    model: FieldModel;
+    /** The slot key field, e.g. `criterionCode`, second path parameter of a setOrClear. */
+    key: string;
+    /** Every value of the slot key when it is an enum — the element lists them all, null for the unset ones. */
+    keyValues: Array<string | number> | null;
+    /** The value field, e.g. `target`. */
+    value: string;
+    /** The array field of the read element, e.g. `targets`. */
+    field: string;
+    /** The TS/SQL column of the slot table pointing at the resource key, e.g. `gradeCode` / `grade_code`. */
+    parentKey: string;
+    parentColumn: string;
+    table: TablePlan;
+    /** The slot fields the element lists, in schema order — the DTO of a slot row. */
+    fields: ResourceFieldPlan[];
+}
+/** D28: a table that points at the resource — counted by refuseWhenReferenced, exposed by countField. */
+export interface ReferencePlan {
+    name: string;
+    tableSql: string;
+    /** The TS/SQL column of the referencing row carrying the resource key. */
+    column: string;
+    columnSql: string;
+    /** The owned table when the block gives a schema (emitted with its factory); null when another feature owns it. */
+    table: TablePlan | null;
+    schemaName: string | null;
+    typeName: string | null;
+    countField: string | null;
+}
+/** The element of a read output: the one array whose element covers the resource. */
+export interface ElementPlan {
+    collection: string;
+    schemaName: string;
+    typeName: string;
+    model: FieldModel;
+}
+export interface OrderPlan {
+    /** A field ordered by an enum schema's declaration order (`ordre TierSchema`). */
+    enumOrder: {
+        field: string;
+        values: Array<string | number>;
+    } | null;
+    tuples: Array<{
+        field: string;
+        direction: "asc" | "desc";
+    }>;
+}
+export interface OperationPlan {
+    id: string;
+    pascalId: string;
+    /** Service function, e.g. `runImport`. */
+    serviceName: string;
+    kind: HttpOperationKind;
+    method: HttpOperation["method"];
+    path: string;
+    /** The path parameters, in order: the key, then the slot key. */
+    pathParameters: string[];
+    guardName: string;
+    /** D34: the code the guard's perFeature refusal answers for this operation. */
+    guardDeniedCode: string | null;
+    inputSchema: string;
+    inputType: string;
+    inputModel: FieldModel;
+    outputSchema: string;
+    outputType: string;
+    outputModel: FieldModel;
+    /** read (and respondsWith): the collection field of the output; create: the resource field; import: the count field. */
+    outputField: string;
+    /** read: output fields echoed from the input, by name. */
+    echoFields: string[];
+    /** The element of the collection, for a read and for a write that responds with one. */
+    element: ElementPlan | null;
+    successStatus: number;
+    motif: {
+        name: string;
+        method: string | null;
+    } | null;
+    /** D28: the business key field of a keyed write, and its 404. */
+    by: string | null;
+    notFound: string | null;
+    slot: SlotPlan | null;
+    /** D30: the read operation whose output this write serves. */
+    respondsWith: string | null;
+    validateHoles: ValidateHolePlan[];
+    transformHole: TransformHolePlan | null;
+    deriveHoles: DeriveHolePlan[];
+    projectHoles: ProjectHolePlan[];
+    viewHoles: ViewHolePlan[];
+    order: OrderPlan | null;
+    limit: number | null;
+    range: string | null;
+    invalidates: string[];
+}
+export interface AppendOnlyPlan {
+    /** `[group, order]` TS keys. */
+    key: [string, string];
+    errors: {
+        duplicate: string;
+        mismatch: string;
+        alreadySuperseded: string;
+        notFound: string;
+    };
+    /** Name of the partial unique index on the current rows. */
+    currentKeyUniqueName: string;
+    /** The enum values of the group field, when it is an enum (latestPerKey order). */
+    groupValues: Array<string | number> | null;
+}
+export interface ImportPlan {
+    rowSchema: string;
+    rowType: string;
+    appliesTo: string;
+    maxBytes: number;
+    errorCode: string;
+}
+export interface GuardPlan {
+    name: string;
+    entry: GuardRegistryEntry;
+    /** Import path of the guard module from the feature folder. */
+    importPath: string;
+    /** Import path of the fixtures module from the feature folder. */
+    fixturesImportPath: string;
+    /** The context type this guard returns — its own `context`, or the product's tenant context (D34). */
+    contextTypeName: string;
+    contextImportPath: string;
+}
+export interface FeaturePlan {
+    featureId: string;
+    pascalName: string;
+    camelName: string;
+    folder: string;
+    appPath: string;
+    specPath: string;
+    generatorVersion: string;
+    migrationFileName: string;
+    /** Repo-relative path of the migration file. */
+    migrationPath: string;
+    /** The tenant column, its TS key and the table it references — null for a target without tenant (D33). */
+    tenant: {
+        column: string;
+        columnKey: string;
+        table: string;
+    } | null;
+    /** D33 (M2): the database port the repositories call when there is no tenant facade (`src/db.ts#Database`); null with a tenant. */
+    databasePort: {
+        typeName: string;
+        importPath: string;
+    } | null;
+    context: {
+        typeName: string;
+        importPath: string;
+    };
+    testBench: {
+        exportName: string;
+        importPath: string;
+    };
+    guards: GuardPlan[];
+    resource: {
+        schemaName: string;
+        typeName: string;
+        model: FieldModel;
+        fields: ResourceFieldPlan[];
+    };
+    table: TablePlan;
+    appendOnly: AppendOnlyPlan | null;
+    importMotif: ImportPlan | null;
+    /** The block's motif configurations as declared — the statuses of their refusals come from the catalog. */
+    motifs: Motifs;
+    /** D33: where and how the feature is emitted. */
+    target: GenerationTarget;
+    /** D37: how the routes validate — the type provider on the route, or `parse` in the handler. */
+    validation: ValidationMode;
+    /** D37: the code the target answers to a violated contract, what the tests expect. */
+    contractViolationCode: string;
+    /** D28: the business key of the keyed writes — its field, its column, the unique that makes it a key. */
+    key: {
+        field: string;
+        column: ColumnPlan;
+        uniqueName: string;
+    } | null;
+    slots: SlotPlan[];
+    references: ReferencePlan[];
+    /** D31: the four motifs of lot 3, as instantiated. */
+    signed: {
+        by: string;
+        at: string;
+    } | null;
+    unique: {
+        key: string[];
+        indexName: string;
+        error: string;
+    } | null;
+    referenced: {
+        reference: ReferencePlan;
+        error: string;
+    } | null;
+    idempotent: {
+        slot: SlotPlan;
+    } | null;
+    /** D31: the product's signer function, when the manifest names one. */
+    signature: {
+        exportName: string;
+        importPath: string;
+    } | null;
+    operations: OperationPlan[];
+    holes: HolePlan[];
+    behaviors: BehaviorPlan[];
+    /** Every schema export name of the module, for index.ts. */
+    schemaExports: string[];
+    /** The introspected schemas, for what needs a field's type after planning (hole shapes). */
+    schemaModels: Readonly<Record<string, FieldModel>>;
+}
+/** How a row field becomes its DTO value: an instant as ISO text; on SQL Server a DATE comes back as a Date and is rendered YYYY-MM-DD (D33 precision, M3). */
+export declare function dtoExpressionOf(name: string, model: FieldModel, sqlType: string | undefined, database: GenerationTarget["database"]): string;
+/** The tenant of a plan, for the emitters of a target that has one — the Postgres emitters never run without it. */
+export declare function tenantOf(plan: FeaturePlan): {
+    column: string;
+    columnKey: string;
+    table: string;
+};
+export declare function buildFeaturePlan(input: FeaturePlanInput): FeaturePlan;

package/dist/emit/repository.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @intent Emits `repository.gen.ts`: the only file of the feature touching the
+ * database, always through tenantDb (AGENTS.md §Multi-tenant). The motifs land
+ * here as functions: appendOnlySupersedes — the current rows per key for every
+ * read operation (its order, limit and range), and the insert that marks the
+ * superseded row BEFORE inserting the new one (id drawn app-side, deferred
+ * foreign key, partial unique index as the belt) — and the all-or-nothing
+ * import's database half (lot 2); the keyed writes of D28 — load by business
+ * key or answer the operation's 404, update the fields sent, set or clear a
+ * slot (same value: nothing written, D31), delete unless a reference points at
+ * the row (409 with the count in cause, D31) —, uniqueKey (409 on a taken
+ * key), signedWrite (who and when on every write), the slot and reference
+ * reads, and the read of every view hole through its read-only mapping (D32).
+ */
+import type { FeaturePlan } from "./plan.js";
+export declare function emitRepository(plan: FeaturePlan): string;

package/dist/emit/routes.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @intent Emits `routes.gen.ts`: one Fastify route per operation, no business
+ * logic — the guard the manifest declares resolves the context, the Zod
+ * schemas validate the contract (CONTRACT_VALIDATION_FAILED with suggestedFix
+ * through the app's error handler) — path parameters included for the keyed
+ * writes (D28: the key, then the slot key, each validated by the schema of its
+ * field) —, the service runs the pipeline (D22). An import route bounds its
+ * body at maxBytes plus a margin so the motif's structured 400 precedes the
+ * server's 413.
+ */
+import type { FieldModel } from "../zod-introspection.js";
+import type { FeaturePlan, OperationPlan } from "./plan.js";
+/** The exported schema whose model is exactly this field's — how a path parameter gets its schema. */
+export declare function schemaNameOfField(plan: FeaturePlan, model: FieldModel): string | null;
+/** The schema of each path parameter of a keyed write: the resource key's, then the slot key's. */
+export declare function pathParameterSchemas(plan: FeaturePlan, operation: OperationPlan): Array<{
+    name: string;
+    schema: string;
+}>;
+/** The arguments the service takes after `deps`: the path parameters, then the input — read on the request (type provider) or on the parsed variables (D37, handler-parse). */
+export declare function serviceArguments(operation: OperationPlan, requestExpression: string, parsed?: boolean): string;
+export declare function emitRoutes(plan: FeaturePlan): string;

package/dist/emit/runtime.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @intent Emits the three files that frame the holes of a feature (D21, D23,
+ * D32): `holes.runtime.gen.ts` — HoleResult, accept/refuse, and `todo`, the
+ * body of an unfilled hole, raising OGYGIE_HOLE_UNFILLED; `logic.ts` — the hole
+ * signatures between `// @hole` / `// @end-hole` markers, the ONLY file of
+ * the folder a human or an agent writes, and only BETWEEN the markers: at
+ * every regeneration a body is kept when its signature is unchanged and reset
+ * to `todo` otherwise, while everything else in the file (header, imports,
+ * row types, signatures, markers) is generated and compared like a `.gen`
+ * file; and `index.ts`, the feature's sole public export point, generated
+ * under its canonical name. A declared effect is a parameter of the signature
+ * (`clock`, `db`) and makes the hole asynchronous; a `view` hole has no
+ * TypeScript signature — its body is SQL in the migration. The runtime is
+ * emitted INTO the feature so a product depends on the generator only at
+ * development time.
+ */
+import type { FeaturePlan, HolePlan } from "./plan.js";
+export declare function emitHolesRuntime(plan: FeaturePlan): string;
+/** The declared effects of a hole, as signature parameters (D32): `clock: Clock`, `db: <tenant facade>`. */
+export declare function effectParameterLines(hole: HolePlan, plan: FeaturePlan): string[];
+/** True when the hole declares an effect: its signature is then asynchronous. */
+export declare function isAsyncHole(hole: HolePlan): boolean;
+/** The TypeScript type of the value a derive hole writes, from its field model. */
+export declare function tsTypeOfModel(model: {
+    kind: string;
+    nullable: boolean;
+    values?: Array<string | number>;
+    integer?: boolean;
+}): string;
+/** The generated signature of one hole, from `// @hole` to the opening brace; empty for a view (its body is SQL). */
+export declare function holeSignatureLines(hole: HolePlan, plan?: FeaturePlan): string[];
+/** `todo` body of a hole, between its signature and its end marker. */
+export declare function holeTodoBodyLines(hole: HolePlan): string[];
+/** One `// @hole` section of an existing logic.ts: its literal signature and its body. */
+export interface LogicSection {
+    id: string;
+    /** From `export function` to the opening brace included. */
+    signature: string;
+    /** The lines between the opening brace and the closing `}` of the function. */
+    body: string;
+}
+/** Reads the hole sections of an existing logic.ts (or of a migration's `-- @hole` sections) — what a regeneration must not lose. */
+export declare function parseLogicSections(logic: string, marker?: string): Map<string, LogicSection>;
+/** The body a regeneration gives a hole: the existing one when its signature is unchanged, `todo` otherwise (B3). */
+export declare function bodyLinesFor(hole: HolePlan, existing: Map<string, LogicSection>, plan?: FeaturePlan): string[];
+export declare function emitLogic(plan: FeaturePlan, existingLogic?: string | null): string;
+export declare function emitIndex(plan: FeaturePlan): string;

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

@@ -0,0 +1,17 @@
+/**
+ * @intent Emits the CONTAINER of a screen, `<Ecran>.container.gen.tsx` (D40):
+ * the hooks — every consumed read and write — a ScreenState on the primary
+ * read, and the body called with served data and actions. Also emits the
+ * body's props interface and the copy interface the body fills: the container
+ * imports `screenCopy` from the written body, the body imports its props type
+ * from here (a type-only cycle, erased at runtime). And `routes.gen.tsx` (D43,
+ * router code): a createRoute factory the app's router adds to its children.
+ * And `index.ts`, the sole public export point of the feature.
+ */
+import type { ScreenPlan } from "../screen-plan.js";
+export declare function bodyPropsLines(plan: ScreenPlan): string[];
+export declare function emitScreenContainer(plan: ScreenPlan): string;
+/** The default body, emitted ONCE when the file is absent and never compared (D40): the views in the block's order, the copy of the states. */
+export declare function emitScreenBodyDefault(plan: ScreenPlan): string;
+export declare function emitScreenRoutes(plan: ScreenPlan): string;
+export declare function emitScreenIndex(plan: ScreenPlan): string;

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

@@ -0,0 +1,14 @@
+/**
+ * @intent Emits `fixtures.gen.ts` of a screen: the deterministic data its
+ * tests serve and send — for every consumed read, the output with two distinct
+ * rows and the empty collection; for every consumed write, the valid input
+ * (the consumed schema's sample under the accept examples of the operation's
+ * holes, D23) and the served output; the OgygieError bodies of an access
+ * denied, of a server failure and of each write's own refusal. Test support
+ * only: imported by the generated tests, never by the screen.
+ */
+import type { ScreenOperationPlan, ScreenPlan } from "../screen-plan.js";
+/** An OgygieError body as the api answers it — the shape every Ogygie failure carries. */
+export declare function failureBodyOf(code: string, message: string, cause: string, suggestedFix: string): Record<string, unknown>;
+export declare function refusalFixtureNameOf(operation: ScreenOperationPlan): string;
+export declare function emitScreenFixtures(plan: ScreenPlan): string;

package/dist/emit/screen/hole-doc.d.ts

@@ -0,0 +1,2 @@
+import type { CustomViewPlan, ScreenPlan } from "../screen-plan.js";
+export declare function emitScreenHoleDoc(plan: ScreenPlan, view: CustomViewPlan): string;

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

@@ -0,0 +1,24 @@
+/**
+ * @intent Emits `<Ecran>.previews.gen.test.tsx` for the `static-render` front
+ * target (spec ogygie-hosted-mode B10, D53): the PREVIEWS of a screen — one
+ * self-contained HTML page per UI state, rendered by the front's bench on the
+ * fixtures the tests already serve: loading (nothing in the cache), error and
+ * denied (the primary read failed with the OgygieFailure an api would answer),
+ * empty (the primary collection served empty, the other reads served) and
+ * nominal (every read served). The preview IS the real screen — the same
+ * container, the same patterns, the same data as the tests — not a drawing of
+ * it.
+ *
+ * It is a test: it proves every state renders, in the loop, under the
+ * product's own Vite transform (the i18n macro). With `OGYGIE_PREVIEW_OUT` set
+ * to a directory, it also WRITES the pages there — that is how `ogygie
+ * generate preview` and the `speculate` job publish them on the spec branch,
+ * under `previews/<id>/<state>.html`, where the hosted studio shows them.
+ * The product's stylesheet, when the front target names one, is inlined
+ * through Vite's `?inline` import so the page carries its tokens.
+ */
+import type { ScreenPlan } from "../screen-plan.js";
+export declare const PREVIEWS_FILE_SUFFIX = ".previews.gen.test.tsx";
+/** The states a preview covers, in the order the hosted studio shows them. */
+export declare function previewStatesOf(plan: ScreenPlan): string[];
+export declare function emitScreenPreviews(plan: ScreenPlan): string;

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

@@ -0,0 +1,10 @@
+/**
+ * @intent Emits `queries.gen.ts` of a screen (D42): one TanStack Query hook
+ * per consumed READ, its cache key the one the manifest client of the core
+ * derives — written as a literal — and its call through `fetchContract` on the
+ * consumed feature's output schema. No key is written by hand in a generated
+ * feature; a read with path parameters or query fields takes them as the
+ * hook's arguments and carries them in its key.
+ */
+import type { ScreenPlan } from "../screen-plan.js";
+export declare function emitScreenQueries(plan: ScreenPlan): string;

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

@@ -0,0 +1,35 @@
+/**
+ * @intent What every screen emitter shares (D40 to D43): the import of the
+ * consumed contracts, the `<Trans>` of a source text, the URL helpers a hook
+ * or a test emits, the names of the body props. Deterministic string building
+ * only, as names.ts.
+ */
+import type { ScreenOperationPlan, ScreenPlan } from "../screen-plan.js";
+/** `<Trans>Effective date</Trans>` — every human text an emitted screen shows goes through the i18n macro (D43). */
+export declare function trans(text: string): string;
+/** The `import { … } from "<contracts>"` line of one consumed feature, values and types sorted. */
+export declare function contractsImportLine(contractsImport: string, values: readonly string[], types: readonly string[]): string | null;
+/** Every consumed feature's contracts import, one line each, grouped by specifier. */
+export declare function contractsImportLines(plan: ScreenPlan, pick: (operation: ScreenOperationPlan) => {
+    values: string[];
+    types: string[];
+}): string[];
+export declare const URL_OF_LINES: string[];
+export declare const PATH_WITH_LINES: string[];
+/** The URL expression of a call: the literal path, with its parameters and, for a GET with input, its query string. */
+export declare function urlExpressionOf(operation: ScreenOperationPlan, paramsExpression: string | null, inputExpression: string | null): string;
+/** `{ code, criterionCode }` — the parameters object of a keyed call, from identifiers of the same names. */
+export declare function paramsObjectOf(operation: ScreenOperationPlan): string | null;
+/** The variables a write hook receives: the input alone, or the parameters with the input. */
+export declare function writeVariablesTypeOf(operation: ScreenOperationPlan): {
+    typeName: string;
+    lines: string[];
+} | null;
+/** The type a MutationLike of a write takes as variables: the `<Op>Variables` of a keyed write (path parameters and input), the input alone otherwise. */
+export declare function mutationVariablesTypeOf(operation: ScreenOperationPlan): string;
+/** The `<Op>Variables` type names a set of writes declares in writes.gen.ts — what a file typing their MutationLike imports from there. */
+export declare function variablesTypesOf(operations: readonly ScreenOperationPlan[]): string[];
+/** `RATES_LIST_ALL` — the fixture prefix of an operation. */
+export declare function fixturePrefixOf(operation: ScreenOperationPlan): string;
+/** The JSON literal of a fixture, two-space indented, deterministic key order as given. */
+export declare function jsonLiteral(value: unknown, indent?: number): string;

package/dist/emit/screen/spec-contracts.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @intent The generated part of a SCREEN spec's `# Contrats de données` (D41,
+ * D42): what the screen consumes — each operation with its route, its hook,
+ * the cache key derived from the map and the roots a write makes stale —, its
+ * views with their fields and the file each one lives in, its custom holes,
+ * and its route. Written between the same `@generated` markers as a feature's,
+ * compared by verify the same way. French prose, English identifiers.
+ */
+import type { ScreenPlan } from "../screen-plan.js";
+export declare function emitScreenSpecContracts(plan: ScreenPlan): string;

package/dist/emit/screen/tests-static.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @intent Emits `<Ecran>.gen.test.tsx` for the `static-render` front target
+ * (D20 for screens, D43): one test per behavior line of the spec, named by the
+ * line, rendering the CONTAINER to HTML with the front's bench
+ * (`renderToStaticMarkup` under the product's providers) — no recording
+ * `fetch`, no gesture. The state of a line is ARRANGED in the query cache
+ * before the render: the consumed reads served from the fixtures, the read the
+ * line speaks of served, emptied or failed with the OgygieFailure an api would
+ * answer, or left unseeded for loading; the renders the line names are read on
+ * the markup — `data-state` of ScreenState, `data-pattern` of the patterns,
+ * `data-view` of a view, the rows of its table and the text of their cells. A
+ * line about a form is a GESTURE (typing, submitting, a refused write): it
+ * stays bound by the grammar — the vocabulary does not depend on the target —
+ * and is a todo here that says why; the jsdom target proves it. A custom view
+ * is proven on its example, red until its body is written; a line carried by a
+ * hole is a todo.
+ */
+import type { ScreenPlan } from "../screen-plan.js";
+/** Why a form line is a todo on this target — the name of the todo ends with it. */
+export declare const STATIC_RENDER_GESTURE_REASON = "geste, hors cible static-render";
+export declare function emitStaticScreenTests(plan: ScreenPlan): string;