@monlite/core 0.8.0 → 0.10.0

package/dist/index.d.cts

@@ -1,9 +1,134 @@
+/**
+ * A collection. In **document** mode (default) every document is stored as JSON
+ * in a `data` column — schema-free. In **structured** mode (when a `schema` is
+ * given) the listed fields become real, typed SQL columns (fast, indexable,
+ * joinable) while any other fields overflow into a JSON `data` column. The CRUD
+ * and query API is identical in both modes.
+ */
+declare class Collection<T = Doc> {
+    private readonly mon;
+    readonly name: string;
+    readonly mode: CollectionMode;
+    private initialized;
+    private readonly columnDefs;
+    private readonly columnOrder;
+    /** Declared native columns (empty in document mode). */
+    private readonly columns;
+    private readonly jsonColumns;
+    private insertSqlCache?;
+    private readonly trackPath;
+    constructor(mon: Monlite, name: string, options?: CollectionOptions);
+    private get db();
+    /** Run a DB operation, normalizing driver errors into typed MonliteErrors. */
+    private guard;
+    /** Native column names declared for this collection (structured mode). */
+    get columnNames(): string[];
+    private ensureTable;
+    private columnDdl;
+    /** Auto-additive migration: add declared columns missing from an existing table. */
+    private migrateColumns;
+    private rowToDoc;
+    private encodeColumn;
+    private insertColumns;
+    private insertSql;
+    /** Split an input document into a row aligned with `insertColumns()`. */
+    private buildInsert;
+    /** Build the `SET` clause + values to persist an updated document. */
+    private buildUpdateSet;
+    /** Sync store for recording local changes (both document and structured). */
+    private get recorder();
+    /** @internal Read a full document by id (mode-aware), synchronously. */
+    getRaw(id: string): WithId<T> | null;
+    /**
+     * @internal Apply a remote change to storage WITHOUT recording it to the
+     * change feed (the sync store records the `remote` feed row itself). Used by
+     * `@monlite/sync` so structured collections sync correctly through the same
+     * column/overflow split as local writes.
+     */
+    applyRemoteWrite(op: "upsert" | "delete", id: string, doc: Record<string, any> | undefined, ts: number): void;
+    /** @internal Notify reactivity watchers and plugins that documents changed. */
+    private afterWrite;
+    create(args: CreateArgs<T>): Promise<WithId<T>>;
+    createMany(args: CreateManyArgs<T>): Promise<{
+        count: number;
+    }>;
+    private buildFindSql;
+    /** @internal Synchronous core of findMany (used by reactivity). */
+    findManyCore(args?: FindManyArgs<T>): WithId<T>[];
+    /** @internal Synchronous core of exists (used by reactivity). */
+    existsCore(where: WhereInput<T> | undefined): boolean;
+    findMany(args?: FindManyArgs<T>): Promise<WithId<T>[]>;
+    findFirst(args?: FindFirstArgs<T>): Promise<WithId<T> | null>;
+    /** Alias of {@link findFirst} for Prisma familiarity. */
+    findUnique(args?: FindFirstArgs<T>): Promise<WithId<T> | null>;
+    /** Like {@link findFirst} but throws if no document matches. */
+    findFirstOrThrow(args?: FindFirstArgs<T>): Promise<WithId<T>>;
+    /** True if at least one document matches. */
+    exists(where?: WhereInput<T>): Promise<boolean>;
+    /**
+     * Subscribe to a live query. The callback fires immediately with the current
+     * results (`type: "init"`) and again whenever a change affects the result set
+     * (row-level: only relevant changes trigger a recompute). Includes changes
+     * applied by `@monlite/sync`.
+     */
+    watch(args: FindManyArgs<T> | undefined, cb: (event: LiveEvent<T>) => void): WatchHandle<T>;
+    /** Show SQLite's query plan for a `findMany`, and whether it uses an index. */
+    explain(args?: FindManyArgs<T>): Promise<ExplainResult>;
+    findById(id: string): Promise<WithId<T> | null>;
+    count(args?: CountArgs<T>): Promise<number>;
+    /**
+     * Return the distinct values of a field. Array fields stored in JSON are
+     * unwound (each element counts as a value), matching MongoDB's `distinct`.
+     */
+    distinct(field: string, where?: WhereInput<T>): Promise<any[]>;
+    private runUpdate;
+    update(args: UpdateArgs<T>): Promise<WithId<T> | null>;
+    updateMany(args: UpdateArgs<T>): Promise<{
+        count: number;
+    }>;
+    upsert(args: UpsertArgs<T>): Promise<WithId<T>>;
+    private runDelete;
+    delete(args: DeleteArgs<T>): Promise<WithId<T> | null>;
+    deleteMany(args?: DeleteArgs<T>): Promise<{
+        count: number;
+    }>;
+    aggregate(args?: AggregateArgs<T>): Promise<AggregateResult>;
+    groupBy(args: GroupByArgs<T>): Promise<GroupByResult[]>;
+}
+
+/** Documents that changed in a single write, delivered to `afterWrite`. */
+interface PluginChange {
+    collection: string;
+    ids: string[];
+}
+/**
+ * A monlite plugin. Plugins keep `@monlite/core` lean — heavier or optional
+ * capabilities (full-text search, vector, encryption) live in their own
+ * packages and hook in here.
+ */
+interface MonlitePlugin {
+    name: string;
+    /** Called once when the database opens (e.g. to create auxiliary tables). */
+    init?(db: Monlite): void;
+    /**
+     * Called synchronously after every committed write (including changes applied
+     * by `@monlite/sync`), so derived state like a search index stays in sync.
+     */
+    afterWrite?(db: Monlite, change: PluginChange): void;
+    /**
+     * Methods to attach to every collection handle (e.g. `search`). The impl
+     * receives the collection as its first argument, then the caller's arguments.
+     */
+    collectionMethods?: Record<string, (collection: Collection<any>, ...args: any[]) => any>;
+}
+
 /**
  * Public type surface for monlite.
  *
  * Documents are plain objects. monlite adds three system fields to every
  * stored document: `_id`, `created_at`, and `updated_at`.
  */
