trellis 2.1.7 → 2.1.9

package/README.md

@@ -1,13 +1,13 @@
 # Trellis
 
-> **A comprehensive graph-native platform for code, knowledge, and collaboration.**
+> **The Agentic State Engine** — an event-sourced, causal graph engine for building stateful, auditable, branchable applications. Use it as version control for code, a runtime for AI agents, or a reactive backend for collaborative apps.
 
-| Capability             | Description                                                   |
-| :--------------------- | :------------------------------------------------------------ |
-| **Graph-Native VCS**   | Immutable causal ops, semantic patching, narrative milestones |
-| **Knowledge Graph**    | EAV store, wiki-links, embeddings, ontology validation        |
-| **Intelligent Agents** | Tool registry, decision traces, agent orchestration           |
-| **Collaboration**      | Peer sync, multi-repo federation, HTTP/WebSocket transports   |
+| Use Case | How |
+| :--- | :--- |
+| **AI agent runtime** | Tool registry + decision traces + branching — agents operate on state they can fork, audit, and roll back |
+| **Collaborative app backend** | CRDT sync + multi-tenancy + realtime subscriptions via `trellis/server` and `trellis/react` |
+| **Version control for code** | Semantic patching + narrative milestones + Idea Garden for abandoned work revival |
+| **Auditable data platform** | Immutable op log + time travel + identity governance — every mutation is signed and causal |
 
 ---
 
@@ -66,7 +66,7 @@ npx trellis import --from /path/to/git-repo
 
 ## Platform Overview
 
-Trellis is a comprehensive platform that unifies version control, knowledge management, semantic analysis, and intelligent automation. Built on a graph-native foundation, it treats every action—code changes, decisions, links, and embeddings—as first-class entities in a causal graph.
+Trellis is an event-sourced causal graph engine that unifies version control, knowledge management, semantic analysis, and intelligent automation. Every action — code changes, agent decisions, wiki-links, embeddings — is an immutable operation in a causal stream, giving you time-travel, branching, and full auditability out of the box.
 
 The platform consists of multiple integrated surfaces:
 
@@ -128,6 +128,10 @@ trellis/
 │   │   ├── query/         # EQL-S query engine and Datalog evaluator
 │   │   ├── agents/        # Agent harness, tool registry, decision traces
 │   │   └── plugins/       # Plugin registry, event bus, workspace config
+│   ├── server/            # HTTP+WS server, auth, permissions, tenancy, deploy
+│   │   └── inspector/     # Visual DB inspector (web component)
+│   ├── client/            # Isomorphic SDK (local + remote), config
+│   ├── react/             # React hooks: useTrellis, useEntity, useQuery, useMutation
 │   ├── vcs/               # Version control: ops, branches, milestones, diff, merge
 │   ├── links/             # Wiki-link parsing, resolution, backlink index
 │   ├── embeddings/        # Semantic indexing, vector search, auto-embed, RAG
@@ -140,6 +144,7 @@ trellis/
 │   ├── watcher/           # File watching + ingestion pipeline
 │   ├── mcp/               # Model Context Protocol server integration
 │   ├── cli/               # CLI entrypoint
+│   ├── db/                # ⚠️ Deprecated shim — re-exports from server + client
 │   ├── engine.ts          # Composition root
 │   └── index.ts           # Main package entrypoint
 ├── vscode-extension/      # VS Code extension surface
@@ -325,6 +330,15 @@ import { TrellisVcsEngine } from 'trellis';
 import { EAVStore, TrellisKernel } from 'trellis/core';
 import type { Fact, Link, EntityRecord } from 'trellis/core';
 
+// Server — HTTP+WS host, auth, permissions, multi-tenancy
+import { startServer, TenantPool } from 'trellis/server';
+
+// Client — isomorphic SDK (local or remote)
+import { TrellisClient } from 'trellis/client';
+
+// React — reactive hooks for graph subscriptions
+import { TrellisProvider, useEntity, useQuery } from 'trellis/react';
+
 // Version control primitives
 import type { VcsOp, VcsOpKind } from 'trellis/vcs';
 
