@metreeca/keep 0.9.0 → 0.11.0

package/dist/stores/caching.js

@@ -0,0 +1,320 @@
+/*
+ * Copyright © 2025-2026 Metreeca srl
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Caching store wrapper.
+ *
+ * Speeds up read-heavy workloads by serving repeated retrievals from an in-memory cache. The cache stays bounded
+ * by size and age, shares concurrent identical retrievals, and stays coherent with writes made through the store, by
+ * other clients, or signalled by the backend.
+ *
+ * @module
+ */
+import { isArray, isObject } from "@metreeca/core";
+import { immutable } from "@metreeca/core/values";
+/**
+ * Creates a caching store backed by a delegate.
+ *
+ * Serves repeated retrievals from an in-memory cache, sparing the delegate a round-trip whenever a prior result can
+ * be reused. This cuts latency and backend load for read-heavy workloads, while writes and eviction keep cached
+ * results coherent and bounded.
+ *
+ * Results are cached by `entry`, `model`, and the `locale` and `limit` of the {@link Store.lookup lookup} retrieval scope.
+ * Templates differing only in member or element order share a cached result.
+ *
+ * > [!IMPORTANT]
+ * > `shape` is not part of the cache key. A retrieval result MUST depend only on `entry`, `model`, `locale` and
+ * > `limit`, with `shape` supplying structural metadata that does not affect the returned payload.
+ *
+ * > [!IMPORTANT]
+ * > The scope `locale` is part of the cache key, because it selects which localised content a retrieval returns.
+ * > Unlike the model, the locale priority list is order-significant: `["en", "it"]` and `["it", "en"]` are cached
+ * > separately. An omitted and an empty locale list share a single cached result, distinct from any explicit list.
+ *
+ * > [!IMPORTANT]
+ * > The scope `limit` is part of the cache key, because it caps the page size of each collection and so changes the
+ * > returned payload. An omitted and a `0` limit share a single cached result. The scope `plain` and `depth` are not
+ * > part of the key: they only accept or reject a model, and never alter a successful payload.
+ *
+ * The cache offers three observable guarantees:
+ *
+ * - **coalescing** — concurrent retrievals for the same key resolve from a single delegate fetch, and a failed
+ *   retrieval or one finding no resource is never cached, so a later retrieval re-fetches;
+ * - **read-after-write coherence** — a retrieval never returns content staler than the latest write made through this
+ *   store: {@link Store.create create}, {@link Store.update update}, {@link Store.delete delete},
+ *   {@link Store.insert insert} and {@link Store.remove remove} invalidate matching entries, and a
+ *   retrieval overlapping an in-progress write to the same entry is served from the delegate without being cached;
+ * - **commit coherence** — writes committed through {@link Store.execute execute}, by other clients sharing the
+ *   delegate, or signalled by the backend invalidate matching entries on commit, for as long as the store stays open
+ *   ({@link Store.close close} ends further invalidation).
+ *
+ * The configurable `match` predicate selects which cached entries a write invalidates.
+ *
+ * > [!IMPORTANT]
+ * > **Transaction Isolation** — Inherited from the wrapped {@link Store}.
+ *
+ * > [!IMPORTANT]
+ * > **Mutation Events** — Inherited from the wrapped {@link Store}.
+ *
+ * @param store - The delegate store to cache
+ * @param options - Cache configuration options
+ *
+ * @returns An immutable store with caching behaviour
+ *
+ * @example
+ * ```typescript
+ * const cache = createCachingStore(restStore, { size: 1_000, ttl: 60_000 });
+ * const product = await cache.lookup({ entry, shape, model });
+ * ```
+ */
+export function createCachingStore(store, { size = 0, ttl = 0, match = () => true } = {}) {
+    // LRU ordering is supplied for free by `Map`'s insertion-order iteration: every hit re-sets the entry,
+    // moving it to the tail, so `cache.keys().next().value` is always the least-recently-used key.
+    const cache = new Map();
+    // Tracks entries with at least one in-flight wrapper-initiated write. Reads of these entries bypass the
+    // cache entirely: they still query the delegate, but their result is not stored. This closes the window
+    // between a lookup call resolving with a pre-commit value and the reactive observer firing on commit, during
+    // which the cache would otherwise hold a stale-but-fresh-looking record.
+    const writing = new Map();
+    // Reactive invalidation: subscribe to the delegate's mutation events and drop matching records on commit.
+    // Covers writes routed through `execute`, writes from other clients sharing the delegate, and backends that
+    // emit storage-level events. The subscription is released by `close()` so the delegate does not retain a
+    // reference to a discarded wrapper.
+    const unsubscribe = store.observe(mutations => {
+        Object.keys(mutations).forEach(invalidate);
+    });
+    return immutable({
+        lookup({ entry, shape, model }, opts) {
+            return memoise(entry, model, opts, () => store.lookup({ entry, shape, model }, opts));
+        },
+        create({ entry, shape, model, state }) {
+            return write(entry, () => store.create({ entry, shape, model, state }));
+        },
+        update({ entry, shape, state }) {
+            return write(entry, () => store.update({ entry, shape, state }));
+        },
+        delete({ entry, shape }) {
+            return write(entry, () => store.delete({ entry, shape }));
+        },
+        insert({ entry, shape, state }) {
+            return write(entry, () => store.insert({ entry, shape, state }));
+        },
+        remove({ entry, shape }) {
+            return write(entry, () => store.remove({ entry, shape }));
+        },
+        observe(observer, resources) {
+            return store.observe(observer, resources);
+        },
+        execute(task) {
+            return store.execute(task); // task mutations invalidate the cache reactively through events
+        },
+        close() {
+            unsubscribe();
+            return store.close();
+        }
+    });
+    /**
+     * Retrieve-with-cache core.
+     *
+     * Three branches:
+     *
+     * - **bypass** — when `entry` has any wrapper-initiated write in flight, runs `miss()` and returns its
+     *   promise without storing it, so a pre-commit snapshot cannot be installed as fresh;
+     * - **fresh hit** — returns the memoised promise and re-inserts the record to bump its LRU position;
+     * - **miss / TTL-expired** — runs `miss()`, stores the pending promise under the canonicalised key so
+     *   concurrent callers share the in-flight request, and enforces TTL/size bounds via {@link purge}; a
+     *   fetch resolving to an absent resource or rejecting evicts its record only if an intervening invalidation
+     *   has not already replaced it.
+     *
+     * @typeParam V - The retrieved payload, opaque to the cache
+     *
+     * @param entry - Resource identifier; paired with the canonicalised model and varying scope members to form the
+     *     cache key
+     * @param model - Retrieval model, canonicalised so that equivalent models in different orderings share a key
+     * @param vary  - Retrieval scope members whose values vary the returned payload, folded into the key: `locale`
+     *   order-significantly (an omitted or empty list collapsing to a single key) and `limit` because it caps each
+     *   collection's `#` pagination bound (an omitted or `0` unbounded value collapsing to a single key)
+     * @param miss  - Fetcher invoked on cache miss, on TTL expiration, or while the entry has an in-flight write
+     *
+     * @returns The memoised, freshly-fetched, or bypass-fetched promise
+     */
+    function memoise(entry, model, vary = {}, miss) {
+        // Bypass the cache while a write to this entry is in flight: still query the delegate so the caller
+        // gets a value, but do not store the result: it is liable to be the pre-commit snapshot that the
+        // reactive observer would invalidate moments later
+        if (writing.has(entry)) {
+            return miss();
+        }
+        else {
+            // Cache key layout: `<entry>\x00<canonical-model>\x00<locale>\x00<limit>`. `canonical` walks the
+            // model bottom-up, sorting object keys and (already-canonical) array elements, so models differing only
+            // in ordering share a key. The locale segment is serialised verbatim (order preserved, since the priority
+            // list is order-significant) with omitted and empty lists collapsing to `[]`. The limit segment is
+            // keyed because it caps each collection's `#` and so changes the payload, with omitted and `0` (both
+            // unbounded) collapsing to `0`. `\x00` is safe as a separator: IRIs cannot contain it and JSON always
+            // escapes it inside string payloads.
+            const key = [entry, canonical(model), JSON.stringify(vary.locale ?? []), vary.limit ?? 0].join("\x00");
+            const cached = cache.get(key);
+            if (cached && !expired(cached.created)) {
+                // hit: re-insert to move the entry to the tail of the Map's iteration order (the LRU position),
+                // and return the memoised promise; ;(cast) the type-erased `Promise<unknown>` storage lets records
+                // with different payload types share one Map
+                cache.delete(key);
+                cache.set(key, cached);
+                return cached.value;
+            }
+            else {
+                // miss (or TTL-expired): drop any stale record, run the fetcher, and memoise the pending promise
+                // under the same key so concurrent callers share the in-flight request; an absent resource or a
+                // failure evicts its own record once settled, so neither a missing resource nor a transient error
+                // is retained
+                if (cached) {
+                    cache.delete(key);
+                }
+                const value = miss().then(resource => {
+                    if (resource === undefined) {
+                        evict();
+                    }
+                    return resource;
+                }, error => {
+                    evict();
+                    throw error;
+                });
+                // identity-check: only evict if this promise is still the cached one, avoiding dropping a newer
+                // record installed after an intervening invalidate
+                function evict() {
+                    if (cache.get(key)?.value === value) {
+                        cache.delete(key);
+                    }
+                }
+                cache.set(key, {
+                    entry,
+                    value,
+                    created: Date.now()
+                });
+                purge();
+                return value;
+            }
+        }
+    }
+    /**
+     * Serialises a value to a canonical JSON-like string.
+     *
+     * Children are canonicalised first, then sorted by their already-canonical string form, so arrays of
+     * objects are ordered by structural content rather than by the `"[object Object]"` placeholder that
+     * `Array.prototype.sort` would otherwise impose. The output collapses values differing only in property
+     * or element order to the same string.
+     *
+     * @param value - Value to serialise
+     *
+     * @returns A canonical string representation of `value`
+     */
+    function canonical(value) {
+        if (isArray(value)) {
+            return `[${value.map(canonical).sort().join(",")}]`;
+        }
+        else if (isObject(value)) {
+            return `{${Object.keys(value).sort().map(k => `${JSON.stringify(k)}:${canonical(value[k])}`).join(",")}}`;
+        }
+        else {
+            // JSON.stringify(undefined) returns undefined, not a string; substitute a distinct sentinel so the
+            // signature holds and `undefined` does not collide with the string literal `"undefined"` (which JSON
+            // would render with surrounding quotes)
+            return value === undefined ? "undefined" : JSON.stringify(value);
+        }
+    }
+    /**
+     * Tests whether a record is older than the configured TTL.
+     *
+     * Returns false when `ttl <= 0`, so the predicate can be reused at both the hit guard and the purge sweep
+     * without duplicating the boundary check. The reference timestamp defaults to `Date.now` but may be
+     * passed in to share a single snapshot across a batch of comparisons.
+     *
+     * @param created - Insertion timestamp (ms) of the record under test
+     * @param now     - Reference timestamp (ms) to compare against; defaults to `Date.now`
+     *
+     * @returns true if `ttl > 0` and `created` is older than `ttl` milliseconds relative to `now`; false otherwise
+     */
+    function expired(created, now = Date.now()) {
+        return ttl > 0 && now - created > ttl;
+    }
+    /**
+     * Run a wrapper-initiated write under in-flight tracking.
+     *
+     * Marks `entry` as having an in-flight write, runs the configured pre-commit invalidation, delegates to
+     * `op`, and clears the marker once the delegate settles. While the marker is set, retrievals of `entry`
+     * bypass the cache so a pre-commit value can never be stored as fresh.
+     *
+     * @param entry - Resource identifier targeted by the write
+     * @param op    - Thunk that delegates the write to the wrapped store and returns its promise
+     *
+     * @returns The promise returned by `op`, settled after the in-flight marker has been cleared
+     */
+    function write(entry, op) {
+        writing.set(entry, (writing.get(entry) ?? 0) + 1);
+        invalidate(entry);
+        return op().finally(() => {
+            const count = (writing.get(entry) ?? 1) - 1;
+            if (count <= 0) {
+                writing.delete(entry);
+            }
+            else {
+                writing.set(entry, count);
+            }
+        });
+    }
+    /**
+     * Drop cached records matching a mutated resource.
+     *
+     * Iterates the cache and removes every record whose stored identifier satisfies the configured {@link match}
+     * predicate against the mutated `entry`. Called from both the pre-commit write path on the wrapper and the
+     * reactive observer attached to the delegate.
+     *
+     * @param entry - Identifier of the mutated resource
+     */
+    function invalidate(entry) {
+        for (const [key, record] of cache) {
+            if (match(entry, record.entry)) {
+                cache.delete(key);
+            }
+        }
+    }
+    /**
+     * Enforce TTL and size bounds.
+     *
+     * Runs two sweeps: first, when `ttl > 0`, drops every record older than `ttl` milliseconds; second, when
+     * `size > 0` and the cache is overfull, drops the head slice of the Map (least-recently-used first) in
+     * a single batch sized to the exact overflow. Invoked after every miss so expired siblings and overfill
+     * are cleaned up incrementally, as the cache has no background sweeper.
+     */
+    function purge() {
+        if (ttl > 0) {
+            const now = Date.now();
+            for (const [key, record] of cache) {
+                if (expired(record.created, now)) {
+                    cache.delete(key);
+                }
+            }
+        }
+        // LRU sweep: when over the size bound, take the head slice of Map keys (insertion order = LRU first)
+        // and drop them: `cache.size - size` is the exact overflow, so no loop condition needs re-checking
+        if (size > 0 && cache.size > size) {
+            Array.from(cache.keys())
+                .slice(0, cache.size - size)
+                .forEach(key => cache.delete(key));
+        }
+    }
+}
+//# sourceMappingURL=caching.js.map