+
 /** A free-form document. */
 type Doc = Record<string, any>;
 /** System fields monlite manages on every document. */
@@ -238,6 +363,8 @@ interface MonliteOptions {
      * when installed, otherwise the built-in `node:sqlite` (Node >= 22.5).
      */
     driver?: DriverName;
+    /** Opt-in plugins (e.g. `@monlite/fts`). */
+    plugins?: MonlitePlugin[];
     /**
      * Enable sync metadata (change feed, tombstones, version tracking) so the
      * database can replicate via `@monlite/sync`. Off by default — adds zero
@@ -259,108 +386,12 @@ interface MonliteOptions {
     wal?: boolean;
     /** Milliseconds to wait on a locked database before erroring. Default `5000`. */
     busyTimeout?: number;
+    /** Allow loading SQLite extensions (required by `@monlite/vector`). Default `false`. */
+    allowExtensions?: boolean;
     /** Verbose logger for executed SQL (debugging). */
     verbose?: (sql: string) => void;
 }
 
-/**
- * A collection. In **document** mode (default) every document is stored as JSON
- * in a `data` column — schema-free. In **structured** mode (when a `schema` is
- * given) the listed fields become real, typed SQL columns (fast, indexable,
- * joinable) while any other fields overflow into a JSON `data` column. The CRUD
- * and query API is identical in both modes.
- */
-declare class Collection<T = Doc> {
-    private readonly mon;
-    readonly name: string;
-    readonly mode: CollectionMode;
-    private initialized;
-    private readonly columnDefs;
-    private readonly columnOrder;
-    /** Declared native columns (empty in document mode). */
-    private readonly columns;
-    private readonly jsonColumns;
-    private insertSqlCache?;
-    private readonly trackPath;
-    constructor(mon: Monlite, name: string, options?: CollectionOptions);
-    private get db();
-    /** Run a DB operation, normalizing driver errors into typed MonliteErrors. */
-    private guard;
-    /** Native column names declared for this collection (structured mode). */
-    get columnNames(): string[];
-    private ensureTable;
-    private columnDdl;
-    /** Auto-additive migration: add declared columns missing from an existing table. */
-    private migrateColumns;
-    private rowToDoc;
-    private encodeColumn;
-    private insertColumns;
-    private insertSql;
-    /** Split an input document into a row aligned with `insertColumns()`. */
-    private buildInsert;
-    /** Build the `SET` clause + values to persist an updated document. */
-    private buildUpdateSet;
-    /** Sync store for recording local changes (both document and structured). */
-    private get recorder();
-    /** @internal Read a full document by id (mode-aware), synchronously. */
-    getRaw(id: string): WithId<T> | null;
-    /**
-     * @internal Apply a remote change to storage WITHOUT recording it to the
-     * change feed (the sync store records the `remote` feed row itself). Used by
-     * `@monlite/sync` so structured collections sync correctly through the same
-     * column/overflow split as local writes.
-     */
-    applyRemoteWrite(op: "upsert" | "delete", id: string, doc: Record<string, any> | undefined, ts: number): void;
-    /** @internal Notify reactivity watchers that documents changed. */
-    private afterWrite;
-    create(args: CreateArgs<T>): Promise<WithId<T>>;
-    createMany(args: CreateManyArgs<T>): Promise<{
-        count: number;
-    }>;
-    private buildFindSql;
-    /** @internal Synchronous core of findMany (used by reactivity). */
-    findManyCore(args?: FindManyArgs<T>): WithId<T>[];
-    /** @internal Synchronous core of exists (used by reactivity). */
-    existsCore(where: WhereInput<T> | undefined): boolean;
-    findMany(args?: FindManyArgs<T>): Promise<WithId<T>[]>;
-    findFirst(args?: FindFirstArgs<T>): Promise<WithId<T> | null>;
-    /** Alias of {@link findFirst} for Prisma familiarity. */
-    findUnique(args?: FindFirstArgs<T>): Promise<WithId<T> | null>;
-    /** Like {@link findFirst} but throws if no document matches. */
-    findFirstOrThrow(args?: FindFirstArgs<T>): Promise<WithId<T>>;
-    /** True if at least one document matches. */
-    exists(where?: WhereInput<T>): Promise<boolean>;
-    /**
-     * Subscribe to a live query. The callback fires immediately with the current
-     * results (`type: "init"`) and again whenever a change affects the result set
-     * (row-level: only relevant changes trigger a recompute). Includes changes
-     * applied by `@monlite/sync`.
-     */
-    watch(args: FindManyArgs<T> | undefined, cb: (event: LiveEvent<T>) => void): WatchHandle<T>;
-    /** Show SQLite's query plan for a `findMany`, and whether it uses an index. */
-    explain(args?: FindManyArgs<T>): Promise<ExplainResult>;
-    findById(id: string): Promise<WithId<T> | null>;
-    count(args?: CountArgs<T>): Promise<number>;
-    /**
-     * Return the distinct values of a field. Array fields stored in JSON are
-     * unwound (each element counts as a value), matching MongoDB's `distinct`.
-     */
-    distinct(field: string, where?: WhereInput<T>): Promise<any[]>;
-    private runUpdate;
-    update(args: UpdateArgs<T>): Promise<WithId<T> | null>;
-    updateMany(args: UpdateArgs<T>): Promise<{
-        count: number;
-    }>;
-    upsert(args: UpsertArgs<T>): Promise<WithId<T>>;
-    private runDelete;
-    delete(args: DeleteArgs<T>): Promise<WithId<T> | null>;
-    deleteMany(args?: DeleteArgs<T>): Promise<{
-        count: number;
-    }>;
-    aggregate(args?: AggregateArgs<T>): Promise<AggregateResult>;
-    groupBy(args: GroupByArgs<T>): Promise<GroupByResult[]>;
-}
-
 /**
  * The minimal SQLite driver surface monlite needs. Implemented by both the
  * better-sqlite3 and the built-in node:sqlite backends so the rest of the
@@ -581,8 +612,11 @@ declare class Monlite {
     /** @internal Sync metadata store; present only when `{ sync: true }`. */
     readonly $sync?: SyncStore;
     private readonly collections;
