reactronic 0.24.275 → 0.24.302

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

@@ -4,22 +4,23 @@ import { Sealant } from "../util/Sealant.js";
 import { SealedArray } from "../util/SealedArray.js";
 import { SealedMap } from "../util/SealedMap.js";
 import { SealedSet } from "../util/SealedSet.js";
-import { ObjectSnapshot, ObjectHandle, ValueSnapshot, Meta } from "./Data.js";
+import { Isolation } from "../Options.js";
+import { ObjectVersion, ObjectHandle, FieldVersion, Meta } from "./Data.js";
 export const MAX_REVISION = Number.MAX_SAFE_INTEGER;
 export const UNDEFINED_REVISION = MAX_REVISION - 1;
 Object.defineProperty(ObjectHandle.prototype, "#this#", {
     configurable: false, enumerable: false,
     get() {
         const result = {};
-        const data = Changeset.current().getObjectSnapshot(this, "#this#").data;
-        for (const m in data) {
-            const v = data[m];
-            if (v instanceof ValueSnapshot)
-                result[m] = v.content;
+        const data = Changeset.current().getObjectVersion(this, "#this#").data;
+        for (const fk in data) {
+            const v = data[fk];
+            if (v instanceof FieldVersion)
+                result[fk] = v.content;
             else if (v === Meta.Raw)
-                result[m] = this.data[m];
+                result[fk] = this.data[fk];
             else
-                result[m] = v;
+                result[fk] = v;
         }
         return result;
     },
@@ -29,56 +30,83 @@ const EMPTY_MAP = Utils.freezeMap(new Map());
 export class Changeset {
     get hint() { var _a; return (_a = this.options.hint) !== null && _a !== void 0 ? _a : "noname"; }
     get timestamp() { return this.revision; }
-    constructor(options) {
+    constructor(options, parent) {
         this.id = ++Changeset.idGen;
         this.options = options !== null && options !== void 0 ? options : DefaultSnapshotOptions;
+        this.parent = parent;
         this.revision = UNDEFINED_REVISION;
         this.bumper = 100;
         this.items = new Map();
         this.obsolete = [];
         this.sealed = false;
     }
-    lookupObjectSnapshot(h, m) {
-        let os = h.editing;
-        if (os && os.changeset !== this) {
-            os = this.items.get(h);
-            if (os)
-                h.editing = os;
+    lookupObjectVersion(h, fk, editing) {
+        let ov = h.editing;
+        if (ov && ov.changeset !== this) {
+            ov = this.items.get(h);
+            if (ov)
+                h.editing = ov;
         }
-        if (!os) {
-            os = h.head;
-            while (os !== EMPTY_SNAPSHOT && os.changeset.timestamp > this.timestamp)
-                os = os.former.snapshot;
+        const parent = this.parent;
+        if (!ov) {
+            if (!parent) {
+                ov = h.applied;
+                while (ov !== EMPTY_OBJECT_VERSION && ov.changeset.timestamp > this.timestamp)
+                    ov = ov.former.objectVersion;
+            }
+            else
+                ov = parent.lookupObjectVersion(h, fk, editing);
         }
-        return os;
+        else if (!editing && parent && !ov.changes.has(fk) && ov.former.objectVersion !== EMPTY_OBJECT_VERSION)
+            ov = parent.lookupObjectVersion(h, fk, editing);
+        return ov;
     }
-    getObjectSnapshot(h, m) {
-        const r = this.lookupObjectSnapshot(h, m);
-        if (r === EMPTY_SNAPSHOT)
-            throw misuse(`${Dump.obj(h, m)} is not yet available for T${this.id}[${this.hint}] because of uncommitted ${h.editing ? `T${h.editing.changeset.id}[${h.editing.changeset.hint}]` : ""} (last committed T${h.head.changeset.id}[${h.head.changeset.hint}])`);
+    getObjectVersion(h, fk) {
+        const r = this.lookupObjectVersion(h, fk, false);
+        if (r === EMPTY_OBJECT_VERSION)
+            throw misuse(`${Dump.obj(h, fk)} is not yet available for T${this.id}[${this.hint}] because ${h.editing ? `T${h.editing.changeset.id}[${h.editing.changeset.hint}]` : ""} is not yet applied (last applied T${h.applied.changeset.id}[${h.applied.changeset.hint}])`);
         return r;
     }
-    getEditableObjectSnapshot(h, m, value, token) {
-        let os = this.lookupObjectSnapshot(h, m);
-        const existing = os.data[m];
+    getEditableObjectVersion(h, fk, value, token) {
+        let ov = this.lookupObjectVersion(h, fk, true);
+        const existing = ov.data[fk];
         if (existing !== Meta.Raw) {
-            if (this.isNewSnapshotRequired(h, os, m, existing, value, token)) {
-                this.bumpBy(os.changeset.timestamp);
-                const revision = m === Meta.Handle ? 1 : os.revision + 1;
-                const data = Object.assign({}, m === Meta.Handle ? value : os.data);
+            if (this.isNewObjectVersionRequired(h, ov, fk, existing, value, token)) {
+                this.bumpBy(ov.changeset.timestamp);
+                const revision = fk === Meta.Handle ? 1 : ov.revision + 1;
+                const data = Object.assign({}, fk === Meta.Handle ? value : ov.data);
                 Meta.set(data, Meta.Handle, h);
-                Meta.set(data, Meta.Revision, new ValueSnapshot(revision));
-                os = new ObjectSnapshot(this, os, data);
-                this.items.set(h, os);
-                h.editing = os;
+                Meta.set(data, Meta.Revision, new FieldVersion(revision, this.id));
+                ov = new ObjectVersion(this, ov, data);
+                this.items.set(h, ov);
+                h.editing = ov;
                 h.editors++;
                 if (Log.isOn && Log.opt.write)
                     Log.write("║", " ++", `${Dump.obj(h)} - new snapshot is created (revision ${revision})`);
             }
         }
         else
-            os = EMPTY_SNAPSHOT;
-        return os;
+            ov = EMPTY_OBJECT_VERSION;
+        return ov;
+    }
+    setFieldContent(h, fk, ov, content, receiver, sensitivity) {
+        let existing = ov.data[fk];
+        if (existing !== undefined || (ov.former.objectVersion.changeset === EMPTY_OBJECT_VERSION.changeset && (fk in h.data) === false)) {
+            if (existing === undefined || existing.content !== content || sensitivity) {
+                const existingContent = existing === null || existing === void 0 ? void 0 : existing.content;
+                if (ov.former.objectVersion.data[fk] === existing) {
+                    existing = ov.data[fk] = new FieldVersion(content, this.id);
+                    Changeset.markEdited(existingContent, content, true, ov, fk, h);
+                }
+                else {
+                    existing.content = content;
+                    existing.lastEditorChangesetId = this.id;
+                    Changeset.markEdited(existingContent, content, true, ov, fk, h);
+                }
+            }
+        }
+        else
+            Reflect.set(h.data, fk, content, receiver);
     }
     static takeSnapshot(obj) {
         return obj[Meta.Handle]["#this#"];
@@ -90,25 +118,23 @@ export class Changeset {
             Changeset.doDispose(ctx, h);
     }
     static doDispose(ctx, h) {
-        const os = ctx.getEditableObjectSnapshot(h, Meta.Revision, Meta.Undefined);
-        if (os !== EMPTY_SNAPSHOT)
-            os.disposed = true;
-        return os;
+        const ov = ctx.getEditableObjectVersion(h, Meta.Revision, Meta.Undefined);
+        if (ov !== EMPTY_OBJECT_VERSION)
+            ov.disposed = true;
+        return ov;
     }
-    isNewSnapshotRequired(h, os, m, existing, value, token) {
-        if (this.sealed && os.changeset !== EMPTY_SNAPSHOT.changeset)
-            throw misuse(`observable property ${Dump.obj(h, m)} can only be modified inside transaction`);
-        if (m !== Meta.Handle) {
+    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`);
+        if (fk !== Meta.Handle) {
             if (value !== Meta.Handle) {
-                if (os.changeset !== this || os.former.snapshot !== EMPTY_SNAPSHOT) {
+                if (ov.changeset !== this || ov.former.objectVersion !== EMPTY_OBJECT_VERSION) {
                     if (this.options.token !== undefined && token !== this.options.token)
-                        throw misuse(`${this.hint} should not have side effects (trying to change ${Dump.snapshot(os, m)})`);
+                        throw misuse(`${this.hint} should not have side effects (trying to change ${Dump.snapshot(ov, fk)})`);
                 }
             }
-            if (os === EMPTY_SNAPSHOT)
-                throw misuse(`${Dump.snapshot(os, m)} is not yet available for T${this.id}[${this.hint}] because of uncommitted ${h.editing ? `T${h.editing.changeset.id}[${h.editing.changeset.hint}]` : ""} (last committed T${h.head.changeset.id}[${h.head.changeset.hint}])`);
         }
-        return os.changeset !== this && !this.sealed;
+        return ov.changeset !== this && !this.sealed;
     }
     acquire(outer) {
         if (!this.sealed && this.revision === UNDEFINED_REVISION) {
@@ -128,16 +154,17 @@ export class Changeset {
     rebase() {
         let conflicts = undefined;
         if (this.items.size > 0) {
-            this.items.forEach((os, h) => {
-                if (os.former.snapshot !== h.head) {
-                    const merged = this.merge(h, os);
-                    if (os.conflicts.size > 0) {
+            this.items.forEach((ov, h) => {
+                const theirs = this.parent ? this.parent.lookupObjectVersion(h, Meta.Handle, false) : h.applied;
+                if (ov.former.objectVersion !== theirs) {
+                    const merged = this.merge(h, ov, theirs);
+                    if (ov.conflicts.size > 0) {
                         if (!conflicts)
                             conflicts = [];
-                        conflicts.push(os);
+                        conflicts.push(ov);
                     }
                     if (Log.isOn && Log.opt.transaction)
-                        Log.write("╠╝", "", `${Dump.snapshot2(h, os.changeset)} is merged with ${Dump.snapshot2(h, h.head.changeset)} among ${merged} properties with ${os.conflicts.size} conflicts.`);
+                        Log.write("╠╝", "", `${Dump.snapshot2(h, ov.changeset)} is merged with ${Dump.snapshot2(h, theirs.changeset)} among ${merged} properties with ${ov.conflicts.size} conflicts.`);
                 }
             });
             if (this.options.token === undefined) {
@@ -154,92 +181,68 @@ export class Changeset {
         }
         return conflicts;
     }
-    merge(h, ours) {
+    merge(h, ours, theirs) {
         let counter = 0;
-        const head = h.head;
-        const headDisposed = head.disposed;
+        const theirsDisposed = theirs.disposed;
         const oursDisposed = ours.disposed;
-        const merged = Object.assign({}, head.data);
-        ours.changes.forEach((o, m) => {
+        const merged = Object.assign({}, theirs.data);
+        ours.changes.forEach((o, fk) => {
             counter++;
-            merged[m] = ours.data[m];
-            if (headDisposed || oursDisposed) {
-                if (headDisposed !== oursDisposed) {
-                    if (headDisposed || this.options.separation !== "disposal") {
+            const ourFieldVersion = ours.data[fk];
+            merged[fk] = ourFieldVersion;
+            if (theirsDisposed || oursDisposed) {
+                if (theirsDisposed !== oursDisposed) {
+                    if (theirsDisposed || this.options.isolation !== Isolation.disjoinForInternalDisposal) {
                         if (Log.isOn && Log.opt.change)
-                            Log.write("║╠", "", `${Dump.snapshot2(h, ours.changeset, m)} <> ${Dump.snapshot2(h, head.changeset, m)}`, 0, " *** CONFLICT ***");
-                        ours.conflicts.set(m, head);
+                            Log.write("║╠", "", `${Dump.snapshot2(h, ours.changeset, fk)} <> ${Dump.snapshot2(h, theirs.changeset, fk)}`, 0, " *** CONFLICT ***");
+                        ours.conflicts.set(fk, theirs);
                     }
                 }
             }
             else {
-                const conflict = Changeset.isConflicting(head.data[m], ours.former.snapshot.data[m]);
+                const conflict = Changeset.isConflicting(theirs.data[fk], ours.former.objectVersion.data[fk]);
                 if (conflict)
-                    ours.conflicts.set(m, head);
+                    ours.conflicts.set(fk, theirs);
                 if (Log.isOn && Log.opt.change)
-                    Log.write("║╠", "", `${Dump.snapshot2(h, ours.changeset, m)} ${conflict ? "<>" : "=="} ${Dump.snapshot2(h, head.changeset, m)}`, 0, conflict ? " *** CONFLICT ***" : undefined);
+                    Log.write("║╠", "", `${Dump.snapshot2(h, ours.changeset, fk)} ${conflict ? "<>" : "=="} ${Dump.snapshot2(h, theirs.changeset, fk)}`, 0, conflict ? " *** CONFLICT ***" : undefined);
             }
         });
         Utils.copyAllMembers(merged, ours.data);
-        ours.former.snapshot = head;
+        ours.former.objectVersion = theirs;
         return counter;
     }
-    applyOrDiscard(error) {
+    seal() {
         this.sealed = true;
-        this.items.forEach((os, h) => {
-            Changeset.sealObjectSnapshot(h, os);
-            h.editors--;
-            if (h.editors === 0)
-                h.editing = undefined;
-            if (!error) {
-                h.head = os;
-                if (Changeset.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
-                    Changeset.totalObjectSnapshotCount++;
-                    if (os.former.snapshot === EMPTY_SNAPSHOT)
-                        Changeset.totalObjectHandleCount++;
-                }
-            }
-        });
-        if (Log.isOn) {
-            if (Log.opt.change && !error) {
-                this.items.forEach((os, h) => {
-                    const members = [];
-                    os.changes.forEach((o, m) => members.push(m.toString()));
-                    const s = members.join(", ");
-                    Log.write("║", "√", `${Dump.snapshot2(h, os.changeset)} (${s}) is ${os.former.snapshot === EMPTY_SNAPSHOT ? "constructed" : `applied over #${h.id}t${os.former.snapshot.changeset.id}s${os.former.snapshot.changeset.timestamp}`}`);
-                });
-            }
-            if (Log.opt.transaction)
-                Log.write(this.revision < UNDEFINED_REVISION ? "╚══" : "═══", `s${this.revision}`, `${this.hint} - ${error ? "CANCEL" : "APPLY"}(${this.items.size})${error ? ` - ${error}` : ""}`);
-        }
-        if (!error)
-            Changeset.propagateAllChangesThroughSubscriptions(this);
-        return this.obsolete;
     }
-    static sealObjectSnapshot(h, os) {
-        if (!os.disposed)
-            os.changes.forEach((o, m) => Changeset.sealValueSnapshot(os.data[m], m, h.proxy.constructor.name));
-        else
-            for (const m in os.former.snapshot.data)
-                os.data[m] = Meta.Undefined;
-        if (Log.isOn)
-            Changeset.freezeObjectSnapshot(os);
+    sealObjectVersion(h, ov) {
+        if (!this.parent) {
+            if (!ov.disposed)
+                ov.changes.forEach((o, fk) => Changeset.sealFieldVersion(ov.data[fk], fk, h.proxy.constructor.name));
+            else
+                for (const fk in ov.former.objectVersion.data)
+                    ov.data[fk] = Meta.Undefined;
+            if (Log.isOn)
+                Changeset.freezeObjectVersion(ov);
+        }
+        h.editors--;
+        if (h.editors === 0)
+            h.editing = undefined;
     }
-    static sealValueSnapshot(o, m, typeName) {
-        if (o instanceof ValueSnapshot) {
-            const value = o.content;
-            if (value !== undefined && value !== null) {
-                const sealedType = Object.getPrototypeOf(value)[Sealant.SealedType];
+    static sealFieldVersion(fv, fk, typeName) {
+        if (fv instanceof FieldVersion) {
+            const content = fv.content;
+            if (content !== undefined && content !== null) {
+                const sealedType = Object.getPrototypeOf(content)[Sealant.SealedType];
                 if (sealedType)
-                    o.content = Sealant.seal(value, sealedType, typeName, m);
+                    fv.content = Sealant.seal(content, sealedType, typeName, fk);
             }
         }
     }
-    static freezeObjectSnapshot(os) {
-        Object.freeze(os.data);
-        Utils.freezeSet(os.changes);
-        Utils.freezeMap(os.conflicts);
-        return os;
+    static freezeObjectVersion(ov) {
+        Object.freeze(ov.data);
+        Utils.freezeSet(ov.changes);
+        Utils.freezeMap(ov.conflicts);
+        return ov;
     }
     triggerGarbageCollection() {
         if (this.revision !== 0) {
@@ -264,16 +267,16 @@ export class Changeset {
     unlinkHistory() {
         if (Log.isOn && Log.opt.gc)
             Log.write("", "[G]", `Dismiss history below t${this.id}s${this.revision} (${this.hint})`);
-        this.items.forEach((os, h) => {
-            if (Log.isOn && Log.opt.gc && os.former.snapshot !== EMPTY_SNAPSHOT)
-                Log.write(" ", "  ", `${Dump.snapshot2(h, os.former.snapshot.changeset)} is ready for GC because overwritten by ${Dump.snapshot2(h, os.changeset)}`);
+        this.items.forEach((ov, h) => {
+            if (Log.isOn && Log.opt.gc && ov.former.objectVersion !== EMPTY_OBJECT_VERSION)
+                Log.write(" ", "  ", `${Dump.snapshot2(h, ov.former.objectVersion.changeset)} is ready for GC because overwritten by ${Dump.snapshot2(h, ov.changeset)}`);
             if (Changeset.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
-                if (os.former.snapshot !== EMPTY_SNAPSHOT)
+                if (ov.former.objectVersion !== EMPTY_OBJECT_VERSION)
                     Changeset.totalObjectSnapshotCount--;
-                if (os.disposed)
+                if (ov.disposed)
                     Changeset.totalObjectHandleCount--;
             }
-            os.former.snapshot = EMPTY_SNAPSHOT;
+            ov.former.objectVersion = EMPTY_OBJECT_VERSION;
         });
         this.items = EMPTY_MAP;
         this.obsolete = EMPTY_ARRAY;
@@ -281,11 +284,11 @@ export class Changeset {
             Object.freeze(this);
     }
     static _init() {
-        const boot = EMPTY_SNAPSHOT.changeset;
+        const boot = EMPTY_OBJECT_VERSION.changeset;
         boot.acquire(boot);
-        boot.applyOrDiscard();
+        boot.seal();
         boot.triggerGarbageCollection();
-        Changeset.freezeObjectSnapshot(EMPTY_SNAPSHOT);
+        Changeset.freezeObjectVersion(EMPTY_OBJECT_VERSION);
         Changeset.idGen = 100;
         Changeset.stampGen = 101;
         Changeset.oldest = undefined;
@@ -311,47 +314,47 @@ Changeset.propagateAllChangesThroughSubscriptions = (changeset) => { };
 Changeset.revokeAllSubscriptions = (changeset) => { };
 Changeset.enqueueReactiveFunctionsToRun = (reactive) => { };
 export class Dump {
-    static obj(h, m, stamp, snapshotId, originSnapshotId, value) {
-        const member = m !== undefined ? `.${m.toString()}` : "";
+    static obj(h, fk, stamp, changesetId, lastEditorChangesetId, value) {
+        const member = fk !== undefined ? `.${fk.toString()}` : "";
         let result;
         if (h !== undefined) {
             const v = value !== undefined && value !== Meta.Undefined ? `[=${Dump.valueHint(value)}]` : "";
             if (stamp === undefined)
                 result = `${h.hint}${member}${v} #${h.id}`;
             else
-                result = `${h.hint}${member}${v} #${h.id}t${snapshotId}s${stamp}${originSnapshotId !== undefined && originSnapshotId !== 0 ? `t${originSnapshotId}` : ""}`;
+                result = `${h.hint}${member}${v} #${h.id}t${changesetId}s${stamp}${lastEditorChangesetId !== undefined ? `e${lastEditorChangesetId}` : ""}`;
         }
         else
             result = `boot${member}`;
         return result;
     }
-    static snapshot2(h, s, m, o) {
+    static snapshot2(h, s, fk, o) {
         var _a;
-        return Dump.obj(h, m, s.timestamp, s.id, o === null || o === void 0 ? void 0 : o.originSnapshotId, (_a = o === null || o === void 0 ? void 0 : o.content) !== null && _a !== void 0 ? _a : Meta.Undefined);
+        return Dump.obj(h, fk, s.timestamp, s.id, o === null || o === void 0 ? void 0 : o.lastEditorChangesetId, (_a = o === null || o === void 0 ? void 0 : o.content) !== null && _a !== void 0 ? _a : Meta.Undefined);
     }
-    static snapshot(os, m) {
-        const h = Meta.get(os.data, Meta.Handle);
-        const value = m !== undefined ? os.data[m] : undefined;
-        return Dump.obj(h, m, os.changeset.timestamp, os.changeset.id, value === null || value === void 0 ? void 0 : value.originSnapshotId);
+    static snapshot(ov, fk) {
+        const h = Meta.get(ov.data, Meta.Handle);
+        const fv = fk !== undefined ? ov.data[fk] : undefined;
+        return Dump.obj(h, fk, ov.changeset.timestamp, ov.changeset.id, fv === null || fv === void 0 ? void 0 : fv.lastEditorChangesetId);
     }
     static conflicts(conflicts) {
         return conflicts.map(ours => {
             const items = [];
-            ours.conflicts.forEach((theirs, m) => {
-                items.push(Dump.conflictingMemberHint(m, ours, theirs));
+            ours.conflicts.forEach((theirs, fk) => {
+                items.push(Dump.conflictingMemberHint(fk, ours, theirs));
             });
             return items.join(", ");
         }).join(", ");
     }
-    static conflictingMemberHint(m, ours, theirs) {
-        return `${theirs.changeset.hint} (${Dump.snapshot(theirs, m)})`;
+    static conflictingMemberHint(fk, ours, theirs) {
+        return `${theirs.changeset.hint} (${Dump.snapshot(theirs, fk)})`;
     }
 }
 Dump.valueHint = (value) => "???";
-export const EMPTY_SNAPSHOT = new ObjectSnapshot(new Changeset({ hint: "<boot>" }), undefined, {});
+export const EMPTY_OBJECT_VERSION = new ObjectVersion(new Changeset({ hint: "<boot>" }), undefined, {});
 export const DefaultSnapshotOptions = Object.freeze({
     hint: "noname",
-    separation: false,
+    isolation: Isolation.joinToCurrentTransaction,
     journal: undefined,
     logging: undefined,
     token: undefined,

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

@@ -5,36 +5,35 @@ export type AbstractChangeset = {
     readonly timestamp: number;
     readonly sealed: boolean;
 };
-export declare class ValueSnapshot<T = any> {
+export declare class FieldVersion<T = any> {
     content: T;
     observers?: Set<Observer>;
-    get isOperation(): boolean;
-    get originSnapshotId(): number | undefined;
-    constructor(content: T);
+    lastEditorChangesetId: number;
+    get isLaunch(): boolean;
+    constructor(content: T, lastEditorChangesetId: number);
 }
-export type SeparationMode = boolean | "isolated" | "disposal";
 export type Observer = {
     readonly order: number;
-    readonly observables: Map<ValueSnapshot, Subscription> | undefined;
+    readonly observables: Map<FieldVersion, Subscription> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
-    markObsoleteDueTo(observable: ValueSnapshot, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Array<Observer>): void;
+    markObsoleteDueTo(observable: FieldVersion, fk: FieldKey, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Array<Observer>): void;
     relaunchIfNotUpToDate(now: boolean, nothrow: boolean): void;
 };
-export type MemberName = PropertyKey;
+export type FieldKey = PropertyKey;
 export type Subscription = {
     readonly memberHint: string;
     readonly usageCount: number;
 };
-export declare class ObjectSnapshot {
+export declare class ObjectVersion {
     readonly changeset: AbstractChangeset;
     readonly former: {
-        snapshot: ObjectSnapshot;
+        objectVersion: ObjectVersion;
     };
     readonly data: any;
-    readonly changes: Set<MemberName>;
-    readonly conflicts: Map<MemberName, ObjectSnapshot>;
-    constructor(changeset: AbstractChangeset, former: ObjectSnapshot | undefined, data: object);
+    readonly changes: Set<FieldKey>;
+    readonly conflicts: Map<FieldKey, ObjectVersion>;
+    constructor(changeset: AbstractChangeset, former: ObjectVersion | undefined, data: object);
     get revision(): number;
     get disposed(): boolean;
     set disposed(value: boolean);
@@ -44,17 +43,17 @@ export declare class ObjectHandle {
     readonly id: number;
     readonly data: any;
     readonly proxy: any;
-    head: ObjectSnapshot;
-    editing?: ObjectSnapshot;
+    applied: ObjectVersion;
+    editing?: ObjectVersion;
     editors: number;
     hint: string;
-    constructor(data: any, proxy: any, handler: ProxyHandler<ObjectHandle>, head: ObjectSnapshot, hint: string);
+    constructor(data: any, proxy: any, handler: ProxyHandler<ObjectHandle>, applied: ObjectVersion, hint: string);
     static getHint(obj: object, full: boolean): string | undefined;
 }
-export type PatchSet = Map<object, Map<MemberName, ValuePatch>>;
+export type PatchSet = Map<object, Map<FieldKey, ValuePatch>>;
 export type ValuePatch = {
-    memberName: MemberName;
+    fieldKey: FieldKey;
     patchKind: "update" | "add" | "remove";
-    freshValue: any;
-    formerValue: any;
+    freshContent: any;
+    formerContent: any;
 };

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

@@ -1,15 +1,14 @@
 import { Log } from "../util/Dbg.js";
 import { Meta } from "./Meta.js";
 export { Meta } from "./Meta.js";
-export class ValueSnapshot {
-    get isOperation() { return false; }
-    get originSnapshotId() { return 0; }
-    constructor(content) { this.content = content; }
+export class FieldVersion {
+    get isLaunch() { return false; }
+    constructor(content, lastEditorChangesetId) { this.content = content; this.lastEditorChangesetId = lastEditorChangesetId; }
 }
-export class ObjectSnapshot {
+export class ObjectVersion {
     constructor(changeset, former, data) {
         this.changeset = changeset;
-        this.former = { snapshot: former || this };
+        this.former = { objectVersion: former || this };
         this.data = data;
         this.changes = new Set();
         this.conflicts = new Map();
@@ -17,7 +16,8 @@ export class ObjectSnapshot {
             Object.freeze(this);
     }
     get revision() {
-        return this.data[Meta.Revision].content;
+        var _a, _b;
+        return (_b = (_a = this.data[Meta.Revision]) === null || _a === void 0 ? void 0 : _a.content) !== null && _b !== void 0 ? _b : 0;
     }
     get disposed() { return this.revision < 0; }
     set disposed(value) {
@@ -27,11 +27,11 @@ export class ObjectSnapshot {
     }
 }
 export class ObjectHandle {
-    constructor(data, proxy, handler, head, hint) {
+    constructor(data, proxy, handler, applied, hint) {
         this.id = ++ObjectHandle.generator;
         this.data = data;
         this.proxy = proxy || new Proxy(this, handler);
-        this.head = head;
+        this.applied = applied;
         this.editing = undefined;
         this.editors = 0;
         this.hint = hint;

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

@@ -16,9 +16,9 @@ export declare class IndicatorImpl extends Indicator {
     busyDuration: number;
     readonly internals: {
         whenBusy: Promise<void> | undefined;
-        resolveWhenBusy: ((value?: void | undefined) => void) | undefined;
+        resolveWhenBusy: ((value?: void) => void) | undefined;
         whenIdle: Promise<void> | undefined;
-        resolveWhenIdle: ((value?: void | undefined) => void) | undefined;
+        resolveWhenIdle: ((value?: void) => void) | undefined;
         started: number;
         activationDelay: number;
         activationTimeout: undefined;

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

@@ -7,6 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { Isolation } from "../Options.js";
 import { ObservableObject, Mvcc } from "./Mvcc.js";
 import { Transaction } from "./Transaction.js";
 export class Indicator extends ObservableObject {
@@ -80,12 +81,12 @@ export class IndicatorImpl extends Indicator {
         mon.leave(worker);
     }
     static doCreate(hint, activationDelay, deactivationDelay, durationResolution) {
-        const m = new IndicatorImpl();
-        Mvcc.setHint(m, hint);
-        m.internals.activationDelay = activationDelay;
-        m.internals.deactivationDelay = deactivationDelay;
-        m.internals.durationResolution = durationResolution;
-        return m;
+        const ind = new IndicatorImpl();
+        Mvcc.setHint(ind, hint);
+        ind.internals.activationDelay = activationDelay;
+        ind.internals.deactivationDelay = deactivationDelay;
+        ind.internals.durationResolution = durationResolution;
+        return ind;
     }
     static activate(mon, delay) {
         const active = mon.counter > 0;
@@ -102,7 +103,7 @@ export class IndicatorImpl extends Indicator {
         }
         if (delay >= 0) {
             if (mon.internals.activationTimeout === undefined)
-                mon.internals.activationTimeout = setTimeout(() => Transaction.run({ hint: "Indicator.activate", separation: "isolated" }, IndicatorImpl.activate, mon, -1), delay);
+                mon.internals.activationTimeout = setTimeout(() => Transaction.run({ hint: "Indicator.activate", isolation: Isolation.disjoinFromOuterAndInnerTransactions }, IndicatorImpl.activate, mon, -1), delay);
         }
         else if (active)
             mon.isBusy = true;
@@ -110,7 +111,7 @@ export class IndicatorImpl extends Indicator {
     static deactivate(mon, delay) {
         if (delay >= 0) {
             clearTimeout(mon.internals.deactivationTimeout);
-            mon.internals.deactivationTimeout = setTimeout(() => Transaction.run({ hint: "Indicator.deactivate", separation: "isolated" }, IndicatorImpl.deactivate, mon, -1), delay);
+            mon.internals.deactivationTimeout = setTimeout(() => Transaction.run({ hint: "Indicator.deactivate", isolation: Isolation.disjoinFromOuterAndInnerTransactions }, IndicatorImpl.deactivate, mon, -1), delay);
         }
         else if (mon.counter <= 0) {
             mon.isBusy = false;

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

@@ -1,5 +1,5 @@
 import { ObservableObject } from "./Mvcc.js";
-import { ObjectHandle, ObjectSnapshot, PatchSet } from "./Data.js";
+import { ObjectHandle, ObjectVersion, PatchSet } from "./Data.js";
 export type Saver = (patch: PatchSet) => Promise<void>;
 export declare abstract class Journal extends ObservableObject {
     abstract capacity: number;
@@ -28,7 +28,7 @@ export declare class JournalImpl extends Journal {
     saved(patch: PatchSet): void;
     undo(count?: number): void;
     redo(count?: number): void;
-    static buildPatch(hint: string, items: Map<ObjectHandle, ObjectSnapshot>): PatchSet;
+    static buildPatch(hint: string, items: Map<ObjectHandle, ObjectVersion>): PatchSet;
     static applyPatch(patch: PatchSet, undoing: boolean): void;
     mergePatchToUnsaved(patch: PatchSet, undoing: boolean): void;
 }