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

package/dist/chunk-DWA3ZRGW.js

@@ -0,0 +1,142 @@
+import {
+  acquireOperationLock,
+  assertLocalDirectory,
+  assertOperationOutput,
+  markOperationOutput
+} from "./chunk-GGKFQ3MA.js";
+import {
+  AppError
+} from "./chunk-WDY4IK6Z.js";
+
+// src/lib/compiler/lifecycle/checkout-preparation.ts
+import { lstat, mkdir, readdir, realpath } from "fs/promises";
+import { isAbsolute, join } from "path";
+import { setTimeout } from "timers/promises";
+async function withCheckoutPreparation({
+  packageRoot,
+  workspaceRoot,
+  signal,
+  prepare
+}) {
+  signal?.throwIfAborted();
+  let selectedRoot = workspaceRoot ?? packageRoot;
+  if (!isAbsolute(selectedRoot))
+    throw new AppError({
+      code: "FRAMEWORK_LOCAL_SOURCE_INVALID",
+      message: "Checkout preparation requires an absolute checkout path."
+    });
+  let sourceRoot = await realpath(selectedRoot), sourceIdentity = await assertLocalDirectory(sourceRoot), outputRoot = join(sourceRoot, ".publish.os");
+  await mkdir(outputRoot).catch((error) => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  let rootIdentity = await assertLocalDirectory(outputRoot), outputDir = join(outputRoot, "checkout-dependencies"), output = { sourceRoot, outputDir, operation: "dependencies" }, created = !1;
+  await mkdir(outputDir).then(() => {
+    created = !0;
+  }).catch((error) => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  let identity = await assertLocalDirectory(outputDir);
+  if (created) {
+    if ((await readdir(outputDir)).length !== 0)
+      throw new AppError({
+        code: "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
+        message: `Checkout preparation metadata changed at ${outputDir}. Preserve it and inspect the owner before retrying.`
+      });
+    await markOperationOutput(output);
+  } else
+    for (let attempt = 0; ; attempt += 1) {
+      signal?.throwIfAborted(), await assertLocalDirectory(sourceRoot, sourceIdentity), await assertLocalDirectory(outputRoot, rootIdentity), await assertLocalDirectory(outputDir, identity);
+      let entries = await readdir(outputDir), published = entries.includes(".operation-owner.json");
+      published && await assertOperationOutput(output);
+      let temporary = entries.filter(
+        (name) => /^\.operation-owner-init-[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}\.tmp$/u.test(
+          name
+        )
+      );
+      if (entries.some(
+        (name) => !temporary.includes(name) && name !== ".operation-owner.json" && !(published && name === ".locks")
+      ))
+        throw new AppError({
+          code: "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
+          message: `Checkout preparation initialization cannot be verified at ${outputDir}. Preserve its files and inspect the owner before retrying.`
+        });
+      for (let name of temporary) {
+        let entry = await lstat(join(outputDir, name)).catch(
+          (error) => {
+            if (error.code !== "ENOENT") throw error;
+          }
+        );
+        if (entry && !entry.isFile())
+          throw new AppError({
+            code: "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
+            message: `Checkout preparation initialization is redirected at ${join(outputDir, name)}. Preserve the marker and restore its owner before retrying.`
+          });
+      }
+      if (published && temporary.length === 0) break;
+      if (attempt >= 50)
+        throw new AppError({
+          code: "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
+          message: `Checkout preparation initialization did not finish at ${outputDir}. Preserve its metadata and verify the initializer stopped before retrying.`
+        });
+      await setTimeout(10, void 0, { signal });
+    }
+  let assertCurrent = async () => {
+    if (await assertLocalDirectory(sourceRoot, sourceIdentity), await assertLocalDirectory(outputRoot, rootIdentity), await assertLocalDirectory(outputDir, identity), await assertOperationOutput(output), (await readdir(outputDir)).some(
+      (name) => name !== ".operation-owner.json" && name !== ".locks"
+    ))
+      throw new AppError({
+        code: "FRAMEWORK_LOCAL_LOCK_UNVERIFIED",
+        message: `Checkout preparation contains unknown files at ${outputDir}. Preserve them and inspect the owner before retrying.`
+      });
+  }, deadline = Date.now() + 36e4, release;
+  for (; ; ) {
+    signal?.throwIfAborted(), await assertCurrent();
+    try {
+      release = await acquireOperationLock({
+        sourceRoot,
+        outputRoot: outputDir,
+        operation: "dependencies",
+        signal
+      });
+      break;
+    } catch (error) {
+      if (!(error instanceof AppError) || error.code !== "FRAMEWORK_LOCAL_OPERATION_ACTIVE" || Date.now() >= deadline)
+        throw error;
+      await setTimeout(100, void 0, { signal });
+    }
+  }
+  let stopped = !0, failed = !1, failure, result;
+  try {
+    await assertCurrent(), signal?.throwIfAborted(), stopped = !1, result = await prepare(() => {
+      stopped = !0;
+    });
+  } catch (error) {
+    failed = !0, failure = error;
+  }
+  try {
+    await assertCurrent(), await release({ shutdownUnverified: !stopped });
+  } catch (error) {
+    if (!failed) throw error;
+    failure instanceof Error && (failure.cause = new AppError({
+      code: "FRAMEWORK_LOCAL_LOCK_UNVERIFIED",
+      message: `Checkout dependency lock retention failed at ${outputDir}. Preserve the metadata and verify the recorded preparer's descendants before recovery.`,
+      details: {
+        lockPath: join(outputDir, ".locks/dependencies"),
+        cause: error,
+        primaryCause: failure.cause
+      }
+    }));
+  }
+  if (failed) throw failure;
+  if (!stopped)
+    throw new AppError({
+      code: "FRAMEWORK_PROCESS_SHUTDOWN_FAILED",
+      message: `Checkout dependency preparation at ${sourceRoot} did not prove shutdown. Its lock remains protected.`,
+      fix: "Verify the recorded preparer's descendants stopped before recovering its retained lock."
+    });
+  return result;
+}
+
+export {
+  withCheckoutPreparation
+};