tablinum 0.5.0 → 0.6.1

package/dist/sync/compact-event.d.ts

@@ -0,0 +1,3 @@
+import type { NostrEvent } from "nostr-tools/pure";
+export declare function packEvent(event: NostrEvent): Uint8Array;
+export declare function unpackEvent(id: string, compact: Uint8Array): NostrEvent;

package/dist/sync/gift-wrap.d.ts

@@ -3,11 +3,10 @@ import { unwrapEvent } from "nostr-tools/nip59";
 import type { NostrEvent, UnsignedEvent } from "nostr-tools/pure";
 import { CryptoError } from "../errors.ts";
 import type { EpochStore } from "../db/epoch.ts";
-type Rumor = ReturnType<typeof unwrapEvent>;
+export type Rumor = ReturnType<typeof unwrapEvent>;
 export interface GiftWrapHandle {
     readonly wrap: (rumor: Partial<UnsignedEvent>) => Effect.Effect<NostrEvent, CryptoError>;
     readonly unwrap: (giftWrap: NostrEvent) => Effect.Effect<Rumor, CryptoError>;
 }
 export declare function createGiftWrapHandle(senderPrivateKey: Uint8Array, recipientPublicKey: string, decryptionPrivateKey: Uint8Array): GiftWrapHandle;
 export declare function createEpochGiftWrapHandle(senderPrivateKey: Uint8Array, epochStore: EpochStore): GiftWrapHandle;
-export {};

package/dist/sync/sync-service.d.ts

@@ -14,5 +14,7 @@ export interface SyncHandle {
     readonly publishLocal: (giftWrap: StoredGiftWrap) => Effect.Effect<void>;
     readonly startSubscription: () => Effect.Effect<void>;
     readonly addEpochSubscription: (publicKey: string) => Effect.Effect<void>;
+    readonly startHealing: () => void;
+    readonly stopHealing: () => void;
 }
 export declare function createSyncHandle(storage: IDBStorageHandle, giftWrapHandle: GiftWrapHandle, relay: RelayHandle, publishQueue: PublishQueueHandle, syncStatus: SyncStatusHandle, watchCtx: WatchContext, relayUrls: readonly string[], knownCollections: ReadonlyMap<string, number>, epochStore: EpochStore, personalPrivateKey: Uint8Array, personalPublicKey: string, scope: Scope.Scope, logLevel: LogLevel.LogLevel, onSyncError?: ((error: unknown) => void) | undefined, onNewAuthor?: ((pubkey: string) => void) | undefined, onRemoved?: ((notice: RemovalNotice) => void) | undefined, onMembersChanged?: (() => void) | undefined): SyncHandle;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "tablinum",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/kevmodrome/tablinum.git"
