@lunora/vite 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/STUDIO_PATH-5ppCdBHa.mjs

@@ -0,0 +1,210 @@
+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';
+
+const STUDIO_PATH = "/__lunora";
+const STUDIO_SCRIPT_PATH = `${STUDIO_PATH}/studio.js`;
+const STUDIO_STYLE_PATH = `${STUDIO_PATH}/styles.css`;
+const LEADING_SLASH = /^\//;
+const TRAILING_SLASH = /\/$/;
+const JSON_ENDPOINT_HANDLERS = {
+  [POLICY_SCAFFOLD_ENDPOINT]: handlePolicyScaffoldRequest,
+  [SCHEMA_EDIT_ENDPOINT]: handleSchemaEditRequest,
+  [SEED_ENDPOINT]: handleSeedRequest
+};
+const STATE_CHANGING_ENDPOINTS = new Set(Object.keys(JSON_ENDPOINT_HANDLERS));
+const headerValue = (raw) => {
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  return typeof value === "string" ? value.trim().toLowerCase() : void 0;
+};
+const isLoopbackAddress = (remoteAddress) => {
+  if (remoteAddress === void 0 || remoteAddress === "") {
+    return true;
+  }
+  const address = remoteAddress.toLowerCase();
+  const v4 = address.startsWith("::ffff:") ? address.slice(7) : address;
+  if (v4 === "::1") {
+    return true;
+  }
+  return v4.startsWith("127.");
+};
+const hostnameOf = (host) => {
+  if (host === void 0) {
+    return void 0;
+  }
+  if (host.startsWith("[")) {
+    const close = host.indexOf("]");
+    return close === -1 ? host.slice(1) : host.slice(1, close);
+  }
+  const colon = host.indexOf(":");
+  return colon === -1 ? host : host.slice(0, colon);
+};
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["0.0.0.0", "127.0.0.1", "::1", "localhost"]);
+const transportRejectionReason = (request) => {
+  if (!isLoopbackAddress(request.socket?.remoteAddress ?? void 0)) {
+    return "Lunora studio is only available on loopback connections in dev.";
+  }
+  const host = hostnameOf(headerValue(request.headers?.host));
+  if (host !== void 0 && !LOOPBACK_HOSTS.has(host)) {
+    return "Lunora studio rejects a non-localhost Host header in dev.";
+  }
+  return void 0;
+};
+const originRejectionReason = (headers) => {
+  const secFetchSite = headerValue(headers["sec-fetch-site"]);
+  if (secFetchSite !== void 0) {
+    return secFetchSite === "same-origin" || secFetchSite === "same-site" || secFetchSite === "none" ? void 0 : "cross-origin request rejected";
+  }
+  const origin = headerValue(headers.origin);
+  if (origin === void 0 || origin === "null") {
+    return void 0;
+  }
+  let originHost;
+  try {
+    originHost = new URL(origin).host.toLowerCase();
+  } catch {
+    return "invalid origin header";
+  }
+  const host = headerValue(headers.host);
+  return host === void 0 || originHost !== host ? "cross-origin request rejected" : void 0;
+};
+const csrfRejectionReason = (request) => {
+  const headers = request.headers ?? {};
+  const originReason = originRejectionReason(headers);
+  if (originReason !== void 0) {
+    return originReason;
+  }
+  const method = (request.method ?? "GET").toUpperCase();
+  if (method !== "GET" && method !== "HEAD") {
+    const contentType = headerValue(headers["content-type"]);
+    if (!contentType?.startsWith("application/json")) {
+      return "content-type must be application/json";
+    }
+  }
+  return void 0;
+};
+const sendOk = (response, body, contentType) => {
+  response.statusCode = 200;
+  response.setHeader("Content-Type", contentType);
+  response.end(body);
+};
+const buildStudioUrl = (input) => {
+  const path = STUDIO_PATH.replace(LEADING_SLASH, "");
+  if (input.resolvedLocal !== void 0 && input.resolvedLocal !== "") {
+    const origin = input.resolvedLocal.endsWith("/") ? input.resolvedLocal.slice(0, -1) : input.resolvedLocal;
+    return `${origin}/${path}`;
+  }
+  const base = input.base === void 0 || input.base === "/" ? "" : input.base.replace(TRAILING_SLASH, "");
+  if (input.address === void 0 || typeof input.address === "string") {
+    return `http://localhost:5173${base}/${path}`;
+  }
+  const host = input.address.address === "::" || input.address.address === "0.0.0.0" ? "localhost" : input.address.address;
+  const bracketed = host.includes(":") ? `[${host}]` : host;
+  return `http://${bracketed}:${String(input.address.port)}${base}/${path}`;
+};
+const pathnameOf = (url) => {
+  try {
+    return new URL(url, "http://localhost").pathname.replace(TRAILING_SLASH, "");
+  } catch {
+    return url;
+  }
+};
+const createStudioHandler = (server, isNonLoopbackBind) => {
+  let assets;
+  let assetsStamp;
+  let html;
+  const projectRoot = server.config.root ?? process.cwd();
+  const serveStaticAsset = (pathname, response) => {
+    const stamp = studioAssetsStamp();
+    if (assets === void 0 || stamp !== assetsStamp) {
+      assets = loadStudioAssets(server.config.logger);
+      assetsStamp = stamp;
+    }
+    if (assets === void 0) {
+      response.statusCode = 501;
+      response.setHeader("Content-Type", "text/plain");
+      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");
+  };
+  return (request, response, next) => {
+    const pathname = pathnameOf(request.url ?? "");
+    if (pathname !== STUDIO_PATH && !pathname.startsWith(`${STUDIO_PATH}/`)) {
+      next();
+      return;
+    }
+    if (isNonLoopbackBind || transportRejectionReason(request) !== void 0) {
+      response.statusCode = 403;
+      response.setHeader("Content-Type", "text/plain");
+      response.end("Lunora studio is only available on loopback hosts in dev.");
+      return;
+    }
+    if (STATE_CHANGING_ENDPOINTS.has(pathname)) {
+      const csrf = csrfRejectionReason(request);
+      if (csrf !== void 0) {
+        response.statusCode = 403;
+        response.setHeader("Content-Type", "application/json; charset=utf-8");
+        response.end(JSON.stringify({ error: csrf, ok: false }));
+        return;
+      }
+    }
+    const jsonHandler = JSON_ENDPOINT_HANDLERS[pathname];
+    if (jsonHandler !== void 0) {
+      serveJsonHandler(request, response, jsonHandler, projectRoot);
+      return;
+    }
+    if (pathname === STUDIO_SCRIPT_PATH || pathname === STUDIO_STYLE_PATH) {
+      serveStaticAsset(pathname, response);
+      return;
+    }
+    html ??= renderStudioHtml({
+      adminToken: resolveAdminToken(projectRoot),
+      basePath: STUDIO_PATH,
+      // Loopback-only dev route (it 403s on a non-loopback bind), so the
+      // developer owns the data — let them edit rows, run-as a user, and edit
+      // the schema by default.
+      dataEditable: true,
+      rulesInstalled: detectAgentRules(projectRoot).installed,
+      runAsIdentity: true,
+      schemaEditable: true,
+      scriptSrc: STUDIO_SCRIPT_PATH,
+      styleHref: STUDIO_STYLE_PATH
+    });
+    sendOk(response, html, "text/html; charset=utf-8");
+  };
+};
+const studioPlugin = () => {
+  return {
+    apply: "serve",
+    configureServer(server) {
+      const configuredHost = server.config.server?.host;
+      const isNonLoopbackBind = configuredHost !== void 0 && configuredHost !== false && configuredHost !== "localhost" && configuredHost !== "127.0.0.1" && configuredHost !== "::1";
+      server.middlewares.use(createStudioHandler(server, isNonLoopbackBind));
+      return () => {
+        const announce = () => {
+          const url = buildStudioUrl({
+            address: server.httpServer?.address() ?? void 0,
+            base: server.config.base,
+            resolvedLocal: server.resolvedUrls?.local[0]
+          });
+          server.config.logger.info(`  \x1B[32m➜\x1B[39m  \x1B[1mLunora\x1B[22m:  \x1B[36m${url}\x1B[39m`);
+        };
+        if (typeof server.printUrls === "function") {
+          const printUrls = server.printUrls.bind(server);
+          server.printUrls = () => {
+            printUrls();
+            announce();
+          };
+        } else if (server.httpServer?.listening === true) {
+          announce();
+        } else {
+          server.httpServer?.once("listening", announce);
+        }
+      };
+    },
+    name: "lunora:studio"
+  };
+};
+
+export { STUDIO_PATH, STUDIO_SCRIPT_PATH, STUDIO_STYLE_PATH, buildStudioUrl, studioPlugin };

package/dist/packem_shared/WORKER_STARTUP_HINT-DhsXUW8k.mjs

@@ -0,0 +1,81 @@
+const WORKER_STARTUP_HINT = [
+  "",
+  "  ┌─ Lunora ──────────────────────────────────────────────────────────────",
+  "  │ Your Worker entry threw while loading, so the dev server couldn't read",
+  "  │ its exports. The TypeError above comes from inside the Cloudflare",
+  "  │ runtime and hides the file that actually failed. It is almost always:",
+  "  │",
+  "  │   • A circular import in lunora/. A query/mutation/action module ran at",
+  "  │     the top level before `v`/`query`/`mutation` finished initializing,",
+  "  │     so they were `undefined` (hence `reading 'string'`/`'id'`/…).",
+  "  │     → Import `v`/`query`/`mutation` only from `lunora/_generated/server`,",
+  "  │       and don't import one lunora/ function module from another at the",
+  "  │       top level.",
+  "  │",
+  "  │   • Stale or missing generated files.",
+  "  │     → Re-run `lunora codegen`, then restart the dev server.",
+  "  │",
+  "  │ Tip: check the lunora/ files you edited most recently — the throw is at",
+  "  │ their module top level.",
+  "  └───────────────────────────────────────────────────────────────────────"
+].join("\n");
+const RUNNER_WORKER_RE = /runner-worker[/\\]index\.js/u;
+const EXPORT_TYPES_PROBE_RE = /getWorkerEntryExportTypes/u;
+const isWorkerEntryEvalError = (error) => {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const haystack = `${error.stack ?? ""}
+${error.message}`;
+  return RUNNER_WORKER_RE.test(haystack) || EXPORT_TYPES_PROBE_RE.test(haystack);
+};
+const HINTED = /* @__PURE__ */ Symbol.for("lunora.workerStartupHintApplied");
+const augmentWorkerStartupError = (error) => {
+  if (!isWorkerEntryEvalError(error)) {
+    return error;
+  }
+  const flagged = error;
+  if (flagged[HINTED]) {
+    return error;
+  }
+  if (Object.isFrozen(flagged) || Object.isSealed(flagged)) {
+    return error;
+  }
+  flagged[HINTED] = true;
+  flagged.message = `${flagged.message}
+${WORKER_STARTUP_HINT}`;
+  if (typeof flagged.stack === "string") {
+    flagged.stack = `${flagged.stack}
+${WORKER_STARTUP_HINT}`;
+  }
+  return error;
+};
+const wrapHookFunction = (function_) => async (...arguments_) => {
+  try {
+    return await function_(...arguments_);
+  } catch (error) {
+    throw augmentWorkerStartupError(error);
+  }
+};
+const wrapHook = (hook) => {
+  if (typeof hook === "function") {
+    return wrapHookFunction(hook);
+  }
+  if (hook !== null && typeof hook === "object" && "handler" in hook && typeof hook["handler"] === "function") {
+    return { ...hook, handler: wrapHookFunction(hook.handler) };
+  }
+  return hook;
+};
+const WRAPPED_HOOKS = ["configureServer", "buildStart"];
+const withWorkerStartupHint = (plugins) => plugins.map((plugin) => {
+  let next = plugin;
+  for (const hookName of WRAPPED_HOOKS) {
+    const hook = plugin[hookName];
+    if (hook !== void 0) {
+      next = { ...next, [hookName]: wrapHook(hook) };
+    }
+  }
+  return next;
+});
+
+export { WORKER_STARTUP_HINT, augmentWorkerStartupError, isWorkerEntryEvalError, withWorkerStartupHint };

package/dist/packem_shared/codegenPlugin-MuvbqAP8.mjs

@@ -0,0 +1,218 @@
+import { existsSync } from 'node:fs';
+import { resolve, sep, join } from 'node:path';
+import { createCodegenProject, refreshCodegenProject, runCodegen, CodegenDiagnosticError } from '@lunora/codegen';
+import { inferLunoraBindings, reconcileWranglerBindings } from '@lunora/config';
+import { reconcileWranglerCrons } from './reconcileWranglerCrons-PxGwfCp_.mjs';
+import { L as LUNORA_TAG, a as advisoryLine } from './log-BjO9EWah.mjs';
+
+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 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 });
+    try {
+      const reconciled = reconcileWranglerCrons(options.projectRoot, result.cronTriggers);
+      if (reconciled.changed) {
+        logger.info?.(
+          `${LUNORA_TAG} synced ${result.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}`);
+    }
+    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 codegenPlugin = (options) => {
+  const absoluteSchemaDirectory = resolve(options.projectRoot, options.schemaDir);
+  let absoluteGeneratedDirectory = resolve(options.projectRoot, options.generatedDir);
+  let debounceTimer;
+  let devServer;
+  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"
+        });
+      });
+    },
+    configureServer(server) {
+      devServer = server;
+      server.watcher.add(absoluteSchemaDirectory);
+      const serverLogger = {
+        error: (message) => {
+          server.config.logger.error(message);
+        },
+        info: (message) => {
+          server.config.logger.info(message);
+        },
+        warn: (message) => {
+          server.config.logger.warn(message);
+        }
+      };
+      const overlay = {
+        onError(error, message) {
+          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 cachedProject;
+      const invalidateGenerated = () => {
+        const environments = server.environments;
+        const graphs = [];
+        if (environments !== void 0) {
+          for (const environment of Object.values(environments)) {
+            if (environment.moduleGraph !== void 0) {
+              graphs.push(environment.moduleGraph);
+            }
+          }
+        }
+        if (graphs.length === 0) {
+          graphs.push(server.moduleGraph);
+        }
+        for (const graph of graphs) {
+          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();
+          server.hot.send({ type: "full-reload" });
+        }, DEBOUNCE_MS);
+      };
+      server.watcher.on("add", onChange);
+      server.watcher.on("change", onChange);
+      server.watcher.on("unlink", onChange);
+      return () => {
+        server.httpServer?.once("close", () => {
+          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);
+        });
+      };
+    },
+    name: "lunora:codegen"
+  };
+};
+
+export { codegenPlugin as default };

