@toon-protocol/rig 2.6.3 → 2.6.4

package/dist/cli/rig.js

@@ -18,7 +18,7 @@ import {
   setHeadSymref,
   updateRef,
   writeGitObjects
-} from "../chunk-NIRC5LFS.js";
+} from "../chunk-PG5PUKDR.js";
 import {
   DEFAULT_KEYSTORE_PASSWORD,
   MissingIdentityError,
@@ -32,8 +32,9 @@ import {
   ChannelMapStore,
   channelStatus,
   defaultDaemonPort,
-  resolveChannelPaths
-} from "../chunk-SW7ZHMGS.js";
+  resolveChannelPaths,
+  resolveConflictingPath
+} from "../chunk-57UY3OGX.js";
 import {
   MAX_OBJECT_SIZE
 } from "../chunk-B5ISARMU.js";
@@ -398,6 +399,13 @@ function describeError(err, command = "push") {
       json: { error: "git_error", detail: err.message }
     };
   }
+  if (err instanceof Error && err.name === "ArnsSdkUnavailableError") {
+    return {
+      code: "arns_sdk_unavailable",
+      lines: err.message.split("\n"),
+      json: { error: "arns_sdk_unavailable", detail: err.message }
+    };
+  }
   if (err instanceof DaemonRouteError) {
     const envelope = err.envelope;
     if (envelope.error === "non_fast_forward" && Array.isArray(envelope["refs"])) {
@@ -966,7 +974,7 @@ function loadPaidSession(deps, relayUrl) {
   });
 }
 var defaultLoadStandalone = async (options) => {
-  const mod = await import("../standalone-mode-WEMJBHME.js");
+  const mod = await import("../standalone-mode-W4DULOEC.js");
   return mod.createStandaloneContext(options);
 };
 function identityReport(ctx) {
@@ -4912,6 +4920,896 @@ async function runMutate(op, args, deps) {
   }
 }
 