+    "url": "git+https://github.com/kevmodrome/tablinum.git",
+    "directory": "packages/tablinum"
   },
   "files": [
     "dist"
@@ -23,41 +24,21 @@
     }
   },
   "scripts": {
-    "dev": "bun run src/main.ts",
-    "lint": "oxlint",
-    "format": "oxfmt --write .",
-    "format:check": "oxfmt --check .",
-    "test": "bun run vitest run",
-    "test:watch": "bun run vitest",
-    "validate": "bun run scripts/validate.ts",
-    "demo": "bun run examples/vanilla/serve.ts",
-    "demo:svelte": "cd examples/svelte && bun run dev",
-    "build": "bun build src/index.ts --outdir dist --format esm --packages external && bun build src/svelte/index.svelte.ts --outdir dist/svelte --format esm --packages external && tsc -p tsconfig.build.json --noCheck && tsc -p tsconfig.build.svelte.json --noCheck",
-    "changeset": "changeset",
-    "version": "changeset version",
-    "release": "changeset publish",
-    "relays": "docker compose up -d",
-    "relays:down": "docker compose down",
-    "relays:clean": "docker compose down -v"
+    "dev": "npx tsx src/main.ts",
+    "build": "esbuild src/index.ts --outdir=dist --format=esm --bundle --packages=external && esbuild src/svelte/index.svelte.ts --outdir=dist/svelte --format=esm --bundle --packages=external && tsc -p tsconfig.build.json --noCheck && tsc -p tsconfig.build.svelte.json --noCheck"
   },
   "dependencies": {
     "@noble/curves": "^2.0.1",
     "@noble/hashes": "^2.0.1",
-    "effect": "4.0.0-beta.28",
+    "effect": "4.0.0-beta.31",
     "idb": "^8.0.3",
     "nostr-tools": "^2.23.3"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.30.0",
     "@effect/vitest": "4.0.0-beta.31",
-    "@j178/prek": "0.3.5",
-    "@types/bun": "^1.3.10",
+    "esbuild": "^0.24.0",
     "fake-indexeddb": "^6.2.5",
-    "oxfmt": "0.38.0",
-    "oxlint": "^1.53.0",
-    "svelte": "^5.53.10",
-    "typescript": "^5.7.0",
-    "vitest": "^3.0.0"
+    "svelte": "^5.53.10"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"

package/README.md

@@ -1,298 +0,0 @@
-# tablinum
-
-A local-first database for the browser with encrypted sync and built-in collaboration.
-
-## Features
-
-### Local first
-
-Your app works offline. All data lives on your device in the browser.
-
-### Backed up and encrypted
-
-Data syncs to relays so it's safe across devices. Everything stored on relays is end-to-end encrypted - relay operators cannot read your data.
-
-### Identity and collaboration built in
-
-Tablinum has a built-in system for sharing a database with other people, and for removing access when needed.
-
-Every database has a shared secret key. When you invite someone, they get a copy of the key so they can read and write data. If someone leaves or is removed, a new key is created and shared with everyone _except_ the removed person — like changing the locks when a roommate moves out. Old data is still available to the removed person but they will not get anything new.
-
-Invites are just links. Share one, and the other person has everything they need to join.
-
-### Typed collections and queries
-
-Define your data shape once with `collection()` and `field.*()` builders, and get full TypeScript inference everywhere. Query with a chainable API:
-
-```typescript
-const pending = await todos.where("done").equals(false).get();
-const recent = await todos.orderBy("createdAt").get();
-```
-
-### Svelte 5 bindings
-
-Optional reactive integration using Svelte 5 async runes. No Effect knowledge needed — the API is plain async/await.
-
-## Getting started
-
-### Install
-
-```bash
-npm install tablinum
-```
-
-### Quick start (Effect)
-
-```typescript
-import { Effect } from "effect";
-import { createTablinum, collection, field } from "tablinum";
-
-const schema = {
-  todos: collection("todos", {
-    title: field.string(),
-    done: field.boolean(),
-  }),
-};
-
-const program = Effect.gen(function* () {
-  const db = yield* createTablinum({
-    schema,
-    relays: ["wss://relay.example.com"],
-  });
-
-  const todos = db.collection("todos");
-
-  // Create
-  const id = yield* todos.add({ title: "Buy milk", done: false });
-
-  // Read
-  const todo = yield* todos.get(id);
-
-  // Query
-  const pending = yield* todos.where("done").equals(false).get();
-
-  // Update
-  yield* todos.update(id, { done: true });
-
-  // Sync across devices
-  yield* db.sync();
-});
-
-Effect.runPromise(Effect.scoped(program));
-```
-
-### Quick start (Svelte 5)
-
-Import from `tablinum/svelte` for reactive bindings. This API uses Svelte's async runes support, so enable it in your app config:
-
-```js
-// svelte.config.js
-const config = {
-  compilerOptions: {
-    experimental: {
-      async: true,
-    },
-  },
-};
-```
-
-Create a database helper:
-
-```typescript
-// src/lib/db.ts
-import { Tablinum, collection, field } from "tablinum/svelte";
-
-const schema = {
-  todos: collection(
-    "todos",
-    {
-      title: field.string(),
-      done: field.boolean(),
-    },
-    { indices: ["done"] },
-  ),
-};
-
-export type AppSchema = typeof schema;
-
-export const db = new Tablinum({
-  schema,
-  relays: ["wss://relay.example.com"],
-});
-
-export const todos = db.collection("todos");
-```
-
-Use it in a component:
-
-```svelte
-<script lang="ts">
-  import { db, todos } from "$lib/db";
-
-  let title = $state("");
-  let booted = $derived(await db.ready.then(() => true, () => false));
-  let pending = $derived(
-    booted && db.status === "ready"
-      ? await todos.where("done").equals(false).get()
-      : [],
-  );
-
-  async function addTodo(e: SubmitEvent) {
-    e.preventDefault();
-    if (!title.trim()) return;
-    await todos.add({ title: title.trim(), done: false });
-    title = "";
-  }
-
-  async function toggle(id: string, currentDone: boolean) {
-    await todos.update(id, { done: !currentDone });
-  }
-
-  async function remove(id: string) {
-    await todos.delete(id);
-  }
-</script>
-
-<svelte:boundary>
-  {#snippet pending()}
-    <p>Initializing database...</p>
-  {/snippet}
-
-  {#if db.status === "error"}
-    <p>{db.error?.message}</p>
-  {:else}
-    <p>{pending.length} pending</p>
-
-    <form onsubmit={addTodo}>
-      <input bind:value={title} placeholder="Add a todo..." />
-      <button type="submit">Add</button>
-    </form>
-
-    <ul>
-      {#each pending as todo (todo.id)}
-        <li>
-          <input
-            type="checkbox"
-            checked={todo.done}
-            onchange={() => toggle(todo.id, todo.done)}
-          />
-          <span>{todo.title}</span>
-          <button onclick={() => remove(todo.id)}>Delete</button>
-        </li>
-      {/each}
-    </ul>
-
-    {#if db.syncStatus === "syncing"}
-      <p>Syncing...</p>
-    {/if}
-
-    <button onclick={() => db.sync()}>Sync</button>
-  {/if}
-</svelte:boundary>
-```
-
-#### Key concepts
-
-- **`new Tablinum(config)`** starts initialization immediately and exposes `db.ready`
-- **Async queries are reactive** when used inside `$derived(await ...)`
-- **`db.status`** tracks initialization and terminal state; **`db.syncStatus`** tracks sync activity
-- **`createTablinum(config)`** still exists as a convenience and resolves once `db.ready` completes
-
-## Logging
-
-Tablinum uses [Effect's built-in logging](https://effect.website/docs/observability/logging/) under the hood. By default, logging is completely silent. Set `logLevel` in your config to enable it:
-
-```typescript
-const db = yield* createTablinum({
-  schema,
-  relays: ["wss://relay.example.com"],
-  logLevel: "debug", // "debug" | "info" | "warning" | "error" | "none"
-});
-```
-
-Wire it to an environment variable for easy toggling:
-
-```typescript
-// Effect API
-createTablinum({
-  schema,
-  relays: ["wss://relay.example.com"],
-  logLevel: import.meta.env.VITE_LOG_LEVEL ?? "none",
-});
-
-// Svelte API
-new Tablinum({
-  schema,
-  relays: ["wss://relay.example.com"],
-  logLevel: import.meta.env.VITE_LOG_LEVEL ?? "none",
-});
-```
-
-### Log levels
-
-| Level | What you see |
-|-------|-------------|
-| `"none"` | Nothing (default) |
-| `"error"` | Unrecoverable failures |
-| `"warning"` | Recoverable issues (e.g. rejected writes from removed members) |
-| `"info"` | Lifecycle milestones — storage opened, identity loaded, sync started/complete |
-| `"debug"` | Everything above plus CRUD operations (with record data), relay reconciliation details, gift wrap processing |
-
-### Log spans
-
-Key operations include timing spans that appear automatically in log output:
-
-```
-[11:50:31] INFO (#1) tablinum.init=13ms: Tablinum ready { ... }
-[11:50:41] INFO (#1) tablinum.sync=520ms: Sync complete { changed: ["todos"] }
-```
-
-Spans: `tablinum.init`, `tablinum.sync`, `tablinum.syncRelay`, `tablinum.negentropy`.
-
-### Using Effect's LogLevel type
-
-Power users can also pass Effect's `LogLevel` type directly:
-
-```typescript
-import { LogLevel } from "tablinum";
-createTablinum({ ..., logLevel: LogLevel.Debug });
-```
-
-## How it works
-
-Tablinum is built on [Effect](https://effect.website) and stores all data locally in [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API).
-
-Sync happens through [Nostr](https://nostr.com) relays. All data sent to relays is encrypted using [NIP-59 gift wrapping](https://github.com/nostr-protocol/nips/blob/master/59.md). Relays never see your application data. Sync uses [NIP-77 negentropy](https://github.com/nostr-protocol/nips/blob/master/77.md) to efficiently reconcile what each side has, minimizing bandwidth usage.
-
-### Picking a relay
-
-Tablinum syncs through Nostr relays that support [NIP-77 (Negentropy)](https://github.com/nostr-protocol/nips/blob/master/77.md). You have two options:
-
-- **Use a public relay** — find NIP-77 compatible relays at [nostrwat.ch](https://nostrwat.ch)
-- **Self-host a relay** — [strfry](https://github.com/hoytech/strfry) is a good choice if you want full control over where your users' data is stored
-
-## Development
-
-### Local relays
-
-To run the example app or integration tests against local relays, spin up three [strfry](https://github.com/hoytech/strfry) instances with Docker:
-
-```bash
-bun run relays        # starts 3 relays on ports 7984, 7985, 7986
-bun run relays:down   # stop relays (data is preserved)
-bun run relays:clean  # stop relays and delete all data
-```
-
-The first run builds strfry from source, which takes a few minutes. Subsequent starts are instant.
-
-Then point your app at the local relays:
-
-```typescript
-relays: ["ws://localhost:7984", "ws://localhost:7985", "ws://localhost:7986"]
-```
-
-The Svelte example app (`bun run demo:svelte`) is pre-configured to use these local relays.
-
-## License
-
-MIT