weida 0.1.0-alpha.14 → 0.1.0-alpha.16

package/lib/index.d.ts

@@ -1051,12 +1051,14 @@ export class Swarm extends Handle {
 /** Dropping it aborts every order in flight. */
 export class Fetch extends Handle {
   blob(): Blob;
-  /** WEIDA_EINVAL while a `next` is pending. */
   list(): PieceList | null;
-  /** WEIDA_EINVAL while a `next` is pending. */
   delivered(): Bits;
-  /** WEIDA_EINVAL while a `next` is pending. */
   inFlight(): Bits;
+  /** What `next` waits for until a seeder gains it, a copy. */
+  unavailable(): Bits;
+  /** An empty range clears the priority. */
+  prioritize(start: number, end: number): void;
+  clearPriority(): void;
   /** The next verified piece, or null once every piece is held; rejects
    * with WEIDA_ENOT_CONNECTED when no seeder is left. */
   next(options?: WaitOptions): Promise<Piece | null>;
@@ -1080,6 +1082,8 @@ export class SeedSession extends Handle {
   answerList(list: PieceList, options?: WaitOptions): Promise<void>;
   answerHave(have: Bits, options?: WaitOptions): Promise<void>;
   answerPiece(data: Bytes, options?: WaitOptions): Promise<void>;
+  /** Answers PIECE `index` with "no longer held". */
+  answerGone(index: number, options?: WaitOptions): Promise<void>;
   /** Consumes the session. */
   decline(options?: WaitOptions): Promise<void>;
 }
@@ -1154,6 +1158,8 @@ export class RelayRequest extends Handle {
   target(): string | null;
   /** Serves it; consumes the request. */
   admit(options?: WaitOptions): Promise<void>;
+  /** As `admit`, holding a tunnel to `bytesPerSec`; consumes the request. */
+  admitWith(bytesPerSec: Count, options?: WaitOptions): Promise<void>;
   /** Refuses it with WEIDA_EREJECTED; consumes the request. */
   refuse(options?: WaitOptions): Promise<void>;
 }

package/lib/index.js

@@ -2651,25 +2651,44 @@ export class Fetch extends Handle {
   }
 
   /** The piece list once it is known and verified, or null: keep it to
-   * resume without asking for it (`{ list }`). WEIDA_EINVAL while a `next`
-   * is pending. */
+   * resume without asking for it (`{ list }`). A pending `next` goes on
+   * unharmed. */
   list() {
     const list = native.fetchList(this[HANDLE]);
     return list === null ? null : adopt(PieceList, list);
   }
 
   /** The pieces the caller holds: those it started with and those this
-   * fetch yielded, a copy. WEIDA_EINVAL while a `next` is pending. */
+   * fetch yielded, a copy. A pending `next` goes on unharmed. */
   delivered() {
     return adopt(Bits, native.fetchDelivered(this[HANDLE]));
   }
 
-  /** The pieces ordered and not yet taken, a copy. WEIDA_EINVAL while a
-   * `next` is pending. */
+  /** The pieces ordered and not yet taken, a copy. A pending `next` goes on
+   * unharmed. */
   inFlight() {
     return adopt(Bits, native.fetchInFlight(this[HANDLE]));
   }
 
+  /** The missing pieces no order fetches and no seeder holds by its last
+   * HAVE: what `next` waits for until a seeder gains them, a copy. A
+   * pending `next` goes on unharmed. */
+  unavailable() {
+    return adopt(Bits, native.fetchUnavailable(this[HANDLE]));
+  }
+
+  /** Orders the missing pieces of `start..end` before any other, in index
+   * order; replaces an earlier range, and an empty one clears it. Takes
+   * effect at the next order. A pending `next` goes on unharmed. */
+  prioritize(start, end) {
+    native.fetchPrioritize(this[HANDLE], start, end);
+  }
+
+  /** Ends the priority: rarest first again. */
+  clearPriority() {
+    native.fetchClearPriority(this[HANDLE]);
+  }
+
   /** The next verified piece, a frozen `{ index, bytes }` copied out at
    * once, or null once every piece is held. Rejects with
    * WEIDA_ENOT_CONNECTED when no seeder is left that has not failed this
@@ -2798,6 +2817,18 @@ export class SeedSession extends Handle {
     );
   }
 
+  /** Answers PIECE `index` with "no longer held": the fetch orders it
+   * elsewhere and keeps the session. */
+  async answerGone(index, { signal } = {}) {
+    await op(
+      this,
+      () => native.seedSessionAnswerGone(this[HANDLE], index),
+      native.seedSessionAnswerGoneOpWait,
+      native.seedSessionAnswerGoneOpFd,
+      signal,
+    );
+  }
+
   /** Ends the session: a blob this seeder does not serve or a piece it
    * does not hold; the fetch drops this seeder for the blob. Consumes the
    * session. */
@@ -3145,6 +3176,19 @@ export class RelayRequest extends Handle {
     );
   }
 
+  /** Serves it as `admit` does and holds a tunnel to `bytesPerSec`, both
+   * directions together, with one second of burst; a registration's budget
+   * is unused. Consumes the request. */
+  async admitWith(bytesPerSec, { signal } = {}) {
+    await op(
+      this,
+      () => native.relayRequestAdmitWith(consume(this), bytesPerSec),
+      native.relayRequestAdmitOpWait,
+      native.relayRequestAdmitOpFd,
+      signal,
+    );
+  }
+
   /** Refuses it: the asker fails with WEIDA_EREJECTED. Consumes the
    * request. */
   async refuse({ signal } = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weida",
-  "version": "0.1.0-alpha.14",
+  "version": "0.1.0-alpha.16",
   "description": "weida for JavaScript: a Node-API addon over libweida for Node, Bun and Deno",
   "license": "MIT OR Apache-2.0",
   "repository": {