@midnight-ntwrk/wallet-sdk-runtime 1.0.4 → 1.0.5

package/README.md

@@ -1,3 +1,10 @@
+> [!IMPORTANT]
+> **This package has moved.** The `@midnight-ntwrk` scope is published only
+> during the migration window and will stop receiving updates. Please migrate to
+> [`@midnightntwrk/wallet-sdk-runtime`](https://www.npmjs.com/package/@midnightntwrk/wallet-sdk-runtime).
+
+---
+
 # @midnight-ntwrk/wallet-sdk-runtime
 
 Runtime infrastructure for Midnight wallet variants.

package/dist/Runtime.js

@@ -33,17 +33,25 @@ export const init = (initArgs) => {
         return runVariantStream(initiatedFirstVariant, currentStateRef, progressRef, currentVariantRef).pipe(Effect.catchAll((error) => {
             return SubscriptionRef.set(currentStateRef, Either.left(error));
         }), Effect.forkScoped);
-    }), Effect.flatMap(({ currentStateRef, progressRef, currentVariantRef }) => {
-        return Effect.gen(function* () {
-            const changesStream = yield* currentStateRef.changes.pipe(Stream.mapEffect((value) => EitherOps.toEffect(value)), Stream.share({ capacity: 'unbounded', replay: 1 }));
-            const runtime = {
-                stateChanges: changesStream,
-                progress: progressRef.get,
-                currentVariant: currentVariantRef.get,
-                dispatch: (impl) => dispatch(runtime, impl),
-            };
-            return runtime;
-        });
+    }), Effect.map(({ currentStateRef, progressRef, currentVariantRef }) => {
+        // Latest-value semantics with bounded memory: each subscriber gets the current state on
+        // subscription (SubscriptionRef.changes emits it atomically with subsequent changes) and
+        // may skip intermediate states when it lags behind the producer — the sliding buffer of
+        // capacity 1 keeps only the latest state, so past state instances (which hold wasm
+        // resources) can be released.
+        //
+        // Deliberately NOT Stream.share with `replay`: Effect's PubSub replay buffer (up to and
+        // including effect 3.21.3) appends every published value to a shared linked list, and a
+        // subscription's ReplayWindowImpl never releases its head node after the replay window is
+        // exhausted — any long-lived subscriber pins every state published during its lifetime.
+        const changesStream = currentStateRef.changes.pipe(Stream.mapEffect((value) => EitherOps.toEffect(value)), Stream.buffer({ capacity: 1, strategy: 'sliding' }));
+        const runtime = {
+            stateChanges: changesStream,
+            progress: progressRef.get,
+            currentVariant: currentVariantRef.get,
+            dispatch: (impl) => dispatch(runtime, impl),
+        };
+        return runtime;
     }));
 };
 export const dispatch = (runtime, impl) => {

package/dist/testing/utils.d.ts

@@ -1,5 +1,5 @@
-import { type ProtocolState } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { Chunk } from 'effect';
+import { ProtocolState } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { Chunk, Equivalence } from 'effect';
 import { type Observable, type OperatorFunction } from 'rxjs';
 /**
  * Utility function that takes state values from an RxJS observable until it completes or errors.
@@ -11,4 +11,22 @@ import { type Observable, type OperatorFunction } from 'rxjs';
  */
 export declare const toProtocolStateArray: <T>(observable: Observable<ProtocolState.ProtocolState<T>>, onErrCallback?: (err: unknown) => void) => Promise<ProtocolState.ProtocolState<T>[]>;
 export declare const reduceToChunk: <T>() => OperatorFunction<T, Chunk.Chunk<T>>;
+/**
+ * Checks whether `received` is an ordered subsequence of `expected` — every received element appears in `expected` in
+ * the same relative order, though elements of `expected` may be skipped.
+ *
+ * This matches the runtime's latest-value state stream contract: a subscriber always converges on the latest state, but
+ * may skip intermediate states when it lags behind the producer. Received states must therefore never be reordered,
+ * fabricated, or repeated out of order — but any prefix of intermediate states may be missing.
+ *
+ * @internal
+ */
+export declare const isOrderedSubsequenceOf: <T>(received: readonly T[], expected: readonly T[], equals: Equivalence.Equivalence<T>) => boolean;
+/**
+ * Equality of {@link ProtocolState.ProtocolState} values over primitive states, for use with
+ * {@link isOrderedSubsequenceOf}.
+ *
+ * @internal
+ */
+export declare const protocolStateEquals: Equivalence.Equivalence<ProtocolState.ProtocolState<unknown>>;
 export declare const isRange: (values: Chunk.Chunk<number>) => boolean;

package/dist/testing/utils.js

@@ -1,4 +1,17 @@
-import { Chunk } from 'effect';
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// 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 { ProtocolState } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { Chunk, Equivalence } from 'effect';
 import { reduce } from 'rxjs';
 /**
  * Utility function that takes state values from an RxJS observable until it completes or errors.
@@ -24,6 +37,33 @@ export const toProtocolStateArray = (observable, onErrCallback) => new Promise((
     });
 });
 export const reduceToChunk = () => reduce((chunk, value) => Chunk.append(chunk, value), Chunk.empty());
+/**
+ * Checks whether `received` is an ordered subsequence of `expected` — every received element appears in `expected` in
+ * the same relative order, though elements of `expected` may be skipped.
+ *
+ * This matches the runtime's latest-value state stream contract: a subscriber always converges on the latest state, but
+ * may skip intermediate states when it lags behind the producer. Received states must therefore never be reordered,
+ * fabricated, or repeated out of order — but any prefix of intermediate states may be missing.
+ *
+ * @internal
+ */
+export const isOrderedSubsequenceOf = (received, expected, equals) => {
+    const searchEnd = received.reduce((searchFrom, value) => {
+        if (searchFrom < 0) {
+            return searchFrom;
+        }
+        const index = expected.findIndex((candidate, i) => i >= searchFrom && equals(candidate, value));
+        return index < 0 ? -1 : index + 1;
+    }, 0);
+    return searchEnd >= 0;
+};
+/**
+ * Equality of {@link ProtocolState.ProtocolState} values over primitive states, for use with
+ * {@link isOrderedSubsequenceOf}.
+ *
+ * @internal
+ */
+export const protocolStateEquals = ProtocolState.getEquivalence(Equivalence.strict());
 export const isRange = (values) => {
     const firstDropped = Chunk.drop(values, 1);
     const lastDropped = Chunk.dropRight(values, 1);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-runtime",
   "description": "Runtime for the wallet variants",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -9,14 +9,16 @@
   "author": "Midnight Foundation",
   "license": "Apache-2.0",
   "publishConfig": {
-    "registry": "https://npm.pkg.github.com/"
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
   },
   "files": [
     "dist/"
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/midnight-ntwrk/artifacts.git"
+    "url": "git+https://github.com/midnightntwrk/midnight-wallet.git",
+    "directory": "packages/runtime"
   },
   "exports": {
     ".": {