+// src/cli/name.ts
+import { parseArgs as parseArgs13 } from "util";
+var ARIO_DECIMALS = 6;
+function renderMario(mario) {
+  return `${mario.toString()} mARIO (~${formatUnits(mario.toString(), ARIO_DECIMALS)} ARIO)`;
+}
+var MARIO_PAYMENT_NOTE = "Payment is mARIO from this identity's Solana wallet, charged on-chain by the ar.io registry program \u2014 NOT through TOON ILP payment channels. Fund this wallet with `rig fund --chain solana` (or send $ARIO to the Solana address above).";
+var ArnsSdkUnavailableError = class extends Error {
+  constructor(cause) {
+    super(
+      "`rig name` needs the optional `@ar.io/sdk` dependency, which is not installed. It is intentionally NOT a base `rig` dependency (keeps the install lean). Add it to use ArNS naming:\n  npm i @ar.io/sdk    # or: pnpm add @ar.io/sdk\nthen re-run your `rig name` command." + (cause instanceof Error ? `
+(underlying error: ${cause.message})` : "")
+    );
+    this.name = "ArnsSdkUnavailableError";
+  }
+};
+var ARIO_MAINNET_PROCESS_ID = "qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE";
+var defaultLoadArns = async (options) => {
+  const specifier = "@ar.io/sdk";
+  let mod;
+  try {
+    mod = await import(specifier);
+  } catch (err) {
+    throw new ArnsSdkUnavailableError(err);
+  }
+  if (!mod.ARIO?.init || !mod.ANT?.init) {
+    throw new ArnsSdkUnavailableError(
+      new Error("the installed @ar.io/sdk does not expose ARIO.init / ANT.init")
+    );
+  }
+  const processId = options.processId ?? (options.network === "devnet" ? mod.ARIO_DEVNET_PROCESS_ID ?? "" : options.network === "testnet" ? mod.ARIO_TESTNET_PROCESS_ID ?? "" : mod.ARIO_MAINNET_PROCESS_ID ?? ARIO_MAINNET_PROCESS_ID);
+  if (!processId) {
+    throw new ArnsSdkUnavailableError(
+      new Error(
+        `the installed @ar.io/sdk exposes no ${options.network} registry process id \u2014 pass --process-id explicitly`
+      )
+    );
+  }
+  if (!mod.SolanaSigner) {
+    throw new ArnsSdkUnavailableError(
+      new Error(
+        "the installed @ar.io/sdk exposes no SolanaSigner \u2014 this build predates ar.io's Solana migration; upgrade @ar.io/sdk"
+      )
+    );
+  }
+  const signer = new mod.SolanaSigner(options.solanaSecretKey);
+  const ario = mod.ARIO.init({ process: processId, signer });
+  const antInit = mod.ANT.init;
+  return {
+    getTokenCost: async (args) => BigInt(String(await ario.getTokenCost(args))),
+    buyRecord: async (args) => await ario.buyRecord(args),
+    getArNSRecord: async (args) => await ario.getArNSRecord(args),
+    ant: async (pid) => {
+      const ant = antInit({ processId: pid, signer });
+      return {
+        getRecords: () => ant.getRecords(),
+        setBaseNameRecord: (a) => ant.setBaseNameRecord(a),
+        setUndernameRecord: (a) => ant.setUndernameRecord(a)
+      };
+    }
+  };
+};
+var NAME_USAGE = `Usage: rig name <buy|set|status> <name> [options]
+
+ArNS naming for Arweave-served artifacts. A name registered on the ar.io
+registry resolves at every ar.io gateway (https://<name>.<gateway>/), pointing
+at whatever Arweave txId its ANT record targets (10 undernames included).
+
+Names are OWNED and PAID FOR by this rig identity's Solana key \u2014 the same
+mnemonic that pays for pushes (derived at m/44'/501'/0'/0'). Fund it with
+\`rig fund --chain solana\`. Purchases spend mARIO on Solana via the ar.io
+registry program \u2014 NOT through TOON ILP payment channels.
+
+Commands:
+  name buy <name> [--years n | --permabuy]
+                       quote (mARIO) \u2192 confirm \u2192 register. The spawned ANT is
+                       owned by this identity's Solana key. Default: 1-year
+                       lease. PAID \u2014 spends mARIO from the Solana wallet.
+  name set <name> <txId> [--undername <sub>] [--ttl <seconds>]
+                       point the name (or an undername) at an Arweave txId
+                       (typically a deployed path manifest). Signs an ANT
+                       record update with the Solana key.
+  name status <name>   FREE: registry record (lease/permabuy, expiry), ANT
+                       process id, current target txId(s), TTL, undernames.
+
+Options:
+  --years <n>          lease length in years (buy; default 1; mutually
+                       exclusive with --permabuy)
+  --permabuy           permanent registration instead of a lease (buy)
+  --undername <sub>    target the undername <sub>_<name> instead of the base
+                       name (set)
+  --ttl <seconds>      record TTL in seconds (set; default 3600)
+  --network <net>      registry: mainnet | devnet | testnet (default mainnet;
+                       or RIG_ARIO_NETWORK). Non-mainnet gateway resolution is
+                       unverified.
+  --process-id <id>    explicit registry process id (overrides --network; or
+                       RIG_ARIO_PROCESS_ID)
+  --yes                skip the confirmation (required when not a TTY) for
+                       buy/set
+  --json               machine-readable envelope; for buy/set without --yes it
+                       is a pure estimate (nothing is bought or written)
+  -h, --help           show this help`;
+var DEFAULT_TTL_SECONDS = 3600;
+var DEFAULT_LEASE_YEARS = 1;
+var NETWORKS = ["mainnet", "devnet", "testnet"];
+async function resolveNameContext(deps, network, processId) {
+  const { io: io2, env } = deps;
+  const resolved = await resolveIdentity({
+    env,
+    cwd: deps.cwd,
+    warn: (line) => io2.err(line)
+  });
+  const identity = {
+    pubkey: resolved.pubkey,
+    source: resolved.source,
+    sourceLabel: resolved.sourceLabel
+  };
+  const client = await import("@toon-protocol/client");
+  const derived = await client.deriveFullIdentity(
+    resolved.mnemonic,
+    resolved.accountIndex
+  );
+  const solanaAddress = derived.solana.publicKey;
+  if (!solanaAddress) {
+    throw new Error(
+      "no Solana key could be derived for this identity \u2014 ArNS names are owned by the Solana key (m/44'/501'/0'/0'). Ensure the optional Solana derivation deps are installed."
+    );
+  }
+  const sdk = await (deps.loadArns ?? defaultLoadArns)({
+    solanaSecretKey: derived.solana.secretKey,
+    solanaPublicKey: solanaAddress,
+    network,
+    ...processId !== void 0 ? { processId } : {}
+  });
+  return { identity, solanaAddress, network, processId, sdk };
+}
+function parseNameFlags(args, env) {
+  const { values, positionals } = parseArgs13({
+    args,
+    allowPositionals: true,
+    options: {
+      years: { type: "string" },
+      permabuy: { type: "boolean", default: false },
+      undername: { type: "string" },
+      ttl: { type: "string" },
+      network: { type: "string" },
+      "process-id": { type: "string" },
+      yes: { type: "boolean", default: false },
+      json: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    return { positionals: ["--help"], flags: { permabuy: false, ttl: 0, network: "mainnet", yes: false, json: false } };
+  }
+  let years;
+  if (values.years !== void 0) {
+    years = Number(values.years);
+    if (!Number.isInteger(years) || years <= 0) {
+      throw new Error(`--years must be a positive integer, got ${JSON.stringify(values.years)}`);
+    }
+  }
+  if (years !== void 0 && values.permabuy) {
+    throw new Error("--years and --permabuy are mutually exclusive");
+  }
+  let ttl = DEFAULT_TTL_SECONDS;
+  if (values.ttl !== void 0) {
+    ttl = Number(values.ttl);
+    if (!Number.isInteger(ttl) || ttl <= 0) {
+      throw new Error(`--ttl must be a positive integer number of seconds, got ${JSON.stringify(values.ttl)}`);
+    }
+  }
+  const networkRaw = values.network ?? env["RIG_ARIO_NETWORK"] ?? "mainnet";
+  if (!NETWORKS.includes(networkRaw)) {
+    throw new Error(`--network must be one of ${NETWORKS.join(" | ")}, got ${JSON.stringify(networkRaw)}`);
+  }
+  const processId = values["process-id"] ?? env["RIG_ARIO_PROCESS_ID"];
+  return {
+    positionals,
+    flags: {
+      ...years !== void 0 ? { years } : {},
+      permabuy: values.permabuy ?? false,
+      ...values.undername !== void 0 ? { undername: values.undername } : {},
+      ttl,
+      network: networkRaw,
+      ...processId !== void 0 ? { processId } : {},
+      yes: values.yes ?? false,
+      json: values.json ?? false
+    }
+  };
+}
+async function runBuy(name, flags, deps) {
+  const { io: io2 } = deps;
+  const type = flags.permabuy ? "permabuy" : "lease";
+  const years = type === "lease" ? flags.years ?? DEFAULT_LEASE_YEARS : null;
+  const ctx = await resolveNameContext(deps, flags.network, flags.processId);
+  const mario = await ctx.sdk.getTokenCost({
+    intent: "Buy-Name",
+    name,
+    type,
+    ...years !== null ? { years } : {}
+  });
+  const quote = {
+    mARIO: mario.toString(),
+    ARIO: formatUnits(mario.toString(), ARIO_DECIMALS)
+  };
+  const buildJson = (executed, extra = {}) => ({
+    command: "name",
+    action: "buy",
+    name,
+    type,
+    years,
+    network: ctx.network,
+    processId: ctx.processId ?? null,
+    identity: ctx.identity,
+    solanaAddress: ctx.solanaAddress,
+    quote,
+    payment: MARIO_PAYMENT_NOTE,
+    executed,
+    ...extra
+  });
+  if (!flags.json) {
+    io2.out(
+      `Buy ArNS name "${name}" \u2014 ${type}` + (years !== null ? ` (${years} year${years === 1 ? "" : "s"})` : "") + ` on ${ctx.network}`
+    );
+    io2.out(`  Cost: ${renderMario(mario)}`);
+    io2.out(`  Solana wallet: ${ctx.solanaAddress}`);
+    io2.out(`  ${MARIO_PAYMENT_NOTE}`);
+    io2.out(renderIdentityLine(ctx.identity));
+  }
+  if (!flags.yes) {
+    if (flags.json) {
+      io2.emitJson(
+        buildJson(false, {
+          hint: "estimate only \u2014 re-run with --yes to buy (spends mARIO on Solana, non-refundable)"
+        })
+      );
+      return 0;
+    }
+    if (!io2.isInteractive) {
+      io2.err(
+        "refusing to spend mARIO without confirmation in a non-interactive session \u2014 re-run with --yes (or use --json for a pure estimate)"
+      );
+      return 1;
+    }
+    const proceed = await io2.confirm(
+      `Proceed \u2014 buy "${name}" for ${renderMario(mario)} from your Solana wallet? [y/N] `
+    );
+    if (!proceed) {
+      io2.err("aborted \u2014 nothing was bought or paid.");
+      return 1;
+    }
+  }
+  const receipt = await ctx.sdk.buyRecord({
+    name,
+    type,
+    ...years !== null ? { years } : {}
+  });
+  const result = {
+    registryTxId: receipt.id,
+    antProcessId: receipt.processId ?? null
+  };
+  if (flags.json) {
+    io2.emitJson(buildJson(true, { result }));
+  } else {
+    io2.out(`Registered "${name}" \u2014 registry tx ${result.registryTxId}`);
+    if (result.antProcessId) io2.out(`  ANT process: ${result.antProcessId}`);
+    io2.out(
+      `Point it at content with \`rig name set ${name} <txId>\`, then it resolves at https://${name}.<gateway>/`
+    );
+  }
+  return 0;
+}
+async function runSet(name, txId, flags, deps) {
+  const { io: io2 } = deps;
+  const ctx = await resolveNameContext(deps, flags.network, flags.processId);
+  const record = await ctx.sdk.getArNSRecord({ name });
+  if (!record || !record.processId) {
+    throw new Error(
+      `no ArNS record for "${name}" on ${ctx.network} \u2014 buy it first with \`rig name buy ${name}\` (or check \`rig name status ${name}\`)`
+    );
+  }
+  const antProcessId = record.processId;
+  const undername = flags.undername ?? null;
+  const buildJson = (executed, extra = {}) => ({
+    command: "name",
+    action: "set",
+    name,
+    undername,
+    txId,
+    ttl: flags.ttl,
+    network: ctx.network,
+    processId: ctx.processId ?? null,
+    identity: ctx.identity,
+    solanaAddress: ctx.solanaAddress,
+    antProcessId,
+    executed,
+    ...extra
+  });
+  const targetLabel = undername ? `undername "${undername}_${name}"` : `base name "${name}"`;
+  if (!flags.json) {
+    io2.out(`Set ${targetLabel} \u2192 txId ${txId} (ttl ${flags.ttl}s) on ${ctx.network}`);
+    io2.out(`  ANT process: ${antProcessId}`);
+    io2.out(`  Signed by the identity's Solana key (${ctx.solanaAddress}).`);
+    io2.out(renderIdentityLine(ctx.identity));
+  }
+  if (!flags.yes) {
+    if (flags.json) {
+      io2.emitJson(
+        buildJson(false, {
+          hint: "estimate only \u2014 re-run with --yes to write the ANT record"
+        })
+      );
+      return 0;
+    }
+    if (!io2.isInteractive) {
+      io2.err(
+        "refusing to write an ANT record without confirmation in a non-interactive session \u2014 re-run with --yes (or --json to preview)"
+      );
+      return 1;
+    }
+    const proceed = await io2.confirm(
+      `Proceed \u2014 point ${targetLabel} at ${txId}? [y/N] `
+    );
+    if (!proceed) {
+      io2.err("aborted \u2014 the ANT record was not changed.");
+      return 1;
+    }
+  }
+  const ant = await ctx.sdk.ant(antProcessId);
+  const receipt = undername ? await ant.setUndernameRecord({ undername, transactionId: txId, ttlSeconds: flags.ttl }) : await ant.setBaseNameRecord({ transactionId: txId, ttlSeconds: flags.ttl });
+  const result = { messageId: receipt.id };
+  if (flags.json) {
+    io2.emitJson(buildJson(true, { result }));
+  } else {
+    io2.out(`Updated \u2014 ANT message ${result.messageId}`);
+    const host = undername ? `${undername}_${name}` : name;
+    io2.out(`  Resolves at https://${host}.<gateway>/ (allow for gateway cache/TTL).`);
+  }
+  return 0;
+}
+async function runStatus(name, flags, deps) {
+  const { io: io2 } = deps;
+  const ctx = await resolveNameContext(deps, flags.network, flags.processId);
+  const record = await ctx.sdk.getArNSRecord({ name });
+  let targets = null;
+  if (record?.processId) {
+    const ant = await ctx.sdk.ant(record.processId);
+    targets = await ant.getRecords();
+  }
+  if (flags.json) {
+    io2.emitJson({
+      command: "name",
+      action: "status",
+      name,
+      network: ctx.network,
+      processId: ctx.processId ?? null,
+      registered: record !== null,
+      identity: ctx.identity,
+      solanaAddress: ctx.solanaAddress,
+      record: record ? {
+        antProcessId: record.processId,
+        type: record.type,
+        startTimestamp: record.startTimestamp ?? null,
+        endTimestamp: record.endTimestamp ?? null,
+        undernameLimit: record.undernameLimit ?? null
+      } : null,
+      targets
+    });
+    return 0;
+  }
+  io2.out(`ArNS name "${name}" on ${ctx.network}:`);
+  if (!record) {
+    io2.out("  not registered \u2014 available to `rig name buy`.");
+    io2.out(renderIdentityLine(ctx.identity));
+    return 0;
+  }
+  io2.out(`  ANT process: ${record.processId ?? "(unknown)"}`);
+  io2.out(`  Type: ${record.type ?? "(unknown)"}`);
+  if (record.type === "permabuy") {
+    io2.out("  Expiry: never (permabuy)");
+  } else if (record.endTimestamp !== void 0) {
+    io2.out(`  Expiry: ${new Date(record.endTimestamp).toISOString()}`);
+  }
+  if (record.undernameLimit !== void 0) {
+    io2.out(`  Undernames included: ${record.undernameLimit}`);
+  }
+  if (targets && Object.keys(targets).length > 0) {
+    io2.out("  Records:");
+    for (const [under, target] of Object.entries(targets)) {
+      const label = under === "@" ? "(base)" : `${under}_${name}`;
+      io2.out(`    ${label} \u2192 ${target.transactionId} (ttl ${target.ttlSeconds}s)`);
+    }
+  } else {
+    io2.out("  Records: none set \u2014 point one with `rig name set`.");
+  }
+  io2.out(renderIdentityLine(ctx.identity));
+  return 0;
+}
+async function runName(args, deps) {
+  const { io: io2 } = deps;
+  const sub = args[0];
+  if (sub === void 0) {
+    io2.err(NAME_USAGE);
+    return 2;
+  }
+  if (sub === "--help" || sub === "-h" || sub === "help") {
+    io2.out(NAME_USAGE);
+    return 0;
+  }
+  if (!["buy", "set", "status"].includes(sub)) {
+    io2.err(`unknown \`rig name\` subcommand: ${JSON.stringify(sub)}`);
+    io2.err(NAME_USAGE);
+    return 2;
+  }
+  let positionals;
+  let flags;
+  try {
+    const parsed = parseNameFlags(args.slice(1), deps.env);
+    positionals = parsed.positionals;
+    flags = parsed.flags;
+  } catch (err) {
+    io2.err(err instanceof Error ? err.message : String(err));
+    io2.err(NAME_USAGE);
+    return 2;
+  }
+  if (positionals[0] === "--help") {
+    io2.out(NAME_USAGE);
+    return 0;
+  }
+  const name = positionals[0];
+  if (name === void 0) {
+    io2.err(`\`rig name ${sub}\` needs a <name>`);
+    io2.err(NAME_USAGE);
+    return 2;
+  }
+  try {
+    if (sub === "buy") return await runBuy(name, flags, deps);
+    if (sub === "status") return await runStatus(name, flags, deps);
+    const txId = positionals[1];
+    if (txId === void 0) {
+      io2.err("`rig name set` needs a <txId> (the Arweave transaction to point at)");
+      io2.err(NAME_USAGE);
+      return 2;
+    }
+    return await runSet(name, txId, flags, deps);
+  } catch (err) {
+    return emitCliError(io2, flags.json, "name", err);
+  }
+}
+
+// src/cli/site.ts
+import { parseArgs as parseArgs14 } from "util";
+
+// src/arweave-manifest.ts
+var DEFAULT_INDEX = "index.html";
+function buildArweaveManifest(entries, indexPath = DEFAULT_INDEX, fallbackTxId) {
+  const paths = {};
+  for (const { path, txId } of entries) {
+    paths[path] = { id: txId };
+  }
+  return {
+    manifest: "arweave/paths",
+    version: "0.2.0",
+    index: { path: indexPath },
+    ...fallbackTxId ? { fallback: { id: fallbackTxId } } : {},
+    paths
+  };
+}
+
+// src/cli/site-record.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+var SITE_MANIFEST_FILENAME = "site-manifests.json";
+function storeDir(env) {
+  return env["TOON_CLIENT_HOME"] ?? join3(homedir2(), ".toon-client");
+}
+function storePath(env) {
+  return join3(storeDir(env), SITE_MANIFEST_FILENAME);
+}
+function keyOf(repoId, ref) {
+  return `${repoId}\0${ref}`;
+}
+function readFile2(env) {
+  try {
+    const parsed = JSON.parse(readFileSync2(storePath(env), "utf8"));
+    if (parsed && typeof parsed === "object") return parsed;
+    return {};
+  } catch {
+    return {};
+  }
+}
+function readSiteRecord(env, repoId, ref) {
+  return readFile2(env)[keyOf(repoId, ref)];
+}
+function writeSiteRecord(env, record) {
+  const dir = storeDir(env);
+  mkdirSync2(dir, { recursive: true });
+  const file = readFile2(env);
+  file[keyOf(record.repoId, record.ref)] = record;
+  writeFileSync(storePath(env), `${JSON.stringify(file, null, 2)}
+`, "utf8");
+}
+
+// src/cli/site.ts
+var MANIFEST_CONTENT_TYPE = "application/x.arweave-manifest+json";
+var DEFAULT_GATEWAY = "https://arweave.net";
+var SITE_USAGE = `Usage: rig site <publish|url> [ref] [options]
+
+Serve a pushed repo as a permanent, path-routed website. \`rig push\` already
+stored the file bytes on Arweave; \`rig site publish\` builds the ar.io path
+manifest (paths \u2192 Arweave txids, index \u2192 index.html) and uploads it as ONE
+paid store write, printing the site URL. \`rig site url\` re-prints the URL of
+the last publish for free.
+
+The repo must be set up with \`rig init\`; the relay is the "origin" remote
+(\`rig push\` reads the same). \`ref\` defaults to the current branch.
+
+Commands:
+  publish [ref]   build + upload the path manifest (paid); prints the URL and
+                  a \`rig name set\` suggestion (#367)
+  url [ref]       print the last-published site URL for a ref (free)
+
+Options (publish):
+  --index <path>       path served at / (default: index.html)
+  --spa                single-page app: serve index for any unknown path
+                       (sets the manifest \`fallback\` to the index txid)
+  --fallback <path>    explicit fallback path for unknown routes (overrides
+                       --spa); must be one of the site's files
+  --force-reupload     re-pay to re-upload the ref's blobs with #368 per-file
+                       Content-Type before building the manifest \u2014 for repos
+                       pushed before mime-typing existed (else they serve as
+                       application/octet-stream)
+  --gateway <url>      gateway base for the printed URL (default: ${DEFAULT_GATEWAY};
+                       env RIG_ARWEAVE_GATEWAY also sets it)
+  --relay <url>        ad-hoc relay override (bypasses configured remotes)
+  --repo-id <id>       repository id (default: git config toon.repoid)
+  --yes                skip the fee confirmation (required when not a TTY)
+  --json               machine-readable envelope; without --yes it is a pure
+                       estimate (nothing uploaded)
+  -h, --help           show this help`;
+function parseSiteArgs(args) {
+  const { values, positionals } = parseArgs14({
+    args,
+    options: {
+      index: { type: "string" },
+      spa: { type: "boolean", default: false },
+      fallback: { type: "string" },
+      "force-reupload": { type: "boolean", default: false },
+      gateway: { type: "string" },
+      relay: { type: "string", multiple: true },
+      "repo-id": { type: "string" },
+      yes: { type: "boolean", default: false },
+      json: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    },
+    allowPositionals: true
+  });
+  const flags = {
+    index: values.index ?? "index.html",
+    spa: values.spa ?? false,
+    forceReupload: values["force-reupload"] ?? false,
+    relay: values.relay ?? [],
+    yes: values.yes ?? false,
+    json: values.json ?? false,
+    help: values.help ?? false,
+    positionals
+  };
+  if (values.fallback !== void 0) flags.fallback = values.fallback;
+  if (values.gateway !== void 0) flags.gateway = values.gateway;
+  if (values["repo-id"] !== void 0) flags.repoId = values["repo-id"];
+  return flags;
+}
+function normalizeGateway(gateway) {
+  return gateway.replace(/\/+$/, "");
+}
+function siteUrl(gateway, manifestTxId) {
+  return `${normalizeGateway(gateway)}/${manifestTxId}/`;
+}
+var PLACEHOLDER_TX = "A".repeat(43);
+async function runSite(args, deps) {
+  const { io: io2 } = deps;
+  const [sub, ...rest] = args;
+  if (sub === "publish") return runSitePublish(rest, deps);
+  if (sub === "url") return runSiteUrl(rest, deps);
+  if (sub === void 0 || sub === "-h" || sub === "--help" || sub === "help") {
+    io2.out(SITE_USAGE);
+    return sub === void 0 ? 2 : 0;
+  }
+  io2.err(`unknown site subcommand ${JSON.stringify(sub)}`);
+  io2.err(SITE_USAGE);
+  return 2;
+}
+async function runSitePublish(args, deps) {
+  const { io: io2 } = deps;
+  let flags;
+  try {
+    flags = parseSiteArgs(args);
+  } catch (err) {
+    io2.err(err instanceof Error ? err.message : String(err));
+    io2.err(SITE_USAGE);
+    return 2;
+  }
+  if (flags.help) {
+    io2.out(SITE_USAGE);
+    return 0;
+  }
+  let ctx;
+  try {
+    const repoRoot = await resolveRepoRoot(deps.cwd);
+    const toonConfig = await readToonConfig(repoRoot);
+    const repoId = flags.repoId ?? toonConfig.repoId;
+    if (!repoId) throw new UnconfiguredRepoAddressError("repository id");
+    const reader = new GitRepoReader(repoRoot);
+    const selected = await selectRefspecs(reader, flags.positionals, false, false);
+    if (selected.length !== 1) {
+      throw new Error(
+        `rig site publish builds ONE ref into a site \u2014 got ${selected.length} (${selected.join(", ")}); pass a single branch or tag`
+      );
+    }
+    const ref = selected[0];
+    const resolved = await resolveRelays({
+      relayFlags: flags.relay,
+      remoteName: void 0,
+      repoRoot,
+      toonRelays: toonConfig.relays
+    });
+    if (resolved.nudge !== void 0) io2.err(resolved.nudge);
+    const relaysUsed = resolved.relays;
+    if (relaysUsed.length > 1) {
+      io2.err(singleRelayRefusal(resolved, "Nothing was uploaded or paid."));
+      return 1;
+    }
+    ctx = await (deps.loadStandalone ?? defaultLoadStandalone)({
+      env: deps.env,
+      cwd: deps.cwd,
+      warn: (line) => io2.err(line),
+      ...relaysUsed[0] !== void 0 ? { relayUrl: relaysUsed[0] } : {}
+    });
+    const identity = identityReport(ctx);
+    if (!ctx.publisher.uploadBlob) {
+      throw new Error(
+        "the active publisher cannot upload a raw manifest blob (uploadBlob unavailable) \u2014 `rig site` requires the standalone publisher"
+      );
+    }
+    const blobs = await reader.listBlobs(ref);
+    if (blobs.length === 0) {
+      throw new Error(`ref ${JSON.stringify(ref)} has no files to serve`);
+    }
+    const shaToPaths = /* @__PURE__ */ new Map();
+    for (const { path, sha } of blobs) {
+      const paths = shaToPaths.get(sha) ?? [];
+      paths.push(path);
+      shaToPaths.set(sha, paths);
+    }
+    const uniqueShas = [...shaToPaths.keys()];
+    const remoteState = await ctx.fetchRemote({
+      ownerPubkey: ctx.ownerPubkey,
+      repoId,
+      relayUrls: relaysUsed
+    });
+    const known = new Map(remoteState.shaToTxId);
+    const gaps = uniqueShas.filter((sha) => !known.has(sha));
+    if (gaps.length > 0) {
+      const found = await remoteState.resolveMissing(gaps);
+      for (const [sha, txId] of found) known.set(sha, txId);
+    }
+    const fallbackPath = flags.fallback ?? (flags.spa ? flags.index : void 0);
+    const pathSet = new Set(blobs.map((b) => b.path));
+    if (fallbackPath !== void 0 && !pathSet.has(fallbackPath)) {
+      throw new Error(
+        `fallback path ${JSON.stringify(fallbackPath)} is not one of the site's files \u2014 pick an existing path (or the --index file for --spa)`
+      );
+    }
+    if (!pathSet.has(flags.index)) {
+      io2.err(
+        `warning: no ${JSON.stringify(flags.index)} in this ref \u2014 the site will 404 at / until you add one (or pass --index <path>)`
+      );
+    }
+    if (!flags.forceReupload) {
+      const unpublished = uniqueShas.filter((sha) => !known.has(sha));
+      if (unpublished.length > 0) {
+        const paths = unpublished.flatMap((sha) => shaToPaths.get(sha) ?? []).slice(0, 10);
+        throw new Error(
+          `${unpublished.length} file(s) in ${ref} are not on Arweave yet (e.g. ${paths.join(", ")}) \u2014 run \`rig push\` first, or \`rig site publish --force-reupload\` to upload them now (paid).`
+        );
+      }
+    }
+    const { uploadFeePerByte } = await ctx.publisher.getFeeRates();
+    const previewEntries = blobs.map((b) => ({
+      path: b.path,
+      txId: known.get(b.sha) ?? PLACEHOLDER_TX
+    }));
+    const previewManifest = buildArweaveManifest(
+      previewEntries,
+      flags.index,
+      fallbackPath ? PLACEHOLDER_TX : void 0
+    );
+    const manifestBytes = Buffer.byteLength(JSON.stringify(previewManifest));
+    let reuploadBytes = 0;
+    if (flags.forceReupload) {
+      const { objects } = await reader.statObjects(uniqueShas);
+      reuploadBytes = objects.reduce((sum, o) => sum + o.size, 0);
+    }
+    const manifestFee = BigInt(manifestBytes) * uploadFeePerByte;
+    const reuploadFee = BigInt(reuploadBytes) * uploadFeePerByte;
+    const totalFee = manifestFee + reuploadFee;
+    const gateway = flags.gateway ?? deps.env["RIG_ARWEAVE_GATEWAY"] ?? DEFAULT_GATEWAY;
+    const baseJson = () => ({
+      command: "site publish",
+      repoId,
+      ref,
+      identity,
+      forceReupload: flags.forceReupload,
+      fileCount: blobs.length,
+      index: flags.index,
+      ...fallbackPath ? { fallback: fallbackPath } : {},
+      estimate: {
+        manifestBytes,
+        reuploadBytes,
+        totalFee: totalFee.toString()
+      }
+    });
+    if (!flags.json) {
+      io2.out(`Site publish plan for ${ref} (repo ${repoId}):`);
+      io2.out(`  files:    ${blobs.length}`);
+      io2.out(`  index:    ${flags.index}${pathSet.has(flags.index) ? "" : " (missing!)"}`);
+      if (fallbackPath) io2.out(`  fallback: ${fallbackPath}`);
+      if (flags.forceReupload) {
+        io2.out(`  re-upload ${uniqueShas.length} blob(s), ${reuploadBytes} bytes (paid)`);
+      }
+      io2.out(`  manifest: ${manifestBytes} bytes`);
+      io2.out(`  total fee: ${totalFee} base units`);
+      io2.out(renderIdentityLine(identity));
+    }
+    if (!flags.yes) {
+      if (flags.json) {
+        io2.emitJson({
+          ...baseJson(),
+          executed: false,
+          hint: "estimate only \u2014 re-run with --yes to upload the manifest (permanent, non-refundable)"
+        });
+        return 0;
+      }
+      if (!io2.isInteractive) {
+        io2.err(
+          "refusing to spend channel funds without confirmation in a non-interactive session \u2014 re-run with --yes (or use --json for an estimate)"
+        );
+        return 1;
+      }
+      const proceed = await io2.confirm(
+        `Proceed with paid site publish (total ${totalFee} base units)? [y/N] `
+      );
+      if (!proceed) {
+        io2.err("aborted \u2014 nothing was uploaded.");
+        return 1;
+      }
+    }
+    if (flags.forceReupload) {
+      const { objects, missing } = await reader.readObjects(uniqueShas);
+      if (missing.length > 0) {
+        throw new Error(
+          `objects vanished from the local repository: ${missing.join(", ")}`
+        );
+      }
+      const bodyBySha = new Map(objects.map((o) => [o.sha, o.body]));
+      for (const sha of uniqueShas) {
+        const body = bodyBySha.get(sha);
+        if (!body) throw new Error(`internal: no body for ${sha}`);
+        const uploadPath = resolveConflictingPath(shaToPaths.get(sha) ?? []);
+        const receipt2 = await ctx.publisher.uploadGitObject({
+          sha,
+          type: "blob",
+          body,
+          repoId,
+          ...uploadPath ? { path: uploadPath } : {}
+        });
+        known.set(sha, receipt2.txId);
+      }
+    }
+    const entries = blobs.map((b) => {
+      const txId = known.get(b.sha);
+      if (!txId) {
+        throw new Error(`internal: no Arweave txid for ${b.path} (${b.sha})`);
+      }
+      return { path: b.path, txId };
+    });
+    const fallbackTxId = fallbackPath !== void 0 ? entries.find((e) => e.path === fallbackPath)?.txId : void 0;
+    const manifest = buildArweaveManifest(entries, flags.index, fallbackTxId);
+    const manifestBody = Buffer.from(JSON.stringify(manifest), "utf8");
+    const receipt = await ctx.publisher.uploadBlob({
+      body: manifestBody,
+      contentType: MANIFEST_CONTENT_TYPE,
+      repoId
+    });
+    const url = siteUrl(gateway, receipt.txId);
+    writeSiteRecord(deps.env, {
+      repoId,
+      ref,
+      owner: ctx.ownerPubkey,
+      manifestTxId: receipt.txId,
+      gateway: normalizeGateway(gateway),
+      updatedAt: Date.now()
+    });
+    const nameHint = `Point a name at it (see #367): rig name set <name> ${receipt.txId}`;
+    if (flags.json) {
+      io2.emitJson({
+        ...baseJson(),
+        executed: true,
+        manifest: { txId: receipt.txId, url },
+        nameHint
+      });
+    } else {
+      io2.out(`Site published: ${url}`);
+      io2.out(nameHint);
+    }
+    return 0;
+  } catch (err) {
+    return emitCliError(io2, flags.json, "site publish", err);
+  } finally {
+    if (ctx) {
+      try {
+        await ctx.stop();
+      } catch {
+      }
+    }
+  }
+}
+async function runSiteUrl(args, deps) {
+  const { io: io2 } = deps;
+  let flags;
+  try {
+    flags = parseSiteArgs(args);
+  } catch (err) {
+    io2.err(err instanceof Error ? err.message : String(err));
+    io2.err(SITE_USAGE);
+    return 2;
+  }
+  if (flags.help) {
+    io2.out(SITE_USAGE);
+    return 0;
+  }
+  try {
+    const repoRoot = await resolveRepoRoot(deps.cwd);
+    const toonConfig = await readToonConfig(repoRoot);
+    const repoId = flags.repoId ?? toonConfig.repoId;
+    if (!repoId) throw new UnconfiguredRepoAddressError("repository id");
+    const reader = new GitRepoReader(repoRoot);
+    const selected = await selectRefspecs(reader, flags.positionals, false, false);
+    if (selected.length !== 1) {
+      throw new Error(
+        `rig site url takes ONE ref \u2014 got ${selected.length} (${selected.join(", ")})`
+      );
+    }
+    const ref = selected[0];
+    const record = readSiteRecord(deps.env, repoId, ref);
+    if (!record) {
+      const detail = `no site published for ${ref} (repo ${repoId}) yet \u2014 run \`rig site publish\` first (the manifest txid is only known after a paid publish)`;
+      if (flags.json) {
+        io2.emitJson({
+          command: "site url",
+          repoId,
+          ref,
+          found: false
+        });
+      }
+      io2.err(detail);
+      return 1;
+    }
+    const url = siteUrl(record.gateway, record.manifestTxId);
+    if (flags.json) {
+      io2.emitJson({
+        command: "site url",
+        repoId,
+        ref,
+        found: true,
+        manifestTxId: record.manifestTxId,
+        url,
+        updatedAt: record.updatedAt
+      });
+    } else {
+      io2.out(url);
+    }
+    return 0;
+  } catch (err) {
+    return emitCliError(io2, flags.json, "site url", err);
+  }
+}
+
 // src/cli/dispatch.ts
 var USAGE = `rig \u2014 git with a TOON remote (pay-to-write Nostr + Arweave)
 
@@ -4942,6 +5840,10 @@ Commands rig owns:
                              push is the TOON transport and shadows git push;
                              plain-git pushes remain available by running
                              \`git push\` directly
+  site publish [ref]         deploy a pushed repo as a permaweb site: build the
+                             ar.io path manifest (paths \u2192 Arweave txids) and
+                             upload it as one paid store write; prints the URL
+  site url [ref]             print the last-published site URL for a ref (free)
   issue create               file an issue (kind:1621) against a repo
   issue list | show <id>     read the repo's issues + comments (free)
   pr list | show <id>        read the repo's patches; show prints the full
@@ -4960,6 +5862,11 @@ Commands rig owns:
                              address(es) to fund externally
   balance                    wallet balances + payment-channel holdings
                              (free \u2014 chain reads and local state only)
+  name buy <name>            ArNS naming (#367): buy points a human name at an
+  name set <name> <txId>     Arweave txId, owned + paid by this identity's
+  name status <name>         Solana key. buy spends mARIO on Solana via the
+                             ar.io registry (NOT ILP); status is free. Needs
+                             the optional \`@ar.io/sdk\` dependency
   channel list               show the payment channels paid commands hold
                              (free \u2014 reads local state)
   channel open               explicitly open (or resume) the channel for a
@@ -5014,6 +5921,8 @@ async function dispatch(argv2, deps) {
       return runFetch(rest, deps);
     case "push":
       return runPush(rest, deps);
+    case "site":
+      return runSite(rest, deps);
     case "issue":
       return runIssue(rest, deps);
     case "comment":
@@ -5028,6 +5937,8 @@ async function dispatch(argv2, deps) {
       return runFund(rest, deps);
     case "balance":
       return runBalance(rest, deps);
+    case "name":
+      return runName(rest, deps);
     case "help":
     case "--help":
     case "-h":
@@ -5097,13 +6008,15 @@ var RIG_OWNED_VERBS = /* @__PURE__ */ new Set([
   "clone",
   "fetch",
   "push",
+  "site",
   "issue",
   "comment",
   "pr",
   "maintainers",
   "channel",
   "fund",
-  "balance"
+  "balance",
+  "name"
 ]);
 function isJsonInvocation(argv2) {
   const [verb, ...rest] = argv2;