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

package/dist/chunk-WKTEO6RS.js

@@ -0,0 +1,586 @@
+import {
+  AppError
+} from "./chunk-WDY4IK6Z.js";
+
+// src/lib/compiler/lifecycle/local-process.ts
+import { spawn as spawn2 } from "child_process";
+import { delimiter, dirname } from "path";
+
+// src/lib/compiler/lifecycle/windows-process.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
+  openSync,
+  readSync,
+  unlinkSync
+} from "fs";
+import { join, win32 } from "path";
+var supervisor = String.raw`
+$ErrorActionPreference = 'Stop'
+[Console]::InputEncoding = [System.Text.UTF8Encoding]::new($false)
+[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)
+Add-Type -TypeDefinition @'
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+public static class PublishOsOwnedProcess {
+  const uint KillOnJobClose = 0x2000, UseStandardHandles = 0x100;
+  const uint CreateSuspended = 0x4, CreateUnicodeEnvironment = 0x400, ExtendedStartupInfoPresent = 0x80000;
+  const uint WaitTimeout = 258, StillActive = 259, CancelledExitCode = 143;
+  const uint GenericRead = 0x80000000, ShareReadWrite = 3, OpenExisting = 3, DuplicateSameAccess = 2;
+  const int BasicAccountingInformation = 1, ExtendedLimitInformation = 9;
+  const int JobListAttribute = 0x2000D, HandleListAttribute = 0x20002, StandardOutput = -11, StandardError = -12;
+  [StructLayout(LayoutKind.Sequential)] struct Limits {
+    public long ProcessTime, JobTime;
+    public uint Flags;
+    public UIntPtr MinWorkingSet, MaxWorkingSet;
+    public uint ActiveProcessLimit;
+    public UIntPtr Affinity;
+    public uint Priority, Scheduling;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct IoCounters {
+    public ulong ReadCount, WriteCount, OtherCount, ReadBytes, WriteBytes, OtherBytes;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct ExtendedLimits {
+    public Limits Basic;
+    public IoCounters Io;
+    public UIntPtr ProcessMemory, JobMemory, PeakProcessMemory, PeakJobMemory;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct Accounting {
+    public long UserTime, KernelTime, PeriodUserTime, PeriodKernelTime;
+    public uint Faults, TotalProcesses, ActiveProcesses, TerminatedProcesses;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct Startup {
+    public int Size;
+    public IntPtr Reserved, Desktop, Title;
+    public uint X, Y, Width, Height, XChars, YChars, Fill, Flags;
+    public ushort Show, ReservedSize;
+    public IntPtr ReservedData, Input, Output, Error;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct ExtendedStartup {
+    public Startup Basic;
+    public IntPtr Attributes;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct ProcessInfo {
+    public IntPtr Process, Thread;
+    public uint ProcessId, ThreadId;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct Security {
+    public int Size;
+    public IntPtr Descriptor;
+    public int Inherit;
+  }
+  [DllImport("kernel32.dll", SetLastError=true)] static extern IntPtr CreateJobObjectW(IntPtr attributes, IntPtr name);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool SetInformationJobObject(IntPtr job, int kind, ref ExtendedLimits value, uint size);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool QueryInformationJobObject(IntPtr job, int kind, out Accounting value, uint size, IntPtr returned);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool TerminateJobObject(IntPtr job, uint code);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool InitializeProcThreadAttributeList(IntPtr list, int count, uint flags, ref IntPtr size);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool UpdateProcThreadAttribute(IntPtr list, uint flags, IntPtr key, IntPtr value, IntPtr size, IntPtr previous, IntPtr returned);
+  [DllImport("kernel32.dll")] static extern void DeleteProcThreadAttributeList(IntPtr list);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool CreateProcessW(string application, StringBuilder command, IntPtr processAttributes, IntPtr threadAttributes, bool inherit, uint flags, IntPtr environment, string directory, ref ExtendedStartup startup, out ProcessInfo process);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern uint ResumeThread(IntPtr thread);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool GetExitCodeProcess(IntPtr process, out uint code);
+  [DllImport("kernel32.dll")] static extern IntPtr GetStdHandle(int kind);
+  [DllImport("kernel32.dll")] static extern IntPtr GetCurrentProcess();
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool DuplicateHandle(IntPtr sourceProcess, IntPtr source, IntPtr targetProcess, out IntPtr target, uint access, bool inherit, uint options);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern IntPtr CreateFileW(string name, uint access, uint share, ref Security security, uint disposition, uint flags, IntPtr template);
+  [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
+
+  static void Check(bool success) {
+    if (!success) throw new Win32Exception(Marshal.GetLastWin32Error());
+  }
+  static string Quote(string value) {
+    if (value.IndexOf('\0') >= 0) throw new ArgumentException("A process argument contains a null character.");
+    var text = new StringBuilder("\"");
+    int slashes = 0;
+    foreach (char c in value) {
+      if (c == '\\') { slashes++; continue; }
+      text.Append('\\', c == '"' ? slashes * 2 + 1 : slashes);
+      text.Append(c);
+      slashes = 0;
+    }
+    return text.Append('\\', slashes * 2).Append('"').ToString();
+  }
+  static void StopJob(IntPtr job) {
+    Check(TerminateJobObject(job, CancelledExitCode));
+    var watch = Stopwatch.StartNew();
+    for (;;) {
+      Accounting value;
+      Check(QueryInformationJobObject(job, BasicAccountingInformation, out value, (uint)Marshal.SizeOf(typeof(Accounting)), IntPtr.Zero));
+      if (value.ActiveProcesses == 0) return;
+      if (watch.ElapsedMilliseconds >= 4000) throw new TimeoutException("A framework descendant did not stop.");
+      Thread.Sleep(20);
+    }
+  }
+  public static int Run(string command, string[] args, string directory, string[] environment, string proof) {
+    IntPtr job = IntPtr.Zero, attributes = IntPtr.Zero, jobList = IntPtr.Zero;
+    IntPtr handles = IntPtr.Zero, input = IntPtr.Zero, output = IntPtr.Zero, error = IntPtr.Zero, env = IntPtr.Zero;
+    ProcessInfo process = new ProcessInfo();
+    bool initialized = false, stopAttempted = false;
+    try {
+      job = CreateJobObjectW(IntPtr.Zero, IntPtr.Zero);
+      Check(job != IntPtr.Zero);
+      var limits = new ExtendedLimits();
+      limits.Basic.Flags = KillOnJobClose; // No breakaway.
+      Check(SetInformationJobObject(job, ExtendedLimitInformation, ref limits, (uint)Marshal.SizeOf(typeof(ExtendedLimits))));
+      var security = new Security { Size = Marshal.SizeOf(typeof(Security)), Inherit = 1 };
+      input = CreateFileW("NUL", GenericRead, ShareReadWrite, ref security, OpenExisting, 0, IntPtr.Zero);
+      Check(input != new IntPtr(-1));
+      Check(DuplicateHandle(GetCurrentProcess(), GetStdHandle(StandardOutput), GetCurrentProcess(), out output, 0, true, DuplicateSameAccess));
+      Check(DuplicateHandle(GetCurrentProcess(), GetStdHandle(StandardError), GetCurrentProcess(), out error, 0, true, DuplicateSameAccess));
+      IntPtr size = IntPtr.Zero;
+      InitializeProcThreadAttributeList(IntPtr.Zero, 2, 0, ref size);
+      Check(size != IntPtr.Zero);
+      attributes = Marshal.AllocHGlobal(size);
+      Check(InitializeProcThreadAttributeList(attributes, 2, 0, ref size));
+      initialized = true;
+      jobList = Marshal.AllocHGlobal(IntPtr.Size);
+      Marshal.WriteIntPtr(jobList, job);
+      Check(UpdateProcThreadAttribute(attributes, 0, new IntPtr(JobListAttribute), jobList, new IntPtr(IntPtr.Size), IntPtr.Zero, IntPtr.Zero));
+      handles = Marshal.AllocHGlobal(IntPtr.Size * 3);
+      Marshal.WriteIntPtr(handles, 0, input);
+      Marshal.WriteIntPtr(handles, IntPtr.Size, output);
+      Marshal.WriteIntPtr(handles, IntPtr.Size * 2, error);
+      Check(UpdateProcThreadAttribute(attributes, 0, new IntPtr(HandleListAttribute), handles, new IntPtr(IntPtr.Size * 3), IntPtr.Zero, IntPtr.Zero));
+      env = Marshal.StringToHGlobalUni(String.Join("\0", environment.OrderBy(value => value, StringComparer.OrdinalIgnoreCase)) + "\0\0");
+      var startup = new ExtendedStartup();
+      startup.Basic.Size = Marshal.SizeOf(typeof(ExtendedStartup));
+      startup.Basic.Flags = UseStandardHandles;
+      startup.Basic.Input = input; startup.Basic.Output = output; startup.Basic.Error = error;
+      startup.Attributes = attributes;
+      var line = new StringBuilder(String.Join(" ", new[] { command }.Concat(args).Select(Quote)));
+      // JOB_LIST assigns ownership atomically, including a supervisor crash before ResumeThread.
+      Check(CreateProcessW(command, line, IntPtr.Zero, IntPtr.Zero, true, ExtendedStartupInfoPresent | CreateUnicodeEnvironment | CreateSuspended, env, directory, ref startup, out process));
+      File.WriteAllText(proof, "running");
+      Check(ResumeThread(process.Thread) != UInt32.MaxValue);
+      var stop = Task.Factory.StartNew(() => Console.ReadLine()); // A stop line or parent EOF cancels.
+      uint wait;
+      while ((wait = WaitForSingleObject(process.Process, 20)) == WaitTimeout && !stop.IsCompleted) {}
+      Check(wait != UInt32.MaxValue);
+      uint code;
+      Check(GetExitCodeProcess(process.Process, out code));
+      if (code == StillActive) code = CancelledExitCode;
+      CloseHandle(process.Thread); process.Thread = IntPtr.Zero;
+      CloseHandle(process.Process); process.Process = IntPtr.Zero;
+      stopAttempted = true;
+      StopJob(job);
+      File.WriteAllText(proof, "stopped:" + code);
+      return 0;
+    } catch (Exception failure) {
+      Console.Error.WriteLine("The framework process owner failed: " + failure.Message);
+      try {
+        if (stopAttempted) return 1;
+        if (process.Thread != IntPtr.Zero) { CloseHandle(process.Thread); process.Thread = IntPtr.Zero; }
+        if (process.Process != IntPtr.Zero) { CloseHandle(process.Process); process.Process = IntPtr.Zero; }
+        if (job != IntPtr.Zero) StopJob(job);
+        File.WriteAllText(proof, "stopped:1");
+      } catch { /* No completion proof: retain owned output and locks. */ }
+      return 1;
+    } finally {
+      // The job handle is never inherited. Closing the only handle kills all members.
+      if (job != IntPtr.Zero) CloseHandle(job);
+      if (process.Thread != IntPtr.Zero) CloseHandle(process.Thread);
+      if (process.Process != IntPtr.Zero) CloseHandle(process.Process);
+      if (input != IntPtr.Zero && input != new IntPtr(-1)) CloseHandle(input);
+      if (output != IntPtr.Zero) CloseHandle(output);
+      if (error != IntPtr.Zero) CloseHandle(error);
+      if (initialized) DeleteProcThreadAttributeList(attributes);
+      foreach (var memory in new[] { attributes, jobList, handles, env })
+        if (memory != IntPtr.Zero) Marshal.FreeHGlobal(memory);
+    }
+  }
+}
+'@
+$payload = ConvertFrom-Json ([Console]::ReadLine())
+$environment = [string[]]@($payload.environment.PSObject.Properties | ForEach-Object { $_.Name + '=' + [string]$_.Value })
+exit ([PublishOsOwnedProcess]::Run([string]$payload.command, [string[]]@($payload.args), [string]$payload.cwd, $environment, [string]$payload.proofPath))
+`;
+function startWindowsProcess(options) {
+  let systemRoot = Object.entries(options.environment).find(
+    ([name]) => name.toUpperCase() === "SYSTEMROOT"
+  )?.[1];
+  if (!systemRoot || !win32.isAbsolute(systemRoot))
+    throw new AppError({
+      code: "FRAMEWORK_PROCESS_OWNER_UNAVAILABLE",
+      message: "Windows process ownership is unavailable. Check the SystemRoot environment variable."
+    });
+  let proofPath = join(options.cwd, `.publishos-process-${randomUUID()}`), child = spawn(
+    win32.join(systemRoot, "System32/WindowsPowerShell/v1.0/powershell.exe"),
+    [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-EncodedCommand",
+      Buffer.from(supervisor, "utf16le").toString("base64")
+    ],
+    {
+      cwd: options.cwd,
+      env: options.environment,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: !0
+    }
+  ), spawnError, isClosed = !1, hasExited = !1, exited = new Promise((resolve) => {
+    child.once("exit", () => {
+      hasExited = !0, resolve();
+    }), child.once("close", () => {
+      isClosed = !0, hasExited = !0, resolve();
+    }), child.once("error", (error) => {
+      spawnError = error, hasExited = !0, resolve();
+    });
+  });
+  child.stdin.on("error", () => {
+  }), child.stdin.write(`${JSON.stringify({ ...options, proofPath })}
+`);
+  let readProof = () => {
+    try {
+      let identity = lstatSync(proofPath);
+      if (!identity.isFile() || identity.isSymbolicLink() || identity.size > 64)
+        throw failure();
+      let file = openSync(
+        proofPath,
+        constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+      );
+      try {
+        let current = fstatSync(file);
+        if (!current.isFile() || current.dev !== identity.dev || current.ino !== identity.ino || current.size > 64)
+          throw failure();
+        let bytes = Buffer.alloc(65), count = readSync(file, bytes, 0, bytes.length, 0);
+        if (count > 64) throw failure();
+        return bytes.subarray(0, count).toString("utf8");
+      } finally {
+        closeSync(file);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      return "";
+    }
+  }, failure = () => new AppError({
+    code: "FRAMEWORK_PROCESS_SHUTDOWN_FAILED",
+    message: "A framework descendant did not stop. Owned staging and locks remain for safe recovery."
+  }), stopped, rejectStop = () => {
+  }, stopFailure = new Promise((_, reject) => {
+    rejectStop = reject;
+  }), stop = () => (stopped ??= (async () => {
+    let deadline = Date.now() + 4750;
+    for (hasExited || child.stdin.end(`stop
+`); !isClosed && !(spawnError && !child.pid); ) {
+      if (Date.now() >= deadline)
+        throw child.kill("SIGKILL"), failure();
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    if (!(spawnError && !child.pid) && !/^stopped:\d+$/.test(readProof()))
+      throw failure();
+  })(), stopped.catch(rejectStop), stopped), startupDeadline = Date.now() + 3e4, startup = setInterval(() => {
+    try {
+      hasExited || readProof() ? clearInterval(startup) : Date.now() >= startupDeadline && (clearInterval(startup), stop().catch(() => {
+      }));
+    } catch (error) {
+      clearInterval(startup), stop().catch(() => {
+      }), rejectStop(error);
+    }
+  }, 20), completion = (async () => {
+    try {
+      if (await Promise.race([exited, stopFailure]), await stop(), spawnError) throw spawnError;
+      let code = Number(readProof().slice(8));
+      return unlinkSync(proofPath), code;
+    } finally {
+      clearInterval(startup);
+    }
+  })();
+  return completion.catch(() => {
+  }), { child, completion, stop };
+}
+
+// src/lib/compiler/lifecycle/local-process.ts
+function localProcessEnvironment({
+  mode
+}) {
+  let environment = Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([name, value]) => value !== void 0 && !/^(?:NODE_(?:OPTIONS|PATH|ENV)|NEXT_TELEMETRY_DISABLED)$/i.test(
+        name
+      ) && // Cache locations do not change the frozen dependency or install policy.
+      (!/^(?:npm_config_|PNPM_|COREPACK_|PUBLISH_OS_|PUBLISHOS_)/i.test(
+        name
+      ) || /^PNPM_CONFIG_(?:STORE|CACHE)_DIR$/i.test(name))
+    )
+  ), inheritedPath = environment.PATH;
+  if (process.platform === "win32")
+    for (let name of Object.keys(environment))
+      name.toUpperCase() === "PATH" && (inheritedPath = environment[name], delete environment[name]);
+  return environment.PATH = [
+    dirname(process.execPath),
+    ...(inheritedPath ?? "").split(delimiter).filter(
+      (path) => path && !/[\\/]node_modules[\\/]\.bin(?:[\\/]|$)/.test(path)
+    )
+  ].join(delimiter), { ...environment, NODE_ENV: mode, NEXT_TELEMETRY_DISABLED: "1" };
+}
+var LocalProcessError = class extends AppError {
+  output;
+  constructor({ output }) {
+    super({
+      code: "FRAMEWORK_PROCESS_FAILED",
+      message: "A required framework process failed. Review the process output and correct the reported error."
+    }), this.output = output;
+  }
+};
+function startLocalProcess(options) {
+  options.signal.throwIfAborted();
+  let grouped = process.platform !== "win32", environment = options.environment ?? localProcessEnvironment({ mode: "production" }), windows = grouped ? void 0 : startWindowsProcess({
+    command: options.command,
+    args: options.args,
+    cwd: options.cwd,
+    environment
+  }), child = windows?.child ?? spawn2(options.command, options.args, {
+    cwd: options.cwd,
+    env: environment,
+    detached: grouped,
+    stdio: ["ignore", "pipe", "pipe"]
+  }), stdout = "", stderr = "";
+  child.stdout.on("data", (chunk) => {
+    let value = chunk.toString();
+    stdout = (stdout + value).slice(-64e3), options.quiet || process.stdout.write(value), options.onStdout?.(value);
+  }), child.stderr.on("data", (chunk) => {
+    let value = chunk.toString();
+    stderr = (stderr + value).slice(-64e3), options.quiet || process.stderr.write(value), options.onStderr?.(value);
+  });
+  let spawnError, exited = new Promise((resolve) => {
+    child.once("error", (error) => {
+      spawnError = error, resolve(null);
+    }), child.once("exit", resolve), child.once("close", resolve);
+  }), closed = new Promise((resolve) => {
+    child.once("close", () => resolve());
+  }), stopped, shutdownProved = !1, rejectStop = () => {
+  }, stopFailure = new Promise((_, reject) => {
+    rejectStop = reject;
+  }), signalError, shutdownFailure = (cause = signalError) => new AppError({
+    code: "FRAMEWORK_PROCESS_SHUTDOWN_FAILED",
+    message: "A framework descendant did not stop. Owned staging and locks remain for safe recovery.",
+    details: { cause }
+  }), killGroup = (signal) => {
+    if (child.pid)
+      try {
+        process.kill(-child.pid, signal);
+      } catch (error) {
+        if (error.code === "ESRCH") return;
+        if (error.code === "EPERM") {
+          signalError = error;
+          return;
+        }
+        throw shutdownFailure(error);
+      }
+  }, groupExists = () => {
+    if (!child.pid) return !1;
+    try {
+      return process.kill(-child.pid, 0), !0;
+    } catch (error) {
+      if (error.code === "ESRCH") return !1;
+      if (error.code === "EPERM")
+        return signalError = error, !0;
+      throw shutdownFailure(error);
+    }
+  }, stop = () => windows ? windows.stop().then(() => {
+    shutdownProved = !0;
+  }) : (stopped ??= (async () => {
+    let deadline = Date.now() + 4e3;
+    if (grouped) {
+      killGroup("SIGTERM");
+      let forced = !1;
+      for (; groupExists(); ) {
+        if (!forced && Date.now() >= deadline - 750 && (killGroup("SIGKILL"), forced = !0), Date.now() >= deadline) throw shutdownFailure();
+        await new Promise((resolve) => setTimeout(resolve, 20));
+      }
+    }
+    let timer;
+    try {
+      await Promise.race([
+        closed,
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(shutdownFailure()),
+            Math.max(0, deadline - Date.now())
+          );
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+    shutdownProved = !0;
+  })(), stopped.catch(rejectStop), stopped), unregister = options.onShutdown(stop), abort = () => {
+    stop().catch(() => {
+    });
+  };
+  options.signal.addEventListener("abort", abort, { once: !0 }), options.signal.aborted && abort();
+  let completion = (async () => {
+    try {
+      let code = await Promise.race([
+        windows?.completion ?? exited,
+        stopFailure
+      ]);
+      if (await stop(), options.signal.throwIfAborted(), spawnError || code !== 0)
+        throw new LocalProcessError({ output: `${stdout}
+${stderr}` });
+      return { stdout, stderr };
+    } finally {
+      options.signal.removeEventListener("abort", abort), shutdownProved && unregister();
+    }
+  })();
+  return completion.catch(() => {
+  }), { completion, stop };
+}
+
+// src/lib/compiler/lifecycle/local-app.ts
+import { lstat, readFile, realpath, symlink, unlink } from "fs/promises";
+import { isAbsolute, join as join2 } from "path";
+import { stripVTControlCharacters } from "util";
+function missingOfflinePackage(error) {
+  if (!(error instanceof LocalProcessError)) return;
+  let output = stripVTControlCharacters(error.output), uncheckedVersion = output.match(
+    /((?:@[a-z0-9._-]+\/)?[a-z0-9._-]+)@[^\s]+ could not be checked against\s+minimumReleaseAge \(version not present in registry manifest\)/iu
+  )?.[1];
+  if (uncheckedVersion) return `registry metadata for ${uncheckedVersion}`;
+  if (/ERR_PNPM_NO_OFFLINE_META\b/.test(output)) {
+    let name = output.match(
+      /Failed to resolve ((?:@[a-z0-9._-]+\/)?[a-z0-9._-]+)/iu
+    )?.[1];
+    if (name) return `registry metadata for ${name}`;
+  }
+  let line = output.split(/\r?\n/u).find(
+    (value) => /ERR_PNPM_(?:NO_OFFLINE_TARBALL|NO_OFFLINE_META)\b/.test(value)
+  );
+  if (!line) return;
+  let safeLine = line.slice(0, 1024);
+  return output.match(
+    /https:\/\/registry\.npmjs\.org\/[A-Za-z0-9@%_./~-]+/
+  )?.[0]?.replace(/\.+$/u, "") ?? safeLine;
+}
+async function installLocalApp({
+  outputDir,
+  framework,
+  options,
+  lifetime,
+  purpose,
+  assertInstallGraph
+}) {
+  let publicCommand = options.request.operation === "validate" ? "init" : options.request.operation, command = options.request.context?.pnpmExecutable;
+  if (typeof command != "string" || !isAbsolute(command))
+    throw new AppError({
+      code: "FRAMEWORK_PNPM_MISSING",
+      message: `Supply the exact pnpm ${framework.release.pnpm} executable from the installed CLI.`
+    });
+  let environment = localProcessEnvironment({
+    mode: options.request.operation === "dev" ? "development" : "production"
+  }), run = async ({
+    args,
+    quiet = !1,
+    timeoutMs
+  }) => {
+    let deadline = new AbortController(), timeout = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+      deadline.abort(
+        new AppError({
+          code: "FRAMEWORK_DEPENDENCY_DOWNLOAD_FAILED",
+          message: `Preparing the locked app dependencies for ${framework.packageName}@${framework.version} exceeded ${timeoutMs / 1e3} seconds.`
+        })
+      );
+    }, timeoutMs);
+    try {
+      return await startLocalProcess({
+        command,
+        args,
+        cwd: outputDir,
+        environment,
+        signal: timeoutMs === void 0 ? lifetime.signal : AbortSignal.any([lifetime.signal, deadline.signal]),
+        onShutdown: lifetime.onShutdown,
+        quiet
+      }).completion;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }, version;
+  try {
+    version = (await run({ args: ["--version"], quiet: !0, timeoutMs: 1e4 })).stdout.trim();
+  } catch (error) {
+    throw error instanceof AppError && error.code === "FRAMEWORK_PROCESS_SHUTDOWN_FAILED" ? error : (lifetime.signal.throwIfAborted(), new AppError({
+      code: "FRAMEWORK_PNPM_MISSING",
+      message: `The required pnpm ${framework.release.pnpm} executable could not run.`
+    }));
+  }
+  if (version !== framework.release.pnpm)
+    throw new AppError({
+      code: "FRAMEWORK_PNPM_UNSUPPORTED",
+      message: `The selected framework requires pnpm ${framework.release.pnpm}; the supplied executable reports ${version || "no version"}.`
+    });
+  let lockPath = join2(outputDir, "pnpm-lock.yaml"), lock = await readFile(lockPath);
+  options.onEvent?.({
+    type: "progress",
+    message: purpose === "ide" ? "Preparing IDE dependencies" : "Preparing app dependencies"
+  });
+  try {
+    await run({
+      args: ["install", "--frozen-lockfile", "--offline"],
+      quiet: !0,
+      timeoutMs: 12e4
+    });
+  } catch (error) {
+    if (error instanceof AppError && error.code === "FRAMEWORK_PROCESS_SHUTDOWN_FAILED")
+      throw error;
+    lifetime.signal.throwIfAborted();
+    let missing = missingOfflinePackage(error);
+    if (!missing)
+      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?.();
+    try {
+      await run({
+        args: ["install", "--frozen-lockfile", "--fetch-timeout=10000"],
+        quiet: options.request.operation !== "build",
+        timeoutMs: 12e4
+      });
+    } 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({
+        code: "FRAMEWORK_DEPENDENCY_DOWNLOAD_FAILED",
+        message: `The locked app dependency ${missing} could not be downloaded for ${framework.packageName}@${framework.version}. Connect to the network and run publish.os ${publicCommand} again.`
+      });
+    }
+  }
+  if (await assertInstallGraph?.(), !(await readFile(lockPath)).equals(lock))
+    throw new AppError({
+      code: "FRAMEWORK_RELEASE_INVALID",
+      message: "App installation changed the released lock. The output was not published."
+    });
+  if (options.request.context?.framework?.kind === "checkout") {
+    let link = join2(outputDir, "node_modules/@publish.os/nextjs");
+    if (!(await lstat(link)).isSymbolicLink() || await realpath(link) !== await realpath(framework.packageRoot))
+      throw new AppError({
+        code: "FRAMEWORK_SELECTION_INVALID",
+        message: "The installed checkout link does not match the selected framework."
+      });
+    await unlink(link), await symlink(
+      framework.packageRoot,
+      link,
+      process.platform === "win32" ? "junction" : "dir"
+    );
+  }
+  return { run: (args) => run({ args }) };
+}
+
+export {
+  localProcessEnvironment,
+  LocalProcessError,
+  startLocalProcess,
+  installLocalApp
+};

