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

package/dist/chunk-535TM4A5.js

@@ -0,0 +1,1455 @@
+import {
+  ASSET_PREFIX,
+  PUBLIC_ASSET_DIRECTORY,
+  isExcludedSourcePath,
+  isSameOrDescendant
+} from "./chunk-YLTOLYWM.js";
+import {
+  AppError
+} from "./chunk-WDY4IK6Z.js";
+
+// 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, sep } from "path";
+async function assertSourceDependency({
+  publishOsDir,
+  path,
+  sourceFile
+}) {
+  let root = resolve(publishOsDir), target = resolve(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 = resolve(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/source/css-imports.ts
+function skipString(css, start) {
+  let quote = css[start];
+  for (let index = start + 1; index < css.length; index += 1)
+    if (css[index] === "\\") index += 1;
+    else if (css[index] === quote) return index + 1;
+  return css.length;
+}
+function maskComments(css) {
+  let result = "";
+  for (let index = 0; index < css.length; )
+    if (css[index] === '"' || css[index] === "'") {
+      let end = skipString(css, index);
+      result += css.slice(index, end), index = end;
+    } else if (css.startsWith("/*", index)) {
+      let closing = css.indexOf("*/", index + 2), end = closing < 0 ? css.length : closing + 2;
+      result += css.slice(index, end).replace(/[^\r\n]/g, " "), index = end;
+    } else
+      result += css[index], index += 1;
+  return result;
+}
+function decodeCssPath(value) {
+  return value.replace(/\\(?:\r\n|[\r\n\f])/g, "").replace(
+    /\\([\da-f]{1,6})[\t\n\f\r ]?|\\(.)/gi,
+    (_match, hex, escaped) => {
+      if (!hex) return escaped ?? "";
+      let codePoint = Number.parseInt(hex, 16);
+      return codePoint > 0 && codePoint <= 1114111 && !(codePoint >= 55296 && codePoint <= 57343) ? String.fromCodePoint(codePoint) : "\uFFFD";
+    }
+  );
+}
+function statementEnd(scan, start) {
+  let depth = 0;
+  for (let index = start; index < scan.length; index += 1)
+    if (scan[index] === '"' || scan[index] === "'")
+      index = skipString(scan, index) - 1;
+    else if (scan[index] === "\\")
+      index += 1;
+    else if (scan[index] === "(")
+      depth += 1;
+    else if (scan[index] === ")")
+      depth -= 1;
+    else {
+      if (scan[index] === ";" && depth === 0)
+        return index + 1;
+      if ((scan[index] === "{" || scan[index] === "}") && depth === 0)
+        return index;
+    }
+  return scan.length;
+}
+function closingParenthesis(scan, start, end) {
+  let depth = 0;
+  for (let index = start; index < end; index += 1)
+    if (scan[index] === '"' || scan[index] === "'")
+      index = skipString(scan, index) - 1;
+    else if (scan[index] === "\\")
+      index += 1;
+    else if (scan[index] === "(")
+      depth += 1;
+    else if (scan[index] === ")" && --depth === 0)
+      return index;
+  return end;
+}
+function importConditions({
+  css,
+  scan,
+  start,
+  end
+}) {
+  let result = {}, tailEnd = scan[end - 1] === ";" ? end - 1 : end, cursor = start, skipWhitespace = () => {
+    for (; cursor < tailEnd && /\s/.test(scan[cursor] ?? ""); ) cursor += 1;
+  };
+  skipWhitespace();
+  let layer = /^layer(?=\(|\s|$)/i.exec(scan.slice(cursor, tailEnd));
+  if (layer) {
+    if (cursor += layer[0].length, scan[cursor] === "(") {
+      let closing = closingParenthesis(scan, cursor, tailEnd);
+      result.layer = css.slice(cursor + 1, closing).trim(), cursor = closing + 1;
+    } else
+      result.layer = !0;
+    skipWhitespace();
+  }
+  let supports = /^supports\(/i.exec(scan.slice(cursor, tailEnd));
+  if (supports) {
+    let opening = cursor + supports[0].length - 1, closing = closingParenthesis(scan, opening, tailEnd);
+    result.supports = css.slice(opening + 1, closing).trim(), cursor = closing + 1, skipWhitespace();
+  }
+  return scan.slice(cursor, tailEnd).trim() && (result.media = css.slice(cursor, tailEnd).trim()), result;
+}
+function cssImports({ css }) {
+  let scan = maskComments(css), pattern = /@import\s+(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|url\(\s*(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|([^\s)]+))\s*\))/giy, imports = [];
+  for (let index = 0; index < scan.length; ) {
+    if (scan[index] === '"' || scan[index] === "'") {
+      index = skipString(scan, index);
+      continue;
+    }
+    if (scan[index] === "\\") {
+      index += 2;
+      continue;
+    }
+    pattern.lastIndex = index;
+    let match = scan[index] === "@" ? pattern.exec(scan) : null;
+    if (!match) {
+      index += 1;
+      continue;
+    }
+    let path = decodeCssPath(
+      match.slice(1).find((value) => value !== void 0) ?? ""
+    ), end = statementEnd(scan, pattern.lastIndex);
+    imports.push({
+      path,
+      start: index,
+      end,
+      ...importConditions({ css, scan, start: pattern.lastIndex, end })
+    }), index = end;
+  }
+  return imports;
+}
+function localCssImports({ css }) {
+  return cssImports({ css }).filter(({ path }) => path.startsWith("."));
+}
+
+// src/lib/compiler/source/assets/favicons-and-logos.ts
+import { createHash } from "crypto";
+import {
+  lstat as lstat2,
+  mkdir,
+  readdir,
+  readFile,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
+import { dirname, extname, join, resolve as resolve2 } from "path";
+
+// src/lib/compiler/source/assets/image-admission.ts
+import sharp from "sharp";
+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";
+  }
+  return format === "webp" ? contents.subarray(0, 4).toString("ascii") === "RIFF" && contents.subarray(8, 12).toString("ascii") === "WEBP" : format === "avif" ? contents.subarray(4, 12).toString("ascii").includes("ftyp") : contents.length >= 6 && contents[0] === 0 && contents[1] === 0 && contents[2] === 1 && contents[3] === 0 && contents.readUInt16LE(4) > 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 sanitizeSvg(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 blocked = [
+    /<!doctype/i,
+    /<!entity/i,
+    /<script[\s>]/i,
+    /<foreignobject[\s>]/i,
+    /<iframe[\s>]/i,
+    /<object[\s>]/i,
+    /<embed[\s>]/i,
+    /<audio[\s>]/i,
+    /<video[\s>]/i,
+    /<animate(?:transform|motion)?[\s>]/i,
+    /\son[a-z]+\s*=/i,
+    /javascript\s*:/i,
+    /\b(?:href|xlink:href|src)\s*=\s*["'](?:https?:|data:|\/\/)/i,
+    /url\(\s*["']?(?:https?:|data:|\/\/)/i
+  ].find((pattern) => pattern.test(source));
+  if (blocked)
+    throw new AppError({
+      code: `${options.errorPrefix}_SVG_UNSAFE`,
+      message: `${options.path} contains unsafe SVG content`,
+      details: { path: options.path, pattern: String(blocked) }
+    });
+  return source = source.replace(/<!--[\s\S]*?-->/g, "").replace(/<\?xml[\s\S]*?\?>/gi, "").trim(), Buffer.from(source, "utf-8");
+}
+
+// src/lib/compiler/source/assets/favicons-and-logos.ts
+var FAVICONS_AND_LOGOS_PUBLIC_PREFIX = `${ASSET_PREFIX}/_publishos`, MAX_FAVICON_BYTES = 1 * 1024 * 1024, MAX_LOGO_BYTES = 2 * 1024 * 1024, FAVICON_IMAGE_ADMISSION_POLICY = {
+  maxRasterMegapixels: 40,
+  maxRasterSidePixels: 8192,
+  maxSvgBytes: 256 * 1024
+}, FAVICON_ASSET_EXTENSIONS = ["ico", "svg", "png", "jpg", "jpeg"], FAVICON_ASSET_STEMS = [
+  "favicon",
+  "favicon.light",
+  "favicon.dark",
+  "apple-icon"
+], FAVICON_ASSET_EXAMPLES = [
+  "favicon.ico",
+  "favicon.svg",
+  "favicon.light.svg",
+  "favicon.dark.svg",
+  "apple-icon.png",
+  "acme.favicon.light.svg",
+  "acme-favicon.dark.png"
+], LOGO_ASSET_EXTENSIONS = ["svg", "png", "jpg", "jpeg", "webp", "avif"], LOGO_ASSET_STEMS = [
+  "logo",
+  "logo.light",
+  "logo.dark",
+  "mark",
+  "mark.light",
+  "mark.dark",
+  "wordmark",
+  "wordmark.light",
+  "wordmark.dark"
+], LOGO_ASSET_EXAMPLES = LOGO_ASSET_STEMS.map((stem) => `${stem}.svg`), LOGO_ROLE_SUFFIXES = [
+  { suffix: "logo", kind: "logo-light", role: "light" },
+  { suffix: "logo.light", kind: "logo-light", role: "light" },
+  { suffix: "logo.dark", kind: "logo-dark", role: "dark" }
+];
+function hash(contents) {
+  return `sha256-${createHash("sha256").update(contents).digest("hex").slice(0, 16)}`;
+}
+async function directoryExists(path) {
+  return await stat(path).then((entry) => entry.isDirectory()).catch(() => !1);
+}
+async function immediateFiles(dir) {
+  let entries = await readdir(dir, { withFileTypes: !0 }).catch(() => []), files = [];
+  for (let entry of entries) {
+    if (isExcludedSourcePath(`assets/${entry.name}`)) continue;
+    let absolutePath = join(dir, entry.name), info = await lstat2(absolutePath);
+    if (info.isSymbolicLink())
+      throw new AppError({
+        code: "FRAMEWORK_FAVICONS_LOGOS_SYMLINK_REJECTED",
+        message: `Favicon/logo asset "${entry.name}" is a symlink. Symlinks are not supported in publish.os/assets/favicon or publish.os/assets/logo.`,
+        details: { path: absolutePath }
+      });
+    if (info.isDirectory())
+      throw new AppError({
+        code: "FRAMEWORK_FAVICONS_LOGOS_NESTED_PATH_REJECTED",
+        message: `Favicon/logo asset folder "${entry.name}" is not supported. Favicon and logo files must be direct children of their folder.`,
+        details: { path: absolutePath }
+      });
+    info.isFile() && files.push(entry.name);
+  }
+  return files.sort();
+}
+async function assertNoRootFaviconOrLogoFiles(publishOsDir) {
+  let entries = await readdir(publishOsDir, { withFileTypes: !0 }).catch(
+    () => []
+  );
+  for (let entry of entries) {
+    if (!entry.isFile()) continue;
+    let file = entry.name;
+    if (!/^(?:favicon(?:\.(?:light|dark))?|apple-icon|logo(?:\.(?:light|dark))?|mark(?:\.(?:light|dark))?|wordmark(?:\.(?:light|dark))?)\.[a-z0-9]+$/i.test(
+      file
+    ))
+      continue;
+    let target = file.startsWith("apple-icon") ? `assets/favicon/${file}` : file.startsWith("favicon") ? `assets/favicon/${file}` : `assets/logo/${file}`;
+    throw new AppError({
+      code: "FRAMEWORK_FAVICONS_LOGOS_ROOT_PATH_REJECTED",
+      message: `publish.os/${file} is not a supported favicon/logo path. Move it to publish.os/${target}.`,
+      details: { path: `publish.os/${file}`, target: `publish.os/${target}` }
+    });
+  }
+}
+async function classifyFaviconOrLogoAsset(options) {
+  let ext = extname(options.file).slice(1).toLowerCase(), relativePath = `assets/${options.section}/${options.file}`;
+  if (ext === "ico") {
+    if (!hasImageSignature({ contents: options.contents, format: "ico" }))
+      throw new AppError({
+        code: "FRAMEWORK_FAVICONS_LOGOS_ICO_INVALID",
+        message: `${relativePath} is not a valid ICO file`,
+        details: { path: relativePath }
+      });
+    return {
+      mimeType: "image/x-icon",
+      outputContents: options.contents
+    };
+  }
+  if (ext === "png" && hasImageSignature({ contents: options.contents, format: "png" }))
+    return {
+      mimeType: "image/png",
+      outputContents: options.contents,
+      ...await readRasterMetadata({
+        contents: options.contents,
+        errorPrefix: "FRAMEWORK_FAVICONS_LOGOS",
+        path: relativePath,
+        policy: FAVICON_IMAGE_ADMISSION_POLICY
+      })
+    };
+  if ((ext === "jpg" || ext === "jpeg") && hasImageSignature({ contents: options.contents, format: "jpeg" }))
+    return {
+      mimeType: "image/jpeg",
+      outputContents: options.contents,
+      ...await readRasterMetadata({
+        contents: options.contents,
+        errorPrefix: "FRAMEWORK_FAVICONS_LOGOS",
+        path: relativePath,
+        policy: FAVICON_IMAGE_ADMISSION_POLICY
+      })
+    };
+  if (options.section === "logo" && ext === "webp" && hasImageSignature({ contents: options.contents, format: "webp" }))
+    return {
+      mimeType: "image/webp",
+      outputContents: options.contents,
+      ...await readRasterMetadata({
+        contents: options.contents,
+        errorPrefix: "FRAMEWORK_FAVICONS_LOGOS",
+        path: relativePath,
+        policy: FAVICON_IMAGE_ADMISSION_POLICY
+      })
+    };
+  if (options.section === "logo" && ext === "avif" && hasImageSignature({ contents: options.contents, format: "avif" }))
+    return {
+      mimeType: "image/avif",
+      outputContents: options.contents,
+      ...await readRasterMetadata({
+        contents: options.contents,
+        errorPrefix: "FRAMEWORK_FAVICONS_LOGOS",
+        path: relativePath,
+        policy: FAVICON_IMAGE_ADMISSION_POLICY
+      })
+    };
+  if (ext === "svg")
+    return {
+      mimeType: "image/svg+xml",
+      outputContents: sanitizeSvg({
+        contents: options.contents,
+        errorPrefix: "FRAMEWORK_FAVICONS_LOGOS",
+        path: relativePath,
+        policy: FAVICON_IMAGE_ADMISSION_POLICY
+      })
+    };
+  throw new AppError({
+    code: "FRAMEWORK_FAVICONS_LOGOS_TYPE_REJECTED",
+    message: `${relativePath} is not an allowed favicon/logo asset type`,
+    details: { path: relativePath }
+  });
+}
+function matchesFaviconStem(stem, role) {
+  return stem === role ? !0 : [".", "-"].some(
+    (separator) => stem.length > role.length + separator.length && stem.endsWith(`${separator}${role}`)
+  );
+}
+function faviconCandidate(file) {
+  let ext = extname(file).slice(1).toLowerCase(), stem = file.slice(0, -(ext.length + 1));
+  if (!FAVICON_ASSET_EXTENSIONS.includes(ext))
+    throw new AppError({
+      code: "FRAMEWORK_FAVICONS_LOGOS_TYPE_REJECTED",
+      message: `assets/favicon/${file} is not an allowed favicon asset type`,
+      details: { path: `assets/favicon/${file}` }
+    });
+  if (matchesFaviconStem(stem, "favicon") && ext === "ico")
+    return {
+      file,
+      kind: "favicon-fallback",
+      role: "fallback",
+      section: "favicon"
+    };
+  if (matchesFaviconStem(stem, "favicon") && ["svg", "png", "jpg", "jpeg"].includes(ext))
+    return {
+      file,
+      kind: "favicon-light",
+      role: "light",
+      section: "favicon"
+    };
+  if (matchesFaviconStem(stem, "favicon.light") && ["ico", "svg", "png", "jpg", "jpeg"].includes(ext))
+    return {
+      file,
+      kind: "favicon-light",
+      role: "light",
+      section: "favicon"
+    };
+  if (matchesFaviconStem(stem, "favicon.dark") && ["ico", "svg", "png", "jpg", "jpeg"].includes(ext))
+    return {
+      file,
+      kind: "favicon-dark",
+      role: "dark",
+      section: "favicon"
+    };
+  if (matchesFaviconStem(stem, "apple-icon") && ext === "svg")
+    throw new AppError({
+      code: "FRAMEWORK_FAVICONS_LOGOS_TYPE_REJECTED",
+      message: `assets/favicon/${file} is not supported. Use a PNG or JPEG Apple icon.`,
+      details: { path: `assets/favicon/${file}` }
+    });
+  if (matchesFaviconStem(stem, "apple-icon") && ["png", "jpg", "jpeg"].includes(ext))
+    return {
+      file,
+      kind: "apple-touch",
+      role: "apple",
+      section: "favicon"
+    };
+  throw new AssetNameRejectedWarning({
+    code: "FRAMEWORK_FAVICONS_LOGOS_NAME_REJECTED",
+    message: `assets/favicon/${file} is not a supported favicon asset name. Supported favicon files include ${FAVICON_ASSET_EXAMPLES.join(", ")}.`,
+    details: {
+      acceptedExtensions: FAVICON_ASSET_EXTENSIONS.map((extension) => `.${extension}`),
+      acceptedNames: FAVICON_ASSET_EXAMPLES,
+      acceptedStems: FAVICON_ASSET_STEMS,
+      file: `assets/favicon/${file}`,
+      path: `assets/favicon/${file}`
+    }
+  });
+}
+function logoCandidate(file) {
+  let ext = extname(file).slice(1).toLowerCase(), stem = file.slice(0, -(ext.length + 1));
+  if (!LOGO_ASSET_EXTENSIONS.includes(ext))
+    throw new AppError({
+      code: "FRAMEWORK_FAVICONS_LOGOS_TYPE_REJECTED",
+      message: `assets/logo/${file} is not an allowed logo asset type`,
+      details: { path: `assets/logo/${file}` }
+    });
+  let flexibleLogoRole = {
+    logo: { kind: "logo-light", role: "light" },
+    "logo.light": { kind: "logo-light", role: "light" },
+    "logo.dark": { kind: "logo-dark", role: "dark" },
+    mark: { kind: "mark-light", role: "markLight" },
+    "mark.light": { kind: "mark-light", role: "markLight" },
+    "mark.dark": { kind: "mark-dark", role: "markDark" },
+    wordmark: { kind: "wordmark-light", role: "wordmarkLight" },
+    "wordmark.light": { kind: "wordmark-light", role: "wordmarkLight" },
+    "wordmark.dark": { kind: "wordmark-dark", role: "wordmarkDark" }
+  }[stem] ?? LOGO_ROLE_SUFFIXES.find((entry) => stem === entry.suffix || stem.endsWith(`.${entry.suffix}`) || stem.endsWith(`-${entry.suffix}`));
+  if (!flexibleLogoRole)
+    throw new AssetNameRejectedWarning({
+      code: "FRAMEWORK_FAVICONS_LOGOS_NAME_REJECTED",
+      message: [
+        `assets/logo/${file} is not a supported logo name.`,
+        "Supported file types: svg, png, jpg, jpeg, webp, avif.",
+        "Naming: *logo, *logo.light, *logo.dark.",
+        "Example:",
+        "  assets/logo/acme.logo.light.svg",
+        "  assets/logo/acme.logo.dark.svg"
+      ].join(`
+`),
+      details: {
+        acceptedExtensions: LOGO_ASSET_EXTENSIONS.map((extension) => `.${extension}`),
+        acceptedNames: [
+          ...LOGO_ASSET_EXAMPLES,
+          "brand.logo.svg",
+          "brand.logo.light.svg",
+          "brand.logo.dark.svg"
+        ],
+        acceptedStems: [
+          ...LOGO_ASSET_STEMS,
+          "*.logo",
+          "*-logo",
+          "*.logo.light",
+          "*-logo.light",
+          "*.logo.dark",
+          "*-logo.dark"
+        ],
+        file: `assets/logo/${file}`,
+        path: `assets/logo/${file}`
+      }
+    });
+  return {
+    file,
+    kind: flexibleLogoRole.kind,
+    role: flexibleLogoRole.role,
+    section: "logo"
+  };
+}
+var AssetNameRejectedWarning = class extends Error {
+  code;
+  details;
+  constructor(warning) {
+    super(warning.message), this.name = "AssetNameRejectedWarning", this.code = warning.code, this.details = warning.details;
+  }
+};
+function collectFaviconCandidates(files) {
+  let candidates = [], warnings = [];
+  for (let file of files)
+    try {
+      candidates.push(faviconCandidate(file));
+    } catch (error) {
+      if (error instanceof AssetNameRejectedWarning) {
+        warnings.push({
+          code: error.code,
+          message: error.message,
+          details: error.details
+        });
+        continue;
+      }
+      throw error;
+    }
+  return { candidates, warnings };
+}
+function collectLogoCandidates(files) {
+  let candidates = [], warnings = [];
+  for (let file of files)
+    try {
+      candidates.push(logoCandidate(file));
+    } catch (error) {
+      if (error instanceof AssetNameRejectedWarning) {
+        warnings.push({
+          code: error.code,
+          message: error.message,
+          details: error.details
+        });
+        continue;
+      }
+      throw error;
+    }
+  return { candidates, warnings };
+}
+function assertUniqueRole(candidates, section) {
+  let seen = /* @__PURE__ */ new Map();
+  for (let candidate of candidates) {
+    let key = `${candidate.section}:${candidate.role}`, existing = seen.get(key);
+    if (!existing) {
+      seen.set(key, candidate.file);
+      continue;
+    }
+    throw new AppError({
+      code: "FRAMEWORK_FAVICONS_LOGOS_DUPLICATE_ROLE",
+      message: `assets/${section}/${existing} and assets/${section}/${candidate.file} both define the same ${section} role`,
+      details: {
+        role: candidate.role,
+        first: `assets/${section}/${existing}`,
+        second: `assets/${section}/${candidate.file}`
+      }
+    });
+  }
+}
+function buildEntry(options) {
+  let contentHash = hash(options.asset.outputContents), hashPath = contentHash.replace(/^sha256-/, ""), publicPath = `${ASSET_PREFIX}/assets/${options.candidate.section}/${options.candidate.file}`, outputPath = `${FAVICONS_AND_LOGOS_PUBLIC_PREFIX}/${options.candidate.section}/${hashPath}/${options.candidate.file}`, sizes = options.asset.width && options.asset.height ? `${options.asset.width}x${options.asset.height}` : options.asset.mimeType === "image/svg+xml" || options.asset.mimeType === "image/x-icon" ? "any" : void 0;
+  return {
+    entry: {
+      kind: options.candidate.kind,
+      sourcePath: options.sourcePath,
+      publicPath,
+      outputPath,
+      contentHash,
+      mimeType: options.asset.mimeType,
+      byteSize: options.asset.outputContents.byteLength,
+      width: options.asset.width,
+      height: options.asset.height,
+      sizes
+    },
+    outputs: [
+      { contents: options.asset.outputContents, outputPath },
+      { contents: options.asset.outputContents, outputPath: publicPath }
+    ]
+  };
+}
+function assertFaviconShape(options) {
+  if (options.candidate.section === "favicon" && options.candidate.role !== "apple" && !(!options.asset.width || !options.asset.height) && options.asset.width !== options.asset.height)
+    throw new AppError({
+      code: "FRAMEWORK_FAVICONS_LOGOS_FAVICON_NOT_SQUARE",
+      message: `assets/favicon/${options.candidate.file} must be square`,
+      details: {
+        height: options.asset.height,
+        path: `assets/favicon/${options.candidate.file}`,
+        width: options.asset.width
+      }
+    });
+}
+function assertAppleIconShape(options) {
+  if (options.candidate.section === "favicon" && options.candidate.role === "apple" && !(!options.asset.width || !options.asset.height) && options.asset.width !== options.asset.height)
+    throw new AppError({
+      code: "FRAMEWORK_FAVICONS_LOGOS_APPLE_ICON_NOT_SQUARE",
+      message: `assets/favicon/${options.candidate.file} must be square`,
+      details: {
+        height: options.asset.height,
+        path: `assets/favicon/${options.candidate.file}`,
+        width: options.asset.width
+      }
+    });
+}
+function metadataIcons(manifest) {
+  let icon = [], light = manifest.light && manifest.light !== manifest.fallback ? manifest.light : void 0;
+  light && manifest.dark ? (icon.push({
+    url: light.outputPath,
+    media: "(prefers-color-scheme: light)",
+    type: light.mimeType,
+    sizes: light.sizes
+  }), icon.push({
+    url: manifest.dark.outputPath,
+    media: "(prefers-color-scheme: dark)",
+    type: manifest.dark.mimeType,
+    sizes: manifest.dark.sizes
+  })) : light ? icon.push({
+    url: light.outputPath,
+    type: light.mimeType,
+    sizes: light.sizes
+  }) : manifest.dark && icon.push({
+    url: manifest.dark.outputPath,
+    media: "(prefers-color-scheme: dark)",
+    type: manifest.dark.mimeType,
+    sizes: manifest.dark.sizes
+  }), manifest.fallback && icon.push({
+    url: manifest.fallback.outputPath,
+    type: manifest.fallback.mimeType,
+    sizes: manifest.fallback.sizes
+  });
+  let apple = manifest.apple ? [
+    {
+      url: manifest.apple.outputPath,
+      type: manifest.apple.mimeType,
+      sizes: manifest.apple.sizes
+    }
+  ] : void 0;
+  return {
+    ...icon.length > 0 ? { icon } : {},
+    ...apple ? { apple } : {}
+  };
+}
+function assignEntry(manifest, candidate, entry) {
+  if (candidate.section === "favicon") {
+    candidate.role === "fallback" ? manifest.favicon.fallback = entry : candidate.role === "light" ? manifest.favicon.light = entry : candidate.role === "dark" ? manifest.favicon.dark = entry : candidate.role === "apple" && (manifest.favicon.apple = entry);
+    return;
+  }
+  candidate.role === "light" ? manifest.logo.light = entry : candidate.role === "dark" ? manifest.logo.dark = entry : candidate.role === "markLight" ? manifest.logo.markLight = entry : candidate.role === "markDark" ? manifest.logo.markDark = entry : candidate.role === "wordmarkLight" ? manifest.logo.wordmarkLight = entry : candidate.role === "wordmarkDark" && (manifest.logo.wordmarkDark = entry);
+}
+async function buildFaviconsAndLogos(options) {
+  await assertNoRootFaviconOrLogoFiles(options.publishOsDir);
+  let faviconDir = resolve2(options.publishOsDir, "assets", "favicon"), logoDir = resolve2(options.publishOsDir, "assets", "logo"), faviconFiles = await directoryExists(faviconDir) ? await immediateFiles(faviconDir) : [], logoFiles = await directoryExists(logoDir) ? await immediateFiles(logoDir) : [], faviconCandidateResult = collectFaviconCandidates(faviconFiles), faviconCandidates = faviconCandidateResult.candidates, logoCandidateResult = collectLogoCandidates(logoFiles), logoCandidates = logoCandidateResult.candidates, warnings = [
+    ...faviconCandidateResult.warnings,
+    ...logoCandidateResult.warnings
+  ];
+  assertUniqueRole(faviconCandidates, "favicon"), assertUniqueRole(logoCandidates, "logo");
+  let manifest = {
+    assets: [],
+    favicon: {},
+    logo: {},
+    metadataIcons: {}
+  }, outputs = [];
+  for (let candidate of [...faviconCandidates, ...logoCandidates]) {
+    let baseDir = candidate.section === "favicon" ? faviconDir : logoDir, sourcePath = resolve2(baseDir, candidate.file);
+    if (!isSameOrDescendant(baseDir, sourcePath))
+      throw new AppError({
+        code: "FRAMEWORK_FAVICONS_LOGOS_PATH_REJECTED",
+        message: `${candidate.file} escapes publish.os/assets/${candidate.section}`,
+        details: { path: candidate.file }
+      });
+    let contents = await readFile(sourcePath), asset = await classifyFaviconOrLogoAsset({
+      contents,
+      file: candidate.file,
+      section: candidate.section
+    });
+    assertFaviconShape({ asset, candidate }), assertAppleIconShape({ asset, candidate });
+    let limit = candidate.section === "favicon" ? MAX_FAVICON_BYTES : MAX_LOGO_BYTES;
+    if (asset.outputContents.byteLength > limit)
+      throw new AppError({
+        code: "FRAMEWORK_FAVICONS_LOGOS_FILE_TOO_LARGE",
+        message: `assets/${candidate.section}/${candidate.file} is ${asset.outputContents.byteLength} bytes. Favicon/logo assets in this folder must be less than ${Math.round(limit / 1024 / 1024)} MB.`,
+        details: {
+          path: `assets/${candidate.section}/${candidate.file}`,
+          bytes: asset.outputContents.byteLength,
+          limit
+        }
+      });
+    let { entry, outputs: entryOutputs } = buildEntry({
+      asset,
+      candidate,
+      sourcePath: `publish.os/assets/${candidate.section}/${candidate.file}`
+    });
+    manifest.assets.push(entry), assignEntry(manifest, candidate, entry), outputs.push(...entryOutputs);
+  }
+  return !manifest.favicon.light && manifest.favicon.fallback && (manifest.favicon.light = manifest.favicon.fallback), !manifest.logo.dark && manifest.logo.light && (manifest.logo.dark = manifest.logo.light), !manifest.logo.markDark && manifest.logo.markLight && (manifest.logo.markDark = manifest.logo.markLight), !manifest.logo.wordmarkDark && manifest.logo.wordmarkLight && (manifest.logo.wordmarkDark = manifest.logo.wordmarkLight), manifest.metadataIcons = metadataIcons(manifest.favicon), { manifest, outputs, warnings };
+}
+async function writeFaviconsAndLogosOutputs(options) {
+  await rm(
+    resolve2(options.outputDir, "public", "_publishos", "favicons-and-logos"),
+    {
+      force: !0,
+      recursive: !0
+    }
+  ), await rm(resolve2(options.outputDir, "public", "_publishos", "identity"), {
+    force: !0,
+    recursive: !0
+  }), await rm(resolve2(options.outputDir, "public", "_publishos", "favicon"), {
+    force: !0,
+    recursive: !0
+  }), await rm(resolve2(options.outputDir, "public", "_publishos", "logo"), {
+    force: !0,
+    recursive: !0
+  }), await rm(
+    resolve2(
+      options.outputDir,
+      "public",
+      ...PUBLIC_ASSET_DIRECTORY.split("/"),
+      "_publishos",
+      "favicon"
+    ),
+    { force: !0, recursive: !0 }
+  ), await rm(
+    resolve2(
+      options.outputDir,
+      "public",
+      ...PUBLIC_ASSET_DIRECTORY.split("/"),
+      "_publishos",
+      "logo"
+    ),
+    { force: !0, recursive: !0 }
+  ), await rm(
+    resolve2(
+      options.outputDir,
+      "public",
+      ...PUBLIC_ASSET_DIRECTORY.split("/"),
+      "assets",
+      "favicon"
+    ),
+    { force: !0, recursive: !0 }
+  ), await rm(
+    resolve2(
+      options.outputDir,
+      "public",
+      ...PUBLIC_ASSET_DIRECTORY.split("/"),
+      "assets",
+      "logo"
+    ),
+    { force: !0, recursive: !0 }
+  ), await rm(resolve2(options.outputDir, "public", "favicon.ico"), {
+    force: !0
+  }), await rm(resolve2(options.outputDir, "public", "apple-touch-icon.png"), {
+    force: !0
+  }), await rm(
+    resolve2(options.outputDir, "public", "apple-touch-icon-precomposed.png"),
+    {
+      force: !0
+    }
+  );
+  for (let output of options.faviconsAndLogos.outputs) {
+    let relativeOutput = output.outputPath.replace(/^\/+/, ""), dest = resolve2(options.outputDir, "public", relativeOutput);
+    await mkdir(dirname(dest), { recursive: !0 }), await writeFile(dest, output.contents);
+  }
+}
+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/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;
+}
+
+// src/lib/compiler/source/assets/media-assets.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  lstat as lstat3,
+  mkdir as mkdir2,
+  readdir as readdir2,
+  readFile as readFile2,
+  rm as rm2,
+  writeFile as writeFile2
+} from "fs/promises";
+import { dirname as dirname2, join as join2, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+var DEFAULT_MAX_IMAGE_BYTES = 20 * 1024 * 1024, DEFAULT_MAX_VIDEO_BYTES = 20 * 1024 * 1024, DEFAULT_MAX_DOCUMENT_BYTES = 20 * 1024 * 1024, DEFAULT_MAX_OTHER_BYTES = 5 * 1024 * 1024, DEFAULT_MAX_TOTAL_BYTES = 100 * 1024 * 1024, DEFAULT_MAX_FILE_COUNT = 500, MEDIA_IMAGE_ADMISSION_POLICY = {
+  maxRasterMegapixels: 40,
+  maxRasterSidePixels: 8192,
+  maxSvgBytes: 256 * 1024
+}, MEDIA_PUBLIC_PREFIX = `${ASSET_PREFIX}/assets`, GENERATED_MEDIA_PUBLIC_PREFIX = `${ASSET_PREFIX}/_publishos/assets`, RESERVED_FAVICON_AND_LOGO_ASSET_DIRS = /* @__PURE__ */ new Set(["favicon", "logo"]);
+function toPosixPath(path) {
+  return path.split(sep2).join("/");
+}
+function normalizeAssetPath(relativePath) {
+  if (relativePath.split("/").some(
+    (segment) => segment === "" || segment === "." || segment === ".." || segment.startsWith(".")
+  ))
+    throw new AppError({
+      code: "FRAMEWORK_MEDIA_PATH_REJECTED",
+      message: `Media asset path "${relativePath}" is not allowed`,
+      details: { path: relativePath }
+    });
+  let normalized = normalizeSlugPath(relativePath);
+  if (normalized.errors.length > 0)
+    throw new AppError({
+      code: "FRAMEWORK_MEDIA_PATH_REJECTED",
+      message: `Media asset path "${relativePath}" does not produce a safe URL path`,
+      details: { errors: normalized.errors, path: relativePath }
+    });
+  return normalized.value;
+}
+function ignoredMediaPathWarning(relativePath) {
+  return {
+    code: "FRAMEWORK_MEDIA_PATH_IGNORED",
+    message: "Hidden media file ignored.",
+    details: { file: relativePath, path: relativePath }
+  };
+}
+async function walkAssetFiles(dir, root = dir) {
+  let entries = await readdir2(dir, { withFileTypes: !0 }).catch(() => []), files = [], warnings = [];
+  for (let entry of entries) {
+    let absolutePath = join2(dir, entry.name), relativePath = toPosixPath(relative2(root, absolutePath));
+    if (isExcludedSourcePath(`assets/${relativePath}`)) continue;
+    if (entry.name.startsWith(".")) {
+      warnings.push(ignoredMediaPathWarning(relativePath));
+      continue;
+    }
+    let info = await lstat3(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()) {
+      let nested = await walkAssetFiles(absolutePath, root);
+      files.push(...nested.files), warnings.push(...nested.warnings);
+      continue;
+    }
+    info.isFile() && files.push(relativePath);
+  }
+  return { files: files.sort(), warnings };
+}
+function hash2(contents) {
+  return `sha256-${createHash2("sha256").update(contents).digest("hex").slice(0, 16)}`;
+}
+function startsWithAscii(contents, value) {
+  return contents.subarray(0, value.length).toString("ascii") === value;
+}
+function hasNullByte(contents) {
+  return contents.includes(0);
+}
+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 === "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") {
+    if (relativePath.startsWith("images/"))
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_SVG_IN_OPTIMIZED_IMAGES",
+        message: `${relativePath} is an SVG. SVG files are not allowed under publish.os/assets/images because that folder is reserved for optimized raster images.`,
+        details: { path: relativePath }
+      });
+    let outputContents = sanitizeSvg({
+      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 === "pdf" && startsWithAscii(contents, "%PDF"))
+    return {
+      contents,
+      mediaType: "document",
+      mimeType: "application/pdf",
+      outputContents: contents
+    };
+  if (ext === "json")
+    return JSON.parse(contents.toString("utf-8")), {
+      contents,
+      mediaType: "file",
+      mimeType: "application/json",
+      outputContents: contents
+    };
+  if ((ext === "txt" || ext === "csv") && !hasNullByte(contents))
+    return {
+      contents,
+      mediaType: "file",
+      mimeType: ext === "csv" ? "text/csv" : "text/plain",
+      outputContents: contents
+    };
+  throw new AppError({
+    code: "FRAMEWORK_MEDIA_TYPE_REJECTED",
+    message: `${relativePath} is not an allowed media type`,
+    details: { path: relativePath }
+  });
+}
+function assertAssetSize(options) {
+  let limits = options.config.media?.assets, limit = options.asset.mediaType === "image" ? limits?.maxImageBytes ?? DEFAULT_MAX_IMAGE_BYTES : options.asset.mediaType === "video" ? limits?.maxVideoBytes ?? DEFAULT_MAX_VIDEO_BYTES : options.asset.mediaType === "document" ? DEFAULT_MAX_DOCUMENT_BYTES : DEFAULT_MAX_OTHER_BYTES;
+  if (options.asset.contents.byteLength <= limit) return;
+  let label = options.asset.mediaType === "image" ? "Image files" : options.asset.mediaType === "video" ? "Video files" : "Media files";
+  throw new AppError({
+    code: "FRAMEWORK_MEDIA_FILE_TOO_LARGE",
+    message: `${options.relativePath} is ${options.asset.contents.byteLength} bytes. ${label} must be less than ${Math.round(limit / 1024 / 1024)} MB.`,
+    details: {
+      path: options.relativePath,
+      bytes: options.asset.contents.byteLength,
+      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"), mediaFiles = await walkAssetFiles(assetsDir), files = mediaFiles.files.filter(
+    (file) => !RESERVED_FAVICON_AND_LOGO_ASSET_DIRS.has(file.split("/")[0] ?? "")
+  ), warnings = mediaFiles.warnings, maxFileCount = options.config.media?.assets?.maxFileCount ?? DEFAULT_MAX_FILE_COUNT;
+  if (files.length > maxFileCount)
+    throw new AppError({
+      code: "FRAMEWORK_MEDIA_FILE_COUNT_EXCEEDED",
+      message: `publish.os/assets contains ${files.length} files, exceeding the limit of ${maxFileCount}`,
+      details: { count: files.length, limit: maxFileCount }
+    });
+  let manifest = {
+    assets: {},
+    remote: {
+      images: options.config.media?.remote?.images ?? [],
+      videos: options.config.media?.remote?.videos ?? [],
+      embeds: options.config.media?.remote?.embeds ?? []
+    },
+    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 = normalizeAssetPath(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 contents = await readFile2(sourcePath), asset = await classifyAsset(file, contents);
+    assertAssetSize({ asset, config: options.config, relativePath: file });
+    let contentHash = hash2(asset.outputContents), outputPath = `${GENERATED_MEDIA_PUBLIC_PREFIX}/${contentHash}/${normalized}`, optimized = isOptimizableLocalImage(asset), aspect = asset.width && asset.height ? asset.width / asset.height : void 0;
+    manifest.assets[sourcePublicPath] = {
+      sourcePath: `publish.os/assets/${file}`,
+      publicPath,
+      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 }), outputs.push({ contents: asset.outputContents, outputPath: publicPath });
+  }
+  let maxTotalBytes = options.config.media?.assets?.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES;
+  if (manifest.totals.bytes > maxTotalBytes)
+    throw new AppError({
+      code: "FRAMEWORK_MEDIA_TOTAL_TOO_LARGE",
+      message: `publish.os/assets is ${manifest.totals.bytes} bytes, exceeding the limit of ${maxTotalBytes}`,
+      details: { bytes: manifest.totals.bytes, limit: maxTotalBytes }
+    });
+  return { manifest, outputs, warnings };
+}
+async function writeMediaOutputs(options) {
+  await rm2(resolve3(options.outputDir, "public", "_publishos", "assets"), {
+    force: !0,
+    recursive: !0
+  }), await rm2(resolve3(options.outputDir, "public", "_publishos", "media"), {
+    force: !0,
+    recursive: !0
+  }), await rm2(resolve3(options.outputDir, "public", "assets"), {
+    force: !0,
+    recursive: !0
+  });
+  for (let output of options.media.outputs) {
+    let relativeOutput = output.outputPath.replace(/^\/+/, ""), dest = resolve3(options.outputDir, "public", relativeOutput);
+    await mkdir2(dirname2(dest), { recursive: !0 }), await writeFile2(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/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;
+}
+
+export {
+  ROOT_CONTENT_GROUP_KEY,
+  ROOT_CONTENT_GROUP_TITLE,
+  assertSourceDependency,
+  decodeCssPath,
+  cssImports,
+  localCssImports,
+  buildFaviconsAndLogos,
+  writeFaviconsAndLogosOutputs,
+  faviconsAndLogosManifestModule,
+  normalizeSlugPath,
+  normalizeUrlPath,
+  joinUrlPath,
+  buildMediaAssets,
+  writeMediaOutputs,
+  mediaManifestModule,
+  groupedMdxExports,
+  replacedMdxSourceFiles,
+  mdxComponentExportName,
+  collectBindingNames,
+  namedValueExports
+};