package/dist/packem_shared/devVariablesPlugin-CVjkQay7.mjs

@@ -0,0 +1,21 @@
+import { ensureDevVariables, createConfirm } from '@lunora/config';
+import { l as lunoraLine } from './log-BjO9EWah.mjs';
+
+const devVariablesPlugin = (options) => {
+  return {
+    apply: "serve",
+    async configResolved() {
+      await ensureDevVariables({
+        confirm: createConfirm("[lunora] "),
+        cwd: options.projectRoot,
+        info: (message) => {
+          console.info(lunoraLine(message));
+        }
+      });
+    },
+    enforce: "pre",
+    name: "lunora:dev-vars"
+  };
+};
+
+export { devVariablesPlugin as default };

package/dist/packem_shared/log-BjO9EWah.mjs

@@ -0,0 +1,8 @@
+import { paintBadge, BADGES } from '@lunora/config';
+
+const LUNORA_TAG = paintBadge(BADGES.lunora);
+const lunoraLine = (message) => `${LUNORA_TAG} ${message}`;
+const ADVISORY_BADGE = { ERROR: BADGES.error, INFO: BADGES.info, WARN: BADGES.warn };
+const advisoryLine = (level, name, detail, remediation) => `${paintBadge(ADVISORY_BADGE[level])} ${name}: ${detail} — ${remediation}`;
+
+export { LUNORA_TAG as L, advisoryLine as a, lunoraLine as l };

