@murumets-ee/yhikas-sync 0.40.0 → 0.42.0

package/dist/index.d.mts

@@ -30,11 +30,36 @@ declare const YHIKAS_SYNC_ACTOR_ID = "yhikas-sync";
  */
 declare const SYNC_JOB_NAME = "yhikas-sync:pull";
 declare const WATCHDOG_JOB_NAME = "yhikas-sync:staleness-watchdog";
-/** The two resources in scope. `site_info` / `site_notice` are Q1, deliberately absent. */
+/**
+ * The three resources in scope.
+ *
+ * `site_info` was deliberately absent until 2026-08-11 (D027). PR 05 left it
+ * out on a MEASUREMENT — `site_info`/`site_notice` appear only in
+ * yhikas-admin's `src/db/schema.ts` and its public route, with no admin UI, no
+ * server action, no seed and no internal consumer — from which the plan
+ * concluded that no rows existed and a sync would pull nothing.
+ *
+ * Measured against production on 2026-08-11 (R028), that premise had expired:
+ * the route answers 200 with populated reception hours and two live notices.
+ * The rows were written outside the app. Hardcoding them in the rebuilt site
+ * would therefore have frozen live data, not stood in for an empty upstream.
+ */
 declare const ROOM_TYPES_RESOURCE = "room_types";
 declare const LEGAL_DOCUMENTS_RESOURCE = "legal_documents";
-declare const SYNC_RESOURCES: readonly ["room_types", "legal_documents"];
+declare const SITE_INFO_RESOURCE = "site_info";
+declare const SYNC_RESOURCES: readonly ["room_types", "legal_documents", "site_info"];
 type SyncResource = (typeof SYNC_RESOURCES)[number];
+/**
+ * The business key of the one `yhikas_site_info` row.
+ *
+ * Upstream `site_info` is a singleton and its notices carry no id or code of
+ * their own — only `{text, isActive, order}` — so there is no natural key to
+ * diff N rows on. Modelling it as ONE row with a constant key keeps the whole
+ * package on a single identity story (`code`, `type`, and now `key`), and
+ * keeps the notices ordered without inventing an identity that upstream would
+ * not preserve across an edit.
+ */
+declare const SITE_INFO_KEY = "default";
 /**
  * Locale codes. Upstream `MultilingualText` is `{ en, et }` and the lumi codes
  * are identical, so there is no mapping to configure — inventing one would be
@@ -56,6 +81,12 @@ declare const EN_LOCALE = "en";
 declare const DECLARED_CURRENCY = "EUR";
 /** `net` = the amount excludes VAT. */
 declare const DECLARED_VAT_TREATMENT = "net";