+    private readonly plugins;
     private closed;
     constructor(filename: string, options?: MonliteOptions);
+    /** @internal Notify plugins that documents changed (post-commit). */
+    firePluginAfterWrite(collection: string, ids: string[]): void;
     /** Stable node id for LWW tie-breaking (only when sync is enabled). */
     get nodeId(): string | undefined;
     /** The underlying native database handle (escape hatch). */
@@ -683,4 +717,4 @@ declare function objectId(): string;
 /** True when a value looks like a monlite/ObjectId id (24 hex chars). */
 declare function isObjectId(value: unknown): value is string;
 
-export { type AggregateArgs, type AggregateResult, type ApplyResult, Collection, type CollectionMode, type CollectionOptions, type CollectionSchema, type ColumnDef, type ColumnInfo, type ColumnType, type ConflictResolver, type ConflictRow, type CountArgs, type CreateArgs, type CreateManyArgs, Monlite as Db, type DeleteArgs, type Doc, type Driver, type DriverName, type ExplainResult, type FieldFilter, type FieldSelection, type FilterInput, type FindFirstArgs, type FindManyArgs, type GroupByArgs, type GroupByResult, type HavingComparison, type HavingInput, type LiveEvent, type LocalChange, Monlite, MonliteConstraintError, MonliteError, MonliteForeignKeyError, MonliteNotNullError, type MonliteOptions, MonliteQueryError, MonliteUniqueConstraintError, type OrderBy, type PreparedStatement, type RemoteChange, type Select, type SortOrder, type SyncOp, type SyncStateRow, SyncStore, type SystemFields, type UpdateArgs, type UpdateData, type UpdateOperators, type UpsertArgs, type Version, type WatchHandle, type WhereInput as WhereClause, type WhereInput, type WithId, compareVersions, createDb, isObjectId, makeVersion, normalizeDriverError, objectId, versionTs };
+export { type AggregateArgs, type AggregateResult, type ApplyResult, Collection, type CollectionMode, type CollectionOptions, type CollectionSchema, type ColumnDef, type ColumnInfo, type ColumnType, type ConflictResolver, type ConflictRow, type CountArgs, type CreateArgs, type CreateManyArgs, Monlite as Db, type DeleteArgs, type Doc, type Driver, type DriverName, type ExplainResult, type FieldFilter, type FieldSelection, type FilterInput, type FindFirstArgs, type FindManyArgs, type GroupByArgs, type GroupByResult, type HavingComparison, type HavingInput, type LiveEvent, type LocalChange, Monlite, MonliteConstraintError, MonliteError, MonliteForeignKeyError, MonliteNotNullError, type MonliteOptions, type MonlitePlugin, MonliteQueryError, MonliteUniqueConstraintError, type OrderBy, type PluginChange, type PreparedStatement, type RemoteChange, type Select, type SortOrder, type SyncOp, type SyncStateRow, SyncStore, type SystemFields, type UpdateArgs, type UpdateData, type UpdateOperators, type UpsertArgs, type Version, type WatchHandle, type WhereInput as WhereClause, type WhereInput, type WithId, compareVersions, createDb, isObjectId, makeVersion, normalizeDriverError, objectId, versionTs };

