@snaha/swarm-id 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Swarm ID Library
+ *
+ * A TypeScript library for integrating Swarm ID authentication
+ * and Bee API operations into dApps.
+ */
+export { SwarmIdClient } from "./swarm-id-client";
+export { SwarmIdProxy, initProxy } from "./swarm-id-proxy";
+export { deriveSecret, deriveIdentityKey, generateMasterKey, hexToUint8Array, uint8ArrayToHex, verifySecret, utils, } from "./utils/key-derivation";
+export { hexAddress } from "./utils/hex";
+export { initializeBatchUtilization, calculateUtilizationUpdate, updateAfterWrite, saveUtilizationState, loadUtilizationState, calculateUtilization, toBucket, assignChunksToBuckets, serializeUint32Array, deserializeUint32Array, splitIntoChunks, reconstructFromChunks, calculateMaxSlotsPerBucket, hasBucketCapacity, createStamper, prepareBucketState, UtilizationAwareStamper, NUM_BUCKETS, BUCKET_DEPTH, UTILIZATION_SLOTS_PER_BUCKET, DATA_COUNTER_START, CHUNK_SIZE, DEFAULT_BATCH_DEPTH, } from "./utils/batch-utilization";
+export { UtilizationStoreDB, evictOldEntries, calculateContentHash, } from "./storage/utilization-store";
+export type { ChunkCacheEntry, BatchMetadata, CacheEvictionPolicy, } from "./storage/utilization-store";
+export { DebouncedUtilizationUploader } from "./storage/debounced-uploader";
+export { VersionedStorageManager, LocalStorageAdapter, MemoryStorageAdapter, createLocalStorageManager, createMemoryStorageManager, createZodParser, VersionedStorageSchema, } from "./utils/versioned-storage";
+export { createAccountsStorageManager, createIdentitiesStorageManager, createConnectedAppsStorageManager, createPostageStampsStorageManager, createNetworkSettingsStorageManager, serializeAccount, serializeIdentity, serializeConnectedApp, serializePostageStamp, serializeNetworkSettings, disconnectApp, } from "./utils/storage-managers";
+export type { NetworkSettingsStorageManager } from "./utils/storage-managers";
+export { serializeAccountStateSnapshot, deserializeAccountStateSnapshot, AccountStateSnapshotSchemaV1, } from "./utils/account-state-snapshot";
+export type { AccountStateSnapshot, AccountStateSnapshotResult, } from "./utils/account-state-snapshot";
+export { deriveBackupEncryptionKey, encryptBackupPayload, decryptBackupPayload, buildBackupHeader, createEncryptedExport, decryptEncryptedExport, parseEncryptedExportHeader, PasskeyBackupHeaderSchemaV1, EthereumBackupHeaderSchemaV1, AgentBackupHeaderSchemaV1, EncryptedSwarmIdExportSchemaV1, } from "./utils/backup-encryption";
+export type { PasskeyBackupHeader, EthereumBackupHeader, AgentBackupHeader, EncryptedSwarmIdExport, BackupHeaderWithoutCiphertext, ParseHeaderResult, } from "./utils/backup-encryption";
+export { EpochIndex, SyncEpochFinder, AsyncEpochFinder, BasicEpochUpdater, lca, next, createSyncEpochFinder, createAsyncEpochFinder, createEpochUpdater, createEpochFinder, // deprecated alias for createSyncEpochFinder
+MAX_LEVEL, } from "./proxy/feeds/epochs";
+export { deriveAccountBackupKey, deriveAccountSwarmEncryptionKey, backupKeyToPrivateKey, serializeAccountState, deserializeAccountState, createSyncAccount, ACCOUNT_SYNC_TOPIC_PREFIX, restoreAccountFromSwarm, } from "./sync";
+export type { SyncResult, SyncAccountOptions, SyncAccountFunction, AccountsStoreInterface, IdentitiesStoreInterface, ConnectedAppsStoreInterface, PostageStampsStoreInterface, StamperOptions, FlushableStamper, RestoreAccountResult, } from "./sync";
+export type { ClientOptions, AuthStatus, ButtonStyles, UploadResult, FileData, PostageBatch, UploadOptions, ActUploadOptions, SOCReader, SOCWriter, SingleOwnerChunk, SocUploadResult, SocRawUploadResult, FeedReaderOptions, FeedWriterOptions, FeedReader, FeedWriter, SequentialFeedReaderOptions, SequentialFeedWriterOptions, SequentialFeedUpdateOptions, SequentialFeedUploadOptions, SequentialFeedPayloadResult, SequentialFeedReferenceResult, SequentialFeedUploadResult, SequentialFeedReader, SequentialFeedWriter, UploadProgress, RequestOptions, DownloadOptions, ParentToIframeMessage, IframeToParentMessage, PopupToIframeMessage, SetSecretMessage, AuthData, AppMetadata, ButtonConfig, ConnectionInfo, ActUploadDataMessage, ActDownloadDataMessage, ActAddGranteesMessage, ActRevokeGranteesMessage, ActGetGranteesMessage, ActUploadDataResponseMessage, ActDownloadDataResponseMessage, ActAddGranteesResponseMessage, ActRevokeGranteesResponseMessage, ActGetGranteesResponseMessage, SocUploadMessage, SocRawUploadMessage, SocDownloadMessage, SocRawDownloadMessage, SocGetOwnerMessage, EpochFeedDownloadReferenceMessage, EpochFeedUploadReferenceMessage, FeedGetOwnerMessage, SequentialFeedGetOwnerMessage, SequentialFeedDownloadPayloadMessage, SequentialFeedDownloadRawPayloadMessage, SequentialFeedDownloadReferenceMessage, SequentialFeedUploadPayloadMessage, SequentialFeedUploadRawPayloadMessage, SequentialFeedUploadReferenceMessage, SocUploadResponseMessage, SocRawUploadResponseMessage, SocDownloadResponseMessage, SocRawDownloadResponseMessage, SocGetOwnerResponseMessage, EpochFeedDownloadReferenceResponseMessage, EpochFeedUploadReferenceResponseMessage, FeedGetOwnerResponseMessage, SequentialFeedGetOwnerResponseMessage, SequentialFeedDownloadPayloadResponseMessage, SequentialFeedDownloadRawPayloadResponseMessage, SequentialFeedDownloadReferenceResponseMessage, SequentialFeedUploadPayloadResponseMessage, SequentialFeedUploadRawPayloadResponseMessage, SequentialFeedUploadReferenceResponseMessage, } from "./types";
+export type { Account, PasskeyAccount, EthereumAccount, AgentAccount, Identity, ConnectedApp, PostageStamp, AccountMetadata, NetworkSettings, } from "./schemas";
+export { DEFAULT_BEE_NODE_URL, DEFAULT_GNOSIS_RPC_URL, NetworkSettingsSchemaV1, } from "./schemas";
+export { ReferenceSchema, BatchIdSchema, AddressSchema, PrivateKeySchema, EncryptionKeySchema, IdentifierSchema, SignatureSchema, TimestampSchema, FeedIndexSchema, } from "./schemas";
+export type { Reference, BatchId, Address, PrivateKey, Identifier, Signature, Timestamp, FeedIndex, } from "./schemas";
+export type { BatchUtilizationState, ChunkWithBucket, UtilizationUpdate, } from "./utils/batch-utilization";
+export type { VersionedStorage, StorageAdapter, VersionParser, Serializer, VersionedStorageOptions, } from "./utils/versioned-storage";
+export type { Epoch, EpochFinder, EpochUpdater, EpochFeedOptions, EpochFeedWriterOptions, EpochLookupResult, } from "./proxy/feeds/epochs";
+export { UploadOptionsSchema, ActUploadOptionsSchema, RequestOptionsSchema, DownloadOptionsSchema, UploadResultSchema, FileDataSchema, PostageBatchSchema, AuthStatusSchema, ButtonStylesSchema, ParentToIframeMessageSchema, IframeToParentMessageSchema, PopupToIframeMessageSchema, SetSecretMessageSchema, AuthDataSchema, ActUploadDataMessageSchema, ActDownloadDataMessageSchema, ActAddGranteesMessageSchema, ActRevokeGranteesMessageSchema, ActGetGranteesMessageSchema, ActUploadDataResponseMessageSchema, ActDownloadDataResponseMessageSchema, ActAddGranteesResponseMessageSchema, ActRevokeGranteesResponseMessageSchema, ActGetGranteesResponseMessageSchema, } from "./types";
+export { downloadDataWithChunkAPI } from "./proxy/download-data";
+export { createActForContent, decryptActReference, addGranteesToAct, revokeGranteesFromAct, getGranteesFromAct, parseCompressedPublicKey, publicKeyFromPrivate, compressPublicKey, publicKeyFromCompressed, } from "./proxy/act";
+export type { ActEntry } from "./proxy/act";
+export { SWARM_SECRET_PREFIX, STORAGE_CHALLENGE_KEY } from "./types";
+export { buildAuthUrl } from "./utils/url";
+export { buildBzzCompatibleManifest, buildBzzManifestNode, buildMinimalManifest, extractReferenceFromManifest, extractEntryFromManifest, extractContentFromFlatManifest, padPayloadForSOCDetection, MAX_PADDED_PAYLOAD_SIZE, } from "./proxy/manifest-builder";
+export type { BzzCompatibleManifestResult, BzzManifestNodeResult, } from "./proxy/manifest-builder";
+export { saveMantarayTreeRecursively, loadMantarayTreeWithChunkAPI, } from "./proxy/mantaray";
+export type { UploadCallback } from "./proxy/mantaray";
+export { SECOND, MINUTE, HOUR, DAY, DEFAULT_SESSION_DURATION, } from "./utils/constants";
+export { calculateTTLSeconds, formatTTL, getBlockTimestamp, calculateExpiryTimestamp, fetchSwarmPrice, SWARMSCAN_STATS_URL, GNOSIS_BLOCK_TIME, } from "./utils/ttl";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/proxy/act/act.d.ts

