@lupinum/ginko 0.4.0 → 0.5.0

package/dist/shared/{ginko.C90fPpMP.mjs → ginko.CXA2R3aS.mjs}

@@ -1,9 +1,84 @@
-import { m as msg, b as stableJson, c as bare, e as sameLabel, i as isTranslatable, g as effectiveMax, h as effectiveMin, j as parseMarkdown, k as sha256, l as effectiveAlt } from './ginko.C-QjDn3O.mjs';
-import { B as BRICK_KEYS, F as FIELD_KEYS, S as SCHEMA_KEYS, r as resolveRouteLinks } from './ginko.CrNRBkS5.mjs';
-import { a as addDays } from './ginko.CQvxhyez.mjs';
+import { i as isTranslatable, A as ALT_MAX, g as effectiveMax, m as msg, h as stableJson, j as bare, k as sameLabel, l as effectiveMin, n as sha256, r as resolveRouteLinks, o as resolveFileRefs, q as effectiveAlt } from './ginko.BNVC-g9n.mjs';
+import { B as BRICK_KEYS, F as FIELD_KEYS, S as SCHEMA_KEYS } from './ginko.C4gcOovG.mjs';
+import { a as addDays } from './ginko.AprJymER.mjs';
+import { B as BUNDLE_FORMAT, w as withMarkdownTrees } from './ginko.yKMIjJ68.mjs';
+
+class CliError extends Error {
+  code;
+  constructor(message, code = "INVALID") {
+    super(message);
+    this.code = code;
+  }
+}
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseReleaseState(value) {
+  if (!isObject(value)) throw new CliError("The platform did not return a valid state.", "UNAVAILABLE");
+  const { site, schema, schemaRev, contentRev, migrations, entries } = value;
+  const valid = typeof site === "string" && isObject(schema) && isObject(schema.bricks) && Array.isArray(schema.migrations) && isObject(schema.retired) && typeof schemaRev === "number" && typeof contentRev === "number" && Array.isArray(migrations) && Array.isArray(entries) && entries.every((e) => isObject(e) && typeof e.id === "string" && typeof e.brick === "string" && isObject(e.data));
+  if (!valid) throw new CliError("The platform returned an incomplete state.", "UNAVAILABLE");
+  return value;
+}
+const EXTENSIONS = {
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/webp": ".webp",
+  "image/avif": ".avif",
+  "application/pdf": ".pdf"
+};
+function defaultDir(site, now) {
+  return `ginko-export-${site}-${now.toISOString().slice(0, 10)}`;
+}
+function pathOf(file) {
+  return `files/${file.id}${EXTENSIONS[file.mime] ?? ""}`;
+}
+function parseExport(value, locator, problem) {
+  const optionalNumber = (v) => v === void 0 || typeof v === "number";
+  const optionalString = (v) => v === void 0 || typeof v === "string";
+  const valid = isObject(value) && value.format === 1 && typeof value.site === "string" && typeof value.name === "string" && typeof value.exportedAt === "string" && isObject(value.schema) && isObject(value.schema.bricks) && typeof value.schemaRev === "number" && typeof value.contentRev === "number" && Array.isArray(value.entries) && value.entries.every((e) => isObject(e) && typeof e.id === "string" && typeof e.brick === "string" && (e.kind === "single" || e.kind === "item") && typeof e.order === "number" && isObject(e.data) && isObject(e.prints) && typeof e.rev === "number" && optionalNumber(e.deletedAt)) && Array.isArray(value.files) && value.files.every((f) => isObject(f) && typeof f.id === "string" && typeof f.name === "string" && typeof f.mime === "string" && typeof f.size === "number" && typeof f[locator] === "string" && optionalNumber(f.width) && optionalNumber(f.height) && optionalString(f.folder) && optionalString(f.sha256) && (f.kept === void 0 || typeof f.kept === "boolean") && (f.original === void 0 || f.original === true) && (f.alt === void 0 || isObject(f.alt) && Object.values(f.alt).every((text) => typeof text === "string")) && (f.focus === void 0 || isObject(f.focus) && typeof f.focus.x === "number" && typeof f.focus.y === "number")) && (value.folders === void 0 || Array.isArray(value.folders) && value.folders.every((f) => isObject(f) && typeof f.id === "string" && typeof f.name === "string" && optionalString(f.parent)));
+  if (!valid) throw new CliError(problem, "UNAVAILABLE" );
+  return value;
+}
+
+const SITE_BUDGET = { siteBytes: 4 * 1024 * 1024, entries: 2e3, entryBytes: 480 * 1024, treeBytes: 8 * 1024 * 1024, trashBytes: 4 * 1024 * 1024 };
+function byteSize(value) {
+  return new TextEncoder().encode(JSON.stringify(value ?? null)).byteLength;
+}
+function entryBytes(data, prints = {}) {
+  return byteSize(data) + byteSize(prints);
+}
+function fitsBudget(after, before, limit) {
+  return after <= limit || after <= before;
+}
+const VALUE_JSON = 8;
+const ID_BYTES = 40;
+const SHORT_VALUE = 32;
+function largestFieldBytes(field, locales) {
+  if (field.retired) return 0;
+  const values = isTranslatable(field) ? locales.length : 1;
+  switch (field.type) {
+    case "text":
+    case "longtext":
+    case "markdown":
+      return (effectiveMax(field) + VALUE_JSON) * values;
+    case "list":
+      return field.max * (largestEntryBytes(field.of, locales) + ID_BYTES);
+    case "choices":
+      return effectiveMax(field) * ID_BYTES;
+    case "ref":
+      return field.multiple ? (field.max ?? 0) * ID_BYTES : ID_BYTES;
+    case "image":
+    case "file":
+      return ID_BYTES + ALT_MAX * locales.length;
+    default:
+      return SHORT_VALUE * values;
+  }
+}
+function largestEntryBytes(fields, locales) {
+  return Object.values(fields).reduce((sum, field) => sum + largestFieldBytes(field, locales), 0);
+}
 
 const fx = (key) => msg(`diff.fix.${key}`);