package/dist/stores/caching.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"caching.js","sourceRoot":"","sources":["../../src/stores/caching.ts"],"names":[],"mappings":"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"}

package/dist/stores/managing.d.ts

@@ -0,0 +1,57 @@
+import type { Store } from "../index.js";
+/**
+ * Manages mutation events, transactional execution, and lifecycle for a connector's {@link StoreClient},
+ * exposing it as a full {@link Store}.
+ *
+ * A connector can implement only the {@link StoreClient} data surface and still offer the full {@link Store}
+ * contract. The connector supplies its transaction primitive through `management.execute`, which hands the
+ * connector's {@link StoreClient} to every data call. The option is required, since only the connector knows what
+ * atomicity its backend can provide. Backend primitives supplied through `management` may also back `observe` or
+ * `close`, and the wrapper fills in whatever is missing.
+ *
+ * Each standalone mutation call and each {@link Store.execute execute} call delivers a single filtered event to each
+ * matching {@link StoreObserver observer} once the call resolves. If the call rejects, its pending events are
+ * discarded and no observer is notified. Synchronous throws and asynchronous rejections from observers are caught and
+ * silently ignored, so one faulty observer cannot break delivery to others.
+ *
+ * All errors, including {@link !RangeError RangeError}, {@link @metreeca/core!TraceError | TraceError} and
+ * {@link @metreeca/http!Problem | Problem}, propagate as promise rejections, in line with the unified {@link Store}
+ * error channel.
+ *
+ * > [!IMPORTANT]
+ * > **Transaction Isolation** — Determined by the supplied `execute` option, typically through a backend
+ * > transaction primitive: the wrapper adds neither isolation nor atomicity of its own.
+ *
+ * > [!IMPORTANT]
+ * > **Mutation Events** — emits in-process observer events: each standalone mutation and each
+ * > {@link Store.execute execute} call delivers a single filtered batch to matching {@link StoreObserver observer}s
+ * > on resolve, and none on rejection. Mutations made by other clients reach local observers only if a
+ * > backend-bridging `observe` option is supplied through `management`.
+ *
+ * @param management - {@link Store} management methods backed by the connector: `execute` is required, and the
+ *     wrapper fills in whatever else is missing
+ * @param management.execute - Transaction wrapper applied to every standalone StoreClient call and to the body of
+ *     each {@link Store.execute execute} call, typically a backend transaction primitive (for example,
+ *     `graph.execute` for a SPARQL connector) responsible for atomic commit and rollback. A backend with no
+ *     transaction primitive supplies a wrapper applying the task directly to its StoreClient, and declares on its
+ *     factory that a failing task neither rolls back nor isolates its mutations. The option MUST call each task it
+ *     receives with a `scope` StoreClient dedicated to that call, so per-call state, such as a freshly bound graph
+ *     buffer, never leaks across concurrent invocations; every data call within the transaction is routed through
+ *     `scope`. Calls made by a user task inside {@link Store.execute execute} do not open further transactions: they
+ *     share the outer one. The option MUST convert synchronous throws from the task into promise rejections, to
+ *     preserve the unified Store error channel: lookups are routed through it with no additional guard
+ * @param management.observe - Backend registration for storage-level events, such as mutations made by other clients
+ *     sharing the backend. Each observer is registered both with this option and locally, and a single detach call
+ *     releases both registrations. The resource filter always arrives as an array of references, or as `undefined`
+ *     for an unfiltered registration, so the option never has to handle bare references or single-pass iterables.
+ *     Absent by default
+ * @param management.close - Exposed as is on the returned store. Defaults to a resolved no-op
+ *
+ * @returns An immutable {@link Store} serving data calls through the supplied `management` opts
+ */
+export declare function createManagingStore({ observe, execute, close }: {
+    readonly observe?: Store["observe"];
+    readonly execute: Store["execute"];
+    readonly close?: Store["close"];
+}): Store;
+//# sourceMappingURL=managing.d.ts.map

