@needmoretruth/nmts-cli 0.34.4 → 0.36.1

package/dist/download-sink-node.js

@@ -0,0 +1,204 @@
+// The two places this tool can put a downloaded file: a real file, and its own stdout.
+//
+// ⛔ THE SHAPE IS `download-sink.ts`'S AND THE PROMISE IS KEPT HERE. A sink is the thing that
+//    decides what "delivered" means, and these two decide it with a rename and with a hold — both
+//    of which need Node. A browser's sink is the caller's, written against the same interface.
+import { randomBytes } from "node:crypto";
+import { createWriteStream, existsSync } from "node:fs";
+import { rename, rm } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { NmtsError } from "./errors.js";
+import { handOver } from "./stdout.js";
+/** The one refusal text for a destination that is already occupied. Shared by every command. */
+function alreadyThere(destination) {
+    return new NmtsError(`${destination} already exists.`, {
+        exitCode: 4,
+        nextStep: "Nothing was written. Pass --out to choose another name, or --force to replace it.",
+    });
+}
+/**
+ * Write to a file, through a temporary name beside it, renamed into place only when the whole
+ * file has been proved.
+ *
+ * ⛔ THE TEMPORARY FILE IS IN THE SAME DIRECTORY AS THE DESTINATION, not in a system temporary
+ *    directory, and that is the whole mechanism: `rename` is atomic only within one filesystem,
+ *    and only an atomic rename guarantees that a reader either sees nothing under the real name or
+ *    sees the finished file. A temporary directory can be — and on the machines this runs on
+ *    usually is — a different filesystem, where the same call becomes copy-then-delete and a
+ *    reader can catch the copy half done.
+ *
+ * ⛔ IT IS CREATED 0600 AND THE RENAME KEEPS THAT. The file is somebody's plaintext; it must not
+ *    be readable by other accounts on the machine for the seconds it takes to download, any more
+ *    than it may be afterwards.
+ */
+export function fileSink(destination, options) {
+    // ⛔ Asked BEFORE the download rather than at the end, which is where the old code found out.
+    //    Fetching a file to discover it had nowhere to go spent somebody's time and the storage
+    //    network's bandwidth for a refusal that was knowable up front.
+    if (!options.force && existsSync(destination))
+        throw alreadyThere(destination);
+    const temporary = join(dirname(destination), `.${basename(destination)}.nmts-${randomBytes(6).toString("hex")}.part`);
+    let stream = null;
+    let failure = null;
+    let renamed = false;
+    // ⚠ Created on the first write rather than up front: a download that fails before it produces a
+    //   byte — a wrong key, a part on a network this build cannot read — then leaves no file at all,
+    //   not even one that appears and disappears.
+    const opened = () => {
+        if (stream !== null)
+            return stream;
+        const fresh = createWriteStream(temporary, { flags: "wx", mode: 0o600 });
+        // ⛔ An 'error' with no listener is thrown out of the event loop and kills the process, which
+        //    would turn "the disk is full" into a crash with no next step. Kept, and reported by the
+        //    next call that can report it.
+        fresh.on("error", (error) => {
+            failure = error;
+        });
+        stream = fresh;
+        return fresh;
+    };
+    const closed = async () => {
+        const open = stream;
+        if (open === null)
+            return;
+        stream = null;
+        // ⚠ Waits for 'close', not 'finish': a stream that failed to open never finishes, and waiting
+        //   for the wrong event there is a hang rather than an error.
+        await new Promise((resolve) => {
+            if (open.closed) {
+                resolve();
+                return;
+            }
+            open.once("close", () => resolve());
+            open.end();
+        });
+    };
+    const abandon = async () => {
+        if (renamed)
+            return;
+        try {
+            await closed();
+        }
+        catch {
+            // Nothing to do about it: the file below is going away either way.
+        }
+        await rm(temporary, { force: true }).catch(() => undefined);
+    };
+    return {
+        // Nothing to refuse: what a disk cannot take, the write itself reports, and the temporary
+        // file means a disk that fills up leaves no file under the name somebody asked for.
+        expect: () => undefined,
+        write: async (bytes) => {
+            const target = opened();
+            await new Promise((resolve, reject) => {
+                const known = failure;
+                if (known !== null) {
+                    reject(known);
+                    return;
+                }
+                target.write(bytes, (error) => {
+                    if (error === undefined || error === null)
+                        resolve();
+                    else
+                        reject(error);
+                });
+            });
+        },
+        commit: async () => {
+            // A file of zero bytes is still a file, so the stream is opened even if nothing was written.
+            opened();
+            await closed();
+            const known = failure;
+            if (known !== null) {
+                await abandon();
+                throw new NmtsError(`${destination} could not be written: ${known.message}`, {
+                    exitCode: 1,
+                    nextStep: "Nothing was left under that name. The download itself was fine — this is the disk.",
+                });
+            }
+            // ⛔ Asked a second time, as late as possible. The first check was before the download; a
+            //    file that appeared in the meantime is somebody else's, and rename would silently
+            //    replace it. The window is now the width of one system call rather than a download.
+            if (!options.force && existsSync(destination)) {
+                await abandon();
+                throw alreadyThere(destination);
+            }
+            await rename(temporary, destination);
+            renamed = true;
+            return true;
+        },
+        abandon,
+    };
+}
+/**
+ * How much plaintext `--out -` will hold before it hands anything over. One part's worth.
+ *
+ * ⛔ NOT AN ARBITRARY NUMBER: it is the upload path's default part size, which is the most memory
+ *    this tool has ever asked for. Keeping the stdout ceiling there means the whole tool's bound
+ *    is one part plus one chunk whichever direction the bytes are going.
+ */
+export const STDOUT_HOLD_LIMIT = 64 * 2 ** 20;
+/**
+ * Hand the whole file to whatever is reading stdout — after it has been proved, not during.
+ *
+ * ⛔ THERE IS NO RENAME ON A PIPE, so the trick the file path uses is not available: a byte handed
+ *    to a reader cannot be taken back, and a reader that has already consumed half a file cannot
+ *    be told afterwards that the half was wrong. An exit code does not fix that — `nmts get x
+ *    --out - > y` leaves the truncated bytes in `y` whatever the exit code says, and an agent
+ *    reading a pipe usually acts on what it read. So this branch keeps the ORIGINAL guarantee
+ *    rather than the original size: the file is held, checked, and only then handed over, exactly
+ *    as before streaming existed.
+ *
+ * ⛔ WHICH MEANS IT HAS TO REFUSE SOMEWHERE, AND IT REFUSES OUT LOUD AND EARLY. Above the ceiling
+ *    the answer is a refusal naming `--out <name>`, which streams and is checked before the file
+ *    appears — not a silent trade of the guarantee for the size, and not the out-of-memory crash
+ *    that this used to be. `put` already refuses this way rather than discovering a limit halfway.
+ *
+ * ⚠ Every protection this branch already had is still here and still applies to the whole file:
+ *   bytes a terminal would act on are refused (`readableOnATerminal`), a reader that closed the
+ *   pipe first is an ordinary end and not a failure, and any other write failure throws.
+ */
+export function stdoutSink(to, limit = STDOUT_HOLD_LIMIT) {
+    const held = [];
+    let total = 0;
+    const tooLarge = (size) => new NmtsError(`This file is ${size} bytes, and \`--out -\` hands over at most ${limit}.`, {
+        exitCode: 4,
+        nextStep: "Nothing was written and nothing was sent. A pipe cannot be taken back, so this mode " +
+            "proves the whole file before it sends a byte, which means holding it. Use `--out <name>` " +
+            "— that writes any size, and the file only appears under that name once it has been checked.",
+    });
+    const forget = () => {
+        for (const run of held)
+            run.fill(0);
+        held.length = 0;
+    };
+    return {
+        expect: (size) => {
+            if (size > limit)
+                throw tooLarge(size);
+        },
+        write: async (bytes) => {
+            // ⚠ Copied, because the caller zeroes what it handed over as soon as this resolves.
+            total += bytes.length;
+            if (total > limit) {
+                forget();
+                throw tooLarge(total);
+            }
+            held.push(new Uint8Array(bytes));
+        },
+        commit: async () => {
+            const whole = new Uint8Array(total);
+            let at = 0;
+            for (const run of held) {
+                whole.set(run, at);
+                at += run.length;
+            }
+            forget();
+            // ⚠ NOT zeroed afterwards, deliberately: `ByteDestination` promises only that the bytes have
+            //   been handed over, and a destination is entitled to keep the array it was given — the
+            //   tests use one that does. Wiping it here would hand a reader a buffer of zeroes.
+            return await handOver(whole, to);
+        },
+        abandon: async () => forget(),
+    };
+}

