@ogygie/core 0.1.0

package/src/shared-tables.test.ts

@@ -0,0 +1,136 @@
+/**
+ * @intent Mutation tests of the shared-table gates (DECISIONS.md D22: every
+ * gate is born with its negative test). The shared-table exception is a hole
+ * in the multi-tenant rail — each way of abusing it is fed here as a KNOWN
+ * VIOLATION and must be DETECTED, never silently tolerated.
+ */
+import { describe, expect, it } from "vitest";
+import type { FeatureManifest } from "./manifest.schema.js";
+import { FeatureManifestSchema } from "./manifest.schema.js";
+import {
+  dbTableNamesOf,
+  findTenantColumnsInSharedTables,
+  mayUseRawDb,
+  ownsOnlySharedTables,
+  sharedTableNamesOf,
+  splitDbSchemaByTable,
+  tenantTableNamesOf,
+} from "./shared-tables.js";
+
+const SOCLE = new Set(["accounts"]);
+
+function feature(overrides: Partial<FeatureManifest>): FeatureManifest {
+  return {
+    name: "labels",
+    intent: "A feature used as a fixture for the shared-table gate tests.",
+    folder: "src/features/labels",
+    spec: null,
+    routes: [],
+    dbTables: [],
+    dependsOn: [],
+    status: "delivered",
+    ...overrides,
+  };
+}
+
+describe("déclaration des tables au manifeste", () => {
+  it("accepte la forme chaîne (tenant) et la forme objet { name, shared: true }", () => {
+    const parsed = FeatureManifestSchema.safeParse(
+      feature({ dbTables: ["orders", { name: "labels", shared: true }] }),
+    );
+
+    expect(parsed.success).toBe(true);
+    const target = feature({ dbTables: ["orders", { name: "labels", shared: true }] });
+    expect(dbTableNamesOf(target)).toEqual(["orders", "labels"]);
+    expect(sharedTableNamesOf(target)).toEqual(["labels"]);
+    expect(tenantTableNamesOf(target)).toEqual(["orders"]);
+  });
+
+  it("MUTATION — `shared: false` est REFUSÉ : une table est partagée et le dit, ou reste une chaîne", () => {
+    // Fed as raw JSON: the manifest arrives from disk, never from typed code —
+    // and TypeScript alone would not protect the file on disk.
+    const rawFeature: unknown = JSON.parse(
+      JSON.stringify({ ...feature({}), dbTables: [{ name: "labels", shared: false }] }),
+    );
+
+    expect(FeatureManifestSchema.safeParse(rawFeature).success).toBe(false);
+  });
+});
+
+describe("politique d'accès brut à la base (raw db)", () => {
+  it("une feature ne possédant QUE des tables partagées peut toucher la base directement", () => {
+    const shared = feature({
+      dbTables: [
+        { name: "labels", shared: true },
+        { name: "label_names", shared: true },
+      ],
+    });
+
+    expect(ownsOnlySharedTables(shared)).toBe(true);
+    expect(mayUseRawDb(shared, SOCLE)).toBe(true);
+  });
+
+  it("MUTATION — une seule table TENANT glissée parmi des tables partagées retire le droit d'accès brut", () => {
+    const mixed = feature({
+      dbTables: [{ name: "labels", shared: true }, "orders"],
+    });
+
+    expect(ownsOnlySharedTables(mixed)).toBe(false);
+    expect(mayUseRawDb(mixed, SOCLE)).toBe(false);
+  });
+
+  it("MUTATION — une feature SANS aucune table ne gagne pas le droit par vacuité", () => {
+    const tableless = feature({ name: "pure-compute", dbTables: [] });
+
+    expect(ownsOnlySharedTables(tableless)).toBe(false);
+    expect(mayUseRawDb(tableless, SOCLE)).toBe(false);
+  });
+
+  it("le socle (liste fermée) conserve son droit historique, les autres features tenant ne l'ont pas", () => {
+    expect(mayUseRawDb(feature({ name: "accounts", dbTables: ["tenants"] }), SOCLE)).toBe(true);
+    expect(mayUseRawDb(feature({ name: "orders", dbTables: ["orders"] }), SOCLE)).toBe(false);
+  });
+});
+
+const DB_SCHEMA_WITH_TWO_TABLES = `
+export const labels = pgTable("labels", {
+  labelCode: text("label_code").primaryKey(),
+  canonicalName: text("canonical_name").notNull(),
+});
+
+export const orders = pgTable("orders", {
+  id: uuid("id").primaryKey(),
+  orgId: uuid("org_id").notNull(),
+});
+`;
+
+describe("forme d'une table partagée", () => {
+  it("découpe le fichier db.schema.ts par table", () => {
+    const blocks = splitDbSchemaByTable(DB_SCHEMA_WITH_TWO_TABLES);
+
+    expect([...blocks.keys()]).toEqual(["labels", "orders"]);
+    expect(blocks.get("labels")).toContain("canonical_name");
+    // The labels block stops before the orders one — no bleed-through, or the
+    // gate below would accuse an innocent table of its neighbour's column.
+    expect(blocks.get("labels")).not.toContain("org_id");
+  });
+
+  it("une table partagée sans colonne tenant ne déclenche aucun finding", () => {
+    expect(
+      findTenantColumnsInSharedTables(DB_SCHEMA_WITH_TWO_TABLES, ["labels"], ["org_id"]),
+    ).toEqual([]);
+  });
+
+  it("MUTATION — une table déclarée partagée qui porte encore la colonne tenant est DÉTECTÉE", () => {
+    const contradictory = `
+export const labels = pgTable("labels", {
+  labelCode: text("label_code").primaryKey(),
+  orgId: uuid("org_id").notNull(),
+});
+`;
+
+    expect(
+      findTenantColumnsInSharedTables(contradictory, ["labels"], ["org_id"]),
+    ).toEqual([{ table: "labels", tenantColumn: "org_id" }]);
+  });
+});