@@ -464,6 +478,81 @@ const decs = queryDecisions(ctx, { tool: 'trellis_issue_*' });
 const chain = queryDecisions(ctx, { entity: 'TRL-5' }); // Full decision chain
 ```
 
+### `trellis/server` — HTTP + WebSocket Server
+
+Production-grade server host for the Trellis engine: multi-tenancy, auth (JWT + OAuth), permission middleware, realtime subscriptions, file uploads, and deployment tooling.
+
+```typescript
+import { startServer, TenantPool } from 'trellis/server';
+
+const pool = new TenantPool('/data/tenants');
+await startServer({
+  port: 3000,
+  dbPath: '/data/trellis',
+  apiKey: 'secret',
+  tenantPool: pool,
+});
+```
+
+### `trellis/client` — Isomorphic SDK
+
+TypeScript client that works in two modes — **local** (embeds TrellisKernel, zero network) or **remote** (calls the Trellis Server HTTP API). Includes CRUD, EQL-S queries, file uploads, auth, and WebSocket subscriptions.
+
+```typescript
+import { TrellisClient } from 'trellis/client';
+
+// Remote mode
+const db = new TrellisClient({ url: 'https://myapp.example.com', apiKey: '...' });
+
+// Local mode (Node/Bun only)
+const local = new TrellisClient({ path: './.trellis-db' });
+
+// CRUD
+const note = await db.create('Note', { title: 'Hello', body: 'World' });
+const notes = await db.list('Note', { limit: 10 });
+
+// Realtime subscriptions
+const sub = db.subscribe("find Note where pinned = 'true'", (results) => {
+  console.log('Live update:', results);
+});
+```
+
+### `trellis/react` — React Hooks
+
+Reactive hooks that turn the Trellis client into a live data layer for React applications. Auto-subscribes via WebSocket and cleans up on unmount.
+
+```tsx
+import { TrellisProvider, useEntity, useEntities, useQuery, useMutation } from 'trellis/react';
+
+function App() {
+  return (
+    <TrellisProvider url="http://localhost:3000" apiKey="...">
+      <NoteList />
+    </TrellisProvider>
+  );
+}
+
+function NoteList() {
+  const { data: notes, loading } = useEntities<Note>('Note', { limit: 20 });
+  const { create } = useMutation();
+
+  if (loading) return <p>Loading...</p>;
+  return notes.map(n => <NoteCard key={n.id} note={n} />);
+}
+
+function NoteDetail({ id }: { id: string }) {
+  const { data: note, loading } = useEntity<Note>(id);
+  if (loading || !note) return <p>Loading...</p>;
+  return <h1>{note.title}</h1>;
+}
+```
+
+### `trellis/db` — Deprecated Alias
+
+> **⚠️ Deprecated.** Use `trellis/server` and `trellis/client` instead.
+
+This subpath re-exports everything from `trellis/server` and `trellis/client` for backward compatibility. It will be removed in a future major version.
+
 ### `src/garden/` — Idea Garden
 
 Detects abandoned work using three heuristics, then exposes a query API.
@@ -760,5 +849,6 @@ just publish
 | P15   | Plugin system + event bus + workspace config       | ✅     |             |
 | P16   | Sync federation + multi-repo linking               | ✅     |             |
 | P17   | Advanced knowledge graph + cross-repo intelligence | 🚧     | In Progress |
-| P18   | Enterprise collaboration features + RBAC           | 📋     | Planned     |
-| P19   | Advanced AI capabilities + intelligent automation  | 📋     | Planned     |
+| P18   | Agentic State Engine pivot — server/client/react split | ✅  |             |
+| P19   | Enterprise collaboration features + RBAC           | 📋     | Planned     |
+| P20   | Advanced AI capabilities + intelligent automation  | 📋     | Planned     |

package/dist/cli/index.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env bun
+/**
+ * TrellisVCS CLI
+ *
+ * Commands:
+ *   init     Initialize a new TrellisVCS repository
+ *   status   Show current repository status
+ *   log      Show operation history
+ *   watch    Start file watcher (foreground)
+ *   files    List tracked files
+ *   import   Import from a Git repository
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;GAUG"}

package/dist/cli/index.js

@@ -3,19 +3,12 @@
 import {
   TrellisVcsEngine,
   init_engine
-} from "../index-22jx9qsz.js";
+} from "../index-czecrvvn.js";
 import {
   OntologyRegistry,
   builtinOntologies,
-  parseQuery,
-  parseSimple,
   validateStore
-} from "../index-5m0g9r0y.js";
-import {
-  QueryEngine,
-  SqliteKernelBackend,
-  TrellisKernel
-} from "../index-hybgxe40.js";
+} from "../index-04sq3h27.js";
 import"../index-3ejh8k6v.js";
 import {
   VectorStore,
@@ -38,6 +31,18 @@ import {
   createVcsOp,
   init_ops
 } from "../index-v9b4hqa7.js";
+import {
+  parseQuery,
+  parseSimple
+} from "../index-n9f2qyh5.js";
+import {
+  SqliteKernelBackend,
+  TrellisKernel
+} from "../index-7t92ej34.js";
+import"../index-5bhe57y9.js";
+import {
+  QueryEngine
+} from "../index-yp88he8n.js";
 import {
   __commonJS,
   __esm,
@@ -5726,4 +5731,189 @@ function formatRelativeTime(iso) {
     return `${Math.floor(diff / 3600000)}h ago`;
   return `${Math.floor(diff / 86400000)}d ago`;
 }
+var db = program2.command("db").description("Trellis DB \u2014 use Trellis as an application database");
+db.command("init").description("Initialize a new Trellis DB in the current directory").option("-p, --path <path>", "Database directory", ".trellis-db").option("--port <port>", "Server port", "3000").option("--key <key>", "API key (auto-generated if omitted)").option("--jwt-secret <secret>", "JWT secret (auto-generated if omitted)").option("--multi-tenant", "Enable multi-tenancy (separate SQLite per tenant)").action(async (opts) => {
+  const { writeConfig, defaultLocalConfig, hasConfig, configPath } = await import("../config-8hczw0rs.js");
+  const { resolve: resolve2 } = await import("path");
+  if (hasConfig(".")) {
+    console.log(source_default.yellow(`Already initialized (${configPath(".")}). Use \`trellis db serve\` to start.`));
+    return;
+  }
+  const dbPath = resolve2(opts.path);
+  const apiKey = opts.key ?? `spk_${crypto.randomUUID().replace(/-/g, "")}`;
+  const jwtSecret = opts.jwtSecret ?? `jws_${crypto.randomUUID().replace(/-/g, "")}`;
+  writeConfig(defaultLocalConfig(dbPath, {
+    port: parseInt(opts.port),
+    apiKey,
+    jwtSecret,
+    multiTenant: !!opts.multiTenant
+  }), ".");
+  console.log(source_default.green("\u2713 Trellis DB initialized"));
+  console.log(source_default.dim(`  Config:     .trellis-db.json`));
+  console.log(source_default.dim(`  DB path:    ${dbPath}`));
+  console.log(source_default.dim(`  API key:    ${apiKey}`));
+  console.log(source_default.dim(`  Port:       ${opts.port}`));
+  console.log("");
+  console.log(source_default.bold("Next steps:"));
+  console.log(`  ${source_default.cyan("trellis db serve")}          Start the local HTTP server`);
+  console.log(`  ${source_default.cyan("trellis db deploy --name <n>")}  Deploy to Sprites`);
+});
+db.command("serve").description("Start the Trellis DB HTTP + WebSocket server").option("-p, --port <port>", "Override port from config").option("--config-dir <dir>", "Directory containing .trellis-db.json", ".").action(async (opts) => {
+  const { readConfig } = await import("../config-8hczw0rs.js");
+  const { TenantPool } = await import("../tenancy-tjr7kk2v.js");
+  const { startServer } = await import("../server-3vkpnpbz.js");
+  const config = readConfig(opts.configDir);
+  if (!config) {
+    console.error(source_default.red("No .trellis-db.json found. Run `trellis db init` first."));
+    process.exit(1);
+  }
+  if (!config.dbPath) {
+    console.error(source_default.red("Config is missing dbPath. Re-run `trellis db init`."));
+    process.exit(1);
+  }
+  const port = opts.port ? parseInt(opts.port) : config.port ?? 3000;
+  const pool = new TenantPool(config.dbPath);
+  const server = startServer({ port, config, pool });
+  console.log(source_default.green(`\u2713 Trellis DB running`));
+  console.log(source_default.dim(`  URL:  http://localhost:${port}`));
+  console.log(source_default.dim(`  Docs: GET http://localhost:${port}/health`));
+  if (config.apiKey) {
+    console.log(source_default.dim(`  Key:  ${config.apiKey}`));
+  }
+});
+db.command("create <type> [json]").description("Create an entity (json can be a JSON string or @file.json)").option("--config-dir <dir>", "Config directory", ".").option("--tenant <id>", "Tenant ID").action(async (type, jsonArg, opts) => {
+  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const db2 = TrellisDb.fromConfig(opts.configDir);
+  let attributes = {};
+  if (jsonArg) {
+    const { readFileSync: readFileSync4 } = await import("fs");
+    const raw = jsonArg.startsWith("@") ? readFileSync4(jsonArg.slice(1), "utf8") : jsonArg;
+    attributes = JSON.parse(raw);
+  }
+  const id = await db2.create(type, attributes);
+  console.log(source_default.green(`\u2713 Created: ${source_default.bold(id)}`));
+  db2.close();
+});
+db.command("read <id>").description("Read an entity by ID").option("--config-dir <dir>", "Config directory", ".").action(async (id, opts) => {
+  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const db2 = TrellisDb.fromConfig(opts.configDir);
+  const entity = await db2.read(id);
+  if (!entity) {
+    console.error(source_default.red(`Not found: ${id}`));
+    process.exit(1);
+  }
+  console.log(JSON.stringify(entity, null, 2));
+  db2.close();
+});
+db.command("update <id> <json>").description("Update entity attributes (JSON string or @file.json)").option("--config-dir <dir>", "Config directory", ".").action(async (id, jsonArg, opts) => {
+  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const db2 = TrellisDb.fromConfig(opts.configDir);
+  const { readFileSync: readFileSync4 } = await import("fs");
+  const raw = jsonArg.startsWith("@") ? readFileSync4(jsonArg.slice(1), "utf8") : jsonArg;
+  await db2.update(id, JSON.parse(raw));
+  console.log(source_default.green(`\u2713 Updated: ${source_default.bold(id)}`));
+  db2.close();
+});
+db.command("delete <id>").description("Delete an entity by ID").option("--config-dir <dir>", "Config directory", ".").action(async (id, opts) => {
+  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const db2 = TrellisDb.fromConfig(opts.configDir);
+  await db2.delete(id);
+  console.log(source_default.green(`\u2713 Deleted: ${source_default.bold(id)}`));
+  db2.close();
+});
+db.command("list").description("List entities").option("--type <type>", "Filter by entity type").option("--limit <n>", "Max results", "50").option("--offset <n>", "Offset", "0").option("--config-dir <dir>", "Config directory", ".").action(async (opts) => {
+  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const db2 = TrellisDb.fromConfig(opts.configDir);
+  const result = await db2.list(opts.type, {
+    limit: parseInt(opts.limit),
+    offset: parseInt(opts.offset)
+  });
+  console.log(JSON.stringify(result, null, 2));
+  db2.close();
+});
+db.command("query <eql>").description("Run an EQL-S query").option("--config-dir <dir>", "Config directory", ".").action(async (eql, opts) => {
+  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const db2 = TrellisDb.fromConfig(opts.configDir);
+  const result = await db2.query(eql);
+  console.log(JSON.stringify(result.bindings, null, 2));
+  console.log(source_default.dim(`Execution time: ${result.executionTime}ms`));
+  db2.close();
+});
+db.command("upload <file>").description("Upload a file to the blob store").option("--config-dir <dir>", "Config directory", ".").option("--type <mime>", "MIME type (auto-detected if omitted)").action(async (filePath, opts) => {
+  const { readFileSync: readFileSync4 } = await import("fs");
+  const { extname } = await import("path");
+  const { TrellisDb } = await import("../sdk-sj8rp0m7.js");
+  const mimeMap = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".pdf": "application/pdf",
+    ".json": "application/json",
+    ".txt": "text/plain"
+  };
+  const contentType = opts.type ?? mimeMap[extname(filePath).toLowerCase()] ?? "application/octet-stream";
+  const buffer = readFileSync4(filePath);
+  const db2 = TrellisDb.fromConfig(opts.configDir);
+  const result = await db2.upload(new Uint8Array(buffer), contentType);
+  console.log(source_default.green(`\u2713 Uploaded`));
+  console.log(source_default.dim(`  Hash: ${result.hash}`));
+  console.log(source_default.dim(`  Size: ${result.size} bytes`));
+  db2.close();
+});
+db.command("import <file>").description("Import data from CSV, JSON, NDJSON, or Parquet").requiredOption("--type <type>", "Entity type to assign to each record").option("--id-field <field>", "Field to use as entity ID").option("--limit <n>", "Max rows to import").option("--config-dir <dir>", "Config directory", ".").option("--tenant <id>", "Tenant ID").action(async (filePath, opts) => {
+  const { readConfig } = await import("../config-8hczw0rs.js");
+  const { TenantPool } = await import("../tenancy-tjr7kk2v.js");
+  const { importFile } = await import("../import-fyg5sgq4.js");
+  const config = readConfig(opts.configDir);
+  if (!config?.dbPath) {
+    console.error(source_default.red("No .trellis-db.json found. Run `trellis db init` first."));
+    process.exit(1);
+  }
+  const pool = new TenantPool(config.dbPath);
+  const kernel = pool.get(opts.tenant ?? null);
+  const result = await importFile(kernel, filePath, {
+    type: opts.type,
+    idField: opts.idField,
+    limit: opts.limit ? parseInt(opts.limit) : undefined
+  });
+  console.log(source_default.green(`\u2713 Import complete`));
+  console.log(source_default.dim(`  Imported: ${result.imported}`));
+  console.log(source_default.dim(`  Skipped:  ${result.skipped}`));
+  if (result.errors.length > 0) {
+    console.log(source_default.yellow(`  Errors:   ${result.errors.length}`));
+    result.errors.slice(0, 5).forEach((e) => {
+      console.log(source_default.red(`    Row ${e.row}: ${e.message}`));
+    });
+  }
+  pool.closeAll();
+});
+db.command("deploy").description("Deploy Trellis DB to a Sprites cloud environment").requiredOption("--name <name>", "Sprite name (becomes <name>.sprites.app)").option("--key <key>", "API key for the deployed server (auto-generated if omitted)").option("--jwt-secret <secret>", "JWT secret (auto-generated if omitted)").option("--port <port>", "Port to run on inside Sprite", "3000").option("--config-dir <dir>", "Config directory", ".").action(async (opts) => {
+  const { deploy } = await import("../deploy-99j5dc9c.js");
+  const { readConfig } = await import("../config-8hczw0rs.js");
+  const config = readConfig(opts.configDir);
+  console.log(source_default.bold(`Deploying to Sprites: ${opts.name}...`));
+  try {
+    const result = await deploy({
+      name: opts.name,
+      dbPath: config?.dbPath,
+      apiKey: opts.key,
+      jwtSecret: opts.jwtSecret,
+      port: opts.port ? parseInt(opts.port) : 3000,
+      configDir: opts.configDir,
+      onProgress: (msg) => console.log(source_default.dim(`  ${msg}`))
+    });
+    console.log("");
+    console.log(source_default.green(`\u2713 Deployed successfully`));
+    console.log(source_default.dim(`  URL:    ${result.url}`));
+    console.log(source_default.dim(`  Key:    ${result.apiKey}`));
+    console.log("");
+    console.log(source_default.bold("SDK usage:"));
+    console.log(source_default.cyan(`  import { TrellisClient } from 'trellis/client';`));
+    console.log(source_default.cyan(`  const db = new TrellisClient({ url: '${result.url}', apiKey: '${result.apiKey}' });`));
+  } catch (err) {
+    console.error(source_default.red(`Deploy failed: ${err.message}`));
+    process.exit(1);
+  }
+});
 program2.parse();