package/dist/index.d.ts

@@ -1,9 +1,134 @@
+/**
+ * A collection. In **document** mode (default) every document is stored as JSON
+ * in a `data` column — schema-free. In **structured** mode (when a `schema` is
+ * given) the listed fields become real, typed SQL columns (fast, indexable,
+ * joinable) while any other fields overflow into a JSON `data` column. The CRUD
+ * and query API is identical in both modes.
+ */
+declare class Collection<T = Doc> {
+    private readonly mon;
+    readonly name: string;
+    readonly mode: CollectionMode;
+    private initialized;
+    private readonly columnDefs;
+    private readonly columnOrder;
+    /** Declared native columns (empty in document mode). */
+    private readonly columns;
+    private readonly jsonColumns;
+    private insertSqlCache?;
+    private readonly trackPath;
+    constructor(mon: Monlite, name: string, options?: CollectionOptions);
+    private get db();
+    /** Run a DB operation, normalizing driver errors into typed MonliteErrors. */
+    private guard;
+    /** Native column names declared for this collection (structured mode). */
+    get columnNames(): string[];
+    private ensureTable;
+    private columnDdl;
+    /** Auto-additive migration: add declared columns missing from an existing table. */
+    private migrateColumns;
+    private rowToDoc;
+    private encodeColumn;
+    private insertColumns;
+    private insertSql;
+    /** Split an input document into a row aligned with `insertColumns()`. */
+    private buildInsert;
+    /** Build the `SET` clause + values to persist an updated document. */
+    private buildUpdateSet;
+    /** Sync store for recording local changes (both document and structured). */
+    private get recorder();
+    /** @internal Read a full document by id (mode-aware), synchronously. */
+    getRaw(id: string): WithId<T> | null;
+    /**
+     * @internal Apply a remote change to storage WITHOUT recording it to the
+     * change feed (the sync store records the `remote` feed row itself). Used by
+     * `@monlite/sync` so structured collections sync correctly through the same
+     * column/overflow split as local writes.
+     */
+    applyRemoteWrite(op: "upsert" | "delete", id: string, doc: Record<string, any> | undefined, ts: number): void;
+    /** @internal Notify reactivity watchers and plugins that documents changed. */
+    private afterWrite;
+    create(args: CreateArgs<T>): Promise<WithId<T>>;
+    createMany(args: CreateManyArgs<T>): Promise<{
+        count: number;
+    }>;
+    private buildFindSql;
+    /** @internal Synchronous core of findMany (used by reactivity). */
+    findManyCore(args?: FindManyArgs<T>): WithId<T>[];
+    /** @internal Synchronous core of exists (used by reactivity). */
+    existsCore(where: WhereInput<T> | undefined): boolean;
+    findMany(args?: FindManyArgs<T>): Promise<WithId<T>[]>;
+    findFirst(args?: FindFirstArgs<T>): Promise<WithId<T> | null>;
+    /** Alias of {@link findFirst} for Prisma familiarity. */
+    findUnique(args?: FindFirstArgs<T>): Promise<WithId<T> | null>;
+    /** Like {@link findFirst} but throws if no document matches. */
+    findFirstOrThrow(args?: FindFirstArgs<T>): Promise<WithId<T>>;
+    /** True if at least one document matches. */
+    exists(where?: WhereInput<T>): Promise<boolean>;
+    /**
+     * Subscribe to a live query. The callback fires immediately with the current
+     * results (`type: "init"`) and again whenever a change affects the result set
+     * (row-level: only relevant changes trigger a recompute). Includes changes
+     * applied by `@monlite/sync`.
+     */
+    watch(args: FindManyArgs<T> | undefined, cb: (event: LiveEvent<T>) => void): WatchHandle<T>;
+    /** Show SQLite's query plan for a `findMany`, and whether it uses an index. */
+    explain(args?: FindManyArgs<T>): Promise<ExplainResult>;
+    findById(id: string): Promise<WithId<T> | null>;
+    count(args?: CountArgs<T>): Promise<number>;
+    /**
+     * Return the distinct values of a field. Array fields stored in JSON are
+     * unwound (each element counts as a value), matching MongoDB's `distinct`.
+     */
+    distinct(field: string, where?: WhereInput<T>): Promise<any[]>;
+    private runUpdate;
+    update(args: UpdateArgs<T>): Promise<WithId<T> | null>;
+    updateMany(args: UpdateArgs<T>): Promise<{
+        count: number;
+    }>;
+    upsert(args: UpsertArgs<T>): Promise<WithId<T>>;
+    private runDelete;
+    delete(args: DeleteArgs<T>): Promise<WithId<T> | null>;
+    deleteMany(args?: DeleteArgs<T>): Promise<{
+        count: number;
+    }>;
+    aggregate(args?: AggregateArgs<T>): Promise<AggregateResult>;
+    groupBy(args: GroupByArgs<T>): Promise<GroupByResult[]>;
+}
+
+/** Documents that changed in a single write, delivered to `afterWrite`. */
+interface PluginChange {
+    collection: string;
+    ids: string[];
+}
+/**
+ * A monlite plugin. Plugins keep `@monlite/core` lean — heavier or optional
+ * capabilities (full-text search, vector, encryption) live in their own
+ * packages and hook in here.
+ */
+interface MonlitePlugin {
+    name: string;
+    /** Called once when the database opens (e.g. to create auxiliary tables). */
+    init?(db: Monlite): void;
+    /**
+     * Called synchronously after every committed write (including changes applied
+     * by `@monlite/sync`), so derived state like a search index stays in sync.
+     */
+    afterWrite?(db: Monlite, change: PluginChange): void;
+    /**
+     * Methods to attach to every collection handle (e.g. `search`). The impl
+     * receives the collection as its first argument, then the caller's arguments.
+     */
+    collectionMethods?: Record<string, (collection: Collection<any>, ...args: any[]) => any>;
+}
+
 /**
  * Public type surface for monlite.
  *
  * Documents are plain objects. monlite adds three system fields to every
  * stored document: `_id`, `created_at`, and `updated_at`.
  */