@@ -0,0 +1,78 @@
+/**
+ * ACT (Access Control Tries) Data Structure
+ *
+ * Bee-compatible Simple Manifest (JSON) format for storing ACT entries.
+ * The ACT stores lookup key -> encrypted access key mappings.
+ *
+ * Bee's ACT format is a Simple Manifest with structure:
+ * {
+ *   "entries": {
+ *     "<lookupKeyHex>": {
+ *       "reference": "<encryptedAccessKeyHex>",
+ *       "metadata": {}
+ *     }
+ *   }
+ * }
+ *
+ * All other data (publisher public key, encrypted reference, grantee list)
+ * is stored separately and passed out-of-band.
+ */
+/**
+ * Single ACT entry: lookup key + encrypted access key
+ */
+export interface ActEntry {
+    lookupKey: Uint8Array;
+    encryptedAccessKey: Uint8Array;
+}
+/**
+ * Serialize ACT entries to JSON bytes (Bee-compatible Simple Manifest format)
+ *
+ * @param entries - Array of ACT entries
+ * @returns JSON-encoded bytes
+ */
+export declare function serializeAct(entries: ActEntry[]): Uint8Array;
+/**
+ * Deserialize ACT entries from JSON bytes (Bee-compatible Simple Manifest format)
+ *
+ * @param data - JSON-encoded bytes
+ * @returns Array of ACT entries
+ */
+export declare function deserializeAct(data: Uint8Array): ActEntry[];
+/**
+ * Find an ACT entry by lookup key
+ *
+ * @param entries - Array of ACT entries
+ * @param lookupKey - 32-byte lookup key
+ * @returns The entry if found, undefined otherwise
+ */
+export declare function findEntryByLookupKey(entries: ActEntry[], lookupKey: Uint8Array): ActEntry | undefined;
+/**
+ * Check if two public keys are equal
+ */
+export declare function publicKeysEqual(a: {
+    x: Uint8Array;
+    y: Uint8Array;
+}, b: {
+    x: Uint8Array;
+    y: Uint8Array;
+}): boolean;
+/**
+ * Helper to collect all ACT entries from JSON-encoded ACT data
+ *
+ * This is a convenience function for working with JSON ACT data directly from storage.
+ *
+ * @param actData - JSON-encoded ACT data from storage
+ * @returns Array of ACT entries
+ */
+export declare function collectActEntriesFromJson(actData: Uint8Array): ActEntry[];
+/**
+ * Helper to find an ACT entry by lookup key from JSON-encoded ACT data
+ *
+ * This is a convenience function for working with JSON ACT data directly from storage.
+ *
+ * @param actData - JSON-encoded ACT data from storage
+ * @param lookupKey - 32-byte lookup key to search for
+ * @returns The encrypted access key if found, undefined otherwise
+ */
+export declare function findActEntryByKey(actData: Uint8Array, lookupKey: Uint8Array): Uint8Array | undefined;
+//# sourceMappingURL=act.d.ts.map