package/dist/client/config.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Trellis Client — Configuration
+ *
+ * Manages `.trellis-db.json` — the local project config file that records
+ * whether this instance is running locally or deployed to Sprites.
+ *
+ * @module trellis/client
+ */
+export type DbMode = 'local' | 'remote';
+export interface TrellisDbConfig {
+    /** Whether the DB is local (SQLite) or remote (Sprites/custom URL). */
+    mode: DbMode;
+    /** Absolute path to the SQLite database directory (local mode). */
+    dbPath?: string;
+    /** Remote API base URL (remote mode). */
+    url?: string;
+    /** API key for remote mode authentication. */
+    apiKey?: string;
+    /** Sprites sprite name (used for deploy). */
+    spriteName?: string;
+    /** ISO timestamp of last deploy. */
+    deployedAt?: string;
+    /** Port for local server mode (default: 3000). */
+    port?: number;
+    /** Enable multi-tenancy (separate SQLite per tenant). */
+    multiTenant?: boolean;
+    /** Secret used to sign/verify JWTs. */
+    jwtSecret?: string;
+}
+export declare const CONFIG_FILE = ".trellis-db.json";
+/**
+ * Resolve the config file path relative to a directory.
+ */
+export declare function configPath(dir?: string): string;
+/**
+ * Check if a `.trellis-db.json` exists in the given directory.
+ */
+export declare function hasConfig(dir?: string): boolean;
+/**
+ * Read and parse the `.trellis-db.json` config file.
+ * Returns null if the file doesn't exist.
+ */
+export declare function readConfig(dir?: string): TrellisDbConfig | null;
+/**
+ * Write a config to `.trellis-db.json`.
+ */
+export declare function writeConfig(config: TrellisDbConfig, dir?: string): void;
+/**
+ * Merge partial updates into an existing config file (creates if missing).
+ */
+export declare function updateConfig(updates: Partial<TrellisDbConfig>, dir?: string): TrellisDbConfig;
+/**
+ * Build a local config with sensible defaults for a given directory.
+ */
+export declare function defaultLocalConfig(dbPath: string, opts?: Partial<TrellisDbConfig>): TrellisDbConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/client/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/client/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,MAAM,MAAM,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAExC,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yCAAyC;IACzC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oCAAoC;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,uCAAuC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAMD,eAAO,MAAM,WAAW,qBAAqB,CAAC;AAM9C;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,SAAM,GAAG,MAAM,CAE5C;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,SAAM,GAAG,OAAO,CAE5C;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,SAAM,GAAG,eAAe,GAAG,IAAI,CAQ5D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,SAAM,GAAG,IAAI,CAGpE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,EACjC,GAAG,SAAM,GACR,eAAe,CAKjB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,OAAO,CAAC,eAAe,CAAM,GAClC,eAAe,CAQjB"}

