@lupinum/ginko 0.4.0 → 0.5.0

package/dist/nuxt/module.mjs

@@ -1,11 +1,14 @@
-import { hasNuxtModule, defineNuxtModule, createResolver, tryResolveModule, installModule, addServerTemplate, addServerHandler, addComponentsDir, addTemplate, addTypeTemplate, addNitroPlugin, addPlugin, extendPages, addImports, addComponent } from '@nuxt/kit';
-import { existsSync, mkdirSync, copyFileSync, readdirSync, rmSync } from 'node:fs';
+import { hasNuxtModule, defineNuxtModule, createResolver, tryResolveModule, installModule, addServerTemplate, addServerHandler, addComponentsDir, addTemplate, addTypeTemplate, addNitroPlugin, addPlugin, extendPages, addImports, addComponent, addServerImports } from '@nuxt/kit';
+import { watch, existsSync, readFileSync, mkdirSync, copyFileSync, readdirSync, rmSync } from 'node:fs';
 import { join, relative, resolve, basename } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { f as fileLinkIssues } from '../shared/ginko.Dht0xxE5.mjs';
-import { s as serializeSchema, a as checkSite, b as redirectProblems, d as entryRedirects } from '../shared/ginko.CrNRBkS5.mjs';
-import { n as coreMessage } from '../shared/ginko.C-QjDn3O.mjs';
-import '../shared/ginko.CQvxhyez.mjs';
+import { f as fileLinkIssues } from '../shared/ginko.raCzOPYC.mjs';
+import { createHash, randomUUID } from 'node:crypto';
+import { c as checkSite, s as serializeSchema } from '../shared/ginko.C4gcOovG.mjs';
+import { L as redirectProblems, N as entryRedirects, F as coreMessage } from '../shared/ginko.BNVC-g9n.mjs';
+import { w as withMarkdownRefs, f as fileMarkdownRef } from '../shared/ginko.DIl7l-75.mjs';
+import '../shared/ginko.D1PeQ3ds.mjs';
+import '../shared/ginko.AprJymER.mjs';
 import 'comark';
 import 'comark/plugins/alert';
 import 'comark/plugins/attributes';
@@ -19,6 +22,32 @@ import 'comark/plugins/task-list';
 import 'comark/plugins/toc';
 import '@lupinum/ginko-i18n/core';
 