package/src/shared-tables.ts

@@ -0,0 +1,113 @@
+/**
+ * @intent Testable heart of the gates that guard the SHARED-TABLE exception
+ * (AGENTS.md §Multi-tenant rule 4). Shared referential tables are the only
+ * sanctioned way to hold rows no tenant owns; they are also a hole in the
+ * product's strongest rail, so every consequence of declaring one is checked
+ * by a gate rather than trusted:
+ *
+ *  1. a shared table carries NO tenant column (nothing to filter on, so
+ *     `tenantDb` would throw TENANT_COLUMN_MISSING at runtime anyway);
+ *  2. a feature owning ONLY shared tables is the sole kind of feature allowed
+ *     to touch the raw database — it has no tenant context to route through;
+ *  3. conversely a feature owning even ONE tenant table must never touch the
+ *     raw db, whatever else it owns: mixing the two in one feature would make
+ *     the raw-db ban unenforceable by inspection.
+ *
+ * These functions are pure (source text in, findings out) so that the negative
+ * tests required by DECISIONS.md D22 can feed them known violations directly —
+ * scripts/lint-interdits.ts and scripts/verify-manifest.ts only report what
+ * they return. The module is GENERIC infrastructure (D10 amended): it speaks
+ * "tenant", never a word of the product's domain.
+ */
+import type { DbTableDeclaration, FeatureManifest } from "./manifest.schema.js";
+
+/** Name of a table however it was declared (bare string or object form). */
+export function dbTableNameOf(declaration: DbTableDeclaration): string {
+  return typeof declaration === "string" ? declaration : declaration.name;
+}
+
+export function dbTableNamesOf(feature: FeatureManifest): string[] {
+  return feature.dbTables.map(dbTableNameOf);
+}
+
+export function sharedTableNamesOf(feature: FeatureManifest): string[] {
+  return feature.dbTables
+    .filter((declaration) => typeof declaration !== "string")
+    .map((declaration) => declaration.name);
+}
+
+export function tenantTableNamesOf(feature: FeatureManifest): string[] {
+  return feature.dbTables
+    .filter((declaration) => typeof declaration === "string")
+    .map((declaration) => declaration);
+}
+
+/**
+ * A feature may bypass the tenant facade ONLY when every table it owns is
+ * shared — and it must own at least one, so that "owns nothing" (a front, a
+ * gateway, a pure-compute feature) never becomes an accidental licence.
+ */
+export function ownsOnlySharedTables(feature: FeatureManifest): boolean {
+  return feature.dbTables.length > 0 && tenantTableNamesOf(feature).length === 0;
+}
+
+/**
+ * Full raw-db policy for one feature: the closed socle allowlist (the tenancy
+ * feature builds the contexts, so it predates them) OR a shared-only feature.
+ */
+export function mayUseRawDb(
+  feature: FeatureManifest,
+  socleAllowlist: ReadonlySet<string>,
+): boolean {
+  return socleAllowlist.has(feature.name) || ownsOnlySharedTables(feature);
+}
+
+/**
+ * Splits a db.schema.ts source into one text block per `pgTable("name", ...)`
+ * definition. Deliberately textual — the same reading verify-manifest already
+ * does — so the gate stays dependency-free and cannot be fooled by a table
+ * defined in a file it does not read.
+ */
+export function splitDbSchemaByTable(source: string): Map<string, string> {
+  const blocks = new Map<string, string>();
+  const matches = [...source.matchAll(/pgTable\(\s*"([^"]+)"/g)];
+  matches.forEach((match, index) => {
+    const tableName = match[1];
+    if (tableName === undefined || match.index === undefined) return;
+    const nextMatch = matches[index + 1];
+    const end = nextMatch?.index ?? source.length;
+    blocks.set(tableName, source.slice(match.index, end));
+  });
+  return blocks;
+}
+
+export interface SharedTableFinding {
+  table: string;
+  /** Name of the tenant-looking column found in the table's definition. */
+  tenantColumn: string;
+}
+
+/**
+ * Reports every SHARED table whose Drizzle definition still declares a tenant
+ * column. Such a table is a contradiction: declared shared (so exempt from RLS
+ * and from tenantDb) yet shaped like a tenant table — exactly the ambiguity
+ * that turns an audited exception back into a leak.
+ */
+export function findTenantColumnsInSharedTables(
+  dbSchemaSource: string,
+  sharedTableNames: readonly string[],
+  tenantColumnNames: readonly string[],
+): SharedTableFinding[] {
+  const blocks = splitDbSchemaByTable(dbSchemaSource);
+  const findings: SharedTableFinding[] = [];
+  for (const table of sharedTableNames) {
+    const block = blocks.get(table);
+    if (block === undefined) continue; // absence is MANIFEST_TABLE_NOT_FOUND's job
+    for (const column of tenantColumnNames) {
+      if (block.includes(`"${column}"`)) {
+        findings.push({ table, tenantColumn: column });
+      }
+    }
+  }
+  return findings;
+}

package/src/spec.schema.test.ts

@@ -0,0 +1,143 @@
+/**
+ * @intent Mutation tests of the spec-frontmatter format (DECISIONS.md D22:
+ * every gate is born — and evolves — with its negative test). Each test feeds
+ * the parser a KNOWN VIOLATION and requires DETECTION, never a silent
+ * default: the three traps consigned in FAILURES.md (2026-07-30, session 7)
+ * each get their mutation, plus the nominal path and the schema-level
+ * rejection of a non-kebab-case blockedBy target.
+ */
+import { describe, expect, it } from "vitest";
+import { SpecFrontmatterSchema, parseSpecFrontmatter } from "./spec.schema.js";
+
+const NOMINAL_FRONTMATTER = `
+id: order-flow
+status: validated
+depends_on: ["billing", "accounts"]
+priority: P0
+refs: ["modele-source tables Orders (250)"]
+deferred: ["QUANTITY_COMPUTATIONS (F1-F4) blockedBy:computations"]
+`;
+
+describe("parseSpecFrontmatter — format restreint D13", () => {
+  it("lit le chemin nominal : scalaires + tableaux inline, validés par SpecFrontmatterSchema", () => {
+    const parsed = parseSpecFrontmatter(NOMINAL_FRONTMATTER);
+
+    expect(parsed.problems).toEqual([]);
+    const validated = SpecFrontmatterSchema.safeParse(parsed.value);
+    expect(validated.success).toBe(true);
+    expect(validated.success && validated.data.deferred).toEqual([
+      "QUANTITY_COMPUTATIONS (F1-F4) blockedBy:computations",
+    ]);
+  });
+
+  it("lit un tableau MULTILIGNE en entier (le format lisible des specs à différés nombreux)", () => {
+    const parsed = parseSpecFrontmatter(`
+id: order-flow
+status: validated
+depends_on: []
+priority: P0
+deferred: [
+  "QUANTITY_COMPUTATIONS blockedBy:computations",
+  "PERENNIAL_ROLLOVER blockedBy:retour-experts-q2"
+]
+`);
+
+    expect(parsed.problems).toEqual([]);
+    expect(parsed.value["deferred"]).toEqual([
+      "QUANTITY_COMPUTATIONS blockedBy:computations",
+      "PERENNIAL_ROLLOVER blockedBy:retour-experts-q2",
+    ]);
+    // No junk key leaks from the consumed lines, and the whole spec validates.
+    expect(Object.keys(parsed.value).sort()).toEqual([
+      "deferred",
+      "depends_on",
+      "id",
+      "priority",
+      "status",
+    ]);
+    expect(SpecFrontmatterSchema.safeParse(parsed.value).success).toBe(true);
+  });
+
+  it("MUTATION — un tableau OUVERT ET JAMAIS FERMÉ est REFUSÉ au lieu d'être lu deferred=[] en silence (le piège order-flow)", () => {
+    const parsed = parseSpecFrontmatter(`
+id: order-flow
+status: validated
+depends_on: []
+priority: P0
+deferred: [
+  "QUANTITY_COMPUTATIONS blockedBy:computations",
+  "PERENNIAL_ROLLOVER blockedBy:retour-experts-q2"
+`);
+
+    // The old parser produced deferred=[] and junk keys — no problem reported,
+    // the SPEC_IMPLEMENTED_WITH_DEFERRED gate went inert. Never again:
+    expect(parsed.problems.length).toBeGreaterThan(0);
+    expect(parsed.problems.join(" ; ")).toContain('key "deferred"');
+    expect(parsed.problems.join(" ; ")).toContain("never closed");
+    // And the lie itself is gone: no silently-empty deferred survives.
+    expect(parsed.value["deferred"]).toBeUndefined();
+  });
+
+  it("MUTATION — une ligne d'élément ORPHELINE (hors de tout tableau) reste refusée", () => {
+    const parsed = parseSpecFrontmatter(`
+id: order-flow
+status: validated
+"PERENNIAL_ROLLOVER blockedBy:retour-experts-q2"
+`);
+
+    expect(
+      parsed.problems.some((problem) => problem.includes("unparseable line")),
+    ).toBe(true);
+  });
+
+  it("MUTATION — une virgule INTERNE à une entrée citée ne casse plus l'entrée en fragments (split conscient des guillemets)", () => {
+    const parsed = parseSpecFrontmatter(
+      'deferred: ["INTERVENTIONS_AND_TIMESHEET (D17, imputation MO/machines) blockedBy:interventions"]',
+    );
+
+    expect(parsed.problems).toEqual([]);
+    // ONE element, comma preserved — the old split produced two broken shards.
+    expect(parsed.value["deferred"]).toEqual([
+      "INTERVENTIONS_AND_TIMESHEET (D17, imputation MO/machines) blockedBy:interventions",
+    ]);
+    // …and that whole entry satisfies the DeferredBehaviorSchema regex.
+    const validated = SpecFrontmatterSchema.safeParse({
+      id: "order-flow",
+      status: "validated",
+      depends_on: [],
+      priority: "P0",
+      deferred: parsed.value["deferred"],
+    });
+    expect(validated.success).toBe(true);
+  });
+
+  it("MUTATION — des guillemets non appariés (dans un tableau ou un scalaire) sont REFUSÉS au lieu de produire des éléments corrompus", () => {
+    const inArray = parseSpecFrontmatter('deferred: ["FOO blockedBy:bar, "BAZ blockedBy:qux"]');
+    expect(inArray.problems.length).toBeGreaterThan(0);
+    expect(inArray.value["deferred"]).toBeUndefined();
+
+    const inScalar = parseSpecFrontmatter('id: "order-flow');
+    expect(inScalar.problems.length).toBeGreaterThan(0);
+    expect(inScalar.value["id"]).toBeUndefined();
+  });
+
+  it("MUTATION — un blockedBy hors kebab-case minuscule (blockedBy:retour-experts-Q2) est rejeté par SpecFrontmatterSchema, champ identifié", () => {
+    const parsed = parseSpecFrontmatter(
+      'deferred: ["PERENNIAL_ROLLOVER blockedBy:retour-experts-Q2"]',
+    );
+    expect(parsed.problems).toEqual([]); // format OK — the SCHEMA is the gate here
+
+    const validated = SpecFrontmatterSchema.safeParse({
+      id: "order-flow",
+      status: "validated",
+      depends_on: [],
+      priority: "P0",
+      deferred: parsed.value["deferred"],
+    });
+    expect(validated.success).toBe(false);
+    expect(
+      !validated.success &&
+        validated.error.issues.some((issue) => issue.path[0] === "deferred"),
+    ).toBe(true);
+  });
+});

package/src/spec.schema.ts

@@ -0,0 +1,182 @@
+/**
+ * @intent Zod schema AND format parser of the YAML frontmatter of
+ * `specs/<feature>.spec.md` files. A spec is a contract, not a document:
+ * machine-readable frontmatter + mandatory canonical sections. The CI
+ * validator (scripts/verify-specs.ts) checks the frontmatter AND the sections;
+ * this module owns the restricted frontmatter format — scalars and arrays of
+ * scalars, inline or multiline (D13) — through parseSpecFrontmatter, which REFUSES what it
+ * cannot read instead of silently swallowing it (a multiline array once read
+ * as `deferred: []` without a sound — FAILURES.md 2026-07-30, DECISIONS.md
+ * D22: every gate is born with its mutation test, see spec.schema.test.ts).
+ * Section titles stay FRENCH on purpose: specs are human-facing documents
+ * (DECISIONS.md D11 — humans of the project read and validate them in French).
+ */
+import { z } from "zod";
+import { FeatureNameSchema } from "./manifest.schema.js";
+
+/**
+ * One deferred behavior (DECISIONS.md D13): a behavior the spec describes but
+ * whose implementation is blocked by a feature that does not exist yet.
+ * Format: "<stable error code or short label> blockedBy:<feature-name>".
+ * The frontmatter parser only reads arrays of STRINGS (inline or multiline),
+ * hence this compact encoding instead of a nested object.
+ */
+export const DeferredBehaviorSchema = z
+  .string()
+  .regex(
+    /^.+ blockedBy:[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
+    'Expected "<behavior> blockedBy:<feature-name>" (feature name in kebab-case)',
+  );
+
+export const SpecFrontmatterSchema = z.object({
+  id: FeatureNameSchema.describe("Identical to the feature name in the manifest"),
+  status: z.enum(["draft", "validated", "implemented"]),
+  depends_on: z.array(FeatureNameSchema),
+  priority: z.enum(["P0", "P1", "P2"]),
+  refs: z
+    .array(z.string())
+    .default([])
+    .describe("References to the domain model, e.g. 'modele-gally §4.2'"),
+  deferred: z
+    .array(DeferredBehaviorSchema)
+    .default([])
+    .describe("Behaviors deferred to a later feature (DECISIONS.md D13)"),
+});
+export type SpecFrontmatter = z.infer<typeof SpecFrontmatterSchema>;
+
+/**
+ * Mandatory Markdown sections in the spec body, in this order.
+ * The CI validator fails when a section is missing (code: SPEC_SECTION_MISSING).
+ */
+export const SECTIONS_SPEC_OBLIGATOIRES = [
+  "# @intent",
+  "# Comportements",
+  "# Contrats de données",
+  "# États UI",
+  "# Non-objectifs",
+  "# Budget",
+] as const;
+
+/**
+ * Lifecycle rule (checked in CI):
+ * - status: draft       → no implementation may exist
+ * - status: validated   → implementation is allowed
+ * - status: implemented → the feature exists in the manifest with status "delivered"
+ *                         AND `deferred` is empty (D13 — nothing left pending)
+ */
+
+// ----------------------------------------------------------- format parser
+export interface ParsedSpecFrontmatter {
+  /** Parsed keys — feed this to SpecFrontmatterSchema. */
+  value: Record<string, unknown>;
+  /** Format violations; non-empty ⇒ the gate reports SPEC_FRONTMATTER_INVALID. */
+  problems: string[];
+}
+
+/** Splits inline-array elements on commas OUTSIDE quotes — a comma inside a
+ * quoted entry is content, not a separator (it used to shatter the entry). */
+function splitInlineArrayElements(inner: string): {
+  elements: string[];
+  unbalancedQuote: boolean;
+} {
+  const elements: string[] = [];
+  let current = "";
+  let openQuote: '"' | "'" | null = null;
+  for (const character of inner) {
+    if (openQuote === null && (character === '"' || character === "'")) {
+      openQuote = character;
+      current += character;
+    } else if (character === openQuote) {
+      openQuote = null;
+      current += character;
+    } else if (openQuote === null && character === ",") {
+      elements.push(current);
+      current = "";
+    } else {
+      current += character;
+    }
+  }
+  elements.push(current);
+  return { elements, unbalancedQuote: openQuote !== null };
+}
+
+/** Unquotes a scalar; both-ends-or-nothing — a dangling quote is a refusal. */
+function unquote(raw: string, location: string, problems: string[]): string | null {
+  const trimmed = raw.trim();
+  const first = trimmed[0];
+  if (first === '"' || first === "'") {
+    if (trimmed.length < 2 || !trimmed.endsWith(first)) {
+      problems.push(`${location}: unbalanced quotes in ${JSON.stringify(trimmed)}`);
+      return null;
+    }
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+/**
+ * Parses the RESTRICTED frontmatter format: one `key: value` per line, values
+ * being scalars or arrays of scalars — nothing nested, no object. An array may
+ * be written INLINE (`[a, b]`) or SPREAD over several lines, the closing `]`
+ * ending it; a long `deferred` list is unreadable on one line, and readability
+ * is the whole point of a spec (3rd friction, PR #15 review).
+ * Everything it cannot read still becomes a problem instead of a silent
+ * default: an array never closed before the end of the frontmatter, a spilled
+ * element line OUTSIDE any array, an unbalanced quote — each once made a spec
+ * lie by omission (FAILURES.md 2026-07-30, D22).
+ */
+export function parseSpecFrontmatter(text: string): ParsedSpecFrontmatter {
+  const value: Record<string, unknown> = {};
+  const problems: string[] = [];
+  const lines = text.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const trimmed = (lines[index] ?? "").trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1 || trimmed.startsWith('"') || trimmed.startsWith("'")) {
+      problems.push(
+        `unparseable line ${JSON.stringify(trimmed)}: expected \`key: value\` — a spilled array element outside any array? (scalars and arrays of scalars only, D13)`,
+      );
+      continue;
+    }
+    const key = trimmed.slice(0, colonIndex).trim();
+    let rawValue = trimmed.slice(colonIndex + 1).trim();
+    if (rawValue.startsWith("[")) {
+      // Multiline array: keep consuming lines until the one closing the
+      // bracket. Reaching the end of the frontmatter without it is a REFUSAL,
+      // never an empty array — that silence is the bug this gate exists for.
+      let closed = rawValue.endsWith("]");
+      while (!closed && index + 1 < lines.length) {
+        index += 1;
+        rawValue = `${rawValue} ${(lines[index] ?? "").trim()}`;
+        closed = rawValue.endsWith("]");
+      }
+      if (!closed) {
+        problems.push(
+          `key "${key}": array opened with "[" and never closed with "]" before the end of the frontmatter — a truncated array would be silently read as empty, hence refused (D13)`,
+        );
+        continue;
+      }
+      const { elements, unbalancedQuote } = splitInlineArrayElements(
+        rawValue.slice(1, -1),
+      );
+      if (unbalancedQuote) {
+        problems.push(`key "${key}": unbalanced quotes inside the array`);
+        continue;
+      }
+      const parsedElements: string[] = [];
+      let broken = false;
+      for (const element of elements) {
+        if (element.trim() === "") continue; // trailing comma tolerated
+        const unquoted = unquote(element, `key "${key}"`, problems);
+        if (unquoted === null) broken = true;
+        else parsedElements.push(unquoted);
+      }
+      if (!broken) value[key] = parsedElements;
+    } else {
+      const unquoted = unquote(rawValue, `key "${key}"`, problems);
+      if (unquoted !== null) value[key] = unquoted;
+    }
+  }
+  return { value, problems };
+}