package/dist/stores/managing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managing.d.ts","sourceRoot":"","sources":["../../src/stores/managing.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAAE,KAAK,EAA8B,MAAM,aAAa,CAAC;AAGrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,mBAAmB,CAAC,EAEnC,OAAO,EACP,OAAO,EAEP,KAA+B,EAE/B,EAAE;IAEF,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;IACnC,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;IAElC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAA;CAE/B,GAAG,KAAK,CA2HR"}

package/dist/stores/managing.js

@@ -0,0 +1,147 @@
+/*
+ * Copyright © 2025-2026 Metreeca srl
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { some } from "@metreeca/core/arrays";
+import { isNestedIRI } from "@metreeca/core/resource";
+import { immutable } from "@metreeca/core/values";
+/**
+ * Manages mutation events, transactional execution, and lifecycle for a connector's {@link StoreClient},
+ * exposing it as a full {@link Store}.
+ *
+ * A connector can implement only the {@link StoreClient} data surface and still offer the full {@link Store}
+ * contract. The connector supplies its transaction primitive through `management.execute`, which hands the
+ * connector's {@link StoreClient} to every data call. The option is required, since only the connector knows what
+ * atomicity its backend can provide. Backend primitives supplied through `management` may also back `observe` or
+ * `close`, and the wrapper fills in whatever is missing.
+ *
+ * Each standalone mutation call and each {@link Store.execute execute} call delivers a single filtered event to each
+ * matching {@link StoreObserver observer} once the call resolves. If the call rejects, its pending events are
+ * discarded and no observer is notified. Synchronous throws and asynchronous rejections from observers are caught and
+ * silently ignored, so one faulty observer cannot break delivery to others.
+ *
+ * All errors, including {@link !RangeError RangeError}, {@link @metreeca/core!TraceError | TraceError} and
+ * {@link @metreeca/http!Problem | Problem}, propagate as promise rejections, in line with the unified {@link Store}
+ * error channel.
+ *
+ * > [!IMPORTANT]
+ * > **Transaction Isolation** — Determined by the supplied `execute` option, typically through a backend
+ * > transaction primitive: the wrapper adds neither isolation nor atomicity of its own.
+ *
+ * > [!IMPORTANT]
+ * > **Mutation Events** — emits in-process observer events: each standalone mutation and each
+ * > {@link Store.execute execute} call delivers a single filtered batch to matching {@link StoreObserver observer}s
+ * > on resolve, and none on rejection. Mutations made by other clients reach local observers only if a
+ * > backend-bridging `observe` option is supplied through `management`.
+ *
+ * @param management - {@link Store} management methods backed by the connector: `execute` is required, and the
+ *     wrapper fills in whatever else is missing
+ * @param management.execute - Transaction wrapper applied to every standalone StoreClient call and to the body of
+ *     each {@link Store.execute execute} call, typically a backend transaction primitive (for example,
+ *     `graph.execute` for a SPARQL connector) responsible for atomic commit and rollback. A backend with no
+ *     transaction primitive supplies a wrapper applying the task directly to its StoreClient, and declares on its
+ *     factory that a failing task neither rolls back nor isolates its mutations. The option MUST call each task it
+ *     receives with a `scope` StoreClient dedicated to that call, so per-call state, such as a freshly bound graph
+ *     buffer, never leaks across concurrent invocations; every data call within the transaction is routed through
+ *     `scope`. Calls made by a user task inside {@link Store.execute execute} do not open further transactions: they
+ *     share the outer one. The option MUST convert synchronous throws from the task into promise rejections, to
+ *     preserve the unified Store error channel: lookups are routed through it with no additional guard
+ * @param management.observe - Backend registration for storage-level events, such as mutations made by other clients
+ *     sharing the backend. Each observer is registered both with this option and locally, and a single detach call
+ *     releases both registrations. The resource filter always arrives as an array of references, or as `undefined`
+ *     for an unfiltered registration, so the option never has to handle bare references or single-pass iterables.
+ *     Absent by default
+ * @param management.close - Exposed as is on the returned store. Defaults to a resolved no-op
+ *
+ * @returns An immutable {@link Store} serving data calls through the supplied `management` opts
+ */
+export function createManagingStore({ observe, execute, close = () => Promise.resolve() }) {
+    const observers = new Map();
+    return immutable({
+        lookup: (request, opts) => execute(store => store.lookup(request, opts)),
+        create: request => notify(({ mutated }) => execute(store => store.create(request).then(mutated))),
+        update: request => notify(({ mutated }) => execute(store => store.update(request).then(mutated))),
+        delete: request => notify(({ deleted }) => execute(store => store.delete(request).then(deleted))),
+        insert: request => notify(({ mutated }) => execute(store => store.insert(request).then(mutated))),
+        remove: request => notify(({ deleted }) => execute(store => store.remove(request).then(deleted))),
+        observe(observer, resources) {
+            // normalise upfront: the filter is drawn from once, so a single-pass iterable is safely
+            // shared between the local registration and the delegate
+            const filter = resources === undefined ? undefined : some(resources);
+            if (filter?.length === 0) {
+                return observe?.(observer, []) ?? (() => { });
+            }
+            else {
+                const token = Symbol();
+                const detach = observe?.(observer, filter);
+                observers.set(token, { observer, resources: filter });
+                return () => {
+                    try {
+                        detach?.();
+                    }
+                    finally {
+                        observers.delete(token);
+                    }
+                };
+            }
+        },
+        execute(task) {
+            return notify(({ mutated, deleted }) => execute(store => task(immutable({
+                lookup: (request, opts) => store.lookup(request, opts),
+                create: request => store.create(request).then(mutated),
+                update: request => store.update(request).then(mutated),
+                delete: request => store.delete(request).then(deleted),
+                insert: request => store.insert(request).then(mutated),
+                remove: request => store.remove(request).then(deleted)
+            }))));
+        },
+        close
+    });
+    async function notify(task) {
+        const mutations = new Map();
+        const value = await task({
+            mutated: entry => {
+                if (entry !== undefined) {
+                    mutations.set(entry, true);
+                }
+                return entry;
+            },
+            deleted: entry => {
+                if (entry !== undefined) {
+                    mutations.set(entry, false);
+                }
+                return entry;
+            }
+        });
+        if (mutations.size > 0) {
+            observers.forEach(({ observer, resources }) => {
+                const event = {};
+                mutations.forEach((exists, id) => {
+                    // `resources` is `undefined` for an unfiltered registration (fires for every mutation)
+                    // and an array (possibly empty) for a filtered one
+                    if (resources === undefined || resources.some(r => isNestedIRI(r, id))) {
+                        event[id] = exists;
+                    }
+                });
+                if (Object.keys(event).length > 0) {
+                    Promise.resolve(event)
+                        .then(observer)
+                        .catch(() => { });
+                }
+            });
+        }
+        return value;
+    }
+}
+//# sourceMappingURL=managing.js.map