package/dist/download-sink.d.ts

@@ -1,4 +1,3 @@
-import { type ByteDestination } from "./stdout.ts";
 /**
  * Somewhere a file's plaintext is delivered in order, and made visible only once.
  *
@@ -27,50 +26,3 @@ export interface PlaintextSink {
     /** Something did not check out: leave nothing behind. Never throws. */
     abandon(): Promise<void>;
 }
-/**
- * Write to a file, through a temporary name beside it, renamed into place only when the whole
- * file has been proved.
- *
- * ⛔ THE TEMPORARY FILE IS IN THE SAME DIRECTORY AS THE DESTINATION, not in a system temporary
- *    directory, and that is the whole mechanism: `rename` is atomic only within one filesystem,
- *    and only an atomic rename guarantees that a reader either sees nothing under the real name or
- *    sees the finished file. A temporary directory can be — and on the machines this runs on
- *    usually is — a different filesystem, where the same call becomes copy-then-delete and a
- *    reader can catch the copy half done.
- *
- * ⛔ IT IS CREATED 0600 AND THE RENAME KEEPS THAT. The file is somebody's plaintext; it must not
- *    be readable by other accounts on the machine for the seconds it takes to download, any more
- *    than it may be afterwards.
- */
-export declare function fileSink(destination: string, options: {
-    force: boolean;
-}): PlaintextSink;
-/**
- * How much plaintext `--out -` will hold before it hands anything over. One part's worth.
- *
- * ⛔ NOT AN ARBITRARY NUMBER: it is the upload path's default part size, which is the most memory
- *    this tool has ever asked for. Keeping the stdout ceiling there means the whole tool's bound
- *    is one part plus one chunk whichever direction the bytes are going.
- */
-export declare const STDOUT_HOLD_LIMIT: number;
-/**
- * Hand the whole file to whatever is reading stdout — after it has been proved, not during.
- *
- * ⛔ THERE IS NO RENAME ON A PIPE, so the trick the file path uses is not available: a byte handed
- *    to a reader cannot be taken back, and a reader that has already consumed half a file cannot
- *    be told afterwards that the half was wrong. An exit code does not fix that — `nmts get x
- *    --out - > y` leaves the truncated bytes in `y` whatever the exit code says, and an agent
- *    reading a pipe usually acts on what it read. So this branch keeps the ORIGINAL guarantee
- *    rather than the original size: the file is held, checked, and only then handed over, exactly
- *    as before streaming existed.
- *
- * ⛔ WHICH MEANS IT HAS TO REFUSE SOMEWHERE, AND IT REFUSES OUT LOUD AND EARLY. Above the ceiling
- *    the answer is a refusal naming `--out <name>`, which streams and is checked before the file
- *    appears — not a silent trade of the guarantee for the size, and not the out-of-memory crash
- *    that this used to be. `put` already refuses this way rather than discovering a limit halfway.
- *
- * ⚠ Every protection this branch already had is still here and still applies to the whole file:
- *   bytes a terminal would act on are refused (`readableOnATerminal`), a reader that closed the
- *   pipe first is an ordinary end and not a failure, and any other write failure throws.
- */
-export declare function stdoutSink(to: ByteDestination, limit?: number): PlaintextSink;