-const NEW_FIELD_FIX = fx("newField");
+const NEW_FIELD_FIX = /* @__PURE__ */ fx("newField");
 function diffSchema(prod, next) {
   const changes = [];
   const rejected = [];
@@ -28,6 +103,7 @@ function diffSchema(prod, next) {
   }
   for (const k of ["name", "url"]) if (prod[k] !== next[k]) ok(k, k, msg("diff.valueChanged", { name: k }));
   if (stableJson(prod.week) !== stableJson(next.week)) ok("week", "week", msg("diff.valueChanged", { name: "week" }));
+  if ((prod.holidays ?? null) !== (next.holidays ?? null)) ok("holidays", "holidays", msg("diff.valueChanged", { name: "holidays" }));
   if (stableJson(prod.pages) !== stableJson(next.pages)) ok("pages", "pages", msg("diff.pagesChanged"));
   if (stableJson(prod.agents ?? null) !== stableJson(next.agents ?? null)) ok("agents", "agents", msg("diff.agentsChanged"));
   for (const [path, rule] of Object.entries(prod.retired)) {
@@ -92,6 +168,8 @@ function diffBrick(key, before, after, newFills, newLocales, ok, no) {
   if (!sameLabel(before.describe ?? "", after.describe ?? "")) ok(`${key}.describe`, "text", msg("diff.textChanged"));
   if ((before.layout ?? "sections") !== (after.layout ?? "sections")) ok(`${key}.layout`, "text", msg("diff.textChanged"));
   if (stableJson(before.tasks ?? []) !== stableJson(after.tasks ?? [])) ok(`${key}.tasks`, "tasks", msg("diff.tasksChanged"));
+  if (stableJson(before.planned ?? null) !== stableJson(after.planned ?? null)) ok(`${key}.planned`, "planned", msg("diff.valueChanged", { name: "planned" }));
+  if (stableJson(before.status ?? null) !== stableJson(after.status ?? null)) ok(`${key}.status`, "text", msg("diff.textChanged"));
   if (before.kind === "collection" && after.kind === "collection") {
     if (after.max < before.max) no(`${key}.max`, "maxLowered", msg("diff.maxLowered", { at: key }), fx("keepMax"));
     else if (after.max > before.max) ok(`${key}.max`, "maxRaised", msg("diff.maxRaised"));
@@ -158,7 +236,7 @@ function diffField(at, old, next, newFills, ok, no) {
     if (onGrid) ok(at, "minLowered", msg("diff.minLowered"));
     else no(at, "minOffGrid", msg("diff.minOffGrid", { at, step }), fx("minOnGrid"));
   }
-  for (const k of ["step", "format", "currency", "from", "accept", "to", "multiple"]) {
+  for (const k of ["step", "format", "currency", "from", "accept", "to", "multiple", "after"]) {
     if (stableJson(o[k] ?? null) !== stableJson(n[k] ?? null)) no(at, `${k}Changed`, msg("diff.propChanged", { at, prop: k }));
   }
   if ((old.type === "choice" || old.type === "choices") && (next.type === "choice" || next.type === "choices")) {
@@ -179,7 +257,7 @@ function diffField(at, old, next, newFills, ok, no) {
   }
 }
 
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function releaseData(stored, next, data, written) {
   const out = { ...data };
   for (const [name, field] of Object.entries(next)) {
@@ -193,7 +271,7 @@ function releaseData(stored, next, data, written) {
     const columns = Object.entries(field.of).filter(([column, inner]) => !Object.hasOwn(old.of, column) && !inner.optional && !inner.retired && inner.default !== void 0);
     if (!columns.length) continue;
     out[name] = out[name].map((row) => {
-      if (!isRecord$1(row)) return row;
+      if (!isRecord(row)) return row;
       const filled = { ...row };
       for (const [column, inner] of columns) if (filled[column] === void 0) filled[column] = inner.default;
       return filled;
@@ -209,81 +287,9 @@ function fieldsChanged(stored, next, brick) {
   return !!before && !!after && stableJson(before.fields) !== stableJson(after.fields);
 }
 
-const BUNDLE_FORMAT = 3;
-function isBundle(value) {
-  if (!isRecord(value)) return false;
-  const b = value;
-  if (b.format !== BUNDLE_FORMAT || typeof b.site !== "string" || typeof b.locale !== "string") return false;
-  if (!Number.isInteger(b.schemaRev) || !Number.isInteger(b.contentRev) || !isRecord(b.bricks)) return false;
-  return Object.values(b.bricks).every(isBundleBrick);
-}
-function knownBricks(bundle, schema) {
-  return { ...bundle, bricks: Object.fromEntries(Object.entries(bundle.bricks).filter(([key]) => Object.hasOwn(schema.bricks, key))) };
-}
-function withFileBricks(platform, files, schema) {
-  const base = platform ?? files;
-  if (!base) throw new Error("withFileBricks: no bundle");
-  const fromPlatform = Object.entries(platform?.bricks ?? {}).filter(([key]) => schema.bricks[key]?.source !== "files");
-  return { ...base, bricks: { ...Object.fromEntries(fromPlatform), ...files?.bricks } };
-}
-async function markdownTrees(fields, data) {
-  const trees = {};
-  const parse = async (text) => (await parseMarkdown(text)).value;
-  const walk = async (inner, row, path) => {
-    for (const [name, field] of Object.entries(inner)) {
-      const value = row[name];
-      const leaf = path ? `${path}.${name}` : name;
-      if (field.type === "markdown" && typeof value === "string") trees[leaf] = await parse(value);
-      else if (field.type === "markdown" && isRecord(value)) {
-        const perLocale = {};
-        for (const [locale, text] of Object.entries(value)) if (typeof text === "string") perLocale[locale] = await parse(text);
-        trees[leaf] = perLocale;
-      } else if (field.type === "list" && Array.isArray(value)) {
-        for (const r of value) if (isRecord(r) && typeof r._id === "string") await walk(field.of, r, `${leaf}.${r._id}`);
-      }
-    }
-  };
-  await walk(fields, data, "");
-  return trees;
-}
-async function withMarkdownTrees(bundle, schema) {
-  const fill = async (fields, data) => {
-    const out = { ...data };
-    for (const [key, field] of Object.entries(fields)) {
-      const value = out[key];
-      if (field.type === "markdown" && typeof value === "string") out[key] = (await parseMarkdown(value)).value;
-      else if (field.type === "list" && Array.isArray(value)) out[key] = await Promise.all(value.map((row) => isRecord(row) ? fill(field.of, row) : row));
-    }
-    return out;
-  };
-  const bricks = {};
-  for (const [key, brick] of Object.entries(bundle.bricks)) {
-    const fields = Object.hasOwn(schema.bricks, key) ? schema.bricks[key].fields : void 0;
-    if (!fields) bricks[key] = brick;
-    else if (brick.kind === "single") bricks[key] = { ...brick, data: await fill(fields, brick.data) };
-    else bricks[key] = { ...brick, items: await Promise.all(brick.items.map(async (item) => ({ ...item, data: await fill(fields, item.data) }))) };
-  }
-  return { ...bundle, bricks };
-}
-function bundleFits(bundle, schema) {
-  return Object.entries(schema.bricks).every(([key, brick]) => {
-    const have = Object.hasOwn(bundle.bricks, key) ? bundle.bricks[key] : void 0;
-    return have === void 0 || have.kind === (brick.kind === "single" ? "single" : "collection");
-  });
-}
-function isBundleBrick(brick) {
-  if (!isRecord(brick)) return false;
-  if (brick.kind === "single") return isRecord(brick.data) && isStrings(brick.fallback);
-  if (brick.kind !== "collection" || !Array.isArray(brick.items)) return false;
-  return brick.items.every((item) => isRecord(item) && typeof item.id === "string" && isRecord(item.data) && isStrings(item.fallback) && (item.urls === void 0 || isRecord(item.urls) && Object.values(item.urls).every((u) => typeof u === "string")) && (item.updatedAt === void 0 || typeof item.updatedAt === "string") && (item.source === void 0 || typeof item.source === "string"));
-}
-function isStrings(value) {
-  return Array.isArray(value) && value.every((v) => typeof v === "string");
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function untranslatedMode(brick) {
+  return brick.untranslated ?? (brick.route ? "hide" : "fallback");
 }
-
 function printOf(mainValue) {
   return sha256(stableJson(mainValue ?? null));
 }
@@ -291,8 +297,9 @@ function resolveEntry(schema, brickKey, entry, ctx) {
   const brick = schema.bricks[brickKey];
   const main = schema.locales[0];
   const fallback = [];
-  const flags = { hidden: false, canHide: brick.kind === "collection" && brick.untranslated === "hide" };
-  const state = { schema, brickKey, entry, ctx, main, fallback, flags };
+  const outdated = [];
+  const blocking = [];
+  const state = { schema, brickKey, entry, ctx, main, fallback, outdated, blocking };
   const data = resolveFields(brick.fields, entry.data, "", state);
   for (const [name, field] of Object.entries(brick.fields)) {
     if (!field.retired) continue;
@@ -303,12 +310,13 @@ function resolveEntry(schema, brickKey, entry, ctx) {
         if (leaf === rule.from || leaf.startsWith(`${rule.from}.`)) fallback.push(name + leaf.slice(rule.from.length));
       }
     } else if (entry.data[name] !== void 0) {
-      data[name] = resolveValue(field, entry.data[name], name, { ...state, flags: { hidden: false, canHide: false } });
+      data[name] = resolveValue(field, entry.data[name], name, { ...state, blocking: [], outdated: [] });
     } else if ("value" in rule) {
-      data[name] = resolveValue(field, rule.value, name, { ...state, flags: { hidden: false, canHide: false } });
+      data[name] = resolveValue(field, rule.value, name, { ...state, blocking: [], outdated: [] });
     }
   }
-  return { data, fallback, hidden: flags.hidden };
+  const hidden = blocking.length > 0 && brick.kind === "collection" && untranslatedMode(brick) === "hide";
+  return { data, fallback, outdated, blocking, hidden };
 }
 function resolveFields(fields, stored, path, state) {
   const out = {};
@@ -362,8 +370,9 @@ function altOf(own, library, leaf, state, field) {
   const fromLibrary = (l) => effectiveAlt(map, void 0, l) ? "" : effectiveAlt(void 0, library, l);
   if (!markAllFallback && locale !== state.main && fromLibrary(locale)) return fromLibrary(locale);
   const main = fromLibrary(state.main);
-  return localized(main ? { ...map, [state.main]: main } : map, leaf, state, field) ?? "";
+  return localized(main ? { ...map, [state.main]: main } : map, leaf, { ...state, blocking: [] }, field) ?? "";
 }
+const isEmpty = (value) => value === void 0 || value === null || value === "";
 function localized(value, leaf, state, field) {
   const map = value ?? {};
   const mainValue = map[state.main];
@@ -374,14 +383,16 @@ function localized(value, leaf, state, field) {
   }
   if (locale === state.main) return mainValue;
   const own = map[locale];
-  const missing = own === void 0 || own === null || own === "";
-  const print = state.entry.prints?.[leaf]?.[locale];
-  const stale = !missing && field.type !== "slug" && print !== printOf(mainValue);
-  if (missing || stale) {
-    if (mainValue !== void 0 && mainValue !== null && mainValue !== "") state.fallback.push(leaf);
-    if (state.flags.canHide && !field.optional) state.flags.hidden = true;
+  if (isEmpty(own)) {
+    if (!isEmpty(mainValue)) {
+      state.fallback.push(leaf);
+      if (!field.optional && field.type !== "slug") state.blocking.push(leaf);
+    }
     return mainValue;
   }
+  if (field.type === "slug" || state.entry.prints?.[leaf]?.[locale] === printOf(mainValue)) return own;
+  if (isEmpty(mainValue)) return mainValue;
+  state.outdated.push(leaf);
   return own;
 }
 function defaultsFor(fields) {
@@ -401,13 +412,19 @@ function visibleUntil(brick, data) {
   return typeof last === "string" ? addDays(last, vis.days ?? 0) : void 0;
 }
 const deletesExpired = (brick) => brick.kind === "collection" && brick.visible?.mode === "until" && brick.visible.deleteExpired === true;
-function sortEntries(brick, entries) {
+function sortEntries(brick, entries, languages) {
   const copy = [...entries];
   if (brick.order === "manual") return copy.sort((a, b) => (a.order ?? 0) - (b.order ?? 0) || a.id.localeCompare(b.id));
   const { field, dir } = brick.order;
   const sign = dir === "desc" ? -1 : 1;
+  const def = brick.fields[field];
+  const translated = def !== void 0 && isTranslatable(def);
   const key = (e) => {
-    const v = e.data[field];
+    let v = e.data[field];
+    if (translated && languages && typeof v === "object" && v !== null && !Array.isArray(v)) {
+      const map = v;
+      v = isEmpty(map[languages.locale]) ? map[languages.main] : map[languages.locale];
+    }
     if (v === void 0 || v === null) return [];
     if (typeof v === "number") return [v];
     if (typeof v === "object" && !Array.isArray(v) && "amount" in v) return [Number(v.amount)];
@@ -426,7 +443,10 @@ function sortEntries(brick, entries) {
   return copy.sort((a, b) => sign * compare(key(a), key(b)) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
 }
 async function servedBundle(input) {
-  return resolveRouteLinks(await withMarkdownTrees(buildBundle(input), input.schema), input.schema);
+  const bundle = buildBundle(input);
+  const main = bundle.locale === bundle.mainLocale ? void 0 : buildBundle({ ...input, requestedLocale: bundle.mainLocale });
+  const trees = await withMarkdownTrees(bundle, input.schema);
+  return resolveRouteLinks(resolveFileRefs(trees, input.schema, input.files), input.schema, main);
 }
 function buildBundle(input) {
   const { schema } = input;
@@ -444,7 +464,7 @@ function buildBundle(input) {
       continue;
     }
     const items = [];
-    for (const entry of sortEntries(brick, stored)) {
+    for (const entry of sortEntries(brick, stored, { locale, main })) {
       const r = resolveEntry(schema, key, entry, ctx);
       if (r.hidden) continue;
       const item = { id: entry.id, data: r.data, fallback: r.fallback };
@@ -453,7 +473,7 @@ function buildBundle(input) {
       if (entry.updatedAt !== void 0) item.updatedAt = entry.updatedAt;
       const source = entry.sources?.[locale] ?? entry.sources?.[main];
       if (source !== void 0) item.source = source;
-      if (brick.route && isVisible(brick, r.data, input.today)) item.urls = urlsFor(schema, key, brick, entry, input.files);
+      if (brick.route && isVisible(brick, r.data, input.today)) item.urls = urlsFor(schema, key, brick, entry);
       items.push(item);
     }
     bricks[key] = { kind: "collection", items };
@@ -472,20 +492,27 @@ function buildBundle(input) {
     bricks
   };
 }
-function urlsFor(schema, key, brick, entry, files) {
+function routeUrls(schema, brick, entry) {
   const slugField = Object.entries(brick.fields).find(([, field]) => field.type === "slug" && !field.retired)?.[0];
   if (!slugField || !brick.route) return {};
   const slugs = entry.data[slugField] ?? {};
   const main = schema.locales[0];
   const urls = {};
   for (const locale of schema.locales) {
-    if (locale !== main && brick.untranslated === "hide" && resolveEntry(schema, key, entry, { locale, files }).hidden) continue;
     const slug = slugs[locale] || slugs[main];
     const route = brick.route[locale];
     if (slug && route) urls[locale] = route.replace("[slug]", slug);
   }
   return urls;
 }
+function urlsFor(schema, key, brick, entry) {
+  const urls = routeUrls(schema, brick, entry);
+  const main = schema.locales[0];
+  for (const locale of schema.locales) {
+    if (locale !== main && urls[locale] && resolveEntry(schema, key, entry, { locale, files: () => void 0 }).blocking.length) delete urls[locale];
+  }
+  return urls;
+}
 function urlClashes(entries) {
   const owner = /* @__PURE__ */ new Map();
   const clashes = [];
@@ -541,4 +568,4 @@ function applyDefaults(bundle, schema) {
   return { ...bundle, bricks };
 }
 
-export { BUNDLE_FORMAT as B, applyDefaults as a, blockedSlugs as b, buildBundle as c, bundleFits as d, defaultsFor as e, deletesExpired as f, diffSchema as g, fieldsChanged as h, isBundle as i, isVisible as j, knownBricks as k, resolveEntry as l, markdownTrees as m, sortEntries as n, urlsFor as o, printOf as p, releaseData as r, servedBundle as s, urlClashes as u, visibleUntil as v, withFileBricks as w };
+export { urlClashes as A, urlsFor as B, CliError as C, SITE_BUDGET as S, fitsBudget as a, diffSchema as b, largestFieldBytes as c, defaultsFor as d, entryBytes as e, fieldsChanged as f, parseReleaseState as g, pathOf as h, isObject as i, defaultDir as j, isVisible as k, largestEntryBytes as l, printOf as m, applyDefaults as n, blockedSlugs as o, parseExport as p, buildBundle as q, releaseData as r, byteSize as s, deletesExpired as t, resolveEntry as u, visibleUntil as v, routeUrls as w, servedBundle as x, sortEntries as y, untranslatedMode as z };

package/dist/shared/ginko.CjWB8N7f.d.ts

@@ -0,0 +1,128 @@
+import { B as Bundle } from './ginko.B_pACpVU.js';
+import { L as Locale } from './ginko.DrkUeYFP.js';
+
+interface NavNode {
+    title: string;
+    path: string;
+    id?: string;
+    brick?: string;
+    children: NavNode[];
+}
+/**
+ * Navigation tree of the collections `bricks` in `locale`, built from item URLs. An item is a child of the
+ * node at its nearest existing path prefix, else a root node. A string `parent` field (item id) overrides that.
+ * Siblings keep the item order of the bundle (bricks in the given order).
+ */
+declare function navTree(bundle: Bundle, bricks: string[], locale: Locale): NavNode[];
+/** Nodes from the root down to the node at `path`; empty when the path is not in the tree. */
+declare function breadcrumbs(tree: NavNode[], path: string): NavNode[];
+
+interface SeoImage {
+    url: string;
+    width?: number;
+    height?: number;
+    alt?: string;
+}
+interface SeoInput {
+    siteName: string;
+    /** `%s` is replaced by the page title; default '%s · <siteName>'. A page without title gets siteName alone. */
+    titleTemplate?: string;
+    title?: string;
+    description?: string;
+    image?: SeoImage;
+    type?: 'website' | 'article';
+    noindex?: boolean;
+}
+interface SeoHead {
+    title: string;
+    meta: (({
+        name: string;
+    } | {
+        property: string;
+    }) & {
+        content: string;
+    })[];
+}
+declare function seoHead(input: SeoInput): SeoHead;
+/** True when a request for `host` (with port, as in the Host header) is not for the site's own address: preview deployments, staging, localhost. Those must never be indexed. */
+declare function isPreviewHost(host: string | undefined, siteUrl: string): boolean;
+declare function robotsTxt(options: {
+    sitemap?: string;
+    noindex?: boolean;
+    disallow?: string[];
+}): string;
+declare function websiteLd(o: {
+    name: string;
+    url: string;
+    lang: string;
+}): Record<string, unknown>;
+/**
+ * `node` with the site's `country` (ISO 3166 code) where a builder left it out: `addressCountry` of every PostalAddress,
+ * and where remote applicants of a remote JobPosting must live. The Nuxt module applies it to a page's JSON-LD, so
+ * `siteJsonLd` and `jobJsonLd` need no `country` (an explicit one wins). An empty `country` changes nothing.
+ */
+declare function withCountry<T>(node: T, country: string): T;
+/** The schema.org types `organizationLd` writes. A page whose JSON-LD has a node of one of them is the site's organisation node. */
+declare const ORGANIZATION_TYPES: readonly ["Organization", "LocalBusiness", "NGO"];
+interface OrganizationLdInput {
+    name: string;
+    url: string;
+    /** `Organization` (default), `LocalBusiness` for a shop or practice, `NGO` for a nonprofit. */
+    type?: (typeof ORGANIZATION_TYPES)[number];
+    legalName?: string;
+    /** Absolute URL of the logo. */
+    logo?: string;
+    email?: string;
+    telephone?: string;
+    address?: {
+        street?: string;
+        postalCode?: string;
+        city?: string;
+        country?: string;
+    };
+    vatID?: string;
+    /** Absolute URLs of the organisation's profiles elsewhere. */
+    sameAs?: string[];
+}
+declare function organizationLd(o: OrganizationLdInput): Record<string, unknown>;
+/**
+ * A schema.org BreadcrumbList from the first step (usually the home page) to the page itself. Each step has a `title`
+ * and a `path` of the site, as the nodes of `useGinkoBreadcrumbs` do; `siteUrl` (`useGinkoSite().url`) makes the
+ * paths absolute.
+ */
+declare function breadcrumbJsonLd(steps: readonly Pick<NavNode, 'title' | 'path'>[], siteUrl: string): Record<string, unknown>;
+interface ArticleLdInput {
+    /** `Article` (default) or `BlogPosting` for a post of a blog. */
+    type?: 'Article' | 'BlogPosting';
+    title: string;
+    url: string;
+    description?: string;
+    image?: string;
+    published?: string;
+    modified?: string;
+    /** One author by name, or a list of authors with an optional website each. */
+    author?: string | readonly {
+        name: string;
+        url?: string;
+    }[];
+    keywords?: readonly string[];
+    lang: string;
+}
+declare function articleLd(o: ArticleLdInput): Record<string, unknown>;
+declare function faqLd(pairs: {
+    question: string;
+    answer: string;
+}[]): Record<string, unknown>;
+/**
+ * Headers every response of a Ginko site carries. Only the platform may frame `/__ginko` (the preview); nothing
+ * else is framed. `nosniff` stops a browser from reading user text (`.md`, `llms.txt`, JSON) as HTML, and the
+ * referrer policy keeps full URLs from leaving the site.
+ */
+declare function siteHeaders(input: {
+    preview: boolean;
+    platformOrigin: string;
+    noindex: boolean;
+}): Record<string, string>;
+
+export { ORGANIZATION_TYPES as a, articleLd as d, breadcrumbJsonLd as e, breadcrumbs as f, faqLd as g, siteHeaders as h, isPreviewHost as i, withCountry as j, navTree as n, organizationLd as o, robotsTxt as r, seoHead as s, websiteLd as w };
+export type { ArticleLdInput as A, NavNode as N, OrganizationLdInput as O, SeoHead as S, SeoImage as b, SeoInput as c };

package/dist/shared/ginko.D1PeQ3ds.mjs

@@ -0,0 +1,36 @@
+const MB = 1024 * 1024;
+const UPLOAD_TYPES = {
+  "image/jpeg": { label: "JPEG", kind: "image", limit: 20 * MB },
+  "image/png": { label: "PNG", kind: "image", limit: 20 * MB },
+  "image/webp": { label: "WebP", kind: "image", limit: 20 * MB },
+  "application/pdf": { label: "PDF", kind: "file", limit: 10 * MB }
+};
+function acceptOf(kind) {
+  return typesOf(kind).join(",");
+}
+function limitOf(kind) {
+  return Math.max(...typesOf(kind).map((type) => UPLOAD_TYPES[type].limit));
+}
+function formatMb(bytes) {
+  return `${roundedMb(bytes)}`.replace(".", ",");
+}
+function roundedMb(bytes) {
+  return Math.round(bytes / MB * 10) / 10;
+}
+function typesOf(kind) {
+  return Object.keys(UPLOAD_TYPES).filter((type) => UPLOAD_TYPES[type].kind === kind);
+}
+
+const CALENDAR_NAMES = ["AT", "DE", "SG", "none"];
+const STORED_HOLIDAYS = [...CALENDAR_NAMES, "custom"];
+const COUNTRY_CALENDARS = { AT: "AT", DE: "DE", SG: "SG" };
+function calendarOfCountry(country) {
+  return Object.hasOwn(COUNTRY_CALENDARS, country) ? COUNTRY_CALENDARS[country] : void 0;
+}
+function holidaysOf(site) {
+  if (site.calendar !== void 0) return typeof site.calendar === "function" ? "custom" : site.calendar;
+  if (site.country !== void 0) return calendarOfCountry(site.country) ?? "none";
+  return void 0;
+}
+
+export { CALENDAR_NAMES as C, STORED_HOLIDAYS as S, UPLOAD_TYPES as U, acceptOf as a, calendarOfCountry as c, formatMb as f, holidaysOf as h, limitOf as l, roundedMb as r };

package/dist/shared/ginko.DIl7l-75.mjs

@@ -0,0 +1,26 @@
+import { w as wordsOf } from './ginko.BNVC-g9n.mjs';
+
+const tail = (brick, id, field) => `${encodeURIComponent(brick)}/${id.split("/").map(encodeURIComponent).join("/")}/${encodeURIComponent(field)}.json`;
+function fileMarkdownRef(locale, brick, id, field) {
+  return `/__ginko/files/${locale}/md/${tail(brick, id, field)}`;
+}
+function platformMarkdownRef(locale, rev, brick, id, field) {
+  return `/__ginko/platform/${locale}/${rev}/md/${tail(brick, id, field)}`;
+}
+function withMarkdownRefs(bundle, schema, trees, refOf) {
+  const swap = (brick, id, data) => {
+    const out = { ...data };
+    for (const [name, field] of Object.entries(schema.bricks[brick]?.fields ?? {})) {
+      const value = out[name];
+      if (field.type !== "markdown" || !value || !("nodes" in value)) continue;
+      const ref = refOf(brick, id, name);
+      trees.set(ref, value);
+      out[name] = { ref, words: wordsOf(value) };
+    }
+    return out;
+  };
+  const bricks = Object.fromEntries(Object.entries(bundle.bricks).map(([key, b]) => [key, b.kind === "single" ? { ...b, data: swap(key, key, b.data) } : { ...b, items: b.items.map((item) => ({ ...item, data: swap(key, item.id, item.data) })) }]));
+  return { ...bundle, bricks };
+}
+
+export { fileMarkdownRef as f, platformMarkdownRef as p, withMarkdownRefs as w };