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

package/dist/chunk-3T4HVDSC.js

@@ -0,0 +1,426 @@
+import {
+  acquireOperationLock,
+  ensureLocalOutputRoot,
+  publishOwnedDirectory
+} from "./chunk-6D2E6UMD.js";
+import {
+  createIdeSourceArtifacts
+} from "./chunk-NHSLTARU.js";
+import {
+  assertFrameworkSelection,
+  readCheckoutTypeScriptConfig
+} from "./chunk-NNBJZPFM.js";
+import {
+  supportedNextjsSourceImports
+} from "./chunk-DX7PXFCM.js";
+import {
+  runtimePackageVersion
+} from "./chunk-AI2UULNX.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/ide/ide-support.ts
+import { constants, existsSync } from "fs";
+import {
+  lstat,
+  mkdir,
+  open,
+  readdir,
+  readFile,
+  realpath,
+  writeFile
+} from "fs/promises";
+import { createRequire } from "module";
+import { dirname, join, resolve } from "path";
+function errorCauses(error) {
+  return [
+    ...error instanceof AggregateError ? error.errors : [],
+    ...error.cause === void 0 ? [] : [error.cause]
+  ];
+}
+function errorMessage(error, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(error)) return "";
+  if (seen.add(error), !(error instanceof Error)) return String(error);
+  let causes = errorCauses(error).map((cause) => errorMessage(cause, seen)).filter(Boolean);
+  return causes.length ? `${error.message}: ${causes.join("; ")}` : error.message;
+}
+function findRequiredFailure(error, seen = /* @__PURE__ */ new Set()) {
+  if (!(!(error instanceof Error) || seen.has(error))) {
+    if (seen.add(error), error instanceof AppError && ["FRAMEWORK_SOURCE_PIN_MISMATCH", "IDE_FRAMEWORK_PIN_MISMATCH"].includes(
+      error.code
+    ) || error.name === "AbortError")
+      return error;
+    for (let cause of errorCauses(error)) {
+      let required = findRequiredFailure(cause, seen);
+      if (required) return required;
+    }
+  }
+}
+function emitWarning(options, message) {
+  options.onEvent?.({
+    type: "diagnostics",
+    diagnostics: {
+      diagnostics: [
+        {
+          code: "IDE_INTEGRATION_REQUIRED",
+          severity: "warning",
+          message
+        }
+      ]
+    }
+  });
+}
+function sourceRootConfigPath(publishOsDir) {
+  return join(publishOsDir, "tsconfig.json");
+}
+function editorIntegrationIssue(source, typescript) {
+  if (!source) return "no authored tsconfig.json exists";
+  let parsed = typescript.parseConfigFileTextToJson(
+    "publish.os/tsconfig.json",
+    source
+  );
+  if (parsed.error || !parsed.config)
+    return "the authored tsconfig.json is invalid";
+  let config = parsed.config;
+  if (!(Array.isArray(config.extends) ? config.extends : [config.extends]).some(
+    (base) => typeof base == "string" && [
+      "./.publish.os/ide/tsconfig",
+      "./.publish.os/ide/tsconfig.json"
+    ].includes(base)
+  ))
+    return "the authored tsconfig.json does not extend the generated IDE config";
+  let overridden = [
+    ...["baseUrl", "paths"].filter(
+      (key) => Object.hasOwn(config.compilerOptions ?? {}, key)
+    ),
+    ...["files", "include", "exclude"].filter(
+      (key) => Object.hasOwn(config, key)
+    )
+  ];
+  return overridden.length ? `the authored tsconfig.json overrides generated ${overridden.join(", ")}` : void 0;
+}
+function typescriptApi(framework) {
+  try {
+    return createRequire(
+      join(framework.packageRoot, "package.json")
+    )("typescript");
+  } catch (cause) {
+    throw new AppError({
+      code: "IDE_TYPESCRIPT_UNAVAILABLE",
+      message: "The selected framework installation does not include TypeScript.",
+      fix: "Install or repair the selected framework, then run the command again. The site operation will continue without IDE support.",
+      details: { cause }
+    });
+  }
+}
+function packageTypePath(options) {
+  let resolved = options.typescript.resolveModuleName(
+    options.specifier,
+    join(options.framework.packageRoot, "__publishos_ide_check__.tsx"),
+    {
+      module: options.typescript.ModuleKind.ESNext,
+      moduleResolution: options.typescript.ModuleResolutionKind.Bundler,
+      preserveSymlinks: !0
+    },
+    options.typescript.sys
+  ).resolvedModule?.resolvedFileName, declared = resolved?.replace(/\.mjs$/u, ".d.mts").replace(/\.cjs$/u, ".d.cts").replace(/\.js$/u, ".d.ts"), path = resolved && /\.d\.[cm]?ts$/u.test(resolved) ? resolved : declared && existsSync(declared) ? declared : void 0;
+  if (!path)
+    throw new AppError({
+      code: "IDE_DECLARATION_UNAVAILABLE",
+      message: `The selected framework installation does not provide declarations for ${options.specifier}${resolved ? ` (resolved to ${resolved})` : ""}.`,
+      fix: "Repair or update the selected framework installation. The site operation will continue without IDE support."
+    });
+  return path;
+}
+async function editorPaths(options) {
+  let typescript = typescriptApi(options.framework), checkout = options.checkoutRoot ? await readCheckoutTypeScriptConfig({
+    packageRoot: options.checkoutRoot
+  }) : void 0, paths = {};
+  for (let specifier of [
+    ...supportedNextjsSourceImports(),
+    "react/jsx-runtime"
+  ]) {
+    let checkoutPath = checkout?.paths[specifier]?.[0];
+    paths[specifier] = [
+      checkoutPath ? resolve(
+        options.checkoutRoot ?? options.framework.packageRoot,
+        checkoutPath
+      ) : packageTypePath({
+        framework: options.framework,
+        typescript,
+        specifier
+      })
+    ];
+  }
+  if (checkout && options.checkoutRoot) {
+    let checkoutRoot = options.checkoutRoot;
+    paths["@/*"] = [join(checkoutRoot, "src", "*")];
+    for (let [specifier, sources] of Object.entries(checkout.paths))
+      specifier.startsWith("@components/") && (paths[specifier] = [
+        join(options.publishOsDir, "components", specifier.slice(12)),
+        ...sources.map((source) => join(checkoutRoot, source))
+      ]);
+  }
+  return paths["@components/*"] = [
+    join(options.publishOsDir, "components", "*"),
+    join(options.framework.packageRoot, "dist/kernel/components", "*")
+  ], paths["@source/*"] = [
+    join(options.publishOsDir, "*"),
+    join(options.publishOsDir, ".publish.os/ide/source", "*")
+  ], paths;
+}
+async function ideTsconfig(options) {
+  let { framework, finalPublishOsDir } = options, resolveFromFramework = createRequire(
+    join(framework.packageRoot, "package.json")
+  ), types = ["node", "react", "react-dom"], typeRoots = [
+    ...new Set(
+      types.map((name) => {
+        let manifest = resolveFromFramework.resolve(
+          `@types/${name}/package.json`
+        );
+        return dirname(dirname(manifest));
+      })
+    )
+  ], config = {
+    compilerOptions: {
+      allowJs: !0,
+      baseUrl: finalPublishOsDir,
+      esModuleInterop: !0,
+      isolatedModules: !0,
+      jsx: "react-jsx",
+      jsxImportSource: "@publish.os/nextjs",
+      lib: ["dom", "dom.iterable", "esnext"],
+      module: "esnext",
+      moduleResolution: "bundler",
+      noEmit: !0,
+      paths: await editorPaths({
+        framework,
+        publishOsDir: finalPublishOsDir,
+        checkoutRoot: options.checkoutRoot
+      }),
+      resolveJsonModule: !0,
+      strict: !0,
+      target: "ES2022",
+      typeRoots,
+      types
+    },
+    exclude: [join(finalPublishOsDir, ".publish.os", "**/*")],
+    include: [join(finalPublishOsDir, "**/*")],
+    // The config lives inside generated state, but TypeScript resolves bare
+    // packages from the exact selected framework installation.
+    typeAcquisition: { enable: !1 }
+  };
+  return `${JSON.stringify(config, null, 2)}
+`;
+}
+function assertExactRuntime(source, framework) {
+  if (runtimePackageVersion(source.config.runtime) !== framework.version)
+    throw new AppError({
+      code: "IDE_FRAMEWORK_PIN_MISMATCH",
+      message: "IDE support does not match the source's selected framework pin.",
+      fix: "Use the framework selected by publish.os.config.json, then run the command again."
+    });
+}
+async function assertLiveRuntimePin(options) {
+  try {
+    let config = JSON.parse(
+      await readFile(
+        join(options.publishOsDir, "publish.os.config.json"),
+        "utf8"
+      )
+    );
+    if (runtimePackageVersion(config.runtime) === options.expectedRuntimeVersion)
+      return;
+  } catch {
+  }
+  throw new AppError({
+    code: "FRAMEWORK_SOURCE_PIN_MISMATCH",
+    message: "The source framework pin changed during IDE preparation.",
+    fix: "Finish editing publish.os.config.json, then run the command again with the framework selected by the source."
+  });
+}
+async function ideOutputMatches(options) {
+  let root = await lstat(options.ideRoot).catch(
+    (error) => {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  );
+  if (root?.isDirectory() !== !0 || root.isSymbolicLink()) return !1;
+  let actual = /* @__PURE__ */ new Map();
+  async function readRegularFile(path) {
+    try {
+      let file = await open(
+        path,
+        constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+      );
+      try {
+        return (await file.stat()).isFile() ? await file.readFile("utf8") : void 0;
+      } finally {
+        await file.close();
+      }
+    } catch {
+      return;
+    }
+  }
+  async function visit(directory, prefix = "") {
+    let entries;
+    try {
+      entries = await readdir(directory, { withFileTypes: !0 });
+    } catch {
+      return !1;
+    }
+    for (let entry of entries) {
+      let path = prefix ? `${prefix}/${entry.name}` : entry.name, absolute = join(directory, entry.name);
+      if (entry.isDirectory() && !entry.isSymbolicLink()) {
+        if (!await visit(absolute, path)) return !1;
+      } else if (entry.isFile() && !entry.isSymbolicLink()) {
+        let contents = await readRegularFile(absolute);
+        if (contents === void 0) return !1;
+        actual.set(path, contents);
+      } else return !1;
+    }
+    return !0;
+  }
+  return await visit(options.ideRoot) ? actual.size === Object.keys(options.files).length && Object.entries(options.files).every(
+    ([path, contents]) => actual.get(path) === contents
+  ) : !1;
+}
+async function acquireIdeOutputLock(options) {
+  let deadline = Date.now() + 1e4;
+  for (; ; ) {
+    options.signal?.throwIfAborted();
+    try {
+      return await acquireOperationLock({ ...options, operation: "ide" });
+    } catch (error) {
+      if (!(error instanceof AppError) || error.code !== "FRAMEWORK_LOCAL_OPERATION_ACTIVE" || Date.now() >= deadline)
+        throw error;
+      await new Promise((resolvePromise) => setTimeout(resolvePromise, 20));
+    }
+  }
+}
+async function publishIdeOutput(options) {
+  let ownership = await ensureLocalOutputRoot({
+    sourceRoot: options.publishOsDir
+  }), { outputRoot: generatedRoot } = ownership, releaseLock = await acquireIdeOutputLock({
+    sourceRoot: options.publishOsDir,
+    outputRoot: generatedRoot,
+    signal: options.signal
+  }), ideRoot = join(generatedRoot, "ide"), stageRoot = join(generatedRoot, ".stages"), recoveryRoot = join(generatedRoot, "recovery"), primaryFailure;
+  try {
+    await options.assertSourcePin(), await ownership.assertCurrent(), await ideOutputMatches({ ideRoot, files: options.files }) || await publishOwnedDirectory({
+      targetDirectory: ideRoot,
+      stagingRoot: stageRoot,
+      stagingPrefix: "ide",
+      recoveryRoot,
+      signal: options.signal,
+      assertOwner: ownership.assertCurrent,
+      beforePublish: options.assertSourcePin,
+      prepareIncoming: async (incoming) => {
+        for (let [path, contents] of Object.entries(options.files)) {
+          let target = join(incoming, path);
+          await mkdir(dirname(target), { recursive: !0 }), await writeFile(target, contents, { flag: "wx" });
+        }
+      }
+    });
+  } catch (error) {
+    primaryFailure = new Error("IDE output publication failed", {
+      cause: error
+    });
+  }
+  try {
+    await releaseLock();
+  } catch (releaseError) {
+    throw primaryFailure ? new AggregateError(
+      [primaryFailure, releaseError],
+      "IDE output publication failed; lock release also failed"
+    ) : releaseError;
+  }
+  if (primaryFailure) throw primaryFailure;
+  return ideRoot;
+}
+async function generateIdeSupport(input) {
+  input.frameworkOptions.signal?.throwIfAborted();
+  let publishOsDir = await realpath(input.publishOsDir), runtime = `@publish.os/nextjs@${input.framework.version}`;
+  await assertFrameworkSelection({
+    context: input.frameworkOptions.request.context,
+    framework: input.framework,
+    runtime
+  });
+  let source = input.source, expectedRuntimeVersion = runtimePackageVersion(source.config.runtime);
+  if (expectedRuntimeVersion === void 0)
+    throw new AppError({
+      code: "FRAMEWORK_SOURCE_PIN_MISMATCH",
+      message: "The validated source no longer has a valid framework pin.",
+      fix: "Restore a valid runtime value in publish.os.config.json, then run the command again."
+    });
+  input.frameworkOptions.request.context?.framework || assertExactRuntime(source, input.framework);
+  let assertSourcePin = async () => {
+    input.frameworkOptions.request.context?.framework || await assertLiveRuntimePin({ publishOsDir, expectedRuntimeVersion });
+  };
+  await assertSourcePin();
+  let finalPublishOsDir = input.finalPublishOsDir ?? publishOsDir, artifacts = await createIdeSourceArtifacts({
+    mediaManifest: source.assets.media.manifest
+  }), [config, authoredConfig] = await Promise.all([
+    ideTsconfig({
+      framework: input.framework,
+      finalPublishOsDir,
+      checkoutRoot: input.frameworkOptions.request.context?.framework?.kind === "checkout" ? input.framework.packageRoot : void 0
+    }),
+    readFile(sourceRootConfigPath(publishOsDir), "utf8").catch(
+      (error) => {
+        if (error.code !== "ENOENT")
+          throw error;
+      }
+    )
+  ]);
+  input.frameworkOptions.signal?.throwIfAborted();
+  let ideRoot = await publishIdeOutput({
+    publishOsDir,
+    signal: input.frameworkOptions.signal,
+    assertSourcePin,
+    files: {
+      "tsconfig.json": config,
+      "source/.publishos/media-manifest.generated.ts": artifacts.mediaModule
+    }
+  }), integrationIssue = editorIntegrationIssue(
+    authoredConfig,
+    typescriptApi(input.framework)
+  );
+  integrationIssue && emitWarning(
+    input.frameworkOptions,
+    `TypeScript support was generated at ${join(ideRoot, "tsconfig.json")}, but ${integrationIssue}. Add extends: "./.publish.os/ide/tsconfig.json" and merge custom TypeScript settings without overriding generated paths. PublishOS left your file unchanged.`
+  );
+}
+async function prepareIdeSupport(input) {
+  try {
+    input.frameworkOptions.signal?.throwIfAborted(), await generateIdeSupport(input);
+  } catch (error) {
+    let required = findRequiredFailure(error);
+    if (required) {
+      if (required === error) throw error;
+      let failure = required instanceof AppError ? new AppError(required) : new Error(required.message);
+      throw failure.name = required.name, failure.cause = error, failure;
+    }
+    input.frameworkOptions.signal?.throwIfAborted();
+    let cause = errorMessage(error);
+    input.frameworkOptions.onEvent?.({
+      type: "diagnostics",
+      diagnostics: {
+        diagnostics: [
+          {
+            code: "IDE_SUPPORT_UNAVAILABLE",
+            severity: "warning",
+            message: `IDE support is unavailable: ${cause}`,
+            correction: "The site operation will continue. IDE support will be retried the next time you run this command."
+          }
+        ]
+      }
+    });
+  }
+}
+
+export {
+  prepareIdeSupport
+};

package/dist/{chunk-WKTEO6RS.js → chunk-4BC2L2KA.js}

@@ -1,6 +1,6 @@
 import {
   AppError
-} from "./chunk-WDY4IK6Z.js";
+} from "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/lifecycle/local-process.ts
 import { spawn as spawn2 } from "child_process";
