@hollware/nuxt 0.0.0 → 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Sergio Azócar and Hollware contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,57 @@
 # @hollware/nuxt
 
-A placeholder. The first release of the Nuxt module of Hollware is 0.4.0: https://hollware.com
+Read [Hollware](https://hollware.com) from a Nuxt site: over a service binding when the site is a
+Worker on the same Cloudflare account, or over HTTP with a read token anywhere else.
+
+```sh
+npm install @hollware/nuxt
+```
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['@hollware/nuxt'],
+  hollware: { site: 'my-site' },
+  nitro: { preset: 'cloudflare_module', cloudflare: { deployConfig: true, nodeCompat: false } },
+})
+```
+
+On Cloudflare, bind the Hollware Worker in the site's `wrangler.jsonc`:
+
+```jsonc
+"services": [{ "binding": "HOLLWARE", "service": "my-hollware", "entrypoint": "Hollware" }]
+```
+
+Elsewhere, set `hollware.url` and a read token (`hollware token create --read`) in
+`NUXT_HOLLWARE_TOKEN`. The token stays on the server: pages read through the site's own
+`/_hollware/` routes.
+
+```vue
+<script setup lang="ts">
+const { data } = await useHollwareEntry('blog', 'en', useRoute().params.slug as string)
+</script>
+
+<template>
+  <h1>{{ data?.entry.frontmatter.title }}</h1>
+  <HollwareContent :entry="data?.entry" />
+</template>
+```
+
+| What                                            | Does                                                 |
+| ----------------------------------------------- | ---------------------------------------------------- |
+| `useHollwareEntry(collection, locale, slug)`    | A published entry with its Comark document, or a 404 |
+| `useHollwareEntries(collection, { locale, … })` | A page of published entries, newest first            |
+| `useHollwareTranslations(collection, group)`    | The entries of a translation group                   |
+| `useHollwareSite()`                             | The site: its locales and collections                |
+| `<HollwareContent :entry :components>`          | Renders the document with `@comark/vue`              |
+| `useHollware(event)` (server)                   | The reader itself, for routes of your own            |
+
+Every page carries `<meta name="generator" content="Hollware">`; set `hollware.generator: false`
+to leave it out.
+
+## Links
+
+- Docs: <https://hollware.com>
+- Repository: <https://github.com/hollware/hollware>
+- Issues: <https://github.com/hollware/hollware/issues>
+- License: MIT

package/dist/index.d.mts

@@ -0,0 +1,38 @@
+import { PageEntry } from "./runtime/types.mjs";
+//#region src/index.d.ts
+/** The options of `hollware` in nuxt.config.ts. */
+export interface ModuleOptions {
+  /** The key of the site in the Hollware config. Required. */
+  site: string;
+  /**
+   * The service binding to the `Hollware` entrypoint of the Hollware Worker, by its name in the
+   * site's wrangler.jsonc. When the Worker has it, every read goes over it: no network, no token.
+   */
+  binding: string;
+  /**
+   * The public URL of the Hollware, to read over HTTP when there is no binding: at build time on
+   * another host, or a site off Cloudflare. It goes with `token`.
+   */
+  url?: string;
+  /**
+   * A read token (`hw_read_`, from `hollware token create --read`). It stays on the server: pages
+   * read through the site's own `/_hollware/` routes. Prefer the `NUXT_HOLLWARE_TOKEN` variable to
+   * writing it here.
+   */
+  token?: string;
+  /** Whether pages carry `<meta name="generator" content="Hollware">`. */
+  generator: boolean;
+  /**
+   * The public URL of the Hollware that counts this site's page views (ADR-031), such as
+   * `https://cms.example.com`: each page the reader sees is sent to its `/events`, as the site and
+   * the path, with no cookie. The site's `url` in the Hollware config must be this site's origin.
+   * No views are counted when it is not set.
+   */
+  beacon?: string;
+}
+export declare const name = "@hollware/nuxt";
+/** The routes of the site that read Hollware for its pages, on the server. */
+export declare const ROUTES: readonly [readonly ['/_hollware/site', 'site'], readonly ['/_hollware/entries/:collection', 'entries'], readonly ['/_hollware/entry/:collection/:locale/:slug', 'entry'], readonly ['/_hollware/translations/:collection/:group', 'translations']];
+declare const _default: import("nuxt/schema").NuxtModule<ModuleOptions, ModuleOptions, false>;
+//#endregion
+export { type PageEntry, _default as default };