+function appSchema(schema) {
+  const { components: _components, ...schemaRest } = schema;
+  return {
+    ...schemaRest,
+    bricks: Object.fromEntries(Object.entries(schema.bricks).map(([key, brick]) => [key, appBrick(brick)]))
+  };
+}
+function appBrick(brick) {
+  const { describe: _describe, tasks: _tasks, ...rest } = brick;
+  return { ...rest, label: "", fields: appFields(brick.fields) };
+}
+function componentsForMarkdown(schema) {
+  return Object.fromEntries(Object.entries(schema.components ?? {}).map(([tag, def]) => [
+    tag,
+    { kind: def.kind, props: Object.fromEntries(Object.entries(def.props).map(([name, field]) => [name, { type: field.type }])) }
+  ]));
+}
+function appFields(fields) {
+  return Object.fromEntries(Object.entries(fields).map(([name, field]) => [name, appField(field)]));
+}
+function appField(field) {
+  const { hint: _hint, group: _group, ...rest } = field;
+  if (rest.type === "list") return { ...rest, label: "", itemLabel: "", of: appFields(rest.of) };
+  return { ...rest, label: "" };
+}
+
 const OWNED = { locales: "locales", defaultLocale: "the first entry of locales", baseUrl: "url", timeZone: "timeZone" };
 function checkI18nOptions(userI18n) {
   const set = new Set(userI18n && typeof userI18n === "object" ? Object.entries(userI18n).filter(([, value]) => value !== void 0).map(([key]) => key) : []);
@@ -91,12 +120,13 @@ function unservedPaths(schema, pages) {
   add(pages, "");
   const served = (path) => patterns.some((pattern) => pattern.test(path));
   const warnings = [];
+  const ours = (locale) => schema.locales.includes(locale);
   for (const [key, paths] of Object.entries(schema.pages)) {
-    for (const [locale, path] of Object.entries(paths)) if (path && !served(path)) warnings.push(`pages.${key}.${locale}: no page at \u201C${path}\u201D. Fix: create the page or change the path in ginko.config.ts.`);
+    for (const [locale, path] of Object.entries(paths)) if (path && ours(locale) && !served(path)) warnings.push(`pages.${key}.${locale}: no page at \u201C${path}\u201D. Fix: create the page or change the path in ginko.config.ts.`);
   }
   for (const [key, brick] of Object.entries(schema.bricks)) {
     if (brick.kind !== "collection" || !brick.route) continue;
-    for (const [locale, route] of Object.entries(brick.route)) if (route && !served(route.replace("[slug]", "beispiel"))) warnings.push(`${key}.route.${locale}: no page at \u201C${route}\u201D. Fix: create the page (for example pages/\u2026/[slug].vue) or change the route.`);
+    for (const [locale, route] of Object.entries(brick.route)) if (route && ours(locale) && !served(route.replace("[slug]", "beispiel"))) warnings.push(`${key}.route.${locale}: no page at \u201C${route}\u201D. Fix: create the page (for example pages/\u2026/[slug].vue) or change the route.`);
   }
   return warnings;
 }
@@ -148,8 +178,61 @@ function ginkoRouteRules(site) {
   return rules;
 }
 
-function configFilesToWatch(rootDir) {
-  return ["ts", "mts", "js", "mjs"].map((ext) => join(rootDir, `ginko.config.${ext}`)).filter(existsSync);
+const CONFIG_NAMES = new Set(["ts", "mts", "js", "mjs"].map((ext) => `ginko.config.${ext}`));
+function restartOnConfigChange(nuxt, rootDir) {
+  let ready = false;
+  let pending;
+  let restarting = false;
+  const restart = (name) => {
+    restarting = true;
+    console.info(`[ginko] ${name} changed: restarting the dev server.`);
+    void Promise.resolve(nuxt.callHook("restart", { hard: true })).catch((error) => console.error("[ginko] The dev server could not restart:", error));
+  };
+  const hashOf = (file) => existsSync(file) ? createHash("sha1").update(readFileSync(file)).digest("hex") : "";
+  const hashes = new Map([...CONFIG_NAMES].map((name) => [name, hashOf(join(rootDir, name))]));
+  const check = async (name) => {
+    const file = join(rootDir, name);
+    const hash = hashOf(file);
+    if (restarting || !hash || hashes.get(name) === hash) return;
+    hashes.set(name, hash);
+    const problem = await configProblem(file);
+    if (problem) console.error(`[ginko] ${name} has an error, the dev server keeps the last good version: ${problem}`);
+    else if (ready) restart(name);
+    else pending = name;
+  };
+  let queue = Promise.resolve();
+  let debounce;
+  const watcher = watch(rootDir, (_event, name) => {
+    if (!name || !CONFIG_NAMES.has(name)) return;
+    clearTimeout(debounce);
+    debounce = setTimeout(() => {
+      queue = queue.then(() => check(name)).catch((error) => console.error("[ginko]", error));
+    }, 100);
+  });
+  watcher.unref();
+  let settle;
+  nuxt.hook("ready", () => nuxt.hook("build:done", () => {
+    settle = setTimeout(() => {
+      ready = true;
+      if (pending && !restarting) restart(pending);
+    }, 1e3);
+  }));
+  nuxt.hook("close", () => {
+    clearTimeout(debounce);
+    clearTimeout(settle);
+    watcher.close();
+  });
+}
+async function configProblem(file) {
+  try {
+    const module = await import(`${pathToFileURL(file).href}?ginko=${randomUUID()}`);
+    const site = module.default;
+    if (!site?.site || !site.bricks) return "the default export must be the result of defineSite().";
+    const problems = checkSite(site);
+    return problems.length ? problems.join(" ") : void 0;
+  } catch (error) {
+    return error instanceof Error ? error.message.split("\n")[0] : String(error);
+  }
 }
 
 const runtimeExt = import.meta.url.endsWith(".mjs") ? "mjs" : "ts";
@@ -163,12 +246,12 @@ const module$1 = defineNuxtModule({
     const problems = checkSite(site, schema);
     if (problems.length) throw new Error(`[ginko] ginko.config.ts is invalid:
 - ${problems.join("\n- ")}`);
+    if (nuxt.options.dev) restartOnConfigChange(nuxt, nuxt.options.rootDir);
     const sources = {
       platform: Object.values(schema.bricks).some((b) => b.source !== "files"),
       files: Object.values(schema.bricks).some((b) => b.source === "files")
     };
     const { resolve } = createResolver(import.meta.url);
-    if (nuxt.options.dev) nuxt.options.watch.push(...configFilesToWatch(nuxt.options.rootDir));
     Object.assign(nuxt.options.runtimeConfig.public, { ginko: {
       site: schema.site,
       name: site.name,
@@ -178,6 +261,10 @@ const module$1 = defineNuxtModule({
       locales: schema.locales,
       mainLocale: schema.locales[0],
       timeZone: schema.timeZone,
+      // ISO country code or ''; the hours rules of the basics take it as `country`, JSON-LD as `addressCountry`.
+      country: site.country ?? "",
+      // The resolved holiday calendar (`schema.holidays`) or '': `custom` means the site passes its own `calendar`.
+      holidays: schema.holidays ?? "",
       seo: site.seo ?? {},
       agents: site.agents ?? {},
       sources
@@ -222,8 +309,10 @@ export const ogTemplate = 'GinkoCard'` : "export const defineOgImage = undefined
     nuxt.options.alias["#ginko/og"] = resolve(nuxt.options.buildDir, "ginko/og.mjs");
     addTemplate({ filename: "ginko/schema-org.mjs", getContents: () => runsNuxtSeo("nuxt-schema-org", nuxt) ? `export { useSchemaOrg } from '#imports'` : "export const useSchemaOrg = undefined" });
     nuxt.options.alias["#ginko/schema-org"] = resolve(nuxt.options.buildDir, "ginko/schema-org.mjs");
-    addTemplate({ filename: "ginko/schema.mjs", getContents: () => `export default ${JSON.stringify(schema)}` });
+    addTemplate({ filename: "ginko/schema.mjs", getContents: () => `export default ${JSON.stringify(appSchema(schema))}` });
     nuxt.options.alias["#ginko/schema"] = resolve(nuxt.options.buildDir, "ginko/schema.mjs");
+    addTemplate({ filename: "ginko/components.mjs", getContents: () => `export default ${JSON.stringify(componentsForMarkdown(schema))}` });
+    nuxt.options.alias["#ginko/components"] = resolve(nuxt.options.buildDir, "ginko/components.mjs");
     addServerTemplate({ filename: "#ginko/schema", getContents: () => `export default ${JSON.stringify(schema)}` });
     const composables = resolve(`./runtime/composables.${runtimeExt}`);
     addTypeTemplate({ filename: "types/ginko-virtual.d.ts", getContents: () => `/// <reference path=${JSON.stringify(resolve("./runtime/schema.d.ts"))} />
@@ -252,6 +341,7 @@ export {}` }, { nuxt: true, nitro: true });
     else {
       addServerTemplate({ filename: "#ginko/files", getContents: () => "export default {}" });
       addServerTemplate({ filename: "#ginko/files-md", getContents: () => "export default {}" });
+      addServerTemplate({ filename: "#ginko/search", getContents: () => "export default {}" });
     }
     nuxt.hook("pages:resolved", (pages) => {
       for (const warning of unservedPaths(schema, pages)) console.warn(`[ginko] ${warning}`);
@@ -262,12 +352,14 @@ export {}` }, { nuxt: true, nitro: true });
       extendPages((pages) => {
         pages.push({ name: "ginko-preview", path: "/__ginko/preview", file: resolve("./runtime/preview.vue") });
       });
+      addServerHandler({ route: "/__ginko/platform/:locale/:rev/md/**", handler: resolve(`./runtime/server/platform-md.${runtimeExt}`) });
     }
     for (const name of ["useGinko", "useGinkoEntry", "useGinkoQuery", "useGinkoNeighbors", "useGinkoNav", "useGinkoBreadcrumbs", "useGinkoToday", "useGinkoWeek", "useGinkoLocale", "useGinkoSeo", "useGinkoPath", "useGinkoLang", "useGinkoSite"]) addImports({ name, from: composables });
     for (const name of ["GinkoItem", "GinkoPageKey", "GinkoLocale", "GinkoSeoInput"]) addImports({ name, from: composables, type: true });
     addComponent({ name: "GinkoMarkdown", export: "GinkoMarkdown", filePath: resolve(`./runtime/GinkoMarkdown.${runtimeExt}`) });
     addComponent({ name: "GinkoImage", export: "GinkoImage", filePath: resolve(`./runtime/GinkoImage.${runtimeExt}`) });
     for (const name of ["useGinkoMarkdown", "fetchGinkoMarkdown"]) addImports({ name, from: resolve(`./runtime/markdown.${runtimeExt}`) });
+    addServerImports([{ name: "getGinkoItems", from: resolve(`./runtime/server/items.${runtimeExt}`) }, { name: "GinkoServerItem", from: resolve(`./runtime/server/items.${runtimeExt}`), type: true }]);
   }
 });
 async function useFiles(schema, site, nuxt) {
@@ -312,7 +404,7 @@ ${linkReport}`);
     writeImages(result.imageFiles);
     trees = /* @__PURE__ */ new Map();
     const now = /* @__PURE__ */ new Date();
-    bundles = Object.fromEntries(Object.entries(result.bundles).map(([locale, bundle]) => [locale, content.withMarkdownRefs(content.publicBundle(bundle, schema, now, fileOptions), schema, trees)]));
+    bundles = Object.fromEntries(Object.entries(result.bundles).map(([locale, bundle]) => [locale, withMarkdownRefs(content.publicBundle(bundle, schema, now, fileOptions), schema, trees, (brick, id, field) => fileMarkdownRef(locale, brick, id, field))]));
     searches = Object.fromEntries(await Promise.all(Object.entries(bundles).map(async ([locale, bundle]) => [locale, await content.searchIndex(bundle, trees, schema)])));
   };
   await build();

package/dist/nuxt/runtime/GinkoImage.d.mts

@@ -33,7 +33,7 @@ export declare const GinkoImage: import("vue").DefineComponent<import("vue").Ext
         default: boolean;
     };
 }>> & Readonly<{}>, {
-    sizes: string;
     image: ImageValue | undefined;
+    sizes: string;
     eager: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/nuxt/runtime/GinkoMarkdown.mjs

@@ -1,5 +1,5 @@
 import { computed, defineComponent, h, inject, provide } from "vue";
-import schema from "#ginko/schema";
+import components from "#ginko/components";
 import { GINKO_COMPONENTS_KEY, GINKO_TOC_KEY } from "../../internal.mjs";
 import { GinkoMarkdown as GinkoMarkdownTree } from "../../vue.mjs";
 import { useGinkoMarkdown } from "./markdown.mjs";
@@ -19,6 +19,6 @@ export const GinkoMarkdown = defineComponent({
     let tree;
     provide(GINKO_TOC_KEY, computed(() => tree?.value?.toc ?? null));
     tree = await useGinkoMarkdown(() => props.value);
-    return () => h(GinkoMarkdownTree, { value: tree.value, components: { ...provided, ...props.components }, registry: schema.components });
+    return () => h(GinkoMarkdownTree, { value: tree.value, components: { ...provided, ...props.components }, registry: components });
   }
 });

package/dist/nuxt/runtime/composables.d.mts

@@ -90,11 +90,12 @@ export declare function useGinkoLang(): (item: {
     fallback?: readonly string[];
 }, path: string) => string | undefined;
 /**
- * The visible entry whose slug in the current locale is `slug`; otherwise a real 404 (SPEC 8). `slug` may be a
+ * The visible entry whose slug in the current locale is `slug`; otherwise a real 404 (SPEC 8). An entry without a
+ * page in this locale (untranslated) is a 404 too, also when a list links it to its main-language page. `slug` may be a
  * getter such as `() => route.params.slug`, so a reused page follows client navigation; an array (catch-all
- * route) is joined with `/`. The 404 is thrown when the value is read, not at the call.
+ * route) is joined with `/`. The 404 is thrown on every read of the value while no entry matches, not at the call.
  */
-export declare function useGinkoEntry<K extends CollectionKey>(brick: K, slug: MaybeRefOrGetter<string | string[] | undefined>): ComputedRef<GinkoItem<K>>;
+export declare function useGinkoEntry<K extends CollectionKey>(brick: K, slug: MaybeRefOrGetter<string | string[] | undefined>): Readonly<Ref<GinkoItem<K>>>;
 export interface GinkoSeoInput {
     title?: string;
     description?: string;

package/dist/nuxt/runtime/composables.mjs

@@ -1,4 +1,4 @@
-import { computed, createError, toValue, useI18n, useHead, useRoute, useRuntimeConfig, useState } from "#imports";
+import { computed, createError, toRef, toValue, useI18n, useHead, useRoute, useRuntimeConfig, useState } from "#imports";
 import schema from "#ginko/schema";
 import { defineOgImage, ogTemplate } from "#ginko/og";
 import { useSchemaOrg } from "#ginko/schema-org";
@@ -9,10 +9,12 @@ import {
   navTree,
   neighbors,
   organizationLd,
+  ORGANIZATION_TYPES,
   query,
   seoHead,
   todayIn,
-  websiteLd
+  websiteLd,
+  withCountry
 } from "../../internal.mjs";
 import { withUrl } from "./shared.mjs";
 export const BUNDLE_STATE = "ginko:bundle";
@@ -53,12 +55,11 @@ export function useGinkoWeek() {
 }
 export function useGinko(brick) {
   const bundle = useVisibleBundle([brick]);
-  const locale = useGinkoLocale();
   return computed(() => {
     const value = bundle.value.bricks[brick];
     const def = schema.bricks[brick];
     if (value?.kind === "collection" && def) {
-      return { items: def.kind === "collection" && def.route ? withUrl(value.items, locale.value) : value.items };
+      return { items: def.kind === "collection" && def.route ? withUrl(value.items, bundle.value.locale, bundle.value.mainLocale) : value.items };
     }
     return value;
   });
@@ -77,24 +78,22 @@ function useVisibleBundle(bricks) {
     return { ...bundle.value, bricks: out };
   });
 }
-function withRouteUrl(brick, items, locale) {
+function withRouteUrl(brick, items, bundle) {
   const def = schema.bricks[brick];
-  return def?.kind === "collection" && def.route ? withUrl(items, locale) : items;
+  return def?.kind === "collection" && def.route ? withUrl(items, bundle.locale, bundle.mainLocale) : items;
 }
 export function useGinkoQuery(brick, q = {}) {
   const bundle = useVisibleBundle([brick]);
-  const locale = useGinkoLocale();
   return computed(() => {
     const result = query(bundle.value, brick, toValue(q), schema);
-    return { ...result, items: withRouteUrl(brick, result.items, locale.value) };
+    return { ...result, items: withRouteUrl(brick, result.items, bundle.value) };
   });
 }
 export function useGinkoNeighbors(brick, id, options = {}) {
   const bundle = useVisibleBundle([brick]);
-  const locale = useGinkoLocale();
   return computed(() => {
     const { prev, next } = neighbors(bundle.value, brick, toValue(id), options.order);
-    const one = (item) => item && withRouteUrl(brick, [item], locale.value)[0];
+    const one = (item) => item && withRouteUrl(brick, [item], bundle.value)[0];
     return { prev: one(prev), next: one(next) };
   });
 }
@@ -116,12 +115,15 @@ export function useGinkoLang() {
 export function useGinkoEntry(brick, slug) {
   const items = useGinko(brick);
   const locale = useGinkoLocale();
-  return computed(() => {
+  const entry = computed(() => {
     const def = schema.bricks[brick];
     const route = def.kind === "collection" ? def.route?.[locale.value] : void 0;
     const value = toValue(slug);
     const path = value === void 0 ? void 0 : route?.replace("[slug]", Array.isArray(value) ? value.join("/") : value);
-    const item = items.value.items.find((i) => path && i.url === path);
+    return items.value.items.find((i) => path && i.urls?.[locale.value] === path);
+  });
+  return toRef(() => {
+    const item = entry.value;
     if (!item) throw createError({ statusCode: 404, statusMessage: "Not found", fatal: true });
     return item;
   });
@@ -153,7 +155,8 @@ export function useGinkoSeo(input) {
       }
     });
   }
-  if (useSchemaOrg) useSchemaOrg(computed(() => (toValue(input).jsonLd ?? []).map(({ "@context": _context, ...node }) => node)));
+  const pageLd = () => (toValue(input).jsonLd ?? []).map((node) => withCountry(node, config.country));
+  if (useSchemaOrg) useSchemaOrg(computed(() => pageLd().map(({ "@context": _context, ...node }) => node)));
   const trim = (p) => p.length > 1 ? p.replace(/\/$/, "") : p;
   useHead(() => {
     const page = toValue(input);
@@ -161,12 +164,13 @@ export function useGinkoSeo(input) {
     const raw = generated ? void 0 : page.image ?? seo.image;
     const image = raw === void 0 ? void 0 : typeof raw === "string" ? { url: absolute(raw) } : { ...raw, url: absolute(raw.url) };
     const head = seoHead({ siteName: config.name, titleTemplate: seo.titleTemplate, title: page.title, description: page.description ?? seo.description, image, type: page.type, noindex: page.noindex });
-    const ld = useSchemaOrg ? [] : [...page.jsonLd ?? []];
+    const ld = useSchemaOrg ? [] : pageLd();
     const home = Object.keys(schema.pages).find((key) => schema.pages[key]?.[config.mainLocale] === "/");
     if (!useSchemaOrg && home !== void 0 && trim(route.path) === trim(path(home, locale.value))) {
       const lang = i18n.locales.find((l) => l.code === locale.value)?.language ?? locale.value;
       ld.unshift(websiteLd({ name: config.name, url: config.url, lang }));
-      if (seo.organization) ld.splice(1, 0, organizationLd({ name: config.name, url: config.url, ...seo.organization, logo: seo.organization.logo && absolute(seo.organization.logo) }));
+      const own = ld.some((node) => ORGANIZATION_TYPES.includes(node["@type"]));
+      if (seo.organization && !own) ld.splice(1, 0, organizationLd({ name: config.name, url: config.url, ...seo.organization, logo: seo.organization.logo && absolute(seo.organization.logo) }));
     }
     return {
       title: head.title,

package/dist/nuxt/runtime/fetch.d.mts

@@ -8,8 +8,10 @@ import type { GinkoPublicConfig } from './shared.mjs';
 export declare function loadBundle(config: GinkoPublicConfig, locale: Locale, minRev: string | undefined, loadFiles: (locale: Locale) => Promise<Bundle | undefined>, siteToken?: string): Promise<Bundle>;
 /** A platform failure: a plain error that carries the status, for the caller to turn into its framework's error. */
 export declare class PlatformError extends Error {
+    readonly platformStatus?: number | undefined;
     readonly statusCode = 503;
-    constructor(message: string, cause?: unknown);
+    /** `platformStatus`: the platform's own HTTP status when it answered with one (409: it has not reached `minRev`). */
+    constructor(message: string, cause?: unknown, platformStatus?: number | undefined);
 }
 /**
  * The 503 text. In dev the platform is a local address that is often not running (a new site, a pasted README

package/dist/nuxt/runtime/fetch.mjs

@@ -1,7 +1,7 @@
 import schema from "#ginko/schema";
-import { BUNDLE_FORMAT, bundleFits, isBundle, knownBricks, withFileBricks } from "../../internal.mjs";
+import { BUNDLE_FORMAT, bundleFits, isBundle, knownBricks, SITE_BUDGET, withFileBricks } from "../../internal.mjs";
 const TIMEOUT_MS = 1e4;
-const MAX_CHARS = 8 * 1024 * 1024;
+const MAX_CHARS = (SITE_BUDGET.siteBytes + SITE_BUDGET.treeBytes) * 1.5;
 export async function loadBundle(config, locale, minRev, loadFiles, siteToken) {
   const [platform, files] = await Promise.all([
     config.sources.platform ? fetchBundle(config, locale, minRev, siteToken) : void 0,
@@ -10,10 +10,12 @@ export async function loadBundle(config, locale, minRev, loadFiles, siteToken) {
   return withFileBricks(platform, files, schema);
 }
 export class PlatformError extends Error {
-  statusCode = 503;
-  constructor(message, cause) {
+  /** `platformStatus`: the platform's own HTTP status when it answered with one (409: it has not reached `minRev`). */
+  constructor(message, cause, platformStatus) {
     super(message, { cause });
+    this.platformStatus = platformStatus;
   }
+  statusCode = 503;
 }
 export function unreachableMessage(config, url) {
   const local = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:|\/|$)/.test(config.platform);
@@ -34,16 +36,20 @@ export async function fetchBundle(config, locale, minRev, siteToken) {
   if (minRev && /^\d+\.\d+$/.test(minRev)) query.set("minRev", minRev);
   const url = `${config.platform.replace(/\/$/, "")}/bundle/${encodeURIComponent(config.site)}?${query}`;
   let body;
+  let status;
   try {
     const headers = { accept: "application/json" };
     if (siteToken) headers[SITE_TOKEN_HEADER] = siteToken;
     const response = await fetch(url, { headers, signal: AbortSignal.timeout(TIMEOUT_MS) });
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    if (!response.ok) {
+      status = response.status;
+      throw new Error(`HTTP ${status}`);
+    }
     const text = await response.text();
     if (text.length > MAX_CHARS) throw new Error("bundle too large");
     body = JSON.parse(text);
   } catch (error) {
-    throw new PlatformError(unreachableMessage(config, url), error);
+    throw new PlatformError(unreachableMessage(config, url), error, status);
   }
   if (!isBundle(body) || body.site !== config.site || !bundleFits(body, schema)) throw new PlatformError("Content in the wrong format");
   return knownBricks(body, schema);

package/dist/nuxt/runtime/markdown.d.mts

@@ -1,5 +1,8 @@
 import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+import type { NuxtApp } from '#app';
 import type { MarkdownTree, MarkdownValue } from '../../internal.mjs';
+/** The trees of this server request (empty outside a server render). @internal Filled by the Ginko plugin. */
+export declare function serverTrees(nuxtApp: NuxtApp): Map<string, MarkdownTree>;
 /**
  * The tree of a markdown value, for server code such as a list page's `useAsyncData` that reads
  * several texts and keeps only what the page needs. `undefined` (an optional field) gives `null`.

package/dist/nuxt/runtime/markdown.mjs

@@ -1,15 +1,27 @@
 import { computed, toValue } from "vue";
-import { useAsyncData } from "#imports";
+import { tryUseNuxtApp, useAsyncData } from "#imports";
+const requestTrees = /* @__PURE__ */ new WeakMap();
+export function serverTrees(nuxtApp) {
+  const context = nuxtApp.ssrContext;
+  if (!context) return /* @__PURE__ */ new Map();
+  let trees = requestTrees.get(context);
+  if (!trees) requestTrees.set(context, trees = /* @__PURE__ */ new Map());
+  return trees;
+}
+function loadTree(ref, nuxtApp = tryUseNuxtApp() ?? void 0) {
+  const tree = import.meta.server && nuxtApp?.ssrContext ? requestTrees.get(nuxtApp.ssrContext)?.get(ref) : void 0;
+  return tree ? Promise.resolve(tree) : $fetch(ref);
+}
 export async function fetchGinkoMarkdown(value) {
   if (!value) return null;
-  return "nodes" in value ? value : $fetch(value.ref);
+  return "nodes" in value ? value : loadTree(value.ref);
 }
 export async function useGinkoMarkdown(value) {
   const ref = computed(() => {
     const v = toValue(value);
     return v && "ref" in v ? v.ref : "";
   });
-  const { data } = await useAsyncData(() => `ginko-md:${ref.value}`, () => ref.value ? $fetch(ref.value) : Promise.resolve(null));
+  const { data } = await useAsyncData(() => `ginko-md:${ref.value}`, (nuxtApp) => ref.value ? loadTree(ref.value, nuxtApp) : Promise.resolve(null));
   return computed(() => {
     const v = toValue(value);
     return v && "nodes" in v ? v : data.value ?? null;

package/dist/nuxt/runtime/plugin.mjs

@@ -1,8 +1,9 @@
-import { addAlternatesResolver, addRouteMiddleware, clearError, createError, defineNuxtPlugin, useError, useRequestHeader, useRequestURL, useResponseHeader, useRuntimeConfig, useState } from "#imports";
+import { addAlternatesResolver, addRouteMiddleware, createError, defineNuxtPlugin, useRequestHeader, useRequestURL, useResponseHeader, useRuntimeConfig, useState } from "#imports";
 import schema from "#ginko/schema";
-import { bundleFits, isBundle, knownBricks, withFileBricks } from "../../internal.mjs";
+import { platformMarkdownRef, withMarkdownRefs } from "../../internal.mjs";
 import { BUNDLE_STATE, PREVIEW_STATE } from "./composables.mjs";
 import { loadBundle as loadBundleCore, PlatformError } from "./fetch.mjs";
+import { serverTrees } from "./markdown.mjs";
 import { localeFromPath } from "@lupinum/ginko-i18n/core";
 import { config as i18nConfig } from "#ginko-i18n/config.mjs";
 async function loadBundle(config, locale, minRev, siteToken) {
@@ -24,10 +25,11 @@ export default defineNuxtPlugin(async (nuxtApp) => {
   const preview = useState(PREVIEW_STATE, () => null);
   const load = async (locale) => {
     if (bundles.value[locale]) return;
-    bundles.value = { ...bundles.value, [locale]: await loadBundle(config, locale, minRev, siteToken) };
+    const full = await loadBundle(config, locale, minRev, siteToken);
+    const rev = `${full.schemaRev}.${full.contentRev}`;
+    bundles.value = { ...bundles.value, [locale]: import.meta.server && config.sources.platform ? withMarkdownRefs(full, schema, serverTrees(nuxtApp), (brick, id, field) => platformMarkdownRef(locale, rev, brick, id, field)) : full };
   };
   const path = useRequestURL().pathname;
-  if (import.meta.client && PREVIEW.test(path)) listenToPlatform(nuxtApp, config, bundles, preview);
   const errorQuery = ERROR_PAGE.test(path) ? useRequestURL().searchParams : void 0;
   const pageError = () => import.meta.server ? nuxtApp.ssrContext?.error : nuxtApp.payload.error;
   const errorPage = () => {
@@ -56,34 +58,3 @@ function entryUrls(bundle, path) {
   }
   return void 0;
 }
-function listenToPlatform(nuxtApp, config, bundles, preview) {
-  const origin = config.platform ? new URL(config.platform).origin : "";
-  window.addEventListener("message", (event) => {
-    const state = preview.value;
-    if (!state || !origin || event.source !== window.parent || event.origin !== origin) return;
-    const data = event.data;
-    if (typeof data !== "object" || data === null) return;
-    const message = data;
-    if (message.type !== "ginko:preview" || message.session !== state.session || message.site !== config.site || message.locale !== state.locale || !isBundle(message.bundle) || !bundleFits(message.bundle, schema)) return;
-    const platform = knownBricks(message.bundle, schema);
-    const locale = state.locale;
-    void filesOf(locale).then((files) => {
-      if (preview.value?.session !== state.session) return;
-      bundles.value = { ...bundles.value, [locale]: withFileBricks(platform, files, schema) };
-      void nuxtApp.runWithContext(() => useError().value ? clearError() : void 0);
-    });
-  });
-  const fileBundles = {};
-  const filesOf = (locale) => fileBundles[locale] ??= config.sources.files ? $fetch(`/__ginko/files/${locale}.json`).catch(() => void 0) : Promise.resolve(void 0);
-  const interceptLink = (event) => {
-    const state = preview.value;
-    if (!state || event.type === "auxclick" && event.button !== 1 || !(event.target instanceof Element)) return;
-    const link = event.target.closest("a[href]");
-    if (!link) return;
-    event.preventDefault();
-    const url = new URL(link.getAttribute("href") ?? "", location.href);
-    if (origin && url.origin === location.origin) window.parent.postMessage({ type: "ginko:navigate", session: state.session, path: url.pathname + url.search + url.hash }, origin);
-  };
-  document.addEventListener("click", interceptLink, true);
-  document.addEventListener("auxclick", interceptLink, true);
-}

package/dist/nuxt/runtime/preview-listener.d.mts

@@ -0,0 +1,13 @@
+import type { NuxtApp } from '#app';
+import type { Ref } from 'vue';
+import { type Bundle, type Locale } from '../../internal.mjs';
+import type { GinkoPublicConfig } from './shared.mjs';
+/**
+ * Preview messages (SPEC 8 "Vorschau"). Only the platform's frame (source and origin) may send a bundle
+ * for the session and locale the preview page announced. Links are cancelled and reported to the platform.
+ * Once per page load: a second call does nothing.
+ */
+export declare function listenToPlatform(nuxtApp: NuxtApp, config: GinkoPublicConfig, bundles: Ref<Partial<Record<Locale, Bundle>>>, preview: Ref<{
+    session: string;
+    locale: Locale;
+} | null>): void;

package/dist/nuxt/runtime/preview-listener.mjs

@@ -0,0 +1,37 @@
+import { clearError, useError } from "#imports";
+import schema from "#ginko/schema";
+import { bundleFits, isBundle, knownBricks, withFileBricks } from "../../internal.mjs";
+let listening = false;
+export function listenToPlatform(nuxtApp, config, bundles, preview) {
+  if (listening) return;
+  listening = true;
+  const origin = config.platform ? new URL(config.platform).origin : "";
+  window.addEventListener("message", (event) => {
+    const state = preview.value;
+    if (!state || !origin || event.source !== window.parent || event.origin !== origin) return;
+    const data = event.data;
+    if (typeof data !== "object" || data === null) return;
+    const message = data;
+    if (message.type !== "ginko:preview" || message.session !== state.session || message.site !== config.site || message.locale !== state.locale || !isBundle(message.bundle) || !bundleFits(message.bundle, schema)) return;
+    const platform = knownBricks(message.bundle, schema);
+    const locale = state.locale;
+    void filesOf(locale).then((files) => {
+      if (preview.value?.session !== state.session) return;
+      bundles.value = { ...bundles.value, [locale]: withFileBricks(platform, files, schema) };
+      void nuxtApp.runWithContext(() => useError().value ? clearError() : void 0);
+    });
+  });
+  const fileBundles = {};
+  const filesOf = (locale) => fileBundles[locale] ??= config.sources.files ? $fetch(`/__ginko/files/${locale}.json`).catch(() => void 0) : Promise.resolve(void 0);
+  const interceptLink = (event) => {
+    const state = preview.value;
+    if (!state || event.type === "auxclick" && event.button !== 1 || !(event.target instanceof Element)) return;
+    const link = event.target.closest("a[href]");
+    if (!link) return;
+    event.preventDefault();
+    const url = new URL(link.getAttribute("href") ?? "", location.href);
+    if (origin && url.origin === location.origin) window.parent.postMessage({ type: "ginko:navigate", session: state.session, path: url.pathname + url.search + url.hash }, origin);
+  };
+  document.addEventListener("click", interceptLink, true);
+  document.addEventListener("auxclick", interceptLink, true);
+}

package/dist/nuxt/runtime/preview.vue

@@ -1,13 +1,15 @@
 <script setup>
-import { definePageMeta, navigateTo, onBeforeUnmount, onMounted, ref, useRequestHeaders, useRoute, useRouter, useRuntimeConfig, useState, watch } from "#imports";
+import { definePageMeta, navigateTo, onBeforeUnmount, onMounted, ref, useNuxtApp, useRequestHeaders, useRoute, useRouter, useRuntimeConfig, useState, watch } from "#imports";
 import { coreMessage } from "../../internal.mjs";
 import { BUNDLE_STATE, PREVIEW_STATE } from "./composables.mjs";
+import { listenToPlatform } from "./preview-listener.mjs";
 definePageMeta({ layout: false });
 const route = useRoute();
 const router = useRouter();
 const config = useRuntimeConfig().public.ginko;
 const bundles = useState(BUNDLE_STATE, () => ({}));
 const preview = useState(PREVIEW_STATE, () => null);
+if (import.meta.client) listenToPlatform(useNuxtApp(), config, bundles, preview);
 const reader = useState("ginko:preview-reader", () => (import.meta.server ? useRequestHeaders(["accept-language"])["accept-language"]?.split(/[,;]/)[0] : navigator.language) || "en");
 function isSafePath(raw) {
   let decoded;

package/dist/nuxt/runtime/schema.d.ts

@@ -7,6 +7,12 @@ declare module '#ginko/schema' {
   export default schema
 }
 
+// The Markdown component registry for the renderer (module.ts, componentsForMarkdown): declared props and their types.
+declare module '#ginko/components' {
+  const components: import('@lupinum/ginko/internal').AttributeRegistry
+  export default components
+}
+
 // The site's file bricks as bundles per locale (CONTENT.md), a Nitro virtual module built from content/.
 declare module '#ginko/files' {
   const bundles: Partial<Record<import('@lupinum/ginko').Locale, import('@lupinum/ginko/internal').Bundle>>

package/dist/nuxt/runtime/server/bundles.d.ts

@@ -0,0 +1,4 @@
+import { getRequestHeader } from 'nuxt/server';
+import type { Bundle, Locale } from '../../../internal.mjs';
+import type { GinkoPublicConfig } from '../shared.mjs';
+export declare function loadServerBundles(event: Parameters<typeof getRequestHeader>[0], config: GinkoPublicConfig, locales: readonly Locale[]): Promise<Partial<Record<Locale, Bundle>>>;

package/dist/nuxt/runtime/server/files-md.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<import("../../..").MarkdownTree>;
+export default _default;

package/dist/nuxt/runtime/server/files.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<import("../../../core").Bundle>;
+export default _default;

package/dist/nuxt/runtime/server/headers.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<void>;
+export default _default;

package/dist/nuxt/runtime/server/items.d.mts

@@ -0,0 +1,12 @@
+import { type RequestEvent } from 'nuxt/server';
+import { type BundleItem } from '../../../internal.mjs';
+/** An entry as `getGinkoItems` returns it: `url` is its path in the requested language (collections with a route). */
+export type GinkoServerItem = BundleItem & {
+    url?: string;
+};
+/**
+ * The visible entries of collection `brick` in `locale` (default: the main language), in the collection's order, as
+ * `useGinko(brick).items` has them on a page: drafts and entries past their `visible` date are left out. Throws a 404
+ * for a language the site does not have or a key that is no collection, and a 503 when the platform cannot be reached.
+ */
+export declare function getGinkoItems(event: RequestEvent, brick: string, locale?: string): Promise<GinkoServerItem[]>;