@needmoretruth/nmts-cli 0.35.0 → 0.36.1

package/dist/run-log.js

@@ -21,12 +21,13 @@
 //    `nmts get` to report a failure it did not have. Every write is inside a `try` that swallows.
 //    ⚠ There is no debug switch in this tool to say so through, so it is silent — which is why
 //      this paragraph is here rather than a line of output.
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
 import { OPTIONS_TAKING_A_VALUE } from "./args.js";
-import { configDir, modesAreEnforced } from "./credentials.js";
+import { fromUtf8, utf8 } from "./bytes.js";
+import { host } from "./host.js";
 import { redact } from "./redact.js";
 import { VERSION } from "./product.js";
+/** The one key the record lives under. On this machine that is `runs.jsonl` in the config directory. */
+export const RUN_LOG_KEY = "runlog";
 /** Set this to `1` and nothing is written. */
 export const NO_RUN_LOG_ENV_VAR = "NMTS_NO_RUN_LOG";
 /**
@@ -69,13 +70,9 @@ const HIDDEN_VALUES = {
  *    common and should not be given one just for this.
  */
 let collected = [];
-/** Where the log lives. Inside the tool's own directory, which is already 0700. */
-export function runLogPath() {
-    return join(configDir(), "runs.jsonl");
-}
 /** Has the person turned it off? */
 export function runLogIsOff() {
-    return process.env[NO_RUN_LOG_ENV_VAR] === "1";
+    return host().env(NO_RUN_LOG_ENV_VAR) === "1";
 }
 function remember(event) {
     if (runLogIsOff())
@@ -158,41 +155,34 @@ export function safeArgs(argv) {
     }
     return out;
 }
-/** Write one line, creating the file 0600 if it is not there yet. */
-function append(line) {
-    const dir = configDir();
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    const path = runLogPath();
-    if (!existsSync(path)) {
-        writeFileSync(path, "", { mode: 0o600 });
-        if (modesAreEnforced())
-            chmodSync(path, 0o600);
-    }
-    appendFileSync(path, line);
-    if (statSync(path).size > MAX_LOG_BYTES)
-        trim(path);
-}
 /**
- * Drop the oldest whole lines until what is left fits.
+ * Add one line, trimming the oldest away when the record has grown past its cap.
+ *
+ * ⛔ WHOLE LINES. Cutting at a byte offset leaves a half-written JSON object at the top, and a
+ *    reader that meets one has to decide whether the record is corrupt or merely trimmed.
  *
- * ⛔ WHOLE LINES. Cutting the file at a byte offset leaves a half-written JSON object at the top,
- *    and a reader that meets one has to decide whether the file is corrupt or merely trimmed.
+ * ⚠ READ, ADD, WRITE, rather than an append. A host's state is bytes under a key — the only shape
+ *   a browser's store and a file both have — and the record is a quarter of a megabyte at most,
+ *   which is what makes rewriting it affordable at the end of a run.
  */