+/**
+ * Hard ceiling on ticker items. A ticker is a marquee: past a couple of dozen
+ * entries nobody reads the tail, and an unbounded array from upstream would
+ * ride into a JSONB column and out onto every page of the site.
+ */
+declare const MAX_SITE_NOTICES = 25;
 /**
  * Env var carrying the sync's OWN bearer credential — deliberately not the
  * site's `PUBLIC_SITE_API_KEY`. The upstream limiter buckets on
@@ -144,16 +175,49 @@ declare function planDiff<T>(input: PlanDiffInput<T>): DiffPlan<T>;
  * NOT `.strict()`: unknown keys are stripped rather than rejected, so adding a
  * third language upstream degrades to "the sync ignores it" instead of "every
  * run fails".
+ *
+ * 🔴 **Each locale key is nullable AND optional, and that is the load-bearing
+ * clause** (F058, cross-referenced to upstream F031). The column is declared
+ * `json(...).notNull()` — and **notNull covers the OBJECT, not its keys**. There
+ * is no CHECK constraint, and two of the four public columns
+ * (`room_type.name`, `legal_document.title`) have no upstream validation at all:
+ * the write is a raw `formData.get(…) as string`, which is `null` the moment a
+ * field is absent. So `{"et":"Tuba","en":null}` — and `{"et":"Tuba"}` — are rows
+ * yhikas-admin accepts today, through its ordinary admin UI.
+ *
+ * Requiring both keys would fail the ENTIRE response for one such row, so 32
+ * room types would stop syncing because one lacks an English name — every six
+ * hours, until somebody edited it upstream. That is exactly the blast-radius
+ * mistake `legalDocumentRowSchema.slug` documents below and deliberately
+ * avoided; a missing translation belongs at one row, and `projection.ts` is
+ * where it is decided (the locale is suppressed, or the row is skipped with a
+ * reason).
+ *
+ * What is NOT relaxed, on purpose:
+ *
+ * - **The object itself stays required.** A missing translation is DATA; a
+ *   missing FIELD is a renamed column or a changed envelope. The consequence of
+ *   tolerating one is caught either way — `assertSomethingSurvived` refuses a
+ *   snapshot in which no row survived — but refusing here NAMES it
+ *   (`title: Required`) instead of reporting 32 identical "no 'et' title
+ *   upstream" skips and leaving the reader to infer the cause.
+ * - **A non-string value is still a shape violation.** `{"en":42}` would
+ *   otherwise be written as a name.
+ *
+ * Note the asymmetry this leaves, deliberately: a RENAMED key (`et_EE`) is
+ * indistinguishable from two absent ones, because unknown keys are stripped by
+ * design so a third language degrades gracefully. That case falls through to
+ * `assertSomethingSurvived`, which is exactly what it is for.
  */
 declare const multilingualTextSchema: z.ZodObject<{
-  et: z.ZodString;
-  en: z.ZodString;
+  et: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  en: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
-  et: string;
-  en: string;
+  et?: string | null | undefined;
+  en?: string | null | undefined;
 }, {
-  et: string;
-  en: string;
+  et?: string | null | undefined;
+  en?: string | null | undefined;
 }>;
 type MultilingualText = z.infer<typeof multilingualTextSchema>;
 /**
@@ -168,14 +232,14 @@ type MultilingualText = z.infer<typeof multilingualTextSchema>;
 declare const roomTypeRowSchema: z.ZodObject<{
   code: z.ZodString;
   name: z.ZodObject<{
-    et: z.ZodString;
-    en: z.ZodString;
+    et: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    en: z.ZodOptional<z.ZodNullable<z.ZodString>>;
   }, "strip", z.ZodTypeAny, {
-    et: string;
-    en: string;
+    et?: string | null | undefined;
+    en?: string | null | undefined;
   }, {
-    et: string;
-    en: string;
+    et?: string | null | undefined;
+    en?: string | null | undefined;
   }>;
   totalArea: z.ZodNullable<z.ZodString>;
   livingArea: z.ZodNullable<z.ZodString>;
@@ -188,8 +252,8 @@ declare const roomTypeRowSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
   code: string;
   name: {
-    et: string;
-    en: string;
+    et?: string | null | undefined;
+    en?: string | null | undefined;
   };
   totalArea: string | null;
   livingArea: string | null;
@@ -202,8 +266,8 @@ declare const roomTypeRowSchema: z.ZodObject<{
 }, {
   code: string;
   name: {
-    et: string;
-    en: string;
+    et?: string | null | undefined;
+    en?: string | null | undefined;
   };
   totalArea: string | null;
   livingArea: string | null;
@@ -227,14 +291,14 @@ type RoomTypeRow = z.infer<typeof roomTypeRowSchema>;
 declare const legalDocumentRowSchema: z.ZodObject<{
   type: z.ZodString;
   title: z.ZodObject<{
-    et: z.ZodString;
-    en: z.ZodString;
+    et: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    en: z.ZodOptional<z.ZodNullable<z.ZodString>>;
   }, "strip", z.ZodTypeAny, {
-    et: string;
-    en: string;
+    et?: string | null | undefined;
+    en?: string | null | undefined;
   }, {
-    et: string;
-    en: string;
+    et?: string | null | undefined;
+    en?: string | null | undefined;
   }>;
   /**
    * Accepted as free text HERE, and screened per-row in the projection.
@@ -255,8 +319,8 @@ declare const legalDocumentRowSchema: z.ZodObject<{
   type: string;
   slug: string;
   title: {
-    et: string;
-    en: string;
+    et?: string | null | undefined;
+    en?: string | null | undefined;
   };
   order: number;
   htmlContentEt: string;
@@ -265,8 +329,8 @@ declare const legalDocumentRowSchema: z.ZodObject<{
   type: string;
   slug: string;
   title: {
-    et: string;
-    en: string;
+    et?: string | null | undefined;
+    en?: string | null | undefined;
   };
   order: number;
   htmlContentEt: string;
@@ -288,14 +352,14 @@ declare const roomTypesResponseSchema: z.ZodObject<{
   roomTypes: z.ZodArray<z.ZodObject<{
     code: z.ZodString;
     name: z.ZodObject<{
-      et: z.ZodString;
-      en: z.ZodString;
+      et: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      en: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, "strip", z.ZodTypeAny, {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     }, {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     }>;
     totalArea: z.ZodNullable<z.ZodString>;
     livingArea: z.ZodNullable<z.ZodString>;
@@ -308,8 +372,8 @@ declare const roomTypesResponseSchema: z.ZodObject<{
   }, "strip", z.ZodTypeAny, {
     code: string;
     name: {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     };
     totalArea: string | null;
     livingArea: string | null;
@@ -322,8 +386,8 @@ declare const roomTypesResponseSchema: z.ZodObject<{
   }, {
     code: string;
     name: {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     };
     totalArea: string | null;
     livingArea: string | null;
@@ -339,8 +403,8 @@ declare const roomTypesResponseSchema: z.ZodObject<{
   roomTypes: {
     code: string;
     name: {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     };
     totalArea: string | null;
     livingArea: string | null;
@@ -356,8 +420,8 @@ declare const roomTypesResponseSchema: z.ZodObject<{
   roomTypes: {
     code: string;
     name: {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     };
     totalArea: string | null;
     livingArea: string | null;
@@ -374,14 +438,14 @@ declare const legalDocumentsResponseSchema: z.ZodObject<{
   documents: z.ZodArray<z.ZodObject<{
     type: z.ZodString;
     title: z.ZodObject<{
-      et: z.ZodString;
-      en: z.ZodString;
+      et: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      en: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, "strip", z.ZodTypeAny, {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     }, {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     }>;
     /**
      * Accepted as free text HERE, and screened per-row in the projection.
@@ -402,8 +466,8 @@ declare const legalDocumentsResponseSchema: z.ZodObject<{
     type: string;
     slug: string;
     title: {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     };
     order: number;
     htmlContentEt: string;
@@ -412,8 +476,8 @@ declare const legalDocumentsResponseSchema: z.ZodObject<{
     type: string;
     slug: string;
     title: {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     };
     order: number;
     htmlContentEt: string;
@@ -425,8 +489,8 @@ declare const legalDocumentsResponseSchema: z.ZodObject<{
     type: string;
     slug: string;
     title: {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     };
     order: number;
     htmlContentEt: string;
@@ -438,14 +502,140 @@ declare const legalDocumentsResponseSchema: z.ZodObject<{
     type: string;
     slug: string;
     title: {
-      et: string;
-      en: string;
+      et?: string | null | undefined;
+      en?: string | null | undefined;
     };
     order: number;
     htmlContentEt: string;
     htmlContentEn: string;
   }[];
 }>;
+/**
+ * One `site_notice` — a ticker item.
+ *
+ * No id, no code, no timestamp: `{text, isActive, order}` is the whole row as
+ * the route serves it. That absence is why `site_info` is modelled as one
+ * local row carrying an ordered list rather than as N diffable rows — there is
+ * no key an edit upstream would preserve.
+ *
+ * `isActive` is honoured HERE rather than assumed: the route returns inactive
+ * notices too, and a ticker that shows a retired notice is worse than one that
+ * shows nothing.
+ */
+declare const siteNoticeRowSchema: z.ZodObject<{
+  text: z.ZodObject<{
+    et: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    en: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  }, "strip", z.ZodTypeAny, {
+    et?: string | null | undefined;
+    en?: string | null | undefined;
+  }, {
+    et?: string | null | undefined;
+    en?: string | null | undefined;
+  }>;
+  isActive: z.ZodBoolean;
+  order: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+  text: {
+    et?: string | null | undefined;
+    en?: string | null | undefined;
+  };
+  order: number;
+  isActive: boolean;
+}, {
+  text: {
+    et?: string | null | undefined;
+    en?: string | null | undefined;
+  };
+  order: number;
+  isActive: boolean;
+}>;
+type SiteNoticeRow = z.infer<typeof siteNoticeRowSchema>;
+/**
+ * `/api/public/site-info` — reception hours plus the notice ticker.
+ *
+ * 🔴 **This envelope cannot express "not configured yet".** The route answers
+ * `200 { success: true, receptionHours: {et:'',en:''}, notices: [] }` when no
+ * row exists, which is byte-identical to an operator having deliberately
+ * cleared everything (F015). The other two resources have no such hole —
+ * theirs discriminate on `success` and on array length against a local
+ * snapshot.
+ *
+ * The schema is therefore NOT where that is solved, and deliberately so: the
+ * shape is valid either way. `projectSiteInfo` refuses an all-empty payload as
+ * unusable (D027), which is the only place that has the standing to decide
+ * that a well-formed response is not authoritative.
+ */
+declare const siteInfoResponseSchema: z.ZodObject<{
+  success: z.ZodLiteral<true>;
+  receptionHours: z.ZodObject<{
+    et: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    en: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  }, "strip", z.ZodTypeAny, {
+    et?: string | null | undefined;
+    en?: string | null | undefined;
+  }, {
+    et?: string | null | undefined;
+    en?: string | null | undefined;
+  }>;
+  notices: z.ZodArray<z.ZodObject<{
+    text: z.ZodObject<{
+      et: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      en: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+      et?: string | null | undefined;
+      en?: string | null | undefined;
+    }, {
+      et?: string | null | undefined;
+      en?: string | null | undefined;
+    }>;
+    isActive: z.ZodBoolean;
+    order: z.ZodNumber;
+  }, "strip", z.ZodTypeAny, {
+    text: {
+      et?: string | null | undefined;
+      en?: string | null | undefined;
+    };
+    order: number;
+    isActive: boolean;
+  }, {
+    text: {
+      et?: string | null | undefined;
+      en?: string | null | undefined;
+    };
+    order: number;
+    isActive: boolean;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  receptionHours: {
+    et?: string | null | undefined;
+    en?: string | null | undefined;
+  };
+  notices: {
+    text: {
+      et?: string | null | undefined;
+      en?: string | null | undefined;
+    };
+    order: number;
+    isActive: boolean;
+  }[];
+  success: true;
+}, {
+  receptionHours: {
+    et?: string | null | undefined;
+    en?: string | null | undefined;
+  };
+  notices: {
+    text: {
+      et?: string | null | undefined;
+      en?: string | null | undefined;
+    };
+    order: number;
+    isActive: boolean;
+  }[];
+  success: true;
+}>;
+type SiteInfoResponse = z.infer<typeof siteInfoResponseSchema>;
 //#endregion
 //#region src/projection.d.ts
 /** Injected at the seam; see the module docblock for why it is not imported. */
@@ -479,6 +669,36 @@ interface ProjectionResult {
 declare function secondaryLocaleOf(defaultLocale: string): string;
 declare function projectRoomTypes(rows: readonly RoomTypeRow[], options: ProjectionOptions): ProjectionResult;
 declare function projectLegalDocuments(rows: readonly LegalDocumentRow[], options: ProjectionOptions, sanitize: HtmlSanitizer): ProjectionResult;
+/**
+ * Reception hours + the notice ticker → the one `yhikas_site_info` row.
+ *
+ * ## 🔴 The refusal is the point of this function
+ *
+ * `/api/public/site-info` answers `200 { success: true, receptionHours:
+ * {et:'',en:''}, notices: [] }` when no upstream row exists. That is
+ * byte-identical to an operator having deliberately cleared both, and it is the
+ * state the endpoint is in whenever nobody has filled it in (F015). The other
+ * two resources have no equivalent hole — theirs discriminate on `success` and
+ * on array length against a local snapshot.
+ *
+ * The shipped `empty-snapshot` floor cannot cover it, and the reason is
+ * structural rather than an oversight: that rule is a row-COUNT test, and this
+ * resource always projects exactly one row. The count is 1 whether the row says
+ * anything or not, so the floor never fires and an all-empty payload would be
+ * applied as an authoritative blanking — emptying the ticker and the hours on
+ * every page of the site, silently, six hours after upstream hiccupped.
+ *
+ * So emptiness is restated here as a CONTENT test: if the default locale has
+ * neither hours nor a single active notice, the payload is refused as
+ * unusable. Local content is left exactly as it was and the failure arms the
+ * staleness watchdog, which is the same posture as an unreachable endpoint —
+ * because epistemically it is the same situation.
+ *
+ * Note what is NOT refused: hours with no notices, or notices with no hours.
+ * Both are ordinary states of a real dormitory, and refusing them would make
+ * the guard fire on exactly the operator action it exists to protect.
+ */
+declare function projectSiteInfo(response: SiteInfoResponse, options: ProjectionOptions): ProjectionResult;
 //#endregion
 //#region src/apply.d.ts
 /**
@@ -529,7 +749,7 @@ declare function applyPlan(input: ApplyPlanInput): Promise<ApplyCounts>;
 //#region src/entities/guard.d.ts
 /** Thrown when a writer other than the sync tries to mutate synced content. */
 declare class YhikasSyncedContentReadOnlyError extends Error {
-  constructor(entityName: string, action: 'create' | 'update' | 'delete' | 'bulk update', actorId: string);
+  constructor(entityName: string, action: 'create' | 'update' | 'delete' | 'bulk update' | 'translation write' | 'locale publish change', actorId: string);
 }
 /**
  * Refuse every create/update/delete not performed by the sync actor.
@@ -539,6 +759,132 @@ declare class YhikasSyncedContentReadOnlyError extends Error {
  */
 declare function machineWritten<N extends string>(entityName: N): Behavior<Record<never, never>, `yhikas-sync:machine-written:${N}`>;
 //#endregion
+//#region src/entities/index.d.ts
+/**
+ * The entities this plugin syncs — ONE list, consumed by the plugin's
+ * declaration and by the contract tests.
+ *
+ * Adding `site_info` turned twelve tests red across two files, every one of
+ * them because a resource or entity had been re-listed by hand somewhere. This
+ * export exists so the next one cannot: `plugin.ts` spreads it into
+ * `server.entities`, and `contract.test.ts` iterates it, so a fourth entity is
+ * covered by both the moment it is added here.
+ */
+declare const SYNCED_ENTITIES: readonly [import("@murumets-ee/entity").Entity<{
+  id: import("@murumets-ee/entity").IdField;
+} & import("@murumets-ee/entity").AuditableFields & import("@murumets-ee/entity").PublishableFields & Record<never, never> & {
+  code: import("@murumets-ee/entity").TextField & {
+    readonly required: true;
+    readonly unique: true;
+    readonly indexed: true;
+    readonly maxLength: 190;
+  };
+  name: import("@murumets-ee/entity").TextField & {
+    readonly required: true;
+    readonly translatable: true;
+  };
+  totalArea: import("@murumets-ee/entity").TextField & {
+    readonly maxLength: 32;
+  };
+  livingArea: import("@murumets-ee/entity").TextField & {
+    readonly maxLength: 32;
+  };
+  commonArea: import("@murumets-ee/entity").TextField & {
+    readonly maxLength: 32;
+  };
+  capacity: import("@murumets-ee/entity").NumberField & {
+    readonly integer: true;
+  };
+  placesOccupied: import("@murumets-ee/entity").NumberField & {
+    readonly integer: true;
+  };
+  monthlyRent: import("@murumets-ee/entity").TextField & {
+    readonly maxLength: 32;
+  };
+  discountedMonthlyRent: import("@murumets-ee/entity").TextField & {
+    readonly maxLength: 32;
+  };
+  dailyRent: import("@murumets-ee/entity").TextField & {
+    readonly maxLength: 32;
+  };
+  currency: import("@murumets-ee/entity").TextField & {
+    readonly required: true;
+    readonly maxLength: 3;
+    readonly default: "EUR";
+  };
+  vatTreatment: import("@murumets-ee/entity").SelectField & {
+    options: readonly ["net", "gross"];
+  } & {
+    readonly options: readonly ["net", "gross"];
+    readonly required: true;
+    readonly default: "net";
+  };
+  hasEnglish: import("@murumets-ee/entity").BooleanField & {
+    readonly required: true;
+    readonly default: false;
+  };
+  sourceHash: import("@murumets-ee/entity").TextField & {
+    readonly maxLength: 64;
+  };
+}, "yhikas_room_type", [import("@murumets-ee/entity").Behavior<import("@murumets-ee/entity").AuditableFields, string>, import("@murumets-ee/entity").Behavior<import("@murumets-ee/entity").PublishableFields, "publishable">, import("@murumets-ee/entity").Behavior<Record<never, never>, "yhikas-sync:machine-written:yhikas_room_type">]>, import("@murumets-ee/entity").Entity<{
+  id: import("@murumets-ee/entity").IdField;
+} & import("@murumets-ee/entity").AuditableFields & import("@murumets-ee/entity").PublishableFields & Record<never, never> & {
+  type: import("@murumets-ee/entity").TextField & {
+    readonly required: true;
+    readonly unique: true;
+    readonly indexed: true;
+    readonly maxLength: 190;
+  };
+  title: import("@murumets-ee/entity").TextField & {
+    readonly required: true;
+    readonly translatable: true;
+  };
+  sourceSlug: import("@murumets-ee/entity").TextField & {
+    readonly required: true;
+    readonly indexed: true;
+    readonly maxLength: 190;
+  };
+  body: import("@murumets-ee/entity").RichTextField & {
+    readonly required: true;
+    readonly translatable: true;
+  };
+  order: import("@murumets-ee/entity").NumberField & {
+    readonly integer: true;
+    readonly required: true;
+    readonly default: 0;
+  };
+  hasEnglish: import("@murumets-ee/entity").BooleanField & {
+    readonly required: true;
+    readonly default: false;
+  };
+  sourceHash: import("@murumets-ee/entity").TextField & {
+    readonly maxLength: 64;
+  };
+}, "yhikas_legal_document", [import("@murumets-ee/entity").Behavior<import("@murumets-ee/entity").AuditableFields, string>, import("@murumets-ee/entity").Behavior<import("@murumets-ee/entity").PublishableFields, "publishable">, import("@murumets-ee/entity").Behavior<Record<never, never>, "yhikas-sync:machine-written:yhikas_legal_document">]>, import("@murumets-ee/entity").Entity<{
+  id: import("@murumets-ee/entity").IdField;
+} & import("@murumets-ee/entity").AuditableFields & import("@murumets-ee/entity").PublishableFields & Record<never, never> & {
+  key: import("@murumets-ee/entity").TextField & {
+    readonly required: true;
+    readonly unique: true;
+    readonly indexed: true;
+    readonly maxLength: 32;
+  };
+  receptionHours: import("@murumets-ee/entity").TextField & {
+    readonly translatable: true;
+    readonly maxLength: 500;
+  };
+  notices: import("@murumets-ee/entity").JsonField & {
+    readonly translatable: true;
+  };
+  hasEnglish: import("@murumets-ee/entity").BooleanField & {
+    readonly default: false;
+    readonly required: true;
+  };
+  sourceHash: import("@murumets-ee/entity").TextField & {
+    readonly maxLength: 64;
+  };
+}, "yhikas_site_info", [import("@murumets-ee/entity").Behavior<import("@murumets-ee/entity").AuditableFields, string>, import("@murumets-ee/entity").Behavior<import("@murumets-ee/entity").PublishableFields, "publishable">, import("@murumets-ee/entity").Behavior<Record<never, never>, "yhikas-sync:machine-written:yhikas_site_info">]>];
+//#endregion
 //#region src/entities/legal-document.d.ts
 /**
  * `yhikas_legal_document` — the local projection of yhikas-admin's
@@ -755,6 +1101,96 @@ declare const YhikasRoomType: import("@murumets-ee/entity").Entity<{
   };
 }, "yhikas_room_type", [import("@murumets-ee/entity").Behavior<import("@murumets-ee/entity").AuditableFields, string>, import("@murumets-ee/entity").Behavior<import("@murumets-ee/entity").PublishableFields, "publishable">, import("@murumets-ee/entity").Behavior<Record<never, never>, "yhikas-sync:machine-written:yhikas_room_type">]>;
 //#endregion
+//#region src/entities/site-info.d.ts
+/**
+ * `yhikas_site_info` — reception hours and the notice ticker, as ONE row.
+ *
+ * ## Why a singleton and not N notice rows
+ *
+ * Upstream `site_notice` carries `{text, isActive, order}` and nothing else —
+ * no id, no code, no timestamp. So there is no business key an edit upstream
+ * would preserve, and a diff keyed on `order` would read "notice 2 was
+ * reworded" and "notices 2 and 3 swapped places" as the same event. Modelling
+ * the resource as one row carrying an ordered list keeps identity honest: the
+ * whole list is the value, and it is replaced as a value.
+ *
+ * That also matches what the site does with it. A ticker renders the list in
+ * order; nothing links to an individual notice, so nothing needs one to have a
+ * URL, a version or a publish state of its own.
+ *
+ * ## Both halves are optional, and that is the point
+ *
+ * `receptionHours` and `notices` can each legitimately be empty — a dormitory
+ * with no current notices is an ordinary state. What is NOT ordinary is BOTH
+ * being empty, because that is exactly what `/api/public/site-info` returns
+ * when no row exists at all (F015), and it is indistinguishable at the wire
+ * from a deliberate clearing. `projectSiteInfo` refuses that payload rather
+ * than writing it (D027) — the refusal lives there because emptiness is a
+ * content judgement, not a schema one.
+ *
+ * ## Security
+ *
+ * As with the other two synced entities: `access` is advisory metadata, the
+ * firewall does not read it, and `admin` bypasses it unconditionally. The real
+ * controls are deny-by-default (no non-admin role is granted anything here) and
+ * `machineWritten`, which since PR 12 refuses non-sync writers on the base row
+ * AND on the translation path.
+ */
+declare const YHIKAS_SITE_INFO_ENTITY = "yhikas_site_info";
+declare const YhikasSiteInfo: import("@murumets-ee/entity").Entity<{
+  id: import("@murumets-ee/entity").IdField;
+} & import("@murumets-ee/entity").AuditableFields & import("@murumets-ee/entity").PublishableFields & Record<never, never> & {
+  /**
+   * The business key, constant at {@link SITE_INFO_KEY}.
+   *
+   * A singleton still needs a key, for the same reason the other two do: the
+   * differ matches local to upstream by key, and `applyPlan` upserts on it.
+   * A constant key makes the singleton a one-element case of the same
+   * machinery rather than a second code path.
+   */
+  key: import("@murumets-ee/entity").TextField & {
+    readonly required: true;
+    readonly unique: true;
+    readonly indexed: true;
+    readonly maxLength: 32;
+  };
+  /**
+   * Reception hours as free text — `E–R 9–17`, or whatever the office writes.
+   *
+   * Deliberately NOT structured. Upstream stores one multilingual string and
+   * the site renders it verbatim; parsing it into open/close pairs here would
+   * invent a schema neither system has, and would fail the first time someone
+   * writes "suletud 24.06".
+   */
+  receptionHours: import("@murumets-ee/entity").TextField & {
+    readonly translatable: true;
+    readonly maxLength: 500;
+  };
+  /**
+   * The ticker, as an ordered array of strings for ONE locale.
+   *
+   * Already filtered to `isActive` and already sorted by `order` at
+   * projection time, so a renderer maps over it and nothing more. `isActive`
+   * and `order` are upstream's editing affordances, not content — carrying
+   * them across would oblige every consumer to re-implement the same filter
+   * and sort, and one of them would eventually get it wrong.
+   */
+  notices: import("@murumets-ee/entity").JsonField & {
+    readonly translatable: true;
+  };
+  /**
+   * Whether the secondary locale has anything publishable. A convenience
+   * flag for the admin list, never the control — per-locale publish status is.
+   */
+  hasEnglish: import("@murumets-ee/entity").BooleanField & {
+    readonly default: false;
+    readonly required: true;
+  }; /** The change signal. Written LAST, so a stale hash means "redo this row". */
+  sourceHash: import("@murumets-ee/entity").TextField & {
+    readonly maxLength: 64;
+  };
+}, "yhikas_site_info", [import("@murumets-ee/entity").Behavior<import("@murumets-ee/entity").AuditableFields, string>, import("@murumets-ee/entity").Behavior<import("@murumets-ee/entity").PublishableFields, "publishable">, import("@murumets-ee/entity").Behavior<Record<never, never>, "yhikas-sync:machine-written:yhikas_site_info">]>;
+//#endregion
 //#region src/entity-client.d.ts
 /** The `AdminClient` methods the adapter forwards, structurally. */
 type AdminClientLike = ReturnType<ToolkitApp['getClient']>;
@@ -930,6 +1366,15 @@ declare class YhikasUpstreamClient {
   fetchRoomTypes(): Promise<RoomTypeRow[]>;
   /** `GET /api/public/legal-documents`. Active only, ordered by `order`; unpaginated. */
   fetchLegalDocuments(): Promise<LegalDocumentRow[]>;
+  /**
+   * `GET /api/public/site-info`. Reception hours + notice ticker; a singleton,
+   * so there is nothing to order or paginate.
+   *
+   * Returns the whole envelope rather than one key, because both halves are the
+   * payload and neither is meaningful without the other — a caller deciding
+   * whether this response is usable at all has to see both (D027).
+   */
+  fetchSiteInfo(): Promise<SiteInfoResponse>;
 }
 //#endregion
 //#region src/run-sync.d.ts
@@ -937,6 +1382,7 @@ interface SyncRunDeps {
   readonly upstream: YhikasUpstreamClient;
   readonly roomTypeClient: SyncEntityClient;
   readonly legalDocumentClient: SyncEntityClient;
+  readonly siteInfoClient: SyncEntityClient;
   readonly state: SyncStateStore;
   readonly sanitizeHtml: HtmlSanitizer;
   readonly logger: SyncLogger;
@@ -982,7 +1428,20 @@ declare class YhikasUpstreamError extends Error {
  */
 declare class YhikasSyncRefusedError extends Error {
   readonly resource: SyncResource;
-  readonly reason: 'empty-snapshot' | 'retire-fraction' | 'oversized-snapshot' | 'duplicate-key';
+  readonly reason: 'empty-snapshot' | 'retire-fraction' | 'oversized-snapshot' | 'duplicate-key'
+  /**
+   * A well-formed 200 whose CONTENT is entirely empty (D027).
+   *
+   * Distinct from `empty-snapshot`, which is a row-COUNT test and therefore
+   * cannot see this: `site_info` always projects exactly one row, so the
+   * count is 1 whether or not that row says anything. `/api/public/site-info`
+   * answers 200 with empty strings and no notices when no upstream row
+   * exists, which is byte-identical to a deliberate clearing (F015) — so the
+   * only safe reading of an all-empty payload is "not authoritative", and the
+   * only safe response is to leave local content alone and let the watchdog
+   * arm.
+   */
+  | 'empty-content';
   constructor(resource: SyncResource, reason: YhikasSyncRefusedError['reason'], message: string);
 }
 //#endregion
@@ -1022,5 +1481,5 @@ declare function assessStaleness(records: readonly SyncStateRecord[], now: Date,
  */
 declare function assertNotStale(records: readonly SyncStateRecord[], now: Date, staleAfterMs: number): ResourceStaleness[];
 //#endregion
-export { API_KEY_ENV_VAR, type AdminClientLike, type ApplyCounts, type ApplyPlanInput, BASE_URL_ENV_VAR, DECLARED_CURRENCY, DECLARED_VAT_TREATMENT, type DiffPlan, EN_LOCALE, ET_LOCALE, type HtmlSanitizer, LEGAL_DOCUMENTS_RESOURCE, type LegalDocumentRow, type LocalRow, type MultilingualText, type PlanDiffInput, type ProjectedRow, type ProjectionOptions, type ProjectionResult, ROOM_TYPES_RESOURCE, type ResolvedYhikasSyncConfig, type ResourceOutcome, type ResourceStaleness, type RoomTypeRow, SYNC_JOB_NAME, SYNC_RESOURCES, type SanityFloor, type SkippedRow, type SyncEntityClient, type SyncLogger, type SyncResource, type SyncRunDeps, type SyncRunSummary, type SyncStateRecord, type SyncStateStore, type UpstreamFailureKind, VAT_TREATMENTS, WATCHDOG_JOB_NAME, YHIKAS_LEGAL_DOCUMENT_ENTITY, YHIKAS_ROOM_TYPE_ENTITY, YHIKAS_SYNC_ACTOR_ID, YHIKAS_SYNC_PLUGIN_NAME, YhikasApplyPartialError, YhikasLegalDocument, YhikasRoomType, type YhikasSyncConfig, YhikasSyncConfigError, YhikasSyncRefusedError, YhikasSyncRunError, YhikasSyncStaleError, YhikasSyncedContentReadOnlyError, YhikasUpstreamClient, type YhikasUpstreamClientOptions, YhikasUpstreamError, applyPlan, assertNotStale, assessStaleness, createSyncStateStore, legalDocumentRowSchema, legalDocumentsResponseSchema, machineWritten, multilingualTextSchema, planDiff, projectLegalDocuments, projectRoomTypes, readLocalRows, resolveYhikasSyncConfig, roomTypeRowSchema, roomTypesResponseSchema, runYhikasSync, secondaryLocaleOf, stableHash, toSyncEntityClient, truncateError, yhikasSyncStateTable };
+export { API_KEY_ENV_VAR, type AdminClientLike, type ApplyCounts, type ApplyPlanInput, BASE_URL_ENV_VAR, DECLARED_CURRENCY, DECLARED_VAT_TREATMENT, type DiffPlan, EN_LOCALE, ET_LOCALE, type HtmlSanitizer, LEGAL_DOCUMENTS_RESOURCE, type LegalDocumentRow, type LocalRow, MAX_SITE_NOTICES, type MultilingualText, type PlanDiffInput, type ProjectedRow, type ProjectionOptions, type ProjectionResult, ROOM_TYPES_RESOURCE, type ResolvedYhikasSyncConfig, type ResourceOutcome, type ResourceStaleness, type RoomTypeRow, SITE_INFO_KEY, SITE_INFO_RESOURCE, SYNCED_ENTITIES, SYNC_JOB_NAME, SYNC_RESOURCES, type SanityFloor, type SiteInfoResponse, type SiteNoticeRow, type SkippedRow, type SyncEntityClient, type SyncLogger, type SyncResource, type SyncRunDeps, type SyncRunSummary, type SyncStateRecord, type SyncStateStore, type UpstreamFailureKind, VAT_TREATMENTS, WATCHDOG_JOB_NAME, YHIKAS_LEGAL_DOCUMENT_ENTITY, YHIKAS_ROOM_TYPE_ENTITY, YHIKAS_SITE_INFO_ENTITY, YHIKAS_SYNC_ACTOR_ID, YHIKAS_SYNC_PLUGIN_NAME, YhikasApplyPartialError, YhikasLegalDocument, YhikasRoomType, YhikasSiteInfo, type YhikasSyncConfig, YhikasSyncConfigError, YhikasSyncRefusedError, YhikasSyncRunError, YhikasSyncStaleError, YhikasSyncedContentReadOnlyError, YhikasUpstreamClient, type YhikasUpstreamClientOptions, YhikasUpstreamError, applyPlan, assertNotStale, assessStaleness, createSyncStateStore, legalDocumentRowSchema, legalDocumentsResponseSchema, machineWritten, multilingualTextSchema, planDiff, projectLegalDocuments, projectRoomTypes, projectSiteInfo, readLocalRows, resolveYhikasSyncConfig, roomTypeRowSchema, roomTypesResponseSchema, runYhikasSync, secondaryLocaleOf, siteInfoResponseSchema, siteNoticeRowSchema, stableHash, toSyncEntityClient, truncateError, yhikasSyncStateTable };
 //# sourceMappingURL=index.d.mts.map