package/dist/proxy/act/act.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"act.d.ts","sourceRoot":"","sources":["../../../src/proxy/act/act.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,UAAU,CAAA;IACrB,kBAAkB,EAAE,UAAU,CAAA;CAC/B;AAiBD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,UAAU,CAiB5D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,EAAE,CAc3D;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,QAAQ,EAAE,EACnB,SAAS,EAAE,UAAU,GACpB,QAAQ,GAAG,SAAS,CAQtB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE;IAAE,CAAC,EAAE,UAAU,CAAC;IAAC,CAAC,EAAE,UAAU,CAAA;CAAE,EACnC,CAAC,EAAE;IAAE,CAAC,EAAE,UAAU,CAAC;IAAC,CAAC,EAAE,UAAU,CAAA;CAAE,GAClC,OAAO,CAST;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,UAAU,GAAG,QAAQ,EAAE,CAEzE;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,UAAU,GACpB,UAAU,GAAG,SAAS,CAIxB"}

package/dist/proxy/act/crypto.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Derive public key from private key
+ */
+export declare function publicKeyFromPrivate(privKey: Uint8Array): {
+    x: Uint8Array;
+    y: Uint8Array;
+};
+/**
+ * Compute ECDH shared secret (x-coordinate of shared point)
+ */
+export declare function ecdhSharedSecret(privKey: Uint8Array, pubX: Uint8Array, pubY: Uint8Array): Uint8Array;
+/**
+ * Derive lookup key and access key decryption key from ECDH shared secret
+ */
+export declare function deriveKeys(privKey: Uint8Array, pubX: Uint8Array, pubY: Uint8Array): {
+    lookupKey: Uint8Array;
+    accessKeyDecryptionKey: Uint8Array;
+};
+/**
+ * Counter-mode encryption/decryption
+ * Matches Bee's Go implementation (bee/pkg/encryption/encryption.go:134-168)
+ * For each 32-byte block i: data[i] XOR keccak256(keccak256(key || uint32LE(i)))
+ */
+export declare function counterModeEncrypt(data: Uint8Array, key: Uint8Array): Uint8Array;
+/**
+ * Counter-mode decryption (symmetric with encryption)
+ */
+export declare const counterModeDecrypt: typeof counterModeEncrypt;
+/**
+ * Parse compressed public key (33 bytes) to uncompressed coordinates
+ */
+export declare function publicKeyFromCompressed(compressed: Uint8Array): {
+    x: Uint8Array;
+    y: Uint8Array;
+};
+/**
+ * Compress public key to 33 bytes
+ */
+export declare function compressPublicKey(x: Uint8Array, y: Uint8Array): Uint8Array;
+/**
+ * Generate a random 32-byte key using crypto.getRandomValues
+ */
+export declare function generateRandomKey(): Uint8Array;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/proxy/act/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../src/proxy/act/crypto.ts"],"names":[],"mappings":"AA2JA;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,UAAU,GAAG;IACzD,CAAC,EAAE,UAAU,CAAA;IACb,CAAC,EAAE,UAAU,CAAA;CACd,CAgBA;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,GACf,UAAU,CAuBZ;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,GACf;IAAE,SAAS,EAAE,UAAU,CAAC;IAAC,sBAAsB,EAAE,UAAU,CAAA;CAAE,CAgB/D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,UAAU,GACd,UAAU,CAmCZ;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,2BAAqB,CAAA;AAEpD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,UAAU,GAAG;IAC/D,CAAC,EAAE,UAAU,CAAA;IACb,CAAC,EAAE,UAAU,CAAA;CACd,CAiCA;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU,CAkB1E;AAoBD;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,UAAU,CAI9C"}

