@needmoretruth/nmts-cli 0.35.0 → 0.36.1

package/dist/platform-sign.js

@@ -0,0 +1,220 @@
+// The two Platform credentials, made here: a business's signature over one request, and the
+// delegation token it mints for one of its users.
+//
+// ⛔ THE SERVER HOLDS ONLY THE VERIFICATION HALF. A business makes this key pair, keeps the secret
+//    half, and registers the public half once. Nothing here is ever sent: what travels is a
+//    signature, and a signature cannot be turned back into the key that made it.
+//
+// ⛔ NO CURVE IS WRITTEN HERE. `@noble/curves` signs and verifies; this module decides only WHAT
+//    is signed. Every byte layout below is the one the server verifies, and each is a fixed
+//    sentence with its own context string — a signature made for one purpose must not verify as
+//    another, which is the whole reason the contexts exist.
+//
+// ⛔ THE BODY IS INSIDE A BUSINESS SIGNATURE, as a SHA-256 digest in lower-case hex. So a proxy
+//    that rewrote one byte of the request invalidates it, and a signature captured off one request
+//    cannot be replayed onto a different body, method or path.
+//
+// ⚠ THE FIELDS ARE NEWLINE-SEPARATED and none of them can contain a newline — the timestamp is
+//   digits, the method is letters, a request path carries none, and the digest is hex. Joining
+//   them without a separator would let two different requests produce the same bytes.
+//
+// ⚠ A TOKEN'S PAYLOAD IS SIGNED AS THE BYTES THAT TRAVEL, never as a value re-encoded on the far
+//   side: two JSON writers disagree about spacing and key order, and a receiver that re-serialised
+//   would verify some correct tokens and refuse others.
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, randomBytes } from "@noble/hashes/utils.js";
+import { concat, fromBase64Url, toBase64Url, utf8 } from "./bytes.js";
+import { NmtsError } from "./errors.js";
+/** The fixed prefix of a business signature. `1` is the format version, so a later shape is `bs2_`. */
+export const BUSINESS_PREFIX = "nmts_bs1_";
+/** …and of a delegation token. */
+export const DELEGATION_PREFIX = "nmts_dt1_";
+/** What a business signature covers, before the moment, the nonce, the method, the path and the digest. */
+export const BUSINESS_CONTEXT = "nmts/p1/business/v1";
+/** What a business signs over a delegation payload. */
+export const DELEGATION_CONTEXT = "nmts/p1/delegation/v1";
+/** What the NEW key signs over the old one when a business replaces its key. */
+export const ROTATE_CONTEXT = "nmts/p1/rotate/v1";
+/** Ed25519 key and signature lengths, named because a parser and a refusal both state them. */
+export const PUBKEY_LEN = 32;
+export const PRIVATE_KEY_LEN = 32;
+export const SIGNATURE_LEN = 64;
+/**
+ * The random half of a delegation payload, and of a business signature: 16 bytes each, so two
+ * credentials made in the same second for the same thing are still different strings.
+ */
+export const NONCE_LEN = 16;
+/** The longest life a delegation token may be minted with — thirty days. */
+export const DELEGATION_MAX_TTL_SECS = 2_592_000;
+/**
+ * What a delegation token may open, by name.
+ *
+ * ⛔ THE FIRST THREE ARE AN API KEY'S OWN SCOPES, value for value. One vocabulary, so that a
+ *    business asking for "read and write" asks for the number a person's key already means by it.
+ *    `register` is the fourth and opens exactly one door: making the account the token names.
+ */
+export const SCOPE_BITS = {
+    files_read: 1,
+    files_write: 2,
+    storage_spend: 4,
+    register: 8,
+};
+/** Every bit a token may carry. */
+export const SCOPE_ALL = SCOPE_BITS.files_read | SCOPE_BITS.files_write | SCOPE_BITS.storage_spend | SCOPE_BITS.register;
+/**
+ * A new key pair, from the runtime's own random source.
+ *
+ * ⚠ The randomness is the curve library's, which is the platform's `crypto.getRandomValues`. There
+ *   is no second source here: a key drawn from anything weaker is a business somebody else can
+ *   speak for.
+ */
+export function generateBusinessKeys() {
+    const pair = ed25519.keygen();
+    return { publicKey: toBase64Url(pair.publicKey), privateKey: toBase64Url(pair.secretKey) };
+}
+/** The public half of a private key, so a caller never has to keep the two in step by hand. */
+export function businessPublicKey(privateKey) {
+    return toBase64Url(ed25519.getPublicKey(secretBytes(privateKey)));
+}
+/**
+ * The bytes a business signature covers.
+ *
+ * `path` is the request path as it is sent, with no query string: no Platform door takes one, and
+ * a signature that did not cover a parameter the server then read would be a signature over half
+ * the request.
+ *
+ * ⚠ THE NONCE IS SIGNED AS THE TEXT THAT TRAVELS, base64url, on its own line after the moment —
+ *   so the sender and the receiver agree about the field without either re-encoding it.
+ */
+export function businessSigningInput(ts, nonce, method, path, body) {
+    return utf8(`${BUSINESS_CONTEXT}\n${ts}\n${nonce}\n${method.toUpperCase()}\n${path}\n${bytesToHex(sha256(body))}`);
+}
+/** The bytes a delegation signature covers: the context, then the payload exactly as it travels. */
+export function delegationSigningInput(payload) {
+    return concat([utf8(`${DELEGATION_CONTEXT}\n`), payload]);
+}
+/** The bytes the new key signs during a rotation: the context, then the key being replaced. */
+export function rotationSigningInput(oldPublicKey) {
+    return concat([utf8(`${ROTATE_CONTEXT}\n`), exactly(oldPublicKey, PUBKEY_LEN, "public key")]);
+}
+/**
+ * The whole `Authorization: Bearer` value for one request to a Platform door.
+ *
+ * ⛔ ONE SIGNATURE, ONE REQUEST. The server remembers each accepted signature for the length of its
+ *    clock window and refuses a second presentation of the same one, so a value from here is not a
+ *    credential to keep — it is made for the request it is about and spent on it.
+ *
+ * ⛔ AND THAT IS WHY THE NONCE IS HERE. Ed25519 is deterministic and the moment is whole seconds,
+ *    so two identical requests inside one second would otherwise be the same bytes — and the
+ *    second of them would be refused as a replay of the first.
+ */
+export function signBusinessRequest(request) {
+    const ts = request.at ?? nowSeconds();
+    const nonce = request.nonce ?? toBase64Url(randomBytes(NONCE_LEN));
+    // ⚠ Checked here because the server checks it: a credential it cannot describe is one it
+    //   refuses, and the refusal would arrive as an authentication failure on a correct request.
+    exactly(nonce, NONCE_LEN, "nonce");
+    const message = businessSigningInput(ts, nonce, request.method, request.path, request.body ?? new Uint8Array(0));
+    const signature = ed25519.sign(message, secretBytes(request.privateKey));
+    return `${BUSINESS_PREFIX}${request.accountId}.${ts}.${nonce}.${toBase64Url(signature)}`;
+}
+/**
+ * Mint one delegation token.
+ *
+ * ⛔ THE LIFE IS REFUSED HERE AS WELL AS THERE. A token longer than the ceiling is refused by the
+ *    server as malformed, which reaches the business as an authentication failure on somebody
+ *    else's request; refusing it where it is made names the mistake to the program that made it.
+ */
+export function mintDelegation(request) {
+    const scope = scopeMask(request.scope);
+    if (request.ttlSecs <= 0 || !Number.isFinite(request.ttlSecs)) {
+        throw new NmtsError("A delegation token's life must be a positive number of seconds.", {
+            exitCode: 2,
+            nextStep: "Nothing was minted. Ask for the number of seconds the token should last.",
+        });
+    }
+    if (request.ttlSecs > DELEGATION_MAX_TTL_SECS) {
+        throw new NmtsError(`A delegation token may last at most ${DELEGATION_MAX_TTL_SECS} seconds (30 days); ${request.ttlSecs} was asked for.`, {
+            exitCode: 2,
+            nextStep: "Nothing was minted. Mint a shorter one and mint it again when it runs out — a token " +
+                "cannot be withdrawn, so its life is the only bound on it.",
+        });
+    }
+    const exp = (request.at ?? nowSeconds()) + Math.floor(request.ttlSecs);
+    const nonce = request.nonce ?? toBase64Url(randomBytes(NONCE_LEN));
+    // ⚠ The nonce's shape is checked here because the server checks it: a payload it cannot describe
+    //   is one it refuses, and the refusal would arrive on a user's request rather than on this call.
+    exactly(nonce, NONCE_LEN, "nonce");
+    const payload = utf8(JSON.stringify({ v: 1, b: request.business, u: request.user, exp, s: scope, n: nonce }));
+    const signature = ed25519.sign(delegationSigningInput(payload), secretBytes(request.privateKey));
+    return `${DELEGATION_PREFIX}${toBase64Url(payload)}.${toBase64Url(signature)}`;
+}
+/**
+ * The proof the new key makes of itself when a business replaces its key.
+ *
+ * ⛔ THE OLD KEY IS IN THE MESSAGE, so this proof is about THIS replacement and cannot be lifted
+ *    onto another. The request carrying it is signed by the old key, so a rotation needs both
+ *    halves in one hand.
+ */
+export function rotationProof(oldPublicKey, newPrivateKey) {
+    return toBase64Url(ed25519.sign(rotationSigningInput(oldPublicKey), secretBytes(newPrivateKey)));
+}
+/** The bitmask these scope names make. */
+export function scopeMask(scopes) {
+    let mask = 0;
+    for (const name of scopes)
+        mask |= SCOPE_BITS[name];
+    if (mask === 0) {
+        throw new NmtsError("A delegation token with no scope can open nothing.", {
+            exitCode: 2,
+            nextStep: `Nothing was minted. Name at least one of: ${Object.keys(SCOPE_BITS).join(", ")}.`,
+        });
+    }
+    return mask;
+}
+/** Does this signature hold over these bytes? Here so a caller can check its own work offline. */
+export function signatureHolds(publicKey, message, signature) {
+    try {
+        return ed25519.verify(exactly(signature, SIGNATURE_LEN, "signature"), message, exactly(publicKey, PUBKEY_LEN, "public key"), {
+            zip215: false,
+        });
+    }
+    catch {
+        // A key or a signature that is not well formed did not verify, which is the answer asked for.
+        return false;
+    }
+}
+/** Unix seconds. One reading, so a signature and the value inside it cannot come from two clocks. */
+function nowSeconds() {
+    return Math.floor(Date.now() / 1000);
+}
+/** The private key as bytes, refusing anything that is not one — before it is handed to the curve. */
+function secretBytes(privateKey) {
+    return exactly(privateKey, PRIVATE_KEY_LEN, "private key");
+}
+/**
+ * Base64url of exactly this many bytes, or a refusal that names the field and never the value.
+ *
+ * ⛔ THE VALUE IS NOT IN THE MESSAGE. One of the things that comes through here is a private key,
+ *    and a refusal a caller logs is not a place for it.
+ */
+function exactly(text, length, what) {
+    let bytes;
+    try {
+        bytes = fromBase64Url(text);
+    }
+    catch {
+        throw new NmtsError(`That ${what} is not base64url.`, {
+            exitCode: 2,
+            nextStep: `Nothing was signed. A ${what} is ${length} bytes written as base64url.`,
+        });
+    }
+    if (bytes.length !== length) {
+        throw new NmtsError(`That ${what} is ${bytes.length} bytes; it must be ${length}.`, {
+            exitCode: 2,
+            nextStep: `Nothing was signed. Check that the right value was passed as the ${what}.`,
+        });
+    }
+    return bytes;
+}

