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

package/dist/{chunk-GGKFQ3MA.js → chunk-6D2E6UMD.js}

@@ -1,9 +1,9 @@
 import {
-  PUBLIC_PAGEFIND_DIRECTORY
-} from "./chunk-YLTOLYWM.js";
+  PUBLIC_SEARCH_DIRECTORY
+} from "./chunk-EFO6AWXN.js";
 import {
   AppError
-} from "./chunk-WDY4IK6Z.js";
+} from "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/lifecycle/output-ownership.ts
 import { createHash, randomUUID } from "crypto";
@@ -12,10 +12,12 @@ import {
   link,
   lstat,
   mkdir,
+  mkdtemp,
   open,
   readdir,
   realpath,
   rename,
+  rmdir,
   unlink,
   writeFile
 } from "fs/promises";
@@ -27,7 +29,7 @@ var MUTABLE_PREVIEW_ENTRIES = /* @__PURE__ */ new Set([
   "tsconfig.tsbuildinfo",
   ".operation-owner.json",
   ".preview-cache.json",
-  PUBLIC_PAGEFIND_DIRECTORY
+  PUBLIC_SEARCH_DIRECTORY
 ]);
 async function generatedInventory(outputDir, stagingDir) {
   if (stagingDir && (dirname(stagingDir) !== outputDir || !/^\.refresh-[a-zA-Z0-9]{6}$/u.test(basename(stagingDir))))
@@ -52,7 +54,7 @@ async function generatedInventory(outputDir, stagingDir) {
       return;
     }
     if (MUTABLE_PREVIEW_ENTRIES.has(path)) {
-      if (["node_modules", ".next", PUBLIC_PAGEFIND_DIRECTORY].includes(path))
+      if (["node_modules", ".next", PUBLIC_SEARCH_DIRECTORY].includes(path))
         await assertLocalDirectory(absolute), path !== "node_modules" && await assertMutable(absolute);
       else if (!entry.isFile()) throw redirectedOutput(absolute);
       return;
@@ -210,7 +212,8 @@ async function markOperationOutput(options) {
 function ownershipError() {
   return new AppError({
     code: "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
-    message: "The generated output owner cannot be verified. Restore this source's output metadata before continuing."
+    message: "The generated output could not be verified. Its files were preserved.",
+    fix: "Stop commands using this source, then run the command again to rebuild its generated output."
   });
 }
 function redirectedOutput(path) {
@@ -224,7 +227,8 @@ async function assertLocalDirectory(path, expected) {
   if (!entry.isDirectory() || entry.isSymbolicLink() || await realpath(path) !== path || expected && (entry.dev !== expected.dev || entry.ino !== expected.ino))
     throw new AppError({
       code: "FRAMEWORK_LOCAL_OUTPUT_REDIRECTED",
-      message: "The source-owned output directory was redirected or replaced. Restore it before continuing."
+      message: "The source-owned output directory was redirected or replaced. Restore it before continuing.",
+      details: { path }
     });
   return entry;
 }
@@ -241,69 +245,41 @@ async function readOwnership(path, maximumSize = 16384) {
     await file.close();
   }
 }
-async function ensureOutputOwnership({
-  sourceRoot,
-  ownerSourceRoot = sourceRoot
+async function ensureLocalOutputRoot({
+  sourceRoot
 }) {
   let sourceIdentity = await assertLocalDirectory(sourceRoot), outputRoot = join(sourceRoot, ".publish.os");
   await mkdir(outputRoot).catch((error) => {
     if (error.code !== "EEXIST") throw error;
   });
-  let outputIdentity = await assertLocalDirectory(outputRoot), ownerPath = join(outputRoot, ".owner.json"), owner = { schemaVersion: 1, sourceRoot: ownerSourceRoot }, assertDirectories = async () => {
+  let outputIdentity = await assertLocalDirectory(outputRoot), assertCurrent = async () => {
     await assertLocalDirectory(sourceRoot, sourceIdentity), await assertLocalDirectory(outputRoot, outputIdentity);
-    for (let name of [
-      ".locks",
-      ".stages",
-      "build",
-      "dev",
-      "ide",
-      ".ide-lock"
-    ])
-      await assertLocalDirectory(join(outputRoot, name)).catch(
-        (error) => {
-          if (error.code !== "ENOENT") throw error;
-        }
-      );
-  }, assertOwner = async () => {
-    try {
-      let current = await readOwnership(ownerPath);
-      if (!current || current.schemaVersion !== 1 || current.sourceRoot !== ownerSourceRoot)
-        throw ownershipError();
-    } catch {
-      throw ownershipError();
-    }
   };
-  if (!await lstat(ownerPath).then(() => !0).catch((error) => {
-    if (error.code !== "ENOENT") throw error;
-    return !1;
-  })) {
-    let entries = await readdir(outputRoot), isIdeOwned = (name) => name === "ide" || name === ".ide-lock" || name.startsWith(".ide.tmp-") || name.startsWith("ide.previous-");
-    if (entries.some(
-      (name) => !isIdeOwned(name) && !/^\.owner-init-[a-f0-9-]+\.tmp$/.test(name)
-    ))
-      await assertOwner();
-    else {
-      await assertDirectories();
-      let temporary = join(outputRoot, `.owner-init-${randomUUID()}.tmp`);
-      await writeFile(temporary, `${JSON.stringify(owner)}
-`, { flag: "wx" });
-      try {
-        await assertDirectories(), await link(temporary, ownerPath).catch(
-          (error) => {
-            if (error.code !== "EEXIST") throw error;
-          }
-        );
-      } finally {
-        await assertDirectories(), await unlink(temporary);
-      }
-    }
+  return await assertCurrent(), { outputRoot, assertCurrent };
+}
+async function recoverOperationOutput(options) {
+  try {
+    await assertOperationOutput(options), await assertGeneratedOutput(options);
+    return;
+  } catch (error) {
+    if (!(error instanceof AppError) || ![
+      "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
+      "FRAMEWORK_LOCAL_OUTPUT_MODIFIED",
+      "FRAMEWORK_LOCAL_OUTPUT_REDIRECTED"
+    ].includes(error.code))
+      throw error;
+  }
+  await options.assertCurrent();
+  let recoveryRoot = join(dirname(options.outputDir), "recovery");
+  await mkdir(recoveryRoot, { recursive: !0 }), await assertLocalDirectory(recoveryRoot);
+  let recovery = await mkdtemp(
+    join(recoveryRoot, `${localOperationName(options)}-`)
+  );
+  try {
+    await options.assertCurrent(), await rename(options.outputDir, join(recovery, "output"));
+  } catch (error) {
+    throw await rmdir(recovery), error;
   }
-  return await assertOwner(), await assertDirectories(), {
-    outputRoot,
-    assertCurrent: async () => {
-      await assertDirectories(), await assertOwner();
-    }
-  };
 }
 
 // src/lib/compiler/lifecycle/operation-lock.ts
@@ -315,18 +291,23 @@ import {
   open as open2,
   readdir as readdir2,
   realpath as realpath2,
-  rmdir,
+  rmdir as rmdir2,
   unlink as unlink2,
   writeFile as writeFile2
 } from "fs/promises";
 import { hostname } from "os";
-import { join as join2, resolve } from "path";
+import { isAbsolute, join as join2, resolve } from "path";
 function lockError({
   code,
   message,
   sourceRoot
 }) {
-  return new AppError({ code, message, details: { sourceRoot } });
+  return new AppError({
+    code,
+    message,
+    details: { sourceRoot },
+    fix: code === "FRAMEWORK_LOCAL_OPERATION_ACTIVE" ? "Stop the running command for this source, then run the command again." : `Stop commands using this source, move only ${join2(sourceRoot, ".publish.os")} aside to preserve it, then run the command again.`
+  });
 }
 async function directoryIdentity({
   path,
@@ -385,7 +366,7 @@ async function readOwner({
       if (!owner || typeof owner != "object")
         throw new Error("Invalid lock metadata.");
       let value = owner;
-      if (value.sourceRoot !== sourceRoot || !["build", "dev", "ide", "dependencies"].includes(
+      if (typeof value.sourceRoot != "string" || !isAbsolute(value.sourceRoot) || !["build", "dev", "ide", "dependencies"].includes(
         value.operation ?? ""
       ) || value.scope !== void 0 && (value.operation !== "dev" || typeof value.scope != "string" || !/^[a-f0-9]{64}$/u.test(value.scope)) || !Number.isSafeInteger(value.pid) || (value.pid ?? 0) <= 0 || typeof value.hostname != "string" || !value.hostname || typeof value.token != "string" || !/^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/u.test(
         value.token
@@ -411,7 +392,7 @@ async function assertOwnedLock({
 }) {
   await verifyDirectory({ directory: parent, sourceRoot: owner.sourceRoot });
   let current = await readOwner({ directory, sourceRoot: owner.sourceRoot });
-  if (current.token !== owner.token || current.operation !== owner.operation || current.scope !== owner.scope)
+  if (current.sourceRoot !== owner.sourceRoot || current.token !== owner.token || current.operation !== owner.operation || current.scope !== owner.scope)
     throw lockError({
       code: "FRAMEWORK_LOCAL_LOCK_UNVERIFIED",
       message: "The operation lock now belongs to another owner. Leave it in place and inspect the active operation.",
@@ -460,7 +441,7 @@ async function removeOwnedLock({
   owner,
   beforeRemoval
 }) {
-  await assertOwnedLock({ directory, parent, owner }), beforeRemoval?.(), await unlink2(join2(directory.path, "owner.json")), await rmdir(directory.path);
+  await assertOwnedLock({ directory, parent, owner }), beforeRemoval?.(), await unlink2(join2(directory.path, "owner.json")), await rmdir2(directory.path);
 }
 function assertDeadOwner({
   owner,
@@ -609,6 +590,97 @@ async function acquireOperationLock({
   };
 }
 
+// src/lib/compiler/lifecycle/owned-directory-publication.ts
+import { lstat as lstat3, mkdir as mkdir3, mkdtemp as mkdtemp2, rename as rename2, rm } from "fs/promises";
+import { basename as basename2, join as join3 } from "path";
+async function assertMissing(path) {
+  try {
+    await lstat3(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  throw new AppError({
+    code: "FRAMEWORK_LOCAL_OUTPUT_REDIRECTED",
+    message: `Owned output appeared during publication: ${path}. The previous bytes were preserved.`
+  });
+}
+async function publishOwnedDirectory(options) {
+  options.signal?.throwIfAborted(), await options.assertOwner(), await mkdir3(options.stagingRoot, { recursive: !0 });
+  let stagingRootIdentity = await assertLocalDirectory(options.stagingRoot), stage = await mkdtemp2(
+    join3(options.stagingRoot, `${options.stagingPrefix}-`)
+  ), stageIdentity = await assertLocalDirectory(stage), incoming = join3(stage, "incoming"), retainStage = !1, assertStage = async () => {
+    try {
+      await options.assertOwner(), await assertLocalDirectory(options.stagingRoot, stagingRootIdentity), await assertLocalDirectory(stage, stageIdentity);
+    } catch (error) {
+      throw options.onRecoveryRequired?.(), error;
+    }
+  }, previous, previousIdentity, recoveryEntry, recoveryRootIdentity, recoveryEntryIdentity, movedPrevious = !1, published = !1, failure;
+  try {
+    await mkdir3(incoming), await assertLocalDirectory(incoming), await options.prepareIncoming(incoming), options.signal?.throwIfAborted(), await assertStage();
+    let preparedIncomingIdentity = await assertLocalDirectory(incoming);
+    await options.validateIncoming?.(incoming), await assertStage(), await assertLocalDirectory(incoming, preparedIncomingIdentity);
+    try {
+      previousIdentity = await lstat3(options.targetDirectory), await assertLocalDirectory(options.targetDirectory, previousIdentity);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      previousIdentity = void 0;
+    }
+    if (previousIdentity) {
+      options.recoveryRoot ? (await mkdir3(options.recoveryRoot, { recursive: !0 }), recoveryRootIdentity = await assertLocalDirectory(options.recoveryRoot), recoveryEntry = await mkdtemp2(
+        join3(options.recoveryRoot, `${basename2(options.targetDirectory)}-`)
+      ), recoveryEntryIdentity = await assertLocalDirectory(recoveryEntry), previous = join3(recoveryEntry, basename2(options.targetDirectory))) : previous = join3(stage, "previous"), await assertStage(), recoveryRootIdentity && options.recoveryRoot && await assertLocalDirectory(options.recoveryRoot, recoveryRootIdentity), recoveryEntryIdentity && recoveryEntry && await assertLocalDirectory(recoveryEntry, recoveryEntryIdentity), await assertLocalDirectory(options.targetDirectory, previousIdentity), await rename2(options.targetDirectory, previous), movedPrevious = !0;
+      try {
+        await assertLocalDirectory(previous, previousIdentity);
+      } catch (error) {
+        throw retainStage = !0, options.onRecoveryRequired?.(), new AggregateError(
+          [error],
+          `Owned output changed while being retained; preserve the previous output at ${previous}.`
+        );
+      }
+    }
+    try {
+      options.signal?.throwIfAborted(), await assertStage(), await assertLocalDirectory(incoming, preparedIncomingIdentity), await assertMissing(options.targetDirectory), await options.beforePublish?.(), await rename2(incoming, options.targetDirectory), published = !0;
+    } catch (publishError) {
+      if (movedPrevious && previous && previousIdentity)
+        try {
+          await assertStage(), recoveryRootIdentity && options.recoveryRoot && await assertLocalDirectory(
+            options.recoveryRoot,
+            recoveryRootIdentity
+          ), recoveryEntryIdentity && recoveryEntry && await assertLocalDirectory(recoveryEntry, recoveryEntryIdentity), await assertMissing(options.targetDirectory), await rename2(previous, options.targetDirectory), await assertLocalDirectory(options.targetDirectory, previousIdentity), movedPrevious = !1;
+        } catch (rollbackError) {
+          throw retainStage = !0, options.onRecoveryRequired?.(), new AggregateError(
+            [publishError, rollbackError],
+            `Owned output publication failed; the previous output remains at ${previous}.`
+          );
+        }
+      throw publishError;
+    }
+  } catch (error) {
+    failure = error;
+  }
+  if (!retainStage && (!failure || options.cleanupFailedStaging !== !1))
+    try {
+      await assertStage(), await rm(stage, { recursive: !0, force: !0 });
+    } catch (cleanupError) {
+      failure = failure ? new AggregateError(
+        [failure, cleanupError],
+        `Owned output publication failed; staging cleanup also failed at ${stage}.`
+      ) : cleanupError;
+    }
+  if (recoveryEntry && !movedPrevious)
+    try {
+      options.recoveryRoot && recoveryRootIdentity && await assertLocalDirectory(options.recoveryRoot, recoveryRootIdentity), recoveryEntryIdentity && await assertLocalDirectory(recoveryEntry, recoveryEntryIdentity), await rm(recoveryEntry, { recursive: !0, force: !0 });
+    } catch (cleanupError) {
+      failure = failure ? new AggregateError(
+        [failure, cleanupError],
+        `Owned output publication failed; recovery cleanup also failed at ${recoveryEntry}.`
+      ) : cleanupError;
+    }
+  if (failure) throw failure;
+  if (!published) throw new Error("Owned output was not published.");
+}
+
 export {
   assertGeneratedOutput,
   prepareGeneratedOutputUpdate,
@@ -616,6 +688,8 @@ export {
   assertOperationOutput,
   markOperationOutput,
   assertLocalDirectory,
-  ensureOutputOwnership,
-  acquireOperationLock
+  ensureLocalOutputRoot,
+  recoverOperationOutput,
+  acquireOperationLock,
+  publishOwnedDirectory
 };

package/dist/{chunk-7OGTPSKI.js → chunk-7NY22B5U.js}

@@ -1,6 +1,11 @@
 import {
+  isOsMetadataPath,
   isSameOrDescendant
-} from "./chunk-YLTOLYWM.js";
+} from "./chunk-WL75GQ5M.js";
+
+// src/lib/compiler/source/assert-publish-os-source-boundary.ts
+import { lstat, readdir, realpath } from "fs/promises";
+import { basename, dirname, join, relative, resolve, sep } from "path";
 
 // src/lib/compiler/source/diagnostics/errors/publish-os-source-error.ts
 var ERROR_CODES = {
@@ -25,6 +30,7 @@ var ERROR_CODES = {
   CONFIG_CONTENT_MISSING: "CONFIG_CONTENT_MISSING",
   CONFIG_CONTENT_NOT_DIRECTORY: "CONFIG_CONTENT_NOT_DIRECTORY",
   CONTENT_FRONTMATTER_INVALID_JSON: "CONTENT_FRONTMATTER_INVALID_JSON",
+  CONTENT_FRONTMATTER_LANGUAGE_UNSUPPORTED: "CONTENT_FRONTMATTER_LANGUAGE_UNSUPPORTED",
   CONTENT_FRONTMATTER_REQUIRED: "CONTENT_FRONTMATTER_REQUIRED",
   CONTENT_FRONTMATTER_ID_INVALID: "CONTENT_FRONTMATTER_ID_INVALID",
   CONTENT_FILE_PARSE_FAILED: "CONTENT_FILE_PARSE_FAILED",
@@ -42,8 +48,6 @@ var ERROR_CODES = {
 };
 
 // src/lib/compiler/source/assert-publish-os-source-boundary.ts
-import { lstat, readdir, realpath } from "fs/promises";
-import { basename, dirname, join, relative, resolve, sep } from "path";
 function displayPath(root, path) {
   return relative(root, path).split(sep).join("/") || ".";
 }
@@ -55,6 +59,7 @@ function sourceBoundaryError(options) {
   });
 }
 async function assertEntry(options) {
+  if (isOsMetadataPath(relative(options.root, options.path))) return;
   let entry = await lstat(options.path);
   if (entry.isSymbolicLink())
     throw sourceBoundaryError({

package/dist/chunk-EFO6AWXN.js

@@ -0,0 +1,19 @@
+// src/lib/hosting/framework-paths.ts
+var FRAMEWORK_PREFIX = "/publishos", SOURCE_ASSET_PREFIX = `${FRAMEWORK_PREFIX}/assets`, INTERNAL_PREFIX = `${FRAMEWORK_PREFIX}/internal`, SITE_API_PREFIX = `${FRAMEWORK_PREFIX}/api`, SEARCH_PREFIX = `${INTERNAL_PREFIX}/search`, PAGEFIND_MODULE_URL = `${SEARCH_PREFIX}/pagefind.js`, PAGEFIND_ENTRY_URL = `${SEARCH_PREFIX}/pagefind-entry.json`, IMAGE_OPTIMIZER_PATH = `${SITE_API_PREFIX}/image`, NEXT_IMAGE_OPTIMIZER_PATH = "/_next/image", OG_SERVICE_PREFIX = `${SITE_API_PREFIX}/og`, PUBLIC_INTERNAL_DIRECTORY = INTERNAL_PREFIX.slice(1), PUBLIC_FONT_DIRECTORY = `${PUBLIC_INTERNAL_DIRECTORY}/fonts`, PUBLIC_SEARCH_DIRECTORY = `public/${PUBLIC_INTERNAL_DIRECTORY}/search`, FRAMEWORK_PROXY_MATCHER = `/((?!${FRAMEWORK_PREFIX.slice(1)}(?:/|$)|_next/static|_next/image|_next/webpack-hmr).*)`;
+function isFrameworkNamespacePath(pathname) {
+  return pathname === FRAMEWORK_PREFIX || pathname.startsWith(`${FRAMEWORK_PREFIX}/`);
+}
+
+export {
+  FRAMEWORK_PREFIX,
+  SOURCE_ASSET_PREFIX,
+  INTERNAL_PREFIX,
+  IMAGE_OPTIMIZER_PATH,
+  NEXT_IMAGE_OPTIMIZER_PATH,
+  OG_SERVICE_PREFIX,
+  PUBLIC_INTERNAL_DIRECTORY,
+  PUBLIC_FONT_DIRECTORY,
+  PUBLIC_SEARCH_DIRECTORY,
+  FRAMEWORK_PROXY_MATCHER,
+  isFrameworkNamespacePath
+};

package/dist/{chunk-726GV2NF.js → chunk-F3AGNDF4.js}

@@ -1,41 +1,50 @@
 import {
-  supportedNextjsSourceImports
-} from "./chunk-NECL5IBJ.js";
+  AppError as AppError2,
+  ERROR_CODES,
+  assertPublishOsSourceBoundary
+} from "./chunk-7NY22B5U.js";
 import {
+  MdxIconImportError,
   ROOT_CONTENT_GROUP_KEY,
   ROOT_CONTENT_GROUP_TITLE,
+  UnsupportedFrontmatterLanguageError,
   assertSourceDependency,
   buildFaviconsAndLogos,
   buildMediaAssets,
   collectBindingNames,
   groupedMdxExports,
   joinUrlPath,
-  localCssImports,
   mdxComponentExportName,
   namedValueExports,
   normalizeSlugPath,
   normalizeUrlPath,
-  replacedMdxSourceFiles
-} from "./chunk-535TM4A5.js";
+  originalDefaultComponentSourcePath,
+  parseSourceFrontmatter,
+  replacedMdxSourceFiles,
+  supportedNextjsSourceImports,
+  validateMdxIconImports
+} from "./chunk-UYGCOWRF.js";
 import {
-  AppError as AppError2,
-  ERROR_CODES,
-  assertPublishOsSourceBoundary
-} from "./chunk-7OGTPSKI.js";
+  isFrameworkNamespacePath
+} from "./chunk-EFO6AWXN.js";
+import {
+  localCssImports
+} from "./chunk-5KAD7W53.js";
 import {
   isApprovedPublishOsPath,
   isExcludedSourcePath,
-  isFrameworkNamespacePath,
   isReservedFrameworkPath,
   isSameOrDescendant
-} from "./chunk-YLTOLYWM.js";
+} from "./chunk-WL75GQ5M.js";
 import {
   runtimePackageVersion
 } from "./chunk-AI2UULNX.js";
 import {
-  AppError,
   readInstalledFrameworkLocation
-} from "./chunk-WDY4IK6Z.js";
+} from "./chunk-5J3YUNRY.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/validation/validate-publish-os-source.ts
 import { readdir as readdir3, readFile as readFile5, stat as stat3 } from "fs/promises";
@@ -88,9 +97,15 @@ import { resolve } from "path";
 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}`];
+  ) : issue.code === "unrecognized_keys" ? issue.keys.map((key) => {
+    let path = [...issue.path, key].join(".");
+    return issue.path.join(".") === "media.assets" && [
+      "maxImageBytes",
+      "maxVideoBytes",
+      "maxTotalBytes",
+      "maxFileCount"
+    ].includes(key) ? `${path}: Media limits are fixed by PublishOS. Remove this field.` : `${path}: Unknown field.`;
+  }) : [`${issue.path.join(".") || "(root)"}: ${issue.message}`];
 }
 function formatConfigIssues(error) {
   return [...new Set(error.issues.flatMap(issueMessages))].join(`
@@ -158,7 +173,10 @@ var treeNodeSchema = z3.lazy(
   scope: outputScopeSchema.optional(),
   description: z3.string().optional(),
   limit: z3.number().int().positive().optional()
-}).strict(), outputDefaultsDeclarationSchema = z3.object({
+}).strict(), sitemapOutputSchema = outputDeclarationSchema.extend({
+  path: z3.string().min(1).optional(),
+  mode: z3.enum(["index", "urls"]).optional()
+}), outputDefaultsDeclarationSchema = z3.object({
   scope: outputScopeSchema.optional(),
   limit: z3.number().int().positive().optional(),
   status: z3.array(outputStatusSchema).optional(),
@@ -172,10 +190,12 @@ var treeNodeSchema = z3.lazy(
   atom: outputDefaultsDeclarationSchema.optional(),
   json: outputDefaultsDeclarationSchema.optional()
 }).strict(), outputsSchema = z3.object({
-  llms: outputDeclarationSchema.optional(),
+  llms: outputDeclarationSchema.or(z3.literal(!1)).optional(),
+  llmsFull: outputDeclarationSchema.or(z3.literal(!1)).optional(),
   feeds: feedsOutputSchema.optional(),
-  robots: outputDeclarationSchema.optional(),
-  sitemap: outputDeclarationSchema.optional()
+  robots: outputDeclarationSchema.or(z3.literal(!1)).optional(),
+  sitemap: sitemapOutputSchema.or(z3.literal(!1)).optional(),
+  sitemapMarkdown: outputDeclarationSchema.or(z3.literal(!1)).optional()
 }).strict(), outputDefaultsSchema = z3.object({
   llms: outputDefaultsDeclarationSchema.optional(),
   feeds: feedsOutputDefaultsSchema.optional()
@@ -267,31 +287,8 @@ var siteSchema = z4.object({
 }), 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()
+  assets: z4.object({}).strict().optional()
 }).strict(), agentConfigSchema = z4.object({
   enabled: z4.boolean().optional(),
   markdownRoutes: z4.boolean().optional(),
@@ -802,7 +799,6 @@ async function resolvePublishOsConfig(baseDir) {
 // 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",
@@ -1008,7 +1004,7 @@ function customMeta(frontmatter, absolutePath) {
 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);
+    let parsed = parseSourceFrontmatter(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,
@@ -1102,7 +1098,11 @@ async function readContentFile(group, absolutePath, configSlugs) {
       warnings
     };
   } catch (error) {
-    throw error instanceof AppError2 ? error : new AppError2({
+    throw error instanceof AppError2 ? error : error instanceof UnsupportedFrontmatterLanguageError ? new AppError2({
+      code: ERROR_CODES.CONTENT_FRONTMATTER_LANGUAGE_UNSUPPORTED,
+      message: `Unsupported frontmatter language "${error.language}" for ${absolutePath}. Use YAML or JSON.`,
+      details: { path: absolutePath, language: error.language }
+    }) : new AppError2({
       code: ERROR_CODES.CONTENT_FILE_PARSE_FAILED,
       message: `Failed to parse frontmatter for ${absolutePath}`,
       details: { error }
@@ -1475,7 +1475,9 @@ async function preparePublishOsSource({
     ), config = await resolvePublishOsConfig(sourceRoot), content = await scanContent(config), media = await buildMediaAssets({
       config,
       publishOsDir
-    }), faviconsAndLogos = await buildFaviconsAndLogos({ publishOsDir }), missingPages = await missingPageReferences({
+    }), faviconsAndLogos = buildFaviconsAndLogos({
+      media
+    }), missingPages = await missingPageReferences({
       sourceRoot,
       config,
       content
@@ -1490,13 +1492,10 @@ async function preparePublishOsSource({
         })),
         ...content.warnings,
         ...missingPages,
+        ...faviconsAndLogos.warnings,
         ...media.warnings.map((warning2) => ({
           ...warning2,
           level: "warning"
-        })),
-        ...faviconsAndLogos.warnings.map((warning2) => ({
-          ...warning2,
-          level: "warning"
         }))
       ],
       source: {
@@ -1704,6 +1703,10 @@ function isAllowedBareImport(specifier) {
   }
   return ALLOWED_BARE_IMPORTS.has(specifier);
 }
+function isOriginalDefaultComponentBridge(options) {
+  let sourcePath = originalDefaultComponentSourcePath(options.specifier);
+  return sourcePath ? options.relativeFile.replace(/\.[^.]+$/, "") === sourcePath : !1;
+}
 function addFileError(store, code, message, file, details = {}) {
   store.error(code, message, { ...details, file });
 }
@@ -2075,7 +2078,7 @@ function validateLegacyIconReferences(source, file, store) {
   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.',
+    'The Icon resolver is removed. Import an exact named component from "@phosphor-icons/react/ssr" in MDX or TSX instead.',
     file,
     sourceDetails(source, match.index, match[0] ?? "")
   );
@@ -2115,7 +2118,23 @@ async function validateSourceFileContents({
     filePath: absolutePath,
     css: source,
     checked: checkedCss
-  })), scansLegacyIcons && validateLegacyIconReferences(source, file, store), sourceModule && (validateSourceModuleSafety(source, file, store), await validateSourceModule({
+  }));
+  let importsIconBinding = !1;
+  if (extension === ".mdx" && !file.startsWith("assets/"))
+    try {
+      importsIconBinding = (await validateMdxIconImports(source)).some(({ local }) => local === "Icon");
+    } catch (error) {
+      let line = error instanceof MdxIconImportError ? error.line : 1, column = error instanceof MdxIconImportError ? error.column : 1;
+      addFileError(
+        store,
+        error instanceof MdxIconImportError ? error.code : "FRAMEWORK_MDX_IMPORT_INVALID",
+        error instanceof Error ? error.message : String(error),
+        file,
+        { line, column, sourceLine: source.split(`
+`)[line - 1] ?? "" }
+      );
+    }
+  scansLegacyIcons && !importsIconBinding && validateLegacyIconReferences(source, file, store), sourceModule && (validateSourceModuleSafety(source, file, store), await validateSourceModule({
     absolutePath,
     groupFolders,
     publishOsDir,
@@ -2140,18 +2159,32 @@ async function validateSourceBoundary(publishOsDir, config, store) {
     "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
-    })));
+    if (validateSourceFilePath({ file, groupFolders, store }) && !validateSourceFontFile({ file, configuredFontSourcePaths, store })) {
+      if (!isApprovedPublishOsPath(file, groupFolders))
+        if (file.startsWith("public/")) {
+          let assetPath = file.slice(7);
+          addFileWarning(
+            store,
+            "FRAMEWORK_SOURCE_PUBLIC_UNSUPPORTED",
+            `Files in publish.os/public are not included. Move this file to publish.os/assets/${assetPath} and reference it as /assets/${assetPath}.`,
+            file,
+            { correction: `assets/${assetPath}` }
+          );
+        } else
+          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,
@@ -2296,7 +2329,7 @@ async function validateImportSpecifier(options) {
     );
     return;
   }
-  isAllowedBareImport(options.specifier) || addFileError(
+  !isAllowedBareImport(options.specifier) && !isOriginalDefaultComponentBridge(options) && addFileError(
     options.store,
     "FRAMEWORK_IMPORT_NOT_ALLOWED",
     `Can't import from "${options.specifier}". Source modules can only import approved runtime packages.`,