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

package/dist/chunk-726GV2NF.js

@@ -0,0 +1,2344 @@
+import {
+  supportedNextjsSourceImports
+} from "./chunk-NECL5IBJ.js";
+import {
+  ROOT_CONTENT_GROUP_KEY,
+  ROOT_CONTENT_GROUP_TITLE,
+  assertSourceDependency,
+  buildFaviconsAndLogos,
+  buildMediaAssets,
+  collectBindingNames,
+  groupedMdxExports,
+  joinUrlPath,
+  localCssImports,
+  mdxComponentExportName,
+  namedValueExports,
+  normalizeSlugPath,
+  normalizeUrlPath,
+  replacedMdxSourceFiles
+} from "./chunk-535TM4A5.js";
+import {
+  AppError as AppError2,
+  ERROR_CODES,
+  assertPublishOsSourceBoundary
+} from "./chunk-7OGTPSKI.js";
+import {
+  isApprovedPublishOsPath,
+  isExcludedSourcePath,
+  isFrameworkNamespacePath,
+  isReservedFrameworkPath,
+  isSameOrDescendant
+} from "./chunk-YLTOLYWM.js";
+import {
+  runtimePackageVersion
+} from "./chunk-AI2UULNX.js";
+import {
+  AppError,
+  readInstalledFrameworkLocation
+} from "./chunk-WDY4IK6Z.js";
+
+// src/lib/compiler/validation/validate-publish-os-source.ts
+import { readdir as readdir3, readFile as readFile5, stat as stat3 } from "fs/promises";
+import { basename, dirname, extname as extname3, relative as relative4, resolve as resolve7, sep } from "path";
+import ts2 from "typescript";
+
+// src/lib/compiler/source/diagnostics/diagnostic-store.ts
+import { z } from "zod";
+var diagnosticSchema = z.object({
+  code: z.string(),
+  level: z.union([z.literal("error"), z.literal("warning")]),
+  message: z.string(),
+  details: z.record(z.unknown()).optional()
+}), DiagnosticStore = class {
+  diagnostics = [];
+  add(diagnostic) {
+    let parsed = diagnosticSchema.parse(diagnostic);
+    this.diagnostics.push(parsed);
+  }
+  error(code, message, details) {
+    this.add({ code, level: "error", message, details });
+  }
+  warning(code, message, details) {
+    this.add({ code, level: "warning", message, details });
+  }
+  all() {
+    return [...this.diagnostics];
+  }
+  hasErrors() {
+    return this.diagnostics.some((d) => d.level === "error");
+  }
+};
+
+// src/lib/compiler/source/icon-source-contract.ts
+function findLegacyIconResolver(source) {
+  return /<Icon\b/.exec(source);
+}
+
+// src/lib/compiler/source/prepare-publish-os-source.ts
+import { resolve as resolve5 } from "path";
+
+// src/lib/compiler/source/config/resolve-publish-os-config.ts
+import { resolve as resolve3 } from "path";
+
+// src/lib/compiler/source/config/load-publish-os-config.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+
+// src/lib/compiler/source/config/format-config-issues.ts
+function issueMessages(issue) {
+  return issue.code === "invalid_union" ? issue.unionErrors.flatMap(
+    (error) => error.issues.flatMap(issueMessages)
+  ) : issue.code === "unrecognized_keys" ? issue.keys.map(
+    (key) => `${[...issue.path, key].join(".")}: Unknown field.`
+  ) : [`${issue.path.join(".") || "(root)"}: ${issue.message}`];
+}
+function formatConfigIssues(error) {
+  return [...new Set(error.issues.flatMap(issueMessages))].join(`
+`);
+}
+
+// src/lib/compiler/source/config/publish-os-config-schema.ts
+import { z as z4 } from "zod";
+
+// src/lib/compiler/source/config/og-metadata-schema.ts
+import { z as z2 } from "zod";
+var ogImageSchema = z2.union([
+  z2.string().min(1),
+  z2.object({ src: z2.string().min(1), alt: z2.string().optional() }).strict()
+]), ogIndexMetadataSchema = z2.object({
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  image: ogImageSchema.optional(),
+  scope: z2.enum(["page", "subtree"]).optional()
+}).strict().refine((value) => value.scope === void 0 || value.image !== void 0, {
+  message: "Set og.image when you set og.scope.",
+  path: ["scope"]
+});
+
+// src/lib/compiler/source/config/publish-os-group-schema.ts
+import { z as z3 } from "zod";
+var treeNodeSchema = z3.lazy(
+  () => z3.union([
+    z3.object({
+      type: z3.literal("section"),
+      id: z3.string(),
+      title: z3.string(),
+      children: z3.array(treeNodeSchema)
+    }),
+    z3.object({
+      type: z3.literal("page"),
+      file: z3.string(),
+      title: z3.string().optional(),
+      slug: z3.string().optional()
+    }),
+    z3.object({
+      type: z3.literal("link"),
+      id: z3.string(),
+      title: z3.string(),
+      url: z3.string()
+    }),
+    z3.object({
+      type: z3.literal("folder"),
+      id: z3.string(),
+      title: z3.string(),
+      group: z3.string().optional(),
+      children: z3.array(treeNodeSchema).optional()
+    })
+  ])
+), groupListSchema = z3.object({
+  source: z3.enum(["content", "ids"]),
+  ids: z3.array(z3.string()).optional(),
+  sort: z3.object({
+    by: z3.string(),
+    direction: z3.enum(["asc", "desc"]).optional()
+  }).optional(),
+  prevNext: z3.boolean().optional()
+}).strict(), outputScopeSchema = z3.enum(["site", "group", "self"]), outputStatusSchema = z3.enum(["published", "draft", "archived"]), outputDeclarationSchema = z3.object({
+  path: z3.string().min(1),
+  scope: outputScopeSchema.optional(),
+  description: z3.string().optional(),
+  limit: z3.number().int().positive().optional()
+}).strict(), outputDefaultsDeclarationSchema = z3.object({
+  scope: outputScopeSchema.optional(),
+  limit: z3.number().int().positive().optional(),
+  status: z3.array(outputStatusSchema).optional(),
+  includeDescriptions: z3.boolean().optional()
+}).strict(), feedsOutputSchema = z3.object({
+  rss: outputDeclarationSchema.optional(),
+  atom: outputDeclarationSchema.optional(),
+  json: outputDeclarationSchema.optional()
+}).strict(), feedsOutputDefaultsSchema = outputDefaultsDeclarationSchema.extend({
+  rss: outputDefaultsDeclarationSchema.optional(),
+  atom: outputDefaultsDeclarationSchema.optional(),
+  json: outputDefaultsDeclarationSchema.optional()
+}).strict(), outputsSchema = z3.object({
+  llms: outputDeclarationSchema.optional(),
+  feeds: feedsOutputSchema.optional(),
+  robots: outputDeclarationSchema.optional(),
+  sitemap: outputDeclarationSchema.optional()
+}).strict(), outputDefaultsSchema = z3.object({
+  llms: outputDefaultsDeclarationSchema.optional(),
+  feeds: feedsOutputDefaultsSchema.optional()
+}).strict();
+function normalizeHttpsOrigin(value) {
+  try {
+    let url = new URL(value);
+    return url.protocol !== "https:" || url.username || url.password || /[?#]/.test(value) || url.pathname !== "/" ? void 0 : url.origin;
+  } catch {
+    return;
+  }
+}
+var httpsOriginSchema = z3.string().transform((value) => normalizeHttpsOrigin(value) ?? value).refine(
+  (value) => value.startsWith("https://") && normalizeHttpsOrigin(value) === value,
+  {
+    message: "Use an HTTPS origin without a path, query, or fragment."
+  }
+), groupThemeForcedModeSchema = z3.enum(["light", "dark", "none"]), groupThemeSchema = z3.object({
+  forcedMode: groupThemeForcedModeSchema.optional()
+}).strict(), staticFontWeightSchema = z3.enum([
+  "100",
+  "200",
+  "300",
+  "400",
+  "500",
+  "600",
+  "700",
+  "800",
+  "900"
+]), variableFontWeightSchema = z3.union([
+  z3.literal("variable"),
+  z3.string().regex(/^\d+\s+\d+$/)
+]), fontWeightSchema = z3.union([
+  z3.literal("all"),
+  variableFontWeightSchema,
+  staticFontWeightSchema,
+  z3.array(staticFontWeightSchema)
+]), localFontStyleSchema = z3.enum(["normal", "italic"]), fontStyleSchema = z3.union([
+  localFontStyleSchema,
+  z3.tuple([z3.literal("normal"), z3.literal("italic")])
+]), localFontFileSchema = z3.object({
+  path: z3.string().min(1),
+  weight: z3.union([variableFontWeightSchema, staticFontWeightSchema]).optional(),
+  style: localFontStyleSchema.optional()
+}).strict(), fontRoleSchema = z3.union([
+  z3.string().min(1),
+  z3.object({
+    family: z3.string().min(1),
+    src: z3.union([z3.string().min(1), z3.array(localFontFileSchema)]).optional(),
+    weight: fontWeightSchema.optional(),
+    style: fontStyleSchema.optional(),
+    subsets: z3.array(z3.string().min(1)).optional(),
+    axes: z3.array(z3.string().min(1)).optional(),
+    display: z3.enum(["auto", "block", "swap", "fallback", "optional"]).optional(),
+    preload: z3.boolean().optional(),
+    fallback: z3.array(z3.string().min(1)).optional(),
+    adjustFontFallback: z3.boolean().optional()
+  }).strict()
+]), fontConfigSchema = z3.record(
+  z3.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  fontRoleSchema
+), groupConfigDocumentSchema = z3.lazy(
+  () => z3.object({
+    origin: httpsOriginSchema.optional(),
+    og: ogIndexMetadataSchema.optional(),
+    title: z3.string().optional(),
+    slug: z3.string().optional(),
+    path: z3.string().regex(/^\//).optional(),
+    mode: z3.enum(["tree", "list"]).optional(),
+    theme: groupThemeSchema.optional(),
+    fonts: fontConfigSchema.optional(),
+    meta: z3.record(z3.unknown()).optional(),
+    tree: z3.array(treeNodeSchema).optional(),
+    list: groupListSchema.optional(),
+    outputs: outputsSchema.optional(),
+    outputDefaults: outputDefaultsSchema.optional()
+  }).strict()
+);
+
+// src/lib/compiler/source/config/publish-os-config-schema.ts
+var siteSchema = z4.object({
+  name: z4.string().optional(),
+  description: z4.string().optional()
+}).strict(), runtimePackageMessage = 'Set runtime to "@publish.os/nextjs@<exact-version>". Replace <exact-version> with the exact framework version for this source.', runtimeSchema = z4.string({
+  required_error: runtimePackageMessage,
+  invalid_type_error: runtimePackageMessage
+}).refine((value) => runtimePackageVersion(value) !== void 0, {
+  message: runtimePackageMessage
+}), rootThemeSchema = z4.object({
+  defaultMode: z4.enum(["system", "light", "dark"]).optional(),
+  forcedMode: z4.enum(["light", "dark"]).optional()
+}).strict(), remoteMediaSourceSchema = z4.object({
+  protocol: z4.literal("https"),
+  hostname: z4.string().min(1),
+  pathname: z4.string().optional()
+}).strict(), remoteEmbedSourceSchema = z4.object({
+  provider: z4.enum([
+    "youtube",
+    "vimeo",
+    "loom",
+    "wistia",
+    "cloudflare-stream"
+  ]),
+  hostname: z4.string().min(1)
+}).strict(), mediaConfigSchema = z4.object({
+  assets: z4.object({
+    maxImageBytes: z4.number().int().positive().optional(),
+    maxVideoBytes: z4.number().int().positive().optional(),
+    maxTotalBytes: z4.number().int().positive().optional(),
+    maxFileCount: z4.number().int().positive().optional()
+  }).strict().optional(),
+  remote: z4.object({
+    images: z4.array(remoteMediaSourceSchema).optional(),
+    videos: z4.array(remoteMediaSourceSchema).optional(),
+    embeds: z4.array(remoteEmbedSourceSchema).optional()
+  }).strict().optional()
+}).strict(), agentConfigSchema = z4.object({
+  enabled: z4.boolean().optional(),
+  markdownRoutes: z4.boolean().optional(),
+  markdownAccept: z4.boolean().optional(),
+  plainTextAccept: z4.boolean().optional(),
+  agentDetection: z4.boolean().optional(),
+  discoveryHeaders: z4.boolean().optional(),
+  blockInternalMarkdownRoute: z4.boolean().optional()
+}).strict(), publishOsConfigSchema = z4.object({
+  $schema: z4.string().optional(),
+  version: z4.literal(1),
+  runtime: runtimeSchema,
+  origin: httpsOriginSchema.optional(),
+  site: siteSchema.optional(),
+  agent: agentConfigSchema.optional(),
+  theme: rootThemeSchema.optional(),
+  fonts: fontConfigSchema.optional(),
+  media: mediaConfigSchema.optional(),
+  og: ogIndexMetadataSchema.optional(),
+  meta: z4.record(z4.unknown()).optional(),
+  outputs: outputsSchema.optional(),
+  outputDefaults: outputDefaultsSchema.optional(),
+  groups: z4.record(groupConfigDocumentSchema).default({})
+}).strict();
+
+// src/lib/compiler/source/diagnostics/json-source-location.ts
+import ts from "typescript";
+function atOffset(raw, offset, length) {
+  let before = raw.slice(0, offset), line = before.split(/\r?\n/).length, lineStart = Math.max(before.lastIndexOf(`
+`) + 1, 0);
+  return {
+    line,
+    column: offset - lineStart + 1,
+    sourceLine: raw.split(/\r?\n/)[line - 1] ?? "",
+    length: Math.max(1, length)
+  };
+}
+function invalidJsonLocation(raw, error) {
+  let diagnostic = ts.parseJsonText("config.json", raw).parseDiagnostics?.[0];
+  if (diagnostic?.start !== void 0)
+    return atOffset(raw, diagnostic.start, diagnostic.length ?? 1);
+  let message = error instanceof Error ? error.message : "", position = /\bposition (\d+)\b/.exec(message)?.[1];
+  if (position !== void 0) {
+    let offset = Number(position), trailingComma = /,\s*$/.exec(raw.slice(0, offset));
+    return atOffset(
+      raw,
+      trailingComma ? offset - trailingComma[0].length : offset,
+      1
+    );
+  }
+}
+function jsonValueLocation(raw, path) {
+  let source = ts.parseJsonText("config.json", raw), statement = source.statements[0];
+  if (!statement || !ts.isExpressionStatement(statement)) return;
+  let current = statement.expression;
+  for (let part of path) {
+    if (typeof part == "number") {
+      if (!ts.isArrayLiteralExpression(current)) return;
+      let child = current.elements[part];
+      if (!child || !ts.isExpression(child)) return;
+      current = child;
+      continue;
+    }
+    if (!ts.isObjectLiteralExpression(current)) return;
+    let property = current.properties.find(
+      (candidate) => ts.isPropertyAssignment(candidate) && (ts.isStringLiteral(candidate.name) || ts.isIdentifier(candidate.name)) && candidate.name.text === part
+    );
+    if (!property || !ts.isPropertyAssignment(property)) return;
+    current = property.initializer;
+  }
+  return atOffset(raw, current.getStart(source), current.getWidth(source));
+}
+
+// src/lib/compiler/source/config/load-publish-os-config.ts
+function parseRootConfig(parsed, raw) {
+  if (parsed && typeof parsed == "object" && "icons" in parsed)
+    throw new AppError2({
+      code: ERROR_CODES.CONFIG_SCHEMA_INVALID,
+      message: 'The "icons" configuration was removed. PublishOS now uses Phosphor icons by default.',
+      details: {
+        file: "publish.os.config.json",
+        ...jsonValueLocation(raw, ["icons"]),
+        propertyPath: "icons",
+        correction: 'Remove "icons" from publish.os.config.json and import icons from "@phosphor-icons/react/ssr".'
+      }
+    });
+  let result = publishOsConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    let path = result.error.issues[0]?.path.filter(
+      (part) => typeof part == "string" || typeof part == "number"
+    ) ?? [];
+    throw new AppError2({
+      code: ERROR_CODES.CONFIG_SCHEMA_INVALID,
+      message: `publish.os.config.json failed schema validation
+${formatConfigIssues(result.error)}`,
+      details: {
+        file: "publish.os.config.json",
+        ...jsonValueLocation(raw, path),
+        propertyPath: path.length > 0 ? path.join(".") : "publish.os.config.json",
+        correction: "Correct the reported config property and save again.",
+        issues: result.error.format()
+      }
+    });
+  }
+  return result.data;
+}
+async function loadPublishOsConfig(baseDir) {
+  let path = resolve(baseDir, "publish.os.config.json"), raw;
+  try {
+    raw = await readFile(path, "utf-8");
+  } catch (error) {
+    throw typeof error == "object" && error !== null && "code" in error && error.code === "ENOENT" ? new AppError2({
+      code: ERROR_CODES.CONFIG_NOT_FOUND,
+      message: "publish.os.config.json is required",
+      details: { path }
+    }) : error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    let location = invalidJsonLocation(raw, error);
+    throw new AppError2({
+      code: ERROR_CODES.CONFIG_INVALID_JSON,
+      message: "Invalid JSON in publish.os.config.json.",
+      details: {
+        file: "publish.os.config.json",
+        ...location,
+        correction: /,\s*[}\]]/.test(raw) ? "Remove the trailing comma and save again." : "Correct the JSON syntax and save again."
+      }
+    });
+  }
+  return parseRootConfig(parsed, raw);
+}
+
+// src/lib/compiler/source/config/normalize-publish-os-config.ts
+import { readdir, readFile as readFile2, stat } from "fs/promises";
+import { join, relative, resolve as resolve2 } from "path";
+async function pathIsDirectory(absolutePath) {
+  return await stat(absolutePath).then((info) => info.isDirectory()).catch(() => !1);
+}
+async function pathIsFile(absolutePath) {
+  return await stat(absolutePath).then((info) => info.isFile()).catch(() => !1);
+}
+async function ensureDirectoryExists(absolutePath, groupKey, label) {
+  try {
+    if (!(await stat(absolutePath)).isDirectory())
+      throw new AppError2({
+        code: ERROR_CODES.CONFIG_CONTENT_NOT_DIRECTORY,
+        message: `Group ${groupKey} ${label} must be a directory`,
+        details: { path: absolutePath }
+      });
+  } catch (error) {
+    throw error instanceof AppError2 ? error : new AppError2({
+      code: ERROR_CODES.CONFIG_CONTENT_MISSING,
+      message: `Group ${groupKey} ${label} does not exist`,
+      details: { error, path: absolutePath }
+    });
+  }
+}
+async function readGroupConfigFile(filePath, groupKey, sourceRoot) {
+  if (!await pathIsFile(filePath)) return;
+  let raw = await readFile2(filePath, "utf-8"), parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    let location = invalidJsonLocation(raw, error);
+    throw new AppError2({
+      code: ERROR_CODES.CONFIG_MOUNT_INVALID_JSON,
+      message: `Invalid JSON in group config for ${groupKey}.`,
+      details: {
+        file: relative(sourceRoot, filePath).replace(/\\/g, "/"),
+        ...location,
+        correction: /,\s*[}\]]/.test(raw) ? "Remove the trailing comma and save again." : "Correct the JSON syntax and save again."
+      }
+    });
+  }
+  let result = groupConfigDocumentSchema.safeParse(parsed);
+  if (!result.success) {
+    let path = result.error.issues[0]?.path.filter(
+      (part) => typeof part == "string" || typeof part == "number"
+    ) ?? [];
+    throw new AppError2({
+      code: ERROR_CODES.CONFIG_GROUP_INVALID_SCHEMA,
+      message: `Group config ${filePath} failed schema validation
+${formatConfigIssues(result.error)}`,
+      details: {
+        file: relative(sourceRoot, filePath).replace(/\\/g, "/"),
+        ...jsonValueLocation(raw, path),
+        propertyPath: path.length > 0 ? path.join(".") : `groups.${groupKey}`,
+        correction: "Correct the reported group config property and save again.",
+        issues: result.error.format()
+      }
+    });
+  }
+  return result.data;
+}
+function normalizeGroupSlug(value, groupKey) {
+  let result = normalizeSlugPath(value, {
+    allowEmpty: groupKey === ROOT_CONTENT_GROUP_KEY
+  });
+  if (result.errors.length > 0)
+    throw new AppError2({
+      code: ERROR_CODES.CONFIG_GROUP_INVALID_SCHEMA,
+      message: `Invalid group slug "${value}" for ${groupKey}`,
+      details: { errors: result.errors, group: groupKey, slug: value }
+    });
+  return result.value;
+}
+function normalizeGroupPath(value, groupKey) {
+  let result = normalizeUrlPath(value, { allowEmpty: !0 });
+  if (result.errors.length > 0 || isFrameworkNamespacePath(result.value))
+    throw new AppError2({
+      code: ERROR_CODES.CONFIG_GROUP_INVALID_SCHEMA,
+      message: isFrameworkNamespacePath(result.value) ? `Group path "${value}" is reserved for framework services` : `Invalid group path "${value}" for ${groupKey}`,
+      details: { errors: result.errors, group: groupKey, path: value }
+    });
+  return result.value;
+}
+function mergeGroupConfig(rootConfig, localConfig) {
+  let root = rootConfig ?? {};
+  return {
+    ...root,
+    ...localConfig,
+    meta: {
+      ...root.meta ?? {},
+      ...localConfig?.meta ?? {}
+    },
+    theme: {
+      ...root.theme ?? {},
+      ...localConfig?.theme ?? {}
+    },
+    fonts: {
+      ...root.fonts ?? {},
+      ...localConfig?.fonts ?? {}
+    },
+    outputs: {
+      ...root.outputs ?? {},
+      ...localConfig?.outputs ?? {}
+    },
+    outputDefaults: {
+      ...root.outputDefaults ?? {},
+      ...localConfig?.outputDefaults ?? {},
+      feeds: {
+        ...root.outputDefaults?.feeds ?? {},
+        ...localConfig?.outputDefaults?.feeds ?? {}
+      },
+      llms: {
+        ...root.outputDefaults?.llms ?? {},
+        ...localConfig?.outputDefaults?.llms ?? {}
+      }
+    }
+  };
+}
+var RESERVED_ROUTE_CLASS_FOLDERS = /* @__PURE__ */ new Set(["(index)", "(page)"]);
+function stripGroupFolderParens(folderName) {
+  return folderName.length > 2 && folderName.startsWith("(") && folderName.endsWith(")") ? {
+    name: folderName.slice(1, -1),
+    layoutBoundary: !0
+  } : { name: folderName, layoutBoundary: !1 };
+}
+function normalizeGroupFolderName(folderName) {
+  let stripped = stripGroupFolderParens(folderName);
+  return {
+    localKey: normalizeGroupSlug(stripped.name, stripped.name),
+    layoutBoundary: stripped.layoutBoundary
+  };
+}
+async function contentFolderHasMdx(contentPath, sourceRoot) {
+  let entries = await readdir(contentPath, { withFileTypes: !0 }).catch(
+    () => []
+  );
+  for (let entry of entries) {
+    let childPath = join(contentPath, entry.name);
+    if (!isExcludedSourcePath(relative(sourceRoot, childPath))) {
+      if (entry.isDirectory()) {
+        if (await contentFolderHasMdx(childPath, sourceRoot)) return !0;
+        continue;
+      }
+      if (entry.isFile() && entry.name.toLowerCase().endsWith(".mdx"))
+        return !0;
+    }
+  }
+  return !1;
+}
+async function isDiscoverableGroupFolder(folderPath, sourceRoot) {
+  if (await pathIsFile(join(folderPath, "index.tsx")) || await pathIsFile(join(folderPath, "(index)", "index.tsx")))
+    return !0;
+  let contentPath = join(folderPath, "content");
+  return await pathIsDirectory(contentPath) ? await contentFolderHasMdx(contentPath, sourceRoot) : !1;
+}
+async function discoverGroups(options) {
+  let entries = (await readdir(options.folderPath, { withFileTypes: !0 }).catch(() => [])).filter((entry) => entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name)), siblingKeys = /* @__PURE__ */ new Map(), groups = [];
+  for (let entry of entries) {
+    if (RESERVED_ROUTE_CLASS_FOLDERS.has(entry.name)) continue;
+    let folderPath = join(options.folderPath, entry.name);
+    if (isExcludedSourcePath(relative(options.absoluteBase, folderPath)))
+      continue;
+    let normalized = normalizeGroupFolderName(entry.name);
+    if (!normalized.localKey) continue;
+    let existing = siblingKeys.get(normalized.localKey);
+    if (existing)
+      throw new AppError2({
+        code: ERROR_CODES.CONFIG_GROUP_INVALID_SCHEMA,
+        message: `Duplicate group key "${normalized.localKey}" for sibling folders ${existing} and ${entry.name}`,
+        details: {
+          group: normalized.localKey,
+          folders: [existing, entry.name],
+          parent: options.parentKey
+        }
+      });
+    if (siblingKeys.set(normalized.localKey, entry.name), !await isDiscoverableGroupFolder(folderPath, options.absoluteBase))
+      continue;
+    let key = options.parentKey ? `${options.parentKey}/${normalized.localKey}` : normalized.localKey, group = {
+      key,
+      localKey: normalized.localKey,
+      localFolderName: entry.name,
+      folderPath,
+      parentKey: options.parentKey,
+      layoutBoundary: normalized.layoutBoundary,
+      hasContent: await pathIsDirectory(join(folderPath, "content"))
+    };
+    groups.push(group), groups.push(
+      ...await discoverGroups({
+        absoluteBase: options.absoluteBase,
+        folderPath,
+        parentKey: key
+      })
+    );
+  }
+  return groups;
+}
+function orderDiscoveredGroups(groups, rootGroups) {
+  let rootOrder = new Map(
+    Object.keys(rootGroups).map((key, index) => [key, index])
+  ), fallbackRank = rootOrder.size;
+  function rootKey(group) {
+    return group.key.split("/")[0] ?? group.key;
+  }
+  function rootRank(group) {
+    return rootOrder.get(rootKey(group)) ?? fallbackRank;
+  }
+  function isAncestor(left, right) {
+    return right.key.startsWith(`${left.key}/`);
+  }
+  return [...groups].sort((left, right) => {
+    let rankDelta = rootRank(left) - rootRank(right);
+    return rankDelta !== 0 ? rankDelta : isAncestor(left, right) ? -1 : isAncestor(right, left) ? 1 : left.key.localeCompare(right.key);
+  });
+}
+function expectedGroupConfigFilename(group) {
+  return `${group.localKey}.config.json`;
+}
+async function assertValidGroupConfigFilenames(group) {
+  let expected = expectedGroupConfigFilename(group), entries = await readdir(group.folderPath, {
+    withFileTypes: !0
+  }).catch(() => []);
+  for (let entry of entries)
+    if (!(!entry.isFile() || !entry.name.endsWith(".config.json")) && entry.name !== expected)
+      throw new AppError2({
+        code: ERROR_CODES.CONFIG_GROUP_INVALID_SCHEMA,
+        message: `Group ${group.key} must use ${expected}; ${entry.name} is not supported`,
+        details: {
+          group: group.key,
+          expected,
+          path: join(group.folderPath, entry.name)
+        }
+      });
+}
+function assertValidRootGroupConfigKeys(groups) {
+  for (let key of Object.keys(groups)) {
+    if (key === ROOT_CONTENT_GROUP_KEY)
+      throw new AppError2({
+        code: ERROR_CODES.CONFIG_GROUP_INVALID_SCHEMA,
+        message: `Root group config key "${key}" is reserved for PublishOS root content`,
+        details: { group: key }
+      });
+    if (!(!key.includes("(") && !key.includes(")")))
+      throw new AppError2({
+        code: ERROR_CODES.CONFIG_GROUP_INVALID_SCHEMA,
+        message: `Root group config key "${key}" must use the normalized group key without parentheses`,
+        details: { group: key }
+      });
+  }
+}
+function rootContentGroup(absoluteBase, rootFilePath) {
+  let contentPath = join(absoluteBase, "content");
+  return {
+    key: ROOT_CONTENT_GROUP_KEY,
+    title: ROOT_CONTENT_GROUP_TITLE,
+    slug: "",
+    path: "/",
+    contentPath,
+    folderPath: absoluteBase,
+    localFolderName: "",
+    layoutBoundary: !1,
+    ancestry: [ROOT_CONTENT_GROUP_KEY],
+    __meta: {
+      filePath: rootFilePath,
+      source: "root",
+      basePath: absoluteBase,
+      folderPath: absoluteBase,
+      localFolderName: "",
+      relativeFolderPath: "",
+      contentPath,
+      relativeContentPath: "content",
+      files: {}
+    }
+  };
+}
+async function collectGroup(options) {
+  let {
+    absoluteBase,
+    discovered,
+    parentPath,
+    entry,
+    rootFilePath,
+    groups,
+    paths
+  } = options, { key, localKey, folderPath, parentKey } = discovered;
+  await ensureDirectoryExists(folderPath, key, "folder"), await assertValidGroupConfigFilenames(discovered);
+  let localConfigPath = join(
+    folderPath,
+    expectedGroupConfigFilename(discovered)
+  ), localConfig = await readGroupConfigFile(
+    localConfigPath,
+    key,
+    absoluteBase
+  ), merged = mergeGroupConfig(entry, localConfig), slug = normalizeGroupSlug(merged.slug ?? localKey, key), path = merged.path ? normalizeGroupPath(merged.path, key) : joinUrlPath(parentPath, slug), contentPath = join(folderPath, "content");
+  discovered.hasContent && await ensureDirectoryExists(contentPath, key, "content folder");
+  let existingPathOwner = paths.get(path);
+  if (existingPathOwner && !(path === "/" && existingPathOwner === ROOT_CONTENT_GROUP_KEY))
+    throw new AppError2({
+      code: ERROR_CODES.CONFIG_GROUP_INVALID_SCHEMA,
+      message: `Duplicate group path "${path}" for ${key} and ${existingPathOwner}`,
+      details: { path, group: key, existingGroup: existingPathOwner }
+    });
+  paths.set(path, key), groups[key] = {
+    ...merged,
+    key,
+    slug,
+    path,
+    contentPath,
+    folderPath,
+    localFolderName: discovered.localFolderName,
+    layoutBoundary: discovered.layoutBoundary,
+    parentKey,
+    ancestry: parentKey ? [...groups[parentKey]?.ancestry ?? [], key] : [key],
+    __meta: {
+      filePath: localConfig ? localConfigPath : rootFilePath,
+      source: localConfig ? "group" : "root",
+      basePath: absoluteBase,
+      folderPath,
+      localFolderName: discovered.localFolderName,
+      relativeFolderPath: relative(absoluteBase, folderPath),
+      contentPath,
+      relativeContentPath: relative(absoluteBase, contentPath),
+      files: {}
+    }
+  };
+}
+async function normalizeConfig(config, baseDir) {
+  let absoluteBase = resolve2(baseDir), rootFilePath = resolve2(absoluteBase, "publish.os.config.json"), groups = {}, paths = /* @__PURE__ */ new Map();
+  assertValidRootGroupConfigKeys(config.groups);
+  let discoveredGroups = orderDiscoveredGroups(
+    await discoverGroups({
+      absoluteBase,
+      folderPath: absoluteBase
+    }),
+    config.groups
+  );
+  await contentFolderHasMdx(join(absoluteBase, "content"), absoluteBase) && (groups[ROOT_CONTENT_GROUP_KEY] = rootContentGroup(
+    absoluteBase,
+    rootFilePath
+  ), paths.set("/", ROOT_CONTENT_GROUP_KEY));
+  let discoveredKeys = new Set(discoveredGroups.map((group) => group.key));
+  for (let key of Object.keys(config.groups))
+    if (!discoveredKeys.has(key))
+      throw new AppError2({
+        code: ERROR_CODES.CONFIG_GROUP_INVALID_SCHEMA,
+        message: `Root group config "${key}" does not match a discovered group`,
+        details: { group: key }
+      });
+  for (let discovered of discoveredGroups) {
+    let parentPath = discovered.parentKey ? groups[discovered.parentKey]?.path ?? "/" : "/";
+    await collectGroup({
+      absoluteBase,
+      discovered,
+      parentPath,
+      entry: config.groups[discovered.key],
+      rootFilePath,
+      groups,
+      paths
+    });
+  }
+  return {
+    ...config,
+    groups
+  };
+}
+
+// src/lib/compiler/source/config/resolve-publish-os-config.ts
+async function resolvePublishOsConfig(baseDir) {
+  let config = await loadPublishOsConfig(baseDir), absoluteBase = resolve3(baseDir);
+  return await normalizeConfig(config, absoluteBase);
+}
+
+// src/lib/compiler/source/content/scan-publish-os-content.ts
+import { readdir as readdir2, readFile as readFile3, stat as stat2 } from "fs/promises";
+import { extname, join as join2, relative as relative2 } from "path";
+import matter from "gray-matter";
+var RESERVED_FIELDS = /* @__PURE__ */ new Set([
+  "title",
+  "slug",
+  "description",
+  "og",
+  "status",
+  "publishedAt",
+  "updatedAt",
+  "authors",
+  "tags"
+]), UNSUPPORTED_FIELDS = /* @__PURE__ */ new Set(["author", "meta", "metadata"]);
+function fileSlug(relativePath) {
+  return relativePath.replace(/\\/g, "/").replace(/\.mdx$/i, "");
+}
+function asString(value) {
+  return typeof value == "string" && value.length > 0 ? value : void 0;
+}
+function normalizeContentSlug(value, absolutePath) {
+  let result = normalizeSlugPath(value);
+  if (result.errors.length > 0)
+    throw new AppError2({
+      code: ERROR_CODES.CONTENT_SLUG_INVALID,
+      message: `Invalid content slug "${value}" for ${absolutePath}`,
+      details: {
+        errors: result.errors,
+        path: absolutePath,
+        slug: value
+      }
+    });
+  return result.value;
+}
+function asDateString(value) {
+  if (typeof value == "string" && value.length > 0) return value;
+  if (value instanceof Date && !Number.isNaN(value.getTime()))
+    return value.toISOString().slice(0, 10);
+}
+function isIsoDate(value) {
+  return !Number.isNaN(Date.parse(value));
+}
+function warning(code, message, details) {
+  return { code, level: "warning", message, details };
+}
+function treeSlugs(nodes) {
+  function visit(tree) {
+    let slugs = /* @__PURE__ */ new Map();
+    for (let node of tree)
+      if (node.type === "page" && (slugs.has(node.file) || slugs.set(node.file, asString(node.slug))), "children" in node && node.children)
+        for (let [fileID, slug] of visit(node.children))
+          slug && !slugs.has(fileID) && slugs.set(fileID, slug);
+    return slugs;
+  }
+  return visit(nodes ?? []);
+}
+function normalizeAuthorship(authors, absolutePath) {
+  let warnings = [];
+  if (authors === void 0)
+    return { authors: [], warnings };
+  if (!Array.isArray(authors))
+    return warnings.push(
+      warning(
+        "CONTENT_AUTHORS_INVALID",
+        `Ignoring invalid authors for ${absolutePath}`,
+        {
+          path: absolutePath
+        }
+      )
+    ), { authors: [], warnings };
+  let normalized = [];
+  for (let author of authors) {
+    if (typeof author == "string" && author.length > 0) {
+      normalized.push({ name: author });
+      continue;
+    }
+    if (author && typeof author == "object" && typeof author.name == "string") {
+      let value = author;
+      normalized.push({
+        id: asString(value.id),
+        name: value.name,
+        handle: asString(value.handle),
+        avatar: asString(value.avatar),
+        url: asString(value.url)
+      });
+      continue;
+    }
+    warnings.push(
+      warning(
+        "CONTENT_AUTHOR_INVALID",
+        `Ignoring invalid author entry for ${absolutePath}`,
+        {
+          path: absolutePath
+        }
+      )
+    );
+  }
+  return { authors: normalized, warnings };
+}
+function normalizeTags(tags, absolutePath) {
+  return tags === void 0 ? { tags: [], warnings: [] } : Array.isArray(tags) ? {
+    tags: tags.filter((tag) => typeof tag == "string"),
+    warnings: []
+  } : {
+    tags: [],
+    warnings: [
+      warning(
+        "CONTENT_TAGS_INVALID",
+        `Ignoring invalid tags for ${absolutePath}`,
+        {
+          path: absolutePath
+        }
+      )
+    ]
+  };
+}
+function normalizeOgMetadata(value, absolutePath) {
+  if (value === void 0) return;
+  if (!value || typeof value != "object" || Array.isArray(value))
+    throw new AppError2({
+      code: "CONTENT_FRONTMATTER_OG_INVALID",
+      message: `Invalid og frontmatter for ${absolutePath}; expected an object with title, description, or image`,
+      details: { path: absolutePath, field: "og" }
+    });
+  let source = value, allowedFields = /* @__PURE__ */ new Set(["title", "description", "image"]);
+  for (let field of Object.keys(source))
+    if (!allowedFields.has(field))
+      throw new AppError2({
+        code: "CONTENT_FRONTMATTER_OG_INVALID",
+        message: `Invalid og frontmatter field "${field}" for ${absolutePath}`,
+        details: { path: absolutePath, field: `og.${field}` }
+      });
+  let og = {};
+  if (source.title !== void 0) {
+    if (typeof source.title != "string" || source.title.length === 0)
+      throw new AppError2({
+        code: "CONTENT_FRONTMATTER_OG_INVALID",
+        message: `Invalid og.title for ${absolutePath}; expected a non-empty string`,
+        details: { path: absolutePath, field: "og.title" }
+      });
+    og.title = source.title;
+  }
+  if (source.description !== void 0) {
+    if (typeof source.description != "string" || source.description.length === 0)
+      throw new AppError2({
+        code: "CONTENT_FRONTMATTER_OG_INVALID",
+        message: `Invalid og.description for ${absolutePath}; expected a non-empty string`,
+        details: { path: absolutePath, field: "og.description" }
+      });
+    og.description = source.description;
+  }
+  if (source.image !== void 0)
+    if (typeof source.image == "string" && source.image.length > 0)
+      og.image = source.image;
+    else if (source.image && typeof source.image == "object" && !Array.isArray(source.image)) {
+      let image = source.image, allowedImageFields = /* @__PURE__ */ new Set(["src", "alt"]);
+      for (let field of Object.keys(image))
+        if (!allowedImageFields.has(field))
+          throw new AppError2({
+            code: "CONTENT_FRONTMATTER_OG_INVALID",
+            message: `Invalid og.image field "${field}" for ${absolutePath}`,
+            details: { path: absolutePath, field: `og.image.${field}` }
+          });
+      if (typeof image.src != "string" || image.src.length === 0)
+        throw new AppError2({
+          code: "CONTENT_FRONTMATTER_OG_INVALID",
+          message: `Invalid og.image.src for ${absolutePath}; expected a non-empty string`,
+          details: { path: absolutePath, field: "og.image.src" }
+        });
+      if (image.alt !== void 0 && typeof image.alt != "string")
+        throw new AppError2({
+          code: "CONTENT_FRONTMATTER_OG_INVALID",
+          message: `Invalid og.image.alt for ${absolutePath}; expected a string`,
+          details: { path: absolutePath, field: "og.image.alt" }
+        });
+      og.image = {
+        src: image.src,
+        ...typeof image.alt == "string" ? { alt: image.alt } : {}
+      };
+    } else
+      throw new AppError2({
+        code: "CONTENT_FRONTMATTER_OG_INVALID",
+        message: `Invalid og.image for ${absolutePath}; expected a non-empty string or object with src`,
+        details: { path: absolutePath, field: "og.image" }
+      });
+  return Object.keys(og).length > 0 ? og : void 0;
+}
+function customMeta(frontmatter, absolutePath) {
+  let meta = {}, warnings = [];
+  for (let [key, value] of Object.entries(frontmatter))
+    if (!RESERVED_FIELDS.has(key)) {
+      if (UNSUPPORTED_FIELDS.has(key)) {
+        warnings.push(
+          warning(
+            "CONTENT_FRONTMATTER_FIELD_UNSUPPORTED",
+            `Ignoring unsupported frontmatter field "${key}" for ${absolutePath}`,
+            { path: absolutePath, field: key }
+          )
+        );
+        continue;
+      }
+      meta[key] = value;
+    }
+  return { meta, warnings };
+}
+async function readContentFile(group, absolutePath, configSlugs) {
+  let raw = await readFile3(absolutePath, "utf-8");
+  try {
+    let parsed = matter(raw), frontmatter = parsed.data, relativePath = relative2(group.contentPath, absolutePath), fileID = normalizeContentSlug(fileSlug(relativePath), absolutePath), title = asString(frontmatter.title);
+    if (frontmatter.id !== void 0)
+      throw new AppError2({
+        code: ERROR_CODES.CONTENT_FRONTMATTER_ID_INVALID,
+        message: `Frontmatter field "id" is not supported for ${absolutePath}; page identity is derived from fileID`,
+        details: { path: absolutePath, field: "id" }
+      });
+    if (!fileID)
+      throw new AppError2({
+        code: ERROR_CODES.CONTENT_FRONTMATTER_ID_INVALID,
+        message: `Could not derive fileID for ${absolutePath}`,
+        details: { path: absolutePath }
+      });
+    if (!title)
+      throw new AppError2({
+        code: ERROR_CODES.CONTENT_FRONTMATTER_REQUIRED,
+        message: `Missing required frontmatter field "title" for ${absolutePath}`,
+        details: { path: absolutePath, field: "title" }
+      });
+    let warnings = [], frontmatterSlug = asString(frontmatter.slug), slugSource = configSlugs.get(fileID) ?? frontmatterSlug ?? fileID, slugResult = normalizeSlugPath(slugSource);
+    if (slugResult.errors.length > 0)
+      throw new AppError2({
+        code: ERROR_CODES.CONTENT_SLUG_INVALID,
+        message: `Invalid content slug "${slugSource}" for ${absolutePath}`,
+        details: {
+          errors: slugResult.errors,
+          path: absolutePath,
+          slug: slugSource
+        }
+      });
+    let slug = slugResult.value;
+    slugResult.changed && warnings.push(
+      warning(
+        "CONTENT_SLUG_NORMALIZED",
+        `Normalized slug "${slugSource}" to "${slug}" for ${absolutePath}`,
+        { path: absolutePath, from: slugSource, to: slug }
+      )
+    );
+    let status = "published";
+    frontmatter.status === "published" || frontmatter.status === "draft" || frontmatter.status === "archived" ? status = frontmatter.status : frontmatter.status !== void 0 && warnings.push(
+      warning(
+        "CONTENT_STATUS_INVALID",
+        `Invalid status "${String(frontmatter.status)}" for ${absolutePath}; defaulting to published`,
+        { path: absolutePath, status: frontmatter.status }
+      )
+    );
+    let rawPublishedAt = asDateString(frontmatter.publishedAt), publishedAt = rawPublishedAt && isIsoDate(rawPublishedAt) ? rawPublishedAt : void 0;
+    rawPublishedAt && !publishedAt && warnings.push(
+      warning(
+        "CONTENT_DATE_INVALID",
+        `Invalid publishedAt for ${absolutePath}`,
+        {
+          path: absolutePath,
+          field: "publishedAt",
+          value: rawPublishedAt
+        }
+      )
+    );
+    let rawUpdatedAt = asDateString(frontmatter.updatedAt), updatedAt = rawUpdatedAt && isIsoDate(rawUpdatedAt) ? rawUpdatedAt : void 0;
+    rawUpdatedAt && !updatedAt && warnings.push(
+      warning(
+        "CONTENT_DATE_INVALID",
+        `Invalid updatedAt for ${absolutePath}`,
+        {
+          path: absolutePath,
+          field: "updatedAt",
+          value: rawUpdatedAt
+        }
+      )
+    );
+    let authors = normalizeAuthorship(frontmatter.authors, absolutePath);
+    warnings.push(...authors.warnings);
+    let tags = normalizeTags(frontmatter.tags, absolutePath);
+    warnings.push(...tags.warnings);
+    let og = normalizeOgMetadata(frontmatter.og, absolutePath), meta = customMeta(frontmatter, absolutePath);
+    return warnings.push(...meta.warnings), {
+      fileID,
+      group: group.key,
+      slug,
+      title,
+      description: asString(frontmatter.description),
+      og,
+      status,
+      publishedAt,
+      updatedAt,
+      authors: authors.authors,
+      tags: tags.tags,
+      meta: meta.meta,
+      absolutePath,
+      relativePath,
+      body: parsed.content.trim(),
+      warnings
+    };
+  } catch (error) {
+    throw error instanceof AppError2 ? error : new AppError2({
+      code: ERROR_CODES.CONTENT_FILE_PARSE_FAILED,
+      message: `Failed to parse frontmatter for ${absolutePath}`,
+      details: { error }
+    });
+  }
+}
+async function walkContent(group) {
+  let files = [], stack = [group.contentPath], configSlugs = treeSlugs(group.tree);
+  for (; stack.length > 0; ) {
+    let current = stack.pop();
+    if (!current) continue;
+    let entries = await readdir2(current).catch(
+      (error) => {
+        if (error.code === "ENOENT") return [];
+        throw error;
+      }
+    );
+    for (let entry of entries) {
+      let absolute = join2(current, entry);
+      if (isExcludedSourcePath(relative2(group.__meta.basePath, absolute)))
+        continue;
+      if ((await stat2(absolute)).isDirectory()) {
+        stack.push(absolute);
+        continue;
+      }
+      extname(entry).toLowerCase() === ".mdx" && files.push(await readContentFile(group, absolute, configSlugs));
+    }
+  }
+  return files;
+}
+function buildRoutes(groups, files) {
+  let routes = [];
+  for (let file of files) {
+    if (file.status === "draft")
+      continue;
+    let group = groups[file.group];
+    if (!group)
+      continue;
+    let path = `${group.path.replace(/\/$/, "")}/${file.slug}`.replace(/\/+/g, "/");
+    routes.push({
+      fileID: file.fileID,
+      slug: file.slug,
+      path: path === "" ? "/" : path,
+      group: file.group
+    });
+  }
+  return routes;
+}
+async function scanContent(config) {
+  let files = (await Promise.all(
+    Object.values(config.groups).map((group) => walkContent(group))
+  )).flat(), warnings = files.flatMap((file) => file.warnings), fileIDs = /* @__PURE__ */ new Set();
+  for (let file of files) {
+    let scopedFileID = `${file.group}:${file.fileID}`;
+    if (fileIDs.has(scopedFileID))
+      throw new AppError2({
+        code: ERROR_CODES.CONTENT_DUPLICATE_ID,
+        message: `Duplicate content fileID "${file.fileID}" in group ${file.group}`,
+        details: { fileID: file.fileID, group: file.group }
+      });
+    fileIDs.add(scopedFileID);
+  }
+  let routes = buildRoutes(config.groups, files), routePaths = /* @__PURE__ */ new Set(), groupPaths = new Map(
+    Object.values(config.groups).map((group) => [group.path, group.key])
+  );
+  for (let route of routes) {
+    if (routePaths.has(route.path))
+      throw new AppError2({
+        code: ERROR_CODES.CONTENT_DUPLICATE_ROUTE,
+        message: `Duplicate route "${route.path}"`,
+        details: { route: route.path }
+      });
+    let groupPathOwner = groupPaths.get(route.path);
+    if (groupPathOwner)
+      throw new AppError2({
+        code: ERROR_CODES.CONTENT_DUPLICATE_ROUTE,
+        message: `Content route "${route.path}" collides with group "${groupPathOwner}"`,
+        details: {
+          route: route.path,
+          group: route.group,
+          fileID: route.fileID,
+          existingGroup: groupPathOwner
+        }
+      });
+    routePaths.add(route.path);
+  }
+  let meta = config.meta;
+  return {
+    site: {
+      name: config.site?.name ?? meta?.title ?? "Untitled",
+      description: config.site?.description ?? meta?.description,
+      ...config.og ? { og: config.og } : {}
+    },
+    files,
+    routes,
+    warnings
+  };
+}
+
+// src/lib/compiler/source/diagnostics/map-app-error-to-diagnostic.ts
+function appErrorToDiagnostic(error) {
+  return {
+    code: error.code,
+    level: "error",
+    message: error.message,
+    details: error.details
+  };
+}
+
+// src/lib/compiler/source/diagnostics/missing-page-references.ts
+import { readFile as readFile4 } from "fs/promises";
+import { relative as relative3, resolve as resolve4 } from "path";
+async function missingPageReferences(options) {
+  let diagnostics = [], configSource = /* @__PURE__ */ new Map(), routes = new Set(
+    options.content.routes.map((route) => `${route.group}\0${route.fileID}`)
+  ), rootConfig = resolve4(options.sourceRoot, "publish.os.config.json");
+  async function locationFor(groupKey, groupFile, path) {
+    for (let [file, sourcePath] of [
+      [groupFile, path],
+      [rootConfig, ["groups", groupKey, ...path]]
+    ]) {
+      let raw = configSource.get(file);
+      raw === void 0 && (raw = await readFile4(file, "utf8"), configSource.set(file, raw));
+      let location = jsonValueLocation(raw, sourcePath);
+      if (location)
+        return {
+          file: relative3(options.sourceRoot, file).replace(/\\/g, "/"),
+          ...location
+        };
+    }
+  }
+  for (let group of Object.values(options.config.groups)) {
+    async function visit(nodes, path) {
+      for (let [index, node] of nodes.entries()) {
+        let nodePath = [...path, index];
+        if (node.type === "page" && !routes.has(`${group.key}\0${node.file}`)) {
+          let propertyPath = `groups.${group.key}.${nodePath.join(".")}.file`, location = await locationFor(group.key, group.__meta.filePath, [
+            ...nodePath,
+            "file"
+          ]), expected = `publish.os/${group.__meta.relativeContentPath.replace(/\\/g, "/")}/${node.file}.mdx`;
+          diagnostics.push({
+            code: "CONTENT_TREE_PAGE_MISSING",
+            level: "warning",
+            message: `Referenced page "${node.file}" was not found. Expected ${expected}.`,
+            details: {
+              ...location,
+              propertyPath,
+              correction: "Add that page, or change or remove the tree entry."
+            }
+          });
+        }
+        "children" in node && node.children && await visit(node.children, [...nodePath, "children"]);
+      }
+    }
+    await visit(group.tree ?? [], ["tree"]);
+  }
+  return diagnostics;
+}
+
+// src/lib/compiler/source/manifest/create-publish-os-manifest.ts
+import { createHash } from "crypto";
+function stableStringify(value) {
+  return Array.isArray(value) ? `[${value.map((item) => stableStringify(item)).join(",")}]` : value && typeof value == "object" ? `{${Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(
+    ([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`
+  ).join(",")}}` : JSON.stringify(value);
+}
+function resolveGroupReference(config, currentGroup, reference) {
+  let relativeKey = `${currentGroup}/${reference}`;
+  if (config.groups[relativeKey]) return relativeKey;
+  if (config.groups[reference]) return reference;
+}
+function normalizeTreeNode(node, group, pagesByFileID, routesByFileID, options) {
+  if (node.type === "page") {
+    let page = pagesByFileID.get(node.file), route = routesByFileID.get(node.file);
+    return !page || !route ? null : {
+      type: "page",
+      fileID: node.file,
+      title: node.title ?? page.title,
+      path: route.path,
+      group,
+      description: page.description,
+      og: page.og,
+      status: page.status,
+      publishedAt: page.publishedAt,
+      updatedAt: page.updatedAt,
+      authors: page.authors,
+      tags: page.tags,
+      meta: page.meta
+    };
+  }
+  if (node.type === "link")
+    return {
+      type: "link",
+      id: node.id,
+      title: node.title,
+      href: node.url
+    };
+  let children = node.children?.map(
+    (child) => normalizeTreeNode(child, group, pagesByFileID, routesByFileID, options)
+  ).filter((child) => child !== null) ?? [];
+  if (node.type === "folder") {
+    let referencedGroup = resolveGroupReference(
+      options.config,
+      group,
+      node.group ?? node.id
+    ), referencedChildren = children.length > 0 || !referencedGroup ? children : options.childTreeForGroup(referencedGroup);
+    return {
+      type: "folder",
+      id: node.id,
+      title: node.title,
+      path: referencedGroup ? options.config.groups[referencedGroup]?.path : void 0,
+      group: referencedGroup ?? group,
+      children: referencedChildren
+    };
+  }
+  return {
+    type: node.type,
+    id: node.id,
+    title: node.title,
+    group,
+    children
+  };
+}
+function defaultTree(group, pages, routesByFileID) {
+  return pages.flatMap((page) => {
+    let route = routesByFileID.get(page.fileID);
+    return route ? {
+      type: "page",
+      fileID: page.fileID,
+      title: page.title,
+      path: route.path,
+      group,
+      description: page.description,
+      og: page.og,
+      status: page.status,
+      publishedAt: page.publishedAt,
+      updatedAt: page.updatedAt,
+      authors: page.authors,
+      tags: page.tags,
+      meta: page.meta
+    } : [];
+  }).sort((a, b) => a.path.localeCompare(b.path));
+}
+function configuredPageIds(nodes) {
+  let ids = /* @__PURE__ */ new Set();
+  for (let node of nodes ?? []) {
+    if (node.type === "page") {
+      ids.add(node.file);
+      continue;
+    }
+    if ("children" in node)
+      for (let id of configuredPageIds(node.children))
+        ids.add(id);
+  }
+  return ids;
+}
+function createManifest(config, content) {
+  let routesByGroup = /* @__PURE__ */ new Map();
+  for (let route of content.routes) {
+    let groupRoutes = routesByGroup.get(route.group);
+    groupRoutes || (groupRoutes = /* @__PURE__ */ new Map(), routesByGroup.set(route.group, groupRoutes)), groupRoutes.has(route.fileID) || groupRoutes.set(route.fileID, route);
+  }
+  let pages = [], pagesByGroup = /* @__PURE__ */ new Map(), pagesByFileIDByGroup = /* @__PURE__ */ new Map();
+  for (let file of content.files) {
+    let route = routesByGroup.get(file.group)?.get(file.fileID);
+    if (!route) continue;
+    let page = {
+      fileID: file.fileID,
+      group: file.group,
+      slug: route.slug,
+      path: route.path,
+      title: file.title,
+      description: file.description,
+      og: file.og,
+      status: file.status,
+      publishedAt: file.publishedAt,
+      updatedAt: file.updatedAt,
+      authors: file.authors,
+      tags: file.tags,
+      meta: file.meta,
+      body: file.body
+    };
+    pages.push(page);
+    let groupPages = pagesByGroup.get(page.group);
+    groupPages ? groupPages.push(page) : pagesByGroup.set(page.group, [page]);
+    let pagesByFileID = pagesByFileIDByGroup.get(page.group);
+    pagesByFileID || (pagesByFileID = /* @__PURE__ */ new Map(), pagesByFileIDByGroup.set(page.group, pagesByFileID)), pagesByFileID.has(page.fileID) || pagesByFileID.set(page.fileID, page);
+  }
+  let configuredPageIDsByGroup = /* @__PURE__ */ new Map();
+  for (let group of Object.values(config.groups))
+    configuredPageIDsByGroup.set(
+      group.key,
+      configuredPageIds(group.tree)
+    );
+  let treeCache = /* @__PURE__ */ new Map();
+  function groupTree(groupKey, stack = /* @__PURE__ */ new Set()) {
+    let cached = treeCache.get(groupKey);
+    if (cached) return cached;
+    if (stack.has(groupKey)) return [];
+    let group = config.groups[groupKey];
+    if (!group) return [];
+    stack.add(groupKey);
+    let groupPages = pagesByGroup.get(group.key) ?? [], pagesByFileID = pagesByFileIDByGroup.get(group.key) ?? /* @__PURE__ */ new Map(), routesByFileID = routesByGroup.get(group.key) ?? /* @__PURE__ */ new Map(), configTree = group.tree, configuredPageIDs = configuredPageIDsByGroup.get(group.key), tree2 = configTree ? [
+      ...configTree.map(
+        (node) => normalizeTreeNode(
+          node,
+          group.key,
+          pagesByFileID,
+          routesByFileID,
+          {
+            childTreeForGroup: (childGroup) => groupTree(childGroup, new Set(stack)),
+            config
+          }
+        )
+      ).filter((node) => node !== null),
+      ...defaultTree(
+        group.key,
+        groupPages.filter((page) => !configuredPageIDs?.has(page.fileID)),
+        routesByFileID
+      )
+    ] : defaultTree(group.key, groupPages, routesByFileID);
+    return stack.delete(groupKey), treeCache.set(groupKey, tree2), tree2;
+  }
+  let groups = Object.fromEntries(
+    Object.values(config.groups).map((group) => {
+      let groupPages = pagesByGroup.get(group.key) ?? [], groupData = {
+        key: group.key,
+        title: group.title ?? group.key,
+        path: group.path,
+        origin: group.origin ?? (group.key === ROOT_CONTENT_GROUP_KEY ? void 0 : config.origin),
+        ancestry: group.ancestry,
+        ...group.og ? { og: group.og } : {},
+        meta: group.meta,
+        tree: groupTree(group.key),
+        pages: groupPages
+      };
+      return [group.key, groupData];
+    })
+  ), tree = Object.values(groups).filter((group) => !config.groups[group.key]?.parentKey).flatMap(
+    (group) => group.key === ROOT_CONTENT_GROUP_KEY ? group.tree : [
+      {
+        type: "section",
+        id: group.key,
+        title: group.title,
+        path: group.path,
+        group: group.key,
+        children: group.tree
+      }
+    ]
+  ), manifest = {
+    site: content.site,
+    groups,
+    tree,
+    routes: content.routes,
+    pages,
+    contentHash: ""
+  }, { contentHash: _contentHash, ...hashInput } = manifest, canonical = stableStringify(hashInput), hash = createHash("sha256").update(canonical).digest("hex");
+  return manifest.contentHash = hash.slice(0, 16), manifest;
+}
+
+// src/lib/compiler/source/prepare-publish-os-source.ts
+async function preparePublishOsSource({
+  publishOsDir,
+  sourceIdentity
+}) {
+  try {
+    let sourceRoot = resolve5(publishOsDir), boundary = await assertPublishOsSourceBoundary(
+      sourceRoot,
+      sourceIdentity
+    ), config = await resolvePublishOsConfig(sourceRoot), content = await scanContent(config), media = await buildMediaAssets({
+      config,
+      publishOsDir
+    }), faviconsAndLogos = await buildFaviconsAndLogos({ publishOsDir }), missingPages = await missingPageReferences({
+      sourceRoot,
+      config,
+      content
+    });
+    return {
+      diagnostics: [
+        ...boundary.nestedSources.map((file) => ({
+          code: "SOURCE_NESTED_EXCLUDED",
+          level: "warning",
+          message: "Nested publish.os source is excluded from this site.",
+          details: { file }
+        })),
+        ...content.warnings,
+        ...missingPages,
+        ...media.warnings.map((warning2) => ({
+          ...warning2,
+          level: "warning"
+        })),
+        ...faviconsAndLogos.warnings.map((warning2) => ({
+          ...warning2,
+          level: "warning"
+        }))
+      ],
+      source: {
+        assets: { faviconsAndLogos, media },
+        config,
+        content,
+        manifest: createManifest(config, content)
+      }
+    };
+  } catch (error) {
+    return error instanceof AppError2 || error instanceof AppError ? { diagnostics: [appErrorToDiagnostic(error)] } : {
+      diagnostics: [
+        {
+          code: "SOURCE_PREPARE_UNKNOWN",
+          level: "error",
+          message: String(error)
+        }
+      ]
+    };
+  }
+}
+
+// src/lib/compiler/theme/theme-token-diagnostics.ts
+import { readdirSync, readFileSync } from "fs";
+import { extname as extname2, join as join3, resolve as resolve6 } from "path";
+import postcss from "postcss";
+function cssFiles(directory) {
+  return readdirSync(directory, { withFileTypes: !0 }).flatMap((entry) => {
+    let path = join3(directory, entry.name);
+    return entry.isDirectory() ? cssFiles(path) : extname2(entry.name) === ".css" ? [path] : [];
+  });
+}
+function readDesignTokens() {
+  let { packageRoot } = readInstalledFrameworkLocation(), assets = resolve6(packageRoot, "compiler-assets/nextjs"), tokens = /* @__PURE__ */ new Set();
+  for (let path of cssFiles(assets))
+    postcss.parse(readFileSync(path, "utf-8"), { from: path }).walkDecls((declaration) => {
+      declaration.prop.startsWith("--") && tokens.add(declaration.prop);
+    });
+  return Object.freeze([...tokens].sort());
+}
+var designTokens = readDesignTokens();
+function editDistance(left, right) {
+  let previous = Array.from(
+    { length: right.length + 1 },
+    (_, index) => index
+  );
+  for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+    let current = [leftIndex];
+    for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1)
+      current[rightIndex] = Math.min(
+        (current[rightIndex - 1] ?? 0) + 1,
+        (previous[rightIndex] ?? 0) + 1,
+        (previous[rightIndex - 1] ?? 0) + (left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1)
+      );
+    previous.splice(0, previous.length, ...current);
+  }
+  return previous[right.length] ?? right.length;
+}
+function nearestThemeDesignToken(token) {
+  let nearest, distance = Number.POSITIVE_INFINITY;
+  for (let candidate of designTokens) {
+    let candidateDistance = editDistance(token, candidate);
+    candidateDistance < distance && (nearest = candidate, distance = candidateDistance);
+  }
+  return distance <= 2 ? nearest : void 0;
+}
+
+// src/lib/compiler/validation/validate-publish-os-source.ts
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".mjs",
+  ".cjs"
+]), ATTRIBUTION_VALIDATION_EXTENSIONS = /* @__PURE__ */ new Set([
+  ...SOURCE_EXTENSIONS,
+  ".css"
+]), MARKDOWN_ICON_SCAN_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx"]), FONT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".woff", ".woff2", ".otf", ".ttf"]), FORBIDDEN_ATTRIBUTION_REFERENCES = [
+  "data-publishos-attribution",
+  "publishos-attribution"
+], ALLOWED_BARE_IMPORTS = new Set(supportedNextjsSourceImports()), BLOCKED_ICON_PACKAGE_IMPORTS = /* @__PURE__ */ new Set([
+  "lucide-react",
+  "@phosphor-icons/react",
+  "@tabler/icons-react"
+]), RUNTIME_TYPES_IMPORT = "@publish.os/nextjs/types", LEGACY_TYPES_IMPORT = "@publish.os/types", RUNTIME_TYPE_EXPORTS = /* @__PURE__ */ new Set([
+  "IndexPageProps",
+  "GroupContext",
+  "LayoutProps",
+  "ManifestLike",
+  "NavFolder",
+  "NavItem",
+  "NavLink",
+  "NavPage",
+  "NavSection",
+  "PageData",
+  "PageProps",
+  "RootLayoutProps",
+  "RootPageProps",
+  "SiteData",
+  "TreeNode"
+]), ROUTE_EXECUTION_EXPORTS = [
+  "runtime",
+  "dynamic",
+  "revalidate",
+  "preferredRegion",
+  "maxDuration"
+], LOCKFILES = /* @__PURE__ */ new Set([
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb"
+]);
+function hasInternalSegment(path) {
+  return path.split(/[\\/]/).includes("_internal");
+}
+async function fileExists(path) {
+  return await stat3(path).then((entry) => entry.isFile()).catch(() => !1);
+}
+async function directoryExists(path) {
+  return await stat3(path).then((entry) => entry.isDirectory()).catch(() => !1);
+}
+async function walkAllFiles(dir, prefix = "") {
+  let entries = await readdir3(dir, { withFileTypes: !0 }).catch(() => []), files = [];
+  for (let entry of entries) {
+    let relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (isExcludedSourcePath(relativePath)) continue;
+    let absolutePath = resolve7(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkAllFiles(absolutePath, relativePath));
+      continue;
+    }
+    files.push(relativePath);
+  }
+  return files;
+}
+function normalizeRelativePath(path) {
+  return path.split(sep).join("/");
+}
+function isRecord(value) {
+  return !!(value && typeof value == "object" && !Array.isArray(value));
+}
+function isLocalFontSourcePath(value) {
+  return !/^[a-z][a-z0-9+.-]*:/i.test(value) && !value.startsWith("//");
+}
+function normalizeLocalFontSourcePath(value) {
+  return value.replace(/^\/+/, "").replace(/^\.\//, "");
+}
+function isFontFilePath(path) {
+  return FONT_FILE_EXTENSIONS.has(extname3(path).toLowerCase());
+}
+function isValidSourceFontFilePath(path) {
+  return path.startsWith("fonts/") && isFontFilePath(path);
+}
+function fontConfigHint(path) {
+  return `To use this font, place it under publish.os/fonts and declare it in publish.os.config.json, for example: "fonts": { "main": { "family": "Your Font", "src": "/${path}", "weight": "400" } }.`;
+}
+function collectFontRoleSourcePaths(roleConfig, sourcePaths) {
+  if (!roleConfig || typeof roleConfig == "string" || !isRecord(roleConfig))
+    return;
+  let addSource = (value) => {
+    typeof value != "string" || !isLocalFontSourcePath(value) || sourcePaths.add(normalizeLocalFontSourcePath(value));
+  }, addFile = (value) => {
+    if (!isRecord(value)) return;
+    let path = value.path;
+    typeof path == "string" && sourcePaths.add(normalizeLocalFontSourcePath(path));
+  };
+  if (addSource(roleConfig.src), Array.isArray(roleConfig.src))
+    for (let file of roleConfig.src) addFile(file);
+}
+async function validateConfiguredLocalFontSources({
+  config,
+  publishOsDir
+}) {
+  let sourcePaths = /* @__PURE__ */ new Set(), collect = async (fonts, sourceFile) => {
+    let paths = /* @__PURE__ */ new Set();
+    for (let font of Object.values(fonts ?? {}))
+      collectFontRoleSourcePaths(font, paths);
+    for (let path of paths)
+      await assertSourceDependency({
+        publishOsDir,
+        path: resolve7(publishOsDir, path),
+        sourceFile
+      }), sourcePaths.add(path);
+  };
+  await collect(
+    config.fonts,
+    "publish.os.config.json"
+  );
+  for (let group of Object.values(config.groups))
+    await collect(group.fonts, group.__meta.filePath);
+  return sourcePaths;
+}
+function isHardRejectedPath(path) {
+  let name = basename(path);
+  return isReservedFrameworkPath(path) || path.split("/").some((segment) => ["packages", "scripts"].includes(segment)) || LOCKFILES.has(name) || name === "tsconfig.json" && path !== "tsconfig.json";
+}
+function isAllowedBareImport(specifier) {
+  if (specifier.startsWith("@components/")) {
+    let componentPath = specifier.slice(12), segments = componentPath.split("/");
+    return componentPath.length > 0 && !componentPath.includes("\\") && !componentPath.includes("\0") && segments.every(
+      (segment) => segment !== "" && segment !== "." && segment !== ".."
+    );
+  }
+  return ALLOWED_BARE_IMPORTS.has(specifier);
+}
+function addFileError(store, code, message, file, details = {}) {
+  store.error(code, message, { ...details, file });
+}
+function addFileWarning(store, code, message, file, details = {}) {
+  store.warning(code, message, { ...details, file });
+}
+function validateThemeTokenSpelling(css, file, store) {
+  let seen = /* @__PURE__ */ new Set();
+  for (let match of css.matchAll(/--[a-z0-9-]+/gi)) {
+    let token = match[0].toLowerCase();
+    if (seen.has(token)) continue;
+    seen.add(token);
+    let correction = nearestThemeDesignToken(token);
+    !correction || correction === token || addFileWarning(
+      store,
+      "FRAMEWORK_THEME_TOKEN_SPELLING",
+      `Unknown design token "${token}". Did you mean "${correction}"?`,
+      file,
+      {
+        correction,
+        ...sourceDetails(css, match.index ?? 0, match[0])
+      }
+    );
+  }
+}
+function getSourceLocation(source, index) {
+  let before = source.slice(0, index), line = before.split(`
+`).length, previousLineBreak = before.lastIndexOf(`
+`), nextLineBreak = source.indexOf(`
+`, index), lineStart = previousLineBreak + 1, lineEnd = nextLineBreak === -1 ? source.length : nextLineBreak;
+  return {
+    line,
+    column: index - previousLineBreak,
+    sourceLine: source.slice(lineStart, lineEnd).trimEnd()
+  };
+}
+function sourceDetails(source, index, snippet) {
+  return {
+    ...getSourceLocation(source, index),
+    source: snippet.trim()
+  };
+}
+function validateAttributionReferences(source, file, store) {
+  for (let reference of FORBIDDEN_ATTRIBUTION_REFERENCES) {
+    let index = source.indexOf(reference);
+    index !== -1 && addFileError(
+      store,
+      "FRAMEWORK_ATTRIBUTION_SELECTOR_RESERVED",
+      "Source code cannot target or reference the platform powered-by attribution selectors.",
+      file,
+      {
+        reference,
+        ...sourceDetails(source, index, reference)
+      }
+    );
+  }
+}
+function parseNamedImports(statement) {
+  let imports = /\b(?:import|export)\s+(?:type\s+)?\{([\s\S]*?)\}\s+from\b/.exec(statement)?.[1];
+  return imports ? imports.split(",").map((name) => name.trim().replace(/^type\s+/, "")).filter(Boolean) : [];
+}
+function runtimeTypeName(importedName) {
+  return importedName.split(/\s+as\s+/i)[0]?.trim() ?? importedName;
+}
+function importSuggestion(options) {
+  if (options.specifier !== LEGACY_TYPES_IMPORT) return;
+  let imports = options.statement ? parseNamedImports(options.statement).filter(
+    (name) => RUNTIME_TYPE_EXPORTS.has(runtimeTypeName(name))
+  ) : [];
+  return imports.length > 0 ? `Use: import type { ${imports.join(", ")} } from "${RUNTIME_TYPES_IMPORT}";` : `PublishOS page props and runtime types are exported from "${RUNTIME_TYPES_IMPORT}", not "${LEGACY_TYPES_IMPORT}".`;
+}
+function importDetails(options) {
+  let suggestion = importSuggestion({
+    specifier: options.specifier,
+    statement: options.statement
+  }), source = options.statement?.includes(`
+`) ? options.statement.trim() : options.location?.sourceLine.trim() ?? options.statement?.trim();
+  return {
+    specifier: options.specifier,
+    ...options.location ?? {},
+    ...source ? { source } : {},
+    ...suggestion ? { suggestion } : {},
+    ...options.extras ?? {}
+  };
+}
+function scriptKindForPath(path) {
+  switch (extname3(path).toLowerCase()) {
+    case ".tsx":
+      return ts2.ScriptKind.TSX;
+    case ".jsx":
+      return ts2.ScriptKind.JSX;
+    case ".ts":
+      return ts2.ScriptKind.TS;
+    default:
+      return ts2.ScriptKind.JS;
+  }
+}
+function hasExportModifier(node) {
+  return !!(ts2.canHaveModifiers(node) && ts2.getModifiers(node)?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword));
+}
+function isRouteOverride(file, groupFolders) {
+  if (file.startsWith("components/")) return !1;
+  for (let folder of ["", ...groupFolders]) {
+    let prefix = folder ? `${folder}/` : "";
+    if (file.startsWith(prefix) && /^(?:layout|index|page)\.tsx$|^\(index\)\/(?:layout|index)\.tsx$|^\(page\)\/(?:layout|page)\.tsx$/.test(
+      file.slice(prefix.length)
+    ))
+      return !0;
+  }
+  return !1;
+}
+function hasDefaultExport(sourceFile) {
+  return sourceFile.statements.some((statement) => ts2.isExportAssignment(statement) ? !statement.isExportEquals : ts2.isFunctionDeclaration(statement) || ts2.isClassDeclaration(statement) ? !!statement.modifiers?.some(
+    (modifier) => modifier.kind === ts2.SyntaxKind.DefaultKeyword
+  ) : ts2.isExportDeclaration(statement) && !statement.isTypeOnly && statement.exportClause && ts2.isNamedExports(statement.exportClause) ? statement.exportClause.elements.some(
+    (element) => !element.isTypeOnly && element.name.text === "default"
+  ) : !1);
+}
+function invalidMdxComponentValue(sourceFile, name) {
+  for (let statement of sourceFile.statements)
+    if (!(!ts2.isVariableStatement(statement) || !hasExportModifier(statement)))
+      for (let declaration of statement.declarationList.declarations) {
+        if (!ts2.isIdentifier(declaration.name) || declaration.name.text !== name)
+          continue;
+        let value = declaration.initializer;
+        if (value && !ts2.isArrowFunction(value) && !ts2.isFunctionExpression(value) && !ts2.isCallExpression(value) && !ts2.isIdentifier(value) && !ts2.isPropertyAccessExpression(value) && !ts2.isParenthesizedExpression(value))
+          return value;
+      }
+}
+function addRouteExecutionExportError(options) {
+  let start = options.node.getStart(options.sourceFile);
+  addFileError(
+    options.store,
+    "FRAMEWORK_ROUTE_EXECUTION_EXPORT",
+    `Source modules cannot export Next.js route execution setting '${options.exportName}'.`,
+    options.relativeFile,
+    {
+      exportName: options.exportName,
+      ...sourceDetails(
+        options.source,
+        start,
+        options.node.getText(options.sourceFile)
+      )
+    }
+  );
+}
+function commonJsExportName(node) {
+  if (node.operatorToken.kind !== ts2.SyntaxKind.EqualsToken) return;
+  let left = node.left;
+  if (ts2.isPropertyAccessExpression(left) && (ts2.isIdentifier(left.expression) && left.expression.text === "exports" || ts2.isPropertyAccessExpression(left.expression) && ts2.isIdentifier(left.expression.expression) && left.expression.expression.text === "module" && left.expression.name.text === "exports"))
+    return left.name.text;
+}
+async function validateSourceModule(options) {
+  let sourceFile = ts2.createSourceFile(
+    options.relativeFile,
+    options.source,
+    ts2.ScriptTarget.Latest,
+    !0,
+    scriptKindForPath(options.relativeFile)
+  ), parseDiagnostics = sourceFile.parseDiagnostics;
+  for (let diagnostic of parseDiagnostics ?? []) {
+    let start = diagnostic.start ?? 0;
+    addFileError(
+      options.store,
+      "FRAMEWORK_SOURCE_PARSE_FAILED",
+      `Source module could not be parsed: ${ts2.flattenDiagnosticMessageText(diagnostic.messageText, " ")}`,
+      options.relativeFile,
+      sourceDetails(options.source, start, "")
+    );
+  }
+  !parseDiagnostics?.length && isRouteOverride(options.relativeFile, options.groupFolders) && !hasDefaultExport(sourceFile) && addFileError(
+    options.store,
+    "SOURCE_OVERRIDE_DEFAULT_EXPORT_MISSING",
+    "Route override files must have a default export. Export the component as default, or remove the file to use the framework default.",
+    options.relativeFile
+  );
+  let mdxComponent = /^components\/mdx\/([a-z0-9]+(?:-[a-z0-9]+)*)\.tsx$/.exec(
+    options.relativeFile
+  );
+  if (mdxComponent && !parseDiagnostics?.length) {
+    let stem = mdxComponent[1] ?? "", name = mdxComponentExportName(stem), exports = namedValueExports(sourceFile);
+    if (name && !exports.has(name))
+      addFileError(
+        options.store,
+        "FRAMEWORK_MDX_COMPONENT_EXPORT_MISSING",
+        `${options.relativeFile} must export a named ${name} component.`,
+        options.relativeFile,
+        sourceDetails(options.source, 0, `export { ${name} }`)
+      );
+    else if (name) {
+      let optionalExports = stem === "figure" ? Object.keys(groupedMdxExports.figure) : stem === "table" ? Object.keys(groupedMdxExports.table) : [];
+      for (let exportName of [name, ...optionalExports]) {
+        if (!exports.has(exportName)) continue;
+        let invalidValue = invalidMdxComponentValue(sourceFile, exportName);
+        invalidValue && addFileError(
+          options.store,
+          "FRAMEWORK_MDX_COMPONENT_EXPORT_INVALID",
+          `${options.relativeFile} must export ${exportName} as a React component, not a static value.`,
+          options.relativeFile,
+          sourceDetails(
+            options.source,
+            invalidValue.getStart(sourceFile),
+            `export function ${exportName}`
+          )
+        );
+      }
+    }
+  }
+  let imports = [], visit = (node) => {
+    if (ts2.isImportDeclaration(node) || ts2.isExportDeclaration(node))
+      node.moduleSpecifier && imports.push({
+        kind: ts2.isImportDeclaration(node) ? "import" : "export",
+        node,
+        specifier: ts2.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : void 0
+      });
+    else if (ts2.isImportEqualsDeclaration(node) && ts2.isExternalModuleReference(node.moduleReference)) {
+      let expression = node.moduleReference.expression;
+      imports.push({
+        kind: "import",
+        node,
+        specifier: expression && ts2.isStringLiteral(expression) ? expression.text : void 0
+      });
+    }
+    if (ts2.isVariableStatement(node) && hasExportModifier(node))
+      for (let declaration of node.declarationList.declarations)
+        for (let exportName of collectBindingNames(declaration.name))
+          ROUTE_EXECUTION_EXPORTS.includes(exportName) && addRouteExecutionExportError({
+            exportName,
+            node,
+            relativeFile: options.relativeFile,
+            source: options.source,
+            sourceFile,
+            store: options.store
+          });
+    if (ts2.isExportDeclaration(node) && node.exportClause && ts2.isNamedExports(node.exportClause))
+      for (let element of node.exportClause.elements) {
+        let exportName = element.name.text;
+        ROUTE_EXECUTION_EXPORTS.includes(exportName) && addRouteExecutionExportError({
+          exportName,
+          node: element,
+          relativeFile: options.relativeFile,
+          source: options.source,
+          sourceFile,
+          store: options.store
+        });
+      }
+    if (ts2.isBinaryExpression(node)) {
+      let exportName = commonJsExportName(node);
+      exportName && ROUTE_EXECUTION_EXPORTS.includes(exportName) && addRouteExecutionExportError({
+        exportName,
+        node,
+        relativeFile: options.relativeFile,
+        source: options.source,
+        sourceFile,
+        store: options.store
+      });
+    }
+    if (ts2.isCallExpression(node)) {
+      let kind = node.expression.kind === ts2.SyntaxKind.ImportKeyword ? "dynamic import" : ts2.isIdentifier(node.expression) && node.expression.text === "require" ? "require" : void 0;
+      if (kind) {
+        let argument = node.arguments[0];
+        imports.push({
+          kind,
+          node,
+          specifier: node.arguments.length === 1 && argument && ts2.isStringLiteral(argument) ? argument.text : void 0
+        });
+      }
+    }
+    ts2.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  for (let moduleImport of imports) {
+    let start = moduleImport.node.getStart(sourceFile), statement = moduleImport.node.getText(sourceFile), location = getSourceLocation(options.source, start);
+    if (moduleImport.specifier === void 0) {
+      addFileError(
+        options.store,
+        "FRAMEWORK_NON_LITERAL_IMPORT",
+        `Non-literal ${moduleImport.kind} specifiers are not allowed in source modules.`,
+        options.relativeFile,
+        {
+          ...location,
+          source: statement.trim()
+        }
+      );
+      continue;
+    }
+    await validateImportSpecifier({
+      specifier: moduleImport.specifier,
+      publishOsDir: options.publishOsDir,
+      sourceFile: options.absolutePath,
+      relativeFile: options.relativeFile,
+      store: options.store,
+      location,
+      statement,
+      groupFolders: options.groupFolders
+    });
+  }
+}
+function validateMdxComponentPath(file, store) {
+  if (!file.startsWith("components/mdx/")) return !0;
+  let stem = /^components\/mdx\/([a-z0-9]+(?:-[a-z0-9]+)*)\.tsx$/.exec(
+    file
+  )?.[1];
+  if (!stem)
+    return addFileError(
+      store,
+      "FRAMEWORK_MDX_COMPONENT_PATH_INVALID",
+      "MDX components must be one kebab-case .tsx file directly under components/mdx/.",
+      file
+    ), !1;
+  if (!Object.hasOwn(replacedMdxSourceFiles, stem)) return !0;
+  let replacement = replacedMdxSourceFiles[stem];
+  return addFileError(
+    store,
+    "FRAMEWORK_MDX_COMPONENT_FILE_REPLACED",
+    `Use components/mdx/${replacement}.tsx instead of ${file}. Related MDX parts belong in the same source file.`,
+    file,
+    { suggestion: `components/mdx/${replacement}.tsx` }
+  ), !1;
+}
+function validateSourceFilePath({
+  file,
+  groupFolders,
+  store
+}) {
+  if (basename(file) === "leaf.tsx" && (file === "leaf.tsx" || groupFolders.has(dirname(file))) || file.split("/").includes("(leaf)")) {
+    let suggestedPath = file.replaceAll("(leaf)", "(page)").replace(/leaf\.tsx$/, "page.tsx");
+    return addFileError(
+      store,
+      "FRAMEWORK_LEGACY_PAGE_PATH",
+      `Rename ${file} to ${suggestedPath} for alpha.9. Rename index renderers to index.tsx and their branch to (index) in the same migration.`,
+      file,
+      { suggestion: suggestedPath }
+    ), !1;
+  }
+  return validateMdxComponentPath(file, store) ? isHardRejectedPath(file) ? (addFileError(
+    store,
+    "FRAMEWORK_SOURCE_PATH_REJECTED",
+    "This file path is not allowed inside publish.os.",
+    file
+  ), !1) : !0 : !1;
+}
+function validateSourceFontFile({
+  file,
+  configuredFontSourcePaths,
+  store
+}) {
+  if (!isFontFilePath(file)) return !1;
+  let configured = configuredFontSourcePaths.has(file);
+  return isValidSourceFontFilePath(file) ? (configured || addFileWarning(
+    store,
+    "FRAMEWORK_FONT_FILE_UNUSED",
+    `Font file "${basename(file)}" is not used by the current font configuration and will not be included in the site.`,
+    file,
+    { fontSourcePath: `/${file}`, suggestion: fontConfigHint(file) }
+  ), !0) : (addFileWarning(
+    store,
+    configured ? "FRAMEWORK_FONT_FILE_PATH_UNSUPPORTED" : "FRAMEWORK_FONT_FILE_PATH_IGNORED",
+    configured ? "This local font is referenced from font config, but local font files should live under publish.os/fonts." : "Font files must live under publish.os/fonts and be used by a fonts entry. This file will not be included in the site.",
+    file,
+    {
+      fontSourcePath: `/${file}`,
+      suggestion: fontConfigHint(`fonts/${basename(file)}`)
+    }
+  ), !0);
+}
+function validateLegacyIconReferences(source, file, store) {
+  let match = findLegacyIconResolver(source);
+  match && addFileError(
+    store,
+    "FRAMEWORK_ICON_RESOLVER_REJECTED",
+    'The Icon resolver is removed. Import an exact component from "@phosphor-icons/react/ssr" in a custom MDX component instead.',
+    file,
+    sourceDetails(source, match.index, match[0] ?? "")
+  );
+}
+function validateSourceModuleSafety(source, file, store) {
+  hasInternalSegment(file) && addFileError(
+    store,
+    "FRAMEWORK_INTERNAL_SOURCE_RESERVED",
+    "The _internal source namespace is reserved for generated platform files.",
+    file
+  );
+  let dangerousHtmlMatch = /\bdangerouslySetInnerHTML\b/.exec(source);
+  dangerousHtmlMatch && addFileWarning(
+    store,
+    "FRAMEWORK_DANGEROUS_HTML",
+    "dangerouslySetInnerHTML requires manual review.",
+    file,
+    sourceDetails(
+      source,
+      dangerousHtmlMatch.index,
+      dangerousHtmlMatch[0] ?? ""
+    )
+  );
+}
+async function validateSourceFileContents({
+  publishOsDir,
+  file,
+  groupFolders,
+  checkedCss,
+  store
+}) {
+  let extension = extname3(file), sourceModule = SOURCE_EXTENSIONS.has(extension), validatesAttribution = ATTRIBUTION_VALIDATION_EXTENSIONS.has(extension), scansLegacyIcons = sourceModule || MARKDOWN_ICON_SCAN_EXTENSIONS.has(extension) && !file.startsWith("assets/");
+  if (!validatesAttribution && !scansLegacyIcons) return;
+  let absolutePath = resolve7(publishOsDir, file), source = await readFile5(absolutePath, "utf-8");
+  validatesAttribution && validateAttributionReferences(source, file, store), extension === ".css" && (validateThemeTokenSpelling(source, file, store), await validateCssDependencies({
+    publishOsDir,
+    filePath: absolutePath,
+    css: source,
+    checked: checkedCss
+  })), scansLegacyIcons && validateLegacyIconReferences(source, file, store), sourceModule && (validateSourceModuleSafety(source, file, store), await validateSourceModule({
+    absolutePath,
+    groupFolders,
+    publishOsDir,
+    relativeFile: file,
+    source,
+    store
+  }));
+}
+async function validateSourceBoundary(publishOsDir, config, store) {
+  let checkedCss = /* @__PURE__ */ new Set(), configuredFontSourcePaths = await validateConfiguredLocalFontSources({
+    config,
+    publishOsDir
+  }), groupFolders = new Set(
+    Object.values(config.groups).map(
+      (group) => group.__meta.relativeFolderPath
+    )
+  );
+  await fileExists(resolve7(publishOsDir, "package.json")) && addFileError(
+    store,
+    "FRAMEWORK_SOURCE_PACKAGE_UNSUPPORTED",
+    "publish.os/package.json is not supported; generated dependencies are controlled by the platform.",
+    "package.json"
+  );
+  for (let file of await walkAllFiles(publishOsDir))
+    validateSourceFilePath({ file, groupFolders, store }) && (validateSourceFontFile({ file, configuredFontSourcePaths, store }) || (isApprovedPublishOsPath(file, groupFolders) || addFileWarning(
+      store,
+      "FRAMEWORK_SOURCE_PATH_IGNORED",
+      "This file is outside the supported publish.os structure and will not be included in the site.",
+      file
+    ), await validateSourceFileContents({
+      publishOsDir,
+      file,
+      groupFolders,
+      checkedCss,
+      store
+    })));
+}
+async function validateCssDependencies({
+  publishOsDir,
+  filePath,
+  css,
+  checked
+}) {
+  if (!checked.has(filePath)) {
+    checked.add(filePath);
+    for (let imported of localCssImports({ css })) {
+      let target = resolve7(dirname(filePath), imported.path);
+      await assertSourceDependency({
+        publishOsDir,
+        path: target,
+        sourceFile: filePath
+      }), !checked.has(target) && await validateCssDependencies({
+        publishOsDir,
+        filePath: target,
+        css: await readFile5(target, "utf8"),
+        checked
+      });
+    }
+  }
+}
+async function resolveRelativeImportTarget(sourceFile, specifier) {
+  let target = resolve7(dirname(sourceFile), specifier);
+  if (await fileExists(target)) return target;
+  for (let extension of SOURCE_EXTENSIONS)
+    if (await fileExists(`${target}${extension}`))
+      return `${target}${extension}`;
+  if (await directoryExists(target))
+    for (let extension of SOURCE_EXTENSIONS) {
+      let indexPath = resolve7(target, `index${extension}`);
+      if (await fileExists(indexPath))
+        return indexPath;
+    }
+  return null;
+}
+async function validateImportSpecifier(options) {
+  let localTarget = options.specifier.startsWith(".") ? normalizeRelativePath(
+    relative4(
+      options.publishOsDir,
+      resolve7(dirname(options.sourceFile), options.specifier)
+    )
+  ) : options.specifier.startsWith("@components/") ? `components/${options.specifier.slice(12)}` : void 0;
+  if (localTarget && isExcludedSourcePath(localTarget)) {
+    addFileError(
+      options.store,
+      "SOURCE_IMPORT_EXCLUDED",
+      "Source modules cannot import nested sites, generated output, or IDE metadata.",
+      options.relativeFile,
+      importDetails(options)
+    );
+    return;
+  }
+  if (options.specifier.startsWith(".")) {
+    let target = resolve7(dirname(options.sourceFile), options.specifier), relativeTarget = relative4(options.publishOsDir, target);
+    if (hasInternalSegment(relativeTarget) && addFileError(
+      options.store,
+      "FRAMEWORK_INTERNAL_IMPORT_RESERVED",
+      "Source modules cannot import the generated _internal source namespace.",
+      options.relativeFile,
+      importDetails(options)
+    ), !isSameOrDescendant(options.publishOsDir, target)) {
+      addFileError(
+        options.store,
+        "FRAMEWORK_RELATIVE_IMPORT_ESCAPE",
+        "Relative imports cannot escape publish.os.",
+        options.relativeFile,
+        importDetails(options)
+      );
+      return;
+    }
+    let resolvedTarget = await resolveRelativeImportTarget(
+      options.sourceFile,
+      options.specifier
+    );
+    if (!resolvedTarget) {
+      addFileError(
+        options.store,
+        "FRAMEWORK_RELATIVE_IMPORT_NOT_FOUND",
+        "Relative imports must resolve to files inside the approved publish.os surface.",
+        options.relativeFile,
+        importDetails(options)
+      );
+      return;
+    }
+    let resolvedRelativeTarget = normalizeRelativePath(
+      relative4(options.publishOsDir, resolvedTarget)
+    );
+    (isHardRejectedPath(resolvedRelativeTarget) || !isApprovedPublishOsPath(resolvedRelativeTarget, options.groupFolders)) && addFileError(
+      options.store,
+      "FRAMEWORK_RELATIVE_IMPORT_NOT_INCLUDED",
+      "Relative imports must resolve to files in the supported publish.os structure.",
+      options.relativeFile,
+      importDetails({
+        specifier: options.specifier,
+        location: options.location,
+        statement: options.statement,
+        extras: { target: resolvedRelativeTarget }
+      })
+    );
+    return;
+  }
+  if (options.specifier.includes("_internal")) {
+    addFileError(
+      options.store,
+      "FRAMEWORK_INTERNAL_IMPORT_RESERVED",
+      "Source modules cannot import the generated _internal source namespace.",
+      options.relativeFile,
+      importDetails(options)
+    );
+    return;
+  }
+  if (options.specifier === "@publish.os/nextjs/mdx/mdx") {
+    addFileError(
+      options.store,
+      "FRAMEWORK_MDX_IMPORT_REJECTED",
+      'Import MDX from "@publish.os/nextjs/mdx" so the generated site component map is applied.',
+      options.relativeFile,
+      importDetails(options)
+    );
+    return;
+  }
+  if (options.specifier === "@publish.os/nextjs/icons" || options.specifier === "@publish.os/nextjs/kernel/framework-icons") {
+    addFileError(
+      options.store,
+      "FRAMEWORK_ICON_ALIAS_REMOVED",
+      `The icon alias "${options.specifier}" was removed. Import exact icons from "@phosphor-icons/react/ssr" instead.`,
+      options.relativeFile,
+      importDetails(options)
+    );
+    return;
+  }
+  if (BLOCKED_ICON_PACKAGE_IMPORTS.has(options.specifier)) {
+    addFileError(
+      options.store,
+      "FRAMEWORK_ICON_PACKAGE_IMPORT_REJECTED",
+      `Can't import from "${options.specifier}". Import exact component names from "@phosphor-icons/react/ssr" instead.`,
+      options.relativeFile,
+      importDetails(options)
+    );
+    return;
+  }
+  isAllowedBareImport(options.specifier) || addFileError(
+    options.store,
+    "FRAMEWORK_IMPORT_NOT_ALLOWED",
+    `Can't import from "${options.specifier}". Source modules can only import approved runtime packages.`,
+    options.relativeFile,
+    importDetails(options)
+  );
+}
+function toValidationDiagnostic(diagnostic) {
+  return {
+    ...diagnostic,
+    file: typeof diagnostic.details?.file == "string" ? diagnostic.details.file : diagnostic.file,
+    line: typeof diagnostic.details?.line == "number" ? diagnostic.details.line : diagnostic.line,
+    column: typeof diagnostic.details?.column == "number" ? diagnostic.details.column : diagnostic.column
+  };
+}
+async function validatePublishOsSource(options) {
+  if (!options.publishOsDir)
+    throw new AppError({
+      code: "FRAMEWORK_VALIDATE_PATH_MISSING",
+      message: "publishOsDir is required"
+    });
+  let publishOsDir = resolve7(options.publishOsDir), store = new DiagnosticStore(), source;
+  try {
+    let prepared = options.sourcePreparation ?? await preparePublishOsSource({
+      publishOsDir,
+      sourceIdentity: options.sourceIdentity
+    });
+    for (let diagnostic of prepared.diagnostics)
+      store.add(diagnostic);
+    prepared.source && (source = prepared.source, await validateSourceBoundary(publishOsDir, prepared.source.config, store));
+  } catch (error) {
+    error instanceof AppError ? store.error(error.code, error.message, error.details) : store.error("FRAMEWORK_VALIDATE_UNKNOWN", String(error));
+  }
+  let allDiagnostics = store.all().map(toValidationDiagnostic), errors = allDiagnostics.filter((d) => d.level === "error"), warnings = allDiagnostics.filter((d) => d.level === "warning"), valid = errors.length === 0;
+  return {
+    valid,
+    errors,
+    warnings,
+    ...valid && source ? { source } : {}
+  };
+}
+
+export {
+  validatePublishOsSource
+};