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

package/dist/chunk-EFO6AWXN.js

@@ -0,0 +1,19 @@
+// src/lib/hosting/framework-paths.ts
+var FRAMEWORK_PREFIX = "/publishos", SOURCE_ASSET_PREFIX = `${FRAMEWORK_PREFIX}/assets`, INTERNAL_PREFIX = `${FRAMEWORK_PREFIX}/internal`, SITE_API_PREFIX = `${FRAMEWORK_PREFIX}/api`, SEARCH_PREFIX = `${INTERNAL_PREFIX}/search`, PAGEFIND_MODULE_URL = `${SEARCH_PREFIX}/pagefind.js`, PAGEFIND_ENTRY_URL = `${SEARCH_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_INTERNAL_DIRECTORY = INTERNAL_PREFIX.slice(1), PUBLIC_FONT_DIRECTORY = `${PUBLIC_INTERNAL_DIRECTORY}/fonts`, PUBLIC_SEARCH_DIRECTORY = `public/${PUBLIC_INTERNAL_DIRECTORY}/search`, 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}/`);
+}
+
+export {
+  FRAMEWORK_PREFIX,
+  SOURCE_ASSET_PREFIX,
+  INTERNAL_PREFIX,
+  IMAGE_OPTIMIZER_PATH,
+  NEXT_IMAGE_OPTIMIZER_PATH,
+  OG_SERVICE_PREFIX,
+  PUBLIC_INTERNAL_DIRECTORY,
+  PUBLIC_FONT_DIRECTORY,
+  PUBLIC_SEARCH_DIRECTORY,
+  FRAMEWORK_PROXY_MATCHER,
+  isFrameworkNamespacePath
+};

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
+};