cojson 0.10.0 → 0.10.1

package/dist/web/coValue.js

@@ -1,52 +0,0 @@
-export class RawUnknownCoValue {
-    constructor(core) {
-        this.id = core.id;
-        this.core = core;
-    }
-    get type() {
-        return this.core.header.type;
-    }
-    get headerMeta() {
-        return this.core.header.meta;
-    }
-    /** @category 6. Meta */
-    get group() {
-        return this.core.getGroup();
-    }
-    toJSON() {
-        return {};
-    }
-    atTime() {
-        return this;
-    }
-    subscribe(listener) {
-        return this.core.subscribe((content) => {
-            listener(content);
-        });
-    }
-}
-export function expectMap(content) {
-    if (content.type !== "comap") {
-        throw new Error("Expected map");
-    }
-    return content;
-}
-export function expectList(content) {
-    if (content.type !== "colist") {
-        throw new Error("Expected list");
-    }
-    return content;
-}
-export function expectStream(content) {
-    if (content.type !== "costream") {
-        throw new Error("Expected stream");
-    }
-    return content;
-}
-export function expectPlainText(content) {
-    if (content.type !== "coplaintext") {
-        throw new Error("Expected plaintext");
-    }
-    return content;
-}
-//# sourceMappingURL=coValue.js.map

package/dist/web/coValue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"coValue.js","sourceRoot":"","sources":["../../src/coValue.ts"],"names":[],"mappings":"AAqCA,MAAM,OAAO,iBAAiB;IAI5B,YAAY,IAAiB;QAC3B,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAgB,CAAC;QAChC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC/B,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAkB,CAAC;IAC7C,CAAC;IAED,wBAAwB;IACxB,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC9B,CAAC;IAED,MAAM;QACJ,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC;IACd,CAAC;IAED,SAAS,CAAC,QAA+B;QACvC,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;YACrC,QAAQ,CAAC,OAAe,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAYD,MAAM,UAAU,SAAS,CAAC,OAAmB;IAC3C,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC;IAClC,CAAC;IAED,OAAO,OAAmB,CAAC;AAC7B,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,OAAmB;IAC5C,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAED,OAAO,OAAoB,CAAC;AAC9B,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,OAAmB;IAC9C,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;IAED,OAAO,OAAsB,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,OAAmB;IACjD,IAAI,OAAO,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;IACxC,CAAC;IAED,OAAO,OAAyB,CAAC;AACnC,CAAC"}

package/dist/web/coValueCore.js

