@metreeca/keep 0.9.0 → 0.10.0

package/dist/clients/batching.js

@@ -0,0 +1,105 @@
+/*
+ * 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 { eager } from "@metreeca/blue/value";
+import { immutable } from "@metreeca/core/structures";
+import { createBroker } from "./batching.core.js";
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ * Creates a batching store client backed by a set of request handlers.
+ *
+ * Routes every {@link StoreClient} call through a {@link Broker} that coalesces concurrent requests
+ * into batches and dispatches each batch through the matching `handlers` entry. Adds conditional CRUD
+ * semantics on top of the handlers: existence is probed through the `detect` handler before a create,
+ * update, or delete is delegated to `modify`, sparing each handler that bookkeeping.
+ *
+ * The `modify` handler is additionally wrapped so the batching layer, not the storage handler,
+ * enforces the §4.1 state-`id` constraint: a request whose `state` carries an `id` other than its
+ * `entry` is rejected on its own before dispatch, and a backend failure is settled as a rejection
+ * across the surviving batch rather than surfaced as a handler throw. The wrapped handler thus always
+ * receives a non-empty batch of pre-validated requests to apply unconditionally.
+ *
+ * @param handlers The batch handlers, one per request type, dispatching detect, lookup, select, and
+ *     modify requests
+ *
+ * @returns An immutable {@link StoreClient} that batches its requests through the broker
+ *
+ * @throws {RangeError} If a create or update `state` carries an `id` that differs from its `entry`
+ */
+export function createBatchingStore(handlers) {
+    const broker = createBroker({
+        ...handlers,
+        async modify(batch, broker) {
+            const items = batch.filter(({ request: { entry, state }, reject }) => {
+                // reject each request whose state id contradicts its entry (§4.1) on its own, so the
+                // rest of the batch still applies and the check stays out of storage-specific handlers
+                const matching = state?.id === undefined || state.id === entry;
+                if (!matching) {
+                    reject(new RangeError(`mismatched state id <${String(state?.id)}> for entry <${entry}>`));
+                }
+                return matching;
+            });
+            if (items.length > 0) {
+                // on backend failure, reject the surviving batch rather than throw: the broker
+                // treats a handler throw as a run-wide fault and propagates it to sibling queues
+                try {
+                    await handlers.modify(items, broker);
+                }
+                catch (error) {
+                    items.forEach(({ reject }) => reject(error));
+                }
+            }
+        }
+    });
+    return immutable({
+        async lookup({ entry, shape, model }, { locale = ["und"] } = {}) {
+            // virtual resources have no stored state of their own: their members are derived from
+            // selection constraints rather than from stored content, so the existence probe is skipped.
+            return eager(shape).virtual || await broker.detect({ entry })
+                ? broker.lookup({ entry, shape, model, locale })
+                : undefined;
+        },
+        async create({ entry, shape, state }) {
+            // the entry identifies the target: a state carrying a different id contradicts it (§4.1)
+            if (state.id !== undefined && state.id !== entry) {
+                throw new RangeError(`mismatched state id <${String(state.id)}> for entry <${entry}>`);
+            }
+            return await broker.detect({ entry })
+                ? undefined
+                : broker.modify({ entry, shape, state });
+        },
+        async update({ entry, shape, state }) {
+            // the entry identifies the target: a state carrying a different id contradicts it (§4.1)
+            if (state.id !== undefined && state.id !== entry) {
+                throw new RangeError(`mismatched state id <${String(state.id)}> for entry <${entry}>`);
+            }
+            return await broker.detect({ entry })
+                ? broker.modify({ entry, shape, state })
+                : undefined;
+        },
+        async delete({ entry, shape }) {
+            return await broker.detect({ entry })
+                ? broker.modify({ entry, shape })
+                : undefined;
+        },
+        insert(insert) {
+            return broker.modify(insert);
+        },
+        remove(remove) {
+            return broker.modify(remove);
+        }
+    });
+}
+//# sourceMappingURL=batching.js.map

package/dist/clients/batching.js.map

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

package/dist/clients/validating.d.ts

