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

package/dist/chunk-GGKFQ3MA.js

@@ -0,0 +1,621 @@
+import {
+  PUBLIC_PAGEFIND_DIRECTORY
+} from "./chunk-YLTOLYWM.js";
+import {
+  AppError
+} from "./chunk-WDY4IK6Z.js";
+
+// src/lib/compiler/lifecycle/output-ownership.ts
+import { createHash, randomUUID } from "crypto";
+import { constants } from "fs";
+import {
+  link,
+  lstat,
+  mkdir,
+  open,
+  readdir,
+  realpath,
+  rename,
+  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_PAGEFIND_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_PAGEFIND_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 owner cannot be verified. Restore this source's output metadata before continuing."
+  });
+}
+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."
+    });
+  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 ensureOutputOwnership({
+  sourceRoot,
+  ownerSourceRoot = 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 () => {
+    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 assertOwner(), await assertDirectories(), {
+    outputRoot,
+    assertCurrent: async () => {
+      await assertDirectories(), await assertOwner();
+    }
+  };
+}
+
+// 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,
+  unlink as unlink2,
+  writeFile as writeFile2
+} from "fs/promises";
+import { hostname } from "os";
+import { join as join2, resolve } from "path";
+function lockError({
+  code,
+  message,
+  sourceRoot
+}) {
+  return new AppError({ code, message, details: { sourceRoot } });
+}
+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 (value.sourceRoot !== 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.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 rmdir(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 });
+    }
+  };
+}
+
+export {
+  assertGeneratedOutput,
+  prepareGeneratedOutputUpdate,
+  localOperationName,
+  assertOperationOutput,
+  markOperationOutput,
+  assertLocalDirectory,
+  ensureOutputOwnership,
+  acquireOperationLock
+};