@limno/core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,74 @@
+import * as magic_string from 'magic-string';
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+/**
+ * Stamp every JSX host element with where it is written and which component renders it,
+ * and every component usage with its call site. React passes data-* props through untouched,
+ * so the attributes cost nothing at runtime and only exist in dev.
+ */
+declare function stampSource(code: string, id: string, relFile: string): {
+    code: string;
+    map: magic_string.SourceMap;
+} | null;
+
+/**
+ * Source stamping for template languages: Vue single-file components and Svelte components.
+ * Every plain HTML element in a template gets `data-limno-src` (file:line:col) and
+ * `data-limno-comp` (the component, i.e. the file). Each framework's own parser is loaded from
+ * the project, so positions match exactly what the framework compiles.
+ */
+declare const TEMPLATE_FILES: RegExp;
+/** Stamp a .vue / .svelte file. Returns null when there's nothing to do. */
+declare function stampTemplate(code: string, id: string, relFile: string, root: string): Promise<{
+    code: string;
+    map: magic_string.SourceMap;
+} | null>;
+
+/**
+ * The framework-neutral half of Limno's dev tooling: the change-set store in the project
+ * (.limno/), the agent presence check, and the /__limno/* endpoints the overlay talks to.
+ * Bundler integrations (Vite, Next.js, webpack/Rspack) mount `handle` in their dev server or
+ * run it on its own port via `startServer`.
+ */
+declare const ROUTE = "/__limno";
+interface LimnoServiceOptions {
+    /** Project root: where .limno/ lives and source paths are relative to. */
+    root: string;
+    /** Directory (relative to root) for change sets. Default ".limno". */
+    dir?: string;
+}
+interface AgentStatus {
+    connected: boolean;
+    client: {
+        name: string;
+        version: string;
+    } | null;
+    lastSeen: number | null;
+    setup: {
+        command: string;
+        args: string[];
+        root: string;
+    };
+}
+declare function overlayFile(): string;
+interface LimnoService {
+    root: string;
+    /** Connect-style middleware: handles /__limno/*, otherwise calls next (or 404s). */
+    handle(req: IncomingMessage, res: ServerResponse, next?: () => void): void;
+    close(): void;
+}
+declare function createLimnoService({ root, dir }: LimnoServiceOptions): LimnoService;
+
+interface LimnoServer {
+    /** Base URL of the server, e.g. http://127.0.0.1:41234 */
+    url: string;
+    close(): void;
+}
+declare function startServer(options: LimnoServiceOptions): Promise<LimnoServer>;
+
+/** Files Limno stamps with source locations by default: JSX in .jsx/.tsx, and in .js/.mjs (common in Create React App, Gatsby and plain-JS Next.js apps). */
+declare const SOURCE_FILES: RegExp;
+/** True for files that should be stamped: JSX/TSX outside node_modules. */
+declare function shouldStamp(file: string, include?: RegExp): boolean;
+
+export { type AgentStatus, type LimnoServer, type LimnoService, type LimnoServiceOptions, ROUTE, SOURCE_FILES, TEMPLATE_FILES, createLimnoService, overlayFile, shouldStamp, stampSource, stampTemplate, startServer };

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import * as magic_string from 'magic-string';
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+/**
+ * Stamp every JSX host element with where it is written and which component renders it,
+ * and every component usage with its call site. React passes data-* props through untouched,
+ * so the attributes cost nothing at runtime and only exist in dev.
+ */
+declare function stampSource(code: string, id: string, relFile: string): {
+    code: string;
+    map: magic_string.SourceMap;
+} | null;
+
+/**
+ * Source stamping for template languages: Vue single-file components and Svelte components.
+ * Every plain HTML element in a template gets `data-limno-src` (file:line:col) and
+ * `data-limno-comp` (the component, i.e. the file). Each framework's own parser is loaded from
+ * the project, so positions match exactly what the framework compiles.
+ */
+declare const TEMPLATE_FILES: RegExp;
+/** Stamp a .vue / .svelte file. Returns null when there's nothing to do. */
+declare function stampTemplate(code: string, id: string, relFile: string, root: string): Promise<{
+    code: string;
+    map: magic_string.SourceMap;
+} | null>;
+
+/**
+ * The framework-neutral half of Limno's dev tooling: the change-set store in the project
+ * (.limno/), the agent presence check, and the /__limno/* endpoints the overlay talks to.
+ * Bundler integrations (Vite, Next.js, webpack/Rspack) mount `handle` in their dev server or
+ * run it on its own port via `startServer`.
+ */
+declare const ROUTE = "/__limno";
+interface LimnoServiceOptions {
+    /** Project root: where .limno/ lives and source paths are relative to. */
+    root: string;
+    /** Directory (relative to root) for change sets. Default ".limno". */
+    dir?: string;
+}
+interface AgentStatus {
+    connected: boolean;
+    client: {
+        name: string;
+        version: string;
+    } | null;
+    lastSeen: number | null;
+    setup: {
+        command: string;
+        args: string[];
+        root: string;
+    };
+}
+declare function overlayFile(): string;
+interface LimnoService {
+    root: string;
+    /** Connect-style middleware: handles /__limno/*, otherwise calls next (or 404s). */
+    handle(req: IncomingMessage, res: ServerResponse, next?: () => void): void;
+    close(): void;
+}
+declare function createLimnoService({ root, dir }: LimnoServiceOptions): LimnoService;
+
+interface LimnoServer {
+    /** Base URL of the server, e.g. http://127.0.0.1:41234 */
+    url: string;
+    close(): void;
+}
+declare function startServer(options: LimnoServiceOptions): Promise<LimnoServer>;
+
+/** Files Limno stamps with source locations by default: JSX in .jsx/.tsx, and in .js/.mjs (common in Create React App, Gatsby and plain-JS Next.js apps). */
+declare const SOURCE_FILES: RegExp;
+/** True for files that should be stamped: JSX/TSX outside node_modules. */
+declare function shouldStamp(file: string, include?: RegExp): boolean;
+
+export { type AgentStatus, type LimnoServer, type LimnoService, type LimnoServiceOptions, ROUTE, SOURCE_FILES, TEMPLATE_FILES, createLimnoService, overlayFile, shouldStamp, stampSource, stampTemplate, startServer };

