tablinum 0.1.1 → 0.2.0

package/dist/layers/EpochStoreLive.d.ts

@@ -0,0 +1,6 @@
+import { Layer } from "effect";
+import { EpochStore } from "../services/EpochStore.ts";
+import { Config } from "../services/Config.ts";
+import { Identity } from "../services/Identity.ts";
+import { Storage } from "../services/Storage.ts";
+export declare const EpochStoreLive: Layer.Layer<EpochStore, import("../errors.ts").StorageError, Config | Identity | Storage>;

package/dist/layers/GiftWrapLive.d.ts

@@ -0,0 +1,5 @@
+import { Layer } from "effect";
+import { GiftWrap } from "../services/GiftWrap.ts";
+import { Identity } from "../services/Identity.ts";
+import { EpochStore } from "../services/EpochStore.ts";
+export declare const GiftWrapLive: Layer.Layer<GiftWrap, never, Identity | EpochStore>;

package/dist/layers/IdentityLive.d.ts

@@ -0,0 +1,5 @@
+import { Layer } from "effect";
+import { Identity } from "../services/Identity.ts";
+import { Config } from "../services/Config.ts";
+import { Storage } from "../services/Storage.ts";
+export declare const IdentityLive: Layer.Layer<Identity, import("../errors.ts").StorageError | import("../errors.ts").CryptoError, Config | Storage>;

package/dist/layers/PublishQueueLive.d.ts

@@ -0,0 +1,5 @@
+import { Layer } from "effect";
+import { PublishQueue } from "../services/PublishQueue.ts";
+import { Storage } from "../services/Storage.ts";
+import { Relay } from "../services/Relay.ts";
+export declare const PublishQueueLive: Layer.Layer<PublishQueue, import("../errors.ts").StorageError, Storage | Relay>;

package/dist/layers/RelayLive.d.ts

@@ -0,0 +1,3 @@
+import { Layer } from "effect";
+import { Relay } from "../services/Relay.ts";
+export declare const RelayLive: Layer.Layer<Relay, never, never>;

package/dist/layers/StorageLive.d.ts

@@ -0,0 +1,4 @@
+import { Layer } from "effect";
+import { Storage } from "../services/Storage.ts";
+import { Config } from "../services/Config.ts";
+export declare const StorageLive: Layer.Layer<Storage, import("../errors.ts").StorageError, Config>;

package/dist/layers/SyncStatusLive.d.ts

@@ -0,0 +1,3 @@
+import { Layer } from "effect";
+import { SyncStatus } from "../services/SyncStatus.ts";
+export declare const SyncStatusLive: Layer.Layer<SyncStatus, never, never>;

package/dist/layers/TablinumLive.d.ts

@@ -0,0 +1,5 @@
+import { Layer } from "effect";
+import { StorageError } from "../errors.ts";
+import { Tablinum } from "../services/Tablinum.ts";
+import { Config } from "../services/Config.ts";
+export declare const TablinumLive: Layer.Layer<Tablinum, StorageError | import("../errors.ts").CryptoError, Config>;

package/dist/layers/index.d.ts

@@ -0,0 +1,8 @@
+export { IdentityLive } from "./IdentityLive.ts";
+export { EpochStoreLive } from "./EpochStoreLive.ts";
+export { StorageLive } from "./StorageLive.ts";
+export { RelayLive } from "./RelayLive.ts";
+export { GiftWrapLive } from "./GiftWrapLive.ts";
+export { PublishQueueLive } from "./PublishQueueLive.ts";
+export { SyncStatusLive } from "./SyncStatusLive.ts";
+export { TablinumLive } from "./TablinumLive.ts";

package/dist/schema/field.d.ts