package/dist/index.mjs

@@ -0,0 +1,68 @@
+import { addComponent, addImports, addPlugin, addServerHandler, addServerImports, createResolver, defineNuxtModule } from "@nuxt/kit";
+//#region src/index.ts
+const name = "@hollware/nuxt";
+/** The routes of the site that read Hollware for its pages, on the server. */
+const ROUTES = [
+	["/_hollware/site", "site"],
+	["/_hollware/entries/:collection", "entries"],
+	["/_hollware/entry/:collection/:locale/:slug", "entry"],
+	["/_hollware/translations/:collection/:group", "translations"]
+];
+var src_default = defineNuxtModule({
+	meta: {
+		name,
+		configKey: "hollware",
+		compatibility: { nuxt: ">=4.6.0" }
+	},
+	defaults: {
+		site: "",
+		binding: "HOLLWARE",
+		generator: true
+	},
+	setup(options, nuxt) {
+		if (options.site === "") throw new Error("@hollware/nuxt: set hollware.site in nuxt.config.ts to the key of your site in the Hollware config.");
+		const resolver = createResolver(import.meta.url);
+		const resolve = (path) => resolver.resolve(path);
+		nuxt.options.runtimeConfig["hollware"] = {
+			site: options.site,
+			binding: options.binding,
+			url: options.url ?? "",
+			token: options.token ?? ""
+		};
+		addServerImports([{
+			name: "useHollware",
+			from: resolve("./runtime/server/reader")
+		}]);
+		for (const [route, handler] of ROUTES) addServerHandler({
+			route,
+			method: "get",
+			handler: resolve(`./runtime/server/routes/${handler}`)
+		});
+		addImports([
+			"useHollwareEntry",
+			"useHollwareEntries",
+			"useHollwareSite",
+			"useHollwareTranslations"
+		].map((imported) => ({
+			name: imported,
+			from: resolve("./runtime/composables")
+		})));
+		addComponent({
+			name: "HollwareContent",
+			filePath: resolve("./runtime/components/HollwareContent")
+		});
+		if (options.generator) addPlugin(resolve("./runtime/generator"));
+		if (options.beacon !== void 0 && options.beacon !== "") {
+			nuxt.options.runtimeConfig.public["hollware"] = {
+				site: options.site,
+				beacon: options.beacon
+			};
+			addPlugin({
+				src: resolve("./runtime/beacon.client"),
+				mode: "client"
+			});
+		}
+	}
+});
+//#endregion
+export { ROUTES, src_default as default, name };

package/dist/runtime/beacon.client.d.mts

@@ -0,0 +1,4 @@
+//#region src/runtime/beacon.client.d.ts
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+//#endregion
+export { _default as default };

package/dist/runtime/beacon.client.mjs

@@ -0,0 +1,16 @@
+import { sendView } from "./beacon.mjs";
+import { defineNuxtPlugin, useRouter, useRuntimeConfig } from "nuxt/app";
+//#region src/runtime/beacon.client.ts
+var beacon_client_default = defineNuxtPlugin((nuxtApp) => {
+	const config = useRuntimeConfig().public["hollware"];
+	if (typeof config !== "object" || config === null) return;
+	const site = "site" in config && typeof config.site === "string" ? config.site : "";
+	const beacon = "beacon" in config && typeof config.beacon === "string" ? config.beacon : "";
+	if (site === "" || beacon === "") return;
+	const router = useRouter();
+	nuxtApp.hook("page:finish", () => {
+		sendView((url, init) => fetch(url, init), beacon, site, router.currentRoute.value.path);
+	});
+});
+//#endregion
+export { beacon_client_default as default };

package/dist/runtime/beacon.d.mts

