@riebeckite/honox 0.0.29 → 0.0.30

package/dist/index.js

@@ -284,6 +284,7 @@ function isJavaScriptModule(filePath) {
 // src/ssg_plugin.ts
 import { rm as rm3 } from "node:fs/promises";
 import { join as join4, relative as relative3, resolve as resolve2 } from "node:path";
+import { buildOutputPlan, compareOutputPlan } from "@riebeckite/core";
 import { defaultExtensionMap, redirectPlugin, toSSG } from "hono/ssg";
 import {
   createServer
@@ -728,6 +729,33 @@ async function discardClientBuildArtifacts(artifacts) {
   if (!artifacts) return;
   await rm(artifacts.stagingDirectory, { recursive: true, force: true });
 }
+async function collectBuildOutputPaths(directory, relativeDirectory = "") {
+  const entries = await readdir(directory, { withFileTypes: true }).catch(
+    (error) => {
+      if (isMissingDirectoryError(error)) return void 0;
+      throw error;
+    }
+  );
+  if (!entries) return [];
+  const paths = [];
+  for (const entry of entries) {
+    const relativePath = join(relativeDirectory, entry.name).replaceAll(
+      "\\",
+      "/"
+    );
+    if (entry.isDirectory()) {
+      paths.push(
+        ...await collectBuildOutputPaths(
+          join(directory, entry.name),
+          relativePath
+        )
+      );
+    } else if (entry.isFile()) {
+      paths.push(relativePath);
+    }
+  }
+  return paths.sort();
+}
 function collectClientAssetPaths(manifestSource) {
   let manifest;
   try {
@@ -1503,6 +1531,7 @@ function riebeckiteSsg(options = {}) {
       }
       const timingsMs = process.env.RIEBECKITE_SSG_METRICS_FILE ? {} : void 0;
       const outDir = resolve2(config.root, config.build.outDir);
+      let viteClientAssetPaths = [];
       removeVirtualEntryChunk(bundle, resolvedVirtualId);
       const server = await measure(
         timingsMs,
@@ -1525,6 +1554,7 @@ function riebeckiteSsg(options = {}) {
       );
       try {
         await restoreClientBuildArtifacts(outDir, clientBuildArtifacts);
+        viteClientAssetPaths = await collectBuildOutputPaths(outDir);
         logSsgDiagnostics(
           this,
           `SSR noExternal=${formatSsrNoExternal()} · client manifest ${clientBuildArtifacts ? "restored" : "not found"}`
@@ -1563,6 +1593,9 @@ function riebeckiteSsg(options = {}) {
           "siteOwnedOutputs",
           () => collectSiteOwnedOutputPaths(config.publicDir)
         );
+        viteClientAssetPaths = [
+          .../* @__PURE__ */ new Set([...viteClientAssetPaths, ...Object.keys(bundle)])
+        ].filter((outputPath) => !siteOwnedOutputPaths.has(outputPath)).sort();
         const siteOutputCollisions = findBuildOutputSiteCollisions(
           Object.keys(bundle),
           siteOwnedOutputPaths
@@ -1588,6 +1621,12 @@ function riebeckiteSsg(options = {}) {
         const reusablePaths = new Set(
           canUseIncremental ? (outputChangeSet?.unchanged ?? []).map((output) => output.path) : []
         );
+        const inventory = [
+          ...outputChangeSet?.affected ?? [],
+          ...outputChangeSet?.unchanged ?? []
+        ];
+        const inventoryPaths = new Set(inventory.map((output) => output.path));
+        const honoStaticRoutePaths = /* @__PURE__ */ new Set();
         logSsgDiagnostics(
           this,
           `output cache ${canUseIncremental ? "hit" : `miss (${outputCacheRejectionReason})`} · ${reusablePaths.size} reusable outputs`
@@ -1631,6 +1670,19 @@ function riebeckiteSsg(options = {}) {
           manifestHookCacheMiss: 0,
           manifestHookDurationMs: 0,
           manifestHookPlugins: {},
+          plannedOutputCount: 0,
+          actualOutputCount: 0,
+          matchedOutputCount: 0,
+          missingInPlanCount: 0,
+          missingInDistCount: 0,
+          unknownOutputCount: 0,
+          ownerConflictCount: 0,
+          publicationViolationCount: 0,
+          plannedGenerateOutputCount: 0,
+          plannedReuseOutputCount: 0,
+          plannedRemoveOutputCount: 0,
+          plannedUnknownOutputCount: 0,
+          outputPlanMemoryDeltaBytes: 0,
           outputCacheDecision,
           outputCacheRejectionReason: outputCacheRejectionReason ?? null,
           timingsMs: timingsMs ?? {}
@@ -1648,6 +1700,9 @@ function riebeckiteSsg(options = {}) {
                   "\\",
                   "/"
                 );
+                if (!inventoryPaths.has(fileName)) {
+                  honoStaticRoutePaths.add(fileName);
+                }
                 if (siteOwnedOutputPaths.has(fileName)) {
                   shadowedOutputs.add(fileName);
                   return;
@@ -1775,7 +1830,18 @@ function riebeckiteSsg(options = {}) {
           timingsMs,
           outDir,
           publicDir: config.publicDir,
-          configFile: config.configFile
+          configFile: config.configFile,
+          outputPlanInput: {
+            inventory,
+            affectedPaths: new Set(
+              (outputChangeSet?.affected ?? []).map((output) => output.path)
+            ),
+            removed: outputChangeSet?.removed ?? [],
+            cacheAvailable: canUseIncremental,
+            honoStaticRoutePaths,
+            viteClientAssetPaths: new Set(viteClientAssetPaths),
+            sitePublicAssetPaths: siteOwnedOutputPaths
+          }
         };
         this.info(
           `SSG outputs: ${metrics.renderedOutputCount} rendered · ${metrics.reusedOutputCount} reused · ${metrics.deletedOutputCount} removed`
@@ -1813,6 +1879,44 @@ function riebeckiteSsg(options = {}) {
             "outputInventory",
             () => fingerprintOutputDirectory(outputCache.outDir)
           );
+          const finalOutputInventory = outputCache.state.finalOutputInventory;
+          const outputPlanRssBefore = process.memoryUsage().rss;
+          const outputPlan = measureSync(
+            outputCache.timingsMs,
+            "outputPlan",
+            () => buildOutputPlan({
+              ...outputCache.outputPlanInput
+            })
+          );
+          const outputPlanComparison = measureSync(
+            outputCache.timingsMs,
+            "outputPlanComparison",
+            () => compareOutputPlan(outputPlan, Object.keys(finalOutputInventory))
+          );
+          outputCache.metrics.plannedOutputCount = outputPlan.entries.length;
+          outputCache.metrics.actualOutputCount = Object.keys(finalOutputInventory).length;
+          outputCache.metrics.matchedOutputCount = outputPlanComparison.matched.length;
+          outputCache.metrics.missingInPlanCount = outputPlanComparison.missingInPlan.length;
+          outputCache.metrics.missingInDistCount = outputPlanComparison.missingInDist.length;
+          outputCache.metrics.unknownOutputCount = outputPlanComparison.unknown.length;
+          outputCache.metrics.ownerConflictCount = outputPlanComparison.ownerConflicts.length;
+          outputCache.metrics.publicationViolationCount = outputPlanComparison.publicationViolations.length;
+          outputCache.metrics.plannedGenerateOutputCount = outputPlan.entries.filter(
+            (entry2) => entry2.action === "generate"
+          ).length;
+          outputCache.metrics.plannedReuseOutputCount = outputPlan.entries.filter(
+            (entry2) => entry2.action === "reuse"
+          ).length;
+          outputCache.metrics.plannedRemoveOutputCount = outputPlan.entries.filter(
+            (entry2) => entry2.action === "remove"
+          ).length;
+          outputCache.metrics.plannedUnknownOutputCount = outputPlan.entries.filter(
+            (entry2) => entry2.action === "unknown"
+          ).length;
+          outputCache.metrics.outputPlanMemoryDeltaBytes = Math.max(
+            0,
+            process.memoryUsage().rss - outputPlanRssBefore
+          );
           const publicDir = outputCache.publicDir;
           outputCache.state.publicDirectory = publicDir ? resolve2(publicDir) : void 0;
           outputCache.state.publicFingerprint = publicDir ? await measure(
@@ -2081,8 +2185,21 @@ async function findWorkspaceRoot(configRoot) {
 async function startHonoxDevServer(options) {
   const root = path9.resolve(options.root);
   await withWorkingDirectory(root, async () => {
-    const server = await createServer2({ root });
-    await server.listen();
+    const server = await createServer2({ root, server: options.server });
+    const restartFiles = new Set(
+      options.restartOnChange?.map((file) => path9.resolve(file))
+    );
+    if (restartFiles.size > 0) {
+      server.watcher.add([...restartFiles]);
+      server.watcher.on("change", (file) => {
+        if (restartFiles.has(path9.resolve(file))) void server.restart();
+      });
+    }
+    await server.listen(options.server?.port);
+    options.onServerReady?.([
+      ...server.resolvedUrls?.local ?? [],
+      ...server.resolvedUrls?.network ?? []
+    ]);
     server.printUrls();
     await waitForShutdown(server);
   });

package/dist/src/ssg/build_output.d.ts

@@ -13,3 +13,4 @@ export declare function emptyBuildOutputDirectory(outDir: string): Promise<void>
 export declare function preserveClientBuildArtifacts(outDir: string): Promise<ClientBuildArtifacts | undefined>;
 export declare function restoreClientBuildArtifacts(outDir: string, artifacts: ClientBuildArtifacts | undefined): Promise<void>;
 export declare function discardClientBuildArtifacts(artifacts: ClientBuildArtifacts | undefined): Promise<void>;
+export declare function collectBuildOutputPaths(directory: string, relativeDirectory?: string): Promise<string[]>;

package/dist/src/ssg/types.d.ts

@@ -1,3 +1,4 @@
+import type { OutputDescriptor } from "@riebeckite/core";
 import type { toSSG } from "hono/ssg";
 export type GeneratedOutputAsset = {
     type: "asset";
@@ -44,18 +45,9 @@ export type SsgModule = {
             }>;
         };
         getOutputChangeSet(): Promise<{
-            affected: readonly {
-                kind: string;
-                path: string;
-            }[];
-            removed: readonly {
-                kind: string;
-                path: string;
-            }[];
-            unchanged: readonly {
-                kind: string;
-                path: string;
-            }[];
+            affected: readonly OutputDescriptor[];
+            removed: readonly OutputDescriptor[];
+            unchanged: readonly OutputDescriptor[];
             fullRegenerationRequired: boolean;
             candidateOutputCount: number;
             affectedOutputCount: number;
@@ -97,6 +89,19 @@ export type SsgOutputMetrics = {
     manifestHookCacheMiss: number;
     manifestHookDurationMs: number;
     manifestHookPlugins: Record<string, unknown>;
+    plannedOutputCount: number;
+    actualOutputCount: number;
+    matchedOutputCount: number;
+    missingInPlanCount: number;
+    missingInDistCount: number;
+    unknownOutputCount: number;
+    ownerConflictCount: number;
+    publicationViolationCount: number;
+    plannedGenerateOutputCount: number;
+    plannedReuseOutputCount: number;
+    plannedRemoveOutputCount: number;
+    plannedUnknownOutputCount: number;
+    outputPlanMemoryDeltaBytes: number;
     outputCacheDecision: OutputCacheDecision;
     outputCacheRejectionReason: OutputCacheRejectionReason | null;
     timingsMs: Record<string, number>;

package/dist/src/vite_runner.d.ts

@@ -3,6 +3,13 @@ import { type RiebeckiteConfigLoaderOptions } from "./config_loader.js";
 export type HonoxApplicationOptions = {
     root: string;
     tracer?: Tracer;
+    server?: {
+        host?: string;
+        open?: boolean;
+        port?: number;
+    };
+    onServerReady?: (urls: readonly string[]) => void;
+    restartOnChange?: readonly string[];
 };
 export type ResolvedHonoxApplication = {
     config: ResolvedRiebeckiteConfig;

package/package.json

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