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

package/dist/chunk-5KAD7W53.js

@@ -0,0 +1,248 @@
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/source/assets/media-file-policy.ts
+import { constants as fsConstants } from "fs";
+import { open } from "fs/promises";
+var DEFAULT_MAX_IMAGE_BYTES = 20 * 1024 * 1024, DEFAULT_MAX_VIDEO_BYTES = 20 * 1024 * 1024, DEFAULT_MAX_OTHER_BYTES = 5 * 1024 * 1024, MAX_THEME_FONT_BYTES = DEFAULT_MAX_OTHER_BYTES, MAX_MEDIA_SVG_BYTES = 256 * 1024, IGNORED_DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set(["pdf", "txt", "csv", "zip"]), THEME_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "avif",
+  "ico",
+  "svg"
+]), THEME_FONT_EXTENSIONS = /* @__PURE__ */ new Set(["woff", "woff2", "ttf", "otf"]);
+function ignoredMediaDocumentWarning(relativePath) {
+  let extension = relativePath.split(".").at(-1)?.toLowerCase() ?? "";
+  if (IGNORED_DOCUMENT_EXTENSIONS.has(extension))
+    return {
+      code: "FRAMEWORK_MEDIA_DOCUMENT_IGNORED",
+      message: `${relativePath} is ignored because this file type is not supported.`,
+      details: { file: relativePath, path: relativePath }
+    };
+}
+function ignoredMediaPathWarning(sourcePath) {
+  return {
+    code: "FRAMEWORK_MEDIA_PATH_IGNORED",
+    message: "Hidden media file ignored.",
+    details: { file: sourcePath, path: sourcePath }
+  };
+}
+function isHiddenMediaPath(sourcePath) {
+  return sourcePath.split(/[\\/]/u).some((segment) => segment.startsWith("."));
+}
+function mediaFileTooLarge(options) {
+  return new AppError({
+    code: "FRAMEWORK_MEDIA_FILE_TOO_LARGE",
+    message: `${options.relativePath} is ${options.bytes} bytes. Media files must be less than ${Math.round(options.limit / 1024 / 1024)} MB.`,
+    details: {
+      path: options.relativePath,
+      bytes: options.bytes,
+      limit: options.limit
+    }
+  });
+}
+function mediaFileByteLimit(relativePath) {
+  let extension = relativePath.split(".").at(-1)?.toLowerCase() ?? "", imageLimit = DEFAULT_MAX_IMAGE_BYTES;
+  return ["png", "jpg", "jpeg", "gif", "webp", "avif", "ico"].includes(extension) ? imageLimit : extension === "svg" ? Math.min(imageLimit, MAX_MEDIA_SVG_BYTES) : ["mp4", "webm"].includes(extension) ? DEFAULT_MAX_VIDEO_BYTES : DEFAULT_MAX_OTHER_BYTES;
+}
+function themeResourceByteLimit(relativePath) {
+  let extension = relativePath.split(".").at(-1)?.toLowerCase() ?? "";
+  if (THEME_FONT_EXTENSIONS.has(extension)) return MAX_THEME_FONT_BYTES;
+  if (THEME_IMAGE_EXTENSIONS.has(extension))
+    return mediaFileByteLimit(relativePath);
+}
+async function readBoundedMediaFile(options) {
+  let handle = await (options.openFile ?? open)(
+    options.path,
+    fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0) | (fsConstants.O_NONBLOCK ?? 0)
+  );
+  try {
+    let opened = await handle.stat();
+    if (!opened.isFile() || options.expectedIdentity !== void 0 && (opened.dev !== options.expectedIdentity.dev || opened.ino !== options.expectedIdentity.ino))
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_FILE_CHANGED",
+        message: `${options.relativePath} changed while media was being read`,
+        details: { path: options.relativePath }
+      });
+    if (opened.size > options.limit)
+      throw mediaFileTooLarge({
+        relativePath: options.relativePath,
+        bytes: opened.size,
+        limit: options.limit
+      });
+    let chunkSize = Math.min(64 * 1024, options.limit + 1), chunk = Buffer.allocUnsafe(Math.max(1, chunkSize)), chunks = [], bytesRead = 0;
+    for (; ; ) {
+      options.signal?.throwIfAborted();
+      let remainingWithOverflowProbe = options.limit - bytesRead + 1, { bytesRead: count } = await handle.read(
+        chunk,
+        0,
+        Math.min(chunk.length, remainingWithOverflowProbe),
+        null
+      );
+      if (options.signal?.throwIfAborted(), count === 0) break;
+      if (bytesRead += count, bytesRead > options.limit)
+        throw mediaFileTooLarge({
+          relativePath: options.relativePath,
+          bytes: bytesRead,
+          limit: options.limit
+        });
+      chunks.push(Buffer.from(chunk.subarray(0, count)));
+    }
+    let completed = await handle.stat();
+    if (completed.size > options.limit)
+      throw mediaFileTooLarge({
+        relativePath: options.relativePath,
+        bytes: completed.size,
+        limit: options.limit
+      });
+    if (completed.size !== bytesRead)
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_FILE_CHANGED",
+        message: `${options.relativePath} changed while media was being read`,
+        details: { path: options.relativePath }
+      });
+    return Buffer.concat(chunks, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+
+// src/lib/compiler/source/css-imports.ts
+function skipString(css, start) {
+  let quote = css[start];
+  for (let index = start + 1; index < css.length; index += 1)
+    if (css[index] === "\\") index += 1;
+    else if (css[index] === quote) return index + 1;
+  return css.length;
+}
+function maskComments(css) {
+  let result = "";
+  for (let index = 0; index < css.length; )
+    if (css[index] === '"' || css[index] === "'") {
+      let end = skipString(css, index);
+      result += css.slice(index, end), index = end;
+    } else if (css.startsWith("/*", index)) {
+      let closing = css.indexOf("*/", index + 2), end = closing < 0 ? css.length : closing + 2;
+      result += css.slice(index, end).replace(/[^\r\n]/g, " "), index = end;
+    } else
+      result += css[index], index += 1;
+  return result;
+}
+function decodeCssPath(value) {
+  return value.replace(/\\(?:\r\n|[\r\n\f])/g, "").replace(
+    /\\([\da-f]{1,6})[\t\n\f\r ]?|\\(.)/gi,
+    (_match, hex, escaped) => {
+      if (!hex) return escaped ?? "";
+      let codePoint = Number.parseInt(hex, 16);
+      return codePoint > 0 && codePoint <= 1114111 && !(codePoint >= 55296 && codePoint <= 57343) ? String.fromCodePoint(codePoint) : "\uFFFD";
+    }
+  );
+}
+function statementEnd(scan, start) {
+  let depth = 0;
+  for (let index = start; index < scan.length; index += 1)
+    if (scan[index] === '"' || scan[index] === "'")
+      index = skipString(scan, index) - 1;
+    else if (scan[index] === "\\")
+      index += 1;
+    else if (scan[index] === "(")
+      depth += 1;
+    else if (scan[index] === ")")
+      depth -= 1;
+    else {
+      if (scan[index] === ";" && depth === 0)
+        return index + 1;
+      if ((scan[index] === "{" || scan[index] === "}") && depth === 0)
+        return index;
+    }
+  return scan.length;
+}
+function closingParenthesis(scan, start, end) {
+  let depth = 0;
+  for (let index = start; index < end; index += 1)
+    if (scan[index] === '"' || scan[index] === "'")
+      index = skipString(scan, index) - 1;
+    else if (scan[index] === "\\")
+      index += 1;
+    else if (scan[index] === "(")
+      depth += 1;
+    else if (scan[index] === ")" && --depth === 0)
+      return index;
+  return end;
+}
+function importConditions({
+  css,
+  scan,
+  start,
+  end
+}) {
+  let result = {}, tailEnd = scan[end - 1] === ";" ? end - 1 : end, cursor = start, skipWhitespace = () => {
+    for (; cursor < tailEnd && /\s/.test(scan[cursor] ?? ""); ) cursor += 1;
+  };
+  skipWhitespace();
+  let layer = /^layer(?=\(|\s|$)/i.exec(scan.slice(cursor, tailEnd));
+  if (layer) {
+    if (cursor += layer[0].length, scan[cursor] === "(") {
+      let closing = closingParenthesis(scan, cursor, tailEnd);
+      result.layer = css.slice(cursor + 1, closing).trim(), cursor = closing + 1;
+    } else
+      result.layer = !0;
+    skipWhitespace();
+  }
+  let supports = /^supports\(/i.exec(scan.slice(cursor, tailEnd));
+  if (supports) {
+    let opening = cursor + supports[0].length - 1, closing = closingParenthesis(scan, opening, tailEnd);
+    result.supports = css.slice(opening + 1, closing).trim(), cursor = closing + 1, skipWhitespace();
+  }
+  return scan.slice(cursor, tailEnd).trim() && (result.media = css.slice(cursor, tailEnd).trim()), result;
+}
+function cssImports({ css }) {
+  let scan = maskComments(css), pattern = /@import\s+(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|url\(\s*(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|([^\s)]+))\s*\))/giy, imports = [];
+  for (let index = 0; index < scan.length; ) {
+    if (scan[index] === '"' || scan[index] === "'") {
+      index = skipString(scan, index);
+      continue;
+    }
+    if (scan[index] === "\\") {
+      index += 2;
+      continue;
+    }
+    pattern.lastIndex = index;
+    let match = scan[index] === "@" ? pattern.exec(scan) : null;
+    if (!match) {
+      index += 1;
+      continue;
+    }
+    let path = decodeCssPath(
+      match.slice(1).find((value) => value !== void 0) ?? ""
+    ), end = statementEnd(scan, pattern.lastIndex);
+    imports.push({
+      path,
+      start: index,
+      end,
+      ...importConditions({ css, scan, start: pattern.lastIndex, end })
+    }), index = end;
+  }
+  return imports;
+}
+function localCssImports({ css }) {
+  return cssImports({ css }).filter(({ path }) => path.startsWith("."));
+}
+
+export {
+  MAX_MEDIA_SVG_BYTES,
+  ignoredMediaDocumentWarning,
+  ignoredMediaPathWarning,
+  isHiddenMediaPath,
+  mediaFileTooLarge,
+  mediaFileByteLimit,
+  themeResourceByteLimit,
+  readBoundedMediaFile,
+  decodeCssPath,
+  cssImports,
+  localCssImports
+};

package/dist/{chunk-DWA3ZRGW.js → chunk-6C65KV7O.js}

@@ -3,10 +3,10 @@ import {
   assertLocalDirectory,
   assertOperationOutput,
   markOperationOutput
-} from "./chunk-GGKFQ3MA.js";
+} from "./chunk-6D2E6UMD.js";
 import {
   AppError
-} from "./chunk-WDY4IK6Z.js";
+} from "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/lifecycle/checkout-preparation.ts
 import { lstat, mkdir, readdir, realpath } from "fs/promises";

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({