+
 /** A free-form document. */
 type Doc = Record<string, any>;
 /** System fields monlite manages on every document. */
@@ -238,6 +363,8 @@ interface MonliteOptions {
      * when installed, otherwise the built-in `node:sqlite` (Node >= 22.5).
      */
     driver?: DriverName;
+    /** Opt-in plugins (e.g. `@monlite/fts`). */
+    plugins?: MonlitePlugin[];
     /**
      * Enable sync metadata (change feed, tombstones, version tracking) so the
      * database can replicate via `@monlite/sync`. Off by default — adds zero
@@ -259,108 +386,12 @@ interface MonliteOptions {
     wal?: boolean;
     /** Milliseconds to wait on a locked database before erroring. Default `5000`. */
     busyTimeout?: number;
+    /** Allow loading SQLite extensions (required by `@monlite/vector`). Default `false`. */
+    allowExtensions?: boolean;
     /** Verbose logger for executed SQL (debugging). */
     verbose?: (sql: string) => void;
 }
 
-/**
- * A collection. In **document** mode (default) every document is stored as JSON
- * in a `data` column — schema-free. In **structured** mode (when a `schema` is
- * given) the listed fields become real, typed SQL columns (fast, indexable,
- * joinable) while any other fields overflow into a JSON `data` column. The CRUD
- * and query API is identical in both modes.
- */
-declare class Collection<T = Doc> {
-    private readonly mon;
-    readonly name: string;
-    readonly mode: CollectionMode;
-    private initialized;
-    private readonly columnDefs;
-    private readonly columnOrder;
-    /** Declared native columns (empty in document mode). */
-    private readonly columns;
-    private readonly jsonColumns;
-    private insertSqlCache?;
-    private readonly trackPath;
-    constructor(mon: Monlite, name: string, options?: CollectionOptions);
-    private get db();
-    /** Run a DB operation, normalizing driver errors into typed MonliteErrors. */
-    private guard;
-    /** Native column names declared for this collection (structured mode). */
-    get columnNames(): string[];
-    private ensureTable;
-    private columnDdl;
-    /** Auto-additive migration: add declared columns missing from an existing table. */
-    private migrateColumns;
-    private rowToDoc;
-    private encodeColumn;
-    private insertColumns;
-    private insertSql;
-    /** Split an input document into a row aligned with `insertColumns()`. */
-    private buildInsert;
-    /** Build the `SET` clause + values to persist an updated document. */
-    private buildUpdateSet;
-    /** Sync store for recording local changes (both document and structured). */
-    private get recorder();
-    /** @internal Read a full document by id (mode-aware), synchronously. */
-    getRaw(id: string): WithId<T> | null;
-    /**
-     * @internal Apply a remote change to storage WITHOUT recording it to the
-     * change feed (the sync store records the `remote` feed row itself). Used by
-     * `@monlite/sync` so structured collections sync correctly through the same
-     * column/overflow split as local writes.
-     */
-    applyRemoteWrite(op: "upsert" | "delete", id: string, doc: Record<string, any> | undefined, ts: number): void;
-    /** @internal Notify reactivity watchers that documents changed. */
-    private afterWrite;
-    create(args: CreateArgs<T>): Promise<WithId<T>>;
-    createMany(args: CreateManyArgs<T>): Promise<{
-        count: number;
-    }>;
-    private buildFindSql;
-    /** @internal Synchronous core of findMany (used by reactivity). */
-    findManyCore(args?: FindManyArgs<T>): WithId<T>[];
-    /** @internal Synchronous core of exists (used by reactivity). */
-    existsCore(where: WhereInput<T> | undefined): boolean;
-    findMany(args?: FindManyArgs<T>): Promise<WithId<T>[]>;
-    findFirst(args?: FindFirstArgs<T>): Promise<WithId<T> | null>;
-    /** Alias of {@link findFirst} for Prisma familiarity. */
-    findUnique(args?: FindFirstArgs<T>): Promise<WithId<T> | null>;
-    /** Like {@link findFirst} but throws if no document matches. */
-    findFirstOrThrow(args?: FindFirstArgs<T>): Promise<WithId<T>>;
-    /** True if at least one document matches. */
-    exists(where?: WhereInput<T>): Promise<boolean>;
-    /**
-     * Subscribe to a live query. The callback fires immediately with the current
-     * results (`type: "init"`) and again whenever a change affects the result set
-     * (row-level: only relevant changes trigger a recompute). Includes changes
-     * applied by `@monlite/sync`.
-     */
-    watch(args: FindManyArgs<T> | undefined, cb: (event: LiveEvent<T>) => void): WatchHandle<T>;
-    /** Show SQLite's query plan for a `findMany`, and whether it uses an index. */
-    explain(args?: FindManyArgs<T>): Promise<ExplainResult>;
-    findById(id: string): Promise<WithId<T> | null>;
-    count(args?: CountArgs<T>): Promise<number>;
-    /**
-     * Return the distinct values of a field. Array fields stored in JSON are
-     * unwound (each element counts as a value), matching MongoDB's `distinct`.
-     */
-    distinct(field: string, where?: WhereInput<T>): Promise<any[]>;
-    private runUpdate;
-    update(args: UpdateArgs<T>): Promise<WithId<T> | null>;
-    updateMany(args: UpdateArgs<T>): Promise<{
-        count: number;
-    }>;
-    upsert(args: UpsertArgs<T>): Promise<WithId<T>>;
-    private runDelete;
-    delete(args: DeleteArgs<T>): Promise<WithId<T> | null>;
-    deleteMany(args?: DeleteArgs<T>): Promise<{
-        count: number;
-    }>;
-    aggregate(args?: AggregateArgs<T>): Promise<AggregateResult>;
-    groupBy(args: GroupByArgs<T>): Promise<GroupByResult[]>;
-}
-
 /**
  * The minimal SQLite driver surface monlite needs. Implemented by both the
  * better-sqlite3 and the built-in node:sqlite backends so the rest of the
@@ -581,8 +612,11 @@ declare class Monlite {
     /** @internal Sync metadata store; present only when `{ sync: true }`. */
     readonly $sync?: SyncStore;
     private readonly collections;