package/dist/packem_shared/logStreamPlugin-CqvZ17kd.mjs

@@ -0,0 +1,61 @@
+import { LUNORA_EVENT_SOURCE, formatLunoraEvent } from '@lunora/config';
+
+const LUNORA_MARKER = `"source":"${LUNORA_EVENT_SOURCE}"`;
+const ANSI = {
+  error: "\x1B[31m",
+  info: "\x1B[36m",
+  reset: "\x1B[0m",
+  warn: "\x1B[33m"
+};
+const decorate = (text, level, colour) => colour ? `${ANSI[level]}[lunora]${ANSI.reset} ${text}` : `[lunora] ${text}`;
+const chunkToText = (chunk) => {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  return Buffer.isBuffer(chunk) ? chunk.toString("utf8") : void 0;
+};
+const rewriteChunk = (text, colour) => text.split("\n").map((segment) => {
+  const formatted = formatLunoraEvent(segment);
+  return formatted ? decorate(formatted.text, formatted.level, colour) : segment;
+}).join("\n");
+const wrapWrite = (original, colour) => (...args) => {
+  try {
+    const text = chunkToText(args[0]);
+    if (text?.includes(LUNORA_MARKER)) {
+      return original(rewriteChunk(text, colour), ...args.slice(1));
+    }
+  } catch {
+  }
+  return original(...args);
+};
+const patchStream = (stream) => {
+  const original = stream.write.bind(stream);
+  stream.write = wrapWrite(original, stream.isTTY === true);
+  return () => {
+    stream.write = original;
+  };
+};
+const logStreamPlugin = () => {
+  let restore;
+  return {
+    apply: "serve",
+    configureServer(server) {
+      if (restore) {
+        return;
+      }
+      const restoreStdout = patchStream(process.stdout);
+      const restoreStderr = patchStream(process.stderr);
+      restore = () => {
+        restoreStdout();
+        restoreStderr();
+        restore = void 0;
+      };
+      server.httpServer?.once("close", () => {
+        restore?.();
+      });
+    },
+    name: "lunora:log-stream"
+  };
+};
+
+export { logStreamPlugin as default };