package/dist/download-sink.js

@@ -12,202 +12,9 @@
 // ⛔ A SINK MUST NOT KEEP THE ARRAY IT IS HANDED. The caller zeroes each run of plaintext as soon
 //    as `write` resolves, so a sink that stored the reference would hold a buffer full of zeroes
 //    and write them out. Copy, or finish with the bytes before resolving.
-import { randomBytes } from "node:crypto";
-import { createWriteStream, existsSync } from "node:fs";
-import { rename, rm } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-import { NmtsError } from "./errors.js";
-import { handOver } from "./stdout.js";
-/** The one refusal text for a destination that is already occupied. Shared by every command. */
-function alreadyThere(destination) {
-    return new NmtsError(`${destination} already exists.`, {
-        exitCode: 4,
-        nextStep: "Nothing was written. Pass --out to choose another name, or --force to replace it.",
-    });
-}
-/**
- * Write to a file, through a temporary name beside it, renamed into place only when the whole
- * file has been proved.
- *
- * ⛔ THE TEMPORARY FILE IS IN THE SAME DIRECTORY AS THE DESTINATION, not in a system temporary
- *    directory, and that is the whole mechanism: `rename` is atomic only within one filesystem,
- *    and only an atomic rename guarantees that a reader either sees nothing under the real name or
- *    sees the finished file. A temporary directory can be — and on the machines this runs on
- *    usually is — a different filesystem, where the same call becomes copy-then-delete and a
- *    reader can catch the copy half done.
- *
- * ⛔ IT IS CREATED 0600 AND THE RENAME KEEPS THAT. The file is somebody's plaintext; it must not
- *    be readable by other accounts on the machine for the seconds it takes to download, any more
- *    than it may be afterwards.
- */
-export function fileSink(destination, options) {
-    // ⛔ Asked BEFORE the download rather than at the end, which is where the old code found out.
-    //    Fetching a file to discover it had nowhere to go spent somebody's time and the storage
-    //    network's bandwidth for a refusal that was knowable up front.
-    if (!options.force && existsSync(destination))
-        throw alreadyThere(destination);
-    const temporary = join(dirname(destination), `.${basename(destination)}.nmts-${randomBytes(6).toString("hex")}.part`);
-    let stream = null;
-    let failure = null;
-    let renamed = false;
-    // ⚠ Created on the first write rather than up front: a download that fails before it produces a
-    //   byte — a wrong key, a part on a network this build cannot read — then leaves no file at all,
-    //   not even one that appears and disappears.
-    const opened = () => {
-        if (stream !== null)
-            return stream;
-        const fresh = createWriteStream(temporary, { flags: "wx", mode: 0o600 });
-        // ⛔ An 'error' with no listener is thrown out of the event loop and kills the process, which
-        //    would turn "the disk is full" into a crash with no next step. Kept, and reported by the
-        //    next call that can report it.
-        fresh.on("error", (error) => {
-            failure = error;
-        });
-        stream = fresh;
-        return fresh;
-    };
-    const closed = async () => {
-        const open = stream;
-        if (open === null)
-            return;
-        stream = null;
-        // ⚠ Waits for 'close', not 'finish': a stream that failed to open never finishes, and waiting
-        //   for the wrong event there is a hang rather than an error.
-        await new Promise((resolve) => {
-            if (open.closed) {
-                resolve();
-                return;
-            }
-            open.once("close", () => resolve());
-            open.end();
-        });
-    };
-    const abandon = async () => {
-        if (renamed)
-            return;
-        try {
-            await closed();
-        }
-        catch {
-            // Nothing to do about it: the file below is going away either way.
-        }
-        await rm(temporary, { force: true }).catch(() => undefined);
-    };
-    return {
-        // Nothing to refuse: what a disk cannot take, the write itself reports, and the temporary
-        // file means a disk that fills up leaves no file under the name somebody asked for.
-        expect: () => undefined,
-        write: async (bytes) => {
-            const target = opened();
-            await new Promise((resolve, reject) => {
-                const known = failure;
-                if (known !== null) {
-                    reject(known);
-                    return;
-                }
-                target.write(bytes, (error) => {
-                    if (error === undefined || error === null)
-                        resolve();
-                    else
-                        reject(error);
-                });
-            });
-        },
-        commit: async () => {
-            // A file of zero bytes is still a file, so the stream is opened even if nothing was written.
-            opened();
-            await closed();
-            const known = failure;
-            if (known !== null) {
-                await abandon();
-                throw new NmtsError(`${destination} could not be written: ${known.message}`, {
-                    exitCode: 1,
-                    nextStep: "Nothing was left under that name. The download itself was fine — this is the disk.",
-                });
-            }
-            // ⛔ Asked a second time, as late as possible. The first check was before the download; a
-            //    file that appeared in the meantime is somebody else's, and rename would silently
-            //    replace it. The window is now the width of one system call rather than a download.
-            if (!options.force && existsSync(destination)) {
-                await abandon();
-                throw alreadyThere(destination);
-            }
-            await rename(temporary, destination);
-            renamed = true;
-            return true;
-        },
-        abandon,
-    };
-}
-/**
- * How much plaintext `--out -` will hold before it hands anything over. One part's worth.
- *
- * ⛔ NOT AN ARBITRARY NUMBER: it is the upload path's default part size, which is the most memory
- *    this tool has ever asked for. Keeping the stdout ceiling there means the whole tool's bound
- *    is one part plus one chunk whichever direction the bytes are going.
- */
-export const STDOUT_HOLD_LIMIT = 64 * 2 ** 20;
-/**
- * Hand the whole file to whatever is reading stdout — after it has been proved, not during.
- *
- * ⛔ THERE IS NO RENAME ON A PIPE, so the trick the file path uses is not available: a byte handed
- *    to a reader cannot be taken back, and a reader that has already consumed half a file cannot
- *    be told afterwards that the half was wrong. An exit code does not fix that — `nmts get x
- *    --out - > y` leaves the truncated bytes in `y` whatever the exit code says, and an agent
- *    reading a pipe usually acts on what it read. So this branch keeps the ORIGINAL guarantee
- *    rather than the original size: the file is held, checked, and only then handed over, exactly
- *    as before streaming existed.
- *
- * ⛔ WHICH MEANS IT HAS TO REFUSE SOMEWHERE, AND IT REFUSES OUT LOUD AND EARLY. Above the ceiling
- *    the answer is a refusal naming `--out <name>`, which streams and is checked before the file
- *    appears — not a silent trade of the guarantee for the size, and not the out-of-memory crash
- *    that this used to be. `put` already refuses this way rather than discovering a limit halfway.
- *
- * ⚠ Every protection this branch already had is still here and still applies to the whole file:
- *   bytes a terminal would act on are refused (`readableOnATerminal`), a reader that closed the
- *   pipe first is an ordinary end and not a failure, and any other write failure throws.
- */
-export function stdoutSink(to, limit = STDOUT_HOLD_LIMIT) {
-    const held = [];
-    let total = 0;
-    const tooLarge = (size) => new NmtsError(`This file is ${size} bytes, and \`--out -\` hands over at most ${limit}.`, {
-        exitCode: 4,
-        nextStep: "Nothing was written and nothing was sent. A pipe cannot be taken back, so this mode " +
-            "proves the whole file before it sends a byte, which means holding it. Use `--out <name>` " +
-            "— that writes any size, and the file only appears under that name once it has been checked.",
-    });
-    const forget = () => {
-        for (const run of held)
-            run.fill(0);
-        held.length = 0;
-    };
-    return {
-        expect: (size) => {
-            if (size > limit)
-                throw tooLarge(size);
-        },
-        write: async (bytes) => {
-            // ⚠ Copied, because the caller zeroes what it handed over as soon as this resolves.
-            total += bytes.length;
-            if (total > limit) {
-                forget();
-                throw tooLarge(total);
-            }
-            held.push(new Uint8Array(bytes));
-        },
-        commit: async () => {
-            const whole = new Uint8Array(total);
-            let at = 0;
-            for (const run of held) {
-                whole.set(run, at);
-                at += run.length;
-            }
-            forget();
-            // ⚠ NOT zeroed afterwards, deliberately: `ByteDestination` promises only that the bytes have
-            //   been handed over, and a destination is entitled to keep the array it was given — the
-            //   tests use one that does. Wiping it here would hand a reader a buffer of zeroes.
-            return await handOver(whole, to);
-        },
-        abandon: async () => forget(),
-    };
-}
+//
+// ⛔ ONLY THE SHAPE IS HERE. The two destinations this tool ships — a file on a disk, and whatever
+//    is reading its stdout — are both Node's, and they live in `download-sink-node.ts`. What is
+//    left is the contract, which is what a caller in a browser implements to hand a download to a
+//    `Blob`, an element or a stream of its own.
+export {};

