@interop/was-client 0.68.0 → 0.70.0

package/dist/paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,EACL,SAAS,EACT,SAAS,EACT,cAAc,EACd,cAAc,EACd,aAAa,EACb,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,KAAK,EACL,cAAc,EACd,gBAAgB,EACjB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,wBAAwB,CAAA;AAC/B,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAE1D,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA"}
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,EACL,SAAS,EACT,SAAS,EACT,cAAc,EACd,cAAc,EACd,aAAa,EACb,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,KAAK,EACL,cAAc,EACd,gBAAgB,EACjB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,wBAAwB,CAAA;AAC/B,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAE1D,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACvE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA"}

package/dist/sync/index.d.ts

@@ -13,6 +13,11 @@
  * - `createPlaintextDocCipher` / `isEncryptedEnvelope` -- the identity cipher
  *   for a plaintext content-addressed collection, and the envelope predicate,
  *   both free of the `@interop/was-client/edv` crypto graph.
+ * - `requireResourceId` -- the guard both built-in ciphers run first, exported
+ *   so a consumer writing its own `DocCipher` refuses a missing resource id
+ *   the same way instead of hand-rolling the check. It raises a
+ *   `ValidationError`, which reports a caller passing no id rather than a
+ *   condition to classify and recover from, so no predicate ships for it.
  * - `ensureSpaceAndCollection` / `ensureSpace` -- idempotent Space +
  *   Collection provisioning, and its Space half alone (ensure the Space once,
  *   then thread the returned description through every collection).
@@ -20,10 +25,11 @@
  *   `isUnknownEpochError` / `isKeyUnwrapError` / `isIntegrityError` /
  *   `isNotSupportedError` -- the classification contract for the signals
  *   below. A consumer matches by `err.name` and never with `instanceof`,