package/dist/proxy/act/grantee-list.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Public key in uncompressed format
+ */
+export interface UncompressedPublicKey {
+    x: Uint8Array;
+    y: Uint8Array;
+}
+/**
+ * Derive the encryption key for the grantee list
+ *
+ * This is different from the legacy format key derivation.
+ * The grantee list is encrypted with a key derived from the publisher's private key.
+ */
+export declare function deriveGranteeListEncryptionKey(publisherPrivKey: Uint8Array): Uint8Array;
+/**
+ * Serialize grantee list to Bee-compatible format
+ *
+ * Bee stores grantees as concatenated 65-byte uncompressed secp256k1 public keys.
+ * Format: [0x04 || X (32 bytes) || Y (32 bytes)] for each key
+ *
+ * @param grantees - Array of public keys with x and y coordinates
+ * @returns Serialized grantee list
+ */
+export declare function serializeGranteeList(grantees: UncompressedPublicKey[]): Uint8Array;
+/**
+ * Deserialize grantee list from Bee-compatible format
+ *
+ * @param data - Serialized grantee list (concatenated 65-byte uncompressed keys)
+ * @returns Array of public keys with x and y coordinates
+ */
+export declare function deserializeGranteeList(data: Uint8Array): UncompressedPublicKey[];
+/**
+ * Encrypt a serialized grantee list for storage
+ *
+ * @param granteeList - Serialized grantee list
+ * @param publisherPrivKey - Publisher's private key for key derivation
+ * @returns Encrypted grantee list
+ */
+export declare function encryptGranteeList(granteeList: Uint8Array, publisherPrivKey: Uint8Array): Uint8Array;
+/**
+ * Decrypt an encrypted grantee list
+ *
+ * @param encryptedList - Encrypted grantee list
+ * @param publisherPrivKey - Publisher's private key for key derivation
+ * @returns Decrypted serialized grantee list
+ */
+export declare function decryptGranteeList(encryptedList: Uint8Array, publisherPrivKey: Uint8Array): Uint8Array;
+/**
+ * Serialize and encrypt grantee list in one step
+ *
+ * @param grantees - Array of public keys
+ * @param publisherPrivKey - Publisher's private key
+ * @returns Encrypted serialized grantee list ready for upload
+ */
+export declare function serializeAndEncryptGranteeList(grantees: UncompressedPublicKey[], publisherPrivKey: Uint8Array): Uint8Array;
+/**
+ * Decrypt and deserialize grantee list in one step
+ *
+ * @param encryptedList - Encrypted serialized grantee list
+ * @param publisherPrivKey - Publisher's private key
+ * @returns Array of public keys
+ */
+export declare function decryptAndDeserializeGranteeList(encryptedList: Uint8Array, publisherPrivKey: Uint8Array): UncompressedPublicKey[];
+/**
+ * Add grantees to an existing encrypted grantee list
+ *
+ * @param encryptedList - Existing encrypted grantee list
+ * @param newGrantees - New grantees to add
+ * @param publisherPrivKey - Publisher's private key
+ * @returns New encrypted grantee list with added grantees
+ */
+export declare function addToGranteeList(encryptedList: Uint8Array, newGrantees: UncompressedPublicKey[], publisherPrivKey: Uint8Array): Uint8Array;
+/**
+ * Remove grantees from an existing encrypted grantee list
+ *
+ * @param encryptedList - Existing encrypted grantee list
+ * @param revokeGrantees - Grantees to remove
+ * @param publisherPrivKey - Publisher's private key
+ * @returns New encrypted grantee list with removed grantees
+ */
+export declare function removeFromGranteeList(encryptedList: Uint8Array, revokeGrantees: UncompressedPublicKey[], publisherPrivKey: Uint8Array): Uint8Array;
+//# sourceMappingURL=grantee-list.d.ts.map

