@publish.os/nextjs 0.0.1-alpha.90 → 0.0.1-alpha.92

package/dist/chunk-DX7PXFCM.js

@@ -0,0 +1,2519 @@
+import {
+  SOURCE_ASSET_PREFIX
+} from "./chunk-EFO6AWXN.js";
+import {
+  MAX_MEDIA_SVG_BYTES,
+  ignoredMediaDocumentWarning,
+  ignoredMediaPathWarning,
+  mediaFileByteLimit,
+  mediaFileTooLarge,
+  readBoundedMediaFile
+} from "./chunk-5KAD7W53.js";
+import {
+  isExcludedSourcePath,
+  isSameOrDescendant
+} from "./chunk-WL75GQ5M.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/source/mdx-component-contract.ts
+import ts from "typescript";
+var groupedMdxExports = {
+  figure: { FigureCaption: "figcaption" },
+  table: {
+    TableHeadGroup: "thead",
+    TableBodyGroup: "tbody",
+    TableRowGroup: "tr",
+    TableHeaderCell: "th",
+    TableDataCell: "td"
+  }
+}, replacedMdxSourceFiles = {
+  a: "link",
+  "figure-caption": "figure",
+  h1: "heading",
+  h2: "heading",
+  h3: "heading",
+  h4: "heading",
+  h5: "heading",
+  h6: "heading",
+  img: "image",
+  pre: "code-block",
+  "table-body-group": "table",
+  "table-data-cell": "table",
+  "table-header-cell": "table",
+  "table-head-group": "table",
+  "table-row-group": "table"
+};
+function mdxComponentExportName(stem) {
+  return stem.split("-").map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+}
+function collectBindingNames(name) {
+  return ts.isIdentifier(name) ? [name.text] : name.elements.flatMap(
+    (element) => ts.isOmittedExpression(element) ? [] : collectBindingNames(element.name)
+  );
+}
+function namedValueExports(sourceFile) {
+  let names = /* @__PURE__ */ new Set();
+  for (let statement of sourceFile.statements) {
+    if (ts.isExportDeclaration(statement) && !statement.isTypeOnly && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+      for (let element of statement.exportClause.elements)
+        element.isTypeOnly || names.add(element.name.text);
+      continue;
+    }
+    if (!ts.canHaveModifiers(statement)) continue;
+    let modifiers = ts.getModifiers(statement);
+    if (!(!modifiers?.some(
+      (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword
+    ) || modifiers.some(
+      (modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword
+    ))) {
+      if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name)
+        names.add(statement.name.text);
+      else if (ts.isVariableStatement(statement))
+        for (let declaration of statement.declarationList.declarations)
+          for (let name of collectBindingNames(declaration.name))
+            names.add(name);
+    }
+  }
+  return names;
+}
+
+// src/lib/compiler/source/mdx-icon-imports.ts
+import { readFile } from "fs/promises";
+import { createRequire } from "module";
+import { dirname, resolve } from "path";
+import remarkMdx from "remark-mdx";
+import remarkParse from "remark-parse";
+import ts2 from "typescript";
+import { unified } from "unified";
+
+// src/lib/compiler/source/frontmatter.ts
+import { isAlias, isMap, isScalar, isSeq, parseDocument } from "yaml";
+function decimalValue(value) {
+  let match = /^([+-]?)(\d*)(?:\.(\d*))?(?:e([+-]?\d+))?$/i.exec(value);
+  if (!match || !(match[2] || match[3])) return;
+  let digits = `${match[2]}${match[3] ?? ""}`.replace(/^0+/, "");
+  if (!digits) return "0";
+  let trimmed = digits.replace(/0+$/, ""), exponent = BigInt(match[4] ?? "0") - BigInt((match[3] ?? "").length) + BigInt(digits.length - trimmed.length);
+  return `${match[1] === "-" ? "-" : ""}${trimmed}e${exponent}`;
+}
+function numberIsExact(source, value) {
+  if (!Number.isFinite(value)) return !1;
+  if (/^[-+]?0[ox]/i.test(source))
+    try {
+      return Number.isInteger(value) && BigInt(source.replace(/^\+/, "")) === BigInt(value);
+    } catch {
+      return !1;
+    }
+  return decimalValue(source) === decimalValue(String(value));
+}
+var FrontmatterParseError = class extends Error {
+  constructor(message, line, column, field) {
+    super(`${message} at line ${line}, column ${column}.`);
+    this.line = line;
+    this.column = column;
+    this.field = field;
+    this.name = "FrontmatterParseError";
+  }
+  line;
+  column;
+  field;
+};
+function parseSourceFrontmatter(source) {
+  let firstLine = /^(?:\uFEFF)?---(?:\r?\n|$)/.exec(source);
+  if (!firstLine) return { data: {}, content: source };
+  let offset = firstLine[0].length, fence, end = -1, bodyStart = -1;
+  for (; offset < source.length; ) {
+    let next = source.indexOf(`
+`, offset), lineEnd = next < 0 ? source.length : next, line = source.slice(offset, lineEnd).replace(/\r$/, ""), marker = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    if (marker) {
+      let run = marker[1] ?? "";
+      fence ? run.charAt(0) === fence.character && run.length >= fence.length && !(marker[2] ?? "").trim() && (fence = void 0) : fence = { character: run.charAt(0), length: run.length };
+    } else if (!fence && line === "---") {
+      end = offset, bodyStart = next < 0 ? source.length : next + 1;
+      break;
+    }
+    offset = next < 0 ? source.length : next + 1;
+  }
+  if (end < 0) return { data: {}, content: source };
+  let frontmatterOffset = firstLine[0].length;
+  function fail(message, offset2 = 0, field) {
+    let absoluteOffset = Math.min(frontmatterOffset + offset2, source.length), before = source.slice(0, absoluteOffset), line = before.split(`
+`).length, column = absoluteOffset - before.lastIndexOf(`
+`);
+    throw new FrontmatterParseError(message, line, column, field);
+  }
+  let doc = parseDocument(source.slice(firstLine[0].length, end), {
+    schema: "core",
+    uniqueKeys: !0
+  }), yamlError = doc.errors[0] ?? doc.warnings[0];
+  if (yamlError) {
+    let message = yamlError.message.replace(
+      / at line \d+, column \d+:[\s\S]*$/,
+      ""
+    );
+    fail(message, yamlError.pos[0]);
+  }
+  doc.contents && !isMap(doc.contents) && fail(
+    "Frontmatter must be a mapping with string keys",
+    doc.contents.range?.[0]
+  );
+  let visits = 0, active = /* @__PURE__ */ new Set();
+  function validate(node, field) {
+    if (node) {
+      if (++visits > 1e4 && fail("Frontmatter alias expansion exceeds the limit"), isAlias(node)) {
+        let target = node.resolve(doc);
+        target || fail(`Invalid alias in ${field}`, node.range?.[0], field), active.has(target) && fail(`Cyclic alias in ${field}`, node.range?.[0], field), validate(target, field);
+        return;
+      }
+      if (!(!isScalar(node) && !isMap(node) && !isSeq(node))) {
+        if (node.tag && ![
+          "tag:yaml.org,2002:str",
+          "tag:yaml.org,2002:int",
+          "tag:yaml.org,2002:float",
+          "tag:yaml.org,2002:bool",
+          "tag:yaml.org,2002:null",
+          "tag:yaml.org,2002:map",
+          "tag:yaml.org,2002:seq"
+        ].includes(node.tag) && fail(`Unsupported YAML tag in ${field}`, node.range?.[0], field), isScalar(node)) {
+          typeof node.value == "number" && !numberIsExact(node.source ?? String(node.value), node.value) && fail(
+            `Invalid number in ${field}; quote the value to preserve its exact digits`,
+            node.range?.[0],
+            field
+          );
+          return;
+        }
+        if (active.add(node), isMap(node))
+          for (let pair of node.items)
+            (!isScalar(pair.key) || typeof pair.key.value != "string") && fail(
+              `Frontmatter keys in ${field} must be strings`,
+              isScalar(pair.key) || isMap(pair.key) || isSeq(pair.key) || isAlias(pair.key) ? pair.key.range?.[0] : void 0,
+              field
+            ), validate(
+              pair.value,
+              field === "frontmatter" ? pair.key.value : `${field}.${pair.key.value}`
+            );
+        else
+          for (let item of node.items) validate(item, field);
+        active.delete(node);
+      }
+    }
+  }
+  validate(doc.contents, "frontmatter");
+  let data = doc.toJS({ maxAliasCount: 100 });
+  return {
+    data: data ? JSON.parse(JSON.stringify(data)) : {},
+    content: source.slice(bodyStart)
+  };
+}
+
+// src/lib/compiler/source/mdx-icon-imports.ts
+var mdxIconPackage = "@phosphor-icons/react/ssr", parser = unified().use(remarkParse).use(remarkMdx), MdxIconImportError = class extends Error {
+  constructor(message, line, column, code = "FRAMEWORK_MDX_IMPORT_REJECTED") {
+    super(message);
+    this.line = line;
+    this.column = column;
+    this.code = code;
+  }
+  line;
+  column;
+  code;
+};
+function mdxIconImportsFromTree(tree, lineOffset = 0) {
+  let imports = [];
+  for (let node of tree.children)
+    if (node.type === "mdxjsEsm")
+      for (let statement of node.data?.estree?.body ?? []) {
+        let line = (statement.loc?.start.line ?? node.position?.start.line ?? 1) + lineOffset, column = (statement.loc?.start.column ?? 0) + 1;
+        if (statement.type !== "ImportDeclaration" || statement.source.value !== mdxIconPackage || statement.specifiers.length === 0 || statement.specifiers.some(
+          (specifier) => specifier.type !== "ImportSpecifier"
+        ))
+          throw new MdxIconImportError(
+            `MDX supports named icon imports from "${mdxIconPackage}". Use import { ArrowRightIcon } from "${mdxIconPackage}". Other MDX imports and exports are unsupported.`,
+            line,
+            column
+          );
+        for (let specifier of statement.specifiers) {
+          if (specifier.type !== "ImportSpecifier") continue;
+          if (specifier.imported.type !== "Identifier")
+            throw new MdxIconImportError(
+              "Import an icon by its exact identifier, such as ArrowRightIcon.",
+              line,
+              column
+            );
+          let imported = specifier.imported.name;
+          imports.push({ imported, local: specifier.local.name, line, column });
+        }
+      }
+  return imports;
+}
+function readMdxIconImports(source, lineOffset = 0) {
+  return /^\s*(?:import|export)\s/m.test(source) ? mdxIconImportsFromTree(parser.parse(source), lineOffset) : [];
+}
+var exportedIcons;
+async function validateMdxIconImports(source) {
+  if (!/^\s*(?:import|export)\s/m.test(source)) return [];
+  let body = parseSourceFrontmatter(source).content, lineOffset = source.slice(0, source.length - body.length).split(`
+`).length - 1, imports = readMdxIconImports(body, lineOffset);
+  if (imports.length === 0) return imports;
+  exportedIcons ??= (async () => {
+    let require2 = createRequire(import.meta.url), entry = resolve(
+      dirname(require2.resolve("@phosphor-icons/react/package.json")),
+      "dist/ssr/index.es.js"
+    );
+    return namedValueExports(
+      ts2.createSourceFile(
+        entry,
+        await readFile(entry, "utf8"),
+        ts2.ScriptTarget.Latest,
+        !0
+      )
+    );
+  })();
+  let exports = await exportedIcons;
+  for (let binding of imports)
+    if (!exports.has(binding.imported))
+      throw new MdxIconImportError(
+        `"${binding.imported}" is not exported by "${mdxIconPackage}". Import an exact icon export such as ArrowRightIcon.`,
+        binding.line,
+        binding.column,
+        "FRAMEWORK_MDX_IMPORT_EXPORT_MISSING"
+      );
+  return imports;
+}
+
+// src/lib/shared/root-content-group.ts
+var ROOT_CONTENT_GROUP_KEY = "__root", ROOT_CONTENT_GROUP_TITLE = "Root";
+
+// src/lib/compiler/source/assert-source-dependency.ts
+import { lstat } from "fs/promises";
+import { isAbsolute, relative, resolve as resolve2, sep } from "path";
+async function assertSourceDependency({
+  publishOsDir,
+  path,
+  sourceFile
+}) {
+  let root = resolve2(publishOsDir), target = resolve2(path), targetRelativePath = relative(root, target), details = {
+    file: (isAbsolute(sourceFile) ? relative(root, sourceFile) : sourceFile).split(sep).join("/"),
+    target: targetRelativePath.split(sep).join("/")
+  };
+  if (!isSameOrDescendant(root, target))
+    throw new AppError({
+      code: "FRAMEWORK_SOURCE_DEPENDENCY_ESCAPE",
+      message: "Source dependencies must stay inside publish.os.",
+      details
+    });
+  if (isExcludedSourcePath(details.target))
+    throw new AppError({
+      code: "FRAMEWORK_SOURCE_DEPENDENCY_EXCLUDED",
+      message: "Source dependencies cannot use nested sites, generated output, or root IDE metadata.",
+      details
+    });
+  let segments = targetRelativePath ? targetRelativePath.split(sep) : [], current = root;
+  for (let segment of ["", ...segments]) {
+    current = resolve2(current, segment);
+    let entry = await lstat(current).catch((error) => {
+      throw error.code !== "ENOENT" && error.code !== "ENOTDIR" ? error : new AppError({
+        code: "FRAMEWORK_SOURCE_DEPENDENCY_MISSING",
+        message: "A source dependency does not exist.",
+        details
+      });
+    });
+    if (entry.isSymbolicLink())
+      throw new AppError({
+        code: "FRAMEWORK_SOURCE_DEPENDENCY_SYMLINK",
+        message: "Source dependencies cannot use symbolic links.",
+        details
+      });
+    if (current === target ? !entry.isFile() : !entry.isDirectory())
+      throw new AppError({
+        code: "FRAMEWORK_SOURCE_DEPENDENCY_NOT_FILE",
+        message: "A source dependency must resolve to a regular file.",
+        details
+      });
+  }
+}
+
+// src/lib/compiler/packages/nextjs-runtime-surface.json
+var nextjs_runtime_surface_default = {
+  packageExports: [
+    ".",
+    "./jsx-runtime",
+    "./jsx-dev-runtime",
+    "./resolvers/manifest-resolver",
+    "./mdx/error-boundary",
+    "./mdx/error-fallback",
+    "./mdx/mdx",
+    "./mdx/rehype-heading-ids",
+    "./mdx/types",
+    "./mdx/components/blockquote",
+    "./mdx/components/callout",
+    "./mdx/components/code-block",
+    "./mdx/components/figure-caption",
+    "./mdx/components/figure",
+    "./mdx/components/footnotes",
+    "./mdx/components/heading-copy-link",
+    "./mdx/components/heading",
+    "./mdx/components/hr",
+    "./mdx/components/image-zoom",
+    "./mdx/components/image",
+    "./mdx/components/inline-code",
+    "./mdx/components/kbd",
+    "./mdx/components/link",
+    "./mdx/components/paragraph",
+    "./mdx/components/strikethrough",
+    "./mdx/components/table",
+    "./mdx/components/task-list",
+    "./mdx/components/video",
+    "./mdx",
+    "./cache/tags",
+    "./keyboard-shortcuts",
+    "./search",
+    "./theme-scope",
+    "./types",
+    "./kernel/defaults.registry",
+    "./kernel/routes/agent/markdown",
+    "./kernel/routes/not-found",
+    "./kernel/routes/layouts/group",
+    "./kernel/routes/metadata/feed",
+    "./kernel/routes/metadata/llms",
+    "./kernel/routes/metadata/og-image",
+    "./kernel/routes/metadata/robots",
+    "./kernel/routes/metadata/sitemap",
+    "./kernel/routes/pages/group",
+    "./kernel/routes/pages/leaf",
+    "./kernel/routes/pages/root",
+    "./kernel/components/blocks/AgentActions",
+    "./kernel/components/blocks/agent-actions",
+    "./kernel/components/blocks/animated-icon-swap",
+    "./kernel/components/blocks/color-palette",
+    "./kernel/components/blocks/logo-block",
+    "./kernel/components/blocks/nav-breadcrumb",
+    "./kernel/components/blocks/navbar",
+    "./kernel/components/blocks/navigation-progress",
+    "./kernel/components/blocks/next-prev",
+    "./kernel/components/blocks/page-list",
+    "./kernel/components/blocks/search",
+    "./kernel/components/blocks/sidebar-node",
+    "./kernel/components/blocks/sidebar",
+    "./kernel/components/blocks/theme-toggle",
+    "./kernel/components/blocks/toc",
+    "./kernel/components/blocks/toc-client",
+    "./kernel/components/next-image",
+    "./kernel/components/mdx/error-boundary",
+    "./kernel/components/mdx/error-fallback",
+    "./kernel/components/mdx/mdx",
+    "./kernel/components/mdx/rehype-heading-ids",
+    "./kernel/components/mdx/types",
+    "./kernel/components/mdx/components/blockquote",
+    "./kernel/components/mdx/components/callout",
+    "./kernel/components/mdx/components/code-block",
+    "./kernel/components/mdx/components/copy-code-button",
+    "./kernel/components/mdx/components/figure-caption",
+    "./kernel/components/mdx/components/figure",
+    "./kernel/components/mdx/components/footnotes",
+    "./kernel/components/mdx/components/heading-copy-link",
+    "./kernel/components/mdx/components/heading",
+    "./kernel/components/mdx/components/hr",
+    "./kernel/components/mdx/components/image-zoom",
+    "./kernel/components/mdx/components/image",
+    "./kernel/components/mdx/components/inline-code",
+    "./kernel/components/mdx/components/kbd",
+    "./kernel/components/mdx/components/link",
+    "./kernel/components/mdx/components/paragraph",
+    "./kernel/components/mdx/components/strikethrough",
+    "./kernel/components/mdx/components/table",
+    "./kernel/components/mdx/components/task-list",
+    "./kernel/components/mdx/components/video-player",
+    "./kernel/components/mdx/components/video",
+    "./kernel/components/ui/accordion",
+    "./kernel/components/ui/breadcrumb-trail",
+    "./kernel/components/ui/breadcrumb",
+    "./kernel/components/ui/button-group",
+    "./kernel/components/ui/button",
+    "./components/ui/button",
+    "./components/blocks/toc",
+    "./components/blocks/agent-actions",
+    "./kernel/components/ui/card",
+    "./kernel/components/ui/dialog",
+    "./kernel/components/ui/drawer",
+    "./kernel/components/ui/input",
+    "./kernel/components/ui/kbd",
+    "./kernel/components/ui/link",
+    "./kernel/components/ui/menu",
+    "./kernel/components/ui/mod-key",
+    "./kernel/components/ui/navigation-menu",
+    "./kernel/components/ui/popover",
+    "./kernel/components/ui/progress",
+    "./kernel/components/ui/scroll-area",
+    "./kernel/components/ui/select",
+    "./kernel/components/ui/separator",
+    "./kernel/components/ui/table",
+    "./kernel/components/ui/tabs",
+    "./kernel/components/ui/tag",
+    "./kernel/components/ui/text",
+    "./kernel/components/ui/toast",
+    "./kernel/components/ui/tooltip",
+    "./utils/pretty-date",
+    "./utils/cn",
+    "./utils/heading-ids",
+    "./utils/toc-selection",
+    "./config/createNextConfig"
+  ],
+  allowedSourceImports: [
+    "@publish.os/nextjs",
+    "@publish.os/nextjs/jsx-runtime",
+    "@publish.os/nextjs/jsx-dev-runtime",
+    "@publish.os/nextjs/cache/tags",
+    "@publish.os/nextjs/config/createNextConfig",
+    "@publish.os/nextjs/kernel/components/blocks/navigation-progress",
+    "@publish.os/nextjs/components/ui/button",
+    "@publish.os/nextjs/components/blocks/toc",
+    "@publish.os/nextjs/components/blocks/agent-actions",
+    "@publish.os/nextjs/kernel/components/blocks/toc-client",
+    "@publish.os/nextjs/kernel/routes/layouts/group",
+    "@publish.os/nextjs/kernel/routes/metadata/feed",
+    "@publish.os/nextjs/kernel/routes/metadata/llms",
+    "@publish.os/nextjs/kernel/routes/metadata/og-image",
+    "@publish.os/nextjs/kernel/routes/metadata/robots",
+    "@publish.os/nextjs/kernel/routes/metadata/sitemap",
+    "@publish.os/nextjs/kernel/routes/pages/group",
+    "@publish.os/nextjs/kernel/routes/pages/leaf",
+    "@publish.os/nextjs/kernel/routes/pages/root",
+    "@publish.os/nextjs/keyboard-shortcuts",
+    "@publish.os/nextjs/mdx",
+    "@publish.os/nextjs/mdx/error-boundary",
+    "@publish.os/nextjs/mdx/error-fallback",
+    "@publish.os/nextjs/mdx/mdx",
+    "@publish.os/nextjs/resolvers/manifest-resolver",
+    "@publish.os/nextjs/search",
+    "@publish.os/nextjs/theme-scope",
+    "@publish.os/nextjs/types",
+    "@publish.os/nextjs/utils/cn",
+    "@publish.os/nextjs/utils/heading-ids",
+    "@publish.os/nextjs/utils/toc-selection",
+    "@publish.os/nextjs/utils/pretty-date"
+  ],
+  allowedSourceDependencyImports: [
+    "@phosphor-icons/react/ssr",
+    "react",
+    "react-dom",
+    "class-variance-authority",
+    "next/link",
+    "next/image",
+    "next/navigation",
+    "@base-ui/react/accordion",
+    "@base-ui/react/button",
+    "@base-ui/react/checkbox",
+    "@base-ui/react/dialog",
+    "@base-ui/react/drawer",
+    "@base-ui/react/input",
+    "@base-ui/react/menu",
+    "@base-ui/react/popover",
+    "@base-ui/react/progress",
+    "@base-ui/react/scroll-area",
+    "@base-ui/react/select",
+    "@base-ui/react/separator",
+    "@base-ui/react/switch",
+    "@base-ui/react/tabs",
+    "@base-ui/react/tooltip",
+    "@base-ui/react/toast"
+  ],
+  entries: {
+    index: "src/index.ts",
+    "jsx-runtime": "src/jsx-runtime.ts",
+    "jsx-dev-runtime": "src/jsx-dev-runtime.ts",
+    "cache/tags": "src/cache-tags.ts",
+    "config/createNextConfig": "src/create-next-config.ts",
+    "keyboard-shortcuts": "src/lib/keyboard/keyboard-shortcuts.tsx",
+    search: "src/modules/search/search.tsx",
+    "theme-scope": "src/lib/theme/theme-scope.tsx",
+    "kernel/defaults.registry": "src/defaults-registry.ts",
+    "kernel/components/blocks/AgentActions": "src/modules/agent-actions/agent-actions.tsx",
+    "kernel/components/blocks/agent-actions": "src/modules/agent-actions/agent-actions.tsx",
+    "kernel/components/blocks/animated-icon-swap": "src/components/ui/animated-icon-swap.tsx",
+    "kernel/components/blocks/color-palette": "src/modules/design-system/color-palette.tsx",
+    "kernel/components/blocks/logo-block": "src/components/block/logo-block.tsx",
+    "kernel/components/blocks/nav-breadcrumb": "src/components/block/navbar/nav-breadcrumb.tsx",
+    "kernel/components/blocks/navbar": "src/components/block/navbar/navbar.tsx",
+    "kernel/components/blocks/navigation-progress": "src/components/block/navigation-progress.tsx",
+    "kernel/components/blocks/next-prev": "src/components/block/page-navigation/next-prev.tsx",
+    "kernel/components/blocks/page-list": "src/components/block/page-navigation/page-list.tsx",
+    "kernel/components/blocks/search": "src/modules/search/search-block.tsx",
+    "kernel/components/blocks/sidebar-node": "src/components/block/sidebar/sidebar-node.tsx",
+    "kernel/components/blocks/sidebar": "src/components/block/sidebar/sidebar.tsx",
+    "kernel/components/blocks/theme-toggle": "src/components/block/theme-toggle.tsx",
+    "kernel/components/blocks/toc": "src/components/block/toc/toc.tsx",
+    "kernel/components/blocks/toc-client": "src/components/block/toc/toc-client.tsx",
+    "kernel/components/next-image": "src/components/next-image.tsx",
+    "kernel/components/mdx/error-boundary": "src/components/mdx/error-boundary.tsx",
+    "kernel/components/mdx/error-fallback": "src/components/mdx/error-fallback.tsx",
+    "kernel/components/mdx/mdx": "src/components/mdx/mdx.tsx",
+    "kernel/components/mdx/rehype-heading-ids": "src/components/mdx/plugins/rehype-heading-ids.ts",
+    "kernel/components/mdx/types": "src/components/mdx/types.ts",
+    "kernel/routes/layouts/group": "src/route-layout-group.tsx",
+    "kernel/routes/agent/markdown": "src/route-agent-markdown.ts",
+    "kernel/routes/not-found": "src/route-not-found.ts",
+    "kernel/routes/metadata/feed": "src/route-metadata-feed.ts",
+    "kernel/routes/metadata/llms": "src/route-metadata-llms.ts",
+    "kernel/routes/metadata/og-image": "src/route-metadata-og-image.tsx",
+    "kernel/routes/metadata/robots": "src/route-metadata-robots.ts",
+    "kernel/routes/metadata/sitemap": "src/route-metadata-sitemap.ts",
+    "kernel/routes/pages/group": "src/route-page-group.tsx",
+    "kernel/routes/pages/leaf": "src/route-page-leaf.tsx",
+    "kernel/routes/pages/root": "src/route-page-root.tsx",
+    "resolvers/manifest-resolver": "src/manifest-resolver.ts",
+    types: "src/types.ts",
+    "utils/cn": "src/components/utils/cn.ts",
+    "utils/heading-ids": "src/components/mdx/heading-ids.ts",
+    "utils/toc-selection": "src/components/block/toc/selection.ts",
+    "utils/pretty-date": "src/components/utils/pretty-date.ts",
+    "kernel/components/mdx/components/blockquote": "src/components/mdx/blockquote.tsx",
+    "kernel/components/mdx/components/callout": "src/components/mdx/callout.tsx",
+    "kernel/components/mdx/components/code-block": "src/components/mdx/code-block/code-block.tsx",
+    "kernel/components/mdx/components/copy-code-button": "src/components/mdx/code-block/copy-code-button.tsx",
+    "kernel/components/mdx/components/figure-caption": "src/components/mdx/figure/figure-caption.tsx",
+    "kernel/components/mdx/components/figure": "src/components/mdx/figure/figure.tsx",
+    "kernel/components/mdx/components/footnotes": "src/components/mdx/footnotes.tsx",
+    "kernel/components/mdx/components/heading-copy-link": "src/components/mdx/heading-copy-link.tsx",
+    "kernel/components/mdx/components/heading": "src/components/mdx/heading.tsx",
+    "kernel/components/mdx/components/hr": "src/components/mdx/hr.tsx",
+    "kernel/components/mdx/components/image-zoom": "src/components/mdx/image/image-zoom.tsx",
+    "kernel/components/mdx/components/image": "src/components/mdx/image/image.tsx",
+    "kernel/components/mdx/components/inline-code": "src/components/mdx/inline-code.tsx",
+    "kernel/components/mdx/components/kbd": "src/components/mdx/kbd.tsx",
+    "kernel/components/mdx/components/link": "src/components/mdx/link.tsx",
+    "kernel/components/mdx/components/paragraph": "src/components/mdx/paragraph.tsx",
+    "kernel/components/mdx/components/strikethrough": "src/components/mdx/strikethrough.tsx",
+    "kernel/components/mdx/components/table": "src/components/mdx/table.tsx",
+    "kernel/components/mdx/components/task-list": "src/components/mdx/task-list.tsx",
+    "kernel/components/mdx/components/video-player": "src/components/mdx/video/video-player.tsx",
+    "kernel/components/mdx/components/video": "src/components/mdx/video/video.tsx",
+    "kernel/components/ui/accordion": "src/components/ui/accordion.tsx",
+    "kernel/components/ui/breadcrumb-trail": "src/components/ui/breadcrumb-trail.tsx",
+    "kernel/components/ui/breadcrumb": "src/components/ui/breadcrumb.tsx",
+    "kernel/components/ui/button-group": "src/components/ui/button-group.tsx",
+    "kernel/components/ui/button": "src/components/ui/button.tsx",
+    "components/ui/button": "src/components/ui/button.tsx",
+    "components/blocks/toc": "src/components/block/toc/toc.tsx",
+    "components/blocks/agent-actions": "src/modules/agent-actions/agent-actions.tsx",
+    "kernel/components/ui/card": "src/components/ui/card.tsx",
+    "kernel/components/ui/dialog": "src/components/ui/dialog.tsx",
+    "kernel/components/ui/drawer": "src/components/ui/drawer.tsx",
+    "kernel/components/ui/input": "src/components/ui/input.tsx",
+    "kernel/components/ui/kbd": "src/components/ui/kbd.tsx",
+    "kernel/components/ui/link": "src/components/ui/link.tsx",
+    "kernel/components/ui/menu": "src/components/ui/menu.tsx",
+    "kernel/components/ui/mod-key": "src/components/ui/mod-key.tsx",
+    "kernel/components/ui/navigation-menu": "src/components/ui/navigation-menu.tsx",
+    "kernel/components/ui/popover": "src/components/ui/popover.tsx",
+    "kernel/components/ui/progress": "src/components/ui/progress.tsx",
+    "kernel/components/ui/scroll-area": "src/components/ui/scroll-area.tsx",
+    "kernel/components/ui/select": "src/components/ui/select.tsx",
+    "kernel/components/ui/separator": "src/components/ui/separator.tsx",
+    "kernel/components/ui/table": "src/components/ui/table.tsx",
+    "kernel/components/ui/tabs": "src/components/ui/tabs.tsx",
+    "kernel/components/ui/tag": "src/components/ui/tag.tsx",
+    "kernel/components/ui/text": "src/components/ui/text.tsx",
+    "kernel/components/ui/toast": "src/components/ui/toast.tsx",
+    "kernel/components/ui/tooltip": "src/components/ui/tooltip.tsx"
+  },
+  entryAliases: {},
+  browserEntries: [
+    "src/lib/keyboard/keyboard-shortcuts.tsx",
+    "src/modules/search/search.tsx",
+    "src/lib/theme/theme-scope.tsx",
+    "src/modules/agent-actions/agent-actions.tsx",
+    "src/modules/design-system/color-palette.tsx",
+    "src/components/block/navbar/navbar.tsx",
+    "src/components/block/navigation-progress.tsx",
+    "src/modules/search/search-block.tsx",
+    "src/components/block/sidebar/sidebar.tsx",
+    "src/components/block/toc/toc-client.tsx",
+    "src/components/mdx/error-boundary.tsx",
+    "src/components/mdx/types.ts",
+    "src/types.ts",
+    "src/components/utils/cn.ts",
+    "src/components/mdx/heading-ids.ts",
+    "src/components/utils/pretty-date.ts",
+    "src/components/mdx/heading-copy-link.tsx",
+    "src/components/mdx/image/image-zoom.tsx",
+    "src/components/mdx/video/video-player.tsx",
+    "src/components/ui/accordion.tsx",
+    "src/components/ui/breadcrumb-trail.tsx",
+    "src/components/ui/dialog.tsx",
+    "src/components/ui/drawer.tsx",
+    "src/components/ui/menu.tsx",
+    "src/components/ui/navigation-menu.tsx",
+    "src/components/ui/popover.tsx",
+    "src/components/ui/progress.tsx",
+    "src/components/ui/scroll-area.tsx",
+    "src/components/ui/tabs.tsx",
+    "src/components/ui/toast.tsx",
+    "src/components/ui/tooltip.tsx"
+  ]
+};
+
+// src/lib/compiler/packages/nextjs-runtime-surface.ts
+var surface = nextjs_runtime_surface_default, allowedNextjsSourceImports = [...surface.allowedSourceImports], allowedNextjsSourceDependencyImports = [
+  ...surface.allowedSourceDependencyImports
+];
+function supportedNextjsSourceImports() {
+  return [
+    ...allowedNextjsSourceImports,
+    ...allowedNextjsSourceDependencyImports
+  ];
+}
+function supportedRuntimeComponentAliases() {
+  return Object.keys(surface.entries).filter((name) => name.startsWith("kernel/components/")).map((name) => `@components/${name.slice(18)}`);
+}
+function originalDefaultComponentSourcePath(specifier) {
+  let prefix = "@publish.os/nextjs/";
+  if (!specifier.startsWith(prefix)) return;
+  let subpath = specifier.slice(prefix.length);
+  if (!surface.packageExports.includes(`./${subpath}`) || !surface.entries[subpath])
+    return;
+  let componentPrefix = "kernel/components/";
+  if (!subpath.startsWith(componentPrefix)) return;
+  let sourcePath = subpath.slice(componentPrefix.length);
+  if (sourcePath.startsWith("mdx/components/") && (sourcePath = `mdx/${sourcePath.slice(15)}`), !!/^(?:ui|blocks|mdx)\//.test(sourcePath))
+    return `components/${sourcePath}`;
+}
+
+// src/lib/compiler/source/assets/favicons-and-logos.ts
+import { extname } from "path";
+var MAX_FAVICON_BYTES = 1 * 1024 * 1024, MAX_LOGO_BYTES = 2 * 1024 * 1024, FAVICON_FORMATS = ["svg", "png", "jpg", "jpeg", "ico"], LOGO_FORMATS = ["svg", "png", "jpg", "jpeg", "webp", "avif"], FORMAT_RANK = {
+  svg: 0,
+  png: 1,
+  jpg: 2,
+  jpeg: 2,
+  ico: 3
+}, LOGO_FORMAT_RANK = {
+  svg: 0,
+  png: 1,
+  jpg: 2,
+  jpeg: 2,
+  webp: 3,
+  avif: 4
+};
+function formatOf(path) {
+  return extname(path).slice(1).toLowerCase();
+}
+function normalizedToken(value) {
+  return value.toLowerCase().split(/[._-]+/).filter(Boolean);
+}
+function classifyPath(path) {
+  let segments = path.split("/"), file = segments.at(-1) ?? "", format = formatOf(file), stem = file.slice(0, -(format.length + 1)), tokens = normalizedToken(stem), inLogoFolder = segments[0] === "assets" && segments[1]?.toLowerCase() === "logo", inFaviconFolder = segments[0] === "assets" && segments[1]?.toLowerCase() === "favicon", inIdentityFolder = inLogoFolder || inFaviconFolder, explicitRoles = /* @__PURE__ */ new Set();
+  if (tokens.includes("logo") && explicitRoles.add("logo"), tokens.includes("mark") && explicitRoles.add("mark"), tokens.includes("wordmark") && explicitRoles.add("wordmark"), tokens.includes("favicon") && explicitRoles.add("favicon"), tokens.includes("apple") && tokens.includes("icon") && explicitRoles.add("apple-icon"), explicitRoles.size > 1)
+    throw conflict("FRAMEWORK_IDENTITY_ROLE_CONFLICT", [path]);
+  let explicitRole = [...explicitRoles][0];
+  if (inLogoFolder && inFaviconFolder)
+    throw conflict("FRAMEWORK_IDENTITY_FOLDER_CONFLICT", [path]);
+  if (inLogoFolder && ["favicon", "apple-icon"].includes(explicitRole ?? "") || inFaviconFolder && ["logo", "mark", "wordmark"].includes(explicitRole ?? ""))
+    throw conflict("FRAMEWORK_IDENTITY_FOLDER_ROLE_CONFLICT", [path]);
+  let role = explicitRole;
+  !role && inLogoFolder && (role = "logo"), !role && inFaviconFolder && (role = "favicon");
+  let hasModeLight = tokens.includes("light"), hasModeDark = tokens.includes("dark");
+  if (hasModeLight && hasModeDark)
+    throw conflict("FRAMEWORK_IDENTITY_MODE_CONFLICT", [path]);
+  let mode = hasModeLight ? "light" : hasModeDark ? "dark" : "default";
+  if (!role && !inIdentityFolder && (hasModeLight || hasModeDark) && (role = "logo"), !role) return;
+  let roleTokens = tokens.filter(
+    (token) => token !== "light" && token !== "dark"
+  ), priority = role === "apple-icon" && roleTokens.length === 2 && roleTokens[0] === "apple" && roleTokens[1] === "icon" || role !== "apple-icon" && roleTokens.length === 1 && roleTokens[0] === role ? 1 : explicitRole ? 2 : format === "svg" ? 3 : inIdentityFolder ? 4 : 5;
+  if (role === "apple-icon" && (inLogoFolder || format === "svg"))
+    throw conflict("FRAMEWORK_IDENTITY_FORMAT_REJECTED", [path]);
+  if (role === "favicon" && !FAVICON_FORMATS.includes(format))
+    throw conflict("FRAMEWORK_IDENTITY_FORMAT_REJECTED", [path]);
+  if (role === "apple-icon" && !["png", "jpg", "jpeg"].includes(format))
+    throw conflict("FRAMEWORK_IDENTITY_FORMAT_REJECTED", [path]);
+  if (["logo", "mark", "wordmark"].includes(role) && !LOGO_FORMATS.includes(format))
+    throw conflict("FRAMEWORK_IDENTITY_FORMAT_REJECTED", [path]);
+  if (role === "apple-icon" && mode !== "default")
+    throw conflict("FRAMEWORK_IDENTITY_MODE_CONFLICT", [path]);
+  return { path, role, mode, format, priority };
+}
+function conflict(code, paths) {
+  let candidates = [...paths].sort();
+  return new AppError({
+    code,
+    message: `Identity asset conflict: ${candidates.join(", ")}`,
+    details: { candidates }
+  });
+}
+function duplicateWarning(role, mode, candidates) {
+  let paths = candidates.map((candidate) => candidate.path).sort(), selected = paths[0] ?? "", ignored = paths.slice(1);
+  return {
+    code: "FRAMEWORK_IDENTITY_DUPLICATE",
+    level: "warning",
+    message: `Duplicate ${role} identity assets for ${mode} mode; using ${selected} and ignoring ${ignored.join(", ")}.`,
+    details: { role, mode, selected, candidates: paths }
+  };
+}
+function deduplicateCandidates(candidates, role) {
+  let groups = /* @__PURE__ */ new Map();
+  for (let candidate of candidates) {
+    let format = ["jpg", "jpeg"].includes(candidate.format) ? "jpeg" : candidate.format, key = role === "favicon" ? `${candidate.mode}:${format}:${candidate.size ?? ""}` : role === "apple-icon" ? `${format}:${candidate.size ?? ""}` : `${candidate.mode}:${format}`, group = groups.get(key) ?? [];
+    group.push(candidate), groups.set(key, group);
+  }
+  let selected = [], warnings = [];
+  for (let key of [...groups.keys()].sort()) {
+    let group = (groups.get(key) ?? []).sort(
+      (left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0
+    ), winner = group[0];
+    winner && selected.push(winner), group.length > 1 && winner && warnings.push(duplicateWarning(role, winner.mode, group));
+  }
+  return { candidates: selected, warnings };
+}
+function chooseCandidates(candidates, role) {
+  let roleCandidates = candidates.filter(
+    (candidate) => candidate.role === role
+  );
+  if (roleCandidates.length === 0) return { selected: [], warnings: [] };
+  if (role === "apple-icon") {
+    let byFormatAndSize = /* @__PURE__ */ new Map();
+    for (let candidate of roleCandidates) {
+      let key = `${["jpg", "jpeg"].includes(candidate.format) ? "jpeg" : candidate.format}:${candidate.size ?? ""}`, group = byFormatAndSize.get(key) ?? [];
+      group.push(candidate), byFormatAndSize.set(key, group);
+    }
+    let selected2 = [], warnings = [];
+    for (let key of [...byFormatAndSize.keys()].sort()) {
+      let group = byFormatAndSize.get(key) ?? [], priority2 = Math.min(
+        ...group.map((candidate) => candidate.priority)
+      ), deduplicated = deduplicateCandidates(
+        group.filter((candidate) => candidate.priority === priority2),
+        role
+      );
+      selected2.push(...deduplicated.candidates), warnings.push(...deduplicated.warnings);
+    }
+    return { selected: selected2, warnings };
+  }
+  let priority = Math.min(
+    ...roleCandidates.map((candidate) => candidate.priority)
+  ), winning = deduplicateCandidates(
+    roleCandidates.filter((candidate) => candidate.priority === priority),
+    role
+  ), selected = [];
+  for (let requestedMode of ["light", "dark"]) {
+    let modeCandidates = winning.candidates.filter((candidate) => candidate.mode === requestedMode).length > 0 ? winning.candidates.filter(
+      (candidate) => candidate.mode === requestedMode
+    ) : winning.candidates.filter((candidate) => candidate.mode === "default").length > 0 ? winning.candidates.filter(
+      (candidate) => candidate.mode === "default"
+    ) : winning.candidates.filter(
+      (candidate) => candidate.mode !== requestedMode
+    );
+    if (role === "favicon") {
+      if (modeCandidates.length === 0) continue;
+      let formatRank = Math.min(
+        ...modeCandidates.map(
+          (candidate) => FORMAT_RANK[candidate.format] ?? 99
+        )
+      );
+      selected.push(
+        ...modeCandidates.filter(
+          (candidate) => (FORMAT_RANK[candidate.format] ?? 99) === formatRank
+        )
+      );
+    } else {
+      let formatRank = Math.min(
+        ...modeCandidates.map(
+          (candidate) => LOGO_FORMAT_RANK[candidate.format] ?? 99
+        )
+      ), preferred = modeCandidates.filter(
+        (candidate) => (LOGO_FORMAT_RANK[candidate.format] ?? 99) === formatRank
+      ).sort(
+        (left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0
+      );
+      preferred[0] && selected.push(preferred[0]);
+    }
+  }
+  let unique = /* @__PURE__ */ new Map();
+  for (let item of selected) unique.set(item.path, item);
+  return {
+    selected: [...unique.values()],
+    warnings: winning.warnings
+  };
+}
+function icoSizes(contents) {
+  if (contents.length < 6) return;
+  let count = contents.readUInt16LE(4), sizes = /* @__PURE__ */ new Set();
+  for (let index = 0; index < count; index += 1) {
+    let offset = 6 + index * 16;
+    if (offset + 16 > contents.length) break;
+    let width = contents[offset] || 256, height = contents[offset + 1] || 256;
+    sizes.add(`${width}x${height}`);
+  }
+  return [...sizes].sort().join(", ") || void 0;
+}
+function assetSizes(asset) {
+  return asset.sizes ? asset.sizes : asset.width && asset.height ? `${asset.width}x${asset.height}` : asset.mimeType === "image/svg+xml" ? "any" : void 0;
+}
+function buildFaviconsAndLogos(options) {
+  let mediaImages = /* @__PURE__ */ new Map();
+  for (let output of options.media.outputs)
+    mediaImages.set(output.outputPath, output.contents);
+  let candidates = [];
+  for (let [sourceUrl, media] of Object.entries(
+    options.media.manifest.assets
+  )) {
+    if (media.mediaType !== "image") continue;
+    let path = sourceUrl.slice(1), candidate = classifyPath(path);
+    if (!candidate) continue;
+    let bytes = mediaImages.get(media.outputPath);
+    if (!bytes) continue;
+    let limit = ["logo", "mark", "wordmark"].includes(candidate.role) ? MAX_LOGO_BYTES : MAX_FAVICON_BYTES;
+    if (media.byteSize > limit)
+      throw new AppError({
+        code: "FRAMEWORK_IDENTITY_FILE_TOO_LARGE",
+        message: `${path} exceeds the ${limit} byte identity image limit`,
+        details: { path, bytes: media.byteSize, limit }
+      });
+    if ((candidate.role === "favicon" || candidate.role === "apple-icon") && (candidate.format === "ico" && (icoSizes(bytes)?.split(", ").some((size) => {
+      let [width, height] = size.split("x").map(Number);
+      return width !== height;
+    }) ?? !1) || media.width && media.height && media.width !== media.height))
+      throw conflict("FRAMEWORK_IDENTITY_NOT_SQUARE", [path]);
+    candidates.push({
+      ...candidate,
+      size: candidate.format === "ico" ? icoSizes(bytes) : media.width && media.height ? `${media.width}x${media.height}` : candidate.format === "svg" ? "any" : void 0
+    });
+  }
+  let choices = [
+    chooseCandidates(candidates, "favicon"),
+    chooseCandidates(candidates, "apple-icon"),
+    chooseCandidates(candidates, "logo"),
+    chooseCandidates(candidates, "mark"),
+    chooseCandidates(candidates, "wordmark")
+  ], selected = choices.flatMap((choice) => choice.selected), warnings = choices.flatMap((choice) => choice.warnings), assets = [];
+  for (let candidate of selected) {
+    let mediaEntry = options.media.manifest.assets[`/${candidate.path}`];
+    if (!mediaEntry) continue;
+    let contents = mediaImages.get(mediaEntry.outputPath);
+    if (!contents) continue;
+    let sizes = candidate.format === "ico" ? icoSizes(contents) : void 0, asset = {
+      kind: `${candidate.role}-${candidate.mode}`,
+      sourcePath: mediaEntry.sourcePath,
+      outputPath: mediaEntry.outputPath,
+      contentHash: mediaEntry.contentHash,
+      mimeType: mediaEntry.mimeType,
+      byteSize: mediaEntry.byteSize,
+      width: mediaEntry.width,
+      height: mediaEntry.height,
+      sizes
+    };
+    assets.push(asset);
+  }
+  let by = (role, mode) => assets.find((asset) => asset.kind === `${role}-${mode}`), all = (role, mode) => assets.filter((asset) => asset.kind === `${role}-${mode}`), favicon = {
+    fallback: all("favicon", "default"),
+    light: all("favicon", "light").length ? all("favicon", "light") : all("favicon", "default").length ? all("favicon", "default") : all("favicon", "dark"),
+    dark: all("favicon", "dark").length ? all("favicon", "dark") : all("favicon", "default").length ? all("favicon", "default") : all("favicon", "light"),
+    apple: all("apple-icon", "default")
+  }, logo = {
+    light: by("logo", "light") ?? by("logo", "default") ?? by("logo", "dark"),
+    dark: by("logo", "dark") ?? by("logo", "default") ?? by("logo", "light"),
+    markLight: by("mark", "light") ?? by("mark", "default") ?? by("mark", "dark"),
+    markDark: by("mark", "dark") ?? by("mark", "default") ?? by("mark", "light"),
+    wordmarkLight: by("wordmark", "light") ?? by("wordmark", "default") ?? by("wordmark", "dark"),
+    wordmarkDark: by("wordmark", "dark") ?? by("wordmark", "default") ?? by("wordmark", "light")
+  }, icon = [];
+  for (let [mode, entries] of [
+    ["light", favicon.light],
+    ["dark", favicon.dark]
+  ])
+    for (let entry of entries ?? []) {
+      let existing = icon.find((item) => item.url === entry.outputPath);
+      existing ? delete existing.media : icon.push({
+        url: entry.outputPath,
+        type: entry.mimeType,
+        sizes: assetSizes(entry),
+        media: `(prefers-color-scheme: ${mode})`
+      });
+    }
+  let apple = favicon.apple?.map((entry) => ({
+    url: entry.outputPath,
+    type: entry.mimeType,
+    sizes: assetSizes(entry)
+  }));
+  return {
+    manifest: {
+      assets,
+      favicon,
+      logo,
+      metadataIcons: {
+        ...icon.length ? { icon } : {},
+        ...apple?.length ? { apple } : {}
+      }
+    },
+    warnings
+  };
+}
+function faviconsAndLogosManifestModule(manifest) {
+  return `export const faviconsAndLogos = ${JSON.stringify(manifest, null, 2)} as const;
+
+export type FaviconsAndLogosManifest = typeof faviconsAndLogos;
+export type FaviconAndLogoAssetManifestEntry = FaviconsAndLogosManifest["assets"][number];
+`;
+}
+
+// src/lib/compiler/source/assets/media-assets.ts
+import { createHash } from "crypto";
+import { lstat as lstat2, mkdir, readdir, rm, writeFile } from "fs/promises";
+import { dirname as dirname2, join, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+
+// src/lib/compiler/source/assets/image-admission.ts
+import { inflateSync } from "zlib";
+import valueParser from "postcss-value-parser";
+import { SaxesParser } from "saxes";
+import sharp from "sharp";
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+function pngCrc32(contents) {
+  let crc = 4294967295;
+  for (let byte of contents) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit += 1)
+      crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function isValidIcoPng(options) {
+  let { payload, width, height, directoryBitDepth } = options;
+  if (payload.length < 45 || !payload.subarray(0, 8).equals(PNG_SIGNATURE))
+    return !1;
+  let offset = 8, imageDataSeen = !1, paletteSeen = !1, imageDataEnded = !1, headerSeen = !1, ended = !1, bitDepth = 0, colorType = -1, interlace = -1, imageData = [];
+  for (; offset + 12 <= payload.length; ) {
+    let length = payload.readUInt32BE(offset), end = offset + 12 + length;
+    if (end > payload.length) return !1;
+    let type = payload.toString("ascii", offset + 4, offset + 8), data = payload.subarray(offset + 8, offset + 8 + length), checkData = payload.subarray(offset + 4, offset + 8 + length);
+    if (pngCrc32(checkData) !== payload.readUInt32BE(offset + 8 + length))
+      return !1;
+    if (type === "IHDR") {
+      if (offset !== 8 || length !== 13 || headerSeen || (headerSeen = !0, data.readUInt32BE(0) !== width || data.readUInt32BE(4) !== height) || (bitDepth = data[8] ?? 0, colorType = data[9] ?? -1, interlace = data[12] ?? -1, !{
+        0: [1, 2, 4, 8, 16],
+        2: [8, 16],
+        3: [1, 2, 4, 8],
+        4: [8, 16],
+        6: [8, 16]
+      }[colorType]?.includes(bitDepth) || data[10] !== 0 || data[11] !== 0 || interlace !== 0 && interlace !== 1))
+        return !1;
+    } else if (type === "PLTE") {
+      if (imageDataSeen || length === 0 || length % 3 !== 0 || length > 768)
+        return !1;
+      paletteSeen = !0;
+    } else if (type === "IDAT") {
+      if (imageDataEnded || colorType === 3 && !paletteSeen) return !1;
+      imageDataSeen = !0, imageData.push(data);
+    } else if (type === "IEND") {
+      if (length !== 0 || !imageDataSeen || end !== payload.length)
+        return !1;
+      ended = !0;
+      break;
+    } else {
+      imageDataSeen && (imageDataEnded = !0);
+      let ancillary = (type.charCodeAt(0) ?? 0) >= 97;
+      if (type === "tRNS" ? imageDataSeen : !ancillary) return !1;
+    }
+    offset = end;
+  }
+  if (!headerSeen || !ended || imageData.length === 0) return !1;
+  let bitsPerPixel = bitDepth * ({
+    0: 1,
+    2: 3,
+    3: 1,
+    4: 2,
+    6: 4
+  }[colorType] ?? 0), expectedDirectoryDepth = colorType === 3 ? bitDepth : bitsPerPixel, passRows = (interlace === 0 ? [[0, 0, 1, 1]] : [
+    [0, 0, 8, 8],
+    [4, 0, 8, 8],
+    [0, 4, 4, 8],
+    [2, 0, 4, 4],
+    [0, 2, 2, 4],
+    [1, 0, 2, 2],
+    [0, 1, 1, 2]
+  ]).flatMap(([xStart, yStart, xStep, yStep]) => {
+    let passWidth = width > xStart ? Math.ceil((width - xStart) / xStep) : 0, passHeight = height > yStart ? Math.ceil((height - yStart) / yStep) : 0;
+    if (passWidth === 0 || passHeight === 0) return [];
+    let rowBytes = Math.ceil(passWidth * bitsPerPixel / 8);
+    return Array.from({ length: passHeight }, () => rowBytes);
+  }), expectedInflatedBytes = passRows.reduce(
+    (total, rowBytes) => total + rowBytes + 1,
+    0
+  );
+  try {
+    let decoded = inflateSync(Buffer.concat(imageData), {
+      maxOutputLength: expectedInflatedBytes
+    });
+    if (decoded.length !== expectedInflatedBytes) return !1;
+    let decodedOffset = 0;
+    for (let rowBytes of passRows) {
+      if ((decoded[decodedOffset] ?? 255) > 4) return !1;
+      decodedOffset += rowBytes + 1;
+    }
+    return expectedDirectoryDepth === directoryBitDepth;
+  } catch {
+    return !1;
+  }
+}
+function isValidIcoDib(options) {
+  let { payload, width, height, directoryBitDepth } = options;
+  if (payload.length < 40) return !1;
+  let headerSize = payload.readUInt32LE(0), dibWidth = payload.readInt32LE(4), dibHeight = payload.readInt32LE(8), planes = payload.readUInt16LE(12), bitDepth = payload.readUInt16LE(14), compression = payload.readUInt32LE(16), colorsUsed = payload.readUInt32LE(32);
+  if (headerSize < 40 || headerSize > payload.length || dibWidth !== width || Math.abs(dibHeight) !== height * 2 || planes !== 1 || directoryBitDepth !== bitDepth || ![1, 4, 8, 24, 32].includes(bitDepth) || compression !== 0)
+    return !1;
+  let paletteBytes = (bitDepth <= 8 ? colorsUsed || 1 << bitDepth : 0) * 4, xorBytes = Math.ceil(width * bitDepth / 32) * 4 * height, maskBytes = Math.ceil(width / 32) * 4 * height;
+  return headerSize + paletteBytes + xorBytes + maskBytes <= payload.length;
+}
+function hasImageSignature(options) {
+  let { contents, format } = options;
+  if (format === "png")
+    return contents.length >= 8 && contents.readUInt32BE(0) === 2303741511;
+  if (format === "jpeg")
+    return contents.length >= 2 && contents[0] === 255 && contents[1] === 216;
+  if (format === "gif") {
+    let header = contents.subarray(0, 6).toString("ascii");
+    return header === "GIF87a" || header === "GIF89a";
+  }
+  if (format === "webp")
+    return contents.subarray(0, 4).toString("ascii") === "RIFF" && contents.subarray(8, 12).toString("ascii") === "WEBP";
+  if (format === "avif")
+    return contents.subarray(4, 12).toString("ascii").includes("ftyp");
+  if (contents.length < 22 || contents[0] !== 0 || contents[1] !== 0 || contents[2] !== 1 || contents[3] !== 0)
+    return !1;
+  let count = contents.readUInt16LE(4), tableEnd = 6 + count * 16;
+  if (count === 0 || tableEnd > contents.length) return !1;
+  let images = [], totalPixels = 0;
+  for (let index = 0; index < count; index += 1) {
+    let entry = 6 + index * 16, width = contents[entry] || 256, height = contents[entry + 1] || 256, planes = contents.readUInt16LE(entry + 4), bitDepth = contents.readUInt16LE(entry + 6), bytes = contents.readUInt32LE(entry + 8), offset = contents.readUInt32LE(entry + 12);
+    if (bytes === 0 || ![0, 1].includes(planes) || ![1, 4, 8, 24, 32].includes(bitDepth) || offset < tableEnd || offset + bytes > contents.length || (totalPixels += width * height, totalPixels > 4e7)) return !1;
+    images.push({ offset, bytes, width, height, bitDepth });
+  }
+  images.sort((left, right) => left.offset - right.offset);
+  let previousEnd = tableEnd;
+  for (let { offset, bytes, width, height, bitDepth } of images) {
+    if (offset < previousEnd) return !1;
+    previousEnd = offset + bytes;
+    let payload = contents.subarray(offset, offset + bytes);
+    if (payload.subarray(0, 8).equals(PNG_SIGNATURE)) {
+      if (!isValidIcoPng({ payload, width, height, directoryBitDepth: bitDepth }))
+        return !1;
+      continue;
+    }
+    if (!isValidIcoDib({
+      payload,
+      width,
+      height,
+      directoryBitDepth: bitDepth
+    }))
+      return !1;
+  }
+  return !0;
+}
+async function readRasterMetadata(options) {
+  let metadata;
+  try {
+    metadata = await sharp(options.contents, { animated: !0 }).metadata();
+  } catch (error) {
+    throw new AppError({
+      code: `${options.errorPrefix}_DIMENSIONS_UNREADABLE`,
+      message: `${options.path} has image metadata that could not be read`,
+      details: {
+        path: options.path,
+        cause: error instanceof Error ? error.message : String(error)
+      }
+    });
+  }
+  let rawWidth = metadata.width, rawHeight = metadata.pageHeight ?? metadata.height;
+  if (!rawWidth || !rawHeight)
+    throw new AppError({
+      code: `${options.errorPrefix}_DIMENSIONS_UNREADABLE`,
+      message: `${options.path} is missing readable raster image dimensions`,
+      details: { path: options.path }
+    });
+  let orientation = metadata.orientation ?? 1, rotated = orientation >= 5 && orientation <= 8, width = rotated ? rawHeight : rawWidth, height = rotated ? rawWidth : rawHeight, { maxRasterMegapixels, maxRasterSidePixels } = options.policy;
+  if (width > maxRasterSidePixels || height > maxRasterSidePixels || width * height > maxRasterMegapixels * 1e6)
+    throw new AppError({
+      code: `${options.errorPrefix}_DIMENSIONS_TOO_LARGE`,
+      message: `${options.path} is ${width}x${height}. Raster images must be no larger than ${maxRasterSidePixels}px on either side and ${maxRasterMegapixels} megapixels.`,
+      details: {
+        path: options.path,
+        width,
+        height,
+        maxSidePixels: maxRasterSidePixels,
+        maxMegapixels: maxRasterMegapixels
+      }
+    });
+  return {
+    width,
+    height,
+    animated: (metadata.pages ?? 1) > 1
+  };
+}
+function validateSvg(options) {
+  if (options.contents.byteLength > options.policy.maxSvgBytes)
+    throw new AppError({
+      code: `${options.errorPrefix}_SVG_TOO_LARGE`,
+      message: `${options.path} is larger than the ${Math.round(options.policy.maxSvgBytes / 1024)} KB SVG limit`,
+      details: { path: options.path, bytes: options.contents.byteLength }
+    });
+  let source = options.contents.toString("utf-8");
+  if (!source.toLowerCase().includes("<svg"))
+    throw new AppError({
+      code: `${options.errorPrefix}_SVG_INVALID`,
+      message: `${options.path} is not a valid SVG document`,
+      details: { path: options.path }
+    });
+  let unsafe = () => {
+    throw new AppError({
+      code: `${options.errorPrefix}_SVG_UNSAFE`,
+      message: `${options.path} contains unsafe SVG content`,
+      details: { path: options.path }
+    });
+  }, forbiddenElements = /* @__PURE__ */ new Set([
+    "script",
+    "foreignobject",
+    "iframe",
+    "object",
+    "embed",
+    "audio",
+    "video",
+    "animate",
+    "animatemotion",
+    "animatetransform",
+    "set"
+  ]), decodeCssEscapes = (value) => value.replace(/\\([\da-f]{1,6})\s?|\\(.)/giu, (_match, hex, char) => {
+    if (!hex) return char ?? "";
+    let codePoint = Number.parseInt(hex, 16);
+    return codePoint === 0 || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343 ? "\uFFFD" : String.fromCodePoint(codePoint);
+  }), hasExternalCssUrl = (value) => {
+    let decoded = decodeCssEscapes(value), external = !1;
+    return valueParser(decoded).walk((node) => {
+      if (node.type !== "function") return;
+      let functionName = node.value.toLowerCase();
+      if (["image-set", "-webkit-image-set", "image"].includes(functionName) && node.nodes.some(
+        (child) => child.type === "string" && child.value.trim() !== "" && !child.value.trim().startsWith("#")
+      ) && (external = !0), functionName !== "url") return;
+      let target = valueParser.stringify(node.nodes).trim().replace(/^(["'])(.*)\1$/su, "$2");
+      target && !target.startsWith("#") && (external = !0);
+    }), external;
+  }, hasExternalCssImport = (value) => {
+    let decoded = decodeCssEscapes(value).replace(/\/\*[\s\S]*?\*\//gu, " ");
+    return /@import(?=\s|["'(])\s*(?:url\(\s*)?(?:"([^"#][^"]*)"|'([^'#][^']*)'|([^\s;)'"#][^\s;)]*))/iu.test(
+      decoded
+    );
+  }, isExternalReference = (value) => {
+    let target = value.trim();
+    return target.length > 0 && !target.startsWith("#");
+  }, rootSeen = !1, styleContents = [], parseFailure, parser2 = new SaxesParser({ xmlns: !0 });
+  parser2.on("doctype", () => unsafe()), parser2.on("processinginstruction", () => unsafe()), parser2.on("error", (error) => {
+    parseFailure ??= error;
+  }), parser2.on("opentag", (tag) => {
+    let localName = tag.local.toLowerCase();
+    styleContents.length > 0 && unsafe(), rootSeen || (rootSeen = !0, localName !== "svg" && unsafe()), forbiddenElements.has(localName) && unsafe(), localName === "style" && styleContents.push("");
+    for (let attribute of Object.values(tag.attributes)) {
+      let name = attribute.local.toLowerCase(), value = attribute.value;
+      name === "base" && attribute.uri === "http://www.w3.org/XML/1998/namespace" && value.trim() !== "" && unsafe(), name.startsWith("on") && unsafe(), (name === "href" || name === "src") && isExternalReference(value) && unsafe(), hasExternalCssUrl(value) && unsafe();
+    }
+  }), parser2.on("closetag", (tag) => {
+    if (tag.local.toLowerCase() === "style") {
+      let contents = styleContents.pop();
+      contents && (hasExternalCssUrl(contents) || hasExternalCssImport(contents)) && unsafe();
+    }
+  });
+  let appendStyleText = (value) => {
+    let last = styleContents.length - 1;
+    last >= 0 && (styleContents[last] = `${styleContents[last]}${value}`);
+  };
+  return parser2.on("text", appendStyleText), parser2.on("cdata", appendStyleText), parser2.write(source).close(), (parseFailure || !rootSeen) && unsafe(), options.contents;
+}
+
+// src/lib/compiler/source/assets/media-assets.ts
+var DEFAULT_MAX_TOTAL_BYTES = 100 * 1024 * 1024, DEFAULT_MAX_FILE_COUNT = 500, MEDIA_IMAGE_ADMISSION_POLICY = {
+  maxRasterMegapixels: 40,
+  maxRasterSidePixels: 8192,
+  maxSvgBytes: MAX_MEDIA_SVG_BYTES
+}, MEDIA_PUBLIC_PREFIX = SOURCE_ASSET_PREFIX;
+function mediaAssetBudgets() {
+  return {
+    maxTotalBytes: DEFAULT_MAX_TOTAL_BYTES,
+    maxFileCount: DEFAULT_MAX_FILE_COUNT
+  };
+}
+function toPosixPath(path) {
+  return path.split(sep2).join("/");
+}
+function hasUnsafeControlCharacters(value) {
+  for (let character of value) {
+    let code = character.codePointAt(0) ?? 0;
+    if (code <= 31 || code >= 127 && code <= 159) return !0;
+  }
+  return !1;
+}
+function encodeAssetPath(relativePath) {
+  let segments = relativePath.split("/");
+  if (segments.some(
+    (segment) => segment === "" || segment === "." || segment === ".." || segment.startsWith(".") || segment.includes("\\") || hasUnsafeControlCharacters(segment)
+  ))
+    throw new AppError({
+      code: "FRAMEWORK_MEDIA_PATH_REJECTED",
+      message: `Media asset path "${relativePath}" is not allowed`,
+      details: { path: relativePath }
+    });
+  let encoded;
+  try {
+    encoded = segments.map((segment) => encodeURIComponent(segment)).join("/");
+  } catch {
+    throw new AppError({
+      code: "FRAMEWORK_MEDIA_PATH_REJECTED",
+      message: `Media asset path "${relativePath}" does not produce a safe URL path`,
+      details: { path: relativePath }
+    });
+  }
+  if (encoded.length > 512 || segments.some((segment) => segment.length > 100))
+    throw new AppError({
+      code: "FRAMEWORK_MEDIA_PATH_REJECTED",
+      message: `Media asset path "${relativePath}" exceeds the supported URL length`,
+      details: { path: relativePath }
+    });
+  return encoded;
+}
+async function walkAssetFiles(dir, state, root = dir) {
+  let entries = await readdir(dir, { withFileTypes: !0 }).catch((error) => {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  });
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (let entry of entries) {
+    let absolutePath = join(dir, entry.name), relativePath = toPosixPath(relative2(root, absolutePath));
+    if (isExcludedSourcePath(`assets/${relativePath}`)) continue;
+    if (entry.name.startsWith(".")) {
+      state.warnings.push(ignoredMediaPathWarning(`assets/${relativePath}`));
+      continue;
+    }
+    let info = await lstat2(absolutePath);
+    if (info.isSymbolicLink())
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_SYMLINK_REJECTED",
+        message: `Media asset "${relativePath}" is a symlink. Symlinks are not supported in publish.os/assets.`,
+        details: { path: absolutePath }
+      });
+    if (info.isDirectory()) {
+      await walkAssetFiles(absolutePath, state, root);
+      continue;
+    }
+    if (info.isFile()) {
+      let ignoredDocument = ignoredMediaDocumentWarning(
+        `assets/${relativePath}`
+      );
+      if (ignoredDocument) {
+        encodeAssetPath(relativePath), state.warnings.push(ignoredDocument);
+        continue;
+      }
+      if (state.files.push(relativePath), state.files.length > state.maxFileCount)
+        throw new AppError({
+          code: "FRAMEWORK_MEDIA_FILE_COUNT_EXCEEDED",
+          message: `publish.os/assets contains more than ${state.maxFileCount} files, exceeding the limit of ${state.maxFileCount}`,
+          details: { count: state.files.length, limit: state.maxFileCount }
+        });
+    }
+  }
+}
+function hash(contents) {
+  return `sha256-${createHash("sha256").update(contents).digest("hex").slice(0, 16)}`;
+}
+async function classifyAsset(relativePath, contents) {
+  let ext = relativePath.split(".").at(-1)?.toLowerCase() ?? "";
+  if (ext === "png" && hasImageSignature({ contents, format: "png" })) {
+    let metadata = await readRasterMetadata({
+      contents,
+      errorPrefix: "FRAMEWORK_MEDIA",
+      path: relativePath,
+      policy: MEDIA_IMAGE_ADMISSION_POLICY
+    });
+    return {
+      contents,
+      mediaType: "image",
+      mimeType: "image/png",
+      outputContents: contents,
+      ...metadata
+    };
+  }
+  if (ext === "ico" && hasImageSignature({ contents, format: "ico" }))
+    return {
+      contents,
+      mediaType: "image",
+      mimeType: "image/x-icon",
+      outputContents: contents
+    };
+  if (ext === "ico")
+    throw new AppError({
+      code: "FRAMEWORK_MEDIA_ICO_INVALID",
+      message: `${relativePath} is not a valid ICO image`,
+      details: { path: relativePath }
+    });
+  if ((ext === "jpg" || ext === "jpeg") && hasImageSignature({ contents, format: "jpeg" })) {
+    let metadata = await readRasterMetadata({
+      contents,
+      errorPrefix: "FRAMEWORK_MEDIA",
+      path: relativePath,
+      policy: MEDIA_IMAGE_ADMISSION_POLICY
+    });
+    return {
+      contents,
+      mediaType: "image",
+      mimeType: "image/jpeg",
+      outputContents: contents,
+      ...metadata
+    };
+  }
+  if (ext === "gif" && hasImageSignature({ contents, format: "gif" })) {
+    let metadata = await readRasterMetadata({
+      contents,
+      errorPrefix: "FRAMEWORK_MEDIA",
+      path: relativePath,
+      policy: MEDIA_IMAGE_ADMISSION_POLICY
+    });
+    return {
+      contents,
+      mediaType: "image",
+      mimeType: "image/gif",
+      outputContents: contents,
+      ...metadata
+    };
+  }
+  if (ext === "webp" && hasImageSignature({ contents, format: "webp" })) {
+    let metadata = await readRasterMetadata({
+      contents,
+      errorPrefix: "FRAMEWORK_MEDIA",
+      path: relativePath,
+      policy: MEDIA_IMAGE_ADMISSION_POLICY
+    });
+    return {
+      contents,
+      mediaType: "image",
+      mimeType: "image/webp",
+      outputContents: contents,
+      ...metadata
+    };
+  }
+  if (ext === "avif" && hasImageSignature({ contents, format: "avif" })) {
+    let metadata = await readRasterMetadata({
+      contents,
+      errorPrefix: "FRAMEWORK_MEDIA",
+      path: relativePath,
+      policy: MEDIA_IMAGE_ADMISSION_POLICY
+    });
+    return {
+      contents,
+      mediaType: "image",
+      mimeType: "image/avif",
+      outputContents: contents,
+      ...metadata
+    };
+  }
+  if (ext === "svg") {
+    let outputContents = validateSvg({
+      contents,
+      errorPrefix: "FRAMEWORK_MEDIA",
+      path: relativePath,
+      policy: MEDIA_IMAGE_ADMISSION_POLICY
+    });
+    return {
+      contents,
+      mediaType: "image",
+      mimeType: "image/svg+xml",
+      outputContents
+    };
+  }
+  if (ext === "mp4" && contents.subarray(4, 8).toString("ascii") === "ftyp")
+    return {
+      contents,
+      mediaType: "video",
+      mimeType: "video/mp4",
+      outputContents: contents
+    };
+  if (ext === "webm" && contents[0] === 26 && contents[1] === 69 && contents[2] === 223 && contents[3] === 163)
+    return {
+      contents,
+      mediaType: "video",
+      mimeType: "video/webm",
+      outputContents: contents
+    };
+  if (ext === "json")
+    return JSON.parse(contents.toString("utf-8")), {
+      contents,
+      mediaType: "file",
+      mimeType: "application/json",
+      outputContents: contents
+    };
+  throw new AppError({
+    code: "FRAMEWORK_MEDIA_TYPE_REJECTED",
+    message: `${relativePath} is not an allowed media type`,
+    details: { path: relativePath }
+  });
+}
+async function admitThemeImageResource(options) {
+  let asset = await classifyAsset(options.relativePath, options.contents);
+  if (asset.mediaType !== "image")
+    throw new AppError({
+      code: "FRAMEWORK_MEDIA_TYPE_REJECTED",
+      message: `${options.relativePath} is not an allowed image type`,
+      details: { path: options.relativePath }
+    });
+  return {
+    contents: asset.outputContents,
+    mimeType: asset.mimeType,
+    width: asset.width,
+    height: asset.height
+  };
+}
+function assertAssetSize(options) {
+  if (options.asset.contents.byteLength > options.limit)
+    throw mediaFileTooLarge({
+      relativePath: options.relativePath,
+      bytes: options.asset.contents.byteLength,
+      limit: options.limit
+    });
+}
+function isOptimizableLocalImage(asset) {
+  return asset.mediaType === "image" && !!(asset.width && asset.height) && !asset.animated && asset.mimeType !== "image/svg+xml" && asset.mimeType !== "image/gif";
+}
+async function buildMediaAssets(options) {
+  let assetsDir = resolve3(options.publishOsDir, "assets"), { maxFileCount, maxTotalBytes } = mediaAssetBudgets(), walkState = { files: [], warnings: [], maxFileCount };
+  await walkAssetFiles(assetsDir, walkState);
+  let files = walkState.files.sort(), warnings = walkState.warnings, manifest = {
+    assets: {},
+    totals: {
+      bytes: 0,
+      count: 0,
+      images: 0,
+      videos: 0,
+      documents: 0,
+      files: 0
+    }
+  }, outputs = [], seenPublicPaths = /* @__PURE__ */ new Map();
+  for (let file of files) {
+    let sourcePath = resolve3(assetsDir, file);
+    if (!isSameOrDescendant(assetsDir, sourcePath))
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_PATH_REJECTED",
+        message: `${file} escapes publish.os/assets`,
+        details: { path: file }
+      });
+    let normalized = encodeAssetPath(file), sourcePublicPath = `/assets/${normalized}`, publicPath = `${MEDIA_PUBLIC_PREFIX}/${normalized}`, existing = seenPublicPaths.get(publicPath);
+    if (existing)
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_PATH_COLLISION",
+        message: `${file} and ${existing} both resolve to ${publicPath}`,
+        details: { path: file, existing, publicPath }
+      });
+    seenPublicPaths.set(publicPath, file);
+    let byteLimit = mediaFileByteLimit(file), contents = await readBoundedMediaFile({
+      path: sourcePath,
+      relativePath: file,
+      limit: byteLimit
+    }), asset = await classifyAsset(file, contents);
+    assertAssetSize({ asset, relativePath: file, limit: byteLimit });
+    let totalBytes = manifest.totals.bytes + asset.outputContents.byteLength;
+    if (totalBytes > maxTotalBytes)
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_TOTAL_TOO_LARGE",
+        message: `publish.os/assets is ${totalBytes} bytes, exceeding the limit of ${maxTotalBytes}`,
+        details: { bytes: totalBytes, limit: maxTotalBytes }
+      });
+    let contentHash = hash(asset.outputContents), outputPath = publicPath, optimized = isOptimizableLocalImage(asset), aspect = asset.width && asset.height ? asset.width / asset.height : void 0;
+    manifest.assets[sourcePublicPath] = {
+      sourcePath: `publish.os/assets/${file}`,
+      outputPath,
+      contentHash,
+      mediaType: asset.mediaType,
+      mimeType: asset.mimeType,
+      byteSize: asset.outputContents.byteLength,
+      intrinsicWidth: asset.width,
+      intrinsicHeight: asset.height,
+      width: asset.width,
+      height: asset.height,
+      aspect,
+      animated: asset.animated,
+      optimized,
+      optimizationReason: optimized ? void 0 : asset.mediaType === "image" ? asset.mimeType === "image/svg+xml" ? "svg" : asset.animated ? "animated" : asset.mimeType === "image/gif" ? "gif" : "dimensions-unavailable" : void 0
+    }, manifest.totals.bytes += asset.outputContents.byteLength, manifest.totals.count += 1, asset.mediaType === "image" ? manifest.totals.images += 1 : asset.mediaType === "video" ? manifest.totals.videos += 1 : asset.mediaType === "document" ? manifest.totals.documents += 1 : manifest.totals.files += 1, outputs.push({ contents: asset.outputContents, outputPath: publicPath });
+  }
+  return { manifest, outputs, warnings };
+}
+async function writeMediaOutputs(options) {
+  await rm(resolve3(options.outputDir, "public", "_publishos", "assets"), {
+    force: !0,
+    recursive: !0
+  }), await rm(resolve3(options.outputDir, "public", "_publishos", "media"), {
+    force: !0,
+    recursive: !0
+  }), await rm(resolve3(options.outputDir, "public", "assets"), {
+    force: !0,
+    recursive: !0
+  });
+  for (let output of options.media.outputs) {
+    let segments = output.outputPath.replace(/^\/+/, "").split("/").map(decodeURIComponent);
+    if (segments.some(
+      (segment) => !segment || segment === "." || segment === ".." || segment.includes("/") || segment.includes("\\") || hasUnsafeControlCharacters(segment)
+    ))
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_PATH_REJECTED",
+        message: `Media output path "${output.outputPath}" is not safe`,
+        details: { path: output.outputPath }
+      });
+    let relativeOutput = segments.join(sep2), dest = resolve3(options.outputDir, "public", relativeOutput);
+    await mkdir(dirname2(dest), { recursive: !0 }), await writeFile(dest, output.contents);
+  }
+}
+function mediaManifestModule(manifest) {
+  return `export const mediaManifest = ${JSON.stringify(manifest, null, 2)} as const;
+
+export type MediaManifest = typeof mediaManifest;
+export type MediaAssetManifestEntry = MediaManifest["assets"][keyof MediaManifest["assets"]];
+`;
+}
+
+// src/lib/compiler/source/routing/slug-path.ts
+var SLUG_SEGMENT_RE = /^[\p{L}\p{N}][\p{L}\p{M}\p{N}]*(?:[.-][\p{L}\p{N}][\p{L}\p{M}\p{N}]*)*$/u;
+function issue(code, message, details) {
+  return details ? { code, message, details } : { code, message };
+}
+function isWhitespace(code) {
+  return code === 32 || code === 9 || code === 10 || code === 11 || code === 12 || code === 13 || code === 160;
+}
+function isUnsafeInvisible(code) {
+  return code <= 31 || code >= 127 && code <= 159 || code >= 8203 && code <= 8207 || code >= 8232 && code <= 8239 || code >= 8288 && code <= 8303 || code === 65279;
+}
+function hasPercentEscape(value) {
+  return /%[0-9a-fA-F]{2}/.test(value);
+}
+function appendNormalizedChar(output, char, pendingSeparator) {
+  pendingSeparator && output.length > 0 && output.push(pendingSeparator), output.push(char);
+}
+function queueSeparator(current, next) {
+  return current === "." || next === "." ? "." : "-";
+}
+function normalizeSegmentValue(input) {
+  let output = [], pendingSeparator, sanitized = !1;
+  for (let char of input.normalize("NFC").toLowerCase().normalize("NFC")) {
+    let code = char.codePointAt(0) ?? 0;
+    if (/^[\p{L}\p{M}\p{N}]$/u.test(char)) {
+      pendingSeparator = appendNormalizedChar(output, char, pendingSeparator);
+      continue;
+    }
+    if (char === "." || char === "-") {
+      pendingSeparator = queueSeparator(pendingSeparator, char);
+      continue;
+    }
+    if (isWhitespace(code) || char === "_" || isUnsafeInvisible(code)) {
+      pendingSeparator = queueSeparator(pendingSeparator, "-"), sanitized = !0;
+      continue;
+    }
+    pendingSeparator = queueSeparator(pendingSeparator, "-"), sanitized = !0;
+  }
+  return { value: output.join(""), sanitized };
+}
+function validateSegment(slug, options) {
+  return slug ? slug.length > options.maxSegmentLength ? {
+    code: "SLUG_SEGMENT_TOO_LONG",
+    error: `URL path must be ${options.maxSegmentLength} characters or less`,
+    isValid: !1
+  } : slug !== slug.toLowerCase() ? {
+    code: "SLUG_UPPERCASE_INVALID",
+    error: "URL path must be lowercase",
+    isValid: !1
+  } : SLUG_SEGMENT_RE.test(slug) ? { isValid: !0 } : {
+    code: "SLUG_PATTERN_INVALID",
+    error: 'URL path can only include lowercase letters, marks, numbers, and single "." or "-" separators',
+    isValid: !1
+  } : {
+    code: "SLUG_EMPTY",
+    error: "URL path is required",
+    isValid: !1
+  };
+}
+function normalizeSlugSegmentInternal(input, options = {}) {
+  let maxSegmentLength = options.maxSegmentLength ?? 100, warnings = [], errors = [], trimmed = input.normalize("NFC").trim(), rawLower = trimmed.toLowerCase();
+  hasPercentEscape(trimmed) && errors.push(
+    issue(
+      "PATH_PERCENT_ESCAPE_INVALID",
+      "Path input must not contain percent escapes",
+      {
+        value: input
+      }
+    )
+  ), (rawLower === "." || rawLower === "..") && errors.push(
+    issue(
+      "PATH_DOT_SEGMENT_INVALID",
+      "Path segments must not be dot traversal segments",
+      {
+        segment: input
+      }
+    )
+  );
+  let normalized = normalizeSegmentValue(trimmed), value = normalized.value;
+  value.length > maxSegmentLength && errors.push(
+    issue(
+      "SLUG_SEGMENT_TOO_LONG",
+      `Path segments must be ${maxSegmentLength} characters or less`,
+      {
+        max: maxSegmentLength,
+        segment: input
+      }
+    )
+  ), (normalized.sanitized || value !== trimmed) && warnings.push(
+    issue("PATH_SEGMENT_NORMALIZED", "Path segment was normalized", {
+      from: input,
+      to: value
+    })
+  ), !value && options.allowEmpty !== !0 && errors.push(
+    issue("PATH_SEGMENT_EMPTY", "Path segment normalized to an empty value", {
+      segment: input
+    })
+  );
+  let validation = value ? validateSegment(value, {
+    maxSegmentLength
+  }) : { isValid: !0 };
+  return validation.isValid || errors.push(issue(validation.code, validation.error, { segment: input })), {
+    changed: value !== input,
+    errors,
+    value,
+    warnings
+  };
+}
+function normalizePathParts(input, options = {}) {
+  let warnings = [], errors = [], maxPathLength = options.maxPathLength ?? 512, trimmed = input.normalize("NFC").trim();
+  (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(trimmed) || /^\/\/[^/]/.test(trimmed)) && errors.push(
+    issue(
+      "PATH_PROTOCOL_INVALID",
+      "Path input must not be a URL or protocol reference",
+      {
+        value: input
+      }
+    )
+  ), /[?#]/.test(trimmed) && errors.push(
+    issue(
+      "PATH_QUERY_HASH_INVALID",
+      "Path input must not include a query string or hash",
+      {
+        value: input
+      }
+    )
+  ), trimmed.includes("\\") && warnings.push(
+    issue(
+      "PATH_BACKSLASH_NORMALIZED",
+      "Backslashes were normalized to slashes",
+      {
+        value: input
+      }
+    )
+  );
+  let rawSegments = trimmed.replace(/\\/g, "/").split("/"), segments = [];
+  for (let rawSegment of rawSegments) {
+    if (!rawSegment) continue;
+    let segment = normalizeSlugSegmentInternal(rawSegment, options);
+    warnings.push(...segment.warnings), errors.push(...segment.errors), segment.value && segments.push(segment.value);
+  }
+  segments.length === 0 && options.allowEmpty !== !0 && errors.push(
+    issue("PATH_EMPTY", "Path input normalized to an empty value", {
+      value: input
+    })
+  );
+  let value = segments.join("/");
+  return value.length > maxPathLength && errors.push(
+    issue(
+      "SLUG_PATH_TOO_LONG",
+      `Path must be ${maxPathLength} characters or less`,
+      {
+        max: maxPathLength,
+        value: input
+      }
+    )
+  ), encodeURI(value).length > 2044 && errors.push(
+    issue(
+      "PATH_ENCODED_TOO_LONG",
+      "Encoded path must leave room for the Markdown route within 2048 characters.",
+      { value: input }
+    )
+  ), { errors, value, warnings };
+}
+function normalizeSlugPath(input, options = {}) {
+  let normalized = normalizePathParts(input, options);
+  return {
+    ...normalized,
+    changed: normalized.value !== input
+  };
+}
+function normalizeUrlPath(input, options = {}) {
+  let normalized = normalizePathParts(input, options), value = normalized.value ? `/${normalized.value}` : "/";
+  return {
+    ...normalized,
+    value,
+    changed: value !== input
+  };
+}
+function joinUrlPath(parentPath, childPath) {
+  if (childPath.startsWith("/"))
+    return normalizeUrlPath(childPath).value;
+  let parent = parentPath === "/" ? "" : parentPath.replace(/\/+$/, "");
+  return normalizeUrlPath(`${parent}/${childPath}`).value;
+}
+
+// src/lib/runtime/metadata/authored-date.ts
+function authoredDate(value) {
+  if (typeof value != "string" || !/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2}))?$/.test(
+    value
+  ))
+    return;
+  let day = value.slice(0, 10), midnight = /* @__PURE__ */ new Date(`${day}T00:00:00.000Z`);
+  if (!(!Number.isFinite(midnight.getTime()) || midnight.toISOString().slice(0, 10) !== day))
+    return Number.isFinite(Date.parse(value)) ? value : void 0;
+}
+
+// src/lib/assets/map-source-asset-url.ts
+var SOURCE_ASSET_PATH = "/assets/";
+function hasUnsafeControlCharacters2(value) {
+  for (let character of value) {
+    let code = character.codePointAt(0) ?? 0;
+    if (code <= 31 || code >= 127 && code <= 159) return !0;
+  }
+  return !1;
+}
+function assertSafeAssetPath(path) {
+  if (path.includes("\\") || hasUnsafeControlCharacters2(path))
+    throw new TypeError("Local asset URLs must use safe path segments.");
+  for (let segment of path.split("/")) {
+    if (!segment)
+      throw new TypeError("Local asset URLs must use safe path segments.");
+    let decoded;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      throw new TypeError("Local asset URLs must use valid URL encoding.");
+    }
+    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasUnsafeControlCharacters2(decoded))
+      throw new TypeError("Local asset URLs must use safe path segments.");
+  }
+}
+function mapSourceAssetUrl(value) {
+  if (typeof value != "string" || !value.startsWith(SOURCE_ASSET_PATH))
+    return value;
+  let suffixIndex = value.search(/[?#]/u), pathname = suffixIndex < 0 ? value : value.slice(0, suffixIndex), suffix = suffixIndex < 0 ? "" : value.slice(suffixIndex), path = pathname.slice(SOURCE_ASSET_PATH.length);
+  return assertSafeAssetPath(path), `${SOURCE_ASSET_PREFIX}/${path}${suffix}`;
+}
+
+// src/lib/compiler/markdown/convert-mdx-to-markdown.ts
+import remarkGfm from "remark-gfm";
+import remarkMdx2 from "remark-mdx";
+import remarkParse2 from "remark-parse";
+import remarkStringify from "remark-stringify";
+import { unified as unified2 } from "unified";
+
+// src/lib/compiler/markdown/utils.ts
+function text(value) {
+  return { type: "text", value };
+}
+function paragraph(children) {
+  if (children.length !== 0)
+    return { type: "paragraph", children };
+}
+function paragraphBlock(children) {
+  let node = paragraph(children);
+  return node ? [node] : [];
+}
+function strongLabel(value) {
+  return { type: "strong", children: [text(value)] };
+}
+function inlineCode(value) {
+  return { type: "inlineCode", value };
+}
+function normalizeComponentName(name) {
+  return (name ?? "").trim().toLowerCase();
+}
+function addDiagnostic(context, diagnostic) {
+  context.collectDiagnostics && context.diagnostics.push(diagnostic);
+}
+function getAttribute(node, name, context) {
+  let attribute = node.attributes?.find(
+    (candidate) => candidate.name === name
+  );
+  if (attribute) {
+    if (attribute.value === null || attribute.value === void 0) return "true";
+    if (typeof attribute.value == "string") return attribute.value;
+    if (attribute.value.type === "mdxJsxAttributeValueExpression")
+      return decodeExpressionValue(attribute.value.value, name, context);
+    addDiagnostic(context, {
+      code: "mdx-invalid-attribute",
+      componentName: node.name ?? void 0,
+      message: `Unsupported MDX attribute value for "${name}".`
+    });
+  }
+}
+function firstAttribute(node, names, context) {
+  for (let name of names) {
+    let value = getAttribute(node, name, context);
+    if (value?.trim()) return value.trim();
+  }
+}
+function decodeExpressionValue(value, attributeName, context) {
+  let trimmed = value.trim();
+  if (trimmed) {
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'"))
+      try {
+        return JSON.parse(
+          trimmed.startsWith("'") ? `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"` : trimmed
+        );
+      } catch {
+        return trimmed.slice(1, -1);
+      }
+    return trimmed.startsWith("`") && trimmed.endsWith("`") ? trimmed.slice(1, -1).replace(/\\`/g, "`").replace(/\\n/g, `
+`).replace(/\\t/g, "	") : (addDiagnostic(context, {
+      code: "mdx-invalid-attribute",
+      message: `MDX expression attribute "${attributeName}" was converted to literal text.`
+    }), trimmed);
+  }
+}
+function extractText(nodes) {
+  return nodes.map((node) => {
+    if (node.type === "break") return `
+`;
+    if (node.type === "html" || node.type === "yaml") return "";
+    if ("value" in node && typeof node.value == "string")
+      return node.type === "code" ? `${node.value}
+` : node.value;
+    if ("alt" in node && typeof node.alt == "string") return node.alt;
+    if ("children" in node && Array.isArray(node.children)) {
+      let value = extractText(node.children);
+      return [
+        "emphasis",
+        "strong",
+        "delete",
+        "link",
+        "linkReference"
+      ].includes(node.type) ? value : `${value}
+`;
+    }
+    return "";
+  }).join("").trim();
+}
+function asPhrasing(nodes) {
+  return nodes.flatMap((node) => {
+    if (node.type === "paragraph") return node.children;
+    if (node.type === "text" || node.type === "emphasis" || node.type === "strong" || node.type === "delete" || node.type === "inlineCode" || node.type === "break" || node.type === "link" || node.type === "image" || node.type === "html" || node.type === "footnoteReference")
+      return [node];
+    let label = extractText([node]);
+    return label ? [text(label)] : [];
+  });
+}
+function isBlockNode(node) {
+  return node.type === "paragraph" || node.type === "heading" || node.type === "thematicBreak" || node.type === "blockquote" || node.type === "list" || node.type === "code" || node.type === "html" || node.type === "yaml" || node.type === "definition" || node.type === "footnoteDefinition" || node.type === "table";
+}
+function asBlocks(nodes) {
+  let blocks = [], pendingPhrasing = [];
+  for (let node of nodes)
+    if (isBlockNode(node)) {
+      let pendingParagraph2 = paragraph(pendingPhrasing);
+      pendingParagraph2 && blocks.push(pendingParagraph2), pendingPhrasing = [], blocks.push(node);
+    } else
+      pendingPhrasing.push(node);
+  let pendingParagraph = paragraph(pendingPhrasing);
+  return pendingParagraph && blocks.push(pendingParagraph), blocks;
+}
+function handlerDiagnostic(node, context) {
+  addDiagnostic(context, {
+    code: "mdx-component-converted",
+    componentName: node.name ?? void 0,
+    message: `Converted MDX component "${node.name ?? "unknown"}" to Markdown.`
+  });
+}
+
+// src/lib/compiler/markdown/handlers/callout.ts
+function calloutHandler(node, context, kind) {
+  handlerDiagnostic(node, context);
+  let title = firstAttribute(node, ["title", "label", "type"], context);
+  if (kind === "inline") {
+    let children2 = context.transformChildrenAsPhrasing(node, context);
+    return [
+      ...title ? [strongLabel(`${title}:`), text(" ")] : [],
+      ...children2
+    ];
+  }
+  let children = [];
+  return title && children.push({ type: "paragraph", children: [strongLabel(title)] }), children.push(
+    ...context.transformChildrenAsBlocks(node, context)
+  ), children.length > 0 ? [{ type: "blockquote", children }] : [];
+}
+
+// src/lib/compiler/markdown/handlers/code-block.ts
+function codeBlockHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let code = firstAttribute(node, ["code", "value"], context), language = firstAttribute(node, ["language", "lang"], context), title = firstAttribute(node, ["title"], context);
+  return code !== void 0 ? [{
+    type: "code",
+    lang: language,
+    meta: title === void 0 ? void 0 : `title="${title.replaceAll('"', "&quot;")}"`,
+    value: code
+  }] : context.transformChildrenAsBlocks(node, context);
+}
+function tabHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let label = firstAttribute(
+    node,
+    ["title", "label", "value", "name"],
+    context
+  ), children = context.transformChildrenAsBlocks(node, context);
+  return label ? [
+    { type: "paragraph", children: [strongLabel(`Tab: ${label}`)] },
+    ...children
+  ] : children;
+}
+
+// src/lib/compiler/markdown/handlers/html.ts
+function inlineHtmlHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let children = context.transformChildrenAsPhrasing(node, context);
+  switch (normalizeComponentName(node.name)) {
+    case "strong":
+    case "b":
+      return [{ type: "strong", children }];
+    case "em":
+    case "i":
+      return [{ type: "emphasis", children }];
+    case "code":
+      return [{ type: "inlineCode", value: extractText(children) }];
+    case "br":
+      return [{ type: "break" }];
+    default:
+      return children;
+  }
+}
+function blockquoteHtmlHandler(node, context) {
+  return handlerDiagnostic(node, context), [
+    {
+      type: "blockquote",
+      children: node.type === "mdxJsxTextElement" ? paragraphBlock(context.transformChildrenAsPhrasing(node, context)) : context.transformChildrenAsBlocks(node, context)
+    }
+  ];
+}
+function paragraphHtmlHandler(node, context) {
+  return handlerDiagnostic(node, context), paragraphBlock(context.transformChildrenAsPhrasing(node, context));
+}
+function preformattedText(node, context) {
+  if (node.type === "mdxTextExpression" || node.type === "mdxFlowExpression") {
+    let statement = node.data?.estree?.body?.[0], expression = statement?.type === "ExpressionStatement" ? statement.expression : void 0;
+    return expression?.type === "Literal" && typeof expression.value == "string" ? expression.value : expression?.type === "TemplateLiteral" && expression.expressions?.length === 0 ? expression.quasis?.[0]?.value.cooked ?? "" : (addDiagnostic(context, {
+      code: "mdx-expression-dropped",
+      message: "Dropped non-literal MDX expression from preformatted Markdown output."
+    }), "");
+  }
+  return typeof node.value == "string" ? node.value : (node.children ?? []).map((child, index) => (index > 0 && child.type === "paragraph" ? `
+
+` : "") + preformattedText(child, context)).join("");
+}
+function preHtmlHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let code = node.children?.find((child) => child.name === "code");
+  return [
+    { type: "code", lang: code ? firstAttribute(code, ["className", "class"], context)?.match(
+      /(?:^|\s)language-([^\s]+)/
+    )?.[1] : void 0, value: preformattedText(node, context) }
+  ];
+}
+
+// src/lib/compiler/markdown/handlers/inline.ts
+function iconHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let label = firstAttribute(
+    node,
+    ["aria-label", "label", "title", "alt"],
+    context
+  );
+  return label ? [text(label)] : [];
+}
+function linkHandler(node, context) {
+  let href = firstAttribute(node, ["href", "to", "url"], context);
+  if (!href) return context.transformChildrenAsPhrasing(node, context);
+  handlerDiagnostic(node, context);
+  let children = context.transformChildrenAsPhrasing(node, context);
+  return [{
+    type: "link",
+    url: context.resolveMediaUrl(href),
+    children: children.length > 0 ? children : [text(href)]
+  }];
+}
+function kbdHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let label = extractText(context.transformChildrenAsPhrasing(node, context)) || firstAttribute(node, ["children", "label"], context);
+  return label ? [inlineCode(label)] : [];
+}
+function inlineComponentHandlers() {
+  return [
+    {
+      componentNames: ["icon"],
+      transform: iconHandler
+    },
+    {
+      componentNames: ["a", "link"],
+      transform: linkHandler
+    },
+    {
+      componentNames: ["kbd"],
+      transform: kbdHandler
+    }
+  ];
+}
+
+// src/lib/compiler/markdown/handlers/media.ts
+function imageHandler(node, context, kind) {
+  let src = firstAttribute(node, ["src", "href"], context);
+  if (!src) return [];
+  handlerDiagnostic(node, context);
+  let caption = firstAttribute(node, ["caption"], context), image = {
+    type: "image",
+    url: context.resolveMediaUrl(src),
+    alt: getAttribute(node, "alt", context) ?? firstAttribute(node, ["title", "aria-label"], context) ?? "",
+    title: firstAttribute(node, ["title"], context)
+  };
+  return kind === "inline" ? [image, ...caption ? [text(` ${caption}`)] : []] : [
+    ...paragraphBlock([image]),
+    ...caption ? paragraphBlock([text(caption)]) : []
+  ];
+}
+function figureCaptionHandler(node, context) {
+  return handlerDiagnostic(node, context), node.type === "mdxJsxTextElement" ? paragraphBlock(context.transformChildrenAsPhrasing(node, context)) : context.transformChildrenAsBlocks(node, context);
+}
+function isCaption(node) {
+  return ["figcaption", "figurecaption", "figure.caption"].includes(
+    normalizeComponentName(node.name)
+  );
+}
+function hasDirectCaption(node) {
+  return (node.children ?? []).some(
+    (child) => isCaption(child) || (child.type === "paragraph" || child.type.startsWith("mdxJsx") && child.name === null) && hasDirectCaption(child)
+  );
+}
+function figureHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let children = context.transformChildrenAsBlocks(node, context);
+  if (hasDirectCaption(node)) return children;
+  let caption = firstAttribute(node, ["caption"], context);
+  return [...children, ...caption ? paragraphBlock([text(caption)]) : []];
+}
+function videoHandler(node, context, kind) {
+  let src = firstAttribute(node, ["src", "url", "href"], context);
+  if (!src) return context.transformChildrenAsBlocks(node, context);
+  handlerDiagnostic(node, context);
+  let label = firstAttribute(node, ["title", "alt", "aria-label"], context) ?? "Video", link = {
+    type: "link",
+    url: context.resolveMediaUrl(src),
+    children: [text(label)]
+  }, children = [text("Video: "), link], caption = firstAttribute(node, ["caption"], context);
+  return kind === "inline" ? [...children, ...caption ? [text(` ${caption}`)] : []] : [
+    ...paragraphBlock(children),
+    ...caption ? paragraphBlock([text(caption)]) : []
+  ];
+}
+
+// src/lib/compiler/markdown/handlers/passthrough.ts
+function passthroughBlockHandler(node, context) {
+  return handlerDiagnostic(node, context), context.transformChildrenAsBlocks(node, context);
+}
+function detailsHandler(node, context) {
+  handlerDiagnostic(node, context);
+  let summary = firstAttribute(node, ["summary", "title", "label"], context) ?? "Details";
+  return [
+    { type: "paragraph", children: [strongLabel(summary)] },
+    ...context.transformChildrenAsBlocks(node, context)
+  ];
+}
+
+// src/lib/compiler/markdown/handlers/registry.ts
+var defaultHandlers = [
+  {
+    componentNames: ["image", "img", "picture"],
+    transform: imageHandler
+  },
+  ...inlineComponentHandlers(),
+  {
+    componentNames: ["callout", "admonition", "note", "warning"],
+    transform: calloutHandler
+  },
+  {
+    componentNames: ["codeblock"],
+    transform: codeBlockHandler
+  },
+  {
+    componentNames: ["strong", "b", "em", "i", "code", "span", "br"],
+    transform: inlineHtmlHandler
+  },
+  {
+    componentNames: ["pre"],
+    transform: preHtmlHandler
+  },
+  {
+    componentNames: ["blockquote"],
+    transform: blockquoteHtmlHandler
+  },
+  {
+    componentNames: ["p"],
+    transform: paragraphHtmlHandler
+  },
+  {
+    componentNames: ["div"],
+    transform: passthroughBlockHandler
+  },
+  {
+    componentNames: [
+      "codetab",
+      "codetabs",
+      "tab",
+      "tabpanel",
+      "tabs",
+      "tabscontent"
+    ],
+    transform: tabHandler
+  },
+  {
+    componentNames: ["figure"],
+    transform: figureHandler
+  },
+  {
+    componentNames: ["figcaption", "figurecaption", "figure.caption"],
+    transform: figureCaptionHandler
+  },
+  {
+    componentNames: ["video", "videoiframe", "iframe"],
+    transform: videoHandler
+  },
+  {
+    componentNames: ["details", "accordion", "summary"],
+    transform: detailsHandler
+  },
+  {
+    componentNames: ["step", "steps"],
+    transform: passthroughBlockHandler
+  }
+], handlersByName = new Map(
+  defaultHandlers.flatMap(
+    (handler) => handler.componentNames.map((name) => [name, handler])
+  )
+);
+
+// src/lib/compiler/markdown/convert-mdx-to-markdown.ts
+var processor = unified2().use(remarkParse2).use(remarkMdx2).use(remarkGfm).use(remarkStringify, {
+  bullet: "-",
+  fences: !0,
+  incrementListMarker: !0,
+  listItemIndent: "one",
+  rule: "-"
+});
+function stripHtmlComments(source) {
+  return source.replace(/<!--[\s\S]*?-->/g, "");
+}
+function stripTopLevelImports(source) {
+  return source.split(`
+`).filter((line) => !/^\s*(?:import|export)\s/.test(line)).join(`
+`).trim();
+}
+function parseSource(source, context) {
+  try {
+    return processor.parse(source);
+  } catch (error) {
+    let withoutComments = stripHtmlComments(source);
+    if (withoutComments !== source)
+      try {
+        return processor.parse(withoutComments);
+      } catch {
+      }
+    addDiagnostic(context, {
+      code: "mdx-parse-failed",
+      message: error instanceof Error ? error.message : "Failed to parse MDX for Markdown output."
+    });
+    return;
+  }
+}
+function transformChildrenAsBlocks(node, context) {
+  return (node.children ?? []).flatMap(
+    (child) => transformBlockNode(child, context)
+  );
+}
+function transformChildrenAsPhrasing(node, context) {
+  return (node.children ?? []).flatMap(
+    (child) => transformInlineNode(child, context)
+  );
+}
+function transformMdxElement(node, context, kind) {
+  if (node.name === null)
+    return kind === "block" ? transformChildrenAsBlocks(node, context) : transformChildrenAsPhrasing(node, context);
+  if (node.name && context.importedIcons.has(node.name)) {
+    let label = firstAttribute(node, ["aria-hidden"], context) === "true" ? "" : firstAttribute(node, ["aria-label", "title"], context), children2 = label ? [{ type: "text", value: label }] : [];
+    return kind === "block" ? paragraphBlock(children2) : children2;
+  }
+  let componentName = normalizeComponentName(node.name), handler = handlersByName.get(componentName);
+  if (handler) {
+    let result = handler.transform(node, context, kind);
+    return kind === "block" ? asBlocks(result) : asPhrasing(result);
+  }
+  if (addDiagnostic(context, {
+    code: "mdx-component-unknown",
+    componentName: node.name ?? void 0,
+    message: `Unknown MDX component "${node.name ?? "unknown"}".`
+  }), context.unknownComponentMode === "error")
+    throw new Error(`Unknown MDX component "${node.name ?? "unknown"}".`);
+  if (context.unknownComponentMode === "html") {
+    let html = htmlFallback(node);
+    return html ? [{ type: "html", value: html }] : [];
+  }
+  let children = kind === "inline" ? transformChildrenAsPhrasing(node, context) : transformChildrenAsBlocks(node, context);
+  return kind === "block" ? asBlocks(children) : asPhrasing(children);
+}
+function htmlFallback(node) {
+  if (!node.name) return;
+  let attrs = (node.attributes ?? []).map((attr) => {
+    if (attr.value === null || attr.value === void 0) return attr.name;
+    if (typeof attr.value == "string")
+      return `${attr.name}="${attr.value.replace(/"/g, "&quot;")}"`;
+  }).filter((value) => !!value).join(" ");
+  return `<${node.name}${attrs ? ` ${attrs}` : ""} />`;
+}
+function transformInlineNode(node, context) {
+  if (node.type === "mdxJsxTextElement")
+    return asPhrasing(transformMdxElement(node, context, "inline"));
+  if (node.type === "mdxTextExpression")
+    return addDiagnostic(context, {
+      code: "mdx-expression-dropped",
+      message: "Dropped inline MDX expression from Markdown output."
+    }), [];
+  switch (node.type) {
+    case "text":
+    case "inlineCode":
+    case "break":
+    case "footnoteReference":
+      return [node];
+    case "emphasis":
+      return [{
+        ...node,
+        children: transformChildrenAsPhrasing(node, context)
+      }];
+    case "strong":
+      return [{
+        ...node,
+        children: transformChildrenAsPhrasing(node, context)
+      }];
+    case "delete":
+      return [{
+        ...node,
+        children: transformChildrenAsPhrasing(node, context)
+      }];
+    case "link":
+      return [{
+        ...node,
+        url: context.resolveMediaUrl(node.url),
+        children: transformChildrenAsPhrasing(node, context)
+      }];
+    case "image":
+      return [
+        {
+          ...node,
+          url: context.resolveMediaUrl(node.url)
+        }
+      ];
+    case "linkReference":
+    case "imageReference":
+      return [node];
+    case "html":
+      return [node];
+    default:
+      return [];
+  }
+}
+function transformListItem(node, context) {
+  return {
+    ...node,
+    children: transformChildrenAsBlocks(node, context)
+  };
+}
+function transformTableCell(node, context) {
+  return {
+    ...node,
+    children: transformChildrenAsPhrasing(node, context)
+  };
+}
+function transformTableRow(node, context) {
+  return {
+    ...node,
+    children: (node.children ?? []).map(
+      (child) => transformTableCell(child, context)
+    )
+  };
+}
+function isFigureBlock(node) {
+  if (node.type !== "mdxJsxTextElement" && node.type !== "mdxJsxFlowElement")
+    return !1;
+  if (node.name === null) return (node.children ?? []).some(isFigureBlock);
+  let name = normalizeComponentName(node.name);
+  return [
+    "figure",
+    "figcaption",
+    "figurecaption",
+    "figure.caption",
+    "pre",
+    "blockquote"
+  ].includes(name) || ["image", "img", "video", "videoiframe", "iframe"].includes(name) && (node.attributes ?? []).some((attribute) => attribute.name === "caption");
+}
+function transformBlockNode(node, context) {
+  if (node.type === "mdxjsEsm")
+    return addDiagnostic(context, {
+      code: "mdx-esm-dropped",
+      message: "Dropped MDX import/export from Markdown output."
+    }), [];
+  if (node.type === "mdxFlowExpression")
+    return addDiagnostic(context, {
+      code: "mdx-expression-dropped",
+      message: "Dropped flow MDX expression from Markdown output."
+    }), [];
+  if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement")
+    return transformMdxElement(node, context, "block");
+  switch (node.type) {
+    case "paragraph": {
+      if ((node.children ?? []).some(isFigureBlock)) {
+        let blocks = [], pending = [], flushPhrasing = () => {
+          let children = transformChildrenAsPhrasing(
+            { type: "paragraph", children: pending },
+            context
+          );
+          children.some(
+            (child) => child.type !== "text" || child.value.trim()
+          ) && blocks.push(...paragraphBlock(children)), pending = [];
+        };
+        for (let child of node.children ?? [])
+          isFigureBlock(child) ? (flushPhrasing(), blocks.push(...transformBlockNode(child, context))) : pending.push(child);
+        return flushPhrasing(), blocks;
+      }
+      let paragraphNode = paragraph(
+        transformChildrenAsPhrasing(node, context)
+      );
+      return paragraphNode ? [paragraphNode] : [];
+    }
+    case "heading":
+      return [{
+        ...node,
+        children: transformChildrenAsPhrasing(node, context)
+      }];
+    case "blockquote":
+      return [
+        {
+          ...node,
+          children: transformChildrenAsBlocks(node, context)
+        }
+      ];
+    case "list":
+      return [{
+        ...node,
+        children: (node.children ?? []).map(
+          (child) => transformListItem(child, context)
+        )
+      }];
+    case "table":
+      return [{
+        ...node,
+        children: (node.children ?? []).map(
+          (child) => transformTableRow(child, context)
+        )
+      }];
+    case "text":
+    case "inlineCode":
+    case "break":
+    case "emphasis":
+    case "strong":
+    case "delete":
+    case "link":
+    case "image":
+    case "footnoteReference":
+      return paragraphBlock(transformInlineNode(node, context));
+    case "code":
+    case "thematicBreak":
+    case "html":
+    case "yaml":
+    case "footnoteDefinition":
+      return [node];
+    case "definition":
+      return [
+        {
+          ...node,
+          url: context.resolveMediaUrl(node.url)
+        }
+      ];
+    default:
+      return [];
+  }
+}
+function convertMdxToMarkdown(options) {
+  let context = {
+    importedIcons: /* @__PURE__ */ new Set(),
+    collectDiagnostics: options.collectDiagnostics ?? !0,
+    diagnostics: [],
+    resolveMediaUrl: (url) => String(mapSourceAssetUrl(url)),
+    transformChildrenAsBlocks,
+    transformChildrenAsPhrasing,
+    unknownComponentMode: options.unknownComponentMode ?? "children"
+  }, parsed = parseSource(options.source, context);
+  if (!parsed)
+    return {
+      diagnostics: context.diagnostics,
+      markdown: stripTopLevelImports(options.source),
+      text: ""
+    };
+  for (let node of parsed.children)
+    if (node.type === "mdxjsEsm") {
+      for (let statement of node.data?.estree?.body ?? [])
+        if (!(statement.type !== "ImportDeclaration" || statement.source.value !== mdxIconPackage))
+          for (let specifier of statement.specifiers)
+            specifier.type === "ImportSpecifier" && context.importedIcons.add(specifier.local.name);
+    }
+  let transformed = {
+    type: "root",
+    children: parsed.children.flatMap(
+      (child) => transformBlockNode(child, context)
+    )
+  }, markdown = String(processor.stringify(transformed)).trim();
+  return {
+    diagnostics: context.diagnostics,
+    markdown,
+    text: extractText(transformed.children)
+  };
+}
+
+export {
+  mapSourceAssetUrl,
+  FrontmatterParseError,
+  parseSourceFrontmatter,
+  groupedMdxExports,
+  replacedMdxSourceFiles,
+  mdxComponentExportName,
+  collectBindingNames,
+  namedValueExports,
+  mdxIconPackage,
+  MdxIconImportError,
+  readMdxIconImports,
+  validateMdxIconImports,
+  convertMdxToMarkdown,
+  ROOT_CONTENT_GROUP_KEY,
+  ROOT_CONTENT_GROUP_TITLE,
+  assertSourceDependency,
+  nextjs_runtime_surface_default,
+  supportedNextjsSourceImports,
+  supportedRuntimeComponentAliases,
+  originalDefaultComponentSourcePath,
+  buildFaviconsAndLogos,
+  faviconsAndLogosManifestModule,
+  mediaAssetBudgets,
+  admitThemeImageResource,
+  buildMediaAssets,
+  writeMediaOutputs,
+  mediaManifestModule,
+  normalizeSlugPath,
+  normalizeUrlPath,
+  joinUrlPath,
+  authoredDate
+};