@@ -0,0 +1,9 @@
+//#region src/runtime/beacon.d.ts
+/**
+ * What a page sends to count a view (ADR-031): the site and the path, nothing else. It goes with
+ * `fetch` and not `navigator.sendBeacon`, so that it can leave cookies out: `credentials: 'omit'`.
+ * `keepalive` lets it finish when the page is left; `no-cors` with a text body needs no preflight,
+ * and the page never reads the answer.
+ */
+export declare function sendView(send: (url: string, init: RequestInit) => Promise<unknown>, hollwareUrl: string, site: string, path: string): void;
+//#endregion

package/dist/runtime/beacon.mjs

@@ -0,0 +1,22 @@
+//#region src/runtime/beacon.ts
+/**
+* What a page sends to count a view (ADR-031): the site and the path, nothing else. It goes with
+* `fetch` and not `navigator.sendBeacon`, so that it can leave cookies out: `credentials: 'omit'`.
+* `keepalive` lets it finish when the page is left; `no-cors` with a text body needs no preflight,
+* and the page never reads the answer.
+*/
+function sendView(send, hollwareUrl, site, path) {
+	send(`${hollwareUrl.replace(/\/+$/, "")}/events`, {
+		method: "POST",
+		body: JSON.stringify({
+			site,
+			path
+		}),
+		headers: { "content-type": "text/plain;charset=UTF-8" },
+		credentials: "omit",
+		keepalive: true,
+		mode: "no-cors"
+	}).catch(() => {});
+}
+//#endregion
+export { sendView };

package/dist/runtime/components/HollwareContent.d.mts