package/dist/proxy/act/grantee-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grantee-list.d.ts","sourceRoot":"","sources":["../../../src/proxy/act/grantee-list.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,CAAC,EAAE,UAAU,CAAA;IACb,CAAC,EAAE,UAAU,CAAA;CACd;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,gBAAgB,EAAE,UAAU,GAC3B,UAAU,CAGZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,qBAAqB,EAAE,GAChC,UAAU,CAiBZ;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,UAAU,GACf,qBAAqB,EAAE,CAqCzB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,UAAU,EACvB,gBAAgB,EAAE,UAAU,GAC3B,UAAU,CAGZ;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,UAAU,EACzB,gBAAgB,EAAE,UAAU,GAC3B,UAAU,CAGZ;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,qBAAqB,EAAE,EACjC,gBAAgB,EAAE,UAAU,GAC3B,UAAU,CAGZ;AAED;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC9C,aAAa,EAAE,UAAU,EACzB,gBAAgB,EAAE,UAAU,GAC3B,qBAAqB,EAAE,CAGzB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,UAAU,EACzB,WAAW,EAAE,qBAAqB,EAAE,EACpC,gBAAgB,EAAE,UAAU,GAC3B,UAAU,CAYZ;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,UAAU,EACzB,cAAc,EAAE,qBAAqB,EAAE,EACvC,gBAAgB,EAAE,UAAU,GAC3B,UAAU,CAcZ"}

package/dist/proxy/act/history.d.ts

