@interop/wallet-core 0.1.0

package/dist/sync/push.js

@@ -0,0 +1,191 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The push side of the WAS replication engine core: fan each dirty local row out
+ * to a conditional WAS write, then reconcile per the content-addressed conflict
+ * table.
+ *
+ * On a content-addressed collection an id's `data` never mutates, so a live row
+ * only ever pushes as a create (`If-None-Match: *`) and a tombstone as a delete;
+ * there is no update path. A mutable (last-write-wins) collection pushes a live
+ * row as a create while never-acked (`version 0`) and as an in-place update
+ * (`If-Match`) once acked, and settles a `412` through its injected
+ * {@link ResolveConflict} policy.
+ *
+ * This loop covers the CONTENT sub-resource only (`data` / `version`, at
+ * `PUT/DELETE /:id`). It does not drive the independently-versioned METADATA
+ * sub-resource (`custom` / `metaVersion`, at `PUT /:id/meta`): a replica that
+ * syncs user-writable metadata (the web wallet's RxDB driver, via
+ * `WasSyncPort.putMeta`) keeps that half in its own push handler. It is left out
+ * of this core deliberately -- none of the wallet Space collections
+ * (`private-credentials`, `public-credentials`, `wallet-activity`, `contacts`,
+ * `contacts-history`) versions its metadata independently of its content, so
+ * folding a `putMeta` diff into this loop would add an untested code path with
+ * no collection to exercise it. The `WasSyncPort.putMeta` capability stays
+ * optional on the port for the driver that needs it.
+ */
+import { formatEtag } from '@interop/was-client/sync';
+import { WasSyncConflictError, WasSyncNotFoundError } from './types.js';
+// Formats a master revision as the quoted strong ETag the server compares
+// `If-Match` against (revision `3` becomes `"3"`). Re-exported so callers keep
+// importing it from here.
+export { formatEtag };
+/**
+ * Pushes a dirty live row. A never-acked row (`version 0`) is a create
+ * (`PUT /:id` with `If-None-Match: *`); an acked row (`version > 0`) is an
+ * in-place update (`If-Match` over its version) -- reachable only on a mutable
+ * collection, since a content-addressed row never mutates in place. On success
+ * the acked version is recorded and the row goes clean.
+ *
+ * A `412` is settled by the collection's policy:
+ * - A mutable collection defers to its {@link ResolveConflict} (re-read master,
+ *   pick the deterministic winner, apply-remote or re-encrypt-local).
+ * - An insert-only content-addressed collection (no resolver) applies the
+ *   built-in settlement: master live -> the identical envelope already exists
+ *   (same content hash), adopt its version, projection untouched; master
+ *   absent/tombstone -> deletion wins, adopt the tombstone and delete the
+ *   projection (a later re-add re-encrypts to a fresh id, so nothing is blocked).
+ */
+async function pushUpsert({ port, store, row, resolveConflict }) {
+    try {
+        const version = await port.putContent({
+            id: row.id,
+            data: row.data ?? null,
+            ...(row.version > 0
+                ? { ifMatch: formatEtag(row.version) }
+                : { ifNoneMatch: true })
+        });
+        await store.markPushed({ id: row.id, version });
+        return { conflictResolved: false };
+    }
+    catch (err) {
+        if (!(err instanceof WasSyncConflictError)) {
+            throw err;
+        }
+        if (resolveConflict) {
+            await resolveConflict({
+                id: row.id,
+                version: row.version,
+                data: row.data
+            });
+            // The resolver may have left the row dirty (local-wins re-encrypt); the
+            // caller reruns so the re-push settles within the same sync run.
+            return { conflictResolved: true };
+        }
+        const master = await port.get({ id: row.id });
+        if (master === null || master.deleted) {
+            await store.adoptMaster({
+                id: row.id,
+                master: null,
+                projection: { kind: 'delete' }
+            });
+        }
+        else {
+            await store.adoptMaster({
+                id: row.id,
+                master,
+                projection: { kind: 'none' }
+            });
+        }
+        return { conflictResolved: false };
+    }
+}
+/**
+ * Attempts one conditional delete. Returns `true` when the delete is settled
+ * (`204` acked, or `404` -- already gone / never reached the server), `false`
+ * on a `412` so the caller can re-read and retry. Any other error propagates to
+ * the engine's backoff.
+ */
+async function tryDelete({ port, store, id, ifMatch }) {
+    try {
+        const version = await port.deleteContent({
+            id,
+            ...(ifMatch !== undefined && { ifMatch })
+        });
+        await store.markDeletedPushed({ id, version });
+        return true;
+    }
+    catch (err) {
+        if (err instanceof WasSyncNotFoundError) {
+            await store.markDeletedPushed({ id });
+            return true;
+        }
+        if (err instanceof WasSyncConflictError) {
+            return false;
+        }
+        throw err;
+    }
+}
+/**
+ * Pushes a dirty tombstone. `DELETE /:id` with `If-Match` when the row was ever
+ * acked (`version > 0`), unconditional otherwise:
+ * - `204` / `404` -> settled (clean).
+ * - `412` then master absent/tombstone -> delete/delete race, settled.
+ * - `412` then master live -> retry once with a fresh `If-Match`; a second
+ *   `412` leaves the row dirty for the next cycle (the next pull refreshes its
+ *   `version` via the dirty-deleted-vs-live rule, so the retry's `If-Match`
+ *   becomes current).
+ */
+async function pushDelete({ port, store, row }) {
+    const firstIfMatch = row.version > 0 ? formatEtag(row.version) : undefined;
+    if (await tryDelete({ port, store, id: row.id, ifMatch: firstIfMatch })) {
+        return;
+    }
+    const master = await port.get({ id: row.id });
+    if (master === null || master.deleted) {
+        // delete/delete race -- the resource is already a tombstone / absent.
+        await store.markDeletedPushed({ id: row.id });
+        return;
+    }
+    // Second attempt with the current master version. If it too hits 412 we simply
+    // leave the row dirty (tryDelete returned false and made no store write).
+    await tryDelete({
+        port,
+        store,
+        id: row.id,
+        ifMatch: formatEtag(master.version)
+    });
+}
+/**
+ * Pushes every dirty row for one feed, sequentially (bounds sockets/CPU, and
+ * keeps conflict reconciliation deterministic). Honors `signal` between rows.
+ * A non-conflict error from any row propagates so the engine aborts the cycle
+ * and backs off; already-pushed rows in the batch stay settled.
+ *
+ * @param options {object}
+ * @param options.port {WasSyncPort}
+ * @param options.store {SyncStore}
+ * @param [options.resolveConflict] {ResolveConflict}   mutable-collection policy
+ * @param [options.signal] {AbortSignal}
+ * @returns {Promise<{ pushed: number; conflictsResolved: number }>}   dirty rows
+ *   processed this cycle, and how many invoked the LWW resolver (a positive
+ *   count means the caller should rerun so a local-wins re-push settles)
+ */
+export async function runPush({ port, store, resolveConflict, signal }) {
+    const rows = await store.getDirtyRows();
+    let pushed = 0;
+    let conflictsResolved = 0;
+    for (const row of rows) {
+        if (signal?.aborted) {
+            break;
+        }
+        if (row.deleted) {
+            await pushDelete({ port, store, row });
+        }
+        else {
+            const { conflictResolved } = await pushUpsert({
+                port,
+                store,
+                row,
+                resolveConflict
+            });
+            if (conflictResolved) {
+                conflictsResolved += 1;
+            }
+        }
+        pushed += 1;
+    }
+    return { pushed, conflictsResolved };
+}
+//# sourceMappingURL=push.js.map