package/dist/chunk-YLTOLYWM.js

@@ -0,0 +1,92 @@
+// src/lib/hosting/framework-paths.ts
+var FRAMEWORK_PREFIX = "/publishos", ASSET_PREFIX = `${FRAMEWORK_PREFIX}/assets`, SITE_API_PREFIX = `${FRAMEWORK_PREFIX}/api`, PAGEFIND_PREFIX = `${ASSET_PREFIX}/pagefind`, PAGEFIND_MODULE_URL = `${PAGEFIND_PREFIX}/pagefind.js`, PAGEFIND_ENTRY_URL = `${PAGEFIND_PREFIX}/pagefind-entry.json`, IMAGE_OPTIMIZER_PATH = `${SITE_API_PREFIX}/image`, NEXT_IMAGE_OPTIMIZER_PATH = "/_next/image", OG_SERVICE_PREFIX = `${SITE_API_PREFIX}/og`, PUBLIC_ASSET_DIRECTORY = "publishos/assets", PUBLIC_FONT_DIRECTORY = `${PUBLIC_ASSET_DIRECTORY}/_publishos/fonts`, PUBLIC_PAGEFIND_DIRECTORY = `public/${PUBLIC_ASSET_DIRECTORY}/pagefind`, FRAMEWORK_PROXY_MATCHER = `/((?!${FRAMEWORK_PREFIX.slice(1)}(?:/|$)|_next/static|_next/image|_next/webpack-hmr).*)`;
+function isFrameworkNamespacePath(pathname) {
+  return pathname === FRAMEWORK_PREFIX || pathname.startsWith(`${FRAMEWORK_PREFIX}/`);
+}
+
+// src/lib/compiler/internal/path-containment.ts
+import * as systemPath from "path";
+function relativePath(parent, child, pathImplementation) {
+  return pathImplementation.relative(
+    pathImplementation.resolve(parent),
+    pathImplementation.resolve(child)
+  );
+}
+function isContainedRelativePath(path, pathImplementation) {
+  return !pathImplementation.isAbsolute(path) && path !== ".." && !path.startsWith(`..${pathImplementation.sep}`);
+}
+function isSameOrDescendant(parent, child, pathImplementation = systemPath) {
+  let path = relativePath(parent, child, pathImplementation);
+  return path === "" || isContainedRelativePath(path, pathImplementation);
+}
+function isDescendant(parent, child, pathImplementation = systemPath) {
+  let path = relativePath(parent, child, pathImplementation);
+  return path !== "" && isContainedRelativePath(path, pathImplementation);
+}
+
+// src/lib/compiler/source/source-paths.ts
+function isExcludedSourcePath(relativePath2) {
+  let segments = relativePath2.split(/[\\/]/);
+  return relativePath2 === "tsconfig.json" || segments[0] === ".publish.os" || segments.includes("publish.os");
+}
+var ROOT_FILES = /* @__PURE__ */ new Set(["publish.os.config.json", "tsconfig.json"]), RENDERER_FILES = /* @__PURE__ */ new Set([
+  "layout.tsx",
+  "index.tsx",
+  "page.tsx",
+  "(index)/layout.tsx",
+  "(index)/index.tsx",
+  "(page)/layout.tsx",
+  "(page)/page.tsx"
+]), ROOT_DIRECTORIES = ["public/", "assets/", "components/", "content/"], RESERVED_DIRECTORIES = /* @__PURE__ */ new Set([
+  "app",
+  "pages",
+  "node_modules",
+  ".publish.os",
+  "[...slug]"
+]), RESERVED_FILES = /* @__PURE__ */ new Set([
+  "postcss.config.js",
+  "postcss.config.mjs",
+  "postcss.config.cjs"
+]), FRAMEWORK_BOUNDARY_FILE_PATTERNS = [
+  /^middleware\.[cm]?[jt]sx?$/,
+  /^route\.[cm]?[jt]sx?$/,
+  /^instrumentation(?:\.[\w-]+)?\.[cm]?[jt]sx?$/,
+  /^proxy\.[cm]?[jt]sx?$/,
+  /^next\.config\./
+];
+function isFrameworkBoundaryFile(name) {
+  return FRAMEWORK_BOUNDARY_FILE_PATTERNS.some((pattern) => pattern.test(name));
+}
+function isReservedFrameworkPath(path) {
+  let segments = path.split("/"), name = segments.at(-1) ?? path;
+  return segments.some((segment) => RESERVED_DIRECTORIES.has(segment)) || RESERVED_FILES.has(name) || isFrameworkBoundaryFile(name) || /^(?:loading|error|not-found)\.[cm]?[jt]sx?$/.test(name);
+}
+function isSourceCssPath(path) {
+  return path.endsWith(".css") && (!path.includes("/") || path.startsWith("css/"));
+}
+function isApprovedGroupPath(path, folder) {
+  if (!folder || !path.startsWith(`${folder}/`)) return !1;
+  let localPath = path.slice(folder.length + 1), groupName = folder.split("/").at(-1)?.replace(/^\((.*)\)$/, "$1");
+  return localPath === `${groupName}.config.json` || RENDERER_FILES.has(localPath) || isSourceCssPath(localPath) || localPath.startsWith("content/");
+}
+function isApprovedPublishOsPath(path, groupFolders) {
+  return ROOT_FILES.has(path) || RENDERER_FILES.has(path) || isSourceCssPath(path) || ROOT_DIRECTORIES.some((directory) => path.startsWith(directory)) || [...groupFolders].some((folder) => isApprovedGroupPath(path, folder));
+}
+
+export {
+  FRAMEWORK_PREFIX,
+  ASSET_PREFIX,
+  IMAGE_OPTIMIZER_PATH,
+  NEXT_IMAGE_OPTIMIZER_PATH,
+  OG_SERVICE_PREFIX,
+  PUBLIC_ASSET_DIRECTORY,
+  PUBLIC_FONT_DIRECTORY,
+  PUBLIC_PAGEFIND_DIRECTORY,
+  FRAMEWORK_PROXY_MATCHER,
+  isFrameworkNamespacePath,
+  isSameOrDescendant,
+  isDescendant,
+  isExcludedSourcePath,
+  isReservedFrameworkPath,
+  isApprovedPublishOsPath
+};