@ogygie/generate 0.32.1 → 0.34.0

package/dist/{chunk-KQ7RGIBV.js → chunk-UTS27UEI.js}

@@ -423,6 +423,8 @@ var ReferenceSchema = z3.strictObject({
   /** A nullable integer field of the read element carrying the count of references. */
   countField: FieldNameSchema.optional()
 });
+var SharedTableSchema = z3.strictObject({ name: TableNameSchema, schema: SchemaNameSchema });
+var SharedTableDeclarationSchema = z3.union([TableNameSchema, SharedTableSchema]);
 var ContractsSchema = z3.strictObject({
   /** Path of the schemas module, relative to the feature folder. */
   module: z3.string().min(1),
@@ -435,9 +437,15 @@ var ContractsSchema = z3.strictObject({
   key: FieldNameSchema.optional(),
   slots: z3.record(IdentifierSchema, SlotSchema).optional(),
   references: z3.record(IdentifierSchema, ReferenceSchema).optional(),
-  /** D32 precision (M3): tables of the product, outside the block, a view hole may read (`from`) — a referential projection, a shared table. Declared, never created nor written. */
-  sharedTables: z3.array(TableNameSchema).optional()
+  /** D32 precision (M3): tables of the product, outside the block, a view hole may read (`from`) — a referential projection, a shared table. Declared, never created nor written. D60: declared WITH the schema of its rows, an aggregate hole reads it typed. */
+  sharedTables: z3.array(SharedTableDeclarationSchema).optional()
 });
+function sharedTableNameOf(declaration) {
+  return typeof declaration === "string" ? declaration : declaration.name;
+}
+function typedSharedTablesOf(contracts) {
+  return (contracts.sharedTables ?? []).filter((declaration) => typeof declaration !== "string");
+}
 var OrderDirectionSchema = z3.enum(["asc", "desc"]);
 var OrderTupleSchema = z3.tuple([FieldNameSchema, OrderDirectionSchema]);
 var OrderBySchema = z3.union([
@@ -582,12 +590,36 @@ var ViewHoleSchema = z3.strictObject({
     value: z3.unknown()
   })
 });
+var AggregateHoleSchema = z3.strictObject({
+  id: IdentifierSchema,
+  kind: z3.literal("aggregate"),
+  /** The fields of the input the hole reads — its first parameter is `Pick<input, reads>`; may be empty. */
+  reads: z3.array(FieldNameSchema).default([]),
+  /** Shared tables declared WITH a schema under contracts.sharedTables, whose rows the hole receives, typed. */
+  from: z3.array(TableNameSchema).optional(),
+  /** The root field of the read's output the hole writes. */
+  writes: FieldNameSchema,
+  /** The clock is the only effect an aggregate may declare: it receives its rows, it never reads the database. */
+  effects: z3.array(z3.literal("clock")).default([]),
+  examples: z3.strictObject({
+    /** One complete case per example: the input (its `reads`), the resource rows, the shared rows by table, the value the hole must answer. */
+    accept: z3.array(
+      z3.strictObject({
+        input: ExampleRecordSchema.optional(),
+        rows: z3.array(ExampleRecordSchema),
+        shared: z3.record(TableNameSchema, z3.array(ExampleRecordSchema)).optional(),
+        value: z3.unknown()
+      })
+    ).min(1)
+  })
+});
 var HoleSchema = z3.discriminatedUnion("kind", [
   ValidateHoleSchema,
   TransformHoleSchema,
   DeriveHoleSchema,
   ProjectHoleSchema,
-  ViewHoleSchema
+  ViewHoleSchema,
+  AggregateHoleSchema
 ]);
 function acceptExamplesOf(hole) {
   return Array.isArray(hole.examples.accept) ? hole.examples.accept : [hole.examples.accept];
@@ -597,7 +629,8 @@ var HOLE_KIND_SERVES = {
   transform: ["import"],
   derive: ["create"],
   project: ["read"],
-  view: ["read"]
+  view: ["read"],
+  aggregate: ["read"]
 };
 var GenerationBlockShapeSchema = z3.strictObject({
   contracts: ContractsSchema,
@@ -793,12 +826,28 @@ function checkCrossReferences(block, issue) {
         }
       });
     }
+    if (hole.kind === "aggregate") {
+      const typed = new Set(typedSharedTablesOf(block.contracts).map((table) => table.name));
+      for (const source of hole.from ?? []) {
+        if (!typed.has(source)) {
+          issue(["holes", index, "from"], `aggregate hole "${hole.id}" reads "${source}", which is not a shared table declared with a schema: declare it as contracts.sharedTables: [{ name: ${source}, schema: <RowSchema> }] (D60) \u2014 a bare name serves view holes only`);
+        }
+      }
+      const reads = new Set(hole.reads);
+      hole.examples.accept.forEach((example, position) => {
+        const outside = Object.keys(example.input ?? {}).filter((key) => !reads.has(key));
+        if (outside.length > 0) issue(["holes", index, "examples"], `examples.accept[${position}].input reads ${outside.join(", ")}, which is not in reads (${hole.reads.join(", ") || "none"})`);
+        const unknownTables = Object.keys(example.shared ?? {}).filter((table) => !(hole.from ?? []).includes(table));
+        if (unknownTables.length > 0) issue(["holes", index, "examples"], `examples.accept[${position}].shared carries ${unknownTables.join(", ")}, which is not in from (${(hole.from ?? []).join(", ") || "none"})`);
+        if (!("value" in example)) issue(["holes", index, "examples"], `examples.accept[${position}] has no value: an aggregate example says what the hole answers for its rows`);
+      });
+    }
     if (hole.kind === "view") {
       const known = /* @__PURE__ */ new Set([
         ...block.contracts.table === void 0 ? [] : [tableNameOf(block.contracts.table)],
         ...Object.values(slots).map((slot) => tableNameOf(slot.table)),
         ...Object.values(references).map((reference) => tableNameOf(reference.table)),
-        ...block.contracts.sharedTables ?? [],
+        ...(block.contracts.sharedTables ?? []).map(sharedTableNameOf),
         ...viewNames
       ]);
       known.delete(hole.name);
@@ -1209,6 +1258,7 @@ function vocabularyOf(operation, block, guards = EMPTY_GUARD_REGISTRY, contractV
       namedValues.add(`${hole.writes} d\xE9riv\xE9`);
       if (hole.error !== void 0) codes.set(hole.error, 400);
     }
+    if (hole?.kind === "aggregate") namedValues.add(`${hole.writes} d\xE9riv\xE9`);
   }
   return { cases, namedValues, phrases, codes, successStatus: SUCCESS_STATUS_BY_KIND[operation.kind] };
 }
@@ -2313,6 +2363,14 @@ function checkBlockAgainstSchemas(input) {
     }
     if (model !== null) checkAdoptedShape(tableRefOf(reference.table), `contracts.references.${name}.table`, model, [], issue);
   }
