@ogygie/generate 0.32.1 → 0.34.0

package/dist/cli/run.js

@@ -37,7 +37,7 @@ import {
   throwOgygieError,
   verifyGeneration,
   writeExtensionRegistries
-} from "../chunk-KQ7RGIBV.js";
+} from "../chunk-UTS27UEI.js";
 
 // src/cli/check-command.ts
 import { existsSync, readFileSync, readdirSync } from "node:fs";

package/dist/emit/db.d.ts

@@ -17,7 +17,6 @@
  * empty marker pair the bench fails on.
  */
 import type { FeaturePlan, TablePlan } from "./plan.js";
-/** Every table of the feature, resource first, then slots, then the references with a schema — adopted ones included (D36). */
 export declare function tablesOf(plan: FeaturePlan): TablePlan[];
 /** The tables the generator CREATES and owns: every table of the feature but the adopted ones (D36). */
 export declare function ownedTables(plan: FeaturePlan): TablePlan[];

package/dist/emit/hole-tests.d.ts

@@ -25,4 +25,6 @@ export declare function holeDeclaresClock(hole: {
         effects?: readonly string[];
     };
 }): boolean;
+/** `sumInPeriod` → `SUM_IN_PERIOD`: the constant name of a hole's examples in factories.gen.ts. */
+export declare function constantNameOf(identifier: string): string;
 export declare function emitHoleTests(plan: FeaturePlan): string;

package/dist/emit/mssql/statements.d.ts

@@ -10,8 +10,10 @@
  * `OUTPUT INSERTED` / `OUTPUT DELETED` so a miss is an empty result, a limit
  * is `OFFSET … FETCH`.
  */