@@ -0,0 +1,38 @@
+import type { StoreClient } from "../index.js";
+/**
+ * Creates a validating store backed by a delegate.
+ *
+ * Each method validates the relevant inputs against the supplied shape before delegating to `store`:
+ *
+ * - `entry` is checked for absolute-IRI form (no query string, no fragment) — failures rejected as `RangeError`
+ * - `state.id`, when present, is checked for equality with `entry` — mismatches rejected as `RangeError`, since
+ *   the entry identifies the target and a contradicting payload identity is a caller error
+ * - `model` is validated as a {@link @metreeca/blue!validate | template} for
+ *   {@link StoreClient.lookup lookup}, with the `lookup` `plain`/`depth`/`limit` opts forwarded as
+ *   query-complexity caps
+ * - `state` is validated as a resource for {@link StoreClient.create create}/
+ *   {@link StoreClient.update update}/{@link StoreClient.insert insert}; `create` and
+ * `update` always cap captive expansion at depth `0` (inline captive batches rejected), while `insert` honours its
+ * `depth` opt
+ *   (omitted leaves expansion unbounded)
+ *
+ * The `trusted` opt controls whether {@link StoreClient.lookup lookup} responses are re-validated
+ * against the shape narrowed by the caller's `model` template before surfacing. Defaults to `false`
+ * — connectors whose backing source isn't trusted to deliver shape-conforming data (for example, a
+ * remote REST endpoint) get the safe default. Local stores that compute results themselves should
+ * pass `trusted: true` to skip the redundant pass.
+ *
+ * Validation failures surface as {@link @metreeca/core!TraceError | TraceError} or `RangeError` rejections per the
+ * unified {@link Store} error channel.
+ *
+ * @param store - Inner StoreClient to delegate to after validation
+ * @param options - Optional validation options
+ * @param options.trusted - When `true`, skips re-validation of the {@link StoreClient.lookup lookup}
+ *     response against the shape narrowed by the caller's `model`; defaults to `false`
+ *
+ * @returns An immutable {@link StoreClient} wrapping `store` with input validation
+ */
+export declare function createValidatingStore(store: StoreClient, { trusted }?: {
+    readonly trusted?: boolean;
+}): StoreClient;
+//# sourceMappingURL=validating.d.ts.map

package/dist/clients/validating.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validating.d.ts","sourceRoot":"","sources":["../../src/clients/validating.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAS,WAAW,EAAE,MAAM,aAAa,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,WAAW,EAAE,EAEzD,OAAe,EAEf,GAAE;IAEF,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAErB,GAAG,WAAW,CA+GnB"}

package/dist/clients/validating.js

