@snaha/swarm-id 0.0.1

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

@@ -0,0 +1,5 @@
+/**
+ * Feed utilities and implementations
+ */
+export * from "./epochs";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/proxy/feeds/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,UAAU,CAAA"}

package/dist/proxy/feeds/sequence/async-finder.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Async Sequential Feed Finder
+ *
+ * Currently delegates to the sync finder to match Go behavior
+ * while keeping an async interface.
+ */
+import type { Bee, EthAddress, Topic, BeeRequestOptions } from "@ethersphere/bee-js";
+import type { SequentialFinder, SequentialLookupResult } from "./types";
+export declare class AsyncSequentialFinder implements SequentialFinder {
+    private readonly syncFinder;
+    constructor(bee: Bee, topic: Topic, owner: EthAddress);
+    findAt(at: bigint, after?: bigint, requestOptions?: BeeRequestOptions): Promise<SequentialLookupResult>;
+}
+//# sourceMappingURL=async-finder.d.ts.map

package/dist/proxy/feeds/sequence/async-finder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-finder.d.ts","sourceRoot":"","sources":["../../../../src/proxy/feeds/sequence/async-finder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,GAAG,EACH,UAAU,EACV,KAAK,EACL,iBAAiB,EAClB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAGvE,qBAAa,qBAAsB,YAAW,gBAAgB;IAC5D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;gBAErC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU;IAI/C,MAAM,CACV,EAAE,EAAE,MAAM,EACV,KAAK,GAAE,MAAW,EAClB,cAAc,CAAC,EAAE,iBAAiB,GACjC,OAAO,CAAC,sBAAsB,CAAC;CAGnC"}

package/dist/proxy/feeds/sequence/finder.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Synchronous Sequential Feed Finder
+ *
+ * Linear scan implementation for finding the latest update index.
+ * Mirrors the Go sequential finder behavior.
+ */
+import type { Bee, EthAddress, Topic, BeeRequestOptions } from "@ethersphere/bee-js";
+import type { SequentialFinder, SequentialLookupResult } from "./types";
+export declare class SyncSequentialFinder implements SequentialFinder {
+    private readonly bee;
+    private readonly topic;
+    private readonly owner;
+    constructor(bee: Bee, topic: Topic, owner: EthAddress);
+    findAt(_at: bigint, _after?: bigint, requestOptions?: BeeRequestOptions): Promise<SequentialLookupResult>;
+    private indexExists;
+}
+//# sourceMappingURL=finder.d.ts.map

package/dist/proxy/feeds/sequence/finder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finder.d.ts","sourceRoot":"","sources":["../../../../src/proxy/feeds/sequence/finder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,GAAG,EACH,UAAU,EACV,KAAK,EACL,iBAAiB,EAClB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAgBvE,qBAAa,oBAAqB,YAAW,gBAAgB;IAEzD,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAFL,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,UAAU;IAG9B,MAAM,CACV,GAAG,EAAE,MAAM,EACX,MAAM,GAAE,MAAW,EACnB,cAAc,CAAC,EAAE,iBAAiB,GACjC,OAAO,CAAC,sBAAsB,CAAC;YAYpB,WAAW;CAkB1B"}

package/dist/proxy/feeds/sequence/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Sequential Feeds
+ *
+ * Sequential feed indexing for versioned updates.
+ */
+export type { SequentialFeedOptions, SequentialFeedWriterOptions, SequentialLookupResult, SequentialFinder, SequentialUpdater, } from "./types";
+export { SyncSequentialFinder } from "./finder";
+export { AsyncSequentialFinder } from "./async-finder";
+export { BasicSequentialUpdater } from "./updater";
+import type { SequentialFeedOptions, SequentialFeedWriterOptions, SequentialFinder, SequentialUpdater } from "./types";
+/**
+ * Create a synchronous sequential feed finder
+ */
+export declare function createSyncSequentialFinder(options: SequentialFeedOptions): SequentialFinder;
+/**
+ * Create an async sequential feed finder
+ */
+export declare function createAsyncSequentialFinder(options: SequentialFeedOptions): SequentialFinder;
+/**
+ * Create a sequential feed updater
+ */
+export declare function createSequentialUpdater(options: SequentialFeedWriterOptions): SequentialUpdater;
+//# sourceMappingURL=index.d.ts.map