-function trim(path) {
-    const lines = readFileSync(path, "utf8").split("\n");
+async function append(line) {
+    const state = host().state;
+    const held = await state.read(RUN_LOG_KEY);
+    const lines = (held === undefined ? "" : fromUtf8(held)).split("\n");
+    lines.push(line.replace(/\n$/, ""));
     const kept = [];
     let bytes = 0;
     for (let i = lines.length - 1; i >= 0; i -= 1) {
-        const line = lines[i];
-        if (line === undefined || line === "")
+        const one = lines[i];
+        if (one === undefined || one === "")
             continue;
-        const size = Buffer.byteLength(line, "utf8") + 1;
+        const size = utf8(one).length + 1;
         if (bytes + size > MAX_LOG_BYTES)
             break;
-        kept.unshift(line);
+        kept.unshift(one);
         bytes += size;
     }
-    writeFileSync(path, kept.length === 0 ? "" : `${kept.join("\n")}\n`, { mode: 0o600 });
+    await state.write(RUN_LOG_KEY, utf8(kept.length === 0 ? "" : `${kept.join("\n")}\n`));
 }
 /**
  * Write this run down, and forget what was collected.
@@ -200,7 +190,7 @@ function trim(path) {
  * Returns nothing and throws nothing: see the header. A run that could not be written is a run
  * that is missing from a report, which is a smaller problem than a command that failed for it.
  */
-export function recordRun(argv, exit, ms, now = new Date()) {
+export async function recordRun(argv, exit, ms, now = new Date()) {
     if (runLogIsOff()) {
         forgetRun();
         return;
@@ -220,7 +210,7 @@ export function recordRun(argv, exit, ms, now = new Date()) {
     };
     forgetRun();
     try {
-        append(`${JSON.stringify(record)}\n`);
+        await append(`${JSON.stringify(record)}\n`);
     }
     catch {
         // Swallowed on purpose. See the header: the log is a convenience and the command is the work.
@@ -274,10 +264,13 @@ function asRecord(value) {
     };
 }
 /** The newest `count` runs, oldest first. An unreadable or missing file is no runs. */
-export function readRuns(count) {
+export async function readRuns(count) {
     let text;
     try {
-        text = readFileSync(runLogPath(), "utf8");
+        const held = await host().state.read(RUN_LOG_KEY);
+        if (held === undefined)
+            return [];
+        text = fromUtf8(held);
     }
     catch {
         return [];

package/dist/seal.js

@@ -8,7 +8,8 @@
 // ⛔ THE PLAINTEXT NEVER LEAVES THIS PROCESS. What goes out is the NCF-3 stream; what the server
 //    is told is its LENGTH. The name, the folder and the real size are written into the account's
 //    sealed file list, which the server cannot open.
-import { createHash } from "node:crypto";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { toBase64Url } from "./bytes.js";
 import { AAD } from "./crypto.js";
 import { NmtsError } from "./errors.js";
 import { chunkCount, sealedLenFor as sealedLength, } from "./shared/lib/crypto/size-padding.js";
@@ -108,8 +109,8 @@ export function fileSecrets(crypt, dataKey, contentDigest) {
     const contentHashCt = crypt.envelope_seal(dataKey, encoder.encode(AAD.contentHash), contentDigest);
     return {
         dek,
-        dekWrapped: Buffer.from(dekWrapped).toString("base64url"),
-        contentHashCt: Buffer.from(contentHashCt).toString("base64url"),
+        dekWrapped: toBase64Url(dekWrapped),
+        contentHashCt: toBase64Url(contentHashCt),
     };
 }
 /**
@@ -180,7 +181,7 @@ export async function sealFile(crypt, dataKey, plaintext) {
             nextStep: "The storage network has nothing to store and would refuse the reservation.",
         });
     }
-    const digest = new Uint8Array(createHash("sha256").update(plaintext).digest());
+    const digest = sha256(plaintext);
     const secrets = fileSecrets(crypt, dataKey, digest);
     digest.fill(0);
     try {

package/dist/server.d.ts

@@ -1,5 +1,5 @@
 export declare const DEFAULT_SERVER = "https://nmts.me";
-export declare const SERVER_ENV_VAR = "NMTS_SERVER";
+export { SERVER_ENV_VAR } from "./env-vars.ts";
 /**
  * Resolve the server for this run: an explicit argument, then the environment, then the default.
  *

package/dist/server.js

@@ -4,9 +4,13 @@
 //    development against a local stack, not as a knob to tune. It is read from an argument or the
 //    environment rather than stored, so a credentials file cannot silently point a later run
 //    somewhere else than the run that wrote it.
+import { SERVER_ENV_VAR } from "./env-vars.js";
 import { NmtsError } from "./errors.js";
+import { host } from "./host.js";
 export const DEFAULT_SERVER = "https://nmts.me";
-export const SERVER_ENV_VAR = "NMTS_SERVER";
+// Re-exported so every caller still finds it here; the name itself lives in a module with no
+// imports, because `nmts --help` prints it (`env-vars.ts`).
+export { SERVER_ENV_VAR } from "./env-vars.js";
 /**
  * Resolve the server for this run: an explicit argument, then the environment, then the default.
  *
@@ -14,7 +18,7 @@ export const SERVER_ENV_VAR = "NMTS_SERVER";
  *    typo that lands on another scheme must stop here rather than somewhere further in.
  */
 export function resolveServer(explicit) {
-    const raw = explicit ?? process.env[SERVER_ENV_VAR] ?? DEFAULT_SERVER;
+    const raw = explicit ?? host().env(SERVER_ENV_VAR) ?? DEFAULT_SERVER;
     let url;
     try {
         url = new URL(raw);

package/dist/setup-questions.js

@@ -19,13 +19,13 @@ import { promptLine, stdinIsATerminal } from "./prompt.js";
  *    never sees a line.
  */
 export async function askAboutCollisions(say) {
-    if (hasChosen() || !stdinIsATerminal())
+    if ((await hasChosen()) || !stdinIsATerminal())
         return;
     say(``);
     say(`When a file with that name is already in the drive:`);
     say(`  ${ANSWER_NUMBER.rename}  ${COLLISION_MEANS.rename}`);
     say(`  ${ANSWER_NUMBER.overwrite}  ${COLLISION_MEANS.overwrite}`);
     const choice = readAnswer(await promptLine(`[${ANSWER_NUMBER.rename}] `));
-    setChoice(choice, VERSION, new Date());
+    await setChoice(choice, VERSION, new Date());
     say(`${choice} — ${COLLISION_MEANS[choice]}  Change it: ${BINARY_NAME} on-collision <rename|overwrite>`);
 }

package/dist/upload-file-node.d.ts

@@ -0,0 +1,3 @@
+import { type PlaintextSource } from "./upload-file.ts";
+/** Read a file off the disk, a chunk at a time. */
+export declare function fileSource(path: string, size: number): PlaintextSource;

package/dist/upload-file-node.js

@@ -0,0 +1,38 @@
+// A file on THIS MACHINE, read a chunk at a time, as a plaintext source.
+//
+// ⛔ THE SEAM IS `upload-file.ts`'S AND THIS IS THE ONE IMPLEMENTATION THAT NEEDS A DISK. A caller
+//    in a browser hands in a `Blob` instead (the SDK's `blobSource`), and everything downstream —
+//    the part plan, the sealing, the reservation records — is the same code for both.
+import { open } from "node:fs/promises";
+import { NmtsError } from "./errors.js";
+import { READ_CHUNK_BYTES } from "./upload-file.js";
+/** Read a file off the disk, a chunk at a time. */
+export function fileSource(path, size) {
+    return {
+        size,
+        async *read(offset, length) {
+            const handle = await open(path, "r");
+            try {
+                const buffer = new Uint8Array(Math.min(READ_CHUNK_BYTES, length));
+                let at = 0;
+                while (at < length) {
+                    const want = Math.min(buffer.length, length - at);
+                    const { bytesRead } = await handle.read(buffer, 0, want, offset + at);
+                    if (bytesRead === 0) {
+                        // ⛔ SHORT IS NOT DONE. The plan was made from the size this file had when it was
+                        //    measured; a read that ends early means it shrank underneath us, and sealing what
+                        //    arrived would declare a length the bytes do not match.
+                        throw new NmtsError(`${path} ended after ${at} of ${length} bytes.`, {
+                            nextStep: "Nothing was sent. The file changed while it was being read.",
+                        });
+                    }
+                    at += bytesRead;
+                    yield new Uint8Array(buffer.subarray(0, bytesRead));
+                }
+            }
+            finally {
+                await handle.close();
+            }
+        },
+    };
+}

package/dist/upload-file.d.ts

@@ -2,6 +2,8 @@ import { type CryptoGlue } from "./crypto.ts";
 import { type PaddingRule } from "./shared/lib/crypto/size-padding.ts";
 import { entryOf } from "./upload.ts";
 import type { BlobProtocol, PaidPart, UploadApi, UploadInput, UploadResult, UploadStep } from "./upload-wire.ts";
+/** How much plaintext is handed to the engine at a time. Matches the format's own chunk size. */
+export declare const READ_CHUNK_BYTES: number;
 /**
  * Where the plaintext comes from.
  *
@@ -15,8 +17,6 @@ export interface PlaintextSource {
     /** Read `[offset, offset + length)`, in pieces small enough to hold. */
     read(offset: number, length: number): AsyncIterable<Uint8Array>;
 }
-/** Read a file off the disk, a chunk at a time. */
-export declare function fileSource(path: string, size: number): PlaintextSource;
 export interface FileUploadInput {
     api: UploadApi;
     protocol: BlobProtocol;

package/dist/upload-file.js

@@ -15,8 +15,8 @@
 //    the reservation key, and the SHA-256 the account will check the contents against — because
 //    both are needed BEFORE the first part is sealed. The second pass is the sealing itself. The
 //    alternative is holding the file, which is the thing this module exists to avoid.
-import { createHash } from "node:crypto";
-import { open } from "node:fs/promises";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { fromBase64Url } from "./bytes.js";
 import { AAD } from "./crypto.js";
 import { NmtsError } from "./errors.js";
 import { fileSecrets, sealPart } from "./seal.js";
@@ -27,37 +27,7 @@ import { buyAndPushPart, entryOf } from "./upload.js";
 import { commitItem } from "./upload-steps.js";
 import { finishReservationKey, partKey, readItemRecord, readReservationBytes, readReservationRecord, startReservationKey, } from "./upload-store.js";
 /** How much plaintext is handed to the engine at a time. Matches the format's own chunk size. */
-const READ_CHUNK_BYTES = 4 * 2 ** 20;
-/** Read a file off the disk, a chunk at a time. */
-export function fileSource(path, size) {
-    return {
-        size,
-        async *read(offset, length) {
-            const handle = await open(path, "r");
-            try {
-                const buffer = Buffer.allocUnsafe(Math.min(READ_CHUNK_BYTES, length));
-                let at = 0;
-                while (at < length) {
-                    const want = Math.min(buffer.length, length - at);
-                    const { bytesRead } = await handle.read(buffer, 0, want, offset + at);
-                    if (bytesRead === 0) {
-                        // ⛔ SHORT IS NOT DONE. The plan was made from the size this file had when it was
-                        //    measured; a read that ends early means it shrank underneath us, and sealing what
-                        //    arrived would declare a length the bytes do not match.
-                        throw new NmtsError(`${path} ended after ${at} of ${length} bytes.`, {
-                            nextStep: "Nothing was sent. The file changed while it was being read.",
-                        });
-                    }
-                    at += bytesRead;
-                    yield new Uint8Array(buffer.subarray(0, bytesRead));
-                }
-            }
-            finally {
-                await handle.close();
-            }
-        },
-    };
-}
+export const READ_CHUNK_BYTES = 4 * 2 ** 20;
 /**
  * Upload one file and return what the caller must write into the account's file list.
  *
@@ -83,15 +53,15 @@ export async function uploadFile(input) {
     //    `POST /v1/items` exists and is paid for; all that can still be missing is the account's own
     //    list. Asking the server about every part again would be a round trip per part to learn
     //    something the record already says.
-    const committed = readItemRecord(fileKey);
+    const committed = await readItemRecord(fileKey);
     if (committed?.itemId !== undefined) {
-        const entry = recordedEntry(fileKey, plan.length, source.size);
+        const entry = await recordedEntry(fileKey, plan.length, source.size);
         if (entry !== null) {
             return { itemId: committed.itemId, resumed: true, ledgerIds: [], fileKey, parts: plan.length, entry };
         }
     }
     // ── the file's secrets: from the record if one exists, otherwise made now ──
-    const secrets = openSecrets(input, fileKey, plan.length, contentDigest);
+    const secrets = await openSecrets(input, fileKey, plan.length, contentDigest);
     try {
         const entry = {
             name: input.name,
@@ -103,7 +73,7 @@ export async function uploadFile(input) {
         const paid = [];
         for (const range of plan) {
             const key = partKey(fileKey, range.partIndex);
-            const stored = readReservationRecord(key);
+            const stored = await readReservationRecord(key);
             // ⛔ A PART THAT IS WRITTEN DOWN IS NEVER SEALED AGAIN. Its bytes are a particular sealing
             //    the treasury may already have paid to register; a fresh one is a different blob.
             // ⛔ THE LAST PART ONLY. Every reader recovers the parts' real lengths from the file's size
@@ -119,7 +89,7 @@ export async function uploadFile(input) {
                 : range.length;
             const sealed = stored === null
                 ? await sealPartOf(input, secrets.dek, range, plan.length, sealFrom)
-                : readReservationBytes(key);
+                : await readReservationBytes(key);
             paid.push(await (input.buy ?? buyAndPushPart)({
                 api: input.api,
                 protocol: input.protocol,
@@ -162,12 +132,12 @@ export function partKeysOf(fileKey, parts) {
 }
 /** Read the whole file once, feeding the key hash and returning the content digest. */
 async function hashWhole(source, keyHash) {
-    const content = createHash("sha256");
+    const content = sha256.create();
     for await (const chunk of source.read(0, source.size)) {
         keyHash.update(chunk);
         content.update(chunk);
     }
-    return new Uint8Array(content.digest());
+    return content.digest();
 }
 /**
  * The file's key and sealed content hash — from a written-down part if there is one.
@@ -176,12 +146,12 @@ async function hashWhole(source, keyHash) {
  *    the bytes already on the network cannot be re-sealed. Unwrapping the recorded one is what
  *    makes the parts still to come belong to the same file.
  */
-function openSecrets(input, fileKey, parts, contentDigest) {
+async function openSecrets(input, fileKey, parts, contentDigest) {
     for (const key of partKeysOf(fileKey, parts)) {
-        const record = readReservationRecord(key);
+        const record = await readReservationRecord(key);
         if (record === null)
             continue;
-        const wrapped = new Uint8Array(Buffer.from(record.dekWrapped, "base64url"));
+        const wrapped = fromBase64Url(record.dekWrapped);
         const dek = input.crypt.envelope_open(input.dataKey, new TextEncoder().encode(AAD.dekWrap), wrapped);
         return { dek, dekWrapped: record.dekWrapped, contentHashCt: record.contentHashCt };
     }
@@ -226,9 +196,9 @@ export { entryOf };
  *    sealed with. A run that wrote its own freshly generated one into the list would produce a
  *    file that is paid for, present, correctly named and impossible to open.
  */
-function recordedEntry(fileKey, parts, size) {
+async function recordedEntry(fileKey, parts, size) {
     for (const key of partKeysOf(fileKey, parts)) {
-        const record = readReservationRecord(key);
+        const record = await readReservationRecord(key);
         if (record === null)
             continue;
         return {

package/dist/upload-price-node.d.ts

@@ -0,0 +1,8 @@
+/**
+ * How big the local file is, with the two refusals that are worth their own words.
+ *
+ * ⛔ IT IS NOT READ HERE. A file large enough to need several parts is a file too large to hold,
+ *    and the size is all that is needed to plan the upload and quote its price. The bytes are read
+ *    later, a slice at a time, by the part that is being sealed.
+ */
+export declare function measureLocal(path: string): number;

package/dist/upload-price-node.js

@@ -0,0 +1,37 @@
+// How big a file on THIS MACHINE is — the one thing the upload price needs that a browser has no
+// equivalent of.
+//
+// ⛔ THE ARITHMETIC IS NOT HERE. `upload-price.ts` turns a size into parts and a price and runs
+//    anywhere; this is the one call that asks a disk, and it is separate so that the price is
+//    reachable from a page where bytes arrive as a `Blob` and their length is already known.
+import { statSync } from "node:fs";
+import { NmtsError } from "./errors.js";
+/**
+ * How big the local file is, with the two refusals that are worth their own words.
+ *
+ * ⛔ IT IS NOT READ HERE. A file large enough to need several parts is a file too large to hold,
+ *    and the size is all that is needed to plan the upload and quote its price. The bytes are read
+ *    later, a slice at a time, by the part that is being sealed.
+ */
+export function measureLocal(path) {
+    let stat;
+    try {
+        stat = statSync(path);
+    }
+    catch {
+        throw new NmtsError(`There is no file at ${path}.`, { exitCode: 4 });
+    }
+    if (stat.isDirectory()) {
+        throw new NmtsError(`${path} is a folder.`, {
+            exitCode: 4,
+            nextStep: "This version uploads one file at a time.",
+        });
+    }
+    if (stat.size === 0) {
+        throw new NmtsError(`${path} is empty.`, {
+            exitCode: 4,
+            nextStep: "The storage network has nothing to store and would refuse the reservation.",
+        });
+    }
+    return stat.size;
+}

package/dist/upload-price.d.ts

@@ -18,14 +18,6 @@ export declare const CREDIT_BYTES: number;
  * shows afterwards. The server is still the authority; this is a quote, not a promise.
  */
 export declare function creditsFor(sealedBytes: number, epochs?: number): number;
-/**
- * How big the local file is, with the two refusals that are worth their own words.
- *
- * ⛔ IT IS NOT READ HERE. A file large enough to need several parts is a file too large to hold,
- *    and the size is all that is needed to plan the upload and quote its price. The bytes are read
- *    later, a slice at a time, by the part that is being sealed.
- */
-export declare function measureLocal(path: string): number;
 /**
  * How much of the file goes into one part.
  *

package/dist/upload-price.js

@@ -1,10 +1,10 @@
 // What an upload will cost, and how the file is cut up to pay for it.
 //
 // ⛔ SPLIT OUT OF `put.ts` SO THAT FILE STAYS READABLE IN ONE SITTING. Everything here is
-//    arithmetic over numbers — no network, no crypto, no disk beyond one `stat` — which is what
-//    lets `--dry-run` answer without reading a very large file, and what lets a test drive the
-//    price without an account.
-import { statSync } from "node:fs";
+//    arithmetic over numbers — no network, no crypto and no disk at all — which is what lets
+//    `--dry-run` answer without reading a very large file, and what lets a test drive the price
+//    without an account. Measuring a file on this machine is Node's, and is in
+//    `upload-price-node.ts`.
 import { NmtsError } from "./errors.js";
 import { DEFAULT_PART_BYTES, NCF3_SHAPE, sealedLenFor } from "./seal.js";
 import { paddedPlaintextLen } from "./shared/lib/crypto/size-padding.js";
@@ -30,35 +30,6 @@ export function creditsFor(sealedBytes, epochs = UPLOAD_EPOCHS) {
     const mib = Math.ceil(sealedBytes / CREDIT_BYTES);
     return Math.ceil((mib * epochs) / UPLOAD_EPOCHS);
 }
-/**
- * How big the local file is, with the two refusals that are worth their own words.
- *
- * ⛔ IT IS NOT READ HERE. A file large enough to need several parts is a file too large to hold,
- *    and the size is all that is needed to plan the upload and quote its price. The bytes are read
- *    later, a slice at a time, by the part that is being sealed.
- */
-export function measureLocal(path) {
-    let stat;
-    try {
-        stat = statSync(path);
-    }
-    catch {
-        throw new NmtsError(`There is no file at ${path}.`, { exitCode: 4 });
-    }
-    if (stat.isDirectory()) {
-        throw new NmtsError(`${path} is a folder.`, {
-            exitCode: 4,
-            nextStep: "This version uploads one file at a time.",
-        });
-    }
-    if (stat.size === 0) {
-        throw new NmtsError(`${path} is empty.`, {
-            exitCode: 4,
-            nextStep: "The storage network has nothing to store and would refuse the reservation.",
-        });
-    }
-    return stat.size;
-}
 /**
  * How much of the file goes into one part.
  *

package/dist/upload-steps.js

@@ -70,14 +70,14 @@ export async function commitItem(input, fileKey, parts) {
     // Advisory only — the chain is the authority on a blob's life. 0 when this machine could not
     // read the epoch clock: a number we do not have is not a number to invent.
     const expiryEpoch = input.currentEpoch === null ? 0 : input.currentEpoch + input.epochs;
-    const previous = readItemRecord(fileKey);
+    const previous = await readItemRecord(fileKey);
     // ⛔ ALREADY COMMITTED IS NOT COMMITTED AGAIN. The record outlives the commit precisely so a run
     //    that died before writing the file list does not make a second file out of storage that is
     //    already named.
     if (previous?.itemId !== undefined)
         return previous.itemId;
     const attempt = previous?.attempt ?? 0;
-    writeItemRecord(fileKey, { attempt });
+    await writeItemRecord(fileKey, { attempt });
     let view;
     try {
         view = await input.api.createItem({
@@ -100,7 +100,7 @@ export async function commitItem(input, fileKey, parts) {
     // ⛔ Written down before returning: from here on the file EXISTS and is paid for, and the only
     //    thing still missing is the account's own list. Losing the record now would make it
     //    unreachable.
-    writeItemRecord(fileKey, { attempt, itemId: view.id });
+    await writeItemRecord(fileKey, { attempt, itemId: view.id });
     return view.id;
 }
 /**

package/dist/upload-store.d.ts

@@ -1,6 +1,6 @@
-import { type Hash } from "node:crypto";
-/** Where unfinished uploads live. */
-export declare function uploadsDir(): string;
+import { sha256 } from "@noble/hashes/sha2.js";
+/** The running hash a reservation key is built in. */
+export type ReservationHash = ReturnType<typeof sha256.create>;
 /**
  * A stable, account-scoped name for one file's upload attempt.
  *
@@ -36,9 +36,9 @@ export declare function reservationKeyStreamed(dataKey: Uint8Array, plaintextChu
  *    the SHA-256 the account checks its contents against; handing the caller the running hash is
  *    what lets both come out of a single pass instead of two reads of a very large file.
  */
-export declare function startReservationKey(dataKey: Uint8Array): Hash;
+export declare function startReservationKey(dataKey: Uint8Array): ReservationHash;
 /** Finish it. The name and the destination go in last, exactly as the one-shot form does. */
-export declare function finishReservationKey(hash: Hash, name: string, destination: string): string;
+export declare function finishReservationKey(hash: ReservationHash, name: string, destination: string): string;
 /**
  * The record name for ONE part of a file.
  *
@@ -131,7 +131,7 @@ export interface Reservation {
  *    resume that only needs to commit still reads every byte of a very large upload off the disk.
  *    They are fetched separately, by the one step that actually pushes them.
  */
-export declare function readReservationRecord(key: string): Reservation | null;
+export declare function readReservationRecord(key: string): Promise<Reservation | null>;
 /**
  * The sealed bytes a reservation bought.
  *
@@ -139,14 +139,14 @@ export declare function readReservationRecord(key: string): Reservation | null;
  *    different blob from the one the treasury registered — the relay refuses them, forever, and
  *    the credits are gone.
  */
-export declare function readReservationBytes(key: string): Uint8Array;
+export declare function readReservationBytes(key: string): Promise<Uint8Array>;
 /** The record and its bytes together, for the callers that need both. */
-export declare function readReservation(key: string): {
+export declare function readReservation(key: string): Promise<{
     record: Reservation;
     sealed: Uint8Array;
-} | null;
+} | null>;
 /** Write the record and its sealed bytes. Called BEFORE the reserve, and again after it answers. */
-export declare function writeReservation(key: string, record: Reservation, sealed: Uint8Array): void;
+export declare function writeReservation(key: string, record: Reservation, sealed: Uint8Array): Promise<void>;
 /**
  * Forget a reservation.
  *
@@ -154,7 +154,7 @@ export declare function writeReservation(key: string, record: Reservation, seale
  *   upload already succeeded" was not true of every caller. What IS true of all of them is that
  *   nothing further depends on the record, which is why it never throws.
  */
-export declare function clearReservation(key: string): void;
+export declare function clearReservation(key: string): Promise<void>;
 /**
  * The FILE-level half of an unfinished upload: what happened after every part was paid for.
  *
@@ -175,8 +175,8 @@ export interface ItemRecord {
     attempt: number;
 }
 /** What is known about this file's commit, or `null` when it has not been attempted. */
-export declare function readItemRecord(fileKey: string): ItemRecord | null;
+export declare function readItemRecord(fileKey: string): Promise<ItemRecord | null>;
 /** Write the file-level record. Called before the commit, and again once it has an id. */
-export declare function writeItemRecord(fileKey: string, record: ItemRecord): void;
+export declare function writeItemRecord(fileKey: string, record: ItemRecord): Promise<void>;
 /** Forget the file-level record. Never throws, for the same reason `clearReservation` does not. */
-export declare function clearItemRecord(fileKey: string): void;
+export declare function clearItemRecord(fileKey: string): Promise<void>;