@needmoretruth/nmts-cli 0.35.0 → 0.36.2

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,51 +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 { walletPut } from "./upload-wallet-put.ts";
-export type { WalletPutContext, WalletPutFile, WalletPutOutcome, WalletPutReview, WalletPutSeams, } from "./upload-wallet-put.ts";
-export { DEFAULT_UPLOAD_EPOCHS } from "./upload-wallet-plan.ts";
-export type { PartQuote, StorageChoice, UploadBudget, WalletUploadReads } from "./upload-wallet-plan.ts";
-export type { Spend } from "./wallet-grant.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, walCoinType, 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 { activeWalletOf, walletCountOf, WALLET_INDEX_LIMIT } from "./shared/lib/drive/manifest-settings.ts";
-export { discoverWallets, WALLET_SCAN_GAP } from "./shared/lib/wallet/discover.ts";
-export type { WalletProbe, WalletScan } from "./shared/lib/wallet/discover.ts";
-export { hasHistory } from "./wallet-list-chain.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,53 +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";
-// Uploading paid by the account's OWN WALLET instead of credits: the same seal-buy-push-record
-// path, priced and refused before anything is signed. `nmts put --pay wallet` is this plus a
-// terminal; the spending ledger and the standing gift are the command's and are not here.
-export { walletPut } from "./upload-wallet-put.js";
-export { DEFAULT_UPLOAD_EPOCHS } from "./upload-wallet-plan.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, walCoinType, walletAddress } from "./wallet.js";
-export { chainReader } from "./wallet-chain.js";
-export { signerAddress, signExtension, signTransfer } from "./wallet-sign.js";
-// WHICH of this key's wallets, and which of them have been used. One key derives a wallet at every
-// index (NCF-3 §1.3), so the account's own number is read out of the sealed list and the rest is a
-// walk. Both are here so that a library built on this package finds the SAME wallets under the same
-// numbers as `nmts wallet list` — a second walk, or a second reading of the setting, would be a
-// second answer to a question that has to have exactly one.
-export { activeWalletOf, walletCountOf, WALLET_INDEX_LIMIT } from "./shared/lib/drive/manifest-settings.js";
-export { discoverWallets, WALLET_SCAN_GAP } from "./shared/lib/wallet/discover.js";
-export { hasHistory } from "./wallet-list-chain.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";

package/dist/main.js

@@ -40,6 +40,7 @@ import { BINARY_NAME, VERSION } from "./product.js";
  */
 export const NOT_BUILT_YET = [];
 export async function run(argv) {
+    (await import("./host-node.js")).registerNodeHost();
     const args = parseArgs(argv);
     if (args.version) {
         process.stdout.write(`${VERSION}\n`);
@@ -54,7 +55,7 @@ export async function run(argv) {
     //    ⚠ `mode` itself is exempt: the command that prints the setting does not need it twice.
     if (args.command !== "mode") {
         const { announcement, currentMode } = await import("./autonomy.js");
-        const line = announcement(currentMode());
+        const line = announcement(await currentMode());
         if (line !== null)
             process.stderr.write(`${line}\n`);
     }
@@ -76,10 +77,8 @@ export async function run(argv) {
                 env: args.env,
             });
         }
-        case "logout": {
-            const { logout } = await import("./commands/logout.js");
-            return logout();
-        }
+        case "logout":
+            return (await import("./commands/logout.js")).logout();
         case "whoami": {
             const { whoami } = await import("./commands/whoami.js");
             return await whoami({
@@ -352,6 +351,8 @@ export async function run(argv) {
             const { mcp } = await import("./commands/mcp.js");
             return await mcp({ server: args.server, network: args.network, out: args.out });
         }
+        case "platform":
+            return (await import("./commands/platform.js")).platform(args.operands[0], { out: args.out });
         case "s3": {
             const { s3 } = await import("./commands/s3.js");
             return await s3({ server: args.server, network: args.network, port: args.port, json: args.json });
@@ -385,7 +386,7 @@ async function main() {
     const { noteFailure, recordRun } = await import("./run-log.js");
     if (failed !== null)
         noteFailure(failed);
-    recordRun(argv, typeof process.exitCode === "number" ? process.exitCode : 0, Date.now() - started);
+    await recordRun(argv, typeof process.exitCode === "number" ? process.exitCode : 0, Date.now() - started);
     await noteUpdateAfter(argv, VERSION);
 }
 if (invokedDirectly(import.meta.filename)) {

package/dist/manifest-chunk-cache.d.ts

@@ -1,7 +1,7 @@
 /** The sealed bytes this machine holds under that name, or null when it holds none. */
-export declare function readCachedChunk(accountId: string, hash: string): string | null;
+export declare function readCachedChunk(accountId: string, hash: string): Promise<string | null>;
 /** Keep these sealed bytes under that name. Silent when the machine will not take them. */
-export declare function writeCachedChunk(accountId: string, hash: string, ct: string): void;
+export declare function writeCachedChunk(accountId: string, hash: string, ct: string): Promise<void>;
 /**
  * Drop every copy this account holds that the given list does not name.
  *
@@ -11,4 +11,4 @@ export declare function writeCachedChunk(accountId: string, hash: string, ct: st
  *    abandoned. Called after every complete read and every successful write, which is exactly when
  *    "what the list names" is known.
  */
-export declare function pruneChunkCache(accountId: string, keep: ReadonlySet<string>): void;
+export declare function pruneChunkCache(accountId: string, keep: ReadonlySet<string>): Promise<void>;