@@ -1,597 +0,0 @@
-import { err, ok } from "neverthrow";
-import { coreToCoValue } from "./coreToCoValue.js";
-import { StreamingHash, } from "./crypto/crypto.js";
-import { getGroupDependentKeyList, getParentGroupId, isParentGroupReference, } from "./ids.js";
-import { parseJSON, stableStringify } from "./jsonStringify.js";
-import { logger } from "./logger.js";
-import { determineValidTransactions, isKeyForKeyField, } from "./permissions.js";
-import { getPriorityFromHeader } from "./priority.js";
-import { accountOrAgentIDfromSessionID } from "./typeUtils/accountOrAgentIDfromSessionID.js";
-import { expectGroup } from "./typeUtils/expectGroup.js";
-import { isAccountID } from "./typeUtils/isAccountID.js";
-/**
-    In order to not block other concurrently syncing CoValues we introduce a maximum size of transactions,
-    since they are the smallest unit of progress that can be synced within a CoValue.
-    This is particularly important for storing binary data in CoValues, since they are likely to be at least on the order of megabytes.
-    This also means that we want to keep signatures roughly after each MAX_RECOMMENDED_TX size chunk,
-    to be able to verify partially loaded CoValues or CoValues that are still being created (like a video live stream).
-**/
-export const MAX_RECOMMENDED_TX_SIZE = 100 * 1024;
-export function idforHeader(header, crypto) {
-    const hash = crypto.shortHash(header);
-    return `co_z${hash.slice("shortHash_z".length)}`;
-}
-const readKeyCache = new WeakMap();
-export class CoValueCore {
-    constructor(header, node, internalInitSessions = new Map()) {
-        this.listeners = new Set();
-        this._decryptionCache = {};
-        this.deferredUpdates = 0;
-        this.crypto = node.crypto;
-        this.id = idforHeader(header, node.crypto);
-        this.header = header;
-        this._sessionLogs = internalInitSessions;
-        this.node = node;
-        if (header.ruleset.type == "ownedByGroup") {
-            this.node
-                .expectCoValueLoaded(header.ruleset.group)
-                .subscribe((_groupUpdate) => {
-                this._cachedContent = undefined;
-                this.notifyUpdate("immediate");
-            });
-        }
-    }
-    get sessionLogs() {
-        return this._sessionLogs;
-    }
-    testWithDifferentAccount(account, currentSessionID) {
-        const newNode = this.node.testWithDifferentAccount(account, currentSessionID);
-        return newNode.expectCoValueLoaded(this.id);
-    }
-    knownState() {
-        if (this._cachedKnownState) {
-            return this._cachedKnownState;
-        }
-        else {
-            const knownState = this.knownStateUncached();
-            this._cachedKnownState = knownState;
-            return knownState;
-        }
-    }
-    /** @internal */
-    knownStateUncached() {
-        const sessions = {};
-        for (const [sessionID, sessionLog] of this.sessionLogs.entries()) {
-            sessions[sessionID] = sessionLog.transactions.length;
-        }
-        return {
-            id: this.id,
-            header: true,
-            sessions,
-        };
-    }
-    get meta() {
-        return this.header?.meta ?? null;
-    }
-    nextTransactionID() {
-        // This is an ugly hack to get a unique but stable session ID for editing the current account
-        const sessionID = this.header.meta?.type === "account"
-            ? this.node.currentSessionID.replace(this.node.account.id, this.node.account
-                .currentAgentID()
-                ._unsafeUnwrap({ withStackTrace: true }))
-            : this.node.currentSessionID;
-        return {
-            sessionID,
-            txIndex: this.sessionLogs.get(sessionID)?.transactions.length || 0,
-        };
-    }
-    tryAddTransactions(sessionID, newTransactions, givenExpectedNewHash, newSignature, skipVerify = false) {
-        return this.node
-            .resolveAccountAgent(accountOrAgentIDfromSessionID(sessionID), "Expected to know signer of transaction")
-            .andThen((agent) => {
-            const signerID = this.crypto.getAgentSignerID(agent);
-            const { expectedNewHash, newStreamingHash } = this.expectedNewHashAfter(sessionID, newTransactions);
-            if (givenExpectedNewHash && givenExpectedNewHash !== expectedNewHash) {
-                return err({
-                    type: "InvalidHash",
-                    id: this.id,
-                    expectedNewHash,
-                    givenExpectedNewHash,
-                });
-            }
-            if (skipVerify !== true &&
-                !this.crypto.verify(newSignature, expectedNewHash, signerID)) {
-                return err({
-                    type: "InvalidSignature",
-                    id: this.id,
-                    newSignature,
-                    sessionID,
-                    signerID,
-                });
-            }
-            this.doAddTransactions(sessionID, newTransactions, newSignature, expectedNewHash, newStreamingHash, "immediate");
-            return ok(true);
-        });
-    }
-    doAddTransactions(sessionID, newTransactions, newSignature, expectedNewHash, newStreamingHash, notifyMode) {
-        if (this.node.crashed) {
-            throw new Error("Trying to add transactions after node is crashed");
-        }
-        const transactions = this.sessionLogs.get(sessionID)?.transactions ?? [];
-        for (const tx of newTransactions) {
-            transactions.push(tx);
-        }
-        const signatureAfter = this.sessionLogs.get(sessionID)?.signatureAfter ?? {};
-        const lastInbetweenSignatureIdx = Object.keys(signatureAfter).reduce((max, idx) => (parseInt(idx) > max ? parseInt(idx) : max), -1);
-        const sizeOfTxsSinceLastInbetweenSignature = transactions
-            .slice(lastInbetweenSignatureIdx + 1)
-            .reduce((sum, tx) => sum +
-            (tx.privacy === "private"
-                ? tx.encryptedChanges.length
-                : tx.changes.length), 0);
-        if (sizeOfTxsSinceLastInbetweenSignature > MAX_RECOMMENDED_TX_SIZE) {
-            signatureAfter[transactions.length - 1] = newSignature;
-        }
-        this._sessionLogs.set(sessionID, {
-            transactions,
-            lastHash: expectedNewHash,
-            streamingHash: newStreamingHash,
-            lastSignature: newSignature,
-            signatureAfter: signatureAfter,
-        });
-        if (this._cachedContent &&
-            "processNewTransactions" in this._cachedContent &&
-            typeof this._cachedContent.processNewTransactions === "function") {
-            this._cachedContent.processNewTransactions();
-        }
-        else {
-            this._cachedContent = undefined;
-        }
-        this._cachedKnownState = undefined;
-        this._cachedDependentOn = undefined;
-        this._cachedNewContentSinceEmpty = undefined;
-        this.notifyUpdate(notifyMode);
-    }
-    notifyUpdate(notifyMode) {
-        if (this.listeners.size === 0) {
-            return;
-        }
-        if (notifyMode === "immediate") {
-            const content = this.getCurrentContent();
-            for (const listener of this.listeners) {
-                listener(content);
-            }
-        }
-        else {
-            if (!this.nextDeferredNotify) {
-                this.nextDeferredNotify = new Promise((resolve) => {
-                    setTimeout(() => {
-                        this.nextDeferredNotify = undefined;
-                        this.deferredUpdates = 0;
-                        const content = this.getCurrentContent();
-                        for (const listener of this.listeners) {
-                            listener(content);
-                        }
-                        resolve();
-                    }, 0);
-                });
-            }
-            this.deferredUpdates++;
-        }
-    }
-    subscribe(listener) {
-        this.listeners.add(listener);
-        listener(this.getCurrentContent());
-        return () => {
-            this.listeners.delete(listener);
-        };
-    }
-    expectedNewHashAfter(sessionID, newTransactions) {
-        const streamingHash = this.sessionLogs.get(sessionID)?.streamingHash.clone() ??
-            new StreamingHash(this.crypto);
-        for (const transaction of newTransactions) {
-            streamingHash.update(transaction);
-        }
-        const newStreamingHash = streamingHash.clone();
-        return {
-            expectedNewHash: streamingHash.digest(),
-            newStreamingHash,
-        };
-    }
-    async expectedNewHashAfterAsync(sessionID, newTransactions) {
-        const streamingHash = this.sessionLogs.get(sessionID)?.streamingHash.clone() ??
-            new StreamingHash(this.crypto);
-        let before = performance.now();
-        for (const transaction of newTransactions) {
-            streamingHash.update(transaction);
-            const after = performance.now();
-            if (after - before > 1) {
-                await new Promise((resolve) => setTimeout(resolve, 0));
-                before = performance.now();
-            }
-        }
-        const newStreamingHash = streamingHash.clone();
-        return {
-            expectedNewHash: streamingHash.digest(),
-            newStreamingHash,
-        };
-    }
-    makeTransaction(changes, privacy) {
-        const madeAt = Date.now();
-        let transaction;
-        if (privacy === "private") {
-            const { secret: keySecret, id: keyID } = this.getCurrentReadKey();
-            if (!keySecret) {
-                throw new Error("Can't make transaction without read key secret");
-            }
-            const encrypted = this.crypto.encryptForTransaction(changes, keySecret, {
-                in: this.id,
-                tx: this.nextTransactionID(),
-            });
-            this._decryptionCache[encrypted] = changes;
-            transaction = {
-                privacy: "private",
-                madeAt,
-                keyUsed: keyID,
-                encryptedChanges: encrypted,
-            };
-        }
-        else {
-            transaction = {
-                privacy: "trusting",
-                madeAt,
-                changes: stableStringify(changes),
-            };
-        }
-        // This is an ugly hack to get a unique but stable session ID for editing the current account
-        const sessionID = this.header.meta?.type === "account"
-            ? this.node.currentSessionID.replace(this.node.account.id, this.node.account
-                .currentAgentID()
-                ._unsafeUnwrap({ withStackTrace: true }))
-            : this.node.currentSessionID;
-        const { expectedNewHash } = this.expectedNewHashAfter(sessionID, [
-            transaction,
-        ]);
-        const signature = this.crypto.sign(this.node.account.currentSignerSecret(), expectedNewHash);
-        const success = this.tryAddTransactions(sessionID, [transaction], expectedNewHash, signature, true)._unsafeUnwrap({ withStackTrace: true });
-        if (success) {
-            void this.node.syncManager.syncCoValue(this);
-        }
-        return success;
-    }
-    getCurrentContent(options) {
-        if (!options?.ignorePrivateTransactions && this._cachedContent) {
-            return this._cachedContent;
-        }
-        const newContent = coreToCoValue(this, options);
-        if (!options?.ignorePrivateTransactions) {
-            this._cachedContent = newContent;
-        }
-        return newContent;
-    }
-    getValidTransactions(options) {
-        const validTransactions = determineValidTransactions(this);
-        const allTransactions = [];
-        for (const { txID, tx } of validTransactions) {
-            if (options?.knownTransactions?.[txID.sessionID] >= txID.txIndex) {
-                continue;
-            }
-            if (tx.privacy === "trusting") {
-                allTransactions.push({
-                    txID,
-                    madeAt: tx.madeAt,
-                    changes: parseJSON(tx.changes),
-                });
-                continue;
-            }
-            if (options?.ignorePrivateTransactions) {
-                continue;
-            }
-            const readKey = this.getReadKey(tx.keyUsed);
-            if (!readKey) {
-                continue;
-            }
-            let decryptedChanges = this._decryptionCache[tx.encryptedChanges];
-            if (!decryptedChanges) {
-                const decryptedString = this.crypto.decryptRawForTransaction(tx.encryptedChanges, readKey, {
-                    in: this.id,
-                    tx: txID,
-                });
-                decryptedChanges = decryptedString && parseJSON(decryptedString);
-                this._decryptionCache[tx.encryptedChanges] = decryptedChanges;
-            }
-            if (!decryptedChanges) {
-                logger.error("Failed to decrypt transaction despite having key");
-                continue;
-            }
-            allTransactions.push({
-                txID,
-                madeAt: tx.madeAt,
-                changes: decryptedChanges,
-            });
-        }
-        return allTransactions;
-    }
-    getValidSortedTransactions(options) {
-        const allTransactions = this.getValidTransactions(options);
-        allTransactions.sort(this.compareTransactions);
-        return allTransactions;
-    }
-    compareTransactions(a, b) {
-        return (a.madeAt - b.madeAt ||
-            (a.txID.sessionID < b.txID.sessionID ? -1 : 1) ||
-            a.txID.txIndex - b.txID.txIndex);
-    }
-    getCurrentReadKey() {
-        if (this.header.ruleset.type === "group") {
-            const content = expectGroup(this.getCurrentContent());
-            const currentKeyId = content.getCurrentReadKeyId();
-            if (!currentKeyId) {
-                throw new Error("No readKey set");
-            }
-            const secret = this.getReadKey(currentKeyId);
-            return {
-                secret: secret,
-                id: currentKeyId,
-            };
-        }
-        else if (this.header.ruleset.type === "ownedByGroup") {
-            return this.node
-                .expectCoValueLoaded(this.header.ruleset.group)
-                .getCurrentReadKey();
-        }
-        else {
-            throw new Error("Only groups or values owned by groups have read secrets");
-        }
-    }
-    getReadKey(keyID) {
-        let key = readKeyCache.get(this)?.[keyID];
-        if (!key) {
-            key = this.getUncachedReadKey(keyID);
-            if (key) {
-                let cache = readKeyCache.get(this);
-                if (!cache) {
-                    cache = {};
-                    readKeyCache.set(this, cache);
-                }
-                cache[keyID] = key;
-            }
-        }
-        return key;
-    }
-    getUncachedReadKey(keyID) {
-        if (this.header.ruleset.type === "group") {
-            const content = expectGroup(this.getCurrentContent({ ignorePrivateTransactions: true }));
-            const keyForEveryone = content.get(`${keyID}_for_everyone`);
-            if (keyForEveryone)
-                return keyForEveryone;
-            // Try to find key revelation for us
-            const lookupAccountOrAgentID = this.header.meta?.type === "account"
-                ? this.node.account
-                    .currentAgentID()
-                    ._unsafeUnwrap({ withStackTrace: true })
-                : this.node.account.id;
-            const lastReadyKeyEdit = content.lastEditAt(`${keyID}_for_${lookupAccountOrAgentID}`);
-            if (lastReadyKeyEdit?.value) {
-                const revealer = lastReadyKeyEdit.by;
-                const revealerAgent = this.node
-                    .resolveAccountAgent(revealer, "Expected to know revealer")
-                    ._unsafeUnwrap({ withStackTrace: true });
-                const secret = this.crypto.unseal(lastReadyKeyEdit.value, this.node.account.currentSealerSecret(), this.crypto.getAgentSealerID(revealerAgent), {
-                    in: this.id,
-                    tx: lastReadyKeyEdit.tx,
-                });
-                if (secret) {
-                    return secret;
-                }
-            }
-            // Try to find indirect revelation through previousKeys
-            for (const co of content.keys()) {
-                if (isKeyForKeyField(co) && co.startsWith(keyID)) {
-                    const encryptingKeyID = co.split("_for_")[1];
-                    const encryptingKeySecret = this.getReadKey(encryptingKeyID);
-                    if (!encryptingKeySecret) {
-                        continue;
-                    }
-                    const encryptedPreviousKey = content.get(co);
-                    const secret = this.crypto.decryptKeySecret({
-                        encryptedID: keyID,
-                        encryptingID: encryptingKeyID,
-                        encrypted: encryptedPreviousKey,
-                    }, encryptingKeySecret);
-                    if (secret) {
-                        return secret;
-                    }
-                    else {
-                        logger.warn(`Encrypting ${encryptingKeyID} key didn't decrypt ${keyID}`);
-                    }
-                }
-            }
-            // try to find revelation to parent group read keys
-            for (const co of content.keys()) {
-                if (isParentGroupReference(co)) {
-                    const parentGroupID = getParentGroupId(co);
-                    const parentGroup = this.node.expectCoValueLoaded(parentGroupID, "Expected parent group to be loaded");
-                    const parentKeys = this.findValidParentKeys(keyID, content, parentGroup);
-                    for (const parentKey of parentKeys) {
-                        const revelationForParentKey = content.get(`${keyID}_for_${parentKey.id}`);
-                        if (revelationForParentKey) {
-                            const secret = parentGroup.crypto.decryptKeySecret({
-                                encryptedID: keyID,
-                                encryptingID: parentKey.id,
-                                encrypted: revelationForParentKey,
-                            }, parentKey.secret);
-                            if (secret) {
-                                return secret;
-                            }
-                            else {
-                                logger.warn(`Encrypting parent ${parentKey.id} key didn't decrypt ${keyID}`);
-                            }
-                        }
-                    }
-                }
-            }
-            return undefined;
-        }
-        else if (this.header.ruleset.type === "ownedByGroup") {
-            return this.node
-                .expectCoValueLoaded(this.header.ruleset.group)
-                .getReadKey(keyID);
-        }
-        else {
-            throw new Error("Only groups or values owned by groups have read secrets");
-        }
-    }
-    findValidParentKeys(keyID, group, parentGroup) {
-        const validParentKeys = [];
-        for (const co of group.keys()) {
-            if (isKeyForKeyField(co) && co.startsWith(keyID)) {
-                const encryptingKeyID = co.split("_for_")[1];
-                const encryptingKeySecret = parentGroup.getReadKey(encryptingKeyID);
-                if (!encryptingKeySecret) {
-                    continue;
-                }
-                validParentKeys.push({
-                    id: encryptingKeyID,
-                    secret: encryptingKeySecret,
-                });
-            }
-        }
-        return validParentKeys;
-    }
-    getGroup() {
-        if (this.header.ruleset.type !== "ownedByGroup") {
-            throw new Error("Only values owned by groups have groups");
-        }
-        return expectGroup(this.node
-            .expectCoValueLoaded(this.header.ruleset.group)
-            .getCurrentContent());
-    }
-    getTx(txID) {
-        return this.sessionLogs.get(txID.sessionID)?.transactions[txID.txIndex];
-    }
-    newContentSince(knownState) {
-        const isKnownStateEmpty = !knownState?.header && !knownState?.sessions;
-        if (isKnownStateEmpty && this._cachedNewContentSinceEmpty) {
-            return this._cachedNewContentSinceEmpty;
-        }
-        let currentPiece = {
-            action: "content",
-            id: this.id,
-            header: knownState?.header ? undefined : this.header,
-            priority: getPriorityFromHeader(this.header),
-            new: {},
-        };
-        const pieces = [currentPiece];
-        const sentState = {};
-        let pieceSize = 0;
-        let sessionsTodoAgain = "first";
-        while (sessionsTodoAgain === "first" || sessionsTodoAgain?.size || 0 > 0) {
-            if (sessionsTodoAgain === "first") {
-                sessionsTodoAgain = undefined;
-            }
-            const sessionsTodo = sessionsTodoAgain ?? this.sessionLogs.keys();
-            for (const sessionIDKey of sessionsTodo) {
-                const sessionID = sessionIDKey;
-                const log = this.sessionLogs.get(sessionID);
-                const knownStateForSessionID = knownState?.sessions[sessionID];
-                const sentStateForSessionID = sentState[sessionID];
-                const nextKnownSignatureIdx = getNextKnownSignatureIdx(log, knownStateForSessionID, sentStateForSessionID);
-                const firstNewTxIdx = sentStateForSessionID ?? knownStateForSessionID ?? 0;
-                const afterLastNewTxIdx = nextKnownSignatureIdx === undefined
-                    ? log.transactions.length
-                    : nextKnownSignatureIdx + 1;
-                const nNewTx = Math.max(0, afterLastNewTxIdx - firstNewTxIdx);
-                if (nNewTx === 0) {
-                    sessionsTodoAgain?.delete(sessionID);
-                    continue;
-                }
-                if (afterLastNewTxIdx < log.transactions.length) {
-                    if (!sessionsTodoAgain) {
-                        sessionsTodoAgain = new Set();
-                    }
-                    sessionsTodoAgain.add(sessionID);
-                }
-                const oldPieceSize = pieceSize;
-                for (let txIdx = firstNewTxIdx; txIdx < afterLastNewTxIdx; txIdx++) {
-                    const tx = log.transactions[txIdx];
-                    pieceSize +=
-                        tx.privacy === "private"
-                            ? tx.encryptedChanges.length
-                            : tx.changes.length;
-                }
-                if (pieceSize >= MAX_RECOMMENDED_TX_SIZE) {
-                    currentPiece = {
-                        action: "content",
-                        id: this.id,
-                        header: undefined,
-                        new: {},
-                        priority: getPriorityFromHeader(this.header),
-                    };
-                    pieces.push(currentPiece);
-                    pieceSize = pieceSize - oldPieceSize;
-                }
-                let sessionEntry = currentPiece.new[sessionID];
-                if (!sessionEntry) {
-                    sessionEntry = {
-                        after: sentStateForSessionID ?? knownStateForSessionID ?? 0,
-                        newTransactions: [],
-                        lastSignature: "WILL_BE_REPLACED",
-                    };
-                    currentPiece.new[sessionID] = sessionEntry;
-                }
-                for (let txIdx = firstNewTxIdx; txIdx < afterLastNewTxIdx; txIdx++) {
-                    const tx = log.transactions[txIdx];
-                    sessionEntry.newTransactions.push(tx);
-                }
-                sessionEntry.lastSignature =
-                    nextKnownSignatureIdx === undefined
-                        ? log.lastSignature
-                        : log.signatureAfter[nextKnownSignatureIdx];
-                sentState[sessionID] =
-                    (sentStateForSessionID ?? knownStateForSessionID ?? 0) + nNewTx;
-            }
-        }
-        const piecesWithContent = pieces.filter((piece) => Object.keys(piece.new).length > 0 || piece.header);
-        if (piecesWithContent.length === 0) {
-            return undefined;
-        }
-        if (isKnownStateEmpty) {
-            this._cachedNewContentSinceEmpty = piecesWithContent;
-        }
-        return piecesWithContent;
-    }
-    getDependedOnCoValues() {
-        if (this._cachedDependentOn) {
-            return this._cachedDependentOn;
-        }
-        else {
-            const dependentOn = this.getDependedOnCoValuesUncached();
-            this._cachedDependentOn = dependentOn;
-            return dependentOn;
-        }
-    }
-    /** @internal */
-    getDependedOnCoValuesUncached() {
-        return this.header.ruleset.type === "group"
-            ? getGroupDependentKeyList(expectGroup(this.getCurrentContent()).keys())
-            : this.header.ruleset.type === "ownedByGroup"
-                ? [
-                    this.header.ruleset.group,
-                    ...new Set([...this.sessionLogs.keys()]
-                        .map((sessionID) => accountOrAgentIDfromSessionID(sessionID))
-                        .filter((session) => isAccountID(session) && session !== this.id)),
-                ]
-                : [];
-    }
-    waitForSync(options) {
-        return this.node.syncManager.waitForSync(this.id, options?.timeout);
-    }
-}
-function getNextKnownSignatureIdx(log, knownStateForSessionID, sentStateForSessionID) {
-    return Object.keys(log.signatureAfter)
-        .map(Number)
-        .sort((a, b) => a - b)
-        .find((idx) => idx >= (sentStateForSessionID ?? knownStateForSessionID ?? -1));
-}
-//# sourceMappingURL=coValueCore.js.map