@@ -0,0 +1,40 @@
+import { PropType } from "vue";
+//#region src/runtime/components/HollwareContent.d.ts
+/**
+ * The body of an entry: the Comark document Hollware stored when it was written, rendered with
+ * `@comark/vue`. `components` maps the names of the entry's components to the site's own.
+ */
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  /** An entry as `useHollwareEntry` gives it, with its `document`. */
+  entry: {
+    type: PropType<{
+      document?: unknown;
+    } | null | undefined>;
+    default: null;
+  };
+  components: {
+    type: PropType<Record<string, unknown>>;
+    default: () => {};
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  /** An entry as `useHollwareEntry` gives it, with its `document`. */
+  entry: {
+    type: PropType<{
+      document?: unknown;
+    } | null | undefined>;
+    default: null;
+  };
+  components: {
+    type: PropType<Record<string, unknown>>;
+    default: () => {};
+  };
+}>> & Readonly<{}>, {
+  entry: {
+    document?: unknown;
+  } | null | undefined;
+  components: Record<string, unknown>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { _default as default };

package/dist/runtime/components/HollwareContent.mjs

@@ -0,0 +1,33 @@
+import { defineComponent, h } from "vue";
+import { MarkdownDocument } from "@comark/vue";
+//#region src/runtime/components/HollwareContent.ts
+/**
+* The body of an entry: the Comark document Hollware stored when it was written, rendered with
+* `@comark/vue`. `components` maps the names of the entry's components to the site's own.
+*/
+var HollwareContent_default = defineComponent({
+	name: "HollwareContent",
+	props: {
+		/** An entry as `useHollwareEntry` gives it, with its `document`. */
+		entry: {
+			type: Object,
+			default: null
+		},
+		components: {
+			type: Object,
+			default: () => ({})
+		}
+	},
+	setup(props) {
+		return () => {
+			const document = props.entry?.document;
+			if (typeof document !== "object" || document === null || !("nodes" in document)) return null;
+			return h(MarkdownDocument, {
+				value: document,
+				components: props.components
+			});
+		};
+	}
+});
+//#endregion
+export { HollwareContent_default as default };

package/dist/runtime/composables.d.mts

@@ -0,0 +1,67 @@
+import { PageEntry } from "./types.mjs";
+import { MaybeRefOrGetter } from "vue";
+//#region src/runtime/composables.d.ts
+/**
+ * The published content of the site, for a page: each reads the site's own `/_hollware/` route,
+ * which reads Hollware on the server, so no token reaches the browser. They are `useFetch`, so the
+ * page renders on the server with the answer and the browser does not ask again.
+ */
+/** An entry, with its Comark document; `data` is null while it loads, `error` a 404 when it is not published. */
+export declare function useHollwareEntry(collection: MaybeRefOrGetter<string>, locale: MaybeRefOrGetter<string>, slug: MaybeRefOrGetter<string>): import("nuxt/app").AsyncData<{
+  outcome: 'ok';
+  entry: PageEntry;
+} | undefined, import("nuxt/app").NuxtError<unknown> | undefined>;
+/** A page of the published entries of a collection, newest first. */
+export declare function useHollwareEntries(collection: MaybeRefOrGetter<string>, options?: MaybeRefOrGetter<{
+  locale?: string;
+  tag?: string;
+  limit?: number;
+  cursor?: string;
+}>,
+/** `lazy: true` renders without waiting for the answer, as `useFetch` does. */
+fetching?: {
+  lazy?: boolean;
+}): import("nuxt/app").AsyncData<{
+  outcome: 'ok';
+  entries: PageEntry[];
+  nextCursor: string | null;
+} | undefined, import("nuxt/app").NuxtError<unknown> | undefined>;
+/** The entries of a translation group, one per locale. */
+export declare function useHollwareTranslations(collection: MaybeRefOrGetter<string>, group: MaybeRefOrGetter<string>): import("nuxt/app").AsyncData<{
+  outcome: 'ok';
+  entries: PageEntry[];
+} | undefined, import("nuxt/app").NuxtError<unknown> | undefined>;
+/** The site: its locales, its collections and their schemas. */
+export declare function useHollwareSite(): import("nuxt/app").AsyncData<{
+  outcome: "ok";
+  site: {
+    key: string;
+    locales: string[];
+    defaultLocale: string;
+    styleGuide: string | null;
+    collections: {
+      name: string;
+      schema: Record<string, unknown>;
+      routes: Record<string, string>;
+      translationGroupField: string | null;
+      tagsField: string | null;
+      sortByField: string | null;
+      components: {
+        name: string;
+        description: string | null;
+        example: string | null;
+        props: Record<string, unknown>;
+      }[];
+      contracts: {
+        id: string;
+        severity: "error" | "warning";
+        phases: ("publish" | "write")[];
+        description: string;
+      }[];
+      maxMarkdownBytes: number;
+      styleGuide: string | null;
+    }[];
+  };
+} | undefined, import("nuxt/app").NuxtError<unknown> | undefined>;
+//#endregion
+export type { PageEntry };

package/dist/runtime/composables.mjs

@@ -0,0 +1,32 @@
+import { useFetch } from "nuxt/app";
+import { computed, toValue } from "vue";
+//#region src/runtime/composables.ts
+/**
+* The published content of the site, for a page: each reads the site's own `/_hollware/` route,
+* which reads Hollware on the server, so no token reaches the browser. They are `useFetch`, so the
+* page renders on the server with the answer and the browser does not ask again.
+*/
+/** An entry, with its Comark document; `data` is null while it loads, `error` a 404 when it is not published. */
+function useHollwareEntry(collection, locale, slug) {
+	const path = computed(() => `/_hollware/entry/${encodeURIComponent(toValue(collection))}/${encodeURIComponent(toValue(locale))}/${encodeURIComponent(toValue(slug))}`);
+	return useFetch(path, { key: path.value });
+}
+/** A page of the published entries of a collection, newest first. */
+function useHollwareEntries(collection, options = {}, fetching = {}) {
+	const path = computed(() => `/_hollware/entries/${encodeURIComponent(toValue(collection))}`);
+	return useFetch(path, {
+		query: computed(() => toValue(options)),
+		...fetching
+	});
+}
+/** The entries of a translation group, one per locale. */
+function useHollwareTranslations(collection, group) {
+	const path = computed(() => `/_hollware/translations/${encodeURIComponent(toValue(collection))}/${encodeURIComponent(toValue(group))}`);
+	return useFetch(path);
+}
+/** The site: its locales, its collections and their schemas. */
+function useHollwareSite() {
+	return useFetch("/_hollware/site");
+}
+//#endregion
+export { useHollwareEntries, useHollwareEntry, useHollwareSite, useHollwareTranslations };

package/dist/runtime/generator.d.mts

@@ -0,0 +1,4 @@
+//#region src/runtime/generator.d.ts
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+//#endregion
+export { _default as default };

package/dist/runtime/generator.mjs

@@ -0,0 +1,10 @@
+import { defineNuxtPlugin, useHead } from "nuxt/app";
+//#region src/runtime/generator.ts
+var generator_default = defineNuxtPlugin(() => {
+	useHead({ meta: [{
+		name: "generator",
+		content: "Hollware"
+	}] });
+});
+//#endregion
+export { generator_default as default };

package/dist/runtime/server/answer.d.mts

@@ -0,0 +1,16 @@
+import { H3Event } from "h3";
+//#region src/runtime/server/answer.d.ts
+/**
+ * Hollware's answer as the site's own: a `not_found` outcome is a 404, a refusal of the read API
+ * keeps its status, and the rest is the answer. Pages revalidate it: it is published content, and
+ * a publication purges nothing on the site's side.
+ */
+export declare function answer<Value extends {
+  outcome: string;
+}>(event: H3Event, read: () => Promise<Value>): Promise<Value>;
+/**
+ * An entry for a page: its verdict, its revision and its last publication stay on the server, as
+ * the page sends what it read to the browser in its payload.
+ */
+export declare function forPage(entry: unknown): Record<string, unknown> | undefined;
+//#endregion

package/dist/runtime/server/answer.mjs

@@ -0,0 +1,49 @@
+import { HollwareClientError } from "@hollware/client";
+import { createError, setResponseHeader } from "h3";
+//#region src/runtime/server/answer.ts
+/**
+* Hollware's answer as the site's own: a `not_found` outcome is a 404, a refusal of the read API
+* keeps its status, and the rest is the answer. Pages revalidate it: it is published content, and
+* a publication purges nothing on the site's side.
+*/
+async function answer(event, read) {
+	let value;
+	try {
+		value = await read();
+	} catch (error) {
+		if (error instanceof HollwareClientError) throw createError({
+			statusCode: error.status,
+			statusMessage: error.message
+		});
+		throw error;
+	}
+	if (value.outcome === "not_found") throw createError({
+		statusCode: 404,
+		statusMessage: "Not found in Hollware"
+	});
+	setResponseHeader(event, "cache-control", "no-cache");
+	return value;
+}
+/** The fields of an entry that a page shows: what a reader sees, and not how it was checked. */
+const PUBLIC_FIELDS = [
+	"id",
+	"collection",
+	"locale",
+	"slug",
+	"translationGroup",
+	"frontmatter",
+	"tags",
+	"publishedAt",
+	"updatedAt",
+	"document"
+];
+/**
+* An entry for a page: its verdict, its revision and its last publication stay on the server, as
+* the page sends what it read to the browser in its payload.
+*/
+function forPage(entry) {
+	if (typeof entry !== "object" || entry === null) return void 0;
+	return Object.fromEntries(PUBLIC_FIELDS.filter((field) => field in entry).map((field) => [field, Reflect.get(entry, field)]));
+}
+//#endregion
+export { answer, forPage };

package/dist/runtime/server/reader.d.mts

@@ -0,0 +1,13 @@
+import { HollwareReader } from "@hollware/client";
+import { H3Event } from "h3";
+//#region src/runtime/server/reader.d.ts
+/**
+ * The site's reader of Hollware for a request: the service binding when the Worker has it, else
+ * HTTP with the URL and the read token of the config. A site with neither gets a 500 that says
+ * which to set.
+ */
+export declare function useHollware(event: H3Event): {
+  site: string;
+  reader: HollwareReader;
+};
+//#endregion

package/dist/runtime/server/reader.mjs

@@ -0,0 +1,34 @@
+import { createClient } from "@hollware/client";
+import { createError } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+//#region src/runtime/server/reader.ts
+function isReader(value) {
+	return typeof value === "object" && value !== null && "getEntry" in value;
+}
+/**
+* The site's reader of Hollware for a request: the service binding when the Worker has it, else
+* HTTP with the URL and the read token of the config. A site with neither gets a 500 that says
+* which to set.
+*/
+function useHollware(event) {
+	const config = useRuntimeConfig(event)["hollware"];
+	const env = event.context["cloudflare"]?.env;
+	const binding = typeof env === "object" && env !== null ? Reflect.get(env, config.binding) : void 0;
+	if (isReader(binding)) return {
+		site: config.site,
+		reader: createClient({ binding })
+	};
+	if (config.url !== "" && config.token !== "") return {
+		site: config.site,
+		reader: createClient({
+			url: config.url,
+			token: config.token
+		})
+	};
+	throw createError({
+		statusCode: 500,
+		statusMessage: `Hollware: the Worker has no binding ${config.binding}, and hollware.url with a read token (NUXT_HOLLWARE_TOKEN) is not set.`
+	});
+}
+//#endregion
+export { useHollware };

package/dist/runtime/server/routes/entries.d.mts

@@ -0,0 +1,8 @@
+//#region src/runtime/server/routes/entries.d.ts
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+  outcome: "ok";
+  entries: (Record<string, unknown> | undefined)[];
+  nextCursor: string | null;
+}>>;
+//#endregion
+export { _default as default };