package/dist/stores/managing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"managing.js","sourceRoot":"","sources":["../../src/stores/managing.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@metreeca/keep",
-  "version": "0.9.0",
-  "description": "{TBD}",
+  "version": "0.11.0",
+  "description": "Core model-driven storage API for @metreeca/keep.",
   "keywords": [
     "typescript",
-    "utilities"
+    "json-ld",
+    "model-driven",
+    "storage"
   ],
   "homepage": "https://metreeca.github.io/keep/",
   "bugs": {
@@ -19,14 +21,32 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/metreeca/keep.git"
+    "url": "git+https://github.com/metreeca/keep.git",
+    "directory": "packages/components/keep"
   },
   "type": "module",
   "sideEffects": false,
   "exports": {
-    ".": "./dist/index/index.js",
-    "./stores": "./dist/stores/index.js",
-    "./states": "./dist/states/index.js"
+    ".": {
+      "@metreeca/source": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./validating": {
+      "@metreeca/source": "./src/clients/validating.ts",
+      "default": "./dist/clients/validating.js"
+    },
+    "./batching": {
+      "@metreeca/source": "./src/clients/batching.ts",
+      "default": "./dist/clients/batching.js"
+    },
+    "./caching": {
+      "@metreeca/source": "./src/stores/caching.ts",
+      "default": "./dist/stores/caching.js"
+    },
+    "./managing": {
+      "@metreeca/source": "./src/stores/managing.ts",
+      "default": "./dist/stores/managing.js"
+    }
   },
   "files": [
     "README.md",
@@ -34,24 +54,20 @@
     "dist"
   ],
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=22.22.0"
   },
   "scripts": {
     "clean": "rm -rf dist docs node_modules",
-    "setup": "npm install && npm audit fix",
-    "build": "rm -rf dist docs && tsc -p tsconfig.build.json && npx typedoc",
-    "check": "npx vitest --typecheck run",
-    "watch": "npx tsc --watch",
-    "proof": "npx typedoc && (npx typedoc --watch & npx five-server docs --open)"
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "check": "npx vitest --typecheck run"
   },
   "dependencies": {
-    "@metreeca/core": "^0.9.13",
-    "@metreeca/qest": "^0.9.0",
-    "@metreeca/blue": "^0.9.0"
+    "@metreeca/blue": "^0.12.0",
+    "@metreeca/core": "^0.12.0",
+    "@metreeca/http": "^0.4.0",
+    "@metreeca/qest": "^0.12.0"
   },
   "devDependencies": {
-    "five-server": "^0.4.5",
-    "typedoc": "^0.28.14",
     "typescript": "^5.9.3",
     "vitest": "^4.0.13"
   }

package/dist/index/index.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.d.ts.map

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

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