package/dist/index.js

@@ -0,0 +1,494 @@
+// src/transform.ts
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import MagicString from "magic-string";
+var traverse = _traverse.default ?? _traverse;
+var SKIP_COMPOSITES = /* @__PURE__ */ new Set(["Fragment", "React.Fragment", "Suspense", "React.Suspense", "StrictMode", "React.StrictMode", "Profiler", "React.Profiler", "Activity"]);
+function jsxName(name) {
+  if (name.type === "JSXIdentifier") return name.name;
+  if (name.type === "JSXNamespacedName") return `${name.namespace.name}:${name.name.name}`;
+  return `${jsxName(name.object)}.${name.property.name}`;
+}
+var isCapitalized = (s) => /^[A-Z]/.test(s);
+function componentName(path3, fileBase) {
+  let p = path3.getFunctionParent();
+  while (p) {
+    const node = p.node;
+    let name;
+    if ((node.type === "FunctionDeclaration" || node.type === "FunctionExpression") && node.id) name = node.id.name;
+    if (!name) {
+      let parent = p.parentPath;
+      while (parent && parent.node.type === "CallExpression") parent = parent.parentPath;
+      if (parent?.node.type === "VariableDeclarator" && parent.node.id.type === "Identifier") name = parent.node.id.name;
+      else if (parent?.node.type === "ExportDefaultDeclaration") name = fileBase;
+      else if (parent?.node.type === "ClassMethod" || parent?.node.type === "ObjectMethod") name = void 0;
+    }
+    if (!name && p.node.type === "ClassMethod") {
+      const cls = p.findParent((q) => q.isClassDeclaration());
+      name = cls?.node.id?.name;
+    }
+    if (name && isCapitalized(name)) return name;
+    p = p.parentPath ? p.parentPath.getFunctionParent() : null;
+  }
+  return void 0;
+}
+function hasAttr(node, name) {
+  return node.attributes.some((a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === name);
+}
+var escapeAttr = (s) => s.replace(/&/g, "&").replace(/"/g, """);
+function stampSource(code, id, relFile) {
+  if (!code.includes("<")) return null;
+  const isTs = /\.tsx$/.test(id);
+  let ast;
+  try {
+    ast = parse(code, {
+      sourceType: "module",
+      plugins: isTs ? ["jsx", "typescript"] : ["jsx"],
+      errorRecovery: true
+    });
+  } catch {
+    return null;
+  }
+  const s = new MagicString(code);
+  const fileBase = relFile.split("/").pop().replace(/\.[jt]sx?$/, "").replace(/^./, (c) => c.toUpperCase());
+  let touched = false;
+  traverse(ast, {
+    JSXOpeningElement(path3) {
+      const node = path3.node;
+      const loc = node.loc;
+      if (!loc || node.name.end == null) return;
+      const name = jsxName(node.name);
+      const where = `${relFile}:${loc.start.line}:${loc.start.column + 1}`;
+      const host = node.name.type === "JSXIdentifier" && !isCapitalized(name);
+      if (host) {
+        if (hasAttr(node, "data-limno-src")) return;
+        const comp = componentName(path3, fileBase);
+        s.appendLeft(node.name.end, ` data-limno-src="${escapeAttr(where)}"${comp ? ` data-limno-comp="${escapeAttr(comp)}"` : ""}`);
+        touched = true;
+      } else {
+        if (SKIP_COMPOSITES.has(name) || /\.(Provider|Consumer)$/.test(name) || hasAttr(node, "data-limno-callsite")) return;
+        s.appendLeft(node.name.end, ` data-limno-callsite="${escapeAttr(where)}"`);
+        touched = true;
+      }
+    }
+  });
+  if (!touched) return null;
+  return { code: s.toString(), map: s.generateMap({ hires: "boundary", source: id, includeContent: true }) };
+}
+
+// src/templates.ts
+import { createRequire } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+import MagicString2 from "magic-string";
+var TEMPLATE_FILES = /\.(vue|svelte)$/;
+var SKIP = /* @__PURE__ */ new Set(["script", "style", "template", "slot", "noscript"]);
+var escapeAttr2 = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+function lineStarts(code) {
+  const starts = [0];
+  for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) starts.push(i + 1);
+  return starts;
+}
+function position(starts, offset) {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return { line: lo + 1, column: offset - starts[lo] + 1 };
+}
+async function load(root, specifiers) {
+  for (const from of [path.join(root, "package.json"), import.meta.url]) {
+    const req = createRequire(from);
+    for (const spec of specifiers) {
+      try {
+        const mod = await import(pathToFileURL(req.resolve(spec)).href);
+        return mod.default && typeof mod.default === "object" ? { ...mod.default, ...mod } : mod;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+async function vueTags(code, root) {
+  const sfc = await load(root, ["vue/compiler-sfc", "@vue/compiler-sfc"]);
+  if (!sfc) return null;
+  const template = sfc.parse(code).descriptor.template;
+  if (!template?.ast || template.lang && template.lang !== "html") return null;
+  const tags = [];
+  const walk = (n) => {
+    if (n.type === 1 && n.tagType === 0 && n.tag && !SKIP.has(n.tag)) {
+      tags.push({ start: n.loc.start.offset, at: n.loc.start.offset + 1 + n.tag.length });
+    }
+    n.children?.forEach(walk);
+    n.branches?.forEach(walk);
+  };
+  template.ast.children?.forEach(walk);
+  return tags;
+}
+async function svelteTags(code, root) {
+  const compiler = await load(root, ["svelte/compiler"]);
+  if (!compiler?.parse) return null;
+  let ast;
+  try {
+    ast = compiler.parse(code, { modern: true });
+  } catch {
+    return null;
+  }
+  const tags = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (n) => {
+    if (!n || typeof n !== "object" || seen.has(n)) return;
+    seen.add(n);
+    const node = n;
+    if ((node.type === "RegularElement" || node.type === "Element") && node.name && node.start != null && !SKIP.has(node.name) && !node.name.includes(":")) {
+      tags.push({ start: node.start, at: node.start + 1 + node.name.length });
+    }
+    for (const [k, v] of Object.entries(node)) if (k !== "parent" && k !== "metadata") walk(v);
+  };
+  walk(ast.fragment ?? ast.html);
+  return tags;
+}
+async function stampTemplate(code, id, relFile, root) {
+  const ext = path.extname(id);
+  let tags = null;
+  try {
+    if (ext === ".vue") tags = await vueTags(code, root);
+    else if (ext === ".svelte") tags = await svelteTags(code, root);
+  } catch {
+    return null;
+  }
+  if (!tags?.length) return null;
+  const component = escapeAttr2(path.basename(id, ext).replace(/^./, (c) => c.toUpperCase()));
+  const starts = lineStarts(code);
+  const s = new MagicString2(code);
+  for (const t of tags) {
+    const { line, column } = position(starts, t.start);
+    if (code.slice(t.at, t.at + 200).split(">")[0].includes("data-limno-src")) continue;
+    s.appendLeft(t.at, ` data-limno-src="${escapeAttr2(`${relFile}:${line}:${column}`)}" data-limno-comp="${component}"`);
+  }
+  return { code: s.toString(), map: s.generateMap({ hires: "boundary", source: id, includeContent: true }) };
+}
+
+// src/service.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, watch, writeFileSync } from "fs";
+import { createRequire as createRequire2 } from "module";
+import path2 from "path";
+import { emptyChangeSet, mergeStatuses, renderPrompt } from "@limno/spec";
+var ROUTE = "/__limno";
+var require2 = createRequire2(import.meta.url);
+var STALE_MS = 3e4;
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeAtomic(file, data) {
+  mkdirSync(path2.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, data);
+  renameSync(tmp, file);
+}
+function body(req) {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    req.on("data", (c) => data += c);
+    req.on("end", () => resolve(data));
+    req.on("error", reject);
+  });
+}
+function send(res, status, payload, type = "application/json") {
+  res.statusCode = status;
+  res.setHeader("Content-Type", type);
+  res.setHeader("Cache-Control", "no-store");
+  res.end(typeof payload === "string" ? payload : JSON.stringify(payload));
+}
+var hash = (s) => createHash("sha1").update(s).digest("hex");
+function overlayFile() {
+  return require2.resolve("@limno/overlay/dist/overlay.js");
+}
+function createLimnoService({ root, dir = ".limno" }) {
+  const folder = path2.join(root, dir);
+  const file = path2.join(folder, "changeset.json");
+  const presenceFile = path2.join(folder, "agent.json");
+  let lastWrittenHash = "";
+  const clients = /* @__PURE__ */ new Set();
+  function broadcast(event, data) {
+    const msg = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+    for (const c of clients) c.write(msg);
+  }
+  function setupInfo() {
+    let cli = null;
+    for (const from of [path2.join(root, "package.json"), import.meta.url]) {
+      try {
+        cli = path2.join(path2.dirname(createRequire2(from).resolve("@limno/mcp/package.json")), "dist", "cli.js");
+        if (existsSync(cli)) break;
+        cli = null;
+      } catch {
+        cli = null;
+      }
+    }
+    return cli ? { command: "node", args: [cli, "--root", root], root } : { command: "npx", args: ["-y", "@limno/mcp", "--root", root], root };
+  }
+  function agentStatus() {
+    const presence = readJson(presenceFile);
+    let alive = !!presence?.pid;
+    if (alive) {
+      try {
+        process.kill(presence.pid, 0);
+      } catch {
+        alive = false;
+      }
+    }
+    const connected = alive && Date.now() - (presence?.lastSeen ?? 0) < STALE_MS;
+    return { connected, client: connected ? presence?.client ?? null : null, lastSeen: presence?.lastSeen ?? null, setup: setupInfo() };
+  }
+  function installConfig(target) {
+    const dest = target === "claude" ? path2.join(root, ".mcp.json") : path2.join(root, ".cursor", "mcp.json");
+    let config = {};
+    if (existsSync(dest)) {
+      try {
+        config = JSON.parse(readFileSync(dest, "utf8"));
+      } catch {
+        throw new Error(`${path2.relative(root, dest)} isn't valid JSON; fix or remove it first.`);
+      }
+    }
+    const { command, args } = setupInfo();
+    const portable = args.map((a, i) => {
+      if (args[i - 1] === "--root") return ".";
+      return path2.isAbsolute(a) ? path2.relative(root, a).split(path2.sep).join("/") : a;
+    });
+    config.mcpServers = { ...config.mcpServers ?? {}, limno: { command, args: portable } };
+    writeAtomic(dest, JSON.stringify(config, null, 2) + "\n");
+    return path2.relative(root, dest);
+  }
+  let lastAgent = "";
+  function pushAgent() {
+    const status = agentStatus();
+    const key = JSON.stringify([status.connected, status.client]);
+    if (key === lastAgent) return;
+    lastAgent = key;
+    broadcast("agent", status);
+  }
+  function onChangeSetFile() {
+    const raw = existsSync(file) ? readFileSync(file, "utf8") : "";
+    if (!raw || hash(raw) === lastWrittenHash) return;
+    const set = readJson(file);
+    if (set) broadcast("changeset", set);
+  }
+  mkdirSync(folder, { recursive: true });
+  let watcher = null;
+  let debounce;
+  try {
+    watcher = watch(folder, (_event, name) => {
+      if (!name || name.endsWith(".tmp")) return;
+      clearTimeout(debounce);
+      debounce = setTimeout(() => {
+        if (name === "changeset.json") onChangeSetFile();
+        if (name === "agent.json") pushAgent();
+      }, 40);
+    });
+    watcher.unref?.();
+  } catch {
+  }
+  const presenceTimer = setInterval(pushAgent, 1e4);
+  presenceTimer.unref();
+  const keepAlive = setInterval(() => {
+    for (const c of clients) c.write(": ping\n\n");
+  }, 25e3);
+  keepAlive.unref();
+  async function openInEditor(spec) {
+    const m = /^(.*?)(?::(\d+))?(?::(\d+))?$/.exec(spec);
+    if (!m) return false;
+    const target = path2.resolve(root, m[1]);
+    if (!target.startsWith(root + path2.sep) || !existsSync(target)) return false;
+    const { default: launch } = await import("launch-editor");
+    launch(`${target}${m[2] ? `:${m[2]}` : ""}${m[3] ? `:${m[3]}` : ""}`);
+    return true;
+  }
+  async function handle(req, res, next) {
+    const [url, query = ""] = (req.url ?? "").split("?");
+    if (!url.startsWith(ROUTE)) return next ? next() : send(res, 404, { error: "not found" });
+    try {
+      if (url === `${ROUTE}/overlay.js`) {
+        return send(res, 200, readFileSync(overlayFile(), "utf8"), "text/javascript");
+      }
+      if (url === `${ROUTE}/events`) {
+        res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-store", Connection: "keep-alive" });
+        res.write(": connected\n\n");
+        clients.add(res);
+        req.on("close", () => clients.delete(res));
+        return;
+      }
+      if (url === `${ROUTE}/changeset` && req.method === "GET") {
+        return send(res, 200, readJson(file) ?? emptyChangeSet());
+      }
+      if (url === `${ROUTE}/changeset` && req.method === "PUT") {
+        const incoming = JSON.parse(await body(req));
+        const merged = mergeStatuses(incoming, readJson(file));
+        merged.updatedAt = Date.now();
+        const raw = JSON.stringify(merged, null, 2);
+        lastWrittenHash = hash(raw);
+        writeAtomic(file, raw);
+        return send(res, 200, merged);
+      }
+      if (url === `${ROUTE}/prompt` && req.method === "GET") {
+        const set = readJson(file) ?? emptyChangeSet();
+        return send(res, 200, renderPrompt(set, { mcp: false, statuses: ["draft", "queued", "in_progress", "differs", "failed"] }), "text/markdown; charset=utf-8");
+      }
+      if (url === `${ROUTE}/agent` && req.method === "GET") {
+        return send(res, 200, agentStatus());
+      }
+      if (url === `${ROUTE}/agent/install` && req.method === "POST") {
+        const { target } = JSON.parse(await body(req));
+        if (target !== "claude" && target !== "cursor") return send(res, 400, { error: "unknown target" });
+        try {
+          return send(res, 200, { written: installConfig(target) });
+        } catch (e) {
+          return send(res, 409, { error: e instanceof Error ? e.message : String(e) });
+        }
+      }
+      if (url === `${ROUTE}/open`) {
+        const spec = new URLSearchParams(query).get("file") ?? "";
+        return send(res, await openInEditor(spec) ? 200 : 404, { ok: true });
+      }
+      if (url === `${ROUTE}/info`) {
+        return send(res, 200, { name: "limno", root, file: path2.relative(root, file) });
+      }
+      send(res, 404, { error: "not found" });
+    } catch (err) {
+      send(res, 500, { error: String(err) });
+    }
+  }
+  return {
+    root,
+    handle: (req, res, next) => void handle(req, res, next),
+    close() {
+      watcher?.close();
+      clearInterval(presenceTimer);
+      clearInterval(keepAlive);
+      for (const c of clients) c.end();
+      clients.clear();
+    }
+  };
+}
+
+// src/server.ts
+import { createHash as createHash2 } from "crypto";
+import http from "http";
+var LOOPBACK = /^(localhost|127\.0\.0\.1|\[::1\]|[\w-]+\.localhost)(:\d+)?$/i;
+function allowedOrigin(origin) {
+  if (!origin) return null;
+  try {
+    const u = new URL(origin);
+    return (u.protocol === "http:" || u.protocol === "https:") && LOOPBACK.test(u.host) ? origin : null;
+  } catch {
+    return null;
+  }
+}
+function preferredPort(root) {
+  return 41e3 + parseInt(createHash2("sha1").update(root).digest("hex").slice(0, 6), 16) % 900;
+}
+async function ours(port, root) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}${ROUTE}/info`, { signal: AbortSignal.timeout(800) });
+    const info = await res.json();
+    return info.name === "limno" && info.root === root;
+  } catch {
+    return false;
+  }
+}
+var running = /* @__PURE__ */ new Map();
+function startServer(options) {
+  const key = `${options.root}|${options.dir ?? ""}`;
+  let p = running.get(key);
+  if (!p) {
+    p = listen(options);
+    running.set(key, p);
+  }
+  return p;
+}
+async function listen(options) {
+  const service = createLimnoService(options);
+  const server = http.createServer((req, res) => {
+    if (!LOOPBACK.test(req.headers.host ?? "")) {
+      res.statusCode = 403;
+      return res.end();
+    }
+    const origin = allowedOrigin(req.headers.origin);
+    if (req.headers.origin && !origin) {
+      res.statusCode = 403;
+      return res.end();
+    }
+    if (origin) {
+      res.setHeader("Access-Control-Allow-Origin", origin);
+      res.setHeader("Vary", "Origin");
+      res.setHeader("Access-Control-Allow-Methods", "GET, PUT, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (req.headers["access-control-request-private-network"]) res.setHeader("Access-Control-Allow-Private-Network", "true");
+    }
+    if (req.method === "OPTIONS") {
+      res.statusCode = 204;
+      return res.end();
+    }
+    service.handle(req, res);
+  });
+  server.unref();
+  const start = preferredPort(options.root);
+  for (let port = start; port < start + 40; port++) {
+    const outcome = await new Promise((resolve, reject) => {
+      const onError = (err) => {
+        server.off("listening", onListening);
+        if (err.code === "EADDRINUSE") resolve("busy");
+        else reject(err);
+      };
+      const onListening = () => {
+        server.off("error", onError);
+        resolve("ok");
+      };
+      server.once("error", onError);
+      server.once("listening", onListening);
+      server.listen(port, "127.0.0.1");
+    });
+    if (outcome === "ok") {
+      return {
+        url: `http://127.0.0.1:${port}`,
+        close: () => {
+          service.close();
+          server.close();
+        }
+      };
+    }
+    if (await ours(port, options.root)) {
+      service.close();
+      return { url: `http://127.0.0.1:${port}`, close: () => void 0 };
+    }
+  }
+  service.close();
+  throw new Error("Limno: no free local port for its dev server.");
+}
+
+// src/files.ts
+var SOURCE_FILES = /\.(jsx|tsx|js|mjs)$/;
+function shouldStamp(file, include = SOURCE_FILES) {
+  return include.test(file) && !/[\\/]node_modules[\\/]/.test(file) && !file.startsWith("\0");
+}
+export {
+  ROUTE,
+  SOURCE_FILES,
+  TEMPLATE_FILES,
+  createLimnoService,
+  overlayFile,
+  shouldStamp,
+  stampSource,
+  stampTemplate,
+  startServer
+};