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

package/dist/chunk-UF6ATARM.js

@@ -0,0 +1,1100 @@
+import {
+  createIdeSourceArtifacts,
+  materializeAppInstallation,
+  prepareAppInstallation
+} from "./chunk-H6XILMZX.js";
+import {
+  supportedNextjsSourceImports
+} from "./chunk-NECL5IBJ.js";
+import {
+  installLocalApp
+} from "./chunk-WKTEO6RS.js";
+import {
+  acquireOperationLock,
+  assertLocalDirectory,
+  ensureOutputOwnership
+} from "./chunk-GGKFQ3MA.js";
+import {
+  assertFrameworkSelection,
+  readCheckoutTypeScriptConfig
+} from "./chunk-DLDFHU7Y.js";
+import {
+  runtimePackageVersion
+} from "./chunk-AI2UULNX.js";
+import {
+  AppError
+} from "./chunk-WDY4IK6Z.js";
+
+// src/lib/compiler/ide/ide-support.ts
+import { createHash, randomUUID } from "crypto";
+import {
+  cp,
+  link,
+  lstat,
+  mkdir,
+  readdir,
+  readFile,
+  realpath,
+  rm as rm2,
+  stat,
+  writeFile
+} from "fs/promises";
+import { createRequire } from "module";
+import {
+  basename as basename2,
+  dirname as dirname2,
+  isAbsolute,
+  join as join2,
+  relative,
+  resolve,
+  sep
+} from "path";
+import { isDeepStrictEqual } from "util";
+import { parseConfigFileTextToJson } from "typescript";
+
+// src/lib/compiler/ide/ide-install.ts
+async function runIdeInstall(options) {
+  let shutdown = /* @__PURE__ */ new Set(), failure;
+  try {
+    await installLocalApp({
+      ...options,
+      purpose: "ide",
+      lifetime: {
+        signal: options.options.signal ?? new AbortController().signal,
+        onShutdown: (stop) => (shutdown.add(stop), () => {
+          shutdown.delete(stop);
+        })
+      }
+    });
+  } catch (error) {
+    failure = error;
+  }
+  if ((await Promise.allSettled([...shutdown].map((stop) => stop()))).some((result) => result.status === "rejected"))
+    throw new AppError({
+      code: "FRAMEWORK_PROCESS_SHUTDOWN_FAILED",
+      message: "The IDE installer did not stop. Its staging files and lock remain in place.",
+      fix: "Stop and verify all installer descendants before recovering the retained IDE paths.",
+      details: { cause: failure }
+    });
+  if (failure) throw failure;
+}
+
+// src/lib/compiler/ide/ide-output.ts
+import { mkdtemp, rename, rm, symlink, unlink } from "fs/promises";
+import { basename, dirname, join } from "path";
+var IDE_CLEANUP_TIMEOUT_MS = 3e4;
+async function cleanupIdeFiles({
+  cleanup,
+  label
+}) {
+  let timer;
+  try {
+    await Promise.race([
+      cleanup(),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(
+          () => reject(
+            new AppError({
+              code: "IDE_CLEANUP_TIMEOUT",
+              message: `${label} did not finish within ${IDE_CLEANUP_TIMEOUT_MS} ms.`,
+              fix: "Stop and verify owned processes before you recover the retained IDE files."
+            })
+          ),
+          IDE_CLEANUP_TIMEOUT_MS
+        );
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function withIdeOutput({
+  outputDir,
+  assertOutputCurrent,
+  run,
+  assertReadyToCommit,
+  onCleanupError,
+  reuseDependencies
+}) {
+  let parent = dirname(outputDir);
+  await assertOutputCurrent();
+  let stage = await mkdtemp(join(parent, `.${basename(outputDir)}.tmp-`)), stageIdentity = await assertLocalDirectory(stage), assertStageCurrent = async () => {
+    await assertOutputCurrent(), await assertLocalDirectory(stage, stageIdentity);
+  }, backup = `${stage}.previous`, previous = !1, replaced = !1, dependenciesMoved = !1, backupIdentity;
+  try {
+    reuseDependencies && await symlink(
+      join(outputDir, "node_modules"),
+      join(stage, "node_modules"),
+      process.platform === "win32" ? "junction" : "dir"
+    ), await run(stage, assertStageCurrent), await assertStageCurrent(), await assertReadyToCommit(), await assertStageCurrent();
+    try {
+      await rename(outputDir, backup), previous = !0, backupIdentity = await assertLocalDirectory(backup);
+    } catch (error) {
+      if (reuseDependencies || error.code !== "ENOENT")
+        throw error;
+    }
+    try {
+      await assertStageCurrent(), reuseDependencies && (await unlink(join(stage, "node_modules")), await assertLocalDirectory(backup, backupIdentity), await rename(join(backup, "node_modules"), join(stage, "node_modules")), dependenciesMoved = !0), await rename(stage, outputDir), replaced = !0;
+    } catch (error) {
+      if (previous)
+        try {
+          await assertOutputCurrent(), await assertLocalDirectory(backup, backupIdentity), dependenciesMoved && await rename(
+            join(stage, "node_modules"),
+            join(backup, "node_modules")
+          ), await rename(backup, outputDir);
+        } catch (rollbackError) {
+          throw new AppError({
+            code: "IDE_ROLLBACK_FAILED",
+            message: `IDE output replacement failed. Previous output remains at ${backup}.`,
+            fix: "Restore the previous IDE output after all command processes stop.",
+            details: { error, rollbackError }
+          });
+        }
+      throw error;
+    }
+  } catch (error) {
+    if (error instanceof AppError && ["FRAMEWORK_PROCESS_SHUTDOWN_FAILED", "IDE_ROLLBACK_FAILED"].includes(
+      error.code
+    ))
+      throw error;
+    try {
+      await cleanupIdeFiles({
+        cleanup: async () => {
+          await assertStageCurrent(), await rm(stage, { recursive: !0, force: !0 });
+        },
+        label: "Temporary IDE output cleanup"
+      });
+    } catch (cleanupError) {
+      onCleanupError(cleanupError);
+    }
+    throw error;
+  }
+  if (previous && replaced)
+    try {
+      await cleanupIdeFiles({
+        cleanup: async () => {
+          await assertOutputCurrent(), await assertLocalDirectory(backup, backupIdentity), await rm(backup, { recursive: !0, force: !0 });
+        },
+        label: "Previous IDE output cleanup"
+      });
+    } catch (cleanupError) {
+      onCleanupError(cleanupError);
+    }
+}
+
+// src/lib/compiler/ide/ide-support.ts
+var IDE_SCHEMA_VERSION = 1, IDE_TSCONFIG = `${JSON.stringify(
+  { extends: "./.publish.os/ide/tsconfig.json" },
+  null,
+  2
+)}
+`, IDE_LOCK_TIMEOUT_MS = 3e4, IDE_LOCK_RETRY_MS = 50, IDE_RELEASE_GRAPH_FILES = [
+  "framework.tgz",
+  "package.json",
+  "pnpm-lock.yaml",
+  "pnpm-workspace.yaml"
+], IDE_GENERATED_FILES = [
+  ...IDE_RELEASE_GRAPH_FILES,
+  "tsconfig.json",
+  "source/.publishos/media-manifest.generated.ts",
+  "source/.publishos/icons.generated.tsx"
+], require2 = createRequire(import.meta.url);
+function portableIdeTsconfig() {
+  return IDE_TSCONFIG;
+}
+function ideDir(publishOsDir) {
+  return resolve(publishOsDir, ".publish.os", "ide");
+}
+function posixPath(path) {
+  return path.split(sep).join("/");
+}
+function relativeIdePath(ideRoot, path) {
+  let value = posixPath(relative(ideRoot, path));
+  return value.startsWith(".") ? value : `./${value}`;
+}
+function fileHash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function isMissing(error) {
+  return typeof error == "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function readOptional(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (isMissing(error)) return;
+    throw error;
+  }
+}
+async function readOptionalBytes(path) {
+  try {
+    return await readFile(path);
+  } catch (error) {
+    if (isMissing(error)) return;
+    throw error;
+  }
+}
+async function exists(path) {
+  return await stat(path).then(() => !0).catch((error) => {
+    if (isMissing(error)) return !1;
+    throw error;
+  });
+}
+function sourceRuntimeVersion(runtime) {
+  let version = runtimePackageVersion(runtime);
+  if (version === void 0)
+    throw new AppError({
+      code: "IDE_SOURCE_SELECTION_INVALID",
+      fix: 'Set runtime to "@publish.os/nextjs@<exact-version>" in publish.os.config.json. Use the exact framework version for this source.',
+      message: "IDE support could not read the current runtime pin."
+    });
+  return version;
+}
+async function sourceSelection(publishOsDir) {
+  let document;
+  try {
+    document = JSON.parse(
+      await readFile(resolve(publishOsDir, "publish.os.config.json"), "utf8")
+    );
+  } catch {
+    throw new AppError({
+      code: "IDE_SOURCE_SELECTION_INVALID",
+      fix: "Restore publish.os.config.json, then run publish.os init again.",
+      message: "IDE support could not read the current source selection."
+    });
+  }
+  return { runtimeVersion: sourceRuntimeVersion(document?.runtime) };
+}
+function assertSelectionCurrent(options) {
+  if (options.actual.runtimeVersion !== options.expected.runtimeVersion)
+    throw new AppError({
+      code: "IDE_SELECTION_STALE",
+      fix: "Run publish.os init again after the source change is complete.",
+      message: "The source runtime pin changed while IDE support was being prepared."
+    });
+}
+async function acquireIdeLock(options) {
+  let legacyLock = resolve(options.publishOsDir, ".publish.os", ".ide-lock"), deadline = Date.now() + IDE_LOCK_TIMEOUT_MS;
+  for (; ; ) {
+    options.signal.throwIfAborted(), await options.assertCurrent();
+    try {
+      if (!await lstat(legacyLock).then(
+        () => !0,
+        (error) => {
+          if (isMissing(error)) return !1;
+          throw error;
+        }
+      ))
+        return await acquireOperationLock({
+          sourceRoot: options.publishOsDir,
+          outputRoot: join2(options.publishOsDir, ".publish.os"),
+          operation: "ide",
+          signal: options.signal
+        });
+    } catch (error) {
+      if (!(error instanceof AppError)) throw error;
+      if (error.code !== "FRAMEWORK_LOCAL_OPERATION_ACTIVE")
+        throw new AppError({
+          code: "IDE_PREPARATION_PROTECTED",
+          message: `IDE preparation cannot verify the lock owner for ${options.publishOsDir}.`,
+          fix: `Inspect ${join2(options.publishOsDir, ".publish.os", ".locks", "ide")} and its recorded owner. Retry only after ownership and process shutdown can be verified; leave uncertain locks and source in place.`,
+          details: { sourceRoot: options.publishOsDir, causeCode: error.code }
+        });
+    }
+    if (Date.now() >= deadline)
+      throw new AppError({
+        code: "IDE_PREPARATION_BUSY",
+        fix: `Wait for the IDE preparation owner of ${options.publishOsDir} to finish, then retry. If the legacy lock ${legacyLock} remains, inspect its owner before recovering it.`,
+        message: `IDE support is already being prepared for ${options.publishOsDir}.`,
+        details: { sourceRoot: options.publishOsDir }
+      });
+    await new Promise((resolve2) => setTimeout(resolve2, IDE_LOCK_RETRY_MS)), options.signal.throwIfAborted();
+  }
+}
+function readIdeMetadata(source) {
+  if (source)
+    try {
+      let value = JSON.parse(source), files = value.files, selection = value.selection;
+      return value.schemaVersion !== IDE_SCHEMA_VERSION || !files || typeof files != "object" || Array.isArray(files) || ![
+        "tsconfig.json",
+        "source/.publishos/media-manifest.generated.ts",
+        ...IDE_RELEASE_GRAPH_FILES.filter(
+          (path) => path !== "framework.tgz" || selection?.inputKind !== "checkout"
+        )
+      ].every((path) => Object.hasOwn(files, path)) || Object.entries(files).some(
+        ([path, hash]) => !IDE_GENERATED_FILES.includes(path) || typeof hash != "string" || !/^[a-f0-9]{64}$/.test(hash)
+      ) || !selection || typeof selection.runtimeVersion != "string" || runtimePackageVersion(
+        `@publish.os/nextjs@${selection.runtimeVersion}`
+      ) === void 0 || selection.inputKind !== void 0 && !["customer", "checkout", "candidate"].includes(selection.inputKind) || (selection.integrity === void 0 ? selection.inputKind !== void 0 : typeof selection.integrity != "string" || !(selection.inputKind === "checkout" ? /^checkout:[a-f0-9]{64}$/u : /^sha512-[A-Za-z0-9+/]{86}==$/u).test(selection.integrity)) ? void 0 : value;
+    } catch {
+      return;
+    }
+}
+async function assertGeneratedIdeOutputUnchanged(options) {
+  let metadataSource = await readOptional(
+    join2(options.ideRoot, "metadata.json")
+  );
+  if (!metadataSource) {
+    if (await exists(options.ideRoot))
+      throw new AppError({
+        code: "IDE_OUTPUT_UNRECOGNIZED",
+        fix: `Inspect ${options.ideRoot} and preserve its custom files. Retry IDE preparation only after its generated ownership can be verified.`,
+        message: `IDE support found unrecognized output at ${options.ideRoot}.`
+      });
+    return;
+  }
+  let metadata = readIdeMetadata(metadataSource);
+  if (!metadata)
+    throw new AppError({
+      code: "IDE_OUTPUT_UNRECOGNIZED",
+      fix: `Inspect and restore recognized metadata at ${join2(options.ideRoot, "metadata.json")}, then retry. Preserve custom files and source.`,
+      message: `IDE support metadata is invalid at ${options.ideRoot}.`
+    });
+  let generatedFiles = /* @__PURE__ */ new Set([...IDE_GENERATED_FILES, "metadata.json"]), generatedDirectories = /* @__PURE__ */ new Set(["source", "source/.publishos"]), inspect = async (parent) => {
+    for (let entry of await readdir(join2(options.ideRoot, parent), {
+      withFileTypes: !0
+    })) {
+      let path = parent ? `${parent}/${entry.name}` : entry.name;
+      if (!(["node_modules", ".pnpm-store"].includes(path) && entry.isDirectory()) && !(generatedFiles.has(path) && entry.isFile())) {
+        if (generatedDirectories.has(path) && entry.isDirectory()) {
+          await inspect(path);
+          continue;
+        }
+        throw new AppError({
+          code: "IDE_OUTPUT_UNRECOGNIZED",
+          message: `IDE support found an unknown or redirected entry at ${join2(options.ideRoot, path)}.`,
+          fix: `Preserve custom files at ${options.ideRoot} and inspect their ownership before retrying IDE preparation.`
+        });
+      }
+    }
+  };
+  await inspect("");
+  let complete = !0;
+  for (let [path, expectedHash] of Object.entries(metadata.files)) {
+    let source = await readOptionalBytes(join2(options.ideRoot, path));
+    if (!source) {
+      complete = !1;
+      continue;
+    }
+    if (fileHash(source) !== expectedHash)
+      throw new AppError({
+        code: "IDE_OUTPUT_MODIFIED",
+        fix: `Inspect and restore the generated files at ${options.ideRoot}, then retry IDE preparation. Preserve custom files and source.`,
+        message: `PublishOS will not replace modified IDE output at ${options.ideRoot}.`
+      });
+  }
+  return { metadata, complete };
+}
+async function assertPortableIdeConfig(publishOsDir) {
+  let path = resolve(publishOsDir, "tsconfig.json"), source = await readOptional(path);
+  if (source === void 0) return "missing";
+  let parsed = parseConfigFileTextToJson(path, source), bases = Array.isArray(parsed.config?.extends) ? parsed.config.extends : [parsed.config?.extends];
+  if (!parsed.error && bases.some((base) => {
+    if (typeof base != "string" || !base.startsWith(".")) return !1;
+    let target = resolve(publishOsDir, base), generated = join2(ideDir(publishOsDir), "tsconfig.json");
+    return target === generated || `${target}.json` === generated;
+  }))
+    return "present";
+  throw new AppError({
+    code: "IDE_TSCONFIG_INCOMPATIBLE",
+    fix: `Set extends to "./.publish.os/ide/tsconfig.json" in ${path}, then retry IDE preparation.`,
+    message: `${path} must extend the generated IDE configuration. Custom source configuration was not replaced.`,
+    details: { sourceRoot: publishOsDir }
+  });
+}
+async function writePortableIdeConfig(options) {
+  let target = resolve(options.publishOsDir, "tsconfig.json"), temporary = `${target}.publishos-tmp-${process.pid}-${randomUUID()}`;
+  await options.assertCurrent(), await writeFile(temporary, portableIdeTsconfig(), { flag: "wx" });
+  try {
+    try {
+      return await options.assertCurrent(), await link(temporary, target), !0;
+    } catch (error) {
+      if (typeof error == "object" && error !== null && "code" in error && error.code === "EEXIST") {
+        if (await assertPortableIdeConfig(options.publishOsDir) === "missing")
+          throw new AppError({
+            code: "IDE_TSCONFIG_CHANGED",
+            fix: "Run publish.os init again after the source change is complete.",
+            message: "publish.os/tsconfig.json changed while IDE support was being prepared."
+          });
+        return !1;
+      }
+      throw error;
+    }
+  } finally {
+    try {
+      await cleanupIdeFiles({
+        cleanup: async () => {
+          await options.assertCurrent(), await rm2(temporary, { force: !0 });
+        },
+        label: "Temporary IDE configuration cleanup"
+      });
+    } catch {
+      options.warn(
+        "Could not remove a temporary IDE configuration file. Remove publish.os/tsconfig.json.publishos-tmp-* after this command finishes."
+      );
+    }
+  }
+}
+async function removePortableIdeConfigIfUnchanged(publishOsDir) {
+  let target = resolve(publishOsDir, "tsconfig.json");
+  await readOptional(target) === portableIdeTsconfig() && await rm2(target, { force: !0 });
+}
+async function assertIdeStateCurrent(options) {
+  let [rootConfig] = await Promise.all([
+    assertPortableIdeConfig(options.publishOsDir),
+    assertGeneratedIdeOutputUnchanged({ ideRoot: options.target })
+  ]);
+  if (rootConfig === "missing" && options.expectedRootConfig !== "missing")
+    throw new AppError({
+      code: "IDE_TSCONFIG_CHANGED",
+      fix: "Run publish.os init again after the source change is complete.",
+      message: "publish.os/tsconfig.json changed while IDE support was being prepared."
+    });
+  if (Object.hasOwn(options, "expectedRootConfigSource") && await readOptional(join2(options.publishOsDir, "tsconfig.json")) !== options.expectedRootConfigSource)
+    throw new AppError({
+      code: "IDE_TSCONFIG_CHANGED",
+      fix: "Run publish.os init again after the source change is complete.",
+      message: "The authored TypeScript configuration changed after IDE verification."
+    });
+  assertSelectionCurrent({
+    actual: await sourceSelection(options.publishOsDir),
+    expected: options.expectedSelection
+  });
+}
+async function packageTypePath(options) {
+  let packageName = options.specifier.split("/").slice(0, options.specifier.startsWith("@") ? 2 : 1).join("/"), packageRoot = join2(options.ideRoot, "node_modules", packageName);
+  try {
+    JSON.parse(await readFile(join2(packageRoot, "package.json"), "utf8"));
+  } catch {
+    throw new AppError({
+      code: "IDE_PACKAGE_MANIFEST_INVALID",
+      fix: "Run publish.os init again. If this continues, update the selected framework.",
+      message: `IDE support could not read ${options.specifier} package metadata.`
+    });
+  }
+  let resolved = options.typescript.resolveModuleName(
+    options.specifier,
+    join2(options.ideRoot, "source-check.tsx"),
+    {
+      module: options.typescript.ModuleKind.ESNext,
+      moduleResolution: options.typescript.ModuleResolutionKind.Bundler,
+      preserveSymlinks: !0
+    },
+    options.typescript.sys
+  ).resolvedModule;
+  if (!resolved || !/\.d\.[cm]?ts$/.test(resolved.resolvedFileName) || relativeIdePath(options.ideRoot, resolved.resolvedFileName).startsWith(
+    "../"
+  ))
+    throw new AppError({
+      code: "IDE_DECLARATION_MISSING",
+      fix: "Run publish.os init again. If this continues, update the selected framework.",
+      message: `The selected framework is missing types for ${options.specifier}.`
+    });
+  return relativeIdePath(options.ideRoot, resolved.resolvedFileName);
+}
+async function sourceImportPaths(options) {
+  let checkoutRoot = options.checkoutRoot, paths = {}, checkoutPaths = checkoutRoot ? (await readCheckoutTypeScriptConfig({ packageRoot: checkoutRoot })).paths : void 0, typescript = typescriptApi(options.ideRoot);
+  for (let specifier of supportedNextjsSourceImports()) {
+    if (options.checkoutRoot && (specifier === "@publish.os/nextjs" || specifier.startsWith("@publish.os/nextjs/"))) {
+      let source = checkoutPaths?.[specifier]?.[0];
+      if (!source)
+        throw new AppError({
+          code: "IDE_DECLARATION_MISSING",
+          message: `The selected checkout is missing the source entry for ${specifier}.`,
+          fix: "Select a complete framework checkout and repeat IDE preparation."
+        });
+      paths[specifier] = [posixPath(join2(options.checkoutRoot, source))];
+      continue;
+    }
+    paths[specifier] = [
+      await packageTypePath({
+        ideRoot: options.ideRoot,
+        specifier,
+        typescript
+      })
+    ];
+  }
+  if (checkoutRoot) {
+    paths["@/*"] = [posixPath(join2(checkoutRoot, "src/*"))];
+    for (let [specifier, sources] of Object.entries(checkoutPaths ?? {}))
+      specifier.startsWith("@components/") && (paths[specifier] = [
+        posixPath(
+          join2(
+            options.publishOsDir,
+            "components",
+            specifier.slice(12)
+          )
+        ),
+        ...sources.map((source) => posixPath(join2(checkoutRoot, source)))
+      ]);
+  }
+  return paths;
+}
+async function ideTsconfig(options) {
+  let frameworkComponents = join2(
+    options.ideRoot,
+    "node_modules",
+    "@publish.os",
+    "nextjs",
+    "dist",
+    "kernel",
+    "components",
+    "*"
+  ), paths = await sourceImportPaths({
+    ideRoot: options.ideRoot,
+    checkoutRoot: options.checkoutRoot,
+    publishOsDir: options.publishOsDir
+  });
+  return paths["@components/*"] = [
+    posixPath(resolve(options.publishOsDir, "components", "*")),
+    relativeIdePath(options.ideRoot, frameworkComponents)
+  ], paths["@source/*"] = [
+    posixPath(resolve(options.publishOsDir, "*")),
+    "./source/*"
+  ], `${JSON.stringify(
+    {
+      compilerOptions: {
+        allowJs: !0,
+        baseUrl: ".",
+        esModuleInterop: !0,
+        isolatedModules: !0,
+        jsx: "react-jsx",
+        lib: ["dom", "dom.iterable", "esnext"],
+        module: "esnext",
+        moduleResolution: "bundler",
+        noEmit: !0,
+        paths,
+        resolveJsonModule: !0,
+        skipLibCheck: !0,
+        strict: !0,
+        target: "ES2022",
+        typeRoots: ["./node_modules/@types"]
+      },
+      exclude: [
+        posixPath(resolve(options.publishOsDir, ".publish.os", "**/*"))
+      ],
+      include: [posixPath(resolve(options.publishOsDir, "**/*"))]
+    },
+    null,
+    2
+  )}
+`;
+}
+async function assertIdeDependencies(options) {
+  let required = [
+    join2(
+      options.ideRoot,
+      "node_modules",
+      "@publish.os",
+      "nextjs",
+      "package.json"
+    ),
+    join2(
+      options.ideRoot,
+      "node_modules",
+      "@phosphor-icons",
+      "react",
+      "package.json"
+    ),
+    join2(options.ideRoot, "node_modules", "typescript", "lib", "typescript.js"),
+    join2(options.ideRoot, "node_modules", "@types", "react", "index.d.ts")
+  ];
+  if (!(await Promise.all(required.map(exists))).every(Boolean))
+    throw new AppError({
+      code: "IDE_DEPENDENCIES_MISSING",
+      fix: "Run publish.os init again. If this continues, update the selected framework.",
+      message: "The selected framework app dependencies are incomplete."
+    });
+}
+function typescriptApi(ideRoot) {
+  try {
+    return require2(
+      join2(ideRoot, "node_modules", "typescript", "lib", "typescript.js")
+    );
+  } catch {
+    throw new AppError({
+      code: "IDE_TYPESCRIPT_MISSING",
+      fix: "Run publish.os init again. If this continues, update the selected framework.",
+      message: "The selected framework does not provide TypeScript for IDE support."
+    });
+  }
+}
+function assertResolvedModule(options) {
+  let file = options.typescript.resolveModuleName(
+    options.specifier,
+    join2(options.sourceRoot, "source-check.tsx"),
+    options.compilerOptions,
+    options.host
+  ).resolvedModule?.resolvedFileName;
+  if (file && /\.[cm]?tsx?$/u.test(file)) {
+    let local = relative(options.ideRoot, file);
+    if (!isAbsolute(local) && local !== ".." && !local.startsWith(`..${sep}`))
+      return;
+    if (options.specifier.startsWith("@components/") || options.specifier.startsWith("@source/") || options.specifier === "@publish.os/nextjs" || options.specifier.startsWith("@publish.os/nextjs/"))
+      for (let [alias, paths] of Object.entries(
+        options.compilerOptions.paths ?? {}
+      )) {
+        let [prefix = "", suffix] = alias.split("*");
+        if (suffix === void 0 ? alias !== options.specifier : !options.specifier.startsWith(prefix) || !options.specifier.endsWith(suffix))
+          continue;
+        let wildcard = options.specifier.slice(
+          prefix.length,
+          suffix ? -suffix.length : void 0
+        );
+        for (let path of paths) {
+          let target = resolve(
+            options.compilerOptions.baseUrl ?? options.ideRoot,
+            path.replace("*", wildcard)
+          );
+          if (file === target || file.replace(/(?:\.d)?\.[cm]?tsx?$/u, "") === target || file.replace(/[/\\]index(?:\.d)?\.[cm]?tsx?$/u, "") === target)
+            return;
+        }
+      }
+  }
+  throw new AppError({
+    code: "IDE_DECLARATION_UNRESOLVED",
+    fix: "Run publish.os init again. If this continues, update the selected framework.",
+    message: `IDE support could not resolve ${options.specifier}.`
+  });
+}
+async function verifyIdeConfiguration(options) {
+  let typescript = typescriptApi(options.ideRoot), finalIdeRoot = ideDir(options.finalPublishOsDir), rootConfigPath = join2(options.finalPublishOsDir, "tsconfig.json"), rootConfigSource = await readOptional(
+    join2(options.publishOsDir, "tsconfig.json")
+  ), authoredConfig = rootConfigSource ?? portableIdeTsconfig(), replaceRoot = (path, from, to) => {
+    let suffix = relative(from, path);
+    return suffix === "" || !isAbsolute(suffix) && !suffix.startsWith(`..${sep}`) && suffix !== ".." ? join2(to, suffix) : void 0;
+  }, stagedPath = (path) => replaceRoot(path, finalIdeRoot, options.ideRoot) ?? replaceRoot(path, options.finalPublishOsDir, options.publishOsDir) ?? path, finalPath = (path) => replaceRoot(path, options.ideRoot, finalIdeRoot) ?? replaceRoot(path, options.publishOsDir, options.finalPublishOsDir) ?? path, host = {
+    ...typescript.sys,
+    fileExists: (path) => path === rootConfigPath || typescript.sys.fileExists(stagedPath(path)),
+    directoryExists: (path) => typescript.sys.directoryExists(stagedPath(path)),
+    readFile: (path) => path === rootConfigPath ? authoredConfig : typescript.sys.readFile(stagedPath(path)),
+    readDirectory: (path, extensions, excludes, includes, depth) => typescript.sys.readDirectory(
+      stagedPath(path),
+      extensions,
+      excludes?.map(stagedPath),
+      includes?.map(stagedPath),
+      depth
+    ).map(finalPath),
+    getDirectories: (path) => typescript.sys.getDirectories(stagedPath(path)).map(finalPath),
+    realpath: (path) => path
+  }, configPath = join2(finalIdeRoot, "tsconfig.json"), read = typescript.readConfigFile(configPath, host.readFile);
+  if (read.error || !read.config)
+    throw new AppError({
+      code: "IDE_CONFIG_INVALID",
+      fix: "Run publish.os init again. If this continues, update the selected framework.",
+      message: "PublishOS could not read the generated IDE configuration."
+    });
+  let parsed = typescript.parseJsonConfigFileContent(
+    read.config,
+    host,
+    finalIdeRoot
+  ), authored = typescript.readConfigFile(rootConfigPath, host.readFile), project = typescript.parseJsonConfigFileContent(
+    authored.config,
+    host,
+    options.finalPublishOsDir
+  ), incompatible = (edit) => {
+    throw new AppError({
+      code: "IDE_TSCONFIG_INCOMPATIBLE",
+      fix: `${edit} in ${rootConfigPath}, then retry IDE preparation.`,
+      message: `The authored TypeScript configuration at ${rootConfigPath} does not preserve IDE support. Custom source configuration was not replaced.`,
+      details: { sourceRoot: options.publishOsDir }
+    });
+  };
+  for (let [specifier, paths] of Object.entries(parsed.options.paths ?? {})) {
+    let expected = paths.map(
+      (path) => resolve(parsed.options.baseUrl ?? finalIdeRoot, path)
+    ), actual = project.options.paths?.[specifier]?.map(
+      (path) => resolve(project.options.baseUrl ?? options.finalPublishOsDir, path)
+    );
+    if (!isDeepStrictEqual(actual, expected)) {
+      let override = Object.hasOwn(
+        authored.config.compilerOptions ?? {},
+        "paths"
+      ) ? "paths" : "baseUrl";
+      incompatible(
+        `Remove the compilerOptions.${override} override to restore ${specifier}`
+      );
+    }
+  }
+  if (parsed.fileNames.some((path) => !project.fileNames.includes(path))) {
+    let fields = ["files", "include", "exclude"].filter(
+      (field) => Object.hasOwn(authored.config, field)
+    );
+    incompatible(
+      `Remove the ${fields.join(", ")} overrides to include all authored files`
+    );
+  }
+  let configurationErrors = project.errors.filter(
+    (diagnostic) => diagnostic.code !== 18003 || parsed.fileNames.length > 0
+  );
+  if (authored.error || configurationErrors.length > 0) {
+    let diagnostic = authored.error ?? configurationErrors[0];
+    incompatible(
+      `Correct the TypeScript configuration error: ${typescript.flattenDiagnosticMessageText(diagnostic?.messageText ?? "Invalid configuration", " ")}`
+    );
+  }
+  for (let specifier of [
+    "react",
+    "react/jsx-runtime",
+    "next/link",
+    "@components/blocks/navbar",
+    ...supportedNextjsSourceImports()
+  ])
+    assertResolvedModule({
+      compilerOptions: project.options,
+      host,
+      ideRoot: finalIdeRoot,
+      sourceRoot: options.finalPublishOsDir,
+      specifier,
+      typescript
+    });
+  return { rootConfigSource };
+}
+async function copyReleaseGraph(options) {
+  let archive = options.frameworkOptions.request.context?.archive;
+  if (!archive && options.frameworkOptions.request.context?.framework?.kind !== "checkout")
+    throw new AppError({
+      code: "IDE_RELEASE_ARCHIVE_MISSING",
+      fix: "Use the exact selected framework archive, then run publish.os init again.",
+      message: "IDE support needs the selected framework archive."
+    });
+  let plan = await prepareAppInstallation({
+    archivePath: archive?.path,
+    archiveIntegrity: archive?.integrity,
+    framework: options.frameworkOptions.request.context?.framework
+  });
+  await materializeAppInstallation({
+    plan,
+    outputDir: options.ideRoot,
+    signal: options.frameworkOptions.signal
+  });
+}
+async function writeIdeFiles(options) {
+  let artifacts = await createIdeSourceArtifacts({
+    mediaManifest: options.source.assets.media.manifest
+  }), config = await ideTsconfig({
+    ideRoot: options.ideRoot,
+    publishOsDir: options.finalPublishOsDir,
+    checkoutRoot: options.checkoutRoot
+  }), files = {
+    "source/.publishos/media-manifest.generated.ts": artifacts.mediaModule,
+    "tsconfig.json": config
+  };
+  return await Promise.all(
+    Object.entries(files).map(async ([path, source]) => {
+      let destination = join2(options.ideRoot, path);
+      await mkdir(dirname2(destination), { recursive: !0 }), await writeFile(destination, source);
+    })
+  ), {
+    files: Object.fromEntries(
+      Object.entries(files).map(([path, source]) => [path, fileHash(source)])
+    ),
+    schemaVersion: IDE_SCHEMA_VERSION,
+    selection: options.selection
+  };
+}
+async function releaseGraphFileHashes(ideRoot, selection) {
+  let hashes = {};
+  for (let path of IDE_RELEASE_GRAPH_FILES) {
+    if (path === "framework.tgz" && selection.inputKind === "checkout")
+      continue;
+    let source = await readOptionalBytes(join2(ideRoot, path));
+    if (!source)
+      throw new AppError({
+        code: "IDE_RELEASE_GRAPH_INVALID",
+        fix: "Run publish.os init again. If this continues, update the selected framework.",
+        message: `IDE support is missing generated ${path}.`
+      });
+    hashes[path] = fileHash(source);
+  }
+  return hashes;
+}
+async function copyExistingIdeOutput(options) {
+  let entries = (await readdir(options.ideRoot)).filter(
+    (entry) => entry !== "node_modules"
+  );
+  await Promise.all(
+    entries.map(
+      async (entry) => await cp(join2(options.ideRoot, entry), join2(options.stageRoot, entry), {
+        force: !0,
+        recursive: !0
+      })
+    )
+  );
+}
+async function canonicalSourceLocation(path) {
+  let parent = dirname2(path), canonicalParent = await realpath(parent).catch(
+    async (error) => {
+      if (error.code !== "ENOENT") throw error;
+      return await canonicalSourceLocation(parent);
+    }
+  );
+  return join2(canonicalParent, basename2(path));
+}
+async function prepareIdeSupport(input) {
+  let requestedFinalLocation = input.finalPublishOsDir ?? input.publishOsDir;
+  if (!isAbsolute(requestedFinalLocation) || basename2(requestedFinalLocation) !== "publish.os" || requestedFinalLocation.split(sep).some((part) => [".publish.os", "node_modules", ".git"].includes(part)))
+    throw new AppError({
+      code: "IDE_FINAL_SOURCE_INVALID",
+      fix: "Choose an absolute source path whose final folder is publish.os, outside generated or dependency folders.",
+      message: "IDE support received an invalid final source location."
+    });
+  let options = {
+    ...input,
+    publishOsDir: await canonicalSourceLocation(input.publishOsDir)
+  }, finalPublishOsDir = await canonicalSourceLocation(
+    requestedFinalLocation
+  ), authoredSelection = await sourceSelection(options.publishOsDir);
+  typeof options.source != "function" && assertSelectionCurrent({
+    actual: authoredSelection,
+    expected: {
+      runtimeVersion: sourceRuntimeVersion(options.source.config.runtime)
+    }
+  });
+  let identity = await assertFrameworkSelection({
+    context: options.frameworkOptions.request.context,
+    framework: options.framework,
+    runtime: `@publish.os/nextjs@${authoredSelection.runtimeVersion}`
+  }), selection = {
+    runtimeVersion: options.framework.version,
+    inputKind: options.frameworkOptions.request.context?.framework?.kind ?? "customer",
+    integrity: identity
+  }, signal = options.frameworkOptions.signal ?? new AbortController().signal, throwIfInterrupted = () => signal.throwIfAborted(), warn = (message) => options.frameworkOptions.onEvent?.({
+    type: "diagnostics",
+    diagnostics: {
+      diagnostics: [
+        { code: "IDE_CLEANUP_WARNING", severity: "warning", message }
+      ]
+    }
+  }), releaseLock, lockIdentity, releaseLockError, retainInstallerState = !1, stagedIdeDirectory, ownership = await ensureOutputOwnership({
+    sourceRoot: options.publishOsDir,
+    ownerSourceRoot: finalPublishOsDir
+  }).catch((error) => {
+    throw !(error instanceof AppError) || ![
+      "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
+      "FRAMEWORK_LOCAL_OUTPUT_REDIRECTED"
+    ].includes(error.code) ? error : new AppError({
+      code: "IDE_PREPARATION_PROTECTED",
+      message: `IDE preparation cannot verify source-owned output for ${options.publishOsDir}.`,
+      fix: `Inspect ${join2(options.publishOsDir, ".publish.os")} ownership, including ${join2(options.publishOsDir, ".publish.os", ".ide-lock")} and ${join2(options.publishOsDir, ".publish.os", ".locks", "ide")}. Preserve redirected or uncertain entries until their ownership can be verified, then retry.`,
+      details: { sourceRoot: options.publishOsDir, causeCode: error.code }
+    });
+  }), lockDirectory = join2(ownership.outputRoot, ".locks", "ide");
+  try {
+    releaseLock = await acquireIdeLock({
+      assertCurrent: ownership.assertCurrent,
+      publishOsDir: options.publishOsDir,
+      signal
+    }), lockIdentity = await assertLocalDirectory(lockDirectory), throwIfInterrupted(), await ownership.assertCurrent();
+    let target = ideDir(options.publishOsDir), targetIdentity = await assertLocalDirectory(target).catch(
+      (error) => {
+        if (error.code !== "ENOENT") throw error;
+      }
+    ), assertTargetCurrent = async () => {
+      await ownership.assertCurrent(), targetIdentity && await assertLocalDirectory(target, targetIdentity);
+    }, [existingOutput, rootConfig] = await Promise.all([
+      assertGeneratedIdeOutputUnchanged({ ideRoot: target }),
+      assertPortableIdeConfig(options.publishOsDir)
+    ]), existingMetadata = existingOutput?.metadata, dependenciesReady = existingMetadata ? await assertIdeDependencies({ ideRoot: target }).then(
+      () => !0,
+      (error) => {
+        if (error instanceof AppError && error.code === "IDE_DEPENDENCIES_MISSING")
+          return !1;
+        throw error;
+      }
+    ) : !1, preserve = options.frameworkOptions.request.context?.ide?.policy === "preserve" && existingOutput?.complete === !0 && dependenciesReady, checkoutGraphUnchanged = !1;
+    if (!preserve && selection.inputKind === "checkout" && existingMetadata?.selection.inputKind === "checkout") {
+      let plan = await prepareAppInstallation({
+        framework: options.frameworkOptions.request.context?.framework
+      });
+      checkoutGraphUnchanged = (await Promise.all(
+        [
+          ["package.json", plan.files.packageJsonSource],
+          ["pnpm-workspace.yaml", plan.files.pnpmWorkspaceSource],
+          ["pnpm-lock.yaml", plan.files.lockfileSource]
+        ].map(
+          async ([path, contents]) => await readOptional(join2(target, path)) === contents
+        )
+      )).every(Boolean);
+    }
+    let reusable = existingOutput?.complete === !0 && existingMetadata?.selection.runtimeVersion === selection.runtimeVersion && existingMetadata.selection.inputKind === selection.inputKind && (existingMetadata.selection.integrity === selection.integrity || checkoutGraphUnchanged) && !Object.keys(existingMetadata.files).some(
+      (path) => path.endsWith("icons.generated.tsx")
+    ) && dependenciesReady;
+    if (preserve || reusable) {
+      let verified = await verifyIdeConfiguration({
+        ideRoot: target,
+        finalPublishOsDir,
+        publishOsDir: options.publishOsDir
+      }).catch((error) => {
+        if (error instanceof AppError && error.code === "IDE_DECLARATION_UNRESOLVED") {
+          reusable = !1;
+          return;
+        }
+        throw error;
+      });
+      if (verified && rootConfig === "present" && (preserve || typeof options.source == "function")) {
+        await assertTargetCurrent(), await assertIdeStateCurrent({
+          expectedRootConfig: rootConfig,
+          expectedRootConfigSource: verified.rootConfigSource,
+          expectedSelection: authoredSelection,
+          publishOsDir: options.publishOsDir,
+          target
+        }), throwIfInterrupted();
+        let release = releaseLock;
+        releaseLock = void 0, await cleanupIdeFiles({ cleanup: release, label: "IDE lock cleanup" });
+        return;
+      }
+    }
+    let source = typeof options.source == "function" ? await options.source() : options.source;
+    assertSelectionCurrent({
+      actual: await sourceSelection(options.publishOsDir),
+      expected: { runtimeVersion: sourceRuntimeVersion(source.config.runtime) }
+    }), reusable || options.frameworkOptions.onEvent?.({
+      type: "progress",
+      message: "Installing the selected framework app dependencies for IDE support..."
+    });
+    let wroteRootConfig = !1;
+    try {
+      await assertPortableIdeConfig(options.publishOsDir);
+      let stagedMetadata, verifiedConfiguration;
+      await withIdeOutput({
+        assertOutputCurrent: ownership.assertCurrent,
+        onCleanupError: () => {
+          warn(
+            "Could not remove temporary IDE output. The original error remains the command error."
+          );
+        },
+        outputDir: target,
+        reuseDependencies: reusable,
+        run: async (stageRoot, assertStageCurrent) => {
+          if (stagedIdeDirectory = stageRoot, await assertStageCurrent(), await assertTargetCurrent(), reusable)
+            await copyExistingIdeOutput({ ideRoot: target, stageRoot });
+          else {
+            await copyReleaseGraph({
+              ideRoot: stageRoot,
+              frameworkOptions: options.frameworkOptions,
+              selection
+            });
+            let expectedGraph = await releaseGraphFileHashes(
+              stageRoot,
+              selection
+            ), assertInstallGraph = async () => {
+              if (await assertStageCurrent(), await assertTargetCurrent(), !isDeepStrictEqual(
+                await releaseGraphFileHashes(stageRoot, selection),
+                expectedGraph
+              ))
+                throw new AppError({
+                  code: "IDE_INSTALL_GRAPH_CHANGED",
+                  message: "IDE installation changed the released dependency graph.",
+                  fix: "Use the unchanged selected framework release. IDE output was not replaced."
+                });
+            };
+            await runIdeInstall({
+              outputDir: stageRoot,
+              framework: options.framework,
+              options: options.frameworkOptions,
+              assertInstallGraph: async () => {
+                await assertInstallGraph(), await assertPortableIdeConfig(options.publishOsDir);
+              }
+            }), throwIfInterrupted(), await assertInstallGraph();
+          }
+          await assertStageCurrent(), await assertTargetCurrent(), await assertIdeDependencies({
+            ideRoot: stageRoot
+          }), await assertStageCurrent(), stagedMetadata = await writeIdeFiles({
+            finalPublishOsDir,
+            ideRoot: stageRoot,
+            publishOsDir: options.publishOsDir,
+            selection,
+            source,
+            checkoutRoot: options.frameworkOptions.request.context?.framework?.kind === "checkout" ? options.framework.packageRoot : void 0
+          }), await assertStageCurrent(), stagedMetadata.files = {
+            ...await releaseGraphFileHashes(stageRoot, selection),
+            ...stagedMetadata.files
+          }, verifiedConfiguration = await verifyIdeConfiguration({
+            ideRoot: stageRoot,
+            finalPublishOsDir,
+            publishOsDir: options.publishOsDir
+          }), await assertStageCurrent(), await assertTargetCurrent(), await assertIdeStateCurrent({
+            expectedRootConfig: rootConfig,
+            expectedRootConfigSource: verifiedConfiguration.rootConfigSource,
+            expectedSelection: authoredSelection,
+            publishOsDir: options.publishOsDir,
+            target
+          }), throwIfInterrupted(), await assertStageCurrent(), await writeFile(
+            join2(stageRoot, "metadata.json"),
+            `${JSON.stringify(stagedMetadata, null, 2)}
+`
+          );
+        },
+        assertReadyToCommit: async () => {
+          await assertTargetCurrent(), await assertIdeStateCurrent({
+            expectedRootConfig: rootConfig,
+            expectedRootConfigSource: verifiedConfiguration?.rootConfigSource,
+            expectedSelection: authoredSelection,
+            publishOsDir: options.publishOsDir,
+            target
+          }), throwIfInterrupted(), rootConfig === "missing" && (wroteRootConfig = await writePortableIdeConfig({
+            assertCurrent: ownership.assertCurrent,
+            publishOsDir: options.publishOsDir,
+            warn
+          })), await assertTargetCurrent(), await assertIdeStateCurrent({
+            expectedRootConfigSource: wroteRootConfig ? portableIdeTsconfig() : verifiedConfiguration?.rootConfigSource,
+            expectedSelection: authoredSelection,
+            publishOsDir: options.publishOsDir,
+            target
+          }), throwIfInterrupted();
+        }
+      });
+    } catch (error) {
+      if (isShutdownFailure(error)) {
+        retainInstallerState = !0;
+        try {
+          await ownership.assertCurrent(), await assertLocalDirectory(lockDirectory, lockIdentity), await writeFile(
+            join2(lockDirectory, "shutdown-unverified.json"),
+            `${JSON.stringify({ stage: stagedIdeDirectory })}
+`,
+            { flag: "wx" }
+          );
+        } catch {
+          warn(
+            "Could not mark the retained IDE lock as unverified. Inspect its installer descendants before recovering it."
+          );
+        }
+        throw warn(
+          `Could not confirm that the IDE installer stopped. Temporary files remain at ${stagedIdeDirectory}. The lock remains at ${lockDirectory}. Stop the installer and its child processes before you inspect these paths.`
+        ), error;
+      }
+      if (wroteRootConfig)
+        try {
+          await cleanupIdeFiles({
+            cleanup: async () => {
+              await ownership.assertCurrent(), await removePortableIdeConfigIfUnchanged(options.publishOsDir);
+            },
+            label: "Generated IDE configuration rollback"
+          });
+        } catch {
+          warn(
+            "Could not remove generated TypeScript configuration after IDE preparation failed. The original error remains the command error."
+          );
+        }
+      throw error;
+    }
+  } finally {
+    try {
+      releaseLock && !retainInstallerState && await cleanupIdeFiles({
+        cleanup: releaseLock,
+        label: "IDE lock cleanup"
+      });
+    } catch (error) {
+      releaseLockError = error;
+    }
+  }
+  if (releaseLockError) throw releaseLockError;
+}
+function isShutdownFailure(error) {
+  return error instanceof AppError && error.code === "FRAMEWORK_PROCESS_SHUTDOWN_FAILED";
+}
+
+export {
+  prepareIdeSupport
+};