package/dist/download.js

@@ -26,7 +26,8 @@
 //    the engine's own buffer for the chunk it is assembling, and the one chunk of plaintext it
 //    hands back — 4 MiB each in NCF-3. A hundred-gigabyte file costs the same as a hundred-megabyte
 //    one. The exception is `--out -`, which is bounded by `STDOUT_HOLD_LIMIT` and refuses above it.
-import { createHash } from "node:crypto";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { fromBase64Url, utf8 } from "./bytes.js";
 import { request } from "./api.js";
 import { AAD, DERIVED, loadCrypto } from "./crypto.js";
 import { asParts, fetchPart, openPart } from "./download-part.js";
@@ -69,7 +70,7 @@ export async function fetchFile(input) {
     derived.fill(0);
     let dek;
     try {
-        dek = crypt.envelope_open(dataKey, new TextEncoder().encode(AAD.dekWrap), Buffer.from(input.dekWrapped, "base64url"));
+        dek = crypt.envelope_open(dataKey, utf8(AAD.dekWrap), fromBase64Url(input.dekWrapped));
     }
     catch {
         dataKey.fill(0);
@@ -80,7 +81,7 @@ export async function fetchFile(input) {
     let expected = null;
     if (input.contentHashCt !== undefined && input.contentHashCt !== "") {
         try {
-            expected = crypt.envelope_open(dataKey, new TextEncoder().encode(AAD.contentHash), Buffer.from(input.contentHashCt, "base64url"));
+            expected = crypt.envelope_open(dataKey, utf8(AAD.contentHash), fromBase64Url(input.contentHashCt));
         }
         catch {
             dataKey.fill(0);
@@ -115,7 +116,7 @@ export async function fetchFile(input) {
  *    sees the finished file or sees nothing under that name.
  */
 async function collect(crypt, ordered, dek, expected, size, chain, read, sink) {
-    const hasher = createHash("sha256");
+    const hasher = sha256.create();
     let remaining = size;
     try {
         // ⛔ Asked before a byte is fetched. A destination that cannot take a file this size says so

package/dist/engine-node.d.ts

@@ -0,0 +1,19 @@
+import { type CryptoGlue } from "./crypto-surface.ts";
+/**
+ * Where the engine's WebAssembly sits, in the three places an installation can put it.
+ *
+ * ⛔ FOUND RATHER THAN CONFIGURED. The package carries it in `vendor/`, a checkout runs from
+ *    `src/` with the same folder one level further up, and the repository's own web tree holds a
+ *    build of the same crate. A path in a setting would be a fourth answer nobody keeps right.
+ */
+export declare function engineDir(): string;
+/**
+ * Load the engine once per process.
+ *
+ * ⛔ NO TYPE ASSERTION. A dynamically imported module is `unknown`, and staying honest about that
+ *    matters here more than anywhere: a rebuild that renamed an export would otherwise become
+ *    "undefined is not a function" deep inside a derivation.
+ */
+export declare function loadEngine(): Promise<CryptoGlue>;
+/** For tests that need a fresh load. */
+export declare function forgetEngine(): void;

package/dist/engine-node.js

@@ -0,0 +1,77 @@
+// Finding and loading the engine on a machine with a disk.
+//
+// ⛔ NOTHING IS RE-IMPLEMENTED HERE. The bytes that derive an account's keys are the same
+//    WebAssembly the browser runs, built from the same Rust crate — this file only finds the build
+//    and hands it to the shape check every load passes.
+//
+// ⛔ SEPARATE FROM `host-node.ts` SO THAT REGISTERING A HOST COSTS NOTHING. `nmts --help` puts the
+//    host in place and never derives anything; loading this file, and the four `node:` modules it
+//    needs, on every run would be a fixed cost an agent pays thousands of times.
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { isCryptoGlue, missingExports } from "./crypto-surface.js";
+import { NmtsError } from "./errors.js";
+/**
+ * Where the engine's WebAssembly sits, in the three places an installation can put it.
+ *
+ * ⛔ FOUND RATHER THAN CONFIGURED. The package carries it in `vendor/`, a checkout runs from
+ *    `src/` with the same folder one level further up, and the repository's own web tree holds a
+ *    build of the same crate. A path in a setting would be a fourth answer nobody keeps right.
+ */
+export function engineDir() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(here, "..", "vendor", "nmts-crypto"),
+        join(here, "..", "..", "vendor", "nmts-crypto"),
+        join(here, "..", "..", "web", "vendor", "nmts-crypto"),
+    ];
+    for (const dir of candidates) {
+        if (existsSync(join(dir, "nmts_crypto_wasm_bg.wasm")))
+            return dir;
+    }
+    throw new NmtsError("The NMTS crypto engine is missing from this installation.", {
+        exitCode: 1,
+        nextStep: "Reinstall the package. Nothing can be encrypted or decrypted without it.",
+    });
+}
+let engine = null;
+/**
+ * Load the engine once per process.
+ *
+ * ⛔ NO TYPE ASSERTION. A dynamically imported module is `unknown`, and staying honest about that
+ *    matters here more than anywhere: a rebuild that renamed an export would otherwise become
+ *    "undefined is not a function" deep inside a derivation.
+ */
+export async function loadEngine() {
+    if (engine !== null)
+        return engine;
+    const dir = engineDir();
+    const module = await import(__rewriteRelativeImportExtension(pathToFileURL(join(dir, "nmts_crypto_wasm.js")).href));
+    if (typeof module !== "object" || module === null || !("default" in module)) {
+        throw new NmtsError("The NMTS crypto engine did not load (no initialiser).", { exitCode: 1 });
+    }
+    const init = Reflect.get(module, "default");
+    if (typeof init !== "function") {
+        throw new NmtsError("The NMTS crypto engine did not load (initialiser is not callable).", { exitCode: 1 });
+    }
+    await init({ module_or_path: await readFile(join(dir, "nmts_crypto_wasm_bg.wasm")) });
+    if (!isCryptoGlue(module)) {
+        throw new NmtsError(`The NMTS crypto engine is missing: ${missingExports(module).join(", ")}. This build does not match this tool.`, { exitCode: 1, nextStep: "Reinstall the package." });
+    }
+    engine = module;
+    return module;
+}
+/** For tests that need a fresh load. */
+export function forgetEngine() {
+    engine = null;
+}

package/dist/env-vars.d.ts

@@ -0,0 +1,20 @@
+/** Which NMTS server this run talks to. */
+export declare const SERVER_ENV_VAR = "NMTS_SERVER";
+/** Which storage network that server uses. */
+export declare const NETWORK_ENV_VAR = "NMTS_NETWORK";
+/**
+ * Point reads at somebody else's aggregator, or at a development stack.
+ *
+ * ⚠ It replaces the list rather than adding to it, and that is deliberate: a run should read from
+ *   where it was told to read, not from there AND the public hosts. Comma-separated for more
+ *   than one, tried in the order given.
+ */
+export declare const AGGREGATOR_ENV_VAR = "NMTS_AGGREGATOR";
+/**
+ * Push writes through somebody else's relay, or through a development stack.
+ *
+ * ⚠ ONE host, not a list. Unlike reads there is nothing to fail over to — see `RELAY_HOSTS`.
+ */
+export declare const RELAY_ENV_VAR = "NMTS_RELAY";
+/** Ask a different Sui JSON-RPC node the shard-count question. */
+export declare const SUI_RPC_ENV_VAR = "NMTS_SUI_RPC";

package/dist/env-vars.js

@@ -0,0 +1,27 @@
+// The names of the environment variables this tool reads.
+//
+// ⛔ NAMES ONLY, AND NO IMPORTS. `nmts --help` prints several of these, and a help text that had to
+//    load the module that USES a variable would drag that module's whole chain into every run —
+//    `check:cli-startup` measures exactly that, and it is the leak it has caught most often. The
+//    modules that read the variables re-export their own name from here, so every caller still
+//    finds it where it belongs and there is still only one spelling of each.
+/** Which NMTS server this run talks to. */
+export const SERVER_ENV_VAR = "NMTS_SERVER";
+/** Which storage network that server uses. */
+export const NETWORK_ENV_VAR = "NMTS_NETWORK";
+/**
+ * Point reads at somebody else's aggregator, or at a development stack.
+ *
+ * ⚠ It replaces the list rather than adding to it, and that is deliberate: a run should read from
+ *   where it was told to read, not from there AND the public hosts. Comma-separated for more
+ *   than one, tried in the order given.
+ */
+export const AGGREGATOR_ENV_VAR = "NMTS_AGGREGATOR";
+/**
+ * Push writes through somebody else's relay, or through a development stack.
+ *
+ * ⚠ ONE host, not a list. Unlike reads there is nothing to fail over to — see `RELAY_HOSTS`.
+ */
+export const RELAY_ENV_VAR = "NMTS_RELAY";
+/** Ask a different Sui JSON-RPC node the shard-count question. */
+export const SUI_RPC_ENV_VAR = "NMTS_SUI_RPC";

package/dist/extend-plan.d.ts

@@ -143,6 +143,8 @@ export type SignExtension = (input: {
     network: string;
     /** ⛔ The NMTS key. It never leaves this machine: it derives the wallet and nothing else. */
     code: string;
+    /** Which of this key's wallets pays — the account's own number (`wallet-pay-index.ts`). */
+    wallet: number;
     objectIds: readonly string[];
     epochs: number;
 }) => Promise<string>;