package/dist/proxy/feeds/sequence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/proxy/feeds/sequence/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACV,qBAAqB,EACrB,2BAA2B,EAC3B,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AAKlD,OAAO,KAAK,EACV,qBAAqB,EACrB,2BAA2B,EAC3B,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,SAAS,CAAA;AAEhB;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,qBAAqB,GAC7B,gBAAgB,CAElB;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,qBAAqB,GAC7B,gBAAgB,CAElB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,2BAA2B,GACnC,iBAAiB,CAEnB"}

package/dist/proxy/feeds/sequence/types.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Types for Sequential Feeds
+ */
+import type { Bee, EthAddress, Topic, PrivateKey, Stamper, BeeRequestOptions } from "@ethersphere/bee-js";
+/**
+ * Options for creating a sequential feed reader
+ */
+export interface SequentialFeedOptions {
+    /** Bee instance for chunk operations */
+    bee: Bee;
+    /** Feed topic (32 bytes) */
+    topic: Topic;
+    /** Feed owner address */
+    owner: EthAddress;
+}
+/**
+ * Options for creating a sequential feed writer
+ */
+export interface SequentialFeedWriterOptions extends SequentialFeedOptions {
+    /** Private key for signing chunks */
+    signer: PrivateKey;
+}
+/**
+ * Result from sequential feed lookup
+ */
+export interface SequentialLookupResult {
+    /** Current (latest) index if found */
+    current?: bigint;
+    /** Next index to use */
+    next: bigint;
+}
+/**
+ * Interface for sequential feed finders (readers)
+ *
+ * Implementations: SyncSequentialFinder, AsyncSequentialFinder
+ */
+export interface SequentialFinder {
+    /**
+     * Find the latest feed update index
+     *
+     * @param at - Ignored for sequential feeds (for compatibility with Go API)
+     * @param after - Hint of latest known index (0 if unknown)
+     * @returns Lookup result with current and next index
+     */
+    findAt(at: bigint, after?: bigint, requestOptions?: BeeRequestOptions): Promise<SequentialLookupResult>;
+}
+/**
+ * Interface for sequential feed updaters (writers)
+ */
+export interface SequentialUpdater {
+    /**
+     * Update feed with payload data
+     *
+     * @param payload - Payload to store
+     * @param stamper - Stamper object for stamping
+     * @returns SOC chunk address for utilization tracking
+     */
+    update(payload: Uint8Array, stamper: Stamper, encryptionKey?: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Get the owner address (derived from signer)
+     */
+    getOwner(): EthAddress;
+    /**
+     * Get current state (for persistence/debugging)
+     */
+    getState(): {
+        nextIndex: bigint;
+    };
+    /**
+     * Restore state (from persistence)
+     */
+    setState(state: {
+        nextIndex: bigint;
+    }): void;
+    /**
+     * Reset updater state (useful for testing or reinitialization)
+     */
+    reset(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/proxy/feeds/sequence/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/proxy/feeds/sequence/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,GAAG,EACH,UAAU,EACV,KAAK,EACL,UAAU,EACV,OAAO,EACP,iBAAiB,EAClB,MAAM,qBAAqB,CAAA;AAE5B;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,wCAAwC;IACxC,GAAG,EAAE,GAAG,CAAA;IAER,4BAA4B;IAC5B,KAAK,EAAE,KAAK,CAAA;IAEZ,yBAAyB;IACzB,KAAK,EAAE,UAAU,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,qBAAqB;IACxE,qCAAqC;IACrC,MAAM,EAAE,UAAU,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAA;IAEhB,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,MAAM,CACJ,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE,MAAM,EACd,cAAc,CAAC,EAAE,iBAAiB,GACjC,OAAO,CAAC,sBAAsB,CAAC,CAAA;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,MAAM,CACJ,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,OAAO,EAChB,aAAa,CAAC,EAAE,UAAU,GACzB,OAAO,CAAC,UAAU,CAAC,CAAA;IAEtB;;OAEG;IACH,QAAQ,IAAI,UAAU,CAAA;IAEtB;;OAEG;IACH,QAAQ,IAAI;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;IAEjC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IAE5C;;OAEG;IACH,KAAK,IAAI,IAAI,CAAA;CACd"}

package/dist/proxy/feeds/sequence/updater.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Basic Sequential Feed Updater
+ *
+ * Handles writing updates to sequential feeds by incrementing the index.
+ */
+import type { Bee, Stamper } from "@ethersphere/bee-js";
+import { EthAddress, Topic, PrivateKey } from "@ethersphere/bee-js";
+import type { SequentialUpdater } from "./types";
+export declare class BasicSequentialUpdater implements SequentialUpdater {
+    private readonly bee;
+    private readonly topic;
+    private readonly signer;
+    private nextIndex;
+    constructor(bee: Bee, topic: Topic, signer: PrivateKey);
+    update(payload: Uint8Array, stamper: Stamper, encryptionKey?: Uint8Array): Promise<Uint8Array>;
+    getOwner(): EthAddress;
+    getState(): {
+        nextIndex: bigint;
+    };
+    setState(state: {
+        nextIndex: bigint;
+    }): void;
+    reset(): void;
+    private makeIdentifier;
+}
+//# sourceMappingURL=updater.d.ts.map

package/dist/proxy/feeds/sequence/updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updater.d.ts","sourceRoot":"","sources":["../../../../src/proxy/feeds/sequence/updater.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAc,MAAM,qBAAqB,CAAA;AAE/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,qBAAa,sBAAuB,YAAW,iBAAiB;IAI5D,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IALzB,OAAO,CAAC,SAAS,CAAa;gBAGX,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,UAAU;IAG/B,MAAM,CACV,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,OAAO,EAChB,aAAa,CAAC,EAAE,UAAU,GACzB,OAAO,CAAC,UAAU,CAAC;IAsBtB,QAAQ,IAAI,UAAU;IAItB,QAAQ,IAAI;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE;IAIjC,QAAQ,CAAC,KAAK,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAI5C,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,cAAc;CAOvB"}

package/dist/proxy/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./chunking";
+export * from "./upload-data";
+export * from "./feeds";
+export * from "./act";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/proxy/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA"}

package/dist/proxy/manifest-builder.d.ts

@@ -0,0 +1,183 @@
+import { MantarayNode } from "@ethersphere/bee-js";
+/**
+ * Result of building a /bzz/-compatible manifest.
+ *
+ * This is a FLAT manifest with no child nodes - just the root manifest.
+ * Bee's /bzz/ endpoint can directly resolve paths from this structure.
+ *
+ * IMPORTANT: The `data` field contains RAW manifest bytes (without span prefix).
+ * When uploaded via `uploadData()`, span will be added and the resulting address
+ * will match the pre-computed `address` field.
+ */
+export interface BzzCompatibleManifestResult {
+    /** The manifest chunk to upload. Raw bytes, no span. */
+    manifestChunk: {
+        data: Uint8Array;
+        address: string;
+    };
+}
+/**
+ * Build a /bzz/-compatible flat manifest with VALUE forks.
+ *
+ * Creates a flat manifest with two VALUE forks at root level:
+ * - "/" → VALUE fork with website-index-document metadata pointing to NULL
+ * - "index.bin" → VALUE fork pointing directly to content reference
+ *
+ * This is built manually because bee-js MantarayNode always creates EDGE forks
+ * with child nodes, which causes Bee to fail to resolve the content.
+ *
+ * When Bee accesses /bzz/manifest/:
+ * 1. Finds "/" fork, reads website-index-document metadata
+ * 2. Looks up "index.bin" fork at root level
+ * 3. "index.bin" is VALUE type → serves content directly
+ *
+ * Binary format (Mantaray v0.2):
+ * - obfuscationKey (32 bytes): All zeros for no obfuscation
+ * - versionHash (31 bytes): MANTARAY_VERSION_HASH
+ * - refBytesCount (1 byte): 32
+ * - entry (32 bytes): All zeros (root has no entry)
+ * - indexBitmap (32 bytes): Bits set for '/' (47) and 'i' (105)
+ * - fork1 (64+ bytes): "/" fork with metadata
+ * - fork2 (64+ bytes): "index.bin" fork with metadata
+ *
+ * @param contentReference - Reference to the actual content (32 bytes / 64 hex chars)
+ * @returns Single manifest chunk to upload
+ */
+export declare function buildBzzCompatibleManifest(contentReference: string | Uint8Array): Promise<BzzCompatibleManifestResult>;
+/**
+ * Result of building a /bzz/-compatible MantarayNode manifest.
+ */
+export interface BzzManifestNodeResult {
+    /** The MantarayNode to be uploaded with saveMantarayTreeRecursively */
+    manifestNode: MantarayNode;
+}
+/**
+ * Build a /bzz/-compatible manifest as a MantarayNode.
+ *
+ * This function creates a MantarayNode with the proper structure for /bzz/ access:
+ * - "/" fork with website-index-document metadata pointing to "index.bin"
+ * - "index.bin" fork pointing to the actual content reference
+ *
+ * IMPORTANT: After calling this function, use saveMantarayTreeRecursively() to
+ * upload the manifest. This ensures all child nodes are uploaded bottom-up and
+ * their addresses are correctly set from Bee's responses.
+ *
+ * Usage:
+ * ```typescript
+ * const { manifestNode } = buildBzzManifestNode(contentReference)
+ * const result = await saveMantarayTreeRecursively(manifestNode, async (data, isRoot) => {
+ *   const uploadResult = await uploadData(bee, stamper, data, uploadOptions)
+ *   return { reference: uploadResult.reference }
+ * })
+ * // result.rootReference is the /bzz/ compatible manifest address
+ * ```
+ *
+ * @param contentReference - Reference to the actual content (32 bytes / 64 hex chars)
+ * @returns MantarayNode ready for upload with saveMantarayTreeRecursively
+ */
+export declare function buildBzzManifestNode(contentReference: string | Uint8Array): BzzManifestNodeResult;
+/**
+ * @deprecated Use buildBzzManifestNode() with saveMantarayTreeRecursively() instead.
+ * This function manually builds binary format but doesn't upload child nodes,
+ * which causes Bee to fail to resolve content via /bzz/.
+ */
+/**
+ * @deprecated Use buildBzzCompatibleManifest() for /bzz/ compatibility.
+ * This function creates a manifest that won't work with Bee's /bzz/ endpoint
+ * because it embeds the content reference directly in the manifest instead
+ * of using the proper two-level structure (root → child → content).
+ *
+ * Build a minimal mantaray manifest for /bzz/ feed compatibility.
+ *
+ * This creates a manifest with a single "/" fork pointing to a content reference.
+ * The manifest is built manually (not using bee-js MantarayNode.marshal()) because
+ * bee-js doesn't embed the targetAddress correctly for value-type nodes.
+ *
+ * Binary format (Mantaray v0.2):
+ * - obfuscationKey (32 bytes): All zeros for no obfuscation
+ * - versionHash (31 bytes): MANTARAY_VERSION_HASH
+ * - refBytesCount (1 byte): 32 (size of entry reference)
+ * - entry (32 bytes): All zeros (root has no entry)
+ * - indexBitmap (32 bytes): Bitmap with bit 47 set (for '/')
+ * - fork (64+ bytes): flags + prefixLen + prefix(30) + reference(32) + metadata
+ *
+ * @param contentReference - Reference to the actual content (32 bytes / 64 hex chars)
+ * @returns Marshaled manifest bytes
+ */
+export declare function buildMinimalManifest(contentReference: string | Uint8Array): Uint8Array;
+/**
+ * Maximum CAC payload size for /bzz/ compatible feed uploads.
+ *
+ * For the /chunks endpoint to detect SOC correctly, total SOC size must be > 4104 bytes.
+ * SOC structure: identifier(32) + signature(65) + span(8) + payload(N)
+ * For N=4096: total = 32 + 65 + 8 + 4096 = 4201 bytes > 4104 ✓
+ */
+export declare const MAX_PADDED_PAYLOAD_SIZE = 4096;
+/**
+ * Pad payload to 4096 bytes for SOC detection by /chunks endpoint.
+ *
+ * The span field in the CAC contains the actual payload size (before padding),
+ * so Bee's joiner will only read the actual data and ignore padding.
+ *
+ * @param payload - Original payload (must be <= 4096 bytes)
+ * @returns Padded payload (exactly 4096 bytes)
+ */
+export declare function padPayloadForSOCDetection(payload: Uint8Array): Uint8Array;
+/**
+ * Extract content reference from a minimal mantaray manifest.
+ *
+ * This is the reverse of buildMinimalManifest() - it parses the manifest
+ * binary format and extracts the "/" fork's targetAddress.
+ *
+ * Binary format (Mantaray v0.2):
+ * - Offset 0-31: obfuscationKey
+ * - Offset 32-62: versionHash (31 bytes)
+ * - Offset 63: refBytesCount
+ * - Offset 64-95: entry (refBytesCount bytes, assuming 32)
+ * - Offset 96-127: indexBitmap
+ * - Offset 128+: forks (flags + prefixLen + prefix + reference + metadata)
+ *
+ * For a minimal manifest with just "/" fork:
+ * - Fork flags at offset 128
+ * - Prefix length at offset 129
+ * - Prefix (30 bytes) at offset 130
+ * - Reference (32 bytes) at offset 160
+ *
+ * @param manifestData - Raw manifest bytes (from feed payload)
+ * @returns Content reference as 64 hex characters
+ */
+export declare function extractReferenceFromManifest(manifestData: Uint8Array): string;
+/**
+ * Extract entry (targetAddress) from a leaf manifest node.
+ *
+ * In Mantaray v0.2, leaf nodes store their targetAddress in the entry field
+ * (bytes 64-95), not in a fork. This is used for the second level of parsing
+ * when using buildBzzCompatibleManifest().
+ *
+ * Binary format (Mantaray v0.2):
+ * - Offset 0-31:   obfuscationKey
+ * - Offset 32-62:  versionHash (31 bytes)
+ * - Offset 63:     refBytesCount
+ * - Offset 64-95:  entry (32 bytes) ← targetAddress for leaf nodes
+ * - Offset 96-127: indexBitmap
+ * - Offset 128+:   forks
+ *
+ * @param manifestData - Raw manifest bytes (child chunk data from two-level structure)
+ * @returns Content reference as 64 hex characters
+ */
+export declare function extractEntryFromManifest(manifestData: Uint8Array): string;
+/**
+ * Extract content reference from a flat /bzz/-compatible manifest.
+ *
+ * In the flat structure, the manifest has:
+ * - "/" fork with NULL_ADDRESS and website-index-document metadata
+ * - "index.bin" fork with VALUE type pointing to content reference
+ *
+ * This function looks for the "index.bin" fork ('i' = ASCII 105) and
+ * extracts its reference.
+ *
+ * @param manifestData - Raw manifest bytes (flat manifest)
+ * @returns Content reference as 64 hex characters
+ */
+export declare function extractContentFromFlatManifest(manifestData: Uint8Array): string;
+//# sourceMappingURL=manifest-builder.d.ts.map

package/dist/proxy/manifest-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-builder.d.ts","sourceRoot":"","sources":["../../src/proxy/manifest-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,YAAY,EAAgB,MAAM,qBAAqB,CAAA;AAoB3E;;;;;;;;;GASG;AACH,MAAM,WAAW,2BAA2B;IAC1C,wDAAwD;IACxD,aAAa,EAAE;QACb,IAAI,EAAE,UAAU,CAAA;QAChB,OAAO,EAAE,MAAM,CAAA;KAChB,CAAA;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,0BAA0B,CAC9C,gBAAgB,EAAE,MAAM,GAAG,UAAU,GACpC,OAAO,CAAC,2BAA2B,CAAC,CAgItC;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,uEAAuE;IACvE,YAAY,EAAE,YAAY,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAClC,gBAAgB,EAAE,MAAM,GAAG,UAAU,GACpC,qBAAqB,CA2BvB;AAED;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,oBAAoB,CAClC,gBAAgB,EAAE,MAAM,GAAG,UAAU,GACpC,UAAU,CA8DZ;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAA;AAE3C;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAgBzE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,UAAU,GAAG,MAAM,CAoG7E;AAwBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,UAAU,GAAG,MAAM,CAiBzE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,8BAA8B,CAC5C,YAAY,EAAE,UAAU,GACvB,MAAM,CAwFR"}

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

@@ -0,0 +1,27 @@
+import type { MantarayNode } from "@ethersphere/bee-js";
+/**
+ * Upload callback type for saveMantarayTreeRecursivelyEncrypted
+ *
+ * @param encryptedData - The encrypted chunk data to upload
+ * @param address - The 32-byte address of the encrypted chunk
+ * @param isRoot - Whether this is the root node
+ * @returns Upload result with optional tag UID
+ */
+export type EncryptedUploadCallback = (encryptedData: Uint8Array, address: Uint8Array, isRoot: boolean) => Promise<{
+    tagUid?: number;
+}>;
+/**
+ * Save a Mantaray tree with encryption by uploading bottom-up
+ *
+ * This mirrors saveMantarayTreeRecursively but encrypts each manifest node
+ * and creates 64-byte encrypted references (address + encryption key).
+ *
+ * @param node - Root Mantaray node to save
+ * @param uploadFn - Callback to upload each encrypted chunk
+ * @returns Root reference (128 hex chars = 64 bytes) and optional tag UID
+ */
+export declare function saveMantarayTreeRecursivelyEncrypted(node: MantarayNode, uploadFn: EncryptedUploadCallback): Promise<{
+    rootReference: string;
+    tagUid?: number;
+}>;
+//# sourceMappingURL=mantaray-encrypted.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mantaray-encrypted.d.ts","sourceRoot":"","sources":["../../src/proxy/mantaray-encrypted.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAOvD;;;;;;;GAOG;AACH,MAAM,MAAM,uBAAuB,GAAG,CACpC,aAAa,EAAE,UAAU,EACzB,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,OAAO,KACZ,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAEjC;;;;;;;;;GASG;AACH,wBAAsB,oCAAoC,CACxD,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,uBAAuB,GAChC,OAAO,CAAC;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA2CrD"}

package/dist/proxy/mantaray.d.ts

@@ -0,0 +1,26 @@
+import { MantarayNode } from "@ethersphere/bee-js";
+import type { Bee, BeeRequestOptions } from "@ethersphere/bee-js";
+/**
+ * Upload callback type for saveMantarayTreeRecursively
+ */
+export type UploadCallback = (data: Uint8Array, isRoot: boolean) => Promise<{
+    reference: string;
+    tagUid?: number;
+}>;
+/**
+ * Save a Mantaray tree by uploading bottom-up
+ *
+ * This mirrors MantarayNode.saveRecursively() but allows custom upload logic
+ * and uses Bee's returned references to avoid address mismatches.
+ */
+export declare function saveMantarayTreeRecursively(node: MantarayNode, uploadFn: UploadCallback): Promise<{
+    rootReference: string;
+    tagUid?: number;
+}>;
+/**
+ * Load a Mantaray tree using only the chunk API.
+ *
+ * This avoids /bytes and supports encrypted references.
+ */
+export declare function loadMantarayTreeWithChunkAPI(bee: Bee, rootReference: string, requestOptions?: BeeRequestOptions): Promise<MantarayNode>;
+//# sourceMappingURL=mantaray.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mantaray.d.ts","sourceRoot":"","sources":["../../src/proxy/mantaray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,GAAG,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAIjE;;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;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAsBrD;AAED;;;;GAIG;AACH,wBAAsB,4BAA4B,CAChD,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,MAAM,EACrB,cAAc,CAAC,EAAE,iBAAiB,GACjC,OAAO,CAAC,YAAY,CAAC,CAgDvB"}

package/dist/proxy/types.d.ts

@@ -0,0 +1,29 @@
+import type { Bee, Stamper } from "@ethersphere/bee-js";
+/**
+ * Upload context shared across handlers
+ */
+export interface UploadContext {
+    bee: Bee;
+    stamper: Stamper;
+}
+/**
+ * Upload progress information
+ */
+export interface UploadProgress {
+    total: number;
+    processed: number;
+}
+/**
+ * Chunk reference (32-byte address)
+ */
+export interface ChunkReference {
+    address: Uint8Array;
+}
+/**
+ * Encrypted chunk reference (64-byte reference: address + encryption key)
+ */
+export interface EncryptedChunkReference {
+    address: Uint8Array;
+    key: Uint8Array;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/proxy/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAEvD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,GAAG,CAAA;IACR,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,UAAU,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,UAAU,CAAA;IACnB,GAAG,EAAE,UAAU,CAAA;CAChB"}

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

@@ -0,0 +1,17 @@
+import type { Bee, BeeRequestOptions, Stamper, UploadOptions, UploadResult } from "@ethersphere/bee-js";
+import { type ContentAddressedChunk } from "../chunk";
+import type { UploadContext, UploadProgress } from "./types";
+/**
+ * Upload data with client-side signing
+ * Handles chunking, merkle tree building, and progress reporting
+ */
+export declare function uploadDataWithSigning(context: UploadContext, data: Uint8Array, options?: UploadOptions, onProgress?: (progress: UploadProgress) => void, requestOptions?: BeeRequestOptions): Promise<{
+    reference: string;
+    tagUid?: number;
+}>;
+/**
+ * Upload a single chunk with optional signing
+ * Returns UploadResult with Bee's actual stored reference for verification
+ */
+export declare function uploadSingleChunk(bee: Bee, stamper: Stamper | undefined, chunk: ContentAddressedChunk, options?: UploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResult>;
+//# sourceMappingURL=upload-data.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"upload-data.d.ts","sourceRoot":"","sources":["../../src/proxy/upload-data.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,GAAG,EACH,iBAAiB,EACjB,OAAO,EACP,aAAa,EACb,YAAY,EACb,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAA6B,KAAK,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAEhF,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAkB,MAAM,SAAS,CAAA;AA4C5E;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,UAAU,EAChB,OAAO,CAAC,EAAE,aAAa,EACvB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,IAAI,EAC/C,cAAc,CAAC,EAAE,iBAAiB,GACjC,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAmFjD;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,KAAK,EAAE,qBAAqB,EAC5B,OAAO,CAAC,EAAE,aAAa,EACvB,cAAc,CAAC,EAAE,iBAAiB,GACjC,OAAO,CAAC,YAAY,CAAC,CA6BvB"}

package/dist/proxy/upload-encrypted-data.d.ts

@@ -0,0 +1,103 @@
+import { PrivateKey, Identifier } from "@ethersphere/bee-js";
+import type { Bee, BeeRequestOptions, Stamper, UploadOptions } from "@ethersphere/bee-js";
+import { type EncryptedChunk } from "../chunk";
+import type { UploadContext, UploadProgress } from "./types";
+/**
+ * Result of uploading encrypted data
+ */
+export interface UploadEncryptedDataResult {
+    reference: string;
+    tagUid?: number;
+    chunkAddresses: Uint8Array[];
+}
+/**
+ * Upload encrypted data with client-side signing
+ * Handles chunking, encryption, merkle tree building, and progress reporting
+ *
+ * @param context - Upload context with bee instance and authentication
+ * @param data - Data to encrypt and upload
+ * @param encryptionKey - Optional 32-byte encryption key (generates random if not provided)
+ * @param options - Upload options
+ * @param onProgress - Progress callback
+ */
+export declare function uploadEncryptedDataWithSigning(context: UploadContext, data: Uint8Array, encryptionKey?: Uint8Array, options?: UploadOptions, onProgress?: (progress: UploadProgress) => void, requestOptions?: BeeRequestOptions): Promise<UploadEncryptedDataResult>;
+/**
+ * Upload a single encrypted chunk with optional signing
+ */
+export declare function uploadSingleEncryptedChunk(bee: Bee, stamper: Stamper, encryptedChunk: EncryptedChunk, options?: UploadOptions, requestOptions?: BeeRequestOptions): Promise<void>;
+/**
+ * Upload a single encrypted chunk with optional signing
+ *
+ * This is the unified interface for uploading encrypted chunks.
+ * Use this instead of direct Bee API calls with fetch.
+ *
+ * @param bee - Bee client instance
+ * @param stamper - Stamper for client-side signing
+ * @param payload - Raw chunk data to encrypt and upload (1-4096 bytes)
+ * @param encryptionKey - Encryption key (32 bytes)
+ * @param options - Upload options (deferred, tag, etc.)
+ */
+export declare function uploadSingleChunkWithEncryption(bee: Bee, stamper: Stamper, payload: Uint8Array, encryptionKey: Uint8Array, options?: UploadOptions): Promise<void>;
+/**
+ * Result of uploading an encrypted SOC
+ */
+export interface UploadEncryptedSOCResult {
+    socAddress: Uint8Array;
+    encryptionKey: Uint8Array;
+    tagUid?: number;
+}
+/**
+ * Result of uploading a SOC
+ */
+export interface UploadSOCResult {
+    socAddress: Uint8Array;
+    tagUid?: number;
+}
+/**
+ * Upload an encrypted Single Owner Chunk (SOC) using the fast chunk upload path
+ *
+ * This function constructs an encrypted SOC manually and uploads it via the regular
+ * /chunks endpoint for better performance compared to the /soc endpoint.
+ *
+ * SOC Structure (Book of Swarm 2.2.3, 2.2.4):
+ * - 32 bytes: identifier
+ * - 65 bytes: signature (r, s, v)
+ * - 8 bytes: span (from encrypted CAC)
+ * - up to 4096 bytes: encrypted payload (from encrypted CAC)
+ *
+ * The signature signs: hash(identifier + encrypted_CAC.address)
+ * SOC address: Keccak256(identifier + owner_address)
+ *
+ * @param bee - Bee client instance
+ * @param stamper - Stamper for client-side signing
+ * @param signer - SOC owner's private key
+ * @param identifier - 32-byte SOC identifier
+ * @param data - Payload data (1-4096 bytes)
+ * @param encryptionKey - Optional 32-byte encryption key (random if not provided)
+ * @param options - Upload options (tag, deferred, etc.)
+ * @returns SOC address, encryption key, and optional tag UID
+ */
+export declare function uploadEncryptedSOC(bee: Bee, stamper: Stamper, signer: PrivateKey, identifier: Identifier, data: Uint8Array, encryptionKey?: Uint8Array, options?: UploadOptions): Promise<UploadEncryptedSOCResult>;
+/**
+ * Upload a plain Single Owner Chunk (SOC) using the fast chunk upload path
+ *
+ * This constructs an unencrypted SOC and uploads it via /chunks to avoid /soc size limits.
+ */
+export declare function uploadSOC(bee: Bee, stamper: Stamper, signer: PrivateKey, identifier: Identifier, data: Uint8Array, options?: UploadOptions): Promise<UploadSOCResult>;
+/**
+ * Upload SOC via the /soc/{owner}/{id} endpoint.
+ *
+ * Use this for small SOCs (< 4104 bytes) that need to preserve exact CAC size,
+ * such as v1 format feeds for /bzz/ compatibility.
+ *
+ * The /soc endpoint explicitly handles SOC uploads without size-based detection,
+ * avoiding "stamp signature is invalid" errors for small SOCs that would be
+ * misidentified as CAC by the /chunks endpoint.
+ *
+ * Key differences from uploadSOC:
+ * - Uses /soc/{owner}/{id}?sig=... endpoint (explicit SOC handling)
+ * - Does NOT pad CAC data (preserves exact payload size for v1 format)
+ * - Stamps using CAC address (what /soc endpoint expects)
+ */
+export declare function uploadSOCViaSocEndpoint(bee: Bee, stamper: Stamper, signer: PrivateKey, identifier: Identifier, data: Uint8Array, options?: UploadOptions): Promise<UploadSOCResult>;
+//# sourceMappingURL=upload-encrypted-data.d.ts.map

package/dist/proxy/upload-encrypted-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-encrypted-data.d.ts","sourceRoot":"","sources":["../../src/proxy/upload-encrypted-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,UAAU,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACvE,OAAO,KAAK,EACV,GAAG,EACH,iBAAiB,EACjB,OAAO,EACP,aAAa,EAEd,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,UAAU,CAAA;AAIjB,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE5D;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,cAAc,EAAE,UAAU,EAAE,CAAA;CAC7B;AA4CD;;;;;;;;;GASG;AACH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,UAAU,EAChB,aAAa,CAAC,EAAE,UAAU,EAC1B,OAAO,CAAC,EAAE,aAAa,EACvB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,IAAI,EAC/C,cAAc,CAAC,EAAE,iBAAiB,GACjC,OAAO,CAAC,yBAAyB,CAAC,CAqIpC;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,cAAc,EAC9B,OAAO,CAAC,EAAE,aAAa,EACvB,cAAc,CAAC,EAAE,iBAAiB,GACjC,OAAO,CAAC,IAAI,CAAC,CAWf;AAmBD;;;;;;;;;;;GAWG;AACH,wBAAsB,+BAA+B,CACnD,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,UAAU,EACnB,aAAa,EAAE,UAAU,EACzB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAuBf;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,UAAU,CAAA;IACtB,aAAa,EAAE,UAAU,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,UAAU,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAgFD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,UAAU,EAChB,aAAa,CAAC,EAAE,UAAU,EAC1B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,wBAAwB,CAAC,CAwDnC;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,UAAU,EAChB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,eAAe,CAAC,CA+C1B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,UAAU,EAChB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,eAAe,CAAC,CAqF1B"}