@@ -0,0 +1,128 @@
+/*
+ * 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.
+ */
+/**
+ * Validating store wrapper.
+ *
+ * Wraps a plain {@link StoreClient} with shape-driven validation of entries, models, and states
+ * before delegating, and optional re-validation of retrieval responses.
+ *
+ * @module
+ */
+import { validate } from "@metreeca/blue";
+import { immutable } from "@metreeca/core/structures";
+import { TraceError } from "@metreeca/core/trace";
+import { isReference } from "@metreeca/qest/resource";
+/**
+ * Creates a validating store backed by a delegate.
+ *
+ * Each method validates the relevant inputs against the supplied shape before delegating to `store`:
+ *
+ * - `entry` is checked for absolute-IRI form (no query string, no fragment) — failures rejected as `RangeError`
+ * - `state.id`, when present, is checked for equality with `entry` — mismatches rejected as `RangeError`, since
+ *   the entry identifies the target and a contradicting payload identity is a caller error
+ * - `model` is validated as a {@link @metreeca/blue!validate | template} for
+ *   {@link StoreClient.lookup lookup}, with the `lookup` `plain`/`depth`/`limit` opts forwarded as
+ *   query-complexity caps
+ * - `state` is validated as a resource for {@link StoreClient.create create}/
+ *   {@link StoreClient.update update}/{@link StoreClient.insert insert}; `create` and
+ * `update` always cap captive expansion at depth `0` (inline captive batches rejected), while `insert` honours its
+ * `depth` opt
+ *   (omitted leaves expansion unbounded)
+ *
+ * The `trusted` opt controls whether {@link StoreClient.lookup lookup} responses are re-validated
+ * against the shape narrowed by the caller's `model` template before surfacing. Defaults to `false`
+ * — connectors whose backing source isn't trusted to deliver shape-conforming data (for example, a
+ * remote REST endpoint) get the safe default. Local stores that compute results themselves should
+ * pass `trusted: true` to skip the redundant pass.
+ *
+ * Validation failures surface as {@link @metreeca/core!TraceError | TraceError} or `RangeError` rejections per the
+ * unified {@link Store} error channel.
+ *
+ * @param store - Inner StoreClient to delegate to after validation
+ * @param options - Optional validation options
+ * @param options.trusted - When `true`, skips re-validation of the {@link StoreClient.lookup lookup}
+ *     response against the shape narrowed by the caller's `model`; defaults to `false`
+ *
+ * @returns An immutable {@link StoreClient} wrapping `store` with input validation
+ */
+export function createValidatingStore(store, { trusted = false } = {}) {
+    return immutable({
+        async lookup({ entry, shape, model }, opts) {
+            return store.lookup({
+                entry: assertEntry(entry),
+                shape,
+                model: validate(model, { ...opts, shape, model: true })({
+                    value: value => value,
+                    trace: trace => { throw new TraceError("invalid model", trace ?? []); }
+                })
+            }, opts).then(result => {
+                return trusted || result === undefined ? immutable(result) : validate(result, { shape, model })({
+                    value: value => value,
+                    trace: trace => { throw new TraceError("invalid response", trace ?? []); }
+                });
+            });
+        },
+        async create({ entry, shape, state }) {
+            return store.create({
+                entry: assertEntry(entry),
+                shape,
+                state: validate(state, { shape, depth: 0 })({
+                    value: value => value,
+                    trace: trace => { throw new TraceError("invalid state", trace ?? []); }
+                })
+            });
+        },
+        async update({ entry, shape, state }) {
+            return store.update({
+                entry: assertEntry(entry),
+                shape,
+                state: validate(state, { shape, depth: 0 })({
+                    value: value => value,
+                    trace: trace => { throw new TraceError("invalid state", trace ?? []); }
+                })
+            });
+        },
+        async delete({ entry, shape }) {
+            return store.delete({ entry: assertEntry(entry), shape });
+        },
+        async insert({ entry, shape, state }, opts) {
+            return store.insert({
+                entry: assertEntry(entry),
+                shape,
+                state: validate(state, { ...opts, shape })({
+                    value: value => value,
+                    trace: trace => { throw new TraceError("invalid state", trace ?? []); }
+                })
+            }, opts);
+        },
+        async remove({ entry, shape }) {
+            return store.remove({
+                entry: assertEntry(entry),
+                shape
+            });
+        }
+    });
+    function assertEntry(entry) {
+        if (!isReference(entry)) {
+            throw new RangeError(`expected absolute IRI <${entry}>`);
+        }
+        if (entry.includes("?") || entry.includes("#")) {
+            throw new RangeError(`unexpected query or fragment in <${entry}>`);
+        }
+        return entry;
+    }
+}
+//# sourceMappingURL=validating.js.map

