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

package/dist/chunk-UYGCOWRF.js

@@ -0,0 +1,1709 @@
+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 matter from "gray-matter";
+var DATA_LANGUAGES = /* @__PURE__ */ new Set(["json", "yaml", "yml"]), FRONTMATTER_DELIMITER = "---", UnsupportedFrontmatterLanguageError = class extends Error {
+  constructor(language) {
+    super(`Unsupported frontmatter language "${language}". Use YAML or JSON.`);
+    this.language = language;
+    this.name = "UnsupportedFrontmatterLanguageError";
+  }
+  language;
+};
+function frontmatterLanguage(source) {
+  if (!matter.test(source) || source[FRONTMATTER_DELIMITER.length] === FRONTMATTER_DELIMITER.at(-1))
+    return;
+  let lineEnd = source.indexOf(`
+`, FRONTMATTER_DELIMITER.length), headerEnd = lineEnd === -1 ? source.length : lineEnd;
+  return source.slice(FRONTMATTER_DELIMITER.length, headerEnd).replace(/\r$/, "").trim();
+}
+function parseSourceFrontmatter(source) {
+  let inspected = source.charCodeAt(0) === 65279 ? source.slice(1) : source, marker = frontmatterLanguage(inspected), language = marker?.toLowerCase();
+  if (marker && language && (!DATA_LANGUAGES.has(language) || language === "json" && marker !== "json"))
+    throw new UnsupportedFrontmatterLanguageError(marker);
+  return matter(source, { language: "yaml" });
+}
+
+// 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/compiler/source/config/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 = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+function issue(code, message, details) {
+  return details ? { code, message, details } : { code, message };
+}
+function isLowerAlpha(code) {
+  return code >= 97 && code <= 122;
+}
+function isUpperAlpha(code) {
+  return code >= 65 && code <= 90;
+}
+function isDigit(code) {
+  return code >= 48 && code <= 57;
+}
+function isAsciiAlphaNumeric(code) {
+  return isLowerAlpha(code) || isUpperAlpha(code) || isDigit(code);
+}
+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 isCombiningMark(code) {
+  return code >= 768 && code <= 879 || code >= 6832 && code <= 6911 || code >= 7616 && code <= 7679 || code >= 8400 && code <= 8447 || code >= 65056 && code <= 65071;
+}
+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("NFKD")) {
+    let code = char.codePointAt(0) ?? 0;
+    if (isCombiningMark(code)) {
+      sanitized = !0;
+      continue;
+    }
+    if (isAsciiAlphaNumeric(code)) {
+      let lower = isUpperAlpha(code) ? char.toLowerCase() : char;
+      pendingSeparator = appendNormalizedChar(output, lower, pendingSeparator), sanitized = sanitized || lower !== char;
+      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, 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("NFKC").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
+      }
+    )
+  ), value = value.slice(0, maxSegmentLength)), (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("NFKC").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
+      }
+    )
+  ), { 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;
+}
+
+export {
+  UnsupportedFrontmatterLanguageError,
+  parseSourceFrontmatter,
+  groupedMdxExports,
+  replacedMdxSourceFiles,
+  mdxComponentExportName,
+  collectBindingNames,
+  namedValueExports,
+  mdxIconPackage,
+  MdxIconImportError,
+  readMdxIconImports,
+  validateMdxIconImports,
+  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
+};