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

package/dist/dev-operation-TZDVJCN7.js

@@ -0,0 +1,1055 @@
+import {
+  withCheckoutPreparation
+} from "./chunk-DWA3ZRGW.js";
+import {
+  approveLocalComposition
+} from "./chunk-SVYGXXYR.js";
+import {
+  withLocalOperation
+} from "./chunk-B2V22WRT.js";
+import {
+  LocalProcessError,
+  installLocalApp,
+  localProcessEnvironment,
+  startLocalProcess
+} from "./chunk-WKTEO6RS.js";
+import {
+  assertGeneratedOutput,
+  assertLocalDirectory,
+  assertOperationOutput,
+  prepareGeneratedOutputUpdate
+} from "./chunk-GGKFQ3MA.js";
+import {
+  assertFrameworkSelection
+} from "./chunk-DLDFHU7Y.js";
+import "./chunk-7OGTPSKI.js";
+import {
+  PUBLIC_PAGEFIND_DIRECTORY,
+  isExcludedSourcePath
+} from "./chunk-YLTOLYWM.js";
+import "./chunk-AI2UULNX.js";
+import {
+  AppError,
+  readInstalledFramework
+} from "./chunk-WDY4IK6Z.js";
+
+// src/lib/compiler/lifecycle/dev-operation.ts
+import { createHash as createHash4 } from "crypto";
+import { mkdtemp as mkdtemp2, readFile as readFile5, realpath as realpath2, rm as rm3 } from "fs/promises";
+import { createServer } from "net";
+import { join as join5 } from "path";
+import { setTimeout as delay } from "timers/promises";
+import { stripVTControlCharacters } from "util";
+
+// src/lib/compiler/lifecycle/checkout-development.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdtemp, readFile as readFile2, rm, stat, writeFile } from "fs/promises";
+import { createRequire } from "module";
+import { dirname, isAbsolute, join as join2 } from "path";
+
+// src/lib/compiler/lifecycle/source-watch.ts
+import { createHash } from "crypto";
+import { watch } from "fs";
+import { lstat, readdir, readFile } from "fs/promises";
+import { join, relative } from "path";
+function ignored(sourceRoot, path, include) {
+  let name = relative(sourceRoot, path).replace(/\\/g, "/");
+  return (include ? !include(name) : isExcludedSourcePath(name)) || name.split("/").length === 1 && name.startsWith(".env") || name.split("/").some(
+    (segment) => ["node_modules", ".next", ".cache", ".turbo", ".git"].includes(segment)
+  );
+}
+function changesBetween(before, after) {
+  return [.../* @__PURE__ */ new Set([...before.keys(), ...after.keys()])].sort().flatMap((path) => {
+    let previous = before.get(path), current = after.get(path);
+    return previous === current ? [] : [
+      {
+        path,
+        action: previous === void 0 ? "added" : current === void 0 ? "deleted" : "edited"
+      }
+    ];
+  });
+}
+async function watchSource(options) {
+  let watchers = /* @__PURE__ */ new Map(), closed = !1, scan = Promise.resolve(), baseline = /* @__PURE__ */ new Map(), scanNow = async () => {
+    let visited = /* @__PURE__ */ new Set(), identity = /* @__PURE__ */ new Map();
+    await visit(options.sourceRoot, visited, identity);
+    for (let [path, entry] of watchers)
+      visited.has(path) || (entry.watcher.close(), watchers.delete(path));
+    return identity;
+  }, rescan = () => (scan = scan.then(async () => {
+    if (closed) return;
+    let identity = await scanNow();
+    changesBetween(baseline, identity).length > 0 && options.onChange();
+  }).catch(options.onError), scan), visit = async (directory, visited, identity) => {
+    if (closed || ignored(options.sourceRoot, directory, options.include))
+      return;
+    let entry = await lstat(directory, { bigint: !0 }).catch(
+      (error) => {
+        if (error.code !== "ENOENT") throw error;
+      }
+    );
+    if (closed) return;
+    if (entry && entry.isFile() && identity.set(
+      relative(options.sourceRoot, directory).replace(/\\/g, "/"),
+      [
+        entry.mode,
+        entry.dev,
+        entry.ino,
+        entry.size,
+        entry.mtimeNs,
+        entry.ctimeNs
+      ].map(String).join(":")
+    ), !entry?.isDirectory() || entry.isSymbolicLink()) {
+      watchers.get(directory)?.watcher.close(), watchers.delete(directory);
+      return;
+    }
+    visited.add(directory);
+    let previous = watchers.get(directory);
+    if (previous && (previous.dev !== entry.dev || previous.ino !== entry.ino) && (previous.watcher.close(), watchers.delete(directory)), !watchers.has(directory)) {
+      let watcher = watch(directory, (_event, filename) => {
+        closed || filename && ignored(
+          options.sourceRoot,
+          join(directory, filename),
+          options.include
+        ) || rescan();
+      });
+      watcher.on("error", (error) => {
+        closed || options.onError(error);
+      }), watchers.set(directory, { watcher, dev: entry.dev, ino: entry.ino });
+    }
+    let entries = await readdir(directory, { withFileTypes: !0 }).catch(
+      (error) => {
+        if (error.code !== "ENOENT" && error.code !== "ENOTDIR") throw error;
+        return [];
+      }
+    );
+    for (let child of entries)
+      await visit(join(directory, child.name), visited, identity);
+  };
+  try {
+    scan = scanNow().then((identity) => {
+      baseline = identity;
+    }), await scan;
+  } catch (error) {
+    closed = !0;
+    for (let { watcher } of watchers.values()) watcher.close();
+    throw error;
+  }
+  return {
+    reconcileStartup: rescan,
+    revision: async () => {
+      if (await scan, closed) return;
+      let before = await scanNow(), hash = createHash("sha256");
+      for (let path of [...before.keys()].sort()) {
+        let contents = await readFile(join(options.sourceRoot, path)).catch(
+          (error) => {
+            if (!(error.code === "ENOENT" || error.code === "ENOTDIR"))
+              throw error;
+          }
+        );
+        if (!contents) return;
+        hash.update(JSON.stringify([path, contents.byteLength])), hash.update("\0"), hash.update(contents);
+      }
+      let after = await scanNow();
+      return changesBetween(before, after).length === 0 ? `sha256:${hash.digest("hex")}` : void 0;
+    },
+    takeChanges: async () => {
+      if (await scan, closed) return [];
+      let current = await scanNow(), changes = changesBetween(baseline, current);
+      return baseline = current, changes;
+    },
+    stop: async () => {
+      closed = !0;
+      for (let { watcher } of watchers.values()) watcher.close();
+      watchers.clear(), await scan;
+    }
+  };
+}
+
+// src/lib/compiler/lifecycle/checkout-development.ts
+var compilerPaths = [
+  "src/compiler.ts",
+  "src/lib/compiler",
+  "compiler-assets/nextjs",
+  "release",
+  "package.json",
+  "tsconfig.json"
+], workspacePaths = [
+  "package.json",
+  "pnpm-lock.yaml",
+  "pnpm-workspace.yaml",
+  ".pnpmfile.mjs"
+], includesPath = (paths, path) => path === "" || paths.some(
+  (input) => input === path || input.startsWith(`${path}/`) || path.startsWith(`${input}/`)
+);
+async function watchCheckout(options) {
+  let workspaceRoot;
+  for (let directory = options.packageRoot; ; directory = dirname(directory)) {
+    if (await stat(join2(directory, "pnpm-workspace.yaml")).then((entry) => entry.isFile()).catch((error) => {
+      if (error.code !== "ENOENT") throw error;
+      return !1;
+    })) {
+      workspaceRoot = directory;
+      break;
+    }
+    if (directory === dirname(directory)) break;
+  }
+  let compiler = await watchSource({
+    ...options,
+    sourceRoot: options.packageRoot,
+    include: (path) => includesPath(
+      workspaceRoot === options.packageRoot ? [...compilerPaths, ...workspacePaths] : compilerPaths,
+      path
+    ) && path !== "compiler-assets/nextjs/defaults/root" && !path.startsWith("compiler-assets/nextjs/defaults/root/")
+  }), workspace;
+  try {
+    workspaceRoot && workspaceRoot !== options.packageRoot && (workspace = await watchSource({
+      ...options,
+      sourceRoot: workspaceRoot,
+      include: (path) => includesPath(workspacePaths, path)
+    }));
+  } catch (error) {
+    throw await compiler.stop(), error;
+  }
+  return {
+    workspaceRoot,
+    reconcileStartup: async () => {
+      await compiler.reconcileStartup(), await workspace?.reconcileStartup();
+    },
+    takeChanges: async () => [
+      ...(await compiler.takeChanges()).map((change) => ({
+        ...change,
+        path: `framework/${change.path}`,
+        dependency: workspacePaths.includes(change.path)
+      })),
+      ...(await workspace?.takeChanges() ?? []).map((change) => ({
+        ...change,
+        path: `workspace/${change.path}`,
+        dependency: !0
+      }))
+    ],
+    revision: async () => {
+      let revisions = [
+        await compiler.revision(),
+        await workspace?.revision()
+      ];
+      if (!(!revisions[0] || workspace && !revisions[1]))
+        return createHash2("sha256").update(JSON.stringify(revisions)).digest("hex");
+    },
+    dependencyRevision: async () => {
+      let hash = createHash2("sha256"), paths = /* @__PURE__ */ new Set([
+        join2(options.packageRoot, "package.json"),
+        ...workspacePaths.map(
+          (path) => join2(workspaceRoot ?? options.packageRoot, path)
+        )
+      ]);
+      for (let path of paths)
+        hash.update(path), hash.update(
+          await readFile2(path).catch((error) => {
+            if (error.code !== "ENOENT") throw error;
+            return "missing";
+          })
+        ), hash.update("\0");
+      return hash.digest("hex");
+    },
+    stop: async () => {
+      await Promise.all([compiler.stop(), workspace?.stop()]);
+    }
+  };
+}
+async function prepareCheckoutDependencies(options) {
+  if (!options.pnpmExecutable || !isAbsolute(options.pnpmExecutable))
+    throw new AppError({
+      code: "FRAMEWORK_PNPM_MISSING",
+      message: "Checkout development requires the caller's pnpm executable."
+    });
+  for (let root of /* @__PURE__ */ new Set([options.packageRoot, options.workspaceRoot])) {
+    if (!root) continue;
+    let manifest = JSON.parse(
+      await readFile2(join2(root, "package.json"), "utf8")
+    );
+    for (let kind of [
+      "dependencies",
+      "devDependencies",
+      "optionalDependencies"
+    ])
+      for (let [name, version] of Object.entries(manifest[kind] ?? {}))
+        if (["@publish.os/nextjs", "@publish.os/cli"].includes(name) && (typeof version != "string" || !/^(?:workspace:|link:|file:)/.test(version)))
+          throw new AppError({
+            code: "FRAMEWORK_SELECTION_INVALID",
+            message: "Checkout dependencies cannot acquire PublishOS packages from npm.",
+            fix: "Use the local workspace or artifact dependency, then save again."
+          });
+  }
+  try {
+    await withCheckoutPreparation({
+      packageRoot: options.packageRoot,
+      workspaceRoot: options.workspaceRoot,
+      signal: options.lifetime.signal,
+      prepare: async (confirmStopped) => {
+        try {
+          await startLocalProcess({
+            command: options.pnpmExecutable,
+            args: [
+              "--filter",
+              "@publish.os/nextjs...",
+              "install",
+              "--frozen-lockfile",
+              "--prefer-offline",
+              "--fetch-timeout=10000"
+            ],
+            cwd: options.workspaceRoot ?? options.packageRoot,
+            environment: {
+              ...localProcessEnvironment({ mode: "development" }),
+              CI: "true"
+            },
+            signal: AbortSignal.any([
+              options.lifetime.signal,
+              AbortSignal.timeout(12e4)
+            ]),
+            onShutdown: options.lifetime.onShutdown,
+            quiet: !0
+          }).completion, confirmStopped();
+        } catch (error) {
+          throw (!(error instanceof AppError) || error.code !== "FRAMEWORK_PROCESS_SHUTDOWN_FAILED") && confirmStopped(), error;
+        }
+      }
+    });
+  } catch (error) {
+    throw error instanceof LocalProcessError && error.output.trim() && process.stderr.write(error.output), error;
+  }
+}
+async function runCheckoutCompiler(options) {
+  let selection = options.request.context?.framework;
+  if (selection?.kind !== "checkout" || !options.request.paths.output)
+    throw new AppError({
+      code: "FRAMEWORK_SELECTION_INVALID",
+      message: "Compiler updates require the selected checkout and owned output."
+    });
+  let temporary = await mkdtemp(
+    join2(dirname(options.request.paths.output), "compiler-")
+  ), identity = await assertLocalDirectory(temporary), requestPath = join2(temporary, "request.json"), resultPath = join2(temporary, "result.json"), importIndex = process.execArgv.indexOf("--import"), retain = !1;
+  try {
+    await writeFile(requestPath, JSON.stringify(options.request), {
+      flag: "wx",
+      mode: 384
+    }), await startLocalProcess({
+      command: process.execPath,
+      args: [
+        "--import",
+        importIndex === -1 ? createRequire(join2(selection.packageRoot, "package.json")).resolve(
+          "tsx/esm"
+        ) : process.execArgv[importIndex + 1] ?? "",
+        join2(
+          selection.packageRoot,
+          "src/lib/compiler/lifecycle/checkout-compiler-worker.ts"
+        ),
+        requestPath,
+        resultPath
+      ],
+      cwd: selection.packageRoot,
+      environment: {
+        ...localProcessEnvironment({ mode: "development" }),
+        TSX_TSCONFIG_PATH: join2(selection.packageRoot, "tsconfig.json")
+      },
+      signal: AbortSignal.any([
+        options.lifetime.signal,
+        AbortSignal.timeout(18e4)
+      ]),
+      onShutdown: options.lifetime.onShutdown
+    }).completion;
+    let response = JSON.parse(await readFile2(resultPath, "utf8"));
+    if (response?.result?.type !== "result" || !["success", "failure", "cancelled"].includes(response.result.status) || !Array.isArray(response.events))
+      throw new Error("Invalid compiler result");
+    return response;
+  } catch (error) {
+    throw options.lifetime.signal.throwIfAborted(), error instanceof AppError && error.code === "FRAMEWORK_PROCESS_SHUTDOWN_FAILED" ? (retain = !0, error) : new AppError({
+      code: "FRAMEWORK_CHECKOUT_COMPILE_FAILED",
+      message: "The checkout compiler could not apply this edit.",
+      fix: "Correct the compiler error and save again. The previous preview remains available.",
+      details: { cause: error }
+    });
+  } finally {
+    retain || (await assertLocalDirectory(temporary, identity), await rm(temporary, { recursive: !0, force: !0 }));
+  }
+}
+
+// src/lib/compiler/lifecycle/preview-cache.ts
+import { createHash as createHash3 } from "crypto";
+import {
+  lstat as lstat2,
+  readdir as readdir2,
+  readFile as readFile3,
+  realpath,
+  writeFile as writeFile2
+} from "fs/promises";
+import { join as join3 } from "path";
+var CACHE_FILE = ".preview-cache.json", GENERATED_FILES = [
+  "package.json",
+  "pnpm-lock.yaml",
+  "manifest.generated.ts",
+  "next.config.mjs",
+  "postcss.config.mjs",
+  "proxy.ts",
+  "tsconfig.json"
+], GENERATED_DIRECTORIES = [".meta", "app", "source", "public", "scripts"], INSTALLATION_FILES = [
+  "node_modules/.modules.yaml",
+  "node_modules/.package-map.json",
+  "node_modules/.pnpm/lock.yaml",
+  "node_modules/next/package.json",
+  "node_modules/next/dist/bin/next",
+  "node_modules/@publish.os/nextjs/package.json"
+];
+async function hashEntry({
+  hash,
+  outputDir,
+  path
+}) {
+  let absolute = join3(outputDir, path), entry = await lstat2(absolute);
+  if (entry.isFile()) {
+    hash.update(`file:${JSON.stringify(path)}\0`), hash.update(await readFile3(absolute)), hash.update("\0");
+    return;
+  }
+  if (!entry.isDirectory())
+    throw new Error(`Unexpected generated preview entry: ${path}`);
+  hash.update(`directory:${JSON.stringify(path)}\0`);
+  for (let name of (await readdir2(absolute)).sort())
+    await hashEntry({ hash, outputDir, path: join3(path, name) });
+}
+async function outputIntegrity({
+  outputDir,
+  inputKind
+}) {
+  let hash = createHash3("sha256");
+  for (let path of [
+    ...GENERATED_FILES,
+    ...inputKind === "checkout" ? ["next.config.base.mjs"] : [],
+    ...GENERATED_DIRECTORIES,
+    ...INSTALLATION_FILES.filter(
+      (path2) => inputKind !== "checkout" || path2 !== "node_modules/@publish.os/nextjs/package.json"
+    )
+  ])
+    await hashEntry({ hash, outputDir, path });
+  return `sha256:${hash.digest("hex")}`;
+}
+async function reusablePreview(options) {
+  if (options.revision)
+    try {
+      let cache = JSON.parse(
+        await readFile3(join3(options.outputDir, CACHE_FILE), "utf8")
+      );
+      if (cache.version !== 5 || cache.inputKind !== (options.inputKind ?? "customer") || cache.runtimeGraph !== (options.inputKind === "checkout" ? "checkout-source" : void 0) || cache.runtime !== options.runtime || cache.sourcePath !== options.sourcePath || typeof cache.integrity != "string")
+        return;
+      let current = cache.revision === options.revision && cache.frameworkIdentity === options.frameworkIdentity && cache.compilerRevision === options.compilerRevision && cache.checkoutDependencyRevision === options.checkoutDependencyRevision && cache.url === options.url;
+      return !current && options.inputKind !== "checkout" || options.inputKind === "checkout" && (!options.checkoutRoot || await realpath(
+        join3(options.outputDir, "node_modules/@publish.os/nextjs")
+      ) !== await realpath(options.checkoutRoot)) || (options.ide && await readFile3(join3(options.sourceRoot, ".publish.os/ide/metadata.json")), cache.integrity !== await outputIntegrity(options)) ? void 0 : {
+        current,
+        dependenciesChanged: cache.checkoutDependencyRevision !== options.checkoutDependencyRevision
+      };
+    } catch {
+      return;
+    }
+}
+async function recordPreviewCache(options) {
+  if (!options.revision) return;
+  let cache = {
+    version: 5,
+    inputKind: options.inputKind ?? "customer",
+    ...options.inputKind === "checkout" ? { runtimeGraph: "checkout-source" } : {},
+    revision: options.revision,
+    runtime: options.runtime,
+    frameworkIdentity: options.frameworkIdentity,
+    ...options.compilerRevision ? { compilerRevision: options.compilerRevision } : {},
+    ...options.checkoutDependencyRevision ? { checkoutDependencyRevision: options.checkoutDependencyRevision } : {},
+    url: options.url,
+    sourcePath: options.sourcePath,
+    integrity: await outputIntegrity(options)
+  };
+  await writeFile2(
+    join3(options.outputDir, CACHE_FILE),
+    `${JSON.stringify(cache)}
+`
+  );
+}
+
+// src/lib/compiler/lifecycle/refresh-preview.ts
+import {
+  cp,
+  lstat as lstat3,
+  mkdir,
+  readdir as readdir3,
+  readFile as readFile4,
+  rename,
+  rm as rm2,
+  writeFile as writeFile3
+} from "fs/promises";
+import { dirname as dirname2, join as join4, relative as relative2 } from "path";
+var PRESERVED_PREVIEW_ENTRIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".next",
+  ".operation-owner.json",
+  ".preview-cache.json",
+  PUBLIC_PAGEFIND_DIRECTORY
+]);
+async function refreshPreview(options) {
+  let sync = async (source, target) => {
+    options.signal.throwIfAborted(), await assertLocalDirectory(source), await assertLocalDirectory(target);
+    let incoming = new Map(
+      (await readdir3(source, { withFileTypes: !0 })).map((entry) => [
+        entry.name,
+        entry
+      ])
+    ), previous = await readdir3(target, { withFileTypes: !0 }), preserved = (name) => {
+      let path = relative2(options.outputDir, join4(target, name)).replace(
+        /\\/g,
+        "/"
+      );
+      return PRESERVED_PREVIEW_ENTRIES.has(path) || path.startsWith(".refresh-");
+    };
+    for (let old of previous)
+      preserved(old.name) || incoming.has(old.name) || await rm2(join4(target, old.name), { recursive: !0, force: !0 });
+    for (let [name, entry] of incoming) {
+      if (preserved(name)) continue;
+      let from = join4(source, name), to = join4(target, name), old = await lstat3(to).catch((error) => {
+        if (error.code !== "ENOENT") throw error;
+      });
+      if (old?.isSymbolicLink() || entry.isSymbolicLink())
+        throw new AppError({
+          code: "FRAMEWORK_LOCAL_OUTPUT_REDIRECTED",
+          message: "Preview output was redirected. Restore the source-owned output before restarting preview."
+        });
+      if (entry.isDirectory() && old?.isDirectory())
+        await sync(from, to);
+      else if (entry.isFile() && old?.isFile()) {
+        if ((await readFile4(from)).equals(await readFile4(to))) continue;
+        await rename(from, to);
+      } else
+        old && await rm2(to, { recursive: !0, force: !0 }), await rename(from, to);
+    }
+  };
+  await assertLocalDirectory(options.incoming), await mkdir(join4(options.incoming, "public"), { recursive: !0 });
+  for (let path of PRESERVED_PREVIEW_ENTRIES) {
+    if (dirname2(path) === ".") continue;
+    (await lstat3(join4(options.outputDir, path)).catch(
+      (error) => {
+        if (error.code !== "ENOENT") throw error;
+      }
+    ))?.isDirectory() && await mkdir(join4(options.incoming, dirname2(path)), { recursive: !0 });
+  }
+  await sync(options.incoming, options.outputDir);
+}
+async function restartPreview(options) {
+  let previous = join4(options.incoming, "..", "previous"), previousIdentity = await assertLocalDirectory(options.outputDir);
+  await mkdir(previous);
+  let preserved = ["node_modules", ".next", ".operation-owner.json"];
+  for (let entry of await readdir3(options.outputDir))
+    preserved.includes(entry) || entry.startsWith(".refresh-") || await cp(join4(options.outputDir, entry), join4(previous, entry), {
+      recursive: !0
+    });
+  options.signal.throwIfAborted(), await assertLocalDirectory(options.outputDir, previousIdentity), await options.stop();
+  let movedDependencies = !1;
+  try {
+    options.dependencies && (await rename(
+      join4(options.outputDir, "node_modules"),
+      join4(previous, "node_modules")
+    ), movedDependencies = !0, await rename(
+      join4(options.incoming, "node_modules"),
+      join4(options.outputDir, "node_modules")
+    )), await refreshPreview(options), await options.start();
+  } catch (error) {
+    try {
+      await options.stop(), await assertLocalDirectory(options.outputDir, previousIdentity), movedDependencies && (await rename(
+        join4(options.outputDir, "node_modules"),
+        join4(options.incoming, "..", "failed-node_modules")
+      ).catch((cause) => {
+        if (cause.code !== "ENOENT") throw cause;
+      }), await rename(
+        join4(previous, "node_modules"),
+        join4(options.outputDir, "node_modules")
+      )), await refreshPreview({
+        incoming: previous,
+        outputDir: options.outputDir,
+        signal: AbortSignal.timeout(3e3)
+      });
+      let cache = await readFile4(join4(previous, ".preview-cache.json")).catch(
+        (cause) => {
+          if (cause.code !== "ENOENT") throw cause;
+        }
+      );
+      cache && await writeFile3(join4(options.outputDir, ".preview-cache.json"), cache), options.signal.aborted || await options.start();
+    } catch (cause) {
+      throw new AppError({
+        code: "FRAMEWORK_PREVIEW_RECOVERY_FAILED",
+        message: "The previous preview could not be restored. Generated recovery state was retained.",
+        fix: "Stop checkout dev and inspect the retained generated output before retrying.",
+        details: { cause: new AggregateError([error, cause]) }
+      });
+    }
+    throw error;
+  }
+}
+
+// src/lib/compiler/lifecycle/dev-operation.ts
+async function readSourceSelection(sourceRoot) {
+  let raw = await readFile5(
+    join5(sourceRoot, "publish.os.config.json"),
+    "utf8"
+  ).catch(() => "");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return;
+  }
+}
+async function availablePort({
+  port,
+  host
+}) {
+  return await new Promise((resolve) => {
+    let server = createServer();
+    server.unref(), server.once(
+      "error",
+      (error) => resolve(
+        host === "::1" && (error.code === "EAFNOSUPPORT" || error.code === "EADDRNOTAVAIL")
+      )
+    ), server.listen({ host, port }, () => server.close(() => resolve(!0)));
+  });
+}
+async function previewPort(requested, explicit) {
+  if (!Number.isInteger(requested) || requested < 1 || requested > 65535)
+    throw new AppError({
+      code: "FRAMEWORK_PREVIEW_PORT_INVALID",
+      message: "The preview port must be an integer from 1 through 65535. Set a valid --port value."
+    });
+  for (let port = requested; port <= 65535; port += 1) {
+    if (await availablePort({ port, host: "127.0.0.1" }) && await availablePort({ port, host: "::1" }) && await availablePort({ port }))
+      return port;
+    if (explicit) {
+      let alternative = await previewPort(
+        requested < 65535 ? requested + 1 : 8080,
+        !1
+      ).catch(() => {
+      });
+      throw new AppError({
+        code: "FRAMEWORK_PREVIEW_PORT_UNAVAILABLE",
+        message: `Port ${requested} is in use. Stop the server on that port${alternative ? ` or run publish.os dev --port ${alternative}` : " and choose another port"}.`
+      });
+    }
+  }
+  throw new AppError({
+    code: "FRAMEWORK_PREVIEW_PORT_UNAVAILABLE",
+    message: `No free preview port is available from ${requested} through 65535. Stop another local server or select a lower --port.`
+  });
+}
+async function runDevelopment(options) {
+  let requestedPort = options.request.port ?? 8080, port = await previewPort(
+    requestedPort,
+    options.request.portExplicit === !0
+  ), url = `http://localhost:${port}`, frameworkIdentity = options.request.context?.archive?.integrity ?? "", inputKind = options.request.context?.framework?.kind ?? "customer", framework = await readInstalledFramework();
+  options.request.context?.framework !== void 0 && (frameworkIdentity = await assertFrameworkSelection({
+    context: options.request.context,
+    framework,
+    runtime: void 0
+  }));
+  let sessionCancellation = new AbortController();
+  port !== requestedPort && options.onEvent?.({
+    type: "progress",
+    message: `Port ${requestedPort} is in use. Using ${port}.`
+  });
+  let scope = options.request.context?.framework?.kind === "checkout" ? createHash4("sha256").update(
+    JSON.stringify([
+      await realpath2(options.request.context.framework.packageRoot),
+      port
+    ])
+  ).digest("hex") : void 0;
+  return await withLocalOperation({
+    sourceRoot: options.request.paths.source,
+    outputDir: options.request.paths.output,
+    operation: "dev",
+    scope,
+    signal: options.signal ? AbortSignal.any([options.signal, sessionCancellation.signal]) : sessionCancellation.signal,
+    run: async (lifetime) => {
+      let localOptions = { ...options, signal: lifetime.signal }, stopped = !1, dirty = !1, refreshing, startupReconciliation, timer, ready = !1, checkoutWatch, checkoutDependenciesDirty = !1, rejectSession = () => {
+      }, failed = new Promise((_resolve, reject) => {
+        rejectSession = reject;
+      });
+      failed.catch(() => {
+      });
+      let abortSession = () => rejectSession(lifetime.signal.reason);
+      lifetime.signal.addEventListener("abort", abortSession, { once: !0 });
+      let watchOptions = {
+        onChange: () => {
+          dirty = !0, timer && clearTimeout(timer), timer = setTimeout(() => {
+            ready && drain();
+          }, 100);
+        },
+        onError: (cause) => {
+          let error = new AppError({
+            code: "FRAMEWORK_PREVIEW_WATCH_FAILED",
+            message: `The source watcher stopped: ${cause instanceof Error ? cause.message : String(cause)}. Restart preview after correcting the file-system error.`
+          });
+          sessionCancellation.abort(error), rejectSession(error);
+        }
+      }, sourceWatch = await watchSource({
+        ...watchOptions,
+        sourceRoot: lifetime.sourceRoot
+      });
+      lifetime.onShutdown(async () => {
+        stopped = !0, timer && clearTimeout(timer), await sourceWatch.stop(), await checkoutWatch?.stop(), await startupReconciliation, await refreshing;
+      }), options.request.context?.framework?.kind === "checkout" && (checkoutWatch = await watchCheckout({
+        ...watchOptions,
+        packageRoot: options.request.context.framework.packageRoot
+      }));
+      let initialRevision = await sourceWatch.revision(), initialCompilerRevision = await checkoutWatch?.revision(), initialDependencyRevision = await checkoutWatch?.dependencyRevision(), initialConfig = await readSourceSelection(lifetime.sourceRoot) ?? {}, reuse = await reusablePreview({
+        outputDir: lifetime.outputDir,
+        sourceRoot: lifetime.sourceRoot,
+        revision: initialRevision,
+        runtime: options.request.context?.framework ? `${framework.packageName}@${framework.version}` : initialConfig.runtime ?? "",
+        frameworkIdentity,
+        compilerRevision: initialCompilerRevision,
+        checkoutDependencyRevision: initialDependencyRevision,
+        inputKind,
+        url,
+        sourcePath: options.request.context?.sourcePath ?? "publish.os",
+        ide: !!options.request.context?.ide,
+        checkoutRoot: options.request.context?.framework?.kind === "checkout" ? options.request.context.framework.packageRoot : void 0
+      });
+      checkoutDependenciesDirty = reuse?.dependenciesChanged ?? !1;
+      let validateSource = async () => (await import("./validate-local-source-XRL2Y7XE.js")).validateLocalSource({
+        options: localOptions,
+        sourceDir: lifetime.sourceDir,
+        sourceRoot: lifetime.sourceRoot
+      }), prepared = reuse ? void 0 : await validateSource(), selection = {
+        runtime: options.request.context?.framework ? `${framework.packageName}@${framework.version}` : prepared?.source.config.runtime ?? initialConfig.runtime
+      }, assertSelection = async () => {
+        if (options.request.context?.framework) return;
+        let config = await readSourceSelection(lifetime.sourceRoot);
+        if (config && config.runtime !== selection.runtime)
+          throw new AppError({
+            code: "FRAMEWORK_PREVIEW_RESTART_REQUIRED",
+            message: "The framework pin changed. Restart publish.os dev to use the new selection."
+          });
+      };
+      if (options.request.context?.ide) {
+        let { prepareIdeSupport } = await import("./ide-support-ZNW7ODFY.js");
+        await prepareIdeSupport({
+          publishOsDir: lifetime.sourceRoot,
+          // Only a verified unchanged source can defer validation until IDE repair.
+          source: prepared?.source ?? (reuse?.current ? async () => (await validateSource()).source : (await validateSource()).source),
+          framework: prepared?.framework ?? framework,
+          frameworkOptions: localOptions
+        });
+      }
+      let compose = async (outputDir, preparedSource) => {
+        let { composeFrameworkSource } = await import("./compose-NN23UJGC.js");
+        await composeFrameworkSource({
+          request: {
+            ...options.request,
+            paths: { source: lifetime.sourceDir, output: outputDir },
+            context: {
+              ...options.request.context,
+              previewUrl: url,
+              sourcePath: options.request.context?.sourcePath ?? "publish.os",
+              sourceRevision: "local-development"
+            }
+          },
+          source: preparedSource,
+          signal: lifetime.signal,
+          onProgress: (message) => options.onEvent?.({ type: "progress", message })
+        });
+      }, search = async (outputDir) => {
+        options.onEvent?.({
+          type: "progress",
+          message: "Refreshing search index"
+        }), await startLocalProcess({
+          command: process.execPath,
+          args: [join5(outputDir, "scripts/build-search-index.mjs")],
+          cwd: outputDir,
+          signal: lifetime.signal,
+          onShutdown: lifetime.onShutdown,
+          environment: localProcessEnvironment({ mode: "development" })
+        }).completion;
+      };
+      prepared && (await approveLocalComposition({ options: localOptions }), await lifetime.replaceOutput(async (outputDir) => {
+        options.onEvent?.({ type: "progress", message: "Preparing preview" }), await compose(outputDir, prepared.source), await installLocalApp({
+          outputDir,
+          framework: prepared.framework,
+          options: localOptions,
+          lifetime
+        }), await search(outputDir), await assertSelection(), await recordPreviewCache({
+          outputDir,
+          revision: initialRevision,
+          runtime: selection.runtime ?? "",
+          frameworkIdentity,
+          compilerRevision: initialCompilerRevision,
+          checkoutDependencyRevision: initialDependencyRevision,
+          inputKind,
+          url,
+          sourcePath: options.request.context?.sourcePath ?? "publish.os"
+        });
+      }));
+      let outputIdentity = await assertLocalDirectory(lifetime.outputDir), assertOutput = async () => {
+        await assertLocalDirectory(lifetime.outputDir, outputIdentity), await assertOperationOutput({
+          sourceRoot: lifetime.sourceRoot,
+          outputDir: lifetime.outputDir,
+          operation: "dev",
+          scope
+        });
+      }, next, resolveSession = () => {
+      }, ended = new Promise((resolve) => {
+        resolveSession = resolve;
+      }), stopNext = async () => {
+        let current = next;
+        next = void 0, ready = !1, await current?.stop();
+      }, startNext = async (verifyStartup = !1) => {
+        let log = "", resolveReady = () => {
+        }, rejectReady = () => {
+        }, started = new Promise((resolve, reject) => {
+          resolveReady = resolve, rejectReady = reject;
+        }), observedReady = !1, observe = (value) => {
+          log = (log + value).slice(-4096), !(observedReady || !/Ready in\s+\S+/i.test(stripVTControlCharacters(log))) && (observedReady = !0, startupReconciliation = (async () => {
+            if (verifyStartup) {
+              let response = await fetch(
+                `${url}/_next/static/__publishos_ready__`,
+                {
+                  signal: AbortSignal.any([
+                    lifetime.signal,
+                    AbortSignal.timeout(15e3)
+                  ])
+                }
+              );
+              if (await response.body?.cancel(), response.status >= 500)
+                throw new AppError({
+                  code: "FRAMEWORK_PREVIEW_START_FAILED",
+                  message: "Next could not serve the restarted preview."
+                });
+            }
+            await sourceWatch.reconcileStartup(), await checkoutWatch?.reconcileStartup(), lifetime.signal.throwIfAborted(), !stopped && (ready = !0, options.onEvent?.({ type: "ready", url }), resolveReady(), drain());
+          })().catch(rejectReady));
+        }, nextExecutable = await realpath2(
+          join5(lifetime.outputDir, "node_modules/next/dist/bin/next")
+        );
+        options.onEvent?.({ type: "progress", message: "Starting Next" });
+        let current = startLocalProcess({
+          command: process.execPath,
+          args: [nextExecutable, "dev", "--port", String(port)],
+          cwd: lifetime.outputDir,
+          signal: lifetime.signal,
+          onShutdown: lifetime.onShutdown,
+          environment: localProcessEnvironment({ mode: "development" }),
+          onStdout: observe,
+          onStderr: observe
+        });
+        next = current, current.completion.then(
+          () => {
+            rejectReady(
+              new AppError({
+                code: "FRAMEWORK_PREVIEW_START_FAILED",
+                message: "Next stopped before preview readiness."
+              })
+            ), next === current && ready && resolveSession();
+          },
+          (error) => {
+            rejectReady(error), next === current && ready && !lifetime.signal.aborted && rejectSession(error);
+          }
+        );
+        let deadline = new AbortController();
+        try {
+          await Promise.race([
+            started,
+            delay(6e4, void 0, { signal: deadline.signal }).then(() => {
+              throw new AppError({
+                code: "FRAMEWORK_PREVIEW_START_FAILED",
+                message: "Next did not become ready within 60 seconds."
+              });
+            })
+          ]);
+        } finally {
+          deadline.abort();
+        }
+      }, refresh = async (compilerChanges) => {
+        checkoutDependenciesDirty ||= compilerChanges.some(
+          (change) => change.dependency
+        );
+        let revisionBefore = await sourceWatch.revision(), compilerRevisionBefore = await checkoutWatch?.revision(), dependencyRevisionBefore = await checkoutWatch?.dependencyRevision(), inputsCurrent = async () => revisionBefore !== void 0 && revisionBefore === await sourceWatch.revision() && (!checkoutWatch || compilerRevisionBefore !== void 0 && compilerRevisionBefore === await checkoutWatch.revision());
+        await assertSelection();
+        let validation = checkoutWatch ? void 0 : await (await import("./validate-local-source-XRL2Y7XE.js")).validateLocalSource({
+          options: localOptions,
+          sourceDir: lifetime.sourceDir,
+          sourceRoot: lifetime.sourceRoot
+        });
+        await assertSelection(), await assertOutput(), await assertGeneratedOutput({ outputDir: lifetime.outputDir, scope });
+        let temporary = await mkdtemp2(join5(lifetime.outputDir, ".refresh-")), identity = await assertLocalDirectory(temporary), retain = !1, recordGeneratedOutput, primaryFailure, cleanup = async () => {
+          try {
+            await assertOutput(), await assertLocalDirectory(temporary, identity), await recordGeneratedOutput?.(), await rm3(temporary, { recursive: !0, force: !0 });
+          } catch (error) {
+            if (!primaryFailure) throw error;
+            primaryFailure.error instanceof Error && (primaryFailure.error.cause = {
+              previous: primaryFailure.error.cause,
+              cleanup: error,
+              retained: temporary
+            });
+          }
+        }, acceptCompilation = (response) => {
+          for (let event of response.events)
+            (event.type === "diagnostics" || event.type === "progress") && options.onEvent?.(event);
+          if (response.result.status !== "success")
+            throw new AppError({
+              code: response.result.error?.code ?? "FRAMEWORK_CHECKOUT_COMPILE_FAILED",
+              message: response.result.error?.message ?? "The checkout compiler did not complete the update.",
+              fix: response.result.error?.fix ?? "Correct the reported error and save again. The previous preview remains available."
+            });
+        };
+        try {
+          let incoming = join5(temporary, "app");
+          if (checkoutWatch) {
+            compilerChanges.length && options.onEvent?.({
+              type: "restart",
+              target: "compiler",
+              reason: "Compiler inputs changed."
+            }), checkoutDependenciesDirty && (await prepareCheckoutDependencies({
+              packageRoot: framework.packageRoot,
+              workspaceRoot: checkoutWatch.workspaceRoot,
+              pnpmExecutable: options.request.context?.pnpmExecutable,
+              lifetime
+            }), checkoutDependenciesDirty = !1);
+            let request = {
+              ...options.request,
+              operation: "compose",
+              paths: { source: lifetime.sourceDir, output: incoming },
+              context: {
+                ...options.request.context,
+                previewUrl: url,
+                sourceRevision: "local-development",
+                sourcePath: options.request.context?.sourcePath ?? "publish.os"
+              }
+            }, response = await runCheckoutCompiler({ request, lifetime });
+            if (!await inputsCurrent())
+              return dirty = !0, !1;
+            acceptCompilation(response), framework = await readInstalledFramework();
+          } else validation && await compose(incoming, validation.source);
+          if (!await inputsCurrent())
+            return dirty = !0, !1;
+          await assertSelection(), await assertOutput();
+          let changed = async (name) => !(await readFile5(join5(incoming, name))).equals(
+            await readFile5(join5(lifetime.outputDir, name))
+          ), dependenciesChanged = checkoutWatch && (await changed("package.json") || await changed("pnpm-workspace.yaml") || await changed("pnpm-lock.yaml")), configurationChanged = checkoutWatch && (await changed("next.config.mjs") || await changed("next.config.base.mjs") || await changed("postcss.config.mjs"));
+          dependenciesChanged && await installLocalApp({
+            outputDir: incoming,
+            framework,
+            options: localOptions,
+            lifetime
+          });
+          let nextFrameworkIdentity = checkoutWatch ? await assertFrameworkSelection({
+            context: options.request.context,
+            framework,
+            runtime: void 0
+          }) : frameworkIdentity;
+          if (checkoutWatch && options.request.context?.ide && JSON.parse(
+            await readFile5(
+              join5(lifetime.sourceRoot, ".publish.os/ide/metadata.json"),
+              "utf8"
+            )
+          ).selection?.integrity !== nextFrameworkIdentity) {
+            let ide = await runCheckoutCompiler({
+              request: {
+                ...options.request,
+                operation: "validate",
+                paths: { source: lifetime.sourceRoot, output: incoming }
+              },
+              lifetime
+            });
+            acceptCompilation(ide);
+          }
+          if (!await inputsCurrent())
+            return dirty = !0, !1;
+          if (recordGeneratedOutput = await prepareGeneratedOutputUpdate({
+            sourceRoot: lifetime.sourceRoot,
+            outputDir: lifetime.outputDir,
+            scope,
+            incoming,
+            stagingDir: temporary
+          }), dependenciesChanged || configurationChanged) {
+            let serving = !!next;
+            serving && options.onEvent?.({
+              type: "restart",
+              target: "next",
+              reason: dependenciesChanged ? "App dependencies changed." : "Next startup configuration changed."
+            }), await restartPreview({
+              incoming,
+              outputDir: lifetime.outputDir,
+              dependencies: !!dependenciesChanged,
+              signal: lifetime.signal,
+              stop: stopNext,
+              start: async () => {
+                await search(lifetime.outputDir), serving && await startNext(!0);
+              }
+            });
+          } else
+            await refreshPreview({
+              incoming,
+              outputDir: lifetime.outputDir,
+              signal: lifetime.signal
+            }), await search(lifetime.outputDir);
+          return frameworkIdentity = nextFrameworkIdentity, await recordGeneratedOutput?.(), recordGeneratedOutput = void 0, revisionBefore && await inputsCurrent() && await recordPreviewCache({
+            outputDir: lifetime.outputDir,
+            revision: revisionBefore,
+            runtime: selection.runtime ?? "",
+            frameworkIdentity,
+            compilerRevision: compilerRevisionBefore,
+            checkoutDependencyRevision: dependencyRevisionBefore,
+            inputKind,
+            url,
+            sourcePath: options.request.context?.sourcePath ?? "publish.os"
+          }), !0;
+        } catch (error) {
+          if (error instanceof AppError && (error.code === "FRAMEWORK_PROCESS_SHUTDOWN_FAILED" || error.code === "FRAMEWORK_PREVIEW_RECOVERY_FAILED") && (retain = !0), !retain && !lifetime.signal.aborted && !await inputsCurrent())
+            return dirty = !0, !1;
+          throw primaryFailure = { error }, error;
+        } finally {
+          retain || await cleanup();
+        }
+      };
+      function drain() {
+        refreshing || stopped || !ready || lifetime.signal.aborted || (refreshing = (async () => {
+          for (; dirty && !stopped; ) {
+            dirty = !1;
+            let changes = await sourceWatch.takeChanges(), compilerChanges = await checkoutWatch?.takeChanges() ?? [];
+            changes.length && options.onEvent?.({ type: "changes", changes });
+            try {
+              await refresh(compilerChanges) && options.onEvent?.({ type: "updated" });
+            } catch (error) {
+              if (lifetime.signal.aborted) return;
+              if (error instanceof AppError && (error.code === "FRAMEWORK_PREVIEW_RESTART_REQUIRED" || error.code === "FRAMEWORK_PROCESS_SHUTDOWN_FAILED" || error.code === "FRAMEWORK_PREVIEW_RECOVERY_FAILED" || error.code.startsWith("FRAMEWORK_LOCAL_OUTPUT_"))) {
+                rejectSession(error);
+                return;
+              }
+              if (error instanceof AppError && error.code === "FRAMEWORK_SOURCE_INVALID")
+                continue;
+              options.onEvent?.({
+                type: "diagnostics",
+                diagnostics: {
+                  diagnostics: [
+                    {
+                      severity: "error",
+                      code: "FRAMEWORK_PREVIEW_REFRESH_FAILED",
+                      message: `Preview artifact refresh failed: ${error instanceof Error ? error.message : String(error)}`,
+                      correction: error instanceof AppError && error.fix ? error.fix : "Correct the source error and save again. The previous preview remains available."
+                    }
+                  ]
+                }
+              });
+            }
+          }
+        })().finally(() => {
+          refreshing = void 0, dirty && drain();
+        }));
+      }
+      return reuse && !reuse.current && await refresh([]), await startNext(), await Promise.race([ended, failed]), { type: "result", status: "success" };
+    }
+  });
+}
+export {
+  runDevelopment
+};