package/dist/client/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Trellis Client — Public API Surface
+ *
+ * Isomorphic SDK for interacting with Trellis (local or remote).
+ * Import from `trellis/client`:
+ *
+ *   import { TrellisClient } from 'trellis/client';
+ *
+ * @module trellis/client
+ */
+export { TrellisDb as TrellisClient, TrellisDb, FetchError } from './sdk.js';
+export type { EntityData, ListResult, QueryResult, UploadResult, AuthResult, Subscription, SubscriptionCallback, TrellisDbLocalOptions, TrellisDbRemoteOptions, TrellisDbOptions, } from './sdk.js';
+export { readConfig, writeConfig, updateConfig, hasConfig, configPath, defaultLocalConfig, CONFIG_FILE, } from './config.js';
+export type { TrellisDbConfig, DbMode } from './config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,SAAS,IAAI,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC7E,YAAY,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,UAAU,EACV,WAAW,EACX,YAAY,EACZ,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,WAAW,GACZ,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dist/client/index.js

@@ -0,0 +1,32 @@
+// @bun
+import"../index-k5b0xskw.js";
+import {
+  FetchError,
+  TrellisDb
+} from "../index-4beszbgg.js";
+import {
+  CONFIG_FILE,
+  configPath,
+  defaultLocalConfig,
+  hasConfig,
+  readConfig,
+  updateConfig,
+  writeConfig
+} from "../index-xzym9w0m.js";
+import"../index-5p6zgspx.js";
+import"../index-7t92ej34.js";
+import"../index-5bhe57y9.js";
+import"../index-yp88he8n.js";
+import"../index-a76rekgs.js";
+export {
+  writeConfig,
+  updateConfig,
+  readConfig,
+  hasConfig,
+  defaultLocalConfig,
+  configPath,
+  TrellisDb,
+  TrellisDb as TrellisClient,
+  FetchError,
+  CONFIG_FILE
+};