- *   because every one of these errors is raised inside a seam the app injects
- *   (the port, the caller's `DocCipher`) and that seam can resolve to a second
- *   copy of this package. Reading a property off the matched value, such as
- *   `status` on an auth error, is the intended shape.
+ *   because these errors are raised inside a seam the app injects (the port,
+ *   the caller's `DocCipher`) and that seam can resolve to a second copy of
+ *   this package. The affordance gate is raised outside a seam but matched the
+ *   same way, so the rule has no exceptions. Reading a property off the
+ *   matched value, such as `status` on an auth error, is the intended shape.
  *
  * The 412 conflict / 404 not-found port signals (`WasSyncConflictError` /
  * `WasSyncNotFoundError`), and the opt-in revoked-access signal
@@ -38,16 +44,19 @@
  * (`IntegrityError`: the stored body does not verify against the resource id
  * it was read under). `EncryptionError`, the fail-closed umbrella both
  * `KeyUnwrapError` and `IntegrityError` fall under, rides along. So does the
- * affordance gate (`NotSupportedError`), which a guarded write raises before
- * any request when the read it is pinned to returned no `ETag` validator -- a
- * permanent refusal, so a replication driver stops rather than retries.
+ * affordance gate (`NotSupportedError`), a permanent refusal raised before any
+ * request: by a guarded write whose pinned read returned no `ETag` validator
+ * (`/log`, `/edv`, and the client's own content-addressed store), and by a
+ * cipher handed a chunked envelope it has no route to (`/edv`). This subpath
+ * raises it on neither a push nor a pull, and is where the predicate for it
+ * ships, so a consumer of those entries can match it by name too.
  * The classes are exported
  * for construction and for a caller inside one resolved copy; across a package
  * boundary the predicates are the contract
  * (`decisions/0001-cross-package-errors-match-by-name.md`).
  */
 export { createWasSyncPort, KEY_EPOCH_HEADER, parseEtag } from './port.js';
-export { httpStatus as errorStatus, errorMessage } from '../errors.js';
+export { httpStatus as errorStatus, errorMessage, requireResourceId } from '../errors.js';
 export { contentCid, cidFrom, deriveSpaceId } from './cid.js';
 export { isEncryptedEnvelope } from './envelope.js';
 export { createPlaintextDocCipher } from './plaintextCipher.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAI1E,OAAO,EAAE,UAAU,IAAI,WAAW,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AACzE,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,eAAe,EACf,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,IAAI,EACJ,cAAc,EACd,OAAO,EACP,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,UAAU,EACV,WAAW,EACX,SAAS,EACV,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAI1E,OAAO,EACL,UAAU,IAAI,WAAW,EACzB,YAAY,EACZ,iBAAiB,EAClB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AACzE,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,eAAe,EACf,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,IAAI,EACJ,cAAc,EACd,OAAO,EACP,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,UAAU,EACV,WAAW,EACX,SAAS,EACV,MAAM,YAAY,CAAA"}

package/dist/sync/index.js

@@ -13,6 +13,11 @@
  * - `createPlaintextDocCipher` / `isEncryptedEnvelope` -- the identity cipher
  *   for a plaintext content-addressed collection, and the envelope predicate,
  *   both free of the `@interop/was-client/edv` crypto graph.
+ * - `requireResourceId` -- the guard both built-in ciphers run first, exported
+ *   so a consumer writing its own `DocCipher` refuses a missing resource id
+ *   the same way instead of hand-rolling the check. It raises a
+ *   `ValidationError`, which reports a caller passing no id rather than a
+ *   condition to classify and recover from, so no predicate ships for it.
  * - `ensureSpaceAndCollection` / `ensureSpace` -- idempotent Space +
  *   Collection provisioning, and its Space half alone (ensure the Space once,
  *   then thread the returned description through every collection).
@@ -20,10 +25,11 @@
  *   `isUnknownEpochError` / `isKeyUnwrapError` / `isIntegrityError` /
  *   `isNotSupportedError` -- the classification contract for the signals
  *   below. A consumer matches by `err.name` and never with `instanceof`,
- *   because every one of these errors is raised inside a seam the app injects
- *   (the port, the caller's `DocCipher`) and that seam can resolve to a second
- *   copy of this package. Reading a property off the matched value, such as
- *   `status` on an auth error, is the intended shape.
+ *   because these errors are raised inside a seam the app injects (the port,
+ *   the caller's `DocCipher`) and that seam can resolve to a second copy of
+ *   this package. The affordance gate is raised outside a seam but matched the
+ *   same way, so the rule has no exceptions. Reading a property off the
+ *   matched value, such as `status` on an auth error, is the intended shape.
  *
  * The 412 conflict / 404 not-found port signals (`WasSyncConflictError` /
  * `WasSyncNotFoundError`), and the opt-in revoked-access signal
@@ -38,9 +44,12 @@
  * (`IntegrityError`: the stored body does not verify against the resource id
  * it was read under). `EncryptionError`, the fail-closed umbrella both
  * `KeyUnwrapError` and `IntegrityError` fall under, rides along. So does the
- * affordance gate (`NotSupportedError`), which a guarded write raises before
- * any request when the read it is pinned to returned no `ETag` validator -- a
- * permanent refusal, so a replication driver stops rather than retries.
+ * affordance gate (`NotSupportedError`), a permanent refusal raised before any
+ * request: by a guarded write whose pinned read returned no `ETag` validator
+ * (`/log`, `/edv`, and the client's own content-addressed store), and by a
+ * cipher handed a chunked envelope it has no route to (`/edv`). This subpath
+ * raises it on neither a push nor a pull, and is where the predicate for it
+ * ships, so a consumer of those entries can match it by name too.
  * The classes are exported
  * for construction and for a caller inside one resolved copy; across a package
  * boundary the predicates are the contract
@@ -50,7 +59,7 @@ export { createWasSyncPort, KEY_EPOCH_HEADER, parseEtag } from './port.js';
 // The sync subpath's names for the client's own error accessors, so a
 // sync-only consumer reads a raw ky/ezcap failure without importing the core
 // entry.
-export { httpStatus as errorStatus, errorMessage } from '../errors.js';
+export { httpStatus as errorStatus, errorMessage, requireResourceId } from '../errors.js';
 export { contentCid, cidFrom, deriveSpaceId } from './cid.js';
 export { isEncryptedEnvelope } from './envelope.js';
 export { createPlaintextDocCipher } from './plaintextCipher.js';

package/dist/sync/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAC1E,sEAAsE;AACtE,6EAA6E;AAC7E,SAAS;AACT,OAAO,EAAE,UAAU,IAAI,WAAW,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AACzE,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,eAAe,EACf,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,cAAc,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAC1E,sEAAsE;AACtE,6EAA6E;AAC7E,SAAS;AACT,OAAO,EACL,UAAU,IAAI,WAAW,EACzB,YAAY,EACZ,iBAAiB,EAClB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AACzE,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,eAAe,EACf,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,cAAc,CAAA"}

package/dist/sync/predicates.d.ts

@@ -6,10 +6,13 @@
  * meet: the port's two wire signals (`WasSyncConflictError` /
  * `WasSyncNotFoundError`), its opt-in revoked-access signal
  * (`WasSyncAuthError`), the cipher's two no-key signals (the stale-descriptor
- * `UnknownEpochError` and the not-a-recipient `KeyUnwrapError`), its tamper
- * signal (`IntegrityError`), and the client's affordance gate
- * (`NotSupportedError`), raised before the request when the operation cannot
- * be carried out as asked.
+ * `UnknownEpochError` and the not-a-recipient `KeyUnwrapError`), and its
+ * tamper signal (`IntegrityError`).
+ *
+ * `isNotSupportedError` rides along for the client's affordance gate. That
+ * refusal belongs to the rest of the package rather than to this subpath,
+ * which raises it on neither a push nor a pull. The predicate's own doc says
+ * where it does come from.
  *
  * They live beside the classes that assign the names they match (`errors.ts`)
  * because every one of those errors is raised inside a seam the consuming app
@@ -99,13 +102,23 @@ export declare function isKeyUnwrapError(err: unknown): boolean;
 export declare function isIntegrityError(err: unknown): boolean;
 /**
  * Whether an error is the client's affordance-gate refusal
- * (`NotSupportedError`): the operation cannot be carried out as asked. On a
- * replication path it is the guarded write refused because the read it is
- * pinned to returned no `ETag` validator, and a chunked envelope a cipher was
- * built with no route to. Permanent, and the one refusal a replication driver
- * must NOT retry: nothing about a later attempt changes the answer, so a retry
- * loop would re-send the same batch forever. Raised before the request, so the
- * matched value carries no `status`.
+ * (`NotSupportedError`): the operation cannot be carried out as asked.
+ * Permanent, since nothing about a later attempt changes the answer. Raised
+ * before the request, so the matched value carries no `status`.
+ *
+ * It takes two forms. A guarded write refuses when the read it is pinned to
+ * returned no `ETag` validator, so the write would go out unconditionally;
+ * every such gate builds the error through `unenforcedPreconditionError`, in
+ * `log/logStore.ts`, `edv/logGovernedDescriptorStore.ts` and
+ * `internal/cas.ts`. A cipher refuses a chunked envelope it was built with no
+ * route to, in `edv/EdvCodec.ts` and `edv/WasTransport.ts`.
+ *
+ * Neither form arises on this subpath. Conditional writes are a baseline
+ * server requirement, so the sync port passes `ifMatch` / `ifNoneMatch`
+ * through with no gate in front of them, and it moves stored bodies verbatim
+ * without the codec. The predicate is exported here so a consumer of `/log` or
+ * `/edv` can classify the refusal by the same `err.name` rule as every other
+ * signal, not because a replication driver can meet it.
  *
  * @param err {unknown}   the caught error
  * @returns {boolean}

package/dist/sync/predicates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"predicates.d.ts","sourceRoot":"","sources":["../../src/sync/predicates.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAaH;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAErD;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEtD;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEtD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEzD"}
+{"version":3,"file":"predicates.d.ts","sourceRoot":"","sources":["../../src/sync/predicates.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAaH;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAErD;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEtD;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEtD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEzD"}

package/dist/sync/predicates.js

@@ -6,10 +6,13 @@
  * meet: the port's two wire signals (`WasSyncConflictError` /
  * `WasSyncNotFoundError`), its opt-in revoked-access signal
  * (`WasSyncAuthError`), the cipher's two no-key signals (the stale-descriptor
- * `UnknownEpochError` and the not-a-recipient `KeyUnwrapError`), its tamper
- * signal (`IntegrityError`), and the client's affordance gate
- * (`NotSupportedError`), raised before the request when the operation cannot
- * be carried out as asked.
+ * `UnknownEpochError` and the not-a-recipient `KeyUnwrapError`), and its
+ * tamper signal (`IntegrityError`).
+ *
+ * `isNotSupportedError` rides along for the client's affordance gate. That
+ * refusal belongs to the rest of the package rather than to this subpath,
+ * which raises it on neither a push nor a pull. The predicate's own doc says
+ * where it does come from.
  *
  * They live beside the classes that assign the names they match (`errors.ts`)
  * because every one of those errors is raised inside a seam the consuming app
@@ -121,13 +124,23 @@ export function isIntegrityError(err) {
 }
 /**
  * Whether an error is the client's affordance-gate refusal
- * (`NotSupportedError`): the operation cannot be carried out as asked. On a
- * replication path it is the guarded write refused because the read it is
- * pinned to returned no `ETag` validator, and a chunked envelope a cipher was
- * built with no route to. Permanent, and the one refusal a replication driver
- * must NOT retry: nothing about a later attempt changes the answer, so a retry
- * loop would re-send the same batch forever. Raised before the request, so the
- * matched value carries no `status`.
+ * (`NotSupportedError`): the operation cannot be carried out as asked.
+ * Permanent, since nothing about a later attempt changes the answer. Raised
+ * before the request, so the matched value carries no `status`.
+ *
+ * It takes two forms. A guarded write refuses when the read it is pinned to
+ * returned no `ETag` validator, so the write would go out unconditionally;
+ * every such gate builds the error through `unenforcedPreconditionError`, in
+ * `log/logStore.ts`, `edv/logGovernedDescriptorStore.ts` and
+ * `internal/cas.ts`. A cipher refuses a chunked envelope it was built with no
+ * route to, in `edv/EdvCodec.ts` and `edv/WasTransport.ts`.
+ *
+ * Neither form arises on this subpath. Conditional writes are a baseline
+ * server requirement, so the sync port passes `ifMatch` / `ifNoneMatch`
+ * through with no gate in front of them, and it moves stored bodies verbatim
+ * without the codec. The predicate is exported here so a consumer of `/log` or
+ * `/edv` can classify the refusal by the same `err.name` rule as every other
+ * signal, not because a replication driver can meet it.
  *
  * @param err {unknown}   the caught error
  * @returns {boolean}

package/dist/sync/predicates.js.map

@@ -1 +1 @@
-{"version":3,"file":"predicates.js","sourceRoot":"","sources":["../../src/sync/predicates.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;GAMG;AACH,SAAS,MAAM,CAAC,GAAY;IAC1B,OAAQ,GAAiC,EAAE,IAAI,CAAA;AACjD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC9C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,sBAAsB,CAAA;AAC/C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC9C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,sBAAsB,CAAA;AAC/C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,eAAe,CAAC,GAAY;IAC1C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,kBAAkB,CAAA;AAC3C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC9C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,mBAAmB,CAAA;AAC5C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAY;IAC3C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,gBAAgB,CAAA;AACzC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAY;IAC3C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,gBAAgB,CAAA;AACzC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC9C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,mBAAmB,CAAA;AAC5C,CAAC"}
+{"version":3,"file":"predicates.js","sourceRoot":"","sources":["../../src/sync/predicates.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;;;GAMG;AACH,SAAS,MAAM,CAAC,GAAY;IAC1B,OAAQ,GAAiC,EAAE,IAAI,CAAA;AACjD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC9C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,sBAAsB,CAAA;AAC/C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC9C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,sBAAsB,CAAA;AAC/C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,eAAe,CAAC,GAAY;IAC1C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,kBAAkB,CAAA;AAC3C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC9C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,mBAAmB,CAAA;AAC5C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAY;IAC3C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,gBAAgB,CAAA;AACzC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAY;IAC3C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,gBAAgB,CAAA;AACzC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC9C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,mBAAmB,CAAA;AAC5C,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@interop/was-client",
   "description": "A developer-friendly client for Wallet Attached Storage (WAS) servers.",
-  "version": "0.68.0",
+  "version": "0.70.0",
   "type": "module",
   "scripts": {
     "build": "pnpm run clear && tsc",
@@ -37,6 +37,12 @@
       "import": "./dist/edv/index.js",
       "default": "./dist/edv/index.js"
     },
+    "./edv/core": {
+      "types": "./dist/edv/core.d.ts",
+      "react-native": "./dist/edv/core.js",
+      "import": "./dist/edv/core.js",
+      "default": "./dist/edv/core.js"
+    },
     "./paths": {
       "types": "./dist/paths.d.ts",
       "react-native": "./dist/paths.js",
@@ -70,12 +76,12 @@
     "@interop/capability-agent": "^0.2.0",
     "@interop/data-integrity-core": "^8.7.1",
     "@interop/ed25519-signature": "^7.2.2",
-    "@interop/edv-client": "^17.8.4",
+    "@interop/edv-client": "^17.9.0",
     "@interop/ezcap": "^7.4.9",
     "@interop/http-client": "^1.0.5",
     "@interop/minimal-cipher": "^7.10.2",
     "@interop/storage-core": "^0.18.0",
-    "@interop/vh-resource-log": "^0.5.1",
+    "@interop/vh-resource-log": "^0.5.2",
     "@interop/x25519-key-agreement-key": "^5.4.0",
     "@noble/hashes": "^2.3.0",
     "@scure/base": "^2.3.0",