@needmoretruth/nmts-cli 0.17.2

package/dist/crypto-surface.js

@@ -0,0 +1,54 @@
+// What the NMTS crypto engine must provide, declared once so a missing piece is named at load
+// time rather than deep inside a derivation.
+//
+// ⛔ SPLIT OUT OF `crypto.ts` RATHER THAN REWRITTEN. Every line below was in that file and is
+//    unchanged; it moved because that file crossed the length gate, and this is where the seam
+//    already was: this half is the ENGINE'S SURFACE — the shape the WebAssembly must have — and
+//    what is left there is finding it on disk and loading it. Nothing here reaches the filesystem
+//    and nothing here derives anything.
+//
+// ⛔ NO TYPE ASSERTION, and that is the reason this is a runtime check and not only a type. A
+//    dynamically imported module is `unknown`; an `as` would turn a renamed export into
+//    "undefined is not a function" halfway through deriving somebody's keys.
+const REQUIRED = [
+    "account_code_generate",
+    "account_code_parse",
+    "account_code_display",
+    "kdf_derive",
+    "share_address_display",
+    "share_address_parse",
+    "share_public_key",
+    "share_address_of",
+    "share_claimed_sender",
+    "share_wrap_dek",
+    "share_unwrap_dek",
+    "envelope_open",
+    "stream_decrypt_all",
+    "generate_dek",
+    "envelope_seal",
+    "stream_encrypt_all",
+    "StreamEncryptor",
+    "StreamDecryptor",
+    "wallet_seed_for",
+];
+export function isCryptoGlue(value) {
+    return missingExports(value).length === 0;
+}
+/** Which of the required functions this object does not have. Empty means it is the engine. */
+export function missingExports(value) {
+    if (typeof value !== "object" || value === null)
+        return [...REQUIRED];
+    return REQUIRED.filter((name) => {
+        if (!(name in value))
+            return true;
+        const member = Reflect.get(value, name);
+        return typeof member !== "function";
+    });
+}
+/**
+ * Where the engine is.
+ *
+ * Two layouts are real: inside the published package the vendored engine sits beside the code, and
+ * inside this repository it lives in web/vendor where the browser build also reads it. Looking in
+ * both is what lets the same source run from a checkout and from an install.
+ */

package/dist/crypto.js

