cantip 0.1.0

package/dist/generate-content.mjs

@@ -0,0 +1,1665 @@
+// scripts/generate-content.ts
+import fs9 from "node:fs/promises";
+import path10 from "node:path";
+
+// scripts/obsidian/types.ts
+import { z } from "zod";
+
+// scripts/obsidian/path.ts
+import path from "node:path";
+import { slug } from "github-slugger";
+function getExtension(filePath) {
+  return path.parse(filePath).ext;
+}
+function stripExtension(filePath) {
+  return path.parse(filePath).name;
+}
+function extractPathAndAnchor(filePathAndAnchor) {
+  const [filePath, fileAnchor] = filePathAndAnchor.split("#", 2);
+  return [filePath, fileAnchor];
+}
+function isAnchor(filePath) {
+  return filePath.startsWith("#");
+}
+function slugifyPath(filePath) {
+  const segments = filePath.split("/");
+  return segments.map((segment, index) => {
+    const isLastSegment = index === segments.length - 1;
+    if (!isLastSegment) {
+      return slug(segment);
+    }
+    const parsedPath = path.parse(segment);
+    return `${slug(parsedPath.name)}${parsedPath.ext}`;
+  }).join("/");
+}
+function slashify(filePath) {
+  const isExtendedLengthPath = filePath.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return filePath;
+  }
+  return filePath.replaceAll("\\", "/");
+}
+function stripLeadingSlash(href) {
+  if (href.startsWith("/"))
+    href = href.slice(1);
+  return href;
+}
+function stripTrailingSlash(href) {
+  if (href.endsWith("/"))
+    href = href.slice(0, -1);
+  return href;
+}
+function stripLeadingAndTrailingSlashes(href) {
+  return stripTrailingSlash(stripLeadingSlash(href));
+}
+
+// scripts/obsidian/types.ts
+var obsidianConfigSchema = z.object({
+  configFolder: z.string().startsWith(".").default(".obsidian"),
+  copyFrontmatter: z.boolean().default(false),
+  ignore: z.array(z.string()).default([]),
+  math: z.object({
+    singleDollarTextMath: z.boolean().default(true)
+  }).prefault({}),
+  output: z.string().default("notes").refine(
+    (value) => {
+      const label = stripLeadingAndTrailingSlashes(value);
+      return label === "." || label !== "" && !label.startsWith("..");
+    },
+    { error: "The `output` directory cannot be empty or start with '..'." }
+  ),
+  skipGeneration: z.boolean().default(false),
+  vault: z.string()
+});
+
+// scripts/obsidian/obsidian.ts
+import fs4 from "node:fs/promises";
+import path5 from "node:path";
+import { z as z2 } from "zod";
+import decodeUriComponent from "decode-uri-component";
+import { slug as slug2 } from "github-slugger";
+import { globby } from "globby";
+import yaml2 from "yaml";
+
+// scripts/obsidian/fs.ts
+import fs from "node:fs/promises";
+import path2 from "node:path";
+async function isDirectory(path11) {
+  try {
+    const stats = await fs.stat(path11);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function isFile(path11) {
+  try {
+    const stats = await fs.stat(path11);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+function ensureDirectory(path11) {
+  return fs.mkdir(path11, { recursive: true });
+}
+function removeDirectory(path11) {
+  return fs.rm(path11, { force: true, recursive: true });
+}
+async function copyFile(sourcePath, destinationPath) {
+  const dirPath = path2.dirname(destinationPath);
+  await ensureDirectory(dirPath);
+  return fs.copyFile(sourcePath, destinationPath);
+}
+
+// scripts/obsidian/files.ts
+import fs3 from "node:fs/promises";
+import path4 from "node:path";
+
+// scripts/obsidian/markdown.ts
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { remark } from "remark";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import { VFile } from "vfile";
+
+// scripts/obsidian/remark.ts
+import fs2 from "node:fs";
+import path3 from "node:path";
+import { toHtml } from "hast-util-to-html";
+import isAbsoluteUrl from "is-absolute-url";
+import { findAndReplace } from "mdast-util-find-and-replace";
+import { toHast } from "mdast-util-to-hast";
+import { customAlphabet } from "nanoid";
+import { CONTINUE, EXIT, SKIP, visit } from "unist-util-visit";
+import yaml from "yaml";
+
+// scripts/obsidian/html.ts
+import { rehype } from "rehype";
+import rehypeMermaid from "rehype-mermaid";
+var processor = rehype().data("settings", {
+  fragment: true,
+  closeSelfClosing: true
+}).use(rehypeMermaid, {
+  dark: true,
+  strategy: "img-svg"
+});
+async function transformHtmlToString(html) {
+  const file = await processor.process(html);
+  return String(file);
+}
+
+// scripts/obsidian/remark.ts
+var generateAssetImportId = customAlphabet("abcdefghijklmnopqrstuvwxyz", 6);
+var highlightReplacementRegex = /==(?<highlight>(?:(?!==).)+)==/g;
+var commentReplacementRegex = /%%(?<comment>(?:(?!%%).)+)%%/gs;
+var wikilinkReplacementRegex = /!?\[\[(?<url>(?:(?![[\]|]).)+)(?:\|(?<maybeText>(?:(?![[\]]).)+))?]]/g;
+var tagReplacementRegex = /(?:^|\s)#(?<tag>[\w/-]+)/g;
+var calloutRegex = /^\[!(?<type>\w+)][+-]? ?(?<title>.*)$/;
+var imageSizeRegex = /^(?:(?<altText>.*)\|)?(?:(?<widthOnly>\d+)|(?:(?<width>\d+)x(?<height>\d+)))$/;
+var mdxNonClosingVoidElementRegex = /<(?<tag>br|hr)(?<attrs>[^/>]*)>/g;
+function remarkObsidian() {
+  return async function transformer(tree, file) {
+    const obsidianFrontmatter = getObsidianFrontmatter(tree);
+    if (obsidianFrontmatter && obsidianFrontmatter.publish === false) {
+      file.data.skip = true;
+      return;
+    }
+    markBlankGaps(tree);
+    handleReplacements(tree, file);
+    await handleMermaid(tree, file);
+    await handleImagesAndNoteEmbeds(tree, file);
+    visit(tree, (node, index, parent) => {
+      const context = { file, index, parent };
+      switch (node.type) {
+        case "math":
+        case "inlineMath": {
+          return handleMath(context);
+        }
+        case "link": {
+          return handleLinks(node, context);
+        }
+        case "blockquote": {
+          return handleBlockquotes(node, context);
+        }
+        default: {
+          return CONTINUE;
+        }
+      }
+    });
+    handleFrontmatter(tree, file, obsidianFrontmatter);
+    handleImports(tree, file);
+    if (file.data.isMdx) {
+      closeVoidElements(tree);
+    }
+  };
+}
+var BLANK_GAP_MARKER = "<!--blank-gap-->";
+var FLOW_PARENTS = /* @__PURE__ */ new Set(["root", "blockquote", "listItem"]);
+function markBlankGaps(tree) {
+  function walk(parent) {
+    const children = parent.children;
+    for (let i = 0; i < children.length; i++) {
+      const node = children[i];
+      const prev = children[i - 1];
+      if (prev && node.type !== "html" && prev.position && node.position && node.position.start.line - prev.position.end.line >= 2) {
+        children.splice(i, 0, { type: "html", value: BLANK_GAP_MARKER });
+        i++;
+      }
+      if (node.type === "list") {
+        for (const item of node.children)
+          walk(item);
+      } else if (FLOW_PARENTS.has(node.type) && "children" in node) {
+        walk(node);
+      }
+    }
+  }
+  walk(tree);
+}
+function getObsidianFrontmatter(tree) {
+  for (const node of tree.children) {
+    if (node.type !== "yaml") {
+      continue;
+    }
+    const obsidianFrontmatter = parseObsidianFrontmatter(node.value);
+    if (obsidianFrontmatter) {
+      return obsidianFrontmatter;
+    }
+  }
+  return;
+}
+function handleFrontmatter(tree, file, obsidianFrontmatter) {
+  if (file.data.embedded) {
+    for (const [index, node] of tree.children.entries()) {
+      if (node.type !== "yaml") {
+        continue;
+      }
+      tree.children.splice(index, 1);
+      break;
+    }
+    return;
+  }
+  let hasFrontmatter = false;
+  for (const node of tree.children) {
+    if (node.type !== "yaml") {
+      continue;
+    }
+    node.value = getFrontmatterNodeValue(file, obsidianFrontmatter);
+    hasFrontmatter = true;
+    if (obsidianFrontmatter?.aliases && obsidianFrontmatter.aliases.length > 0) {
+      file.data.aliases = obsidianFrontmatter.aliases;
+    }
+    break;
+  }
+  if (!hasFrontmatter) {
+    tree.children.unshift({ type: "yaml", value: getFrontmatterNodeValue(file) });
+  }
+}
+function handleImports(_tree, _file) {
+}
+function handleReplacements(tree, file) {
+  findAndReplace(tree, [
+    [
+      highlightReplacementRegex,
+      (_match, highlight) => ({
+        type: "html",
+        value: `<mark class="obs-highlight">${highlight}</mark>`
+      })
+    ],
+    [commentReplacementRegex, null],
+    [
+      wikilinkReplacementRegex,
+      (match, url, maybeText) => {
+        ensureTransformContext(file);
+        let fileUrl;
+        let text = maybeText ?? url;
+        if (isAnchor(url)) {
+          fileUrl = slugifyObsidianAnchor(url);
+          text = maybeText ?? url.slice(isObsidianBlockAnchor(url) ? 2 : 1);
+        } else {
+          const [urlPath, urlAnchor] = extractPathAndAnchor(url);
+          switch (file.data.vault.options.linkFormat) {
+            case "relative": {
+              fileUrl = getFileUrl(file.data.output, getRelativeFilePath(file, urlPath), urlAnchor);
+              break;
+            }
+            case "absolute":
+            case "shortest": {
+              const matchingFile = file.data.files.find(
+                (vaultFile) => vaultFile.isEqualStem(urlPath) || vaultFile.isEqualFileName(urlPath)
+              );
+              fileUrl = getFileUrl(
+                file.data.output,
+                matchingFile ? getFilePathFromVaultFile(matchingFile, urlPath) : urlPath,
+                urlAnchor
+              );
+              break;
+            }
+          }
+        }
+        if (match.startsWith("!")) {
+          const isMarkdown = isMarkdownFile(url, file);
+          return {
+            type: "image",
+            url: isMarkdown ? url : fileUrl,
+            alt: text,
+            data: { isAssetResolved: !isMarkdown }
+          };
+        }
+        return {
+          children: [{ type: "text", value: text }],
+          type: "link",
+          url: fileUrl
+        };
+      }
+    ],
+    [
+      tagReplacementRegex,
+      (_match, tag) => {
+        if (/^\d+$/.test(tag)) {
+          return false;
+        }
+        return {
+          type: "html",
+          value: ` <span class="obs-tag">#${tag}</span>`
+        };
+      }
+    ]
+  ]);
+}
+function handleMath({ file }) {
+  file.data.includeKatexStyles = true;
+  return SKIP;
+}
+function handleLinks(node, { file }) {
+  ensureTransformContext(file);
+  if (file.data.vault.options.linkSyntax === "wikilink" || isAbsoluteUrl(node.url) || !file.dirname) {
+    return SKIP;
+  }
+  if (isAnchor(node.url)) {
+    node.url = slugifyObsidianAnchor(node.url);
+    return SKIP;
+  }
+  const url = path3.basename(decodeURIComponent(node.url));
+  const [urlPath, urlAnchor] = extractPathAndAnchor(url);
+  const matchingFile = file.data.files.find((vaultFile) => vaultFile.isEqualFileName(urlPath));
+  if (!matchingFile) {
+    return SKIP;
+  }
+  switch (file.data.vault.options.linkFormat) {
+    case "relative": {
+      node.url = getFileUrl(file.data.output, getRelativeFilePath(file, node.url), urlAnchor);
+      break;
+    }
+    case "absolute":
+    case "shortest": {
+      node.url = getFileUrl(file.data.output, getFilePathFromVaultFile(matchingFile, node.url), urlAnchor);
+      break;
+    }
+  }
+  return SKIP;
+}
+async function handleImages(node, context) {
+  const { file } = context;
+  ensureTransformContext(file);
+  if (!file.dirname) {
+    return SKIP;
+  }
+  if (isAbsoluteUrl(node.url)) {
+    if (isObsidianFile(node.url, "image")) {
+      handleImagesWithSize(node, context, "external");
+    }
+    return SKIP;
+  }
+  if (isMarkdownFile(node.url, file)) {
+    replaceNode(context, await getMarkdownFileNode(file, node.url));
+    return SKIP;
+  }
+  let fileUrl = node.url;
+  if (!node.data?.isAssetResolved) {
+    switch (file.data.vault.options.linkFormat) {
+      case "relative": {
+        fileUrl = getFileUrl(file.data.output, getRelativeFilePath(file, node.url));
+        break;
+      }
+      case "absolute": {
+        fileUrl = getFileUrl(file.data.output, slugifyObsidianPath(node.url));
+        break;
+      }
+      case "shortest": {
+        const url = path3.basename(decodeURIComponent(node.url));
+        const [urlPath] = extractPathAndAnchor(url);
+        const matchingFile = file.data.files.find((vaultFile) => vaultFile.isEqualFileName(urlPath));
+        if (!matchingFile) {
+          break;
+        }
+        fileUrl = getFileUrl(file.data.output, getFilePathFromVaultFile(matchingFile, node.url));
+        break;
+      }
+    }
+  }
+  if (isCustomFile(node.url)) {
+    replaceNode(context, getCustomFileNode(fileUrl));
+    return SKIP;
+  }
+  node.url = fileUrl;
+  if (isAssetFile(node.url)) {
+    handleImagesWithSize(node, context, "asset");
+  }
+  return SKIP;
+}
+function handleBlockquotes(node, context) {
+  const [firstChild, ...otherChildren] = node.children;
+  if (firstChild?.type !== "paragraph") {
+    return SKIP;
+  }
+  const [firstGrandChild, ...otherGrandChildren] = firstChild.children;
+  if (firstGrandChild?.type !== "text") {
+    return SKIP;
+  }
+  const [firstLine, ...otherLines] = firstGrandChild.value.split(/\r?\n/);
+  if (!firstLine) {
+    return SKIP;
+  }
+  const match = calloutRegex.exec(firstLine);
+  const { title, type } = match?.groups ?? {};
+  if (!match || !type) {
+    return SKIP;
+  }
+  const calloutType = getCalloutType(type);
+  const calloutTitle = title?.trim() || type.charAt(0).toUpperCase() + type.slice(1);
+  const escapedTitle = calloutTitle.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const openTag = `<div class="callout callout-${calloutType}"><p class="callout-title">${escapedTitle}</p>`;
+  const contentChildren = [];
+  if (otherLines.length > 0) {
+    contentChildren.push({ type: "text", value: otherLines.join("\n") });
+  }
+  contentChildren.push(...otherGrandChildren);
+  const aside = [
+    { type: "html", value: openTag }
+  ];
+  if (contentChildren.length > 0) {
+    aside.push({
+      type: "paragraph",
+      children: contentChildren
+    });
+  }
+  aside.push(...otherChildren);
+  aside.push({ type: "html", value: "</div>" });
+  replaceNode(context, aside);
+  return CONTINUE;
+}
+async function handleMermaid(tree, file) {
+  const mermaidNodes = [];
+  visit(tree, "code", (node, index, parent) => {
+    if (node.lang === "mermaid") {
+      mermaidNodes.push([node, { file, index, parent }]);
+      return SKIP;
+    }
+    return CONTINUE;
+  });
+  await Promise.all(
+    mermaidNodes.map(async ([node, context]) => {
+      const html = toHtml(toHast(node));
+      const processedHtml = await transformHtmlToString(html);
+      replaceNode(context, { type: "html", value: processedHtml });
+    })
+  );
+}
+async function handleImagesAndNoteEmbeds(tree, file) {
+  const imageNodes = [];
+  visit(tree, "image", (node, index, parent) => {
+    imageNodes.push([node, { file, index, parent }]);
+    return SKIP;
+  });
+  await Promise.all(
+    imageNodes.map(async ([node, context]) => {
+      await handleImages(node, context);
+    })
+  );
+}
+function getFrontmatterNodeValue(file, obsidianFrontmatter) {
+  let frontmatter = {
+    title: file.stem
+  };
+  if (obsidianFrontmatter && file.data.copyFrontmatter) {
+    const { cover, image, description, permalink, tags, publish, aliases, ...restFrontmatter } = obsidianFrontmatter.raw;
+    frontmatter = { ...frontmatter, ...restFrontmatter };
+  }
+  if (obsidianFrontmatter?.description && obsidianFrontmatter.description.length > 0) {
+    frontmatter.description = obsidianFrontmatter.description;
+  }
+  if (obsidianFrontmatter?.permalink && obsidianFrontmatter.permalink.length > 0) {
+    frontmatter.permalink = obsidianFrontmatter.permalink;
+  }
+  if (obsidianFrontmatter?.tags && obsidianFrontmatter.tags.length > 0) {
+    frontmatter.tags = obsidianFrontmatter.tags;
+  }
+  const { title, ...frontmatterWithoutTitle } = frontmatter;
+  let result = yaml.stringify({ title }, { version: "1.1" });
+  if (Object.keys(frontmatterWithoutTitle).length > 0) {
+    result += yaml.stringify(frontmatterWithoutTitle);
+  }
+  return result.trim();
+}
+function getFileUrl(output, filePath, anchor) {
+  return `${path3.posix.join(path3.posix.sep, output, slugifyObsidianPath(filePath))}${slugifyObsidianAnchor(anchor ?? "")}`;
+}
+function getRelativeFilePath(file, relativePath) {
+  ensureTransformContext(file);
+  return path3.posix.join(getObsidianRelativePath(file.data.vault, file.dirname), relativePath);
+}
+function getFilePathFromVaultFile(vaultFile, url) {
+  return vaultFile.uniqueFileName ? vaultFile.slug : slugifyObsidianPath(url);
+}
+function isMarkdownFile(filePath, file) {
+  return file.data.vault?.options.linkSyntax === "markdown" && filePath.endsWith(".md") || getExtension(filePath).length === 0;
+}
+function handleImagesWithSize(node, context, type) {
+  if (!node.alt) {
+    return;
+  }
+  const match = imageSizeRegex.exec(node.alt);
+  const { altText, width, widthOnly, height } = match?.groups ?? {};
+  if (widthOnly === void 0 && width === void 0) {
+    return;
+  }
+  const imgAltText = altText ?? "";
+  const imgWidth = widthOnly ?? width;
+  const imgHeight = height ?? "auto";
+  const imgStyle = height === void 0 ? "" : ` style="height: ${height}px !important;"`;
+  replaceNode(context, {
+    type: "html",
+    value: `<img src="${node.url}" alt="${imgAltText}" width="${imgWidth}" height="${imgHeight}"${imgStyle} />`
+  });
+}
+function isCustomFile(filePath) {
+  return isObsidianFile(filePath) && !isObsidianFile(filePath, "image");
+}
+function getCustomFileNode(filePath) {
+  if (isObsidianFile(filePath, "audio")) {
+    return {
+      type: "html",
+      value: `<audio class="obs-embed-audio" controls src="${filePath}"></audio>`
+    };
+  } else if (isObsidianFile(filePath, "video")) {
+    return {
+      type: "html",
+      value: `<video class="obs-embed-video" controls src="${filePath}"></video>`
+    };
+  }
+  return {
+    type: "html",
+    value: `<iframe class="obs-embed-pdf" src="${filePath}"></iframe>`
+  };
+}
+async function getMarkdownFileNode(file, fileUrl) {
+  ensureTransformContext(file);
+  const [fileName, ...anchorSegments] = fileUrl.split("#");
+  const fileAnchor = anchorSegments.join("#");
+  const fileExt = file.data.vault.options.linkSyntax === "wikilink" ? ".md" : "";
+  const filePath = decodeURIComponent(
+    file.data.vault.options.linkFormat === "relative" ? getRelativeFilePath(file, fileName ?? fileUrl) : fileName ?? fileUrl
+  );
+  const url = path3.posix.join(path3.posix.sep, `${filePath}${fileExt}`);
+  const matchingFile = file.data.files.find(
+    (vaultFile) => vaultFile.path === url || vaultFile.isEqualStem(filePath) || vaultFile.isEqualFileName(filePath)
+  );
+  if (!matchingFile) {
+    return { type: "text", value: "" };
+  }
+  const content = fs2.readFileSync(matchingFile.fsPath, "utf8");
+  const root = await transformMarkdownToAST(matchingFile.fsPath, content, { ...file.data, embedded: true });
+  if (fileAnchor) {
+    root.children = extractMarkdownSection(root, fileAnchor);
+  }
+  return {
+    type: "blockquote",
+    children: [
+      {
+        type: "html",
+        value: `<strong>${matchingFile.stem}</strong>`
+      },
+      ...root.children
+    ]
+  };
+}
+function replaceNode({ index, parent }, replacement) {
+  if (!parent || index === void 0) {
+    return;
+  }
+  parent.children.splice(index, 1, ...Array.isArray(replacement) ? replacement : [replacement]);
+}
+function extractMarkdownSection(root, sectionAnchor) {
+  const children = [];
+  visit(root, (node, index, parent) => {
+    switch (node.type) {
+      case "heading": {
+        if (!parent || index === void 0)
+          return CONTINUE;
+        const headingText = node.children.find((child) => child.type === "text")?.value;
+        if (headingText !== sectionAnchor)
+          return CONTINUE;
+        children.push(node);
+        let nextNode = parent.children[index + 1];
+        while (nextNode && (nextNode.type !== "heading" || nextNode.depth > node.depth)) {
+          children.push(nextNode);
+          nextNode = parent.children[index + children.length];
+        }
+        return EXIT;
+      }
+      default: {
+        return CONTINUE;
+      }
+    }
+  });
+  return children;
+}
+function closeVoidElements(tree) {
+  visit(tree, "html", (node) => {
+    node.value = node.value.replaceAll(mdxNonClosingVoidElementRegex, "<$<tag>$<attrs>/>");
+    return SKIP;
+  });
+}
+function ensureTransformContext(file) {
+  if (!file.dirname || !file.data.files || file.data.output === void 0 || !file.data.vault) {
+    throw new Error("Invalid transform context.");
+  }
+}
+
+// scripts/obsidian/markdown.ts
+var processor2;
+async function transformMarkdownToString(filePath, markdown, context) {
+  const file = await getProcessor(context).process(getVFile(filePath, markdown, context));
+  return {
+    aliases: file.data.aliases,
+    content: String(file),
+    skip: file.data.skip === true,
+    type: file.data.isMdx === true ? "mdx" : "markdown"
+  };
+}
+async function transformMarkdownToAST(filePath, markdown, context) {
+  const { content } = await transformMarkdownToString(filePath, markdown, context);
+  return fromMarkdown(content);
+}
+function getProcessor(context) {
+  processor2 ??= remark().data("settings", { resourceLink: true }).use(remarkGfm).use(remarkMath, { singleDollarTextMath: context.singleDollarTextMath }).use(remarkFrontmatter).use(remarkObsidian);
+  return processor2;
+}
+function getVFile(filePath, markdown, context) {
+  return new VFile({
+    data: { ...context },
+    path: filePath,
+    value: markdown
+  });
+}
+
+// scripts/obsidian/files.ts
+var DEFAULT_OUTPUT_ROOTS = { content: "content", public: "public" };
+var calloutTypeMap = {
+  note: "note",
+  abstract: "tip",
+  summary: "tip",
+  tldr: "tip",
+  info: "note",
+  todo: "note",
+  tip: "tip",
+  hint: "tip",
+  important: "tip",
+  success: "note",
+  check: "note",
+  done: "note",
+  question: "caution",
+  help: "caution",
+  faq: "caution",
+  warning: "caution",
+  caution: "caution",
+  attention: "caution",
+  failure: "danger",
+  fail: "danger",
+  missing: "danger",
+  danger: "danger",
+  error: "danger",
+  bug: "danger",
+  example: "tip",
+  quote: "note",
+  cite: "note"
+};
+function getCalloutType(obsidianCalloutType) {
+  return calloutTypeMap[obsidianCalloutType] ?? "note";
+}
+function isAssetFile(filePath) {
+  return getExtension(filePath) !== ".bmp" && isObsidianFile(filePath, "image");
+}
+async function addObsidianFiles(config, vault, obsidianPaths, logger2, roots = DEFAULT_OUTPUT_ROOTS) {
+  const outputPaths = getOutputPaths(config, roots);
+  if (stripLeadingAndTrailingSlashes(config.output) !== ".") {
+    await cleanOutputPaths(outputPaths);
+  }
+  const vaultFiles = getObsidianVaultFiles(vault, obsidianPaths);
+  const results = await Promise.allSettled(
+    vaultFiles.map(async (vaultFile) => {
+      await (vaultFile.type === "asset" ? addAsset(outputPaths, vaultFile) : vaultFile.type === "file" ? addFile(outputPaths, vaultFile) : addContent(config, vault, outputPaths, vaultFiles, vaultFile));
+    })
+  );
+  let didFail = false;
+  for (const result of results) {
+    if (result.status === "rejected") {
+      didFail = true;
+      logger2.error(result.reason instanceof Error ? result.reason.message : String(result.reason));
+    }
+  }
+  if (didFail) {
+    throw new Error("Failed to generate some pages. See the error(s) above for more information.");
+  }
+}
+async function addContent(config, vault, outputPaths, vaultFiles, vaultFile) {
+  try {
+    const obsidianContent = await fs3.readFile(vaultFile.fsPath, "utf8");
+    const {
+      content,
+      aliases,
+      skip,
+      type
+    } = await transformMarkdownToString(vaultFile.fsPath, obsidianContent, {
+      files: vaultFiles,
+      copyFrontmatter: config.copyFrontmatter,
+      output: config.output,
+      singleDollarTextMath: config.math.singleDollarTextMath,
+      vault
+    });
+    if (skip) {
+      return;
+    }
+    const outputPath = path4.join(
+      outputPaths.content,
+      type === "markdown" ? vaultFile.path : vaultFile.path.replace(/\.md$/, ".mdx")
+    );
+    const outputDirPath = path4.dirname(outputPath);
+    await ensureDirectory(outputDirPath);
+    await fs3.writeFile(outputPath, content);
+    if (aliases) {
+      for (const alias of aliases) {
+        await addAlias(config, outputPaths, vaultFile, alias);
+      }
+    }
+  } catch (error) {
+    throwVaultFileError(error, vaultFile);
+  }
+}
+async function addFile(outputPaths, vaultFile) {
+  try {
+    await copyFile(vaultFile.fsPath, path4.join(outputPaths.file, vaultFile.slug));
+  } catch (error) {
+    throwVaultFileError(error, vaultFile);
+  }
+}
+async function addAsset(outputPaths, vaultFile) {
+  try {
+    await copyFile(vaultFile.fsPath, path4.join(outputPaths.asset, vaultFile.slug));
+  } catch (error) {
+    throwVaultFileError(error, vaultFile);
+  }
+}
+async function addAlias(config, outputPaths, vaultFile, alias) {
+  const htmlPath = path4.join(outputPaths.file, path4.dirname(vaultFile.path), alias, "index.html");
+  const htmlDirPath = path4.dirname(htmlPath);
+  const to = path4.posix.join(path4.posix.sep, config.output, vaultFile.slug);
+  const from = path4.posix.join(path4.dirname(to), alias);
+  await ensureDirectory(htmlDirPath);
+  await fs3.writeFile(
+    htmlPath,
+    `<!doctype html>
+<html lang="en">
+  <head>
+    <title>${vaultFile.stem}</title>
+    <meta http-equiv="refresh" content="0;url=${to}">
+    <meta name="robots" content="noindex">
+    <link rel="canonical" href="${to}">
+  </head>
+  <body>
+    <a href="${to}">Redirecting from <code>${from}</code> to <code>${to}</code></a>
+  </body>
+</html>`
+  );
+}
+function getOutputPaths(config, roots) {
+  return {
+    asset: path4.join(roots.public, config.output),
+    content: path4.join(roots.content, config.output),
+    file: path4.join(roots.public, config.output)
+  };
+}
+async function cleanOutputPaths(outputPaths) {
+  await removeDirectory(outputPaths.asset);
+  await removeDirectory(outputPaths.content);
+  await removeDirectory(outputPaths.file);
+}
+function throwVaultFileError(error, vaultFile) {
+  throw new Error(`${vaultFile.path} \u2014 ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+}
+
+// scripts/obsidian/obsidian.ts
+var obsidianAppConfigSchema = z2.object({
+  newLinkFormat: z2.union([z2.literal("absolute"), z2.literal("relative"), z2.literal("shortest")]).default("shortest"),
+  useMarkdownLinks: z2.boolean().default(false)
+});
+var obsidianFrontmatterSchema = z2.object({
+  aliases: z2.array(z2.string()).optional().nullable().transform((aliases) => aliases?.map((alias) => slug2(alias))),
+  cover: z2.string().optional().nullable(),
+  description: z2.string().optional().nullable(),
+  image: z2.string().optional().nullable(),
+  permalink: z2.string().optional().nullable(),
+  publish: z2.union([z2.boolean(), z2.literal("true"), z2.literal("false")]).optional().nullable().transform((publish) => publish === void 0 || publish === "true" || publish === true),
+  tags: z2.array(z2.string()).optional().nullable()
+});
+var imageFileFormats = /* @__PURE__ */ new Set([".avif", ".bmp", ".gif", ".jpeg", ".jpg", ".png", ".svg", ".webp"]);
+var audioFileFormats = /* @__PURE__ */ new Set([".flac", ".m4a", ".mp3", ".wav", ".ogg", ".wav", ".3gp"]);
+var videoFileFormats = /* @__PURE__ */ new Set([".mkv", ".mov", ".mp4", ".ogv", ".webm"]);
+var otherFileFormats = /* @__PURE__ */ new Set([".pdf"]);
+var fileFormats = /* @__PURE__ */ new Set([...imageFileFormats, ...audioFileFormats, ...videoFileFormats, ...otherFileFormats]);
+async function getVault(config) {
+  const vaultPath = path5.resolve(config.vault);
+  if (!await isDirectory(vaultPath)) {
+    throw new Error(`The provided vault path is not a directory.
+> Provided path: ${vaultPath}`);
+  }
+  const options = await isVaultDirectory(config, vaultPath) ? await getVaultOptions(config, vaultPath) : { linkFormat: "shortest", linkSyntax: "wikilink" };
+  return {
+    options,
+    path: slashify(vaultPath)
+  };
+}
+function getObsidianPaths(vault, ignore = []) {
+  return globby(["**/*.md", ...[...fileFormats].map((fileFormat) => `**/*${fileFormat}`)], {
+    absolute: true,
+    cwd: vault.path,
+    ignore
+  });
+}
+function getObsidianVaultFiles(vault, obsidianPaths) {
+  const allFileNames = obsidianPaths.map((obsidianPath) => path5.basename(obsidianPath));
+  return obsidianPaths.map((obsidianPath, index) => {
+    const baseFileName = allFileNames[index];
+    let fileName = baseFileName;
+    const type = isAssetFile(fileName) ? "asset" : isObsidianFile(fileName) ? "file" : "content";
+    if (type === "asset") {
+      fileName = slugifyPath(fileName);
+    }
+    const filePath = getObsidianRelativePath(vault, obsidianPath);
+    const fileSlug = slugifyObsidianPath(filePath);
+    return createVaultFile({
+      fileName,
+      fsPath: obsidianPath,
+      path: type === "asset" ? fileSlug : filePath,
+      slug: fileSlug,
+      stem: stripExtension(fileName),
+      type,
+      uniqueFileName: allFileNames.filter((currentFileName) => currentFileName === baseFileName).length === 1
+    });
+  });
+}
+function getObsidianRelativePath(vault, obsidianPath) {
+  return obsidianPath.replace(vault.path, "");
+}
+function slugifyObsidianPath(obsidianPath) {
+  const segments = obsidianPath.split("/");
+  return segments.map((segment, index) => {
+    const isLastSegment = index === segments.length - 1;
+    if (!isLastSegment) {
+      return slug2(decodeUriComponent(segment));
+    } else if (isObsidianFile(segment) && !isAssetFile(segment)) {
+      return decodeUriComponent(segment);
+    } else if (isAssetFile(segment)) {
+      return `${slug2(decodeUriComponent(stripExtension(segment)))}${getExtension(segment)}`;
+    }
+    return slug2(decodeUriComponent(stripExtension(segment)));
+  }).join("/");
+}
+function slugifyObsidianAnchor(obsidianAnchor) {
+  if (obsidianAnchor.length === 0) {
+    return "";
+  }
+  let anchor = isAnchor(obsidianAnchor) ? obsidianAnchor.slice(1) : obsidianAnchor;
+  if (isObsidianBlockAnchor(anchor)) {
+    anchor = anchor.replace("^", "block-");
+  }
+  return `#${slug2(decodeURIComponent(anchor))}`;
+}
+function isObsidianBlockAnchor(anchor) {
+  return anchor.startsWith("#^") || anchor.startsWith("^");
+}
+function isObsidianFile(filePath, type) {
+  const formats = type === void 0 ? fileFormats : type === "image" ? imageFileFormats : type === "audio" ? audioFileFormats : type === "video" ? videoFileFormats : otherFileFormats;
+  return formats.has(getExtension(filePath));
+}
+function parseObsidianFrontmatter(content) {
+  try {
+    const raw = yaml2.parse(content);
+    return { ...obsidianFrontmatterSchema.parse(raw), raw };
+  } catch {
+    return;
+  }
+}
+function createVaultFile(baseVaultFile) {
+  return {
+    ...baseVaultFile,
+    isEqualFileName(otherFileName) {
+      return (isAssetFile(otherFileName) ? slugifyPath(otherFileName) : otherFileName) === this.fileName;
+    },
+    isEqualStem(otherStem) {
+      return (isAssetFile(otherStem) ? slugifyPath(otherStem) : otherStem) === this.stem;
+    }
+  };
+}
+async function isVaultDirectory(config, vaultPath) {
+  const configPath = path5.join(vaultPath, config.configFolder);
+  return await isDirectory(configPath) && await isFile(path5.join(configPath, "app.json"));
+}
+async function getVaultOptions(config, vaultPath) {
+  const appConfigPath = path5.join(vaultPath, config.configFolder, "app.json");
+  try {
+    const appConfigData = await fs4.readFile(appConfigPath, "utf8");
+    const appConfig = obsidianAppConfigSchema.parse(JSON.parse(appConfigData));
+    return {
+      linkFormat: appConfig.newLinkFormat,
+      linkSyntax: appConfig.useMarkdownLinks ? "markdown" : "wikilink"
+    };
+  } catch (error) {
+    throw new Error("Failed to read Obsidian vault app configuration.", { cause: error });
+  }
+}
+
+// scripts/obsidian/generate.ts
+async function generateObsidian(userConfig, logger2, roots) {
+  const parsed = obsidianConfigSchema.safeParse(userConfig);
+  if (!parsed.success) {
+    throw new Error(`Invalid obsidian configuration:
+
+${JSON.stringify(parsed.error.format(), null, 2)}`);
+  }
+  const config = parsed.data;
+  if (config.skipGeneration) {
+    logger2.warn(`Skipping generation for '${config.output}' (skipGeneration enabled).`);
+    return;
+  }
+  const start = performance.now();
+  logger2.info(`Generating pages from Obsidian vault '${config.vault}'\u2026`);
+  const vault = await getVault(config);
+  const obsidianPaths = await getObsidianPaths(vault, config.ignore);
+  await addObsidianFiles(config, vault, obsidianPaths, logger2, roots);
+  logger2.info(`Generated '${config.output}' in ${Math.round(performance.now() - start)}ms.`);
+}
+
+// scripts/canvas-to-md.ts
+import path6 from "node:path";
+import fs5 from "node:fs/promises";
+import { glob } from "tinyglobby";
+function escapeYamlString(s) {
+  if (/[:"'#\[\]{}&*!|>%@`]/.test(s) || s.includes("\n")) {
+    return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return s;
+}
+async function generateCanvasFile(vaultDir, outDir, relPath, log) {
+  const absPath = path6.join(vaultDir, relPath);
+  const contents = await fs5.readFile(absPath, "utf-8");
+  let canvasObj;
+  try {
+    canvasObj = JSON.parse(contents);
+  } catch (err) {
+    log(`Invalid JSON in ${relPath}: ${err.message}`);
+    return;
+  }
+  const title = path6.basename(relPath, ".canvas");
+  const safeJson = JSON.stringify(canvasObj).replace(/</g, "\\u003c");
+  const md = [
+    "---",
+    `title: ${escapeYamlString(title)}`,
+    "tableOfContents: false",
+    "---",
+    "",
+    `<div class="canvas-container not-content" data-canvas-mount><script type="application/json">${safeJson}</script></div>`,
+    ""
+  ].join("\n");
+  const mdRelPath = relPath.replace(/\.canvas$/, ".md");
+  const outPath = path6.join(outDir, mdRelPath);
+  await fs5.mkdir(path6.dirname(outPath), { recursive: true });
+  await fs5.writeFile(outPath, md, "utf-8");
+}
+async function generateCanvas(options, logger2) {
+  const { vault, output, contentRoot = "content" } = options;
+  const vaultDir = path6.resolve(vault);
+  const outDir = path6.resolve(contentRoot, output);
+  const entries = await glob("**/[^_]*.canvas", { cwd: vaultDir });
+  await Promise.all(entries.map((relPath) => generateCanvasFile(vaultDir, outDir, relPath, (m) => logger2.info(m))));
+  if (entries.length > 0) {
+    logger2.info(`Generated ${entries.length} canvas page(s) for '${output}'`);
+  }
+}
+
+// scripts/compile.ts
+import fs6 from "node:fs/promises";
+import path7 from "node:path";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm2 from "remark-gfm";
+import remarkBreaks from "remark-breaks";
+import remarkMath2 from "remark-math";
+import remarkFrontmatter2 from "remark-frontmatter";
+import remarkRehype from "remark-rehype";
+import rehypeKatex from "rehype-katex";
+import rehypeStringify from "rehype-stringify";
+import { visit as visit2 } from "unist-util-visit";
+import { slug as slugify } from "github-slugger";
+import yaml3 from "yaml";
+function extractFrontmatter(tree) {
+  for (const node of tree.children) {
+    if (node.type === "yaml") {
+      try {
+        const parsed = yaml3.parse(node.value);
+        return parsed && typeof parsed === "object" ? parsed : {};
+      } catch {
+        return {};
+      }
+    }
+  }
+  return {};
+}
+function nodeText(node) {
+  let out = "";
+  visit2(node, "text", (t) => {
+    out += t.value;
+  });
+  return out;
+}
+function rehypeHeadings() {
+  return (tree, file) => {
+    const headings = [];
+    const seen = /* @__PURE__ */ new Map();
+    visit2(tree, "element", (node) => {
+      const m = /^h([1-6])$/.exec(node.tagName);
+      if (!m)
+        return;
+      const depth = Number(m[1]);
+      const text = nodeText(node).trim();
+      let id = slugify(text);
+      if (seen.has(id)) {
+        const n = seen.get(id) + 1;
+        seen.set(id, n);
+        id = `${id}-${n}`;
+      } else {
+        seen.set(id, 0);
+      }
+      node.properties = node.properties ?? {};
+      if (!node.properties.id)
+        node.properties.id = id;
+      headings.push({ depth, slug: String(node.properties.id), text });
+    });
+    file.data.headings = headings;
+  };
+}
+function rehypeHoistBlankBeforeToPre() {
+  return (tree) => {
+    visit2(tree, "element", (node) => {
+      if (node.tagName !== "pre")
+        return;
+      const code = node.children.find(
+        (c) => c.type === "element" && c.tagName === "code"
+      );
+      if (!code)
+        return;
+      const codeCls = code.properties?.className;
+      if (!Array.isArray(codeCls) || !codeCls.includes("has-blank-before"))
+        return;
+      const remaining = codeCls.filter((c) => c !== "has-blank-before");
+      if (remaining.length > 0)
+        code.properties.className = remaining;
+      else
+        delete code.properties.className;
+      node.properties = node.properties ?? {};
+      const preCls = node.properties.className;
+      node.properties.className = Array.isArray(preCls) ? [...preCls, "has-blank-before"] : ["has-blank-before"];
+    });
+  };
+}
+var BLANK_GAP_MARKER2 = "<!--blank-gap-->";
+function remarkBlankLineGaps() {
+  const isGapMarker = (n) => n?.type === "html" && n.value?.trim() === BLANK_GAP_MARKER2;
+  function walk(parent) {
+    const children = parent.children;
+    if (!children)
+      return;
+    const gapped = /* @__PURE__ */ new Set();
+    for (let i = children.length - 1; i >= 0; i--) {
+      if (isGapMarker(children[i])) {
+        const next = children[i + 1];
+        if (next)
+          gapped.add(next);
+        children.splice(i, 1);
+      }
+    }
+    for (const node of children) {
+      if (gapped.has(node)) {
+        node.data ??= {};
+        node.data.hProperties ??= {};
+        const cls = node.data.hProperties.className ?? [];
+        cls.push("has-blank-before");
+        node.data.hProperties.className = cls;
+      }
+      walk(node);
+    }
+  }
+  return (tree) => {
+    walk(tree);
+  };
+}
+var processor3 = unified().use(remarkParse).use(remarkFrontmatter2).use(remarkGfm2).use(remarkBreaks).use(remarkBlankLineGaps).use(remarkMath2, { singleDollarTextMath: true }).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeKatex).use(rehypeHoistBlankBeforeToPre).use(rehypeHeadings).use(rehypeStringify, { allowDangerousHtml: true });
+async function compileMarkdown(markdown) {
+  const mdast = processor3.parse(markdown);
+  const frontmatter = extractFrontmatter(mdast);
+  const file = await processor3.process(markdown);
+  return {
+    frontmatter,
+    headings: file.data.headings ?? [],
+    html: String(file)
+  };
+}
+async function compileDir(contentRoot, logger2) {
+  const docs = [];
+  async function walk(dir) {
+    const entries = await fs6.readdir(dir, { withFileTypes: true });
+    await Promise.all(
+      entries.map(async (entry) => {
+        const full = path7.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(full);
+        } else if (entry.isFile() && entry.name.endsWith(".md")) {
+          const raw = await fs6.readFile(full, "utf8");
+          const compiled = await compileMarkdown(raw);
+          const rel = path7.relative(contentRoot, full).replace(/\\/g, "/").replace(/\.md$/, "");
+          const id = slugifyObsidianPath(rel);
+          docs.push({ id, ...compiled });
+        }
+      })
+    );
+  }
+  await walk(contentRoot);
+  logger2.info(`Compiled ${docs.length} markdown page(s) to HTML.`);
+  return docs;
+}
+
+// scripts/build-search-index.ts
+async function buildSearchIndex(docs, canonicalUrl, logger2, options = { outputPath: "public/pagefind", lang: "ru" }) {
+  const { createIndex } = await import("pagefind");
+  const { index, errors } = await createIndex({
+    // Set the default site language so tokenisation and stemming are correct.
+    // Pagefind still detects per-page `lang` if present.
+    forceLanguage: options.lang
+  });
+  if (!index) {
+    logger2.warn(`Pagefind index could not be created: ${errors.join("; ")}`);
+    return;
+  }
+  let indexed = 0;
+  let skipped = 0;
+  for (const doc of docs) {
+    if (doc.frontmatter.draft === true) {
+      skipped++;
+      continue;
+    }
+    if (doc.html.includes("data-canvas-mount")) {
+      skipped++;
+      continue;
+    }
+    const title = doc.frontmatter.title ?? doc.id.split("/").pop()?.replace(/-/g, " ") ?? doc.id;
+    const url = canonicalUrl.get(doc.id) ?? `/${doc.id}/`;
+    const segments = doc.id.split("/");
+    const project = segments[0];
+    const dirSegments = segments.slice(0, -1);
+    const dirPrefixes = dirSegments.map((_, i) => dirSegments.slice(0, i + 1).join("/"));
+    const filterTags = `<span data-pagefind-filter="project" style="display:none">${escapeHtml(project)}</span>` + dirPrefixes.map(
+      (d) => `<span data-pagefind-filter="dir" style="display:none">${escapeHtml(d)}</span>`
+    ).join("");
+    const content = `<!DOCTYPE html><html lang="${escapeHtml(options.lang)}"><head><title>${escapeHtml(
+      title
+    )}</title></head><body><main data-pagefind-body>${filterTags}<h1>${escapeHtml(
+      title
+    )}</h1>${doc.html}</main></body></html>`;
+    const { errors: fileErrors } = await index.addHTMLFile({
+      url,
+      content
+    });
+    if (fileErrors.length) {
+      logger2.warn(`Pagefind failed on ${doc.id}: ${fileErrors.join("; ")}`);
+      continue;
+    }
+    indexed++;
+  }
+  const { errors: writeErrors } = await index.writeFiles({
+    outputPath: options.outputPath
+  });
+  if (writeErrors.length) {
+    logger2.warn(`Pagefind writeFiles errors: ${writeErrors.join("; ")}`);
+  }
+  await index.deleteIndex();
+  logger2.info(`Pagefind: indexed ${indexed} pages (skipped ${skipped}) \u2192 ${options.outputPath}`);
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// scripts/canonical.ts
+function projectOf(id) {
+  return id.split("/")[0] ?? "";
+}
+function buildIdToCanonicalUrl(docs) {
+  const map = /* @__PURE__ */ new Map();
+  for (const d of docs) {
+    const raw = d.frontmatter.permalink;
+    if (typeof raw === "string" && raw.trim() !== "") {
+      const rel = raw.trim().replace(/^\/+|\/+$/g, "");
+      if (rel) {
+        map.set(d.id, `/${projectOf(d.id)}/${rel}/`);
+        continue;
+      }
+    }
+    map.set(d.id, `/${d.id}/`);
+  }
+  return map;
+}
+
+// app/lib/config/load.ts
+import { pathToFileURL } from "node:url";
+import path8 from "node:path";
+import fs7 from "node:fs";
+
+// app/lib/config/schema.ts
+import { z as z3 } from "zod";
+var colorMap = z3.record(z3.string(), z3.string());
+var projectSchema = z3.object({
+  /** First id segment + output dir name, e.g. `krista`. */
+  id: z3.string().min(1),
+  /** Display name in the switcher / home cards. */
+  name: z3.string().min(1),
+  /** Directory of markdown/canvas files. Submodule, loose folder, or any path. */
+  source: z3.string().min(1),
+  /** Logo under the user's `/public`. Defaults to `/projects/<id>.svg`. */
+  logo: z3.string().optional(),
+  /** Landing URL when switching to this project. Defaults to its first doc. */
+  landing: z3.string().optional(),
+  /** Short blurb, reused on home cards. */
+  description: z3.string().default(""),
+  /** Ingest `.canvas` files from this source too. */
+  canvas: z3.boolean().default(false),
+  /** Globs (relative to `source`) to skip, e.g. `['CLAUDE.md']`. */
+  ignore: z3.array(z3.string()).default([])
+});
+var generalSchema = z3.object({
+  enabled: z3.boolean().default(false),
+  name: z3.string().default("\u0411\u0435\u0437 \u043F\u0440\u043E\u0435\u043A\u0442\u0430"),
+  /** Directory of loose docs. When unset, the bucket has no docs. */
+  source: z3.string().optional(),
+  logo: z3.string().default("/projects/general.svg"),
+  description: z3.string().default(""),
+  ignore: z3.array(z3.string()).default([])
+});
+var siteSchema = z3.object({
+  title: z3.string().default("Docs"),
+  /** Home-page blurb under the title. */
+  description: z3.string().default(""),
+  /** BCP-47-ish tag; drives `localeCompare` sorting + Pagefind `forceLanguage`. */
+  lang: z3.string().default("ru"),
+  favicon: z3.string().default("/favicon.svg"),
+  logo: z3.object({
+    light: z3.string().default("/iti-logo-light.svg"),
+    dark: z3.string().default("/iti-logo-dark.svg")
+  }).prefault({}),
+  defaultTheme: z3.enum(["dark", "light"]).default("dark")
+});
+var themeSchema = z3.object({
+  /** OKLCH (or any CSS color) token overrides, merged OVER the shipped defaults. */
+  colors: z3.object({
+    light: colorMap.default({}),
+    dark: colorMap.default({})
+  }).prefault({})
+});
+var componentsSchema = z3.object({
+  Home: z3.string().optional(),
+  DocPage: z3.string().optional(),
+  Sidebar: z3.string().optional(),
+  TopBar: z3.string().optional(),
+  Toc: z3.string().optional(),
+  Search: z3.string().optional(),
+  Layout: z3.string().optional()
+}).default({});
+var uiSchema = z3.record(z3.string(), z3.string()).default({});
+var docsConfigSchema = z3.object({
+  site: siteSchema.prefault({}),
+  projects: z3.array(projectSchema).default([]),
+  general: generalSchema.prefault({}),
+  theme: themeSchema.prefault({}),
+  components: componentsSchema,
+  ui: uiSchema,
+  /**
+   * Reserved for custom remark/rehype plugins + callout types. NOT wired in this
+   * phase (the markdown pipeline stays fixed); accepted so configs are
+   * forward-compatible.
+   */
+  markdown: z3.unknown().optional()
+});
+
+// app/lib/config/defaults.ts
+var DEFAULT_THEME = {
+  light: {
+    "--brand": "oklch(0.42 0.158 286)",
+    "--background": "oklch(1 0 0)",
+    "--foreground": "oklch(0.145 0 0)",
+    "--card": "oklch(1 0 0)",
+    "--card-foreground": "oklch(0.145 0 0)",
+    "--popover": "oklch(1 0 0)",
+    "--popover-foreground": "oklch(0.145 0 0)",
+    "--primary": "var(--brand)",
+    "--primary-foreground": "oklch(0.985 0 0)",
+    "--secondary": "oklch(0.97 0 0)",
+    "--secondary-foreground": "oklch(0.205 0 0)",
+    "--muted": "oklch(0.97 0 0)",
+    "--muted-foreground": "oklch(0.556 0 0)",
+    "--accent": "oklch(0.97 0 0)",
+    "--accent-foreground": "oklch(0.205 0 0)",
+    "--destructive": "oklch(0.577 0.245 27.325)",
+    "--border": "oklch(0.922 0 0)",
+    "--input": "oklch(0.922 0 0)",
+    "--ring": "oklch(0.708 0 0)",
+    "--sidebar": "oklch(0.985 0 0)",
+    "--sidebar-foreground": "oklch(0.145 0 0)",
+    "--sidebar-primary": "oklch(0.205 0 0)",
+    "--sidebar-primary-foreground": "oklch(0.985 0 0)",
+    "--sidebar-accent": "oklch(0.97 0 0)",
+    "--sidebar-accent-foreground": "oklch(0.205 0 0)",
+    "--sidebar-border": "oklch(0.922 0 0)",
+    "--sidebar-ring": "oklch(0.708 0 0)"
+  },
+  dark: {
+    "--brand": "oklch(0.68 0.14 286)",
+    "--background": "oklch(0.145 0 0)",
+    "--foreground": "oklch(0.985 0 0)",
+    "--card": "oklch(0.205 0 0)",
+    "--card-foreground": "oklch(0.985 0 0)",
+    "--popover": "oklch(0.205 0 0)",
+    "--popover-foreground": "oklch(0.985 0 0)",
+    "--primary": "var(--brand)",
+    "--primary-foreground": "oklch(0.205 0 0)",
+    "--secondary": "oklch(0.269 0 0)",
+    "--secondary-foreground": "oklch(0.985 0 0)",
+    "--muted": "oklch(0.269 0 0)",
+    "--muted-foreground": "oklch(0.708 0 0)",
+    "--accent": "oklch(0.269 0 0)",
+    "--accent-foreground": "oklch(0.985 0 0)",
+    "--destructive": "oklch(0.704 0.191 22.216)",
+    "--border": "oklch(1 0 0 / 10%)",
+    "--input": "oklch(1 0 0 / 15%)",
+    "--ring": "oklch(0.556 0 0)",
+    "--sidebar": "oklch(0.205 0 0)",
+    "--sidebar-foreground": "oklch(0.985 0 0)",
+    "--sidebar-primary": "oklch(0.488 0.243 264.376)",
+    "--sidebar-primary-foreground": "oklch(0.985 0 0)",
+    "--sidebar-accent": "oklch(0.269 0 0)",
+    "--sidebar-accent-foreground": "oklch(0.985 0 0)",
+    "--sidebar-border": "oklch(1 0 0 / 10%)",
+    "--sidebar-ring": "oklch(0.556 0 0)"
+  }
+};
+var UI_STRINGS = {
+  ru: {
+    projects: "\u041F\u0440\u043E\u0435\u043A\u0442\u044B",
+    selectProject: "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u043F\u0440\u043E\u0435\u043A\u0442",
+    noProject: "\u0411\u0435\u0437 \u043F\u0440\u043E\u0435\u043A\u0442\u0430",
+    onThisPage: "\u041D\u0430 \u044D\u0442\u043E\u0439 \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u0435",
+    properties: "\u0421\u0432\u043E\u0439\u0441\u0442\u0432\u0430",
+    shortcuts: "\u0413\u043E\u0440\u044F\u0447\u0438\u0435 \u043A\u043B\u0430\u0432\u0438\u0448\u0438",
+    searchProjectFilter: "\u041F\u0440\u043E\u0435\u043A\u0442",
+    close: "\u0417\u0430\u043A\u0440\u044B\u0442\u044C",
+    closePanel: "\u0417\u0430\u043A\u0440\u044B\u0442\u044C \u043F\u0430\u043D\u0435\u043B\u044C",
+    closeSearch: "\u0417\u0430\u043A\u0440\u044B\u0442\u044C \u043F\u043E\u0438\u0441\u043A",
+    closeTab: "\u0417\u0430\u043A\u0440\u044B\u0442\u044C \u0432\u043A\u043B\u0430\u0434\u043A\u0443",
+    home: "\u0413\u043B\u0430\u0432\u043D\u0430\u044F",
+    files: "\u0424\u0430\u0439\u043B\u044B",
+    search: "\u041F\u043E\u0438\u0441\u043A",
+    toggleTheme: "\u041F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0438\u0442\u044C \u0442\u0435\u043C\u0443"
+  },
+  en: {
+    projects: "Projects",
+    selectProject: "Select a project",
+    noProject: "No project",
+    onThisPage: "On this page",
+    properties: "Properties",
+    shortcuts: "Keyboard shortcuts",
+    searchProjectFilter: "Project",
+    close: "Close",
+    closePanel: "Close panel",
+    closeSearch: "Close search",
+    closeTab: "Close tab",
+    home: "Home",
+    files: "Files",
+    search: "Search",
+    toggleTheme: "Toggle theme"
+  }
+};
+function defaultUiFor(lang) {
+  return UI_STRINGS[lang] ?? UI_STRINGS.en ?? UI_STRINGS.ru;
+}
+
+// app/lib/config/load.ts
+var CONFIG_NAMES = ["docs.config.ts", "docs.config.js", "docs.config.mjs"];
+function findConfigFile(cwd) {
+  for (const name of CONFIG_NAMES) {
+    const p = path8.join(cwd, name);
+    if (fs7.existsSync(p))
+      return p;
+  }
+  return null;
+}
+async function loadConfig(cwd = process.cwd()) {
+  const file = findConfigFile(cwd);
+  let authored = {};
+  if (file) {
+    const mtime = fs7.statSync(file).mtimeMs;
+    const mod = await import(`${pathToFileURL(file).href}?t=${mtime}`);
+    authored = mod.default ?? mod.config ?? mod;
+  }
+  const parsed = docsConfigSchema.safeParse(authored);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid docs.config:
+
+${JSON.stringify(parsed.error.format(), null, 2)}`
+    );
+  }
+  return resolveDerived(parsed.data);
+}
+function resolveDerived(config) {
+  const projects = config.projects.map((p) => ({
+    ...p,
+    logo: p.logo ?? `/projects/${p.id}.svg`
+  }));
+  const theme = {
+    colors: {
+      light: { ...DEFAULT_THEME.light, ...config.theme.colors.light },
+      dark: { ...DEFAULT_THEME.dark, ...config.theme.colors.dark }
+    }
+  };
+  const ui = { ...defaultUiFor(config.site.lang), ...config.ui };
+  return { ...config, projects, theme, ui };
+}
+
+// scripts/emit-config.ts
+import fs8 from "node:fs/promises";
+import path9 from "node:path";
+var GENERAL_PROJECT_ID = "general";
+var SLOT_NAMES = ["Home", "DocPage", "TopBar", "Toc"];
+function renderSlots(components, manifestDir) {
+  const imports = [];
+  const exports = [];
+  for (const name of SLOT_NAMES) {
+    const src = components[name];
+    if (src) {
+      let rel = path9.relative(manifestDir, path9.resolve(process.cwd(), src)).replace(/\\/g, "/");
+      if (!rel.startsWith("."))
+        rel = `./${rel}`;
+      imports.push(`import ${name}Override from '${rel}'`);
+      exports.push(`export const ${name} = ${name}Override`);
+    } else {
+      exports.push(`export const ${name}: ComponentType<any> | null = null`);
+    }
+  }
+  return `// AUTO-GENERATED by scripts/generate-content.ts \u2014 DO NOT EDIT.
+import type { ComponentType } from 'react'
+` + (imports.length ? imports.join("\n") + "\n" : "") + `
+` + exports.join("\n") + `
+`;
+}
+function renderThemeCss(colors) {
+  const block = (selector, vars) => {
+    const lines = Object.entries(vars).map(([k, v]) => `	${k}: ${v};`);
+    return `${selector} {
+${lines.join("\n")}
+}`;
+  };
+  return `/* AUTO-GENERATED by scripts/generate-content.ts from docs.config.ts theme. DO NOT EDIT. */
+${block(":root", colors.light)}
+
+${block(".dark", colors.dark)}
+`;
+}
+function firstDocOfProject(index, projectId) {
+  for (const e of index) {
+    if ((e.id.split("/")[0] ?? "") === projectId)
+      return e.id;
+  }
+  return null;
+}
+function firstGeneralDoc(index, projectIds) {
+  for (const e of index) {
+    if (!projectIds.has(e.id.split("/")[0] ?? ""))
+      return e.id;
+  }
+  return null;
+}
+async function emitGeneratedConfig({ config, manifestDir, index, logger: logger2 }) {
+  const projectIds = new Set(config.projects.map((p) => p.id));
+  const projects = config.projects.map((p) => {
+    const first = firstDocOfProject(index, p.id);
+    const landing = p.landing ?? (first ? `/${first}/` : "/");
+    return {
+      id: p.id,
+      name: p.name,
+      logo: p.logo ?? `/projects/${p.id}.svg`,
+      landing,
+      description: p.description
+    };
+  });
+  const generalHasDocs = config.general.enabled && firstGeneralDoc(index, projectIds) !== null;
+  const site = {
+    site: {
+      title: config.site.title,
+      description: config.site.description,
+      lang: config.site.lang,
+      favicon: config.site.favicon,
+      logo: config.site.logo,
+      defaultTheme: config.site.defaultTheme
+    },
+    projects,
+    general: {
+      enabled: generalHasDocs,
+      id: GENERAL_PROJECT_ID,
+      name: config.general.name,
+      logo: config.general.logo,
+      description: config.general.description
+    },
+    ui: config.ui
+  };
+  const fullConfig = { ...config, projects: config.projects.map((p, i) => ({ ...p, landing: projects[i].landing })) };
+  await fs8.writeFile(path9.join(manifestDir, "config.json"), JSON.stringify(fullConfig));
+  const siteModule = `// AUTO-GENERATED by scripts/generate-content.ts \u2014 DO NOT EDIT.
+import type { GeneratedSite } from '~/lib/config/site'
+
+export const SITE: GeneratedSite = ${JSON.stringify(site, null, "	")}
+`;
+  await fs8.writeFile(path9.join(manifestDir, "site.ts"), siteModule);
+  await fs8.writeFile(path9.join(manifestDir, "theme.generated.css"), renderThemeCss(config.theme.colors));
+  await fs8.writeFile(path9.join(manifestDir, "slots.ts"), renderSlots(config.components, manifestDir));
+  logger2.info(`Emitted config.json + site.ts + theme.generated.css + slots.ts (${projects.length} project(s)${generalHasDocs ? " + general" : ""}).`);
+}
+
+// scripts/generate-content.ts
+var logger = {
+  info: (m) => console.log(`  ${m}`),
+  warn: (m) => console.warn(`  \u26A0 ${m}`),
+  error: (m) => console.error(`  \u2716 ${m}`)
+};
+var CWD = process.cwd();
+var CONTENT_ROOT = path10.resolve(CWD, "content");
+var PUBLIC_ROOT = path10.resolve(CWD, "public");
+var MANIFEST_DIR = path10.resolve(CWD, "app/generated");
+var OUTPUT_ROOTS = { content: CONTENT_ROOT, public: PUBLIC_ROOT };
+function buildWorkLists(config) {
+  const vaults = config.projects.map((p) => ({ vault: p.source, output: p.id, ignore: p.ignore }));
+  const canvas = config.projects.filter((p) => p.canvas).map((p) => ({ vault: p.source, output: p.id }));
+  if (config.general.enabled && config.general.source) {
+    vaults.push({ vault: config.general.source, output: ".", ignore: config.general.ignore });
+  }
+  return { vaults, canvas };
+}
+function rewriteContentLinks(docs, canonicalUrl) {
+  let count = 0;
+  for (const d of docs) {
+    d.html = d.html.replace(/href="(\/[^"#]+)(#[^"]*)?"/g, (whole, rawPath, anchor) => {
+      let decoded;
+      try {
+        decoded = decodeURIComponent(rawPath);
+      } catch {
+        return whole;
+      }
+      const id = decoded.replace(/^\/+|\/+$/g, "");
+      const canonical = canonicalUrl.get(id);
+      if (!canonical || canonical === `/${id}/`)
+        return whole;
+      count++;
+      return `href="${canonical}${anchor ?? ""}"`;
+    });
+  }
+  return count;
+}
+async function main() {
+  const start = performance.now();
+  console.log("\u25B6 Generating content from Obsidian vaults\u2026");
+  const config = await loadConfig(CWD);
+  const { vaults, canvas } = buildWorkLists(config);
+  await fs9.rm(CONTENT_ROOT, { recursive: true, force: true });
+  const orderedVaults = [...vaults].sort((a, b) => a.output === "." ? -1 : b.output === "." ? 1 : 0);
+  for (const v of orderedVaults) {
+    await generateObsidian(v, logger, OUTPUT_ROOTS);
+  }
+  for (const c of canvas) {
+    await generateCanvas({ ...c, contentRoot: CONTENT_ROOT }, logger);
+  }
+  const docs = await compileDir(CONTENT_ROOT, logger);
+  const canonicalUrl = buildIdToCanonicalUrl(docs);
+  const rewrites = rewriteContentLinks(docs, canonicalUrl);
+  if (rewrites > 0) {
+    logger.info(`Rewrote ${rewrites} in-content link(s) to permalinks.`);
+  }
+  await fs9.rm(MANIFEST_DIR, { recursive: true, force: true });
+  await fs9.mkdir(path10.join(MANIFEST_DIR, "docs"), { recursive: true });
+  const index = docs.map((d) => ({
+    id: d.id,
+    title: d.frontmatter.title ?? null,
+    draft: d.frontmatter.draft === true,
+    tableOfContents: d.frontmatter.tableOfContents !== false,
+    tags: d.frontmatter.tags ?? [],
+    isCanvas: d.html.includes("data-canvas-mount")
+  })).sort((a, b) => a.id.localeCompare(b.id, config.site.lang));
+  await fs9.writeFile(path10.join(MANIFEST_DIR, "index.json"), JSON.stringify(index));
+  const permalinks = {};
+  for (const d of docs) {
+    const raw = d.frontmatter.permalink;
+    if (typeof raw !== "string" || raw.trim() === "")
+      continue;
+    const rel = raw.trim().replace(/^\/+|\/+$/g, "");
+    if (!rel)
+      continue;
+    const project = d.id.split("/")[0];
+    const key = `${project}/${rel}`;
+    if (permalinks[key] && permalinks[key] !== d.id) {
+      logger.warn(`Duplicate permalink "${raw}" in project "${project}" on ${d.id} (already used by ${permalinks[key]}); keeping the first.`);
+      continue;
+    }
+    permalinks[key] = d.id;
+  }
+  await fs9.writeFile(path10.join(MANIFEST_DIR, "permalinks.json"), JSON.stringify(permalinks));
+  if (Object.keys(permalinks).length > 0) {
+    logger.info(`Registered ${Object.keys(permalinks).length} permalink(s).`);
+  }
+  await Promise.all(
+    docs.map(async (d) => {
+      const outPath = path10.join(MANIFEST_DIR, "docs", `${d.id}.json`);
+      await fs9.mkdir(path10.dirname(outPath), { recursive: true });
+      await fs9.writeFile(
+        outPath,
+        JSON.stringify({ id: d.id, frontmatter: d.frontmatter, headings: d.headings, html: d.html })
+      );
+    })
+  );
+  await buildSearchIndex(docs, canonicalUrl, logger, {
+    outputPath: path10.join(PUBLIC_ROOT, "pagefind"),
+    lang: config.site.lang
+  });
+  await emitGeneratedConfig({ config, manifestDir: MANIFEST_DIR, index, logger });
+  console.log(`\u2714 Done: ${docs.length} pages in ${Math.round(performance.now() - start)}ms`);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});