@lunora/vite 1.0.0-alpha.7 → 1.0.0-alpha.71

package/dist/index.mjs

@@ -1,22 +1,28 @@
+import { createRequire } from 'node:module';
 import { cloudflare } from '@cloudflare/vite-plugin';
 import errorOverlayPlugin from '@visulima/vite-overlay';
 import { detectAgentRules, claimAgentRulesHint, AGENT_RULES_HINT, detectFramework } from '@lunora/config';
-export { detectFramework } from '@lunora/config';
+export { detectFramework, reconcileWranglerCrons } from '@lunora/config';
 import { l as lunoraLine } from './packem_shared/log-BjO9EWah.mjs';
-import codegenPlugin from './packem_shared/codegenPlugin-MuvbqAP8.mjs';
-import devVariablesPlugin from './packem_shared/devVariablesPlugin-CVjkQay7.mjs';
+import codegenPlugin from './packem_shared/codegenPlugin-B8c38rky.mjs';
+import containerLogsPlugin from './packem_shared/containerLogsPlugin-DMssU3wb.mjs';
+import devStatePlugin from './packem_shared/devStatePlugin-DdjfMrhx.mjs';
+import devVariablesPlugin from './packem_shared/devVariablesPlugin-CDNSnvOP.mjs';
 import { createCommandProbe, withDevWorkerEnv } from './packem_shared/DEV_WORKER_ENV_VALUE-Coo6bgVz.mjs';
 export { DEV_WORKER_ENV_VALUE, DEV_WORKER_ENV_VAR } from './packem_shared/DEV_WORKER_ENV_VALUE-Coo6bgVz.mjs';
-import { frameworkComposePlugin } from './packem_shared/CLASS_A_WIRING-CZVcjgKo.mjs';
-export { CLASS_A_WIRING, LUNORA_WORKER_VIRTUAL_ID, buildWorkerEntrySource, isAutoComposable } from './packem_shared/CLASS_A_WIRING-CZVcjgKo.mjs';
-import logStreamPlugin from './packem_shared/logStreamPlugin-CqvZ17kd.mjs';
-import { planViteRemoteBindings, remoteBindingsCleanupPlugin, withRemoteBindings } from './packem_shared/planViteRemoteBindings-QN5ncUS1.mjs';
-import { studioPlugin } from './packem_shared/STUDIO_PATH-5ppCdBHa.mjs';
-export { STUDIO_PATH, buildStudioUrl } from './packem_shared/STUDIO_PATH-5ppCdBHa.mjs';
+import { frameworkComposePlugin } from './packem_shared/CLASS_A_WIRING-T1RohRZQ.mjs';
+export { CLASS_A_WIRING, LUNORA_WORKER_VIRTUAL_ID, buildWorkerEntrySource, isAutoComposable } from './packem_shared/CLASS_A_WIRING-T1RohRZQ.mjs';
+import logStreamPlugin from './packem_shared/logStreamPlugin-DeFzd_pC.mjs';
+import { planViteRemoteBindings, remoteBindingsCleanupPlugin, remoteBindingsConfigPlugin } from './packem_shared/planViteRemoteBindings-CRU90Bip.mjs';
+export { withRemoteBindings } from './packem_shared/planViteRemoteBindings-CRU90Bip.mjs';
+import { lunoraSolutionFinders } from './packem_shared/lunoraSolutionFinder-BKEAiUJP.mjs';
+export { lunoraSolutionFinder } from './packem_shared/lunoraSolutionFinder-BKEAiUJP.mjs';
+import { studioPlugin } from './packem_shared/STUDIO_PATH-U0eIaW1t.mjs';
+export { STUDIO_PATH, buildStudioUrl } from './packem_shared/STUDIO_PATH-U0eIaW1t.mjs';
 import { withWorkerStartupHint } from './packem_shared/WORKER_STARTUP_HINT-DhsXUW8k.mjs';
 export { WORKER_STARTUP_HINT, augmentWorkerStartupError, isWorkerEntryEvalError } from './packem_shared/WORKER_STARTUP_HINT-DhsXUW8k.mjs';