@@ -0,0 +1,137 @@
+// Loading the real NMTS crypto engine in Node.
+//
+// ⛔ NOTHING IS RE-IMPLEMENTED HERE. The bytes that derive an account's keys are the same
+//    WebAssembly the browser runs, built from the same Rust crate. Two harnesses in this repo
+//    already load it exactly this way and a gate refuses green if their assertion count drops, so
+//    this path is held by a machine and not by memory. A TypeScript re-derivation of NCF-3 would
+//    be a second implementation that can drift from the first, silently and in the direction that
+//    loses files.
+//
+// ⛔ NO TYPE ASSERTION. A dynamically imported module is `unknown` and staying honest about that
+//    matters here more than anywhere: if a rebuild renamed an export, an `as` would turn that into
+//    "undefined is not a function" deep inside a derivation. The guard below checks each function
+//    exists before anything is derived, so a missing export is named at load time.
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { NmtsError } from "./errors.js";
+import { isCryptoGlue, missingExports } from "./crypto-surface.js";
+/**
+ * The associated-data strings of NCF-3, for the envelopes this tool opens.
+ *
+ * ⛔ FROZEN (NCF-3 §2.2). They are the separator between one purpose and another: the file list
+ *    cannot be opened as a delegation, and neither can be opened as a file. Copied here rather
+ *    than imported because this package does not import the browser tree — the conformance
+ *    vectors are what arbitrate, and they are in the crypto repository.
+ */
+export const AAD = {
+    fileList: "nmts/v3/file-list",
+    /** Wraps a file's own key under the account's data key (NCF-3 §3). */
+    dekWrap: "nmts/v3/dek-wrap",
+    /**
+     * Wraps the SHA-256 of a file's whole plaintext (NCF-3 §2.2).
+     *
+     * Sealed rather than stored bare because a plaintext content hash identifies the FILE: it is
+     * matchable against public hash sets, and it is equal across two accounts holding the same file.
+     */
+    contentHash: "nmts/v3/content-hash",
+    /**
+     * Seals a shared file's name and size FOR THE RECIPIENT, under the file's own key (NCF-3 §5.4).
+     *
+     * ⚠ A different separator from the account's own file list on purpose: the recipient holds the
+     *   file key and nothing else, so the name has to travel under that key rather than under an
+     *   account data key they do not have.
+     */
+    shareName: "nmts/v3/share-name",
+    /** Seals the shared file's plaintext digest for the recipient, under the same file key. */
+    shareContentHash: "nmts/v3/share-content-hash",
+    /** Seals the RECOVERY LIST — where every file's bytes are (NRM §1). ⛔ The old spelling of the
+     *  artefact's name is frozen INTO the separator: every list ever sealed is bound to these bytes. */
+    recoveryMap: "nmts/v3/recovery-map",
+};
+/**
+ * Byte ranges inside `kdf_derive`'s output.
+ *
+ * ⛔ These are a CONTRACT WITH A FROZEN FORMAT (NCF-3 §1), not a convenience. They are written
+ *    here as ranges rather than magic numbers at call sites so a reader can check them against the
+ *    format document in one place — and so a future version bump changes one table.
+ */
+export const DERIVED = {
+    accountId: [0, 16],
+    authSecret: [16, 48],
+    dataKey: [48, 80],
+    fileListKey: [80, 112],
+    /**
+     * The three secrets behind this account's sharing identity (NCF-3 §5.1).
+     *
+     * ⚠ `shareSigSeed` SITS AT THE TAIL, not beside the other two, and that is not tidiness lost —
+     *   it was appended on 2026-08-02 because filing it in the obvious place would have shifted
+     *   `walletRoot` and `shareAddress`, which are frozen. `web/src/lib/crypto/kdf-offsets.ts`
+     *   carries the same table for the browser.
+     */
+    shareKemSeed: [112, 144],
+    shareAuthSecret: [144, 176],
+    /**
+     * The root every one of this account's wallets is derived from.
+     *
+     * ⚠ IT IS AN HKDF PRK, NOT KEY MATERIAL TO EXTRACT AGAIN. `wallet_seed_for` expands from it
+     *   directly; a re-implementation that ran a second Extract over these bytes would produce
+     *   plausible-looking seeds for a different set of addresses.
+     */
+    walletRoot: [176, 208],
+    shareAddress: [208, 224],
+    shareSigSeed: [224, 256],
+};
+export function engineDir() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(here, "..", "vendor", "nmts-crypto"),
+        join(here, "..", "..", "vendor", "nmts-crypto"),
+        join(here, "..", "..", "web", "vendor", "nmts-crypto"),
+    ];
+    for (const dir of candidates) {
+        if (existsSync(join(dir, "nmts_crypto_wasm_bg.wasm")))
+            return dir;
+    }
+    throw new NmtsError("The NMTS crypto engine is missing from this installation.", {
+        exitCode: 1,
+        nextStep: "Reinstall the package. Nothing can be encrypted or decrypted without it.",
+    });
+}
+let cached = null;
+/** Load the engine once per process. */
+export async function loadCrypto() {
+    if (cached !== null)
+        return cached;
+    const dir = engineDir();
+    const module = await import(__rewriteRelativeImportExtension(pathToFileURL(join(dir, "nmts_crypto_wasm.js")).href));
+    if (typeof module !== "object" || module === null || !("default" in module)) {
+        throw new NmtsError("The NMTS crypto engine did not load (no initialiser).", { exitCode: 1 });
+    }
+    const init = Reflect.get(module, "default");
+    if (typeof init !== "function") {
+        throw new NmtsError("The NMTS crypto engine did not load (initialiser is not callable).", {
+            exitCode: 1,
+        });
+    }
+    await init({ module_or_path: await readFile(join(dir, "nmts_crypto_wasm_bg.wasm")) });
+    if (!isCryptoGlue(module)) {
+        const missing = missingExports(module);
+        throw new NmtsError(`The NMTS crypto engine is missing: ${missing.join(", ")}. This build does not match this tool.`, { exitCode: 1, nextStep: "Reinstall the package." });
+    }
+    cached = module;
+    return module;
+}
+/** For tests that need a fresh load. */
+export function forgetCrypto() {
+    cached = null;
+}

package/dist/download-part.js

