@karibsen/eponyme 0.1.0 → 0.2.0

package/dist/runtime/server/services/eponyme-store.js

@@ -1,9 +1,11 @@
+import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { createDefaultEponymeData } from "../../utils/create-default-eponyme-data.js";
 import { getEponymeCollections, getEponymeSchemas } from "../../utils/get-eponyme-schemas.js";
 import { normalizeSlug } from "../../utils/normalize-slug.js";
 import { applyPreviewSlug } from "../../utils/preview.js";
 import { validateEponymeData, validateEponymePatch } from "../../utils/validate-eponyme-data.js";
+export const COLLECTION_METADATA_KEYS = ["updatedAt", "publishedAt", "title", "slug"];
 export class EponymeService {
   constructor(config, client) {
     this.client = client;
@@ -70,7 +72,7 @@ export class EponymeService {
     if (!schema) return void 0;
     const defaults = this.createState(schema);
     const row = this.getCollectionEntry(name) ? await this.client.eponyme.findUnique({ where: { name } }) : await this.client.eponyme.upsert({ where: { name }, create: { name, data: defaults }, update: {} });
-    if (!row) return void 0;
+    if (!row || row.deletedAt) return void 0;
     const state = this.normalizeState(schema, row.data);
     if (sameData(state, row.data)) return { state, updatedAt: row.updatedAt };
     const healed = await this.client.eponyme.update({ where: { name }, data: { data: state } });
@@ -127,11 +129,17 @@ export class EponymeService {
     }));
     return Object.fromEntries(entries);
   }
