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

package/dist/chunk-NNBJZPFM.js

@@ -0,0 +1,193 @@
+import {
+  runtimePackageVersion
+} from "./chunk-AI2UULNX.js";
+import {
+  readInstalledFrameworkLocation
+} from "./chunk-5J3YUNRY.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/release/framework-selection.ts
+import { createHash } from "crypto";
+import { readFile, realpath, stat } from "fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "path";
+import { fileURLToPath } from "url";
+
+// src/lib/compiler/release/framework-archive.ts
+import { posix } from "path";
+import { isDeepStrictEqual } from "util";
+import { Parser } from "tar";
+function invalidArchive(message) {
+  return new AppError({ code: "FRAMEWORK_ARCHIVE_INVALID", message });
+}
+async function readArchiveManifest(archive) {
+  return await new Promise((resolve2, reject) => {
+    let manifestFound = !1, manifestSource, parser = new Parser({
+      strict: !0,
+      onReadEntry: (entry) => {
+        if (posix.normalize(entry.path.replaceAll("\\", "/")) !== "package/package.json") {
+          entry.resume();
+          return;
+        }
+        if (manifestFound || entry.path !== "package/package.json" || entry.type !== "File" || entry.size > 1048576) {
+          parser.abort(
+            invalidArchive(
+              "The framework archive must contain one regular package manifest."
+            )
+          ), entry.resume();
+          return;
+        }
+        manifestFound = !0;
+        let chunks = [];
+        entry.on("data", (chunk) => {
+          chunks.push(chunk);
+        }), entry.on("end", () => {
+          manifestSource = Buffer.concat(chunks).toString("utf8");
+        }), entry.resume();
+      }
+    });
+    parser.on("error", (error) => {
+      reject(
+        error instanceof AppError ? error : invalidArchive("The framework archive is malformed.")
+      );
+    }), parser.on("end", () => {
+      try {
+        let manifest = JSON.parse(manifestSource ?? "");
+        if (!manifest || typeof manifest != "object" || Array.isArray(manifest))
+          throw invalidArchive(
+            "The framework archive package manifest is invalid."
+          );
+        resolve2(manifest);
+      } catch {
+        reject(
+          invalidArchive(
+            "The framework archive package manifest is missing or invalid."
+          )
+        );
+      }
+    }), parser.end(archive);
+  });
+}
+async function assertFrameworkArchiveIdentity({
+  archive,
+  framework
+}) {
+  let manifest = await readArchiveManifest(archive);
+  if (manifest.name !== framework.packageName || manifest.version !== framework.version)
+    throw invalidArchive(
+      "The framework archive identity does not match the executing release."
+    );
+  let installed = readInstalledFrameworkLocation();
+  if (installed.packageRoot !== framework.packageRoot || installed.manifest.version !== framework.version)
+    throw invalidArchive(
+      "The executing framework identity changed during archive validation."
+    );
+  for (let field of [
+    "dependencies",
+    "optionalDependencies",
+    "peerDependencies",
+    "peerDependenciesMeta",
+    "engines"
+  ])
+    if (!isDeepStrictEqual(manifest[field] ?? {}, installed.manifest[field] ?? {}))
+      throw invalidArchive(
+        `The framework archive field ${field} does not match the executing release.`
+      );
+}
+
+// src/lib/compiler/release/framework-selection.ts
+async function readCheckoutTypeScriptConfig({
+  packageRoot
+}) {
+  try {
+    let source = await readFile(join(packageRoot, "tsconfig.json")), paths = JSON.parse(source.toString("utf8"))?.compilerOptions?.paths;
+    if (!paths || typeof paths != "object" || Array.isArray(paths) || !Object.values(paths).every(
+      (targets) => Array.isArray(targets) && targets.length > 0 && targets.every(
+        (target) => typeof target == "string" && target.length > 0
+      )
+    ))
+      throw new Error("Invalid checkout paths");
+    let aliases = paths;
+    if (!aliases["@/*"] || aliases["@/*"].some(
+      (target) => resolve(packageRoot, target) !== join(packageRoot, "src/*")
+    ))
+      throw new Error("Missing compiler source alias");
+    return { source, paths: aliases };
+  } catch {
+    throw new AppError({
+      code: "FRAMEWORK_SELECTION_INVALID",
+      message: "The selected checkout TypeScript configuration is missing or invalid.",
+      fix: "Restore the checkout tsconfig.json and its source paths, then repeat the operation. No registry fallback is available."
+    });
+  }
+}
+async function assertFrameworkSelection({
+  context,
+  framework,
+  runtime
+}) {
+  let selected = context?.framework;
+  if (selected !== void 0) {
+    if (!selected || !["checkout", "candidate"].includes(selected.kind) || selected.packageName !== framework.packageName || selected.version !== framework.version)
+      throw new AppError({
+        code: "FRAMEWORK_SELECTION_INVALID",
+        message: "The selected local framework does not match the executing input.",
+        fix: "Select a valid local checkout or package candidate and repeat the operation. No registry fallback is available."
+      });
+    if (selected.kind === "checkout") {
+      let root = typeof selected.packageRoot == "string" && isAbsolute(selected.packageRoot) ? await realpath(selected.packageRoot).catch(() => {
+      }) : void 0;
+      if (!root || !relative(root, fileURLToPath(import.meta.url)).startsWith(
+        `src${sep}`
+      ) || !fileURLToPath(import.meta.url).endsWith(".ts") || root !== await realpath(framework.packageRoot) || !(await stat(join(root, "src/compiler.ts")).catch(() => {
+      }))?.isFile() || context?.archive !== void 0)
+        throw new AppError({
+          code: "FRAMEWORK_SELECTION_INVALID",
+          message: "The selected checkout is missing or does not contain the executing compiler.",
+          fix: "Invoke src/compiler.ts from the selected editable checkout without a package archive. No registry fallback is available."
+        });
+      let config = await readCheckoutTypeScriptConfig({ packageRoot: root }), manifest = await readFile(join(root, "package.json")).catch(() => {
+        throw new AppError({
+          code: "FRAMEWORK_SELECTION_INVALID",
+          message: "The selected checkout package metadata is unreadable.",
+          fix: "Restore the checkout package.json, then repeat the operation. No registry fallback is available."
+        });
+      });
+      return `checkout:${createHash("sha256").update(root).update(manifest).update(config.source).update(JSON.stringify(framework.release)).digest("hex")}`;
+    }
+    if (typeof selected.integrity != "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/u.test(selected.integrity) || selected.integrity !== context?.archive?.integrity)
+      throw new AppError({
+        code: "FRAMEWORK_SELECTION_INVALID",
+        message: "The selected local framework does not match the executing input.",
+        fix: "Select a valid local checkout or package candidate and repeat the operation. No registry fallback is available."
+      });
+    let archive = await readFile(context?.archive?.path ?? "").catch(() => {
+      throw new AppError({
+        code: "FRAMEWORK_SELECTION_INVALID",
+        message: "The selected local framework archive is missing or unreadable.",
+        fix: "Prepare the selected local framework again. No registry fallback is available."
+      });
+    });
+    if (`sha512-${createHash("sha512").update(archive).digest("base64")}` !== selected.integrity)
+      throw new AppError({
+        code: "FRAMEWORK_SELECTION_INVALID",
+        message: "The selected local framework archive does not match its integrity.",
+        fix: "Prepare the selected local framework again. No registry fallback is available."
+      });
+    return await assertFrameworkArchiveIdentity({ archive, framework }), selected.integrity;
+  }
+  if (runtimePackageVersion(runtime) !== framework.version)
+    throw new AppError({
+      code: "FRAMEWORK_SOURCE_PIN_MISMATCH",
+      message: "The source pin does not match the executing framework release.",
+      fix: "Invoke the exact framework version selected in publish.os.config.json."
+    });
+  return context?.archive?.integrity ?? "";
+}
+
+export {
+  assertFrameworkArchiveIdentity,
+  readCheckoutTypeScriptConfig,
+  assertFrameworkSelection
+};

package/dist/chunk-ORIUWJBQ.js

@@ -0,0 +1,58 @@
+import {
+  assertFrameworkSelection
+} from "./chunk-NNBJZPFM.js";
+import {
+  validatePublishOsSource
+} from "./chunk-F3AGNDF4.js";
+import {
+  readInstalledFramework
+} from "./chunk-5J3YUNRY.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/lifecycle/validate-local-source.ts
+async function validateLocalSource({
+  options,
+  sourceDir,
+  sourceRoot
+}) {
+  options.signal?.throwIfAborted(), options.onEvent?.({ type: "progress", message: "Validating source" });
+  let validation = await validatePublishOsSource({
+    publishOsDir: sourceDir,
+    sourceIdentity: { sourceRoot }
+  });
+  if (options.signal?.throwIfAborted(), options.onEvent?.({
+    type: "diagnostics",
+    diagnostics: {
+      diagnostics: [...validation.errors, ...validation.warnings].map(
+        (diagnostic) => ({
+          code: diagnostic.code,
+          severity: diagnostic.level,
+          message: diagnostic.message,
+          ...diagnostic.file === void 0 ? {} : { file: diagnostic.file },
+          ...diagnostic.line === void 0 ? {} : { line: diagnostic.line },
+          ...diagnostic.column === void 0 ? {} : { column: diagnostic.column },
+          ...typeof diagnostic.details?.correction == "string" ? { correction: diagnostic.details.correction } : {},
+          ...typeof diagnostic.details?.sourceLine == "string" ? { sourceLine: diagnostic.details.sourceLine } : {},
+          ...typeof diagnostic.details?.length == "number" ? { length: diagnostic.details.length } : {},
+          ...typeof diagnostic.details?.propertyPath == "string" ? { propertyPath: diagnostic.details.propertyPath } : {}
+        })
+      )
+    }
+  }), !validation.valid || !validation.source)
+    throw new AppError({
+      code: "FRAMEWORK_SOURCE_INVALID",
+      message: "The selected source failed validation."
+    });
+  let framework = await readInstalledFramework();
+  return await assertFrameworkSelection({
+    context: options.request.context,
+    framework,
+    runtime: validation.source.config.runtime
+  }), { source: validation.source, framework };
+}
+
+export {
+  validateLocalSource
+};