@leofcoin/peernet 1.2.29 → 1.2.30

package/exports/peernet.js

@@ -301,6 +301,196 @@ const nothingFoundError = (hash) => {
     return new Error(`nothing found for ${hash}`);
 };
 
+/** A resumable download. Completed chunks remain cached on the transfer instance. */
+class FileTransfer {
+    hash;
+    state = 'idle';
+    result;
+    error;
+    #fetch;
+    #decode;
+    #verify;
+    #pin;
+    #verifyManifest;
+    #concurrency;
+    #stopped = false;
+    #listeners = new Set();
+    #chunks = new Map();
+    #resumeWaiters = [];
+    #resolve;
+    #reject;
+    #totalChunks = 0;
+    #totalBytes = 0;
+    #started = false;
+    constructor(options) {
+        this.hash = options.hash;
+        this.#fetch = options.fetch;
+        this.#decode = options.decode;
+        this.#verify = options.verify;
+        this.#pin = options.pin;
+        this.#verifyManifest = options.verifyManifest !== false;
+        this.#concurrency = options.concurrency ?? 4;
+        if (!Number.isSafeInteger(this.#concurrency) || this.#concurrency <= 0)
+            throw new TypeError('concurrency must be a positive integer');
+        this.result = new Promise((resolve, reject) => {
+            this.#resolve = resolve;
+            this.#reject = reject;
+        });
+    }
+    get progress() {
+        let transferredBytes = 0;
+        for (const chunk of this.#chunks.values())
+            transferredBytes += chunk.length;
+        return {
+            hash: this.hash,
+            state: this.state,
+            completedChunks: this.#chunks.size,
+            totalChunks: this.#totalChunks,
+            transferredBytes,
+            totalBytes: this.#totalBytes
+        };
+    }
+    onProgress(listener) {
+        this.#listeners.add(listener);
+        listener(this.progress);
+        return () => this.#listeners.delete(listener);
+    }
+    start() {
+        if (!this.#started) {
+            this.#started = true;
+            this.state = 'running';
+            this.#emit();
+            void this.#run();
+        }
+        return this;
+    }
+    pause() {
+        if (this.state === 'running') {
+            this.state = 'paused';
+            this.#emit();
+        }
+    }
+    resume() {
+        if (this.state !== 'paused')
+            return;
+        this.state = 'running';
+        const waiters = this.#resumeWaiters.splice(0);
+        for (const resolve of waiters)
+            resolve();
+        this.#emit();
+    }
+    cancel() {
+        if (this.state === 'completed' || this.state === 'failed' || this.state === 'cancelled')
+            return;
+        this.state = 'cancelled';
+        this.#stopped = true;
+        const error = new Error(`Transfer ${this.hash} was cancelled`);
+        this.error = error;
+        const waiters = this.#resumeWaiters.splice(0);
+        for (const resolve of waiters)
+            resolve();
+        this.#reject(error);
+        this.#emit();
+    }
+    async #waitUntilRunning() {
+        if (this.state === 'paused')
+            await new Promise((resolve) => this.#resumeWaiters.push(resolve));
+        if (this.state === 'cancelled')
+            throw this.error;
+    }
+    async #run() {
+        try {
+            const manifestData = await this.#fetch(this.hash);
+            if (!manifestData)
+                throw new Error(`Unable to download ${this.hash}`);
+            if (this.#verifyManifest && !(await this.#verify(manifestData, this.hash)))
+                throw new Error(`Manifest hash mismatch for ${this.hash}`);
+            const manifest = await this.#decode(manifestData);
+            if (this.#pin)
+                await this.#pin(this.hash, manifestData);
+            if (!manifest.chunked) {
+                if (manifest.links?.length)
+                    throw new Error(`${this.hash} is a directory`);
+                const content = manifest.content || new Uint8Array();
+                this.#totalChunks = 1;
+                this.#totalBytes = content.length;
+                this.#chunks.set(0, content);
+                this.state = 'completed';
+                this.#resolve(content);
+                this.#emit();
+                return;
+            }
+            const links = manifest.links || [];
+            this.#totalChunks = links.length;
+            this.#totalBytes =
+                Number(manifest.size) || links.reduce((sum, link) => sum + (Number(link.size) || 0), 0);
+            this.#emit();
+            let nextIndex = 0;
+            const worker = async () => {
+                while (!this.#stopped) {
+                    await this.#waitUntilRunning();
+                    const index = nextIndex++;
+                    if (index >= links.length)
+                        return;
+                    if (this.#chunks.has(index))
+                        continue;
+                    const encoded = await this.#fetch(links[index].hash, index);
+                    if (this.#stopped)
+                        return;
+                    if (!encoded)
+                        throw new Error(`Missing chunk ${index + 1}/${links.length}`);
+                    if (!(await this.#verify(encoded, links[index].hash)))
+                        throw new Error(`Hash mismatch for chunk ${index + 1}`);
+                    const chunkNode = await this.#decode(encoded);
+                    const content = chunkNode.content || new Uint8Array();
+                    this.#chunks.set(index, content);
+                    if (this.#pin)
+                        await this.#pin(links[index].hash, encoded);
+                    this.#emit();
+                }
+            };
+            await Promise.all(Array.from({ length: Math.min(this.#concurrency, links.length) }, () => worker()));
+            const output = new Uint8Array(this.#totalBytes);
+            let offset = 0;
+            for (let index = 0; index < this.#totalChunks; index++) {
+                const chunk = this.#chunks.get(index);
+                if (!chunk)
+                    throw new Error(`Missing downloaded chunk ${index + 1}`);
+                output.set(chunk, offset);
+                offset += chunk.length;
+            }
+            this.state = 'completed';
+            this.#resolve(offset === output.length ? output : output.slice(0, offset));
+            this.#emit();
+        }
+        catch (error) {
+            if (this.state === 'cancelled')
+                return;
+            this.state = 'failed';
+            this.#stopped = true;
+            this.error = error;
+            this.#reject(error);
+            this.#emit();
+        }
+    }
+    #emit() {
+        const progress = this.progress;
+        for (const listener of this.#listeners)
+            listener(progress);
+    }
+}
+
+const DEFAULT_CHUNK_SIZE = 256 * 1024;
+const DEFAULT_BLOCK_CHUNK_SIZE = 256 * 1024;
+const DEFAULT_BLOCK_CHUNK_THRESHOLD = 1024 * 1024;
+const DEFAULT_TRANSFER_CONCURRENCY = 4;
+const adaptiveChunkSize = (size, minimum = DEFAULT_CHUNK_SIZE) => {
+    if (size >= 256 * 1024 * 1024)
+        return Math.max(minimum, 4 * 1024 * 1024);
+    if (size >= 32 * 1024 * 1024)
+        return Math.max(minimum, 1024 * 1024);
+    return minimum;
+};
 globalThis.LeofcoinStorage = Storage;
 globalThis.leofcoin = globalThis.leofcoin || {};
 globalThis.pubsub = globalThis.pubsub || new PubSub();
@@ -338,6 +528,9 @@ class Peernet {
     _peerHandler;
     protos;
     version;
+    blockChunkSize;
+    blockChunkThreshold;
+    transferConcurrency;
     #peerAttempts = {};
     _inMemoryBroadcasts;
     /**
@@ -364,6 +557,15 @@ class Peernet {
         this.stars = options.stars;
         this.transport = options.transport;
         this.version = options.version;
+        this.blockChunkSize = options.blockChunkSize ?? DEFAULT_BLOCK_CHUNK_SIZE;
+        this.blockChunkThreshold = options.blockChunkThreshold ?? DEFAULT_BLOCK_CHUNK_THRESHOLD;
+        this.transferConcurrency = options.transferConcurrency ?? DEFAULT_TRANSFER_CONCURRENCY;
+        if (!Number.isSafeInteger(this.blockChunkSize) || this.blockChunkSize <= 0)
+            throw new TypeError('blockChunkSize must be a positive integer');
+        if (!Number.isSafeInteger(this.blockChunkThreshold) || this.blockChunkThreshold < 0)
+            throw new TypeError('blockChunkThreshold must be a non-negative integer');
+        if (!Number.isSafeInteger(this.transferConcurrency) || this.transferConcurrency <= 0)
+            throw new TypeError('transferConcurrency must be a positive integer');
         const parts = this.network.split(':');
         this.networkVersion = options.networkVersion || parts.length > 1 ? parts[1] : 'mainnet';
         if (!options.storePrefix)
@@ -456,7 +658,7 @@ class Peernet {
         await getAddress();
         this.storePrefix = options.storePrefix;
         this.root = options.root;
-        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-CHKVVTVE.js');
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-0uXHmQH7.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -592,12 +794,34 @@ class Peernet {
    
      * @returns {Promise<string>} The hash that can be shared for direct download
      */
-    async broadcast(path, { content, links }) {
+    async broadcast(path, { content, links, chunkSize }) {
+        chunkSize = chunkSize ?? (content ? adaptiveChunkSize(content.length) : DEFAULT_CHUNK_SIZE);
+        if (!Number.isSafeInteger(chunkSize) || chunkSize <= 0)
+            throw new TypeError('chunkSize must be a positive integer');
         let protoInput;
-        if (content)
-            protoInput = { path, content };
+        if (content && content.length > chunkSize) {
+            const chunkLinks = [];
+            for (let offset = 0, index = 0; offset < content.length; offset += chunkSize, index++) {
+                const chunkNode = await new globalThis.peernet.protos['peernet-file']({
+                    path: `${path}.part-${index}`,
+                    content: content.slice(offset, Math.min(offset + chunkSize, content.length))
+                });
+                const chunkHash = await chunkNode.hash();
+                const chunkEncoded = await chunkNode.encoded;
+                if (!this._inMemoryBroadcasts)
+                    this._inMemoryBroadcasts = new Map();
+                this._inMemoryBroadcasts.set(chunkHash, chunkEncoded);
+                await shareStore.put(chunkHash, chunkEncoded);
+                chunkLinks.push({ hash: chunkHash, path: String(index), size: chunkNode.decoded.content.length });
+            }
+            protoInput = { path, links: chunkLinks, size: content.length, chunkSize, chunked: true };
+        }
+        else if (content)
+            protoInput = { path, content, size: content.length };
         else if (links)
             protoInput = { path, links };
+        else
+            throw new TypeError('broadcast requires content or links');
         const protoNode = await new globalThis.peernet.protos['peernet-file'](protoInput);
         const hash = await protoNode.hash();
         const encoded = await protoNode.encoded;
@@ -609,6 +833,46 @@ class Peernet {
         await this.publish('broadcast', { hash, from: this.id });
         return hash;
     }
+    /** Create and immediately start a resumable, integrity-checked file download. */
+    download(hash, options = {}) {
+        const FileProto = globalThis.peernet.protos['peernet-file'];
+        const transfer = new FileTransfer({
+            hash,
+            fetch: async (wantedHash, index) => {
+                if (wantedHash !== hash) {
+                    const providers = Object.values(this.dht.providersFor(hash) || {});
+                    for (const provider of providers)
+                        this.dht.addProvider(provider, wantedHash);
+                }
+                const store = await this.whichStore([...this.stores], wantedHash);
+                if (store && (await store.has(wantedHash)))
+                    return store.get(wantedHash);
+                const result = await this.requestData(wantedHash, undefined, { providerIndex: index });
+                return result;
+            },
+            decode: async (encoded) => {
+                const node = await new FileProto(encoded);
+                await node.decode();
+                if (node.decoded?.chunked) {
+                    const providers = Object.values(this.dht.providersFor(hash) || {});
+                    for (const link of node.decoded.links || []) {
+                        for (const provider of providers)
+                            this.dht.addProvider(provider, link.hash);
+                    }
+                }
+                return node.decoded;
+            },
+            concurrency: this.transferConcurrency,
+            verify: async (encoded, expectedHash) => {
+                const node = await new FileProto(encoded);
+                return (await node.hash()) === expectedHash;
+            },
+            pin: options.pin ? (chunkHash, encoded) => dataStore.put(chunkHash, encoded) : undefined
+        });
+        if (options.autoStart !== false)
+            transfer.start();
+        return transfer;
+    }
     async handleData(peer, id, proto) {
         let { hash, store } = proto.decoded;
         let data;
@@ -619,15 +883,9 @@ class Peernet {
                 if (typeof hash === 'function') {
                     resolvedHash = await hash();
                 }
-                // Decode the stored proto to extract the content or links
-                const FileProto = globalThis.peernet.protos['peernet-file'];
-                const fileProto = await new FileProto(data);
-                await fileProto.decode();
-                const { content, links } = fileProto.decoded;
-                console.log(links);
                 data = await new globalThis.peernet.protos['peernet-data-response']({
                     hash: resolvedHash,
-                    data: links || content
+                    data
                 });
                 const node = await this.prepareMessage(data);
                 await this.sendMessage(peer, id, node.encoded);
@@ -783,18 +1041,92 @@ class Peernet {
     get block() {
         return {
             get: async (hash) => {
-                const data = await blockStore.has(hash);
-                if (data)
-                    return blockStore.get(hash);
-                return this.requestData(hash, 'block');
+                return this.#createBlockTransfer(hash).result;
             },
             put: async (hash, data) => {
                 if (await blockStore.has(hash))
                     return;
+                if (data.length > this.blockChunkThreshold)
+                    return this.#putChunkedBlock(hash, data);
                 return await blockStore.put(hash, data);
             },
-            has: async (hash) => await blockStore.has(hash)
+            has: async (hash) => await blockStore.has(hash),
+            download: (hash, options = {}) => this.#createBlockTransfer(hash, options)
+        };
+    }
+    async #putChunkedBlock(hash, data) {
+        const links = [];
+        const FileProto = globalThis.peernet.protos['peernet-file'];
+        const chunkSize = adaptiveChunkSize(data.length, this.blockChunkSize);
+        for (let offset = 0, index = 0; offset < data.length; offset += chunkSize, index++) {
+            const content = data.slice(offset, Math.min(offset + chunkSize, data.length));
+            const chunk = new FileProto({ path: `block-${hash}.part-${index}`, content });
+            const chunkHash = await chunk.hash();
+            await blockStore.put(chunkHash, chunk.encoded);
+            links.push({ hash: chunkHash, path: String(index).padStart(12, '0'), size: content.length });
+        }
+        const manifest = new FileProto({
+            path: `block-${hash}`,
+            links,
+            size: data.length,
+            chunkSize,
+            chunked: true,
+            kind: 'block',
+            blockHash: hash
+        });
+        return blockStore.put(hash, manifest.encoded);
+    }
+    #createBlockTransfer(hash, options = {}) {
+        const FileProto = globalThis.peernet.protos['peernet-file'];
+        const fetch = async (wantedHash, index) => {
+            if (wantedHash !== hash) {
+                const providers = Object.values(this.dht.providersFor(hash) || {});
+                for (const provider of providers)
+                    this.dht.addProvider(provider, wantedHash);
+            }
+            if (await blockStore.has(wantedHash))
+                return blockStore.get(wantedHash);
+            const result = await this.requestData(wantedHash, 'block', { providerIndex: index });
+            return result;
         };
+        const transfer = new FileTransfer({
+            hash,
+            fetch,
+            decode: async (encoded) => {
+                let node;
+                try {
+                    node = new FileProto(encoded);
+                    await node.decode();
+                }
+                catch {
+                    // A normal block is intentionally not a peernet-file envelope.
+                    return { content: encoded };
+                }
+                if (node.decoded?.kind === 'block') {
+                    if (node.decoded.blockHash !== hash)
+                        throw new Error(`Block manifest hash mismatch for ${hash}`);
+                    const providers = Object.values(this.dht.providersFor(hash) || {});
+                    for (const link of node.decoded.links || []) {
+                        for (const provider of providers)
+                            this.dht.addProvider(provider, link.hash);
+                    }
+                    return node.decoded;
+                }
+                if (node.decoded?.path?.startsWith(`block-${hash}.part-`))
+                    return node.decoded;
+                return { content: encoded };
+            },
+            verify: async (encoded, expectedHash) => {
+                const node = new FileProto(encoded);
+                return (await node.hash()) === expectedHash;
+            },
+            verifyManifest: false,
+            concurrency: this.transferConcurrency,
+            pin: (wantedHash, encoded) => blockStore.put(wantedHash, encoded)
+        });
+        if (options.autoStart !== false)
+            transfer.start();
+        return transfer;
     }
     get transaction() {
         return {
@@ -812,14 +1144,17 @@ class Peernet {
             has: async (hash) => await transactionStore.has(hash)
         };
     }
-    async requestData(hash, store) {
+    async requestData(hash, store, options = {}) {
         try {
             const providers = await this.providersFor(hash);
             if (!providers || (providers && Object.keys(providers).length === 0))
                 throw nothingFoundError(hash);
             debug(`found ${Object.keys(providers).length} provider(s) for ${hash}`);
             // get closest peer on earth
-            let closestPeer = await this.dht.closestPeer(Object.values(providers));
+            const providerValues = Object.values(providers);
+            let closestPeer = options.providerIndex === undefined
+                ? await this.dht.closestPeer(providerValues)
+                : providerValues[options.providerIndex % providerValues.length];
             // fallback to first provider if no closest peer found
             if (!closestPeer || !closestPeer.id)
                 closestPeer = Object.values(providers)[0];
@@ -831,7 +1166,7 @@ class Peernet {
             const peer = this.connections[id];
             if (!peer || !peer?.connected) {
                 this.dht.removeProvider(id, hash);
-                return this.requestData(hash, store?.name || store);
+                return this.requestData(hash, store?.name || store, options);
             }
             let data = await new globalThis.peernet.protos['peernet-data']({
                 hash,
@@ -874,7 +1209,7 @@ class Peernet {
                     if (this.#peerAttempts[id] === undefined)
                         this.#peerAttempts[id] = 0;
                     this.#peerAttempts[id]++;
-                    return this.requestData(hash, store?.name || store);
+                    return this.requestData(hash, store?.name || store, options);
                 }
                 // this.put(hash, proto.decoded.data)
             }
@@ -1051,18 +1386,8 @@ class Peernet {
         return paths;
     }
     async cat(hash, options) {
-        let data;
-        const has = await dataStore.has(hash);
-        data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
-        if (!data)
-            throw nothingFoundError(hash);
-        const node = await new globalThis.peernet.protos['peernet-file'](data);
-        await node.decode();
-        if (node.decoded?.links.length > 0)
-            throw new Error(`${hash} is a directory`);
-        if (options?.pin)
-            await dataStore.put(hash, node.encoded);
-        return node.decoded.content;
+        const transfer = this.download(hash, { pin: options?.pin });
+        return transfer.result;
     }
     /**
      * goes trough given stores and tries to find data for given hash
@@ -1174,4 +1499,4 @@ class Peernet {
 }
 globalThis.Peernet = Peernet;
 
-export { Peernet as default };
+export { FileTransfer, Peernet as default };

package/exports/types/file-transfer.d.ts

@@ -0,0 +1,34 @@
+export type FileTransferState = 'idle' | 'running' | 'paused' | 'completed' | 'cancelled' | 'failed';
+export type FileTransferProgress = {
+    hash: string;
+    state: FileTransferState;
+    completedChunks: number;
+    totalChunks: number;
+    transferredBytes: number;
+    totalBytes: number;
+};
+type ProgressListener = (progress: FileTransferProgress) => void;
+/** A resumable download. Completed chunks remain cached on the transfer instance. */
+export default class FileTransfer {
+    #private;
+    readonly hash: string;
+    state: FileTransferState;
+    result: Promise<Uint8Array>;
+    error?: unknown;
+    constructor(options: {
+        hash: string;
+        fetch: (hash: string, index?: number) => Promise<Uint8Array | undefined>;
+        decode: (data: Uint8Array) => Promise<any>;
+        verify: (data: Uint8Array, hash: string) => Promise<boolean>;
+        pin?: (hash: string, data: Uint8Array) => Promise<any>;
+        verifyManifest?: boolean;
+        concurrency?: number;
+    });
+    get progress(): FileTransferProgress;
+    onProgress(listener: ProgressListener): () => void;
+    start(): this;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+}
+export {};

package/exports/types/peernet.d.ts

@@ -5,6 +5,7 @@ import MessageHandler from './handlers/message.js';
 import { Storage as LeofcoinStorageClass } from '@leofcoin/storage';
 import Identity from './identity.js';
 import swarm from '@netpeer/swarm/client';
+import FileTransfer from './file-transfer.js';
 declare global {
     var LeofcoinStorage: typeof LeofcoinStorageClass;
     var peernet: Peernet;
@@ -52,6 +53,9 @@ export default class Peernet {
     _peerHandler: PeerDiscovery;
     protos: {};
     version: any;
+    blockChunkSize: number;
+    blockChunkThreshold: number;
+    transferConcurrency: number;
     private _inMemoryBroadcasts;
     /**
      * @access public
@@ -161,10 +165,16 @@ export default class Peernet {
    
      * @returns {Promise<string>} The hash that can be shared for direct download
      */
-    broadcast(path: string, { content, links }: {
+    broadcast(path: string, { content, links, chunkSize }: {
         content?: Uint8Array;
         links?: any[];
+        chunkSize?: number;
     }): Promise<string>;
+    /** Create and immediately start a resumable, integrity-checked file download. */
+    download(hash: string, options?: {
+        pin?: boolean;
+        autoStart?: boolean;
+    }): FileTransfer;
     handleData(peer: any, id: any, proto: any): Promise<any>;
     handleRequest(peer: any, id: any, proto: any): Promise<void>;
     /**
@@ -195,16 +205,21 @@ export default class Peernet {
      */
     providersFor(hash: string, store?: undefined): Promise<import("./dht/dht.js").DHTProviderMapValue>;
     get block(): {
-        get: (hash: string) => Promise<any>;
+        get: (hash: string) => Promise<Uint8Array<ArrayBufferLike>>;
         put: (hash: string, data: Uint8Array) => Promise<unknown>;
         has: (hash: string) => Promise<boolean | any[]>;
+        download: (hash: string, options?: {
+            autoStart?: boolean;
+        }) => FileTransfer;
     };
     get transaction(): {
         get: (hash: string) => Promise<any>;
         put: (hash: string, data: Uint8Array) => Promise<unknown>;
         has: (hash: string) => Promise<boolean | any[]>;
     };
-    requestData(hash: any, store: any): any;
+    requestData(hash: any, store: any, options?: {
+        providerIndex?: number;
+    }): any;
     get message(): {
         /**
          * Get content for given message hash
@@ -304,7 +319,7 @@ export default class Peernet {
         path: any;
         hash: any;
     }[]>;
-    cat(hash: any, options: any): Promise<any>;
+    cat(hash: any, options: any): Promise<Uint8Array<ArrayBufferLike>>;
     /**
      * goes trough given stores and tries to find data for given hash
      * @param {Array} stores
@@ -346,3 +361,4 @@ export default class Peernet {
     removePeer(peer: any): Promise<void>;
     get Buffer(): BufferConstructor;
 }
+export { FileTransfer };

package/exports/types/proto/file.proto.d.ts

@@ -2,5 +2,10 @@ declare const _default: {
     path: string;
     'content?': Uint8Array<ArrayBuffer>;
     'links?': never[];
+    'size?': number;
+    'chunkSize?': number;
+    'chunked?': boolean;
+    'kind?': string;
+    'blockHash?': string;
 };
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.2.29",
+  "version": "1.2.30",
   "description": "",
   "repository": {
     "type": "git",
@@ -96,7 +96,7 @@
   "scripts": {
     "build": "rollup -c",
     "watch": "rollup -c -w",
-    "test": "node --test test/peernet.test.js",
+    "test": "node --test test/peernet.test.js test/file-transfer.test.js",
     "server": "discovery-swarm-webrtc --port=4000",
     "demo": "jsproject --serve ./ --port 6868"
   },

package/rollup.config.js

@@ -28,9 +28,7 @@ const walk = async (dir) => {
 const isHashedChunk = (runtimePath) => /-[A-Za-z0-9_-]{8,}\.js$/.test(runtimePath)
 
 const isPromptImport = (id) =>
-  id === './prompts/password.js' ||
-  id === './src/prompts/password.js' ||
-  id.endsWith('/src/prompts/password.js')
+  id === './prompts/password.js' || id === './src/prompts/password.js' || id.endsWith('/src/prompts/password.js')
 
 const runtimeFirstExports = ({ exportsDir = 'exports', declarationsDir = 'exports/types' } = {}) => ({
   name: 'runtime-first-exports',
@@ -125,9 +123,7 @@ export default [
       })
     ],
     external: (id) =>
-      isPromptImport(id) ||
-      id === './prompts/password/browser.js' ||
-      id === './prompts/password/node.js'
+      isPromptImport(id) || id === './prompts/password/browser.js' || id === './prompts/password/node.js'
   },
   {
     input: ['./src/prompts/password/browser.js'],