dacument 1.0.0

package/dist/CRSet/class.js

@@ -0,0 +1,198 @@
+import { v7 as uuidv7 } from "uuid";
+export class CRSet {
+    nodes = [];
+    seenNodeIds = new Set();
+    addTagsByKey = new Map();
+    tombstones = new Set();
+    aliveKeys = new Set();
+    latestValueByKey = new Map();
+    listeners = new Set();
+    objectKeyByRef = new WeakMap();
+    objectKeyCounter = 0;
+    symbolKeyByRef = new Map();
+    symbolKeyCounter = 0;
+    keyFn;
+    constructor(options) {
+        this.keyFn = options?.key;
+        if (options?.snapshot?.length)
+            this.merge(options.snapshot);
+    }
+    // --- public API ---
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    snapshot() {
+        return this.nodes.slice();
+    }
+    merge(input) {
+        const nodes = Array.isArray(input) ? input : [input];
+        const accepted = [];
+        for (const node of nodes) {
+            if (this.seenNodeIds.has(node.id))
+                continue;
+            this.seenNodeIds.add(node.id);
+            this.nodes.push(node);
+            this.applyNode(node);
+            accepted.push(node);
+        }
+        if (accepted.length)
+            this.emit(accepted);
+        return accepted;
+    }
+    // --- Set<T> API ---
+    get size() {
+        return this.aliveKeys.size;
+    }
+    add(value) {
+        const key = this.keyOf(value);
+        const node = { op: "add", id: this.newId(), value, key };
+        this.appendAndApply(node);
+        return this;
+    }
+    delete(value) {
+        const key = this.keyOf(value);
+        const targets = this.currentAddTagsForKey(key);
+        if (targets.length === 0)
+            return false;
+        const node = { op: "rem", id: this.newId(), key, targets };
+        this.appendAndApply(node);
+        return true;
+    }
+    clear() {
+        const patches = [];
+        for (const key of this.aliveKeys) {
+            const targets = this.currentAddTagsForKey(key);
+            if (targets.length === 0)
+                continue;
+            patches.push({ op: "rem", id: this.newId(), key, targets });
+        }
+        if (patches.length === 0)
+            return;
+        for (const patch of patches) {
+            this.seenNodeIds.add(patch.id);
+            this.nodes.push(patch);
+            this.applyNode(patch);
+        }
+        this.emit(patches);
+    }
+    has(value) {
+        const key = this.keyOf(value);
+        return this.aliveKeys.has(key);
+    }
+    forEach(callbackfn, thisArg) {
+        for (const value of this.values())
+            callbackfn.call(thisArg, value, value, this);
+    }
+    *values() {
+        for (const key of this.aliveKeys) {
+            if (!this.latestValueByKey.has(key))
+                continue;
+            yield this.latestValueByKey.get(key);
+        }
+    }
+    *keys() {
+        yield* this.values();
+    }
+    *entries() {
+        for (const value of this.values())
+            yield [value, value];
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    [Symbol.toStringTag] = "CRSet";
+    // --- internals ---
+    appendAndApply(node) {
+        this.seenNodeIds.add(node.id);
+        this.nodes.push(node);
+        this.applyNode(node);
+        this.emit([node]);
+    }
+    applyNode(node) {
+        if (node.op === "add") {
+            let tags = this.addTagsByKey.get(node.key);
+            if (!tags) {
+                tags = new Map();
+                this.addTagsByKey.set(node.key, tags);
+            }
+            tags.set(node.id, node.value);
+            this.recomputeAliveForKey(node.key);
+            return;
+        }
+        for (const targetTag of node.targets)
+            this.tombstones.add(targetTag);
+        this.recomputeAliveForKey(node.key);
+    }
+    recomputeAliveForKey(key) {
+        const tags = this.addTagsByKey.get(key);
+        if (!tags || tags.size === 0) {
+            this.aliveKeys.delete(key);
+            this.latestValueByKey.delete(key);
+            return;
+        }
+        let winnerTag = null;
+        let winnerValue;
+        for (const [tag, value] of tags) {
+            if (this.tombstones.has(tag))
+                continue;
+            if (!winnerTag || tag > winnerTag) {
+                winnerTag = tag;
+                winnerValue = value;
+            }
+        }
+        if (winnerTag) {
+            this.aliveKeys.add(key);
+            this.latestValueByKey.set(key, winnerValue);
+            return;
+        }
+        this.aliveKeys.delete(key);
+        this.latestValueByKey.delete(key);
+    }
+    currentAddTagsForKey(key) {
+        const tags = this.addTagsByKey.get(key);
+        if (!tags)
+            return [];
+        return [...tags.keys()];
+    }
+    emit(patches) {
+        for (const listener of this.listeners)
+            listener(patches);
+    }
+    newId() {
+        return uuidv7();
+    }
+    keyOf(value) {
+        if (this.keyFn)
+            return this.keyFn(value);
+        const valueType = typeof value;
+        if (valueType === "string")
+            return `str:${value}`;
+        if (valueType === "number")
+            return `num:${Object.is(value, -0) ? "-0" : String(value)}`;
+        if (valueType === "bigint")
+            return `big:${String(value)}`;
+        if (valueType === "boolean")
+            return `bool:${value ? "1" : "0"}`;
+        if (valueType === "undefined")
+            return "undef";
+        if (value === null)
+            return "null";
+        if (valueType === "symbol") {
+            const existing = this.symbolKeyByRef.get(value);
+            if (existing)
+                return existing;
+            const created = `sym:${(++this.symbolKeyCounter).toString(36)}`;
+            this.symbolKeyByRef.set(value, created);
+            return created;
+        }
+        // objects + functions: stable identity key (matches native Set semantics)
+        const objectRef = value;
+        const existing = this.objectKeyByRef.get(objectRef);
+        if (existing)
+            return existing;
+        const created = `obj:${(++this.objectKeyCounter).toString(36)}`;
+        this.objectKeyByRef.set(objectRef, created);
+        return created;
+    }
+}

package/dist/CRText/class.d.ts

@@ -0,0 +1,19 @@
+import { DAGNode } from "../DAGNode/class.js";
+export declare class CRText<CharT extends string = string> {
+    private readonly nodes;
+    private readonly nodeById;
+    private readonly listeners;
+    constructor(snapshot?: readonly DAGNode<CharT>[]);
+    get length(): number;
+    onChange(listener: (nodes: readonly DAGNode<CharT>[]) => void): () => void;
+    snapshot(): DAGNode<CharT>[];
+    toString(): string;
+    at(index: number): CharT | undefined;
+    insertAt(index: number, char: CharT): this;
+    deleteAt(index: number): CharT | undefined;
+    merge(remoteSnapshot: DAGNode<CharT>[] | DAGNode<CharT>): DAGNode<CharT>[];
+    sort(compareFn?: (a: DAGNode<CharT>, b: DAGNode<CharT>) => number): this;
+    private alive;
+    private afterIdForAliveInsertAt;
+    private emit;
+}

package/dist/CRText/class.js

@@ -0,0 +1,156 @@
+import { DAGNode } from "../DAGNode/class.js";
+const ROOT = [];
+function afterKey(after) {
+    return after.join(",");
+}
+export class CRText {
+    nodes = [];
+    nodeById = new Map();
+    listeners = new Set();
+    constructor(snapshot) {
+        if (snapshot) {
+            for (const node of snapshot) {
+                if (this.nodeById.has(node.id))
+                    continue;
+                this.nodes.push(node);
+                this.nodeById.set(node.id, node);
+            }
+        }
+        this.sort();
+    }
+    get length() {
+        let count = 0;
+        for (const node of this.nodes)
+            if (!node.deleted)
+                count++;
+        return count;
+    }
+    // --- public API ---
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    snapshot() {
+        return this.nodes.slice();
+    }
+    toString() {
+        let output = "";
+        for (const node of this.nodes)
+            if (!node.deleted)
+                output += String(node.value);
+        return output;
+    }
+    at(index) {
+        return this.alive().at(index);
+    }
+    insertAt(index, char) {
+        if (!Number.isInteger(index))
+            throw new TypeError("CRText.insertAt: index must be an integer");
+        if (index < 0)
+            throw new RangeError("CRText.insertAt: negative index not supported");
+        if (index > this.length)
+            throw new RangeError("CRText.insertAt: index out of bounds");
+        const after = this.afterIdForAliveInsertAt(index);
+        const node = new DAGNode({ value: char, after });
+        this.nodes.push(node);
+        this.nodeById.set(node.id, node);
+        this.sort();
+        this.emit([node]);
+        return this;
+    }
+    deleteAt(index) {
+        if (!Number.isInteger(index))
+            throw new TypeError("CRText.deleteAt: index must be an integer");
+        if (index < 0)
+            throw new RangeError("CRText.deleteAt: negative index not supported");
+        let aliveIndex = 0;
+        for (const node of this.nodes) {
+            if (node.deleted)
+                continue;
+            if (aliveIndex === index) {
+                node.deleted = true;
+                this.emit([node]);
+                return node.value;
+            }
+            aliveIndex++;
+        }
+        return undefined;
+    }
+    merge(remoteSnapshot) {
+        const snapshot = Array.isArray(remoteSnapshot)
+            ? remoteSnapshot
+            : [remoteSnapshot];
+        const changed = [];
+        for (const remote of snapshot) {
+            const local = this.nodeById.get(remote.id);
+            if (!local) {
+                const clone = structuredClone(remote);
+                this.nodes.push(clone);
+                this.nodeById.set(clone.id, clone);
+                changed.push(clone);
+            }
+            else if (!local.deleted && remote.deleted) {
+                local.deleted = true;
+                changed.push(local);
+            }
+        }
+        if (changed.length) {
+            this.sort();
+            this.emit(changed);
+        }
+        return changed;
+    }
+    sort(compareFn) {
+        if (compareFn) {
+            this.nodes.sort(compareFn);
+            return this;
+        }
+        this.nodes.sort((left, right) => {
+            const leftIsRoot = left.after.length === 0;
+            const rightIsRoot = right.after.length === 0;
+            if (leftIsRoot !== rightIsRoot)
+                return leftIsRoot ? -1 : 1;
+            const leftAfterKey = afterKey(left.after);
+            const rightAfterKey = afterKey(right.after);
+            if (leftAfterKey !== rightAfterKey)
+                return leftAfterKey < rightAfterKey ? -1 : 1;
+            if (left.id === right.id)
+                return 0;
+            if (leftIsRoot)
+                return left.id > right.id ? -1 : 1;
+            return left.id < right.id ? -1 : 1;
+        });
+        return this;
+    }
+    // --- internals ---
+    alive() {
+        const values = [];
+        for (const node of this.nodes)
+            if (!node.deleted)
+                values.push(node.value);
+        return values;
+    }
+    afterIdForAliveInsertAt(index) {
+        if (index === 0)
+            return ROOT;
+        let aliveIndex = 0;
+        let previousAliveId = null;
+        for (const node of this.nodes) {
+            if (node.deleted)
+                continue;
+            if (aliveIndex === index)
+                break;
+            previousAliveId = node.id;
+            aliveIndex++;
+        }
+        if (previousAliveId)
+            return [previousAliveId];
+        return ROOT;
+    }
+    emit(nodes) {
+        if (nodes.length === 0)
+            return;
+        for (const listener of this.listeners)
+            listener(nodes);
+    }
+}

package/dist/DAGNode/class.d.ts

@@ -0,0 +1,13 @@
+export type NodeId = string;
+export declare class DAGNode<ValueType> {
+    readonly id: NodeId;
+    readonly value: ValueType;
+    readonly after: readonly NodeId[];
+    deleted: boolean;
+    constructor(params: {
+        value: ValueType;
+        after?: readonly NodeId[];
+        deleted?: boolean;
+        id?: NodeId;
+    });
+}

package/dist/DAGNode/class.js

@@ -0,0 +1,13 @@
+import { v7 as uuidv7 } from "uuid";
+export class DAGNode {
+    id;
+    value;
+    after;
+    deleted;
+    constructor(params) {
+        this.id = params.id ?? uuidv7();
+        this.value = params.value;
+        this.after = params.after ?? [];
+        this.deleted = params.deleted ?? false;
+    }
+}

package/dist/Dacument/acl.d.ts

@@ -0,0 +1,16 @@
+import type { AclAssignment, Role } from "./types.js";
+export declare class AclLog {
+    private readonly nodes;
+    private readonly nodesById;
+    private readonly nodesByActor;
+    private readonly currentByActor;
+    merge(input: AclAssignment[] | AclAssignment): AclAssignment[];
+    snapshot(): AclAssignment[];
+    reset(): void;
+    isEmpty(): boolean;
+    roleAt(actorId: string, stamp: AclAssignment["stamp"]): Role;
+    currentRole(actorId: string): Role;
+    currentEntry(actorId: string): AclAssignment | null;
+    knownActors(): string[];
+    private insert;
+}

package/dist/Dacument/acl.js

@@ -0,0 +1,84 @@
+import { compareHLC } from "./clock.js";
+function compareAssignment(left, right) {
+    const cmp = compareHLC(left.stamp, right.stamp);
+    if (cmp !== 0)
+        return cmp;
+    if (left.id === right.id)
+        return 0;
+    return left.id < right.id ? -1 : 1;
+}
+export class AclLog {
+    nodes = [];
+    nodesById = new Set();
+    nodesByActor = new Map();
+    currentByActor = new Map();
+    merge(input) {
+        const nodes = Array.isArray(input) ? input : [input];
+        const accepted = [];
+        for (const node of nodes) {
+            if (this.nodesById.has(node.id))
+                continue;
+            this.nodesById.add(node.id);
+            this.nodes.push(node);
+            this.insert(node);
+            accepted.push(node);
+        }
+        return accepted;
+    }
+    snapshot() {
+        return this.nodes.slice();
+    }
+    reset() {
+        this.nodes.length = 0;
+        this.nodesById.clear();
+        this.nodesByActor.clear();
+        this.currentByActor.clear();
+    }
+    isEmpty() {
+        return this.nodes.length === 0;
+    }
+    roleAt(actorId, stamp) {
+        const list = this.nodesByActor.get(actorId);
+        if (!list || list.length === 0)
+            return "revoked";
+        for (let index = list.length - 1; index >= 0; index--) {
+            const entry = list[index];
+            if (compareHLC(entry.stamp, stamp) <= 0)
+                return entry.role;
+        }
+        return "revoked";
+    }
+    currentRole(actorId) {
+        const entry = this.currentByActor.get(actorId);
+        return entry ? entry.role : "revoked";
+    }
+    currentEntry(actorId) {
+        return this.currentByActor.get(actorId) ?? null;
+    }
+    knownActors() {
+        return [...this.currentByActor.keys()];
+    }
+    insert(node) {
+        const list = this.nodesByActor.get(node.actorId) ?? [];
+        if (list.length === 0) {
+            list.push(node);
+            this.nodesByActor.set(node.actorId, list);
+            this.currentByActor.set(node.actorId, node);
+            return;
+        }
+        let inserted = false;
+        for (let index = list.length - 1; index >= 0; index--) {
+            if (compareAssignment(list[index], node) <= 0) {
+                list.splice(index + 1, 0, node);
+                inserted = true;
+                break;
+            }
+        }
+        if (!inserted)
+            list.unshift(node);
+        const current = this.currentByActor.get(node.actorId);
+        if (!current || compareAssignment(current, node) < 0) {
+            this.currentByActor.set(node.actorId, node);
+        }
+    }
+}

package/dist/Dacument/class.d.ts

@@ -0,0 +1,141 @@
+import { type AclAssignment, type DacumentEventMap, type DocFieldAccess, type DocSnapshot, type RoleKeys, type RolePublicKeys, type SchemaDefinition, type SchemaId, type SignedOp, type Role, array, map, record, register, set, text } from "./types.js";
+export declare class Dacument<S extends SchemaDefinition> {
+    private static actorId?;
+    static setActorId(actorId: string): void;
+    private static requireActorId;
+    private static isValidActorId;
+    static schema: <Schema extends SchemaDefinition>(schema: Schema) => Schema;
+    static register: typeof register;
+    static text: typeof text;
+    static array: typeof array;
+    static set: typeof set;
+    static map: typeof map;
+    static record: typeof record;
+    static computeSchemaId(schema: SchemaDefinition): Promise<SchemaId>;
+    static create<Schema extends SchemaDefinition>(params: {
+        schema: Schema;
+        docId?: string;
+    }): Promise<{
+        docId: string;
+        schemaId: SchemaId;
+        roleKeys: RoleKeys;
+        snapshot: DocSnapshot;
+    }>;
+    static load<Schema extends SchemaDefinition>(params: {
+        schema: Schema;
+        roleKey?: JsonWebKey;
+        snapshot: DocSnapshot;
+    }): Promise<DacumentDoc<Schema>>;
+    readonly docId: string;
+    readonly actorId: string;
+    readonly schema: S;
+    readonly schemaId: SchemaId;
+    private readonly fields;
+    private readonly aclLog;
+    private readonly clock;
+    private readonly roleKey?;
+    private readonly roleKeys;
+    private readonly opLog;
+    private readonly opTokens;
+    private readonly verifiedOps;
+    private readonly appliedTokens;
+    private currentRole;
+    private readonly revokedCrdtByField;
+    private readonly deleteStampsByField;
+    private readonly tombstoneStampsByField;
+    private readonly deleteNodeStampsByField;
+    private readonly eventListeners;
+    private readonly pending;
+    private readonly ackByActor;
+    private suppressMerge;
+    private ackScheduled;
+    private lastGcBarrier;
+    private snapshotFieldValues;
+    readonly acl: {
+        setRole: (actorId: string, role: Role) => void;
+        getRole: (actorId: string) => Role;
+        knownActors: () => string[];
+        snapshot: () => AclAssignment[];
+    };
+    constructor(params: {
+        schema: S;
+        schemaId: SchemaId;
+        docId: string;
+        roleKey?: JsonWebKey;
+        roleKeys: RolePublicKeys;
+    });
+    addEventListener<K extends keyof DacumentEventMap>(type: K, listener: (event: DacumentEventMap[K]) => void): void;
+    removeEventListener<K extends keyof DacumentEventMap>(type: K, listener: (event: DacumentEventMap[K]) => void): void;
+    flush(): Promise<void>;
+    snapshot(): DocSnapshot;
+    merge(input: SignedOp | SignedOp[] | string | string[]): Promise<{
+        accepted: SignedOp[];
+        rejected: number;
+    }>;
+    private rebuildFromVerified;
+    private ack;
+    private scheduleAck;
+    private computeGcBarrier;
+    private maybeGc;
+    private compactFields;
+    private compactListField;
+    private compactTombstoneField;
+    private setRegisterValue;
+    private createFieldView;
+    private shadowFor;
+    private isRevoked;
+    private readCrdt;
+    private revokedCrdt;
+    private stampMapFor;
+    private setMinStamp;
+    private recordDeletedNode;
+    private recordTombstone;
+    private recordDeleteNodeStamp;
+    private createTextView;
+    private createArrayView;
+    private createSetView;
+    private createMapView;
+    private createRecordView;
+    private commitArrayMutation;
+    private commitSetMutation;
+    private commitMapMutation;
+    private commitRecordMutation;
+    private capturePatches;
+    private queueLocalOp;
+    private applyRemotePayload;
+    private applyAclPayload;
+    private applyRegisterPayload;
+    private applyNodePayload;
+    private applySetNodes;
+    private applyMapNodes;
+    private applyRecordNodes;
+    private validateDagNodeValues;
+    private emitListOps;
+    private diffSet;
+    private diffMap;
+    private diffRecord;
+    private emitInvalidationDiffs;
+    private emitFieldDiff;
+    private emitTextDiff;
+    private emitArrayDiff;
+    private arrayEquals;
+    private commonPrefix;
+    private commonSuffix;
+    private setRole;
+    private recordValue;
+    private mapValue;
+    private fieldValue;
+    private emitEvent;
+    private emitMerge;
+    private emitRevoked;
+    private emitError;
+    private canWriteField;
+    private canWriteAcl;
+    private assertWritable;
+    private assertValueType;
+    private assertValueArray;
+    private assertMapKey;
+    private isValidPayload;
+    private assertSchemaKeys;
+}
+export type DacumentDoc<S extends SchemaDefinition> = Dacument<S> & DocFieldAccess<S>;