@riebeckite/core 0.0.1

package/dist/index.js

@@ -0,0 +1,3040 @@
+// src/config_validation.ts
+var ConfigValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(formatValidationIssues(issues));
+    this.name = "ConfigValidationError";
+    this.issues = issues;
+  }
+};
+function validateConfig(config) {
+  const issues = validateConfigIssues(config);
+  if (issues.length > 0) throw new ConfigValidationError(issues);
+}
+function validateConfigIssues(config) {
+  const issues = [];
+  const value = config;
+  if (!isRecord(value)) {
+    return [{ path: "config", message: "Expected an object." }];
+  }
+  validateSite(value.site, issues);
+  validateContent(value.content, issues);
+  validateTheme(value.theme, issues);
+  validatePlugins(value.plugins, issues);
+  return issues;
+}
+function validateSite(value, issues) {
+  if (!isRecord(value)) {
+    issues.push({ path: "site", message: "Expected an object." });
+    return;
+  }
+  validateRequiredString(value.title, "site.title", issues);
+  validateOptionalString(value.description, "site.description", issues);
+  validateOptionalString(value.author, "site.author", issues);
+  validateOptionalString(value.locale, "site.locale", issues);
+  validateOptionalString(value.twitterSite, "site.twitterSite", issues);
+  validateOptionalString(value.defaultOgImage, "site.defaultOgImage", issues);
+  validateAbsoluteUrl(value.baseUrl, "site.baseUrl", issues);
+  validateFeed(value.feed, issues);
+}
+function validateFeed(value, issues) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    issues.push({ path: "site.feed", message: "Expected an object." });
+    return;
+  }
+  validateOptionalString(value.title, "site.feed.title", issues);
+  validateOptionalString(value.description, "site.feed.description", issues);
+  validateOptionalString(value.language, "site.feed.language", issues);
+}
+function validateContent(value, issues) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    issues.push({ path: "content", message: "Expected an object." });
+    return;
+  }
+  validateOptionalString(value.directory, "content.directory", issues);
+  validateContentSource(value.source, issues);
+  validateStringArray(value.exclude, "content.exclude", issues);
+  validatePublishStrategy(value.filters, issues);
+}
+function validateContentSource(value, issues) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    issues.push({
+      path: "content.source",
+      message: "Expected a ContentSource."
+    });
+    return;
+  }
+  if (typeof value.scan !== "function") {
+    issues.push({
+      path: "content.source.scan",
+      message: "Expected a function."
+    });
+  }
+  if (typeof value.read !== "function") {
+    issues.push({
+      path: "content.source.read",
+      message: "Expected a function."
+    });
+  }
+}
+function validatePublishStrategy(value, issues) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    issues.push({ path: "content.filters", message: "Expected an object." });
+    return;
+  }
+  if (value.publishStrategy !== void 0 && value.publishStrategy !== "explicit" && value.publishStrategy !== "selective") {
+    issues.push({
+      path: "content.filters.publishStrategy",
+      message: 'Expected "explicit" or "selective".'
+    });
+  }
+}
+function validateTheme(value, issues) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    issues.push({ path: "theme", message: "Expected an object." });
+    return;
+  }
+  validateThemeConfig(value, "theme", issues);
+  validateThemeStyles(value.styles, "theme.styles", issues);
+  if (value.config !== void 0) {
+    if (!isRecord(value.config)) {
+      issues.push({ path: "theme.config", message: "Expected an object." });
+    } else {
+      validateThemeConfig(value.config, "theme.config", issues);
+    }
+  }
+}
+function validateThemeConfig(value, path4, issues) {
+  validateOptionalString(value.name, `${path4}.name`, issues);
+  validateOneOf(
+    value.colorMode,
+    `${path4}.colorMode`,
+    ["light", "dark", "system"],
+    issues
+  );
+  validateOneOf(
+    value.typography,
+    `${path4}.typography`,
+    ["system", "serif", "sans"],
+    issues
+  );
+  validateOneOf(
+    value.articleLayout,
+    `${path4}.articleLayout`,
+    ["article", "sidebar", "full-width"],
+    issues
+  );
+  validateStringArray(value.userCss, `${path4}.userCss`, issues);
+  if (value.attributes !== void 0 && !isRecord(value.attributes)) {
+    issues.push({ path: `${path4}.attributes`, message: "Expected an object." });
+  }
+}
+function validateThemeStyles(value, path4, issues) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) {
+    issues.push({ path: path4, message: "Expected an array." });
+    return;
+  }
+  for (const [index, style] of value.entries()) {
+    if (!isRecord(style) || !isNonEmptyString(style.moduleSpecifier)) {
+      issues.push({
+        path: `${path4}[${index}].moduleSpecifier`,
+        message: "Expected a non-empty string."
+      });
+    }
+  }
+}
+function validatePlugins(value, issues) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) {
+    issues.push({ path: "plugins", message: "Expected an array." });
+    return;
+  }
+  const names = /* @__PURE__ */ new Map();
+  for (const [index, input] of value.entries()) {
+    if (input === false || input === null || input === void 0) continue;
+    if (!isRecord(input)) {
+      issues.push({ path: `plugins[${index}]`, message: "Expected a plugin." });
+      continue;
+    }
+    const plugin = input;
+    const path4 = `plugins[${index}]`;
+    if (!isNonEmptyString(plugin.name)) {
+      issues.push({
+        path: `${path4}.name`,
+        message: "Expected a non-empty string."
+      });
+    } else if (plugin.enabled !== false) {
+      const duplicateIndex = names.get(plugin.name);
+      if (duplicateIndex !== void 0) {
+        issues.push({
+          path: `${path4}.name`,
+          message: `Duplicate plugin name "${plugin.name}" (also plugins[${duplicateIndex}]).`
+        });
+      } else {
+        names.set(plugin.name, index);
+      }
+    }
+    validateOptionalBoolean(plugin.enabled, `${path4}.enabled`, issues);
+    validateCapabilityMetadata(plugin, path4, issues);
+    if (plugin.enabled !== false) validatePluginOptions(plugin, path4, issues);
+  }
+}
+function validateCapabilityMetadata(plugin, path4, issues) {
+  validateStringArray(plugin.provides, `${path4}.provides`, issues, true);
+  validateStringArray(plugin.requires, `${path4}.requires`, issues, true);
+  validateStringArray(plugin.optional, `${path4}.optional`, issues, true);
+}
+function validatePluginOptions(plugin, path4, issues) {
+  if (!plugin.validateOptions) return;
+  try {
+    const optionIssues = plugin.validateOptions(plugin.options) ?? [];
+    for (const issue of optionIssues) {
+      issues.push({
+        path: issue.path ? `${path4}.options.${issue.path}` : `${path4}.options`,
+        message: issue.message
+      });
+    }
+  } catch (error) {
+    issues.push({
+      path: `${path4}.options`,
+      message: `Validator failed: ${toErrorMessage(error)}`
+    });
+  }
+}
+function validateRequiredString(value, path4, issues) {
+  if (!isNonEmptyString(value)) {
+    issues.push({ path: path4, message: "Expected a non-empty string." });
+  }
+}
+function validateOptionalString(value, path4, issues) {
+  if (value !== void 0 && typeof value !== "string") {
+    issues.push({ path: path4, message: "Expected a string." });
+  }
+}
+function validateOptionalBoolean(value, path4, issues) {
+  if (value !== void 0 && typeof value !== "boolean") {
+    issues.push({ path: path4, message: "Expected a boolean." });
+  }
+}
+function validateAbsoluteUrl(value, path4, issues) {
+  if (value === void 0 || value === "") return;
+  if (typeof value !== "string") {
+    issues.push({ path: path4, message: "Expected an absolute URL." });
+    return;
+  }
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      throw new Error();
+  } catch {
+    issues.push({ path: path4, message: "Expected an absolute HTTP(S) URL." });
+  }
+}
+function validateStringArray(value, path4, issues, nonEmpty = false) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) {
+    issues.push({ path: path4, message: "Expected an array." });
+    return;
+  }
+  for (const [index, item] of value.entries()) {
+    if (typeof item !== "string" || nonEmpty && !item.trim()) {
+      issues.push({
+        path: `${path4}[${index}]`,
+        message: nonEmpty ? "Expected a non-empty string." : "Expected a string."
+      });
+    }
+  }
+}
+function validateOneOf(value, path4, choices, issues) {
+  if (value !== void 0 && (typeof value !== "string" || !choices.includes(value))) {
+    issues.push({ path: path4, message: `Expected one of: ${choices.join(", ")}.` });
+  }
+}
+function formatValidationIssues(issues) {
+  return [
+    "Invalid Riebeckite configuration:",
+    ...issues.map((issue) => `
+${issue.path}
+  ${issue.message}`)
+  ].join("\n");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/plugin/plugin_dependency_error.ts
+var PluginDependencyError = class extends Error {
+  kind;
+  pluginName;
+  capability;
+  declaration;
+  pluginNames;
+  chain;
+  availableCapabilities;
+  constructor(input) {
+    super(createMessage(input));
+    this.name = "PluginDependencyError";
+    this.kind = input.kind;
+    this.pluginName = input.pluginName;
+    this.capability = input.capability;
+    this.declaration = input.declaration;
+    this.pluginNames = input.pluginNames ?? [];
+    this.chain = input.chain ?? [];
+    this.availableCapabilities = input.availableCapabilities ?? [];
+  }
+};
+function createMessage(input) {
+  if (input.kind === "missing-capability") {
+    return [
+      `Plugin "${input.pluginName}" requires missing capability "${input.capability}".`,
+      formatAvailableCapabilities(input.availableCapabilities)
+    ].join("\n");
+  }
+  if (input.kind === "self-dependency") {
+    return `Plugin "${input.pluginName}" requires capability "${input.capability}" that it also provides.`;
+  }
+  if (input.kind === "invalid-capability") {
+    return `Plugin "${input.pluginName}" declares an empty or invalid capability in "${input.declaration}".`;
+  }
+  if (input.kind === "duplicate-provider") {
+    return [
+      `Capability "${input.capability}" is provided by multiple plugins:`,
+      ...(input.pluginNames ?? []).map((name) => `- ${name}`),
+      "A capability must have exactly one provider."
+    ].join("\n");
+  }
+  return [
+    `Plugin dependency cycle detected for capability "${input.capability}":`,
+    (input.chain ?? []).join(" -> ")
+  ].join("\n");
+}
+function formatAvailableCapabilities(capabilities) {
+  if (!capabilities || capabilities.length === 0) {
+    return "No plugin declares a provided capability.";
+  }
+  return [
+    "Available capabilities:",
+    ...[...capabilities].sort().map((capability) => `- ${capability}`)
+  ].join("\n");
+}
+
+// src/plugin/plugin_dependency.ts
+function resolvePluginDependencies(plugins) {
+  validateCapabilityNames(plugins);
+  const providers = collectProviders(plugins);
+  const dependencies = collectDependencies(plugins, providers);
+  return stableTopologicalSort(plugins, dependencies);
+}
+var CAPABILITY_DECLARATIONS = [
+  "provides",
+  "requires",
+  "optional"
+];
+function validateCapabilityNames(plugins) {
+  for (const plugin of plugins) {
+    for (const declaration of CAPABILITY_DECLARATIONS) {
+      for (const capability of plugin[declaration] ?? []) {
+        if (capability.trim() === "") {
+          throw new PluginDependencyError({
+            kind: "invalid-capability",
+            pluginName: plugin.name,
+            declaration
+          });
+        }
+      }
+    }
+  }
+}
+function collectProviders(plugins) {
+  const providerIndices = /* @__PURE__ */ new Map();
+  for (const [index, plugin] of plugins.entries()) {
+    for (const capability of new Set((plugin.provides ?? []).map(normalize))) {
+      const indices = providerIndices.get(capability) ?? [];
+      indices.push(index);
+      providerIndices.set(capability, indices);
+    }
+  }
+  const providers = /* @__PURE__ */ new Map();
+  for (const [capability, indices] of providerIndices) {
+    if (indices.length > 1) {
+      throw new PluginDependencyError({
+        kind: "duplicate-provider",
+        capability,
+        pluginNames: indices.map((index) => plugins[index].name)
+      });
+    }
+    providers.set(capability, indices[0]);
+  }
+  return providers;
+}
+function collectDependencies(plugins, providers) {
+  const availableCapabilities = [...providers.keys()];
+  return plugins.map((plugin, pluginIndex) => {
+    const requiredDependencies = (plugin.requires ?? []).map((rawCapability) => {
+      const capability = normalize(rawCapability);
+      return resolveDependency({
+        pluginIndex,
+        pluginName: plugin.name,
+        capability,
+        availableCapabilities,
+        providers
+      });
+    });
+    const optionalDependencies = (plugin.optional ?? []).flatMap(
+      (rawCapability) => {
+        const capability = normalize(rawCapability);
+        const providerIndex = providers.get(capability);
+        if (providerIndex === void 0) return [];
+        assertNotSelfDependency({
+          pluginIndex,
+          pluginName: plugin.name,
+          capability,
+          providerIndex
+        });
+        return [{ providerIndex, capability }];
+      }
+    );
+    return [...requiredDependencies, ...optionalDependencies];
+  });
+}
+function resolveDependency(input) {
+  const providerIndex = input.providers.get(input.capability);
+  if (providerIndex === void 0) {
+    throw new PluginDependencyError({
+      kind: "missing-capability",
+      pluginName: input.pluginName,
+      capability: input.capability,
+      availableCapabilities: input.availableCapabilities
+    });
+  }
+  assertNotSelfDependency({
+    pluginIndex: input.pluginIndex,
+    pluginName: input.pluginName,
+    capability: input.capability,
+    providerIndex
+  });
+  return { providerIndex, capability: input.capability };
+}
+function assertNotSelfDependency(input) {
+  if (input.providerIndex !== input.pluginIndex) return;
+  throw new PluginDependencyError({
+    kind: "self-dependency",
+    pluginName: input.pluginName,
+    capability: input.capability
+  });
+}
+function normalize(capability) {
+  return capability.trim();
+}
+function stableTopologicalSort(plugins, dependencies) {
+  const dependents = plugins.map(() => /* @__PURE__ */ new Set());
+  const remainingDependencies = dependencies.map(
+    (pluginDependencies, index) => {
+      for (const dependency of pluginDependencies) {
+        dependents[dependency.providerIndex].add(index);
+      }
+      return new Set(
+        pluginDependencies.map((dependency) => dependency.providerIndex)
+      ).size;
+    }
+  );
+  const available = remainingDependencies.map((count, index) => count === 0 ? index : -1).filter((index) => index >= 0);
+  const resolved = [];
+  while (available.length > 0) {
+    const index = available.shift();
+    if (index === void 0) break;
+    resolved.push(plugins[index]);
+    for (const dependentIndex of dependents[index]) {
+      remainingDependencies[dependentIndex] -= 1;
+      if (remainingDependencies[dependentIndex] === 0) {
+        insertByOriginalOrder(available, dependentIndex);
+      }
+    }
+  }
+  if (resolved.length !== plugins.length) {
+    throw createCycleError(plugins, dependencies, remainingDependencies);
+  }
+  return resolved;
+}
+function insertByOriginalOrder(indices, index) {
+  const insertionIndex = indices.findIndex((current) => current > index);
+  if (insertionIndex === -1) {
+    indices.push(index);
+    return;
+  }
+  indices.splice(insertionIndex, 0, index);
+}
+function createCycleError(plugins, dependencies, remainingDependencies) {
+  const remaining = new Set(
+    remainingDependencies.map((count, index) => count > 0 ? index : -1).filter((index) => index >= 0)
+  );
+  const cycle = findCycle(dependencies, remaining);
+  const chain = cycle.indices.map((index) => plugins[index].name);
+  return new PluginDependencyError({
+    kind: "cycle",
+    capability: cycle.capability,
+    pluginNames: chain,
+    chain
+  });
+}
+function findCycle(dependencies, remaining) {
+  const visiting = [];
+  const visited = /* @__PURE__ */ new Set();
+  for (const index of remaining) {
+    const cycle = visitDependency(
+      index,
+      dependencies,
+      remaining,
+      visiting,
+      visited
+    );
+    if (cycle) return cycle;
+  }
+  throw new Error("Plugin dependency cycle could not be resolved.");
+}
+function visitDependency(index, dependencies, remaining, visiting, visited) {
+  if (visited.has(index)) return void 0;
+  visiting.push(index);
+  for (const dependency of dependencies[index]) {
+    if (!remaining.has(dependency.providerIndex)) continue;
+    const cycleStart = visiting.indexOf(dependency.providerIndex);
+    if (cycleStart >= 0) {
+      return {
+        indices: [...visiting.slice(cycleStart), dependency.providerIndex],
+        capability: dependency.capability
+      };
+    }
+    const cycle = visitDependency(
+      dependency.providerIndex,
+      dependencies,
+      remaining,
+      visiting,
+      visited
+    );
+    if (cycle) return cycle;
+  }
+  visiting.pop();
+  visited.add(index);
+  return void 0;
+}
+
+// src/types/plugin.ts
+function definePlugin(plugin) {
+  return plugin;
+}
+function resolvePlugins(plugins = []) {
+  const orderedPlugins = plugins.filter((plugin) => Boolean(plugin)).filter((plugin) => plugin.enabled !== false).toSorted((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  return resolvePluginDependencies(orderedPlugins);
+}
+function getResolvedPluginMetadata(plugins) {
+  return plugins.map((plugin) => ({
+    name: plugin.name,
+    enabled: plugin.enabled !== false,
+    provides: plugin.provides ?? [],
+    requires: plugin.requires ?? [],
+    optional: plugin.optional ?? []
+  }));
+}
+
+// src/types/publish_strategy.ts
+function isPublishable(strategy, frontmatter) {
+  if (strategy === "explicit") {
+    return frontmatter?.publish === true;
+  }
+  return !(frontmatter?.private === true || frontmatter?.draft === true);
+}
+
+// src/types/theme_config.ts
+function defineTheme(theme) {
+  return theme;
+}
+function isRiebeckiteTheme(theme) {
+  return "styles" in theme || "config" in theme;
+}
+
+// src/config.ts
+var defaultThemeStyle = {
+  moduleSpecifier: "@riebeckite/theme-default/style.css"
+};
+function defineConfig(config) {
+  return config;
+}
+function resolveConfigModule(configModule) {
+  return resolveConfig(unwrapConfigModule(configModule));
+}
+var configModuleWrapperKeys = /* @__PURE__ */ new Set([
+  "default",
+  "module.exports",
+  "__esModule"
+]);
+function unwrapConfigModule(configModule) {
+  let candidate = configModule;
+  while (isConfigModuleWrapper(candidate)) {
+    candidate = candidate.default;
+  }
+  return candidate;
+}
+function isConfigModuleWrapper(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("default" in value)) return false;
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((key) => configModuleWrapperKeys.has(key));
+}
+function resolveConfig(config) {
+  validateConfig(config);
+  const theme = resolveThemeConfig(config.theme);
+  return {
+    site: {
+      title: config.site?.title ?? "",
+      description: config.site?.description ?? "",
+      author: config.site?.author ?? "",
+      baseUrl: config.site?.baseUrl ?? "",
+      locale: config.site?.locale ?? "en",
+      twitterSite: config.site?.twitterSite ?? "",
+      defaultOgImage: config.site?.defaultOgImage ?? "",
+      feed: {
+        title: config.site?.feed?.title ?? config.site?.title ?? "",
+        description: config.site?.feed?.description ?? config.site?.description ?? "",
+        language: config.site?.feed?.language ?? config.site?.locale ?? "en"
+      }
+    },
+    content: {
+      directory: config.content?.directory ?? "../../content",
+      source: config.content?.source,
+      exclude: config.content?.exclude ?? [],
+      filters: {
+        publishStrategy: config.content?.filters?.publishStrategy ?? "explicit"
+      }
+    },
+    markdown: {
+      syntaxHighlight: {
+        theme: config.markdown?.syntaxHighlight?.theme ?? ""
+      }
+    },
+    theme,
+    plugins: resolvePlugins(config.plugins)
+  };
+}
+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];
+  const attributes = themeInput ? isRiebeckiteTheme(themeInput) ? { ...themeInput.config?.attributes, ...themeInput.attributes } : themeInput.attributes : void 0;
+  return {
+    name: theme?.name ?? "riebeckite",
+    colorMode: theme?.colorMode ?? "system",
+    typography: theme?.typography ?? "system",
+    articleLayout: theme?.articleLayout ?? "article",
+    tokens: theme?.tokens ?? {},
+    attributes: sanitizeThemeAttributes(attributes),
+    userCss: theme?.userCss ?? [],
+    styles
+  };
+}
+function sanitizeThemeAttributes(attributes) {
+  if (!attributes) return {};
+  const reservedAttributes = /* @__PURE__ */ new Set([
+    "data-theme",
+    "data-theme-name",
+    "data-typography",
+    "data-article-layout"
+  ]);
+  return Object.fromEntries(
+    Object.entries(attributes).filter(
+      ([name, value]) => name.startsWith("data-") && value !== void 0
+    ).filter(([name]) => !reservedAttributes.has(name))
+  );
+}
+function isPublished(config, frontmatter) {
+  return isPublishable(config.content.filters.publishStrategy, frontmatter);
+}
+function isExcluded(patterns, relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  return patterns.some((pattern) => matchGlob(pattern, normalized));
+}
+function matchGlob(pattern, value) {
+  return globToRegExp(pattern).test(value);
+}
+function globToRegExp(glob) {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        i++;
+        if (glob[i + 1] === "/") {
+          i++;
+          re += "(?:[^/]+/)*";
+        } else {
+          re += ".*";
+        }
+      } else {
+        re += "[^/]*";
+      }
+    } else if (ch === "?") {
+      re += "[^/]";
+    } else {
+      re += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+
+// src/content/image_extensions.ts
+var IMAGE_EXTENSIONS = [
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "svg",
+  "webp",
+  "bmp"
+];
+
+// src/content/attachment.ts
+var ATTACHMENTS_BASE_PATH = "/assets/attachments";
+function isMarkdownPath(filePath) {
+  return getExtension(filePath) === "md";
+}
+function isImagePath(filePath) {
+  return IMAGE_EXTENSIONS.includes(getExtension(filePath));
+}
+function isAttachmentPath(filePath) {
+  return hasFileExtension(filePath) && !isMarkdownPath(filePath) && !isImagePath(filePath);
+}
+function getExtension(filePath) {
+  const lowerPath = filePath.toLowerCase();
+  if (lowerPath.endsWith(".tar.gz")) return "tar.gz";
+  const fileName = getFileName(filePath);
+  const extensionStart = fileName.lastIndexOf(".");
+  if (extensionStart <= 0) return "";
+  return fileName.slice(extensionStart + 1).toLowerCase();
+}
+function attachmentUrl(filePath) {
+  const encodedPath = normalizeContentPath(filePath).split("/").map(encodeURIComponent).join("/");
+  return `${ATTACHMENTS_BASE_PATH}/${encodedPath}`;
+}
+function normalizeContentPath(filePath) {
+  return filePath.replace(/\\/g, "/").normalize("NFC");
+}
+function hasFileExtension(filePath) {
+  const fileName = getFileName(filePath);
+  const extensionStart = fileName.lastIndexOf(".");
+  return extensionStart > 0 && extensionStart < fileName.length - 1;
+}
+function getFileName(filePath) {
+  const normalizedPath = normalizeContentPath(filePath);
+  return normalizedPath.slice(normalizedPath.lastIndexOf("/") + 1);
+}
+
+// src/content/content_build_state_store.ts
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+// src/content/content_build_state.ts
+var CONTENT_BUILD_STATE_VERSION = 2;
+var CONTENT_BUILD_STATE_DIRECTORY = ".riebeckite";
+var CONTENT_BUILD_STATE_EXCLUDE = `${CONTENT_BUILD_STATE_DIRECTORY}/**`;
+
+// src/content/content_build_state_store.ts
+async function loadContentBuildState(statePath) {
+  try {
+    const parsed = JSON.parse(await fs.readFile(statePath, "utf8"));
+    return isContentBuildState(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readContentBuildStateStatus(statePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await fs.readFile(statePath, "utf8"));
+  } catch (error) {
+    if (isNotFoundError(error)) return { kind: "missing", path: statePath };
+    if (error instanceof SyntaxError) {
+      return { kind: "invalid", path: statePath, reason: "malformed-json" };
+    }
+    throw error;
+  }
+  if (!isRecord2(parsed)) {
+    return { kind: "invalid", path: statePath, reason: "invalid-shape" };
+  }
+  if (parsed.version !== CONTENT_BUILD_STATE_VERSION) {
+    return { kind: "invalid", path: statePath, reason: "unsupported-version" };
+  }
+  if (!isContentBuildStateShape(parsed)) {
+    return { kind: "invalid", path: statePath, reason: "invalid-shape" };
+  }
+  return {
+    kind: "valid",
+    path: statePath,
+    version: parsed.version,
+    entryCount: Object.keys(parsed.entries).length
+  };
+}
+async function saveContentBuildState(statePath, state) {
+  const directory = path.dirname(statePath);
+  const temporaryPath = `${statePath}.${randomUUID()}.tmp`;
+  await fs.mkdir(directory, { recursive: true });
+  try {
+    await fs.writeFile(temporaryPath, JSON.stringify(state), "utf8");
+    await fs.rename(temporaryPath, statePath);
+  } catch (error) {
+    await fs.rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+function resolveContentBuildStatePath(config, contentDirectory) {
+  const directory = config?.content.directory ?? contentDirectory ?? process.cwd();
+  return path.resolve(
+    directory,
+    CONTENT_BUILD_STATE_DIRECTORY,
+    "content-state.json"
+  );
+}
+function isContentBuildState(value) {
+  return isRecord2(value) && value.version === CONTENT_BUILD_STATE_VERSION && isContentBuildStateShape(value);
+}
+function isContentBuildStateShape(value) {
+  if (!isRecord2(value.entries) || !isRecord2(value.contentIndex)) return false;
+  return Object.values(value.entries).every(
+    (entry) => isRecord2(entry) && typeof entry.fingerprint === "string" && entry.fingerprint.length > 0 && Array.isArray(entry.dependencies) && entry.dependencies.every(
+      (dependency) => typeof dependency === "string"
+    )
+  ) && Object.values(value.contentIndex).every(
+    (entry) => typeof entry === "string"
+  );
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/content/content_fingerprint.ts
+import { createHash } from "node:crypto";
+async function fingerprintContentEntries(entries, read) {
+  return await Promise.all(
+    [...entries].sort((left, right) => left.path.localeCompare(right.path)).map(async (entry) => ({
+      entry,
+      fingerprint: await fingerprintContentEntry(entry, read)
+    }))
+  );
+}
+async function fingerprintContentEntry(entry, read) {
+  if (entry.metadata?.hash) return `hash:${entry.metadata.hash}`;
+  if (entry.metadata?.etag) return `etag:${entry.metadata.etag}`;
+  const content = await read(entry);
+  return `sha256:${createHash("sha256").update(typeof content === "string" ? content : content).digest("hex")}`;
+}
+
+// src/content/content_query.ts
+function queryContentEntries(entries, spec = {}) {
+  const filter = spec.filter ?? {};
+  const matched = entries.filter((entry) => matchesFilter(entry, filter));
+  const sorted = applySort(matched, spec.sort);
+  return applyPagination(sorted, spec.offset, spec.limit);
+}
+function queryContentPage(entries, spec = {}) {
+  const ordered = queryContentEntries(entries, {
+    filter: spec.filter,
+    sort: spec.sort
+  });
+  const page = resolveContentQueryPagination(ordered.length, spec);
+  const end = page.limit > 0 ? page.offset + page.limit : void 0;
+  return { entries: ordered.slice(page.offset, end), page };
+}
+function resolveContentQueryPagination(total, spec = {}) {
+  const limit = typeof spec.limit === "number" && Number.isFinite(spec.limit) && spec.limit > 0 ? Math.floor(spec.limit) : 0;
+  const offset = typeof spec.offset === "number" && Number.isFinite(spec.offset) && spec.offset > 0 ? Math.floor(spec.offset) : 0;
+  const pageCount = limit > 0 ? Math.ceil(total / limit) : total > 0 ? 1 : 0;
+  const page = limit > 0 ? Math.floor(offset / limit) + 1 : 1;
+  return {
+    offset,
+    limit,
+    total,
+    page,
+    pageCount,
+    hasPrevious: offset > 0,
+    hasNext: limit > 0 ? offset + limit < total : false
+  };
+}
+function matchesFilter(entry, filter) {
+  return matchesTags(entry.tags, filter.tags) && matchesFolder(entry.slug, filter.folder) && matchesFrontmatter(entry.frontmatter, filter.frontmatter) && matchesDate(entry.frontmatter, filter.date);
+}
+function matchesTags(tags, filter) {
+  if (!filter) return true;
+  const normalized = tags.map((tag) => tag.toLowerCase());
+  const has = (tag) => normalized.includes(tag.toLowerCase());
+  if (filter.any && filter.any.length > 0 && !filter.any.some(has)) {
+    return false;
+  }
+  if (filter.all && filter.all.length > 0 && !filter.all.every(has)) {
+    return false;
+  }
+  if (filter.none && filter.none.length > 0 && filter.none.some(has)) {
+    return false;
+  }
+  return true;
+}
+function matchesFolder(slug, folder) {
+  if (folder === void 0) return true;
+  const folders = (Array.isArray(folder) ? folder : [folder]).map(normalizeFolder).filter((value) => value.length > 0);
+  if (folders.length === 0) return true;
+  return folders.some(
+    (value) => slug === value || slug.startsWith(`${value}/`)
+  );
+}
+function normalizeFolder(value) {
+  return value.trim().replace(/^\/+|\/+$/g, "");
+}
+function matchesFrontmatter(frontmatter, filter) {
+  if (!filter) return true;
+  for (const [key, expected] of Object.entries(filter)) {
+    const actual = frontmatter[key];
+    const expectedValues = Array.isArray(expected) ? expected : [expected];
+    if (expectedValues.length === 0) continue;
+    if (!expectedValues.some((value) => matchesFrontmatterValue(actual, value))) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchesFrontmatterValue(actual, expected) {
+  if (Array.isArray(actual)) {
+    return actual.some((item) => scalarEquals(item, expected));
+  }
+  return scalarEquals(actual, expected);
+}
+function scalarEquals(actual, expected) {
+  if (actual === void 0 || actual === null) return false;
+  if (typeof actual === "string" && typeof expected === "string") {
+    return actual.toLowerCase() === expected.toLowerCase();
+  }
+  if (actual instanceof Date) {
+    const time = toTime(expected);
+    return time !== null && actual.getTime() === time;
+  }
+  return actual === expected;
+}
+function matchesDate(frontmatter, filter) {
+  if (!filter) return true;
+  const from = filter.from ? parseLowerBound(filter.from) : null;
+  const to = filter.to ? parseUpperBound(filter.to) : null;
+  if (from === null && to === null) return true;
+  const value = toTime(frontmatter[filter.field ?? "date"]);
+  if (value === null) return false;
+  if (from !== null && value < from) return false;
+  if (to !== null && value > to) return false;
+  return true;
+}
+function parseLowerBound(value) {
+  return toTime(value);
+}
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+function parseUpperBound(value) {
+  const time = toTime(
+    DATE_ONLY.test(value.trim()) ? `${value.trim()}T23:59:59.999Z` : value
+  );
+  return time;
+}
+function toTime(value) {
+  if (value instanceof Date) {
+    const time2 = value.getTime();
+    return Number.isFinite(time2) ? time2 : null;
+  }
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  const time = Date.parse(trimmed);
+  return Number.isNaN(time) ? null : time;
+}
+var TITLE_FIELDS = /* @__PURE__ */ new Set(["title", "slug", "permalink"]);
+function applySort(entries, sort) {
+  const keys = normalizeSort(sort);
+  if (keys.length === 0) return [...entries];
+  return [...entries].sort((left, right) => {
+    for (const key of keys) {
+      const result = compareEntries(left, right, key);
+      if (result !== 0) return result;
+    }
+    return 0;
+  });
+}
+function normalizeSort(sort) {
+  if (!sort) return [];
+  const list = Array.isArray(sort) ? sort : [sort];
+  return list.map((value) => ({
+    field: value.field?.trim() || "date",
+    order: value.order === "desc" ? "desc" : "asc"
+  }));
+}
+function compareEntries(left, right, sort) {
+  const leftValue = resolveSortValue(left, sort.field);
+  const rightValue = resolveSortValue(right, sort.field);
+  if (leftValue === void 0 && rightValue === void 0) return 0;
+  if (leftValue === void 0) return 1;
+  if (rightValue === void 0) return -1;
+  const direction = sort.order === "desc" ? -1 : 1;
+  return direction * compareValues(leftValue, rightValue);
+}
+function resolveSortValue(entry, field) {
+  if (!TITLE_FIELDS.has(field)) return entry.frontmatter[field];
+  if (field === "title") return entry.title;
+  if (field === "slug") return entry.slug;
+  return entry.permalink;
+}
+function compareValues(left, right) {
+  const leftComparable = toComparable(left);
+  const rightComparable = toComparable(right);
+  if (typeof leftComparable === "number" && typeof rightComparable === "number") {
+    return leftComparable - rightComparable;
+  }
+  return String(leftComparable).localeCompare(String(rightComparable), "en");
+}
+function toComparable(value) {
+  if (value instanceof Date) return value.getTime();
+  if (typeof value === "number") return value;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (value === void 0 || value === null) return "";
+  return String(value);
+}
+function applyPagination(entries, offset, limit) {
+  const start = typeof offset === "number" && Number.isFinite(offset) && offset > 0 ? Math.floor(offset) : 0;
+  let result = start > 0 ? entries.slice(start) : [...entries];
+  if (typeof limit === "number" && Number.isFinite(limit) && limit >= 0) {
+    result = result.slice(0, Math.floor(limit));
+  }
+  return result;
+}
+function groupContentEntries(entries, groupBy, options = {}) {
+  const matched = queryContentEntries(entries, {
+    filter: options.filter,
+    sort: options.sort
+  });
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of matched) {
+    for (const key of resolveGroupKeys(entry, groupBy)) {
+      appendGroup(groups, key, entry);
+    }
+  }
+  return [...groups.entries()].sort(
+    ([left], [right]) => options.order === "desc" ? right.localeCompare(left, "en") : left.localeCompare(right, "en")
+  ).map(([key, groupEntries]) => ({ key, entries: groupEntries }));
+}
+function appendGroup(groups, key, entry) {
+  const values = groups.get(key);
+  if (values) {
+    values.push(entry);
+  } else {
+    groups.set(key, [entry]);
+  }
+}
+function resolveGroupKeys(entry, groupBy) {
+  switch (groupBy.by) {
+    case "tags":
+      return [...entry.tags];
+    case "folder":
+      return resolveFolderKeys(entry.slug, groupBy.depth);
+    case "date":
+      return resolveDateKeys(
+        entry.frontmatter,
+        groupBy.fields ?? [groupBy.field ?? "date"],
+        groupBy.granularity ?? "month"
+      );
+    case "frontmatter":
+      return resolveFrontmatterKeys(entry.frontmatter[groupBy.field]);
+    default:
+      return [];
+  }
+}
+function resolveFolderKeys(slug, depth) {
+  const segments = slug.split("/");
+  segments.pop();
+  const directories = typeof depth === "number" && Number.isFinite(depth) && depth > 0 ? segments.slice(0, Math.floor(depth)) : segments;
+  return [directories.join("/")];
+}
+var DATE_GRANULARITY_LENGTH = {
+  year: 4,
+  month: 7,
+  day: 10
+};
+function resolveDateKeys(frontmatter, fields, granularity) {
+  for (const field of fields) {
+    const time = toTime(frontmatter[field]);
+    if (time === null) continue;
+    return [
+      new Date(time).toISOString().slice(0, DATE_GRANULARITY_LENGTH[granularity])
+    ];
+  }
+  return [];
+}
+function resolveFrontmatterKeys(value) {
+  if (value === void 0 || value === null) return [];
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isFinite(time) ? [value.toISOString().slice(0, 10)] : [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => resolveFrontmatterKeys(item));
+  }
+  const text = String(value).trim();
+  return text.length > 0 ? [text] : [];
+}
+
+// src/content/content_collection.ts
+function buildContentCollections(entries, definitions) {
+  const collections = [];
+  for (const definition of definitions) {
+    const basePath = normalizeBasePath(definition.basePath);
+    const pageSize = normalizePageSize(definition.pageSize);
+    const groups = groupContentEntries(entries, definition.groupBy, {
+      filter: definition.filter,
+      sort: definition.sort,
+      order: definition.order
+    });
+    for (const group of groups) {
+      const context = {
+        kind: definition.kind,
+        value: group.key,
+        basePath
+      };
+      const title = definition.resolveTitle?.(context) ?? group.key;
+      const collectionPath = normalizePath(
+        definition.resolvePath?.(context) ?? defaultPath(context)
+      );
+      const total = group.entries.length;
+      const pageCount = pageSize > 0 ? Math.ceil(total / pageSize) : 1;
+      for (let index = 0; index < pageCount; index++) {
+        const start = pageSize > 0 ? index * pageSize : 0;
+        const end = pageSize > 0 ? start + pageSize : void 0;
+        collections.push({
+          kind: definition.kind,
+          value: group.key,
+          title,
+          path: withPage(collectionPath, index),
+          page: {
+            current: index + 1,
+            count: pageCount,
+            size: pageSize,
+            total,
+            previousPath: index > 0 ? withPage(collectionPath, index - 1) : null,
+            nextPath: index < pageCount - 1 ? withPage(collectionPath, index + 1) : null
+          },
+          entries: group.entries.slice(start, end)
+        });
+      }
+    }
+  }
+  return collections;
+}
+function normalizePageSize(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function withPage(path4, index) {
+  if (index === 0) return path4;
+  const base = path4 === "/" ? "" : path4;
+  return normalizePath(`${base}/page/${index + 1}`);
+}
+function defaultPath(context) {
+  const slug = slugifyValue(context.value);
+  if (!slug) return context.basePath || "/";
+  return `${context.basePath}/${slug}`;
+}
+function slugifyValue(value) {
+  return value.split("/").map(
+    (segment) => segment.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")
+  ).filter((segment) => segment.length > 0).join("/");
+}
+function normalizeBasePath(value) {
+  const trimmed = value.trim().replace(/\/+$/, "");
+  if (trimmed.length === 0) return "";
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function normalizePath(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return "/";
+  const absolute = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  return absolute.replace(/\/{2,}/g, "/").replace(/\/+$/, "") || "/";
+}
+
+// src/utils/collections.ts
+function uniqueStrings(values) {
+  return Array.from(new Set(values));
+}
+
+// src/content/content_graph.ts
+function createContentGraph(manifest) {
+  return {
+    nodes: () => [...manifest.entries],
+    get: (slug) => manifest.bySlug.get(slug) ?? null,
+    outgoing: (slug) => toEntries(manifest, getOutgoingSlugs(manifest, slug)),
+    incoming: (slug) => toEntries(manifest, getIncomingSlugs(manifest, slug)),
+    neighbors: (slug) => toEntries(manifest, getNeighborSlugs(manifest, slug)),
+    outgoingSlugs: (slug) => getOutgoingSlugs(manifest, slug),
+    incomingSlugs: (slug) => getIncomingSlugs(manifest, slug),
+    neighborSlugs: (slug) => getNeighborSlugs(manifest, slug),
+    filterNeighbors: (slug, include) => ({
+      outgoingSlugs: uniqueStrings(
+        getOutgoingSlugs(manifest, slug).filter(include)
+      ),
+      incomingSlugs: uniqueStrings(
+        getIncomingSlugs(manifest, slug).filter(include)
+      )
+    })
+  };
+}
+function getOutgoingSlugs(manifest, slug) {
+  const links = manifest.outgoingLinks.get(slug) ?? [];
+  return uniqueStrings(
+    links.filter(isResolvedNoteLink).map((link) => link.slug).filter((targetSlug) => targetSlug !== slug)
+  );
+}
+function getIncomingSlugs(manifest, slug) {
+  return manifest.incomingLinks.get(slug) ?? [];
+}
+function getNeighborSlugs(manifest, slug) {
+  return uniqueStrings([
+    ...getOutgoingSlugs(manifest, slug),
+    ...getIncomingSlugs(manifest, slug)
+  ]);
+}
+function toEntries(manifest, slugs) {
+  return slugs.map((slug) => manifest.bySlug.get(slug) ?? null).filter((entry) => entry !== null);
+}
+function isResolvedNoteLink(link) {
+  return link.kind === "note" && link.slug !== null;
+}
+
+// src/content/graph_layout.ts
+function buildGraphEdges(nodes, visibleSlugs = new Set(nodes.map((node) => node.slug))) {
+  const edges = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    for (const target of node.outgoing) {
+      if (!visibleSlugs.has(node.slug) || !visibleSlugs.has(target)) continue;
+      const key = `${node.slug}\0${target}`;
+      edges.set(key, { source: node.slug, target });
+    }
+  }
+  return Array.from(edges.values());
+}
+function layoutRadialGraph(nodes, options) {
+  const layout = /* @__PURE__ */ new Map();
+  const centerX = options.width / 2;
+  const centerY = options.height / 2;
+  const radius = Math.min(options.width, options.height) * (options.radiusRatio ?? 0.36);
+  const minNodeRadius = options.minNodeRadius ?? 8;
+  const maxNodeRadius = options.maxNodeRadius ?? 14;
+  const selectedIndex = Math.max(
+    nodes.findIndex((node) => node.slug === options.centerSlug),
+    0
+  );
+  nodes.forEach((node, index) => {
+    const shiftedIndex = (index - selectedIndex + nodes.length) % nodes.length;
+    const angle = shiftedIndex / Math.max(nodes.length, 1) * Math.PI * 2;
+    const linkCount = node.outgoing.length + node.backlinks.length;
+    const isCenter = node.slug === options.centerSlug;
+    layout.set(node.slug, {
+      x: isCenter ? centerX : centerX + Math.cos(angle) * radius,
+      y: isCenter ? centerY : centerY + Math.sin(angle) * radius,
+      radius: clamp(7 + linkCount, minNodeRadius, maxNodeRadius)
+    });
+  });
+  return layout;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+// src/content/content_location.ts
+function resolveDefaultContentLocation(content) {
+  return {
+    slug: content.slug,
+    permalink: content.slug === "index" ? "/" : `/${content.slug}`
+  };
+}
+
+// src/observability.ts
+var NoopLogger = class {
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+  child() {
+    return this;
+  }
+};
+var ConsoleLogger = class _ConsoleLogger {
+  constructor(context = {}) {
+    this.context = context;
+  }
+  context;
+  debug(message, context) {
+    this.write("debug", message, context);
+  }
+  info(message, context) {
+    this.write("info", message, context);
+  }
+  warn(message, context) {
+    this.write("warn", message, context);
+  }
+  error(message, context, cause) {
+    const details = mergeContext(this.context, context);
+    if (cause) {
+      console.error(message, details, cause);
+      return;
+    }
+    console.error(message, details);
+  }
+  child(context) {
+    return new _ConsoleLogger(mergeContext(this.context, context));
+  }
+  write(level, message, context) {
+    console[level](message, mergeContext(this.context, context));
+  }
+};
+var NoopTracer = class {
+  async span(_name, _attributes, fn) {
+    return await fn();
+  }
+  event() {
+  }
+};
+var SinkTracer = class {
+  constructor(sink) {
+    this.sink = sink;
+  }
+  sink;
+  async span(name, attributes, fn) {
+    const startTime = wallClockNow();
+    const startTick = monotonicNow();
+    try {
+      const result = await fn();
+      this.emitSpan({
+        name,
+        startTime,
+        durationMs: monotonicNow() - startTick,
+        status: "ok",
+        attributes
+      });
+      return result;
+    } catch (error) {
+      this.emitSpan({
+        name,
+        startTime,
+        durationMs: monotonicNow() - startTick,
+        status: "error",
+        attributes
+      });
+      throw error;
+    }
+  }
+  event(name, attributes = {}) {
+    try {
+      this.sink.onEvent({ name, time: wallClockNow(), attributes });
+    } catch {
+    }
+  }
+  emitSpan(span) {
+    try {
+      this.sink.onSpan(span);
+    } catch {
+    }
+  }
+};
+var CompositeTraceSink = class {
+  constructor(sinks) {
+    this.sinks = sinks;
+  }
+  sinks;
+  onSpan(span) {
+    for (const sink of this.sinks) {
+      try {
+        sink.onSpan(span);
+      } catch {
+      }
+    }
+  }
+  onEvent(event) {
+    for (const sink of this.sinks) {
+      try {
+        sink.onEvent(event);
+      } catch {
+      }
+    }
+  }
+};
+var noopObservability = {
+  logger: new NoopLogger(),
+  tracer: new NoopTracer()
+};
+function mergeContext(base, context) {
+  return context ? { ...base, ...context } : base;
+}
+function wallClockNow() {
+  return Date.now();
+}
+function monotonicNow() {
+  return typeof performance === "undefined" ? Date.now() : performance.now();
+}
+
+// src/pipeline.ts
+import rehypeFormat from "rehype-format";
+import rehypeKatex from "rehype-katex";
+import rehypeRaw from "rehype-raw";
+import rehypeSlug from "rehype-slug";
+import rehypeStringify from "rehype-stringify";
+import remarkDirective from "remark-directive";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified } from "unified";
+import { matter } from "vfile-matter";
+
+// src/plugin/plugin_cache.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+function createUnavailablePluginCache() {
+  return {
+    get: unavailableAtRuntime,
+    set: unavailableAtRuntime,
+    delete: unavailableAtRuntime,
+    clear: unavailableAtRuntime
+  };
+}
+function createPluginCache(options) {
+  const pluginDirectory = path2.join(
+    options.cacheDirectory,
+    pluginNamespace(options.pluginName)
+  );
+  const versionDirectory = path2.join(
+    pluginDirectory,
+    hash(options.cacheVersion ?? "1")
+  );
+  const writes = /* @__PURE__ */ new Map();
+  return {
+    async get(key) {
+      let raw;
+      try {
+        raw = await fs2.readFile(cachePath(versionDirectory, key), "utf8");
+      } catch (error) {
+        if (isNotFoundError2(error)) {
+          options.tracer?.event("cache.miss", { plugin: options.pluginName });
+          return void 0;
+        }
+        throw error;
+      }
+      try {
+        const value = JSON.parse(raw);
+        options.tracer?.event("cache.hit", { plugin: options.pluginName });
+        return value;
+      } catch {
+        options.logger?.warn(
+          "Plugin cache entry is corrupted and will be ignored.",
+          {
+            plugin: options.pluginName
+          }
+        );
+        return void 0;
+      }
+    },
+    async set(key, value) {
+      const targetPath = cachePath(versionDirectory, key);
+      const serialized = JSON.stringify(value);
+      if (serialized === void 0) {
+        throw new TypeError("Plugin cache values must be JSON serializable.");
+      }
+      const previousWrite = writes.get(targetPath) ?? Promise.resolve();
+      const write = previousWrite.catch(() => void 0).then(() => writeAtomically(targetPath, versionDirectory, serialized));
+      writes.set(targetPath, write);
+      try {
+        await write;
+      } finally {
+        if (writes.get(targetPath) === write) {
+          writes.delete(targetPath);
+        }
+      }
+    },
+    async delete(key) {
+      await fs2.rm(cachePath(versionDirectory, key), { force: true });
+    },
+    async clear() {
+      await fs2.rm(pluginDirectory, { recursive: true, force: true });
+    }
+  };
+}
+async function writeAtomically(targetPath, versionDirectory, serialized) {
+  await fs2.mkdir(versionDirectory, { recursive: true });
+  const temporaryPath = `${targetPath}.${randomUUID2()}.tmp`;
+  try {
+    await fs2.writeFile(temporaryPath, serialized, "utf8");
+    await fs2.rename(temporaryPath, targetPath);
+  } catch (error) {
+    await fs2.rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+function resolvePluginCacheDirectory(config) {
+  if (!config) return path2.resolve(process.cwd(), ".riebeckite", "cache");
+  return path2.resolve(config.content.directory, "..", ".riebeckite", "cache");
+}
+function cachePath(versionDirectory, key) {
+  return path2.join(versionDirectory, `${hash(key)}.json`);
+}
+function pluginNamespace(pluginName) {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(pluginName) ? pluginName : hash(pluginName);
+}
+function hash(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function isNotFoundError2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function unavailableAtRuntime() {
+  throw new Error(
+    "Plugin cache is available only through an explicit build context."
+  );
+}
+
+// src/types/generated_output.ts
+function createUnavailableGeneratedOutputSink() {
+  return {
+    emit() {
+      throw new Error(
+        "Generated output is available only during a build lifecycle."
+      );
+    }
+  };
+}
+function normalizeGeneratedOutputPath(input) {
+  if (typeof input !== "string" || input.length === 0) {
+    throw new Error("Generated output path must be a non-empty string.");
+  }
+  const replaced = input.replace(/\\/g, "/");
+  if (replaced.includes("\0")) {
+    throw new Error(
+      `Generated output path must not contain a null byte: "${input}".`
+    );
+  }
+  if (replaced.startsWith("/") || replaced.startsWith("~") || /^[A-Za-z]:/.test(replaced)) {
+    throw new Error(`Generated output path must be relative: "${input}".`);
+  }
+  const segments = replaced.split("/").filter((segment) => segment.length > 0);
+  if (segments.length === 0) {
+    throw new Error(`Generated output path must not be empty: "${input}".`);
+  }
+  for (const segment of segments) {
+    if (segment === "." || segment === "..") {
+      throw new Error(
+        `Generated output path must not contain "." or ".." segments: "${input}".`
+      );
+    }
+  }
+  const normalized = segments.join("/");
+  if (normalized === "assets" || normalized.startsWith("assets/")) {
+    throw new Error(
+      `Generated output path must not conflict with the static assets namespace: "${input}".`
+    );
+  }
+  if (normalized === ".riebeckite" || normalized.startsWith(".riebeckite/")) {
+    throw new Error(
+      `Generated output path must not target internal Riebeckite files: "${input}".`
+    );
+  }
+  return normalized;
+}
+
+// src/pipeline.ts
+var Pipeline = class {
+  constructor(contentIndex, permalinks, getMarkdownBySlug, options = {}, isBuildTime = false) {
+    this.contentIndex = contentIndex;
+    this.permalinks = permalinks;
+    this.getMarkdownBySlug = getMarkdownBySlug;
+    this.options = options;
+    this.isBuildTime = isBuildTime;
+  }
+  contentIndex;
+  permalinks;
+  getMarkdownBySlug;
+  options;
+  isBuildTime;
+  pluginCaches = /* @__PURE__ */ new Map();
+  async execute(markDownContent, embedDepth = 0, embedTrail = /* @__PURE__ */ new Set()) {
+    const processor = unified();
+    const plugins = resolvePlugins(this.options.plugins);
+    this.use(processor, remarkParse);
+    this.use(processor, remarkDirective);
+    this.use(processor, remarkFrontmatter, ["yaml", "toml"]);
+    this.use(processor, function loadFrontmatter() {
+      return (_tree, file2) => {
+        matter(file2);
+      };
+    });
+    this.use(processor, remarkMath);
+    this.use(processor, remarkGfm);
+    const markdownPipelineContext = {
+      contentIndex: this.contentIndex,
+      resolvePermalink: (slug) => this.getPermalink(slug),
+      renderNoteEmbed: this.createNoteEmbedRenderer(embedDepth, embedTrail),
+      renderContent: this.createContentRenderer(),
+      contentSource: this.options.contentSource
+    };
+    for (const plugin of plugins) {
+      for (const remarkPlugin of plugin.remarkPlugins ?? []) {
+        this.use(processor, remarkPlugin);
+      }
+      plugin.extendMarkdownPipeline?.(
+        {
+          use: (pipelinePlugin, options) => {
+            this.use(processor, pipelinePlugin, options);
+          }
+        },
+        markdownPipelineContext
+      );
+    }
+    this.use(processor, remarkRehype, { allowDangerousHtml: true });
+    this.use(processor, rehypeRaw);
+    for (const plugin of plugins) {
+      for (const rehypePlugin of plugin.rehypePlugins ?? []) {
+        this.use(processor, rehypePlugin);
+      }
+      plugin.extendHtmlPipeline?.({
+        use: (pipelinePlugin, options) => {
+          this.use(processor, pipelinePlugin, options);
+        }
+      });
+    }
+    this.use(processor, rehypeSlug);
+    this.use(processor, rehypeKatex, { output: "mathml", strict: false });
+    this.use(processor, rehypeFormat);
+    this.use(processor, rehypeStringify, { allowDangerousHtml: true });
+    const file = await processor.process(markDownContent.trim());
+    return {
+      frontmatter: file.data.matter || {},
+      html: String(file.value)
+    };
+  }
+  getPermalink(slug) {
+    const permalink = this.permalinks.get(slug);
+    if (!permalink) {
+      throw new Error(`Content public location was not resolved: ${slug}`);
+    }
+    return permalink;
+  }
+  use(processor, plugin, options) {
+    const register = processor.use.bind(processor);
+    if (options === void 0) {
+      register(plugin);
+    } else {
+      register(plugin, options);
+    }
+  }
+  createNoteEmbedRenderer(embedDepth, embedTrail) {
+    if (!this.getMarkdownBySlug || embedDepth >= 3) return void 0;
+    return async (slug, fragment) => {
+      if (embedTrail.has(slug)) return null;
+      const sourceMarkdown = await this.getMarkdownBySlug?.(slug);
+      const markdown = sourceMarkdown ? selectEmbedMarkdownFragment(sourceMarkdown, fragment) : null;
+      if (!markdown) return null;
+      const nextEmbedTrail = new Set(embedTrail);
+      nextEmbedTrail.add(slug);
+      const content = await this.execute(
+        markdown,
+        embedDepth + 1,
+        nextEmbedTrail
+      );
+      return content.html;
+    };
+  }
+  createContentRenderer() {
+    const renderers = resolvePlugins(this.options.plugins).flatMap(
+      (plugin) => (plugin.renderers ?? []).map((renderer) => ({ plugin, renderer }))
+    );
+    if (renderers.length === 0) return void 0;
+    return async (input) => {
+      for (const { plugin, renderer } of renderers) {
+        const observability = this.options.observability ?? noopObservability;
+        const html = await observability.tracer.span(
+          "plugin.render",
+          {
+            plugin: plugin.name,
+            contentPath: input.path,
+            target: input.kind
+          },
+          () => renderer.render({
+            config: this.options.config,
+            contentIndex: this.contentIndex,
+            diagnostics: [],
+            cache: this.cacheFor(plugin, observability),
+            output: createUnavailableGeneratedOutputSink(),
+            logger: observability.logger.child({ plugin: plugin.name }),
+            tracer: observability.tracer,
+            contentSource: this.options.contentSource,
+            ...input
+          })
+        );
+        if (html) return html;
+      }
+      return null;
+    };
+  }
+  cacheFor(plugin, observability) {
+    const cached = this.pluginCaches.get(plugin.name);
+    if (cached) return cached;
+    const cache = this.isBuildTime ? createPluginCache({
+      pluginName: plugin.name,
+      cacheVersion: plugin.cacheVersion,
+      cacheDirectory: resolvePluginCacheDirectory(this.options.config),
+      tracer: observability.tracer,
+      logger: observability.logger.child({ plugin: plugin.name })
+    }) : createUnavailablePluginCache();
+    this.pluginCaches.set(plugin.name, cache);
+    return cache;
+  }
+};
+function selectEmbedMarkdownFragment(markdown, fragment) {
+  if (!fragment) return markdown;
+  if (fragment.kind === "block")
+    return selectBlockFragment(markdown, fragment.value);
+  return selectHeadingFragment(markdown, fragment.value);
+}
+function selectBlockFragment(markdown, blockId) {
+  const lines = markdown.split(/\r?\n/);
+  const blockIdRe = new RegExp(`(?:^|\\s)\\^${escapeRegExp(blockId)}\\s*$`);
+  const line = lines.find((currentLine) => blockIdRe.test(currentLine));
+  return line?.replace(blockIdRe, "").trimEnd() || null;
+}
+function selectHeadingFragment(markdown, heading) {
+  const lines = markdown.split(/\r?\n/);
+  const targetHeading = heading.trim().toLowerCase();
+  const startIndex = lines.findIndex((line) => {
+    const match = line.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
+    return match?.[2]?.trim().toLowerCase() === targetHeading;
+  });
+  if (startIndex < 0) return null;
+  const level = lines[startIndex]?.match(/^(#{1,6})\s+/)?.[1]?.length ?? 6;
+  const endIndex = lines.findIndex((line, index) => {
+    if (index <= startIndex) return false;
+    const match = line.match(/^(#{1,6})\s+/);
+    return match !== null && match[1].length <= level;
+  });
+  const selectedLines = lines.slice(
+    startIndex,
+    endIndex === -1 ? void 0 : endIndex
+  );
+  return selectedLines.join("\n").trim() || null;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/plugin/plugin_lifecycle.ts
+var PluginLifecycleError = class extends Error {
+  constructor(pluginName, hookName, cause) {
+    super(`Plugin "${pluginName}" failed during "${hookName}"`, { cause });
+    this.name = "PluginLifecycleError";
+  }
+};
+async function runSetup(plugins, createContext) {
+  await runLifecycleHook(
+    plugins,
+    "setup",
+    (plugin) => plugin.setup,
+    createContext
+  );
+}
+async function runBuildStart(plugins, createContext) {
+  await runLifecycleHook(
+    plugins,
+    "buildStart",
+    (plugin) => plugin.buildStart,
+    createContext
+  );
+}
+async function runBuildEnd(plugins, createContext) {
+  await runLifecycleHook(
+    plugins,
+    "buildEnd",
+    (plugin) => plugin.buildEnd,
+    createContext
+  );
+}
+async function runDispose(plugins, createContext) {
+  await runLifecycleHook(
+    [...plugins].reverse(),
+    "dispose",
+    (plugin) => plugin.dispose,
+    createContext
+  );
+}
+async function runLifecycleHook(plugins, hookName, getHook, createContext) {
+  for (const plugin of plugins) {
+    const hook = getHook(plugin);
+    if (!hook) continue;
+    try {
+      const context = createContext(plugin);
+      await context.tracer.span(
+        `plugin.${hookName}`,
+        {
+          plugin: plugin.name,
+          hook: hookName
+        },
+        () => hook(context)
+      );
+    } catch (error) {
+      throw new PluginLifecycleError(plugin.name, hookName, error);
+    }
+  }
+}
+
+// src/plugin/plugin_runtime.ts
+var PluginRuntime = class {
+  constructor(pipelineOptions = {}) {
+    this.pipelineOptions = pipelineOptions;
+  }
+  pipelineOptions;
+  buildLifecycle = null;
+  buildStage = "idle";
+  disposed = false;
+  diagnostics = [];
+  pluginCaches = /* @__PURE__ */ new Map();
+  generatedOutputs = [];
+  generatedOutputOwners = /* @__PURE__ */ new Map();
+  isBuildTime = false;
+  getDiagnostics() {
+    return this.diagnostics;
+  }
+  getBuildStage() {
+    return this.buildStage;
+  }
+  /**
+   * Starts the plugin build lifecycle exactly once, regardless of which public
+   * entry point (content processing or location resolution) reaches it first.
+   * Concurrent callers await the same run, so the ordered hooks
+   * (`setup` → `buildStart` → `onBuildStart` → `onConfigResolved`) are never
+   * duplicated and no caller proceeds before the lifecycle completes.
+   */
+  startBuild(contentIndex) {
+    this.buildLifecycle ??= this.runBuildLifecycle(contentIndex);
+    return this.buildLifecycle;
+  }
+  async runContentLoaded(slug, markdown, contentIndex) {
+    await this.runHook((plugin) => plugin.onContentLoaded, {
+      ...this.createContext(contentIndex),
+      slug,
+      markdown
+    });
+  }
+  async resolveContentLocations(entries, contentIndex) {
+    const context = { ...this.createContext(contentIndex), entries };
+    const locations = [];
+    for (const plugin of this.plugins()) {
+      const resolver = plugin.resolveContentLocations;
+      if (!resolver) continue;
+      const resolved = await resolver(
+        this.createPluginContext(plugin, context)
+      );
+      locations.push(...resolved);
+    }
+    return locations;
+  }
+  async extendContentLocations(entries, locations, contentIndex) {
+    await this.runHook((plugin) => plugin.extendContentLocations, {
+      ...this.createContext(contentIndex),
+      entries,
+      locations
+    });
+  }
+  async runPostHook(hookName, slug, markdown, content, contentIndex) {
+    await this.runHook((plugin) => plugin[hookName], {
+      ...this.createContext(contentIndex),
+      slug,
+      markdown,
+      content
+    });
+  }
+  async runGraphHook(entries, contentIndex) {
+    await this.runHook((plugin) => plugin.extendContentGraph, {
+      ...this.createContext(contentIndex),
+      entries
+    });
+  }
+  async runManifestCreated(manifest, contentIndex) {
+    await this.runHook((plugin) => plugin.onManifestCreated, {
+      ...this.createContext(contentIndex),
+      manifest
+    });
+  }
+  async runBuildEnd(manifest, contentIndex) {
+    const context = {
+      ...this.createContext(contentIndex),
+      manifest
+    };
+    await runBuildEnd(
+      this.plugins(),
+      (plugin) => this.createPluginContext(plugin, context)
+    );
+    await this.runHook((plugin) => plugin.onBuildEnd, {
+      ...this.createContext(contentIndex),
+      manifest
+    });
+  }
+  enableBuildTime() {
+    this.isBuildTime = true;
+  }
+  async dispose(contentIndex) {
+    if (this.disposed || this.buildLifecycle === null) return;
+    this.disposed = true;
+    const context = this.createContext(contentIndex);
+    await runDispose(
+      this.plugins(),
+      (plugin) => this.createPluginContext(plugin, context)
+    );
+  }
+  collectAssets() {
+    return this.plugins().flatMap(
+      (plugin) => (plugin.assets ?? []).map((asset) => ({
+        ...asset,
+        path: asset.moduleSpecifier,
+        pluginName: asset.pluginName || plugin.name
+      }))
+    );
+  }
+  /** Returns registered outputs sorted by path for a deterministic build. */
+  collectGeneratedOutputs() {
+    return [...this.generatedOutputs].sort(
+      (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+    );
+  }
+  async collectDiagnostics(contentIndex) {
+    const tracer = this.observability().tracer;
+    return await tracer.span("diagnostics.run", {}, async () => {
+      const results = [];
+      const context = this.createContext(contentIndex);
+      for (const plugin of this.plugins()) {
+        const diagnostics = await plugin.addDiagnostics?.(
+          this.createPluginContext(plugin, context)
+        );
+        for (const diagnostic of diagnostics ?? []) {
+          results.push({
+            ...diagnostic,
+            pluginName: diagnostic.pluginName || plugin.name
+          });
+        }
+      }
+      tracer.event("diagnostics.summary", {
+        total: results.length,
+        errors: countSeverity(results, "error"),
+        warnings: countSeverity(results, "warning"),
+        info: countSeverity(results, "info")
+      });
+      return results;
+    });
+  }
+  async runBuildLifecycle(contentIndex) {
+    const context = this.createContext(contentIndex);
+    const createPluginContext = (plugin) => this.createPluginContext(plugin, context);
+    const stages = [
+      {
+        stage: "setup",
+        run: () => runSetup(this.plugins(), createPluginContext)
+      },
+      {
+        stage: "buildStart",
+        run: () => runBuildStart(this.plugins(), createPluginContext)
+      },
+      {
+        stage: "onBuildStart",
+        run: () => this.runHook((plugin) => plugin.onBuildStart, context)
+      },
+      {
+        stage: "onConfigResolved",
+        run: () => this.runHook((plugin) => plugin.onConfigResolved, context)
+      }
+    ];
+    for (const { stage, run } of stages) {
+      this.buildStage = stage;
+      await run();
+    }
+    this.buildStage = "started";
+  }
+  createContext(contentIndex) {
+    return {
+      config: this.pipelineOptions.config,
+      contentIndex,
+      diagnostics: this.diagnostics
+    };
+  }
+  createPluginContext(plugin, context) {
+    const observability = this.observability();
+    return {
+      ...context,
+      cache: this.cacheFor(plugin),
+      output: this.generatedOutputSinkFor(plugin),
+      logger: observability.logger.child({ plugin: plugin.name }),
+      tracer: observability.tracer
+    };
+  }
+  generatedOutputSinkFor(plugin) {
+    return {
+      emit: (output) => {
+        const path4 = normalizeGeneratedOutputPath(output.path);
+        const owner = this.generatedOutputOwners.get(path4);
+        if (owner) {
+          throw new Error(
+            `Duplicate generated output path "${path4}" declared by "${owner}" and "${plugin.name}".`
+          );
+        }
+        this.generatedOutputOwners.set(path4, plugin.name);
+        this.generatedOutputs.push({
+          path: path4,
+          content: output.content,
+          owner: plugin.name
+        });
+      }
+    };
+  }
+  cacheFor(plugin) {
+    const cached = this.pluginCaches.get(plugin.name);
+    if (cached) return cached;
+    const cache = this.isBuildTime ? createPluginCache({
+      pluginName: plugin.name,
+      cacheVersion: plugin.cacheVersion,
+      cacheDirectory: resolvePluginCacheDirectory(
+        this.pipelineOptions.config
+      ),
+      logger: this.observability().logger.child({ plugin: plugin.name }),
+      tracer: this.observability().tracer
+    }) : createUnavailablePluginCache();
+    this.pluginCaches.set(plugin.name, cache);
+    return cache;
+  }
+  async runHook(hook, context) {
+    for (const plugin of this.plugins()) {
+      const pluginHook = hook(plugin);
+      if (!pluginHook) continue;
+      const pluginContext = this.createPluginContext(plugin, context);
+      await pluginContext.tracer.span(
+        "plugin.hook",
+        {
+          plugin: plugin.name
+        },
+        () => pluginHook(pluginContext)
+      );
+    }
+  }
+  observability() {
+    return this.pipelineOptions.observability ?? noopObservability;
+  }
+  plugins() {
+    return resolvePlugins(this.pipelineOptions.plugins);
+  }
+};
+function countSeverity(diagnostics, severity) {
+  return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
+}
+
+// src/content/affected_content.ts
+function determineAffectedContent(changeSet, previousState, currentPaths) {
+  const changedPaths = [
+    ...changeSet.added,
+    ...changeSet.changed,
+    ...changeSet.removed
+  ];
+  const direct = new Set(
+    changedPaths.filter(isMarkdownPath2).map(toDependencyKey)
+  );
+  const dependent = /* @__PURE__ */ new Set();
+  if (!previousState) {
+    addAllNotes(direct, currentPaths);
+    return { direct, dependent };
+  }
+  if (changeSet.added.length > 0 || changeSet.removed.length > 0) {
+    addAllNotes(dependent, currentPaths, direct);
+  }
+  const pending = changedPaths.map(toDependencyKey);
+  const seen = new Set(pending);
+  while (pending.length > 0) {
+    const changed = pending.pop();
+    if (changed === void 0) continue;
+    for (const [path4, entry] of Object.entries(previousState.entries)) {
+      if (!isMarkdownPath2(path4)) continue;
+      const slug = toDependencyKey(path4);
+      if (direct.has(slug) || dependent.has(slug)) continue;
+      if (!entry.dependencies.includes(changed)) continue;
+      dependent.add(slug);
+      if (!seen.has(slug)) {
+        seen.add(slug);
+        pending.push(slug);
+      }
+    }
+  }
+  return { direct, dependent };
+}
+function addAllNotes(target, currentPaths, exclude) {
+  for (const path4 of currentPaths) {
+    if (!isMarkdownPath2(path4)) continue;
+    const slug = toDependencyKey(path4);
+    if (exclude?.has(slug)) continue;
+    target.add(slug);
+  }
+}
+function isMarkdownPath2(path4) {
+  return path4.endsWith(".md");
+}
+function toDependencyKey(path4) {
+  return path4.replace(/\.md$/, "");
+}
+
+// src/content/content_change_set.ts
+function diffContentEntries(previous, current) {
+  const currentFingerprints = new Map(
+    current.map(({ entry, fingerprint }) => [entry.path, fingerprint])
+  );
+  const added = [];
+  const changed = [];
+  const unchanged = [];
+  for (const [path4, fingerprint] of currentFingerprints) {
+    const previousEntry = previous.entries[path4];
+    if (!previousEntry) {
+      added.push(path4);
+    } else if (previousEntry.fingerprint !== fingerprint) {
+      changed.push(path4);
+    } else {
+      unchanged.push(path4);
+    }
+  }
+  const removed = Object.keys(previous.entries).filter(
+    (path4) => !currentFingerprints.has(path4)
+  );
+  return sortChangeSet({ added, changed, removed, unchanged });
+}
+function allContentChanged(entries) {
+  return sortChangeSet({
+    added: entries.map(({ entry }) => entry.path),
+    changed: [],
+    removed: [],
+    unchanged: []
+  });
+}
+function hasContentChanges(changeSet) {
+  return changeSet.added.length > 0 || changeSet.changed.length > 0 || changeSet.removed.length > 0;
+}
+function sortChangeSet(changeSet) {
+  return {
+    added: [...changeSet.added].sort(),
+    changed: [...changeSet.changed].sort(),
+    removed: [...changeSet.removed].sort(),
+    unchanged: [...changeSet.unchanged].sort()
+  };
+}
+
+// src/content/content_build_coordinator.ts
+var ContentBuildCoordinator = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  dependencies;
+  preparation = null;
+  getPreparation(incremental) {
+    this.preparation ??= this.prepare(incremental);
+    return this.preparation;
+  }
+  async commit(preparation, manifest) {
+    const entriesBySlug = new Map(
+      manifest.entries.map((entry) => [entry.slug, entry])
+    );
+    const state = {
+      version: CONTENT_BUILD_STATE_VERSION,
+      entries: Object.fromEntries(
+        preparation.currentEntries.map(({ entry, fingerprint }) => {
+          const manifestEntry = entriesBySlug.get(toSlug(entry.path));
+          return [
+            entry.path,
+            {
+              fingerprint,
+              dependencies: collectDependencies2(manifestEntry)
+            }
+          ];
+        })
+      ),
+      contentIndex: Object.fromEntries(
+        [...manifest.contentIndex.entries()].sort(
+          ([left], [right]) => left.localeCompare(right)
+        )
+      )
+    };
+    try {
+      await saveContentBuildState(this.dependencies.buildStatePath, state);
+    } catch {
+    }
+  }
+  async prepare(incremental) {
+    const currentEntries = await fingerprintContentEntries(
+      await this.dependencies.getEntries(),
+      (entry) => this.dependencies.readEntry(entry)
+    );
+    const previousState = incremental === false ? void 0 : await loadContentBuildState(this.dependencies.buildStatePath);
+    const changeSet = previousState ? diffContentEntries(previousState, currentEntries) : allContentChanged(currentEntries);
+    const affected = determineAffectedContent(
+      changeSet,
+      previousState,
+      currentEntries.map(({ entry }) => entry.path)
+    );
+    this.dependencies.observability.tracer.event("build.incremental", {
+      incremental: incremental !== false,
+      added: changeSet.added.length,
+      changed: changeSet.changed.length,
+      removed: changeSet.removed.length,
+      unchanged: changeSet.unchanged.length,
+      affected: affected.direct.size + affected.dependent.size
+    });
+    return { previousState, currentEntries, changeSet };
+  }
+};
+function toSlug(path4) {
+  return path4.replace(/\.md$/, "");
+}
+function collectDependencies2(manifestEntry) {
+  if (!manifestEntry) return [];
+  return [
+    ...new Set(
+      manifestEntry.links.filter(
+        (link) => link.slug !== null
+      ).map((link) => link.slug)
+    )
+  ].sort();
+}
+
+// src/content/content_entry_reader.ts
+var ContentEntryReader = class {
+  constructor(source, observability) {
+    this.source = source;
+    this.observability = observability;
+  }
+  source;
+  observability;
+  entries = null;
+  texts = /* @__PURE__ */ new Map();
+  async getEntries() {
+    this.entries ??= await this.observability.tracer.span(
+      "content.scan",
+      {},
+      () => this.source.scan()
+    );
+    return this.entries;
+  }
+  async readText(logicalPath) {
+    const entry = (await this.getEntries()).find(
+      (current) => current.path === logicalPath
+    );
+    if (!entry) throw new Error(`Content entry was not found: ${logicalPath}`);
+    return await this.read(entry);
+  }
+  read(entry) {
+    const cached = this.texts.get(entry.path);
+    if (cached) return cached;
+    const content = this.source.read(entry).then(
+      (value) => typeof value === "string" ? value : new TextDecoder().decode(value)
+    );
+    this.texts.set(entry.path, content);
+    return content;
+  }
+};
+
+// src/utils/tags.ts
+function normalizeTag(raw) {
+  const cleaned = raw.replace(/[/-]+$/, "");
+  if (!cleaned) return null;
+  const isPurelyNumeric = /^[\p{N}/\-_]+$/u.test(cleaned);
+  return isPurelyNumeric ? null : cleaned;
+}
+
+// src/content/content_metadata.ts
+var TAG_PATTERN = /(^|[\s([{"'])#([\p{L}\p{N}_\-/]+)/gu;
+function extractContentTags(markdown) {
+  TAG_PATTERN.lastIndex = 0;
+  const tags = [];
+  for (let match = TAG_PATTERN.exec(markdown); match !== null; match = TAG_PATTERN.exec(markdown)) {
+    const tag = normalizeTag(match[2] ?? "");
+    if (tag) tags.push(tag);
+  }
+  return uniqueStrings(tags);
+}
+function normalizeFrontmatterTags(tags) {
+  if (Array.isArray(tags)) {
+    return tags.flatMap((tag) => normalizeFrontmatterTags(tag));
+  }
+  if (typeof tags !== "string") return [];
+  return tags.split(/[\s,]+/).map((tag) => normalizeTag(tag.replace(/^#/, ""))).filter((tag) => tag !== null);
+}
+function extractFrontmatterAliases(markdown) {
+  const frontmatter = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatter?.[1]) return [];
+  const aliases = [];
+  const lines = frontmatter[1].split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const inlineMatch = line.match(/^aliases?:\s*(.+)$/i);
+    if (inlineMatch?.[1]) {
+      aliases.push(...parseYamlScalarOrList(inlineMatch[1]));
+      continue;
+    }
+    if (/^aliases?:\s*$/i.test(line)) {
+      for (let j = i + 1; j < lines.length; j++) {
+        const itemMatch = lines[j]?.match(/^\s*-\s*(.+)$/);
+        if (!itemMatch?.[1]) break;
+        aliases.push(stripYamlQuotes(itemMatch[1]));
+      }
+    }
+  }
+  return uniqueStrings(aliases.map((alias) => alias.trim()).filter(Boolean));
+}
+function parseYamlScalarOrList(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return trimmed.slice(1, -1).split(",").map(stripYamlQuotes).filter(Boolean);
+  }
+  return [stripYamlQuotes(trimmed)];
+}
+function stripYamlQuotes(value) {
+  return value.trim().replace(/^[']|[']$/g, "").replace(/^["]|["]$/g, "");
+}
+
+// src/content/content_index_builder.ts
+var ContentIndexBuilder = class {
+  constructor(source) {
+    this.source = source;
+  }
+  source;
+  async build(contentEntries, read = (entry) => this.source.read(entry)) {
+    const index = /* @__PURE__ */ new Map();
+    for (const contentEntry of contentEntries) {
+      await this.indexContentEntry(index, contentEntry, read);
+    }
+    return index;
+  }
+  async indexContentEntry(index, contentEntry, read) {
+    const contentPath = contentEntry.path;
+    const ext = contentPath.split(".").pop()?.toLowerCase() ?? "";
+    const value = ext === "md" ? contentPath.replace(/\.md$/, "") : contentPath;
+    const parts = value.split("/");
+    for (let i = parts.length - 1; i >= 0; i--) {
+      const rawSuffix = parts.slice(i).join("/");
+      addIndexEntry(index, rawSuffix, value);
+      if (ext !== "md") {
+        addIndexEntry(index, rawSuffix.replace(/\.[^/.]+$/, ""), value);
+      }
+    }
+    if (ext === "md") {
+      const markdown = readText(await read(contentEntry));
+      for (const alias of extractFrontmatterAliases(markdown)) {
+        addIndexEntry(index, alias, value);
+      }
+    }
+  }
+};
+function readText(content) {
+  return typeof content === "string" ? content : new TextDecoder().decode(content);
+}
+function addIndexEntry(index, key, value) {
+  const normalizedKey = key.toLowerCase();
+  if (!index.has(normalizedKey)) index.set(normalizedKey, value);
+}
+
+// src/content/content_location_resolver.ts
+var ContentLocationResolver = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  dependencies;
+  locations = null;
+  async getLocations() {
+    if (this.locations) return this.locations;
+    const [entries, contentIndex] = await Promise.all([
+      this.dependencies.getEntries(),
+      this.dependencies.getContentIndex()
+    ]);
+    await this.dependencies.pluginRuntime.startBuild(contentIndex);
+    const inputs = await Promise.all(
+      entries.filter((entry) => entry.path.endsWith(".md")).map(async (entry) => ({
+        slug: toSlug2(entry.path),
+        path: entry.path,
+        markdown: await this.dependencies.readEntry(entry)
+      }))
+    );
+    const locations = new Map(
+      inputs.map((input) => [input.slug, resolveDefaultContentLocation(input)])
+    );
+    for (const location of await this.dependencies.pluginRuntime.resolveContentLocations(
+      inputs,
+      contentIndex
+    )) {
+      if (!locations.has(location.slug)) {
+        throw new Error(
+          `Content public location references an unknown slug: ${location.slug}`
+        );
+      }
+      locations.set(location.slug, location);
+    }
+    await this.dependencies.pluginRuntime.extendContentLocations(
+      inputs,
+      locations,
+      contentIndex
+    );
+    this.locations = locations;
+    return locations;
+  }
+  async getPermalinks() {
+    return new Map(
+      Array.from(
+        (await this.getLocations()).entries(),
+        ([slug, location]) => [slug, location.permalink]
+      )
+    );
+  }
+  populateRedirects(manifest, locations) {
+    for (const [slug, location] of locations) {
+      for (const redirect of location.redirects ?? []) {
+        manifest.redirects.set(redirect.path, { ...redirect, slug });
+      }
+    }
+  }
+};
+function toSlug2(path4) {
+  return path4.replace(/\.md$/, "");
+}
+
+// src/content/file_system_content_source.ts
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+var FileSystemContentSource = class {
+  constructor(contentDirectory, exclude = []) {
+    this.contentDirectory = contentDirectory;
+    this.exclude = exclude;
+  }
+  contentDirectory;
+  exclude;
+  async scan() {
+    return await this.scanDirectory(this.contentDirectory, "");
+  }
+  async read(entry) {
+    const filePath = this.resolveFilePath(entry.path);
+    const stats = await fs3.lstat(filePath);
+    if (!stats.isFile() || stats.isSymbolicLink()) {
+      throw new Error(`Content entry is not a regular file: ${entry.path}`);
+    }
+    return await fs3.readFile(filePath);
+  }
+  async scanDirectory(directory, parentPath) {
+    const directoryEntries = await fs3.readdir(directory, {
+      withFileTypes: true
+    });
+    const entries = [];
+    for (const directoryEntry of directoryEntries) {
+      if (directoryEntry.isSymbolicLink()) continue;
+      const logicalPath = normalizeContentPath(
+        parentPath ? `${parentPath}/${directoryEntry.name}` : directoryEntry.name
+      );
+      const filePath = path3.join(directory, directoryEntry.name);
+      if (directoryEntry.isDirectory()) {
+        entries.push(...await this.scanDirectory(filePath, logicalPath));
+        continue;
+      }
+      if (!directoryEntry.isFile() || this.isExcluded(logicalPath)) continue;
+      const stats = await fs3.stat(filePath);
+      entries.push({
+        path: logicalPath,
+        metadata: {
+          modifiedAt: stats.mtimeMs,
+          size: stats.size
+        }
+      });
+    }
+    return entries;
+  }
+  isExcluded(logicalPath) {
+    if (isExcluded(this.exclude, logicalPath)) return true;
+    return logicalPath.endsWith(".md") && isExcluded(this.exclude, logicalPath.slice(0, -3));
+  }
+  resolveFilePath(logicalPath) {
+    const normalizedPath = normalizeLogicalPath(logicalPath);
+    const filePath = path3.resolve(this.contentDirectory, normalizedPath);
+    const relativePath = path3.relative(this.contentDirectory, filePath);
+    if (relativePath.startsWith("..") || path3.isAbsolute(relativePath)) {
+      throw new Error(`Invalid content path: ${logicalPath}`);
+    }
+    return filePath;
+  }
+};
+function normalizeLogicalPath(logicalPath) {
+  const normalizedPath = normalizeContentPath(logicalPath);
+  if (normalizedPath.length === 0 || normalizedPath.startsWith("/") || path3.isAbsolute(normalizedPath) || path3.win32.isAbsolute(normalizedPath) || normalizedPath.split("/").some((segment) => segment === "..")) {
+    throw new Error(`Invalid content path: ${logicalPath}`);
+  }
+  return normalizedPath;
+}
+
+// src/content/content_links.ts
+var WIKILINK_PATTERN = /(!)?\[\[([^\]|#^]+)(?:[#^][^\]|]+)?(?:\|[^\]]+)?\]\]/g;
+function extractContentLinks(markdown, contentIndex) {
+  WIKILINK_PATTERN.lastIndex = 0;
+  const links = [];
+  for (let match = WIKILINK_PATTERN.exec(markdown); match !== null; match = WIKILINK_PATTERN.exec(markdown)) {
+    const rawTarget = match[2]?.trim();
+    if (!rawTarget) continue;
+    const resolved = contentIndex.get(rawTarget.toLowerCase()) ?? null;
+    links.push({
+      raw: rawTarget,
+      slug: resolved,
+      kind: resolved ? linkKind(resolved) : "unresolved",
+      embed: match[1] === "!"
+    });
+  }
+  return links;
+}
+function linkKind(value) {
+  if (isImagePath(value)) return "image";
+  if (isAttachmentPath(value)) return "attachment";
+  return "note";
+}
+
+// src/content/manifest_builder.ts
+var ManifestBuilder = class {
+  createEntry(slug, markdown, processed, contentIndex, location) {
+    const links = extractContentLinks(markdown, contentIndex);
+    const assets = links.filter(
+      (link) => (link.kind === "image" || link.kind === "attachment") && link.slug !== null
+    ).map((link) => ({ path: link.slug }));
+    return {
+      slug,
+      permalink: location.permalink,
+      publicLocation: location,
+      title: getManifestTitle(slug, processed.frontmatter.title),
+      frontmatter: processed.frontmatter,
+      html: processed.html,
+      tags: uniqueStrings([
+        ...normalizeFrontmatterTags(processed.frontmatter.tags),
+        ...extractContentTags(markdown)
+      ]),
+      links,
+      backlinks: [],
+      assets: uniqueAssets(assets)
+    };
+  }
+  build(entries, contentIndex) {
+    const bySlug = new Map(entries.map((entry) => [entry.slug, entry]));
+    const byPermalink = new Map(
+      entries.map((entry) => [entry.permalink, entry])
+    );
+    const byTag = /* @__PURE__ */ new Map();
+    const byAsset = /* @__PURE__ */ new Map();
+    const outgoingLinks = /* @__PURE__ */ new Map();
+    const incomingLinks = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      outgoingLinks.set(entry.slug, entry.links);
+      for (const tag of entry.tags) appendToMap(byTag, tag, entry);
+      for (const asset of entry.assets) appendToMap(byAsset, asset.path, entry);
+      for (const link of entry.links) {
+        if (link.kind !== "note" || !link.slug || link.slug === entry.slug) {
+          continue;
+        }
+        appendUniqueToMap(incomingLinks, link.slug, entry.slug);
+      }
+    }
+    for (const entry of entries) {
+      entry.backlinks = incomingLinks.get(entry.slug) ?? [];
+    }
+    const manifest = {
+      entries,
+      publicEntries: [...entries],
+      bySlug,
+      byPermalink,
+      redirects: /* @__PURE__ */ new Map(),
+      publicRedirects: /* @__PURE__ */ new Map(),
+      byTag,
+      byAsset,
+      outgoingLinks,
+      incomingLinks,
+      contentIndex,
+      assets: [],
+      diagnostics: [],
+      generatedOutputs: []
+    };
+    return { ...manifest, graph: createContentGraph(manifest) };
+  }
+};
+function getManifestTitle(slug, title) {
+  return typeof title === "string" && title.trim() ? title : slug;
+}
+function uniqueAssets(assets) {
+  return Array.from(
+    new Map(assets.map((asset) => [asset.path, asset])).values()
+  );
+}
+function appendToMap(map, key, value) {
+  const values = map.get(key) ?? [];
+  values.push(value);
+  map.set(key, values);
+}
+function appendUniqueToMap(map, key, value) {
+  const values = map.get(key) ?? [];
+  if (!values.includes(value)) values.push(value);
+  map.set(key, values);
+}
+
+// src/content/content_manager.ts
+var ContentManager = class {
+  constructor(content, exclude = [], pipelineOptions = {}) {
+    this.pipelineOptions = pipelineOptions;
+    this.pipelineOptions = {
+      ...pipelineOptions,
+      plugins: pipelineOptions.plugins ?? pipelineOptions.config?.plugins
+    };
+    this.source = typeof content === "string" ? pipelineOptions.config?.content.source ?? new FileSystemContentSource(content, [
+      ...exclude,
+      CONTENT_BUILD_STATE_EXCLUDE
+    ]) : content;
+    this.pipelineOptions = {
+      ...this.pipelineOptions,
+      contentSource: this.source
+    };
+    this.contentIndexBuilder = new ContentIndexBuilder(this.source);
+    this.pluginRuntime = new PluginRuntime(this.pipelineOptions);
+    const buildStatePath = resolveContentBuildStatePath(
+      pipelineOptions.config,
+      typeof content === "string" ? content : void 0
+    );
+    const observability = this.observability();
+    this.entryReader = new ContentEntryReader(this.source, observability);
+    this.locationResolver = new ContentLocationResolver({
+      getEntries: () => this.entryReader.getEntries(),
+      readEntry: (entry) => this.entryReader.read(entry),
+      getContentIndex: () => this.getContentIndex(),
+      pluginRuntime: this.pluginRuntime
+    });
+    this.buildCoordinator = new ContentBuildCoordinator({
+      buildStatePath,
+      getEntries: () => this.entryReader.getEntries(),
+      readEntry: (entry) => this.entryReader.read(entry),
+      observability
+    });
+  }
+  pipelineOptions;
+  source;
+  contentIndexBuilder;
+  manifestBuilder = new ManifestBuilder();
+  pluginRuntime;
+  contentIndex = null;
+  contentCache = /* @__PURE__ */ new Map();
+  manifest = null;
+  pipeline = null;
+  entryReader;
+  locationResolver;
+  buildCoordinator;
+  isBuildTime = false;
+  async getAllPosts() {
+    return (await this.scan()).filter((entry) => entry.path.endsWith(".md")).map((entry) => ({ slug: entry.path.replace(/\.md$/, "") }));
+  }
+  async scan() {
+    return await this.entryReader.getEntries();
+  }
+  async getPost(slug) {
+    return await this.entryReader.readText(`${slug}.md`);
+  }
+  async getContentIndex(preparation) {
+    if (this.contentIndex) return this.contentIndex;
+    if (preparation?.previousState && !hasContentChanges(preparation.changeSet)) {
+      this.contentIndex = new Map(
+        Object.entries(preparation.previousState.contentIndex)
+      );
+      return this.contentIndex;
+    }
+    this.contentIndex = await this.contentIndexBuilder.build(
+      await this.entryReader.getEntries(),
+      (entry) => this.entryReader.read(entry)
+    );
+    return this.contentIndex;
+  }
+  async getProcessedContent(slug) {
+    const cached = this.contentCache.get(slug);
+    if (cached) return cached;
+    return await this.observability().tracer.span(
+      "content.process",
+      {
+        contentPath: `${slug}.md`
+      },
+      async () => {
+        const [contentIndex, rawPost] = await Promise.all([
+          this.getContentIndex(),
+          this.getPost(slug)
+        ]);
+        await this.pluginRuntime.startBuild(contentIndex);
+        await this.pluginRuntime.runContentLoaded(slug, rawPost, contentIndex);
+        this.pipeline ??= new Pipeline(
+          contentIndex,
+          await this.locationResolver.getPermalinks(),
+          (postSlug) => this.getPost(postSlug),
+          this.pipelineOptions,
+          this.isBuildTime
+        );
+        const content = await this.pipeline.execute(
+          rawPost,
+          0,
+          /* @__PURE__ */ new Set([slug])
+        );
+        await this.pluginRuntime.runPostHook(
+          "onPostParsed",
+          slug,
+          rawPost,
+          content,
+          contentIndex
+        );
+        await this.pluginRuntime.runPostHook(
+          "onPostProcessed",
+          slug,
+          rawPost,
+          content,
+          contentIndex
+        );
+        this.contentCache.set(slug, content);
+        return content;
+      }
+    );
+  }
+  async getManifest(options) {
+    if (this.manifest) return this.manifest;
+    this.enableBuildTime();
+    const preparation = options ? await this.buildCoordinator.getPreparation(options.incremental) : void 0;
+    return await this.observability().tracer.span(
+      "content.manifest",
+      {},
+      async () => {
+        const [posts, contentIndex, locations] = await Promise.all([
+          this.getAllPosts(),
+          this.getContentIndex(preparation),
+          this.getContentLocations()
+        ]);
+        const entries = await Promise.all(
+          posts.map(async (post) => {
+            const [rawPost, processed] = await Promise.all([
+              this.getPost(post.slug),
+              this.getProcessedContent(post.slug)
+            ]);
+            const location = locations.get(post.slug);
+            if (!location) {
+              throw new Error(
+                `Content public location was not resolved: ${post.slug}`
+              );
+            }
+            return this.manifestBuilder.createEntry(
+              post.slug,
+              rawPost,
+              processed,
+              contentIndex,
+              location
+            );
+          })
+        );
+        await this.pluginRuntime.runGraphHook(entries, contentIndex);
+        const manifest = await this.observability().tracer.span(
+          "content.graph",
+          {},
+          () => this.manifestBuilder.build(entries, contentIndex)
+        );
+        this.locationResolver.populateRedirects(manifest, locations);
+        await this.pluginRuntime.runManifestCreated(manifest, contentIndex);
+        this.applyPublicView(manifest);
+        manifest.assets = this.pluginRuntime.collectAssets();
+        manifest.diagnostics = [
+          ...this.pluginRuntime.getDiagnostics(),
+          ...await this.pluginRuntime.collectDiagnostics(contentIndex)
+        ];
+        await this.pluginRuntime.runBuildEnd(manifest, contentIndex);
+        manifest.generatedOutputs = this.pluginRuntime.collectGeneratedOutputs();
+        if (preparation)
+          await this.buildCoordinator.commit(preparation, manifest);
+        this.manifest = manifest;
+        return manifest;
+      }
+    );
+  }
+  async build(options = {}) {
+    return await this.getManifest(options);
+  }
+  async getBacklinks(targetSlug) {
+    const graph = await this.getContentGraph();
+    return graph.incomingSlugs(targetSlug).map((slug) => ({
+      slug
+    }));
+  }
+  async getContentGraph() {
+    const manifest = await this.getManifest();
+    return manifest.graph;
+  }
+  async getDiagnostics() {
+    const manifest = await this.getManifest();
+    return manifest.diagnostics;
+  }
+  async inspect() {
+    const [entries, contentIndex] = await Promise.all([
+      this.entryReader.getEntries(),
+      this.getContentIndex()
+    ]);
+    const diagnostics = await this.pluginRuntime.collectDiagnostics(contentIndex);
+    return { entries, contentIndex, diagnostics };
+  }
+  async dispose() {
+    if (!this.contentIndex) return;
+    await this.pluginRuntime.dispose(this.contentIndex);
+  }
+  async getContentLocations() {
+    return await this.locationResolver.getLocations();
+  }
+  applyPublicView(manifest) {
+    const strategy = this.pipelineOptions.config?.content.filters.publishStrategy ?? "explicit";
+    manifest.publicEntries = manifest.entries.filter(
+      (entry) => isPublishable(strategy, entry.frontmatter)
+    );
+    const publicSlugs = new Set(
+      manifest.publicEntries.map((entry) => entry.slug)
+    );
+    manifest.publicRedirects = new Map(
+      [...manifest.redirects].filter(
+        ([, redirect]) => publicSlugs.has(redirect.slug)
+      )
+    );
+  }
+  enableBuildTime() {
+    this.isBuildTime = true;
+    this.pluginRuntime.enableBuildTime();
+  }
+  observability() {
+    return this.pipelineOptions.observability ?? noopObservability;
+  }
+};
+
+// src/content/content_source.ts
+async function readContentSourceEntry(source, logicalPath) {
+  const entry = await getContentSourceEntry(source, logicalPath);
+  return entry ? await source.read(entry) : null;
+}
+async function getContentSourceEntry(source, logicalPath) {
+  return (await source.scan()).find((candidate) => candidate.path === logicalPath) ?? null;
+}
+
+// src/content/read_only_content_graph.ts
+async function readOnlyContentGraph(source, locations) {
+  const entries = await source.scan();
+  const contentIndex = await new ContentIndexBuilder(source).build(entries);
+  const markdownEntries = entries.filter((entry) => entry.path.endsWith(".md")).toSorted((left, right) => left.path.localeCompare(right.path));
+  const markdownContents = await Promise.all(
+    markdownEntries.map(async (entry) => ({
+      entry,
+      markdown: await readText2(source, entry)
+    }))
+  );
+  const graphEntries = markdownContents.map(
+    ({ entry, markdown }) => createGraphEntry(entry, markdown, contentIndex, locations)
+  );
+  return new ManifestBuilder().build(graphEntries, contentIndex).graph;
+}
+function createGraphEntry(entry, markdown, contentIndex, locations) {
+  const slug = entry.path.replace(/\.md$/, "");
+  const location = locations.get(slug);
+  if (!location) {
+    throw new Error(`Content public location was not resolved: ${slug}`);
+  }
+  return {
+    slug,
+    permalink: location.permalink,
+    publicLocation: location,
+    title: slug,
+    frontmatter: {},
+    html: "",
+    tags: [],
+    links: extractContentLinks(markdown, contentIndex),
+    backlinks: [],
+    assets: []
+  };
+}
+async function readText2(source, entry) {
+  const content = await source.read(entry);
+  return typeof content === "string" ? content : new TextDecoder().decode(content);
+}
+
+// src/utils/html.ts
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeHtmlAttribute(value) {
+  return escapeHtml(value);
+}
+
+// src/utils/text.ts
+function stripHtml(html) {
+  return html.replace(/<script\b[\s\S]*?<\/script>/gi, " ").replace(/<style\b[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ");
+}
+function calculateReadingTime(html) {
+  const text = stripHtml(html).trim();
+  if (!text) return 1;
+  const cjkCharacters = text.match(/\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}/gu)?.length ?? 0;
+  const latinWords = text.replace(/\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}/gu, " ").match(/[\p{L}\p{N}]+/gu)?.length ?? 0;
+  return Math.max(1, Math.ceil(cjkCharacters / 500 + latinWords / 220));
+}
+
+// src/plugin/plugin_memo.ts
+import { createHash as createHash3 } from "node:crypto";
+function createPluginMemo(cache, options = {}) {
+  return {
+    async memo(key, dependencies, compute) {
+      const memoKey = `${key}:${hash2(stableStringify(dependencies))}`;
+      try {
+        const cached = await cache.get(memoKey);
+        if (cached !== void 0) return cached;
+      } catch (error) {
+        warn(options.logger, "Plugin cache read failed; recomputing.", key, error);
+      }
+      const value = await compute();
+      try {
+        await cache.set(memoKey, value);
+      } catch (error) {
+        warn(options.logger, "Plugin cache write failed; result not cached.", key, error);
+      }
+      return value;
+    }
+  };
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  const body = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",");
+  return `{${body}}`;
+}
+function hash2(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+function warn(logger, message, key, error) {
+  logger?.warn(message, {
+    memoKey: key,
+    error: error instanceof Error ? error.message : String(error)
+  });
+}
+
+// src/types/plugin_asset.ts
+function createStyleAsset(pluginName) {
+  return {
+    pluginName,
+    kind: "style",
+    moduleSpecifier: `@riebeckite/plugin-${pluginName}/style.css`
+  };
+}
+function createClientEntry(pluginName, exportName) {
+  return {
+    pluginName,
+    moduleSpecifier: `@riebeckite/plugin-${pluginName}/client`,
+    ...exportName === void 0 ? {} : { exportName }
+  };
+}
+
+// src/types/plugin_endpoint.ts
+function defineEndpoint(path4, handler, options = {}) {
+  if (options.cacheControl === void 0) {
+    return { path: path4, handler };
+  }
+  return {
+    path: path4,
+    handler: async (context) => {
+      const response = await handler(context);
+      return {
+        ...response,
+        headers: {
+          ...response.headers,
+          "Cache-Control": options.cacheControl
+        }
+      };
+    }
+  };
+}
+export {
+  ATTACHMENTS_BASE_PATH,
+  CompositeTraceSink,
+  ConfigValidationError,
+  ConsoleLogger,
+  ContentManager,
+  FileSystemContentSource,
+  IMAGE_EXTENSIONS,
+  NoopLogger,
+  NoopTracer,
+  Pipeline,
+  PluginDependencyError,
+  SinkTracer,
+  attachmentUrl,
+  buildContentCollections,
+  buildGraphEdges,
+  calculateReadingTime,
+  createClientEntry,
+  createContentGraph,
+  createPluginMemo,
+  createStyleAsset,
+  createUnavailableGeneratedOutputSink,
+  defineConfig,
+  defineEndpoint,
+  definePlugin,
+  defineTheme,
+  escapeHtml,
+  escapeHtmlAttribute,
+  extractFrontmatterAliases,
+  fingerprintContentEntries,
+  getContentSourceEntry,
+  getExtension,
+  getResolvedPluginMetadata,
+  groupContentEntries,
+  isAttachmentPath,
+  isExcluded,
+  isImagePath,
+  isMarkdownPath,
+  isPublishable,
+  isPublished,
+  layoutRadialGraph,
+  loadContentBuildState,
+  normalizeContentPath,
+  normalizeGeneratedOutputPath,
+  normalizeTag,
+  queryContentEntries,
+  queryContentPage,
+  readContentBuildStateStatus,
+  readContentSourceEntry,
+  readOnlyContentGraph,
+  resolveConfig,
+  resolveConfigModule,
+  resolveContentBuildStatePath,
+  resolveContentQueryPagination,
+  resolveDefaultContentLocation,
+  resolvePlugins,
+  stableStringify,
+  stripHtml,
+  uniqueStrings
+};