@wildo-ai/saas-frontend-lib 1.0.1 → 1.1.1

package/dist/esm/core/resources/rmm/ResourceMutationManager.js

@@ -6,11 +6,14 @@
  * Side-effect events via useEffect([snapshot.lastEvent?.id]).
  *
  * State machine: IDLE → QUEUED → SAVING → IDLE (happy path)
- *                SAVING → ERROR → SAVING (retry) → IDLE (exhaust)
+ *                SAVING → ERROR → SAVING (retry) → IDLE (exhaust: optimistic
+ *                  state REVERTS to confirmedData + user-visible failure)
  *                SAVING → CONFLICT → IDLE (acknowledge)
  *                ANY → DELETED (terminal)
  */
-import { DataMode, extractCrdtFieldNames, lwwFieldWinner, nextMonotonicTimestamp, CrdtResolutionWinner, sanitizeFieldMeta, } from '@wildo-ai/saas-models';
+import { DataMode, extractCrdtFieldNames, lwwFieldWinner, nextMonotonicTimestamp, CrdtResolutionWinner, sanitizeFieldMeta, CoreResourceOperation, ErrorCustomMessageReference, ResourcesConfig_OperationPathUtils, } from '@wildo-ai/saas-models';
+import { frontendEventBus } from '../../../core/events/event-bus.frontend.service.js';
+import { FrontendEvents } from '../../../core/events/events.frontend.schemas.js';
 import { RMMState, RMMEventType, MutationType, MutationSourceType, MutationErrorType, OperationResultStatus, ConflictStrategy, ConflictReason, MutationPriority, MutationCancelledError, ResourceDeletedError, BackpressureRejectedError, } from './types.js';
 import { RMM_HARD_TIMEOUT_MS, RMM_MAX_QUEUE_DEPTH, RMM_SERVER_RETRY_DELAY_MS, RMM_SOFT_TIMEOUT_MS, RMM_TRANSIENT_RETRY_DELAYS, } from './rmm-constants.js';
 import { rmmFieldPathsOverlap, rmmNormalizeFieldPath, rmmReadPathValue } from './field-path.utils.js';
@@ -21,9 +24,36 @@ import { LoggerFrontendService } from '../../../core/monitoring/logger.frontend.
 const logger = LoggerFrontendService.getLogger();
 const logDebug = logger.debugByType('ResourceMutationManager');
 logger.setDebugTypeLogging('ResourceMutationManager', false);
+/**
+ * Cap on remembered self-produced versions (see `_producedVersions`). Only very
+ * recent self-versions can still be in flight over the WebSocket, so a small
+ * bound is ample; it prevents unbounded growth on long-lived, heavily-edited
+ * resources.
+ */
+const PRODUCED_VERSIONS_MAX = 64;
 // =============================================================================
 // MODULE HELPERS
 // =============================================================================