@@ -0,0 +1,183 @@
+/**
+ * ACT History Management
+ *
+ * This module provides timestamped versioning of ACT entries, matching Bee's
+ * approach to tracking ACT versions over time.
+ *
+ * Key concepts:
+ * - Each ACT update creates a new history entry
+ * - Entries are keyed by reversed timestamp (MaxInt64 - timestamp)
+ * - History enables looking up ACT state at any point in time
+ * - Encrypted grantee list reference is stored in metadata
+ *
+ * This implementation uses the MantarayNode class from bee-js to produce
+ * Bee-compatible binary manifests with the proper version hash header.
+ *
+ * IMPORTANT: Mantaray manifests are hierarchical - each child node must be
+ * uploaded separately to Swarm. The root node references children by their
+ * content addresses (selfAddress). To read entries, all child nodes must be
+ * loaded recursively.
+ */
+import { MantarayNode } from "@ethersphere/bee-js";
+/**
+ * Single history entry metadata
+ */
+export interface HistoryEntryMetadata {
+    actReference: string;
+    encryptedGranteeListRef?: string;
+}
+/**
+ * History entry with timestamp
+ */
+export interface HistoryEntry {
+    timestamp: number;
+    metadata: HistoryEntryMetadata;
+}
+/**
+ * Result of serializing a history tree
+ */
+export interface SerializedHistoryTree {
+    blobs: Map<string, Uint8Array>;
+    rootReference: string;
+}
+/**
+ * Result of saving a history tree
+ */
+export interface SaveHistoryTreeResult {
+    rootReference: string;
+    tagUid?: number;
+}
+/**
+ * Calculate reversed timestamp key for history lookup
+ *
+ * Bee uses reversed timestamps so that the latest entry sorts first.
+ * Key = MaxInt64 - timestamp
+ *
+ * @param timestamp - Unix timestamp in seconds
+ * @returns Reversed timestamp as string (for use as path)
+ */
+export declare function calculateReversedTimestamp(timestamp: number): string;
+/**
+ * Calculate original timestamp from reversed key
+ *
+ * @param reversedKey - Reversed timestamp string
+ * @returns Original Unix timestamp in seconds
+ */
+export declare function calculateOriginalTimestamp(reversedKey: string): number;
+/**
+ * Create a new empty history manifest using MantarayNode
+ */
+export declare function createHistoryManifest(): MantarayNode;
+/**
+ * Add an entry to the history manifest
+ *
+ * This mutates the manifest in place by adding a fork.
+ *
+ * @param manifest - Existing history manifest (MantarayNode)
+ * @param timestamp - Unix timestamp for this entry
+ * @param actReference - Reference to the ACT manifest (hex string)
+ * @param encryptedGranteeListRef - Optional reference to encrypted grantee list (hex string)
+ */
+export declare function addHistoryEntry(manifest: MantarayNode, timestamp: number, actReference: string, encryptedGranteeListRef?: string): void;
+/**
+ * Get the latest history entry (most recent timestamp)
+ *
+ * Since keys are reversed timestamps, the smallest key is the latest entry.
+ * NOTE: This requires the manifest to have been loaded with loadRecursively()
+ * or to have been populated locally with addHistoryEntry().
+ *
+ * @param manifest - History manifest (MantarayNode)
+ * @returns Latest entry with its timestamp, or undefined if empty
+ */
+export declare function getLatestEntry(manifest: MantarayNode): HistoryEntry | undefined;
+/**
+ * Get entry at or before a specific timestamp
+ *
+ * This finds the ACT state that was valid at the given timestamp.
+ * NOTE: This requires the manifest to have been loaded with loadRecursively().
+ *
+ * @param manifest - History manifest (MantarayNode)
+ * @param timestamp - Target timestamp
+ * @returns Entry at or before timestamp, or undefined if none exists
+ */
+export declare function getEntryAtTimestamp(manifest: MantarayNode, timestamp: number): HistoryEntry | undefined;
+/**
+ * Get all history entries sorted by timestamp (newest first)
+ *
+ * @param manifest - History manifest (MantarayNode)
+ * @returns Array of entries sorted newest first
+ */
+export declare function getAllEntries(manifest: MantarayNode): HistoryEntry[];
+/**
+ * Serialize the entire history manifest tree to individual blobs
+ *
+ * Mantaray manifests are hierarchical - each node is stored at its content
+ * address. This function returns all blobs that need to be uploaded, keyed
+ * by their content addresses.
+ *
+ * @deprecated Use saveHistoryTreeRecursively instead which uploads bottom-up
+ * and uses Bee's actual returned references to avoid address mismatches.
+ *
+ * @param manifest - History manifest (MantarayNode)
+ * @returns Map of content address -> serialized data, plus root reference
+ */
+export declare function serializeHistoryTree(manifest: MantarayNode): Promise<SerializedHistoryTree>;
+/**
+ * Upload callback type for saveHistoryTreeRecursively
+ */
+export type UploadCallback = (data: Uint8Array, isRoot: boolean) => Promise<{
+    reference: string;
+    tagUid?: number;
+}>;
+/**
+ * Save the entire history manifest tree by uploading bottom-up
+ *
+ * This function uploads nodes in the correct order (children before parents)
+ * and uses Bee's actual returned references to update selfAddress before
+ * marshaling parents. This avoids address mismatches between local hash
+ * computation and Bee's storage.
+ *
+ * The flow mirrors MantarayNode.saveRecursively() from bee-js:
+ * 1. Recursively save all child forks first
+ * 2. Marshal this node (which uses children's updated selfAddress)
+ * 3. Upload and set selfAddress from Bee's response
+ *
+ * @param manifest - History manifest (MantarayNode)
+ * @param uploadFn - Callback to upload data, returns reference from Bee
+ * @returns Root reference from Bee and optional tag UID
+ */
+export declare function saveHistoryTreeRecursively(manifest: MantarayNode, uploadFn: UploadCallback): Promise<SaveHistoryTreeResult>;
+/**
+ * Serialize history manifest root to Mantaray binary format
+ *
+ * @deprecated Use serializeHistoryTree for proper Mantaray serialization
+ * @param manifest - History manifest (MantarayNode)
+ * @returns Serialized root manifest as Uint8Array
+ */
+export declare function serializeHistory(manifest: MantarayNode): Promise<Uint8Array>;
+/**
+ * Deserialize history manifest from Mantaray binary format
+ *
+ * NOTE: After deserialization, call loadRecursively() or manually load
+ * child nodes to populate targetAddress for entries.
+ *
+ * @param data - Serialized manifest
+ * @param selfAddress - The reference/address of the manifest (32 bytes as Uint8Array)
+ * @returns Parsed history manifest (MantarayNode)
+ */
+export declare function deserializeHistory(data: Uint8Array, selfAddress: Uint8Array): MantarayNode;
+/**
+ * Load child node data into a deserialized manifest
+ *
+ * After deserializing the root node, this function loads all child node data
+ * so that targetAddress is available for each entry.
+ *
+ * @param manifest - Deserialized root manifest
+ * @param loadData - Callback to load data for a given reference
+ */
+export declare function loadHistoryEntries(manifest: MantarayNode, loadData: (reference: string) => Promise<Uint8Array>): Promise<void>;
+/**
+ * Get current Unix timestamp in seconds
+ */
+export declare function getCurrentTimestamp(): number;
+//# sourceMappingURL=history.d.ts.map

package/dist/proxy/act/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../src/proxy/act/history.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAclD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAA;IACpB,uBAAuB,CAAC,EAAE,MAAM,CAAA;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,oBAAoB,CAAA;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IAC9B,aAAa,EAAE,MAAM,CAAA;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGpE;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAItE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,YAAY,CAEpD;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,YAAY,EACtB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,uBAAuB,CAAC,EAAE,MAAM,GAC/B,IAAI,CAON;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,YAAY,GACrB,YAAY,GAAG,SAAS,CAkB1B;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,YAAY,EACtB,SAAS,EAAE,MAAM,GAChB,YAAY,GAAG,SAAS,CAoC1B;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,EAAE,CAcpE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,qBAAqB,CAAC,CAoBhC;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAC3B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,OAAO,KACZ,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,qBAAqB,CAAC,CA4BhC;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,UAAU,CAAC,CAErB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,UAAU,EAChB,WAAW,EAAE,UAAU,GACtB,YAAY,CAEd;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,GACnD,OAAO,CAAC,IAAI,CAAC,CAiCf;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAQ5C"}

package/dist/proxy/act/index.d.ts

