@riebeckite/honox 0.0.22 → 0.0.23

package/dist/server.js

@@ -54,10 +54,11 @@ async function pluginPageSsgParams(content, parameter = "slug") {
   return paths.filter((path) => path !== "/").map((path) => ({ [parameter]: path.replace(/^\/+/, "") }));
 }
 async function riebeckiteSsgParams(content, parameter = "slug") {
-  const [manifest, changeSet] = await Promise.all([
-    content.getManifest({ incremental: true }),
-    content.getOutputChangeSet({ incremental: true })
-  ]);
+  const changeSet = await content.getOutputChangeSet({ incremental: true });
+  if (process.env.RIEBECKITE_SSG_SKIP_UNCHANGED === "1" && !changeSet.fullRegenerationRequired && changeSet.affected.length === 0) {
+    return [];
+  }
+  const manifest = await content.getManifest({ incremental: true });
   if (changeSet.fullRegenerationRequired || process.env.RIEBECKITE_SSG_FULL_REGENERATION === "1") {
     return [
       ...manifest.publicEntries.filter((entry) => entry.permalink !== "/").map((entry) => ({ [parameter]: entry.permalink.replace(/^\/+/, "") })),
@@ -68,7 +69,7 @@ async function riebeckiteSsgParams(content, parameter = "slug") {
   const affected = new Set(
     changeSet.affected.filter((output) => output.kind !== "generated").map((output) => output.path)
   );
-  const contentParams = manifest.publicEntries.filter((entry) => affected.has(routeOutputPath(entry.permalink))).map((entry) => ({ [parameter]: entry.permalink.replace(/^\/+/, "") }));
+  const contentParams = manifest.publicEntries.filter((entry) => affected.has(routeOutputPath(entry.permalink))).filter((entry) => entry.permalink !== "/").map((entry) => ({ [parameter]: entry.permalink.replace(/^\/+/, "") }));
   const redirectParams = [...manifest.publicRedirects.keys()].filter((path) => affected.has(routeOutputPath(path))).filter((path) => path !== "/").map((path) => ({ [parameter]: path.replace(/^\/+/, "") }));
   const pluginPageParams = (await content.getPagePaths()).filter((path) => affected.has(routeOutputPath(path))).filter((path) => path !== "/").map((path) => ({ [parameter]: path.replace(/^\/+/, "") }));
   return [...contentParams, ...redirectParams, ...pluginPageParams];

package/dist/src/site_externals.d.ts

@@ -0,0 +1 @@
+export declare function siteRiebeckiteExternals(siteRoot: string): string[];

package/dist/src/ssg_plugin.d.ts

@@ -2,14 +2,30 @@ import { toSSG } from "hono/ssg";
 import { type ConfigEnv, type Plugin } from "vite";
 type ToSsgOptions = NonNullable<Parameters<typeof toSSG>[2]>;
 type OutputCacheEntry = {
-    source: string;
-    encoding: "utf8" | "base64";
+    cachePath: string;
+    checksum: string;
 };
 type OutputCacheState = {
-    version: 1;
+    version: 4;
     appFingerprint?: string;
+    clientManifestFingerprint?: string;
     outputs: Record<string, OutputCacheEntry>;
+    finalOutputInventory?: Record<string, string>;
+    publicDirectory?: string;
+    publicFingerprint?: string;
+    configFile?: string;
 };
+export type NoChangeFastPathResult = {
+    readonly used: boolean;
+    readonly blockReason?: string;
+};
+export type NoChangeFastPathOutputMetrics = {
+    outputInventoryValidationDurationMs: number;
+    outputHashValidationDurationMs: number;
+    outputFilesHashed: number;
+    outputBytesHashed: number;
+};
+export declare function createNoChangeFastPathOutputMetrics(): NoChangeFastPathOutputMetrics;
 export type RiebeckiteSsgOptions = {
     entry?: string;
     plugins?: ToSsgOptions["plugins"];
@@ -18,8 +34,14 @@ export type RiebeckiteSsgOptions = {
 export declare function riebeckiteSsg(options?: RiebeckiteSsgOptions): Plugin;
 export declare function shouldApplyRiebeckiteSsg(_config: unknown, env: ConfigEnv): boolean;
 export declare function findBuildOutputSiteCollisions(buildOutputPaths: Iterable<string>, siteOwnedOutputPaths: ReadonlySet<string>): readonly string[];
+export declare function verifyNoChangeFastPath(input: {
+    readonly root: string;
+    readonly outputDirectory: string;
+    readonly expectedOutputPaths: readonly string[];
+    readonly metrics?: NoChangeFastPathOutputMetrics;
+}): Promise<NoChangeFastPathResult>;
 export declare function loadOutputCache(path: string, timingsMs?: Record<string, number>, log?: (message: string) => void): Promise<(OutputCacheState & {
     fileSizeBytes?: number;
 }) | undefined>;
-export declare function saveOutputCache(path: string, state: OutputCacheState, timingsMs?: Record<string, number>): Promise<void>;
+export declare function saveOutputCache(path: string, state: OutputCacheState, outputDirectory: string, timingsMs?: Record<string, number>): Promise<string>;
 export {};

package/dist/src/ui/primitives.d.ts

@@ -1,4 +1,4 @@
-import type { ContentBodySlot, ContentBodySlots, PluginHeadTag, ResolvedRiebeckiteConfig } from "@riebeckite/core";
+import type { PluginHeadTag, ResolvedRiebeckiteConfig } from "@riebeckite/core";
 export type PrimitiveChildren = unknown;
 export type PrimitiveProps = {
     children?: PrimitiveChildren;
@@ -41,24 +41,12 @@ export declare function ArticleContent(props: ArticleContentProps): import("hono
 export type ArticleBodyProps = PrimitiveClassProps & {
     html: string;
 };
-export type ContentSlotProps = PrimitiveClassProps & {
-    slots?: ContentBodySlots;
-    name: ContentBodySlot;
+export type HtmlFragmentSource = "markdown" | "plugin-page";
+export type HtmlFragmentProps = {
+    html: string;
+    source: HtmlFragmentSource;
 };
-/**
- * Whether a body slot holds renderable content.
- *
- * A slot is absent when its source map is missing, the value is missing, or
- * the value is whitespace-only. This is the same check `ContentSlot` uses.
- */
-export declare function hasSlot(slots: ContentBodySlots | undefined, name: ContentBodySlot): boolean;
-/**
- * Renders a Plugin-provided body slot fragment at the position the Site chose.
- *
- * The Site owns placement; this primitive owns the lookup, empty handling, and
- * HTML injection. It renders nothing when the slot is absent or blank.
- */
-export declare function ContentSlot(props: ContentSlotProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;
+export declare function HtmlFragment(props: HtmlFragmentProps): import("hono/utils/html").HtmlEscapedString;
 /**
  * Renders Markdown-produced HTML as the canonical article body.
  *

package/dist/src/ui/primitives.js

@@ -1,5 +1,6 @@
 // src/ui/primitives.tsx
 import { ColorModeScript } from "@riebeckite/plugin-color-mode";
+import { raw } from "hono/html";
 import { Link, Script } from "honox/server";
 import { Fragment, jsx, jsxs } from "hono/jsx/jsx-runtime";
 import { createElement } from "hono/jsx";
@@ -58,22 +59,8 @@ function ArticleContent(props) {
   const dataSlot = props["data-slot"] ?? "article-body";
   return /* @__PURE__ */ jsx("div", { class: className, "data-slot": dataSlot, children: props.children });
 }
-function hasSlot(slots, name) {
-  return Boolean(slots?.[name]?.trim());
-}
-function ContentSlot(props) {
-  const html = props.slots?.[props.name];
-  if (!html?.trim()) {
-    return null;
-  }
-  return /* @__PURE__ */ jsx(
-    "div",
-    {
-      "data-slot": props.name,
-      class: joinClassNames(props.class, props.className) || void 0,
-      dangerouslySetInnerHTML: { __html: html }
-    }
-  );
+function HtmlFragment(props) {
+  return raw(props.html);
 }
 function ArticleBody(props) {
   return /* @__PURE__ */ jsx(
@@ -172,12 +159,11 @@ export {
   ArticleHeader,
   ArticleLayout,
   ArticleMeta,
-  ContentSlot,
+  HtmlFragment,
   PageBody,
   PluginHeadTags,
   RiebeckiteHead,
   Sidebar,
   ThemeRoot,
-  hasSlot,
   themeRootAttributes
 };

package/dist/src/vite_plugin.d.ts

@@ -1,5 +1,6 @@
 import type { Plugin } from "vite";
 import type { RiebeckiteSsgOptions } from "./ssg_plugin.js";
+import { type ResolvedHonoxApplication } from "./vite_runner.js";
 export type RiebeckiteIntegrationOptions = {
     configRoot?: string;
     workspaceRoot?: string;
@@ -18,7 +19,7 @@ export type RiebeckiteViteOptions = RiebeckiteIntegrationOptions & {
     /** SSG overrides. A normal site does not need them. */
     ssg?: RiebeckiteSsgOptions;
 };
-export declare function riebeckite(options?: RiebeckiteIntegrationOptions): Plugin[];
+export declare function riebeckite(options?: RiebeckiteIntegrationOptions, onApplicationResolved?: (application: ResolvedHonoxApplication) => void): Plugin[];
 /**
  * Higher-level helper that registers the complete Riebeckite Vite integration
  * without exposing internal Vite/HonoX/SSR details. A site only needs to add

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/honox",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -38,12 +38,12 @@
     "hono": "^4.12.25",
     "honox": "0.1.56",
     "vite": "^8.0.9",
-    "@riebeckite/plugin-color-mode": "0.0.22",
-    "@riebeckite/core": "0.0.22"
+    "@riebeckite/plugin-color-mode": "0.0.23",
+    "@riebeckite/core": "0.0.23"
   },
   "devDependencies": {
     "tsx": "^4.22.4",
-    "@riebeckite/test": "0.0.22"
+    "@riebeckite/test": "0.0.23"
   },
   "publishConfig": {
     "access": "public"