+  const sharedModels = /* @__PURE__ */ new Map();
+  (block.contracts.sharedTables ?? []).forEach((declaration, position) => {
+    if (typeof declaration === "string") return;
+    const model = exists(declaration.schema, `contracts.sharedTables.${position}.schema`);
+    if (model === null) return;
+    if (model.kind !== "object") issue(`contracts.sharedTables.${position}.schema`, `${declaration.schema} is not an object schema: a shared table's schema describes one row`, "Name a z.object() schema of one row of the shared table (D60).");
+    else sharedModels.set(declaration.name, model);
+  });
   const supersedesMotif = block.motifs.appendOnlySupersedes;
   if (supersedesMotif !== void 0 && resource !== null && resource.kind === "object") {
     const missing = ["supersedes", "supersededBy"].filter((field) => {
@@ -2416,6 +2474,22 @@ function checkBlockAgainstSchemas(input) {
           );
         }
       }
+      if (hole.kind === "aggregate") {
+        const outside = hole.reads.filter((field) => !inputFields.has(field));
+        if (outside.length > 0) issue(`holes.${holeIndex}.reads`, `aggregate hole "${hole.id}" reads ${outside.join(", ")}, not field(s) of ${operation.input}`, "An aggregate hole reads fields of the input of the read it serves (D60).");
+        if (inputFields.has(hole.writes)) issue(`holes.${holeIndex}.writes`, `aggregate hole "${hole.id}" writes "${hole.writes}", which ${operation.input} already carries: an echo of the input is served as is, nothing to compute`, "Write a field of the output the input does not carry (D60).");
+        hole.examples.accept.forEach((example, position) => {
+          const rowsOutside = [...new Set(example.rows.flatMap((row) => Object.keys(row).filter((key) => !resourceFields.has(key))))];
+          if (rowsOutside.length > 0) issue(`holes.${holeIndex}.examples`, `examples.accept[${position}].rows carry ${rowsOutside.join(", ")}, not field(s) of ${block.contracts.resource ?? "the resource"}`, "The rows of an aggregate example are rows of the resource schema, partial allowed: the test completes them (D60).");
+          for (const [table, sharedRows] of Object.entries(example.shared ?? {})) {
+            const model = sharedModels.get(table);
+            if (model === void 0) continue;
+            const fields = new Set(fieldNamesOf(model));
+            const sharedOutside = [...new Set(sharedRows.flatMap((row) => Object.keys(row).filter((key) => !fields.has(key))))];
+            if (sharedOutside.length > 0) issue(`holes.${holeIndex}.examples`, `examples.accept[${position}].shared.${table} carries ${sharedOutside.join(", ")}, not field(s) of its schema`, "The shared rows of an aggregate example are rows of the shared table's schema (D60).");
+          }
+        });
+      }
       if (hole.kind === "derive" && resource !== null) {
         if (!resourceFields.has(hole.writes)) {
           issue(`holes.${holeIndex}.writes`, `derive hole "${hole.id}" writes "${hole.writes}", which is not a field of ${block.contracts.resource}`, "A derive hole writes a field of the resource (D32).");
@@ -2497,12 +2571,29 @@ function checkOutputMapping(operation, index, output, inputFields, resource, blo
   const entries = Object.entries(output.fields);
   if (operation.kind === "read") {
     const collection = readCollectionOf(output, resource);
+    const aggregates = (operation.holes ?? []).map((id) => block.holes.find((candidate) => candidate.id === id)).flatMap((hole) => hole?.kind === "aggregate" ? [hole] : []);
+    const aggregateWrites = new Set(aggregates.map((hole) => hole.writes));
+    for (const hole of aggregates) {
+      if (!(hole.writes in output.fields)) {
+        issue(`holes.${block.holes.indexOf(hole)}.writes`, `aggregate hole "${hole.id}" writes "${hole.writes}", which is not a root field of ${operation.output}`, "An aggregate hole writes a root field of the read's output (D60).");
+      }
+    }
     if (collection === null) {
-      issue(
-        path,
-        `${operation.output} must carry exactly one array whose element covers ${resourceLabel(resource)} \u2014 found ${entries.map(([name]) => name).join(", ")}`,
-        "Shape a read output as { <collection>: z.array(ResourceView), ...echoed input fields, ...project fields }."
+      if (aggregates.length === 0) {
+        issue(
+          path,
+          `${operation.output} must carry exactly one array whose element covers ${resourceLabel(resource)} \u2014 found ${entries.map(([name]) => name).join(", ")}`,
+          "Shape a read output as { <collection>: z.array(ResourceView), ...echoed input fields, ...project fields } \u2014 or, for a report computed over the rows (an aggregate read, D60), carry no collection and write every other field with an aggregate hole: { id, kind: aggregate, reads: [input fields], writes: <field>, examples: { accept: [{ input, rows, value }] } }."
+        );
+        return;
+      }
+      const projectRootsOfReport = new Set(
+        (operation.holes ?? []).map((id) => block.holes.find((candidate) => candidate.id === id)).flatMap((hole) => hole?.kind === "project" ? hole.writes.filter((write) => !write.includes("[]")) : [])
       );
+      const others = entries.filter(([name]) => !inputFields.has(name) && !aggregateWrites.has(name) && !projectRootsOfReport.has(name));
+      if (others.length > 0) {
+        issue(path, `${operation.output} carries ${others.map(([name]) => name).join(", ")}: neither an echo of the input nor written by an aggregate hole of "${operation.id}"`, "In an aggregate read (D60) every root field of the output is an echo of the input (same name) or the writes of an aggregate hole the operation lists: declare a hole { kind: aggregate, writes: <field>, \u2026 } for each computed field.");
+      }
       return;
     }
     const projectRoots = new Set(
@@ -2514,7 +2605,7 @@ function checkOutputMapping(operation, index, output, inputFields, resource, blo
     const viewFields2 = new Set(
       (operation.holes ?? []).map((id) => block.holes.find((candidate) => candidate.id === id)).flatMap((hole) => hole?.kind === "view" ? [hole.writes] : [])
     );
-    const rootOthers = entries.filter(([name]) => name !== collection.collection && !inputFields.has(name) && !projectRoots.has(name));
+    const rootOthers = entries.filter(([name]) => name !== collection.collection && !inputFields.has(name) && !projectRoots.has(name) && !aggregateWrites.has(name));
     if (rootOthers.length > 0) {
       issue(path, `${operation.output} carries ${rootOthers.map(([name]) => name).join(", ")} at its root: neither an echo of the input nor a field a project hole writes`, "A read output's root holds the collection, echoes of the input and the fields of its project holes.");
     }
@@ -3091,10 +3182,6 @@ function orderPlanOf(operation, schemas, resourceFields) {
   const tuples = typeof operation.orderBy[0] === "string" ? [operation.orderBy] : operation.orderBy;
   return { enumOrder: null, tuples: tuples.map(([field, direction]) => ({ field, direction })) };
 }
-function tenantOf(plan) {
-  if (plan.tenant === null) throw new Error("generation plan: this emitter needs a tenant column (target.tenancy column) \u2014 a target without tenant is emitted by the mssql emitters");
-  return plan.tenant;
-}
 function schemaNameOfModel(model, schemas, except) {
   const wanted = JSON.stringify({ ...model, optional: false, nullable: model.nullable, examples: [] });
   for (const [name, entry] of Object.entries(schemas)) {
@@ -3378,6 +3465,22 @@ function buildFeaturePlan(input) {
     }
     return null;
   };
+  const sharedTables = typedSharedTablesOf(block.contracts).map((declaration) => {
+    const model = modelNamed2(schemas, declaration.schema);
+    const fields = objectFields(model, declaration.schema);
+    const sharedColumns = [...tenantColumns(), ...Object.entries(fields).map(([name, fieldModel2]) => columnOf(name, fieldModel2, void 0))];
+    const typeName = typeNameOfSchema(declaration.schema);
+    return {
+      sqlName: declaration.name,
+      tsName: camelOfSnake(declaration.name),
+      schemaName: declaration.schema,
+      typeName,
+      rowType: `${typeName}Row`,
+      model,
+      fields: Object.entries(fields).map(([name, fieldModel2]) => ({ name, model: fieldModel2, dtoExpression: dtoExpressionOf(name, fieldModel2, sharedColumns.find((column) => column.key === name)?.sqlType, generation.target.database) })),
+      columns: sharedColumns
+    };
+  });
   const holes = block.holes.map((hole) => {
     const carrier = block.operations.find((operation) => isHttpOperation(operation) && (operation.holes ?? []).includes(hole.id));
     invariant(carrier !== void 0 && isHttpOperation(carrier), `hole ${hole.id} has no carrier`);
@@ -3424,6 +3527,29 @@ function buildFeaturePlan(input) {
     if (hole.kind === "project") {
       return { kind: "project", id: hole.id, hole, reads: hole.reads, writes: hole.writes, outputTypeName: typeNameOfSchema(carrier.output), accepts: hole.examples.accept };
     }
+    if (hole.kind === "aggregate") {
+      const outputModel = modelNamed2(schemas, carrier.output);
+      const writesModel2 = outputModel.kind === "object" ? outputModel.fields[hole.writes] : void 0;
+      invariant(writesModel2 !== void 0, `aggregate hole ${hole.id} writes an unknown output field`);
+      const from = (hole.from ?? []).map((name) => {
+        const table = sharedTables.find((candidate) => candidate.sqlName === name);
+        invariant(table !== void 0, `aggregate hole ${hole.id} reads an undeclared shared table ${name}`);
+        return table;
+      });
+      return {
+        kind: "aggregate",
+        id: hole.id,
+        hole,
+        reads: hole.reads,
+        inputTypeName: typeNameOfSchema(carrier.input),
+        resourceTypeName: resourceType,
+        outputTypeName: typeNameOfSchema(carrier.output),
+        writes: hole.writes,
+        writesModel: writesModel2,
+        from,
+        accepts: hole.examples.accept.map((example) => ({ input: example.input ?? {}, rows: example.rows, shared: example.shared ?? {}, value: example.value }))
+      };
+    }
     const element = elementOf(carrier);
     invariant(element !== null && element.model.kind === "object", `view hole ${hole.id}: the read has no element`);
     const writesModel = element.model.fields[hole.writes];
@@ -3473,6 +3599,9 @@ function buildFeaturePlan(input) {
       else if (operation.kind === "import" && model.kind === "number") outputField = name;
       else if (name in inputFields) echoFields.push(name);
     }
+    const aggregateIds = new Set(block.holes.filter((hole) => hole.kind === "aggregate").map((hole) => hole.id));
+    const report2 = operation.kind === "read" && element === null && (operation.holes ?? []).some((id) => aggregateIds.has(id));
+    if (report2) outputField = "";
     invariant(outputField !== void 0, `${operation.output} has no mappable field`);
     const opHoles = (operation.holes ?? []).map((id) => {
       const hole = holeById.get(id);
@@ -3513,6 +3642,8 @@ function buildFeaturePlan(input) {
       deriveHoles: opHoles.filter((hole) => hole.kind === "derive"),
       projectHoles: opHoles.filter((hole) => hole.kind === "project"),
       viewHoles: opHoles.filter((hole) => hole.kind === "view"),
+      aggregateHoles: opHoles.filter((hole) => hole.kind === "aggregate"),
+      report: report2,
       order: orderPlanOf(operation, schemas, resourceFields),
       limit: operation.kind === "read" ? operation.limit ?? null : null,
       range: operation.kind === "read" ? operation.range ?? null : null,
@@ -3585,6 +3716,7 @@ function buildFeaturePlan(input) {
     key: keyField === null || keyColumn === void 0 || keyUniqueName === null ? null : { field: keyField, column: keyColumn, uniqueName: keyUniqueName },
     slots,
     references,
+    sharedTables,
     signed: block.motifs.signedWrite ?? null,
     unique,
     referenced: (() => {
@@ -3724,6 +3856,19 @@ function holeSignatureLines(hole, plan) {
     ];
   }
   if (hole.kind === "view") return [];
+  if (hole.kind === "aggregate") {
+    const picks = hole.reads.length === 0 ? "Record<never, never>" : `Pick<${hole.inputTypeName}, ${hole.reads.map((field) => quote(field)).join(" | ")}>`;
+    const shared = hole.from.length === 0 ? [] : [`  shared: { ${hole.from.map((table) => `${table.tsName}: readonly ${table.typeName}[]`).join("; ")} },`];
+    return [
+      `// @hole ${hole.id}`,
+      `${prefix} ${hole.id}(`,
+      `  input: ${picks},`,
+      `  rows: readonly ${hole.resourceTypeName}[],`,
+      ...shared,
+      ...effects,
+      `): ${wrapResult(`${hole.outputTypeName}[${quote(hole.writes)}]`)} {`
+    ];
+  }
   return [
     `// @hole ${hole.id}`,
     `${prefix} ${hole.id}(input: { text: string }${effects.length === 0 ? "" : `, ${effects.map((line) => line.trim().replace(/,$/u, "")).join(", ")}`}): ${wrapResult(`HoleResult<${hole.rowTypeName}[], ${quote(hole.errorCode)}>`)} {`
@@ -3778,8 +3923,14 @@ function emitLogic(plan, existingLogic = null) {
   for (const hole of plan.holes) {
     if (hole.kind === "validate" || hole.kind === "derive") inputTypes.add(hole.inputTypeName);
     if (hole.kind === "project") inputTypes.add(hole.outputTypeName);
+    if (hole.kind === "aggregate") {
+      if (hole.reads.length > 0) inputTypes.add(hole.inputTypeName);
+      inputTypes.add(hole.resourceTypeName);
+      inputTypes.add(hole.outputTypeName);
+      for (const table of hole.from) inputTypes.add(table.typeName);
+    }
   }
-  const needsClock = plan.holes.some((hole) => (hole.kind === "validate" || hole.kind === "derive" || hole.kind === "transform") && hole.hole.effects.includes("clock"));
+  const needsClock = plan.holes.some((hole) => (hole.kind === "validate" || hole.kind === "derive" || hole.kind === "transform" || hole.kind === "aggregate") && hole.hole.effects.includes("clock"));
   const needsDb = plan.holes.some((hole) => (hole.kind === "validate" || hole.kind === "derive" || hole.kind === "transform") && hole.hole.effects.includes("db"));
   const hasProject = plan.holes.some((hole) => hole.kind === "project");
   const sections = [];
@@ -3808,7 +3959,8 @@ function emitLogic(plan, existingLogic = null) {
     needsDb ? plan.tenant === null ? `import type { ${plan.databasePort?.typeName ?? "Database"} } from ${quote(plan.databasePort?.importPath ?? "../../db.js")};` : 'import type { TenantDb } from "@ogygie/core/tenant";' : null,
     hasProject ? `import type { ${plan.context.typeName} } from ${quote(plan.context.importPath)};` : null,
     inputTypes.size === 0 ? null : `import type { ${[...inputTypes].sort().join(", ")} } from "./schemas.js";`,
-    'import { accept, refuse, todo, type HoleResult } from "./holes.runtime.gen.js";',
+    // A hole answering a HoleResult needs accept and refuse; an aggregate or a project answers a value — todo alone (D60).
+    plan.holes.some((hole) => hole.kind === "validate" || hole.kind === "derive" || hole.kind === "transform") ? 'import { accept, refuse, todo, type HoleResult } from "./holes.runtime.gen.js";' : 'import { todo } from "./holes.runtime.gen.js";',
     ...hasProject ? [
       "",
       "/** What a project hole may read of the caller: the guard's context without its database (D32). */",
@@ -3895,13 +4047,23 @@ function drizzleTableLines(table, builders, tablesByName) {
 function drizzleViewLines(view, builders) {
   for (const column of view.columns) builders.add(builderOf(column));
   return [
-    `/** READ-ONLY mapping of the view ${view.name} (hole ${view.id}, D32): the SQL lives in the migration, this table shape is what tenantDb reads; nothing is ever written through it. */`,
+    `/** READ-ONLY mapping of the view ${view.name} (hole ${view.id}, D32): the SQL lives in the migration, this table shape is what the repository's facade reads; nothing is ever written through it. */`,
     `export const ${view.tsName} = pgTable(${quote(view.name)}, {`,
     ...view.columns.map((column) => `  ${column.key}: ${column.drizzle},`),
     "});",
     `export type ${view.rowType} = typeof ${view.tsName}.$inferSelect;`
   ];
 }
+function drizzleSharedLines(table, builders) {
+  for (const column of table.columns) builders.add(builderOf(column));
+  return [
+    `/** READ-ONLY mapping of the shared table ${table.sqlName} (D60): a table of the product outside this feature, read by its aggregate holes through the repository's facade; never created nor written here. */`,
+    `export const ${table.tsName} = pgTable(${quote(table.sqlName)}, {`,
+    ...table.columns.map((column) => `  ${column.key}: ${column.drizzle},`),
+    "});",
+    `export type ${table.rowType} = typeof ${table.tsName}.$inferSelect;`
+  ];
+}
 function tablesOf(plan) {
   return [plan.table, ...plan.slots.map((slot) => slot.table), ...plan.references.flatMap((reference) => reference.table === null ? [] : [reference.table])];
 }
@@ -3945,9 +4107,10 @@ function emitDbSchema(plan) {
   const sections = [];
   for (const table of tables) sections.push("", ...drizzleTableLines(table, builders, tablesByName));
   for (const view of views) sections.push("", ...drizzleViewLines(view, builders));
+  for (const table of plan.sharedTables) sections.push("", ...drizzleSharedLines(table, builders));
   const needsSql = tables.some((table) => table.uniques.some((unique) => unique.where !== null));
   const intent = wrap(
-    `Drizzle tables owned by the ${plan.featureId} feature, derived from ${plan.resource.schemaName} (${plan.specPath}, section G\xE9n\xE9ration): tenant-scoped by ${tenantOf(plan).column} (TS key \`${tenantOf(plan).columnKey}\`, the column tenantDb injects and filters).${plan.key === null ? "" : ` The business key ${plan.key.field} is unique per tenant (${plan.key.uniqueName}), the target of every slot and reference foreign key.`}${plan.slots.length === 0 ? "" : ` Slot tables: ${plan.slots.map((slot) => slot.table.sqlName).join(", ")} (cascade with the resource row).`}${plan.references.some((reference) => reference.table !== null) ? ` Reference tables: ${plan.references.flatMap((reference) => reference.table === null ? [] : [reference.table.sqlName]).join(", ")} (a referenced row cannot be deleted).` : ""}${views.length === 0 ? "" : ` Views ${views.map((view) => view.name).join(", ")} are read-only mappings: their SQL is in the migration.`}${plan.appendOnly === null ? "" : ` The append-only key (${plan.appendOnly.key.join(", ")}) is unique among CURRENT rows (superseded_by is null).`} SQL migration: ${plan.migrationPath}.`
+    `Drizzle tables owned by the ${plan.featureId} feature, derived from ${plan.resource.schemaName} (${plan.specPath}, section G\xE9n\xE9ration): ${plan.tenant === null ? "without tenant column (target.tenancy none, D33: the product is single-tenant, the repository reads whole tables through plainDb)" : `tenant-scoped by ${plan.tenant.column} (TS key \`${plan.tenant.columnKey}\`, the column tenantDb injects and filters)`}.${plan.key === null ? "" : ` The business key ${plan.key.field} is unique per tenant (${plan.key.uniqueName}), the target of every slot and reference foreign key.`}${plan.slots.length === 0 ? "" : ` Slot tables: ${plan.slots.map((slot) => slot.table.sqlName).join(", ")} (cascade with the resource row).`}${plan.references.some((reference) => reference.table !== null) ? ` Reference tables: ${plan.references.flatMap((reference) => reference.table === null ? [] : [reference.table.sqlName]).join(", ")} (a referenced row cannot be deleted).` : ""}${views.length === 0 ? "" : ` Views ${views.map((view) => view.name).join(", ")} are read-only mappings: their SQL is in the migration.`}${plan.appendOnly === null ? "" : ` The append-only key (${plan.appendOnly.key.join(", ")}) is unique among CURRENT rows (superseded_by is null).`} SQL migration: ${plan.migrationPath}.`
   );
   return fileOf(
     tsGeneratedHeader(plan.generatorVersion),
@@ -3975,6 +4138,8 @@ function createTableStatements(table) {
   for (const unique of table.uniques.filter((candidate) => candidate.where !== null)) {
     statements.push(`create unique index ${quote(unique.name)} on ${quote(table.sqlName)} (${unique.columns.map(quote).join(", ")}) where ${unique.where ?? ""};`);
   }
+  const tenantColumn = table.columns.find((column) => column.model === null && column.key !== "id");
+  if (tenantColumn === void 0) return statements;
   statements.push(
     "",
     `alter table ${quote(table.sqlName)} enable row level security;`,
@@ -3993,7 +4158,7 @@ function emitMigration(plan, existingMigration = null) {
   const bodies = viewBodiesOf(existingMigration);
   const adopted = tablesOf(plan).filter((candidate) => candidate.mode === "adopted");
   const intent = wrap(
-    `${plan.featureId} feature: the ${plan.table.sqlName} table${tables.length > 1 ? ` and ${tables.slice(1).map((table) => table.sqlName).join(", ")}` : ""}, tenant-scoped by ${tenantOf(plan).column} (derived from ${plan.resource.schemaName}, ${plan.specPath}).${adopted.length === 0 ? "" : ` ${adopted.map((table) => table.sqlName).join(", ")} ${adopted.length > 1 ? "are ADOPTED tables" : "is an ADOPTED table"} (D36): declared in the block, created by the product, altered here within the closed list only.`} Same rails as the socle: foreign key to ${tenantOf(plan).table}, Row-Level Security on every table (AGENTS.md \xA7Multi-tenant 3 \u2014 second rampart, tenantDb remains the first)${plan.appendOnly === null ? "" : ", plus the append-only motif: a partial unique index on the current rows and a DEFERRABLE superseded_by foreign key, so the old row is marked before the new one is inserted"}${views.length === 0 ? "." : `. The views ${views.map((view) => view.name).join(", ")} are HOLES (D32): their SQL stands between the @hole markers below, written by a human, kept at every regeneration; everything else in this file is generated.`}`
+    `${plan.featureId} feature: the ${plan.table.sqlName} table${tables.length > 1 ? ` and ${tables.slice(1).map((table) => table.sqlName).join(", ")}` : ""}, ${plan.tenant === null ? "without tenant column (target.tenancy none, D33)" : `tenant-scoped by ${plan.tenant.column}`} (derived from ${plan.resource.schemaName}, ${plan.specPath}).${adopted.length === 0 ? "" : ` ${adopted.map((table) => table.sqlName).join(", ")} ${adopted.length > 1 ? "are ADOPTED tables" : "is an ADOPTED table"} (D36): declared in the block, created by the product, altered here within the closed list only.`} ${plan.tenant === null ? "No tenant column, no row-level security: the product is single-tenant (D33)" : `Same rails as the socle: foreign key to ${plan.tenant.table}, Row-Level Security on every table (AGENTS.md \xA7Multi-tenant 3 \u2014 second rampart, tenantDb remains the first)`}${plan.appendOnly === null ? "" : ", plus the append-only motif: a partial unique index on the current rows and a DEFERRABLE superseded_by foreign key, so the old row is marked before the new one is inserted"}${views.length === 0 ? "." : `. The views ${views.map((view) => view.name).join(", ")} are HOLES (D32): their SQL stands between the @hole markers below, written by a human, kept at every regeneration; everything else in this file is generated.`}`
   ).map((line, index) => `-- ${index === 0 ? "@intent " : ""}${line}`);
   const statements = [];
   for (const table of tables) statements.push(...statements.length === 0 ? [] : [""], ...createTableStatements(table));
@@ -4011,6 +4176,160 @@ function emitMigration(plan, existingMigration = null) {
   return fileOf(sqlGeneratedHeader(plan.generatorVersion), ...intent, "", ...statements);
 }
 
+// src/emit/hole-tests.ts
+function deepOverlay(base, overlay) {
+  if (Array.isArray(overlay)) {
+    const baseItems = Array.isArray(base) ? base : [];
+    return overlay.map((item, index) => deepOverlay(baseItems[index] ?? baseItems[0], item));
+  }
+  if (overlay !== null && typeof overlay === "object") {
+    const result = base !== null && typeof base === "object" && !Array.isArray(base) ? { ...base } : {};
+    for (const [key, value] of Object.entries(overlay)) result[key] = deepOverlay(result[key], value);
+    return result;
+  }
+  return overlay;
+}
+function sampleUnder(model, overlay) {
+  if (model.kind === "object" && overlay !== null && typeof overlay === "object" && !Array.isArray(overlay)) {
+    const given = overlay;
+    const value = {};
+    for (const [name, field] of Object.entries(model.fields)) {
+      if (name in given) value[name] = sampleUnder(field, given[name]);
+      else if (!field.optional) {
+        const sample = sampleOf(field, [name]);
+        value[name] = sample.ok ? sample.value : null;
+      }
+    }
+    return value;
+  }
+  if (model.kind === "array" && Array.isArray(overlay)) return overlay.map((item) => sampleUnder(model.element, item));
+  return overlay;
+}
+function projectInputOf(plan, carrier, partial) {
+  void plan;
+  return sampleUnder(carrier.outputModel, partial);
+}
+var HOLE_TESTS_CLOCK_INSTANT = "2026-01-01T00:00:00.000Z";
+function holeDeclaresClock(hole) {
+  return (hole.hole.effects ?? []).includes("clock");
+}
+function constantNameOf(identifier) {
+  return identifier.replace(/([a-z0-9])([A-Z])/gu, "$1_$2").toUpperCase();
+}
+function emitHoleTests(plan) {
+  const blocks = [];
+  const testedHoles = plan.holes.filter((hole) => hole.kind !== "view");
+  const needsOutputs = /* @__PURE__ */ new Set();
+  const needsExamples = /* @__PURE__ */ new Set();
+  const needsClock = testedHoles.some((hole) => hole.kind !== "project" && holeDeclaresClock(hole));
+  for (const hole of testedHoles) {
+    const withEffects = (argument) => hole.kind !== "project" && holeDeclaresClock(hole) ? `${argument}, CLOCK` : argument;
+    const call = (argument) => isAsyncHole(hole) ? `await ${hole.id}(${withEffects(argument)})` : `${hole.id}(${withEffects(argument)})`;
+    blocks.push("", `  describe(${quote(hole.id)}, () => {`);
+    if (hole.kind === "validate") {
+      hole.accepts.forEach((accept, index) => {
+        blocks.push(
+          `    it(${quote(`accepte l'exemple ${index + 1} : ${JSON.stringify(accept)}`)}, async () => {`,
+          `      expect((${call(JSON.stringify(accept))}).ok).toBe(true);`,
+          "    });"
+        );
+      });
+      blocks.push(
+        `    it(${quote(`refuse ${JSON.stringify(hole.reject)} avec ${hole.errorCode}${hole.hole.suggestedFix === true ? " et un suggestedFix" : ""}`)}, async () => {`,
+        `      const result = ${call(JSON.stringify(hole.reject))};`,
+        "      expect(result.ok).toBe(false);",
+        "      if (result.ok) return;",
+        `      expect(result.code).toBe(${quote(hole.errorCode)});`,
+        "      expect(result.suggestedFix.length).toBeGreaterThan(0);",
+        "    });"
+      );
+    } else if (hole.kind === "derive") {
+      hole.accepts.forEach((accept, index) => {
+        blocks.push(
+          `    it(${quote(`d\xE9rive ${JSON.stringify(accept.output)} de l'exemple ${index + 1} : ${JSON.stringify(accept.input)}`)}, async () => {`,
+          `      const result = ${call(JSON.stringify(accept.input))};`,
+          "      expect(result.ok).toBe(true);",
+          "      if (!result.ok) return;",
+          `      expect(result.value).toEqual(${JSON.stringify(accept.output)});`,
+          "    });"
+        );
+      });
+      if (hole.reject !== null && hole.errorCode !== null) {
+        blocks.push(
+          `    it(${quote(`refuse ${JSON.stringify(hole.reject)} avec ${hole.errorCode}`)}, async () => {`,
+          `      const result = ${call(JSON.stringify(hole.reject))};`,
+          "      expect(result.ok).toBe(false);",
+          "      if (result.ok) return;",
+          `      expect(result.code).toBe(${quote(hole.errorCode)});`,
+          "      expect(result.suggestedFix.length).toBeGreaterThan(0);",
+          "    });"
+        );
+      }
+    } else if (hole.kind === "project") {
+      const carrier = plan.operations.find((operation) => operation.projectHoles.some((candidate) => candidate.id === hole.id));
+      if (carrier === void 0) throw new Error(`generation plan: project hole ${hole.id} has no carrier`);
+      needsOutputs.add(carrier.outputSchema);
+      hole.accepts.forEach((accept, index) => {
+        blocks.push(
+          `    it(${quote(`forme la sortie pour le contexte ${JSON.stringify(accept.context)} (exemple ${index + 1})`)}, () => {`,
+          `      const input = ${carrier.outputSchema}.parse(${JSON.stringify(projectInputOf(plan, carrier, accept.input))});`,
+          `      expect(${hole.id}(${JSON.stringify(accept.context)}, input)).toMatchObject(${JSON.stringify(accept.output)});`,
+          "    });"
+        );
+      });
+    } else if (hole.kind === "aggregate") {
+      const constant = `EXAMPLES_OF_${constantNameOf(hole.id)}`;
+      needsExamples.add(constant);
+      hole.accepts.forEach((accept, index) => {
+        blocks.push(
+          `    it(${quote(`rend ${JSON.stringify(accept.value)} pour l'exemple ${index + 1} (${accept.rows.length} ligne(s))`)}, async () => {`,
+          `      const example = ${constant}[${index}];`,
+          '      if (example === undefined) throw new Error("example missing");',
+          `      expect(${call(`example.input, example.rows${hole.from.length === 0 ? "" : ", example.shared"}`)}).toEqual(example.value);`,
+          "    });"
+        );
+      });
+    } else {
+      blocks.push(
+        `    it("accepte le fichier exemple et rend ses lignes", async () => {`,
+        `      const result = ${call(`{ text: ${JSON.stringify(hole.hole.examples.accept.input)} }`)};`,
+        "      expect(result.ok).toBe(true);",
+        "      if (!result.ok) return;",
+        `      expect(result.value).toEqual(${JSON.stringify(hole.hole.examples.accept.output)});`,
+        "    });",
+        `    it(${quote(`refuse le fichier illisible avec ${hole.errorCode} et sa ligne`)}, async () => {`,
+        `      const result = ${call(`{ text: ${JSON.stringify(hole.hole.examples.reject.input)} }`)};`,
+        "      expect(result.ok).toBe(false);",
+        "      if (result.ok) return;",
+        `      expect(result.code).toBe(${quote(hole.errorCode)});`,
+        `      expect(result.line).toBe(${JSON.stringify(hole.hole.examples.reject.line ?? 1)});`,
+        "      expect(result.suggestedFix.length).toBeGreaterThan(0);",
+        "    });"
+      );
+    }
+    blocks.push("  });");
+  }
+  return fileOf(
+    tsGeneratedHeader(plan.generatorVersion),
+    intentBlock(
+      wrap(
+        `Pure tests of the holes of ${plan.featureId}, derived from their examples (D23, D32): each accept example passes, the reject example answers the hole's code. Red while a body reads todo; what a candidate body is run against (D24).${plan.holes.length !== testedHoles.length ? " The view holes are proven on the bench, not here." : ""}`
+      )
+    ),
+    'import { describe, expect, it } from "vitest";',
+    needsClock ? 'import { fixedClock } from "@ogygie/core/clock";' : null,
+    `import { ${testedHoles.map((hole) => hole.id).sort().join(", ")} } from "./logic.js";`,
+    needsOutputs.size === 0 ? null : `import { ${[...needsOutputs].sort().join(", ")} } from "./schemas.js";`,
+    needsExamples.size === 0 ? null : `import { ${[...needsExamples].sort().join(", ")} } from "./factories.gen.js";`,
+    needsClock ? "" : null,
+    needsClock ? `const CLOCK = fixedClock(${quote(HOLE_TESTS_CLOCK_INSTANT)});` : null,
+    "",
+    `describe(${quote(`${plan.featureId} \u2014 trous`)}, () => {`,
+    ...blocks,
+    "});"
+  );
+}
+
 // src/hole-shape.ts
 import { createHash } from "node:crypto";
 import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
@@ -4073,7 +4392,7 @@ function normalizedTypeOf(model) {
   return `${base}${model.nullable ? "?" : ""}`;
 }
 var HoleShapeSchema = z6.strictObject({
-  kind: z6.enum(["validate", "transform", "derive", "project", "view", "custom-view"]),
+  kind: z6.enum(["validate", "transform", "derive", "project", "view", "aggregate", "custom-view"]),
   /** Normalized types of the fields read, by position. */
   reads: z6.array(z6.string()),
   /** Transform only: normalized types of the columns, by position. */
@@ -4107,7 +4426,7 @@ function hash16(text) {
 }
 function rowModelOf2(hole, plan) {
   const carrier = plan.operations.find(
-    (operation) => operation.validateHoles.some((candidate) => candidate.id === hole.id) || operation.transformHole?.id === hole.id || operation.deriveHoles.some((candidate) => candidate.id === hole.id)
+    (operation) => operation.validateHoles.some((candidate) => candidate.id === hole.id) || operation.transformHole?.id === hole.id || operation.deriveHoles.some((candidate) => candidate.id === hole.id) || operation.aggregateHoles.some((candidate) => candidate.id === hole.id)
   );
   if (carrier === void 0) return null;
   if (carrier.kind === "import") {
@@ -4143,6 +4462,9 @@ function shapeOfHole(hole, plan) {
   if (hole.kind === "view") {
     return { kind: "view", reads: hole.from.map(() => "table"), columns: hole.columns.map((column) => column.sqlType), codeRole: "none", returns: `view:${hole.shape}` };
   }
+  if (hole.kind === "aggregate") {
+    return { kind: "aggregate", reads: readTypes(hole.reads), columns: ["rows", ...hole.from.map(() => "table")], codeRole: "none", returns: normalizedTypeOf(hole.writesModel) };
+  }
   return {
     kind: "transform",
     reads: ["string:text"],
@@ -4166,7 +4488,7 @@ function signatureHashOf(signature) {
 }
 function bodyTemplateOf(body, hole) {
   const replacements = [];
-  if (hole.kind === "validate" || hole.kind === "derive") {
+  if (hole.kind === "validate" || hole.kind === "derive" || hole.kind === "aggregate") {
     hole.reads.forEach((name, index) => replacements.push([name, `{{read:${index}}}`]));
   } else if (hole.kind === "transform") {
     hole.columns.forEach((name, index) => replacements.push([name, `{{column:${index}}}`]));
@@ -4185,7 +4507,7 @@ function bodyTemplateOf(body, hole) {
 }
 function instantiateBody(template, hole) {
   let body = template;
-  if (hole.kind === "validate" || hole.kind === "derive") {
+  if (hole.kind === "validate" || hole.kind === "derive" || hole.kind === "aggregate") {
     hole.reads.forEach((name, index) => {
       body = body.replaceAll(`{{read:${index}}}`, name);
     });
@@ -4235,143 +4557,6 @@ function libraryFileNameOf(entry) {
   return `${entry.signatureHash}.json`;
 }
 
-// src/emit/hole-tests.ts
-function deepOverlay(base, overlay) {
-  if (Array.isArray(overlay)) {
-    const baseItems = Array.isArray(base) ? base : [];
-    return overlay.map((item, index) => deepOverlay(baseItems[index] ?? baseItems[0], item));
-  }
-  if (overlay !== null && typeof overlay === "object") {
-    const result = base !== null && typeof base === "object" && !Array.isArray(base) ? { ...base } : {};
-    for (const [key, value] of Object.entries(overlay)) result[key] = deepOverlay(result[key], value);
-    return result;
-  }
-  return overlay;
-}
-function sampleUnder(model, overlay) {
-  if (model.kind === "object" && overlay !== null && typeof overlay === "object" && !Array.isArray(overlay)) {
-    const given = overlay;
-    const value = {};
-    for (const [name, field] of Object.entries(model.fields)) {
-      if (name in given) value[name] = sampleUnder(field, given[name]);
-      else if (!field.optional) {
-        const sample = sampleOf(field, [name]);
-        value[name] = sample.ok ? sample.value : null;
-      }
-    }
-    return value;
-  }
-  if (model.kind === "array" && Array.isArray(overlay)) return overlay.map((item) => sampleUnder(model.element, item));
-  return overlay;
-}
-function projectInputOf(plan, carrier, partial) {
-  void plan;
-  return sampleUnder(carrier.outputModel, partial);
-}
-var HOLE_TESTS_CLOCK_INSTANT = "2026-01-01T00:00:00.000Z";
-function holeDeclaresClock(hole) {
-  return (hole.hole.effects ?? []).includes("clock");
-}
-function emitHoleTests(plan) {
-  const blocks = [];
-  const testedHoles = plan.holes.filter((hole) => hole.kind !== "view");
-  const needsOutputs = /* @__PURE__ */ new Set();
-  const needsClock = testedHoles.some((hole) => hole.kind !== "project" && holeDeclaresClock(hole));
-  for (const hole of testedHoles) {
-    const withEffects = (argument) => hole.kind !== "project" && holeDeclaresClock(hole) ? `${argument}, CLOCK` : argument;
-    const call = (argument) => isAsyncHole(hole) ? `await ${hole.id}(${withEffects(argument)})` : `${hole.id}(${withEffects(argument)})`;
-    blocks.push("", `  describe(${quote(hole.id)}, () => {`);
-    if (hole.kind === "validate") {
-      hole.accepts.forEach((accept, index) => {
-        blocks.push(
-          `    it(${quote(`accepte l'exemple ${index + 1} : ${JSON.stringify(accept)}`)}, async () => {`,
-          `      expect((${call(JSON.stringify(accept))}).ok).toBe(true);`,
-          "    });"
-        );
-      });
-      blocks.push(
-        `    it(${quote(`refuse ${JSON.stringify(hole.reject)} avec ${hole.errorCode}${hole.hole.suggestedFix === true ? " et un suggestedFix" : ""}`)}, async () => {`,
-        `      const result = ${call(JSON.stringify(hole.reject))};`,
-        "      expect(result.ok).toBe(false);",
-        "      if (result.ok) return;",
-        `      expect(result.code).toBe(${quote(hole.errorCode)});`,
-        "      expect(result.suggestedFix.length).toBeGreaterThan(0);",
-        "    });"
-      );
-    } else if (hole.kind === "derive") {
-      hole.accepts.forEach((accept, index) => {
-        blocks.push(
-          `    it(${quote(`d\xE9rive ${JSON.stringify(accept.output)} de l'exemple ${index + 1} : ${JSON.stringify(accept.input)}`)}, async () => {`,
-          `      const result = ${call(JSON.stringify(accept.input))};`,
-          "      expect(result.ok).toBe(true);",
-          "      if (!result.ok) return;",
-          `      expect(result.value).toEqual(${JSON.stringify(accept.output)});`,
-          "    });"
-        );
-      });
-      if (hole.reject !== null && hole.errorCode !== null) {
-        blocks.push(
-          `    it(${quote(`refuse ${JSON.stringify(hole.reject)} avec ${hole.errorCode}`)}, async () => {`,
-          `      const result = ${call(JSON.stringify(hole.reject))};`,
-          "      expect(result.ok).toBe(false);",
-          "      if (result.ok) return;",
-          `      expect(result.code).toBe(${quote(hole.errorCode)});`,
-          "      expect(result.suggestedFix.length).toBeGreaterThan(0);",
-          "    });"
-        );
-      }
-    } else if (hole.kind === "project") {
-      const carrier = plan.operations.find((operation) => operation.projectHoles.some((candidate) => candidate.id === hole.id));
-      if (carrier === void 0) throw new Error(`generation plan: project hole ${hole.id} has no carrier`);
-      needsOutputs.add(carrier.outputSchema);
-      hole.accepts.forEach((accept, index) => {
-        blocks.push(
-          `    it(${quote(`forme la sortie pour le contexte ${JSON.stringify(accept.context)} (exemple ${index + 1})`)}, () => {`,
-          `      const input = ${carrier.outputSchema}.parse(${JSON.stringify(projectInputOf(plan, carrier, accept.input))});`,
-          `      expect(${hole.id}(${JSON.stringify(accept.context)}, input)).toMatchObject(${JSON.stringify(accept.output)});`,
-          "    });"
-        );
-      });
-    } else {
-      blocks.push(
-        `    it("accepte le fichier exemple et rend ses lignes", async () => {`,
-        `      const result = ${call(`{ text: ${JSON.stringify(hole.hole.examples.accept.input)} }`)};`,
-        "      expect(result.ok).toBe(true);",
-        "      if (!result.ok) return;",
-        `      expect(result.value).toEqual(${JSON.stringify(hole.hole.examples.accept.output)});`,
-        "    });",
-        `    it(${quote(`refuse le fichier illisible avec ${hole.errorCode} et sa ligne`)}, async () => {`,
-        `      const result = ${call(`{ text: ${JSON.stringify(hole.hole.examples.reject.input)} }`)};`,
-        "      expect(result.ok).toBe(false);",
-        "      if (result.ok) return;",
-        `      expect(result.code).toBe(${quote(hole.errorCode)});`,
-        `      expect(result.line).toBe(${JSON.stringify(hole.hole.examples.reject.line ?? 1)});`,
-        "      expect(result.suggestedFix.length).toBeGreaterThan(0);",
-        "    });"
-      );
-    }
-    blocks.push("  });");
-  }
-  return fileOf(
-    tsGeneratedHeader(plan.generatorVersion),
-    intentBlock(
-      wrap(
-        `Pure tests of the holes of ${plan.featureId}, derived from their examples (D23, D32): each accept example passes, the reject example answers the hole's code. Red while a body reads todo; what a candidate body is run against (D24).${plan.holes.length !== testedHoles.length ? " The view holes are proven on the bench, not here." : ""}`
-      )
-    ),
-    'import { describe, expect, it } from "vitest";',
-    needsClock ? 'import { fixedClock } from "@ogygie/core/clock";' : null,
-    `import { ${testedHoles.map((hole) => hole.id).sort().join(", ")} } from "./logic.js";`,
-    needsOutputs.size === 0 ? null : `import { ${[...needsOutputs].sort().join(", ")} } from "./schemas.js";`,
-    needsClock ? "" : null,
-    needsClock ? `const CLOCK = fixedClock(${quote(HOLE_TESTS_CLOCK_INSTANT)});` : null,
-    "",
-    `describe(${quote(`${plan.featureId} \u2014 trous`)}, () => {`,
-    ...blocks,
-    "});"
-  );
-}
-
 // src/emit/mssql/sql-types.ts
 function sqlColumnName(plan, column) {
   return plan.target.naming === "pascal" ? column.columnName.charAt(0).toUpperCase() + column.columnName.slice(1) : column.columnName;
@@ -4647,6 +4832,33 @@ function mssqlStatements(plan) {
       parameters: []
     });
   }
+  for (const table of plan.sharedTables) {
+    statements.push({
+      key: `select${table.typeName}Rows`,
+      kind: "selectShared",
+      text: `SELECT ${selectList(plan, "t", table.columns)} FROM ${qualifiedTable(plan, table.sqlName)} AS t`,
+      table: table.sqlName,
+      rowType: table.rowType,
+      parameters: []
+    });
+  }
+  const arrangingRows = plan.operations.every((operation) => operation.kind !== "create") && plan.operations.some((operation) => operation.aggregateHoles.length > 0);
+  if (arrangingRows) {
+    const arrangeOf = (sqlName, columns, rowType, typeName) => {
+      const written = [...columns.filter((column) => column.key === "id"), ...columns.filter((column) => column.key !== "id")];
+      return {
+        key: `arrange${typeName}Row`,
+        kind: "insert",
+        text: `INSERT INTO ${qualifiedTable(plan, sqlName)} (${written.map((column) => sqlColumnName(plan, column)).join(", ")}) OUTPUT ${outputList(plan, "INSERTED", columns)} VALUES (${written.map((column) => `@${column.key}`).join(", ")})`,
+        table: sqlName,
+        rowType,
+        parameters: written.map((column) => column.key),
+        written: written.map((column) => column.key)
+      };
+    };
+    statements.push(arrangeOf(resource.sqlName, resource.columns, resource.rowType, plan.resource.typeName));
+    for (const table of plan.sharedTables) statements.push(arrangeOf(table.sqlName, table.columns, table.rowType, table.typeName));
+  }
   if (keyField !== null && keyColumn !== null) {
     const keyName = sqlColumnName(plan, keyColumn);
     statements.push({
@@ -4812,6 +5024,10 @@ function rowInterfaceLines(name, columns) {
 function parametersLiteral(entries) {
   return `{ ${entries.map(([name, expression]) => `${name}: ${expression}`).join(", ")} }`;
 }
+function parameterValue(column, expression) {
+  if (column.sqlType === "timestamptz") return expression;
+  return expression;
+}
 function notFoundLines(plan, codeExpression, indent) {
   const key = plan.key?.field ?? "id";
   return [
@@ -4851,6 +5067,34 @@ function viewReadLines(plan, view, statement) {
     "}"
   ];
 }
+function sharedReadLines(plan, table, statement) {
+  return [
+    `/** The rows of the shared table ${table.sqlName} (D60) \u2014 read-only, the product owns it. */`,
+    `export async function ${statement.key}(db: ${plan.databasePort?.typeName ?? "Database"}): Promise<${table.rowType}[]> {`,
+    `  return db.query<${table.rowType}>(SQL.${statement.key});`,
+    "}"
+  ];
+}
+function arrangeLines(plan, statement, typeName, columns, withId) {
+  const written = statement.written ?? [];
+  const valueOf = (field) => {
+    if (field === "id") return "crypto.randomUUID()";
+    const column = columns.find((candidate) => candidate.key === field);
+    return column === void 0 ? `row.${field}` : parameterValue(column, `row.${field}`);
+  };
+  return [
+    `/** TESTS ONLY (D60): rows of ${statement.table} arranged at their schema \u2014 the feature never writes them, they come from elsewhere. */`,
+    `export async function arrange${typeName}Rows(db: ${plan.databasePort?.typeName ?? "Database"}, rows: readonly ${withId ? `Omit<${typeName}, "id">` : typeName}[]): Promise<${statement.rowType}[]> {`,
+    `  const inserted: ${statement.rowType}[] = [];`,
+    "  for (const row of rows) {",
+    `    const [written] = await db.query<${statement.rowType}>(SQL.${statement.key}, ${parametersLiteral(written.map((field) => [field, valueOf(field)]))});`,
+    "    if (written === undefined) throwOgygieError(insertReturnedNothing());",
+    "    inserted.push(written);",
+    "  }",
+    "  return inserted;",
+    "}"
+  ];
+}
 function referenceLines(plan, table, column, countStatement, insertStatement) {
   const database = plan.databasePort?.typeName ?? "Database";
   const typeName = table.rowType.replace(/Row$/u, "");
@@ -5061,6 +5305,7 @@ function emitMssqlRepository(plan) {
   for (const slot of plan.slots) rows.push("", ...rowInterfaceLines(slot.table.rowType, slot.table.columns));
   for (const reference of plan.references) if (reference.table !== null) rows.push("", ...rowInterfaceLines(reference.table.rowType, reference.table.columns));
   for (const view of views) rows.push("", ...rowInterfaceLines(view.rowType, view.columns));
+  for (const table of plan.sharedTables) rows.push("", ...rowInterfaceLines(table.rowType, table.columns));
   const sqlLines = ["/** Every statement of this feature, `@named` parameters, read back under camelCase aliases \u2014 the stub answers these very texts (D33). */", "export const SQL = {", ...statements.map((statement) => `  ${statement.key}: ${quote(statement.text)},`), "} as const;"];
   const sections = [];
   for (const operation of plan.operations.filter((candidate) => candidate.kind === "read")) sections.push("", ...readFunctionLines(plan, operation, statementNamed(statements, `select${operation.pascalId}`)));
@@ -5071,8 +5316,14 @@ function emitMssqlRepository(plan) {
     sections.push("", ...referenceLines(plan, reference.table, reference.column, statementNamed(statements, `count${typeName}`), statementNamed(statements, `insert${typeName}`)));
   }
   for (const view of views) sections.push("", ...viewReadLines(plan, view, statementNamed(statements, `select${view.rowType.replace(/Row$/u, "")}`)));
-  if (plan.key !== null) sections.push("", ...loadByKeyLines(plan, statementNamed(statements, `load${plan.resource.typeName}ByKey`)));
+  for (const table of plan.sharedTables) sections.push("", ...sharedReadLines(plan, table, statementNamed(statements, `select${table.typeName}Rows`)));
   const create = plan.operations.find((operation) => operation.kind === "create");
+  const arranging = create === void 0 && plan.operations.some((operation) => operation.aggregateHoles.length > 0);
+  if (arranging) {
+    sections.push("", ...arrangeLines(plan, statementNamed(statements, `arrange${plan.resource.typeName}Row`), plan.resource.typeName, plan.table.columns, true));
+    for (const table of plan.sharedTables) sections.push("", ...arrangeLines(plan, statementNamed(statements, `arrange${table.typeName}Row`), table.typeName, table.columns, false));
+  }
+  if (plan.key !== null) sections.push("", ...loadByKeyLines(plan, statementNamed(statements, `load${plan.resource.typeName}ByKey`)));
   const update = plan.operations.find((operation) => operation.kind === "update");
   const setOrClear = plan.operations.find((operation) => operation.kind === "setOrClear");
   const remove = plan.operations.find((operation) => operation.kind === "delete");
@@ -5081,7 +5332,7 @@ function emitMssqlRepository(plan) {
   if (setOrClear !== void 0) sections.push("", ...setOrClearFunctionLines(plan, setOrClear, statements));
   if (remove !== void 0) sections.push("", ...deleteFunctionLines(plan, remove, statements));
   const inputTypes = [...new Set([create?.inputType, update?.inputType].filter((name) => name !== void 0))].sort();
-  const resourceTypes = [...new Set([plan.key === null ? null : plan.resource.typeName, ...setOrClear?.slot === null || setOrClear?.slot === void 0 ? [] : [setOrClear.slot.typeName]].filter((name) => name !== null))].sort();
+  const resourceTypes = [...new Set([plan.key === null ? null : plan.resource.typeName, ...arranging ? [plan.resource.typeName, ...plan.sharedTables.map((table) => table.typeName)] : [], ...setOrClear?.slot === null || setOrClear?.slot === void 0 ? [] : [setOrClear.slot.typeName]].filter((name) => name !== null))].sort();
   return fileOf(
     tsGeneratedHeader(plan.generatorVersion),
     intentBlock(
@@ -5162,6 +5413,8 @@ function emitMssqlStub(plan) {
   const tables = tablesOf(plan);
   const views = plan.holes.filter((hole) => hole.kind === "view");
   const tableOf = (sqlName) => {
+    const shared = plan.sharedTables.find((candidate) => candidate.sqlName === sqlName);
+    if (shared !== void 0) return { sqlName: shared.sqlName, tsName: shared.tsName, rowType: shared.rowType, newType: `New${shared.typeName}`, mode: "adopted", hasId: false, primaryKey: [], alter: [], columns: shared.columns, indexes: [], uniques: [], foreignKeys: [] };
     const table = tables.find((candidate) => candidate.sqlName === sqlName);
     if (table === void 0) throw new Error(`generation plan: stub has no table ${sqlName}`);
     return table;
@@ -5181,7 +5434,8 @@ function emitMssqlStub(plan) {
         cases.push(`      const rows = tables.${statement.table};`, ...compareLines(statement));
         break;
       }
-      case "selectView": {
+      case "selectView":
+      case "selectShared": {
         rowTypes.add(statement.rowType);
         cases.push(`      return [...tables.${statement.table}];`);
         break;
@@ -5316,9 +5570,9 @@ function emitMssqlStub(plan) {
     }
     cases.push("    }");
   }
-  const tableFields = [...tables.map((table) => `  ${table.sqlName}: ${table.rowType}[];`), ...views.map((view) => `  ${view.name}: ${view.rowType}[];`)];
-  const emptyFields = [...tables.map((table) => `${table.sqlName}: []`), ...views.map((view) => `${view.name}: []`)];
-  const importedRowTypes = [.../* @__PURE__ */ new Set([...tables.map((table) => table.rowType), ...views.map((view) => view.rowType)])].sort();
+  const tableFields = [...tables.map((table) => `  ${table.sqlName}: ${table.rowType}[];`), ...views.map((view) => `  ${view.name}: ${view.rowType}[];`), ...plan.sharedTables.map((table) => `  ${table.sqlName}: ${table.rowType}[];`)];
+  const emptyFields = [...tables.map((table) => `${table.sqlName}: []`), ...views.map((view) => `${view.name}: []`), ...plan.sharedTables.map((table) => `${table.sqlName}: []`)];
+  const importedRowTypes = [.../* @__PURE__ */ new Set([...tables.map((table) => table.rowType), ...views.map((view) => view.rowType), ...plan.sharedTables.map((table) => table.rowType)])].sort();
   return fileOf(
     tsGeneratedHeader(plan.generatorVersion),
     intentBlock(
@@ -5428,8 +5682,9 @@ function sampleOrThrow(model, variant, label) {
   }
   return sample.value;
 }
-function acceptOverlay(holes, derives, variant) {
+function acceptOverlay(holes, derives, variant, aggregates = []) {
   const overlay = {};
+  for (const hole of aggregates) Object.assign(overlay, hole.accepts[Math.min(variant, hole.accepts.length - 1)]?.input ?? {});
   for (const hole of holes) {
     const example = hole.accepts[Math.min(variant, hole.accepts.length - 1)] ?? {};
     Object.assign(overlay, example);
@@ -5443,7 +5698,8 @@ function acceptOverlay(holes, derives, variant) {
 function validInputsOf(plan, operation) {
   const holes = operation.kind === "import" ? [] : operation.validateHoles;
   const derives = operation.deriveHoles;
-  const variants = Math.max(1, ...holes.map((hole) => hole.accepts.length), ...derives.map((hole) => hole.accepts.length));
+  const aggregates = operation.aggregateHoles;
+  const variants = Math.max(1, ...holes.map((hole) => hole.accepts.length), ...derives.map((hole) => hole.accepts.length), ...aggregates.map((hole) => hole.accepts.length));
   if (operation.kind === "update" && operation.inputModel.kind === "object") {
     return Array.from({ length: variants }, (_, variant) => {
       const body = {};
@@ -5455,7 +5711,7 @@ function validInputsOf(plan, operation) {
     });
   }
   const base = sampleOrThrow(operation.inputModel, 0, operation.inputSchema);
-  return Array.from({ length: variants }, (_, variant) => ({ ...base, ...acceptOverlay(holes, derives, variant) }));
+  return Array.from({ length: variants }, (_, variant) => ({ ...base, ...acceptOverlay(holes, derives, variant, aggregates) }));
 }
 function derivedOf(operation, variant = 0) {
   const derived = {};
@@ -5490,7 +5746,7 @@ function sampleOfSqlType(sqlType) {
   if (sqlType === "uuid") return "00000000-0000-4000-8000-000000000001";
   return "arranged";
 }
-function constantNameOf(typeName) {
+function constantNameOf2(typeName) {
   return typeName.replace(/([a-z0-9])([A-Z])/gu, "$1_$2").toUpperCase();
 }
 function sampleValueOf(model, variant = 0) {
@@ -5511,13 +5767,13 @@ function emitFactories(plan) {
         sections.push(
           "",
           `/** Structurally invalid ${operation.inputType}: the required field \`${invalidImport.removedField}\` is missing. */`,
-          `export const INVALID_${constantNameOf(operation.inputType)}: Record<string, unknown> = ${JSON.stringify(invalidImport.value)};`
+          `export const INVALID_${constantNameOf2(operation.inputType)}: Record<string, unknown> = ${JSON.stringify(invalidImport.value)};`
         );
       }
       continue;
     }
     typeImports.add(operation.inputType);
-    const constant = `VALID_${constantNameOf(operation.inputType)}S`;
+    const constant = `VALID_${constantNameOf2(operation.inputType)}S`;
     const factory = `valid${operation.inputType}`;
     sections.push(
       "",
@@ -5537,13 +5793,13 @@ function emitFactories(plan) {
       sections.push(
         "",
         `/** Structurally invalid ${operation.inputType}: the required field \`${invalid.removedField}\` is missing. */`,
-        `export const INVALID_${constantNameOf(operation.inputType)}: Record<string, unknown> = ${JSON.stringify(invalid.value)};`
+        `export const INVALID_${constantNameOf2(operation.inputType)}: Record<string, unknown> = ${JSON.stringify(invalid.value)};`
       );
     } else if (operation.kind === "update") {
       sections.push(
         "",
         `/** Structurally invalid ${operation.inputType}: a partial body with no field at all \u2014 the contract refuses it. */`,
-        `export const INVALID_${constantNameOf(operation.inputType)}: Record<string, unknown> = {};`
+        `export const INVALID_${constantNameOf2(operation.inputType)}: Record<string, unknown> = {};`
       );
     }
   }
@@ -5575,6 +5831,31 @@ function emitFactories(plan) {
   } else if (create !== null) {
     sections.push("", "/** No derive hole: an arranged row carries nothing beyond its input. */", "export const DERIVED_OF_VALID_CREATES: readonly Record<string, unknown>[] = [{}];");
   }
+  for (const hole of plan.holes) {
+    if (hole.kind !== "aggregate") continue;
+    const carrier = plan.operations.find((operation) => operation.aggregateHoles.some((candidate) => candidate.id === hole.id));
+    if (carrier === void 0) continue;
+    typeImports.add(hole.resourceTypeName);
+    typeImports.add(hole.outputTypeName);
+    if (hole.reads.length > 0) typeImports.add(hole.inputTypeName);
+    for (const table of hole.from) typeImports.add(table.typeName);
+    const inputType = hole.reads.length === 0 ? "Record<never, never>" : `Pick<${hole.inputTypeName}, ${hole.reads.map(quote).join(" | ")}>`;
+    const sharedType = hole.from.length === 0 ? "Record<never, never>" : `{ ${hole.from.map((table) => `${table.tsName}: readonly ${table.typeName}[]`).join("; ")} }`;
+    const examples = hole.accepts.map((accept) => {
+      const fullInput = sampleUnder(carrier.inputModel, accept.input);
+      const input = Object.fromEntries(hole.reads.map((field) => [field, fullInput[field]]));
+      const rows = accept.rows.map((row) => sampleUnder(plan.resource.model, row));
+      const shared = Object.fromEntries(hole.from.map((table) => [table.tsName, (accept.shared[table.sqlName] ?? []).map((row) => sampleUnder(table.model, row))]));
+      return { input, rows, shared, value: accept.value };
+    });
+    sections.push(
+      "",
+      `/** The complete examples of the aggregate hole ${hole.id} (D60): input pick, rows and shared rows completed under their schemas, the value expected \u2014 one fixture for the pure test and the behaviour test. */`,
+      `export const EXAMPLES_OF_${constantNameOf(hole.id)}: readonly { input: ${inputType}; rows: readonly ${hole.resourceTypeName}[]; shared: ${sharedType}; value: ${hole.outputTypeName}[${quote(hole.writes)}] }[] = [`,
+      ...examples.map((example) => `  ${JSON.stringify(example)},`),
+      "];"
+    );
+  }
   for (const reference of plan.references) {
     if (reference.table === null) continue;
     const model = reference.schemaName === null ? void 0 : plan.schemaModels[reference.schemaName];
@@ -5640,14 +5921,14 @@ function emitFactories(plan) {
       sections.push(
         "",
         `/** The input ${hole.id} rejects (its reject example), as an overlay of a valid input. */`,
-        `export const REJECT_EXAMPLE_OF_${constantNameOf(hole.id)} = ${JSON.stringify(hole.reject)} as const;`
+        `export const REJECT_EXAMPLE_OF_${constantNameOf2(hole.id)} = ${JSON.stringify(hole.reject)} as const;`
       );
     }
     if (hole.kind === "derive" && hole.reject !== null) {
       sections.push(
         "",
         `/** The input ${hole.id} refuses to derive from (its reject example), as an overlay of a valid input. */`,
-        `export const REJECT_EXAMPLE_OF_${constantNameOf(hole.id)} = ${JSON.stringify(hole.reject)} as const;`
+        `export const REJECT_EXAMPLE_OF_${constantNameOf2(hole.id)} = ${JSON.stringify(hole.reject)} as const;`
       );
     }
   }
@@ -5670,7 +5951,7 @@ function markdownGeneratedHeader(version) {
 }
 function carriersOf(hole, plan) {
   return plan.operations.filter(
-    (operation) => operation.validateHoles.some((candidate) => candidate.id === hole.id) || operation.transformHole?.id === hole.id || operation.deriveHoles.some((candidate) => candidate.id === hole.id) || operation.projectHoles.some((candidate) => candidate.id === hole.id) || operation.viewHoles.some((candidate) => candidate.id === hole.id)
+    (operation) => operation.validateHoles.some((candidate) => candidate.id === hole.id) || operation.transformHole?.id === hole.id || operation.deriveHoles.some((candidate) => candidate.id === hole.id) || operation.projectHoles.some((candidate) => candidate.id === hole.id) || operation.viewHoles.some((candidate) => candidate.id === hole.id) || operation.aggregateHoles.some((candidate) => candidate.id === hole.id)
   ).map((operation) => `\`${operation.id}\` (${operation.method} ${operation.path})`);
 }
 function tick(name) {
@@ -5712,6 +5993,17 @@ function contractLines(hole, plan, shape) {
         "## Champs",
         ...hole.writes.map((path) => `- ${tick(path)} : \xE9crit par le trou`)
       ];
+    case "aggregate":
+      return [
+        `- lit : ${hole.reads.length === 0 ? "rien de l'entr\xE9e" : `${hole.reads.map(tick).join(", ")} de ${tick(hole.inputTypeName)}`}, les lignes de la ressource (${tick(`readonly ${hole.resourceTypeName}[]`)} : TOUTES celles du tenant, au sch\xE9ma, dans l'ordre de la lecture)${hole.from.length === 0 ? "" : ` et les lignes des tables partag\xE9es ${hole.from.map((table) => `${tick(table.sqlName)} (${tick(`shared.${table.tsName}: readonly ${table.typeName}[]`)})`).join(", ")}`}`,
+        `- rend : ${tick(hole.writes)} de la sortie \u2014 ${tick(`${hole.outputTypeName}["${hole.writes}"]`)}, la VALEUR, jamais un ${tick("HoleResult")} : une agr\xE9gation ne refuse pas (D60)`,
+        `- effets : ${effects(hole.hole.effects)}`,
+        "- filtre : c'est le trou qui garde les lignes que l'entr\xE9e demande (une p\xE9riode, un site) ; le d\xE9p\xF4t ne filtre pas",
+        "",
+        "## Champs",
+        ...hole.reads.map((name, index) => `- ${tick(name)} : ${shape.reads[index] ?? "unknown"}`),
+        `- ${tick(hole.writes)} (\xE9crit) : ${shape.returns}`
+      ];
     case "view":
       return [
         `- corps : du SQL, dans la migration ${tick(plan.migrationPath)} entre ${tick(`-- @hole ${hole.id}`)} et ${tick(`-- @end-hole ${hole.id}`)} \u2014 ${tick(`create or replace view "${hole.name}" as \u2026`)}`,
@@ -5748,6 +6040,10 @@ function exampleLines(hole, plan) {
       ];
     case "project":
       return hole.accepts.map((accept) => `- contexte ${tick(JSON.stringify(accept.context))}, entr\xE9e ${tick(JSON.stringify(accept.input))} \u2192 ${tick(JSON.stringify(accept.output))}`);
+    case "aggregate":
+      return hole.accepts.map(
+        (accept, index) => `- exemple ${index + 1} : entr\xE9e ${tick(JSON.stringify(accept.input))}, lignes ${tick(JSON.stringify(accept.rows))}${Object.keys(accept.shared).length === 0 ? "" : `, partag\xE9es ${tick(JSON.stringify(accept.shared))}`} \u2192 ${tick(hole.writes)} = ${tick(JSON.stringify(accept.value))} (les lignes sont compl\xE9t\xE9es sous leur sch\xE9ma par le test)`
+      );
     case "view":
       return [
         `- lignes de case d'UNE ligne de ressource : ${tick(JSON.stringify(hole.hole.examples.rows))}`,
@@ -5786,7 +6082,7 @@ function emitHoleDoc(plan, hole, library) {
     "## Contrat",
     `- appel\xE9 par : ${carriersOf(hole, plan).join(", ")}`,
     ...contractLines(hole, plan, shape),
-    `- forme normalis\xE9e : ${shape.kind} [${(hole.kind === "transform" || hole.kind === "project" || hole.kind === "view" ? shape.columns : shape.reads).join(", ")}] \u2192 ${shape.returns}, code ${shape.codeRole} \u2014 shapeHash \`${shapeHash}\``,
+    `- forme normalis\xE9e : ${shape.kind} [${(hole.kind === "transform" || hole.kind === "project" || hole.kind === "view" || hole.kind === "aggregate" ? shape.columns : shape.reads).join(", ")}] \u2192 ${shape.returns}, code ${shape.codeRole} \u2014 shapeHash \`${shapeHash}\``,
     "",
     hole.kind === "view" ? "## Colonnes (g\xE9n\xE9r\xE9es, le SQL doit les produire)" : "## Signature (g\xE9n\xE9r\xE9e)",
     hole.kind === "view" ? "```sql" : "```ts",
@@ -5810,8 +6106,8 @@ function emitHoleDoc(plan, hole, library) {
       "- aucune table hors de celles list\xE9es en `lit` ; aucune \xE9criture ; `null` quand rien n'est pos\xE9 (un crit\xE8re sans cible ne compte pas pour z\xE9ro)",
       "- ne touche rien hors des marqueurs : le reste de la migration est r\xE9g\xE9n\xE9r\xE9"
     ] : [
-      hole.kind === "project" ? "- pur : lit le contexte re\xE7u et la sortie re\xE7ue, rend une sortie du m\xEAme type ; jamais la base ni l'horloge" : "- pur hors de ses effets d\xE9clar\xE9s : ne lit ni horloge ni base ni r\xE9seau au-del\xE0 des param\xE8tres re\xE7us (AGENTS.md principe 5)",
-      hole.kind === "project" ? "- rend la sortie, jamais une exception" : "- r\xE9pond par `accept(...)` ou `refuse(code, cause, suggestedFix[, line])` du runtime ; jamais par une exception",
+      hole.kind === "project" ? "- pur : lit le contexte re\xE7u et la sortie re\xE7ue, rend une sortie du m\xEAme type ; jamais la base ni l'horloge" : hole.kind === "aggregate" ? "- pur hors de l'horloge quand elle est d\xE9clar\xE9e : lit l'entr\xE9e re\xE7ue, les lignes re\xE7ues et les lignes partag\xE9es re\xE7ues, rien d'autre (AGENTS.md principe 5) ; les dates sont des cha\xEEnes ISO, \xE0 comparer comme telles" : "- pur hors de ses effets d\xE9clar\xE9s : ne lit ni horloge ni base ni r\xE9seau au-del\xE0 des param\xE8tres re\xE7us (AGENTS.md principe 5)",
+      hole.kind === "project" ? "- rend la sortie, jamais une exception" : hole.kind === "aggregate" ? "- rend la valeur, jamais une exception ; une agr\xE9gation sur z\xE9ro ligne rend la valeur neutre que la spec dit (0, [], null)" : "- r\xE9pond par `accept(...)` ou `refuse(code, cause, suggestedFix[, line])` du runtime ; jamais par une exception",
       "- aucun `any`, aucune d\xE9pendance nouvelle, identifiants et commentaires en anglais",
       "- ne touche rien hors du corps : signature, marqueurs et imports sont r\xE9g\xE9n\xE9r\xE9s"
     ]
@@ -5821,7 +6117,7 @@ function emitHoleDoc(plan, hole, library) {
 
 // src/emit/tests.ts
 var UUID_PATTERN = "/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u";
-function constantNameOf2(typeName) {
+function constantNameOf3(typeName) {
   return typeName.replace(/([a-z0-9])([A-Z])/gu, "$1_$2").toUpperCase();
 }
 function invariant2(condition, message) {
@@ -5868,7 +6164,7 @@ function harnessLines(plan, options) {
   const create = createOperation(plan);
   const imports = [
     `import { ${plan.tenant === null ? "afterEach, beforeEach" : "afterAll, beforeAll"}, describe, expect, it } from "vitest";`,
-    ...options.arranging ? ['import { fixedClock } from "@ogygie/core/clock";'] : [],
+    ...options.arranging && create !== null ? ['import { fixedClock } from "@ogygie/core/clock";'] : [],
     `import type { ${plan.context.typeName} } from ${quote(plan.context.importPath)};`,
     `import { ${plan.testBench.exportName} } from ${quote(plan.testBench.importPath)};`,
     `import { ${[...fixtureNames].sort().join(", ")} } from ${quote(fixturesImportPath ?? "")};`
@@ -5936,6 +6232,33 @@ function harnessLines(plan, options) {
     "  return String(a) < String(b) ? -1 : 1;",
     "}"
   ];
+  const arrangingReport = options.arranging && options.report === true && create === null && plan.operations.some((operation) => operation.aggregateHoles.length > 0);
+  if (arrangingReport) {
+    const handleType = plan.tenant === null ? `db: ${plan.databasePort?.typeName ?? "Database"}` : `context: ${plan.context.typeName}`;
+    const handleName = plan.tenant === null ? "db" : "context";
+    imports.push(
+      `import type { ${plan.table.rowType} } from ${plan.target.database === "mssql-raw" ? '"./repository.gen.js"' : '"./db.schema.gen.js"'};`,
+      `import { ${["arrange" + plan.resource.typeName + "Rows", ...plan.sharedTables.map((table) => `arrange${table.typeName}Rows`)].sort().join(", ")} } from "./repository.gen.js";`,
+      `import type { ${[plan.resource.typeName, ...plan.sharedTables.map((table) => table.typeName)].sort().join(", ")} } from "./schemas.js";`
+    );
+    if (plan.tenant === null && plan.databasePort !== null) imports.push(`import type { ${plan.databasePort.typeName} } from ${quote(plan.databasePort.importPath)};`);
+    helpers.push(
+      "",
+      "/** Rows arranged at their schema (D60): the block has no create, the tests put their rows on the bench through the repository's arrangement. */",
+      `async function arrangeRows(${handleType}, rows: readonly Omit<${plan.resource.typeName}, "id">[]): Promise<${plan.table.rowType}[]> {`,
+      `  return arrange${plan.resource.typeName}Rows(${handleName}, rows);`,
+      "}"
+    );
+    if (plan.sharedTables.length > 0) {
+      helpers.push(
+        "",
+        "/** The shared rows of an aggregate example (D60), arranged in their tables before the request. */",
+        `async function arrangeShared(${handleType}, shared: { ${plan.sharedTables.map((table) => `${table.tsName}?: readonly ${table.typeName}[]`).join("; ")} }): Promise<void> {`,
+        ...plan.sharedTables.map((table) => `  if (shared.${table.tsName} !== undefined) await arrange${table.typeName}Rows(${handleName}, shared.${table.tsName});`),
+        "}"
+      );
+    }
+  }
   if (options.arranging && create !== null) {
     imports.push(
       plan.target.database === "mssql-raw" ? `import { insert${plan.resource.typeName}, type ${plan.table.rowType} } from "./repository.gen.js";` : `import type { ${plan.table.rowType} } from "./db.schema.gen.js";`,
@@ -6034,7 +6357,7 @@ function emitContractTests(plan) {
       );
     }
     const invalid = operation.kind === "delete" ? { ok: false, reason: "no body" } : invalidSampleOf(operation.inputModel);
-    const invalidConstant = `INVALID_${constantNameOf2(operation.inputType)}`;
+    const invalidConstant = `INVALID_${constantNameOf3(operation.inputType)}`;
     const hasInvalid = invalid.ok || operation.kind === "update";
     if (hasInvalid) {
       factoryImports.add(invalidConstant);
@@ -6148,7 +6471,14 @@ function behaviorTestLines(plan, item, factoryImports, schemaImports, repository
     referenced: false,
     key: "ARRANGED_KEY",
     snapshotBefore: behavior.expectations.some((expectation) => expectation.raw === "rien n'est \xE9crit"),
-    needsReplacement: false
+    needsReplacement: false,
+    sharedExample: null,
+    bindArranged: !operation.report
+  };
+  const examplesOf = (aggregate) => {
+    const constant = `EXAMPLES_OF_${constantNameOf(aggregate.id)}`;
+    useFactory(constant);
+    return constant;
   };
   const useFactory = (name) => {
     factoryImports.add(name);
@@ -6175,11 +6505,21 @@ function behaviorTestLines(plan, item, factoryImports, schemaImports, repository
     if (key === `with:${guard.entry.valid.case}`) continue;
     if (key === "with:entr\xE9e valide") continue;
     if (key === "with:entr\xE9e invalide") {
-      const constant = `INVALID_${constantNameOf2(operation.inputType)}`;
+      const constant = `INVALID_${constantNameOf3(operation.inputType)}`;
       useFactory(constant);
       derivation.input = constant;
       continue;
     }
+    const firstAggregate = operation.aggregateHoles[0] ?? null;
+    if (operation.kind === "read" && operation.motif === null && createFactory === null && firstAggregate !== null) {
+      if (key === "with:lignes") {
+        const constant = examplesOf(firstAggregate);
+        derivation.arrangements.push(`...(${constant}[0]?.rows ?? [])`);
+        if (firstAggregate.from.length > 0) derivation.sharedExample = `${constant}[0]?.shared ?? {}`;
+        continue;
+      }
+      if (key === "without:ligne") continue;
+    }
     if (operation.kind === "read" && operation.motif === null && createFactory !== null) {
       if (key === "with:lignes") {
         derivation.arrangements.push(`${createFactory}(0)`, `${createFactory}(1)`);
@@ -6294,7 +6634,7 @@ function behaviorTestLines(plan, item, factoryImports, schemaImports, repository
   const refusedByHole = hole !== null && behavior.code !== null && ((hole.kind === "validate" || hole.kind === "transform" || hole.kind === "derive") && hole.errorCode === behavior.code);
   if (hole !== null && refusedByHole) {
     if ((hole.kind === "validate" || hole.kind === "derive" && hole.reject !== null) && inputFactory !== null) {
-      const constant = `REJECT_EXAMPLE_OF_${constantNameOf2(hole.id)}`;
+      const constant = `REJECT_EXAMPLE_OF_${constantNameOf3(hole.id)}`;
       useFactory(constant);
       derivation.overrides.push(`...${constant}`);
     } else if (hole.kind === "transform") {
@@ -6314,6 +6654,16 @@ function behaviorTestLines(plan, item, factoryImports, schemaImports, repository
     derivation.needsReplacement = true;
     derivation.expectedIds = "[arranged[0]?.id, replacement.id]";
   }
+  if (hole !== null && hole.kind === "aggregate") {
+    const constant = examplesOf(hole);
+    derivation.arrangements = [`...(${constant}[0]?.rows ?? [])`];
+    derivation.sharedExample = hole.from.length === 0 ? null : `${constant}[0]?.shared ?? {}`;
+    if (inputFactory === null) derivation.input = `(${constant}[0]?.input ?? {})`;
+    else {
+      useFactory(inputFactory);
+      derivation.input = `{ ...${inputFactory}(), ...(${constant}[0]?.input ?? {}) }`;
+    }
+  }
   if (createFactory !== null && derivation.arrangements.length > 0) useFactory(createFactory);
   if (inputFactory !== null && derivation.input !== null && derivation.input.startsWith(inputFactory)) useFactory(inputFactory);
   if (inputFactory !== null && (derivation.overrides.length > 0 || derivation.queryOverrides.length > 0)) {
@@ -6330,8 +6680,9 @@ function behaviorTestLines(plan, item, factoryImports, schemaImports, repository
   }
   const handle = arrangingHandle(plan, "member");
   if (derivation.arrangements.length > 0) {
-    lines.push(`    const arranged = await arrangeRows(${handle}, [${derivation.arrangements.join(", ")}]);`);
+    lines.push(`    ${derivation.bindArranged ? "const arranged = " : ""}await arrangeRows(${handle}, [${derivation.arrangements.join(", ")}]);`);
   }
+  if (derivation.sharedExample !== null) lines.push(`    await arrangeShared(${handle}, ${derivation.sharedExample});`);
   if (derivation.needsReplacement && createFactory !== null) {
     lines.push(`    const replacement = await insert${plan.resource.typeName}(${handle}, ${createFactory}(0, { supersedes: arranged[0]?.id })${plan.signed === null ? "" : ", ARRANGED_SIGNATURE"}, CLOCK);`);
   }
@@ -6442,6 +6793,9 @@ function behaviorTestLines(plan, item, factoryImports, schemaImports, repository
         const target = signatureTarget();
         const expected = value === "renouvel\xE9e" ? `${plan.signature?.exportName ?? "signerOf"}(${derivation.session}.context)` : "ARRANGED_SIGNATURE.by";
         lines.push(`    expect(${target}?.${plan.signed.by}).toBe(${expected});`);
+      } else if (value.endsWith(" d\xE9riv\xE9") && operation.aggregateHoles.some((candidate) => value === `${candidate.writes} d\xE9riv\xE9`)) {
+        const writer = operation.aggregateHoles.find((candidate) => value === `${candidate.writes} d\xE9riv\xE9`);
+        if (writer !== void 0) lines.push(`    expect(output.${subPath}).toEqual(${examplesOf(writer)}[0]?.value);`);
       } else if (value.endsWith(" d\xE9riv\xE9") && operation.deriveHoles.some((candidate) => value === `${candidate.writes} d\xE9riv\xE9`)) {
         const field = value.slice(0, -" d\xE9riv\xE9".length);
         lines.push(`    expect(valuesAt(${root}, ${quote(subPath)})).toEqual([DERIVED_OF_VALID_CREATES[0]?.[${quote(field)}]]);`);
@@ -6502,7 +6856,7 @@ function behaviorTestLines(plan, item, factoryImports, schemaImports, repository
   return lines;
 }
 function emitBehaviorTests(plan) {
-  const { imports, helpers } = harnessLines(plan, { arranging: true });
+  const { imports, helpers } = harnessLines(plan, { arranging: true, report: true });
   const factoryImports = /* @__PURE__ */ new Set();
   const schemaImports = /* @__PURE__ */ new Set();
   const repositoryImports = /* @__PURE__ */ new Set();
@@ -6542,6 +6896,9 @@ function emitBehaviorTests(plan) {
 }
 
 // src/emit/repository.ts
+function writtenTypeOf(plan, newType) {
+  return plan.tenant === null ? newType : `Omit<${newType}, ${quote(plan.tenant.columnKey)}>`;
+}
 function comparatorLines(plan, operation) {
   const order = operation.order;
   if (order === null) return ["    return 0;"];
@@ -6680,7 +7037,7 @@ function insertFunctionLines2(plan, operation) {
   const signature = signatureParts(plan);
   const derivedParameter = derived.length === 0 ? "" : `, derived: Pick<${plan.resource.typeName}, ${derived.map(quote).join(" | ")}>`;
   const valuesLines = [
-    `  const values: Omit<${plan.table.newType}, ${quote(tenantOf(plan).columnKey)}> = {`,
+    `  const values: ${writtenTypeOf(plan, plan.table.newType)} = {`,
     "    id,",
     ...inputFieldsPresent.map((field) => `    ${field}: input.${field},`),
     ...derived.map((field) => `    ${field}: derived.${field},`),
@@ -6790,7 +7147,7 @@ function insertFunctionLines2(plan, operation) {
     "          409,",
     "        );",
     "      }",
-    `      const marking: Partial<Omit<${plan.table.newType}, ${quote(tenantOf(plan).columnKey)}>> = { supersededBy: id };`,
+    `      const marking: Partial<${writtenTypeOf(plan, plan.table.newType)}> = { supersededBy: id };`,
     `      await db.update(${table}).set(marking).where(eq(${table}.id, old.id));`,
     "    } else {",
     `      const [existing] = await db`,
@@ -6882,7 +7239,7 @@ function importFunctionLines(plan, operation) {
   }
   lines.push(
     "    for (const { row } of rows) {",
-    `      const values: Omit<${plan.table.newType}, ${quote(tenantOf(plan).columnKey)}> = {`,
+    `      const values: ${writtenTypeOf(plan, plan.table.newType)} = {`,
     "        id: crypto.randomUUID(),",
     ...valueFields.map((field) => `        ${field}: row.${field},`),
     ...appendOnly === null ? [] : ["        supersedes: null,", "        supersededBy: null,"],
@@ -6919,7 +7276,7 @@ function updateFunctionLines2(plan, operation) {
     `/** ${operation.id} \u2014 update by key (D28): the fields sent are written, the key never changes${plan.signed === null ? "" : ", the signature is renewed (D31)"}. */`,
     `export async function update${plan.resource.typeName}ByKey(ctx: ${plan.context.typeName}, key: ${plan.resource.typeName}[${quote(plan.key.field)}], input: ${operation.inputType}${signature.parameter}): Promise<${plan.table.rowType}> {`,
     `  const row = await load${plan.resource.typeName}ByKey(ctx, key, ${quote(operation.notFound ?? "")});`,
-    `  const patch: Partial<Omit<${plan.table.newType}, ${quote(tenantOf(plan).columnKey)}>> = {`,
+    `  const patch: Partial<${writtenTypeOf(plan, plan.table.newType)}> = {`,
     ...fields.map((field) => `    ...(input.${field} === undefined ? {} : { ${field}: input.${field} }),`),
     ...signature.values,
     "  };",
@@ -6956,11 +7313,11 @@ function setOrClearFunctionLines2(plan, operation) {
     "    }",
     ...idempotent ? [`    if (existing !== undefined && existing.${slot.value} === value) return "unchanged";`] : [],
     "    if (existing !== undefined) {",
-    `      const patch: Partial<Omit<${slot.table.newType}, ${quote(tenantOf(plan).columnKey)}>> = { ${slot.value}: value${signature.values.length === 0 ? "" : `, ${plan.signed?.by ?? ""}: signature.by, ${plan.signed?.at ?? ""}: signature.at`} };`,
+    `      const patch: Partial<${writtenTypeOf(plan, slot.table.newType)}> = { ${slot.value}: value${signature.values.length === 0 ? "" : `, ${plan.signed?.by ?? ""}: signature.by, ${plan.signed?.at ?? ""}: signature.at`} };`,
     `      await db.update(${table}).set(patch).where(${whereExisting});`,
     `      return "set";`,
     "    }",
-    `    const values: Omit<${slot.table.newType}, ${quote(tenantOf(plan).columnKey)}> = {`,
+    `    const values: ${writtenTypeOf(plan, slot.table.newType)} = {`,
     ...slot.table.hasId ? ["      id: crypto.randomUUID(),"] : [],
     `      ${slot.parentKey}: parent.${plan.key.field},`,
     `      ${slot.key}: slotKey,`,
@@ -7027,13 +7384,46 @@ function referenceLines2(plan, reference) {
     "",
     `/** One ${reference.name} row pointing at a resource key \u2014 what a test arranges to prove \xAB ligne r\xE9f\xE9renc\xE9e \xBB. */`,
     `export async function insert${typeName}(ctx: ${plan.context.typeName}, values: Pick<${reference.table.newType}, ${writtenColumns2.map(quote).join(" | ")}>): Promise<${reference.table.rowType}> {`,
-    `  const inserted: Omit<${reference.table.newType}, ${quote(tenantOf(plan).columnKey)}> = { ...values };`,
+    `  const inserted: ${writtenTypeOf(plan, reference.table.newType)} = { ...values };`,
     `  const [row] = await tenantDb(ctx).insert(${reference.table.tsName}).values(inserted).returning();`,
     "  if (row === undefined) throwOgygieError(insertReturnedNothing());",
     "  return row;",
     "}"
   ];
 }
+function sharedReadLines2(plan, table) {
+  return [
+    `/** The rows of the shared table ${table.sqlName} (D60) for the tenant, through its read-only mapping \u2014 what the aggregate holes receive, at their schema. */`,
+    `export async function select${table.typeName}Rows(ctx: ${plan.context.typeName}): Promise<${table.rowType}[]> {`,
+    `  return tenantDb(ctx).select(${table.tsName}).all();`,
+    "}"
+  ];
+}
+function insertExpressionOf(field) {
+  if (field.model.kind === "string" && field.model.format === "datetime") {
+    return field.model.nullable ? `row.${field.name} === null ? null : new Date(row.${field.name})` : `new Date(row.${field.name})`;
+  }
+  return `row.${field.name}`;
+}
+function arrangeLines2(plan, target) {
+  const valuesType = target.newType === null ? `typeof ${target.tsName}.$inferInsert` : target.newType;
+  return [
+    `/** TESTS ONLY (D60): rows of ${target.sqlTable} arranged at their schema \u2014 the feature never writes them, they come from elsewhere; the tests of a block without create put their rows on the bench here. */`,
+    `export async function arrange${target.typeName}Rows(ctx: ${plan.context.typeName}, rows: readonly ${target.withId ? `Omit<${target.typeName}, "id">` : target.typeName}[]): Promise<${target.rowType}[]> {`,
+    `  const inserted: ${target.rowType}[] = [];`,
+    "  for (const row of rows) {",
+    `    const values: ${writtenTypeOf(plan, valuesType)} = {`,
+    ...target.withId ? ["      id: crypto.randomUUID(),"] : [],
+    ...target.fields.filter((field) => !(target.withId && field.name === "id")).map((field) => `      ${field.name}: ${insertExpressionOf(field)},`),
+    "    };",
+    `    const [written] = await tenantDb(ctx).insert(${target.tsName}).values(values).returning();`,
+    "    if (written === undefined) throwOgygieError(insertReturnedNothing());",
+    "    inserted.push(written);",
+    "  }",
+    "  return inserted;",
+    "}"
+  ];
+}
 function viewReadLines2(plan, view) {
   return [
     `/** The rows of the view ${view.name} (hole ${view.id}, D32) for the tenant, through its read-only mapping. */`,
@@ -7064,34 +7454,44 @@ function emitRepository(plan) {
   }
   const queryTypes = reads.filter((operation) => operation.motif?.method === "currentByKey").map((operation) => operation.inputType);
   const inputTypes = [...new Set([create?.inputType, update?.inputType, plan.importMotif?.rowType, ...queryTypes].filter((name) => name !== void 0))].sort();
-  const resourceTypes = [...new Set([plan.key === null ? null : plan.resource.typeName, ...setOrClear?.slot === null || setOrClear?.slot === void 0 ? [] : [setOrClear.slot.typeName]].filter((name) => name !== null))].sort();
+  const arranging = create === void 0 && plan.operations.some((operation) => operation.aggregateHoles.length > 0);
+  const resourceTypes = [...new Set([plan.key === null ? null : plan.resource.typeName, ...arranging ? [plan.resource.typeName, ...plan.sharedTables.map((table) => table.typeName)] : [], ...setOrClear?.slot === null || setOrClear?.slot === void 0 ? [] : [setOrClear.slot.typeName]].filter((name) => name !== null))].sort();
   const tableImports = [`${plan.table.tsName}, type ${plan.table.newType}, type ${plan.table.rowType}`];
   for (const slot of plan.slots) tableImports.push(`${slot.table.tsName}, type ${slot.table.newType}, type ${slot.table.rowType}`);
   for (const reference of plan.references) if (reference.table !== null) tableImports.push(`${reference.table.tsName}, type ${reference.table.newType}, type ${reference.table.rowType}`);
   for (const view of views) tableImports.push(`${view.tsName}, type ${view.rowType}`);
+  for (const table of plan.sharedTables) tableImports.push(`${table.tsName}, type ${table.rowType}`);
   const sections = [];
   for (const operation of reads) sections.push("", ...readFunctionLines2(plan, operation));
   for (const slot of plan.slots) sections.push("", ...slotReadLines2(plan, slot));
   for (const reference of plan.references) sections.push("", ...referenceLines2(plan, reference));
   for (const view of views) sections.push("", ...viewReadLines2(plan, view));
+  for (const table of plan.sharedTables) sections.push("", ...sharedReadLines2(plan, table));
+  if (create === void 0 && plan.operations.some((operation) => operation.aggregateHoles.length > 0)) {
+    sections.push("", ...arrangeLines2(plan, { sqlTable: plan.table.sqlName, tsName: plan.table.tsName, rowType: plan.table.rowType, newType: plan.table.newType, typeName: plan.resource.typeName, fields: plan.resource.fields, withId: true }));
+    for (const table of plan.sharedTables) sections.push("", ...arrangeLines2(plan, { sqlTable: table.sqlName, tsName: table.tsName, rowType: table.rowType, newType: null, typeName: table.typeName, fields: table.fields, withId: false }));
+  }
   if (plan.key !== null) sections.push("", ...loadByKeyLines2(plan));
   if (create !== void 0) sections.push("", ...insertFunctionLines2(plan, create));
   if (update !== void 0) sections.push("", ...updateFunctionLines2(plan, update));
   if (setOrClear !== void 0) sections.push("", ...setOrClearFunctionLines2(plan, setOrClear));
   if (deleteOperation !== void 0) sections.push("", ...deleteFunctionLines2(plan, deleteOperation));
   if (importOperation !== void 0) sections.push("", ...importFunctionLines(plan, importOperation));
+  const noTenant = plan.tenant === null;
+  const handleType = noTenant ? plan.databasePort?.typeName ?? "Database" : plan.context.typeName;
+  const finalSections = noTenant ? sections.map((line) => line.replace(/\btenantDb\(ctx\)/gu, "plainDb(db)").replace(/\bctx\b/gu, "db").replaceAll(`db: ${plan.context.typeName}`, `db: ${handleType}`)) : sections;
   return fileOf(
     tsGeneratedHeader(plan.generatorVersion),
     intentBlock(
       wrap(
-        `Persistence of the ${plan.featureId} feature \u2014 the only file of the feature allowed to touch the database, always through tenantDb: the tenant column is injected on insert and filtered on every read, never written by hand (AGENTS.md \xA7Multi-tenant).${plan.appendOnly === null ? "" : ` The append-only motif appendOnlySupersedes on (${plan.appendOnly.key.join(", ")}): current rows per key, supersede by marking the old row BEFORE inserting the new one.`}${plan.importMotif === null ? "" : " The all-or-nothing import: one transaction or nothing."}${plan.key === null ? "" : ` The keyed writes of D28 address a row by ${plan.key.field} and answer the operation's 404 otherwise.`}${plan.unique === null ? "" : ` uniqueKey: 409 ${plan.unique.error} on a taken key.`}${plan.referenced === null ? "" : ` refuseWhenReferenced: 409 ${plan.referenced.error} while a ${plan.referenced.reference.name} row points at the row.`}${plan.signed === null ? "" : ` signedWrite: ${plan.signed.by} and ${plan.signed.at} on every write.`}${views.length === 0 ? "" : ` The views ${views.map((view) => view.name).join(", ")} are read through their read-only mappings (D32).`} Derived from ${plan.specPath}.`
+        `Persistence of the ${plan.featureId} feature \u2014 the only file of the feature allowed to touch the database, ${noTenant ? "always through plainDb: the product is single-tenant (target.tenancy none, D33), the whole table is read and written through the one facade, never a raw query builder" : "always through tenantDb: the tenant column is injected on insert and filtered on every read, never written by hand (AGENTS.md \xA7Multi-tenant)"}.${plan.appendOnly === null ? "" : ` The append-only motif appendOnlySupersedes on (${plan.appendOnly.key.join(", ")}): current rows per key, supersede by marking the old row BEFORE inserting the new one.`}${plan.importMotif === null ? "" : " The all-or-nothing import: one transaction or nothing."}${plan.key === null ? "" : ` The keyed writes of D28 address a row by ${plan.key.field} and answer the operation's 404 otherwise.`}${plan.unique === null ? "" : ` uniqueKey: 409 ${plan.unique.error} on a taken key.`}${plan.referenced === null ? "" : ` refuseWhenReferenced: 409 ${plan.referenced.error} while a ${plan.referenced.reference.name} row points at the row.`}${plan.signed === null ? "" : ` signedWrite: ${plan.signed.by} and ${plan.signed.at} on every write.`}${views.length === 0 ? "" : ` The views ${views.map((view) => view.name).join(", ")} are read through their read-only mappings (D32).`} Derived from ${plan.specPath}.`
       )
     ),
     drizzleImports.size === 0 ? null : `import { ${[...drizzleImports].sort().join(", ")} } from "drizzle-orm";`,
     'import type { Clock } from "@ogygie/core/clock";',
     'import { throwOgygieError } from "@ogygie/core/errors";',
-    'import { tenantDb } from "@ogygie/core/tenant";',
-    `import type { ${plan.context.typeName} } from ${quote(plan.context.importPath)};`,
+    noTenant ? 'import { plainDb } from "@ogygie/core/tenant";' : 'import { tenantDb } from "@ogygie/core/tenant";',
+    noTenant ? `import type { ${handleType} } from ${quote(plan.databasePort?.importPath ?? "../../db.js")};` : `import type { ${plan.context.typeName} } from ${quote(plan.context.importPath)};`,
     "import {",
     ...tableImports.map((line) => `  ${line},`),
     '} from "./db.schema.gen.js";',
@@ -7126,7 +7526,7 @@ function emitRepository(plan) {
     `    suggestedFix: "Check the migration ${plan.migrationFileName} was applied to this database.",`,
     "  };",
     "}",
-    ...sections
+    ...finalSections
   );
 }
 
@@ -7340,7 +7740,51 @@ function emitService(plan) {
   const signatureLine = plan.signed === null ? [] : [`  const signature: WriteSignature = { by: ${plan.signature?.exportName ?? "signerOf"}(deps.ctx), at: deps.clock.now() };`];
   const signatureArgument = plan.signed === null ? "" : ", signature";
   if (plan.signed !== null) repositoryImports.add("type WriteSignature");
+  const projectionLines = (operation) => {
+    if (operation.projectHoles.length === 0) return ["  return computed;"];
+    const lines = [];
+    if (plan.tenant === null) lines.push("  const projection = deps.ctx;");
+    else lines.push("  const { db: _db, ...projection } = deps.ctx;", "  void _db;");
+    let current = "computed";
+    for (const hole of operation.projectHoles) {
+      lines.push(`  const ${hole.id}Output = ${hole.id}(projection, ${current});`);
+      current = `${hole.id}Output`;
+    }
+    lines.push(`  return ${current};`);
+    return lines;
+  };
+  const reportBodyLines = (operation) => {
+    const selectName = `select${operation.pascalId}`;
+    repositoryImports.add(selectName);
+    const lines = [`  const rows = (await ${selectName}(${handle})).map(${dto});`];
+    const sharedUsed = /* @__PURE__ */ new Map();
+    for (const hole of operation.aggregateHoles) for (const table of hole.from) sharedUsed.set(table.sqlName, table);
+    for (const table of sharedUsed.values()) {
+      repositoryImports.add(`select${table.typeName}Rows`);
+      dbImports.add(`type ${table.rowType}`);
+      typeImports.add(table.typeName);
+      lines.push(`  const ${table.tsName}Rows = (await select${table.typeName}Rows(${handle})).map(to${table.typeName}Dto);`);
+    }
+    for (const hole of operation.aggregateHoles) {
+      const picked = hole.reads.map((field) => `${field}: input.${field}`).join(", ");
+      const shared = hole.from.length === 0 ? "" : `, { ${hole.from.map((table) => `${table.tsName}: ${table.tsName}Rows`).join(", ")} }`;
+      const call = `${hole.id}({ ${picked} }, rows${shared}${effectArguments(plan, hole)})`;
+      lines.push(`  const ${hole.id}Value = ${isAsyncHole(hole) ? `await ${call}` : call};`);
+    }
+    const rootFields = [];
+    if (operation.outputModel.kind === "object") {
+      for (const [name, model] of Object.entries(operation.outputModel.fields)) {
+        const hole = operation.aggregateHoles.find((candidate) => candidate.writes === name);
+        if (hole !== void 0) rootFields.push(`    ${name}: ${hole.id}Value,`);
+        else if (operation.echoFields.includes(name)) rootFields.push(`    ${name}: input.${name},`);
+        else rootFields.push(`    ${name}: ${neutralValueOf(model)},`);
+      }
+    }
+    lines.push(`  const computed: ${operation.outputType} = {`, ...rootFields, "  };", ...projectionLines(operation));
+    return lines;
+  };
   const readBodyLines = (operation) => {
+    if (operation.report) return reportBodyLines(operation);
     const element = operation.element;
     if (element === null) {
       const selectName2 = `select${operation.pascalId}`;
@@ -7400,20 +7844,9 @@ function emitService(plan) {
       ...elementFields,
       "    })),",
       ...rootFields,
-      "  };"
+      "  };",
+      ...projectionLines(operation)
     );
-    if (operation.projectHoles.length === 0) {
-      lines.push("  return computed;");
-    } else {
-      if (plan.tenant === null) lines.push("  const projection = deps.ctx;");
-      else lines.push("  const { db: _db, ...projection } = deps.ctx;", "  void _db;");
-      let current = "computed";
-      for (const hole of operation.projectHoles) {
-        lines.push(`  const ${hole.id}Output = ${hole.id}(projection, ${current});`);
-        current = `${hole.id}Output`;
-      }
-      lines.push(`  return ${current};`);
-    }
     return lines;
   };
   const respondLines = (operation) => {
@@ -7429,7 +7862,7 @@ function emitService(plan) {
         "",
         `/** ${operation.method} ${operation.path} \u2014 ${operation.id}. */`,
         `export async function ${operation.serviceName}(deps: ${deps}, input: ${operation.inputType}): Promise<${operation.outputType}> {`,
-        ...operation.echoFields.length === 0 && operation.motif?.method !== "currentByKey" ? ["  void input;"] : [],
+        ...operation.echoFields.length === 0 && operation.motif?.method !== "currentByKey" && !operation.aggregateHoles.some((hole) => hole.reads.length > 0) ? ["  void input;"] : [],
         ...readBodyLines(operation),
         "}"
       );
@@ -7588,6 +8021,16 @@ function emitService(plan) {
     "  };",
     "}"
   ];
+  const sharedUsedByHoles = plan.sharedTables.filter((table) => plan.holes.some((hole) => hole.kind === "aggregate" && hole.from.some((candidate) => candidate.sqlName === table.sqlName)));
+  const sharedDtoLines = sharedUsedByHoles.flatMap((table) => [
+    "",
+    `/** One row of the shared table ${table.sqlName} at its schema (D60): what the aggregate holes receive. */`,
+    `function to${table.typeName}Dto(row: ${table.rowType}): ${table.typeName} {`,
+    "  return {",
+    ...table.fields.map((field) => `    ${field.name}: ${field.dtoExpression},`),
+    "  };",
+    "}"
+  ]);
   const slotHelpers = plan.slots.flatMap((slot) => {
     const dtoFields = slot.fields.map((field) => `${field.name}: ${field.dtoExpression}`).join(", ");
     const keyValues = slot.keyValues === null ? null : `KEY_VALUES_OF_${slot.name.toUpperCase()}`;
@@ -7636,6 +8079,7 @@ ${[...typeImports].sort().map((name) => `  type ${name},`).join("\n")}
     "}",
     "",
     ...dtoLines,
+    ...sharedDtoLines,
     ...slotHelpers,
     "",
     "/** A hole's refusal becomes the operation's 400 OgygieError. */",
@@ -7758,7 +8202,8 @@ function manifestEntryOf(plan) {
     })),
     // The views of the view holes are read through Drizzle like tables: what the repository reads is on the map (D32).
     // D33 precision (M3): the manifest gate proves a declared table by its pgTable — a SQL Server product has none, so its entry declares no table; the generated block of its spec is the map.
-    dbTables: plan.target.database === "mssql-raw" ? [] : [...tablesOf(plan).map((table) => table.sqlName), ...plan.holes.flatMap((hole) => hole.kind === "view" ? [hole.name] : [])]
+    // D60: a shared table read through its Drizzle mapping is on the map like a view — the manifest gate asks every pgTable of the folder to be declared.
+    dbTables: plan.target.database === "mssql-raw" ? [] : [...tablesOf(plan).map((table) => table.sqlName), ...plan.holes.flatMap((hole) => hole.kind === "view" ? [hole.name] : []), ...plan.sharedTables.map((table) => table.sqlName)]
   };
 }
 function canonicalJson(value) {
@@ -7990,6 +8435,8 @@ function holeLine(hole, plan) {
       return `- ${tick3(hole.id)} \u2014 ${tick3("validate")}, lit ${hole.reads.map(tick3).join(", ")} de ${tick3(hole.inputTypeName)}, refuse en ${tick3(hole.errorCode)} (400) ; appel\xE9 par ${carriers} ; ${context}`;
     case "derive":
       return `- ${tick3(hole.id)} \u2014 ${tick3("derive")}, lit ${hole.reads.map(tick3).join(", ")} de ${tick3(hole.inputTypeName)}, \xE9crit ${tick3(hole.writes)}${hole.errorCode === null ? "" : `, refuse en ${tick3(hole.errorCode)} (400)`} ; appel\xE9 par ${carriers} ; ${context}`;
+    case "aggregate":
+      return `- ${tick3(hole.id)} \u2014 ${tick3("aggregate")} (D60), lit ${hole.reads.length === 0 ? "rien de l'entr\xE9e" : `${hole.reads.map(tick3).join(", ")} de ${tick3(hole.inputTypeName)}`}, les lignes de ${tick3(hole.resourceTypeName)}${hole.from.length === 0 ? "" : ` et ${hole.from.map((table) => tick3(table.sqlName)).join(", ")}`}, \xE9crit ${tick3(hole.writes)} de la sortie ; appel\xE9 par ${carriers} ; ${context}`;
     case "project":
       return `- ${tick3(hole.id)} \u2014 ${tick3("project")}, lit ${hole.reads.map(tick3).join(", ")} du contexte de l'appelant, \xE9crit ${hole.writes.map(tick3).join(", ")} ; appel\xE9 par ${carriers} ; ${context}`;
     case "view":
@@ -8037,6 +8484,7 @@ function emitSpecContracts(plan) {
     ...tableSection(plan.table, plan, indexes.length === 0 ? [] : [`index ${indexes.join(" ; ")}`]),
     ...detailTables.flatMap((table) => ["", ...tableSection(table, plan, [])]),
     ...views.flatMap((view) => ["", ...viewSection(view)]),
+    ...plan.sharedTables.flatMap((table) => ["", `${tick3(table.sqlName)} \u2014 table PARTAG\xC9E (D60) : table du produit hors du bloc, lue par les trous aggregate qui la nomment, typ\xE9e par ${tick3(table.schemaName)}, jamais cr\xE9\xE9e ni \xE9crite ici ; mapping en lecture seule dans ${tick3("db.schema.gen.ts")}.`]),
     "",
     "## Trous (D23)",
     "",
@@ -11504,10 +11952,14 @@ export {
   tableNameOf,
   tableRefOf,
   parentKeyFieldOf,
+  SharedTableSchema,
+  sharedTableNameOf,
+  typedSharedTablesOf,
   OperationSchema,
   isHttpOperation,
   isWriteOperation,
   isKeyedOperation,
+  AggregateHoleSchema,
   HoleSchema,
   acceptExamplesOf,
   HOLE_KIND_SERVES,
@@ -11588,6 +12040,7 @@ export {
   tablesOf,
   ownedTables,
   viewBodiesOf,
+  deepOverlay,
   normalizedTypeOf,
   HoleShapeSchema,
   HoleProvenanceSchema,
@@ -11603,7 +12056,6 @@ export {
   HOLES_LIBRARY_DIR,
   loadHolesLibrary,
   libraryFileNameOf,
-  deepOverlay,
   GENERATED_FEATURE_FILES,
   generateFeature,
   migrationFileNameFor,