+    private readonly plugins;
     private closed;
     constructor(filename: string, options?: MonliteOptions);
+    /** @internal Notify plugins that documents changed (post-commit). */
+    firePluginAfterWrite(collection: string, ids: string[]): void;
     /** Stable node id for LWW tie-breaking (only when sync is enabled). */
     get nodeId(): string | undefined;
     /** The underlying native database handle (escape hatch). */
@@ -683,4 +717,4 @@ declare function objectId(): string;
 /** True when a value looks like a monlite/ObjectId id (24 hex chars). */
 declare function isObjectId(value: unknown): value is string;
 
-export { type AggregateArgs, type AggregateResult, type ApplyResult, Collection, type CollectionMode, type CollectionOptions, type CollectionSchema, type ColumnDef, type ColumnInfo, type ColumnType, type ConflictResolver, type ConflictRow, type CountArgs, type CreateArgs, type CreateManyArgs, Monlite as Db, type DeleteArgs, type Doc, type Driver, type DriverName, type ExplainResult, type FieldFilter, type FieldSelection, type FilterInput, type FindFirstArgs, type FindManyArgs, type GroupByArgs, type GroupByResult, type HavingComparison, type HavingInput, type LiveEvent, type LocalChange, Monlite, MonliteConstraintError, MonliteError, MonliteForeignKeyError, MonliteNotNullError, type MonliteOptions, MonliteQueryError, MonliteUniqueConstraintError, type OrderBy, type PreparedStatement, type RemoteChange, type Select, type SortOrder, type SyncOp, type SyncStateRow, SyncStore, type SystemFields, type UpdateArgs, type UpdateData, type UpdateOperators, type UpsertArgs, type Version, type WatchHandle, type WhereInput as WhereClause, type WhereInput, type WithId, compareVersions, createDb, isObjectId, makeVersion, normalizeDriverError, objectId, versionTs };
+export { type AggregateArgs, type AggregateResult, type ApplyResult, Collection, type CollectionMode, type CollectionOptions, type CollectionSchema, type ColumnDef, type ColumnInfo, type ColumnType, type ConflictResolver, type ConflictRow, type CountArgs, type CreateArgs, type CreateManyArgs, Monlite as Db, type DeleteArgs, type Doc, type Driver, type DriverName, type ExplainResult, type FieldFilter, type FieldSelection, type FilterInput, type FindFirstArgs, type FindManyArgs, type GroupByArgs, type GroupByResult, type HavingComparison, type HavingInput, type LiveEvent, type LocalChange, Monlite, MonliteConstraintError, MonliteError, MonliteForeignKeyError, MonliteNotNullError, type MonliteOptions, type MonlitePlugin, MonliteQueryError, MonliteUniqueConstraintError, type OrderBy, type PluginChange, type PreparedStatement, type RemoteChange, type Select, type SortOrder, type SyncOp, type SyncStateRow, SyncStore, type SystemFields, type UpdateArgs, type UpdateData, type UpdateOperators, type UpsertArgs, type Version, type WatchHandle, type WhereInput as WhereClause, type WhereInput, type WithId, compareVersions, createDb, isObjectId, makeVersion, normalizeDriverError, objectId, versionTs };