@@ -4,7 +4,6 @@ export interface FieldDef<out T = unknown> {
     readonly kind: FieldKind;
     readonly isOptional: boolean;
     readonly isArray: boolean;
-    /** Phantom type carrier — never read at runtime. */
     readonly _T?: T;
 }
 export declare const field: {

package/dist/schema/types.d.ts

@@ -1,14 +1,10 @@
 import type { CollectionDef, CollectionFields } from "./collection.ts";
 import type { FieldDef } from "./field.ts";
-/** Extract the TypeScript type from a FieldDef phantom. */
 export type InferFieldType<F> = F extends FieldDef<infer T> ? T : never;
-/** Infer the full record type from a CollectionDef, including the auto-injected `id`. */
 export type InferRecord<C> = C extends CollectionDef<infer F> ? {
     readonly id: string;
 } & {
     readonly [K in keyof F]: InferFieldType<F[K]>;
 } : never;
-/** A schema configuration mapping collection names to their definitions. */
 export type SchemaConfig = Record<string, CollectionDef<CollectionFields>>;
-/** Extract indexed field names from a CollectionDef. */
 export type IndexedFields<C> = C extends CollectionDef<infer _F> ? C["indices"][number] : never;

package/dist/services/Config.d.ts

@@ -0,0 +1,16 @@
+import { ServiceMap } from "effect";
+import type { ResolvedRuntimeConfig } from "../db/runtime-config.ts";
+import type { SchemaConfig } from "../schema/types.ts";
+export interface TablinumConfigShape extends ResolvedRuntimeConfig {
+    readonly schema: SchemaConfig;
+    readonly onSyncError?: ((error: Error) => void) | undefined;
+    readonly onRemoved?: ((info: {
+        epochId: string;
+        removedBy: string;
+    }) => void) | undefined;
+    readonly onMembersChanged?: (() => void) | undefined;
+}
+declare const Config_base: ServiceMap.ServiceClass<Config, "tablinum/Config", TablinumConfigShape>;
+export declare class Config extends Config_base {
+}
+export {};

package/dist/services/EpochStore.d.ts

@@ -0,0 +1,6 @@
+import { ServiceMap } from "effect";
+import type { EpochStore as EpochStoreShape } from "../db/epoch.ts";
+declare const EpochStore_base: ServiceMap.ServiceClass<EpochStore, "tablinum/EpochStore", EpochStoreShape>;
+export declare class EpochStore extends EpochStore_base {
+}
+export {};

package/dist/services/GiftWrap.d.ts

@@ -0,0 +1,6 @@
+import { ServiceMap } from "effect";
+import type { GiftWrapHandle } from "../sync/gift-wrap.ts";
+declare const GiftWrap_base: ServiceMap.ServiceClass<GiftWrap, "tablinum/GiftWrap", GiftWrapHandle>;
+export declare class GiftWrap extends GiftWrap_base {
+}
+export {};

package/dist/services/Identity.d.ts

@@ -0,0 +1,6 @@
+import { ServiceMap } from "effect";
+import type { Identity as IdentityShape } from "../db/identity.ts";
+declare const Identity_base: ServiceMap.ServiceClass<Identity, "tablinum/Identity", IdentityShape>;
+export declare class Identity extends Identity_base {
+}
+export {};

package/dist/services/PublishQueue.d.ts

@@ -0,0 +1,6 @@
+import { ServiceMap } from "effect";
+import type { PublishQueueHandle } from "../sync/publish-queue.ts";
+declare const PublishQueue_base: ServiceMap.ServiceClass<PublishQueue, "tablinum/PublishQueue", PublishQueueHandle>;
+export declare class PublishQueue extends PublishQueue_base {
+}
+export {};

package/dist/services/Relay.d.ts

@@ -0,0 +1,6 @@
+import { ServiceMap } from "effect";
+import type { RelayHandle } from "../sync/relay.ts";
+declare const Relay_base: ServiceMap.ServiceClass<Relay, "tablinum/Relay", RelayHandle>;
+export declare class Relay extends Relay_base {
+}
+export {};

package/dist/services/Storage.d.ts

@@ -0,0 +1,6 @@
+import { ServiceMap } from "effect";
+import type { IDBStorageHandle } from "../storage/idb.ts";
+declare const Storage_base: ServiceMap.ServiceClass<Storage, "tablinum/Storage", IDBStorageHandle>;
+export declare class Storage extends Storage_base {
+}
+export {};

package/dist/services/Sync.d.ts

@@ -0,0 +1,6 @@
+import { ServiceMap } from "effect";
+import type { SyncHandle } from "../sync/sync-service.ts";
+declare const Sync_base: ServiceMap.ServiceClass<Sync, "tablinum/Sync", SyncHandle>;
+export declare class Sync extends Sync_base {
+}
+export {};

package/dist/services/SyncStatus.d.ts

@@ -0,0 +1,6 @@
+import { ServiceMap } from "effect";
+import type { SyncStatusHandle } from "../sync/sync-status.ts";
+declare const SyncStatus_base: ServiceMap.ServiceClass<SyncStatus, "tablinum/SyncStatus", SyncStatusHandle>;
+export declare class SyncStatus extends SyncStatus_base {
+}
+export {};

package/dist/services/Tablinum.d.ts

@@ -0,0 +1,7 @@
+import { ServiceMap } from "effect";
+import type { DatabaseHandle } from "../db/database-handle.ts";
+import type { SchemaConfig } from "../schema/types.ts";
+declare const Tablinum_base: ServiceMap.ServiceClass<Tablinum, "tablinum/Tablinum", DatabaseHandle<SchemaConfig>>;
+export declare class Tablinum extends Tablinum_base {
+}
+export {};

package/dist/services/index.d.ts

@@ -0,0 +1,10 @@
+export { Config, type TablinumConfigShape } from "./Config.ts";
+export { Identity } from "./Identity.ts";
+export { EpochStore } from "./EpochStore.ts";
+export { Storage } from "./Storage.ts";
+export { Relay } from "./Relay.ts";
+export { GiftWrap } from "./GiftWrap.ts";
+export { PublishQueue } from "./PublishQueue.ts";
+export { SyncStatus } from "./SyncStatus.ts";
+export { Sync } from "./Sync.ts";
+export { Tablinum } from "./Tablinum.ts";

package/dist/storage/idb.d.ts

@@ -1,6 +1,8 @@
 import { Effect, Scope } from "effect";
+import type { NostrEvent } from "nostr-tools/pure";
 import { StorageError } from "../errors.ts";
 import type { SchemaConfig } from "../schema/types.ts";
+import type { DatabaseName } from "../brands.ts";
 export interface StoredEvent {
     readonly id: string;
     readonly collection: string;
@@ -8,10 +10,12 @@ export interface StoredEvent {
     readonly kind: "create" | "update" | "delete";
     readonly data: Record<string, unknown> | null;
     readonly createdAt: number;
+    readonly author?: string | undefined;
 }
 export interface StoredGiftWrap {
     readonly id: string;
-    readonly event: Record<string, unknown>;
+    readonly eventId?: string;
+    readonly event?: NostrEvent;
     readonly createdAt: number;
 }
 export interface IDBStorageHandle {
@@ -30,6 +34,11 @@ export interface IDBStorageHandle {
     readonly putGiftWrap: (gw: StoredGiftWrap) => Effect.Effect<void, StorageError>;
     readonly getGiftWrap: (id: string) => Effect.Effect<StoredGiftWrap | undefined, StorageError>;
     readonly getAllGiftWraps: () => Effect.Effect<ReadonlyArray<StoredGiftWrap>, StorageError>;
+    readonly deleteGiftWrap: (id: string) => Effect.Effect<void, StorageError>;
+    readonly stripGiftWrapBlob: (id: string) => Effect.Effect<void, StorageError>;
+    readonly deleteEvent: (id: string) => Effect.Effect<void, StorageError>;
+    readonly getMeta: (key: string) => Effect.Effect<unknown | undefined, StorageError>;
+    readonly putMeta: (key: string, value: unknown) => Effect.Effect<void, StorageError>;
     readonly close: () => Effect.Effect<void>;
 }
-export declare function openIDBStorage(dbName: string | undefined, schema: SchemaConfig): Effect.Effect<IDBStorageHandle, StorageError, Scope.Scope>;
+export declare function openIDBStorage(dbName: DatabaseName, schema: SchemaConfig): Effect.Effect<IDBStorageHandle, StorageError, Scope.Scope>;

package/dist/storage/lww.d.ts

@@ -2,9 +2,4 @@ export interface EventMeta {
     readonly id: string;
     readonly createdAt: number;
 }
-/**
- * Last-write-wins resolution.
- * Higher `createdAt` wins. Ties broken by lowest event ID (lexicographic).
- * Returns the winner.
- */
 export declare function resolveWinner<T extends EventMeta>(existing: T | null, incoming: T): T;

package/dist/storage/records-store.d.ts

@@ -1,12 +1,5 @@
 import { Effect } from "effect";
 import type { IDBStorageHandle, StoredEvent } from "./idb.ts";
 import type { StorageError } from "../errors.ts";
-/**
- * Apply an event to the records store using LWW resolution.
- * Returns true if the incoming event won and the record was updated.
- */
 export declare function applyEvent(storage: IDBStorageHandle, event: StoredEvent): Effect.Effect<boolean, StorageError>;
-/**
- * Rebuild the records store by clearing it and replaying all events.
- */
 export declare function rebuild(storage: IDBStorageHandle, collections: ReadonlyArray<string>): Effect.Effect<void, StorageError>;

package/dist/svelte/collection.svelte.d.ts

@@ -4,17 +4,20 @@ import type { CollectionHandle } from "../crud/collection-handle.ts";
 import { type SvelteWhereClause, type SvelteOrderByBuilder } from "./query.svelte.ts";
 export declare class Collection<C extends CollectionDef<CollectionFields>> {
     #private;
-    items: any;
-    error: any;
-    constructor(handle: CollectionHandle<C>);
+    error: Error | null;
+    /** @internal */
+    _bind(handle: CollectionHandle<C>): void;
+    /** @internal */
+    _fail(err: Error): void;
     add: (data: Omit<InferRecord<C>, "id">) => Promise<string>;
     update: (id: string, data: Partial<Omit<InferRecord<C>, "id">>) => Promise<void>;
     delete: (id: string) => Promise<void>;
-    get: (id: string) => Promise<InferRecord<C>>;
+    get(): Promise<ReadonlyArray<InferRecord<C>>>;
+    get(id: string): Promise<InferRecord<C>>;
     first: () => Promise<InferRecord<C> | null>;
     count: () => Promise<number>;
     where: (field: string & keyof Omit<InferRecord<C>, "id">) => SvelteWhereClause<InferRecord<C>>;
     orderBy: (field: string & keyof Omit<InferRecord<C>, "id">) => SvelteOrderByBuilder<InferRecord<C>>;
-    /** @internal Called by Database.close() */
-    _destroy(): void;
+    /** @internal */
+    _destroy(reason?: Error): void;
 }

package/dist/svelte/deferred.d.ts

@@ -0,0 +1,7 @@
+export interface Deferred<T> {
+    readonly promise: Promise<T>;
+    readonly settled: () => boolean;
+    readonly resolve: (value?: T | PromiseLike<T>) => void;
+    readonly reject: (reason?: unknown) => void;
+}
+export declare function createDeferred<T>(): Deferred<T>;

package/dist/svelte/index.svelte.d.ts

@@ -1,6 +1,3 @@
-import type { SchemaConfig } from "../schema/types.ts";
-import { type TablinumConfig } from "../db/create-tablinum.ts";
-import { Database } from "./database.svelte.ts";
 export { field } from "../schema/field.ts";
 export { collection } from "../schema/collection.ts";
 export type { CollectionDef, CollectionFields } from "../schema/collection.ts";
@@ -8,9 +5,12 @@ export type { FieldDef, FieldKind } from "../schema/field.ts";
 export type { InferRecord, SchemaConfig } from "../schema/types.ts";
 export type { TablinumConfig } from "../db/create-tablinum.ts";
 export type { SyncStatus } from "../db/database-handle.ts";
+export type { RelayStatus } from "../sync/relay.ts";
+export { encodeInvite, decodeInvite } from "../db/invite.ts";
+export type { Invite } from "../db/invite.ts";
+export type { EpochKey, EpochKeyInput } from "../db/epoch.ts";
+export type { MemberRecord } from "../db/members.ts";
 export { ValidationError, StorageError, CryptoError, RelayError, SyncError, NotFoundError, ClosedError, } from "../errors.ts";
-export { Database } from "./database.svelte.ts";
+export { Tablinum } from "./tablinum.svelte.ts";
 export { Collection } from "./collection.svelte.ts";
-export { LiveQuery } from "./live-query.svelte.ts";
 export type { SvelteQueryBuilder, SvelteWhereClause, SvelteOrderByBuilder, } from "./query.svelte.ts";
-export declare function createTablinum<S extends SchemaConfig>(config: TablinumConfig<S>): Promise<Database<S>>;