package/dist/clients/validating.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,358 @@
+import type { ResourceShape } from "@metreeca/blue/resource";
+import type { Lazy } from "@metreeca/core";
+import type { Tag } from "@metreeca/core/language";
+import { type Reference, Resource } from "@metreeca/qest/resource";
+import { Instance, Template } from "@metreeca/qest/template";
+/**
+ * Model-driven resource store.
+ *
+ * Extends {@link StoreClient} with management facilities — mutation events, transactional execution, and lifecycle —
+ * to form the store surface produced by factories like
+ * {@link createManagingStore}. The data surface is factored into a standalone
+ * {@link StoreClient} so it can be implemented and passed around on its own (for example, the inner client handed to
+ * {@link Store.execute execute} carries no `execute` of its own), while consumers of a store reach both
+ * surfaces through the same object.
+ *
+ * Data methods on a store — {@link StoreClient.lookup lookup}, {@link StoreClient.create create},
+ * {@link StoreClient.update update}, {@link StoreClient.delete delete}, {@link StoreClient.insert insert}, and
+ * {@link StoreClient.remove remove} — are individually atomic even when executed outside
+ * {@link Store.execute execute}, regardless of the number of server round-trips they may internally require.
+ *
+ * > [!IMPORTANT]
+ * > Implementations provide best-effort transaction isolation, targeting snapshot isolation where the backend
+ * > supports it and degrading gracefully to the maximum level achievable by the underlying storage, down to no
+ * > isolation at all. Each implementation **must** document its supported isolation level. Implementations not
+ * > supporting atomic updates natively **must** emulate them by buffering and deferring mutations until commit time.
+ *
+ * > [!IMPORTANT]
+ * > Implementations provide best-effort mutation event signalling, targeting notification for all mutations on the
+ * > backing storage layer and degrading gracefully to signalling only events generated by calls to the mutation
+ * > methods on the store. Each implementation **must** document its supported event scope.
+ */
+export interface Store extends StoreClient {
+    /**
+     * Observe mutation events.
+     *
+     * Each call mints an independent registration; multiple registrations of the same observer coexist and
+     * fire independently — the observer is invoked once per matching registration per mutation batch. The
+     * returned handle detaches **only** that registration; calling it more than once is a no-op and other
+     * registrations of the same observer are unaffected. Detachment is the only supported way to stop
+     * receiving events — repeated `observe` calls do not replace any prior registration.
+     *
+     * `resources` is the filter for the registration:
+     *
+     * - `undefined` (omitted) — no filter; the observer fires for every mutation
+     * - a single {@link Reference} — fires for mutations to that resource and its
+     *   {@link @metreeca/core!isNestedIRI | descendants}
+     * - an array of references — fires for mutations matching any element and its descendants
+     * - an empty array — ignored; no registration is created and the returned handle is a no-op
+     *
+     * > [!NOTE]
+     * > The observer receives only resource identifiers and an existence flag — not the mutated state.
+     * > This keeps event payloads small even when many resources are mutated within a single transaction,
+     * > and lets each observer fetch whatever data envelope it needs via {@link StoreClient.lookup lookup}.
+     *
+     * @param observer - Mutation observer invoked with each batch of matching mutations
+     * @param resources - Filter (single reference, array of references, or omitted for no filter)
+     *
+     * @returns A function that detaches **this** registration
+     *
+     * @throws `Error` if the store has been {@link Store.close closed}
+     */
+    observe(observer: StoreObserver, resources?: Reference | readonly Reference[]): () => void;
+    /**
+     * Execute a task within a store transaction.
+     *
+     * All operations performed during the task are executed atomically. If the task completes successfully, all
+     * mutations are committed and {@link Store.observe registered observers} receive a single mutation event
+     * containing all affected resources. If the task throws or rejects — including logic errors (`RangeError`,
+     * {@link TraceError}) raised by inner {@link StoreClient} calls — no mutations are executed, no events are
+     * notified, and the error is propagated to the caller as a promise rejection.
+     *
+     * The task is handled its own {@link StoreClient} for the transaction. Operations performed through it belong to
+     * the transaction and commit together, kept separate from any other `execute` running at the same time.
+     *
+     * > [!WARNING]
+     * > `execute` is not re-entrant: transaction boundaries are flat, so a task cannot open a nested transaction
+     * > and compositions must share a single outer call site.
+     *
+     * > [!WARNING]
+     * > The task MUST NOT retain or use the {@link StoreClient} it receives after `execute` settles: implementations
+     * > may back it with transaction-scoped state (buffered mutations, a bound backend scope) that is flushed or
+     * > discarded on completion, so any later call has undefined behaviour.
+     *
+     * > [!WARNING]
+     * > **Atomicity is mandatory; isolation is best-effort.** The task's mutations and their events always commit
+     * > all-or-nothing. `SNAPSHOT` is the suggested read-isolation level; each implementation declares the level it
+     * > actually provides. An implementation with neither native transactions nor `SNAPSHOT` isolation MUST buffer
+     * > the mutations and events, commit them as one batch on success, and drop the buffer on failure (a synchronous
+     * > throw or a rejected promise).
+     *
+     * @typeParam V - Return type of the task
+     *
+     * @param task - Async or sync function performing store operations within the transaction
+     *
+     * @returns A promise resolving to the value returned by `task`; rejects with any error raised or
+     * propagated by `task`, including a `RangeError`/{@link TraceError} from inner Store validation or a
+     * {@link Problem} from a transactional, network, storage, or other processing failure
+     *
+     * @throws `Error` if the store has been {@link Store.close closed}
+     */
+    execute<V>(task: (store: StoreClient) => V | Promise<V>): Promise<V>;
+    /**
+     * Release resources held by this store.
+     *
+     * Frees underlying resources such as database connections or file handles. Calling `close` on an
+     * already-closed store has no effect; implementations with no resources to release MAY return a
+     * resolved no-op.
+     *
+     * @returns A promise resolving when all resources have been released; rejects with a {@link Problem} if a
+     * clean-up error occurs
+     */
+    close(): Promise<void>;
+}
+/**
+ * Model-driven resource CRUD operations.
+ *
+ * Persists and retrieves linked data resources as shape-validated states and query projections.
+ */
+export interface StoreClient {
+    /**
+     * Retrieve a resource.
+     *
+     * The result is shaped by the `model` {@link Template}: plain identifier properties are resolved from the
+     * shape's {@link Instance}\<T\> type, while computed bindings are derived from the template value.
+     *
+     * > [!NOTE]
+     * > `shape` and `model` are kept distinct so that a single `shape` can serve many retrieval templates —
+     * > for example, a server wiring one `shape` at startup and accepting any admissible `model` decoded
+     * > from the client request on each call. Callers wanting the shape's own model as template MUST pass
+     * > it explicitly via {@link @metreeca/blue/value!model}.
+     *
+     * > [!CAUTION]
+     * > By default, `model` templates support the full query language, including aggregate transforms and nested
+     * > expansion. When exposing retrieval to untrusted clients, restrict query complexity as required by setting
+     * > `plain` to `true`, `depth` to `0` or a positive value, and/or `limit` to a maximum result set size.
+     *
+     * @typeParam T - The retrieval template type
+     *
+     * @param request - Retrieval specifications
+     * @param request.entry - Absolute identifier of the resource to be retrieved
+     * @param request.shape - Resource shape driving the operation
+     * @param request.model - Retrieval template defining the data envelope
+     * @param opts - Optional retrieval options
+     * @param opts.locale - {@link Tag} priority list driving language negotiation for localised content; entries are
+     * matched in order of preference against the language tags available for each localised value. Implementations
+     * default this to `["und"]` when omitted
+     * @param opts.plain - When `true`, rejects `model` templates carrying aggregate transforms (`count`, `sum`, `min`,
+     * `max`, `avg`); defaults to `false`, admitting the full query language
+     * @param opts.depth - Maximum depth admitted for nested `model` expansion and query probe paths, each nesting
+     * level or path segment counting against the budget; `0` rejects any nested template while still accepting IRI
+     * references; omission leaves expansion unbounded
+     * @param opts.limit - Maximum value admitted for the `#` pagination constraint in `model` selections; a positive
+     * value caps the result set, rejecting any `#` exceeding it or set to `0` (unbounded) and injecting itself as a
+     * default where `#` is absent; omission, like `0`, leaves result sets unbounded
+     *
+     * @returns A promise resolving to an immutable copy of the resource data matching the specified model,
+     * or to `undefined` if the resource is not present in the store; rejects with a `RangeError` if `entry`
+     * is not an absolute IRI, a {@link TraceError} if `model` doesn't {@link validate} against the shape,
+     * or a {@link Problem} on network, storage, or other processing errors
+     *
+     * @throws `Error` if the store has been {@link Store.close closed}
+     */
+    lookup<T extends Template>(request: {
+        readonly entry: Reference;
+        readonly shape: Lazy<ResourceShape>;
+        readonly model: T;
+    }, opts?: {
+        locale?: readonly Tag[];
+        plain?: boolean;
+        depth?: number;
+        limit?: number;
+    }): Promise<undefined | Instance<T>>;
+    /**
+     * Create a resource.
+     *
+     * Stores the resource's own data if the resource doesn't already exist. Specific reference kinds are handled
+     * as follows:
+     *
+     * - {@link ResourceShape | embedded references} — cascades recursively with the same semantics
+     * - {@link @metreeca/blue/reference!ReferenceConstraints.captive | captive references} — accepted only as bare
+     * IRI references; inline captive batches are rejected, as `state` is always validated at depth `0`. Use
+     * {@link StoreClient.insert insert} to embed a captive tree in a single batch
+     * - {@link @metreeca/blue/reference!ReferenceConstraints.foreign | foreign references} — skipped, as their
+     * data is owned by the defining resource
+     *
+     * @param request - Creation specifications
+     * @param request.entry - Absolute identifier of the target resource
+     * @param request.shape - Resource shape driving the operation
+     * @param request.state - Initial property values for the new resource
+     *
+     * @returns A promise resolving to the `entry` {@link Reference} of the created resource, or to `undefined`
+     * if the resource already exists; rejects with a `RangeError` if `entry` is not an absolute IRI or if
+     * `state` carries an `id` differing from `entry`, a {@link TraceError} if `state` doesn't {@link validate}
+     * against the shape, or a {@link Problem} on network, storage, or other processing errors
+     *
+     * @throws `Error` if the store has been {@link Store.close closed}
+     *
+     * @see {@link StoreClient.insert insert} for unconditional insertion
+     */
+    create(request: {
+        readonly entry: Reference;
+        readonly shape: Lazy<ResourceShape>;
+        readonly state: Resource;
+    }): Promise<undefined | Reference>;
+    /**
+     * Update a resource.
+     *
+     * Replaces the resource's own data if the resource already exists, fully removing any previously existing
+     * embedded data. Specific reference kinds are handled as follows:
+     *
+     * - {@link ResourceShape | embedded references} — cascades recursively with the same semantics
+     * - {@link @metreeca/blue/reference!ReferenceConstraints.captive | captive references} — accepted only as bare
+     * IRI references; inline captive batches are rejected, as `state` is always validated at depth `0`. Use
+     * {@link StoreClient.insert insert} to embed a captive tree in a single batch
+     * - {@link @metreeca/blue/reference!ReferenceConstraints.foreign | foreign references} — skipped, as their
+     * data is owned by the defining resource
+     *
+     * @param request - Update specifications
+     * @param request.entry - Absolute identifier of the target resource
+     * @param request.shape - Resource shape driving the operation
+     * @param request.state - Complete replacement state for the resource
+     *
+     * @returns A promise resolving to the `entry` {@link Reference} of the updated resource, or to `undefined`
+     * if the resource doesn't exist; rejects with a `RangeError` if `entry` is not an absolute IRI or if
+     * `state` carries an `id` differing from `entry`, a {@link TraceError} if `state` doesn't {@link validate}
+     * against the shape, or a {@link Problem} on network, storage, or other processing errors
+     *
+     * @throws `Error` if the store has been {@link Store.close closed}
+     *
+     * @see {@link StoreClient.insert insert} for unconditional insertion
+     */
+    update(request: {
+        readonly entry: Reference;
+        readonly shape: Lazy<ResourceShape>;
+        readonly state: Resource;
+    }): Promise<undefined | Reference>;
+    /**
+     * Delete a resource.
+     *
+     * Removes the resource's own data and clears references to it from other resources, if the resource exists.
+     * Specific reference kinds are handled as follows:
+     *
+     * - {@link ResourceShape | embedded references} — cascades recursively with the same semantics
+     * - {@link @metreeca/blue/reference!ReferenceConstraints.captive | captive references} — cascade-deleted with
+     * the same semantics
+     *
+     * @param request - Deletion specifications
+     * @param request.entry - Absolute identifier of the target resource
+     * @param request.shape - Resource shape driving the operation
+     *
+     * @returns A promise resolving to the `entry` {@link Reference} of the deleted resource, or to `undefined`
+     * if the resource doesn't exist; rejects with a `RangeError` if `entry` is not an absolute IRI, or a
+     * {@link Problem} on network, storage, or other processing errors
+     *
+     * @throws `Error` if the store has been {@link Store.close closed}
+     *
+     * @see {@link StoreClient.remove remove} for unconditional removal
+     */
+    delete(request: {
+        readonly entry: Reference;
+        readonly shape: Lazy<ResourceShape>;
+    }): Promise<undefined | Reference>;
+    /**
+     * Insert a resource.
+     *
+     * Unconditionally inserts or replaces the resource's own data, fully removing any previously existing embedded
+     * data. Specific reference kinds are handled as follows:
+     *
+     * - {@link ResourceShape | embedded references} — cascades recursively with the same semantics
+     * - {@link @metreeca/blue/reference!ReferenceConstraints.captive | captive references} — accepted as bare IRI
+     * references or, up to `opts.depth` nesting levels, as inline batches creating or updating the captive tree
+     * - {@link @metreeca/blue/reference!ReferenceConstraints.foreign | foreign references} — skipped, as their
+     * data is owned by the defining resource
+     *
+     * > [!CAUTION]
+     * > By default, resources accept captive reference expansion to unbounded depth. To enforce a strict insertion
+     * > process that admits only bare references, set `opts.depth` to `0` to reject all expansion; set it to a positive
+     * > value to cap the nesting depth admitted.
+     *
+     * @param request - Insertion specifications
+     * @param request.entry - Absolute identifier of the target resource
+     * @param request.shape - Resource shape driving the operation
+     * @param request.state - Complete resource state to be inserted
+     * @param opts - Optional insertion options
+     * @param opts.depth - Maximum nesting depth for expanding `captive` reference values as inline target resource
+     * states, each expansion level counting against the budget; `0` rejects all expansion, accepting bare IRI
+     * references only; omission leaves expansion unbounded
+     *
+     * @returns A promise resolving to the `entry` {@link Reference} of the inserted resource; rejects with a
+     * `RangeError` if `entry` is not an absolute IRI or if `state` carries an `id` differing from `entry`, a
+     * {@link TraceError} if `state` doesn't {@link validate} against the shape, or a {@link Problem} on
+     * network, storage, or other processing errors
+     *
+     * @throws `Error` if the store has been {@link Store.close closed}
+     *
+     * @see {@link StoreClient.create create} for conditional creation
+     * @see {@link StoreClient.update update} for conditional replacement
+     */
+    insert(request: {
+        readonly entry: Reference;
+        readonly shape: Lazy<ResourceShape>;
+        readonly state: Resource;
+    }, opts?: {
+        readonly depth?: number;
+    }): Promise<Reference>;
+    /**
+     * Remove a resource.
+     *
+     * Unconditionally removes the resource's own data and clears references to it from other resources. Specific
+     * reference kinds are handled as follows:
+     *
+     * - {@link ResourceShape | embedded references} — cascades recursively with the same semantics
+     * - {@link @metreeca/blue/reference!ReferenceConstraints.captive | captive references} — cascade-removed with
+     * the same semantics
+     *
+     * @param request - Removal specifications
+     * @param request.entry - Absolute identifier of the target resource
+     * @param request.shape - Resource shape driving the operation
+     *
+     * @returns A promise resolving to the `entry` {@link Reference} of the removed resource; rejects with a
+     * `RangeError` if `entry` is not an absolute IRI, or a {@link Problem} on network, storage, or other
+     * processing errors
+     *
+     * @throws `Error` if the store has been {@link Store.close closed}
+     *
+     * @see {@link StoreClient.delete delete} for conditional removal
+     */
+    remove(request: {
+        readonly entry: Reference;
+        readonly shape: Lazy<ResourceShape>;
+    }): Promise<Reference>;
+}
+/**
+ * Store mutation observer.
+ *
+ * Receives batched mutation events. Registered via {@link Store.observe}.
+ */
+export interface StoreObserver {
+    /**
+     * Receive a batch of mutation events.
+     *
+     * Each entry maps a mutated resource id to an existence flag: `true` if the resource was
+     * {@link StoreClient.create created}, {@link StoreClient.update updated}, or {@link StoreClient.insert inserted};
+     * `false` if it was {@link StoreClient.delete deleted} or {@link StoreClient.remove removed}. When the same
+     * resource is mutated multiple times within a batch, last-write-wins semantics apply.
+     *
+     * > [!NOTE]
+     * > Observers may be sync or async. Both synchronous throws and asynchronous rejections are caught and
+     * > silently ignored so that one faulty observer cannot break delivery to others.
+     *
+     * @param mutations - Record mapping resource identifiers to existence flags
+     *     (`true` for upserted, `false` for removed)
+     */
+    (mutations: {
+        readonly [entry: Reference]: boolean;
+    }): void | Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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