package/dist/runtime/server/routes/entries.mjs

@@ -0,0 +1,29 @@
+import { answer, forPage } from "../answer.mjs";
+import { useHollware } from "../reader.mjs";
+import { defineEventHandler, getQuery, getRouterParam } from "h3";
+//#region src/runtime/server/routes/entries.ts
+const text = (value) => typeof value === "string" && value !== "" ? value : void 0;
+var entries_default = defineEventHandler(async (event) => {
+	const { site, reader } = useHollware(event);
+	const query = getQuery(event);
+	const [locale, tag, cursor, limit] = [
+		"locale",
+		"tag",
+		"cursor",
+		"limit"
+	].map((key) => text(query[key]));
+	const options = {
+		...locale === void 0 ? {} : { locale },
+		...tag === void 0 ? {} : { tag },
+		...cursor === void 0 ? {} : { cursor },
+		...limit === void 0 ? {} : { limit: Number(limit) }
+	};
+	const page = await answer(event, () => reader.listEntries(site, getRouterParam(event, "collection") ?? "", options));
+	return {
+		outcome: page.outcome,
+		entries: page.entries.map(forPage),
+		nextCursor: page.nextCursor
+	};
+});
+//#endregion
+export { entries_default as default };

package/dist/runtime/server/routes/entry.d.mts

