reactronic 0.94.25037 → 0.95.25040

package/build/dist/source/core/Changeset.js

@@ -125,7 +125,7 @@ export class Changeset {
     }
     isNewObjectVersionRequired(h, ov, fk, existing, value, token) {
         if (this.sealed && ov.changeset !== EMPTY_OBJECT_VERSION.changeset)
-            throw misuse(`observable property ${Dump.obj(h, fk)} can only be modified inside transaction`);
+            throw misuse(`signal property ${Dump.obj(h, fk)} can only be modified inside transaction`);
         if (fk !== Meta.Handle) {
             if (value !== Meta.Handle) {
                 if (ov.changeset !== this || ov.former.objectVersion !== EMPTY_OBJECT_VERSION) {

package/build/dist/source/core/Data.d.ts

@@ -14,7 +14,7 @@ export declare class ContentFootprint<T = any> {
 }
 export type OperationFootprint = {
     readonly order: number;
-    readonly observables: Map<ContentFootprint, Subscription> | undefined;
+    readonly signals: Map<ContentFootprint, Subscription> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
     markObsoleteDueTo(footprint: ContentFootprint, fk: FieldKey, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, collector: Array<OperationFootprint>): void;

package/build/dist/source/core/Indicator.d.ts

@@ -1,6 +1,6 @@
 import { Worker } from "../Worker.js";
-import { ObservableObject } from "./Mvcc.js";
-export declare abstract class Indicator extends ObservableObject {
+import { SxObject } from "./Mvcc.js";
+export declare abstract class Indicator extends SxObject {
     abstract readonly isBusy: boolean;
     abstract readonly counter: number;
     abstract readonly workers: ReadonlySet<Worker>;

package/build/dist/source/core/Indicator.js

@@ -8,9 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Isolation } from "../Enums.js";
-import { ObservableObject, Mvcc } from "./Mvcc.js";
+import { SxObject, Mvcc } from "./Mvcc.js";
 import { Transaction } from "./Transaction.js";
-export class Indicator extends ObservableObject {
+export class Indicator extends SxObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
         return IndicatorImpl.createImpl(hint, activationDelay, deactivationDelay, durationResolution);
     }

package/build/dist/source/core/Journal.d.ts

@@ -1,7 +1,7 @@
-import { ObservableObject } from "./Mvcc.js";
+import { SxObject } from "./Mvcc.js";
 import { ObjectHandle, ObjectVersion, PatchSet } from "./Data.js";
 export type Saver = (patch: PatchSet) => Promise<void>;
-export declare abstract class Journal extends ObservableObject {
+export declare abstract class Journal extends SxObject {
     abstract capacity: number;
     abstract readonly edits: ReadonlyArray<PatchSet>;
     abstract readonly unsaved: PatchSet;

package/build/dist/source/core/Journal.js

@@ -1,11 +1,11 @@
 import { misuse } from "../util/Dbg.js";
 import { Isolation } from "../Enums.js";
-import { ObservableObject } from "./Mvcc.js";
+import { SxObject } from "./Mvcc.js";
 import { Meta, ContentFootprint } from "./Data.js";
 import { Changeset, EMPTY_OBJECT_VERSION } from "./Changeset.js";
 import { Transaction } from "./Transaction.js";
 import { Sealant } from "../util/Sealant.js";
-export class Journal extends ObservableObject {
+export class Journal extends SxObject {
     static create() { return new JournalImpl(); }
 }
 export class JournalImpl extends Journal {

package/build/dist/source/core/Mvcc.d.ts

@@ -6,13 +6,13 @@ import { FieldKey, ObjectHandle } from "./Data.js";
 import { Journal } from "./Journal.js";
 import { Indicator } from "./Indicator.js";
 export declare abstract class MvccObject {
-    protected constructor(isObservable: boolean);
+    protected constructor(isSignal: boolean);
     [Symbol.toStringTag](): string;
 }
-export declare abstract class AtomicObject extends MvccObject {
+export declare abstract class TxObject extends MvccObject {
     constructor();
 }
-export declare abstract class ObservableObject extends MvccObject {
+export declare abstract class SxObject extends MvccObject {
     constructor();
 }
 export declare class OptionsImpl implements ReactivityOptions {
@@ -22,7 +22,7 @@ export declare class OptionsImpl implements ReactivityOptions {
     readonly isolation: Isolation;
     readonly order: number;
     readonly noSideEffects: boolean;
-    readonly observableArgs: boolean;
+    readonly signalArgs: boolean;
     readonly throttling: number;
     readonly reentrance: Reentrance;
     readonly allowObsoleteToFinish: boolean;
@@ -38,10 +38,10 @@ export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     static mainThreadBlockingWarningThreshold: number;
     static asyncActionDurationWarningThreshold: number;
     static sensitivity: boolean;
-    static readonly atomic: Mvcc;
-    static readonly observable: Mvcc;
-    readonly isObservable: boolean;
-    constructor(isObservable: boolean);
+    static readonly tx: Mvcc;
+    static readonly sx: Mvcc;
+    readonly isSignal: boolean;
+    constructor(isSignal: boolean);
     getPrototypeOf(h: ObjectHandle): object | null;
     get(h: ObjectHandle, fk: FieldKey, receiver: any): any;
     set(h: ObjectHandle, fk: FieldKey, value: any, receiver: any): boolean;
@@ -49,11 +49,11 @@ export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     defineProperty?(h: ObjectHandle, name: string | symbol, attributes: PropertyDescriptor): boolean;
     getOwnPropertyDescriptor(h: ObjectHandle, fk: FieldKey): PropertyDescriptor | undefined;
     ownKeys(h: ObjectHandle): Array<string | symbol>;
-    static decorateData(isObservable: boolean, proto: any, fk: FieldKey): any;
+    static decorateData(isSignal: boolean, proto: any, fk: FieldKey): any;
     static decorateOperation(implicit: boolean, decorator: Function, options: Partial<ReactivityOptions>, proto: any, member: FieldKey, pd: PropertyDescriptor | undefined): any;
     static decorateOperationParametrized(decorator: Function, options: Partial<ReactivityOptions>): F<any>;
     static acquireHandle(obj: any): ObjectHandle;
-    static createHandleForMvccObject(proto: any, data: any, blank: any, hint: string, isObservable: boolean): ObjectHandle;
+    static createHandleForMvccObject(proto: any, data: any, blank: any, hint: string, isSignal: boolean): ObjectHandle;
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
     static sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
     static setHint<T>(obj: T, hint: string | undefined): T;

package/build/dist/source/core/Mvcc.js

@@ -4,10 +4,10 @@ import { Kind, Reentrance, Isolation } from "../Enums.js";
 import { ObjectVersion, ObjectHandle, ContentFootprint, Meta } from "./Data.js";
 import { Changeset, Dump, EMPTY_OBJECT_VERSION } from "./Changeset.js";
 export class MvccObject {
-    constructor(isObservable) {
+    constructor(isSignal) {
         const proto = new.target.prototype;
         const initial = Meta.getFrom(proto, Meta.Initial);
-        const h = Mvcc.createHandleForMvccObject(proto, this, initial, new.target.name, isObservable);
+        const h = Mvcc.createHandleForMvccObject(proto, this, initial, new.target.name, isSignal);
         return h.proxy;
     }
     [Symbol.toStringTag]() {
@@ -15,12 +15,12 @@ export class MvccObject {
         return Dump.obj(h);
     }
 }
-export class AtomicObject extends MvccObject {
+export class TxObject extends MvccObject {
     constructor() {
         super(false);
     }
 }
-export class ObservableObject extends MvccObject {
+export class SxObject extends MvccObject {
     constructor() {
         super(true);
     }
@@ -30,7 +30,7 @@ const DEFAULT_OPTIONS = Object.freeze({
     isolation: Isolation.joinToCurrentTransaction,
     order: 0,
     noSideEffects: false,
-    observableArgs: false,
+    signalArgs: false,
     throttling: Number.MAX_SAFE_INTEGER,
     reentrance: Reentrance.preventWithError,
     allowObsoleteToFinish: false,
@@ -46,7 +46,7 @@ export class OptionsImpl {
         this.isolation = merge(DEFAULT_OPTIONS.isolation, existing.isolation, patch.isolation, implicit);
         this.order = merge(DEFAULT_OPTIONS.order, existing.order, patch.order, implicit);
         this.noSideEffects = merge(DEFAULT_OPTIONS.noSideEffects, existing.noSideEffects, patch.noSideEffects, implicit);
-        this.observableArgs = merge(DEFAULT_OPTIONS.observableArgs, existing.observableArgs, patch.observableArgs, implicit);
+        this.signalArgs = merge(DEFAULT_OPTIONS.signalArgs, existing.signalArgs, patch.signalArgs, implicit);
         this.throttling = merge(DEFAULT_OPTIONS.throttling, existing.throttling, patch.throttling, implicit);
         this.reentrance = merge(DEFAULT_OPTIONS.reentrance, existing.reentrance, patch.reentrance, implicit);
         this.allowObsoleteToFinish = merge(DEFAULT_OPTIONS.allowObsoleteToFinish, existing.allowObsoleteToFinish, patch.allowObsoleteToFinish, implicit);
@@ -62,8 +62,8 @@ function merge(def, existing, patch, implicit) {
     return patch !== undefined && (existing === def || !implicit) ? patch : existing;
 }
 export class Mvcc {
-    constructor(isObservable) {
-        this.isObservable = isObservable;
+    constructor(isSignal) {
+        this.isSignal = isSignal;
     }
     getPrototypeOf(h) {
         return Reflect.getPrototypeOf(h.data);
@@ -75,7 +75,7 @@ export class Mvcc {
             const ov = cs.getObjectVersion(h, fk);
             result = ov.data[fk];
             if (result instanceof ContentFootprint && !result.isComputed) {
-                if (this.isObservable)
+                if (this.isSignal)
                     Changeset.markUsed(result, ov, fk, h, Kind.plain, false);
                 result = result.content;
             }
@@ -122,16 +122,16 @@ export class Mvcc {
         }
         return result;
     }
-    static decorateData(isObservable, proto, fk) {
-        if (isObservable) {
+    static decorateData(isSignal, proto, fk) {
+        if (isSignal) {
             Meta.acquire(proto, Meta.Initial)[fk] = new ContentFootprint(undefined, 0);
             const get = function () {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.observable.get(h, fk, this);
+                return Mvcc.sx.get(h, fk, this);
             };
             const set = function (value) {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.observable.set(h, fk, value, this);
+                return Mvcc.sx.set(h, fk, value, this);
             };
             const enumerable = true;
             const configurable = false;
@@ -177,19 +177,19 @@ export class Mvcc {
         let h = obj[Meta.Handle];
         if (!h) {
             if (obj !== Object(obj) || Array.isArray(obj))
-                throw misuse("only objects can be observable");
+                throw misuse("only objects can be signalling");
             const initial = Meta.getFrom(Object.getPrototypeOf(obj), Meta.Initial);
             const ov = new ObjectVersion(EMPTY_OBJECT_VERSION.changeset, EMPTY_OBJECT_VERSION, Object.assign({}, initial));
-            h = new ObjectHandle(obj, obj, Mvcc.observable, ov, obj.constructor.name);
+            h = new ObjectHandle(obj, obj, Mvcc.sx, ov, obj.constructor.name);
             Meta.set(ov.data, Meta.Handle, h);
             Meta.set(obj, Meta.Handle, h);
             Meta.set(ov.data, Meta.Revision, new ContentFootprint(1, 0));
         }
         return h;
     }
-    static createHandleForMvccObject(proto, data, blank, hint, isObservable) {
+    static createHandleForMvccObject(proto, data, blank, hint, isSignal) {
         const ctx = Changeset.edit();
-        const mvcc = isObservable ? Mvcc.observable : Mvcc.atomic;
+        const mvcc = isSignal ? Mvcc.sx : Mvcc.tx;
         const h = new ObjectHandle(data, undefined, mvcc, EMPTY_OBJECT_VERSION, hint);
         ctx.getEditableObjectVersion(h, Meta.Handle, blank);
         if (!Mvcc.reactivityAutoStartDisabled)
@@ -238,8 +238,8 @@ Mvcc.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.sensitivity = false;
-Mvcc.atomic = new Mvcc(false);
-Mvcc.observable = new Mvcc(true);
+Mvcc.tx = new Mvcc(false);
+Mvcc.sx = new Mvcc(true);
 Mvcc.createOperationDescriptor = function (h, fk, options) {
     throw misuse("this implementation of createOperationDescriptor should never be called");
 };

package/build/dist/source/core/MvccArray.d.ts

@@ -1,7 +1,7 @@
 import { MvccObject } from "./Mvcc.js";
 export declare class MvccArray<T> extends MvccObject {
     private impl;
-    constructor(isObservable: boolean, array: Array<T>);
+    constructor(isSignalling: boolean, array: Array<T>);
     get length(): number;
     set length(n: number);
     getItem(n: number): T;
@@ -47,13 +47,13 @@ export declare class MvccArray<T> extends MvccObject {
     values(): IterableIterator<T>;
     private get mutable();
 }
-export declare class AtomicArray<T> extends MvccArray<T> {
+export declare class TxArray<T> extends MvccArray<T> {
     constructor();
     constructor(arrayLength: number);
     constructor(arrayLength?: number);
     constructor(...items: T[]);
 }
-export declare class ObservableArray<T> extends MvccArray<T> {
+export declare class SxArray<T> extends MvccArray<T> {
     constructor();
     constructor(arrayLength: number);
     constructor(arrayLength?: number);

package/build/dist/source/core/MvccArray.js

@@ -1,8 +1,8 @@
 import { Sealant } from "../util/Sealant.js";
 import { MvccObject } from "./Mvcc.js";
 export class MvccArray extends MvccObject {
-    constructor(isObservable, array) {
-        super(isObservable);
+    constructor(isSignalling, array) {
+        super(isSignalling);
         this.impl = array;
     }
     get length() { return this.impl.length; }
@@ -46,12 +46,12 @@ export class MvccArray extends MvccObject {
         return this.impl;
     }
 }
-export class AtomicArray extends MvccArray {
+export class TxArray extends MvccArray {
     constructor(...args) {
         super(false, new Array(...args));
     }
 }
-export class ObservableArray extends MvccArray {
+export class SxArray extends MvccArray {
     constructor(...args) {
         super(true, new Array(...args));
     }

package/build/dist/source/core/MvccMap.d.ts

@@ -1,7 +1,7 @@
 import { MvccObject } from "./Mvcc.js";
 export declare class MvccMap<K, V> extends MvccObject {
     private impl;
-    constructor(isObservable: boolean, map: Map<K, V>);
+    constructor(isSignalling: boolean, map: Map<K, V>);
     clear(): void;
     delete(key: K): boolean;
     forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
@@ -15,11 +15,11 @@ export declare class MvccMap<K, V> extends MvccObject {
     [Symbol.toStringTag](): string;
     private get mutable();
 }
-export declare class AtomicMap<K, V> extends MvccMap<K, V> {
+export declare class TxMap<K, V> extends MvccMap<K, V> {
     constructor();
     constructor(iterable?: Iterable<readonly [K, V]> | null);
 }
-export declare class ObservableMap<K, V> extends MvccMap<K, V> {
+export declare class SxMap<K, V> extends MvccMap<K, V> {
     constructor();
     constructor(iterable?: Iterable<readonly [K, V]> | null);
 }

package/build/dist/source/core/MvccMap.js

@@ -1,8 +1,8 @@
 import { Sealant } from "../util/Sealant.js";
 import { MvccObject } from "./Mvcc.js";
 export class MvccMap extends MvccObject {
-    constructor(isObservable, map) {
-        super(isObservable);
+    constructor(isSignalling, map) {
+        super(isSignalling);
         this.impl = map;
     }
     clear() { this.mutable.clear(); }
@@ -23,12 +23,12 @@ export class MvccMap extends MvccObject {
         return this.impl;
     }
 }
-export class AtomicMap extends MvccMap {
+export class TxMap extends MvccMap {
     constructor(args) {
         super(false, args !== undefined ? new Map(args) : new Map());
     }
 }
-export class ObservableMap extends MvccMap {
+export class SxMap extends MvccMap {
     constructor(args) {
         super(true, args !== undefined ? new Map(args) : new Map());
     }

package/build/dist/source/core/MvccReconciliationList.d.ts

@@ -1,6 +1,6 @@
 import { ReconciliationList, LinkedItem, ReconciliationListReader } from "../util/ReconciliationList.js";
-import { ObservableObject } from "./Mvcc.js";
-export declare abstract class ObservableReconciliationList<T> extends ObservableObject implements ReconciliationListReader<T> {
+import { SxObject } from "./Mvcc.js";
+export declare abstract class SxReconciliationList<T> extends SxObject implements ReconciliationListReader<T> {
     protected abstract impl: ReconciliationList<T>;
     get isStrict(): boolean;
     get count(): number;
@@ -8,20 +8,21 @@ export declare abstract class ObservableReconciliationList<T> extends Observable
     get countOfRemoved(): number;
     get isReconciliationInProgress(): boolean;
     lookup(key: string): LinkedItem<T> | undefined;
-    tryMergeAsExisting(key: string): LinkedItem<T> | undefined;
-    mergeAsAdded(instance: T): LinkedItem<T>;
-    mergeAsRemoved(item: LinkedItem<T>): void;
+    tryReuse(key: string): LinkedItem<T> | undefined;
+    add(instance: T): LinkedItem<T>;
+    remove(item: LinkedItem<T>): void;
     move(item: LinkedItem<T>, after: LinkedItem<T>): void;
-    beginMerge(): void;
-    endMerge(error?: unknown): void;
-    resetAddedAndRemovedLists(): void;
+    beginReconciliation(): void;
+    endReconciliation(error?: unknown): void;
+    clearAddedAndRemovedLists(): void;
     firstItem(): LinkedItem<T> | undefined;
     lastItem(): LinkedItem<T> | undefined;
     items(): Generator<LinkedItem<T>>;
-    itemsAdded(reset?: boolean): Generator<LinkedItem<T>>;
-    itemsRemoved(reset?: boolean): Generator<LinkedItem<T>>;
+    itemsAdded(clear?: boolean): Generator<LinkedItem<T>>;
+    itemsRemoved(clear?: boolean): Generator<LinkedItem<T>>;
     isAdded(item: LinkedItem<T>): boolean;
     isMoved(item: LinkedItem<T>): boolean;
     isRemoved(item: LinkedItem<T>): boolean;
-    isFresh(item: LinkedItem<T>): boolean;
+    isActual(item: LinkedItem<T>): boolean;
+    isExternal(item: LinkedItem<T>): boolean;
 }

package/build/dist/source/core/MvccReconciliationList.js

@@ -1,25 +1,26 @@
-import { ObservableObject } from "./Mvcc.js";
-export class ObservableReconciliationList extends ObservableObject {
+import { SxObject } from "./Mvcc.js";
+export class SxReconciliationList extends SxObject {
     get isStrict() { return this.impl.isStrict; }
     get count() { return this.impl.count; }
     get countOfAdded() { return this.impl.countOfAdded; }
     get countOfRemoved() { return this.impl.countOfRemoved; }
     get isReconciliationInProgress() { return this.impl.isReconciliationInProgress; }
     lookup(key) { return this.impl.lookup(key); }
-    tryMergeAsExisting(key) { return this.impl.tryReuse(key); }
-    mergeAsAdded(instance) { return this.impl.add(instance); }
-    mergeAsRemoved(item) { return this.impl.remove(item); }
+    tryReuse(key) { return this.impl.tryReuse(key); }
+    add(instance) { return this.impl.add(instance); }
+    remove(item) { return this.impl.remove(item); }
     move(item, after) { this.impl.move(item, after); }
-    beginMerge() { this.impl.beginReconciliation(); }
-    endMerge(error) { this.impl.endReconciliation(error); }
-    resetAddedAndRemovedLists() { this.impl.resetAddedAndRemovedLists(); }
+    beginReconciliation() { this.impl.beginReconciliation(); }
+    endReconciliation(error) { this.impl.endReconciliation(error); }
+    clearAddedAndRemovedLists() { this.impl.clearAddedAndRemoved(); }
     firstItem() { return this.impl.firstItem(); }
     lastItem() { return this.impl.lastItem(); }
     items() { return this.impl.items(); }
-    itemsAdded(reset) { return this.impl.itemsAdded(reset); }
-    itemsRemoved(reset) { return this.impl.itemsRemoved(reset); }
+    itemsAdded(clear) { return this.impl.itemsAdded(clear); }
+    itemsRemoved(clear) { return this.impl.itemsRemoved(clear); }
     isAdded(item) { return this.impl.isAdded(item); }
     isMoved(item) { return this.impl.isMoved(item); }
     isRemoved(item) { return this.impl.isRemoved(item); }
-    isFresh(item) { return this.impl.isFresh(item); }
+    isActual(item) { return this.impl.isActual(item); }
+    isExternal(item) { return this.impl.isExternal(item); }
 }

package/build/dist/source/core/Operation.d.ts

@@ -1,9 +1,9 @@
 import { F } from "../util/Utils.js";
-import { ReactiveOperation, ReactivityOptions } from "../Options.js";
+import { Reaction, ReactivityOptions } from "../Options.js";
 import { FieldKey, ObjectHandle, ContentFootprint, OperationFootprint, Subscription, AbstractChangeset } from "./Data.js";
 import { Transaction } from "./Transaction.js";
 import { OptionsImpl } from "./Mvcc.js";
-export declare class ReactiveOperationImpl implements ReactiveOperation<any> {
+export declare class ReactionImpl implements Reaction<any> {
     readonly ownerHandle: ObjectHandle;
     readonly fieldKey: FieldKey;
     configure(options: Partial<ReactivityOptions>): ReactivityOptions;
@@ -18,8 +18,8 @@ export declare class ReactiveOperationImpl implements ReactiveOperation<any> {
     pullLastResult(args?: any[]): any;
     constructor(h: ObjectHandle, fk: FieldKey);
     reuseOrRelaunch(weak: boolean, args: any[] | undefined): OperationFootprintImpl;
-    static manageReactiveOperation(method: F<any>): ReactiveOperation<any>;
-    static configureImpl(self: ReactiveOperationImpl | undefined, options: Partial<ReactivityOptions>): ReactivityOptions;
+    static manageReaction(method: F<any>): Reaction<any>;
+    static configureImpl(self: ReactionImpl | undefined, options: Partial<ReactivityOptions>): ReactivityOptions;
     static proceedWithinGivenLaunch<T>(footprint: OperationFootprintImpl | undefined, func: F<T>, ...args: any[]): T;
     static why(): string;
     static briefWhy(): string;
@@ -37,9 +37,9 @@ declare class OperationFootprintImpl extends ContentFootprint implements Operati
     static deferredReactions: Array<OperationFootprintImpl>;
     readonly margin: number;
     readonly transaction: Transaction;
-    readonly descriptor: ReactiveOperationImpl;
+    readonly descriptor: ReactionImpl;
     readonly changeset: AbstractChangeset;
-    observables: Map<ContentFootprint, Subscription> | undefined;
+    signals: Map<ContentFootprint, Subscription> | undefined;
     options: OptionsImpl;
     cause: string | undefined;
     args: any[];
@@ -49,7 +49,7 @@ declare class OperationFootprintImpl extends ContentFootprint implements Operati
     obsoleteDueTo: string | undefined;
     obsoleteSince: number;
     successor: OperationFootprintImpl | undefined;
-    constructor(transaction: Transaction, descriptor: ReactiveOperationImpl, changeset: AbstractChangeset, former: OperationFootprintImpl | OptionsImpl, clone: boolean);
+    constructor(transaction: Transaction, descriptor: ReactionImpl, changeset: AbstractChangeset, former: OperationFootprintImpl | OptionsImpl, clone: boolean);
     get isComputed(): boolean;
     hint(): string;
     get order(): number;
@@ -81,7 +81,7 @@ declare class OperationFootprintImpl extends ContentFootprint implements Operati
     private static enqueueReactionsToRun;
     private static migrateContentFootprint;
     private static processQueuedReactions;
-    private unsubscribeFromAllObservables;
+    private unsubscribeFromAllSignals;
     private subscribeTo;
     private static canSubscribeTo;
     private static createOperationDescriptor;