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

package/dist/chunk-GBPLER5H.js

@@ -0,0 +1,426 @@
+import {
+  acquireOperationLock,
+  ensureLocalOutputRoot,
+  publishOwnedDirectory
+} from "./chunk-6D2E6UMD.js";
+import {
+  createIdeSourceArtifacts
+} from "./chunk-OXOFRXEI.js";
+import {
+  assertFrameworkSelection,
+  readCheckoutTypeScriptConfig
+} from "./chunk-NNBJZPFM.js";
+import {
+  supportedNextjsSourceImports
+} from "./chunk-UYGCOWRF.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-IL4RJOKI.js

@@ -0,0 +1,186 @@
+import {
+  acquireOperationLock,
+  assertGeneratedOutput,
+  assertLocalDirectory,
+  assertOperationOutput,
+  ensureLocalOutputRoot,
+  localOperationName,
+  markOperationOutput,
+  publishOwnedDirectory,
+  recoverOperationOutput
+} from "./chunk-6D2E6UMD.js";
+import {
+  assertPublishOsSourceBoundary
+} from "./chunk-7NY22B5U.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/lifecycle/local-operation.ts
+import { mkdir, mkdtemp, realpath, rm } from "fs/promises";
+import { isAbsolute, join, resolve } from "path";
+async function withLocalOperation(options) {
+  let operation = await openLocalOperation(options);
+  try {
+    operation.context.signal.throwIfAborted();
+    let result = await options.run(operation.context);
+    return options.signal?.throwIfAborted(), result;
+  } finally {
+    await operation.close();
+  }
+}
+async function openLocalOperation(options) {
+  if (options.signal?.throwIfAborted(), options.operation !== "build" && options.operation !== "dev")
+    throw new AppError({
+      code: "FRAMEWORK_LOCAL_OPERATION_INVALID",
+      message: "Select a build or development operation."
+    });
+  if (!isAbsolute(options.sourceRoot))
+    throw new AppError({
+      code: "FRAMEWORK_LOCAL_SOURCE_INVALID",
+      message: "Supply an absolute publish.os source path."
+    });
+  await assertPublishOsSourceBoundary(options.sourceRoot);
+  let operationName = localOperationName(options), sourceRoot = await realpath(options.sourceRoot), outputRoot = join(sourceRoot, ".publish.os"), outputDir = join(outputRoot, operationName);
+  if (options.outputDir && resolve(options.outputDir) !== outputDir)
+    throw new AppError({
+      code: "FRAMEWORK_LOCAL_OUTPUT_INVALID",
+      message: "Local output must use the selected source and operation directory."
+    });
+  let ownership = await ensureLocalOutputRoot({ sourceRoot }), output = {
+    sourceRoot,
+    outputDir,
+    operation: options.operation,
+    scope: options.scope
+  }, releaseLock = await acquireOperationLock({
+    sourceRoot,
+    outputRoot,
+    operation: options.operation,
+    scope: options.scope,
+    signal: options.signal
+  }), stagingRoot;
+  try {
+    await recoverOperationOutput({
+      ...output,
+      assertCurrent: ownership.assertCurrent
+    }), options.signal?.throwIfAborted(), await ownership.assertCurrent(), await mkdir(join(outputRoot, ".stages"), { recursive: !0 }), await assertLocalDirectory(join(outputRoot, ".stages")), stagingRoot = await mkdtemp(
+      join(outputRoot, ".stages", `${operationName}-`)
+    );
+  } catch (error) {
+    throw await releaseLock(), error;
+  }
+  let stagingIdentity = await assertLocalDirectory(stagingRoot), retainStaging = !1, assertStaging = async () => {
+    try {
+      await ownership.assertCurrent(), await assertLocalDirectory(stagingRoot, stagingIdentity);
+    } catch (error) {
+      throw retainStaging = !0, error;
+    }
+  }, controller = new AbortController(), signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal, sourceDir = sourceRoot, sourceRevision;
+  try {
+    if (options.operation === "build") {
+      let { captureLocalSource } = await import("./capture-local-source-WGGDIUU2.js"), capture = await captureLocalSource({
+        sourceRoot,
+        captureDir: join(stagingRoot, "source"),
+        signal
+      });
+      sourceDir = capture.sourceDir, sourceRevision = capture.sourceRevision;
+    }
+  } catch (error) {
+    throw await assertStaging(), await rm(stagingRoot, { recursive: !0, force: !0 }), await releaseLock(), error;
+  }
+  let shutdown = [], shutdownFailures = [], acceptsShutdownRegistrations = !0, stopping, stopCallbacks = async (callbacks) => {
+    let results = await Promise.allSettled(
+      callbacks.map((callback) => Promise.resolve().then(callback))
+    );
+    shutdownFailures.push(
+      ...results.filter((result) => result.status === "rejected").map((result) => result.reason)
+    );
+  }, stop = async () => {
+    stopping ??= stopCallbacks(shutdown);
+    let active = stopping;
+    for (; await active, active !== stopping; )
+      active = stopping;
+    if (shutdownFailures.length)
+      throw new AppError({
+        code: "FRAMEWORK_PROCESS_SHUTDOWN_FAILED",
+        message: "Owned resources did not stop. Output and locks remain in place. Confirm that all operation processes have stopped before recovery.",
+        details: { failures: shutdownFailures }
+      });
+  }, abort = () => {
+    stop().catch(() => {
+    });
+  };
+  signal.addEventListener("abort", abort, { once: !0 });
+  let replacementWork, replaceOutput = async (run) => {
+    signal.throwIfAborted(), await assertStaging(), await publishOwnedDirectory({
+      targetDirectory: outputDir,
+      stagingRoot,
+      stagingPrefix: "output",
+      signal,
+      cleanupFailedStaging: !1,
+      assertOwner: async () => {
+        try {
+          await assertStaging();
+        } catch (error) {
+          throw retainStaging = !0, error;
+        }
+      },
+      onRecoveryRequired: () => {
+        retainStaging = !0;
+      },
+      prepareIncoming: run,
+      validateIncoming: async (incoming) => {
+        await assertLocalDirectory(incoming), await assertOperationOutput(output), await assertGeneratedOutput(output), await markOperationOutput({ ...output, outputDir: incoming });
+      }
+    });
+  };
+  return {
+    context: {
+      sourceRoot,
+      sourceDir,
+      sourceRevision,
+      outputDir,
+      signal,
+      onShutdown: (callback) => acceptsShutdownRegistrations ? stopping ? (stopping = stopping.then(() => stopCallbacks([callback])), () => {
+      }) : (shutdown.push(callback), () => {
+        let index = shutdown.indexOf(callback);
+        index !== -1 && shutdown.splice(index, 1);
+      }) : (signal.throwIfAborted(), () => {
+      }),
+      replaceOutput: (run) => {
+        if (replacementWork)
+          return Promise.reject(
+            new AppError({
+              code: "FRAMEWORK_LOCAL_REPLACEMENT_ACTIVE",
+              message: "Wait for the current output replacement to finish."
+            })
+          );
+        let work = replaceOutput(run);
+        return replacementWork = work, work.finally(() => {
+          replacementWork === work && (replacementWork = void 0);
+        }).catch(() => {
+        }), work;
+      }
+    },
+    close: async () => {
+      if (controller.abort(), acceptsShutdownRegistrations = !1, await stop().catch(async (error) => {
+        try {
+          await releaseLock({ shutdownUnverified: !0 });
+        } catch (retentionFailure) {
+          error instanceof AppError && error.details && (error.details.lockRetentionFailure = retentionFailure);
+        }
+        throw error;
+      }), await replacementWork?.catch(() => {
+      }), signal.removeEventListener("abort", abort), await assertStaging(), retainStaging)
+        throw new AppError({
+          code: "FRAMEWORK_LOCAL_OUTPUT_REDIRECTED",
+          message: `Output cleanup stopped to preserve unverified data. Inspect ${stagingRoot} before recovery.`
+        });
+      await rm(stagingRoot, { recursive: !0, force: !0 }), await releaseLock();
+    }
+  };
+}
+
+export {
+  withLocalOperation
+};

package/dist/{chunk-DLDFHU7Y.js → chunk-NNBJZPFM.js}

@@ -2,9 +2,11 @@ import {
   runtimePackageVersion
 } from "./chunk-AI2UULNX.js";
 import {
-  AppError,
   readInstalledFrameworkLocation
-} from "./chunk-WDY4IK6Z.js";
+} from "./chunk-5J3YUNRY.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/release/framework-selection.ts
 import { createHash } from "crypto";

package/dist/{chunk-VO2I7MTM.js → chunk-ORIUWJBQ.js}

@@ -1,13 +1,15 @@
-import {
-  validatePublishOsSource
-} from "./chunk-726GV2NF.js";
 import {
   assertFrameworkSelection
-} from "./chunk-DLDFHU7Y.js";
+} from "./chunk-NNBJZPFM.js";
+import {
+  validatePublishOsSource
+} from "./chunk-F3AGNDF4.js";
 import {
-  AppError,
   readInstalledFramework
-} from "./chunk-WDY4IK6Z.js";
+} from "./chunk-5J3YUNRY.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/lifecycle/validate-local-source.ts
 async function validateLocalSource({