@@ -0,0 +1,104 @@
+/**
+ * ACT (Access Control Tries) - Bee-Compatible Implementation
+ *
+ * This module provides client-side ACT operations with Bee-compatible
+ * Simple Manifest (JSON) format:
+ * - ACT manifest (JSON with lookup key -> encrypted access key mappings)
+ * - Encrypted grantee list (stored separately)
+ * - History manifest (tracks ACT versions over time)
+ */
+import type { Bee, BeeRequestOptions, UploadOptions } from "@ethersphere/bee-js";
+import type { UploadContext, UploadProgress } from "../types";
+type ActUploadOptions = UploadOptions & {
+    beeCompatible?: boolean;
+};
+/**
+ * Result of ACT upload operation
+ */
+export interface ActUploadResult {
+    encryptedReference: string;
+    historyReference: string;
+    granteeListReference: string;
+    publisherPubKey: string;
+    actReference: string;
+    tagUid?: number;
+}
+/**
+ * Result of ACT grantee modification
+ */
+export interface ActGranteeModifyResult {
+    historyReference: string;
+    granteeListReference: string;
+    actReference: string;
+    tagUid?: number;
+}
+/**
+ * Result of ACT revocation (includes new encrypted reference due to key rotation)
+ */
+export interface ActRevocationResult extends ActGranteeModifyResult {
+    encryptedReference: string;
+}
+/**
+ * Create an ACT-protected upload
+ *
+ * This creates:
+ * 1. ACT manifest (JSON Simple Manifest with lookup key -> encrypted access key mappings)
+ * 2. Encrypted grantee list (for publisher management)
+ * 3. History manifest (tracks ACT versions over time)
+ *
+ * @param context - Upload context with bee and stamper
+ * @param contentReference - The reference to protect (32 or 64 bytes)
+ * @param publisherPrivateKey - Publisher's private key (32 bytes)
+ * @param granteePublicKeys - Array of grantee public keys
+ * @param options - Upload options
+ * @param requestOptions - Bee request options
+ * @param onProgress - Progress callback
+ * @returns Multiple references for ACT
+ */
+export declare function createActForContent(context: UploadContext, contentReference: Uint8Array, publisherPrivateKey: Uint8Array, granteePublicKeys: Array<{
+    x: Uint8Array;
+    y: Uint8Array;
+}>, options?: ActUploadOptions, requestOptions?: BeeRequestOptions, onProgress?: (progress: UploadProgress) => void): Promise<ActUploadResult>;
+/**
+ * Decrypt an ACT-protected reference
+ *
+ * @param bee - Bee instance
+ * @param encryptedReference - The encrypted reference (hex string)
+ * @param historyReference - History manifest reference
+ * @param publisherPubKeyHex - Publisher's compressed public key (hex)
+ * @param readerPrivateKey - Reader's private key (32 bytes)
+ * @param timestamp - Optional timestamp to look up specific ACT version
+ * @param requestOptions - Bee request options
+ * @returns Decrypted content reference (hex string)
+ */
+export declare function decryptActReference(bee: Bee, encryptedReference: string, historyReference: string, publisherPubKeyHex: string, readerPrivateKey: Uint8Array, timestamp?: number, requestOptions?: BeeRequestOptions): Promise<string>;
+/**
+ * Add grantees to an existing ACT
+ */
+export declare function addGranteesToAct(context: UploadContext, historyReference: string, publisherPrivateKey: Uint8Array, newGranteePublicKeys: Array<{
+    x: Uint8Array;
+    y: Uint8Array;
+}>, options?: ActUploadOptions, requestOptions?: BeeRequestOptions, onProgress?: (progress: UploadProgress) => void): Promise<ActGranteeModifyResult>;
+/**
+ * Revoke grantees from an ACT (performs key rotation)
+ */
+export declare function revokeGranteesFromAct(context: UploadContext, historyReference: string, encryptedReference: string, publisherPrivateKey: Uint8Array, revokePublicKeys: Array<{
+    x: Uint8Array;
+    y: Uint8Array;
+}>, options?: ActUploadOptions, requestOptions?: BeeRequestOptions, onProgress?: (progress: UploadProgress) => void): Promise<ActRevocationResult>;
+/**
+ * Get grantees from an ACT
+ */
+export declare function getGranteesFromAct(bee: Bee, historyReference: string, publisherPrivateKey: Uint8Array, requestOptions?: BeeRequestOptions): Promise<string[]>;
+/**
+ * Parse a compressed public key from hex string
+ */
+export declare function parseCompressedPublicKey(hex: string): {
+    x: Uint8Array;
+    y: Uint8Array;
+};
+export { type ActEntry } from "./act";
+export { type UncompressedPublicKey } from "./grantee-list";
+export { type HistoryEntry, type HistoryEntryMetadata } from "./history";
+export { publicKeyFromPrivate, compressPublicKey, publicKeyFromCompressed, } from "./crypto";
+//# sourceMappingURL=index.d.ts.map

package/dist/proxy/act/index.d.ts.map

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

package/dist/proxy/chunking-encrypted.d.ts