@@ -0,0 +1,7 @@
+//#region src/runtime/server/routes/entry.d.ts
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+  outcome: "not_found" | "ok";
+  entry: Record<string, unknown> | undefined;
+}>>;
+//#endregion
+export { _default as default };

package/dist/runtime/server/routes/entry.mjs

@@ -0,0 +1,15 @@
+import { answer, forPage } from "../answer.mjs";
+import { useHollware } from "../reader.mjs";
+import { defineEventHandler, getRouterParam } from "h3";
+//#region src/runtime/server/routes/entry.ts
+var entry_default = defineEventHandler(async (event) => {
+	const { site, reader } = useHollware(event);
+	const param = (name) => getRouterParam(event, name) ?? "";
+	const found = await answer(event, () => reader.getEntry(site, param("collection"), param("slug"), param("locale"), { formats: ["document"] }));
+	return {
+		outcome: found.outcome,
+		entry: forPage(found.entry)
+	};
+});
+//#endregion
+export { entry_default as default };

package/dist/runtime/server/routes/site.d.mts

@@ -0,0 +1,34 @@
+//#region src/runtime/server/routes/site.d.ts
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+  outcome: "ok";
+  site: {
+    key: string;
+    locales: string[];
+    defaultLocale: string;
+    styleGuide: string | null;
+    collections: {
+      name: string;
+      schema: Record<string, unknown>;
+      routes: Record<string, string>;
+      translationGroupField: string | null;
+      tagsField: string | null;
+      sortByField: string | null;
+      components: {
+        name: string;
+        description: string | null;
+        example: string | null;
+        props: Record<string, unknown>;
+      }[];
+      contracts: {
+        id: string;
+        severity: "error" | "warning";
+        phases: ("publish" | "write")[];
+        description: string;
+      }[];
+      maxMarkdownBytes: number;
+      styleGuide: string | null;
+    }[];
+  };
+}>>;
+//#endregion
+export { _default as default };