@@ -336,6 +336,9 @@ var LocalProcessError = class extends AppError {
     }), this.output = output;
   }
 };
+async function processGroupAbsentAfterReapTurn(groupExists) {
+  return await new Promise((resolve) => setImmediate(resolve)), !groupExists();
+}
 function startLocalProcess(options) {
   options.signal.throwIfAborted();
   let grouped = process.platform !== "win32", environment = options.environment ?? localProcessEnvironment({ mode: "production" }), windows = grouped ? void 0 : startWindowsProcess({
@@ -399,7 +402,10 @@ function startLocalProcess(options) {
       killGroup("SIGTERM");
       let forced = !1;
       for (; groupExists(); ) {
-        if (!forced && Date.now() >= deadline - 750 && (killGroup("SIGKILL"), forced = !0), Date.now() >= deadline) throw shutdownFailure();
+        if (!forced && Date.now() >= deadline - 750 && (killGroup("SIGKILL"), forced = !0), Date.now() >= deadline) {
+          if (await processGroupAbsentAfterReapTurn(groupExists)) break;
+          throw shutdownFailure();
+        }
         await new Promise((resolve) => setTimeout(resolve, 20));
       }
     }
@@ -470,9 +476,7 @@ async function installLocalApp({
   outputDir,
   framework,
   options,
-  lifetime,
-  purpose,
-  assertInstallGraph
+  lifetime
 }) {
   let publicCommand = options.request.operation === "validate" ? "init" : options.request.operation, command = options.request.context?.pnpmExecutable;
   if (typeof command != "string" || !isAbsolute(command))
@@ -525,7 +529,7 @@ async function installLocalApp({
   let lockPath = join2(outputDir, "pnpm-lock.yaml"), lock = await readFile(lockPath);
   options.onEvent?.({
     type: "progress",
-    message: purpose === "ide" ? "Preparing IDE dependencies" : "Preparing app dependencies"
+    message: "Preparing app dependencies"
   });
   try {
     await run({
@@ -542,13 +546,13 @@ async function installLocalApp({
       throw error instanceof LocalProcessError && error.output.trim() && process.stderr.write(error.output), error;
     options.onEvent?.({
       type: "progress",
-      message: `Downloading missing ${purpose === "ide" ? "IDE" : "app"} dependencies`
-    }), await assertInstallGraph?.();
+      message: "Downloading missing app dependencies"
+    });
     try {
       await run({
-        args: ["install", "--frozen-lockfile", "--fetch-timeout=10000"],
+        args: ["install", "--frozen-lockfile"],
         quiet: options.request.operation !== "build",
-        timeoutMs: 12e4
+        timeoutMs: 3e5
       });
     } catch (downloadError) {
       throw downloadError instanceof AppError && downloadError.code === "FRAMEWORK_PROCESS_SHUTDOWN_FAILED" || (lifetime.signal.throwIfAborted(), !(downloadError instanceof LocalProcessError) && !(downloadError instanceof AppError && downloadError.code === "FRAMEWORK_DEPENDENCY_DOWNLOAD_FAILED")) ? downloadError : new AppError({
@@ -557,7 +561,7 @@ async function installLocalApp({
       });
     }
   }
-  if (await assertInstallGraph?.(), !(await readFile(lockPath)).equals(lock))
+  if (!(await readFile(lockPath)).equals(lock))
     throw new AppError({
       code: "FRAMEWORK_RELEASE_INVALID",
       message: "App installation changed the released lock. The output was not published."
@@ -578,9 +582,39 @@ async function installLocalApp({
   return { run: (args) => run({ args }) };
 }
 
+// src/lib/compiler/lifecycle/local-gates.ts
+async function requestLocalGate({
+  options,
+  gate
+}) {
+  options.signal?.throwIfAborted();
+  let approved = await new Promise((resolve, reject) => {
+    let abort = () => reject(options.signal?.reason);
+    options.signal?.addEventListener("abort", abort, { once: !0 }), options.signal?.aborted && abort(), Promise.resolve().then(() => options.onGate?.(gate)).then((value) => resolve(value === !0), reject).finally(() => options.signal?.removeEventListener("abort", abort));
+  });
+  if (options.signal?.throwIfAborted(), !approved)
+    throw new AppError({
+      code: "FRAMEWORK_GATE_DENIED",
+      message: "The caller did not authorize the operation."
+    });
+}
+async function approveLocalComposition({
+  options
+}) {
+  options.onGate && await requestLocalGate({
+    options,
+    gate: {
+      id: "compose",
+      kind: "compose",
+      summary: "Compose the validated source."
+    }
+  });
+}
+
 export {
   localProcessEnvironment,
   LocalProcessError,
   startLocalProcess,
-  installLocalApp
+  installLocalApp,
+  approveLocalComposition
 };

package/dist/{chunk-WDY4IK6Z.js → chunk-5J3YUNRY.js}

@@ -1,12 +1,6 @@
-// src/lib/compiler/internal/errors.ts
-var AppError = class extends Error {
-  code;
-  details;
-  fix;
-  constructor({ code, message, details, fix }) {
-    super(message), this.name = "FrameworkError", this.code = code, this.details = details, this.fix = fix;
-  }
-};
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/release/installed-framework.ts
 import { readFileSync } from "fs";
@@ -122,7 +116,6 @@ async function readInstalledFramework() {
 }
 
 export {
-  AppError,
   readInstalledFrameworkLocation,
   readInstalledFramework
 };