-  async listCollection(name, version = "published") {
+  /** Metadata keys that can be sorted on, alongside every field of the collection. */
+  collectionSortKeys(name) {
+    const definition = this.collections[name];
+    if (!definition) return void 0;
+    return [.../* @__PURE__ */ new Set([...COLLECTION_METADATA_KEYS, ...Object.keys(definition.fields)])];
+  }
+  async listCollection(name, version = "published", query = {}) {
     const definition = this.collections[name];
     if (!definition) return void 0;
     const rows = await this.client.eponyme.findMany({
-      where: { name: { startsWith: `${name}/` } },
+      where: { name: { startsWith: `${name}/` }, deletedAt: null },
       orderBy: [
         { updatedAt: "desc" },
         { name: "asc" }
@@ -149,7 +157,14 @@ export class EponymeService {
         updatedAt: row.updatedAt ? new Date(row.updatedAt).toISOString() : null
       };
     }));
-    return version === "draft" ? entries : entries.filter((entry) => entry.publishedAt);
+    const visible = version === "draft" ? entries : entries.filter((entry) => entry.publishedAt);
+    const sorted = query.orderBy ? sortCollectionEntries(visible, query.orderBy, query.order ?? "desc") : visible;
+    const skip = Math.max(0, Math.trunc(query.skip ?? 0) || 0);
+    const take = query.take === void 0 ? void 0 : Math.max(0, Math.trunc(query.take) || 0);
+    return {
+      entries: take === void 0 ? sorted.slice(skip) : sorted.slice(skip, skip + take),
+      total: sorted.length
+    };
   }
   /**
    * Builds the public URL list configured by `previewPaths`.
@@ -167,7 +182,7 @@ export class EponymeService {
       if (!path.includes(":slug"))
         throw new Error(`[Eponyme] previewPaths.${name} must include ":slug" to generate collection sitemap URLs.`);
       const rows = await this.client.eponyme.findMany({
-        where: { name: { startsWith: `${name}/` } },
+        where: { name: { startsWith: `${name}/` }, deletedAt: null },
         orderBy: [
           { updatedAt: "desc" },
           { name: "asc" }
@@ -186,6 +201,108 @@ export class EponymeService {
       entries.set(entry.loc, entry);
     return [...entries.values()];
   }
+  /**
+   * Every singleton and every live collection entry, as a portable file.
+   * Collections are read with one query each rather than one per entry.
+   */
+  async exportContent() {
+    const schemas = {};
+    const entries = [];
+    for (const [name, schema] of Object.entries(this.schemas)) {
+      schemas[name] = schemaFingerprint(schema);
+      const row = await this.loadRow(name);
+      if (row) entries.push({ name, ...toExportEntry(row.state) });
+    }
+    for (const [name, definition] of Object.entries(this.collections)) {
+      schemas[name] = schemaFingerprint(definition.fields);
+      const rows = await this.client.eponyme.findMany({
+        where: { name: { startsWith: `${name}/` }, deletedAt: null },
+        orderBy: [
+          { updatedAt: "desc" },
+          { name: "asc" }
+        ]
+      });
+      for (const row of rows) {
+        const slug = row.name.slice(name.length + 1);
+        if (!slug || slug.includes("/")) continue;
+        entries.push({ name: row.name, collection: name, ...toExportEntry(this.normalizeState(definition.fields, row.data)) });
+      }
+    }
+    return {
+      eponyme: { format: 1, exportedAt: (/* @__PURE__ */ new Date()).toISOString(), schemas },
+      entries
+    };
+  }
+  /**
+   * Applies an export file on top of the current content: every entry it carries is
+   * upserted, everything else is left alone. Nothing is ever deleted.
+   *
+   * The schema check runs first and refuses the whole file, so an import can never
+   * land half of its entries into a configuration that no longer matches.
+   */
+  async importContent(file, options = {}) {
+    const parsed = parseExportFile(file);
+    if (!parsed) return { errors: ["This file is not an Eponyme export."] };
+    const declared = parsed.eponyme.schemas;
+    const mismatch = Object.keys(declared).filter((name) => {
+      const local = this.schemas[name] ?? this.collections[name]?.fields;
+      return !local || schemaFingerprint(local) !== declared[name];
+    });
+    for (const entry of parsed.entries) {
+      const owner = entry.collection ?? this.getCollectionEntry(entry.name)?.name ?? entry.name;
+      if (!(owner in declared) && !mismatch.includes(owner)) mismatch.push(owner);
+    }
+    if (mismatch.length) {
+      return {
+        errors: ["The exported schema does not match this application's configuration."],
+        schemaMismatch: mismatch
+      };
+    }
+    const result = { dryRun: Boolean(options.dryRun), created: 0, updated: 0, skipped: [] };
+    for (const entry of parsed.entries) {
+      const collectionEntry = this.getCollectionEntry(entry.name);
+      const schema = this.schemas[entry.name] ?? collectionEntry?.definition.fields;
+      if (!schema) {
+        result.skipped.push({ name: entry.name, reason: "No schema is configured for this entry." });
+        continue;
+      }
+      const row = await this.client.eponyme.findUnique({ where: { name: entry.name } });
+      if (row?.deletedAt) {
+        result.skipped.push({ name: entry.name, reason: "An entry with this name is in the trash. Restore it or delete it permanently first." });
+        continue;
+      }
+      const state = this.normalizeState(schema, {
+        __eponyme: {
+          version: 1,
+          draft: entry.draft,
+          published: entry.published,
+          status: entry.status,
+          publishedAt: entry.publishedAt
+        }
+      });
+      if (collectionEntry) {
+        const { slugField } = collectionEntry.definition;
+        if (slugField in state.__eponyme.draft) state.__eponyme.draft[slugField] = collectionEntry.slug;
+        if (slugField in state.__eponyme.published) state.__eponyme.published[slugField] = collectionEntry.slug;
+      }
+      if (!options.dryRun) {
+        const data = state;
+        await this.client.eponyme.upsert({ where: { name: entry.name }, create: { name: entry.name, data }, update: { data } });
+        await this.client.eponymeVersion.create({
+          data: {
+            entryName: entry.name,
+            data,
+            action: "import",
+            status: state.__eponyme.status,
+            userId: options.actorId ?? null
+          }
+        });
+      }
+      if (row) result.updated++;
+      else result.created++;
+    }
+    return result;
+  }
   async createCollectionEntry(name, payload, actorId) {
     const definition = this.collections[name];
     if (!definition) return void 0;
@@ -196,8 +313,8 @@ export class EponymeService {
     const slug = normalizeSlug(String(input[definition.slugField] || input[definition.titleField] || ""));
     if (!slug) return { errors: { [definition.slugField]: ["A slug or title is required."] } };
     const entryName = `${name}/${slug}`;
-    if (await this.client.eponyme.findUnique({ where: { name: entryName } }))
-      return { errors: { [definition.slugField]: ["This slug is already in use."] } };
+    const taken = await this.slugTakenError(definition, entryName);
+    if (taken) return taken;
     const defaults = createDefaultEponymeData(definition.fields);
     const data = { ...defaults, ...input, [definition.slugField]: slug };
     const errors = validateEponymePatch(definition.fields, data, data, "draft");
@@ -214,14 +331,47 @@ export class EponymeService {
     try {
       await this.client.eponyme.create({ data: { name: entryName, data: state } });
     } catch (error) {
-      if (isPrismaError(error, "P2002")) return { errors: { [definition.slugField]: ["This slug is already in use."] } };
+      if (isPrismaError(error, "P2002")) return await this.slugTakenError(definition, entryName) ?? { errors: { [definition.slugField]: ["This slug is already in use."] } };
       throw error;
     }
     await this.client.eponymeVersion.create({ data: { entryName, data: state, action: "draft", status: "draft", userId: actorId ?? null } });
     return { slug, data, status: "draft", publishedAt: null };
   }
+  /**
+   * A trashed entry keeps its row, so it keeps its slug: reusing one has to be
+   * refused with an error the editor can act on rather than the generic message.
+   */
+  async slugTakenError(definition, entryName) {
+    const row = await this.client.eponyme.findUnique({ where: { name: entryName } });
+    if (!row) return void 0;
+    return {
+      errors: {
+        [definition.slugField]: [row.deletedAt ? "An entry with this slug is in the trash. Restore it or delete it permanently first." : "This slug is already in use."]
+      }
+    };
+  }
+  /** Moves an entry to the trash. Its history is kept, so it stays restorable. */
   async deleteCollectionEntry(name) {
     if (!this.getCollectionEntry(name)) return false;
+    const { count } = await this.client.eponyme.updateMany({
+      where: { name, deletedAt: null },
+      data: { deletedAt: /* @__PURE__ */ new Date() }
+    });
+    return count > 0;
+  }
+  async restoreCollectionEntry(name) {
+    if (!this.getCollectionEntry(name)) return false;
+    const { count } = await this.client.eponyme.updateMany({
+      where: { name, deletedAt: { not: null } },
+      data: { deletedAt: null }
+    });
+    return count > 0;
+  }
+  /** Definitive: `onDelete: Cascade` takes the entry's whole history with it. */
+  async purgeCollectionEntry(name) {
+    if (!this.getCollectionEntry(name)) return false;
+    const row = await this.client.eponyme.findUnique({ where: { name } });
+    if (!row?.deletedAt) return false;
     try {
       await this.client.eponyme.delete({ where: { name } });
     } catch (error) {
@@ -230,6 +380,33 @@ export class EponymeService {
     }
     return true;
   }
+  /** Trashed entries of a collection, most recently updated first. */
+  async listCollectionTrash(name) {
+    const definition = this.collections[name];
+    if (!definition) return void 0;
+    const rows = await this.client.eponyme.findMany({
+      where: { name: { startsWith: `${name}/` }, deletedAt: { not: null } },
+      orderBy: [
+        { updatedAt: "desc" },
+        { name: "asc" }
+      ]
+    });
+    const entries = rows.flatMap((row) => {
+      const slug = row.name.slice(name.length + 1);
+      if (!slug || slug.includes("/")) return [];
+      const state = this.normalizeState(definition.fields, row.data);
+      return [{
+        slug,
+        title: String(state.__eponyme.draft[definition.titleField] || slug),
+        data: state.__eponyme.draft,
+        status: state.__eponyme.status,
+        publishedAt: state.__eponyme.publishedAt,
+        updatedAt: row.updatedAt ? new Date(row.updatedAt).toISOString() : null,
+        deletedAt: row.deletedAt ? new Date(row.deletedAt).toISOString() : null
+      }];
+    });
+    return { entries, total: entries.length };
+  }
   async patch(name, payload, action = "publish", actorId) {
     const schema = this.getSchema(name);
     if (!schema) return void 0;
@@ -279,7 +456,7 @@ export class EponymeService {
     });
     return versions.map((version) => ({
       id: version.id,
-      action: version.action === "draft" || version.action === "publish" ? version.action : "restore",
+      action: isHistoryAction(version.action) ? version.action : "restore",
       status: version.status === "draft" ? "draft" : "published",
       createdAt: new Date(version.createdAt).toISOString(),
       user: version.user ? { id: version.user.id, username: version.user.username } : null
@@ -319,6 +496,68 @@ function getStoredState(value) {
   );
   return valid ? state : void 0;
 }
+function isHistoryAction(action) {
+  return action === "draft" || action === "publish" || action === "import";
+}
+function toExportEntry(state) {
+  return {
+    draft: state.__eponyme.draft,
+    published: state.__eponyme.published,
+    status: state.__eponyme.status,
+    publishedAt: state.__eponyme.publishedAt
+  };
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function describeSchema(schema) {
+  const fields = schema;
+  return Object.keys(fields).sort().map((key) => `${key}:${describeField(fields[key])}`).join(",");
+}
+function describeField(field) {
+  if (!isPlainObject(field) || typeof field.type !== "string") return "unknown";
+  const options = isPlainObject(field.options) ? field.options : {};
+  if (field.type === "array") {
+    const item = isPlainObject(options.of) ? options.of : {};
+    return `array(${typeof item.type === "string" ? describeField(item) : describeSchema(item)})`;
+  }
+  if (field.type === "section")
+    return `section(${describeSchema(isPlainObject(options.fields) ? options.fields : {})})`;
+  if (field.type === "tabs") {
+    const tabs = isPlainObject(options.tabs) ? options.tabs : {};
+    return `tabs(${Object.keys(tabs).sort().map((key) => {
+      const tab = tabs[key];
+      return `${key}:${describeSchema(isPlainObject(tab) && isPlainObject(tab.fields) ? tab.fields : {})}`;
+    }).join(",")})`;
+  }
+  return field.type;
+}
+export function schemaFingerprint(schema) {
+  return createHash("sha256").update(describeSchema(schema)).digest("hex").slice(0, 32);
+}
+function parseExportFile(value) {
+  if (!isPlainObject(value)) return void 0;
+  const envelope = value.eponyme;
+  if (!isPlainObject(envelope) || envelope.format !== 1 || !isPlainObject(envelope.schemas)) return void 0;
+  if (!Object.values(envelope.schemas).every((fingerprint) => typeof fingerprint === "string")) return void 0;
+  if (!Array.isArray(value.entries)) return void 0;
+  const entries = [];
+  for (const entry of value.entries) {
+    if (!isPlainObject(entry)) return void 0;
+    const { name, collection, draft, published, status, publishedAt } = entry;
+    const valid = typeof name === "string" && name.length > 0 && isPlainObject(draft) && isPlainObject(published) && (status === "draft" || status === "published") && (publishedAt === null || typeof publishedAt === "string") && (collection === void 0 || typeof collection === "string");
+    if (!valid) return void 0;
+    entries.push({ name, collection, draft, published, status, publishedAt });
+  }
+  return {
+    eponyme: {
+      format: 1,
+      exportedAt: typeof envelope.exportedAt === "string" ? envelope.exportedAt : (/* @__PURE__ */ new Date()).toISOString(),
+      schemas: envelope.schemas
+    },
+    entries
+  };
+}
 function mergeErrors(...groups) {
   const errors = {};
   for (const group of groups) {
@@ -333,6 +572,30 @@ export function isPrismaError(error, code) {
 function sameData(left, right) {
   return isDeepStrictEqual(left, right);
 }
+function sortValue(entry, key) {
+  if (COLLECTION_METADATA_KEYS.includes(key))
+    return entry[key];
+  return entry.data[key];
+}
+function isEmptyValue(value) {
+  return value === void 0 || value === null || value === "";
+}
+function sortCollectionEntries(entries, key, direction) {
+  const factor = direction === "asc" ? 1 : -1;
+  return [...entries].sort((left, right) => {
+    const a = sortValue(left, key);
+    const b = sortValue(right, key);
+    if (isEmptyValue(a) || isEmptyValue(b)) {
+      if (isEmptyValue(a) && isEmptyValue(b)) return left.slug.localeCompare(right.slug);
+      return isEmptyValue(a) ? 1 : -1;
+    }
+    if (typeof a === "number" && typeof b === "number")
+      return (a - b) * factor || left.slug.localeCompare(right.slug);
+    if (typeof a === "boolean" && typeof b === "boolean")
+      return (Number(a) - Number(b)) * factor || left.slug.localeCompare(right.slug);
+    return String(a).localeCompare(String(b), void 0, { numeric: true }) * factor || left.slug.localeCompare(right.slug);
+  });
+}
 function withLastmod(loc, publishedAt) {
   return publishedAt ? { loc, lastmod: publishedAt } : { loc };
 }

package/dist/runtime/server/utils/eponyme-entry.d.ts

@@ -0,0 +1,9 @@
+import type { EponymeService } from '../services/eponyme-store.js';
+/**
+ * Splits `<collection>/<slug>` when the name belongs to a configured collection, so
+ * hook listeners can branch on the collection without re-parsing the name themselves.
+ */
+export declare function splitEponymeCollectionEntry(service: EponymeService, name: string): {
+    name: string;
+    slug: string;
+} | undefined;

package/dist/runtime/server/utils/eponyme-entry.js

@@ -0,0 +1,7 @@
+export function splitEponymeCollectionEntry(service, name) {
+  const separator = name.lastIndexOf("/");
+  if (separator <= 0) return void 0;
+  const collection = name.slice(0, separator);
+  const slug = name.slice(separator + 1);
+  return slug && service.getCollection(collection) ? { name: collection, slug } : void 0;
+}

package/dist/runtime/server/utils/eponyme-hooks.d.ts

@@ -0,0 +1,16 @@
+import type { EponymeHooks } from '../../types/hooks.js';
+type HookName = keyof EponymeHooks;
+type HookContext<Name extends HookName> = Parameters<EponymeHooks[Name]>[0];
+/**
+ * Notification hooks. The write already happened, so a listener that throws is
+ * logged and swallowed: a failing webhook must not report a successful save as an
+ * error the editor cannot act on.
+ */
+export declare function callEponymeHook<Name extends Exclude<HookName, `${string}before${string}`>>(name: Name, context: HookContext<Name>): Promise<void>;
+/**
+ * Blocking hooks, run before the write. A listener may mutate `context.data` to amend
+ * the payload, or throw to reject the operation — the error surfaces as a 422 so the
+ * message reaches the editor.
+ */
+export declare function callEponymeBlockingHook<Name extends Extract<HookName, `${string}before${string}`>>(name: Name, context: HookContext<Name>): Promise<void>;
+export {};

package/dist/runtime/server/utils/eponyme-hooks.js

@@ -0,0 +1,24 @@
+import { createError } from "h3";
+import { useNitroApp } from "nitropack/runtime";
+function hooks() {
+  return useNitroApp().hooks;
+}
+export async function callEponymeHook(name, context) {
+  try {
+    await hooks().callHook(name, context);
+  } catch (error) {
+    console.error(`[Eponyme] The "${name}" hook threw. The operation itself succeeded.`, error);
+  }
+}
+export async function callEponymeBlockingHook(name, context) {
+  try {
+    await hooks().callHook(name, context);
+  } catch (error) {
+    if (error && typeof error === "object" && "statusCode" in error) throw error;
+    throw createError({
+      statusCode: 422,
+      statusMessage: error instanceof Error ? error.message : `Rejected by the "${name}" hook.`,
+      data: { errors: { _form: [error instanceof Error ? error.message : "Rejected by a server hook."] } }
+    });
+  }
+}

package/dist/runtime/server/utils/eponyme-variables.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Resolved per call rather than cached: a variable such as `currentYear` has to
+ * reflect the moment the page is served, not the moment the server booted.
+ */
+export declare function interpolateEponymeContent<T>(value: T): T;

package/dist/runtime/server/utils/eponyme-variables.js

@@ -0,0 +1,5 @@
+import eponymeVariables from "#eponyme/variables";
+import { interpolateEponymeValue, resolveEponymeVariables } from "../../utils/variables.js";
+export function interpolateEponymeContent(value) {
+  return interpolateEponymeValue(value, resolveEponymeVariables(eponymeVariables));
+}

package/dist/runtime/types/eponyme-config.d.ts

@@ -9,3 +9,10 @@ declare module '#eponyme/prisma' {
   const prisma: unknown
   export default prisma
 }
+
+declare module '#eponyme/variables' {
+  import type { EponymeVariables } from './variables'
+
+  const variables: EponymeVariables
+  export default variables
+}

package/dist/runtime/types/field.d.ts

@@ -70,6 +70,7 @@ export interface UrlValue {
     href: string;
     type: UrlType;
     openInNewTab: boolean;
+    download?: boolean;
 }
 export interface UrlFieldOptions extends DefaultFieldOptions<UrlValue> {
     placeholder?: string;

package/dist/runtime/types/hooks.d.ts

@@ -0,0 +1,67 @@
+import type { EponymeAction, EponymeStatus } from '../server/services/eponyme-store.js';
+export interface EponymeEntryContext {
+    /** Full entry name, `homepage` or `articles/my-article`. */
+    name: string;
+    /** Collection name and slug when the entry belongs to one. */
+    collection?: {
+        name: string;
+        slug: string;
+    };
+    action: EponymeAction | 'restore';
+    status: EponymeStatus;
+    publishedAt: string | null;
+    data: Record<string, unknown>;
+    /** Author of the write, absent for an unattended one. */
+    userId?: string;
+}
+/** Mutating `data` here changes what gets written. */
+export interface EponymeEntryBeforeSaveContext {
+    name: string;
+    collection?: {
+        name: string;
+        slug: string;
+    };
+    action: EponymeAction;
+    data: Record<string, unknown>;
+    userId?: string;
+}
+/** Trash moves carry no content: the entry is untouched, only its availability changed. */
+export interface EponymeEntryTrashContext {
+    /** Full entry name, `articles/my-article`. Only collection entries can be trashed. */
+    name: string;
+    collection: {
+        name: string;
+        slug: string;
+    };
+    /** Author of the move, absent for an unattended one. */
+    userId?: string;
+}
+export interface EponymeFormSubmissionContext {
+    form: string;
+    data: Record<string, unknown>;
+    /** Absent until the submission is stored, so `undefined` in `before`. */
+    id?: string;
+}
+export interface EponymeHooks {
+    /**
+     * Runs before the write. Throwing rejects it with a 422, so an application can
+     * enforce a rule the schema cannot express. Mutating `data` amends the payload.
+     */
+    'eponyme:entry:beforeSave': (context: EponymeEntryBeforeSaveContext) => void | Promise<void>;
+    /** After a draft save. The entry is already stored. */
+    'eponyme:entry:saved': (context: EponymeEntryContext) => void | Promise<void>;
+    /** After a publication: the usual place to purge a cache or ping a webhook. */
+    'eponyme:entry:published': (context: EponymeEntryContext) => void | Promise<void>;
+    /** After a history version was restored as the current draft. */
+    'eponyme:entry:restored': (context: EponymeEntryContext) => void | Promise<void>;
+    /** After a collection entry was moved to the trash. It is recoverable, nothing was destroyed. */
+    'eponyme:entry:trashed': (context: EponymeEntryTrashContext) => void | Promise<void>;
+    /** After a collection entry was taken back out of the trash. */
+    'eponyme:entry:untrashed': (context: EponymeEntryTrashContext) => void | Promise<void>;
+    /** After a collection entry and its whole history were deleted for good. */
+    'eponyme:entry:purged': (context: EponymeEntryTrashContext) => void | Promise<void>;
+    /** Runs before a managed submission is stored. Throwing rejects it with a 422. */
+    'eponyme:form:beforeSubmit': (context: EponymeFormSubmissionContext) => void | Promise<void>;
+    /** After a managed submission was stored, with its id. */
+    'eponyme:form:submitted': (context: Required<EponymeFormSubmissionContext>) => void | Promise<void>;
+}

package/dist/runtime/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from './auth.js';
 export * from './eponyme.js';
 export * from './field.js';
+export * from './variables.js';

package/dist/runtime/types/index.js

@@ -1,3 +1,4 @@
 export * from "./auth.js";
 export * from "./eponyme.js";
 export * from "./field.js";
+export * from "./variables.js";

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

@@ -9,3 +9,13 @@ declare module '@nuxt/schema' {
     eponyme: ModuleOptions
   }
 }
+
+declare module 'nitropack/types' {
+  import type { EponymeHooks } from './hooks'
+
+  // Interface augmentation: the body is empty by design, the point is the supertype.
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface NitroRuntimeHooks extends EponymeHooks {}
+}
+
+export {}

package/dist/runtime/types/variables.d.ts

@@ -0,0 +1,17 @@
+/** A variable resolves to a fixed value, or is computed on every read. */
+export type EponymeVariableValue = string | number | (() => string | number);
+export interface EponymeVariableDefinition {
+    /** Shown in the editor's variable menu. Defaults to the variable name. */
+    label?: string;
+    description?: string;
+    value: EponymeVariableValue;
+}
+export type EponymeVariables = Record<string, EponymeVariableValue | EponymeVariableDefinition>;
+/** What the editor needs to list a variable without being able to resolve it. */
+export interface EponymeVariableSummary {
+    name: string;
+    label: string;
+    description?: string;
+    /** Value at build time, shown as an example in the menu. */
+    preview: string;
+}

package/dist/runtime/utils/build-navigation-tree.d.ts

@@ -0,0 +1,22 @@
+import type { EponymeNavigationNode } from '../types/eponyme-navigation.js';
+export interface EponymeNavigationTreeInput {
+    /** Singleton entry names, `pages/homepage`. Only the keys are read. */
+    schemas: Record<string, unknown>;
+    collections: Record<string, {
+        label?: string;
+    }>;
+    forms: Record<string, {
+        label?: string;
+    }>;
+    /** Entries already loaded per collection, added as leaves under their collection. */
+    collectionEntries?: Record<string, Array<{
+        slug: string;
+        title: string;
+    }>>;
+}
+/**
+ * Turns the flat, slash-separated names of the configuration into the nested tree the
+ * sidebar renders. Intermediate segments become folders, so `pages/homepage` yields a
+ * `pages` folder even though nothing declares one.
+ */
+export declare function buildEponymeNavigationTree(input: EponymeNavigationTreeInput): EponymeNavigationNode[];

package/dist/runtime/utils/build-navigation-tree.js

@@ -0,0 +1,30 @@
+import { humanizeLabel } from "./humanize-label.js";
+export function buildEponymeNavigationTree(input) {
+  const root = [];
+  function addPath(pathValue, finalKind, configuredLabel) {
+    const parts = pathValue.split("/");
+    let children = root;
+    for (let index = 0; index < parts.length; index++) {
+      const part = parts[index];
+      const path = parts.slice(0, index + 1).join("/");
+      const last = index === parts.length - 1;
+      const kind = last ? finalKind : "folder";
+      let node = children.find((item) => item.path === path);
+      if (!node) {
+        node = { kind, path, label: humanizeLabel(part, last ? configuredLabel : void 0), children: [] };
+        children.push(node);
+      } else if (last) {
+        node.kind = finalKind;
+        if (configuredLabel) node.label = configuredLabel;
+      }
+      children = node.children;
+    }
+  }
+  for (const entry of Object.keys(input.schemas)) addPath(entry, "entry");
+  for (const [name, definition] of Object.entries(input.collections)) {
+    addPath(name, "collection", definition.label);
+    for (const entry of input.collectionEntries?.[name] ?? []) addPath(`${name}/${entry.slug}`, "entry", entry.title);
+  }
+  for (const [name, definition] of Object.entries(input.forms)) addPath(name, "form", definition.label);
+  return root;
+}

package/dist/runtime/utils/date-locale.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Dates in the dashboard are formatted with a fixed locale rather than the ambient one.
+ *
+ * `Intl.DateTimeFormat(undefined, …)` resolves to the server's locale during SSR and to
+ * the visitor's in the browser, so the two renders disagree and Vue reports a hydration
+ * mismatch on every timestamp. The dashboard interface is English throughout, so pinning
+ * the locale keeps the formatting consistent with the rest of it. `en-GB` is day-first
+ * and 24-hour, which reads closer to what most of the world expects than `en-US`.
+ */
+export declare const EPONYME_DATE_LOCALE = "en-GB";

package/dist/runtime/utils/date-locale.js

@@ -0,0 +1 @@
+export const EPONYME_DATE_LOCALE = "en-GB";

package/dist/runtime/utils/downloadable-link.d.ts

@@ -0,0 +1,2 @@
+export declare function getDownloadableExtension(href: string): string | undefined;
+export declare function isDownloadableLink(href: string): boolean;