package/dist/client/sdk.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Trellis Client — TypeScript SDK
+ *
+ * Isomorphic client that works in two modes:
+ *
+ *   Local  — embeds TrellisKernel directly (Node/Bun only, zero network)
+ *   Remote — calls the Trellis Server HTTP API (works anywhere, including browsers)
+ *
+ * Usage:
+ *   // Local (embeds SQLite kernel)
+ *   const db = new TrellisClient({ path: './.trellis-db' });
+ *
+ *   // Remote (hits HTTP server or Sprites deployment)
+ *   const db = new TrellisClient({ url: 'https://myapp.sprites.app', apiKey: '...' });
+ *
+ *   // Auto (reads .trellis-db.json from cwd)
+ *   const db = await TrellisClient.fromConfig();
+ *
+ * @module trellis/client
+ */
+export interface EntityData {
+    id: string;
+    type: string;
+    [key: string]: unknown;
+}
+export interface ListResult<T = EntityData> {
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+export interface QueryResult {
+    bindings: Record<string, unknown>[];
+    executionTime: number;
+}
+export interface UploadResult {
+    hash: string;
+    size: number;
+    contentType: string;
+}
+export interface AuthResult {
+    token: string;
+    userId: string;
+}
+export interface Subscription<T = EntityData> {
+    unsubscribe(): void;
+}
+export type SubscriptionCallback<T = EntityData> = (result: T[], diff: {
+    added: T[];
+    updated: T[];
+    removed: T[];
+}) => void;
+export interface TrellisDbLocalOptions {
+    /** Path to the SQLite database directory. */
+    path: string;
+    /** Agent ID for attributing ops. Default: 'sdk'. */
+    agentId?: string;
+    /** Tenant ID (multi-tenant mode). */
+    tenantId?: string;
+}
+export interface TrellisDbRemoteOptions {
+    /** Base URL of the Trellis DB server. */
+    url: string;
+    /** API key or JWT for authentication. */
+    apiKey?: string;
+    /** Tenant ID (passed as query param if not in JWT). */
+    tenantId?: string;
+}
+export type TrellisDbOptions = TrellisDbLocalOptions | TrellisDbRemoteOptions;
+export declare class TrellisDb {
+    private opts;
+    private _pool;
+    private _ws;
+    private _subCallbacks;
+    constructor(opts: TrellisDbOptions);
+    /**
+     * Create a TrellisDb instance from `.trellis-db.json` in the given directory.
+     */
+    static fromConfig(dir?: string): TrellisDb;
+    /**
+     * Create a new entity.
+     * Returns the generated entity ID.
+     */
+    create(type: string, attributes?: Record<string, unknown>, links?: Array<{
+        attribute: string;
+        targetEntityId: string;
+    }>): Promise<string>;
+    /**
+     * Read an entity by ID.
+     * Returns null if not found.
+     */
+    read<T extends EntityData = EntityData>(id: string): Promise<T | null>;
+    /**
+     * Update an entity's attributes (partial update).
+     */
+    update(id: string, attributes: Record<string, unknown>): Promise<void>;
+    /**
+     * Delete an entity by ID.
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * List entities of a given type.
+     */
+    list<T extends EntityData = EntityData>(type?: string, opts?: {
+        limit?: number;
+        offset?: number;
+        filters?: Record<string, unknown>;
+    }): Promise<ListResult<T>>;
+    /**
+     * Run an EQL-S query string.
+     */
+    query(eql: string): Promise<QueryResult>;
+    /**
+     * Upload a file to the blob store.
+     * Returns a content-addressed hash.
+     */
+    upload(data: Uint8Array | ArrayBuffer, contentType?: string): Promise<UploadResult>;
+    /**
+     * Download a file by its blob hash.
+     */
+    getFile(hash: string): Promise<Uint8Array | null>;
+    register(email: string, password: string, name?: string): Promise<AuthResult>;
+    login(email: string, password: string): Promise<AuthResult>;
+    /**
+     * Set the active API key / JWT token for subsequent requests.
+     */
+    setToken(token: string): void;
+    /**
+     * Subscribe to a live EQL-S query.
+     * Callback is fired immediately with the initial result, then on every update.
+     *
+     * Requires remote mode (WebSocket to server).
+     */
+    subscribe<T = EntityData>(eql: string, callback: SubscriptionCallback<T>): Subscription<T>;
+    /**
+     * Close the WebSocket connection.
+     */
+    disconnect(): void;
+    /**
+     * Close local kernel pool connections.
+     */
+    close(): void;
+    private _getPool;
+    private _fetch;
+    private _ensureWs;
+}
+export declare class FetchError extends Error {
+    status: number;
+    body?: unknown | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined);
+}
+//# sourceMappingURL=sdk.d.ts.map