dirsql 0.4.95 → 0.4.97

package/dist/dirsql.d.ts

@@ -145,6 +145,8 @@ export declare class DirSQL {
      */
     get ready(): Promise<void>;
     private _inner;
+    private readonly _watchStreams;
+    private _watchPoll?;
     readonly _options: DirSQLOptions;
     /** Construct from a `.dirsql.toml` config-file path. */
     constructor(configPath: string);
@@ -208,6 +210,8 @@ export declare class DirSQL {
      * Awaits the initial scan on first iteration, starts the underlying
      * watcher, then awaits a bounded native poll each cycle. The iterator
      * runs indefinitely; break out of the `for await` loop to stop.
+     * Each stream receives every event observed after its creation, even
+     * while another stream is consuming events on the same instance.
      */
     watch(): AsyncGenerator<RowEvent, void, unknown>;
     /**

package/dist/dirsql.js

@@ -47,6 +47,8 @@ export class DirSQL {
     }
     // Initialized by `ready`. Do NOT touch before awaiting `ready`.
     _inner;
+    _watchStreams = new Set();
+    _watchPoll;
     // Constructor options preserved verbatim; public-by-design.
     _options;
     constructor(arg) {
@@ -159,18 +161,47 @@ export class DirSQL {
      * Awaits the initial scan on first iteration, starts the underlying
      * watcher, then awaits a bounded native poll each cycle. The iterator
      * runs indefinitely; break out of the `for await` loop to stop.
+     * Each stream receives every event observed after its creation, even
+     * while another stream is consuming events on the same instance.
      */
-    async *watch() {
-        await this.ready;
-        await this._inner.startWatcher();
-        while (true) {
-            // Native poll runs on the libuv threadpool; ~200ms bounds each await
-            // without starving the event loop.
-            const events = await this._inner.pollEvents(200);
-            for (const event of events) {
-                yield event;
+    watch() {
+        const buffer = [];
+        const reference = new WeakRef(buffer);
+        this._watchStreams.add(reference);
+        const owner = this;
+        return (async function* () {
+            try {
+                await owner.ready;
+                await owner._inner.startWatcher();
+                while (true) {
+                    while (buffer.length === 0) {
+                        owner._watchPoll ??= owner._inner
+                            .pollEvents(200)
+                            .then((events) => {
+                            for (const reference of owner._watchStreams) {
+                                const stream = reference.deref();
+                                if (stream) {
+                                    for (const event of events) {
+                                        stream.push(event);
+                                    }
+                                }
+                                else {
+                                    owner._watchStreams.delete(reference);
+                                }
+                            }
+                        })
+                            .finally(() => {
+                            owner._watchPoll = undefined;
+                        });
+                        await owner._watchPoll;
+                    }
+                    yield buffer.shift();
+                }
+            }
+            finally {
+                owner._watchStreams.delete(reference);
             }
-        }
+        })();
     }
     /**
      * Explicitly close the database connection. Used primarily for cleanup or

package/docs/reference/sdk.md

@@ -301,7 +301,7 @@ under the root. The watcher starts on first iteration (Python/TypeScript)
 or at the `watch()` call (Rust). The stream never terminates on its own;
 stop consuming it to stop.
 
-Python: each `watch()` call returns an independent stream, and every stream
+Python/TypeScript: each `watch()` call returns an independent stream, and every stream
 on one instance receives every event observed after it was created, so
 several consumers (one per client, say) can share one instance.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dirsql",
-  "version": "0.4.95",
+  "version": "0.4.97",
   "description": "Ephemeral SQL index over a local directory",
   "license": "MIT",
   "repository": "https://github.com/thekevinscott/dirsql",
@@ -221,10 +221,10 @@
     ]
   },
   "optionalDependencies": {
-    "@dirsql/lib-linux-x64-gnu": "0.4.95",
-    "@dirsql/lib-linux-arm64-gnu": "0.4.95",
-    "@dirsql/lib-darwin-x64": "0.4.95",
-    "@dirsql/lib-darwin-arm64": "0.4.95",
-    "@dirsql/lib-win32-x64-msvc": "0.4.95"
+    "@dirsql/lib-linux-x64-gnu": "0.4.97",
+    "@dirsql/lib-linux-arm64-gnu": "0.4.97",
+    "@dirsql/lib-darwin-x64": "0.4.97",
+    "@dirsql/lib-darwin-arm64": "0.4.97",
+    "@dirsql/lib-win32-x64-msvc": "0.4.97"
   }
 }