trellis 3.2.3 → 3.2.4

package/dist/chunk-WXAURJUD.js

@@ -0,0 +1,1948 @@
+import {
+  McpServer,
+  StreamableMcpGateway,
+  corsEnabledForConfig,
+  corsPreflightResponse,
+  discoveryMcpGateway,
+  mcpServiceDocument,
+  oauthAuthorizationServerMetadata,
+  oauthProtectedResourceMetadata,
+  withCors
+} from "./chunk-W5PADCDF.js";
+import {
+  McpRateLimitError,
+  UsageMeter,
+  assertMcpBudget,
+  collectionSlugFromMetaId,
+  resolveCollectionId,
+  resolveMcpTenantId,
+  resolveUsageTenantId,
+  verifyAdminKey,
+  writeContext
+} from "./chunk-CMSFD6OV.js";
+import {
+  DEFAULT_TENANT
+} from "./chunk-GCQF75T4.js";
+import {
+  rel
+} from "./chunk-44FFQKQX.js";
+import {
+  entityRecordToPlain,
+  hydrateBindings,
+  resolveRelations
+} from "./chunk-JUEMDWLU.js";
+import {
+  parseSimple
+} from "./chunk-X5FLTRUB.js";
+
+// src/server/server.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+// src/server/auth.ts
+var ANONYMOUS = {
+  userId: null,
+  tenantId: null,
+  roles: [],
+  claims: {},
+  authenticated: false
+};
+function base64UrlEncode(input) {
+  return btoa(String.fromCharCode(...input)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlDecode(input) {
+  const padded = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padLen = (4 - padded.length % 4) % 4;
+  const base64 = padded + "=".repeat(padLen);
+  const binary = atob(base64);
+  return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+}
+async function hmacKey(secret) {
+  return crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign", "verify"]
+  );
+}
+async function signJwt(payload, secret, expiresInSeconds = 86400) {
+  const header = { alg: "HS256", typ: "JWT" };
+  const now = Math.floor(Date.now() / 1e3);
+  const claims = { iat: now, exp: now + expiresInSeconds, ...payload };
+  const enc = new TextEncoder();
+  const headerB64 = base64UrlEncode(enc.encode(JSON.stringify(header)));
+  const payloadB64 = base64UrlEncode(enc.encode(JSON.stringify(claims)));
+  const signing = `${headerB64}.${payloadB64}`;
+  const key = await hmacKey(secret);
+  const sig = await crypto.subtle.sign("HMAC", key, enc.encode(signing));
+  const sigB64 = base64UrlEncode(new Uint8Array(sig));
+  return `${signing}.${sigB64}`;
+}
+async function verifyJwt(token, secret) {
+  const parts = token.split(".");
+  if (parts.length !== 3) return null;
+  const [headerB64, payloadB64, sigB64] = parts;
+  const enc = new TextEncoder();
+  const signing = `${headerB64}.${payloadB64}`;
+  try {
+    const key = await hmacKey(secret);
+    const sigRaw = base64UrlDecode(sigB64);
+    const sigBuf = sigRaw.buffer.slice(
+      sigRaw.byteOffset,
+      sigRaw.byteOffset + sigRaw.byteLength
+    );
+    const valid = await crypto.subtle.verify(
+      "HMAC",
+      key,
+      sigBuf,
+      enc.encode(signing)
+    );
+    if (!valid) return null;
+    const claims = JSON.parse(
+      new TextDecoder().decode(base64UrlDecode(payloadB64))
+    );
+    const now = Math.floor(Date.now() / 1e3);
+    if (typeof claims.exp === "number" && claims.exp < now) return null;
+    return claims;
+  } catch {
+    return null;
+  }
+}
+async function resolveAuth(authHeader, config) {
+  if (!authHeader) {
+    return config.allowPublic === false ? { ...ANONYMOUS, authenticated: false } : ANONYMOUS;
+  }
+  const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
+  if (config.apiKey && token === config.apiKey) {
+    return {
+      userId: "service",
+      tenantId: null,
+      roles: ["admin"],
+      claims: { sub: "service" },
+      authenticated: true
+    };
+  }
+  if (config.jwtSecret) {
+    const claims = await verifyJwt(token, config.jwtSecret);
+    if (claims) {
+      return {
+        userId: claims.sub ?? null,
+        tenantId: claims.tenantId ?? null,
+        roles: Array.isArray(claims.roles) ? claims.roles : typeof claims.role === "string" ? [claims.role] : [],
+        claims,
+        authenticated: true
+      };
+    }
+  }
+  return ANONYMOUS;
+}
+var GOOGLE_PROVIDER = {
+  name: "google",
+  authUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+  tokenUrl: "https://oauth2.googleapis.com/token",
+  userInfoUrl: "https://www.googleapis.com/oauth2/v3/userinfo",
+  scopes: ["openid", "email", "profile"]
+};
+var GITHUB_PROVIDER = {
+  name: "github",
+  authUrl: "https://github.com/login/oauth/authorize",
+  tokenUrl: "https://github.com/login/oauth/access_token",
+  userInfoUrl: "https://api.github.com/user",
+  scopes: ["read:user", "user:email"]
+};
+function buildOAuthUrl(provider, redirectUri, state) {
+  const params = new URLSearchParams({
+    client_id: provider.clientId,
+    redirect_uri: redirectUri,
+    response_type: "code",
+    scope: provider.scopes.join(" "),
+    state
+  });
+  return `${provider.authUrl}?${params}`;
+}
+async function exchangeOAuthCode(provider, code, redirectUri) {
+  const tokenRes = await fetch(provider.tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    },
+    body: new URLSearchParams({
+      client_id: provider.clientId,
+      client_secret: provider.clientSecret,
+      code,
+      redirect_uri: redirectUri,
+      grant_type: "authorization_code"
+    })
+  });
+  if (!tokenRes.ok) {
+    throw new Error(`OAuth token exchange failed: ${tokenRes.status}`);
+  }
+  const tokenData = await tokenRes.json();
+  const accessToken = tokenData.access_token;
+  const userRes = await fetch(provider.userInfoUrl, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      Accept: "application/json"
+    }
+  });
+  if (!userRes.ok) {
+    throw new Error(`OAuth user info fetch failed: ${userRes.status}`);
+  }
+  const user = await userRes.json();
+  return {
+    id: String(user.id ?? user.sub ?? ""),
+    email: String(user.email ?? ""),
+    name: String(user.name ?? user.login ?? ""),
+    avatarUrl: user.picture ?? user.avatar_url ?? void 0
+  };
+}
+
+// src/server/permissions.ts
+var PermissionRegistry = class {
+  rules = /* @__PURE__ */ new Map();
+  defaultRule = "authenticated";
+  /**
+   * Register permissions for an entity type.
+   */
+  register(entityType, permissions) {
+    this.rules.set(entityType, permissions);
+  }
+  /**
+   * Set the fallback rule used when an entity type has no declared permissions.
+   */
+  setDefault(rule) {
+    this.defaultRule = rule;
+  }
+  /**
+   * Get the permission rule for a specific operation on an entity type.
+   * Falls back to the default rule if not declared.
+   */
+  getRule(entityType, op) {
+    const def = this.rules.get(entityType);
+    return def?.[op] ?? this.defaultRule;
+  }
+  /**
+   * Check whether an auth context is allowed to perform an operation.
+   */
+  check(auth, entityType, op, entity = null) {
+    const rule = this.getRule(entityType, op);
+    return evaluateRule(rule, auth, entity);
+  }
+  /**
+   * Assert access — throws a PermissionError if denied.
+   */
+  assert(auth, entityType, op, entity = null) {
+    if (!this.check(auth, entityType, op, entity)) {
+      throw new PermissionError(auth, entityType, op);
+    }
+  }
+};
+function evaluateRule(rule, auth, entity) {
+  if (rule === "public") {
+    return true;
+  }
+  if (rule === "authenticated") {
+    return auth.authenticated;
+  }
+  if (rule === "own") {
+    if (!auth.authenticated || !auth.userId) return false;
+    const ownerFact = entity?.facts.find(
+      (f) => f.a === "ownerId" || f.a === "createdBy"
+    );
+    return ownerFact?.v === auth.userId;
+  }
+  if (typeof rule === "object") {
+    if ("role" in rule) {
+      return auth.roles.includes(rule.role);
+    }
+    if ("roles" in rule) {
+      return rule.roles.some((r) => auth.roles.includes(r));
+    }
+    if ("fn" in rule) {
+      try {
+        return rule.fn(auth, entity);
+      } catch {
+        return false;
+      }
+    }
+  }
+  return false;
+}
+var PermissionError = class extends Error {
+  constructor(auth, entityType, op) {
+    const who = auth.authenticated ? `user:${auth.userId}` : "anonymous";
+    super(`Permission denied: ${who} cannot ${op} ${entityType}`);
+    this.auth = auth;
+    this.entityType = entityType;
+    this.op = op;
+    this.name = "PermissionError";
+  }
+  toResponse() {
+    return {
+      error: "Forbidden",
+      message: this.message,
+      code: 403
+    };
+  }
+};
+var PUBLIC_READ = {
+  read: "public",
+  create: "authenticated",
+  update: "authenticated",
+  delete: "authenticated"
+};
+var FULLY_PUBLIC = {
+  read: "public",
+  create: "public",
+  update: "public",
+  delete: "public"
+};
+var OWNER_ONLY = {
+  read: "own",
+  create: "authenticated",
+  update: "own",
+  delete: "own"
+};
+var ADMIN_ONLY = {
+  read: { role: "admin" },
+  create: { role: "admin" },
+  update: { role: "admin" },
+  delete: { role: "admin" }
+};
+
+// src/schema/kernel-resolve.ts
+import { z } from "zod";
+function ontologyTypeName(id) {
+  return id.includes(":") ? id.split(":").pop() : id;
+}
+function findOntologyByTypeName(kernel, typeName) {
+  return kernel.listOntologies().find((s) => {
+    const short = ontologyTypeName(s["@id"]);
+    return short === typeName || short.toLowerCase() === typeName.toLowerCase() || s.label === typeName;
+  });
+}
+function schemaHandleFromOntology(def, typeName) {
+  const name = typeName ?? ontologyTypeName(def["@id"]);
+  const relations = {};
+  for (const field of def.fields) {
+    if (field.valueType === "relation" && field.relation?.targetSchema) {
+      const target = ontologyTypeName(field.relation.targetSchema);
+      relations[field.name] = rel(
+        target,
+        field.relation.cardinality ?? "one"
+      );
+    }
+  }
+  return {
+    type: name,
+    zod: z.object({}),
+    relations,
+    computed: {},
+    definition: def,
+    toOntologySchema: () => {
+      throw new Error("schemaHandleFromOntology: legacy adapter not available");
+    }
+  };
+}
+function createSchemaLookup(kernel) {
+  const cache = /* @__PURE__ */ new Map();
+  return (typeName) => {
+    if (cache.has(typeName)) return cache.get(typeName);
+    const def = findOntologyByTypeName(kernel, typeName);
+    if (!def) return null;
+    const handle = schemaHandleFromOntology(def, typeName);
+    cache.set(typeName, handle);
+    return handle;
+  };
+}
+function createKernelResolveClient(kernel) {
+  return {
+    read: async (id) => {
+      const entity = kernel.getEntity(id);
+      return entity ? entityRecordToPlain(entity) : null;
+    },
+    query: async (q) => {
+      const parsed = parseSimple(q);
+      const qr = await kernel.query(parsed);
+      return {
+        bindings: hydrateBindings(
+          kernel,
+          qr.bindings
+        ),
+        executionTime: qr.executionTime
+      };
+    }
+  };
+}
+async function hydrateAndResolve(kernel, bindings, entityType, resolve) {
+  let entities = hydrateBindings(kernel, bindings);
+  if (!entityType || !resolve || Object.keys(resolve).length === 0) {
+    return entities;
+  }
+  const def = findOntologyByTypeName(kernel, entityType);
+  if (!def) return entities;
+  const schema = schemaHandleFromOntology(def, entityType);
+  const client = createKernelResolveClient(kernel);
+  const lookup = createSchemaLookup(kernel);
+  return resolveRelations(client, schema, entities, resolve, {
+    schemaLookup: lookup
+  });
+}
+
+// src/server/realtime.ts
+var SubscriptionManager = class {
+  clients = /* @__PURE__ */ new Map();
+  pool;
+  permissions;
+  meter;
+  constructor(pool, permissions = null, meter = null) {
+    this.pool = pool;
+    this.permissions = permissions;
+    this.meter = meter;
+  }
+  // -------------------------------------------------------------------------
+  // Client lifecycle
+  // -------------------------------------------------------------------------
+  addClient(clientId, ws, auth, tenantId) {
+    this.clients.set(clientId, {
+      id: clientId,
+      ws,
+      subscriptions: /* @__PURE__ */ new Map(),
+      auth,
+      tenantId
+    });
+  }
+  removeClient(clientId) {
+    this.clients.delete(clientId);
+  }
+  // -------------------------------------------------------------------------
+  // Message handling
+  // -------------------------------------------------------------------------
+  async handleMessage(clientId, raw) {
+    const client = this.clients.get(clientId);
+    if (!client) return;
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      this._send(client, { type: "error", id: "", message: "Invalid JSON" });
+      return;
+    }
+    if (msg.type === "ping") {
+      this._send(client, { type: "pong" });
+      return;
+    }
+    if (msg.type === "subscribe") {
+      await this._handleSubscribe(client, msg.id, msg.query, {
+        tenantId: msg.tenantId,
+        entityType: msg.entityType,
+        resolve: msg.resolve
+      });
+      return;
+    }
+    if (msg.type === "unsubscribe") {
+      client.subscriptions.delete(msg.id);
+      return;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Notify — called after every mutation
+  // -------------------------------------------------------------------------
+  /**
+   * Re-evaluate all subscriptions for a given tenant and push diffs.
+   * Called after every write op lands.
+   */
+  async notify(tenantId) {
+    const tid = tenantId ?? null;
+    const dead = [];
+    for (const [clientId, client] of this.clients) {
+      if (client.ws.readyState !== 1) {
+        dead.push(clientId);
+        continue;
+      }
+      for (const [subId, sub] of client.subscriptions) {
+        if (sub.tenantId !== tid) continue;
+        await this._pushUpdate(client, sub);
+      }
+    }
+    for (const id of dead) this.clients.delete(id);
+  }
+  get clientCount() {
+    return this.clients.size;
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  async _handleSubscribe(client, subId, queryStr, opts = {}) {
+    const tid = opts.tenantId ?? client.tenantId ?? null;
+    let parsedQuery;
+    try {
+      parsedQuery = parseSimple(queryStr);
+    } catch (err) {
+      this._send(client, {
+        type: "error",
+        id: subId,
+        message: `Invalid query: ${err instanceof Error ? err.message : String(err)}`
+      });
+      return;
+    }
+    const kernel = await this.pool.preload(tid);
+    let result;
+    try {
+      const qr = await kernel.query(parsedQuery);
+      this._recordGraphIo(tid);
+      result = await hydrateAndResolve(
+        kernel,
+        qr.bindings,
+        opts.entityType,
+        opts.resolve
+      );
+    } catch (err) {
+      this._send(client, {
+        type: "error",
+        id: subId,
+        message: `Query failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+      return;
+    }
+    const resolved = Boolean(opts.entityType) && Boolean(opts.resolve && Object.keys(opts.resolve).length > 0);
+    const sub = {
+      id: subId,
+      query: queryStr,
+      tenantId: tid,
+      auth: client.auth,
+      lastResult: result,
+      entityType: opts.entityType,
+      resolve: opts.resolve
+    };
+    client.subscriptions.set(subId, sub);
+    if (tid !== null && client.tenantId !== tid) {
+      client.tenantId = tid;
+    }
+    this._send(client, { type: "subscribed", id: subId });
+    this._send(client, {
+      type: "data",
+      id: subId,
+      result,
+      diff: { added: result, updated: [], removed: [] },
+      ...resolved ? { resolved: true } : {}
+    });
+  }
+  async _pushUpdate(client, sub) {
+    const kernel = await this.pool.preload(sub.tenantId);
+    let newResult;
+    try {
+      const parsed = parseSimple(sub.query);
+      const qr = await kernel.query(parsed);
+      this._recordGraphIo(sub.tenantId);
+      newResult = await hydrateAndResolve(
+        kernel,
+        qr.bindings,
+        sub.entityType,
+        sub.resolve
+      );
+    } catch {
+      return;
+    }
+    const diff = computeDiff(sub.lastResult, newResult);
+    if (diff.added.length === 0 && diff.updated.length === 0 && diff.removed.length === 0) {
+      return;
+    }
+    sub.lastResult = newResult;
+    const resolved = Boolean(sub.entityType) && Boolean(sub.resolve && Object.keys(sub.resolve).length > 0);
+    this._send(client, {
+      type: "data",
+      id: sub.id,
+      result: newResult,
+      diff,
+      ...resolved ? { resolved: true } : {}
+    });
+  }
+  _recordGraphIo(tenantId) {
+    this.meter?.recordGraphIo(resolveUsageTenantId(tenantId));
+  }
+  _send(client, payload) {
+    const data = JSON.stringify(payload);
+    if (this.meter) {
+      const tid = resolveUsageTenantId(client.tenantId ?? DEFAULT_TENANT);
+      this.meter.recordEgress(tid, new TextEncoder().encode(data).length);
+    }
+    try {
+      client.ws.send(data);
+    } catch {
+    }
+  }
+};
+function entityId(row) {
+  return String(row["?e"] ?? row.id ?? row.e ?? JSON.stringify(row));
+}
+function computeDiff(prev, next) {
+  const prevMap = new Map(prev.map((r) => [entityId(r), r]));
+  const nextMap = new Map(next.map((r) => [entityId(r), r]));
+  const added = [];
+  const updated = [];
+  const removed = [];
+  for (const [id, row] of nextMap) {
+    if (!prevMap.has(id)) {
+      added.push(row);
+    } else if (JSON.stringify(prevMap.get(id)) !== JSON.stringify(row)) {
+      updated.push(row);
+    }
+  }
+  for (const [id, row] of prevMap) {
+    if (!nextMap.has(id)) removed.push(row);
+  }
+  return { added, updated, removed };
+}
+
+// src/mcp/room.ts
+import { z as z2 } from "zod";
+
+// src/mcp/graph-summary.ts
+var SKIP_ATTRS = /* @__PURE__ */ new Set(["@id", "@type", "id", "type"]);
+function buildRoomGraphSummary(kernel, tenantId, opts = {}) {
+  const limit = opts.limit ?? 10;
+  const store = kernel.getStore();
+  let factCount = 0;
+  for (const _ of store.getAllFacts()) factCount++;
+  let linkCount = 0;
+  for (const _ of store.getAllLinks()) linkCount++;
+  const typeCounts = {};
+  const entityIds = /* @__PURE__ */ new Set();
+  for (const fact of store.getAllFacts()) {
+    if (fact.a === "type") {
+      const type = String(fact.v);
+      typeCounts[type] = (typeCounts[type] ?? 0) + 1;
+      entityIds.add(fact.e);
+    }
+  }
+  const entityTypes = Object.entries(typeCounts).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([type, count]) => ({ type, count }));
+  const systemOntologies = [];
+  const userOntologies = [];
+  for (const schema of kernel.listOntologies()) {
+    const shortId = schema["@id"].replace(/^(trellis:schema\/|core:)/, "");
+    if (schema.tier === "user") {
+      userOntologies.push(shortId);
+    } else if (schema.tier !== "core") {
+      systemOntologies.push(shortId);
+    }
+  }
+  const topAttributes = store.getCatalog().filter((c) => !SKIP_ATTRS.has(c.attribute)).sort((a, b) => b.distinctCount - a.distinctCount).slice(0, limit).map((c) => ({
+    attribute: c.attribute,
+    distinctCount: c.distinctCount,
+    cardinality: c.cardinality
+  }));
+  const relations = /* @__PURE__ */ new Set();
+  for (const link of store.getAllLinks()) relations.add(link.a);
+  const recentMutations = kernel.readAllOps().slice(-limit).reverse().map((op) => ({
+    kind: op.kind,
+    agentId: op.agentId,
+    timestamp: op.timestamp,
+    entityId: inferEntityIdFromOp(op)
+  }));
+  return {
+    health: {
+      status: "ok",
+      factCount,
+      linkCount,
+      entityCount: entityIds.size,
+      ops: kernel.readAllOps().length,
+      tenantId
+    },
+    entityTypes,
+    ontologies: {
+      total: kernel.listOntologies().length,
+      system: systemOntologies.slice(0, limit),
+      user: userOntologies.slice(0, limit)
+    },
+    topAttributes,
+    links: { total: linkCount, relations: [...relations].sort().slice(0, limit) },
+    recentMutations
+  };
+}
+function inferEntityIdFromOp(op) {
+  const facts = op.facts ?? op.deleteFacts;
+  if (!facts?.length) return void 0;
+  const typeFact = facts.find((f) => "a" in f && f.a === "type");
+  return typeFact?.e ?? facts[0]?.e;
+}
+
+// src/mcp/room-audit.ts
+function sanitizeInput(params) {
+  const out = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value === "string" && value.length > 2e3) {
+      out[key] = value.slice(0, 2e3) + "\u2026";
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function summarizeText(text2, max = 500) {
+  return text2.length > max ? text2.slice(0, max) + "\u2026" : text2;
+}
+async function recordRoomMcpAudit(kernel, agentId, toolName, params, resultText, wctx, relatedEntities = []) {
+  try {
+    const id = `decision:mcp-${crypto.randomUUID().slice(0, 8)}`;
+    const links = relatedEntities.map((targetEntityId) => ({
+      attribute: "relatedTo",
+      targetEntityId
+    }));
+    await kernel.createEntity(
+      id,
+      "Decision",
+      {
+        title: `MCP ${toolName}`,
+        toolName,
+        input: JSON.stringify(sanitizeInput(params)),
+        outputSummary: summarizeText(resultText),
+        createdBy: agentId,
+        source: "room-mcp"
+      },
+      links.length > 0 ? links : void 0,
+      wctx
+    );
+    return id;
+  } catch {
+    return null;
+  }
+}
+function scheduleRoomMcpAudit(kernelPromise, agentId, toolName, params, resultText, wctx, relatedEntities) {
+  void kernelPromise.then(
+    (kernel) => recordRoomMcpAudit(
+      kernel,
+      agentId,
+      toolName,
+      params,
+      resultText,
+      wctx,
+      relatedEntities
+    )
+  );
+}
+
+// src/mcp/room.ts
+var laneSchema = z2.string().optional().describe(
+  "Draft lane for op attribution (e.g. agent:cursor). Defaults to authenticated user or agent:room-mcp."
+);
+var tenantIdSchema = z2.string().optional().describe(
+  "Tenant id (e.g. embed-design-review). Overrides session default. Use for Playground multi-tenant rooms."
+);
+var roomSchema = z2.string().optional().describe(
+  "Playground ?room= slug \u2014 resolves to tenant embed-{slug} (same as playground.trellis.computer session rooms)."
+);
+function resolveToolTenant(ctx, args) {
+  return resolveMcpTenantId({
+    defaultTenantId: ctx.tenantId,
+    headerTenant: ctx.headerTenant,
+    toolTenantId: args.tenantId,
+    roomSlug: args.room
+  });
+}
+function text(content) {
+  return { content: [{ type: "text", text: content }] };
+}
+function jsonText(data) {
+  return text(JSON.stringify(data, null, 2));
+}
+function toolError(err) {
+  if (err instanceof PermissionError || err instanceof McpRateLimitError) {
+    return text(err.message);
+  }
+  return text(err instanceof Error ? err.message : String(err));
+}
+async function withMcpIo(ctx, tenantId, fn) {
+  assertMcpBudget(ctx.meter, tenantId);
+  const result = await fn();
+  ctx.meter?.recordGraphIo(resolveUsageTenantId(tenantId));
+  return result;
+}
+function auditWrite(kernel, wctx, toolName, params, payload, relatedEntities = []) {
+  const agentId = wctx.agentId ?? "agent:room-mcp";
+  const resultText = typeof payload === "string" ? payload : JSON.stringify(payload);
+  scheduleRoomMcpAudit(
+    Promise.resolve(kernel),
+    agentId,
+    toolName,
+    params,
+    resultText,
+    wctx,
+    relatedEntities
+  );
+}
+function createRoomMcpServer(ctx) {
+  const server = new McpServer({
+    name: "trellis-room",
+    version: "0.2.0"
+  });
+  server.registerTool(
+    "get_graph_summary",
+    {
+      description: "Compact graph overview \u2014 health, entity types, ontologies, top attributes, links, recent ops. Call first.",
+      inputSchema: {
+        limit: z2.number().optional().describe("Max items per section (default: 10)"),
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ limit, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          return jsonText(
+            buildRoomGraphSummary(kernel, effectiveTenant, { limit })
+          );
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "graph_health",
+    {
+      description: "Quick liveness check for the Trellis room graph (ops + entity counts).",
+      inputSchema: {
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const entities = kernel.listEntities();
+          const byType = {};
+          for (const e of entities) {
+            byType[e.type] = (byType[e.type] ?? 0) + 1;
+          }
+          return jsonText({
+            status: "ok",
+            ops: kernel.readAllOps().length,
+            entities: entities.length,
+            byType,
+            tenantId: effectiveTenant
+          });
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "query_graph",
+    {
+      description: "Run an EQL-S query against the room graph.",
+      inputSchema: {
+        query: z2.string().describe("EQL-S query string"),
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ query, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const parsed = parseSimple(query);
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const result = await kernel.query(parsed);
+          const bindings = hydrateBindings(
+            kernel,
+            result.bindings
+          );
+          return jsonText({
+            bindings,
+            executionTime: result.executionTime
+          });
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "get_node",
+    {
+      description: "Read a single entity by ID.",
+      inputSchema: {
+        id: z2.string().describe("Entity ID"),
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ id, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const entity = kernel.getEntity(id);
+          if (!entity) return text(`Not found: ${id}`);
+          ctx.permissions?.assert(ctx.auth, entity.type, "read", entity);
+          return jsonText(entityRecordToPlain(entity));
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "create_node",
+    {
+      description: "Create a new entity in the room graph. Optionally pass links for relations.",
+      inputSchema: {
+        type: z2.string().describe("Entity type name"),
+        id: z2.string().optional().describe("Optional explicit entity ID"),
+        attributes: z2.record(z2.string(), z2.unknown()).optional().describe("Entity attributes"),
+        links: z2.array(
+          z2.object({
+            attribute: z2.string(),
+            targetEntityId: z2.string()
+          })
+        ).optional().describe("Relation links to create with the entity"),
+        lane: laneSchema,
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ type, id, attributes, links, lane, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        ctx.permissions?.assert(ctx.auth, type, "create");
+        const wctx = writeContext(lane, ctx.auth, ctx.headerLane);
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const entityId2 = id ?? `${type.toLowerCase()}:${crypto.randomUUID()}`;
+          const attrs = { ...attributes ?? {} };
+          if (ctx.auth.userId) attrs.createdBy = ctx.auth.userId;
+          if (effectiveTenant) attrs.tenantId = effectiveTenant;
+          attrs.laneId = wctx.agentId;
+          const result = await kernel.createEntity(
+            entityId2,
+            type,
+            attrs,
+            links,
+            wctx
+          );
+          await ctx.subs.notify(effectiveTenant);
+          const payload = {
+            id: entityId2,
+            op: result.op.hash,
+            lane: wctx.agentId,
+            tenantId: effectiveTenant
+          };
+          auditWrite(
+            kernel,
+            wctx,
+            "create_node",
+            { type, id, attributes, links, lane, tenantId, room },
+            payload,
+            [entityId2]
+          );
+          return jsonText(payload);
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "update_node",
+    {
+      description: "Partial update of an entity attributes.",
+      inputSchema: {
+        id: z2.string().describe("Entity ID"),
+        attributes: z2.record(z2.string(), z2.unknown()).describe("Attributes to merge"),
+        lane: laneSchema,
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ id, attributes, lane, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        const wctx = writeContext(lane, ctx.auth, ctx.headerLane);
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const entity = kernel.getEntity(id);
+          if (!entity) return text(`Not found: ${id}`);
+          ctx.permissions?.assert(ctx.auth, entity.type, "update", entity);
+          await kernel.updateEntity(id, attributes, wctx);
+          await ctx.subs.notify(effectiveTenant);
+          const payload = {
+            id,
+            updated: true,
+            lane: wctx.agentId,
+            tenantId: effectiveTenant
+          };
+          auditWrite(
+            kernel,
+            wctx,
+            "update_node",
+            { id, attributes, lane, tenantId, room },
+            payload,
+            [id]
+          );
+          return jsonText(payload);
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "delete_node",
+    {
+      description: "Delete an entity by ID.",
+      inputSchema: {
+        id: z2.string().describe("Entity ID"),
+        lane: laneSchema,
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ id, lane, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        const wctx = writeContext(lane, ctx.auth, ctx.headerLane);
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const entity = kernel.getEntity(id);
+          if (!entity) return text(`Not found: ${id}`);
+          ctx.permissions?.assert(ctx.auth, entity.type, "delete", entity);
+          await kernel.deleteEntity(id, wctx);
+          await ctx.subs.notify(effectiveTenant);
+          const payload = {
+            id,
+            deleted: true,
+            lane: wctx.agentId,
+            tenantId: effectiveTenant
+          };
+          auditWrite(
+            kernel,
+            wctx,
+            "delete_node",
+            { id, lane, tenantId, room },
+            payload,
+            [id]
+          );
+          return jsonText(payload);
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "create_collection_record",
+    {
+      description: "Create a Playground CollectionRecord row (shows in Collections UI). Sets collectionId to collectionMeta:<slug> so recordBelongsToCollection matches. Optionally ensureCollection to create CollectionMeta when the collection is missing.",
+      inputSchema: {
+        collectionSlug: z2.string().optional().describe("Collection slug (e.g. people, ideas). Required unless collectionId is set."),
+        collectionId: z2.string().optional().describe("Explicit collection id (e.g. collectionMeta:people). Overrides slug."),
+        title: z2.string().min(1).describe("Record title shown in the collection"),
+        body: z2.string().optional().describe("Optional record body / notes"),
+        sortOrder: z2.number().int().optional().describe("Row sort order within the collection"),
+        attributes: z2.record(z2.string(), z2.unknown()).optional().describe("Extra typed fields (status, tags, etc.) merged into the record"),
+        ensureCollection: z2.boolean().optional().describe(
+          "When true, create CollectionMeta with stable id collectionMeta:<slug> if missing."
+        ),
+        collectionTitle: z2.string().optional().describe("Title for CollectionMeta when ensureCollection creates it"),
+        lane: laneSchema,
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({
+      collectionSlug,
+      collectionId,
+      title,
+      body,
+      sortOrder,
+      attributes,
+      ensureCollection,
+      collectionTitle,
+      lane,
+      tenantId,
+      room
+    }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        ctx.permissions?.assert(ctx.auth, "CollectionRecord", "create");
+        const wctx = writeContext(lane, ctx.auth, ctx.headerLane);
+        const resolvedCollectionId = resolveCollectionId({
+          collectionSlug,
+          collectionId
+        });
+        const slug = collectionSlug?.trim() || collectionSlugFromMetaId(resolvedCollectionId) || resolvedCollectionId;
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          let collectionCreated = false;
+          if (ensureCollection) {
+            const existingMeta = kernel.getEntity(resolvedCollectionId);
+            if (!existingMeta) {
+              ctx.permissions?.assert(ctx.auth, "CollectionMeta", "create");
+              const metaAttrs = {
+                title: collectionTitle?.trim() || slug,
+                slug,
+                sortOrder: 0
+              };
+              if (ctx.auth.userId) metaAttrs.createdBy = ctx.auth.userId;
+              if (effectiveTenant) metaAttrs.tenantId = effectiveTenant;
+              metaAttrs.laneId = wctx.agentId;
+              await kernel.createEntity(
+                resolvedCollectionId,
+                "CollectionMeta",
+                metaAttrs,
+                void 0,
+                wctx
+              );
+              collectionCreated = true;
+            }
+          }
+          const recordId = `collectionRecord:${crypto.randomUUID()}`;
+          const recordAttrs = {
+            ...attributes ?? {},
+            collectionId: resolvedCollectionId,
+            title
+          };
+          if (body !== void 0) recordAttrs.body = body;
+          if (sortOrder !== void 0) recordAttrs.sortOrder = sortOrder;
+          if (ctx.auth.userId) recordAttrs.createdBy = ctx.auth.userId;
+          if (effectiveTenant) recordAttrs.tenantId = effectiveTenant;
+          recordAttrs.laneId = wctx.agentId;
+          const result = await kernel.createEntity(
+            recordId,
+            "CollectionRecord",
+            recordAttrs,
+            void 0,
+            wctx
+          );
+          await ctx.subs.notify(effectiveTenant);
+          const payload = {
+            id: recordId,
+            collectionId: resolvedCollectionId,
+            collectionCreated,
+            op: result.op.hash,
+            lane: wctx.agentId,
+            tenantId: effectiveTenant
+          };
+          auditWrite(
+            kernel,
+            wctx,
+            "create_collection_record",
+            {
+              collectionSlug,
+              collectionId,
+              title,
+              body,
+              sortOrder,
+              attributes,
+              ensureCollection,
+              collectionTitle,
+              lane,
+              tenantId,
+              room
+            },
+            payload,
+            collectionCreated ? [recordId, resolvedCollectionId] : [recordId]
+          );
+          return jsonText(payload);
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "link_nodes",
+    {
+      description: "Create a semantic link between two entities (assignedTo, belongsTo, references, dependsOn, \u2026).",
+      inputSchema: {
+        e1: z2.string().describe("Source entity ID"),
+        relation: z2.string().describe("Relation attribute name"),
+        e2: z2.string().describe("Target entity ID"),
+        lane: laneSchema,
+        tenantId: tenantIdSchema,
+        room: roomSchema
+      }
+    },
+    async ({ e1, relation, e2, lane, tenantId, room }) => {
+      try {
+        const effectiveTenant = resolveToolTenant(ctx, { tenantId, room });
+        const wctx = writeContext(lane, ctx.auth, ctx.headerLane);
+        return await withMcpIo(ctx, effectiveTenant, async () => {
+          const kernel = await ctx.pool.preload(effectiveTenant);
+          const source = kernel.getEntity(e1);
+          const target = kernel.getEntity(e2);
+          if (!source) return text(`Not found: ${e1}`);
+          if (!target) return text(`Not found: ${e2}`);
+          ctx.permissions?.assert(ctx.auth, source.type, "update", source);
+          const result = await kernel.addLink(e1, relation, e2, wctx);
+          await ctx.subs.notify(effectiveTenant);
+          const payload = {
+            e1,
+            relation,
+            e2,
+            op: result.op.hash,
+            lane: wctx.agentId,
+            tenantId: effectiveTenant
+          };
+          auditWrite(
+            kernel,
+            wctx,
+            "link_nodes",
+            { e1, relation, e2, lane, tenantId, room },
+            payload,
+            [e1, e2]
+          );
+          return jsonText(payload);
+        });
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  return server;
+}
+
+// src/server/mcp-gateway.ts
+var RoomMcpGateway = class {
+  gateway = new StreamableMcpGateway();
+  async handle(req, ctx, auth, tenantId) {
+    const roomCtx = {
+      pool: ctx.pool,
+      permissions: ctx.permissions,
+      subs: ctx.subs,
+      meter: ctx.meter,
+      auth,
+      tenantId,
+      headerLane: req.headers.get("x-trellis-lane"),
+      headerTenant: req.headers.get("x-trellis-tenant")
+    };
+    return this.gateway.handle(req, () => createRoomMcpServer(roomCtx));
+  }
+  async close() {
+    await this.gateway.close();
+  }
+};
+var roomMcpGateway = new RoomMcpGateway();
+
+// src/server/server.ts
+var __moduleDir = import.meta.dir ?? dirname(fileURLToPath(import.meta.url));
+async function startServer(opts) {
+  return startServerNode(opts);
+}
+var startServerCrossRuntime = startServer;
+function buildServerContext(opts) {
+  const { pool, permissions, config } = opts;
+  const port = opts.port ?? config.port ?? 3e3;
+  const authConfig = {
+    jwtSecret: config.jwtSecret,
+    apiKey: config.apiKey,
+    allowPublic: true
+  };
+  const meter = new UsageMeter();
+  const subs = new SubscriptionManager(pool, permissions ?? null, meter);
+  const enableCors = corsEnabledForConfig(config.apiKey);
+  const handleHttpInner = async (req) => {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    const auth = await resolveAuth(
+      req.headers.get("authorization"),
+      authConfig
+    );
+    const tenantId = auth.tenantId ?? url.searchParams.get("tenantId") ?? null;
+    try {
+      return await route(req, url, path, auth, tenantId, {
+        pool,
+        permissions: permissions ?? null,
+        subs,
+        meter,
+        authConfig,
+        config,
+        oauthProviders: opts.oauthProviders ?? {}
+      });
+    } catch (err) {
+      if (err instanceof PermissionError) {
+        return json(err.toResponse(), 403);
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      if (process.env.TRELLIS_DEBUG) {
+        console.error(
+          `[trellis] ${req.method} ${path} \u2192 500:`,
+          msg
+        );
+      }
+      return json(
+        {
+          error: "Internal Server Error",
+          message: msg,
+          method: req.method,
+          path
+        },
+        500
+      );
+    }
+  };
+  const handleHttp = async (req) => {
+    if (enableCors && req.method === "OPTIONS") {
+      return corsPreflightResponse(req);
+    }
+    const res = await handleHttpInner(req);
+    return enableCors ? withCors(req, res) : res;
+  };
+  return { port, authConfig, subs, handleHttp };
+}
+async function startServerNode(opts) {
+  const { port, subs, handleHttp } = buildServerContext(opts);
+  const { startNodeServer } = await import("./server/node-adapter.js");
+  return startNodeServer({
+    port,
+    fetch: handleHttp,
+    attachPresenceRelay: opts.presenceRelay,
+    websocket: {
+      open(ws) {
+        const id = crypto.randomUUID();
+        ws.__clientId = id;
+        subs.addClient(
+          id,
+          ws,
+          {
+            userId: null,
+            tenantId: null,
+            roles: [],
+            claims: {},
+            authenticated: false
+          },
+          null
+        );
+      },
+      async message(ws, raw) {
+        const id = ws.__clientId;
+        await subs.handleMessage(
+          id,
+          typeof raw === "string" ? raw : raw.toString()
+        );
+      },
+      close(ws) {
+        const id = ws.__clientId;
+        subs.removeClient(id);
+      }
+    }
+  });
+}
+function recordGraphIo(ctx, tenantId) {
+  ctx.meter.recordGraphIo(resolveUsageTenantId(tenantId));
+}
+async function route(req, url, path, auth, tenantId, ctx) {
+  const method = req.method.toUpperCase();
+  if (method === "GET" && path === "/__trellis/inspector.js") {
+    const candidates = [
+      join(__moduleDir, "db", "inspector.js"),
+      // chunk lives in dist/, inspector in dist/db/
+      join(__moduleDir, "inspector.js")
+      // chunk lives in dist/db/, inspector alongside
+    ];
+    for (const p of candidates) {
+      if (existsSync(p)) {
+        return new Response(readFileSync(p, "utf-8"), {
+          headers: { "Content-Type": "application/javascript; charset=utf-8" }
+        });
+      }
+    }
+    return new Response(
+      "/* Trellis DB Inspector: run `bun run build:inspector` first */",
+      {
+        headers: { "Content-Type": "application/javascript" }
+      }
+    );
+  }
+  if (method === "GET" && path === "/__trellis/trellis.css") {
+    const candidates = [
+      join(__moduleDir, "db", "trellis.css"),
+      join(__moduleDir, "trellis.css")
+    ];
+    for (const p of candidates) {
+      if (existsSync(p)) {
+        return new Response(readFileSync(p, "utf-8"), {
+          headers: { "Content-Type": "text/css; charset=utf-8" }
+        });
+      }
+    }
+    return new Response("/* Trellis CSS not found */", {
+      headers: { "Content-Type": "text/css" }
+    });
+  }
+  if (method === "GET" && (path === "/" || path === "/inspector")) {
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Trellis DB Inspector</title>
+  <link rel="stylesheet" href="/__trellis/trellis.css">
+</head>
+<body>
+  <script src="/__trellis/inspector.js"></script>
+</body>
+</html>`;
+    return new Response(html, {
+      headers: { "Content-Type": "text/html; charset=utf-8" }
+    });
+  }
+  if (path === "/mcp" || path === "/mcp/" || path === "/trellis/mcp" || path === "/trellis/mcp/") {
+    return roomMcpGateway.handle(req, ctx, auth, tenantId);
+  }
+  if (path === "/gateway/mcp" || path === "/gateway/mcp/") {
+    return discoveryMcpGateway.handle(req, {
+      configDir: ".",
+      origin: url.origin
+    });
+  }
+  if (method === "GET" && path === "/.well-known/oauth-protected-resource") {
+    return json(oauthProtectedResourceMetadata(url.origin));
+  }
+  if (method === "GET" && path === "/.well-known/oauth-authorization-server") {
+    return json(oauthAuthorizationServerMetadata(url.origin));
+  }
+  if (method === "GET" && path === "/.well-known/trellis-mcp") {
+    return json(mcpServiceDocument(url.origin, ctx.authConfig));
+  }
+  if (method === "GET" && path === "/health") {
+    const kernel = await ctx.pool.preload(tenantId);
+    const ops = kernel.readAllOps().length;
+    return json({
+      status: "ok",
+      ops,
+      tenants: ctx.pool.activeTenants().length,
+      mcp: "/mcp",
+      mcpSprites: "/trellis/mcp",
+      mcpGateway: "/gateway/mcp",
+      oauth: {
+        protectedResource: "/.well-known/oauth-protected-resource",
+        authorizationServer: "/.well-known/oauth-authorization-server"
+      }
+    });
+  }
+  if (method === "GET" && path === "/admin/usage") {
+    return handleAdminUsage(req, url, ctx);
+  }
+  if (path === "/entities" || path === "/entities/") {
+    if (method === "POST") return handleCreate(req, auth, tenantId, ctx);
+    if (method === "GET") return handleList(url, auth, tenantId, ctx);
+  }
+  const entityMatch = path.match(/^\/entities\/([^/]+)$/);
+  if (entityMatch) {
+    const id = decodeURIComponent(entityMatch[1]);
+    if (method === "GET") return handleRead(id, auth, tenantId, ctx);
+    if (method === "PUT" || method === "PATCH")
+      return handleUpdate(req, id, auth, tenantId, ctx);
+    if (method === "DELETE") return handleDelete(id, auth, tenantId, ctx);
+  }
+  if (method === "GET" && (path === "/ops" || path === "/ops/")) {
+    return handleListOps(url, tenantId, ctx);
+  }
+  if (method === "POST" && path === "/query") {
+    return handleQuery(req, auth, tenantId, ctx);
+  }
+  if (method === "POST" && (path === "/ontologies" || path === "/ontologies/")) {
+    return handleCreateOntology(req, auth, tenantId, ctx);
+  }
+  const ontologyMatch = path.match(/^\/ontologies\/(.+)$/);
+  if (ontologyMatch && (method === "PATCH" || method === "PUT")) {
+    const id = decodeURIComponent(ontologyMatch[1]);
+    return handleUpdateOntology(req, id, auth, tenantId, ctx);
+  }
+  if (method === "POST" && path === "/upload") {
+    return handleUpload(req, auth, tenantId, ctx);
+  }
+  const fileMatch = path.match(/^\/files\/([^/]+)$/);
+  if (method === "GET" && fileMatch) {
+    return handleFileDownload(fileMatch[1], ctx, tenantId);
+  }
+  if (method === "POST" && path === "/auth/register") {
+    return handleRegister(req, tenantId, ctx);
+  }
+  if (method === "POST" && path === "/auth/login") {
+    return handleLogin(req, tenantId, ctx);
+  }
+  const oauthMatch = path.match(/^\/auth\/oauth\/([^/]+)(\/callback)?$/);
+  if (oauthMatch) {
+    const providerName = oauthMatch[1];
+    const isCallback = !!oauthMatch[2];
+    if (isCallback)
+      return handleOAuthCallback(url, providerName, tenantId, ctx);
+    return handleOAuthRedirect(providerName, url, ctx);
+  }
+  return json({ error: "Not Found" }, 404);
+}
+async function handleCreate(req, auth, tenantId, ctx) {
+  const body = await req.json();
+  if (!body.type) return json({ error: "type is required" }, 400);
+  ctx.permissions?.assert(auth, body.type, "create");
+  const kernel = await ctx.pool.preload(tenantId);
+  const entityId2 = `${body.type.toLowerCase()}:${crypto.randomUUID()}`;
+  const attrs = {
+    ...body.attributes
+  };
+  if (auth.userId) attrs.createdBy = auth.userId;
+  if (auth.tenantId) attrs.tenantId = auth.tenantId;
+  const result = await kernel.createEntity(
+    entityId2,
+    body.type,
+    attrs,
+    body.links
+  );
+  recordGraphIo(ctx, tenantId);
+  await ctx.subs.notify(tenantId);
+  return json({ id: entityId2, op: result.op.hash }, 201);
+}
+async function handleRead(id, auth, tenantId, ctx) {
+  const kernel = await ctx.pool.preload(tenantId);
+  const entity = kernel.getEntity(id);
+  if (!entity) return json({ error: "Not Found" }, 404);
+  ctx.permissions?.assert(auth, entity.type, "read", entity);
+  return json(entityToJson(entity));
+}
+async function handleUpdate(req, id, auth, tenantId, ctx) {
+  const kernel = await ctx.pool.preload(tenantId);
+  const entity = kernel.getEntity(id);
+  if (!entity) return json({ error: "Not Found" }, 404);
+  ctx.permissions?.assert(auth, entity.type, "update", entity);
+  const updates = await req.json();
+  await kernel.updateEntity(id, updates);
+  recordGraphIo(ctx, tenantId);
+  await ctx.subs.notify(tenantId);
+  return json({ id, updated: true });
+}
+async function handleDelete(id, auth, tenantId, ctx) {
+  const kernel = await ctx.pool.preload(tenantId);
+  const entity = kernel.getEntity(id);
+  if (!entity) return json({ error: "Not Found" }, 404);
+  ctx.permissions?.assert(auth, entity.type, "delete", entity);
+  await kernel.deleteEntity(id);
+  recordGraphIo(ctx, tenantId);
+  await ctx.subs.notify(tenantId);
+  return json({ id, deleted: true });
+}
+async function handleListOps(url, tenantId, ctx) {
+  const kind = url.searchParams.get("kind") ?? void 0;
+  const limit = Math.min(parseInt(url.searchParams.get("limit") ?? "100", 10), 500);
+  const offset = parseInt(url.searchParams.get("offset") ?? "0", 10);
+  const kernel = await ctx.pool.preload(tenantId);
+  let ops = kernel.readAllOps();
+  if (kind) {
+    ops = ops.filter((op) => op.kind === kind);
+  }
+  const total = ops.length;
+  const page = ops.slice(offset, offset + limit);
+  return json({
+    data: page.map((op, index) => summarizeKernelOp(op, offset + index)),
+    total,
+    limit,
+    offset
+  });
+}
+function summarizeKernelOp(op, index) {
+  const entityIds = /* @__PURE__ */ new Set();
+  for (const fact of op.facts ?? []) entityIds.add(fact.e);
+  for (const fact of op.deleteFacts ?? []) entityIds.add(fact.e);
+  return {
+    index,
+    hash: op.hash,
+    kind: op.kind,
+    timestamp: op.timestamp,
+    agentId: op.agentId,
+    previousHash: op.previousHash,
+    factCount: op.facts?.length ?? 0,
+    linkCount: op.links?.length ?? 0,
+    deleteFactCount: op.deleteFacts?.length ?? 0,
+    deleteLinkCount: op.deleteLinks?.length ?? 0,
+    entityCount: entityIds.size
+  };
+}
+async function handleList(url, auth, tenantId, ctx) {
+  const type = url.searchParams.get("type") ?? void 0;
+  const limit = parseInt(url.searchParams.get("limit") ?? "100");
+  const offset = parseInt(url.searchParams.get("offset") ?? "0");
+  const kernel = await ctx.pool.preload(tenantId);
+  let entities = kernel.listEntities(type);
+  if (ctx.permissions && type) {
+    entities = entities.filter(
+      (e) => ctx.permissions.check(auth, e.type, "read", e)
+    );
+  }
+  const page = entities.slice(offset, offset + limit);
+  return json({
+    data: page.map(entityToJson),
+    total: entities.length,
+    limit,
+    offset
+  });
+}
+async function handleQuery(req, auth, tenantId, ctx) {
+  const body = await req.json();
+  if (!body.query) return json({ error: "query is required" }, 400);
+  let parsed;
+  try {
+    parsed = parseSimple(body.query);
+  } catch (err) {
+    return json({ error: "Invalid query", message: String(err) }, 400);
+  }
+  const kernel = await ctx.pool.preload(tenantId);
+  const result = await kernel.query(parsed);
+  recordGraphIo(ctx, tenantId);
+  const bindings = hydrateBindings(
+    kernel,
+    result.bindings
+  );
+  return json({
+    bindings,
+    executionTime: result.executionTime
+  });
+}
+async function readJsonObject(req, route2) {
+  const raw = await req.text();
+  if (!raw.trim()) {
+    if (process.env.TRELLIS_DEBUG) {
+      console.warn(`[trellis] ${req.method} ${route2}: empty request body`);
+    }
+    return {
+      ok: false,
+      response: json(
+        {
+          error: "Bad Request",
+          message: "Request body is empty \u2014 client may not have sent JSON (common on iOS HTTP dev)",
+          method: req.method,
+          path: route2,
+          bodyBytes: 0
+        },
+        400
+      )
+    };
+  }
+  try {
+    const data = JSON.parse(raw);
+    return { ok: true, data };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (process.env.TRELLIS_DEBUG) {
+      console.warn(
+        `[trellis] ${req.method} ${route2}: invalid JSON (${raw.length}B):`,
+        msg
+      );
+    }
+    return {
+      ok: false,
+      response: json(
+        {
+          error: "Bad Request",
+          message: `Invalid JSON: ${msg}`,
+          method: req.method,
+          path: route2,
+          bodyBytes: raw.length
+        },
+        400
+      )
+    };
+  }
+}
+async function handleCreateOntology(req, auth, tenantId, ctx) {
+  const parsed = await readJsonObject(req, "/ontologies");
+  if (!parsed.ok) return parsed.response;
+  const schema = parsed.data;
+  if (!schema || !schema["@id"] || !Array.isArray(schema.fields)) {
+    return json(
+      { error: "A SchemaDefinition (with @id and fields) is required" },
+      400
+    );
+  }
+  if ((schema.tier ?? "user") === "core") {
+    return json({ error: "Core ontologies are immutable" }, 403);
+  }
+  const kernel = await ctx.pool.preload(tenantId);
+  const exists = kernel.listOntologies().some((ont) => ont["@id"] === schema["@id"]);
+  if (exists) {
+    return json({ id: schema["@id"], registered: false, existed: true }, 200);
+  }
+  try {
+    kernel.createOntology(schema);
+    recordGraphIo(ctx, tenantId);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("already exists")) {
+      return json({ id: schema["@id"], registered: false, existed: true }, 200);
+    }
+    return json({ error: "Could not register schema", message: msg }, 409);
+  }
+  return json({ id: schema["@id"], registered: true }, 201);
+}
+async function handleUpdateOntology(req, id, auth, tenantId, ctx) {
+  const parsed = await readJsonObject(req, "/ontologies");
+  if (!parsed.ok) return parsed.response;
+  const updates = parsed.data;
+  const kernel = await ctx.pool.preload(tenantId);
+  const existing = kernel.getOntology(id);
+  if (!existing) {
+    return json({ error: `Ontology ${id} not found` }, 404);
+  }
+  if ((existing.tier ?? "user") === "core") {
+    return json({ error: "Core ontologies are immutable" }, 403);
+  }
+  try {
+    kernel.updateOntology(id, updates);
+    recordGraphIo(ctx, tenantId);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return json({ error: "Could not update schema", message: msg }, 400);
+  }
+  const updated = kernel.getOntology(id);
+  return json(updated ?? { id, updated: true });
+}
+async function handleUpload(req, auth, tenantId, ctx) {
+  if (!auth.authenticated && ctx.config.apiKey) {
+    return json({ error: "Unauthorized" }, 401);
+  }
+  const contentType = req.headers.get("content-type") ?? "application/octet-stream";
+  const buffer = new Uint8Array(await req.arrayBuffer());
+  const hashBuf = await crypto.subtle.digest("SHA-256", buffer);
+  const hash = `blob:${Array.from(new Uint8Array(hashBuf)).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+  const kernel = await ctx.pool.preload(tenantId);
+  const backend = kernel.getBackend();
+  if (!backend.hasBlob(hash)) {
+    backend.putBlob(hash, buffer);
+  }
+  return json({ hash, size: buffer.length, contentType }, 201);
+}
+async function handleFileDownload(hash, ctx, tenantId) {
+  const kernel = await ctx.pool.preload(tenantId);
+  const backend = kernel.getBackend();
+  const blob = backend.getBlob(hash);
+  if (!blob) return json({ error: "Not Found" }, 404);
+  const cleanBuf = blob.buffer.slice(
+    blob.byteOffset,
+    blob.byteOffset + blob.byteLength
+  );
+  ctx.meter.recordEgress(resolveUsageTenantId(tenantId), blob.byteLength);
+  return new Response(cleanBuf, {
+    headers: { "Content-Type": "application/octet-stream" }
+  });
+}
+async function handleRegister(req, tenantId, ctx) {
+  if (!ctx.config.jwtSecret) {
+    return json({ error: "Auth not configured (no jwtSecret)" }, 501);
+  }
+  const body = await req.json();
+  if (!body.email || !body.password) {
+    return json({ error: "email and password are required" }, 400);
+  }
+  const kernel = await ctx.pool.preload(tenantId);
+  const existing = kernel.listEntities("User", { email: body.email });
+  if (existing.length > 0) {
+    return json({ error: "Email already registered" }, 409);
+  }
+  const userId = `user:${crypto.randomUUID()}`;
+  const pwHash = await hashPassword(body.password);
+  await kernel.createEntity(userId, "User", {
+    email: body.email,
+    name: body.name ?? "",
+    passwordHash: pwHash,
+    role: "user",
+    ...tenantId ? { tenantId } : {}
+  });
+  const token = await signJwt(
+    { sub: userId, email: body.email, roles: ["user"], tenantId },
+    ctx.config.jwtSecret
+  );
+  return json({ token, userId }, 201);
+}
+async function handleLogin(req, tenantId, ctx) {
+  if (!ctx.config.jwtSecret) {
+    return json({ error: "Auth not configured (no jwtSecret)" }, 501);
+  }
+  const body = await req.json();
+  if (!body.email || !body.password) {
+    return json({ error: "email and password are required" }, 400);
+  }
+  const kernel = await ctx.pool.preload(tenantId);
+  const users = kernel.listEntities("User", { email: body.email });
+  if (users.length === 0) {
+    return json({ error: "Invalid credentials" }, 401);
+  }
+  const user = users[0];
+  const pwHashFact = user.facts.find((f) => f.a === "passwordHash");
+  const roleFact = user.facts.find((f) => f.a === "role");
+  if (!pwHashFact || !await verifyPassword(body.password, String(pwHashFact.v))) {
+    return json({ error: "Invalid credentials" }, 401);
+  }
+  const role = String(roleFact?.v ?? "user");
+  const token = await signJwt(
+    { sub: user.id, email: body.email, roles: [role], tenantId },
+    ctx.config.jwtSecret
+  );
+  return json({ token, userId: user.id });
+}
+function handleOAuthRedirect(providerName, url, ctx) {
+  const provider = ctx.oauthProviders[providerName] ?? getBuiltinProvider(providerName, ctx);
+  if (!provider)
+    return json({ error: `Unknown provider: ${providerName}` }, 400);
+  const redirectUri = `${url.origin}/auth/oauth/${providerName}/callback`;
+  const state = crypto.randomUUID();
+  const authUrl = buildOAuthUrl(provider, redirectUri, state);
+  return Response.redirect(authUrl, 302);
+}
+async function handleOAuthCallback(url, providerName, tenantId, ctx) {
+  if (!ctx.config.jwtSecret) {
+    return json({ error: "Auth not configured (no jwtSecret)" }, 501);
+  }
+  const code = url.searchParams.get("code");
+  if (!code) return json({ error: "Missing code" }, 400);
+  const provider = ctx.oauthProviders[providerName] ?? getBuiltinProvider(providerName, ctx);
+  if (!provider)
+    return json({ error: `Unknown provider: ${providerName}` }, 400);
+  const redirectUri = `${url.origin}/auth/oauth/${providerName}/callback`;
+  let profile;
+  try {
+    profile = await exchangeOAuthCode(provider, code, redirectUri);
+  } catch (err) {
+    return json({ error: "OAuth exchange failed", message: String(err) }, 400);
+  }
+  const kernel = await ctx.pool.preload(tenantId);
+  const oauthId = `oauth:${providerName}:${profile.id}`;
+  let users = kernel.listEntities("User", { oauthId });
+  let userId;
+  if (users.length === 0) {
+    userId = `user:${crypto.randomUUID()}`;
+    await kernel.createEntity(userId, "User", {
+      email: profile.email,
+      name: profile.name,
+      avatarUrl: profile.avatarUrl ?? "",
+      oauthId,
+      oauthProvider: providerName,
+      role: "user",
+      ...tenantId ? { tenantId } : {}
+    });
+  } else {
+    userId = users[0].id;
+  }
+  const token = await signJwt(
+    { sub: userId, email: profile.email, roles: ["user"], tenantId },
+    ctx.config.jwtSecret
+  );
+  return json({ token, userId });
+}
+function getBuiltinProvider(name, ctx) {
+  if (name === "google") {
+    const cid = process.env.GOOGLE_CLIENT_ID;
+    const csec = process.env.GOOGLE_CLIENT_SECRET;
+    if (!cid || !csec) return null;
+    return { ...GOOGLE_PROVIDER, clientId: cid, clientSecret: csec };
+  }
+  if (name === "github") {
+    const cid = process.env.GITHUB_CLIENT_ID;
+    const csec = process.env.GITHUB_CLIENT_SECRET;
+    if (!cid || !csec) return null;
+    return { ...GITHUB_PROVIDER, clientId: cid, clientSecret: csec };
+  }
+  return null;
+}
+async function hashPassword(password) {
+  const salt = crypto.randomUUID().replace(/-/g, "");
+  const enc = new TextEncoder();
+  const keyMat = await crypto.subtle.importKey(
+    "raw",
+    enc.encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits"]
+  );
+  const bits = await crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt: enc.encode(salt),
+      iterations: 1e5,
+      hash: "SHA-256"
+    },
+    keyMat,
+    256
+  );
+  const hash = Array.from(new Uint8Array(bits)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `${salt}:${hash}`;
+}
+async function verifyPassword(password, stored) {
+  const [salt, expectedHash] = stored.split(":");
+  if (!salt || !expectedHash) return false;
+  const enc = new TextEncoder();
+  const keyMat = await crypto.subtle.importKey(
+    "raw",
+    enc.encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits"]
+  );
+  const bits = await crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt: enc.encode(salt),
+      iterations: 1e5,
+      hash: "SHA-256"
+    },
+    keyMat,
+    256
+  );
+  const hash = Array.from(new Uint8Array(bits)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hash === expectedHash;
+}
+function handleAdminUsage(req, url, ctx) {
+  if (!process.env.TURTLEDB_ADMIN_KEY) {
+    return json({ error: "Admin usage not configured" }, 501);
+  }
+  if (!verifyAdminKey(req)) {
+    return json({ error: "Unauthorized" }, 401);
+  }
+  const tenant = url.searchParams.get("tenant");
+  if (!tenant) {
+    return json({ error: "tenant query param is required" }, 400);
+  }
+  const refresh = url.searchParams.get("refresh") === "1";
+  if (refresh) {
+    ctx.meter.sampleStorage(ctx.pool, tenant);
+  }
+  const day = url.searchParams.get("day") ?? void 0;
+  return json(ctx.meter.getUsage(tenant, day));
+}
+function entityToJson(entity) {
+  return entityRecordToPlain(entity);
+}
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+export {
+  ANONYMOUS,
+  signJwt,
+  verifyJwt,
+  resolveAuth,
+  GOOGLE_PROVIDER,
+  GITHUB_PROVIDER,
+  buildOAuthUrl,
+  exchangeOAuthCode,
+  PermissionRegistry,
+  PermissionError,
+  PUBLIC_READ,
+  FULLY_PUBLIC,
+  OWNER_ONLY,
+  ADMIN_ONLY,
+  SubscriptionManager,
+  startServer,
+  startServerCrossRuntime
+};