@wovin/core 0.2.2 → 0.3.2

package/dist/ipfs.js

@@ -1,6 +1,6 @@
 import {
   fetchSnapshotChainUntil
-} from "./chunk-BLF5MAWU.js";
+} from "./chunk-BIYQEX3N.js";
 import {
   carFromBlob,
   collectDagBlocks,
@@ -11,9 +11,9 @@ import {
   makeCarBlob,
   makeCarOut,
   streamReaderToIterable
-} from "./chunk-6ALNRM3J.js";
+} from "./chunk-H3JNNTVP.js";
 import "./chunk-YDAKBU6Q.js";
-import "./chunk-3SUFNJEZ.js";
+import "./chunk-N7SEGHU4.js";
 import {
   MULTICODEC_IPNS_KEY,
   areCidsEqual,
@@ -29,7 +29,7 @@ import {
   prepareForPub,
   toIpnsString,
   tryParseCID
-} from "./chunk-SHUHRHOT.js";
+} from "./chunk-4MKPGQIM.js";
 import "./chunk-ZAADLBSB.js";
 export {
   MULTICODEC_IPNS_KEY,

package/dist/ipns/gateway-resolver.d.ts

@@ -0,0 +1,21 @@
+import { CID } from 'multiformats/cid';
+/**
+ * Resolve an IPNS name to a CID using a public IPFS gateway's HTTP HEAD response.
+ *
+ * Mechanism: per the IPFS HTTP Gateway spec, `HEAD <gateway>/ipns/<name>/` returns the
+ * IPNS-resolved root CID in the `X-Ipfs-Roots` response header (space-separated, ordered
+ * from root to leaf). The first entry is the IPNS-resolved CID.
+ *
+ * This works against any gateway that follows the spec and exposes CORS for HEAD
+ * (most public gateways do, e.g. ipfs.zt.ax, ipfs.io, dweb.link).
+ *
+ * The legacy w3name HTTP endpoint (`GET <base>/name/<ipns>` returning `{value: "/ipfs/<cid>"}`)
+ * is also supported here for back-compat with self-hosted w3name-like services — but the
+ * X-Ipfs-Roots path is preferred since it's the standardised gateway mechanism.
+ *
+ * @param ipns - The IPNS name (k51... string)
+ * @param gateways - List of gateway base URLs (e.g. `["https://ipfs.zt.ax"]`)
+ * @returns The resolved CID, or null if no gateway could resolve the name
+ */
+export declare function resolveIPNSViaGateway(ipns: string, gateways: string[]): Promise<CID | null>;
+//# sourceMappingURL=gateway-resolver.d.ts.map

package/dist/ipns/gateway-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-resolver.d.ts","sourceRoot":"","sources":["../../src/ipns/gateway-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAKtC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,CAuCjG"}

package/dist/ipns/ipns-record.d.ts

@@ -14,21 +14,60 @@ export declare function ipnsNameFromPrivateKey(privKeyBytes: Uint8Array): string
  */
 export declare function createSignedIPNSRecord(privateKey: Uint8Array, cid: CID, sequence: bigint, lifetimeMs?: number): Promise<SignedIPNSRecord>;
 export { unmarshalIPNSRecord };
-/** A target that can receive a signed IPNS record */
+/**
+ * A target that can receive a signed IPNS record, advertise its current
+ * sequence, or both.
+ *
+ * - `publish` is called by `publishIPNSRecord` to actually store the record
+ *   on the target's backing service. Targets without `publish` are skipped
+ *   during the fan-out (e.g. a sequence-only source).
+ * - `resolveSequence` is consulted by `publishIPNSRecord` to compute the
+ *   next IPNS sequence. The first target to return a value (including
+ *   `null` for "never published") wins. Throw to indicate a transient
+ *   error — the caller will try the next target.
+ *
+ * Most real targets (e.g. a storage connector) provide both. A simple
+ * "track sequence in localStorage" target only needs `resolveSequence`.
+ */
 export interface IPNSPublishTarget {
     name: string;
-    publish(ipnsName: string, recordBytes: Uint8Array): Promise<void>;
+    publish?(ipnsName: string, recordBytes: Uint8Array): Promise<void>;
+    resolveSequence?(ipnsName: string): Promise<bigint | null>;
 }
 /**
- * Resolve current IPNS sequence number from a naming service.
+ * Resolve the current IPNS sequence from a generic naming service.
  * Returns null if the name was never published (404).
- * Throws on network/server errors.
+ * Throws on network/server errors so the caller can try a different target.
  */
 export declare function resolveIPNSSequence(nameServiceUrl: string, ipnsName: string): Promise<bigint | null>;
+/**
+ * Options for {@link publishIPNSRecord}.
+ */
+export interface PublishIPNSRecordOptions {
+    /**
+     * Max number of times to bump the sequence on "existing >= new" conflict.
+     * Defaults to 3. Each bump re-signs the record with a higher sequence
+     * and retries all targets.
+     */
+    maxSequenceBumps?: number;
+}
 /**
  * Create a signed IPNS record and publish to all configured targets.
- * Resolves sequence from sequenceServiceUrl, creates record once, fans out.
- * Throws if ALL targets fail; warns on partial failure.
+ *
+ * Sequence resolution: walks `targets` in order asking each one with a
+ * `resolveSequence` method. The first target to successfully return a value
+ * (including `null` for "never published") determines the next sequence.
+ * If every target throws or none supports `resolveSequence`, falls back to 0n.
+ *
+ * Publish fan-out: only targets with a `publish` method are called.
+ * Throws if every publish-capable target fails; partial failures are logged.
+ *
+ * **Sequence-coherence retry:** if a publish target rejects with the Kubo
+ * "existing IPNS record has sequence X >= new record sequence Y" error,
+ * the function parses `X`, bumps the sequence to `max(X + 1n, Y + 1n)`,
+ * re-signs the record, and retries (up to `maxSequenceBumps` times).
+ * This is the "increment and clobber" mechanism that recovers from
+ * sequence drift without requiring server-side `--force` support.
  */
-export declare function publishIPNSRecord(privateKey: Uint8Array, cid: CID, targets: IPNSPublishTarget[], sequenceServiceUrl?: string): Promise<SignedIPNSRecord>;
+export declare function publishIPNSRecord(privateKey: Uint8Array, cid: CID, targets: IPNSPublishTarget[], options?: PublishIPNSRecordOptions): Promise<SignedIPNSRecord>;
 //# sourceMappingURL=ipns-record.d.ts.map

package/dist/ipns/ipns-record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ipns-record.d.ts","sourceRoot":"","sources":["../../src/ipns/ipns-record.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,mBAAmB,EAAE,MAAM,MAAM,CAAA;AAI/E,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAE3C,MAAM,WAAW,gBAAgB;IAChC,WAAW,EAAE,UAAU,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CAChB;AAED,sEAAsE;AACtE,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,UAAU,GAAG,MAAM,CAGvE;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC3C,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,EAChB,UAAU,SAA4B,GACpC,OAAO,CAAC,gBAAgB,CAAC,CAO3B;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA;AAE9B,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACjE;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACxC,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA0BxB;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACtC,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,iBAAiB,EAAE,EAC5B,kBAAkB,SAA8B,GAC9C,OAAO,CAAC,gBAAgB,CAAC,CAuB3B"}
+{"version":3,"file":"ipns-record.d.ts","sourceRoot":"","sources":["../../src/ipns/ipns-record.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,mBAAmB,EAAE,MAAM,MAAM,CAAA;AAI/E,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAE3C,MAAM,WAAW,gBAAgB;IAChC,WAAW,EAAE,UAAU,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CAChB;AAED,sEAAsE;AACtE,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,UAAU,GAAG,MAAM,CAGvE;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC3C,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,EAChB,UAAU,SAA4B,GACpC,OAAO,CAAC,gBAAgB,CAAC,CAO3B;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAA;AAE9B;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClE,eAAe,CAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;CAC1D;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACxC,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA2BxB;AAKD;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,iBAAiB,CACtC,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,iBAAiB,EAAE,EAC5B,OAAO,CAAC,EAAE,wBAAwB,GAChC,OAAO,CAAC,gBAAgB,CAAC,CAkF3B"}

package/dist/ipns/ipns-w3name.d.ts

@@ -0,0 +1,45 @@
+import type { IPNSPublishTarget } from '@wovin/core/ipns';
+import { CID } from 'multiformats/cid';
+import * as W3Name from 'w3name';
+/**
+ * Publish CID to IPNS, automatically handling increment vs v0.
+ * Returns the revision for further processing (e.g., Kubo integration).
+ */
+export declare function publishIPNS(ipnsPrivateKey: Uint8Array, cid: CID): Promise<W3Name.Revision>;
+/**
+ * Resolve the current IPNS sequence from a zt.ax-compatible naming service.
+ *
+ * The naming service API uses the simple W3NameRecord format:
+ *   `GET <baseUrl>/<ipnsName>` → `{ value: "/ipfs/<cid>", seq?: number, validity?: string }`
+ *
+ * Also supports the legacy w3name record format (`{ record: "<base64>", value: "..." }`)
+ * for backward compatibility with hybrid services.
+ */
+export declare function resolveZtaxSequence(baseUrl: string, ipnsName: string): Promise<bigint | null>;
+/**
+ * Create an IPNSPublishTarget that publishes to a zt.ax naming service.
+ *
+ * Uses HTTP POST to publish signed IPNS records and HTTP GET to resolve
+ * the current sequence number, following the same wire format as the
+ * standard w3name API but at a configurable base URL.
+ *
+ * The naming service is expected to support:
+ *   - `POST <baseUrl>/<ipnsName>` — publish signed IPNS record (base64-encoded body)
+ *   - `GET  <baseUrl>/<ipnsName>` — resolve current record (`{ value, seq?, record? }`)
+ *
+ * @param baseUrl - Base URL of the naming service (default: https://ipfs.zt.ax)
+ */
+export declare function ztaxTarget(baseUrl?: string): IPNSPublishTarget;
+/**
+ * Create an IPNSPublishTarget for the w3name service.
+ *
+ * @deprecated w3name is shut down for publishing. This target is kept as a
+ * read‑only backup for sequence resolution only (no publish method).
+ * Use {@link ztaxTarget} for all publishing.
+ *
+ * @param serviceUrl - Base URL of the w3name-compatible service (default: https://name.web3.storage)
+ */
+export declare function w3nameTarget(serviceUrl?: string): IPNSPublishTarget;
+export declare function generateIpnsKey(): Promise<W3Name.WritableName>;
+export declare function getW3NamePublic(pk: Uint8Array): Promise<string>;
+//# sourceMappingURL=ipns-w3name.d.ts.map

package/dist/ipns/ipns-w3name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipns-w3name.d.ts","sourceRoot":"","sources":["../../src/ipns/ipns-w3name.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAIzD,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACtC,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAwChC;;;GAGG;AACH,wBAAsB,WAAW,CAAC,cAAc,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAMhG;AA6BD;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmCxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,OAAO,SAAuB,GAAG,iBAAiB,CA0B5E;AAMD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,UAAU,SAA8B,GAAG,iBAAiB,CAQxF;AAID,wBAAsB,eAAe,iCAEpC;AAED,wBAAsB,eAAe,CAAC,EAAE,EAAE,UAAU,mBAGnD"}

package/dist/ipns/ipns-watcher.d.ts

@@ -0,0 +1,190 @@
+import { CID } from 'multiformats/cid';
+import { type Options as PartysocketOptions } from 'partysocket/ws';
+export type { PartysocketOptions };
+export interface W3NameRecord {
+    value: string;
+    seq?: number;
+    validity?: string;
+}
+/**
+ * Debug info provided when a stale WebSocket connection is detected.
+ */
+export interface StaleConnectionInfo {
+    /** When the WebSocket connection was established */
+    connectedAt: Date;
+    /** When we last received a WebSocket message */
+    lastMessageAt: Date | null;
+    /** How long since last message (ms) */
+    silenceDuration: number;
+    /** The stale value from WebSocket */
+    staleValue: string | null;
+    /** The current value from HTTP */
+    currentValue: string;
+}
+/**
+ * Enriched IPNS update with parsed CID and change detection.
+ * Backwards compatible - `.value` still works as before.
+ */
+export interface IpnsUpdate {
+    /** Raw IPNS value string (e.g. '/ipfs/bafy...') — same as W3NameRecord.value */
+    value: string;
+    /** Parsed CID if value is valid IPFS path, null otherwise */
+    cid: CID | null;
+    /** Previous value (null on first update) */
+    lastValue: string | null;
+    /** Whether this is a change from lastValue */
+    isNew: boolean;
+    /** Original W3NameRecord for access to seq/validity */
+    record: W3NameRecord;
+}
+export interface WatchRawOptions {
+    /** Called when the IPNS record is updated */
+    onUpdate: (record: W3NameRecord) => void;
+    /** Called when an error occurs */
+    onError?: (error: Event | Error) => void;
+    /** Called when the connection is opened */
+    onOpen?: () => void;
+    /** Called when the connection is closed */
+    onClose?: (event: CloseEvent) => void;
+}
+export interface WatchRawSubscription {
+    /** Close the WebSocket connection */
+    close: () => void;
+    /** The underlying WebSocket instance */
+    ws: WebSocket;
+}
+/**
+ * Low-level WebSocket watcher for IPNS (no reconnect logic).
+ * Use this when you want full control over connection lifecycle.
+ * For most cases, prefer `watchName` or `IpnsWatcher` which handle reconnection.
+ *
+ * @param nameBaseUrl - Base URL of a naming service that supports `/name/<ipns>/watch` (WebSocket) and `/name/<ipns>` (HTTP)
+ * @param name - The IPNS name/key to watch
+ * @param options - Callback options
+ * @returns Subscription with close() and ws
+ *
+ * @example
+ * ```ts
+ * const sub = watchNameRaw('https://name.example.com', 'k51qzi5u...', {
+ *   onUpdate: (record) => console.log('Update:', record.value),
+ *   onClose: () => console.log('Disconnected - handle reconnect yourself'),
+ * })
+ * ```
+ */
+export declare function watchNameRaw(nameBaseUrl: string, name: string, options: WatchRawOptions): WatchRawSubscription;
+export interface IpnsWatcherOptions {
+    /** Called when the IPNS record is updated (enriched payload with CID and change detection) */
+    onUpdate: (update: IpnsUpdate) => void | Promise<void>;
+    /** Called when an error occurs */
+    onError?: (error: Error | Event) => void;
+    /** Called when the connection is opened/reconnected */
+    onConnected?: () => void;
+    /** Called when the connection is closed */
+    onDisconnected?: () => void;
+    /** Fetch current IPNS state on first connect (default: false) */
+    fetchInitialState?: boolean;
+    /** Fetch current IPNS state on reconnect to catch missed updates (default: true) */
+    catchUpOnReconnect?: boolean;
+    /** If true, call onUpdate even when value hasn't changed (default: false) */
+    includeUnchanged?: boolean;
+    /**
+     * Enable periodic liveness checks via HTTP to detect zombie connections (default: true).
+     * When enabled, periodically fetches current IPNS value and forces reconnect if it
+     * differs from the last WebSocket update.
+     */
+    livenessCheck?: boolean;
+    /**
+     * Liveness check interval in milliseconds (default: 3600000 = 1 hour).
+     * Only used when livenessCheck is enabled.
+     */
+    livenessCheckInterval?: number;
+    /**
+     * Called when a stale connection is detected (WebSocket missed updates).
+     * Provides debug info about the connection state.
+     */
+    onStaleConnection?: (info: StaleConnectionInfo) => void;
+    /**
+     * Partysocket options (passed through to ReconnectingWebSocket).
+     * Useful options: startClosed, maxReconnectionDelay, minReconnectionDelay, etc.
+     * @see https://github.com/partykit/partykit/tree/main/packages/partysocket
+     */
+    wsOptions?: PartysocketOptions;
+}
+export declare class IpnsWatcher {
+    private name;
+    private nameBaseUrl;
+    private ws;
+    private lastKnownValue;
+    private options;
+    private isFirstConnect;
+    private livenessTimer;
+    private connectedAt;
+    private lastMessageAt;
+    constructor(nameBaseUrl: string, name: string, options: IpnsWatcherOptions);
+    /**
+     * Resolve current IPNS value via HTTP API to catch missed updates
+     */
+    private checkForMissedUpdates;
+    /**
+     * Start periodic liveness checks to detect zombie connections.
+     */
+    private startLivenessCheck;
+    /**
+     * Stop periodic liveness checks.
+     */
+    private stopLivenessCheck;
+    /**
+     * Perform a single liveness check via HTTP.
+     * If the HTTP value differs from lastKnownValue, the connection is stale.
+     */
+    private performLivenessCheck;
+    /**
+     * Manually start/reconnect the WebSocket.
+     * Only needed if you used `wsOptions: { startClosed: true }`.
+     */
+    start(): void;
+    /**
+     * Alias for close() - for backward compatibility
+     */
+    stop(): void;
+    /**
+     * Close the WebSocket connection and stop watching
+     */
+    close(): void;
+    /**
+     * Get the last known IPNS value
+     */
+    get lastValue(): string | null;
+    /**
+     * Get the WebSocket ready state
+     */
+    get readyState(): number;
+}
+/**
+ * Create an IPNS watcher with auto-reconnect and catch-up logic.
+ * Convenience function that creates and returns an IpnsWatcher instance.
+ *
+ * @param nameBaseUrl - Base URL of a naming service that supports `/name/<ipns>/watch` (WebSocket) and `/name/<ipns>` (HTTP)
+ * @param name - The IPNS name/key to watch (e.g. "k51qzi5u...")
+ * @param options - Callback options for handling events
+ * @returns An IpnsWatcher instance with close() method
+ */
+export declare function watchName(nameBaseUrl: string, name: string, options: IpnsWatcherOptions): IpnsWatcher;
+/**
+ * Watch an IPNS name and return updates as an async iterator.
+ * Includes auto-reconnect - iterator continues through disconnections.
+ *
+ * @param nameBaseUrl - Base URL of a naming service that supports `/name/<ipns>/watch` (WebSocket) and `/name/<ipns>` (HTTP)
+ * @param name - The IPNS name/key to watch
+ * @param signal - Optional AbortSignal to stop the watch
+ *
+ * @example
+ * ```ts
+ * const controller = new AbortController()
+ * for await (const update of watchNameIterator('https://name.example.com', 'k51qzi5u...', controller.signal)) {
+ *   console.log('Update:', update.cid?.toString())
+ * }
+ * ```
+ */
+export declare function watchNameIterator(nameBaseUrl: string, name: string, signal?: AbortSignal): AsyncGenerator<IpnsUpdate, void, unknown>;
+//# sourceMappingURL=ipns-watcher.d.ts.map

package/dist/ipns/ipns-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipns-watcher.d.ts","sourceRoot":"","sources":["../../src/ipns/ipns-watcher.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACtC,OAA8B,EAAE,KAAK,OAAO,IAAI,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAE1F,YAAY,EAAE,kBAAkB,EAAE,CAAA;AAmClC,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,oDAAoD;IACpD,WAAW,EAAE,IAAI,CAAA;IACjB,gDAAgD;IAChD,aAAa,EAAE,IAAI,GAAG,IAAI,CAAA;IAC1B,uCAAuC;IACvC,eAAe,EAAE,MAAM,CAAA;IACvB,qCAAqC;IACrC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,kCAAkC;IAClC,YAAY,EAAE,MAAM,CAAA;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IAC1B,gFAAgF;IAChF,KAAK,EAAE,MAAM,CAAA;IACb,6DAA6D;IAC7D,GAAG,EAAE,GAAG,GAAG,IAAI,CAAA;IACf,4CAA4C;IAC5C,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,8CAA8C;IAC9C,KAAK,EAAE,OAAO,CAAA;IACd,uDAAuD;IACvD,MAAM,EAAE,YAAY,CAAA;CACpB;AAiBD,MAAM,WAAW,eAAe;IAC/B,6CAA6C;IAC7C,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAA;IACxC,kCAAkC;IAClC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,KAAK,IAAI,CAAA;IACxC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,IAAI,CAAA;IACnB,2CAA2C;IAC3C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;CACrC;AAED,MAAM,WAAW,oBAAoB;IACpC,qCAAqC;IACrC,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,wCAAwC;IACxC,EAAE,EAAE,SAAS,CAAA;CACb;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,oBAAoB,CAyC9G;AAED,MAAM,WAAW,kBAAkB;IAClC,8FAA8F;IAC9F,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACtD,kCAAkC;IAClC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,KAAK,IAAI,CAAA;IACxC,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;IACxB,2CAA2C;IAC3C,cAAc,CAAC,EAAE,MAAM,IAAI,CAAA;IAC3B,iEAAiE;IACjE,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,oFAAoF;IACpF,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,CAAA;IACvD;;;;OAIG;IACH,SAAS,CAAC,EAAE,kBAAkB,CAAA;CAC9B;AAmBD,qBAAa,WAAW;IACvB,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,EAAE,CAAuB;IACjC,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,cAAc,CAAO;IAC7B,OAAO,CAAC,aAAa,CAA8C;IACnE,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,aAAa,CAAoB;gBAE7B,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB;IAmG1E;;OAEG;YACW,qBAAqB;IAkDnC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;;OAGG;YACW,oBAAoB;IA6ElC;;;OAGG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,IAAI,IAAI,IAAI;IAIZ;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,GAAG,IAAI,CAE7B;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;CACD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAErG;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAuB,iBAAiB,CACvC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,WAAW,GAClB,cAAc,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,CAAC,CAsC3C"}

package/dist/ipns.d.ts

@@ -1,2 +1,5 @@
+export * from './ipns/gateway-resolver.ts';
 export * from './ipns/ipns-record.ts';
+export * from './ipns/ipns-w3name.ts';
+export * from './ipns/ipns-watcher.ts';
 //# sourceMappingURL=ipns.d.ts.map

package/dist/ipns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ipns.d.ts","sourceRoot":"","sources":["../src/ipns.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA"}
+{"version":3,"file":"ipns.d.ts","sourceRoot":"","sources":["../src/ipns.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,uBAAuB,CAAA;AACrC,cAAc,uBAAuB,CAAA;AACrC,cAAc,wBAAwB,CAAA"}