@lunora/vite 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/buildStudioUrl-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/codegenPlugin-BAyt6iWS.mjs

@@ -0,0 +1,210 @@
+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';
+
+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] inferred bindings → ${reconciled.added.join(", ")} (written to ${reconciled.wranglerPath ?? "wrangler.jsonc"})`);
+    }
+    for (const warning of reconciled.warnings) {
+      logger.warn(`[lunora] ${warning}`);
+    }
+    if (reconciled.exportGaps.length > 0) {
+      onExportGaps?.(reconciled.exportGaps);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`[lunora] 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] 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] 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] cron trigger sync skipped: ${message}`);
+    }
+    for (const advisory of result.advisories) {
+      logger.warn(`[lunora] schema advisory [${advisory.level}] ${advisory.name}: ${advisory.detail} — ${advisory.remediation}`);
+    }
+    return resolve(result.outputDirectory);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`[lunora] 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/createCommandProbe-Coo6bgVz.mjs

@@ -0,0 +1,36 @@
+const DEV_WORKER_ENV_VAR = "WORKER_ENV";
+const DEV_WORKER_ENV_VALUE = "development";
+const withDevWorkerEnv = (options, isServe) => {
+  const userConfig = options.config;
+  return {
+    ...options,
+    config: (workerConfig) => {
+      if (typeof userConfig === "function") {
+        const partial = userConfig(workerConfig);
+        if (partial) {
+          Object.assign(workerConfig, partial);
+        }
+      } else if (userConfig) {
+        Object.assign(workerConfig, userConfig);
+      }
+      if (isServe()) {
+        workerConfig.vars = { [DEV_WORKER_ENV_VAR]: DEV_WORKER_ENV_VALUE, ...workerConfig.vars };
+      }
+    }
+  };
+};
+const createCommandProbe = () => {
+  let command;
+  return {
+    isServe: () => command === "serve",
+    plugin: {
+      config(_userConfig, env) {
+        command = env.command;
+      },
+      enforce: "pre",
+      name: "lunora:command-probe"
+    }
+  };
+};
+
+export { DEV_WORKER_ENV_VALUE, DEV_WORKER_ENV_VAR, createCommandProbe, withDevWorkerEnv };

package/dist/packem_shared/devVariablesPlugin-BRWbWHhq.mjs

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

package/dist/packem_shared/frameworkComposePlugin-Cja0SF6x.mjs

@@ -0,0 +1,96 @@
+import { existsSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+
+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 TRAILING_SLASH = /\/$/;
+const CLASS_A_WIRING = {
+  "react-router": {
+    // `@react-router/dev` provides `virtual:react-router/server-build`; the
+    // runtime helper turns it into a `(request) => Promise<Response>`, which
+    // is exactly the `httpRouter.fetch` contract. Needs a named import.
+    handler: '{ fetch: (request) => createRequestHandler(() => import("virtual:react-router/server-build"), import.meta.env.MODE)(request) }',
+    imports: 'import { createRequestHandler } from "react-router";'
+  },
+  "solid-start": {
+    // SolidStart's `cloudflare-module` preset default-exports a fetch
+    // handler — structurally an `HttpRouterLike` already.
+    handler: "ssrModule.default",
+    imports: 'import * as ssrModule from "@solidjs/start/server-handler";'
+  },
+  "tanstack-start": {
+    // TanStack Start's server entry default-exports a `{ fetch }` handler.
+    handler: "ssrModule.default",
+    imports: 'import * as ssrModule from "@tanstack/react-start/server-entry";'
+  },
+  "tanstack-start-solid": {
+    // TanStack Start (Solid)'s server entry default-exports a `{ fetch }`
+    // handler — same shape as the React variant, different package.
+    handler: "ssrModule.default",
+    imports: 'import * as ssrModule from "@tanstack/solid-start/server-entry";'
+  }
+};
+const isAutoComposable = (context) => {
+  const detected = context.framework;
+  return detected?.class === "A" && CLASS_A_WIRING[detected.framework] !== void 0;
+};
+const isWorkerVirtualActive = (context) => isAutoComposable(context);
+const buildWorkerEntrySource = (framework, generatedImportBase, hasContainers = false) => {
+  const wiring = CLASS_A_WIRING[framework];
+  if (wiring === void 0) {
+    throw new Error(`[lunora] no class-A worker wiring for framework "${framework}"`);
+  }
+  const containersReexport = hasContainers ? `
+export * from "${generatedImportBase}/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 "@lunora/runtime";
+${wiring.imports}
+import { LUNORA_FUNCTIONS } from "${generatedImportBase}/functions";
+import { openApiSpec } from "${generatedImportBase}/openapi";
+import { createShardDO } from "${generatedImportBase}/shard";
+
+export const ShardDO = createShardDO();
+${containersReexport}
+
+let worker;
+
+export default {
+    async fetch(request, env, context) {
+        worker ??= composeWorker({
+            functions: LUNORA_FUNCTIONS,
+            httpRouter: ${wiring.handler},
+            openApiSpec,
+            routes: {},
+            shardDO: env.SHARD,
+        });
+
+        return worker.fetch(request, env, context);
+    },
+};
+`;
+};
+const frameworkComposePlugin = (options, context) => {
+  const generatedImportBase = resolve(options.projectRoot, options.generatedDir.replace(TRAILING_SLASH, ""));
+  return {
+    load(id) {
+      if (id === RESOLVED_LUNORA_WORKER_ID && isWorkerVirtualActive(context) && context.framework !== void 0) {
+        const hasContainers = existsSync(join(generatedImportBase, "containers.ts"));
+        return buildWorkerEntrySource(context.framework.framework, generatedImportBase, hasContainers);
+      }
+      return void 0;
+    },
+    name: "lunora:framework-compose",
+    resolveId(id) {
+      if (id === LUNORA_WORKER_VIRTUAL_ID && isWorkerVirtualActive(context)) {
+        return RESOLVED_LUNORA_WORKER_ID;
+      }
+      return void 0;
+    }
+  };
+};
+
+export { CLASS_A_WIRING, LUNORA_WORKER_VIRTUAL_ID, RESOLVED_LUNORA_WORKER_ID, buildWorkerEntrySource, frameworkComposePlugin, isAutoComposable };

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