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

package/dist/chunk-6D2E6UMD.js

@@ -0,0 +1,695 @@
+import {
+  PUBLIC_SEARCH_DIRECTORY
+} from "./chunk-EFO6AWXN.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/lifecycle/output-ownership.ts
+import { createHash, randomUUID } from "crypto";
+import { constants } from "fs";
+import {
+  link,
+  lstat,
+  mkdir,
+  mkdtemp,
+  open,
+  readdir,
+  realpath,
+  rename,
+  rmdir,
+  unlink,
+  writeFile
+} from "fs/promises";
+import { basename, dirname, join } from "path";
+var MUTABLE_PREVIEW_ENTRIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".next",
+  "next-env.d.ts",
+  "tsconfig.tsbuildinfo",
+  ".operation-owner.json",
+  ".preview-cache.json",
+  PUBLIC_SEARCH_DIRECTORY
+]);
+async function generatedInventory(outputDir, stagingDir) {
+  if (stagingDir && (dirname(stagingDir) !== outputDir || !/^\.refresh-[a-zA-Z0-9]{6}$/u.test(basename(stagingDir))))
+    throw modifiedOutput(stagingDir);
+  let inventory = /* @__PURE__ */ Object.create(null);
+  async function assertMutable(path) {
+    try {
+      let entry = await lstat(path);
+      if (entry.isDirectory()) {
+        if (await assertLocalDirectory(path), path === join(outputDir, ".next/dev/node_modules")) return;
+        for (let name of await readdir(path))
+          await assertMutable(join(path, name));
+      } else if (!entry.isFile()) throw redirectedOutput(path);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  async function visit(path) {
+    let absolute = join(outputDir, path), entry = await lstat(absolute);
+    if (stagingDir && absolute === stagingDir) {
+      await assertLocalDirectory(absolute);
+      return;
+    }
+    if (MUTABLE_PREVIEW_ENTRIES.has(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;
+    }
+    if (entry.isDirectory()) {
+      await assertLocalDirectory(absolute), inventory[path] = "directory";
+      for (let name of (await readdir(absolute)).sort())
+        await visit(path ? `${path}/${name}` : name);
+    } else if (entry.isFile()) {
+      let file = await open(
+        absolute,
+        constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+      );
+      try {
+        if (!(await file.stat()).isFile()) throw modifiedOutput(path);
+        inventory[path] = createHash("sha256").update(await file.readFile()).digest("hex");
+      } finally {
+        await file.close();
+      }
+    } else throw modifiedOutput(path);
+  }
+  return await visit(""), inventory;
+}
+function modifiedOutput(path) {
+  return new AppError({
+    code: "FRAMEWORK_LOCAL_OUTPUT_MODIFIED",
+    message: `Generated preview contains unverified or modified files: ${path || ".operation-owner.json"}. The files were preserved.`,
+    fix: "Move custom work into the authored source, or restore the generated file before restarting this preview."
+  });
+}
+async function assertGeneratedOutput(options) {
+  if (options.scope === void 0 || !await lstat(options.outputDir).then(() => !0).catch((error) => {
+    if (error.code !== "ENOENT") throw error;
+    return !1;
+  })) return;
+  let owner = await readGeneratedOwner(options.outputDir, options.scope), actual = await generatedInventory(
+    options.outputDir,
+    options.stagingDir
+  );
+  assertInventory(actual, [owner.generated]);
+}
+async function readGeneratedOwner(outputDir, scope) {
+  let owner = await readOwnership(
+    join(outputDir, ".operation-owner.json"),
+    16777216
+  );
+  if (!owner || owner.scope !== scope || owner.operation !== "dev" || !owner.generated || typeof owner.generated != "object" || Array.isArray(owner.generated))
+    throw modifiedOutput("");
+  return { ...owner, generated: owner.generated };
+}
+function assertInventory(actual, expected) {
+  for (let [path, digest] of Object.entries(actual))
+    if (!expected.some((inventory) => inventory[path] === digest))
+      throw modifiedOutput(path);
+}
+async function prepareGeneratedOutputUpdate(options) {
+  let scope = options.scope;
+  if (scope === void 0) return;
+  let output = { ...options, operation: "dev" };
+  await assertOperationOutput(output);
+  let identity = await assertLocalDirectory(options.outputDir), stagingIdentity = await assertLocalDirectory(options.stagingDir), owner = await readGeneratedOwner(options.outputDir, scope), current = await generatedInventory(
+    options.outputDir,
+    options.stagingDir
+  );
+  assertInventory(current, [owner.generated]);
+  let incoming = await generatedInventory(options.incoming), assertCurrent = async () => {
+    await assertLocalDirectory(options.outputDir, identity), await assertLocalDirectory(options.stagingDir, stagingIdentity), await assertOperationOutput(output);
+    let latest = await readGeneratedOwner(options.outputDir, scope);
+    if (JSON.stringify(latest) !== JSON.stringify(owner))
+      throw ownershipError();
+  };
+  return async () => {
+    await assertCurrent();
+    let actual = await generatedInventory(
+      options.outputDir,
+      options.stagingDir
+    );
+    assertInventory(actual, [owner.generated, incoming]);
+    let temporary = join(
+      options.stagingDir,
+      `.operation-owner-${randomUUID()}.tmp`
+    );
+    await writeFile(
+      temporary,
+      `${JSON.stringify({ ...owner, generated: actual })}
+`,
+      { flag: "wx" }
+    ), await assertCurrent(), await rename(temporary, join(options.outputDir, ".operation-owner.json"));
+  };
+}
+function localOperationName({
+  operation,
+  scope
+}) {
+  if (scope !== void 0 && (operation !== "dev" || typeof scope != "string" || !/^[a-f0-9]{64}$/u.test(scope)))
+    throw new AppError({
+      code: "FRAMEWORK_LOCAL_OPERATION_INVALID",
+      message: "A scoped development operation requires a lowercase SHA-256 identity. Retry with the selected preview's internal identity."
+    });
+  return scope === void 0 ? operation : `dev-${scope}`;
+}
+async function assertOperationOutput(options) {
+  if (localOperationName(options), !!await lstat(options.outputDir).then(() => !0).catch((error) => {
+    if (error.code !== "ENOENT") throw error;
+    return !1;
+  })) {
+    await assertLocalDirectory(options.outputDir);
+    try {
+      let owner = await readOwnership(
+        join(options.outputDir, ".operation-owner.json"),
+        options.scope === void 0 ? 16384 : 16777216
+      );
+      if (!owner || owner.schemaVersion !== 1 || owner.sourceRoot !== options.sourceRoot || owner.operation !== options.operation || owner.scope !== options.scope)
+        throw ownershipError();
+    } catch {
+      throw ownershipError();
+    }
+  }
+}
+async function markOperationOutput(options) {
+  localOperationName(options);
+  let identity = await assertLocalDirectory(options.outputDir), owner = {
+    schemaVersion: 1,
+    sourceRoot: options.sourceRoot,
+    operation: options.operation,
+    scope: options.scope,
+    ...options.scope === void 0 ? {} : { generated: await generatedInventory(options.outputDir) }
+  }, marker = join(options.outputDir, ".operation-owner.json"), temporary = join(
+    options.outputDir,
+    `.operation-owner-init-${randomUUID()}.tmp`
+  );
+  await writeFile(temporary, `${JSON.stringify(owner)}
+`, {
+    flag: "wx",
+    mode: 384
+  });
+  let failure;
+  try {
+    await assertLocalDirectory(options.outputDir, identity), await link(temporary, marker);
+  } catch (error) {
+    failure = { error };
+  }
+  try {
+    await assertLocalDirectory(options.outputDir, identity), await unlink(temporary);
+  } catch (error) {
+    if (!failure) throw error;
+    failure.error instanceof Error && (failure.error.cause = {
+      previous: failure.error.cause,
+      cleanup: error,
+      retained: temporary
+    });
+  }
+  if (failure) throw failure.error;
+}
+function ownershipError() {
+  return new AppError({
+    code: "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
+    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) {
+  return new AppError({
+    code: "FRAMEWORK_LOCAL_OUTPUT_REDIRECTED",
+    message: `The source-owned preview state was redirected at ${path}. Restore it before continuing. Linked targets were preserved.`
+  });
+}
+async function assertLocalDirectory(path, expected) {
+  let entry = await lstat(path);
+  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.",
+      details: { path }
+    });
+  return entry;
+}
+async function readOwnership(path, maximumSize = 16384) {
+  let file = await open(
+    path,
+    constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+  );
+  try {
+    let entry = await file.stat();
+    if (!entry.isFile() || entry.size > maximumSize) throw ownershipError();
+    return JSON.parse(await file.readFile("utf8"));
+  } finally {
+    await file.close();
+  }
+}
+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), assertCurrent = async () => {
+    await assertLocalDirectory(sourceRoot, sourceIdentity), await assertLocalDirectory(outputRoot, outputIdentity);
+  };
+  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;
+  }
+}
+
+// src/lib/compiler/lifecycle/operation-lock.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { constants as constants2 } from "fs";
+import {
+  lstat as lstat2,
+  mkdir as mkdir2,
+  open as open2,
+  readdir as readdir2,
+  realpath as realpath2,
+  rmdir as rmdir2,
+  unlink as unlink2,
+  writeFile as writeFile2
+} from "fs/promises";
+import { hostname } from "os";
+import { isAbsolute, join as join2, resolve } from "path";
+function lockError({
+  code,
+  message,
+  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,
+  sourceRoot
+}) {
+  let identity = await lstat2(path);
+  if (!identity.isDirectory() || identity.isSymbolicLink() || await realpath2(path) !== path)
+    throw lockError({
+      code: "FRAMEWORK_LOCAL_LOCK_REDIRECTED",
+      message: "The operation lock directory is redirected. Restore the source-owned output directory before retrying.",
+      sourceRoot
+    });
+  return identity;
+}
+async function verifyDirectory({
+  directory,
+  sourceRoot
+}) {
+  let current = await directoryIdentity({ path: directory.path, sourceRoot });
+  if (current.dev !== directory.identity.dev || current.ino !== directory.identity.ino)
+    throw lockError({
+      code: "FRAMEWORK_LOCAL_LOCK_REDIRECTED",
+      message: "The operation lock directory changed. Restore the source-owned output directory before retrying.",
+      sourceRoot
+    });
+}
+async function createLock({
+  path,
+  owner
+}) {
+  await mkdir2(path);
+  let identity = await directoryIdentity({
+    path,
+    sourceRoot: owner.sourceRoot
+  });
+  return await writeFile2(join2(path, "owner.json"), `${JSON.stringify(owner)}
+`, {
+    flag: "wx"
+  }), { path, identity };
+}
+async function readOwner({
+  directory,
+  sourceRoot
+}) {
+  await verifyDirectory({ directory, sourceRoot });
+  try {
+    let file = await open2(
+      join2(directory.path, "owner.json"),
+      constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK
+    );
+    try {
+      let identity = await file.stat();
+      if (!identity.isFile() || identity.size > 16384)
+        throw new Error("Invalid lock metadata file.");
+      let owner = JSON.parse(await file.readFile("utf8"));
+      if (!owner || typeof owner != "object")
+        throw new Error("Invalid lock metadata.");
+      let value = owner;
+      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
+      ))
+        throw new Error("Invalid lock metadata.");
+      return await verifyDirectory({ directory, sourceRoot }), value;
+    } finally {
+      await file.close();
+    }
+  } catch {
+    throw lockError({
+      code: "FRAMEWORK_LOCAL_LOCK_UNVERIFIED",
+      message: "The operation lock owner cannot be verified. Inspect the source-owned lock before retrying.",
+      sourceRoot
+    });
+  }
+}
+async function assertOwnedLock({
+  directory,
+  parent,
+  owner,
+  activePreparation = !1
+}) {
+  await verifyDirectory({ directory: parent, sourceRoot: owner.sourceRoot });
+  let current = await readOwner({ directory, sourceRoot: owner.sourceRoot });
+  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.",
+      sourceRoot: owner.sourceRoot
+    });
+  let files = await readdir2(directory.path);
+  if (activePreparation && owner.operation === "dependencies" && files.length === 2 && files.includes("owner.json") && files.includes("active-preparation.json"))
+    await assertPreparationMarker({ directory, owner });
+  else if (files.length !== 1 || files[0] !== "owner.json")
+    throw lockError({
+      code: "FRAMEWORK_LOCAL_LOCK_UNVERIFIED",
+      message: "The operation lock contains unknown files. Leave it in place and inspect the lock before retrying.",
+      sourceRoot: owner.sourceRoot
+    });
+  await verifyDirectory({ directory: parent, sourceRoot: owner.sourceRoot }), await verifyDirectory({ directory, sourceRoot: owner.sourceRoot });
+}
+async function assertPreparationMarker({
+  directory,
+  owner
+}) {
+  try {
+    let file = await open2(
+      join2(directory.path, "active-preparation.json"),
+      constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK
+    );
+    try {
+      let identity = await file.stat();
+      if (!identity.isFile() || identity.size > 16384 || await file.readFile("utf8") !== `${JSON.stringify(owner)}
+`)
+        throw new Error("Invalid active preparation marker.");
+    } finally {
+      await file.close();
+    }
+    await verifyDirectory({ directory, sourceRoot: owner.sourceRoot });
+  } catch {
+    throw lockError({
+      code: "FRAMEWORK_LOCAL_LOCK_UNVERIFIED",
+      message: "Dependency preparation shutdown cannot be verified. Preserve the checkout lock and verify its recorded processes before recovery.",
+      sourceRoot: owner.sourceRoot
+    });
+  }
+}
+async function removeOwnedLock({
+  directory,
+  parent,
+  owner,
+  beforeRemoval
+}) {
+  await assertOwnedLock({ directory, parent, owner }), beforeRemoval?.(), await unlink2(join2(directory.path, "owner.json")), await rmdir2(directory.path);
+}
+function assertDeadOwner({
+  owner,
+  operation,
+  scope
+}) {
+  if (owner.operation !== operation || owner.scope !== scope || owner.hostname !== hostname())
+    throw lockError({
+      code: "FRAMEWORK_LOCAL_LOCK_UNVERIFIED",
+      message: "The operation lock owner cannot be verified on this host. Inspect the recorded owner before retrying.",
+      sourceRoot: owner.sourceRoot
+    });
+  try {
+    process.kill(owner.pid, 0);
+  } catch (error) {
+    if (error.code === "ESRCH") return;
+    throw lockError({
+      code: "FRAMEWORK_LOCAL_LOCK_UNVERIFIED",
+      message: "The operation lock owner may still be running. Verify that process has stopped before retrying.",
+      sourceRoot: owner.sourceRoot
+    });
+  }
+  throw lockError({
+    code: "FRAMEWORK_LOCAL_OPERATION_ACTIVE",
+    message: `A ${operation} operation already owns ${owner.sourceRoot}. Stop that operation before starting another writer.`,
+    sourceRoot: owner.sourceRoot
+  });
+}
+async function acquireOperationLock({
+  sourceRoot,
+  outputRoot,
+  operation,
+  scope,
+  signal
+}) {
+  signal?.throwIfAborted();
+  let operationName = localOperationName({ operation, scope }), canonicalSource = await realpath2(sourceRoot), root = resolve(outputRoot);
+  await directoryIdentity({ path: root, sourceRoot: canonicalSource });
+  let locksPath = join2(root, ".locks");
+  await mkdir2(locksPath).catch((error) => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  let locks = {
+    path: locksPath,
+    identity: await directoryIdentity({
+      path: locksPath,
+      sourceRoot: canonicalSource
+    })
+  }, owner = {
+    sourceRoot: canonicalSource,
+    operation,
+    scope,
+    pid: process.pid,
+    hostname: hostname(),
+    token: randomUUID2()
+  }, transitionPath = join2(locksPath, `${operationName}.transition`), transition = async ({
+    waitForActive = !1
+  } = {}) => {
+    for (let attempt = 0; ; attempt += 1) {
+      await verifyDirectory({ directory: locks, sourceRoot: canonicalSource });
+      try {
+        return await createLock({ path: transitionPath, owner });
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        if (waitForActive && attempt < 50) {
+          await new Promise((resolve2) => setTimeout(resolve2, 10));
+          continue;
+        }
+        throw lockError({
+          code: "FRAMEWORK_LOCAL_LOCK_UNVERIFIED",
+          message: "Another operation is changing or recovering this lock. Wait for it to finish; inspect an abandoned transition before retrying.",
+          sourceRoot: canonicalSource
+        });
+      }
+    }
+  }, guard = await transition({
+    waitForActive: operation === "ide" || operation === "dependencies"
+  }), lock, interruptedRecovery = !1;
+  try {
+    signal?.throwIfAborted();
+    try {
+      lock = await createLock({ path: join2(locksPath, operationName), owner });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      let existing = {
+        path: join2(locksPath, operationName),
+        identity: await directoryIdentity({
+          path: join2(locksPath, operationName),
+          sourceRoot: canonicalSource
+        })
+      }, previous = await readOwner({
+        directory: existing,
+        sourceRoot: canonicalSource
+      });
+      operation === "dependencies" && await assertOwnedLock({
+        directory: existing,
+        parent: locks,
+        owner: previous,
+        activePreparation: !0
+      }), assertDeadOwner({ owner: previous, operation, scope }), signal?.throwIfAborted(), await removeOwnedLock({
+        directory: existing,
+        parent: locks,
+        owner: previous,
+        beforeRemoval: () => {
+          interruptedRecovery = !0;
+        }
+      }), signal?.throwIfAborted(), lock = await createLock({ path: join2(locksPath, operationName), owner }), interruptedRecovery = !1;
+    }
+    signal?.aborted && (await removeOwnedLock({ directory: lock, parent: locks, owner }), signal.throwIfAborted()), operation === "dependencies" && (interruptedRecovery = !0, await writeFile2(
+      join2(lock.path, "active-preparation.json"),
+      `${JSON.stringify(owner)}
+`,
+      { flag: "wx", mode: 384 }
+    ), interruptedRecovery = !1);
+  } finally {
+    interruptedRecovery || await removeOwnedLock({
+      directory: guard,
+      parent: locks,
+      owner
+    });
+  }
+  let released = !1;
+  return async ({ shutdownUnverified = !1 } = {}) => {
+    if (released) return;
+    let guard2 = await transition({ waitForActive: !0 }), preserveGuard = shutdownUnverified;
+    try {
+      shutdownUnverified ? (await assertOwnedLock({
+        directory: lock,
+        parent: locks,
+        owner,
+        activePreparation: operation === "dependencies"
+      }), await writeFile2(
+        join2(lock.path, "shutdown-unverified.json"),
+        `${JSON.stringify(owner)}
+`,
+        { flag: "wx", mode: 384 }
+      ), preserveGuard = !1) : (operation === "dependencies" && (await assertOwnedLock({
+        directory: lock,
+        parent: locks,
+        owner,
+        activePreparation: !0
+      }), await unlink2(join2(lock.path, "active-preparation.json"))), await removeOwnedLock({ directory: lock, parent: locks, owner })), released = !0;
+    } finally {
+      preserveGuard || await removeOwnedLock({ directory: guard2, parent: locks, owner });
+    }
+  };
+}
+
+// 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,
+  localOperationName,
+  assertOperationOutput,
+  markOperationOutput,
+  assertLocalDirectory,
+  ensureLocalOutputRoot,
+  recoverOperationOutput,
+  acquireOperationLock,
+  publishOwnedDirectory
+};