@riebeckite/core 0.0.30 → 0.0.32

package/dist/client.d.ts

@@ -1,2 +1,4 @@
+export type { ClientCleanup, ClientInitializer, ClientInitializerContext, ClientLifecycleErrorContext, ClientLifecycleMount, ClientLifecycleOptions, ClientLifecycleScope, ClientResourceScope, } from "./src/client_lifecycle.js";
+export { ClientLifecycle } from "./src/client_lifecycle.js";
 export type { ForceGraphLayoutOptions, ForceLayoutGuardOptions, GraphEdge, GraphLayoutNode, LinkableGraphNode, RadialGraphLayoutOptions, } from "./src/content/graph_layout.js";
 export { buildGraphEdges, FORCE_LAYOUT_CONFIRM_NODE_COUNT, layoutForceGraph, layoutRadialGraph, shouldGuardForceLayout, } from "./src/content/graph_layout.js";

package/dist/client.js

@@ -1,3 +1,179 @@
+// src/client_lifecycle.ts
+var ClientLifecycle = class {
+  mounted = /* @__PURE__ */ new Map();
+  scopes = /* @__PURE__ */ new Map();
+  onError;
+  constructor(options = {}) {
+    this.onError = options.onError ?? defaultErrorReporter;
+  }
+  mount(mount) {
+    const scoped = this.scoped(mount.scope);
+    const current = scoped.get(mount.name);
+    if (current) {
+      if (current.root === mount.root) return current.ready;
+      throw new Error(
+        `Client initializer "${mount.name}" is already mounted in ${mount.scope} scope.`
+      );
+    }
+    const scope = this.scopeState(mount.scope);
+    const resources = new InitializerResources(
+      scope.controller,
+      (error) => this.report(error, {
+        scope: mount.scope,
+        name: mount.name,
+        phase: "cleanup"
+      })
+    );
+    const cleanup = this.initialize(mount, resources);
+    const ready = cleanup.then(() => void 0);
+    const mounted = { root: mount.root, resources, cleanup, ready };
+    scoped.set(mount.name, mounted);
+    return ready;
+  }
+  async unmount(scope) {
+    const scoped = this.mounted.get(scope);
+    const state = this.scopes.get(scope);
+    this.mounted.delete(scope);
+    this.scopes.delete(scope);
+    state?.controller.abort();
+    if (!scoped) return;
+    await Promise.all(
+      [...scoped.entries()].map(
+        ([name, mounted]) => this.cleanupMounted(scope, name, mounted)
+      )
+    );
+  }
+  async dispose() {
+    await Promise.all([this.unmount("page"), this.unmount("app")]);
+  }
+  scoped(scope) {
+    let scoped = this.mounted.get(scope);
+    if (!scoped) {
+      scoped = /* @__PURE__ */ new Map();
+      this.mounted.set(scope, scoped);
+    }
+    return scoped;
+  }
+  scopeState(scope) {
+    let state = this.scopes.get(scope);
+    if (!state) {
+      state = { controller: new AbortController() };
+      this.scopes.set(scope, state);
+    }
+    return state;
+  }
+  async initialize(mount, resources) {
+    try {
+      const result = await mount.initialize({
+        root: mount.root,
+        signal: resources.signal,
+        scope: resources,
+        config: mount.config
+      });
+      return typeof result === "function" ? result : void 0;
+    } catch (error) {
+      await resources.dispose();
+      this.report(error, {
+        scope: mount.scope,
+        name: mount.name,
+        phase: "initialize"
+      });
+      return void 0;
+    }
+  }
+  async cleanupMounted(scope, name, mounted) {
+    const [cleanup] = await Promise.all([
+      mounted.cleanup,
+      mounted.resources.dispose()
+    ]);
+    try {
+      await cleanup?.();
+    } catch (error) {
+      this.report(error, { scope, name, phase: "cleanup" });
+    }
+  }
+  report(error, context) {
+    try {
+      this.onError(error, context);
+    } catch {
+      return;
+    }
+  }
+};
+var InitializerResources = class {
+  constructor(controller, report) {
+    this.controller = controller;
+    this.report = report;
+  }
+  controller;
+  report;
+  cleanups = [];
+  listeners = [];
+  timers = /* @__PURE__ */ new Set();
+  intervals = /* @__PURE__ */ new Set();
+  disposed = false;
+  get signal() {
+    return this.controller.signal;
+  }
+  on(target, type, listener, options) {
+    if (this.disposed || this.signal.aborted) return;
+    target.addEventListener(type, listener, {
+      ...options,
+      signal: this.signal
+    });
+    this.listeners.push({ target, type, listener, options });
+  }
+  timeout(callback, delay = 0) {
+    if (this.disposed || this.signal.aborted) return;
+    const timer = setTimeout(() => {
+      this.timers.delete(timer);
+      if (!this.disposed && !this.signal.aborted) callback();
+    }, delay);
+    this.timers.add(timer);
+  }
+  interval(callback, delay = 0) {
+    if (this.disposed || this.signal.aborted) return;
+    const interval = setInterval(() => {
+      if (!this.disposed && !this.signal.aborted) callback();
+    }, delay);
+    this.intervals.add(interval);
+  }
+  cleanup(cleanup) {
+    if (this.disposed) {
+      void this.run(cleanup);
+      return;
+    }
+    this.cleanups.push(cleanup);
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const { target, type, listener, options } of this.listeners) {
+      target.removeEventListener(type, listener, options);
+    }
+    this.listeners.length = 0;
+    for (const timer of this.timers) clearTimeout(timer);
+    for (const interval of this.intervals) clearInterval(interval);
+    this.timers.clear();
+    this.intervals.clear();
+    const cleanups = this.cleanups.splice(0).reverse();
+    await Promise.all(cleanups.map((cleanup) => this.run(cleanup)));
+  }
+  async run(cleanup) {
+    try {
+      await cleanup();
+    } catch (error) {
+      this.report(error);
+    }
+  }
+};
+function defaultErrorReporter(error, context) {
+  console.error(
+    `[riebeckite] Client initializer ${context.phase} failed: ${context.name}`,
+    error
+  );
+}
+
 // src/content/graph_layout.ts
 var FORCE_LAYOUT_CONFIRM_NODE_COUNT = 500;
 function shouldGuardForceLayout(options) {
@@ -176,6 +352,7 @@ function clampFinite(value, min, max) {
   return clamp(value, min, max);
 }
 export {
+  ClientLifecycle,
   FORCE_LAYOUT_CONFIRM_NODE_COUNT,
   buildGraphEdges,
   layoutForceGraph,

package/dist/index.d.ts

@@ -47,6 +47,7 @@ export { PluginDependencyError, type PluginDependencyErrorKind, } from "./src/pl
 export { PluginHookError } from "./src/plugin/plugin_lifecycle.js";
 export type { CreatePluginMemoOptions, PluginMemo, } from "./src/plugin/plugin_memo.js";
 export { createPluginMemo, stableStringify, } from "./src/plugin/plugin_memo.js";
+export { PluginRuntime } from "./src/plugin/plugin_runtime.js";
 export { resolveBuildOutputDirectory, resolveManagedStateRoot, } from "./src/project/project_layout.js";
 export type { ConfigValidationIssue, PluginOptionsValidator, } from "./src/types/config_validation.js";
 export type { ContentAsset, ContentFileMetadata, ContentLink, ContentLinkKind, ContentLocationInput, ContentManifest, ContentManifestEntry, ContentManifestPluginClientEntry, ContentPublicLocation, ContentRedirect, FolderLocation, PluginPageRoute, } from "./src/types/content_manifest.js";
@@ -73,7 +74,7 @@ export type { PostContent, PostFrontmatter } from "./src/types/post_content.js";
 export type { PublishFrontmatter, PublishStrategy, } from "./src/types/publish_strategy.js";
 export { isPublishable } from "./src/types/publish_strategy.js";
 export type { ResolvedRiebeckiteConfig } from "./src/types/resolved_riebeckite_config.js";
-export type { RiebeckiteConfig } from "./src/types/riebeckite_config.js";
+export type { RiebeckiteConfig, SpaConfig, } from "./src/types/riebeckite_config.js";
 export type { SiteConfig } from "./src/types/site_config.js";
 export type { RiebeckiteTheme, ThemeArticleLayoutPreset, ThemeAttributes, ThemeColorMode, ThemeConfig, ThemeDesignTokens, ThemeInput, ThemeStyle, ThemeTypographyPreset, } from "./src/types/theme_config.js";
 export { defineTheme } from "./src/types/theme_config.js";

package/dist/index.js

@@ -20,6 +20,7 @@ function validateConfigIssues(config) {
   validateSite(value.site, issues);
   validateContent(value.content, issues);
   validateCache(value.cache, issues);
+  validateSpa(value.spa, issues);
   validateTheme(value.theme, issues);
   validatePlugins(value.plugins, issues);
   return issues;
@@ -103,6 +104,12 @@ function validateCache(value, issues) {
   validateOptionalBoolean(value.enabled, "cache.enabled", issues);
   validateOptionalString(value.directory, "cache.directory", issues);
 }
+function validateSpa(value, issues) {
+  if (value === void 0 || typeof value === "boolean" || isRecord(value)) {
+    return;
+  }
+  issues.push({ path: "spa", message: "Expected a boolean or an object." });
+}
 function validateTheme(value, issues) {
   if (value === void 0) return;
   if (!isRecord(value)) {
@@ -680,6 +687,7 @@ function isConfigModuleWrapper(value) {
 function resolveConfig(config) {
   validateConfig(config);
   const theme = resolveThemeConfig(config.theme);
+  const spa = resolveSpaConfig(config.spa);
   return {
     site: {
       title: config.site?.title ?? "",
@@ -708,9 +716,14 @@ function resolveConfig(config) {
     cache: {
       enabled: config.cache?.enabled ?? true,
       directory: config.cache?.directory ?? ""
-    }
+    },
+    ...spa === void 0 ? {} : { spa }
   };
 }
+function resolveSpaConfig(spa) {
+  if (spa === void 0 || spa === false) return void 0;
+  return spa === true ? {} : spa;
+}
 function resolveThemeConfig(themeInput) {
   const theme = themeInput ? isRiebeckiteTheme(themeInput) ? { name: themeInput.name, ...themeInput.config } : themeInput : void 0;
   const styles = themeInput ? isRiebeckiteTheme(themeInput) ? themeInput.styles ?? [] : [defaultThemeStyle] : [defaultThemeStyle];
@@ -826,7 +839,7 @@ function getFileName(filePath) {
 }
 
 // src/content/content_build_state.ts
-var CONTENT_BUILD_STATE_VERSION = 19;
+var CONTENT_BUILD_STATE_VERSION = 20;
 var CONTENT_BUILD_STATE_DIRECTORY = ".riebeckite";
 var CONTENT_BUILD_STATE_EXCLUDE = `${CONTENT_BUILD_STATE_DIRECTORY}/**`;
 
@@ -834,8 +847,11 @@ var CONTENT_BUILD_STATE_EXCLUDE = `${CONTENT_BUILD_STATE_DIRECTORY}/**`;
 import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+var MAX_CONTENT_BUILD_STATE_BYTES = 64 * 1024 * 1024;
 async function loadContentBuildState(statePath) {
   try {
+    const metadata = await fs.stat(statePath);
+    if (metadata.size > MAX_CONTENT_BUILD_STATE_BYTES) return void 0;
     const parsed = JSON.parse(await fs.readFile(statePath, "utf8"));
     return isContentBuildState(parsed) ? parsed : void 0;
   } catch {
@@ -922,7 +938,7 @@ function isContentBuildStateShape(value) {
 }
 function isManifestHookCache(value) {
   return Array.isArray(value) && value.every(
-    (entry) => isRecord2(entry) && typeof entry.pluginName === "string" && typeof entry.cacheable === "boolean" && (entry.pipelineFingerprint === void 0 || typeof entry.pipelineFingerprint === "string") && typeof entry.inputFingerprint === "string" && (entry.outputFingerprint === void 0 || typeof entry.outputFingerprint === "string") && (entry.snapshot === void 0 || isManifestHookSnapshot(entry.snapshot))
+    (entry) => isRecord2(entry) && typeof entry.pluginName === "string" && typeof entry.cacheVersion === "string" && typeof entry.cacheable === "boolean" && (entry.pipelineFingerprint === void 0 || typeof entry.pipelineFingerprint === "string") && typeof entry.inputFingerprint === "string" && (entry.outputFingerprint === void 0 || typeof entry.outputFingerprint === "string") && (entry.snapshot === void 0 || isManifestHookSnapshot(entry.snapshot))
   );
 }
 function isManifestHookSnapshot(value) {
@@ -2516,6 +2532,34 @@ function rejectInternalRiebeckitePath(normalized, input) {
 }
 
 // src/pipeline.ts
+function isPluginTable(node) {
+  const className = node.properties?.className;
+  const names = Array.isArray(className) ? className : [className];
+  return names.some(
+    (name) => typeof name === "string" && (name.startsWith("rb-") || name.startsWith("rr-"))
+  );
+}
+function wrapMarkdownTables() {
+  return (tree) => {
+    wrapTableChildren(tree);
+  };
+}
+function wrapTableChildren(parent) {
+  if (!parent.children) return;
+  parent.children = parent.children.map((child) => {
+    const node = child;
+    if (node.type === "element" && node.tagName === "table" && !isPluginTable(node)) {
+      return {
+        type: "element",
+        tagName: "div",
+        properties: { className: ["rb-table-scroll"] },
+        children: [child]
+      };
+    }
+    wrapTableChildren(node);
+    return child;
+  });
+}
 var Pipeline = class {
   constructor(contentIndex, permalinks, getMarkdownBySlug, options = {}, isBuildTime = false) {
     this.contentIndex = contentIndex;
@@ -2691,6 +2735,7 @@ var Pipeline = class {
         }
       });
     }
+    this.use(processor, wrapMarkdownTables);
     this.use(processor, rehypeSlug);
     this.use(processor, rehypeKatex, { output: "mathml", strict: false });
     this.use(processor, rehypeFormat);
@@ -2900,12 +2945,14 @@ function createStyleAsset(pluginName, moduleSpecifier) {
     moduleSpecifier
   };
 }
-function createClientEntry(pluginName, moduleSpecifier, exportName, publicConfig) {
+function createClientEntry(pluginName, moduleSpecifier, exportName, publicConfig, scope, initializerArguments) {
   return {
     pluginName,
     moduleSpecifier,
     ...exportName === void 0 ? {} : { exportName },
-    ...publicConfig === void 0 ? {} : { publicConfig }
+    ...publicConfig === void 0 ? {} : { publicConfig },
+    ...scope === void 0 ? {} : { scope },
+    ...initializerArguments === void 0 ? {} : { initializerArguments }
   };
 }
 function serializePublicClientConfig(value) {
@@ -2991,16 +3038,18 @@ function serializeManifestEntries(entries) {
     serialized.set(entry.slug, JSON.stringify(entry));
   return serialized;
 }
-function createManifestHookCacheEntry(pluginName, cacheable, pipelineFingerprint, inputFingerprint, manifest, beforeEntries, afterEntries) {
+function createManifestHookCacheEntry(pluginName, cacheVersion, cacheable, pipelineFingerprint, inputFingerprint, manifest, beforeEntries, afterEntries) {
   if (!cacheable)
     return {
       pluginName,
+      cacheVersion,
       cacheable,
       pipelineFingerprint,
       inputFingerprint
     };
   return {
     pluginName,
+    cacheVersion,
     cacheable,
     pipelineFingerprint,
     inputFingerprint,
@@ -3282,9 +3331,10 @@ var ManifestHookRunner = class {
       if (plugin.buildEnd) return "plugin-build-end";
       if (plugin.planGeneratedOutputs) return "plugin-generated-output-plan";
       if (!plugin.onManifestCreated) continue;
+      if (!plugin.manifestHookCache) return "manifest-hook-cache-disabled";
       const cached = previousCache[cacheIndex];
       cacheIndex += 1;
-      if (cached?.pluginName !== plugin.name || !cached.cacheable || cached.pipelineFingerprint !== pipelineFingerprint)
+      if (cached?.pluginName !== plugin.name || cached.cacheVersion !== plugin.manifestHookCache.version || !cached.cacheable || cached.pipelineFingerprint !== pipelineFingerprint)
         return "manifest-hook-cache-miss";
     }
     return void 0;
@@ -3298,10 +3348,14 @@ var ManifestHookRunner = class {
       manifest
     };
     let cacheIndex = 0;
-    let entriesBeforeHook = serializeManifestEntries(manifest.entries);
     for (const plugin of this.options.plugins()) {
       const hook = plugin.onManifestCreated;
       if (!hook) continue;
+      const cacheVersion = plugin.manifestHookCache?.version;
+      if (!cacheVersion) {
+        await this.runManifestHook(plugin, hook, context, "cache-disabled");
+        continue;
+      }
       const inputFingerprint = fingerprintManifestHookInput(manifest);
       const cached = previousCache[cacheIndex];
       cacheIndex += 1;
@@ -3313,46 +3367,29 @@ var ManifestHookRunner = class {
       );
       let restored = false;
       let restorePoint;
-      if (cached !== void 0 && cached.pluginName === plugin.name && cached.cacheable && cached.pipelineFingerprint === pipelineFingerprint && cached.inputFingerprint === inputFingerprint && cached.snapshot !== void 0 && cached.outputFingerprint !== void 0) {
+      if (cached !== void 0 && cached.pluginName === plugin.name && cached.cacheVersion === cacheVersion && cached.cacheable && cached.pipelineFingerprint === pipelineFingerprint && cached.inputFingerprint === inputFingerprint && cached.snapshot !== void 0 && cached.outputFingerprint !== void 0) {
         restorePoint = captureManifestHookRestorePoint(manifest);
         restored = applyManifestHookSnapshot(manifest, cached.snapshot);
         if (restored && fingerprintManifestHookSnapshot(manifest) === cached.outputFingerprint) {
           this.manifestHooksReused += 1;
           this.manifestHookCache.push(cached);
           this.recordManifestHookMetric(plugin.name, "reused", "cache-hit", 0);
-          entriesBeforeHook = serializeManifestEntries(manifest.entries);
           continue;
         }
       }
       if (restored && restorePoint)
         restoreManifestHookEntries(manifest, restorePoint);
+      const entriesBeforeHook = serializeManifestEntries(manifest.entries);
       const sideEffectsBefore = fingerprintManifestHookSideEffects(manifest);
       const outputCountBefore = this.options.generatedOutputCount();
       const diagnosticCountBefore = this.options.diagnosticCount();
       const manifestDiagnosticCountBefore = manifest.diagnostics.length;
-      const started = performance.now();
-      this.manifestHooksExecuted += 1;
-      try {
-        await runPluginHook(
-          plugin,
-          "onManifestCreated",
-          this.options.createPluginContext(plugin, context),
-          hook
-        );
-      } finally {
-        const durationMs = performance.now() - started;
-        this.manifestHookDurationMs += durationMs;
-        this.recordManifestHookMetric(
-          plugin.name,
-          "executed",
-          reason,
-          durationMs
-        );
-      }
+      await this.runManifestHook(plugin, hook, context, reason);
       const entriesAfterHook = serializeManifestEntries(manifest.entries);
       this.manifestHookCache.push(
         createManifestHookCacheEntry(
           plugin.name,
+          cacheVersion,
           plugin.resolveExternalDependencies === void 0 && sideEffectsBefore === fingerprintManifestHookSideEffects(manifest) && outputCountBefore === this.options.generatedOutputCount() && diagnosticCountBefore === this.options.diagnosticCount() && manifestDiagnosticCountBefore === manifest.diagnostics.length,
           pipelineFingerprint,
           inputFingerprint,
@@ -3361,7 +3398,27 @@ var ManifestHookRunner = class {
           entriesAfterHook
         )
       );
-      entriesBeforeHook = entriesAfterHook;
+    }
+  }
+  async runManifestHook(plugin, hook, context, reason) {
+    const started = performance.now();
+    this.manifestHooksExecuted += 1;
+    try {
+      await runPluginHook(
+        plugin,
+        "onManifestCreated",
+        this.options.createPluginContext(plugin, context),
+        hook
+      );
+    } finally {
+      const durationMs = performance.now() - started;
+      this.manifestHookDurationMs += durationMs;
+      this.recordManifestHookMetric(
+        plugin.name,
+        "executed",
+        reason,
+        durationMs
+      );
     }
   }
   recordManifestHookMetric(pluginName, outcome, reason, durationMs) {
@@ -3410,7 +3467,8 @@ var PluginPageResolver = class {
         const context = {
           ...this.options.createContext(contentIndex),
           manifest,
-          pathname: pagePathname
+          pathname: pagePathname,
+          renderMarkdown: this.options.renderMarkdown
         };
         const page = await pageType.resolve(
           this.options.createPluginContext(plugin, context)
@@ -3465,7 +3523,8 @@ var PluginPageResolver = class {
           const context = {
             ...this.options.createContext(contentIndex),
             manifest,
-            pathname
+            pathname,
+            renderMarkdown: this.options.renderMarkdown
           };
           const dependencies = pageType.outputDependencies ? typeof pageType.outputDependencies === "function" ? await pageType.outputDependencies(
             this.options.createPluginContext(plugin, context)
@@ -3605,7 +3664,13 @@ var PluginRuntime = class {
     this.pageResolver = new PluginPageResolver({
       plugins: () => this.plugins(),
       createContext: (contentIndex) => this.createContext(contentIndex),
-      createPluginContext: (plugin, context) => this.createPluginContext(plugin, context)
+      createPluginContext: (plugin, context) => this.createPluginContext(plugin, context),
+      renderMarkdown: async (markdown) => {
+        if (!this.pageMarkdownRenderer) {
+          throw new Error("Plugin page Markdown renderer is unavailable.");
+        }
+        return await this.pageMarkdownRenderer(markdown);
+      }
     });
     this.manifestHooks = new ManifestHookRunner({
       plugins: () => this.plugins(),
@@ -3628,9 +3693,13 @@ var PluginRuntime = class {
   externalDependenciesResolved = false;
   pageResolver;
   manifestHooks;
+  pageMarkdownRenderer = null;
   getDiagnostics() {
     return this.diagnostics;
   }
+  setPageMarkdownRenderer(renderer) {
+    this.pageMarkdownRenderer = renderer;
+  }
   getManifestHookMetrics() {
     return this.manifestHooks.getMetrics();
   }
@@ -5628,6 +5697,12 @@ var ContentManager = class {
     this.contentIndexBuilder = new ContentIndexBuilder(this.source);
     this.manifestAssembler = new ManifestAssembler(this.contentCache);
     this.pluginRuntime = new PluginRuntime(this.pipelineOptions);
+    this.pluginRuntime.setPageMarkdownRenderer(async (markdown) => {
+      if (!this.pipeline) {
+        throw new Error("Markdown pipeline is unavailable for plugin pages.");
+      }
+      return (await this.pipeline.execute(markdown)).html;
+    });
     const buildStatePath = resolveContentBuildStatePath(
       pipelineOptions.config,
       typeof content === "string" ? content : void 0
@@ -6026,7 +6101,7 @@ var ContentManager = class {
   /** Resolves a page contributed by an enabled plugin. */
   async resolvePage(pathname) {
     const [manifest, contentIndex] = await Promise.all([
-      this.getManifest(),
+      this.getManifest({ incremental: false }),
       this.getContentIndex()
     ]);
     return await this.pluginRuntime.resolvePage(
@@ -6089,7 +6164,7 @@ var ContentManager = class {
   }
   requestBuildStateCommit(options) {
     if (this.pipelineOptions.commitBuildState === false) return;
-    if (options?.incremental === true) this.buildStateCommitRequested = true;
+    if (options?.incremental !== false) this.buildStateCommitRequested = true;
   }
   async commitBuildState() {
     if (this.buildStateCommitted || !this.buildStateCommitRequested || !this.manifest || !this.outputChangeSet) {
@@ -6834,6 +6909,7 @@ export {
   Pipeline,
   PluginDependencyError,
   PluginHookError,
+  PluginRuntime,
   SinkTracer,
   attachErrorPath,
   attachmentUrl,

package/dist/src/client_lifecycle.d.ts

@@ -0,0 +1,45 @@
+export type ClientLifecycleScope = "app" | "page";
+export type ClientCleanup = () => void | Promise<void>;
+export type ClientResourceScope = {
+    readonly signal: AbortSignal;
+    on(target: EventTarget, type: string, listener: EventListenerOrEventListenerObject, options?: Omit<AddEventListenerOptions, "signal">): void;
+    timeout(callback: () => void, delay?: number): void;
+    interval(callback: () => void, delay?: number): void;
+    cleanup(cleanup: ClientCleanup): void;
+};
+export type ClientInitializerContext<TRoot, TConfig> = {
+    root: TRoot;
+    signal: AbortSignal;
+    scope: ClientResourceScope;
+    config: TConfig;
+};
+export type ClientInitializer<TRoot, TConfig> = (context: ClientInitializerContext<TRoot, TConfig>) => undefined | ClientCleanup | Promise<undefined | ClientCleanup>;
+export type ClientLifecycleErrorContext = {
+    scope: ClientLifecycleScope;
+    name: string;
+    phase: "initialize" | "cleanup";
+};
+export type ClientLifecycleOptions = {
+    onError?: (error: unknown, context: ClientLifecycleErrorContext) => void;
+};
+export type ClientLifecycleMount<TRoot, TConfig> = {
+    scope: ClientLifecycleScope;
+    name: string;
+    root: TRoot;
+    config: TConfig;
+    initialize: ClientInitializer<TRoot, TConfig>;
+};
+export declare class ClientLifecycle<TRoot> {
+    private readonly mounted;
+    private readonly scopes;
+    private readonly onError;
+    constructor(options?: ClientLifecycleOptions);
+    mount<TConfig>(mount: ClientLifecycleMount<TRoot, TConfig>): Promise<void>;
+    unmount(scope: ClientLifecycleScope): Promise<void>;
+    dispose(): Promise<void>;
+    private scoped;
+    private scopeState;
+    private initialize;
+    private cleanupMounted;
+    private report;
+}

package/dist/src/content/content_build_state.d.ts

@@ -1,7 +1,7 @@
 import type { ContentManifestEntry } from "../types/content_manifest.js";
 import type { ContentSourceEntry } from "./content_source.js";
 import type { OutputDescriptor } from "./output_dependency.js";
-export declare const CONTENT_BUILD_STATE_VERSION = 19;
+export declare const CONTENT_BUILD_STATE_VERSION = 20;
 /**
  * Build state lives under `<content directory>/.riebeckite`. That directory is
  * build-time state, not content, so content sources must exclude it from scans
@@ -33,6 +33,7 @@ export type ContentBuildState = {
 };
 export type ManifestHookCacheEntry = {
     readonly pluginName: string;
+    readonly cacheVersion: string;
     readonly cacheable: boolean;
     readonly pipelineFingerprint: string | undefined;
     readonly inputFingerprint: string;

package/dist/src/content/manifest_hook_cache.d.ts

@@ -2,7 +2,7 @@ import type { ContentManifest, ContentManifestEntry } from "../types/content_man
 import type { ManifestHookCacheEntry, ManifestHookSnapshot } from "./content_build_state.js";
 export declare function fingerprintManifestHookInput(manifest: ContentManifest): string;
 export declare function serializeManifestEntries(entries: readonly ContentManifestEntry[]): Map<string, string>;
-export declare function createManifestHookCacheEntry(pluginName: string, cacheable: boolean, pipelineFingerprint: string | undefined, inputFingerprint: string, manifest: ContentManifest, beforeEntries: ReadonlyMap<string, string>, afterEntries: ReadonlyMap<string, string>): ManifestHookCacheEntry;
+export declare function createManifestHookCacheEntry(pluginName: string, cacheVersion: string, cacheable: boolean, pipelineFingerprint: string | undefined, inputFingerprint: string, manifest: ContentManifest, beforeEntries: ReadonlyMap<string, string>, afterEntries: ReadonlyMap<string, string>): ManifestHookCacheEntry;
 export declare function fingerprintManifestHookSideEffects(manifest: ContentManifest): string;
 export declare function fingerprintManifestHookSnapshot(manifest: ContentManifest): string;
 export type ManifestHookRestorePoint = {

package/dist/src/plugin/manifest_hooks.d.ts

@@ -37,6 +37,7 @@ export declare class ManifestHookRunner {
     getNoChangeFastPathBlockReason(previousCache: readonly ManifestHookCacheEntry[], pipelineFingerprint: string | undefined): string | undefined;
     getCache(): readonly ManifestHookCacheEntry[];
     runManifestCreated(manifest: ContentManifest, contentIndex: Map<string, string>, previousCache: readonly ManifestHookCacheEntry[], pipelineFingerprint: string | undefined): Promise<void>;
+    private runManifestHook;
     private recordManifestHookMetric;
 }
 export {};

package/dist/src/plugin/plugin_pages.d.ts

@@ -7,6 +7,7 @@ type PluginPageResolverOptions = {
     readonly plugins: () => readonly RiebeckitePlugin[];
     readonly createContext: (contentIndex: Map<string, string>) => PluginContextBase;
     readonly createPluginContext: <TContext extends PluginContextBase>(plugin: RiebeckitePlugin, context: TContext) => PluginContextWithCache<TContext>;
+    readonly renderMarkdown: (markdown: string) => Promise<string>;
 };
 export declare class PluginPageResolver {
     private readonly options;

package/dist/src/plugin/plugin_runtime.d.ts

@@ -25,8 +25,10 @@ export declare class PluginRuntime {
     private externalDependenciesResolved;
     private readonly pageResolver;
     private readonly manifestHooks;
+    private pageMarkdownRenderer;
     constructor(pipelineOptions?: PipelineOptions);
     getDiagnostics(): Diagnostic[];
+    setPageMarkdownRenderer(renderer: (markdown: string) => Promise<string>): void;
     getManifestHookMetrics(): ManifestHookMetrics;
     getNoChangeFastPathBlockReason(previousCache: readonly ManifestHookCacheEntry[], pipelineFingerprint: string | undefined): string | undefined;
     getManifestHookCache(): readonly ManifestHookCacheEntry[];

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

@@ -23,13 +23,6 @@ export type ContentAsset = {
 export type ContentManifestPluginAsset = PluginAsset & {
     path: string;
 };
-/**
- * The standard `article.*` positions the article consumer recognizes.
- *
- * These constants are a convenience for Sites that prefer named references;
- * writing the slot string inline (for example `name="article.metadata"`) stays
- * the recommended, most readable form in TSX layouts.
- */
 /** Client entries and their explicitly public configuration. */
 export type ContentManifestPluginClientEntry = PluginClientEntry;
 export type ContentManifestEntry = {

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

@@ -74,6 +74,9 @@ export type RiebeckitePlugin<TOptions = unknown> = {
     extendContentLocations?(context: PluginContentLocationAugmentContext): void | Promise<void>;
     onPostParsed?(context: PluginPostContext): void | Promise<void>;
     onPostProcessed?(context: PluginPostContext): void | Promise<void>;
+    manifestHookCache?: {
+        version: string;
+    };
     onManifestCreated?(context: PluginManifestContext): void | Promise<void>;
     extendMarkdownPipeline?(pipeline: MarkdownPipeline, context: MarkdownPipelineContext): void;
     extendHtmlPipeline?(pipeline: HtmlPipeline): void;

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

@@ -1,3 +1,4 @@
+import type { ClientLifecycleScope } from "../client_lifecycle.js";
 import type { JsonValue } from "./json_value.js";
 export type PluginAssetKind = "style" | "script";
 export type PluginAsset = {
@@ -9,6 +10,8 @@ export type PluginClientEntry<TPublicConfig extends JsonValue = JsonValue> = {
     pluginName: string;
     moduleSpecifier: string;
     exportName?: string;
+    scope?: ClientLifecycleScope;
+    initializerArguments?: ClientInitializerArguments;
     /**
      * Configuration intentionally made available to this browser entry.
      *
@@ -18,8 +21,9 @@ export type PluginClientEntry<TPublicConfig extends JsonValue = JsonValue> = {
      */
     publicConfig?: TPublicConfig;
 };
+export type ClientInitializerArguments = "config" | "root" | "context";
 export declare function createStyleAsset(pluginName: string, moduleSpecifier: string): PluginAsset;
-export declare function createClientEntry<TPublicConfig extends JsonValue>(pluginName: string, moduleSpecifier: string, exportName?: string, publicConfig?: TPublicConfig): PluginClientEntry<TPublicConfig>;
+export declare function createClientEntry<TPublicConfig extends JsonValue>(pluginName: string, moduleSpecifier: string, exportName?: string, publicConfig?: TPublicConfig, scope?: ClientLifecycleScope, initializerArguments?: ClientInitializerArguments): PluginClientEntry<TPublicConfig>;
 /**
  * Serializes explicitly registered client configuration for code generation.
  * Rejecting non-JSON values prevents generated client modules from silently

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

@@ -59,6 +59,7 @@ export type PluginRenderTarget = {
     label: string;
     url: string;
     embed: boolean;
+    fragment?: string;
 };
 export type PluginRenderContext = PluginContext & PluginRenderTarget;
 export type PluginContentRenderer = {
@@ -72,6 +73,7 @@ export type PluginRenderInput = {
     label: string;
     url: string;
     embed: boolean;
+    fragment?: string;
 };
 export type PluginGeneratedHtml = {
     /** Output-relative path of the generated HTML file (e.g. "index.html"). */

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

@@ -36,6 +36,8 @@ export type PluginEndpoint = {
     path: string;
     /** Defaults to `GET` when omitted. */
     method?: PluginEndpointMethod;
+    /** Defaults to `true`; set to `false` for endpoints that only use configuration. */
+    requiresManifest?: boolean;
     handler(context: PluginEndpointContext): PluginEndpointResponse | Promise<PluginEndpointResponse>;
 };
 export type PluginEndpointOptions = {

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

@@ -26,6 +26,7 @@ export type PluginPageContext = PluginContext & {
     manifest: ContentManifest;
     /** Request pathname, normalized to an absolute path. */
     pathname: string;
+    renderMarkdown(markdown: string): Promise<string>;
 };
 export type PluginPageType = {
     /** Globally unique, stable page type identifier. */

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

@@ -1,6 +1,7 @@
 import type { ContentSource } from "../content/content_source.js";
 import type { RiebeckitePlugin } from "./plugin.js";
 import type { PublishStrategy } from "./publish_strategy.js";
+import type { SpaConfig } from "./riebeckite_config.js";
 import type { SiteConfig } from "./site_config.js";
 import type { ThemeConfig, ThemeStyle } from "./theme_config.js";
 export type ResolvedRiebeckiteConfig = {
@@ -38,4 +39,5 @@ export type ResolvedRiebeckiteConfig = {
         enabled: boolean;
         directory: string;
     };
+    spa?: SpaConfig;
 };

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

@@ -3,6 +3,11 @@ import type { PluginInput } from "./plugin.js";
 import type { PublishStrategy } from "./publish_strategy.js";
 import type { SiteConfig } from "./site_config.js";
 import type { ThemeInput } from "./theme_config.js";
+export type SpaConfig = {
+    prefetch?: false | "hover";
+    scrollRestoration?: boolean;
+    viewTransitions?: boolean;
+};
 export interface RiebeckiteConfig {
     site: SiteConfig;
     content?: {
@@ -19,4 +24,5 @@ export interface RiebeckiteConfig {
         enabled?: boolean;
         directory?: string;
     };
+    spa?: boolean | SpaConfig;
 }

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

@@ -7,6 +7,9 @@ export type ThemeDesignTokens = {
         ink?: string;
         muted?: string;
         accent?: string;
+        link?: string;
+        focus?: string;
+        selected?: string;
         border?: string;
         borderStrong?: string;
         surface?: string;
@@ -15,6 +18,8 @@ export type ThemeDesignTokens = {
         danger?: string;
         success?: string;
         codeBackground?: string;
+        codeInk?: string;
+        codeInline?: string;
     };
     typography?: {
         bodyFont?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/core",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
   },
   "devDependencies": {
     "tsx": "^4.22.4",
-    "@riebeckite/test": "0.0.30"
+    "@riebeckite/test": "0.0.32"
   },
   "repository": {
     "type": "git",