package/dist/sync/push.js.map

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

package/dist/sync/types.d.ts

@@ -0,0 +1,123 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * Types for the WAS replication engine core.
+ *
+ * The wire contract and port seam (`Json`, `SyncCheckpoint`, `WireDoc`,
+ * `MasterState`, `WasSyncPort`, `DocCipher`, and the `WasSyncConflictError` /
+ * `WasSyncNotFoundError` signals) come from `@interop/was-client/sync` and are
+ * re-exported here so a single import gives a consumer both the wire types and
+ * the replica-side seams.
+ *
+ * The local-persistence seam (`SyncStore`, `SyncedRow`, `ProjectionAction`,
+ * `ResolveConflict`) is the replica's side of the contract: it stands in for a
+ * concrete store (an RxDB collection, a SQLite `synced_docs` / `sync_checkpoints`
+ * table pair, or an in-memory test double). The engine owns the `DocCipher` and
+ * decrypts OUTSIDE the store transaction, so these methods never see key
+ * material.
+ *
+ * This module (and `pull.ts` / `push.ts` / `engine.ts`) has no runtime imports
+ * beyond the wire contract, so the engine runs anywhere: browser, Node, or React
+ * Native, against a fake port and an in-memory store.
+ */
+export { WasSyncConflictError, WasSyncNotFoundError } from '@interop/was-client/sync';
+export type { Json, SyncCheckpoint, WireDoc, MasterState, WasSyncPort, DocCipher } from '@interop/was-client/sync';
+import type { Json, MasterState, SyncCheckpoint, WireDoc } from '@interop/was-client/sync';
+/**
+ * A dirty local synced-docs row awaiting push. `data` is the stored body (the
+ * EDV envelope on an encrypted collection, or the plaintext JSON on a plaintext
+ * one), `null` for a tombstone. `version` is the last server-acked content
+ * revision (`0` = never acked, so a create).
+ */
+export interface SyncedRow {
+    id: string;
+    version: number;
+    updatedAt: string;
+    deleted: boolean;
+    data: Json | null;
+}
+/**
+ * What a pulled / reconciled document does to the decrypted read-model (the
+ * plaintext projection for the collection). Computed by the engine (which owns
+ * the DocCipher) and handed to the store to apply inside the same transaction as
+ * the envelope write. The collection-specific meaning of "upsert" / "delete" is
+ * supplied to the store as transactional writer functions, so this action stays
+ * collection-agnostic: `payload` is the decrypted document body. `none` = leave
+ * the projection untouched (e.g. adopting a live master for a document already
+ * present locally).
+ */
+export type ProjectionAction = {
+    kind: 'upsert';
+    payload: Json;
+} | {
+    kind: 'delete';
+} | {
+    kind: 'none';
+};
+/**
+ * The per-row 412-conflict policy for a mutable (last-write-wins) collection,
+ * injected into the push loop. Insert-only content-addressed collections leave
+ * it undefined: their settlement rules -- identical-envelope adoption and
+ * tombstone-wins -- already cover every 412. For a mutable head document the
+ * resolver re-reads the master, decides the winner deterministically, and either
+ * applies the remote payload or re-encrypts the local one for the next push.
+ * Bound to a profile's cipher + store by the caller; opaque to the push loop.
+ */
+export type ResolveConflict = (row: {
+    id: string;
+    version: number;
+    data: Json | null;
+}) => Promise<void>;
+/**
+ * The local-persistence seam, pre-bound to one `(replica, collection)` feed. A
+ * concrete store implements it; the engine and the pull/push loops depend only
+ * on this interface. Every method that mutates more than one table does so in
+ * ONE exclusive transaction (see the per-method notes). Decryption happens in
+ * the engine, outside these calls.
+ */
+export interface SyncStore {
+    /** The last persisted pull checkpoint, or `undefined` before the first pull. */
+    getCheckpoint(): Promise<SyncCheckpoint | undefined>;
+    /** All rows awaiting push (dirty). */
+    getDirtyRows(): Promise<SyncedRow[]>;
+    /**
+     * Applies one pulled page in a single exclusive transaction: reconcile each
+     * document against the local row (per the pull-apply conflict table), write
+     * the matching projection action, and advance the checkpoint. `projections`
+     * is keyed by document id.
+     */
+    applyPulledPage(options: {
+        documents: WireDoc[];
+        checkpoint: SyncCheckpoint;
+        projections: Map<string, ProjectionAction>;
+    }): Promise<void>;
+    /**
+     * Marks a pushed create as acked: clear dirty, and record the server `version`
+     * when provided (the `204` ETag).
+     */
+    markPushed(options: {
+        id: string;
+        version?: number;
+    }): Promise<void>;
+    /**
+     * Marks a pushed delete as settled: keep the tombstone, clear dirty, and
+     * record the server `version` when provided.
+     */
+    markDeletedPushed(options: {
+        id: string;
+        version?: number;
+    }): Promise<void>;
+    /**
+     * Adopts the server's master state for a row whose push hit a `412`, applying
+     * `projection` in the same transaction. `master === null` means the server has
+     * a tombstone (or the resource is absent): record the tombstone and delete the
+     * projection.
+     */
+    adoptMaster(options: {
+        id: string;
+        master: MasterState | null;
+        projection: ProjectionAction;
+    }): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/sync/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,0BAA0B,CAAA;AACjC,YAAY,EACV,IAAI,EACJ,cAAc,EACd,OAAO,EACP,WAAW,EACX,WAAW,EACX,SAAS,EACV,MAAM,0BAA0B,CAAA;AAEjC,OAAO,KAAK,EACV,IAAI,EACJ,WAAW,EACX,cAAc,EACd,OAAO,EACR,MAAM,0BAA0B,CAAA;AAEjC;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;CAClB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAEpB;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;CAClB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAEnB;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,gFAAgF;IAChF,aAAa,IAAI,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAAA;IAEpD,sCAAsC;IACtC,YAAY,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAA;IAEpC;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE;QACvB,SAAS,EAAE,OAAO,EAAE,CAAA;QACpB,UAAU,EAAE,cAAc,CAAA;QAC1B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;KAC3C,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEjB;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEpE;;;OAGG;IACH,iBAAiB,CAAC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE3E;;;;;OAKG;IACH,WAAW,CAAC,OAAO,EAAE;QACnB,EAAE,EAAE,MAAM,CAAA;QACV,MAAM,EAAE,WAAW,GAAG,IAAI,CAAA;QAC1B,UAAU,EAAE,gBAAgB,CAAA;KAC7B,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAClB"}

package/dist/sync/types.js

@@ -0,0 +1,25 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * Types for the WAS replication engine core.
+ *
+ * The wire contract and port seam (`Json`, `SyncCheckpoint`, `WireDoc`,
+ * `MasterState`, `WasSyncPort`, `DocCipher`, and the `WasSyncConflictError` /
+ * `WasSyncNotFoundError` signals) come from `@interop/was-client/sync` and are
+ * re-exported here so a single import gives a consumer both the wire types and
+ * the replica-side seams.
+ *
+ * The local-persistence seam (`SyncStore`, `SyncedRow`, `ProjectionAction`,
+ * `ResolveConflict`) is the replica's side of the contract: it stands in for a
+ * concrete store (an RxDB collection, a SQLite `synced_docs` / `sync_checkpoints`
+ * table pair, or an in-memory test double). The engine owns the `DocCipher` and
+ * decrypts OUTSIDE the store transaction, so these methods never see key
+ * material.
+ *
+ * This module (and `pull.ts` / `push.ts` / `engine.ts`) has no runtime imports
+ * beyond the wire contract, so the engine runs anywhere: browser, Node, or React
+ * Native, against a fake port and an in-memory store.
+ */
+export { WasSyncConflictError, WasSyncNotFoundError } from '@interop/was-client/sync';
+//# sourceMappingURL=types.js.map

package/dist/sync/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/sync/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,0BAA0B,CAAA"}

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@interop/wallet-core",
+  "description": "Shared wallet-domain logic (WAS sync engine core and wallet Space layout contracts) for Interop wallet apps.",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "pnpm run clear && tsc",
+    "clear": "rimraf dist/*",
+    "dev": "vite",
+    "fix": "eslint --fix src test && pnpm run format",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\" \"*.md\"",
+    "lint": "eslint src test",
+    "prepare": "pnpm run build",
+    "rebuild": "pnpm run clear && pnpm run build",
+    "typecheck": "tsc -p tsconfig.dev.json",
+    "test": "pnpm run fix && pnpm run lint && pnpm run typecheck && pnpm run test:node",
+    "test:browser": "playwright test",
+    "test:node": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "react-native": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./sync": {
+      "types": "./dist/sync/index.d.ts",
+      "react-native": "./dist/sync/index.js",
+      "import": "./dist/sync/index.js",
+      "default": "./dist/sync/index.js"
+    },
+    "./space": {
+      "types": "./dist/space/index.d.ts",
+      "react-native": "./dist/space/index.js",
+      "import": "./dist/space/index.js",
+      "default": "./dist/space/index.js"
+    }
+  },
+  "module": "dist/index.js",
+  "browser": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "dependencies": {
+    "@interop/was-client": "^0.19.0",
+    "@scure/base": "^1.2.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.60.0",
+    "@types/node": "^26.0.1",
+    "@vitest/coverage-v8": "^4.1.7",
+    "eslint": "^10.4.0",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.6.0",
+    "prettier": "^3.8.3",
+    "rimraf": "^6.1.3",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.4",
+    "vite": "^8.0.14",
+    "vitest": "^4.1.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "wallet",
+    "verifiable-credentials",
+    "sync",
+    "wallet-attached-storage",
+    "isomorphic"
+  ],
+  "packageManager": "pnpm@11.5.0",
+  "engines": {
+    "node": ">=24.0"
+  },
+  "author": {
+    "name": "Interop Alliance",
+    "url": "https://github.com/interop-alliance/"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/interop-alliance/wallet-core.git"
+  },
+  "homepage": "https://github.com/interop-alliance/wallet-core",
+  "bugs": "https://github.com/interop-alliance/wallet-core/issues"
+}