package/dist/portable.d.ts

@@ -0,0 +1,59 @@
+export { forgetHost, host, hostIsRegistered, registerHost } from "./host.ts";
+export type { EngineHost, Host, HostName, StateHost, ZstdHost } from "./host.ts";
+export { hostContract } from "./host-contract.ts";
+export { concat, fromBase64Url, fromUtf8, toBase64Url, utf8 } from "./bytes.ts";
+export { setZstdCodec, zstdCodec, zstdContentSize } from "./shared/lib/drive/zstd.ts";
+export type { ZstdCodec } from "./shared/lib/drive/zstd.ts";
+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 { 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 { isCryptoGlue, missingExports } from "./crypto-surface.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 { businessPublicKey, businessSigningInput, BUSINESS_CONTEXT, BUSINESS_PREFIX, delegationSigningInput, DELEGATION_CONTEXT, DELEGATION_MAX_TTL_SECS, DELEGATION_PREFIX, generateBusinessKeys, mintDelegation, NONCE_LEN, PUBKEY_LEN, rotationProof, rotationSigningInput, ROTATE_CONTEXT, SCOPE_ALL, SCOPE_BITS, scopeMask, signatureHolds, signBusinessRequest, SIGNATURE_LEN, } from "./platform-sign.ts";
+export type { BusinessKeyPair, BusinessRequest, DelegationRequest, ScopeName } from "./platform-sign.ts";
+export { newAccountCode, registrationProofOf } from "./registration.ts";
+export type { RegistrationProof } from "./registration.ts";
+export { 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, 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 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";

package/dist/portable.js

@@ -0,0 +1,82 @@
+// The library surface that runs ANYWHERE — what `import "@needmoretruth/nmts-cli/portable"` hands
+// a program that brought its own host.
+//
+// ⛔ THIS IS `index.ts` MINUS THE THINGS THAT NEED NODE, and it is the file the machine check
+//    judges. `test/portable-closure.test.ts` walks everything reachable from the built version of
+//    this file and fails on a `node:` import, a `process.`, a `Buffer.` or an `import.meta.url` —
+//    by file and by line. So this is not a promise anybody has to remember: a module that grows a
+//    dependency on Node turns this red on the day it is written.
+//
+// ⛔ IT REGISTERS NO HOST. Loading the engine, keeping state, reading the environment, reporting
+//    progress and expanding zstd all come from `host.ts`, and whoever imports this entry point
+//    puts one there first. `index.ts` registers the Node host on the way in, so every existing
+//    program is unaffected; the SDK's `/browser` entry registers a browser one.
+//
+// ⛔ WHAT IS NOT HERE, AND WHY. `credentials.ts` reads a home directory, `code-vault.ts` opens a
+//    passphrase-locked file, `fileSink`, `stdoutSink`, `fileSource` and `measureLocal` each take or
+//    give a path, and `Nmts.fromEnv` reads an environment. All of them are in `index.ts` and none
+//    of them has a meaning in a page.
+// The host every module below reaches for. A program that imported this entry point registers one.
+export { forgetHost, host, hostIsRegistered, registerHost } from "./host.js";
+export { hostContract } from "./host-contract.js";
+// Bytes to text and back, in the two spellings the format uses.
+export { concat, fromBase64Url, fromUtf8, toBase64Url, utf8 } from "./bytes.js";
+// The file-list codec's zstd register (NCF-3 §6.3.4). A host fills it with the encoder its runtime
+// has; the bound a frame declares is read with `zstdContentSize` before anything is allocated.
+export { setZstdCodec, zstdCodec, zstdContentSize } from "./shared/lib/drive/zstd.js";
+// 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";
+// 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 gate every engine load passes, whichever runtime found the build. A host that fetched one
+// runs its answer through this rather than trusting it.
+export { isCryptoGlue, missingExports } from "./crypto-surface.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";
+// The Platform's two credentials: a business's signature over one request, and the delegation
+// token it mints for one of its users. Making either needs no host and no server — a business
+// signs on its own machine, and a device that was handed a token presents it from a page — so
+// they belong on this side of the line rather than behind the Node entry.
+export { businessPublicKey, businessSigningInput, BUSINESS_CONTEXT, BUSINESS_PREFIX, delegationSigningInput, DELEGATION_CONTEXT, DELEGATION_MAX_TTL_SECS, DELEGATION_PREFIX, generateBusinessKeys, mintDelegation, NONCE_LEN, PUBKEY_LEN, rotationProof, rotationSigningInput, ROTATE_CONTEXT, SCOPE_ALL, SCOPE_BITS, scopeMask, signatureHolds, signBusinessRequest, SIGNATURE_LEN, } from "./platform-sign.js";
+// What a brand-new account is registered with, derived from its NMTS key and from nothing else.
+// ⚠ Here because a business registering a user makes the same pair the account door has always
+//   taken — a second derivation for the Platform would be a second answer to one question.
+export { newAccountCode, registrationProofOf } from "./registration.js";
+// Uploading: sealing here, buying storage with credits, pushing the sealed bytes.
+export { partKeysOf, uploadFile } from "./upload-file.js";
+export { createUploadApi } from "./upload-api.js";
+export { CREDIT_BYTES, creditsFor, 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 { 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";

package/dist/product.d.ts

@@ -9,7 +9,7 @@ export declare const BINARY_NAME = "nmts";
  *    beside it. Here rather than in `main.ts` because the MCP server has to say it too, and a
  *    command importing the entry point is a cycle waiting to bite.
  */
-export declare const VERSION = "0.35.0";
+export declare const VERSION = "0.36.1";
 /** Where the product lives, for messages that need to send somebody somewhere real. */
 export declare const HOME_URL = "https://nmts.me";
 /** The source, so a person holding only the built program can find what it was built from. */

package/dist/product.js

@@ -18,7 +18,7 @@ export const BINARY_NAME = "nmts";
  *    beside it. Here rather than in `main.ts` because the MCP server has to say it too, and a
  *    command importing the entry point is a cycle waiting to bite.
  */
-export const VERSION = "0.35.0";
+export const VERSION = "0.36.1";
 /** Where the product lives, for messages that need to send somebody somewhere real. */
 export const HOME_URL = "https://nmts.me";
 /** The source, so a person holding only the built program can find what it was built from. */

package/dist/progress-node.d.ts

@@ -0,0 +1,2 @@
+import type { ProgressSink } from "./progress.ts";
+export declare function stderrSink(): ProgressSink;

package/dist/progress-node.js

@@ -0,0 +1,14 @@
+// This process's own stderr, as a progress reporter.
+//
+// ⛔ STDERR, NOT STDOUT. Progress is not the answer, and a caller redirecting the answer to a file
+//    must not find it interleaved with percentages.
+//
+// ⛔ SEPARATE FROM `progress.ts` SO THE REPORTER RUNS IN A BROWSER. Everything about how often to
+//    print and what a pipe gets instead of a rewriting line is the same wherever the text goes;
+//    only this one destination is Node's.
+export function stderrSink() {
+    return {
+        write: (text) => void process.stderr.write(text),
+        interactive: process.stderr.isTTY === true,
+    };
+}

package/dist/progress.d.ts

@@ -4,7 +4,6 @@ export interface ProgressSink {
     /** True for a terminal that can rewrite its last line. */
     interactive: boolean;
 }
-export declare function stderrSink(): ProgressSink;
 /** A reporter that says nothing. What `--json` gets, and what a test gets by default. */
 export declare function silentSink(): ProgressSink;
 /**

package/dist/progress.js

@@ -7,14 +7,10 @@
 //
 // ⛔ IT NEVER WRITES TO STDOUT WHEN THE OUTPUT IS MACHINE-READABLE. `--json` promises one JSON
 //    document and nothing else; a progress line would break every parser that trusted that.
-export function stderrSink() {
-    return {
-        // ⛔ STDERR, NOT STDOUT. Progress is not the answer, and a caller redirecting the answer to a
-        //    file must not find it interleaved with percentages.
-        write: (text) => void process.stderr.write(text),
-        interactive: process.stderr.isTTY === true,
-    };
-}
+//
+// ⛔ THE TERMINAL SINK IS NOT HERE. Writing to a real stderr is Node's, so it is in
+//    `progress-node.ts`; what is left runs in a page, where the same reporter drives a caller's
+//    own `onProgress`.
 /** A reporter that says nothing. What `--json` gets, and what a test gets by default. */
 export function silentSink() {
     return { write: () => { }, interactive: false };

package/dist/redact.js

@@ -19,6 +19,7 @@
 //   shape and is not in this process's environment, and nothing here will find it. That is why the
 //   text a person reads before sending asks them to keep personal details out: the machine covers
 //   what a machine can recognise, and the sentence covers the rest.
+import { host } from "./host.js";
 /** An NMTS key is 32 data symbols and one check symbol. `crypto/src/codes.rs` is the origin. */
 const ACCOUNT_CODE_SYMBOLS = 33;
 /** Crockford base32, the data half: `0-9 A-H J-K M-N P-T V-Z`, either case. No `I L O U`. */
@@ -157,10 +158,10 @@ function escapeForRegExp(value) {
  */
 export function environmentRules() {
     const found = [];
-    for (const [name, value] of Object.entries(process.env)) {
+    for (const { name, value } of host().envEntries()) {
         if (!name.startsWith("NMTS_"))
             continue;
-        if (value === undefined || value.length < SHORTEST_ENV_VALUE)
+        if (value.length < SHORTEST_ENV_VALUE)
             continue;
         found.push({ name, value });
     }

package/dist/registration.js

@@ -17,6 +17,7 @@
 //    secret, the key that opens the files, the file-list key, the wallet root. Two public fields
 //    are copied out and the rest is zeroed before this returns, the same discipline `identityOf`
 //    keeps and for the same reason: a live copy of that buffer is a live copy of the account.
+import { toBase64Url } from "./bytes.js";
 import { DERIVED, loadCrypto } from "./crypto.js";
 import { NmtsError } from "./errors.js";
 /**
@@ -72,8 +73,10 @@ export async function registrationProofOf(code) {
         const [idFrom, idTo] = DERIVED.accountId;
         const [secretFrom, secretTo] = DERIVED.authSecret;
         return {
-            accountId: Buffer.from(derived.slice(idFrom, idTo)).toString("base64url"),
-            authSecret: Buffer.from(derived.slice(secretFrom, secretTo)).toString("base64url"),
+            // ⚠ `bytes.ts` rather than `Buffer`, which is Node's alone: this module is reachable from
+            //   the portable entry, where a business registers a user from wherever it runs.
+            accountId: toBase64Url(derived.slice(idFrom, idTo)),
+            authSecret: toBase64Url(derived.slice(secretFrom, secretTo)),
         };
     }
     finally {

package/dist/risk.d.ts

@@ -152,6 +152,9 @@ export declare const ACTS: {
     readonly mcp: {
         readonly tier: "none";
     };
+    readonly platform: {
+        readonly tier: "none";
+    };
     readonly "accept-terms": {
         readonly tier: "none";
     };
@@ -226,6 +229,10 @@ export declare const ACTS: {
         readonly tier: "medium";
         readonly what: "Revoke an API key. Whatever used it stops working.";
     };
+    readonly "platform.keygen": {
+        readonly tier: "medium";
+        readonly what: "Make a business key pair and write its private half to a file on this disk.";
+    };
     readonly "public-code.publish": {
         readonly tier: "medium";
         readonly what: "Publish this account's public code. Publishing cannot be undone.";

package/dist/risk.js

@@ -69,6 +69,9 @@ export const ACTS = {
     verify: { tier: "none" },
     support: { tier: "none" },
     mcp: { tier: "none" },
+    // The bare word and `platform register` only say where a business registers; what MAKES
+    // something is `platform.keygen` below.
+    platform: { tier: "none" },
     "accept-terms": { tier: "none" },
     // ── low ──
     rm: { tier: "low", what: "Move these to the trash, restorable for 30 days." },
@@ -90,6 +93,11 @@ export const ACTS = {
     "key.list": { tier: "none" },
     "key.new": { tier: "medium", what: "Make a new API key for this machine." },
     "key.revoke": { tier: "medium", what: "Revoke an API key. Whatever used it stops working." },
+    // ⛔ MEDIUM, BESIDE `key.new`, AND NOT `high`. It writes a long-lived secret to this disk, which
+    //    is more than a read; but the pair opens nothing until a person registers the public half in
+    //    a browser, nothing is spent, and the file is never replaced — so it is not the tier that
+    //    waits for an unlock.
+    "platform.keygen": { tier: "medium", what: "Make a business key pair and write its private half to a file on this disk." },
     "public-code.publish": { tier: "medium", what: "Publish this account's public code. Publishing cannot be undone." },
     "losses.dismiss": { tier: "medium", what: "Put this loss notice down. It will not be shown again." },
     // ⛔ MEDIUM AND NOT HIGH. It moves value, so it is not `low`; but it moves it INSIDE one person's
@@ -179,6 +187,8 @@ export function actOf(args) {
             return args.publish ? "public-code.publish" : "public-code";
         case "support":
             return sub === "send" || sub === "reply" ? "support.send" : "support";
+        case "platform":
+            return sub === "keygen" ? "platform.keygen" : "platform";
         case "on-collision":
             return sub === "" ? "on-collision" : "on-collision.set";
         case "padding":

package/dist/run-log.d.ts

@@ -1,3 +1,5 @@
+/** The one key the record lives under. On this machine that is `runs.jsonl` in the config directory. */
+export declare const RUN_LOG_KEY = "runlog";
 /** One request this run made, and what came back. */
 export interface HttpEvent {
     readonly kind: "http";
@@ -37,8 +39,6 @@ export declare const NO_RUN_LOG_ENV_VAR = "NMTS_NO_RUN_LOG";
 export declare const MAX_LOG_BYTES: number;
 /** The most runs `--attach-log` will take. */
 export declare const MAX_ATTACHED_RUNS = 20;
-/** Where the log lives. Inside the tool's own directory, which is already 0700. */
-export declare function runLogPath(): string;
 /** Has the person turned it off? */
 export declare function runLogIsOff(): boolean;
 /**
@@ -73,6 +73,6 @@ export declare function safeArgs(argv: readonly string[]): string[];
  * Returns nothing and throws nothing: see the header. A run that could not be written is a run
  * that is missing from a report, which is a smaller problem than a command that failed for it.
  */
-export declare function recordRun(argv: readonly string[], exit: number, ms: number, now?: Date): void;
+export declare function recordRun(argv: readonly string[], exit: number, ms: number, now?: Date): Promise<void>;
 /** The newest `count` runs, oldest first. An unreadable or missing file is no runs. */
-export declare function readRuns(count: number): RunRecord[];
+export declare function readRuns(count: number): Promise<RunRecord[]>;