@horizonmedia/blu-sdk 0.0.0-stage → 1.8.4

package/bin/blu.js

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+import {
+  REGISTRY_URL,
+  validateModuleManifest
+} from "../chunks/chunk-CSQHQLB7.js";
+
+// src/cli/blu.js
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".next", "out", "coverage", ".git", ".turbo", "public", "__pycache__", "venv", "site-packages"]);
+var CODE = /\.(m?[jt]sx?|cjs|py)$/;
+var isPy = (f) => f.endsWith(".py");
+var usesPySdk = (src) => /^\s*(?:from\s+blu_sdk(?:\.\w+)*\s+import|import\s+blu_sdk)\b/m.test(src);
+var FORBIDDEN_IMPORTS = [
+  { re: /^@blu\/sdk\/shell$/, fail: true, why: "is internal to the Blu shell. Read the context with the hooks in @blu/sdk." },
+  { re: /^@blu\/contracts$/, fail: true, why: "is internal to Blu. Validate your manifest with `blu check`." },
+  { re: /^@blu\/host-sdk\/frame$/, fail: true, why: "was renamed: import from @blu/sdk/frame." },
+  { re: /^@blu\/host-sdk$/, fail: true, why: "was renamed: import from @blu/sdk." },
+  { re: /^@blu\/service-sdk$/, fail: true, why: "was renamed: import from @blu/sdk/server." },
+  { re: /^@blu\/module-dev-harness$/, fail: true, why: "was renamed: import from @blu/sdk/dev." },
+  { re: /^@blu\/(sdk|next-adapter)\/(src|dist|types|chunks)\b/, fail: true, why: "reaches inside the package. Import only its documented entry points." },
+  { re: /^@horizonmedia\/blu-(sdk|next-adapter)(\/|$)/, fail: false, why: "uses the published name. Import it as @blu/sdk (or @blu/next-adapter) and alias it in package.json." }
+];
+function sdkVersion() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  for (const p of [path.join(here, "package.json"), path.join(here, "../../package.json")]) {
+    try {
+      const pkg = JSON.parse(readFileSync(p, "utf8"));
+      if (pkg.name === "@horizonmedia/blu-sdk" || pkg.name === "@blu/sdk") return pkg.version;
+    } catch {
+    }
+  }
+  return null;
+}
+function walk(dir, out = []) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    if (e.name.startsWith(".") && e.name !== ".npmrc") continue;
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      if (!SKIP_DIRS.has(e.name)) walk(p, out);
+    } else out.push(p);
+  }
+  return out;
+}
+function findModuleRoot(dir) {
+  if (existsSync(path.join(dir, "blu.module.json"))) return dir;
+  const found = walk(dir).filter((f) => path.basename(f) === "blu.module.json");
+  if (found.length === 1) return path.dirname(found[0]);
+  if (found.length > 1) throw new Error(`Several blu.module.json files under ${dir}; run blu check in one module's folder:
+  ${found.join("\n  ")}`);
+  throw new Error(`No blu.module.json in ${dir} or below. Run blu check in your module's folder.`);
+}
+var pyImportsOf = (src) => [...src.matchAll(/^\s*(?:from\s+([\w.]+)\s+import|import\s+([\w.]+))/gm)].map((m) => m[1] ?? m[2]);
+function nearestPythonManifest(file, root) {
+  let d = path.dirname(file);
+  const stop = path.dirname(root);
+  while (d.startsWith(stop)) {
+    const found = ["pyproject.toml", "requirements.txt", "requirements.in"].map((n) => path.join(d, n)).find((p) => existsSync(p));
+    if (found) return found;
+    if (d === stop) break;
+    d = path.dirname(d);
+  }
+  return null;
+}
+var importsOf = (src) => [...src.matchAll(/(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s+|\brequire\s*\(\s*)["']([^"']+)["']/g)].map((m) => m[1]);
+function nearestPackageJson(file, root) {
+  let d = path.dirname(file);
+  const stop = path.dirname(root);
+  while (d.startsWith(stop)) {
+    const p = path.join(d, "package.json");
+    if (existsSync(p)) return p;
+    if (d === stop) break;
+    d = path.dirname(d);
+  }
+  return null;
+}
+function githubPackagesNpmrc(dir) {
+  let d = dir;
+  for (; ; ) {
+    const p = path.join(d, ".npmrc");
+    if (existsSync(p) && /^\s*@horizonmedia:registry\s*=\s*https:\/\/npm\.pkg\.github\.com/m.test(readFileSync(p, "utf8"))) return p;
+    const up = path.dirname(d);
+    if (up === d) return null;
+    d = up;
+  }
+}
+var below = (a, b) => {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) < (pb[i] ?? 0);
+  return false;
+};
+function check(dir, { simulatedDns = false } = {}) {
+  const root = findModuleRoot(path.resolve(dir));
+  const results = [];
+  const add = (status, area, message, file) => results.push({ status, area, message, ...file ? { file: path.relative(root, file) } : {} });
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(path.join(root, "blu.module.json"), "utf8"));
+  } catch (e) {
+    add("fail", "manifest", `blu.module.json isn't valid JSON: ${e.message}`);
+    return { root, manifest: null, results };
+  }
+  const problems = validateModuleManifest(manifest, { simulatedDns });
+  for (const p of problems) add("fail", "manifest", p);
+  const routes = new Set((manifest.routes ?? []).map((r) => r.name));
+  const tools = (manifest.mcp?.tools ?? []).map((t) => t.name);
+  if (!problems.length) {
+    const mounts = [manifest.remote && "inline", manifest.frame && "isolated"].filter(Boolean).join(" + ");
+    add("pass", "manifest", `valid: module "${manifest.id}", ${mounts}, ${routes.size} route(s), ${tools.length} Concierge tool(s)`);
+  }
+  const unversioned = Object.entries(manifest.environments ?? {}).flatMap(
+    ([stage, e]) => ["remoteEntry", "frameEntry"].filter((k) => typeof e?.[k] === "string" && !e[k].includes("{version}") && !(manifest.version && e[k].includes(`/${manifest.version}/`))).map((k) => `${stage}.${k}`)
+  );
+  if (unversioned.length) {
+    add("warn", "releases", `${unversioned.join(", ")} don't name the release's folder. Use {version} in the address (\u2026/{version}/remoteEntry.js), so each release keeps its own files and rollback works.`);
+  } else if (Object.keys(manifest.environments ?? {}).length) add("pass", "releases", "bundle addresses are per release ({version})");
+  const files = walk(root).filter((f) => CODE.test(f));
+  const sources = new Map(files.map((f) => [f, readFileSync(f, "utf8")]));
+  const usingSdk = /* @__PURE__ */ new Map();
+  let badImports = 0;
+  const usingPySdk = /* @__PURE__ */ new Set();
+  for (const [f, src] of sources) {
+    if (isPy(f)) {
+      for (const mod of pyImportsOf(src)) {
+        if (/^blu_sdk\._/.test(mod)) {
+          add("fail", "imports", `"${mod}" is internal to blu-sdk. Import from blu_sdk or its documented modules (blu_sdk.fastapi, .flask, .django, .asgi, .mcp, .contracts).`, f);
+          badImports++;
+        } else if (/^blu_platform(\.|$)/.test(mod)) {
+          add("fail", "imports", `"${mod}" is internal to Blu. Use blu-sdk.`, f);
+          badImports++;
+        }
+      }
+      if (usesPySdk(src)) {
+        const manifestFile = nearestPythonManifest(f, root);
+        usingPySdk.add(manifestFile ?? f);
+      }
+      continue;
+    }
+    for (const spec of importsOf(src)) {
+      const rule = FORBIDDEN_IMPORTS.find((r) => r.re.test(spec));
+      if (rule) {
+        add(rule.fail ? "fail" : "warn", "imports", `"${spec}" ${rule.why}`, f);
+        badImports++;
+      }
+      if (/^@blu\/(sdk|next-adapter)(\/|$)/.test(spec)) {
+        const pj = nearestPackageJson(f, root);
+        if (pj) usingSdk.set(pj, /* @__PURE__ */ new Set([...usingSdk.get(pj) ?? [], spec.split("/").slice(0, 2).join("/")]));
+      }
+    }
+  }
+  if (!badImports) add("pass", "imports", `only public ${usingPySdk.size ? "blu-sdk, " : ""}@blu/sdk and @blu/next-adapter entry points`);
+  const current = sdkVersion();
+  const oldNpmrcs = /* @__PURE__ */ new Set();
+  for (const [pj, used] of usingSdk) {
+    const pkg = JSON.parse(readFileSync(pj, "utf8"));
+    const deps = { ...pkg.devDependencies, ...pkg.peerDependencies, ...pkg.dependencies };
+    for (const name of used) {
+      const spec = deps[name];
+      const published = name === "@blu/sdk" ? "@horizonmedia/blu-sdk" : "@horizonmedia/blu-next-adapter";
+      if (!spec) {
+        add("fail", "dependencies", `${name} is imported but not in package.json. Add "${name}": "npm:${published}@^${name === "@blu/sdk" && current ? current : "1.0.0"}".`, pj);
+      } else if (spec.startsWith("workspace:")) {
+        add("pass", "dependencies", `${name}: workspace package (the Blu repo itself)`, pj);
+      } else if (!spec.startsWith(`npm:${published}@`)) {
+        add("fail", "dependencies", `${name} is "${spec}". Use the published package under that name: "npm:${published}@^\u2026".`, pj);
+      } else {
+        const min = /@[~^]?(\d+\.\d+\.\d+)/.exec(spec.slice(4 + published.length))?.[1];
+        if (name === "@blu/sdk" && current && min && below(min, current)) {
+          add("warn", "dependencies", `${name} allows ${min}; this check came with ${current}. Raise the range to ^${current} to build against what the Blu shell provides.`, pj);
+        } else add("pass", "dependencies", `${name}: ${spec}`, pj);
+        const npmrc = githubPackagesNpmrc(path.dirname(pj));
+        if (npmrc && !oldNpmrcs.has(npmrc)) {
+          oldNpmrcs.add(npmrc);
+          add("warn", "dependencies", `${path.relative(process.cwd(), npmrc) || ".npmrc"} points @horizonmedia at GitHub Packages. The Blu SDKs are public on npm now: remove that line (and any token for it), so new versions install from registry.npmjs.org.`, pj);
+        }
+      }
+    }
+    const zodMin = /(\d+\.\d+\.\d+)/.exec(deps.zod ?? "")?.[1];
+    if (zodMin && below(zodMin, "4.6.6")) {
+      add("warn", "dependencies", `zod allows ${zodMin}: versions before 4.6.6 can exhaust memory validating oversized input (GHSA-mrhx-c7xc-m3w5). Use "zod": "^4.6.7".`, pj);
+    }
+    const reactSpec = deps.react;
+    if (manifest.remote && reactSpec && !/(^|[^\d.])19(\.|$|\b)|\*|latest|>=\s*1[89]/.test(reactSpec)) {
+      add(
+        "warn",
+        "react",
+        `react is "${reactSpec}": inside Blu this module runs on the shell's React 19 (one shared copy). React 18 code generally works there; avoid what 19 removed: ReactDOM.render/hydrate, string refs, legacy context (contextTypes), defaultProps on function components, findDOMNode. Test it in the shell before releasing.`,
+        pj
+      );
+    }
+  }
+  for (const file of usingPySdk) {
+    if (!/\.(toml|txt|in)$/.test(file)) {
+      add("fail", "dependencies", "Python code imports blu_sdk but there's no pyproject.toml or requirements.txt declaring blu-sdk.", file);
+      continue;
+    }
+    const line = readFileSync(file, "utf8").split("\n").find((l) => /^\s*["']?blu-sdk\b/.test(l));
+    const spec = line?.trim().replace(/^["']|["'],?$/g, "");
+    if (!spec) add("fail", "dependencies", `blu_sdk is imported but blu-sdk isn't declared. Add "blu-sdk @ git+https://github.com/HorizonMedia/blu-composable-experience@sdk-py-v1.2.0#subdirectory=packages/sdk-python".`, file);
+    else if (/git\+/.test(spec) && !/@sdk-py-v\d+\.\d+\.\d+/.test(spec)) add("warn", "dependencies", `blu-sdk is installed from Git without a release tag ("${spec}"). Pin @sdk-py-vX.Y.Z so builds are repeatable.`, file);
+    else add("pass", "dependencies", `blu-sdk: ${spec}`, file);
+  }
+  if (!usingSdk.size && !usingPySdk.size) add("warn", "dependencies", "no code here imports @blu/sdk or blu_sdk yet");
+  const grep = (re) => [...sources].filter(([, s]) => re.test(s)).map(([f]) => f);
+  const usesNextAdapter = [...usingSdk.values()].some((u) => u.has("@blu/next-adapter"));
+  if (manifest.remote) {
+    const name = manifest.remote.name;
+    if (usesNextAdapter) {
+      const configs = grep(/\bbluModule\s*\(/);
+      const named = configs.filter((f) => new RegExp(`\\bname\\s*:\\s*["']${name}["']`).test(sources.get(f)));
+      if (!configs.length) add("fail", "inline", "uses @blu/next-adapter but no Vite config calls bluModule(). Add vite.blu.config.ts.");
+      else if (!named.length) add("fail", "inline", `bluModule() isn't given name "${name}" (manifest remote.name).`, configs[0]);
+      else add("pass", "inline", `bluModule({ name: "${name}" }) matches the manifest`, named[0]);
+    } else {
+      const configs = grep(/\bfederation\s*\(/);
+      if (!configs.length) {
+        add("fail", "inline", "the manifest declares `remote` (inline) but no Vite config calls federation(). Add @module-federation/vite.");
+      } else {
+        for (const f of configs) {
+          const src = sources.get(f);
+          if (!new RegExp(`\\bname\\s*:\\s*["']${name}["']`).test(src)) add("fail", "inline", `federation() name isn't "${name}" (manifest remote.name).`, f);
+          if (!src.includes(`"${manifest.remote.exposed}"`) && !src.includes(`'${manifest.remote.exposed}'`)) {
+            add("fail", "inline", `federation() doesn't expose "${manifest.remote.exposed}" (manifest remote.exposed).`, f);
+          }
+          if (!/["']@blu\/sdk["']\s*:\s*\{[^}]*singleton\s*:\s*true/.test(src)) {
+            add("fail", "inline", 'federation() must share "@blu/sdk": { singleton: true }. Two copies would mean two contexts, and the hooks would find no Blu.', f);
+          } else add("pass", "inline", `federation() "${name}" shares @blu/sdk as a singleton`, f);
+        }
+      }
+    }
+  }
+  if (manifest.frame) {
+    const frames = grep(/\b(mountIsolated|connectToBluShell)\s*\(/);
+    if (frames.length) add("pass", "isolated", "the frame page connects with mountIsolated / connectToBluShell", frames[0]);
+    else add("fail", "isolated", "the manifest declares `frame` (isolated) but nothing calls mountIsolated() or connectToBluShell() from @blu/sdk/frame.");
+  }
+  const servers = [...grep(/["']@blu\/(sdk\/server|next-adapter\/server)["']/), ...[...sources].filter(([f, s]) => isPy(f) && usesPySdk(s)).map(([f]) => f)];
+  if (!servers.length) {
+    add("warn", "server", "no code here uses @blu/sdk/server, @blu/next-adapter/server or blu_sdk (Python). If your API lives in another repo, run blu check there too.");
+  } else {
+    let mismatched = false;
+    for (const f of servers) {
+      for (const m of sources.get(f).matchAll(/\b(?:moduleId\s*:|module_id\s*=)\s*["']([^"']+)["']/g)) {
+        if (m[1] !== manifest.id) {
+          add("fail", "server", `moduleId "${m[1]}" isn't the manifest's id "${manifest.id}". Blu issues your tokens for blu-module:${manifest.id}.`, f);
+          mismatched = true;
+        }
+      }
+    }
+    if (!mismatched) add("pass", "server", `${servers.length} file(s) use the server SDK; module ids match the manifest`);
+  }
+  if (tools.length) {
+    const endpoints = [...sources].filter(([f, s]) => isPy(f) ? usesPySdk(s) && /(?:\.(?:mount_)?mcp|\bMcpEndpoint)\s*\(/.test(s) : /\bcreateMcp(Endpoint|WebHandler)\s*\(/.test(s)).map(([f]) => f);
+    if (!endpoints.length) {
+      add("fail", "mcp", `the manifest declares ${tools.length} tool(s) but no code serves them: createMcpEndpoint() / createMcpWebHandler() (JS), or blu.mount_mcp(...) / McpEndpoint(...) (Python).`);
+    } else {
+      const withManifest = endpoints.filter((f) => /(?:\bcreateMcp(?:Endpoint|WebHandler)|\.(?:mount_)?mcp|\bMcpEndpoint)\s*\([\s\S]{0,400}?\bmanifest\b/.test(sources.get(f)));
+      if (!withManifest.length) add("fail", "mcp", "pass your blu.module.json as `manifest` to the MCP endpoint, so tools that don't match it stop the API from starting.", endpoints[0]);
+      const missing = tools.filter((t) => !grep(new RegExp(`\\bname\\s*[:=]\\s*["']${t}["']`)).length);
+      for (const t of missing) add("fail", "mcp", `tool "${t}" is declared in the manifest but no code defines it (name: "${t}").`);
+      if (withManifest.length && !missing.length) add("pass", "mcp", `${tools.length} tool(s) defined; the endpoint is checked against the manifest at startup`, withManifest[0]);
+    }
+  }
+  let links = 0;
+  for (const [f, src] of sources) {
+    if (!/["']@blu\/sdk\/server["']/.test(src) && !(isPy(f) && usesPySdk(src))) continue;
+    for (const m of src.matchAll(/\blink\s*\(\s*["']([^"']+)["']/g)) {
+      links++;
+      if (!routes.has(m[1])) add("fail", "links", `link("${m[1]}", \u2026) names a route the manifest doesn't declare. Add it to routes, or link to one that exists.`, f);
+    }
+  }
+  if (links && !results.some((r) => r.area === "links")) add("pass", "links", `${links} link(s), all to declared routes`);
+  return { root, manifest, results };
+}
+async function register(rest) {
+  const flag = rest.indexOf("--registry");
+  const registry = (flag >= 0 ? rest[flag + 1] : process.env.BLU_REGISTRY_URL) || REGISTRY_URL;
+  const dir = rest.find((a, i) => !a.startsWith("--") && rest[i - 1] !== "--registry") ?? process.cwd();
+  const token = process.env.BLU_CI_TOKEN;
+  if (!token) {
+    console.error("blu register: set BLU_CI_TOKEN to your module's CI token (ask the Blu team for it).");
+    return 2;
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(path.join(findModuleRoot(path.resolve(dir)), "blu.module.json"), "utf8"));
+  } catch (e) {
+    console.error(`blu register: ${e.message}`);
+    return 2;
+  }
+  const url = `${registry.replace(/\/$/, "")}/v1/modules/${encodeURIComponent(manifest.id)}/versions`;
+  let res;
+  try {
+    res = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` }, body: JSON.stringify(manifest) });
+  } catch (e) {
+    console.error(`blu register: couldn't reach ${registry}: ${e.cause?.message ?? e.message}`);
+    return 1;
+  }
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    console.error(`\u2718 ${manifest.id}@${manifest.version}: ${body.detail ?? body.error ?? `HTTP ${res.status}`}`);
+    for (const p of body.problems ?? []) console.error(`    - ${p}`);
+    return 1;
+  }
+  console.log(`\u2714 ${manifest.id}@${body.version} ${body.created ? "registered" : "was already registered (unchanged)"}`);
+  for (const [env, status] of Object.entries(body.environments ?? {})) console.log(`    ${env.padEnd(8)} ${status}`);
+  if (body.review) console.log(`  Blu admins review it at ${body.review}`);
+  return 0;
+}
+async function main(argv) {
+  const [cmd, ...rest] = argv;
+  if (cmd === "register") return register(rest);
+  if (cmd !== "check") {
+    console.log("Usage: blu check [dir] [--json] [--simulated-dns]\n       blu register [dir] [--registry <url>]   (BLU_CI_TOKEN = the module's CI token)");
+    return cmd === void 0 || cmd === "--help" || cmd === "-h" ? 0 : 2;
+  }
+  const json = rest.includes("--json");
+  const simulatedDns = rest.includes("--simulated-dns");
+  const dir = rest.find((a) => !a.startsWith("--")) ?? process.cwd();
+  let report;
+  try {
+    report = check(dir, { simulatedDns });
+  } catch (e) {
+    console.error(`blu check: ${e.message}`);
+    return 2;
+  }
+  const fails = report.results.filter((r) => r.status === "fail").length;
+  const warns = report.results.filter((r) => r.status === "warn").length;
+  if (json) {
+    console.log(JSON.stringify({ root: report.root, module: report.manifest?.id ?? null, ok: fails === 0, ...report }, null, 2));
+  } else {
+    console.log(`blu check: ${report.root}${report.manifest?.id ? ` (module "${report.manifest.id}")` : ""}`);
+    const icon = { pass: "\u2714", warn: "\u26A0", fail: "\u2718" };
+    for (const r of report.results) console.log(`${icon[r.status]} ${r.area}: ${r.message}${r.file ? `  [${r.file}]` : ""}`);
+    console.log(fails ? `
+${fails} problem(s)${warns ? `, ${warns} warning(s)` : ""}` : `
+All checks passed${warns ? ` (${warns} warning(s))` : ""}.`);
+  }
+  return fails ? 1 : 0;
+}
+process.exitCode = await main(process.argv.slice(2));

package/chunks/chunk-CSQHQLB7.js

@@ -0,0 +1,163 @@
+// ../contracts/src/index.js
+var MANIFEST_VERSION = 1;
+var SUPPORTED_CONTRACT_MAJORS = [1];
+var STAGES = ["local", "dev", "staging", "prod"];
+function isLocalHost(hostname) {
+  const h = String(hostname).replace(/\.$/, "").toLowerCase();
+  return h === "localhost" || h.endsWith(".localhost") || /^127(\.\d{1,3}){3}$/.test(h) || h === "[::1]";
+}
+var isLocalUrl = (url) => {
+  try {
+    return isLocalHost(new URL(url).hostname);
+  } catch {
+    return false;
+  }
+};
+var ENTRY_POINTS = ["blu", "service", "team", "api-key"];
+var ID = /^[a-z][a-z0-9-]{1,40}$/;
+var TOOL = /^[a-z][a-z0-9_]{1,50}$/;
+var ROUTE_NAME = /^[a-z][a-z0-9-]{0,40}$/;
+var ROUTE_SEGMENT = /^(:[a-zA-Z][a-zA-Z0-9]{0,30}|[a-z0-9][a-z0-9._-]*)$/;
+function isLoopbackOrIp(hostname) {
+  const h = hostname.replace(/\.$/, "").toLowerCase();
+  return h === "localhost" || h.endsWith(".localhost") || /^\d{1,3}(\.\d{1,3}){3}$/.test(h) || h.startsWith("[");
+}
+function redirectUriProblems(uri, stage, { simulatedDns = false } = {}) {
+  let url;
+  try {
+    url = new URL(uri);
+  } catch {
+    return ["must be an absolute URL"];
+  }
+  const problems = [];
+  if (url.protocol !== "https:" && url.protocol !== "http:") problems.push("must be http(s)");
+  if (/[*\s#]/.test(uri)) problems.push("no wildcards, spaces or fragments");
+  if (url.username || url.password) problems.push("no user:password@");
+  if (stage !== "local") {
+    const simulated = simulatedDns && url.hostname.endsWith(".localhost");
+    if (isLoopbackOrIp(url.hostname) && !simulated) problems.push(`localhost and IP addresses are only allowed in local, not ${stage}`);
+    if (url.protocol !== "https:" && !simulated) problems.push(`must be https in ${stage}`);
+  }
+  return problems;
+}
+function validateModuleManifest(m, opts = {}) {
+  const problems = [];
+  const req = (cond, msg) => cond || problems.push(msg);
+  if (!m || typeof m !== "object") return ["manifest must be a JSON object"];
+  req(m.manifestVersion === MANIFEST_VERSION, `manifestVersion must be ${MANIFEST_VERSION}`);
+  req(typeof m.id === "string" && ID.test(m.id), "id: lowercase letters, digits, dashes");
+  req(typeof m.displayName === "string" && m.displayName.length > 0, "displayName required");
+  req(typeof m.owner === "string" && m.owner.length > 0, "owner required");
+  req(typeof m.version === "string" && /^\d+\.\d+\.\d+/.test(m.version), "version must be semver");
+  const major = Number(String(m.contractVersion ?? "").split(".")[0]);
+  req(SUPPORTED_CONTRACT_MAJORS.includes(major), `contractVersion major must be one of ${SUPPORTED_CONTRACT_MAJORS.join(", ")} (admission floor)`);
+  const inline = m.remote !== void 0;
+  const isolated = m.frame !== void 0;
+  req(inline || isolated, "declare `remote` (inline, Module Federation) and/or `frame` (isolated iframe)");
+  if (inline) req(typeof m.remote?.name === "string" && typeof m.remote?.exposed === "string", "remote.name and remote.exposed required");
+  if (isolated) {
+    req(m.frame && typeof m.frame === "object", "frame must be an object");
+    req(m.frame?.routing === void 0 || ["bridge", "url"].includes(m.frame.routing), 'frame.routing must be "bridge" or "url"');
+    req(m.frame?.inlineScripts === void 0 || typeof m.frame.inlineScripts === "boolean", "frame.inlineScripts must be true/false");
+  }
+  req(m.navDefaults && typeof m.navDefaults.path === "string" && m.navDefaults.path.startsWith("/"), "navDefaults.path required");
+  req(m.navDefaults?.moduleInfo === void 0 || typeof m.navDefaults.moduleInfo === "boolean", "navDefaults.moduleInfo must be true/false");
+  const envs = Object.keys(m.environments ?? {});
+  req(envs.length > 0, "environments: at least one stage");
+  for (const stage of envs) {
+    req(STAGES.includes(stage), `environments.${stage}: unknown stage`);
+    for (const k of ["apiBase", "mcpUrl", ...inline ? ["remoteEntry"] : [], ...isolated ? ["frameEntry"] : []]) {
+      const v = m.environments[stage]?.[k];
+      req(typeof v === "string" && /^https?:\/\//.test(v), `environments.${stage}.${k} must be an absolute URL`);
+    }
+    const redirects = m.environments[stage]?.standaloneRedirectUris;
+    if (redirects !== void 0) {
+      req(Array.isArray(redirects), `environments.${stage}.standaloneRedirectUris must be an array`);
+      for (const u of Array.isArray(redirects) ? redirects : []) {
+        const issues = typeof u === "string" ? redirectUriProblems(u, stage, opts) : ["must be a string"];
+        req(issues.length === 0, `environments.${stage}.standaloneRedirectUris: "${u}" ${issues.join("; ")}`);
+      }
+    }
+  }
+  if (m.routes !== void 0) {
+    req(Array.isArray(m.routes), "routes must be an array");
+    const names = /* @__PURE__ */ new Set();
+    for (const r of Array.isArray(m.routes) ? m.routes : []) {
+      req(typeof r?.name === "string" && ROUTE_NAME.test(r.name), `routes: bad name "${r?.name}"`);
+      req(!names.has(r?.name), `routes: duplicate "${r?.name}"`);
+      names.add(r?.name);
+      const segs = typeof r?.path === "string" && r.path.startsWith("/") ? r.path.slice(1).split("/") : null;
+      req(segs !== null && segs.every((x) => ROUTE_SEGMENT.test(x)), `routes.${r?.name}: path must be /literal/:param/\u2026 (got "${r?.path}")`);
+      req(typeof r?.title === "string" && r.title.length > 0, `routes.${r?.name}: title required`);
+    }
+  }
+  req(Array.isArray(m.serviceScopes), "serviceScopes must be an array");
+  const tools = m.mcp?.tools;
+  req(Array.isArray(tools), "mcp.tools must be an array");
+  const seen = /* @__PURE__ */ new Set();
+  for (const t of tools ?? []) {
+    req(typeof t.name === "string" && TOOL.test(t.name), `mcp.tools: bad name "${t.name}"`);
+    req(!seen.has(t.name), `mcp.tools: duplicate "${t.name}"`);
+    seen.add(t.name);
+    req(typeof t.readOnly === "boolean", `mcp.tools.${t.name}: readOnly must be true/false`);
+    const eps = Object.keys(t.requires ?? {});
+    req(eps.length > 0, `mcp.tools.${t.name}: requires must name at least one entry point`);
+    for (const ep of eps) {
+      req(ENTRY_POINTS.includes(ep), `mcp.tools.${t.name}.requires: unknown entry point "${ep}"`);
+      req(Array.isArray(t.requires[ep]), `mcp.tools.${t.name}.requires.${ep} must be an array`);
+    }
+  }
+  return problems;
+}
+var same = (a, b) => JSON.stringify([...a ?? []].sort()) === JSON.stringify([...b ?? []].sort());
+function diffToolsAgainstManifest(codeTools, manifest) {
+  const problems = [];
+  const declared = new Map((manifest.mcp?.tools ?? []).map((t) => [t.name, t]));
+  for (const t of codeTools) {
+    const d = declared.get(t.name);
+    if (!d) {
+      problems.push(`tool "${t.name}" is in code but not declared in blu.module.json`);
+      continue;
+    }
+    declared.delete(t.name);
+    const readOnly = t.annotations?.readOnlyHint === true;
+    if (readOnly !== d.readOnly) problems.push(`tool "${t.name}": readOnly is ${readOnly} in code, ${d.readOnly} in manifest`);
+    const eps = /* @__PURE__ */ new Set([...Object.keys(t.policy ?? {}), ...Object.keys(d.requires ?? {})]);
+    for (const ep of eps) {
+      if (!same(t.policy?.[ep], d.requires?.[ep])) {
+        problems.push(`tool "${t.name}": ${ep} requires [${t.policy?.[ep] ?? "\u2014"}] in code, [${d.requires?.[ep] ?? "\u2014"}] in manifest`);
+      }
+    }
+  }
+  for (const name of declared.keys()) problems.push(`tool "${name}" is declared in blu.module.json but not in code`);
+  return problems;
+}
+function buildRoutePath(route, params = {}) {
+  let ok = true;
+  const path = route.path.replace(/:([a-zA-Z][a-zA-Z0-9]*)/g, (_, name) => {
+    const v = params[name];
+    if (v === void 0 || v === null || v === "") ok = false;
+    return encodeURIComponent(String(v ?? ""));
+  });
+  return ok ? path : null;
+}
+
+// src/server/platform.js
+var REGISTRY_URL = "https://registry.blu-ce.horizonmedia.com";
+var STAGES2 = ["dev", "staging", "prod"];
+var prefix = (stage) => {
+  if (!STAGES2.includes(stage)) throw new Error(`Unknown Blu environment "${stage}" (expected ${STAGES2.join(", ")})`);
+  return stage === "prod" ? "" : `${stage}.`;
+};
+var bluShellOrigins = (stage) => [`https://${prefix(stage)}blu-ce.horizonmedia.com`];
+var bluIssuer = (stage) => `https://api.${prefix(stage)}blu-ce.horizonmedia.com`;
+
+export {
+  isLocalUrl,
+  validateModuleManifest,
+  diffToolsAgainstManifest,
+  buildRoutePath,
+  REGISTRY_URL,
+  bluShellOrigins,
+  bluIssuer
+};