trellis 3.1.35 → 3.2.2

package/dist/chunk-J2TXUFCZ.js

@@ -0,0 +1,289 @@
+// src/client/sdk.browser.ts
+function isRemote(opts) {
+  return "url" in opts;
+}
+function browserOnlyRemoteError(feature) {
+  return new Error(
+    `${feature} is not available in browser bundles. Use remote mode with \`new TrellisDb({ url })\`, or import \`trellis/client\` in Node.`
+  );
+}
+var TrellisDb = class {
+  opts;
+  _ws = null;
+  /** In-flight connect — concurrent subscribe() shares one socket open. */
+  _wsPromise = null;
+  _subCallbacks = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    if (!isRemote(opts)) {
+      throw browserOnlyRemoteError("TrellisDb local mode");
+    }
+    this.opts = opts;
+  }
+  /**
+   * Browser bundles cannot read `.trellis-db.json`.
+   */
+  static async fromConfig(_dir = ".") {
+    throw browserOnlyRemoteError("TrellisDb.fromConfig()");
+  }
+  // -------------------------------------------------------------------------
+  // CRUD
+  // -------------------------------------------------------------------------
+  /**
+   * Create a new entity.
+   * Returns the generated entity ID.
+   */
+  async create(type, attributes = {}, links) {
+    const res = await this._fetch("POST", "/entities", {
+      type,
+      attributes,
+      links
+    });
+    return res.id;
+  }
+  /**
+   * Read an entity by ID.
+   * Returns null if not found.
+   */
+  async read(id) {
+    try {
+      return await this._fetch(
+        "GET",
+        `/entities/${encodeURIComponent(id)}`
+      );
+    } catch (err) {
+      if (err?.status === 404) return null;
+      throw err;
+    }
+  }
+  /**
+   * Update an entity's attributes (partial update).
+   */
+  async update(id, attributes) {
+    await this._fetch(
+      "PUT",
+      `/entities/${encodeURIComponent(id)}`,
+      attributes
+    );
+  }
+  /**
+   * Delete an entity by ID.
+   */
+  async delete(id) {
+    await this._fetch("DELETE", `/entities/${encodeURIComponent(id)}`);
+  }
+  /**
+   * List entities of a given type.
+   */
+  async list(type, opts = {}) {
+    const params = new URLSearchParams();
+    if (type) params.set("type", type);
+    if (opts.limit) params.set("limit", String(opts.limit));
+    if (opts.offset) params.set("offset", String(opts.offset));
+    const qs = params.toString() ? `?${params}` : "";
+    return await this._fetch("GET", `/entities${qs}`);
+  }
+  // -------------------------------------------------------------------------
+  // Query
+  // -------------------------------------------------------------------------
+  /**
+   * Run an EQL-S query string.
+   */
+  async query(eql) {
+    return await this._fetch("POST", "/query", {
+      query: eql
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Schema registration
+  // -------------------------------------------------------------------------
+  /**
+   * Register a user/system-tier ontology schema with a remote Trellis server.
+   */
+  async registerType(schema) {
+    const def = "@id" in schema ? schema : schema.definition;
+    try {
+      await this._fetch("POST", "/ontologies", def);
+    } catch (err) {
+      if (err instanceof FetchError && err.status === 409) return;
+      throw err;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // File upload
+  // -------------------------------------------------------------------------
+  /**
+   * Upload a file to the blob store.
+   * Returns a content-addressed hash.
+   */
+  async upload(data, contentType = "application/octet-stream") {
+    const raw = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    const cleanBuf = raw.buffer.slice(
+      raw.byteOffset,
+      raw.byteOffset + raw.byteLength
+    );
+    const res = await fetch(`${this.opts.url}/upload`, {
+      method: "POST",
+      headers: {
+        "Content-Type": contentType,
+        ...this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
+      },
+      body: cleanBuf
+    });
+    if (!res.ok) throw new FetchError(res.status, await res.text());
+    return await res.json();
+  }
+  /**
+   * Download a file by its blob hash.
+   */
+  async getFile(hash) {
+    const res = await fetch(
+      `${this.opts.url}/files/${encodeURIComponent(hash)}`,
+      {
+        headers: this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
+      }
+    );
+    if (res.status === 404) return null;
+    if (!res.ok) throw new FetchError(res.status, await res.text());
+    return new Uint8Array(await res.arrayBuffer());
+  }
+  // -------------------------------------------------------------------------
+  // Auth helpers
+  // -------------------------------------------------------------------------
+  async register(email, password, name) {
+    return await this._fetch("POST", "/auth/register", {
+      email,
+      password,
+      name
+    });
+  }
+  async login(email, password) {
+    return await this._fetch("POST", "/auth/login", {
+      email,
+      password
+    });
+  }
+  /**
+   * Set the active API key / JWT token for subsequent requests.
+   */
+  setToken(token) {
+    this.opts.apiKey = token;
+  }
+  // -------------------------------------------------------------------------
+  // Realtime
+  // -------------------------------------------------------------------------
+  /**
+   * Subscribe to a live EQL-S query.
+   * Callback is fired immediately with the initial result, then on every update.
+   */
+  subscribe(eql, callback, opts) {
+    const subId = `sub_${crypto.randomUUID()}`;
+    this._subCallbacks.set(subId, callback);
+    this._ensureWs().then((ws) => {
+      ws.send(
+        JSON.stringify({
+          type: "subscribe",
+          id: subId,
+          query: eql,
+          ...opts?.entityType ? { entityType: opts.entityType } : {},
+          ...opts?.resolve ? { resolve: opts.resolve } : {}
+        })
+      );
+    });
+    return {
+      unsubscribe: () => {
+        this._subCallbacks.delete(subId);
+        this._ws?.send(JSON.stringify({ type: "unsubscribe", id: subId }));
+      }
+    };
+  }
+  /**
+   * Close the WebSocket connection.
+   */
+  disconnect() {
+    const ws = this._ws;
+    this._ws = null;
+    this._wsPromise = null;
+    ws?.close();
+  }
+  /**
+   * Close open client resources.
+   */
+  close() {
+    this.disconnect();
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  async _fetch(method, path, body) {
+    const url = `${this.opts.url}${path}`;
+    const res = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    const data = await res.json();
+    if (!res.ok)
+      throw new FetchError(
+        res.status,
+        data?.message ?? res.statusText,
+        data
+      );
+    return data;
+  }
+  _ensureWs() {
+    if (this._ws?.readyState === WebSocket.OPEN) {
+      return Promise.resolve(this._ws);
+    }
+    if (this._wsPromise) {
+      return this._wsPromise;
+    }
+    const wsUrl = this.opts.url.replace(
+      /^https?/,
+      this.opts.url.startsWith("https") ? "wss" : "ws"
+    ) + "/realtime";
+    this._wsPromise = new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      ws.onopen = () => {
+        this._ws = ws;
+        resolve(ws);
+      };
+      ws.onerror = (e) => {
+        reject(e instanceof Error ? e : new Error("WebSocket error"));
+      };
+      ws.onmessage = (e) => {
+        try {
+          const msg = JSON.parse(e.data);
+          if (msg.type === "data" && this._subCallbacks.has(msg.id)) {
+            const meta = msg.resolved === true ? { resolved: true } : void 0;
+            this._subCallbacks.get(msg.id)(msg.result, msg.diff, meta);
+          }
+        } catch {
+        }
+      };
+      ws.onclose = () => {
+        if (this._ws === ws) {
+          this._ws = null;
+        }
+      };
+    }).finally(() => {
+      this._wsPromise = null;
+    });
+    return this._wsPromise;
+  }
+};
+var FetchError = class extends Error {
+  constructor(status, message, body) {
+    super(`HTTP ${status}: ${message}`);
+    this.status = status;
+    this.body = body;
+    this.name = "FetchError";
+  }
+};
+
+export {
+  TrellisDb,
+  FetchError
+};

package/dist/chunk-J3WYZO3Q.js

@@ -0,0 +1,211 @@
+import {
+  bindingEntityId,
+  bindingToEntity,
+  entitiesQuery,
+  entityQuery,
+  isSparseBinding,
+  resolveRelations
+} from "./chunk-JUEMDWLU.js";
+import {
+  Signal
+} from "./chunk-UBGUDMUV.js";
+
+// src/client/live.ts
+function liveQuery(client, eql) {
+  const signal = new Signal({
+    data: [],
+    loading: true,
+    error: null
+  });
+  let sub = null;
+  return {
+    signal,
+    start() {
+      if (sub) return () => stop();
+      try {
+        sub = client.subscribe(eql, (rows) => {
+          signal.value = { data: rows, loading: false, error: null };
+        });
+      } catch (err) {
+        signal.value = {
+          data: [],
+          loading: false,
+          error: err instanceof Error ? err : new Error(String(err))
+        };
+      }
+      return () => stop();
+    }
+  };
+  function stop() {
+    sub?.unsubscribe();
+    sub = null;
+  }
+}
+function normalizeLiveEntitiesOpts(whereOrOpts) {
+  if (!whereOrOpts) return {};
+  if ("resolve" in whereOrOpts || "where" in whereOrOpts) {
+    return whereOrOpts;
+  }
+  return { where: whereOrOpts };
+}
+function liveEntities(client, typeOrSchema, whereOrOpts) {
+  const schema = typeof typeOrSchema === "string" ? void 0 : typeOrSchema;
+  const type = typeof typeOrSchema === "string" ? typeOrSchema : typeOrSchema.type;
+  const { where, resolve } = normalizeLiveEntitiesOpts(whereOrOpts);
+  const signal = new Signal({
+    data: [],
+    loading: true,
+    error: null
+  });
+  let sub = null;
+  let token = 0;
+  return {
+    signal,
+    start() {
+      if (sub) return () => stop();
+      try {
+        const serverResolve = schema && resolve && Object.keys(resolve).length > 0;
+        sub = client.subscribe(
+          entitiesQuery(type, where),
+          (rows, _diff, meta) => {
+            const turn = ++token;
+            const hydrate = async () => hydrateSubscriptionRows(client, rows, meta);
+            hydrate().then(async (entities) => {
+              if (turn !== token) return;
+              let data = entities;
+              if (schema && resolve && Object.keys(resolve).length > 0 && !meta?.resolved) {
+                data = await resolveRelations(
+                  client,
+                  schema,
+                  data,
+                  resolve
+                );
+              }
+              if (turn !== token) return;
+              signal.value = { data, loading: false, error: null };
+            }).catch((err) => {
+              if (turn !== token) return;
+              signal.value = {
+                data: signal.peek().data,
+                loading: false,
+                error: err instanceof Error ? err : new Error(String(err))
+              };
+            });
+          },
+          serverResolve ? { entityType: type, resolve } : void 0
+        );
+      } catch (err) {
+        signal.value = {
+          data: [],
+          loading: false,
+          error: err instanceof Error ? err : new Error(String(err))
+        };
+      }
+      return () => stop();
+    }
+  };
+  function stop() {
+    token++;
+    sub?.unsubscribe();
+    sub = null;
+  }
+}
+async function hydrateSubscriptionRows(client, rows, meta) {
+  if (rows.length === 0) return [];
+  if (meta?.resolved) return rows;
+  if (rows.some((r) => isSparseBinding(r))) {
+    const ids = rows.map((r) => bindingEntityId(r)).filter((id) => Boolean(id));
+    const loaded = await Promise.all(ids.map((id) => client.read(id)));
+    return loaded.filter((e) => e != null);
+  }
+  return rows.map((r) => bindingToEntity(r));
+}
+async function pickEntityFromRows(client, rows, entityId, meta) {
+  const hydrated = await hydrateSubscriptionRows(client, rows, meta);
+  const hit = hydrated.find((r) => r.id === entityId);
+  if (hit) return hit;
+  if (hydrated.length === 0) return client.read(entityId);
+  return null;
+}
+function liveEntity(client, typeOrSchema, id, opts) {
+  const schema = typeof typeOrSchema === "string" ? void 0 : typeOrSchema;
+  const type = typeof typeOrSchema === "string" ? typeOrSchema : typeOrSchema.type;
+  const { resolve } = opts ?? {};
+  const signal = new Signal({
+    data: null,
+    loading: Boolean(id),
+    error: null
+  });
+  let sub = null;
+  let token = 0;
+  return {
+    signal,
+    start() {
+      if (!id) {
+        signal.value = { data: null, loading: false, error: null };
+        return () => {
+        };
+      }
+      if (sub) return () => stop();
+      const entityId = id;
+      const serverResolve = Boolean(schema) && Boolean(resolve && Object.keys(resolve).length > 0);
+      const applyRow = async (row, turn) => {
+        if (turn !== token) return;
+        if (!row) {
+          signal.value = { data: null, loading: false, error: null };
+          return;
+        }
+        let data = row;
+        if (schema && resolve && Object.keys(resolve).length > 0 && !serverResolve) {
+          const [resolved] = await resolveRelations(client, schema, [data], resolve);
+          data = resolved ?? data;
+        }
+        if (turn !== token) return;
+        signal.value = { data, loading: false, error: null };
+      };
+      const readGen = token;
+      client.read(entityId).then((row) => applyRow(row, readGen)).catch((err) => {
+        signal.value = {
+          data: signal.peek().data,
+          loading: false,
+          error: err instanceof Error ? err : new Error(String(err))
+        };
+      });
+      try {
+        sub = client.subscribe(
+          entityQuery(type, entityId),
+          (rows, _diff, meta) => {
+            const turn = ++token;
+            pickEntityFromRows(client, rows, entityId, meta).then((row) => applyRow(row, turn)).catch((err) => {
+              if (turn !== token) return;
+              signal.value = {
+                data: signal.peek().data,
+                loading: false,
+                error: err instanceof Error ? err : new Error(String(err))
+              };
+            });
+          },
+          serverResolve ? { entityType: type, resolve } : void 0
+        );
+      } catch (err) {
+        signal.value = {
+          data: null,
+          loading: false,
+          error: err instanceof Error ? err : new Error(String(err))
+        };
+      }
+      return () => stop();
+    }
+  };
+  function stop() {
+    token++;
+    sub?.unsubscribe();
+    sub = null;
+  }
+}
+
+export {
+  liveQuery,
+  liveEntities,
+  liveEntity
+};

package/dist/{index-xzym9w0m.js → chunk-JA7AIHRK.js}

@@ -1,4 +1,3 @@
-// @bun
 // src/client/config.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { resolve, join } from "path";
@@ -11,8 +10,7 @@ function hasConfig(dir = ".") {
 }
 function readConfig(dir = ".") {
   const path = configPath(dir);
-  if (!existsSync(path))
-    return null;
+  if (!existsSync(path)) return null;
   try {
     return JSON.parse(readFileSync(path, "utf8"));
   } catch {
@@ -21,8 +19,7 @@ function readConfig(dir = ".") {
 }
 function writeConfig(config, dir = ".") {
   const path = configPath(dir);
-  writeFileSync(path, JSON.stringify(config, null, 2) + `
-`, "utf8");
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", "utf8");
 }
 function updateConfig(updates, dir = ".") {
   const existing = readConfig(dir) ?? { mode: "local" };
@@ -34,10 +31,18 @@ function defaultLocalConfig(dbPath, opts = {}) {
   return {
     mode: "local",
     dbPath,
-    port: 3000,
+    port: 3e3,
     multiTenant: false,
     ...opts
   };
 }
 
-export { CONFIG_FILE, configPath, hasConfig, readConfig, writeConfig, updateConfig, defaultLocalConfig };
+export {
+  CONFIG_FILE,
+  configPath,
+  hasConfig,
+  readConfig,
+  writeConfig,
+  updateConfig,
+  defaultLocalConfig
+};

package/dist/chunk-JHHEXEDM.js

@@ -0,0 +1,162 @@
+import {
+  attachStandardMiddleware
+} from "./chunk-SPSPV5BC.js";
+import {
+  SqliteKernelBackend
+} from "./chunk-XMQ7G77X.js";
+import {
+  TrellisKernel
+} from "./chunk-KQ4A2D2P.js";
+
+// src/server/tenancy.ts
+import { existsSync, mkdirSync } from "fs";
+import { join, resolve } from "path";
+var DEFAULT_TENANT = "default";
+var TENANTS_DIR = "tenants";
+function resolvePoolBackendFromEnv() {
+  const backend = process.env.TRELLIS_BACKEND;
+  if (backend === "sqljs") return { backend: "sqljs" };
+  if (backend === "better-sqlite") return { backend: "better-sqlite" };
+  return void 0;
+}
+var TenantPool = class {
+  pool = /* @__PURE__ */ new Map();
+  dbPath;
+  agentId;
+  backendOpts;
+  constructor(dbPath, agentIdOrOpts = "trellis-db") {
+    this.dbPath = resolve(dbPath);
+    if (typeof agentIdOrOpts === "string") {
+      this.agentId = agentIdOrOpts;
+      this.backendOpts = void 0;
+    } else {
+      this.agentId = agentIdOrOpts.agentId ?? "trellis-db";
+      this.backendOpts = agentIdOrOpts.backend;
+    }
+    this._ensureDirs();
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  /**
+   * Get (or create) the kernel for a tenant.
+   * Pass `null` or `undefined` to get the default tenant.
+   *
+   * Uses the synchronous bun:sqlite backend. To use an async backend
+   * (better-sqlite3, sql.js) call `preload(tenantId)` first; subsequent
+   * `get()` calls will return the preloaded kernel from the pool.
+   */
+  get(tenantId) {
+    const id = tenantId ?? DEFAULT_TENANT;
+    if (!this.pool.has(id)) {
+      const isBun = typeof process !== "undefined" && Boolean(process.versions?.bun);
+      if (!isBun) {
+        throw new Error(
+          "TenantPool.get() on Node requires `await pool.preload()` first. `trellis db serve` preloads automatically; custom servers should call preload before get()."
+        );
+      }
+      this.pool.set(id, this._createKernelSync(id));
+    }
+    return this.pool.get(id);
+  }
+  /**
+   * Pre-create a tenant's kernel using the runtime-selected backend.
+   * Required when running with an async-only backend (sql.js / WebContainer
+   * / browser). Idempotent — safe to call multiple times.
+   *
+   * After `preload()`, subsequent `get(tenantId)` returns the same kernel
+   * synchronously from the pool.
+   */
+  async preload(tenantId) {
+    const id = tenantId ?? DEFAULT_TENANT;
+    const cached = this.pool.get(id);
+    if (cached) return cached;
+    const kernel = await this._createKernelAsync(id);
+    this.pool.set(id, kernel);
+    return kernel;
+  }
+  /**
+   * Check whether a tenant has been initialized (kernel created).
+   */
+  has(tenantId) {
+    return this.pool.has(tenantId);
+  }
+  /**
+   * List all active tenant IDs (those with open kernels).
+   */
+  activeTenants() {
+    return Array.from(this.pool.keys());
+  }
+  /**
+   * Close a specific tenant's kernel and remove it from the pool.
+   */
+  close(tenantId) {
+    const kernel = this.pool.get(tenantId);
+    if (kernel) {
+      kernel.close();
+      this.pool.delete(tenantId);
+    }
+  }
+  /**
+   * Close all kernels and clear the pool.
+   */
+  closeAll() {
+    for (const kernel of this.pool.values()) {
+      kernel.close();
+    }
+    this.pool.clear();
+  }
+  /** Absolute path to the tenant data directory. */
+  dataPath() {
+    return this.dbPath;
+  }
+  /**
+   * Return the SQLite file path for a given tenant.
+   */
+  dbFilePath(tenantId) {
+    const id = tenantId ?? DEFAULT_TENANT;
+    if (id === DEFAULT_TENANT) {
+      return join(this.dbPath, "default.sqlite");
+    }
+    return join(this.dbPath, TENANTS_DIR, `${id}.sqlite`);
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  _createKernelSync(tenantId) {
+    const sqlitePath = this.dbFilePath(tenantId);
+    const backend = new SqliteKernelBackend(sqlitePath);
+    return this._wrapKernel(backend);
+  }
+  async _createKernelAsync(tenantId) {
+    const sqlitePath = this.dbFilePath(tenantId);
+    const { createKernelBackend } = await import("./core/persist/factory.js");
+    const backend = await createKernelBackend(sqlitePath, this.backendOpts);
+    return this._wrapKernel(backend);
+  }
+  _wrapKernel(backend) {
+    const kernel = new TrellisKernel({
+      backend,
+      agentId: this.agentId,
+      snapshotThreshold: 1e3
+    });
+    kernel.boot();
+    attachStandardMiddleware(kernel);
+    return kernel;
+  }
+  _ensureDirs() {
+    if (!existsSync(this.dbPath)) {
+      mkdirSync(this.dbPath, { recursive: true });
+    }
+    const tenantsPath = join(this.dbPath, TENANTS_DIR);
+    if (!existsSync(tenantsPath)) {
+      mkdirSync(tenantsPath, { recursive: true });
+    }
+  }
+};
+
+export {
+  DEFAULT_TENANT,
+  resolvePoolBackendFromEnv,
+  TenantPool
+};