@lupinum/ginko 0.4.0 → 0.6.0

package/dist/internal.d.mts

@@ -1,19 +1,41 @@
-import { S as Schema, L as Locale, J as Json, P as ParseOptions, I as Issue, g as FileField, D as Described, b as Msg, F as Fields, B as Brick, e as CollectionBrick, T as Task, W as WeekInfo, C as Currency, c as Label, M as MarkdownTree } from './shared/ginko.D-fNojn9.mjs';
-export { A as ALT_MAX, h as BooleanField, d as BrickSource, i as BrickValue, j as ChoiceField, k as ChoiceOption, l as ChoicesField, m as ComponentDef, a as ComponentRegistry, n as ComponentSlot, o as CoreKey, p as DEFAULT_WEEK, q as DataOf, r as DateField, s as DateRangeField, t as Field, u as FieldType, v as FileValue, G as GINKO_COMPONENTS_KEY, w as GINKO_TOC_KEY, x as ImageField, y as ImageValue, z as ItemOf, E as ListField, H as Localized, K as LongTextField, N as MARKDOWN_PROFILES, O as MarkdownField, Q as MarkdownProfile, U as MarkdownToc, X as MarkdownValue, Y as MigrationDescriptor, Z as Money, _ as MoneyField, $ as NumberField, a0 as PREFILL_TOKENS, a1 as ParsedMarkdown, a2 as PrefillToken, a3 as RefField, R as RetiredRule, f as SingleBrick, a4 as SlugField, a5 as TextBlock, a6 as TextField, a7 as TimeField, a8 as TocLink, a9 as UNSAFE_LINK, aa as URL_PROPS, ab as UnknownChoice, ac as ValueOf, V as Visibility, ad as addDays, ae as componentProblems, af as componentPropMessage, ag as componentPropProblem, ah as coreCatalogs, ai as coreMessage, aj as defineComponents, ak as describeProfile, al as effectiveAlt, am as effectiveMax, an as effectiveProfile, ao as f, ap as isPrefillToken, aq as isShown, ar as isTranslatable, as as msg, at as parseMarkdown, au as plainText, av as profileCovers, aw as resolveToken, ax as startOfWeek, ay as textBlocks, az as todayIn, aA as weekInfoOf, aB as workWeekOf } from './shared/ginko.D-fNojn9.mjs';
-import { S as SiteInput } from './shared/ginko.akHewCGt.mjs';
-export { C as CheckLinksOptions, E as ExternalLink, L as LinkConfig, a as LinkIssue, M as Migration, b as MigrationContext, R as Redirect, c as RouteTemplate, d as checkLinks, e as collection, f as defineSite, g as entryRedirects, h as externalLinks, i as findRedirect, l as linkTargets, m as matchRedirect, r as redirectProblems, j as resolveRouteLinks, s as single } from './shared/ginko.akHewCGt.mjs';
-import { M as MarkdownTrees, B as Bundle, a as BundleItem } from './shared/ginko.Bwan3BB-.mjs';
-export { b as BUNDLE_FORMAT, c as BundleBrick, d as bundleFits, i as isBundle, k as knownBricks, m as markdownTrees, w as withFileBricks } from './shared/ginko.Bwan3BB-.mjs';
-export { C as Condition, N as NavNode, Q as Query, a as QueryOrder, b as QueryResult, c as QuerySchema, S as SeoHead, d as SeoImage, e as SeoInput, f as articleLd, g as breadcrumbLd, h as breadcrumbs, i as faqLd, j as formatMoney, k as isPreviewHost, l as isSafeHref, m as minorDigits, n as navTree, o as neighbors, p as organizationLd, q as query, r as robotsTxt, s as safeHref, t as seoHead, u as siteHeaders, w as websiteLd } from './shared/ginko.BTUfZCfa.mjs';
+import { C as Currency, L as Locale, c as Label, B as Brick, S as Schema, F as Fields, p as Field, J as Json, P as ParseOptions, E as Issue, x as FileField, G as Described, a as Msg, f as CollectionBrick, M as MarkdownTree, T as Task, W as WeekInfo, b as ComponentRegistry } from './shared/ginko.DrkUeYFP.mjs';
+export { K as ALT_INVISIBLE, O as ALT_MAX, A as AttributeRegistry, o as BooleanField, d as BrickSource, Q as BrickStatus, U as BrickValue, X as CALENDAR_NAMES, r as ChoiceField, Y as ChoiceOption, Z as ChoicesField, e as CollectionStatus, _ as ComponentDef, $ as ComponentSlot, a0 as CoreKey, a1 as DEFAULT_WEEK, a2 as DataOf, D as DateField, k as DateRangeField, a3 as FieldType, a4 as FileValue, a5 as GINKO_COMPONENTS_KEY, a6 as GINKO_TOC_KEY, s as Holiday, t as HolidayCalendar, y as HolidayCalendarName, H as HolidaysOption, I as ImageField, a7 as ImageValue, a8 as ItemOf, v as ListField, a9 as Localized, w as LongTextField, aa as MARKDOWN_PROFILES, m as MarkdownField, ab as MarkdownProfile, ac as MarkdownToc, ad as MarkdownValue, ae as MigrationDescriptor, af as Money, n as MoneyField, N as NumberField, ag as PREFILL_TOKENS, ah as ParsedMarkdown, ai as PrefillToken, q as RefField, R as RetiredRule, aj as STORED_HOLIDAYS, h as SingleBrick, g as SingleStatus, j as SlugField, u as StoredHolidays, ak as TextBlock, i as TextField, l as TimeField, al as TocLink, am as UNSAFE_LINK, an as URL_PROPS, ao as UnknownChoice, ap as ValueOf, V as Visibility, aq as addDays, z as calendarOfCountry, ar as componentProblems, as as componentPropMessage, at as componentPropProblem, au as coreCatalogs, av as coreMessage, aw as defineComponents, ax as describeProfile, ay as effectiveAlt, az as effectiveMax, aA as effectiveProfile, aB as f, aC as firstDayShown, aD as holidaysOf, aE as isPrefillToken, aF as isShown, aG as isTranslatable, aH as msg, aI as parseMarkdown, aJ as plainText, aK as profileCovers, aL as resolveToken, aM as startOfWeek, aN as textBlocks, aO as todayIn, aP as weekInfoOf, aQ as wordsOf, aR as workWeekOf, aS as zoneOffset, aT as zonedDateTime } from './shared/ginko.DrkUeYFP.mjs';
+import { S as SiteInput } from './shared/ginko.DkIc0ZZk.mjs';
+export { C as CheckLinksOptions, E as ExternalLink, L as LinkConfig, a as LinkIssue, M as Migration, b as MigrationContext, c as Redirect, R as RouteTemplate, W as WithoutFiles, d as checkLinks, e as collection, f as defineSite, g as entryRedirects, h as externalLinks, i as findRedirect, l as linkTargets, m as matchRedirect, r as redirectProblems, j as resolveRouteLinks, s as single, k as siteForContent, w as withoutFiles } from './shared/ginko.DkIc0ZZk.mjs';
+import { M as MarkdownTrees, B as Bundle, a as BundleItem } from './shared/ginko.6cI8KXZP.mjs';
+export { b as BUNDLE_FORMAT, c as BundleBrick, d as bundleFits, i as isBundle, k as knownBricks, m as markdownTrees, w as withFileBricks } from './shared/ginko.6cI8KXZP.mjs';
+export { C as Condition, Q as Query, a as QueryOrder, b as QueryResult, c as QuerySchema, f as formatMoney, i as isSafeHref, m as minorDigits, n as neighbors, q as query, s as safeHref } from './shared/ginko.BaFweQcB.mjs';
+export { A as ArticleLdInput, N as NavNode, a as ORGANIZATION_TYPES, O as OrganizationLdInput, S as SeoHead, b as SeoImage, c as SeoInput, d as articleLd, e as breadcrumbJsonLd, f as breadcrumbs, g as faqLd, i as isPreviewHost, n as navTree, o as organizationLd, r as robotsTxt, s as seoHead, h as siteHeaders, w as websiteLd, j as withCountry } from './shared/ginko.o1yIKlgj.mjs';
+export { g as HourPlan, i as HoursLine, j as HoursLineContext, Z as HoursTexts, _ as NoticeTask, $ as PostalAddressInput, a0 as WeekRow, a1 as eventsBrick, a2 as hourPlansBrick, a3 as hoursBrick, z as hoursLine, a4 as noticesBrick, a5 as offerPrice, a6 as postalAddress, a7 as weekdays } from './shared/ginko.C_nq6vk7.mjs';
 import '@lupinum/ginko-i18n/core';
 import 'comark';
 