@@ -0,0 +1,144 @@
+import { NmtsError } from "./errors.js";
+import { NCF3_SHAPE } from "./seal.js";
+import { isRecord } from "./guards.js";
+import { readBlob, readQuiltPatch } from "./walrus.js";
+import { NETWORK_WHEN_UNRECORDED, networkName } from "./shared/lib/storage-network.js";
+/** `storage_kind` in the server's part rows. */
+const DEDICATED_BLOB = 0;
+const QUILT_PATCH = 1;
+export function asParts(value) {
+    if (!isRecord(value))
+        throw new NmtsError("The server's answer was not an object.");
+    const v = value;
+    const size = v["size"];
+    const parts = v["parts"];
+    if (typeof size !== "number" || !Array.isArray(parts)) {
+        throw new NmtsError("The server described this file in a shape this version cannot read.", {
+            nextStep: "Update this tool, or open the file in a browser.",
+        });
+    }
+    const out = [];
+    for (const raw of parts) {
+        if (!isRecord(raw))
+            throw new NmtsError("A part was not an object.");
+        const p = raw;
+        if (typeof p["part_index"] !== "number" || typeof p["storage_kind"] !== "number" || typeof p["blob_id"] !== "string") {
+            throw new NmtsError("A part is missing the fields needed to read it.");
+        }
+        const view = {
+            part_index: p["part_index"],
+            storage_kind: p["storage_kind"],
+            blob_id: p["blob_id"],
+        };
+        if (typeof p["network"] === "number")
+            view.network = p["network"];
+        if (typeof p["patch_id"] === "string")
+            view.patch_id = p["patch_id"];
+        out.push(view);
+    }
+    return { size, parts: out };
+}
+/**
+ * Fetch one part's sealed bytes.
+ *
+ * ⛔ Refuse before reading, not after. A part on a storage network this build has no reader for
+ *    would otherwise be fetched from a Walrus aggregator, 404, and be reported as missing bytes —
+ *    which is a different thing and sends somebody looking for the wrong one.
+ */
+export async function fetchPart(part, chain, read) {
+    const where = networkName(part.network ?? NETWORK_WHEN_UNRECORDED);
+    if (where !== "walrus") {
+        throw new NmtsError(`Part ${part.part_index} is stored on ${where ?? `an unknown network (${part.network})`}, which this version cannot read.`, { nextStep: "Nothing was written. Open the file in a browser, which may know that network." });
+    }
+    if (part.storage_kind !== QUILT_PATCH && part.storage_kind !== DEDICATED_BLOB) {
+        throw new NmtsError(`Part ${part.part_index} is stored in a way this version does not know (${part.storage_kind}).`);
+    }
+    return part.storage_kind === QUILT_PATCH && part.patch_id !== undefined
+        ? readQuiltPatch(chain, part.patch_id, read ?? {})
+        : readBlob(chain, part.blob_id, read ?? {});
+}
+/**
+ * Open ONE part and pass its contribution on, a chunk at a time. Returns how much of the file it
+ * contributed.
+ *
+ * ⛔ THE SEALED BYTES ARE FED IN ONE CHUNK AT A TIME, not all at once. Handing the engine the whole
+ *    part would make it hand back the whole part's plaintext in one array, which is the ceiling
+ *    this path exists to remove; feeding it a chunk's worth means at most one chunk of plaintext
+ *    exists at a time. The size fed is the format's own chunk plus its tag, so a well-formed
+ *    stream yields exactly one chunk per push — and a stream whose header declares a different
+ *    chunk size still works, because the engine buffers what it has not finished.
+ *
+ * ⛔ `finish()` IS WHAT CATCHES A PART CUT SHORT. Every chunk that arrived authenticates; only the
+ *    end-of-stream check knows the rest is missing. Skipping it would accept a truncated part.
+ *
+ * ⛔ THE ENGINE-SIDE SESSION IS FREED ON EVERY PATH OUT, including a failure: it holds the file
+ *    key until it is, and a download that failed is exactly when nobody comes back to tidy up.
+ */
+export async function openPart(crypt, dek, part, sealed, isLast, remaining, emit) {
+    const refuse = () => new NmtsError(`Part ${part.part_index} did not decrypt.`, {
+        nextStep: "The bytes that arrived are not the bytes this account sealed. Nothing was written. " +
+            "Try again — a different aggregator may hold the right ones.",
+    });
+    if (sealed.length < NCF3_SHAPE.headerLen)
+        throw refuse();
+    // ⚠ Constructed on the header alone, which is parsed and checked inside the engine, so a blob
+    //   that is not an NCF-3 stream at all fails here rather than as a strange length later.
+    let opener;
+    try {
+        opener = new crypt.StreamDecryptor(dek, sealed.subarray(0, NCF3_SHAPE.headerLen));
+    }
+    catch {
+        throw refuse();
+    }
+    let taken = 0;
+    let left = remaining;
+    try {
+        // ⚠ A chunk's worth at a time: the format's chunk plus its tag. A well-formed stream yields
+        //   exactly one chunk per push, and a header declaring some other chunk size still works —
+        //   the engine buffers whatever it has not finished.
+        const feed = NCF3_SHAPE.chunkSize + NCF3_SHAPE.tagLen;
+        for (let at = NCF3_SHAPE.headerLen; at < sealed.length; at += feed) {
+            // ⛔ The push and the emit are in separate try blocks on purpose. Wrapping both would let a
+            //    disk that filled up, or a pipe that refused, be reported as "this part did not
+            //    decrypt" — sending somebody to look at the storage network for a fault on their own
+            //    machine.
+            let run;
+            try {
+                run = opener.push(sealed.subarray(at, Math.min(at + feed, sealed.length)));
+            }
+            catch {
+                throw refuse();
+            }
+            if (run.length === 0)
+                continue;
+            // ⛔ Only the LAST part may hand back more than the file has left; that surplus is the
+            //    padding the write side added to hide the true size. From any other part it means the
+            //    file list and the stored bytes describe different files.
+            const take = isLast ? Math.min(run.length, left) : run.length;
+            if (take > left) {
+                run.fill(0);
+                throw new NmtsError(`Part ${part.part_index} contributes ${run.length} bytes and only ${left} of the file are left.`, { nextStep: "The file list and the stored parts do not agree. Nothing was written." });
+            }
+            try {
+                await emit(run.subarray(0, take));
+            }
+            finally {
+                // ⚠ Zeroed as soon as it has been passed on, failure included. A sink that kept the array
+                //   instead of copying would find zeroes — which is why its contract says not to.
+                run.fill(0);
+            }
+            taken += take;
+            left -= take;
+        }
+        try {
+            opener.finish();
+        }
+        catch {
+            throw refuse();
+        }
+    }
+    finally {
+        opener.free();
+    }
+    return taken;
+}

package/dist/download-sink.js

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