package/dist/packem_shared/planViteRemoteBindings-QN5ncUS1.mjs

@@ -0,0 +1,50 @@
+import { resolveRemoteEnabled, readProjectRemotePreference, materializeRemoteWranglerConfig } from '@lunora/config';
+
+const noopCleanup = () => {
+};
+const planViteRemoteBindings = (options) => {
+  const readPreference = options.readPreference ?? readProjectRemotePreference;
+  const enabled = resolveRemoteEnabled({
+    configPreference: readPreference(options.projectRoot),
+    envValue: options.remoteEnv ?? process.env["LUNORA_REMOTE"]
+  });
+  if (!enabled) {
+    return { cleanup: noopCleanup, enabled: false };
+  }
+  const materialize = options.materialize ?? materializeRemoteWranglerConfig;
+  const result = materialize({ enabled: true, projectRoot: options.projectRoot });
+  return {
+    // The materializer always returns an idempotent, never-throwing `cleanup`.
+    cleanup: result.cleanup,
+    configPath: result.configPath,
+    enabled: true,
+    reason: result.reason
+  };
+};
+const withRemoteBindings = (options, isServe, plan) => {
+  if (!plan.enabled || plan.configPath === void 0) {
+    return options;
+  }
+  const existing = options;
+  if (typeof existing.configPath === "string") {
+    return options;
+  }
+  if (!isServe()) {
+    return options;
+  }
+  return { ...options, configPath: plan.configPath };
+};
+const remoteBindingsCleanupPlugin = (cleanup) => {
+  return {
+    buildEnd() {
+      cleanup();
+    },
+    closeBundle() {
+      cleanup();
+    },
+    enforce: "pre",
+    name: "lunora:remote-bindings-cleanup"
+  };
+};
+
+export { planViteRemoteBindings, remoteBindingsCleanupPlugin, withRemoteBindings };