+/**
+ * Read a value at a possibly-DOTTED path, mirroring `deepSetByPath`'s traversal and normalisation.
+ *
+ * Used to ask whether the server ECHOED a value for a field the caller cleared. A dotted key cannot
+ * be answered by a flat lookup: the read-back carries `{ address: { city: 'X' } }`, never a literal
+ * `'address.city'` key, so a flat probe would report "no echo" for every nested field and clear it
+ * even when the server said otherwise.
+ */
+function deepReadByPath(obj, path) {
+    const segments = rmmNormalizeFieldPath(path).split('.').filter(Boolean);
+    let current = obj;
+    for (const segment of segments) {
+        if (current === null || current === undefined || typeof current !== 'object')
+            return undefined;
+        current = Array.isArray(current)
+            ? current[Number(segment)]
+            : current[segment];
+    }
+    return current;
+}
 function deepSetByPath(obj, path, value) {
     const segments = rmmNormalizeFieldPath(path).split('.').filter(Boolean);
     let current = obj;
@@ -123,6 +153,11 @@ export class ResourceMutationManager {
     // --- WebSocket Event Deferral (Phase 4 — data structure only) ---
     _deferredSelfEvents = [];
     _allowSettledSelfEventRepair = false;
+    // Server versions THIS tab's own confirmed mutations minted. A WebSocket echo
+    // whose version is in this set is this tab's own optimistic echo (discard /
+    // defer); a version NOT in it is a change from another client — even another
+    // tab of the same user — so it is applied. See `_isOwnEcho`. Bounded FIFO.
+    _producedVersions = new Set();
     // --- CRDT Metadata ---
     _crdtFieldNames;
     _fieldMeta = null;
@@ -203,8 +238,10 @@ export class ResourceMutationManager {
     syncRuntimeRoutingConfig(patch) {
         if (this._state === RMMState.DELETED)
             return;
+        const hasReadOperationPathKeyPatch = Object.prototype.hasOwnProperty.call(patch, 'readOperationPathKey');
+        const hasParentResourcesRequirementsPatch = Object.prototype.hasOwnProperty.call(patch, 'parentResourcesRequirements');
         const didUpdateOperationPathKey = patch.operationPathKey !== undefined && patch.operationPathKey !== this._config.operationPathKey;
-        const didUpdateReadOperationPathKey = patch.readOperationPathKey !== undefined && patch.readOperationPathKey !== this._config.readOperationPathKey;
+        const didUpdateReadOperationPathKey = hasReadOperationPathKeyPatch && patch.readOperationPathKey !== this._config.readOperationPathKey;
         const didUpdateTransportAdapter = patch.transportAdapter !== undefined && patch.transportAdapter !== this._config.transportAdapter;
         const didUpdateConflictPolicy = patch.conflictPolicy !== undefined
             && patch.conflictPolicy.strategy !== this._config.conflictPolicy.strategy;
@@ -217,11 +254,11 @@ export class ResourceMutationManager {
                 ? { contextResourceIdentifiers: { ...patch.contextResourceIdentifiers } }
                 : {}),
             contextualParameters: { ...patch.contextualParameters },
-            ...(patch.parentResourcesRequirements !== undefined
+            ...(hasParentResourcesRequirementsPatch
                 ? { parentResourcesRequirements: patch.parentResourcesRequirements }
                 : {}),
             ...(patch.operationPathKey !== undefined ? { operationPathKey: patch.operationPathKey } : {}),
-            ...(patch.readOperationPathKey !== undefined ? { readOperationPathKey: patch.readOperationPathKey } : {}),
+            ...(hasReadOperationPathKeyPatch ? { readOperationPathKey: patch.readOperationPathKey } : {}),
             ...(patch.conflictPolicy !== undefined ? { conflictPolicy: patch.conflictPolicy } : {}),
             ...(patch.resourceSchema !== undefined ? { resourceSchema: patch.resourceSchema } : {}),
         };
@@ -423,12 +460,55 @@ export class ResourceMutationManager {
     // PUBLIC API — Remote Events
     // =============================================================================
     /**
-     * Apply a remote update from another user (typically via WebSocket).
+     * Whether an incoming remote update is THIS tab's OWN echo (so it should be
+     * deferred/discarded rather than applied).
+     *
+     * The signal is the **server version**, not the user id. Server `_version`s
+     * are a monotonic, per-resource counter: the version produced by one tab's
+     * mutation is globally unique, so `_producedVersions` (the versions THIS
+     * manager's own confirmed mutations minted) identifies this tab's echoes
+     * exactly. A change from ANOTHER tab — even the SAME user — carries a version
+     * this tab never produced, so it is (correctly) foreign and gets applied.
      *
-     * Self-event handling: when `initiatorUserId === currentUserId` and a mutation
-     * is in-flight, the event is deferred (pushed to `_deferredSelfEvents`) and
-     * reconciled when the HTTP response arrives. Without an in-flight mutation,
-     * self-events are discarded immediately (the HTTP response already updated state).
+     * WHY NOT `initiatorUserId === currentUserId` (the previous check): that
+     * treated EVERY same-user tab as "self" and silently discarded cross-tab
+     * updates — the multi-tab-stale bug (two tabs of one user never see each
+     * other's edits; the receiver logged `self-event discarded`).
+     *
+     * Fail-open: if a produced version was never recorded (e.g. the HTTP response
+     * was lost but the echo arrived), the echo is treated as foreign and APPLIED
+     * — harmless, since it carries the authoritative value the tab would have
+     * confirmed anyway (and the bridge's field-diff skips it when it's a no-op).
+     */
+    _isOwnEcho(version) {
+        return this._producedVersions.has(version);
+    }
+    /**
+     * Record a server version this manager's own mutation just minted, so a later
+     * WebSocket echo of that same version is recognised as this tab's own and not
+     * re-applied. Bounded (FIFO) — only recent self-versions can still be in
+     * flight over the wire; older ones are pruned.
+     */
+    _recordProducedVersion(version) {
+        if (version == null)
+            return;
+        this._producedVersions.add(version);
+        if (this._producedVersions.size > PRODUCED_VERSIONS_MAX) {
+            // Sets preserve insertion order → the first key is the oldest.
+            const oldest = this._producedVersions.values().next().value;
+            if (oldest !== undefined)
+                this._producedVersions.delete(oldest);
+        }
+    }
+    /**
+     * Apply a remote update from another client (typically via WebSocket).
+     *
+     * Self-event handling: an echo of a version THIS tab produced (see
+     * {@link _isOwnEcho}) is deferred while a mutation is in-flight (so the
+     * canonical HTTP/read-back path settles confirmed truth first) and otherwise
+     * discarded (the HTTP response already applied it). An update from ANOTHER tab
+     * — even the same user — carries a version this tab never produced, so it is
+     * foreign and applied.
      *
      * Silent merge when no pending field overlap. Falls through to conflictPolicy
      * when overlap exists.
@@ -436,12 +516,12 @@ export class ResourceMutationManager {
     applyRemoteUpdate(changedFields, version, initiatorUserId, _fieldMeta) {
         if (this._state === RMMState.DELETED)
             return;
-        if (initiatorUserId && this._config.currentUserId && initiatorUserId === this._config.currentUserId) {
+        if (this._isOwnEcho(version)) {
             if (this._activeMutation !== null) {
-                // Self-originated websocket echoes are deferred while the matching
-                // mutation is still in flight so the canonical HTTP/read-back path gets
-                // first chance to settle confirmed truth.
-                logDebug('applyRemoteUpdate: self-event deferred (mutation in-flight)', {
+                // This tab's own echo, deferred while the matching mutation is still in
+                // flight so the canonical HTTP/read-back path settles confirmed truth
+                // first.
+                logDebug('applyRemoteUpdate: own-echo deferred (mutation in-flight)', {
                     version,
                     activeMutationId: this._activeMutation.entry.id,
                 });
@@ -450,15 +530,41 @@ export class ResourceMutationManager {
             }
             if (this._allowSettledSelfEventRepair) {
                 // If the immediate authoritative read-back missed, one later settled
-                // self-event may repair confirmed truth instead of being discarded as a
-                // normal echo.
+                // own-echo may repair confirmed truth instead of being discarded.
                 this._clearAuthoritativeRecoveryTimer();
                 this._allowSettledSelfEventRepair = false;
-                logDebug('applyRemoteUpdate: accepting settled self-event after canonical read-back miss', { version });
+                logDebug('applyRemoteUpdate: accepting settled own-echo after canonical read-back miss', { version });
                 this._applyRemoteUpdateInternal(changedFields, version, initiatorUserId, _fieldMeta, true);
                 return;
             }
-            logDebug('applyRemoteUpdate: self-event discarded (no in-flight mutation)', { version });
+            logDebug('applyRemoteUpdate: own-echo discarded (no in-flight mutation)', { version });
+            return;
+        }
+        // In-flight race guard (complements the version-correlated self-check above).
+        // While a mutation is in flight the version WE are about to produce is not
+        // yet known — `_isOwnEcho` cannot recognise this tab's own echo until the
+        // HTTP response records the produced version. An echo from the CURRENT user
+        // arriving in that window is EITHER (a) this tab's own echo racing ahead of
+        // its HTTP response, OR (b) a concurrent commit from ANOTHER tab of the same
+        // user. Defer either way; once our mutation settles,
+        // `_processDeferredSelfEvents(producedVersion)` discards the deferred event
+        // whose version matches ours (own echo) and applies the rest as remote
+        // changes — so the same-user-other-tab case (b) still lands (the multi-tab
+        // fix), just after our own mutation settles.
+        //
+        // Without this, an own echo that beats the HTTP response is treated as a
+        // foreign change and spuriously CONFLICTS with the in-flight pending fields,
+        // cancelling a mutation that actually succeeded. User-id here is only a
+        // "defer for now" heuristic — version correlation still makes the final
+        // discard-vs-apply decision, so it never mis-discards another tab's change.
+        if (this._activeMutation !== null
+            && initiatorUserId !== undefined
+            && initiatorUserId === this._config.currentUserId) {
+            logDebug('applyRemoteUpdate: same-user echo deferred (mutation in-flight, version not yet known)', {
+                version,
+                activeMutationId: this._activeMutation.entry.id,
+            });
+            this._deferredSelfEvents.push({ changedFields, version, initiatorUserId, fieldMeta: _fieldMeta });
             return;
         }
         this._applyRemoteUpdateInternal(changedFields, version, initiatorUserId, _fieldMeta);
@@ -518,8 +624,11 @@ export class ResourceMutationManager {
      * Flush pending fields, wait for in-flight to complete, then clean up.
      * Called by the registry when refCount reaches zero after DESTROY_DELAY_MS.
      *
-     * Bounded flush loop: retry-exhausted fields may be returned to _pendingFields
-     * after the first flush completes, so we re-check up to 3 times.
+     * Bounded flush loop: fields folded back into _pendingFields by mid-ladder
+     * paths (a VALIDATION failure, a superseded retry) may reappear after the
+     * first flush completes, so we re-check up to 3 times. A retry-EXHAUSTED
+     * flush no longer re-queues — terminal failure reverts to confirmed state —
+     * so exhaustion simply exits this loop with nothing pending.
      */
     async destroy() {
         logDebug('destroy: starting', {
@@ -574,7 +683,38 @@ export class ResourceMutationManager {
                 if (this._state === RMMState.IDLE) {
                     this._state = RMMState.QUEUED;
                 }
-                else if (this._state === RMMState.ERROR && !this._retryTimer) {
+                else if (this._state === RMMState.ERROR) {
+                    // A fresh mutation supersedes one that is failing/erroring. The
+                    // original `!_retryTimer` arm already resumed the queue once retries
+                    // were exhausted (or a retry was mid-flight, timer already null);
+                    // this branch additionally BREAKS a still-pending retry so the newest
+                    // user edit is not held hostage by the retry ladder.
+                    //
+                    // Without this, an edit queued while the active mutation is WAITING to
+                    // retry a transient/server error (e.g. a backend blip or a dev
+                    // restart-window 503 that the browser surfaces as a CORS-less network
+                    // error) fires no request at all — `_processQueue` early-returns while
+                    // state is ERROR — until the ladder exhausts (several seconds). To the
+                    // user that reads as "the second edit silently did nothing".
+                    //
+                    // Fold the superseded mutation's in-flight fields back into the
+                    // pending batch (newest edit wins on overlap — the `!has` guard — so
+                    // nothing is lost), cancel the pending retry, and reject its promise
+                    // as cancelled so its autosave quietly returns to idle while THIS
+                    // fresh mutation reports the real save state. Mirrors the field
+                    // preservation already done on the retry-exhausted path.
+                    if (this._retryTimer && this._activeMutation) {
+                        this._clearTimers();
+                        const superseded = this._activeMutation;
+                        for (const [field, value] of Object.entries(superseded.savingFields)) {
+                            if (!this._pendingFields.has(field)) {
+                                this._pendingFields.set(field, value);
+                            }
+                        }
+                        superseded.abortController.abort();
+                        this._activeMutation = null;
+                        superseded.entry.reject(new MutationCancelledError(superseded.entry.source));
+                    }
                     this._state = RMMState.QUEUED;
                 }
                 this._invalidateSnapshot();
@@ -594,6 +734,7 @@ export class ResourceMutationManager {
                 if (event.result.data) {
                     this._mergeResponseDataIntoConfirmed(event.result.data);
                 }
+                this._applyConfirmedClears(event.clearedFields, event.result.data);
                 if (event.result.newVersion !== undefined) {
                     this._version = event.result.newVersion;
                 }
@@ -730,15 +871,41 @@ export class ResourceMutationManager {
                     }, delay);
                     break;
                 }
-                // --- Retry exhausted ---
+                // --- Retry exhausted — TERMINAL failure: revert + surface (audit B1) ---
+                //
+                // The ladder is spent and the write is NOT persisted. The previous
+                // behaviour re-queued the failed values into `_pendingFields`, which
+                // kept `optimisticData` rendering them as "saved" forever while the
+                // transport's `silent: true` suppressed every toast — a silent write
+                // loss (checklist edits surviving on screen and vanishing on reload).
+                //
+                // Terminal contract, mirroring CONFLICT_DETECTED's reset shape:
+                // 1. REVERT — drop the failed values (and anything queued behind them
+                //    on the same dead backend) so `optimisticData` falls back to
+                //    `confirmedData` and the UI stops claiming the save happened.
+                // 2. EVENT — emit a MUTATION_RESULT failure (`retriesRemaining: 0`) so
+                //    subscribers (forms/displayers) observe the terminal failure and
+                //    drop their own optimistic UI.
+                // 3. NOTIFY — emit a user-visible resource error notification; the
+                //    transport's `silent: true` only suppresses the per-attempt global
+                //    toasts, so without this the terminal failure had NO user signal.
+                //
+                // Rejected alternative — keep re-queueing and let a later mutation
+                // retry: with the backend down every later attempt exhausts the same
+                // way, so the "eventual save" never comes and the lie compounds.
+                // CONFLICT semantics are untouched (handled above).
                 this._clearTimers();
-                if (this._activeMutation) {
-                    for (const field of event.savedFields) {
-                        if (!this._pendingFields.has(field)) {
-                            this._pendingFields.set(field, this._activeMutation.savingFields[field]);
-                        }
-                    }
+                const terminalDiscardedFields = [...new Set([
+                        ...event.savedFields,
+                        ...this._pendingFields.keys(),
+                    ])];
+                for (const entry of this._queue) {
+                    entry.reject(new MutationCancelledError());
                 }
+                this._queue = [];
+                this._pendingFields.clear();
+                this._pendingFieldTimestamps.clear();
+                this._deferredSelfEvents = [];
                 this._lastEvent = {
                     type: RMMEventType.MUTATION_RESULT,
                     result: {
@@ -750,8 +917,8 @@ export class ResourceMutationManager {
                     source: event.source,
                     id: ++this._eventCounter,
                 };
-                this._state =
-                    this._queue.length > 0 || this._pendingFields.size > 0 ? RMMState.QUEUED : RMMState.IDLE;
+                this._state = RMMState.IDLE;
+                this._emitTerminalMutationFailureNotification(mutationError, terminalDiscardedFields);
                 break;
             }
             case TransitionEventType.RETRY:
@@ -845,6 +1012,61 @@ export class ResourceMutationManager {
         }
         this._invalidateSnapshot();
     }
+    /**
+     * Emit the user-visible notification for a TERMINAL mutation failure
+     * (transient/server retry ladder exhausted).
+     *
+     * Why HERE and not in a React subscriber: the retry ladder can outlive the
+     * surface that queued the mutation (registry-held instance, destroy-delayed),
+     * and the notification invariant is "every exhausted ladder surfaces exactly
+     * one user-visible error". Emitting from the single exhaustion site makes
+     * that unbypassable for every creation path (hooks, registry, tests) instead
+     * of hoping each consumer wires a handler. The transport's `silent: true`
+     * suppresses only the per-attempt global error toasts; this is the one
+     * deliberate terminal signal.
+     *
+     * Emission is best-effort and must never throw into the state machine.
+     */
+    _emitTerminalMutationFailureNotification(error, discardedFields) {
+        const operationPathKey = this._config.operationPathKey ?? this.resourceType;
+        let operationPath = {};
+        try {
+            operationPath = ResourcesConfig_OperationPathUtils.parseOperationPathKey(operationPathKey);
+        }
+        catch {
+            // A bare resourceType fallback key is not a parseable operation path —
+            // notify with UPDATE-shaped defaults rather than dropping the signal.
+        }
+        try {
+            frontendEventBus.emit(FrontendEvents.NOTIFY_RESOURCE_ERROR, {
+                resourceType: this.resourceType,
+                parentResourcesRequirements: [],
+                operationIdentifier: String(operationPath.operationIdentifier ?? CoreResourceOperation.UPDATE),
+                isOperationDefault: operationPath.isOperationDefault ?? true,
+                isBulkOperation: operationPath.isBulkOperation ?? false,
+                variantKey: operationPath.variantKey,
+                operation: undefined,
+                contextResourceIdentifiers: this._config.contextResourceIdentifiers ?? {},
+                additionalContext: {
+                    error: error.message ?? 'Saving failed after retries',
+                    // TRANSIENT terminal failures are network-level (connection refused,
+                    // readiness gate gave up): route the toast copy through the
+                    // localized NETWORK error label. SERVER failures fall through to
+                    // the notification layer's default error message.
+                    errorCustomMessageReference: error.type === MutationErrorType.TRANSIENT ? ErrorCustomMessageReference.NETWORK : undefined,
+                    errorHttpStatus: error.status,
+                    mutationErrorType: error.type,
+                    discardedFields,
+                },
+            });
+        }
+        catch (emitError) {
+            logDebug('_emitTerminalMutationFailureNotification: emit failed', {
+                resourceId: this._resourceId,
+                error: emitError instanceof Error ? emitError.message : String(emitError),
+            });
+        }
+    }
     // =============================================================================
     // INTERNAL — Queue Processing
     // =============================================================================
@@ -964,8 +1186,18 @@ export class ResourceMutationManager {
                 for (const field of savedFields) {
                     this._pendingFieldTimestamps.delete(field);
                 }
-                this._transition({ type: TransitionEventType.SAVE_SUCCESS, result, savedFields, source });
+                // The fields this mutation explicitly CLEARED. Carried through to confirmed state because
+                // the canonical read-back expresses a clear by OMITTING the key, which a merge cannot act
+                // on — see `_applyConfirmedClears`.
+                const clearedFields = Object.entries(thisMutation.savingFields)
+                    .filter(([, fieldValue]) => fieldValue === null)
+                    .map(([fieldName]) => fieldName);
+                this._transition({ type: TransitionEventType.SAVE_SUCCESS, result, savedFields, clearedFields, source });
                 this._activeMutation = null;
+                // Remember the version THIS tab's mutation just minted, so its own
+                // WebSocket echo is recognised (and skipped) while another tab's
+                // change — carrying a version this tab never produced — is applied.
+                this._recordProducedVersion(result.newVersion);
                 this._processDeferredSelfEvents(result.newVersion);
                 this._invalidateSnapshot();
                 thisMutation.entry.resolve({
@@ -1126,6 +1358,38 @@ export class ResourceMutationManager {
      * entry so dotted keys and nested shapes match optimistic/remote merge semantics
      * (avoids shallow spread clobbering nested objects).
      */
+    /**
+     * Remove fields the caller CLEARED from confirmed state, which a merge structurally cannot do.
+     *
+     * `_mergeResponseDataIntoConfirmed` walks the response's own entries, so it can only ever ADD or
+     * OVERWRITE. A cleared field is absent from the canonical read-back — that absence IS the server
+     * telling us the field is gone — and an absent key overwrites nothing, so the stale value
+     * survived in confirmed state and kept rendering until a full page reload. Live-observed on the
+     * surface this contract was built for: the colour disappeared from storage and stayed on screen.
+     *
+     * Authority still rests with the server: a field is dropped only when the caller explicitly sent
+     * `null` for it AND the response did not come back carrying a value. If the server echoes
+     * something (a default, a computed value, a rejection of the clear), that echo wins.
+     *
+     * DOTTED paths are handled, not just top-level names. That is not theoretical tidiness: autosave
+     * calls `triggerSave` with the field's RESOLVED name, which for a composite child is its absolute
+     * dotted path (`address.city`), and that string is queued verbatim as the mutation key. A
+     * top-level `delete next['address.city']` matched no key at all, so a cleared composite child was
+     * silently exempt from the very correction this method exists to make.
+     */
+    _applyConfirmedClears(clearedFields, responseData) {
+        if (!clearedFields?.length || !this._confirmedData)
+            return;
+        const next = structuredClone(this._confirmedData);
+        for (const fieldName of clearedFields) {
+            if (responseData && deepReadByPath(responseData, fieldName) !== undefined)
+                continue;
+            // `deepSetByPath` with `undefined` DELETES, and it normalises bracket notation first, so this
+            // reaches a nested member as well as a top-level field.
+            deepSetByPath(next, fieldName, undefined);
+        }
+        this._confirmedData = next;
+    }
     _mergeResponseDataIntoConfirmed(data) {
         const base = this._confirmedData !== null ? structuredClone(this._confirmedData) : {};
         for (const [path, value] of Object.entries(data)) {
@@ -1574,4 +1838,4 @@ export class ResourceMutationManager {
         this._onDrainCallbacks = [];
     }
 }
-//# sourceMappingURL=ResourceMutationManager.js.map
+//# sourceMappingURL=ResourceMutationManager.js.map