-import { wranglerValidatorPlugin } from './packem_shared/wranglerValidatorPlugin-CEoJEghS.mjs';
-export { reconcileWranglerCrons } from './packem_shared/reconcileWranglerCrons-PxGwfCp_.mjs';
+import { wranglerValidatorPlugin } from './packem_shared/wranglerValidatorPlugin-C5VWOD7N.mjs';
+export { default as LUNORA_API_UPDATED_EVENT } from './packem_shared/LUNORA_API_UPDATED_EVENT-BrkWk3rr.mjs';
 
 const agentRulesHintPlugin = (options) => {
   return {
@@ -81,6 +87,19 @@ const frameworkDetectPlugin = (options, context) => {
   };
 };
 
+const resolveOverlayOption = (overlay) => {
+  if (overlay === false) {
+    return false;
+  }
+  const userOverlay = overlay === true || overlay === void 0 ? {} : overlay;
+  return {
+    ...userOverlay,
+    // After the spread + nullish-coalesce so an explicit `undefined` from the
+    // user doesn't erase Lunora's default (the spread would otherwise win).
+    forwardedConsoleMethods: userOverlay.forwardedConsoleMethods ?? ["error", "warn"],
+    solutionFinders: [...lunoraSolutionFinders, ...userOverlay.solutionFinders ?? []]
+  };
+};
 const resolveOptions = (options) => {
   const input = options ?? {};
   const schemaDirectory = input.schemaDir ?? "lunora";
@@ -92,20 +111,13 @@ const resolveOptions = (options) => {
   } else {
     cloudflareOption = input.cloudflare;
   }
-  let overlayOption;
-  if (input.overlay === false) {
-    overlayOption = false;
-  } else if (input.overlay === true || input.overlay === void 0) {
-    overlayOption = {};
-  } else {
-    overlayOption = input.overlay;
-  }
   return {
+    allowUnauthenticatedShardAccess: input.allowUnauthenticatedShardAccess ?? false,
     apiSpec: input.apiSpec ?? "openapi",
     cloudflare: cloudflareOption,
     studio: input.studio ?? true,
     generatedDir: input.generatedDir ?? `${schemaDirectory}/_generated`,
-    overlay: overlayOption,
+    overlay: resolveOverlayOption(input.overlay),
     projectRoot: input.projectRoot ?? process.cwd(),
     schemaDir: schemaDirectory,
     validateWrangler: input.validateWrangler ?? true
@@ -128,6 +140,9 @@ const lunora = (options) => {
     devVariablesPlugin(resolved),
     codegenPlugin(resolved),
     logStreamPlugin(),
+    // Registers the running dev server in `.lunora/dev.json` so
+    // `lunora dev --background|stop|status|logs` manage Vite projects too.
+    devStatePlugin(resolved),
     agentRulesHintPlugin(resolved)
   ];
   if (resolved.studio) {
@@ -140,15 +155,19 @@ const lunora = (options) => {
     plugins.push(errorOverlayPlugin(resolved.overlay));
   }
   if (resolved.cloudflare !== false) {
+    plugins.push(containerLogsPlugin(resolved));
     const remotePlan = planViteRemoteBindings({ projectRoot: resolved.projectRoot });
-    if (remotePlan.enabled && remotePlan.configPath !== void 0) {
-      plugins.push(remoteBindingsCleanupPlugin(remotePlan.cleanup));
+    const cloudflareOptions = withDevWorkerEnv(resolved.cloudflare, isServe);
+    if (remotePlan.enabled) {
+      if (remotePlan.configPath !== void 0) {
+        plugins.push(remoteBindingsCleanupPlugin(remotePlan.cleanup));
+      }
+      plugins.push(remoteBindingsConfigPlugin(cloudflareOptions, remotePlan));
     }
-    const cloudflareOptions = withRemoteBindings(withDevWorkerEnv(resolved.cloudflare, isServe), isServe, remotePlan);
     plugins.push(...withWorkerStartupHint(cloudflare(cloudflareOptions)));
   }
   return plugins;
 };
-const VERSION = "0.0.0";
+const VERSION = createRequire(import.meta.url)("../package.json").version;
 
-export { VERSION, codegenPlugin, createCommandProbe, devVariablesPlugin, frameworkComposePlugin, logStreamPlugin, lunora, planViteRemoteBindings, remoteBindingsCleanupPlugin, studioPlugin, withDevWorkerEnv, withRemoteBindings, withWorkerStartupHint, wranglerValidatorPlugin };
+export { VERSION, codegenPlugin, containerLogsPlugin, createCommandProbe, devStatePlugin, devVariablesPlugin, frameworkComposePlugin, logStreamPlugin, lunora, lunoraSolutionFinders, planViteRemoteBindings, remoteBindingsCleanupPlugin, remoteBindingsConfigPlugin, resolveOverlayOption, studioPlugin, withDevWorkerEnv, withWorkerStartupHint, wranglerValidatorPlugin };

package/dist/packem_shared/{CLASS_A_WIRING-CZVcjgKo.mjs → CLASS_A_WIRING-T1RohRZQ.mjs}

@@ -1,9 +1,13 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve, join } from 'node:path';
+import { LunoraError } from '@lunora/errors';
 
 const LUNORA_WORKER_VIRTUAL_ID = "virtual:lunora/worker";
 const RESOLVED_VIRTUAL_PREFIX = "\0";
 const RESOLVED_LUNORA_WORKER_ID = `${RESOLVED_VIRTUAL_PREFIX}${LUNORA_WORKER_VIRTUAL_ID}`;
+const CLIENT_WORKER_STUB = `// @lunora/vite — the composed worker entry is worker-only and unavailable in the client environment.
+export default {};
+`;
 const TRAILING_SLASH = /\/$/;
 const CLASS_A_WIRING = {
   "react-router": {
@@ -44,23 +48,24 @@ const projectUsesUmbrella = (projectRoot) => {
     return false;
   }
 };
-const buildWorkerEntrySource = (framework, generatedImportBase, hasContainers = false, useUmbrella = false) => {
+const buildWorkerEntrySource = (framework, generatedImportBase, hasContainers = false, useUmbrella = false, allowUnauthenticatedShardAccess = false) => {
   const wiring = CLASS_A_WIRING[framework];
   if (wiring === void 0) {
-    throw new Error(`[lunora] no class-A worker wiring for framework "${framework}"`);
+    throw new LunoraError("INTERNAL", `[lunora] no class-A worker wiring for framework "${framework}"`);
   }
+  const base = generatedImportBase.replaceAll("\\", "/");
   const runtimeModule = useUmbrella ? "lunorash/runtime" : "@lunora/runtime";
   const containersReexport = hasContainers ? `
-export * from "${generatedImportBase}/containers";
+export * from "${base}/containers";
 ` : "";
   return `// Generated by @lunora/vite — class-A worker composition (PLAN4 M2).
 // Do not edit: emitted from the detected framework (${framework}). Point your
 // wrangler \`main\` here (or re-export it) instead of hand-wiring createWorker.
 import { composeWorker } from "${runtimeModule}";
 ${wiring.imports}
-import { LUNORA_FUNCTIONS } from "${generatedImportBase}/functions";
-import { openApiSpec } from "${generatedImportBase}/openapi";
-import { createShardDO } from "${generatedImportBase}/shard";
+import { LUNORA_FUNCTIONS } from "${base}/functions";
+import { openApiSpec } from "${base}/openapi";
+import { createShardDO } from "${base}/shard";
 
 export const ShardDO = createShardDO();
 ${containersReexport}
@@ -69,7 +74,7 @@ let worker;
 
 export default {
     async fetch(request, env, context) {
-        worker ??= composeWorker({
+        worker ??= composeWorker({${allowUnauthenticatedShardAccess ? "\n            allowUnauthenticatedShardAccess: true," : ""}
             functions: LUNORA_FUNCTIONS,
             httpRouter: ${wiring.handler},
             openApiSpec,
@@ -88,8 +93,17 @@ const frameworkComposePlugin = (options, context) => {
   return {
     load(id) {
       if (id === RESOLVED_LUNORA_WORKER_ID && isWorkerVirtualActive(context) && context.framework !== void 0) {
+        if (this.environment.name === "client") {
+          return CLIENT_WORKER_STUB;
+        }
         const hasContainers = existsSync(join(generatedImportBase, "containers.ts"));
-        return buildWorkerEntrySource(context.framework.framework, generatedImportBase, hasContainers, useUmbrella);
+        return buildWorkerEntrySource(
+          context.framework.framework,
+          generatedImportBase,
+          hasContainers,
+          useUmbrella,
+          options.allowUnauthenticatedShardAccess
+        );
       }
       return void 0;
     },

package/dist/packem_shared/LUNORA_API_UPDATED_EVENT-BrkWk3rr.mjs

@@ -0,0 +1,3 @@
+const LUNORA_API_UPDATED_EVENT = "lunora:api-updated";
+
+export { LUNORA_API_UPDATED_EVENT as default };

package/dist/packem_shared/{STUDIO_PATH-5ppCdBHa.mjs → STUDIO_PATH-U0eIaW1t.mjs}

@@ -1,5 +1,5 @@
 import { detectAgentRules } from '@lunora/config';
-import { handleSeedRequest, handleSchemaEditRequest, handlePolicyScaffoldRequest, SEED_ENDPOINT, SCHEMA_EDIT_ENDPOINT, POLICY_SCAFFOLD_ENDPOINT, serveJsonHandler, renderStudioHtml, resolveAdminToken, studioAssetsStamp, loadStudioAssets } from '@lunora/config/studio-host';
+import { handleSeedRequest, handleSchemaEditRequest, handlePolicyScaffoldRequest, SEED_ENDPOINT, SCHEMA_EDIT_ENDPOINT, POLICY_SCAFFOLD_ENDPOINT, serveJsonHandler, isStandaloneModulePath, renderStudioHtml, resolveAdminToken, studioAssetsStamp, loadStudioAssets, readStandaloneAsset, assetContentType } from '@lunora/config/studio-host';
 
 const STUDIO_PATH = "/__lunora";
 const STUDIO_SCRIPT_PATH = `${STUDIO_PATH}/studio.js`;
@@ -47,6 +47,10 @@ const transportRejectionReason = (request) => {
   if (host !== void 0 && !LOOPBACK_HOSTS.has(host)) {
     return "Lunora studio rejects a non-localhost Host header in dev.";
   }
+  const FORWARDING_HEADERS = ["x-forwarded-for", "x-forwarded-host", "x-forwarded-proto", "forwarded"];
+  if (FORWARDING_HEADERS.some((name) => request.headers?.[name] !== void 0)) {
+    return "Lunora studio refuses a proxied (X-Forwarded-*) request in dev.";
+  }
   return void 0;
 };
 const originRejectionReason = (headers) => {
@@ -113,7 +117,7 @@ const createStudioHandler = (server, isNonLoopbackBind) => {
   let assetsStamp;
   let html;
   const projectRoot = server.config.root ?? process.cwd();
-  const serveStaticAsset = (pathname, response) => {
+  const serveStaticAsset = (pathname, request, response) => {
     const stamp = studioAssetsStamp();
     if (assets === void 0 || stamp !== assetsStamp) {
       assets = loadStudioAssets(server.config.logger);
@@ -125,8 +129,30 @@ const createStudioHandler = (server, isNonLoopbackBind) => {
       response.end("Lunora studio assets not found — install and build @lunora/studio.");
       return;
     }
-    const isScript = pathname === STUDIO_SCRIPT_PATH;
-    sendOk(response, isScript ? assets.script : assets.styles, isScript ? "text/javascript; charset=utf-8" : "text/css; charset=utf-8");
+    const isStyle = pathname === STUDIO_STYLE_PATH;
+    const fileName = pathname.slice(pathname.lastIndexOf("/") + 1);
+    const etag = stamp === void 0 ? void 0 : `W/"${fileName}-${String(stamp)}"`;
+    response.setHeader("Cache-Control", "no-cache");
+    if (etag !== void 0) {
+      response.setHeader("ETag", etag);
+      if (headerValue(request.headers?.["if-none-match"]) === etag.toLowerCase()) {
+        response.statusCode = 304;
+        response.end();
+        return;
+      }
+    }
+    if (isStyle) {
+      sendOk(response, assets.styles, "text/css; charset=utf-8");
+      return;
+    }
+    const bytes = readStandaloneAsset(fileName);
+    if (bytes === void 0) {
+      response.statusCode = 404;
+      response.setHeader("Content-Type", "text/plain");
+      response.end("Not found");
+      return;
+    }
+    sendOk(response, bytes, assetContentType(fileName));
   };
   return (request, response, next) => {
     const pathname = pathnameOf(request.url ?? "");
@@ -154,8 +180,8 @@ const createStudioHandler = (server, isNonLoopbackBind) => {
       serveJsonHandler(request, response, jsonHandler, projectRoot);
       return;
     }
-    if (pathname === STUDIO_SCRIPT_PATH || pathname === STUDIO_STYLE_PATH) {
-      serveStaticAsset(pathname, response);
+    if (pathname === STUDIO_STYLE_PATH || isStandaloneModulePath(pathname)) {
+      serveStaticAsset(pathname, request, response);
       return;
     }
     html ??= renderStudioHtml({

package/dist/packem_shared/codegenPlugin-B8c38rky.mjs

@@ -0,0 +1,347 @@
+import { existsSync } from 'node:fs';
+import { join, resolve, sep, basename } from 'node:path';
+import { createCodegenProject, refreshCodegenProject, runCodegen, CodegenDiagnosticError } from '@lunora/codegen';
+import { findWranglerFile, LUNORA_CONFIG_FILE, readWranglerJsonc, WRANGLER_FILES, collectWranglerSecretVariables, inferLunoraBindings, reconcileWranglerBindings, reconcileWranglerCrons, reconcileWranglerCompatibilityDate } from '@lunora/config';
+import { isRunnableDevEnvironment } from 'vite';
+import LUNORA_API_UPDATED_EVENT from './LUNORA_API_UPDATED_EVENT-BrkWk3rr.mjs';
+import { L as LUNORA_TAG, a as advisoryLine } from './log-BjO9EWah.mjs';
+import { r as runPendingClose, a as registerDevServerClose } from './server-close-DKDp7YTU.mjs';
+
+const fingerprintJsonc = (filePath, normalize) => {
+  try {
+    const { parsed, text } = readWranglerJsonc(filePath);
+    if (parsed === void 0) {
+      return `raw:${text}`;
+    }
+    return JSON.stringify(normalize ? normalize(parsed) : parsed);
+  } catch {
+    return "unreadable";
+  }
+};
+const stripCodegenOwnedCrons = (parsed) => {
+  const clone = { ...parsed };
+  const { triggers } = clone;
+  if (triggers !== null && typeof triggers === "object") {
+    const restTriggers = { ...triggers };
+    delete restTriggers.crons;
+    if (Object.keys(restTriggers).length > 0) {
+      clone.triggers = restTriggers;
+    } else {
+      delete clone.triggers;
+    }
+  }
+  return clone;
+};
+const computeConfigFingerprint = (projectRoot) => {
+  const wranglerFile = findWranglerFile(projectRoot);
+  const wranglerPart = wranglerFile === void 0 ? "absent" : fingerprintJsonc(wranglerFile, stripCodegenOwnedCrons);
+  const lunoraConfigPath = join(projectRoot, LUNORA_CONFIG_FILE);
+  const lunoraPart = existsSync(lunoraConfigPath) ? fingerprintJsonc(lunoraConfigPath) : "absent";
+  return `${wranglerPart}\0${lunoraPart}`;
+};
+
+const DEBOUNCE_MS = 100;
+const TSCONFIG_VARIANT_RE = /[/\\]tsconfig\..+\.json$/u;
+const formatExportGapOverlay = (gaps) => {
+  const lines = gaps.map((gap) => `  • ${gap.kind} "${gap.exportName}" — class ${gap.className} is not exported by your worker entry.`);
+  const hints = [...new Set(gaps.map((gap) => gap.module))].map((module) => `  export * from "./lunora/_generated/${module}";`);
+  return [
+    `[lunora] ${String(gaps.length)} declared ${gaps.length === 1 ? "binding is" : "bindings are"} not exported by your worker entry — \`wrangler deploy\` will fail.`,
+    ...lines,
+    "",
+    "Add to your worker entry:",
+    ...hints
+  ].join("\n");
+};
+const reconcileBindingsSafely = async (options, logger, onExportGaps) => {
+  try {
+    const inferred = await inferLunoraBindings({ projectRoot: options.projectRoot, schemaDir: options.schemaDir });
+    const reconciled = reconcileWranglerBindings(options.projectRoot, inferred);
+    if (reconciled.changed) {
+      logger.info?.(`${LUNORA_TAG} inferred bindings → ${reconciled.added.join(", ")} (written to ${reconciled.wranglerPath ?? "wrangler.jsonc"})`);
+    }
+    for (const warning of reconciled.warnings) {
+      logger.warn(`${LUNORA_TAG} ${warning}`);
+    }
+    if (reconciled.exportGaps.length > 0) {
+      onExportGaps?.(reconciled.exportGaps);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`${LUNORA_TAG} binding inference skipped: ${message}`);
+  }
+};
+const reconcileWranglerExtras = (projectRoot, cronTriggers, logger) => {
+  try {
+    const reconciled = reconcileWranglerCrons(projectRoot, cronTriggers);
+    if (reconciled.changed) {
+      logger.info?.(`${LUNORA_TAG} synced ${cronTriggers.length.toFixed(0)} cron trigger(s) into ${reconciled.wranglerPath ?? "wrangler.jsonc"}`);
+    }
+  } catch (cronError) {
+    const message = cronError instanceof Error ? cronError.message : String(cronError);
+    logger.warn(`${LUNORA_TAG} cron trigger sync skipped: ${message}`);
+  }
+  try {
+    const reconciled = reconcileWranglerCompatibilityDate(projectRoot);
+    if (reconciled.changed) {
+      logger.info?.(
+        `${LUNORA_TAG} bumped compatibility_date to ${reconciled.date ?? "unknown"} (Workers Cache enabled) → ${reconciled.wranglerPath ?? "wrangler.jsonc"}`
+      );
+    }
+  } catch (dateError) {
+    const message = dateError instanceof Error ? dateError.message : String(dateError);
+    logger.warn(`${LUNORA_TAG} compatibility date sync skipped: ${message}`);
+  }
+};
+const runCodegenSafely = (options, logger, overlay, project) => {
+  const schemaPath = join(options.projectRoot, options.schemaDir, "schema.ts");
+  if (!existsSync(schemaPath)) {
+    logger.warn(`${LUNORA_TAG} schema.ts not found at ${schemaPath} — codegen skipped`);
+    return void 0;
+  }
+  try {
+    const result = runCodegen({
+      apiSpec: options.apiSpec,
+      lunoraDirectory: options.schemaDir,
+      project,
+      projectRoot: options.projectRoot,
+      wranglerVariables: collectWranglerSecretVariables(options.projectRoot)
+    });
+    reconcileWranglerExtras(options.projectRoot, result.cronTriggers, logger);
+    for (const advisory of result.advisories) {
+      const line = advisoryLine(advisory.level, advisory.name, advisory.detail, advisory.remediation);
+      if (advisory.level === "ERROR") {
+        logger.error(line);
+      } else {
+        logger.warn(line);
+      }
+    }
+    return resolve(result.outputDirectory);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`${LUNORA_TAG} codegen failed: ${message}`);
+    overlay?.onError(error, message);
+    return void 0;
+  }
+};
+const notifyEnvironmentsAfterCodegen = (server, changedFile, clearErrorOverlay) => {
+  let clientEnvironment;
+  for (const [name, environment] of Object.entries(server.environments)) {
+    if (name === "client") {
+      clientEnvironment = environment;
+      continue;
+    }
+    if (isRunnableDevEnvironment(environment)) {
+      continue;
+    }
+    environment.hot.send({ path: "*", triggeredBy: changedFile, type: "full-reload" });
+  }
+  if (clientEnvironment === void 0) {
+    server.hot.send({ type: "full-reload" });
+    return;
+  }
+  if (clearErrorOverlay) {
+    clientEnvironment.hot.send({ type: "full-reload" });
+    return;
+  }
+  clientEnvironment.hot.send({ event: LUNORA_API_UPDATED_EVENT, type: "custom" });
+};
+const codegenPlugin = (options) => {
+  const absoluteSchemaDirectory = resolve(options.projectRoot, options.schemaDir);
+  let absoluteGeneratedDirectory = resolve(options.projectRoot, options.generatedDir);
+  let devServer;
+  const pendingMiddlewareTeardowns = /* @__PURE__ */ new Map();
+  let configFingerprint;
+  let configBaselineSettled = false;
+  let restartInFlight = false;
+  return {
+    async buildStart() {
+      const logger = {
+        error: (message) => {
+          console.error(message);
+        },
+        info: (message) => {
+          console.info(message);
+        },
+        warn: (message) => {
+          console.warn(message);
+        }
+      };
+      const outputDirectory = runCodegenSafely(options, logger);
+      if (outputDirectory !== void 0) {
+        absoluteGeneratedDirectory = outputDirectory;
+      }
+      await reconcileBindingsSafely(options, logger, (gaps) => {
+        devServer?.hot.send({
+          err: { loc: void 0, message: formatExportGapOverlay(gaps), stack: "" },
+          type: "error"
+        });
+      });
+      if (devServer !== void 0) {
+        configFingerprint = computeConfigFingerprint(options.projectRoot);
+        configBaselineSettled = true;
+      }
+    },
+    configureServer(server) {
+      devServer = server;
+      server.watcher.add(absoluteSchemaDirectory);
+      configFingerprint = computeConfigFingerprint(options.projectRoot);
+      configBaselineSettled = false;
+      const serverLogger = {
+        error: (message) => {
+          server.config.logger.error(message);
+        },
+        info: (message) => {
+          server.config.logger.info(message);
+        },
+        warn: (message) => {
+          server.config.logger.warn(message);
+        }
+      };
+      let hadErrorOverlay = false;
+      const overlay = {
+        onError(error, message) {
+          hadErrorOverlay = true;
+          const loc = error instanceof CodegenDiagnosticError ? { column: error.column, file: error.file, line: error.line } : void 0;
+          const overlayMessage = loc === void 0 ? `[lunora] codegen failed: ${message}
+(see terminal for full stack trace and file location)` : `[lunora] codegen failed: ${message}`;
+          devServer?.hot.send({
+            err: {
+              loc,
+              message: overlayMessage,
+              stack: error instanceof Error ? error.stack ?? "" : ""
+            },
+            type: "error"
+          });
+        }
+      };
+      const isInside = (path, directory) => path === directory || path.startsWith(directory + sep);
+      let closed = false;
+      let debounceTimer;
+      let cachedProject;
+      const invalidateGenerated = () => {
+        for (const environment of Object.values(server.environments)) {
+          const graph = environment.moduleGraph;
+          for (const moduleEntry of graph.idToModuleMap.values()) {
+            if (moduleEntry.id && isInside(moduleEntry.id, absoluteGeneratedDirectory)) {
+              graph.invalidateModule(moduleEntry);
+            }
+          }
+        }
+      };
+      const onChange = (file) => {
+        const normalized = resolve(file);
+        if (!isInside(normalized, absoluteSchemaDirectory)) {
+          return;
+        }
+        if (isInside(normalized, absoluteGeneratedDirectory)) {
+          return;
+        }
+        if (normalized.endsWith(`${sep}tsconfig.json`) || TSCONFIG_VARIANT_RE.test(normalized)) {
+          cachedProject = void 0;
+          return;
+        }
+        if (!normalized.endsWith(".ts")) {
+          return;
+        }
+        if (normalized.includes(`${sep}__tests__${sep}`) || normalized.endsWith(".test.ts") || normalized.endsWith(".spec.ts")) {
+          return;
+        }
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(() => {
+          debounceTimer = void 0;
+          if (closed) {
+            return;
+          }
+          if (cachedProject === void 0) {
+            cachedProject = createCodegenProject(absoluteSchemaDirectory);
+          } else {
+            refreshCodegenProject(cachedProject, absoluteSchemaDirectory);
+          }
+          const outputDirectory = runCodegenSafely(options, serverLogger, overlay, cachedProject);
+          if (outputDirectory === void 0) {
+            cachedProject = void 0;
+            return;
+          }
+          absoluteGeneratedDirectory = outputDirectory;
+          invalidateGenerated();
+          notifyEnvironmentsAfterCodegen(server, normalized, hadErrorOverlay);
+          hadErrorOverlay = false;
+        }, DEBOUNCE_MS);
+      };
+      server.watcher.on("add", onChange);
+      server.watcher.on("change", onChange);
+      server.watcher.on("unlink", onChange);
+      const configWatchPaths = /* @__PURE__ */ new Set([
+        ...WRANGLER_FILES.map((name) => resolve(options.projectRoot, name)),
+        resolve(options.projectRoot, LUNORA_CONFIG_FILE)
+      ]);
+      for (const configPath of configWatchPaths) {
+        server.watcher.add(configPath);
+      }
+      const onConfigChange = (file) => {
+        if (!configWatchPaths.has(resolve(file))) {
+          return;
+        }
+        if (restartInFlight) {
+          return;
+        }
+        const nextFingerprint = computeConfigFingerprint(options.projectRoot);
+        if (!configBaselineSettled) {
+          configFingerprint = nextFingerprint;
+          return;
+        }
+        if (configFingerprint === void 0) {
+          configFingerprint = nextFingerprint;
+          return;
+        }
+        if (nextFingerprint === configFingerprint) {
+          return;
+        }
+        configFingerprint = nextFingerprint;
+        restartInFlight = true;
+        server.config.logger.info(`${LUNORA_TAG} ${basename(resolve(file))} changed — restarting dev server`);
+        Promise.resolve(server.restart()).finally(() => {
+          restartInFlight = false;
+        }).catch((error) => {
+          const message = error instanceof Error ? error.message : String(error);
+          server.config.logger.error(
+            `${LUNORA_TAG} dev server restart failed: ${message} — keeping the running server; re-save your config to retry.`
+          );
+          server.hot.send({ err: { loc: void 0, message: `[lunora] dev server restart failed: ${message}`, stack: "" }, type: "error" });
+        });
+      };
+      server.watcher.on("add", onConfigChange);
+      server.watcher.on("change", onConfigChange);
+      server.watcher.on("unlink", onConfigChange);
+      const teardown = () => {
+        if (closed) {
+          return;
+        }
+        closed = true;
+        cachedProject = void 0;
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+          debounceTimer = void 0;
+        }
+        server.watcher.off("add", onChange);
+        server.watcher.off("change", onChange);
+        server.watcher.off("unlink", onChange);
+        server.watcher.off("add", onConfigChange);
+        server.watcher.off("change", onConfigChange);
+        server.watcher.off("unlink", onConfigChange);
+      };
+      return () => {
+        registerDevServerClose(server, pendingMiddlewareTeardowns, teardown);
+      };
+    },
+    buildEnd() {
+      runPendingClose(pendingMiddlewareTeardowns, this.environment);
+    },
+    name: "lunora:codegen"
+  };
+};
+
+export { codegenPlugin as default };

package/dist/packem_shared/containerLogsPlugin-DMssU3wb.mjs

@@ -0,0 +1,50 @@
+import { discoverContainerInfo, streamContainerLogs } from '@lunora/config';
+import { l as lunoraLine } from './log-BjO9EWah.mjs';
+
+const containerLogsPlugin = (options) => {
+  let handle;
+  const closeHandle = () => {
+    handle?.close();
+    handle = void 0;
+  };
+  return {
+    apply: "serve",
+    // Fires on `server.close()` for both the normal and middleware-mode dev
+    // servers, so the Docker poll loop is torn down even when there is no
+    // `httpServer` to listen on (middleware mode).
+    buildEnd() {
+      closeHandle();
+    },
+    configureServer(server) {
+      if (handle || process.env.LUNORA_CONTAINER_LOGS === "0") {
+        return;
+      }
+      const discovery = discoverContainerInfo(options.projectRoot, options.schemaDir);
+      const containers = discovery.containers.map((container) => {
+        return { className: container.className, exportName: container.exportName };
+      });
+      if (containers.length === 0) {
+        return;
+      }
+      const { logger } = server.config;
+      handle = streamContainerLogs({
+        containers,
+        onLine: (line) => {
+          const text = lunoraLine(`container:${line.name} ${line.text}`);
+          if (line.level === "error") {
+            logger.warn(text);
+          } else {
+            logger.info(text);
+          }
+        },
+        onUnavailable: (message) => {
+          logger.warn(lunoraLine(`container: Docker engine unreachable — container logs unavailable (${message})`));
+        }
+      });
+      server.httpServer?.once("close", closeHandle);
+    },
+    name: "lunora:container-logs"
+  };
+};
+
+export { containerLogsPlugin as default };