package/dist/packem_shared/reconcileWranglerCrons-PxGwfCp_.mjs

@@ -0,0 +1,29 @@
+import { writeFileSync } from 'node:fs';
+import { findWranglerFile, readWranglerJsonc } from '@lunora/config';
+import { modify, applyEdits } from 'jsonc-parser';
+
+const sameTriggers = (a, b) => a.length === b.length && a.every((value, index) => value === b[index]);
+const reconcileWranglerCrons = (projectRoot, cronTriggers) => {
+  const wranglerPath = findWranglerFile(projectRoot);
+  if (!wranglerPath) {
+    return { changed: false, reason: "wrangler.jsonc not found" };
+  }
+  const { parsed, text } = readWranglerJsonc(wranglerPath);
+  if (parsed === void 0) {
+    return { changed: false, reason: `failed to parse ${wranglerPath} as JSONC`, wranglerPath };
+  }
+  const existing = Array.isArray(parsed.triggers?.crons) ? parsed.triggers.crons.filter((value) => typeof value === "string") : [];
+  if (sameTriggers(existing, cronTriggers)) {
+    return { changed: false, reason: "triggers.crons already in sync", wranglerPath };
+  }
+  const edits = modify(text, ["triggers", "crons"], [...cronTriggers], {
+    formattingOptions: { insertSpaces: true, tabSize: 4 }
+  });
+  if (edits.length === 0) {
+    return { changed: false, reason: "no structural edit produced", wranglerPath };
+  }
+  writeFileSync(wranglerPath, applyEdits(text, edits), "utf8");
+  return { changed: true, wranglerPath };
+};
+
+export { reconcileWranglerCrons };