package/dist/runtime/server/routes/site.mjs

@@ -0,0 +1,10 @@
+import { answer } from "../answer.mjs";
+import { useHollware } from "../reader.mjs";
+import { defineEventHandler } from "h3";
+//#region src/runtime/server/routes/site.ts
+var site_default = defineEventHandler((event) => {
+	const { site, reader } = useHollware(event);
+	return answer(event, () => reader.describeSite(site));
+});
+//#endregion
+export { site_default as default };

package/dist/runtime/server/routes/translations.d.mts

@@ -0,0 +1,7 @@
+//#region src/runtime/server/routes/translations.d.ts
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+  outcome: "not_found" | "ok";
+  entries: (Record<string, unknown> | undefined)[];
+}>>;
+//#endregion
+export { _default as default };

package/dist/runtime/server/routes/translations.mjs

@@ -0,0 +1,14 @@
+import { answer, forPage } from "../answer.mjs";
+import { useHollware } from "../reader.mjs";
+import { defineEventHandler, getRouterParam } from "h3";
+//#region src/runtime/server/routes/translations.ts
+var translations_default = defineEventHandler(async (event) => {
+	const { site, reader } = useHollware(event);
+	const group = await answer(event, () => reader.getTranslations(site, getRouterParam(event, "collection") ?? "", getRouterParam(event, "group") ?? ""));
+	return {
+		outcome: group.outcome,
+		entries: (group.entries ?? []).map(forPage)
+	};
+});
+//#endregion
+export { translations_default as default };

package/dist/runtime/types.d.mts

@@ -0,0 +1,16 @@
+//#region src/runtime/types.d.ts
+/** An entry as a page of the site gets it: what a reader sees, and how to render it. */
+export interface PageEntry {
+  readonly id: string;
+  readonly collection: string;
+  readonly locale: string;
+  readonly slug: string;
+  readonly translationGroup: string | null;
+  readonly frontmatter: Record<string, unknown>;
+  readonly tags: readonly string[];
+  readonly publishedAt: string | null;
+  readonly updatedAt: string;
+  /** The Comark document of the entry: only an entry read alone has it. */
+  readonly document?: unknown;
+}
+//#endregion

package/dist/runtime/types.mjs

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,12 +1,59 @@
 {
   "name": "@hollware/nuxt",
-  "version": "0.0.0",
-  "description": "Read Hollware from a Nuxt site. Placeholder: the first release is 0.4.0.",
+  "version": "0.5.0",
+  "description": "Read Hollware from a Nuxt site, over a service binding or HTTP.",
   "homepage": "https://hollware.com",
+  "bugs": {
+    "url": "https://github.com/hollware/hollware/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/hollware/hollware.git",
     "directory": "packages/nuxt"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@comark/vue": "0.7.0",
+    "@hollware/client": "0.5.0",
+    "@nuxt/kit": "4.6.1"
+  },
+  "devDependencies": {
+    "@types/node": "24.19.2",
+    "h3": "1.15.11",
+    "nitropack": "2.13.4",
+    "nuxt": "4.6.1",
+    "publint": "0.3.25",
+    "typescript": "7.0.2",
+    "vite-plus": "1.1.0",
+    "vue": "3.5.44"
+  },
+  "peerDependencies": {
+    "h3": "^1.15.0",
+    "nitropack": "^2.13.0",
+    "nuxt": "^4.6.0",
+    "vue": "^3.5.0"
+  },
+  "engines": {
+    "node": ">=24.11.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "test": "vp test",
+    "publint": "publint --strict"
   }
-}
+}