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

package/dist/chunk-5J3YUNRY.js

@@ -0,0 +1,121 @@
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/release/installed-framework.ts
+import { readFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var frameworkPackageName = "@publish.os/nextjs", exactVersion = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z]+(?:\.[0-9A-Za-z]+)*)?(?:\+[0-9A-Za-z]+(?:\.[0-9A-Za-z]+)*)?$/u, sha256Digest = /^[a-f0-9]{64}$/u;
+function record(value) {
+  if (!value || typeof value != "object" || Array.isArray(value))
+    throw new AppError({
+      code: "FRAMEWORK_RELEASE_INVALID",
+      message: "The installed framework release metadata is invalid."
+    });
+  return value;
+}
+function version(value) {
+  if (typeof value != "string" || !exactVersion.test(value))
+    throw new AppError({
+      code: "FRAMEWORK_RELEASE_INVALID",
+      message: "The installed framework release version is not exact."
+    });
+  return value;
+}
+function graphRecord(value) {
+  let graph = record(value), fields = [
+    "packageJsonSha256",
+    "pnpmWorkspaceSha256",
+    "lockfileTemplateSha256"
+  ];
+  for (let field of fields)
+    if (typeof graph[field] != "string" || !sha256Digest.test(graph[field]))
+      throw new AppError({
+        code: "FRAMEWORK_RELEASE_INVALID",
+        message: `The installed framework release has an invalid ${field}.`
+      });
+  return Object.freeze({
+    packageJsonSha256: graph.packageJsonSha256,
+    pnpmWorkspaceSha256: graph.pnpmWorkspaceSha256,
+    lockfileTemplateSha256: graph.lockfileTemplateSha256
+  });
+}
+function readInstalledFrameworkLocation() {
+  let directory = dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    try {
+      let manifest = record(
+        JSON.parse(readFileSync(join(directory, "package.json"), "utf8"))
+      );
+      if (manifest.name !== frameworkPackageName)
+        throw new AppError({
+          code: "FRAMEWORK_RELEASE_INVALID",
+          message: "The compiler is not inside the selected framework package."
+        });
+      return { packageRoot: directory, manifest };
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error instanceof AppError ? error : new AppError({
+          code: "FRAMEWORK_RELEASE_INVALID",
+          message: "The installed framework package metadata is unreadable or invalid."
+        });
+    }
+    let parent = dirname(directory);
+    if (parent === directory)
+      throw new AppError({
+        code: "FRAMEWORK_RELEASE_INVALID",
+        message: "The installed framework package metadata is missing."
+      });
+    directory = parent;
+  }
+}
+async function readInstalledFramework() {
+  let { packageRoot, manifest } = readInstalledFrameworkLocation(), installedVersion = version(manifest.version), release;
+  try {
+    release = record(
+      JSON.parse(
+        await readFile(join(packageRoot, "release", "release.json"), "utf8")
+      )
+    );
+  } catch {
+    throw new AppError({
+      code: "FRAMEWORK_RELEASE_INVALID",
+      message: "The installed framework release metadata is unreadable or invalid."
+    });
+  }
+  let node = record(manifest.engines).node;
+  if (release.schemaVersion !== 1 || release.runtime !== "nextjs" || release.version !== installedVersion || typeof node != "string" || node.trim().length === 0 || release.node !== node)
+    throw new AppError({
+      code: "FRAMEWORK_RELEASE_INVALID",
+      message: "The installed framework release identity does not match its package."
+    });
+  let graphRecords = record(release.graphs), graphs = Object.freeze({
+    compiler: graphRecord(graphRecords.compiler),
+    "app/phosphor": graphRecord(graphRecords["app/phosphor"])
+  });
+  if ("configurableDependencies" in release)
+    throw new AppError({
+      code: "FRAMEWORK_RELEASE_INVALID",
+      message: "The installed framework still declares configurable icon dependencies."
+    });
+  return Object.freeze({
+    packageName: frameworkPackageName,
+    version: installedVersion,
+    packageRoot,
+    release: Object.freeze({
+      schemaVersion: 1,
+      runtime: "nextjs",
+      version: installedVersion,
+      node,
+      pnpm: version(release.pnpm),
+      graphs
+    })
+  });
+}
+
+export {
+  readInstalledFrameworkLocation,
+  readInstalledFramework
+};

