wowok 2.1.10 → 2.1.13

package/dist/esm/cryptography/signature.js

@@ -1,54 +1,50 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
 import { fromBase64, toBase64 } from "@mysten/bcs";
 import { bcs } from "../bcs/index.js";
 import { parseSerializedPasskeySignature } from "../keypairs/passkey/publickey.js";
 import { parseSerializedKeypairSignature } from "./publickey.js";
-import {
-  SIGNATURE_FLAG_TO_SCHEME,
-  SIGNATURE_SCHEME_TO_FLAG
-} from "./signature-scheme.js";
-function toSerializedSignature({
-  signature,
-  signatureScheme,
-  publicKey
-}) {
-  if (!publicKey) {
-    throw new Error("`publicKey` is required");
-  }
-  const pubKeyBytes = publicKey.toRawBytes();
-  const serializedSignature = new Uint8Array(
-    1 + signature.length + pubKeyBytes.length
-  );
-  serializedSignature.set([SIGNATURE_SCHEME_TO_FLAG[signatureScheme]]);
-  serializedSignature.set(signature, 1);
-  serializedSignature.set(pubKeyBytes, 1 + signature.length);
-  return toBase64(serializedSignature);
+import { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG, } from "./signature-scheme.js";
+/**
+ * Takes in a signature, its associated signing scheme and a public key, then serializes this data
+ */
+export function toSerializedSignature({ signature, signatureScheme, publicKey, }) {
+    if (!publicKey) {
+        throw new Error("`publicKey` is required");
+    }
+    const pubKeyBytes = publicKey.toRawBytes();
+    const serializedSignature = new Uint8Array(1 + signature.length + pubKeyBytes.length);
+    serializedSignature.set([SIGNATURE_SCHEME_TO_FLAG[signatureScheme]]);
+    serializedSignature.set(signature, 1);
+    serializedSignature.set(pubKeyBytes, 1 + signature.length);
+    return toBase64(serializedSignature);
 }
-function parseSerializedSignature(serializedSignature) {
-  const bytes = fromBase64(serializedSignature);
-  const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
-  switch (signatureScheme) {
-    case "Passkey":
-      return parseSerializedPasskeySignature(serializedSignature);
-    case "MultiSig":
-      const multisig = bcs.MultiSig.parse(bytes.slice(1));
-      return {
-        serializedSignature,
-        signatureScheme,
-        multisig,
-        bytes,
-        signature: void 0
-      };
-    case "ZkLogin":
-      throw new Error("ZkLogin signature scheme is not supported");
-    case "ED25519":
-    case "Secp256k1":
-    case "Secp256r1":
-      return parseSerializedKeypairSignature(serializedSignature);
-    default:
-      throw new Error("Unsupported signature scheme");
-  }
+/**
+ * Decodes a serialized signature into its constituent components: the signature scheme, the actual signature, and the public key
+ */
+export function parseSerializedSignature(serializedSignature) {
+    const bytes = fromBase64(serializedSignature);
+    const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
+    switch (signatureScheme) {
+        case "Passkey":
+            return parseSerializedPasskeySignature(serializedSignature);
+        case "MultiSig":
+            const multisig = bcs.MultiSig.parse(bytes.slice(1));
+            return {
+                serializedSignature,
+                signatureScheme,
+                multisig,
+                bytes,
+                signature: undefined,
+            };
+        case "ZkLogin":
+            throw new Error("ZkLogin signature scheme is not supported");
+        case "ED25519":
+        case "Secp256k1":
+        case "Secp256r1":
+            return parseSerializedKeypairSignature(serializedSignature);
+        default:
+            throw new Error("Unsupported signature scheme");
+    }
 }
-export {
-  parseSerializedSignature,
-  toSerializedSignature
-};
+//# sourceMappingURL=signature.js.map

package/dist/esm/cryptography/signature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.js","sourceRoot":"","sources":["../../../src/cryptography/signature.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,sCAAsC;AAEtC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEnD,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAE,+BAA+B,EAAE,MAAM,kCAAkC,CAAC;AAEnF,OAAO,EAAE,+BAA+B,EAAE,MAAM,gBAAgB,CAAC;AAGjE,OAAO,EACN,wBAAwB,EACxB,wBAAwB,GACxB,MAAM,uBAAuB,CAAC;AAa/B;;GAEG;AACH,MAAM,UAAU,qBAAqB,CAAC,EACrC,SAAS,EACT,eAAe,EACf,SAAS,GACgB;IACzB,IAAI,CAAC,SAAS,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,WAAW,GAAG,SAAS,CAAC,UAAU,EAAE,CAAC;IAC3C,MAAM,mBAAmB,GAAG,IAAI,UAAU,CACzC,CAAC,GAAG,SAAS,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CACzC,CAAC;IACF,mBAAmB,CAAC,GAAG,CAAC,CAAC,wBAAwB,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IACrE,mBAAmB,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;IACtC,mBAAmB,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;IAC3D,OAAO,QAAQ,CAAC,mBAAmB,CAAC,CAAC;AACtC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,wBAAwB,CAAC,mBAA2B;IACnE,MAAM,KAAK,GAAG,UAAU,CAAC,mBAAmB,CAAC,CAAC;IAE9C,MAAM,eAAe,GACpB,wBAAwB,CACvB,KAAK,CAAC,CAAC,CAA0C,CACjD,CAAC;IAEH,QAAQ,eAAe,EAAE,CAAC;QACzB,KAAK,SAAS;YACb,OAAO,+BAA+B,CAAC,mBAAmB,CAAC,CAAC;QAC7D,KAAK,UAAU;YACd,MAAM,QAAQ,GAAmB,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YACpE,OAAO;gBACN,mBAAmB;gBACnB,eAAe;gBACf,QAAQ;gBACR,KAAK;gBACL,SAAS,EAAE,SAAS;aACpB,CAAC;QACH,KAAK,SAAS;YACb,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC9D,KAAK,SAAS,CAAC;QACf,KAAK,WAAW,CAAC;QACjB,KAAK,WAAW;YACf,OAAO,+BAA+B,CAAC,mBAAmB,CAAC,CAAC;QAC7D;YACC,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;IAClD,CAAC;AACF,CAAC"}

package/dist/esm/experimental/cache.js

@@ -0,0 +1,61 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+export class ClientCache {
+    #prefix;
+    #cache;
+    constructor({ prefix, cache } = {}) {
+        this.#prefix = prefix ?? [];
+        this.#cache = cache ?? new Map();
+    }
+    read(key, load) {
+        const cacheKey = [this.#prefix, ...key].join(":");
+        if (this.#cache.has(cacheKey)) {
+            return this.#cache.get(cacheKey);
+        }
+        const result = load();
+        this.#cache.set(cacheKey, result);
+        if (typeof result === "object" && result !== null && "then" in result) {
+            return Promise.resolve(result)
+                .then((v) => {
+                this.#cache.set(cacheKey, v);
+                return v;
+            })
+                .catch((err) => {
+                this.#cache.delete(cacheKey);
+                throw err;
+            });
+        }
+        return result;
+    }
+    readSync(key, load) {
+        const cacheKey = [this.#prefix, ...key].join(":");
+        if (this.#cache.has(cacheKey)) {
+            return this.#cache.get(cacheKey);
+        }
+        const result = load();
+        this.#cache.set(cacheKey, result);
+        return result;
+    }
+    clear(prefix) {
+        const prefixKey = [...this.#prefix, ...(prefix ?? [])].join(":");
+        if (!prefixKey) {
+            this.#cache.clear();
+            return;
+        }
+        for (const key of this.#cache.keys()) {
+            if (key.startsWith(prefixKey)) {
+                this.#cache.delete(key);
+            }
+        }
+    }
+    scope(prefix) {
+        return new ClientCache({
+            prefix: [
+                ...this.#prefix,
+                ...(Array.isArray(prefix) ? prefix : [prefix]),
+            ],
+            cache: this.#cache,
+        });
+    }
+}
+//# sourceMappingURL=cache.js.map

package/dist/esm/experimental/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../src/experimental/cache.ts"],"names":[],"mappings":"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"}

package/dist/esm/experimental/client.js

@@ -0,0 +1,23 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+/* eslint-disable @typescript-eslint/ban-types */
+import { ClientCache } from "./cache.js";
+export class Experimental_BaseClient {
+    network;
+    cache;
+    base;
+    constructor({ network, base, cache = base?.cache ?? new ClientCache(), }) {
+        this.network = network;
+        this.base = base ?? this;
+        this.cache = cache;
+    }
+    $extend(...registrations) {
+        return Object.create(this, Object.fromEntries(registrations.map((registration) => {
+            return [
+                registration.name,
+                { value: registration.register(this) },
+            ];
+        })));
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/esm/experimental/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/experimental/client.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,sCAAsC;AACtC,iDAAiD;AAGjD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAQzC,MAAM,OAAgB,uBAAuB;IAC5C,OAAO,CAAsC;IAC7C,KAAK,CAAc;IACnB,IAAI,CAA0B;IAE9B,YAAY,EACX,OAAO,EACP,IAAI,EACJ,KAAK,GAAG,IAAI,EAAE,KAAK,IAAI,IAAI,WAAW,EAAE,GACM;QAC9C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACpB,CAAC;IAID,OAAO,CACN,GAAG,aAA4B;QAE/B,OAAO,MAAM,CAAC,MAAM,CACnB,IAAI,EACJ,MAAM,CAAC,WAAW,CACjB,aAAa,CAAC,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE;YAClC,OAAO;gBACN,YAAY,CAAC,IAAI;gBACjB,EAAE,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;aACtC,CAAC;QACH,CAAC,CAAC,CACF,CAkBD,CAAC;IACH,CAAC;CACD"}

package/dist/esm/experimental/core.js

@@ -0,0 +1,85 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+import { TypeTagSerializer } from "../bcs/type-tag-serializer.js";
+import { deriveDynamicFieldID } from "../utils/dynamic-fields.js";
+import { normalizeStructTag, parseStructTag, WOW_ADDRESS_LENGTH, } from "../utils/sui-types.js";
+import { Experimental_BaseClient } from "./client.js";
+export class Experimental_CoreClient extends Experimental_BaseClient {
+    core = this;
+    constructor(options) {
+        super(options);
+    }
+    async getObject(options) {
+        const { objectId } = options;
+        const { objects: [result], } = await this.getObjects({
+            objectIds: [objectId],
+            signal: options.signal,
+        });
+        if (result instanceof Error) {
+            throw result;
+        }
+        return { object: result };
+    }
+    async getDynamicField(options) {
+        const normalizedNameType = TypeTagSerializer.parseFromStr(options.name.type);
+        const fieldId = deriveDynamicFieldID(options.parentId, normalizedNameType, options.name.bcs);
+        const { objects: [fieldObject], } = await this.getObjects({
+            objectIds: [fieldId],
+            signal: options.signal,
+        });
+        if (fieldObject instanceof Error) {
+            throw fieldObject;
+        }
+        const fieldType = parseStructTag(fieldObject.type);
+        const content = await fieldObject.content;
+        return {
+            dynamicField: {
+                id: fieldObject.id,
+                digest: fieldObject.digest,
+                version: fieldObject.version,
+                type: fieldObject.type,
+                previousTransaction: fieldObject.previousTransaction,
+                name: {
+                    type: typeof fieldType.typeParams[0] === "string"
+                        ? fieldType.typeParams[0]
+                        : normalizeStructTag(fieldType.typeParams[0]),
+                    bcs: options.name.bcs,
+                },
+                value: {
+                    type: typeof fieldType.typeParams[1] === "string"
+                        ? fieldType.typeParams[1]
+                        : normalizeStructTag(fieldType.typeParams[1]),
+                    bcs: content.slice(WOW_ADDRESS_LENGTH + options.name.bcs.length),
+                },
+            },
+        };
+    }
+    async waitForTransaction({ signal, timeout = 60 * 1000, ...input }) {
+        const abortSignal = signal
+            ? AbortSignal.any([AbortSignal.timeout(timeout), signal])
+            : AbortSignal.timeout(timeout);
+        const abortPromise = new Promise((_, reject) => {
+            abortSignal.addEventListener("abort", () => reject(abortSignal.reason));
+        });
+        abortPromise.catch(() => {
+            // Swallow unhandled rejections that might be thrown after early return
+        });
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            abortSignal.throwIfAborted();
+            try {
+                return await this.getTransaction({
+                    ...input,
+                    signal: abortSignal,
+                });
+            }
+            catch {
+                await Promise.race([
+                    new Promise((resolve) => setTimeout(resolve, 2_000)),
+                    abortPromise,
+                ]);
+            }
+        }
+    }
+}
+//# sourceMappingURL=core.js.map

package/dist/esm/experimental/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/experimental/core.ts"],"names":[],"mappings":"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"}

package/dist/esm/experimental/errors.js

@@ -0,0 +1,27 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+export class SuiClientError extends Error {
+}
+export class ObjectError extends SuiClientError {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+    static fromResponse(response, objectId) {
+        switch (response.code) {
+            case "notExists":
+                return new ObjectError(response.code, `Object ${response.object_id} does not exist`);
+            case "dynamicFieldNotFound":
+                return new ObjectError(response.code, `Dynamic field not found for object ${response.parent_object_id}`);
+            case "deleted":
+                return new ObjectError(response.code, `Object ${response.object_id} has been deleted`);
+            case "displayError":
+                return new ObjectError(response.code, `Display error: ${response.error}`);
+            case "unknown":
+            default:
+                return new ObjectError(response.code, `Unknown error while loading object${objectId ? ` ${objectId}` : ""}`);
+        }
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/esm/experimental/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/experimental/errors.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,sCAAsC;AAItC,MAAM,OAAO,cAAe,SAAQ,KAAK;CAAG;AAE5C,MAAM,OAAO,WAAY,SAAQ,cAAc;IAC9C,IAAI,CAAS;IAEb,YAAY,IAAY,EAAE,OAAe;QACxC,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IAClB,CAAC;IAED,MAAM,CAAC,YAAY,CAClB,QAA6B,EAC7B,QAAiB;QAEjB,QAAQ,QAAQ,CAAC,IAAI,EAAE,CAAC;YACvB,KAAK,WAAW;gBACf,OAAO,IAAI,WAAW,CACrB,QAAQ,CAAC,IAAI,EACb,UAAU,QAAQ,CAAC,SAAS,iBAAiB,CAC7C,CAAC;YACH,KAAK,sBAAsB;gBAC1B,OAAO,IAAI,WAAW,CACrB,QAAQ,CAAC,IAAI,EACb,sCAAsC,QAAQ,CAAC,gBAAgB,EAAE,CACjE,CAAC;YACH,KAAK,SAAS;gBACb,OAAO,IAAI,WAAW,CACrB,QAAQ,CAAC,IAAI,EACb,UAAU,QAAQ,CAAC,SAAS,mBAAmB,CAC/C,CAAC;YACH,KAAK,cAAc;gBAClB,OAAO,IAAI,WAAW,CACrB,QAAQ,CAAC,IAAI,EACb,kBAAkB,QAAQ,CAAC,KAAK,EAAE,CAClC,CAAC;YACH,KAAK,SAAS,CAAC;YACf;gBACC,OAAO,IAAI,WAAW,CACrB,QAAQ,CAAC,IAAI,EACb,qCAAqC,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CACrE,CAAC;QACJ,CAAC;IACF,CAAC;CACD"}

package/dist/esm/experimental/index.js

@@ -0,0 +1,8 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+import { Experimental_BaseClient } from "./client.js";
+import { Experimental_CoreClient } from "./core.js";
+export { parseTransactionBcs, parseTransactionEffectsBcs, } from "./transports/utils.js";
+export { Experimental_BaseClient, Experimental_CoreClient, };
+export { ClientCache } from "./cache.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/experimental/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/experimental/index.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,sCAAsC;AAEtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAKtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAMpD,OAAO,EACN,mBAAmB,EACnB,0BAA0B,GAC1B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACN,uBAAuB,EACvB,uBAAuB,GAMvB,CAAC;AAEF,OAAO,EAAE,WAAW,EAA2B,MAAM,YAAY,CAAC"}

package/dist/esm/experimental/persistent-storage.js

@@ -0,0 +1,337 @@
+import { randomBytes } from "crypto";
+import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, openSync, closeSync, constants, } from "fs";
+/**
+ * A persistent storage module that supports multi-process access with file locking mechanism.
+ * This module ensures safe concurrent read/write operations across multiple processes.
+ */
+export class PersistentStorage {
+    filePath;
+    lock;
+    /**
+     * Creates a new PersistentStorage instance.
+     * @param filePath Path to the storage file
+     */
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.lock = new Lock(`${filePath}.lock`);
+        // Create the file if it doesn't exist
+        if (!existsSync(filePath)) {
+            writeFileSync(filePath, JSON.stringify({}));
+        }
+    }
+    /**
+     * Reads the entire storage content.
+     * @returns The parsed storage content
+     */
+    async readAll() {
+        await this.lock.acquireShared();
+        try {
+            const content = readFileSync(this.filePath, "utf8");
+            return JSON.parse(content);
+        }
+        finally {
+            await this.lock.releaseShared();
+        }
+    }
+    /**
+     * Writes data to the storage.
+     * This operation is atomic and safe for multi-process access.
+     * @param data The data to write
+     */
+    async writeAll(data) {
+        await this.lock.acquireExclusive();
+        try {
+            // Write to a temporary file first
+            const tempFilePath = `${this.filePath}.tmp.${randomBytes(8).toString("hex")}`;
+            writeFileSync(tempFilePath, JSON.stringify(data));
+            // Rename is atomic on most file systems
+            renameSync(tempFilePath, this.filePath);
+        }
+        finally {
+            await this.lock.releaseExclusive();
+        }
+    }
+    /**
+     * Updates a specific key in the storage.
+     * This operation is atomic and safe for multi-process access.
+     * @param key The key to update
+     * @param value The new value
+     */
+    async set(key, value) {
+        await this.lock.acquireExclusive();
+        try {
+            const content = readFileSync(this.filePath, "utf8");
+            const data = JSON.parse(content);
+            data[key] = value;
+            const tempFilePath = `${this.filePath}.tmp.${randomBytes(8).toString("hex")}`;
+            writeFileSync(tempFilePath, JSON.stringify(data));
+            renameSync(tempFilePath, this.filePath);
+        }
+        finally {
+            await this.lock.releaseExclusive();
+        }
+    }
+    /**
+     * Gets a specific key from the storage.
+     * @param key The key to get
+     * @returns The value associated with the key
+     */
+    async get(key) {
+        await this.lock.acquireShared();
+        try {
+            const content = readFileSync(this.filePath, "utf8");
+            const data = JSON.parse(content);
+            return data[key];
+        }
+        finally {
+            await this.lock.releaseShared();
+        }
+    }
+    /**
+     * Updates the storage using a transaction function.
+     * This operation is atomic and safe for multi-process access.
+     * @param transactionFn A function that takes the current data and returns updated data
+     */
+    async transaction(transactionFn) {
+        await this.lock.acquireExclusive();
+        try {
+            const content = readFileSync(this.filePath, "utf8");
+            const data = JSON.parse(content);
+            const updatedData = transactionFn(data);
+            const tempFilePath = `${this.filePath}.tmp.${randomBytes(8).toString("hex")}`;
+            writeFileSync(tempFilePath, JSON.stringify(updatedData));
+            renameSync(tempFilePath, this.filePath);
+        }
+        finally {
+            await this.lock.releaseExclusive();
+        }
+    }
+    /**
+     * Clears all data from the storage.
+     */
+    async clear() {
+        await this.lock.acquireExclusive();
+        try {
+            const tempFilePath = `${this.filePath}.tmp.${randomBytes(8).toString("hex")}`;
+            writeFileSync(tempFilePath, JSON.stringify({}));
+            renameSync(tempFilePath, this.filePath);
+        }
+        finally {
+            await this.lock.releaseExclusive();
+        }
+    }
+}
+/**
+ * A file-based lock implementation that supports both shared and exclusive locks.
+ * This ensures safe concurrent access across multiple processes using atomic file operations.
+ */
+export class Lock {
+    lockPath;
+    sharedLockPath;
+    lockFd = null;
+    sharedLockCount = 0;
+    exclusiveLockCount = 0;
+    constructor(lockPath) {
+        this.lockPath = lockPath;
+        this.sharedLockPath = `${lockPath}.shared`;
+    }
+    /**
+     * Acquires a shared lock. Multiple processes can hold a shared lock simultaneously.
+     */
+    async acquireShared() {
+        // If we already hold the exclusive lock, we can upgrade to shared
+        if (this.exclusiveLockCount > 0) {
+            this.sharedLockCount++;
+            this.exclusiveLockCount--;
+            return;
+        }
+        // If we already hold a shared lock, just increment the count
+        if (this.sharedLockCount > 0) {
+            this.sharedLockCount++;
+            return;
+        }
+        // Try to acquire a new shared lock
+        let attempts = 0;
+        const maxAttempts = 100;
+        const delay = 50; // milliseconds
+        while (attempts < maxAttempts) {
+            try {
+                // Check if exclusive lock exists
+                if (existsSync(this.lockPath)) {
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    attempts++;
+                    continue;
+                }
+                // Create shared lock file (atomic operation)
+                writeFileSync(this.sharedLockPath, "");
+                this.sharedLockCount = 1;
+                return;
+            }
+            catch (error) {
+                // If we can't acquire the lock, wait before trying again
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                attempts++;
+            }
+        }
+        throw new Error("Failed to acquire shared lock after multiple attempts");
+    }
+    /**
+     * Acquires an exclusive lock. Only one process can hold an exclusive lock at a time.
+     */
+    async acquireExclusive() {
+        // If we already hold the exclusive lock, just increment the count
+        if (this.exclusiveLockCount > 0) {
+            this.exclusiveLockCount++;
+            return;
+        }
+        // Try to acquire a new exclusive lock
+        let attempts = 0;
+        const maxAttempts = 100;
+        const delay = 50; // milliseconds
+        while (attempts < maxAttempts) {
+            try {
+                // Check if shared lock exists
+                if (existsSync(this.sharedLockPath)) {
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    attempts++;
+                    continue;
+                }
+                // Create exclusive lock file (atomic operation)
+                const fd = openSync(this.lockPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o644);
+                closeSync(fd);
+                this.exclusiveLockCount = 1;
+                return;
+            }
+            catch (error) {
+                // If we can't acquire the lock, wait before trying again
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                attempts++;
+            }
+        }
+        throw new Error("Failed to acquire exclusive lock after multiple attempts");
+    }
+    /**
+     * Releases a shared lock.
+     */
+    async releaseShared() {
+        if (this.sharedLockCount === 0) {
+            throw new Error("No shared lock to release");
+        }
+        this.sharedLockCount--;
+        // If this was the last shared lock, release the file lock
+        if (this.sharedLockCount === 0) {
+            try {
+                unlinkSync(this.sharedLockPath);
+            }
+            catch (error) {
+                // Ignore errors if the file doesn't exist
+            }
+        }
+    }
+    /**
+     * Releases an exclusive lock.
+     */
+    async releaseExclusive() {
+        if (this.exclusiveLockCount === 0) {
+            throw new Error("No exclusive lock to release");
+        }
+        this.exclusiveLockCount--;
+        // If this was the last exclusive lock, release the file lock
+        if (this.exclusiveLockCount === 0) {
+            try {
+                unlinkSync(this.lockPath);
+            }
+            catch (error) {
+                // Ignore errors if the file doesn't exist
+            }
+        }
+    }
+}
+/**
+ * A simple key-value store that supports multi-process access and persistence.
+ * This is a higher-level API built on top of PersistentStorage for easier use.
+ */
+export class MultiProcessKVStore {
+    storage;
+    /**
+     * Creates a new MultiProcessKVStore instance.
+     * @param filePath Path to the storage file
+     */
+    constructor(filePath) {
+        this.storage = new PersistentStorage(filePath);
+    }
+    /**
+     * Gets a value by key.
+     * @param key The key to get
+     * @returns The value associated with the key, or undefined if not found
+     */
+    async get(key) {
+        return this.storage.get(key);
+    }
+    /**
+     * Sets a value by key.
+     * @param key The key to set
+     * @param value The value to set
+     */
+    async set(key, value) {
+        return this.storage.set(key, value);
+    }
+    /**
+     * Deletes a key-value pair.
+     * @param key The key to delete
+     */
+    async delete(key) {
+        return this.storage.transaction((data) => {
+            delete data[key];
+            return data;
+        });
+    }
+    /**
+     * Checks if a key exists.
+     * @param key The key to check
+     * @returns True if the key exists, false otherwise
+     */
+    async has(key) {
+        const value = await this.storage.get(key);
+        return value !== undefined;
+    }
+    /**
+     * Gets all keys.
+     * @returns An array of all keys
+     */
+    async keys() {
+        const data = await this.storage.readAll();
+        return Object.keys(data);
+    }
+    /**
+     * Gets all values.
+     * @returns An array of all values
+     */
+    async values() {
+        const data = await this.storage.readAll();
+        return Object.values(data);
+    }
+    /**
+     * Gets all key-value pairs.
+     * @returns An array of all key-value pairs
+     */
+    async entries() {
+        const data = await this.storage.readAll();
+        return Object.entries(data);
+    }
+    /**
+     * Clears all key-value pairs.
+     */
+    async clear() {
+        return this.storage.clear();
+    }
+    /**
+     * Gets the number of key-value pairs.
+     * @returns The number of key-value pairs
+     */
+    async size() {
+        const data = await this.storage.readAll();
+        return Object.keys(data).length;
+    }
+}
+//# sourceMappingURL=persistent-storage.js.map