-/** Content budget per site (SPEC 3), shared by the platform's writes and the CLI's release check. */
-declare const SITE_BUDGET: {
-    readonly siteBytes: number;
-    readonly entries: 2000;
-    readonly entryBytes: number;
-};
+/** Most content languages one site can have. */
+declare const MAX_LOCALES = 20;
+/**
+ * A content language: a BCP-47 tag that `Intl.getCanonicalLocales` accepts and that is already canonical
+ * (`es`, `pt-BR`, `zh-Hant`; not `EN-us` or `pt_BR`). Runtime check for `Locale`, which is a plain string.
+ */
+declare function isLocale(value: unknown): value is Locale;
+/** An ISO-4217 code (`EUR`, `JPY`, `SGD`) that this runtime's `Intl` knows. */
+declare function isCurrency(value: unknown): value is Currency;
+/**
+ * The text of a label in `locale`: that language, else the main language, else English, else the first one given.
+ * A plain string is the main language's text and is shown in every language.
+ */
+declare function labelOf(label: Label, locale: string, main: string): string;
+/**
+ * A schema label in the Studio's languages (German, English, Spanish, French), for factories that ship ready-made
+ * bricks. The stored schema keeps the record; `labelOf` picks the editor's language and falls back to English.
+ */
+declare const studioLabel: (de: string, en: string, es: string, fr: string) => Record<Locale, string>;
+/**
+ * `brick` with every label, hint, group, item label, option label and task label written as its plain text in
+ * `locale`. For a package that shares a factory but keeps the one-language labels its sites already store
+ * (ginko-docs): a changed label is a schema change on every such site.
+ */
+declare function labelsIn<B extends Brick>(brick: B, locale: Locale): B;
+
 declare const SCHEMA_LIMITS: {
     readonly bytes: number;
     readonly bricks: 30;
@@ -31,6 +53,16 @@ declare function platformSchema(schema: Schema): Schema;
 declare function ordered<T extends {
     pos?: number;
 }>(record: Record<string, T>): [string, T][];
+/**
+ * A staff member's rights (`brick.task` grants, SPEC 2.7) by area: the live bricks in schema order, each with the
+ * labels of its granted tasks in task order. A grant whose brick or task is gone or retired grants nothing and is
+ * left out. The one reading of grants for the Team page, the invite mail and the invite page.
+ */
+declare function grantGroups(schema: Pick<Schema, 'bricks'>, grants: readonly string[]): {
+    brick: string;
+    label: Label;
+    tasks: Label[];
+}[];
 /** Exact source text: a changed literal inside the function must change the fingerprint. */
 declare function migrationFingerprint(brick: string, fills: string, compute: (...args: never[]) => unknown): string;
 declare function mainLocale(schema: Pick<Schema, 'locales'>): Locale;
@@ -45,9 +77,49 @@ declare function checkSite(site: SiteInput, schema?: Schema): string[];
  * schemas from the network (release, devPush), so any value is a problem list, never a crash.
  */
 declare function checkSchema(schema: unknown): string[];
+/** True when `brick` is a live collection with the live fields of `hourPlans()`. */
+declare function isHourPlans(brick: Brick): boolean;
 /** An IANA time zone name this runtime's `Intl` knows, e.g. `Europe/Vienna`. */
 declare function isTimeZone(timeZone: unknown): timeZone is string;
 
+/**
+ * Content budget per site (SPEC 3): one rule for the platform's writes, imports and releases, the CLI's checks and
+ * the Studio's meters. Bytes are the stored text, the JSON of an entry's `data` and `prints`. Markdown trees are
+ * derived from that text and do not count; `treeBytes` only bounds their total, so the public bundle a site reads
+ * stays inside Convex's read limit even for text that is almost all formatting.
+ *
+ * `entryBytes` is 480 KiB, not 512: a history row holds the before and after of a changed field, and two values of
+ * 512 KiB would pass Convex's 1 MiB document limit. `trashBytes` caps the removed entries, which count apart from the
+ * site: a removal past it deletes the oldest removed entries early, and an import past it is refused.
+ *
+ * The Studio's list queries (ginko-server entries.list, titles, ofBricks) read a whole brick per run, which these
+ * limits keep inside Convex's per-query read limits. Raising `siteBytes` above about 8 MiB needs index pagination.
+ */
+declare const SITE_BUDGET: {
+    readonly siteBytes: number;
+    readonly entries: 2000;
+    readonly entryBytes: number;
+    readonly treeBytes: number;
+    readonly trashBytes: number;
+};
+/** UTF-8 bytes of `value` as JSON, the way the budget counts. */
+declare function byteSize(value: unknown): number;
+/** The bytes one entry counts against the budget: its text, not its derived trees. */
+declare function entryBytes(data: unknown, prints?: unknown): number;
+/**
+ * Whether a write keeps a byte count within `limit`. A write that does not grow the count always passes, so an
+ * entry or a site that is over its limit (after an import, or a lowered limit) can still be shortened.
+ */
+declare function fitsBudget(after: number, before: number, limit: number): boolean;
+/**
+ * About how many bytes a full value of `field` takes: every text at its max in every language, every list at its max
+ * rows. One byte per character, as for Latin text (worst-case UTF-8 would flag almost every schema). Several refs
+ * without a `max` count 0. An estimate for `ginko check`; the platform's exact count stays the authority.
+ */
+declare function largestFieldBytes(field: Field, locales: readonly string[]): number;
+/** About how many bytes an entry with every field full takes (largestFieldBytes summed), to compare with SITE_BUDGET.entryBytes. */
+declare function largestEntryBytes(fields: Fields, locales: readonly string[]): number;
+
 /**
  * The source of one or more neighbouring top-level nodes. One block has one node, except where the
  * text cannot be cut between them (`# Title` directly followed by a line of text) or where a piece
@@ -97,19 +169,38 @@ declare function serializeMarkdown(nodes: readonly Json[], options?: SerializeOp
  * True when `text` survives a trip through comark's renderer: parse, render the whole tree, parse
  * again gives the same nodes. The editor opens a text in source mode when this is false. The
  * `<!-- more -->` line is not part of the nodes, so it does not count here (serializeMarkdown with
- * `original` keeps it). Frontmatter is read and ignored.
+ * `original` keeps it). A text with parts the tree does not show (`hidden`) is never stable: written
+ * from the tree, it would lose them. Frontmatter is read and ignored.
  */
 declare function isStableMarkdown(text: string, options?: ParseOptions): Promise<boolean>;
 
+/**
+ * Codes of values the Studio and the site cannot read at all (wrong shape, unknown names). A `restore` refuses only
+ * these: a backup brings back what the platform once stored, even where a rule became stricter since.
+ */
+declare const SHAPE_CODES: ReadonlySet<string>;
 interface ValidateOptions {
-    /** create/release: everything strict. patch: only paths under `changed` are errors, the rest are warnings. */
-    mode: 'create' | 'patch' | 'release';
+    /**
+     * create/release: everything strict. patch: only paths under `changed` are errors, the rest are warnings.
+     * restore (backup import, never a Studio path): only SHAPE_CODES are errors, the rest are warnings.
+     * The rules across fields (`ruleIssues`: a plan set by halves, a week that does not start on its first day) bind
+     * what is written now: errors in create, and in patch when the save touches one of their fields. Stored data that
+     * breaks one (release, restore) only warns.
+     */
+    mode: 'create' | 'patch' | 'release' | 'restore';
     /** Leaf paths changed by a patch, e.g. `closedNote` or `days.k3Fd9aZ0qx.dish`. */
     changed?: ReadonlySet<string>;
     /** Whether entry `id` exists in collection brick `brick`. Without it, referenced IDs are not looked up. */
     refs?: (brick: string, id: string) => boolean;
     /** The description text a file has in the Files library, per language. Without it an image field must carry its own main-language alt. */
     fileAlt?: (file: string) => Record<string, string> | undefined;
+    /**
+     * Platform texts: the kind of the ready upload of the site, not in the trash, that a `$file.<id>` in a Markdown text
+     * names (`image`, or `file` for a PDF); undefined when there is none. With it, every such reference must name one, a
+     * picture must name an image, and every Markdown image needs a description (its own, else the library's in
+     * `fileAlt`), the rule of image fields. Without it (file content) none of this is checked.
+     */
+    uploads?: (file: string) => 'image' | 'file' | undefined;
 }
 interface ValidationResult {
     errors: Issue[];
@@ -150,6 +241,34 @@ interface SchemaDiff {
  */
 declare function diffSchema(prod: Schema, next: Schema): SchemaDiff;
 
+type Row = Record<string, Json>;
+interface RowDiff {
+    /** The row's `_id`; `#<index>` for a row without one (legacy data). */
+    id: string;
+    change: 'added' | 'removed' | 'changed';
+    before: Json | null;
+    after: Json | null;
+    /** Keys of the row whose value differs (only for `changed`). */
+    fields?: string[];
+}
+/** Added, removed and changed rows of a list by `_id`, and whether the rows both sides keep moved. */
+declare function rowDiffs(before: Json | null | undefined, after: Json | null | undefined): {
+    rows: RowDiff[];
+    reordered?: true;
+};
+/**
+ * Both people's row changes of one list since `base`: their list in their order, my edits on rows
+ * they left as they were, my removals of rows they did not change, and my new rows after the row
+ * before them in my list (after their new rows there). `clashes` are the ids of rows both changed
+ * differently, or one changed and the other removed. A moved row, or a row without `_id`, cannot be
+ * merged row by row: `reordered` says so, and the person chooses one version.
+ */
+declare function mergeRows(base: Json | null | undefined, mine: Json | null | undefined, theirs: Json | null | undefined): {
+    rows: Row[];
+    clashes: string[];
+    reordered: boolean;
+};
+
 /**
  * The data an existing entry gets in a release: the defaults of new required fields, the defaults of
  * new required list columns in every row that lacks them, then the migration writes. `roots` names
@@ -207,10 +326,24 @@ interface ResolveContext {
 }
 interface ResolvedEntry {
     data: Record<string, unknown>;
+    /** Leaves delivered in the main language because their translation is missing. */
     fallback: string[];
-    /** `untranslated: 'hide'` and a required translatable leaf is missing or outdated in this locale. */
+    /**
+     * Leaves whose translation was made for an older main-language text. They are delivered as they are, until someone
+     * translates them again or confirms them (D6); the Studio lists them.
+     */
+    outdated: string[];
+    /**
+     * The required translatable leaves without text in this locale (an outdated one counts as translated): while there
+     * is one, the entry has no page in this locale. Never for the main locale or an unknown one; slugs and image
+     * descriptions never count, they fall back by design.
+     */
+    blocking: string[];
+    /** `blocking` is not empty in a collection whose mode is `'hide'` (`untranslatedMode`): the bundle leaves the entry out of this locale. */
     hidden: boolean;
 }
+/** Pages (collections with a route) leave an untranslated entry out of that language; parts of pages fall back to the main language. */
+declare function untranslatedMode(brick: CollectionBrick): 'hide' | 'fallback';
 /** The print that marks a translation as fresh for the current main-language value. */
 declare function printOf(mainValue: unknown): string;
 /** Stored entry → bundle form for one locale (SPEC part 6). */
@@ -226,7 +359,14 @@ declare function isVisible(brick: Brick, data: Record<string, unknown>, today: s
 declare function visibleUntil(brick: Brick, data: Record<string, unknown>): string | undefined;
 /** Whether the platform deletes the entries of this brick that no longer show (`visible.deleteExpired`). */
 declare const deletesExpired: (brick: Brick) => boolean;
-declare function sortEntries(brick: CollectionBrick, entries: StoredEntry[]): StoredEntry[];
+/**
+ * The entries in the brick's order. With `languages`, a translatable field (a title) sorts by its text in `locale`,
+ * else in the main language, so every language's list is in its own alphabetical order.
+ */
+declare function sortEntries(brick: CollectionBrick, entries: StoredEntry[], languages?: {
+    locale: Locale;
+    main: Locale;
+}): StoredEntry[];
 interface BuildBundleInput {
     schema: Schema;
     requestedLocale: string;
@@ -240,13 +380,23 @@ interface BuildBundleInput {
     today: string;
 }
 /**
- * The bundle a site receives: `buildBundle` with every Markdown text as its tree. The platform's
- * bundle endpoint, the Studio preview and the contract fixtures all serve this, never `buildBundle` alone.
+ * The bundle a site receives: `buildBundle` with every Markdown text as its tree, its `$file.<id>` references
+ * resolved to the files' URLs and its route links to paths. The platform's bundle endpoint, the Studio preview and
+ * the contract fixtures all serve this, never `buildBundle` alone. In another language, links to entries left out of
+ * it go to their main-language page (`resolveRouteLinks`).
  */
 declare function servedBundle(input: BuildBundleInput): Promise<Bundle>;
 declare function buildBundle(input: BuildBundleInput): Bundle;
-/** URL per locale where the entry exists (respects `untranslated: 'hide'`); the slug falls back to the main language. */
-declare function urlsFor(schema: Schema, key: string, brick: CollectionBrick, entry: StoredEntry, files: (id: string) => FileInfo | undefined): Partial<Record<Locale, string>>;
+/**
+ * Every locale's address of the entry from the route and slug (a locale without its own slug takes the main one),
+ * translated or not: for cache refresh and URL clash checks.
+ */
+declare function routeUrls(schema: Schema, brick: CollectionBrick, entry: StoredEntry): Partial<Record<Locale, string>>;
+/**
+ * The URLs where the entry is a page: `routeUrls` without the locales where it is untranslated, whatever the
+ * mode. In `'fallback'` mode such an entry stays in that locale's lists but has no page there.
+ */
+declare function urlsFor(schema: Schema, key: string, brick: CollectionBrick, entry: StoredEntry): Partial<Record<Locale, string>>;
 /** Two entries that resolve to the same URL in one locale. `first` comes earlier in the input. */
 interface UrlClash {
     url: string;
@@ -255,9 +405,9 @@ interface UrlClash {
     second: string;
 }
 /**
- * Entries that share a URL in one locale. Takes the `urlsFor` results of all entries (of all bricks:
+ * Entries that share a URL in one locale. Takes the `routeUrls` results of all entries (of all bricks:
  * two bricks with `route: '/[slug]'` clash too); this catches clashes that slugs alone miss, because
- * `urlsFor` lets a locale without its own slug fall back to the main slug. One clash per later entry and URL.
+ * `routeUrls` lets a locale without its own slug fall back to the main slug. One clash per later entry and URL.
  */
 declare function urlClashes(entries: Iterable<{
     id: string;
@@ -278,12 +428,100 @@ declare function blockedSlugs(schema: Schema, brickKey: string, locale: Locale,
  */
 declare function applyDefaults(bundle: Bundle, schema: Schema): Bundle;
 
+/** The ref of one markdown field: `brick` and `id` name the entry (a single's id is its brick), `field` the field. */
+type MarkdownRefOf = (brick: string, id: string, field: string) => string;
+/** The site path that serves a tree of a file brick, from the build (`/__ginko/files/<locale>/md/…`). */
+declare function fileMarkdownRef(locale: Locale, brick: string, id: string, field: string): string;
+/**
+ * The site path that serves a tree of a platform brick at content revision `rev` (`<schemaRev>.<contentRev>`).
+ * The rev in the path lets the site's route keep one copy of the platform's trees per revision.
+ */
+declare function platformMarkdownRef(locale: Locale, rev: string, brick: string, id: string, field: string): string;
+/**
+ * The bundle for page state: every markdown field that holds its tree becomes `{ ref, words }` (values that are refs
+ * already stay). `trees` collects the trees by their ref, for the route that serves them. The tree keeps its own
+ * toc, so a page reads the toc of the text it loaded; `words` lets a list show a reading time without the tree.
+ * Markdown inside `list` fields stays inline.
+ */
+declare function withMarkdownRefs(bundle: Bundle, schema: Pick<Schema, 'bricks'>, trees: Map<string, MarkdownTree>, refOf: MarkdownRefOf): Bundle;
+
 /** German-friendly URL slug: "Über uns & Team" → "ueber-uns-team". Empty input gives "eintrag". */
 declare function slugify(input: string): string;
 declare const SLUG_PATTERN: RegExp;
+/**
+ * The slug of a new entry per locale before it is made unique (SPEC 2.2), from the text of its `from` field in that
+ * locale: the main locale (the first) always gets one; another locale gets one from its own text, or `undefined`
+ * when it has none and takes the main locale's slug. The platform makes these unique; the Studio's preview of a new
+ * entry uses them as they are.
+ */
+declare function slugBases(locales: readonly string[], texts: Readonly<Record<string, string | undefined>>): Record<string, string | undefined>;
 /** First free slug: base, base-2, base-3, … */
 declare function uniqueSlug(base: string, taken: (slug: string) => boolean): string;
 
+/**
+ * Today's opening hours of a single with `status: { hours: true }`: closed (with the owner's reason or the public
+ * holiday's name, when there is one), open in `ranges` (`['11:30', '14:30']`), or unknown (the rules give no answer for
+ * today, which makes the section due).
+ */
+type HoursToday = {
+    closed: true;
+    reason?: Label;
+} | {
+    ranges: readonly (readonly [string, string])[];
+} | {
+    unknown: true;
+};
+/**
+ * What the status line says. Titles are in the site's main language (null while an entry has none: the Studio shows the
+ * brick's label), dates are `YYYY-MM-DD`, `field` is the field's name.
+ */
+type StatusLine = {
+    kind: 'next';
+    title: string | null;
+    date: string;
+} | {
+    kind: 'count';
+    ending: number;
+    online: number;
+} | {
+    kind: 'missing';
+    count: number;
+    field: string;
+} | {
+    kind: 'age';
+    title: string | null;
+    date: string;
+    weeks: number;
+} | {
+    kind: 'hours';
+    today: HoursToday;
+} | {
+    kind: 'drafts';
+    drafts: number;
+    scheduled: number;
+};
+/** An entry as the status reads it: its data, and for a draft its state and when it goes live. */
+interface StatusEntry {
+    data: Record<string, Json>;
+    state?: 'draft' | 'live';
+    publishAt?: number;
+}
+/**
+ * The status line of `brick` and whether its section is due (`due`), from the brick's entries (removed ones left out;
+ * drafts count only for the drafts line). `hours` is today's answer of the hours rules for `{ hours: true }`; without
+ * it (null) the brick shows no hours line. Due: entries end within 7 days, entries miss the `missing` field, the next
+ * entry starts within 7 days with a required text empty in a site language, or today's hours are unknown. The weekly
+ * upkeep rule (`staleOf`) is the caller's: it needs the other bricks.
+ */
+declare function brickStatus(brick: Brick, entries: readonly StatusEntry[], site: {
+    today: string;
+    locales: readonly Locale[];
+    hours?: HoursToday | null;
+}): {
+    line: StatusLine | null;
+    due: boolean;
+};
+
 interface WeekState {
     /** The edit task that fixes it. */
     task: Extract<Task, {
@@ -315,6 +553,21 @@ declare function weeklyTask(brick: {
     }>;
     tasks?: readonly Task[];
 }): Pick<WeekState, 'task' | 'field'> | undefined;
+/**
+ * The date field of a brick that holds the first day of a week: `plans.field` of a collection that plans weeks, else
+ * the field of the weekly task (`weeklyTask`), else the first date field a task presets to `@workWeek` or
+ * `@nextWorkWeek`. Validation wants a week start there (a week stored as a Thursday never shows), and the Studio offers
+ * week shortcuts for it.
+ */
+declare function weekStartField(brick: {
+    fields: Record<string, {
+        type: string;
+    }>;
+    tasks?: readonly Task[];
+    plans?: {
+        field: string;
+    };
+}): string | undefined;
 /**
  * The week starts planned ahead for the single brick `singleKey`: the `plans.field` of every entry of the
  * collections that plan it. The caller passes only live entries (no drafts, nothing deleted).
@@ -329,25 +582,62 @@ declare function plannedWeeks(schema: Pick<Schema, 'bricks'>, singleKey: string,
  * live entries only and `thisWeek` from `workWeekOf` in the site's time zone.
  */
 declare function plansThisWeek(schema: Pick<Schema, 'bricks'>, singleKey: string, task: Task, entryBrick: string, data: Record<string, Json>, thisWeek: string): boolean;
+/**
+ * The value of a planned change (`planned`) once its day has come: `next` when `from` is `today` or earlier, else
+ * undefined. From that day the site shows it in place of `field`, so a task opens on it and the Studio lists it.
+ * `today` is in the site's time zone.
+ */
+declare function duePlan(brick: Pick<Brick, 'planned'>, data: Record<string, Json>, today: string): Json | undefined;
+/**
+ * Whether a create task asks for `key`. With `task.fields`: only those fields. Without: every field of the brick. Never
+ * the address (made from the title) or the plan of a planned change (`planned`), which needs a value in effect to
+ * replace. The Studio's sheet and the agent door's tool both use this rule.
+ */
+declare function createAsks(brick: Pick<Brick, 'fields' | 'planned'>, key: string, task?: Pick<Extract<Task, {
+    kind: 'create';
+}>, 'fields'>): boolean;
+/**
+ * The day a save shows on the website when that is later than `today` (the site's time zone), else undefined (it shows
+ * at once): a week planned ahead (`plans`) from its first shown day (`firstDayShown`); a save that changed only the
+ * plan of a planned change (`planned`) from the plan's date. `changed` are the root fields the save wrote.
+ */
+declare function liveFrom(schema: Pick<Schema, 'bricks' | 'week'>, brickKey: string, data: Record<string, Json>, changed: readonly string[], today: string): string | undefined;
 
 declare function sha256(input: string): string;
 /** Stable JSON: object keys sorted, so equal values always hash the same. */
 declare function stableJson(value: unknown): string;
 
-/** Most content languages one site can have. */
-declare const MAX_LOCALES = 20;
+/** Translation prints: leaf path → locale → print of the main-language value the translation was made from. */
+type Prints = Record<string, Record<string, string>>;
+/** Every translatable leaf of a root field: path → value per locale. Paths match resolveEntry's fallback paths. */
+declare function leavesOf(field: Field, value: Json | undefined, path: string, out?: Map<string, Record<string, Json>>): Map<string, Record<string, Json>>;
 /**
- * A content language: a BCP-47 tag that `Intl.getCanonicalLocales` accepts and that is already canonical
- * (`es`, `pt-BR`, `zh-Hant`; not `EN-us` or `pt_BR`). Runtime check for `Locale`, which is a plain string.
+ * Prints after a rewrite that keeps the meaning, such as the file IDs that replace image paths in a text on export, or
+ * the new IDs an import gives those files: a translation that was current for the old main-language value stays
+ * current for the new one. Other prints stay as they are.
  */
-declare function isLocale(value: unknown): value is Locale;
-/** An ISO-4217 code (`EUR`, `JPY`, `SGD`) that this runtime's `Intl` knows. */
-declare function isCurrency(value: unknown): value is Currency;
+declare function carryPrints(fields: Fields, before: Record<string, Json>, after: Record<string, Json>, prints: Prints, main: Locale): Prints;
+
+type Data = Record<string, unknown>;
+/** The text of a translatable value in one locale, or the plain value when it is not localized. */
+declare function textIn(value: unknown, locale: Locale): string;
+/** Lower case without accents, so "schnitz" finds "Schnitzel" and "kase" finds "Käse". */
+declare function searchable(text: string): string;
 /**
- * The text of a label in `locale`: that language, else the main language, else English, else the first one given.
- * A plain string is the main language's text and is shown in every language.
+ * The name the entry's own input gives it: a week planned ahead by its week ("Woche ab 19.10.2026"), else its first
+ * filled text or longtext field in `locale`; undefined while nothing is typed. `label` words the week's field label
+ * for the reader (default: in `locale`).
  */
-declare function labelOf(label: Label, locale: string, main: string): string;
+declare function entryTitle(brick: Brick, data: Data, locale: Locale, label?: (label: Label) => string): string | undefined;
+/** All words of an entry's text and longtext fields in every language, in `searchable` form: what a list search matches. */
+declare function listHaystack(brick: Brick, data: Data, locales: readonly string[]): string;
+/** A list sorted by one field (a saved view's sort), as a copy. Entries without a value come last, in either direction. */
+declare function listSort<T extends {
+    data: Data;
+}>(rows: readonly T[], brick: Brick, sort: {
+    field: string;
+    dir: 'asc' | 'desc';
+}, main: string): T[];
 
 /** The JSON Schema subset the tools use. */
 interface JsonSchema {
@@ -416,11 +706,6 @@ declare const UPLOAD_TYPES: {
         readonly kind: "image";
         readonly limit: number;
     };
-    readonly 'image/heic': {
-        readonly label: "HEIC";
-        readonly kind: "image";
-        readonly limit: number;
-    };
     readonly 'application/pdf': {
         readonly label: "PDF";
         readonly kind: "file";
@@ -435,6 +720,58 @@ declare function limitOf(kind: 'image' | 'file'): number;
 /** Megabytes the German way: 1,5. */
 declare function formatMb(bytes: number): string;
 
+/**
+ * A reference to a library file in a Markdown text; group 1 is the upload ID. Only where a text can name a file: a
+ * link or image destination (`]($file.x)`, `[ref]: $file.x`, also inside `<…>`), a component attribute value
+ * (`{src="$file.x"}`) and a prop in the YAML block of a component (`src: $file.x`), which the editor writes for a
+ * component with more than three props. The same words elsewhere are text: `mv "$file" "$file.bak"` in a shell
+ * example names no file. A prose line that looks like a YAML prop (`Hinweis: $file.x`) matches too; the server keeps
+ * only IDs that have the form of an upload ID. The match is the reference alone, so a replace keeps what stands before it.
+ */
+declare const FILE_REF: RegExp;
+/** The upload ID when the whole `value` is a file reference (`$file.<id>`), else undefined. */
+declare const fileRefOf: (value: string) => string | undefined;
+/** The upload IDs a text references; code is text. */
+declare function fileRefsIn(text: string): Set<string>;
+/** The upload IDs of the Markdown images in a text (`![alt]($file.<id>)`) that have no description of their own. */
+declare function fileImagesWithoutAlt(text: string): Set<string>;
+/** The text with every reference whose ID is in `map` pointing at its new ID. Unknown IDs, and words in code, stay as they are. */
+declare function rewriteFileRefs(text: string, map: ReadonlyMap<string, string>): string;
+/** The entry IDs and slugs that a text links to (`$authors.<ref>`); page links and words in code are left out. */
+declare function entryLinkRefs(text: string): Set<string>;
+/** The text with every link to an entry whose ID is in `map` pointing at its new ID. Slugs, unknown IDs and words in code stay as they are. */
+declare function rewriteEntryLinks(text: string, map: ReadonlyMap<string, string>): string;
+/**
+ * The data with every upload ID found in `map` replaced by its new ID: in image and file fields (`{ file }`) and in the
+ * `$file.<id>` references of Markdown texts, also in list rows. Unknown IDs stay as they are. One walk for the import of
+ * a backup (platform) and for `local:files-export` (public paths to file IDs).
+ */
+declare function remapFileIds(fields: Fields, data: Record<string, Json>, map: ReadonlyMap<string, string>): Record<string, Json>;
+/** The data with `fn` applied to every Markdown text: each language, list rows included. Other values stay as they are. */
+declare function mapMarkdownTexts(fields: Fields, data: Record<string, Json>, fn: (text: string) => string): Record<string, Json>;
+type Node = [string, Record<string, Json>, ...Json[]];
+/** The image props a component declares (`f.image`), by tag. */
+declare function imagePropsOf(components: ComponentRegistry | undefined): Record<string, string[]>;
+/** One place in a tree that names a library file: an `img` source, a declared component image prop or a link. */
+interface FileRefUse {
+    id: string;
+    kind: 'img' | 'prop' | 'link';
+    node: Node;
+    prop: string;
+}
+/** Every `$file.<id>` that a tree uses as a whole `img` source, component image prop or link `href`. */
+declare function fileRefUses(nodes: readonly Json[], components: ComponentRegistry | undefined): FileRefUse[];
+/**
+ * The bundle with every `$file.<id>` of its Markdown trees resolved through `files` (the bundle's ready uploads):
+ * - `img`: the file's URL, its pixel size, a `srcset` of its variants and the original, and the library description
+ *   of the bundle's language when the image has none of its own (`effectiveAlt`).
+ * - a component image prop: the URL; for `src` also the file's `width` and `height` when the author set neither (and
+ *   the component declares both), and an empty `alt` (when it declares one) from the library.
+ * - a link: the file's URL.
+ * An unknown or not yet ready file loses its URL and gets `data-broken: true`, like a route link that cannot be resolved.
+ */
+declare function resolveFileRefs(bundle: Bundle, schema: Pick<Schema, 'components'>, files: (id: string) => FileInfo | undefined): Bundle;
+
 interface AgentOptions {
     /** Tells which fields are markdown and text, and the labels of the bricks. */
     schema: Pick<Schema, 'bricks'>;
@@ -464,6 +801,7 @@ declare function llmsFullTxt(bundle: Bundle, options: AgentOptions & {
 declare function markdownNotFound(bundle: Bundle, path: string, options: {
     origin: string;
     limit?: number;
+    schema?: AgentOptions['schema'];
 }): string;
 
 interface EntryMatch {
@@ -492,5 +830,13 @@ type ImageInfo = {
 /** Returns undefined when the bytes are not a recognised image, or when the header is truncated. */
 declare function imageInfo(bytes: Uint8Array): ImageInfo | undefined;
 
-export { Brick, Bundle, BundleItem, CollectionBrick, Currency, Described, Fields, FileField, Issue, Json, Label, Locale, MAX_LOCALES, MarkdownTree, MarkdownTrees, Msg, ParseOptions, SCHEMA_LIMITS, SITE_BUDGET, SLUG_PATTERN, Schema, SiteInput, Task, UPLOAD_TYPES, WeekInfo, acceptOf, applyDefaults, blockedSlugs, buildBundle, checkSchema, checkSite, defaultsFor, deletesExpired, diffSchema, entryMarkdown, fieldsChanged, fileProblem, findEntryByPath, formatMb, fromToolInput, imageInfo, isCurrency, isDate, isLocale, isStableMarkdown, isTimeZone, isVisible, labelOf, limitOf, llmsFullTxt, llmsTxt, mainLocale, markdownBlocks, markdownNotFound, markdownRequestPath, migrationFingerprint, ordered, plannedWeeks, plansThisWeek, platformSchema, printOf, releaseData, resolveEntry, serializeMarkdown, serializeSchema, servedBundle, sha256, slugify, sortEntries, stableJson, staleOf, taskInputSchema, uniqueSlug, urlClashes, urlsFor, validate, visibleUntil, weeklyTask };
-export type { AgentOptions, BuildBundleInput, EntryMatch, FileInfo, ImageInfo, ImageType, JsonSchema, JsonSchemaObject, MarkdownBlock, MarkdownBlocks, ResolveContext, SchemaChange, SchemaDiff, SerializeOptions, StoredEntry, ToolInputContext, ToolSchemaContext, UploadType, UrlClash, ValidateOptions, ValidationResult, WeekState };
+/** The folder `ginko export` writes to when no folder is given: `ginko-export-<site>-<YYYY-MM-DD>` (UTC). */
+declare function defaultDir(site: string, now: Date): string;
+/** Where a file lies in the export folder, relative to it. */
+declare function pathOf(file: {
+    id: string;
+    mime: string;
+}): string;
+
+export { Brick, Bundle, BundleItem, CollectionBrick, ComponentRegistry, Currency, Described, FILE_REF, Field, Fields, FileField, Issue, Json, Label, Locale, MAX_LOCALES, MarkdownTree, MarkdownTrees, Msg, ParseOptions, SCHEMA_LIMITS, SHAPE_CODES, SITE_BUDGET, SLUG_PATTERN, Schema, SiteInput, Task, UPLOAD_TYPES, WeekInfo, acceptOf, applyDefaults, blockedSlugs, brickStatus, buildBundle, byteSize, carryPrints, checkSchema, checkSite, createAsks, defaultDir, defaultsFor, deletesExpired, diffSchema, duePlan, entryBytes, entryLinkRefs, entryMarkdown, entryTitle, fieldsChanged, fileImagesWithoutAlt, fileMarkdownRef, fileProblem, fileRefOf, fileRefUses, fileRefsIn, findEntryByPath, fitsBudget, formatMb, fromToolInput, grantGroups, imageInfo, imagePropsOf, isCurrency, isDate, isHourPlans, isLocale, isStableMarkdown, isTimeZone, isVisible, labelOf, labelsIn, largestEntryBytes, largestFieldBytes, leavesOf, limitOf, listHaystack, listSort, liveFrom, llmsFullTxt, llmsTxt, mainLocale, mapMarkdownTexts, markdownBlocks, markdownNotFound, markdownRequestPath, mergeRows, migrationFingerprint, ordered, pathOf, plannedWeeks, plansThisWeek, platformMarkdownRef, platformSchema, printOf, releaseData, remapFileIds, resolveEntry, resolveFileRefs, rewriteEntryLinks, rewriteFileRefs, routeUrls, rowDiffs, searchable, serializeMarkdown, serializeSchema, servedBundle, sha256, slugBases, slugify, sortEntries, stableJson, staleOf, studioLabel, taskInputSchema, textIn, uniqueSlug, untranslatedMode, urlClashes, urlsFor, validate, visibleUntil, weekStartField, weeklyTask, withMarkdownRefs };
+export type { AgentOptions, BuildBundleInput, EntryMatch, FileInfo, FileRefUse, HoursToday, ImageInfo, ImageType, JsonSchema, JsonSchemaObject, MarkdownBlock, MarkdownBlocks, MarkdownRefOf, Prints, ResolveContext, RowDiff, SchemaChange, SchemaDiff, SerializeOptions, StatusEntry, StatusLine, StoredEntry, ToolInputContext, ToolSchemaContext, UploadType, UrlClash, ValidateOptions, ValidationResult, WeekState };