@limno/core 0.1.0

package/LICENSE.md

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 Damilola Adewale
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,543 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ROUTE: () => ROUTE,
+  SOURCE_FILES: () => SOURCE_FILES,
+  TEMPLATE_FILES: () => TEMPLATE_FILES,
+  createLimnoService: () => createLimnoService,
+  overlayFile: () => overlayFile,
+  shouldStamp: () => shouldStamp,
+  stampSource: () => stampSource,
+  stampTemplate: () => stampTemplate,
+  startServer: () => startServer
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/transform.ts
+var import_parser = require("@babel/parser");
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+var import_magic_string = __toESM(require("magic-string"), 1);
+var traverse = import_traverse.default.default ?? import_traverse.default;
+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 = (0, import_parser.parse)(code, {
+      sourceType: "module",
+      plugins: isTs ? ["jsx", "typescript"] : ["jsx"],
+      errorRecovery: true
+    });
+  } catch {
+    return null;
+  }
+  const s = new import_magic_string.default(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
+var import_node_module = require("module");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var import_magic_string2 = __toESM(require("magic-string"), 1);
+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 [import_node_path.default.join(root, "package.json"), importMetaUrl]) {
+    const req = (0, import_node_module.createRequire)(from);
+    for (const spec of specifiers) {
+      try {
+        const mod = await import((0, import_node_url.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 = import_node_path.default.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(import_node_path.default.basename(id, ext).replace(/^./, (c) => c.toUpperCase()));
+  const starts = lineStarts(code);
+  const s = new import_magic_string2.default(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
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_module2 = require("module");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_spec = require("@limno/spec");
+var ROUTE = "/__limno";
+var require2 = (0, import_node_module2.createRequire)(importMetaUrl);
+var STALE_MS = 3e4;
+function readJson(file) {
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeAtomic(file, data) {
+  (0, import_node_fs.mkdirSync)(import_node_path2.default.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  (0, import_node_fs.writeFileSync)(tmp, data);
+  (0, import_node_fs.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) => (0, import_node_crypto.createHash)("sha1").update(s).digest("hex");
+function overlayFile() {
+  return require2.resolve("@limno/overlay/dist/overlay.js");
+}
+function createLimnoService({ root, dir = ".limno" }) {
+  const folder = import_node_path2.default.join(root, dir);
+  const file = import_node_path2.default.join(folder, "changeset.json");
+  const presenceFile = import_node_path2.default.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 [import_node_path2.default.join(root, "package.json"), importMetaUrl]) {
+      try {
+        cli = import_node_path2.default.join(import_node_path2.default.dirname((0, import_node_module2.createRequire)(from).resolve("@limno/mcp/package.json")), "dist", "cli.js");
+        if ((0, import_node_fs.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" ? import_node_path2.default.join(root, ".mcp.json") : import_node_path2.default.join(root, ".cursor", "mcp.json");
+    let config = {};
+    if ((0, import_node_fs.existsSync)(dest)) {
+      try {
+        config = JSON.parse((0, import_node_fs.readFileSync)(dest, "utf8"));
+      } catch {
+        throw new Error(`${import_node_path2.default.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 import_node_path2.default.isAbsolute(a) ? import_node_path2.default.relative(root, a).split(import_node_path2.default.sep).join("/") : a;
+    });
+    config.mcpServers = { ...config.mcpServers ?? {}, limno: { command, args: portable } };
+    writeAtomic(dest, JSON.stringify(config, null, 2) + "\n");
+    return import_node_path2.default.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 = (0, import_node_fs.existsSync)(file) ? (0, import_node_fs.readFileSync)(file, "utf8") : "";
+    if (!raw || hash(raw) === lastWrittenHash) return;
+    const set = readJson(file);
+    if (set) broadcast("changeset", set);
+  }
+  (0, import_node_fs.mkdirSync)(folder, { recursive: true });
+  let watcher = null;
+  let debounce;
+  try {
+    watcher = (0, import_node_fs.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 = import_node_path2.default.resolve(root, m[1]);
+    if (!target.startsWith(root + import_node_path2.default.sep) || !(0, import_node_fs.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, (0, import_node_fs.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) ?? (0, import_spec.emptyChangeSet)());
+      }
+      if (url === `${ROUTE}/changeset` && req.method === "PUT") {
+        const incoming = JSON.parse(await body(req));
+        const merged = (0, import_spec.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) ?? (0, import_spec.emptyChangeSet)();
+        return send(res, 200, (0, import_spec.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: import_node_path2.default.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
+var import_node_crypto2 = require("crypto");
+var import_node_http = __toESM(require("http"), 1);
+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((0, import_node_crypto2.createHash)("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 = import_node_http.default.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");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ROUTE,
+  SOURCE_FILES,
+  TEMPLATE_FILES,
+  createLimnoService,
+  overlayFile,
+  shouldStamp,
+  stampSource,
+  stampTemplate,
+  startServer
+});