@needmoretruth/nmts-cli 0.34.4 → 0.36.1

package/dist/gate.js

@@ -34,7 +34,7 @@ export async function unlocked(key, now) {
 }
 export async function gate(act, args, io = {}) {
     const a = ACTS[act];
-    const mode = currentMode();
+    const mode = await currentMode();
     const now = io.now ?? (() => new Date());
     if (a.tier === "none")
         return { ask: false, mode };

package/dist/help.js

@@ -10,10 +10,11 @@ import { AGENTS_DOC, BINARY_NAME, HOME_URL, PRODUCT_NAME, SOURCE_URL, VERSION }
 //    reading it here costs `nmts --help` nothing (`check:cli-startup`).
 import { ATTACH_LOG_TEXT, SUPPORT_LONG, supportHelpText } from "./support-copy.js";
 import { API_KEY_ENV_VAR, API_KEY_FILE_ENV_VAR, CODE_ENV_VAR, CODE_FILE_ENV_VAR, PASSPHRASE_ENV_VAR, } from "./credentials.js";
-import { NETWORK_ENV_VAR } from "./network.js";
+// ⛔ THE NAMES COME FROM THE MODULE THAT HAS NO IMPORTS, not from the modules that USE them. Those
+//    three reach the host register, and loading them to print a variable's name would put that
+//    chain in front of every `nmts --help` (`check:cli-startup`).
+import { AGGREGATOR_ENV_VAR, NETWORK_ENV_VAR, SERVER_ENV_VAR } from "./env-vars.js";
 import { LATEST_RELEASE_URL, NO_CHECK_ENV_VAR } from "./update-source.js";
-import { SERVER_ENV_VAR } from "./server.js";
-import { AGGREGATOR_ENV_VAR } from "./walrus.js";
 import { CHECK_DOES_NOT_PROVE, CHECK_PROVES, RECOVERY_TOOL_URL, wrapText, } from "./recovery-release.js";
 export function helpText(version) {
     return [
@@ -52,7 +53,9 @@ export function helpText(version) {
         `                        refused in mode auto. Read first: terms · privacy · notices`,
         `  wallet                Show the account's wallet address, and its SUI and WAL balances`,
         `  wallet address        Just the address, derived on this machine — no network call.`,
-        `                        \`--qr\` draws it as a code a phone can scan`,
+        `                        \`--qr\` draws it as a code a phone can scan; \`--index N\` another wallet`,
+        `  wallet list           Every wallet this key has, with balances, and which one pays`,
+        `  wallet use <number>   Pay from that wallet from now on — on the account, not this machine`,
         `  wallet activity       The wallet's recent transactions, named where the chain proves it`,
         `  wallet storage        The storage resources (size × time) the wallet holds, unbound`,
         `  wallet storage split <id> --size <n>|--epochs <n> · merge <id> <id> · transfer <id> <address>`,
@@ -121,6 +124,9 @@ export function helpText(version) {
         `  privacy               The Privacy Policy in force`,
         `  mcp                   Serve this account's commands as tools, for an agent that speaks MCP`,
         `  s3                    Serve the drive to any S3 program, on this machine only`,
+        `  platform keygen       Make the key pair a business signs its Platform requests with — writes`,
+        `                        both halves to a file only you can read, prints only the public half`,
+        `  platform register     Where that public key is registered: a browser session, not this tool`,
         ``,
         `OPTIONS`,
         `  --server <url>        NMTS server (default ${SERVER_ENV_VAR} or the live one)`,
@@ -169,7 +175,8 @@ export function helpText(version) {
         `  --desc                Reverse whichever order is in effect (ls)`,
         `  --hidden              Include entries whose name begins with a dot (push)`,
         `  --out <path>          Where to write files (get, pull, mcp, listfile, recovery,`,
-        `                        recovery-list, kit, create, notices, terms, privacy). Default: here`,
+        `                        recovery-list, kit, create, notices, terms, privacy, platform`,
+        `                        keygen). Default: here`,
         `  --out -               Send a fetched file to stdout instead of writing it (get, listfile)`,
         `  --lang <en|ko>        Which language of a document (terms, privacy). Default: English`,
         `  --board               The message board's terms rather than the service's (terms)`,

package/dist/host-contract.d.ts

@@ -0,0 +1,7 @@
+import type { Host } from "./host.ts";
+/**
+ * Put a host's state through everything the package relies on, and say what it got wrong.
+ *
+ * An empty array is a pass.
+ */
+export declare function hostContract(host: Host): Promise<string[]>;

package/dist/host-contract.js

@@ -0,0 +1,95 @@
+// The one test both hosts sit: what "keeping state" has to mean, whoever is keeping it.
+//
+// ⛔ ONE FUNCTION, RUN FROM TWO TEST FILES. `test/host-node.test.ts` runs it over the Node host and
+//    the SDK's `test/host-browser.test.ts` runs it over the browser one. Two tests written
+//    separately would drift, and the way that drift shows up is a half-finished upload that
+//    resumes on a laptop and starts again in a browser — the same account, the same file, two
+//    answers.
+//
+// ⛔ IT REPORTS EVERY VIOLATION RATHER THAN THROWING AT THE FIRST. A host that is wrong is usually
+//    wrong about one thing; a list says which, and a caller that wanted an assertion gets one by
+//    asserting the list is empty.
+//
+// ⚠ IT WRITES. The keys all sit under `contract/`, which nothing else uses, and each one is
+//   removed before the function returns — including when a check above it failed.
+/** Where this check keeps its scratch. Nothing else in the package writes under it. */
+const AREA = "contract";
+function sample(length, seed) {
+    const out = new Uint8Array(length);
+    for (let i = 0; i < length; i += 1)
+        out[i] = (i * 31 + seed) & 0xff;
+    return out;
+}
+function same(left, right) {
+    if (left === undefined || left.length !== right.length)
+        return false;
+    for (let i = 0; i < left.length; i += 1)
+        if (left[i] !== right[i])
+            return false;
+    return true;
+}
+/**
+ * Put a host's state through everything the package relies on, and say what it got wrong.
+ *
+ * An empty array is a pass.
+ */
+export async function hostContract(host) {
+    const state = host.state;
+    const problems = [];
+    const one = `${AREA}/one`;
+    const two = `${AREA}/two`;
+    const big = `${AREA}/big`;
+    const say = (what) => void problems.push(what);
+    try {
+        // A key nothing has written is not an error and not empty bytes: it is nothing.
+        if ((await state.read(`${AREA}/never-written`)) !== undefined) {
+            say("read() of a key that was never written answered bytes instead of undefined");
+        }
+        const first = sample(64, 1);
+        await state.write(one, first);
+        if (!same(await state.read(one), first))
+            say("read() did not hand back the bytes write() was given");
+        // ⛔ THE SECOND WRITE REPLACES. A store that appended, or that kept the first value, would make
+        //    every record in the package grow a second version nobody reads.
+        const second = sample(96, 2);
+        await state.write(one, second);
+        if (!same(await state.read(one), second))
+            say("writing a key a second time did not replace what was there");
+        await state.write(two, sample(8, 3));
+        const listed = await state.keys(`${AREA}/`);
+        for (const key of [one, two]) {
+            if (!listed.includes(key))
+                say(`keys("${AREA}/") did not include ${key}`);
+        }
+        if (listed.includes(`${AREA}/never-written`))
+            say("keys() listed a key that was never written");
+        await state.remove(one);
+        if ((await state.read(one)) !== undefined)
+            say("remove() left the bytes readable");
+        if ((await state.keys(`${AREA}/`)).includes(one))
+            say("remove() left the key in keys()");
+        // Removing what is not there is how every caller here clears a record it may never have made.
+        await state.remove(one);
+        // ⛔ ONE MEBIBYTE, BECAUSE THAT IS WHAT AN UPLOAD KEEPS. A reservation holds a sealed part, and
+        //    a store that quietly truncated or refused at some smaller size would lose exactly the
+        //    records that let a large upload resume — and nothing else would notice.
+        const large = sample(1024 * 1024, 4);
+        await state.write(big, large);
+        if (!same(await state.read(big), large))
+            say("a 1 MiB value did not come back as it was written");
+    }
+    catch (error) {
+        say(`a call threw instead of answering: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        for (const key of [one, two, big]) {
+            try {
+                await state.remove(key);
+            }
+            catch {
+                // The store is somebody else's; a scratch key left behind is not this check's to report.
+            }
+        }
+    }
+    return problems;
+}

package/dist/host-node.d.ts

@@ -0,0 +1,27 @@
+import { type Host, type StateHost } from "./host.ts";
+/** Files under the person's own config directory, named by `placeOf`. */
+export declare function nodeState(): StateHost;
+/** Where a state key lands on this machine. For tests, and for messages that name a file. */
+export declare function statePath(key: string): string;
+/**
+ * Every `NMTS_*` variable this process is holding.
+ *
+ * ⛔ THE ONE PLACE THE WHOLE ENVIRONMENT IS READ. `redact.ts` needs the values to label them out of
+ *    a report, and a browser has none — so it is a host call rather than a `process.env` walk in a
+ *    module that has to run in both.
+ */
+export declare function nodeEnvEntries(): {
+    name: string;
+    value: string;
+}[];
+/** This machine, as the package's host. */
+export declare function nodeHost(): Host;
+/**
+ * Put this machine in the register: what the two Node doors — `index.ts` and the command's own
+ * entry point — call before anything that loads the engine, keeps state or reads the environment.
+ *
+ * ⛔ THE COMMAND LOADS THIS FILE LATE, not at the top of `main.ts`. The chain below reaches the
+ *    credentials module, and a fixed cost at the head of `nmts --help` is one an agent running
+ *    this tool in a loop pays thousands of times (`check:cli-startup`).
+ */
+export declare function registerNodeHost(): void;

package/dist/host-node.js

@@ -0,0 +1,192 @@
+// The Node host: the five things `host.ts` names, done the way this tool has always done them.
+//
+// ⛔ THIS FILE IS WHERE THE `node:` IMPORTS WENT. They used to be spread over a dozen modules, and
+//    that is what stopped the package running anywhere else. Nothing moved in behaviour: the
+//    engine is found on disk the same way, the state is the same files under the same names, and
+//    an installation made by an earlier version is read without noticing the change.
+//
+// ⛔ THE FILE NAMES ARE A COMPATIBILITY PROMISE, not a mapping somebody is free to tidy. A kept
+//    file list, a chunk of one and an unfinished upload all sit in a home directory that this
+//    version did not create. `placeOf` is the whole of that promise, and it is a table so a reader
+//    can check it against a real `~/.nmts` in one glance.
+//
+// ⛔ EVERY WRITE IS ASIDE-AND-RENAME, 0600, under a 0700 directory. A rename within one directory
+//    is atomic, so a reader meets the old bytes or the new ones and never half of either — which
+//    matters most for the one record that says an upload was already paid for.
+//
+// ⚠ NOTHING HERE THROWS ON A FAILED WRITE. Every caller in the package treats missing state as
+//   "do the work again", so a full disk, a read-only home directory or a directory owned by
+//   somebody else costs a slower command rather than a failed one.
+//
+// ⛔ THE ENGINE AND THE ZSTD ENCODER ARE LOADED WHEN THEY ARE ASKED FOR, not when the host is made.
+//    `nmts --help` registers a host and uses none of it, and an agent runs this tool in a loop —
+//    `check:cli-startup` measures exactly this and refuses a build that widened it.
+import { chmodSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join, sep } from "node:path";
+import { configDir, modesAreEnforced } from "./credentials.js";
+import { registerHost } from "./host.js";
+/**
+ * The file one state key names — the table an earlier installation's layout is read through.
+ *
+ * Anything not named here is spelled out as it reads: the slashes become directories and the last
+ * segment is the file name, which is what `uploads/…` and the host-contract check already are.
+ */
+function placeOf(key) {
+    if (key === "runlog")
+        return { dir: "", file: "runs.jsonl" };
+    if (key === "collision")
+        return { dir: "", file: "collision.json" };
+    if (key === "autonomy")
+        return { dir: "", file: "autonomy.json" };
+    if (key === "manifest/state")
+        return { dir: "", file: "file-list-state.json" };
+    const manifest = after(key, "manifest/");
+    if (manifest !== null)
+        return { dir: "", file: `file-list-${manifest}.json` };
+    const chunk = after(key, "chunks/");
+    if (chunk !== null) {
+        const cut = chunk.lastIndexOf("/");
+        return { dir: join("file-list-chunks", chunk.slice(0, cut)), file: `${chunk.slice(cut + 1)}.ct` };
+    }
+    const cut = key.lastIndexOf("/");
+    return cut < 0 ? { dir: "", file: key } : { dir: key.slice(0, cut), file: key.slice(cut + 1) };
+}
+function after(key, prefix) {
+    return key.startsWith(prefix) ? key.slice(prefix.length) : null;
+}
+/** The key a file stands for, or null when this tool keeps no key for it. The inverse of `placeOf`. */
+function keyOf(place) {
+    if (place.dir === "") {
+        if (place.file === "runs.jsonl")
+            return "runlog";
+        if (place.file === "collision.json")
+            return "collision";
+        if (place.file === "autonomy.json")
+            return "autonomy";
+        if (place.file === "file-list-state.json")
+            return "manifest/state";
+        const listed = place.file.match(/^file-list-(.+)\.json$/);
+        return listed?.[1] === undefined ? null : `manifest/${listed[1]}`;
+    }
+    const parts = place.dir.split(sep);
+    if (parts[0] === "file-list-chunks") {
+        if (!place.file.endsWith(".ct"))
+            return null;
+        return ["chunks", ...parts.slice(1), place.file.slice(0, -".ct".length)].join("/");
+    }
+    return [...parts, place.file].join("/");
+}
+/** Every file under the config directory, as `Place`s. A missing directory is no files. */
+function walk(root, dir, out) {
+    let names;
+    try {
+        names = readdirSync(join(root, dir));
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        const full = join(root, dir, name);
+        let isDirectory = false;
+        try {
+            isDirectory = statSync(full).isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isDirectory)
+            walk(root, join(dir, name), out);
+        else
+            out.push({ dir, file: name });
+    }
+}
+function atomically(target, bytes) {
+    const scratch = `${target}.${process.pid}.tmp`;
+    writeFileSync(scratch, bytes, { mode: 0o600 });
+    if (modesAreEnforced())
+        chmodSync(scratch, 0o600);
+    renameSync(scratch, target);
+}
+/** Files under the person's own config directory, named by `placeOf`. */
+export function nodeState() {
+    return {
+        durable: true,
+        async read(key) {
+            const place = placeOf(key);
+            try {
+                return new Uint8Array(readFileSync(join(configDir(), place.dir, place.file)));
+            }
+            catch {
+                return undefined;
+            }
+        },
+        async write(key, bytes) {
+            const place = placeOf(key);
+            const dir = join(configDir(), place.dir);
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+            if (modesAreEnforced())
+                chmodSync(configDir(), 0o700);
+            atomically(join(dir, place.file), bytes);
+        },
+        async remove(key) {
+            const place = placeOf(key);
+            rmSync(join(configDir(), place.dir, place.file), { force: true });
+        },
+        async keys(prefix) {
+            const found = [];
+            walk(configDir(), "", found);
+            const keys = [];
+            for (const place of found) {
+                const key = keyOf(place);
+                if (key !== null && key.startsWith(prefix))
+                    keys.push(key);
+            }
+            return keys;
+        },
+    };
+}
+/** Where a state key lands on this machine. For tests, and for messages that name a file. */
+export function statePath(key) {
+    const place = placeOf(key);
+    return join(configDir(), place.dir, place.file);
+}
+/**
+ * Every `NMTS_*` variable this process is holding.
+ *
+ * ⛔ THE ONE PLACE THE WHOLE ENVIRONMENT IS READ. `redact.ts` needs the values to label them out of
+ *    a report, and a browser has none — so it is a host call rather than a `process.env` walk in a
+ *    module that has to run in both.
+ */
+export function nodeEnvEntries() {
+    const out = [];
+    for (const [name, value] of Object.entries(process.env)) {
+        if (value !== undefined)
+            out.push({ name, value });
+    }
+    return out;
+}
+/** This machine, as the package's host. */
+export function nodeHost() {
+    return {
+        name: "node",
+        engine: { load: async () => (await import("./engine-node.js")).loadEngine() },
+        state: nodeState(),
+        env: (name) => process.env[name],
+        envEntries: nodeEnvEntries,
+        // ⛔ STDERR, NOT STDOUT. Progress is not the answer, and a caller redirecting the answer to a
+        //    file must not find it interleaved with percentages.
+        log: (line) => void process.stderr.write(line),
+        zstd: { register: async () => (await import("./zstd-node.js")).registerNodeZstd() },
+    };
+}
+/**
+ * Put this machine in the register: what the two Node doors — `index.ts` and the command's own
+ * entry point — call before anything that loads the engine, keeps state or reads the environment.
+ *
+ * ⛔ THE COMMAND LOADS THIS FILE LATE, not at the top of `main.ts`. The chain below reaches the
+ *    credentials module, and a fixed cost at the head of `nmts --help` is one an agent running
+ *    this tool in a loop pays thousands of times (`check:cli-startup`).
+ */
+export function registerNodeHost() {
+    registerHost(nodeHost());
+}

package/dist/host.d.ts

@@ -0,0 +1,99 @@
+import type { CryptoGlue } from "./crypto-surface.ts";
+/** Which runtime put the host in the register. Reported; nothing branches on it. */
+export type HostName = "node" | "browser";
+/** Loading the WebAssembly engine that derives this account's keys. */
+export interface EngineHost {
+    /**
+     * The engine, made once and kept.
+     *
+     * ⛔ THE SHAPE CHECK IS NOT THE HOST'S. `crypto.ts` runs `isCryptoGlue` over whatever comes
+     *    back, so both hosts pass the same gate and a build that renamed an export is named at load
+     *    time whichever runtime met it.
+     */
+    load(): Promise<CryptoGlue>;
+}
+/**
+ * What this installation keeps between runs, as bytes under a key.
+ *
+ * ⛔ KEYS ARE `<area>/<name>`, and the area is what a reader of the key can see at a glance:
+ *    `manifest/…` is a kept file list, `chunks/…` a copy of one of its chunks, `uploads/…` a
+ *    reservation a half-finished upload can be resumed from, `runlog` this machine's record of
+ *    what it did, `collision` and `autonomy` the two answers a person gave at setup.
+ *
+ * ⛔ NOTHING HERE IS A CACHE THE ACCOUNT DEPENDS ON. Every reader treats "no bytes" as "fetch it
+ *    again", so a host whose store is empty, full or unavailable is a slower program and never a
+ *    broken one.
+ */
+export interface StateHost {
+    /**
+     * False when what is written will not survive the page or the process — a browser with no
+     * IndexedDB, or one that would not open it. Reported so a caller can say so rather than
+     * promising a resumable upload it cannot resume.
+     */
+    readonly durable: boolean;
+    read(key: string): Promise<Uint8Array | undefined>;
+    write(key: string, bytes: Uint8Array): Promise<void>;
+    remove(key: string): Promise<void>;
+    /** Every key that starts with `prefix`, in no particular order. */
+    keys(prefix: string): Promise<string[]>;
+}
+/**
+ * Filling the file-list codec's zstd register (NCF-3 §6.3.4). Safe to call more than once.
+ *
+ * ⛔ IT IS AWAITED. Both hosts fetch their encoder rather than carrying it — Node's `zlib` and a
+ *    WebAssembly build respectively — and a list read that did not wait for it would fall back to
+ *    gzip for a frame the browser wrote in zstd.
+ */
+export interface ZstdHost {
+    register(): Promise<void>;
+}
+/** Everything this package needs from the runtime it was loaded into. */
+export interface Host {
+    readonly name: HostName;
+    readonly engine: EngineHost;
+    readonly state: StateHost;
+    /**
+     * A named value from the environment, or undefined.
+     *
+     * ⚠ A PAGE HAS NO ENVIRONMENT, so the addresses a variable would have carried — the relay, the
+     *   Sui endpoint, the aggregators — arrive as options on the client, and the browser host
+     *   answers those three under the same variable names and undefined to everything else. Asking
+     *   through here rather than `process.env` is what lets one module do both without knowing which
+     *   runtime it is in.
+     */
+    env(name: string): string | undefined;
+    /**
+     * Every variable this process is holding, for the one caller that needs the VALUES rather than
+     * one of them: `redact.ts` labels them out of a report before it is written down.
+     *
+     * ⚠ A BROWSER ANSWERS AN EMPTY LIST, which is the truth rather than a stub: a page holds no
+     *   environment, so there is nothing of that kind to take out of a report.
+     */
+    envEntries(): {
+        name: string;
+        value: string;
+    }[];
+    /** One line about how far along something is. Where it goes is the host's business. */
+    log(line: string): void;
+    readonly zstd: ZstdHost;
+}
+/**
+ * Put the host for this runtime in the register.
+ *
+ * Called once, from the entry point a program imported, before anything else runs. Calling it
+ * again replaces what is there, which is what a test that swaps a host needs and what nothing else
+ * should do.
+ */
+export declare function registerHost(next: Host): void;
+/** Empty the register. For tests that need to see what an unhosted module does. */
+export declare function forgetHost(): void;
+/** True when something has registered one. Lets a caller ask instead of catching. */
+export declare function hostIsRegistered(): boolean;
+/**
+ * The host for this runtime.
+ *
+ * ⛔ IT REFUSES RATHER THAN GUESSING. A program that imported `@needmoretruth/nmts-cli/portable`
+ *    and registered nothing has one thing wrong with it, and naming that is worth more than a
+ *    default host that half-works and fails somewhere further in.
+ */
+export declare function host(): Host;

package/dist/host.js

@@ -0,0 +1,59 @@
+// The five things this package cannot do by itself, in one register — so that everything else in
+// it is code that runs anywhere a `fetch` does.
+//
+// ⛔ A REGISTER, NOT A BRANCH. Nothing below asks which runtime it is in. The entry point that a
+//    program imports puts a host in here — `index.ts` registers the Node one, the SDK's `/browser`
+//    entry registers a browser one — and every portable module afterwards asks for the one that is
+//    there. A `typeof window === "undefined"` test in each of the modules instead would be the
+//    same decision made twenty times, and the twenty-first is the one that gets it wrong on a
+//    runtime nobody was thinking about.
+//
+// ⛔ FIVE, AND THEY ARE THE WHOLE LIST. Loading the engine, keeping state, reading the
+//    environment, saying how far along something is, and having a zstd encoder: those are what a
+//    browser cannot do the way Node does. Anything a sixth entry would be asked to carry is a sign
+//    that a module is doing something it should be handed instead.
+//
+// ⛔ STATE IS ASYNCHRONOUS. A browser's store is a database with transactions and there is no
+//    honest way to read one without waiting. Node's is a file and could have stayed synchronous;
+//    making it look synchronous in a browser would take a worker and a shared buffer to fake, and
+//    a fake that blocks the page is worse than the `await` it saves.
+//
+// ⛔ NO `node:` IMPORT MAY EVER APPEAR IN THIS FILE, or in anything it reaches. `portable.ts` is
+//    the entry that promises it and `test/portable-closure.test.ts` is what holds the promise.
+import { NmtsError } from "./errors.js";
+let registered = null;
+/**
+ * Put the host for this runtime in the register.
+ *
+ * Called once, from the entry point a program imported, before anything else runs. Calling it
+ * again replaces what is there, which is what a test that swaps a host needs and what nothing else
+ * should do.
+ */
+export function registerHost(next) {
+    registered = next;
+}
+/** Empty the register. For tests that need to see what an unhosted module does. */
+export function forgetHost() {
+    registered = null;
+}
+/** True when something has registered one. Lets a caller ask instead of catching. */
+export function hostIsRegistered() {
+    return registered !== null;
+}
+/**
+ * The host for this runtime.
+ *
+ * ⛔ IT REFUSES RATHER THAN GUESSING. A program that imported `@needmoretruth/nmts-cli/portable`
+ *    and registered nothing has one thing wrong with it, and naming that is worth more than a
+ *    default host that half-works and fails somewhere further in.
+ */
+export function host() {
+    if (registered === null) {
+        throw new NmtsError("HOST_MISSING: no runtime host has been registered.", {
+            exitCode: 1,
+            nextStep: "Import `@needmoretruth/nmts-cli` (which registers the Node host) or the SDK's `/browser` " +
+                "entry (which registers a browser one) before calling anything that keeps state.",
+        });
+    }
+    return registered;
+}

package/dist/index.d.ts

@@ -1,42 +1,8 @@
-export { NmtsError, NotLoggedInError, renderError } from "./errors.ts";
-export { request, ServerError, DEFAULT_TIMEOUT_MS } from "./api.ts";
-export type { RequestOptions, ServerRefusal } from "./api.ts";
-export { DEFAULT_SERVER, SERVER_ENV_VAR, resolveServer } from "./server.ts";
-export { NETWORKS, NETWORK_ENV_VAR, resolveNetwork } from "./network.ts";
-export type { Network } from "./network.ts";
+export * from "./portable.ts";
 export { API_KEY_ENV_VAR, API_KEY_FILE_ENV_VAR, CODE_ENV_VAR, CODE_FILE_ENV_VAR, configDir, readSecretFile, resolveAccountCode, resolveApiKey, } from "./credentials.ts";
 export type { CredentialSource, ResolvedCode } from "./credentials.ts";
-export { assertUsableCode, identityOf } from "./account.ts";
-export type { AccountIdentity } from "./account.ts";
-export { AAD, DERIVED, loadCrypto } from "./crypto.ts";
-export type { CryptoGlue } from "./crypto.ts";
-export { readFileList } from "./manifest.ts";
-export type { FileList } from "./manifest.ts";
-export { addEntry, applyManyToList, applyToList, planAddition } from "./manifest-write.ts";
-export type { AddEntryInput, AddEntryResult, ListEditInput, ListEditResult } from "./manifest-write.ts";
-export type { Manifest, ManifestEntry } from "./shared/lib/drive/manifest-codec.ts";
-export { buildIndex, entryAt, folderIdFor, fullPathOf, isLive, KIND_FILE, KIND_FOLDER, namesIn, normalisePath, trashedAt, } from "./drive-paths.ts";
-export type { FindOptions, ManifestIndex } from "./drive-paths.ts";
-export { setTrashed } from "./item-trash.ts";
-export { fileSource, partKeysOf, uploadFile } from "./upload-file.ts";
-export type { FileUploadInput, FileUploadStep, PlaintextSource } from "./upload-file.ts";
-export { createUploadApi } from "./upload-api.ts";
-export { CREDIT_BYTES, creditsFor, measureLocal, partSizeFor, planAndPrice, UPLOAD_EPOCHS, } from "./upload-price.ts";
-export { clearItemRecord, clearReservation } from "./upload-store.ts";
-export { UploadError } from "./upload-wire.ts";
-export type { BlobProtocol, UploadApi, UploadResult, UploadStep } from "./upload-wire.ts";
-export type { PaddingRule } from "./shared/lib/crypto/size-padding.ts";
-export { DEFAULT_PART_BYTES } from "./seal.ts";
-export { createBlobProtocol, readCurrentEpoch } from "./walrus-write.ts";
-export { fetchFile, fetchWithKey } from "./download.ts";
-export type { FetchedFile, FetchInput } from "./download.ts";
-export { fileSink } from "./download-sink.ts";
-export type { PlaintextSink } from "./download-sink.ts";
-export { AGGREGATOR_ENV_VAR, readBlob, RELAY_ENV_VAR, SUI_RPC_ENV_VAR } from "./walrus.ts";
-export type { ReadOptions } from "./walrus.ts";
-export { coinAmount, readBalances, walletAddress } from "./wallet.ts";
-export type { ChainReader, CoinBalance, WalletBalances } from "./wallet.ts";
-export { chainReader } from "./wallet-chain.ts";
-export { signerAddress, signExtension, signTransfer } from "./wallet-sign.ts";
-export type { SignTransfer } from "./wallet-sign.ts";
-export { HOME_URL, PRODUCT_NAME, SOURCE_URL, SUPPORT_EMAIL, VERSION } from "./product.ts";
+export { nodeHost, registerNodeHost, statePath } from "./host-node.ts";
+export { engineDir } from "./engine-node.ts";
+export { fileSource } from "./upload-file-node.ts";
+export { measureLocal } from "./upload-price-node.ts";
+export { fileSink } from "./download-sink-node.ts";

package/dist/index.js

@@ -10,40 +10,28 @@
 //    that stops to ask on somebody's server is a library that hangs. A program that wants the
 //    NMTS key from the environment reads `credentials.ts` and decides for itself.
 //
+// ⛔ THIS ENTRY POINT IS NODE'S, AND IT SAYS SO BY REGISTERING THE NODE HOST ON THE WAY IN. Every
+//    program that imports this package is unchanged by the split: the engine is still found on
+//    disk, state is still the same files under the same names, the environment is still read. What
+//    is new is that the same modules also run in a page, through `portable.ts` and a host
+//    registered there.
+//
 // ⚠ THE PACKAGE'S `exports` MAP NAMES THIS FILE AND A FEW OF THE MODULES BELOW BY SUBPATH. A
 //   module not named there is reachable through this file only; adding a subpath is a promise
 //   that its shape stays put, so it is done on purpose and one at a time.
-// Errors — the one shape every failure below arrives in.
-export { NmtsError, NotLoggedInError, renderError } from "./errors.js";
-// The server: one request function, and what a refusal looks like.
-export { request, ServerError, DEFAULT_TIMEOUT_MS } from "./api.js";
-export { DEFAULT_SERVER, SERVER_ENV_VAR, resolveServer } from "./server.js";
-export { NETWORKS, NETWORK_ENV_VAR, resolveNetwork } from "./network.js";
+import { registerNodeHost } from "./host-node.js";
+// ⛔ BEFORE ANYTHING BELOW CAN BE CALLED, AND THAT IS WHY IT IS A STATEMENT RATHER THAN SOMETHING A
+//    CALLER DOES. A module's imports run before its body, so by the time a program holds anything
+//    from this file the host is in place — and no existing caller had to learn that there is one.
+registerNodeHost();
+// Everything that runs anywhere, with the reasons: `portable.ts`.
+export * from "./portable.js";
 // Where a credential can come from on this machine. Reading is here; ASKING is not.
 export { API_KEY_ENV_VAR, API_KEY_FILE_ENV_VAR, CODE_ENV_VAR, CODE_FILE_ENV_VAR, configDir, readSecretFile, resolveAccountCode, resolveApiKey, } from "./credentials.js";
-// The account: what a code derives, and the engine that derives it.
-export { assertUsableCode, identityOf } from "./account.js";
-export { AAD, DERIVED, loadCrypto } from "./crypto.js";
-// The sealed file list: reading it, editing it, and walking it by path.
-export { readFileList } from "./manifest.js";
-export { addEntry, applyManyToList, applyToList, planAddition } from "./manifest-write.js";
-export { buildIndex, entryAt, folderIdFor, fullPathOf, isLive, KIND_FILE, KIND_FOLDER, namesIn, normalisePath, trashedAt, } from "./drive-paths.js";
-export { setTrashed } from "./item-trash.js";
-// Uploading: sealing here, buying storage with credits, pushing the sealed bytes.
-export { fileSource, partKeysOf, uploadFile } from "./upload-file.js";
-export { createUploadApi } from "./upload-api.js";
-export { CREDIT_BYTES, creditsFor, measureLocal, partSizeFor, planAndPrice, UPLOAD_EPOCHS, } from "./upload-price.js";
-export { clearItemRecord, clearReservation } from "./upload-store.js";
-export { UploadError } from "./upload-wire.js";
-export { DEFAULT_PART_BYTES } from "./seal.js";
-export { createBlobProtocol, readCurrentEpoch } from "./walrus-write.js";
-// Downloading: fetching sealed parts from the storage network and opening them here.
-export { fetchFile, fetchWithKey } from "./download.js";
-export { fileSink } from "./download-sink.js";
-export { AGGREGATOR_ENV_VAR, readBlob, RELAY_ENV_VAR, SUI_RPC_ENV_VAR } from "./walrus.js";
-// The wallet the NMTS key derives: reading it, and signing with it.
-export { coinAmount, readBalances, walletAddress } from "./wallet.js";
-export { chainReader } from "./wallet-chain.js";
-export { signerAddress, signExtension, signTransfer } from "./wallet-sign.js";
-// What this package is.
-export { HOME_URL, PRODUCT_NAME, SOURCE_URL, SUPPORT_EMAIL, VERSION } from "./product.js";
+// This machine as a host: the engine on disk, state in the config directory, the real environment.
+export { nodeHost, registerNodeHost, statePath } from "./host-node.js";
+export { engineDir } from "./engine-node.js";
+// Bytes in and out of the places only Node has: a file on a disk, and this process's own stdout.
+export { fileSource } from "./upload-file-node.js";
+export { measureLocal } from "./upload-price-node.js";
+export { fileSink } from "./download-sink-node.js";