package/dist/index.js

@@ -949,9 +949,11 @@ var Collection = class {
     ).run(...values);
     this.afterWrite([id]);
   }
-  /** @internal Notify reactivity watchers that documents changed. */
+  /** @internal Notify reactivity watchers and plugins that documents changed. */
   afterWrite(ids) {
+    if (ids.length === 0) return;
     this.mon.reactor.emit(this.name, ids);
+    this.mon.firePluginAfterWrite(this.name, ids);
   }
   /* ----------------------------- create ----------------------------- */
   async create(args) {
@@ -1368,8 +1370,10 @@ var NodeSqliteDriver = class {
     this.verbose = options.verbose;
     const { DatabaseSync } = nodeSqlite;
     this.raw = new DatabaseSync(filename, {
-      readOnly: options.readonly ?? false
+      readOnly: options.readonly ?? false,
+      ...options.allowExtensions ? { allowExtension: true } : {}
     });
+    if (options.allowExtensions) this.raw.enableLoadExtension(true);
     this.raw.exec(`PRAGMA busy_timeout = ${options.busyTimeout ?? 5e3}`);
     if (!options.readonly && (options.wal ?? true)) {
       this.raw.exec("PRAGMA journal_mode = WAL");
@@ -1885,6 +1889,7 @@ var Monlite = class {
   /** @internal Sync metadata store; present only when `{ sync: true }`. */
   $sync;
   collections = /* @__PURE__ */ new Map();
+  plugins;
   closed = false;
   constructor(filename, options = {}) {
     this.driver = createDriver(filename, {
@@ -1892,6 +1897,7 @@ var Monlite = class {
       readonly: options.readonly,
       wal: options.wal,
       busyTimeout: options.busyTimeout,
+      allowExtensions: options.allowExtensions,
       verbose: options.verbose
     });
     this.autoIndexer = new AutoIndexer(
@@ -1902,6 +1908,15 @@ var Monlite = class {
     if (options.sync) {
       this.$sync = new SyncStore(this.driver, options.nodeId, this);
     }
+    this.plugins = options.plugins ?? [];
+    for (const plugin of this.plugins) plugin.init?.(this);
+  }
+  /** @internal Notify plugins that documents changed (post-commit). */
+  firePluginAfterWrite(collection, ids) {
+    if (this.plugins.length === 0 || ids.length === 0) return;
+    for (const plugin of this.plugins) {
+      plugin.afterWrite?.(this, { collection, ids });
+    }
   }
   /** Stable node id for LWW tie-breaking (only when sync is enabled). */
   get nodeId() {
@@ -1927,6 +1942,13 @@ var Monlite = class {
     if (!col) {
       col = new Collection(this, name, options);
       this.collections.set(name, col);
+      for (const plugin of this.plugins) {
+        for (const [method, impl] of Object.entries(
+          plugin.collectionMethods ?? {}
+        )) {
+          col[method] = (...args) => impl(col, ...args);
+        }
+      }
     } else if (options?.schema) {
       const requested = Object.keys(options.schema);
       const existing = new Set(col.columnNames);