-import type { ColumnPlan, FeaturePlan, SlotPlan } from "../plan.js";
-export type StatementKind = "selectAll" | "selectByKey" | "selectByUniqueKey" | "countByColumn" | "countByKey" | "insert" | "updateByKey" | "selectSlot" | "insertSlot" | "updateSlotById" | "updateSlotByKey" | "deleteById" | "deleteSlotByKey" | "deleteByKey" | "selectView";
+import type { ColumnPlan, FeaturePlan, SharedTablePlan, SlotPlan } from "../plan.js";
+export type StatementKind = "selectAll" | "selectByKey" | "selectByUniqueKey" | "countByColumn" | "countByKey" | "insert" | "updateByKey" | "selectSlot" | "insertSlot" | "updateSlotById" | "updateSlotByKey" | "deleteById" | "deleteSlotByKey" | "deleteByKey" | "selectView"
+/** D60: the rows of a shared table, read as a view is — the stub answers what the test arranged. */
+ | "selectShared";
 export interface Statement {
     /** Key in the exported `SQL` constant, e.g. `selectListAll`. */
     key: string;
@@ -51,5 +53,7 @@ export declare function selectList(plan: FeaturePlan, prefix: string, columns: r
 export declare function mssqlStatements(plan: FeaturePlan): Statement[];
 /** The statement of a key, or a loud failure — the emitters never guess a name. */
 export declare function statementNamed(statements: readonly Statement[], key: string): Statement;
+/** D60: the shared table plan a statement reads, when it reads one. */
+export declare function sharedTableOf(plan: FeaturePlan, statement: Statement): SharedTablePlan | null;
 /** The slot plan a statement belongs to. */
 export declare function slotOf(plan: FeaturePlan, statement: Statement): SlotPlan | null;

package/dist/emit/plan.d.ts

@@ -9,7 +9,7 @@
  * 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 DeriveHole, type GenerationBlock, type HttpOperation, type ProjectHole, type TransformHole, type ValidateHole, type ViewHole, type AggregateHole } 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";
@@ -142,7 +142,46 @@ export interface ViewHolePlan {
     columns: ColumnPlan[];
     from: string[];
 }
-export type HolePlan = ValidateHolePlan | TransformHolePlan | DeriveHolePlan | ProjectHolePlan | ViewHolePlan;
+/** D60: a shared table of the product an aggregate hole reads, typed by the schema of its rows — a read-only mapping, never created nor written. */
+export interface SharedTablePlan {
+    sqlName: string;
+    /** Drizzle constant / stub key of its read-only mapping, e.g. `siteTargets`. */
+    tsName: string;
+    schemaName: string;
+    /** The row type of the schema, e.g. `SiteTarget` — what the hole receives. */
+    typeName: string;
+    /** The database row type, e.g. `SiteTargetRow`. */
+    rowType: string;
+    model: FieldModel;
+    fields: ResourceFieldPlan[];
+    /** Tenant column, then the fields of the schema. */
+    columns: ColumnPlan[];
+}
+/** D60: computes ONE root field of an aggregate read's output from the input pick, the resource rows and the shared rows it names. */
+export interface AggregateHolePlan {
+    kind: "aggregate";
+    id: string;
+    hole: AggregateHole;
+    reads: string[];
+    /** The input type the reads are picked from, e.g. `ReadBalanceInput`. */
+    inputTypeName: string;
+    /** The resource type the rows carry, e.g. `Movement`. */
+    resourceTypeName: string;
+    /** The read's output type, e.g. `ReadBalanceOutput` — the hole answers `Output["<writes>"]`. */
+    outputTypeName: string;
+    writes: string;
+    /** The model of the written output field — the type the hole answers. */
+    writesModel: FieldModel;
+    /** The shared tables the hole receives, in `from` order. */
+    from: SharedTablePlan[];
+    accepts: Array<{
+        input: Record<string, unknown>;
+        rows: Record<string, unknown>[];
+        shared: Record<string, Record<string, unknown>[]>;
+        value: unknown;
+    }>;
+}
+export type HolePlan = ValidateHolePlan | TransformHolePlan | DeriveHolePlan | ProjectHolePlan | ViewHolePlan | AggregateHolePlan;
 /** D36: one replayable step of the bounded ALTER an adopted table receives. */
 export type AlterPlan = {
     kind: "dropCheck";
@@ -294,6 +333,10 @@ export interface OperationPlan {
     deriveHoles: DeriveHolePlan[];
     projectHoles: ProjectHolePlan[];
     viewHoles: ViewHolePlan[];
+    /** D60: the aggregate holes of a read, in declared order. */
+    aggregateHoles: AggregateHolePlan[];
+    /** D60: an aggregate read — no collection of the resource, every root field an echo or a hole's value; `outputField` is then "". */
+    report: boolean;
     order: OrderPlan | null;
     limit: number | null;
     range: string | null;
@@ -387,6 +430,8 @@ export interface FeaturePlan {
     } | null;
     slots: SlotPlan[];
     references: ReferencePlan[];
+    /** D60: the shared tables declared with a schema, read by the aggregate holes. */
+    sharedTables: SharedTablePlan[];
     /** D31: the four motifs of lot 3, as instantiated. */
     signed: {
         by: string;

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

@@ -254,6 +254,16 @@ export declare const ReferenceSchema: z.ZodObject<{
     countField: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type Reference = z.infer<typeof ReferenceSchema>;
+/** D60: a table of the product outside the block, read by an aggregate hole, typed by the schema of its rows — declared, never created nor written. */
+export declare const SharedTableSchema: z.ZodObject<{
+    name: z.ZodString;
+    schema: z.ZodString;
+}, z.core.$strict>;
+/** A shared table: its name alone (read by views only), or its name with the schema of its rows (D60). */
+export declare const SharedTableDeclarationSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    schema: z.ZodString;
+}, z.core.$strict>]>;
 export declare const ContractsSchema: z.ZodObject<{
     module: z.ZodString;
     resource: z.ZodOptional<z.ZodString>;
@@ -379,8 +389,19 @@ export declare const ContractsSchema: z.ZodObject<{
         schema: z.ZodOptional<z.ZodString>;
         countField: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
-    sharedTables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sharedTables: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        schema: z.ZodString;
+    }, z.core.$strict>]>>>;
 }, z.core.$strict>;
+/** D60: a shared table whose rows an aggregate hole receives — its name and the schema of one row. */
+export type SharedTable = z.infer<typeof SharedTableSchema>;
+export type SharedTableDeclaration = z.infer<typeof SharedTableDeclarationSchema>;
+export declare function sharedTableNameOf(declaration: SharedTableDeclaration): string;
+/** The shared tables declared with a schema — the only ones an aggregate hole may read (D60). */
+export declare function typedSharedTablesOf(contracts: {
+    sharedTables?: readonly SharedTableDeclaration[] | undefined;
+}): SharedTable[];
 export declare const OrderBySchema: z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodEnum<{
     asc: "asc";
     desc: "desc";
@@ -770,6 +791,23 @@ export declare const ViewHoleSchema: z.ZodObject<{
         value: z.ZodUnknown;
     }, z.core.$strict>;
 }, z.core.$strict>;
+/** D60: computes ONE root field of an aggregate read's output from the input and the rows — pure, a value, never a refusal. */
+export declare const AggregateHoleSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"aggregate">;
+    reads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    writes: z.ZodString;
+    effects: z.ZodDefault<z.ZodArray<z.ZodLiteral<"clock">>>;
+    examples: z.ZodObject<{
+        accept: z.ZodArray<z.ZodObject<{
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            shared: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+            value: z.ZodUnknown;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export declare const HoleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     id: z.ZodString;
     kind: z.ZodLiteral<"validate">;
@@ -848,6 +886,21 @@ export declare const HoleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         value: z.ZodUnknown;
     }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"aggregate">;
+    reads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    writes: z.ZodString;
+    effects: z.ZodDefault<z.ZodArray<z.ZodLiteral<"clock">>>;
+    examples: z.ZodObject<{
+        accept: z.ZodArray<z.ZodObject<{
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            shared: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+            value: z.ZodUnknown;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
 }, z.core.$strict>], "kind">;
 export type Hole = z.infer<typeof HoleSchema>;
 export type ValidateHole = Extract<Hole, {
@@ -865,6 +918,9 @@ export type ProjectHole = Extract<Hole, {
 export type ViewHole = Extract<Hole, {
     kind: "view";
 }>;
+export type AggregateHole = Extract<Hole, {
+    kind: "aggregate";
+}>;
 /** The accept examples of a validate hole, always as a list (first = the valid input overlay). */
 export declare function acceptExamplesOf(hole: ValidateHole): Record<string, unknown>[];
 /** The kinds of operation each kind of hole may serve (D22, D32). */
@@ -997,7 +1053,10 @@ export declare const GenerationBlockSchema: z.ZodObject<{
             schema: z.ZodOptional<z.ZodString>;
             countField: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
-        sharedTables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sharedTables: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            schema: z.ZodString;
+        }, z.core.$strict>]>>>;
     }, z.core.$strict>;
     operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"read">;
@@ -1244,6 +1303,21 @@ export declare const GenerationBlockSchema: z.ZodObject<{
             rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             value: z.ZodUnknown;
         }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"aggregate">;
+        reads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writes: z.ZodString;
+        effects: z.ZodDefault<z.ZodArray<z.ZodLiteral<"clock">>>;
+        examples: z.ZodObject<{
+            accept: z.ZodArray<z.ZodObject<{
+                input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                shared: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+                value: z.ZodUnknown;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
     }, z.core.$strict>], "kind">>>;
 }, z.core.$strict>;
 export type GenerationBlock = z.infer<typeof GenerationBlockSchema>;

package/dist/hole-shape.d.ts

@@ -10,6 +10,7 @@ export declare const HoleShapeSchema: z.ZodObject<{
         derive: "derive";
         project: "project";
         view: "view";
+        aggregate: "aggregate";
         "custom-view": "custom-view";
     }>;
     reads: z.ZodArray<z.ZodString>;
@@ -48,6 +49,7 @@ export declare const HoleLibraryEntrySchema: z.ZodObject<{
             derive: "derive";
             project: "project";
             view: "view";
+            aggregate: "aggregate";
             "custom-view": "custom-view";
         }>;
         reads: z.ZodArray<z.ZodString>;

package/dist/index.d.ts

@@ -7,7 +7,7 @@
 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 { 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 AggregateHole, type SharedTable, type SharedTableDeclaration, AggregateHoleSchema, SharedTableSchema, sharedTableNameOf, typedSharedTablesOf, 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";
@@ -15,7 +15,7 @@ export { HTTP_OPERATION_KINDS, KEYED_OPERATION_KINDS, MOTIF_CATALOG, MOTIF_NAMES
 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 { buildFeaturePlan, type AggregateHolePlan, type SharedTablePlan, 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";

package/dist/index.js

@@ -1,5 +1,6 @@
 import {
   AdoptedColumnSchema,
+  AggregateHoleSchema,
   AlterStepSchema,
   BEHAVIOR_UNBOUND,
   BODY_BANS,
@@ -58,6 +59,7 @@ import {
   SUCCESS_STATUS_BY_KIND,
   ScreenBlockSchema,
   ScreenHoleSchema,
+  SharedTableSchema,
   TableDeclarationSchema,
   TableRefSchema,
   VIEW_BODY_BANS,
@@ -173,6 +175,7 @@ import {
   serializeManifest,
   shapeHashOf,
   shapeOfHole,
+  sharedTableNameOf,
   signatureHashOf,
   signatureTextOf,
   specGeneratedStart,
@@ -181,6 +184,7 @@ import {
   tableNameOf,
   tableRefOf,
   tablesOf,
+  typedSharedTablesOf,
   validateGenerationBlock,
   validateScreenBlock,
   validationOf,
@@ -189,7 +193,7 @@ import {
   viewCandidateTextOf,
   viewExampleTestName,
   vocabularyOf
-} from "./chunk-KQ7RGIBV.js";
+} from "./chunk-UTS27UEI.js";
 
 // src/prompt-card.ts
 var phrase = (caseKey) => caseKey.replace(/^with:/u, "avec ").replace(/^without:/u, "sans ");
@@ -225,10 +229,10 @@ function generationGrammarCard(generation) {
     "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\" }, sharedTables?: [snake_case] }` \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` ; `sharedTables` nomme les tables du produit HORS du bloc qu'un trou `view` lit (`from`) \u2014 d\xE9clar\xE9es, jamais cr\xE9\xE9es ni \xE9crites ; sans cette d\xE9claration, la vue est refus\xE9e, `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>\` ; une \`read\` ne prend AUCUN param\xE8tre de chemin : le filtre (une soci\xE9t\xE9, une p\xE9riode) passe par les champs de son \`input\`.`,
+    "- `contracts: { module: ./schemas.ts, resource: <Nom>Schema, table: snake_case, key?: champ (cl\xE9 m\xE9tier des \xE9critures par cl\xE9), columns?: { champ: \"type\" }, sharedTables?: [snake_case | { name: snake_case, schema: <Nom>Schema }] }` \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` ; `sharedTables` nomme les tables du produit HORS du bloc qu'un trou `view` lit (`from`) \u2014 d\xE9clar\xE9es, jamais cr\xE9\xE9es ni \xE9crites ; sans cette d\xE9claration, la vue est refus\xE9e, `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>\` ; une \`read\` ne prend AUCUN param\xE8tre de chemin : le filtre (une soci\xE9t\xE9, une p\xE9riode) passe par les champs de son \`input\`. Deux formes de \`read\` (D60) : la LISTE, dont la sortie porte UNE collection de la ressource (\`{ <collection>: [\xE9l\xE9ments], ...\xE9chos de l'entr\xE9e }\`) ; la LECTURE AGR\xC9G\xC9E \u2014 un rapport, des totaux, une s\xE9rie, un top \u2014 dont la sortie ne porte AUCUNE collection et dont chaque champ est un \xE9cho de l'entr\xE9e ou le \`writes\` d'un trou \`aggregate\` : c'est la forme d'un chiffre sur une p\xE9riode, jamais une vue.`,
     `- \`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 \`view\` = \`{ id, kind: view, name: snake_case, from: [tables ou vues lues], writes: <champ de la ressource>, examples: { rows: [{\u2026}], value } }\` \u2014 \`from\` ne lit que la table de la ressource, une table de slot ou de r\xE9f\xE9rence, une autre vue du bloc ou une table de \`contracts.sharedTables\` ; 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 } } }\` ; un \`transform\` (une ligne d'import, D22) = \`{ id, kind: transform, from: text/csv, columns: [colonnes lues], effects: [], error?: CODE, examples: { accept: { input, output }, reject: { input, line? } } }\` ; un \`project\` (la forme de la sortie d'une \`read\` selon l'appelant, D32) = \`{ id, kind: project, reads: [champs du CONTEXTE du guard \u2014 un r\xF4le, un e-mail \u2014 jamais de l'entr\xE9e], writes: [chemins de la sortie, ex. rows[].field], examples: { accept: [{ context: { <champ du contexte>: \u2026 }, input, output }] } }\` \u2014 chaque exemple \`accept\` d'un \`project\` porte son \`context\`, OBLIGATOIRE. Les exemples sont OBLIGATOIRES ; une date d'exemple se rapporte au 2026-01-01 (horloge fig\xE9e des tests).`,
+    `- \`holes\` : ${holeKinds.join(", ")} ; un trou \`view\` = \`{ id, kind: view, name: snake_case, from: [tables ou vues lues], writes: <champ de la ressource>, examples: { rows: [{\u2026}], value } }\` \u2014 \`from\` ne lit que la table de la ressource, une table de slot ou de r\xE9f\xE9rence, une autre vue du bloc ou une table de \`contracts.sharedTables\` ; 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 } } }\` ; un \`transform\` (une ligne d'import, D22) = \`{ id, kind: transform, from: text/csv, columns: [colonnes lues], effects: [], error?: CODE, examples: { accept: { input, output }, reject: { input, line? } } }\` ; un \`project\` (la forme de la sortie d'une \`read\` selon l'appelant, D32) = \`{ id, kind: project, reads: [champs du CONTEXTE du guard \u2014 un r\xF4le, un e-mail \u2014 jamais de l'entr\xE9e], writes: [chemins de la sortie, ex. rows[].field], examples: { accept: [{ context: { <champ du contexte>: \u2026 }, input, output }] } }\` \u2014 chaque exemple \`accept\` d'un \`project\` porte son \`context\`, OBLIGATOIRE ; un \`aggregate\` (un champ d'une lecture agr\xE9g\xE9e calcul\xE9 sur les lignes sous l'entr\xE9e, D60) = \`{ id, kind: aggregate, reads: [champs de l'ENTR\xC9E lus \u2014 une p\xE9riode, un filtre], from?: [tables partag\xE9es d\xE9clar\xE9es AVEC sch\xE9ma], writes: <champ racine de la sortie>, effects: [], examples: { accept: [{ input: { <reads>: \u2026 }, rows: [{ <champs de la ressource>: \u2026 }], shared?: { <table>: [{\u2026}] }, value: <la valeur attendue> }] } }\` \u2014 le trou re\xE7oit TOUTES les lignes et filtre lui-m\xEAme ; un \`view\` ne convient JAMAIS \xE0 un total sur une p\xE9riode : il remplit un champ de chaque ligne. 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 ; 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).`,
     "",
@@ -256,11 +260,25 @@ function generationGrammarCard(generation) {
     "```",
     "- \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"
+    "- \xC9TANT DONN\xC9 create avec entr\xE9e invalide ALORS 400 CONTRACT_VALIDATION_FAILED et suggestedFix",
+    "",
+    "Exemple minimal d'une LECTURE AGR\xC9G\xC9E (D60) \u2014 un total sur une p\xE9riode, sans collection :",
+    "```yaml",
+    "contracts: { module: ./schemas.ts, resource: OrderSchema, table: orders, sharedTables: [{ name: yearly_goals, schema: YearlyGoalSchema }] }",
+    "operations:",
+    "  - { id: readSummary, kind: read, method: GET, path: /api/orders/summary, guard: <guard>, input: ReadOrdersSummaryInputSchema, output: OrdersSummarySchema, holes: [countInPeriod, goalReached] }",
+    "motifs: {}",
+    "holes:",
+    '  - { id: countInPeriod, kind: aggregate, reads: [from, to], writes: orderCount, effects: [], examples: { accept: [{ input: { from: "2026-01-01", to: "2026-01-31" }, rows: [{ placedOn: "2026-01-10" }, { placedOn: "2026-02-03" }], value: 1 }] } }',
+    '  - { id: goalReached, kind: aggregate, reads: [to], from: [yearly_goals], writes: goalReached, effects: [], examples: { accept: [{ input: { to: "2026-01-31" }, rows: [{ placedOn: "2026-01-10" }], shared: { yearly_goals: [{ year: 2026, orderGoal: 1 }] }, value: true }] } }',
+    "```",
+    "- \xC9TANT DONN\xC9 readSummary avec lignes ALORS 200 et orderCount = orderCount d\xE9riv\xE9 [hole:countInPeriod]",
+    "- \xC9TANT DONN\xC9 readSummary sans ligne ALORS 200 et orderCount = 0"
   ].join("\n");
 }
 export {
   AdoptedColumnSchema,
+  AggregateHoleSchema,
   AlterStepSchema,
   BEHAVIOR_UNBOUND,
   BODY_BANS,
@@ -316,6 +334,7 @@ export {
   SUCCESS_STATUS_BY_KIND,
   ScreenBlockSchema,
   ScreenHoleSchema,
+  SharedTableSchema,
   TableDeclarationSchema,
   TableRefSchema,
   VIEW_BODY_BANS,
@@ -432,6 +451,7 @@ export {
   serializeManifest,
   shapeHashOf,
   shapeOfHole,
+  sharedTableNameOf,
   signatureHashOf,
   signatureTextOf,
   specGeneratedStart,
@@ -440,6 +460,7 @@ export {
   tableNameOf,
   tableRefOf,
   tablesOf,
+  typedSharedTablesOf,
   validateGenerationBlock,
   validateScreenBlock,
   validationOf,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogygie/generate",
-  "version": "0.32.1",
+  "version": "0.34.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.32.1",
+    "@ogygie/core": "0.34.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.32.1",
+    "@ogygie/ui": "0.34.0",
     "@starter/api": "0.1.0",
     "@tanstack/react-query": "^5.102.2",
     "@tanstack/react-router": "^1.170.32",