@@ -0,0 +1,14 @@
+import { Reference } from "@ethersphere/bee-js";
+export declare const CHUNK_SIZE = 4096;
+export declare const ENCRYPTED_REFS_PER_CHUNK = 64;
+/**
+ * Build encrypted merkle tree from chunk references
+ * Adapted from bee-js encrypted-chunk-stream.ts
+ * Returns root reference (64 bytes: 32-byte address + 32-byte encryption key)
+ */
+export declare function buildEncryptedMerkleTree(encryptedChunks: Array<{
+    address: Uint8Array;
+    key: Uint8Array;
+    span: bigint;
+}>, onChunk: (encryptedChunkData: Uint8Array) => Promise<void>): Promise<Reference>;
+//# sourceMappingURL=chunking-encrypted.d.ts.map

package/dist/proxy/chunking-encrypted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunking-encrypted.d.ts","sourceRoot":"","sources":["../../src/proxy/chunking-encrypted.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAQ,MAAM,qBAAqB,CAAA;AAKrD,eAAO,MAAM,UAAU,OAAO,CAAA;AAC9B,eAAO,MAAM,wBAAwB,KAAK,CAAA;AAE1C;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,eAAe,EAAE,KAAK,CAAC;IACrB,OAAO,EAAE,UAAU,CAAA;IACnB,GAAG,EAAE,UAAU,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb,CAAC,EACF,OAAO,EAAE,CAAC,kBAAkB,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GACzD,OAAO,CAAC,SAAS,CAAC,CA0EpB"}

package/dist/proxy/chunking.d.ts

@@ -0,0 +1,15 @@
+import { Reference } from "@ethersphere/bee-js";
+import { type ContentAddressedChunk } from "../chunk";
+import type { ChunkReference } from "./types";
+export declare const CHUNK_SIZE = 4096;
+export declare const REFS_PER_CHUNK = 64;
+/**
+ * Split data into 4096-byte chunks
+ */
+export declare function splitDataIntoChunks(data: Uint8Array): Uint8Array[];
+/**
+ * Build merkle tree from chunk references
+ * Returns root reference (32 bytes)
+ */
+export declare function buildMerkleTree(chunkRefs: ChunkReference[], onIntermediateChunk: (chunk: ContentAddressedChunk) => Promise<void>): Promise<Reference>;
+//# sourceMappingURL=chunking.d.ts.map

package/dist/proxy/chunking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunking.d.ts","sourceRoot":"","sources":["../../src/proxy/chunking.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAA6B,KAAK,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAG7C,eAAO,MAAM,UAAU,OAAO,CAAA;AAC9B,eAAO,MAAM,cAAc,KAAK,CAAA;AAEhC;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE,CAMlE;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,cAAc,EAAE,EAC3B,mBAAmB,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,GACnE,OAAO,CAAC,SAAS,CAAC,CAsCpB"}

package/dist/proxy/download-data.d.ts

@@ -0,0 +1,16 @@
+import { EthAddress, Identifier } from "@ethersphere/bee-js";
+import type { Bee, BeeRequestOptions, DownloadOptions } from "@ethersphere/bee-js";
+import type { UploadProgress } from "./types";
+import type { SingleOwnerChunk } from "../types";
+/**
+ * Download data using only the chunk API
+ * This ensures encrypted data remains encrypted during transmission and avoids metadata leakage
+ *
+ * Supports both:
+ * - Regular references (64 hex chars = 32 bytes)
+ * - Encrypted references (128 hex chars = 64 bytes: 32-byte address + 32-byte encryption key)
+ */
+export declare function downloadDataWithChunkAPI(bee: Bee, reference: string, _options?: DownloadOptions, onProgress?: (progress: UploadProgress) => void, requestOptions?: BeeRequestOptions): Promise<Uint8Array>;
+export declare function downloadSOC(bee: Bee, owner: string | Uint8Array | EthAddress, identifier: string | Uint8Array | Identifier, requestOptions?: BeeRequestOptions): Promise<SingleOwnerChunk>;
+export declare function downloadEncryptedSOC(bee: Bee, owner: string | Uint8Array | EthAddress, identifier: string | Uint8Array | Identifier, encryptionKey: string | Uint8Array, requestOptions?: BeeRequestOptions): Promise<SingleOwnerChunk>;
+//# sourceMappingURL=download-data.d.ts.map

package/dist/proxy/download-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"download-data.d.ts","sourceRoot":"","sources":["../../src/proxy/download-data.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,UAAU,EAGX,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EACV,GAAG,EACH,iBAAiB,EACjB,eAAe,EAChB,MAAM,qBAAqB,CAAA;AAa5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AA4RhD;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,eAAe,EAC1B,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,IAAI,EAC/C,cAAc,CAAC,EAAE,iBAAiB,GACjC,OAAO,CAAC,UAAU,CAAC,CAkFrB;AAED,wBAAsB,WAAW,CAC/B,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,EACvC,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,EAC5C,cAAc,CAAC,EAAE,iBAAiB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CAY3B;AAED,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,EACvC,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,EAC5C,aAAa,EAAE,MAAM,GAAG,UAAU,EAClC,cAAc,CAAC,EAAE,iBAAiB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CAgB3B"}