package/dist/chunk-5KAD7W53.js

@@ -0,0 +1,248 @@
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/source/assets/media-file-policy.ts
+import { constants as fsConstants } from "fs";
+import { open } from "fs/promises";
+var DEFAULT_MAX_IMAGE_BYTES = 20 * 1024 * 1024, DEFAULT_MAX_VIDEO_BYTES = 20 * 1024 * 1024, DEFAULT_MAX_OTHER_BYTES = 5 * 1024 * 1024, MAX_THEME_FONT_BYTES = DEFAULT_MAX_OTHER_BYTES, MAX_MEDIA_SVG_BYTES = 256 * 1024, IGNORED_DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set(["pdf", "txt", "csv", "zip"]), THEME_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "avif",
+  "ico",
+  "svg"
+]), THEME_FONT_EXTENSIONS = /* @__PURE__ */ new Set(["woff", "woff2", "ttf", "otf"]);
+function ignoredMediaDocumentWarning(relativePath) {
+  let extension = relativePath.split(".").at(-1)?.toLowerCase() ?? "";
+  if (IGNORED_DOCUMENT_EXTENSIONS.has(extension))
+    return {
+      code: "FRAMEWORK_MEDIA_DOCUMENT_IGNORED",
+      message: `${relativePath} is ignored because this file type is not supported.`,
+      details: { file: relativePath, path: relativePath }
+    };
+}
+function ignoredMediaPathWarning(sourcePath) {
+  return {
+    code: "FRAMEWORK_MEDIA_PATH_IGNORED",
+    message: "Hidden media file ignored.",
+    details: { file: sourcePath, path: sourcePath }
+  };
+}
+function isHiddenMediaPath(sourcePath) {
+  return sourcePath.split(/[\\/]/u).some((segment) => segment.startsWith("."));
+}
+function mediaFileTooLarge(options) {
+  return new AppError({
+    code: "FRAMEWORK_MEDIA_FILE_TOO_LARGE",
+    message: `${options.relativePath} is ${options.bytes} bytes. Media files must be less than ${Math.round(options.limit / 1024 / 1024)} MB.`,
+    details: {
+      path: options.relativePath,
+      bytes: options.bytes,
+      limit: options.limit
+    }
+  });
+}
+function mediaFileByteLimit(relativePath) {
+  let extension = relativePath.split(".").at(-1)?.toLowerCase() ?? "", imageLimit = DEFAULT_MAX_IMAGE_BYTES;
+  return ["png", "jpg", "jpeg", "gif", "webp", "avif", "ico"].includes(extension) ? imageLimit : extension === "svg" ? Math.min(imageLimit, MAX_MEDIA_SVG_BYTES) : ["mp4", "webm"].includes(extension) ? DEFAULT_MAX_VIDEO_BYTES : DEFAULT_MAX_OTHER_BYTES;
+}
+function themeResourceByteLimit(relativePath) {
+  let extension = relativePath.split(".").at(-1)?.toLowerCase() ?? "";
+  if (THEME_FONT_EXTENSIONS.has(extension)) return MAX_THEME_FONT_BYTES;
+  if (THEME_IMAGE_EXTENSIONS.has(extension))
+    return mediaFileByteLimit(relativePath);
+}
+async function readBoundedMediaFile(options) {
+  let handle = await (options.openFile ?? open)(
+    options.path,
+    fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0) | (fsConstants.O_NONBLOCK ?? 0)
+  );
+  try {
+    let opened = await handle.stat();
+    if (!opened.isFile() || options.expectedIdentity !== void 0 && (opened.dev !== options.expectedIdentity.dev || opened.ino !== options.expectedIdentity.ino))
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_FILE_CHANGED",
+        message: `${options.relativePath} changed while media was being read`,
+        details: { path: options.relativePath }
+      });
+    if (opened.size > options.limit)
+      throw mediaFileTooLarge({
+        relativePath: options.relativePath,
+        bytes: opened.size,
+        limit: options.limit
+      });
+    let chunkSize = Math.min(64 * 1024, options.limit + 1), chunk = Buffer.allocUnsafe(Math.max(1, chunkSize)), chunks = [], bytesRead = 0;
+    for (; ; ) {
+      options.signal?.throwIfAborted();
+      let remainingWithOverflowProbe = options.limit - bytesRead + 1, { bytesRead: count } = await handle.read(
+        chunk,
+        0,
+        Math.min(chunk.length, remainingWithOverflowProbe),
+        null
+      );
+      if (options.signal?.throwIfAborted(), count === 0) break;
+      if (bytesRead += count, bytesRead > options.limit)
+        throw mediaFileTooLarge({
+          relativePath: options.relativePath,
+          bytes: bytesRead,
+          limit: options.limit
+        });
+      chunks.push(Buffer.from(chunk.subarray(0, count)));
+    }
+    let completed = await handle.stat();
+    if (completed.size > options.limit)
+      throw mediaFileTooLarge({
+        relativePath: options.relativePath,
+        bytes: completed.size,
+        limit: options.limit
+      });
+    if (completed.size !== bytesRead)
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_FILE_CHANGED",
+        message: `${options.relativePath} changed while media was being read`,
+        details: { path: options.relativePath }
+      });
+    return Buffer.concat(chunks, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+
+// src/lib/compiler/source/css-imports.ts
+function skipString(css, start) {
+  let quote = css[start];
+  for (let index = start + 1; index < css.length; index += 1)
+    if (css[index] === "\\") index += 1;
+    else if (css[index] === quote) return index + 1;
+  return css.length;
+}
+function maskComments(css) {
+  let result = "";
+  for (let index = 0; index < css.length; )
+    if (css[index] === '"' || css[index] === "'") {
+      let end = skipString(css, index);
+      result += css.slice(index, end), index = end;
+    } else if (css.startsWith("/*", index)) {
+      let closing = css.indexOf("*/", index + 2), end = closing < 0 ? css.length : closing + 2;
+      result += css.slice(index, end).replace(/[^\r\n]/g, " "), index = end;
+    } else
+      result += css[index], index += 1;
+  return result;
+}
+function decodeCssPath(value) {
+  return value.replace(/\\(?:\r\n|[\r\n\f])/g, "").replace(
+    /\\([\da-f]{1,6})[\t\n\f\r ]?|\\(.)/gi,
+    (_match, hex, escaped) => {
+      if (!hex) return escaped ?? "";
+      let codePoint = Number.parseInt(hex, 16);
+      return codePoint > 0 && codePoint <= 1114111 && !(codePoint >= 55296 && codePoint <= 57343) ? String.fromCodePoint(codePoint) : "\uFFFD";
+    }
+  );
+}
+function statementEnd(scan, start) {
+  let depth = 0;
+  for (let index = start; index < scan.length; index += 1)
+    if (scan[index] === '"' || scan[index] === "'")
+      index = skipString(scan, index) - 1;
+    else if (scan[index] === "\\")
+      index += 1;
+    else if (scan[index] === "(")
+      depth += 1;
+    else if (scan[index] === ")")
+      depth -= 1;
+    else {
+      if (scan[index] === ";" && depth === 0)
+        return index + 1;
+      if ((scan[index] === "{" || scan[index] === "}") && depth === 0)
+        return index;
+    }
+  return scan.length;
+}
+function closingParenthesis(scan, start, end) {
+  let depth = 0;
+  for (let index = start; index < end; index += 1)
+    if (scan[index] === '"' || scan[index] === "'")
+      index = skipString(scan, index) - 1;
+    else if (scan[index] === "\\")
+      index += 1;
+    else if (scan[index] === "(")
+      depth += 1;
+    else if (scan[index] === ")" && --depth === 0)
+      return index;
+  return end;
+}
+function importConditions({
+  css,
+  scan,
+  start,
+  end
+}) {
+  let result = {}, tailEnd = scan[end - 1] === ";" ? end - 1 : end, cursor = start, skipWhitespace = () => {
+    for (; cursor < tailEnd && /\s/.test(scan[cursor] ?? ""); ) cursor += 1;
+  };
+  skipWhitespace();
+  let layer = /^layer(?=\(|\s|$)/i.exec(scan.slice(cursor, tailEnd));
+  if (layer) {
+    if (cursor += layer[0].length, scan[cursor] === "(") {
+      let closing = closingParenthesis(scan, cursor, tailEnd);
+      result.layer = css.slice(cursor + 1, closing).trim(), cursor = closing + 1;
+    } else
+      result.layer = !0;
+    skipWhitespace();
+  }
+  let supports = /^supports\(/i.exec(scan.slice(cursor, tailEnd));
+  if (supports) {
+    let opening = cursor + supports[0].length - 1, closing = closingParenthesis(scan, opening, tailEnd);
+    result.supports = css.slice(opening + 1, closing).trim(), cursor = closing + 1, skipWhitespace();
+  }
+  return scan.slice(cursor, tailEnd).trim() && (result.media = css.slice(cursor, tailEnd).trim()), result;
+}
+function cssImports({ css }) {
+  let scan = maskComments(css), pattern = /@import\s+(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|url\(\s*(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|([^\s)]+))\s*\))/giy, imports = [];
+  for (let index = 0; index < scan.length; ) {
+    if (scan[index] === '"' || scan[index] === "'") {
+      index = skipString(scan, index);
+      continue;
+    }
+    if (scan[index] === "\\") {
+      index += 2;
+      continue;
+    }
+    pattern.lastIndex = index;
+    let match = scan[index] === "@" ? pattern.exec(scan) : null;
+    if (!match) {
+      index += 1;
+      continue;
+    }
+    let path = decodeCssPath(
+      match.slice(1).find((value) => value !== void 0) ?? ""
+    ), end = statementEnd(scan, pattern.lastIndex);
+    imports.push({
+      path,
+      start: index,
+      end,
+      ...importConditions({ css, scan, start: pattern.lastIndex, end })
+    }), index = end;
+  }
+  return imports;
+}
+function localCssImports({ css }) {
+  return cssImports({ css }).filter(({ path }) => path.startsWith("."));
+}
+
+export {
+  MAX_MEDIA_SVG_BYTES,
+  ignoredMediaDocumentWarning,
+  ignoredMediaPathWarning,
+  isHiddenMediaPath,
+  mediaFileTooLarge,
+  mediaFileByteLimit,
+  themeResourceByteLimit,
+  readBoundedMediaFile,
+  decodeCssPath,
+  cssImports,
+  localCssImports
+};

package/dist/chunk-6C65KV7O.js

@@ -0,0 +1,142 @@
+import {
+  acquireOperationLock,
+  assertLocalDirectory,
+  assertOperationOutput,
+  markOperationOutput
+} from "./chunk-6D2E6UMD.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/lifecycle/checkout-preparation.ts
+import { lstat, mkdir, readdir, realpath } from "fs/promises";
+import { isAbsolute, join } from "path";
+import { setTimeout } from "timers/promises";
+async function withCheckoutPreparation({
+  packageRoot,
+  workspaceRoot,
+  signal,
+  prepare
+}) {
+  signal?.throwIfAborted();
+  let selectedRoot = workspaceRoot ?? packageRoot;
+  if (!isAbsolute(selectedRoot))
+    throw new AppError({
+      code: "FRAMEWORK_LOCAL_SOURCE_INVALID",
+      message: "Checkout preparation requires an absolute checkout path."
+    });
+  let sourceRoot = await realpath(selectedRoot), sourceIdentity = await assertLocalDirectory(sourceRoot), outputRoot = join(sourceRoot, ".publish.os");
+  await mkdir(outputRoot).catch((error) => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  let rootIdentity = await assertLocalDirectory(outputRoot), outputDir = join(outputRoot, "checkout-dependencies"), output = { sourceRoot, outputDir, operation: "dependencies" }, created = !1;
+  await mkdir(outputDir).then(() => {
+    created = !0;
+  }).catch((error) => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  let identity = await assertLocalDirectory(outputDir);
+  if (created) {
+    if ((await readdir(outputDir)).length !== 0)
+      throw new AppError({
+        code: "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
+        message: `Checkout preparation metadata changed at ${outputDir}. Preserve it and inspect the owner before retrying.`
+      });
+    await markOperationOutput(output);
+  } else
+    for (let attempt = 0; ; attempt += 1) {
+      signal?.throwIfAborted(), await assertLocalDirectory(sourceRoot, sourceIdentity), await assertLocalDirectory(outputRoot, rootIdentity), await assertLocalDirectory(outputDir, identity);
+      let entries = await readdir(outputDir), published = entries.includes(".operation-owner.json");
+      published && await assertOperationOutput(output);
+      let temporary = entries.filter(
+        (name) => /^\.operation-owner-init-[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}\.tmp$/u.test(
+          name
+        )
+      );
+      if (entries.some(
+        (name) => !temporary.includes(name) && name !== ".operation-owner.json" && !(published && name === ".locks")
+      ))
+        throw new AppError({
+          code: "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
+          message: `Checkout preparation initialization cannot be verified at ${outputDir}. Preserve its files and inspect the owner before retrying.`
+        });
+      for (let name of temporary) {
+        let entry = await lstat(join(outputDir, name)).catch(
+          (error) => {
+            if (error.code !== "ENOENT") throw error;
+          }
+        );
+        if (entry && !entry.isFile())
+          throw new AppError({
+            code: "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
+            message: `Checkout preparation initialization is redirected at ${join(outputDir, name)}. Preserve the marker and restore its owner before retrying.`
+          });
+      }
+      if (published && temporary.length === 0) break;
+      if (attempt >= 50)
+        throw new AppError({
+          code: "FRAMEWORK_LOCAL_OUTPUT_OWNERSHIP",
+          message: `Checkout preparation initialization did not finish at ${outputDir}. Preserve its metadata and verify the initializer stopped before retrying.`
+        });
+      await setTimeout(10, void 0, { signal });
+    }
+  let assertCurrent = async () => {
+    if (await assertLocalDirectory(sourceRoot, sourceIdentity), await assertLocalDirectory(outputRoot, rootIdentity), await assertLocalDirectory(outputDir, identity), await assertOperationOutput(output), (await readdir(outputDir)).some(
+      (name) => name !== ".operation-owner.json" && name !== ".locks"
+    ))
+      throw new AppError({
+        code: "FRAMEWORK_LOCAL_LOCK_UNVERIFIED",
+        message: `Checkout preparation contains unknown files at ${outputDir}. Preserve them and inspect the owner before retrying.`
+      });
+  }, deadline = Date.now() + 36e4, release;
+  for (; ; ) {
+    signal?.throwIfAborted(), await assertCurrent();
+    try {
+      release = await acquireOperationLock({
+        sourceRoot,
+        outputRoot: outputDir,
+        operation: "dependencies",
+        signal
+      });
+      break;
+    } catch (error) {
+      if (!(error instanceof AppError) || error.code !== "FRAMEWORK_LOCAL_OPERATION_ACTIVE" || Date.now() >= deadline)
+        throw error;
+      await setTimeout(100, void 0, { signal });
+    }
+  }
+  let stopped = !0, failed = !1, failure, result;
+  try {
+    await assertCurrent(), signal?.throwIfAborted(), stopped = !1, result = await prepare(() => {
+      stopped = !0;
+    });
+  } catch (error) {
+    failed = !0, failure = error;
+  }
+  try {
+    await assertCurrent(), await release({ shutdownUnverified: !stopped });
+  } catch (error) {
+    if (!failed) throw error;
+    failure instanceof Error && (failure.cause = new AppError({
+      code: "FRAMEWORK_LOCAL_LOCK_UNVERIFIED",
+      message: `Checkout dependency lock retention failed at ${outputDir}. Preserve the metadata and verify the recorded preparer's descendants before recovery.`,
+      details: {
+        lockPath: join(outputDir, ".locks/dependencies"),
+        cause: error,
+        primaryCause: failure.cause
+      }
+    }));
+  }
+  if (failed) throw failure;
+  if (!stopped)
+    throw new AppError({
+      code: "FRAMEWORK_PROCESS_SHUTDOWN_FAILED",
+      message: `Checkout dependency preparation at ${sourceRoot} did not prove shutdown. Its lock remains protected.`,
+      fix: "Verify the recorded preparer's descendants stopped before recovering its retained lock."
+    });
+  return result;
+}
+
+export {
+  withCheckoutPreparation
+};