polkadot-cli 0.14.0 → 1.1.1

package/dist/cli.mjs

@@ -5,7 +5,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/cli.ts
 import cac from "cac";
 // package.json
-var version = "0.14.0";
+var version = "1.1.1";
 
 // src/config/accounts-store.ts
 import { access as access2, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
@@ -830,6 +830,7 @@ async function accountInspect(input, opts) {
 import { createClient } from "polkadot-api";
 import { withPolkadotSdkCompat } from "polkadot-api/polkadot-sdk-compat";
 import { getWsProvider } from "polkadot-api/ws-provider";
+import { WebSocket } from "ws";
 
 // src/utils/errors.ts
 class CliError extends Error {
@@ -891,7 +892,10 @@ async function createChainClient(chainName, chainConfig, rpcOverride) {
       restoreConsole();
       throw new ConnectionError(`No RPC endpoint configured for chain "${chainName}". Use --rpc or configure one with: dot chain add ${chainName} --rpc <url>`);
     }
-    provider = withPolkadotSdkCompat(getWsProvider(rpc, { timeout: 1e4 }));
+    provider = withPolkadotSdkCompat(getWsProvider(rpc, {
+      timeout: 1e4,
+      websocketClass: WebSocket
+    }));
   }
   const client = createClient(provider, {
     getMetadata: async () => loadMetadata(chainName),
@@ -1333,135 +1337,450 @@ function suggestMessage(kind, input, candidates) {
   return `Unknown ${kind} "${input}". Did you mean: ${suggestions.join(", ")}?`;
 }
 
-// src/utils/parse-target.ts
-function parseTarget(input, options) {
-  const parts = input.split(".");
-  if (options?.allowPalletOnly) {
-    switch (parts.length) {
-      case 1:
-        if (!parts[0]) {
-          throw new Error(`Invalid target "${input}". Expected format: Pallet or Pallet.Item (e.g. System or System.Account)`);
-        }
-        return { pallet: parts[0] };
-      case 2:
-        if (!parts[0] || !parts[1]) {
-          throw new Error(`Invalid target "${input}". Expected format: Pallet.Item or Chain.Pallet (e.g. System.Account or kusama.System)`);
-        }
-        if (options.knownChains?.some((c) => c.toLowerCase() === parts[0].toLowerCase())) {
-          return { chain: parts[0], pallet: parts[1] };
-        }
-        return { pallet: parts[0], item: parts[1] };
-      case 3:
-        if (!parts[0] || !parts[1] || !parts[2]) {
-          throw new Error(`Invalid target "${input}". Expected format: Chain.Pallet.Item (e.g. kusama.System.Account)`);
-        }
-        return { chain: parts[0], pallet: parts[1], item: parts[2] };
-      default:
-        throw new Error(`Invalid target "${input}". Expected format: Pallet, Pallet.Item, or Chain.Pallet.Item`);
+// src/commands/focused-inspect.ts
+async function loadMeta(chainName, chainConfig, rpcOverride) {
+  try {
+    return await getOrFetchMetadata(chainName);
+  } catch {
+    console.error(`Fetching metadata from ${chainName}...`);
+    const clientHandle = await createChainClient(chainName, chainConfig, rpcOverride);
+    try {
+      return await getOrFetchMetadata(chainName, clientHandle);
+    } finally {
+      clientHandle.destroy();
     }
   }
-  switch (parts.length) {
-    case 2:
-      if (!parts[0] || !parts[1]) {
-        throw new Error(`Invalid target "${input}". Expected format: Pallet.Item (e.g. System.Account)`);
+}
+function resolvePallet(meta, palletName) {
+  const palletNames = getPalletNames(meta);
+  const pallet = findPallet(meta, palletName);
+  if (!pallet) {
+    throw new Error(suggestMessage("pallet", palletName, palletNames));
+  }
+  return pallet;
+}
+async function handleCalls(target, opts) {
+  if (!target) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta2 = await loadMeta(chainName2, chainConfig2, opts.rpc);
+    const pallets = listPallets(meta2);
+    const withCalls = pallets.filter((p) => p.calls.length > 0);
+    printHeading(`Pallets with calls on ${chainName2} (${withCalls.length})`);
+    for (const p of withCalls) {
+      printItem(p.name, `${p.calls.length} calls`);
+    }
+    console.log();
+    return;
+  }
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const meta = await loadMeta(chainName, chainConfig, opts.rpc);
+  const dotIdx = target.indexOf(".");
+  const palletName = dotIdx === -1 ? target : target.slice(0, dotIdx);
+  const itemName = dotIdx === -1 ? undefined : target.slice(dotIdx + 1);
+  const pallet = resolvePallet(meta, palletName);
+  if (!itemName) {
+    if (pallet.calls.length === 0) {
+      console.log(`No calls in ${pallet.name}.`);
+      return;
+    }
+    printHeading(`${pallet.name} Calls`);
+    for (const c of pallet.calls) {
+      const args2 = describeCallArgs(meta, pallet.name, c.name);
+      console.log(`  ${CYAN}${c.name}${RESET}${DIM}${args2}${RESET}`);
+      const summary = firstSentence(c.docs);
+      if (summary) {
+        console.log(`      ${DIM}${summary}${RESET}`);
       }
-      return { pallet: parts[0], item: parts[1] };
-    case 3:
-      if (!parts[0] || !parts[1] || !parts[2]) {
-        throw new Error(`Invalid target "${input}". Expected format: Chain.Pallet.Item (e.g. kusama.System.Account)`);
+    }
+    console.log();
+    return;
+  }
+  const callItem = pallet.calls.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
+  if (!callItem) {
+    const names = pallet.calls.map((c) => c.name);
+    throw new Error(suggestMessage(`call in ${pallet.name}`, itemName, names));
+  }
+  printHeading(`${pallet.name}.${callItem.name} (Call)`);
+  const args = describeCallArgs(meta, pallet.name, callItem.name);
+  console.log(`  ${BOLD}Args:${RESET} ${args}`);
+  if (callItem.docs.length) {
+    console.log();
+    printDocs(callItem.docs);
+  }
+  console.log();
+}
+async function handleEvents(target, opts) {
+  if (!target) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta2 = await loadMeta(chainName2, chainConfig2, opts.rpc);
+    const pallets = listPallets(meta2);
+    const withEvents = pallets.filter((p) => p.events.length > 0);
+    printHeading(`Pallets with events on ${chainName2} (${withEvents.length})`);
+    for (const p of withEvents) {
+      printItem(p.name, `${p.events.length} events`);
+    }
+    console.log();
+    return;
+  }
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const meta = await loadMeta(chainName, chainConfig, opts.rpc);
+  const dotIdx = target.indexOf(".");
+  const palletName = dotIdx === -1 ? target : target.slice(0, dotIdx);
+  const itemName = dotIdx === -1 ? undefined : target.slice(dotIdx + 1);
+  const pallet = resolvePallet(meta, palletName);
+  if (!itemName) {
+    if (pallet.events.length === 0) {
+      console.log(`No events in ${pallet.name}.`);
+      return;
+    }
+    printHeading(`${pallet.name} Events`);
+    for (const e of pallet.events) {
+      const fields2 = describeEventFields(meta, pallet.name, e.name);
+      console.log(`  ${CYAN}${e.name}${RESET}${DIM}${fields2}${RESET}`);
+      const summary = firstSentence(e.docs);
+      if (summary) {
+        console.log(`      ${DIM}${summary}${RESET}`);
       }
-      return { chain: parts[0], pallet: parts[1], item: parts[2] };
-    default:
-      throw new Error(`Invalid target "${input}". Expected format: Pallet.Item (e.g. System.Account)`);
+    }
+    console.log();
+    return;
   }
+  const eventItem = pallet.events.find((e) => e.name.toLowerCase() === itemName.toLowerCase());
+  if (!eventItem) {
+    const names = pallet.events.map((e) => e.name);
+    throw new Error(suggestMessage(`event in ${pallet.name}`, itemName, names));
+  }
+  printHeading(`${pallet.name}.${eventItem.name} (Event)`);
+  const fields = describeEventFields(meta, pallet.name, eventItem.name);
+  console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
+  if (eventItem.docs.length) {
+    console.log();
+    printDocs(eventItem.docs);
+  }
+  console.log();
 }
-function resolveTargetChain(target, chainFlag) {
-  if (target.chain && chainFlag) {
-    throw new Error(`Chain specified both as prefix ("${target.chain}") and as --chain flag ("${chainFlag}"). Use one or the other.`);
+async function handleErrors(target, opts) {
+  if (!target) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta2 = await loadMeta(chainName2, chainConfig2, opts.rpc);
+    const pallets = listPallets(meta2);
+    const withErrors = pallets.filter((p) => p.errors.length > 0);
+    printHeading(`Pallets with errors on ${chainName2} (${withErrors.length})`);
+    for (const p of withErrors) {
+      printItem(p.name, `${p.errors.length} errors`);
+    }
+    console.log();
+    return;
   }
-  return target.chain ?? chainFlag;
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const meta = await loadMeta(chainName, chainConfig, opts.rpc);
+  const dotIdx = target.indexOf(".");
+  const palletName = dotIdx === -1 ? target : target.slice(0, dotIdx);
+  const itemName = dotIdx === -1 ? undefined : target.slice(dotIdx + 1);
+  const pallet = resolvePallet(meta, palletName);
+  if (!itemName) {
+    if (pallet.errors.length === 0) {
+      console.log(`No errors in ${pallet.name}.`);
+      return;
+    }
+    printHeading(`${pallet.name} Errors`);
+    for (const e of pallet.errors) {
+      console.log(`  ${CYAN}${e.name}${RESET}`);
+      const summary = firstSentence(e.docs);
+      if (summary) {
+        console.log(`      ${DIM}${summary}${RESET}`);
+      }
+    }
+    console.log();
+    return;
+  }
+  const errorItem = pallet.errors.find((e) => e.name.toLowerCase() === itemName.toLowerCase());
+  if (!errorItem) {
+    const names = pallet.errors.map((e) => e.name);
+    throw new Error(suggestMessage(`error in ${pallet.name}`, itemName, names));
+  }
+  printHeading(`${pallet.name}.${errorItem.name} (Error)`);
+  if (errorItem.docs.length) {
+    printDocs(errorItem.docs);
+  }
+  console.log();
 }
-
-// src/commands/const.ts
-function registerConstCommand(cli) {
-  cli.command("const [target]", "Look up or list pallet constants (e.g. Balances.ExistentialDeposit)").alias("consts").alias("constants").action(async (target, opts) => {
-    if (!target) {
-      console.log("Usage: dot const <[Chain.]Pallet[.Constant]> [--chain <name>] [--output json]");
-      console.log("");
-      console.log("Examples:");
-      console.log("  $ dot const Balances                              # list constants");
-      console.log("  $ dot const Balances.ExistentialDeposit           # look up value");
-      console.log("  $ dot const System.SS58Prefix --chain kusama");
-      console.log("  $ dot const kusama.Balances.ExistentialDeposit    # chain prefix");
+async function handleStorage(target, opts) {
+  if (!target) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta2 = await loadMeta(chainName2, chainConfig2, opts.rpc);
+    const pallets = listPallets(meta2);
+    const withStorage = pallets.filter((p) => p.storage.length > 0);
+    printHeading(`Pallets with storage on ${chainName2} (${withStorage.length})`);
+    for (const p of withStorage) {
+      printItem(p.name, `${p.storage.length} storage`);
+    }
+    console.log();
+    return;
+  }
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const meta = await loadMeta(chainName, chainConfig, opts.rpc);
+  const dotIdx = target.indexOf(".");
+  const palletName = dotIdx === -1 ? target : target.slice(0, dotIdx);
+  const itemName = dotIdx === -1 ? undefined : target.slice(dotIdx + 1);
+  const pallet = resolvePallet(meta, palletName);
+  if (!itemName) {
+    if (pallet.storage.length === 0) {
+      console.log(`No storage items in ${pallet.name}.`);
       return;
     }
-    const config = await loadConfig();
-    const knownChains = Object.keys(config.chains);
-    const parsed = parseTarget(target, { knownChains, allowPalletOnly: true });
-    const effectiveChain = resolveTargetChain(parsed, opts.chain);
-    const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
-    const pallet = parsed.pallet;
-    const item = parsed.item;
-    if (!item) {
-      let meta;
-      try {
-        meta = await getOrFetchMetadata(chainName);
-      } catch {
-        console.error(`Fetching metadata from ${chainName}...`);
-        const clientHandle2 = await createChainClient(chainName, chainConfig, opts.rpc);
-        try {
-          meta = await getOrFetchMetadata(chainName, clientHandle2);
-        } finally {
-          clientHandle2.destroy();
-        }
+    printHeading(`${pallet.name} Storage`);
+    for (const s of pallet.storage) {
+      const valueType = describeType(meta.lookup, s.valueTypeId);
+      let typeSuffix;
+      if (s.keyTypeId != null) {
+        const keyType = describeType(meta.lookup, s.keyTypeId);
+        typeSuffix = `: ${keyType} → ${valueType}    [map]`;
+      } else {
+        typeSuffix = `: ${valueType}`;
       }
-      const palletNames = getPalletNames(meta);
-      const palletInfo = findPallet(meta, pallet);
-      if (!palletInfo) {
-        throw new Error(suggestMessage("pallet", pallet, palletNames));
+      console.log(`  ${CYAN}${s.name}${RESET}${DIM}${typeSuffix}${RESET}`);
+      const summary = firstSentence(s.docs);
+      if (summary) {
+        console.log(`      ${DIM}${summary}${RESET}`);
       }
-      if (palletInfo.constants.length === 0) {
-        console.log(`No constants in ${palletInfo.name}.`);
+    }
+    console.log();
+    return;
+  }
+  const storageItem = pallet.storage.find((s) => s.name.toLowerCase() === itemName.toLowerCase());
+  if (!storageItem) {
+    const names = pallet.storage.map((s) => s.name);
+    throw new Error(suggestMessage(`storage item in ${pallet.name}`, itemName, names));
+  }
+  printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
+  console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
+  console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
+  if (storageItem.keyTypeId != null) {
+    console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
+  }
+  if (storageItem.docs.length) {
+    console.log();
+    printDocs(storageItem.docs);
+  }
+  console.log();
+}
+async function showItemHelp(category, target, opts) {
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const meta = await loadMeta(chainName, chainConfig, opts.rpc);
+  const dotIdx = target.indexOf(".");
+  const palletName = dotIdx === -1 ? target : target.slice(0, dotIdx);
+  const itemName = dotIdx === -1 ? undefined : target.slice(dotIdx + 1);
+  const pallet = resolvePallet(meta, palletName);
+  if (!itemName) {
+    switch (category) {
+      case "tx":
+        await handleCalls(target, opts);
+        return;
+      case "query":
+        await handleStorage(target, opts);
+        return;
+      case "const":
+        return;
+      case "events":
+        await handleEvents(target, opts);
+        return;
+      case "errors":
+        await handleErrors(target, opts);
         return;
+    }
+  }
+  switch (category) {
+    case "tx": {
+      const callItem = pallet.calls.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
+      if (!callItem) {
+        const names = pallet.calls.map((c) => c.name);
+        throw new Error(suggestMessage(`call in ${pallet.name}`, itemName, names));
       }
-      printHeading(`${palletInfo.name} Constants`);
-      for (const c of palletInfo.constants) {
-        const typeStr = describeType(meta.lookup, c.typeId);
-        console.log(`  ${CYAN}${c.name}${RESET}${DIM}: ${typeStr}${RESET}`);
-        const summary = firstSentence(c.docs);
-        if (summary) {
-          console.log(`      ${DIM}${summary}${RESET}`);
-        }
+      printHeading(`${pallet.name}.${callItem.name} (Call)`);
+      const args = describeCallArgs(meta, pallet.name, callItem.name);
+      console.log(`  ${BOLD}Args:${RESET} ${args}`);
+      if (callItem.docs.length) {
+        console.log();
+        printDocs(callItem.docs);
       }
       console.log();
+      console.log(`${BOLD}Usage:${RESET}`);
+      console.log(`  dot tx.${pallet.name}.${callItem.name} --from <account>`);
+      console.log(`  dot tx.${pallet.name}.${callItem.name} --encode`);
+      console.log();
+      console.log(`${BOLD}Options:${RESET}`);
+      console.log(`  --from <name>    Account to sign with`);
+      console.log(`  --dry-run        Estimate fees without submitting`);
+      console.log(`  --encode         Encode call to hex without signing`);
+      console.log(`  --ext <json>     Custom signed extension values as JSON`);
+      console.log();
       return;
     }
-    const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
-    try {
-      const meta = await getOrFetchMetadata(chainName, clientHandle);
-      const palletNames = getPalletNames(meta);
-      const palletInfo = findPallet(meta, pallet);
-      if (!palletInfo) {
-        throw new Error(suggestMessage("pallet", pallet, palletNames));
+    case "query": {
+      const storageItem = pallet.storage.find((s) => s.name.toLowerCase() === itemName.toLowerCase());
+      if (!storageItem) {
+        const names = pallet.storage.map((s) => s.name);
+        throw new Error(suggestMessage(`storage item in ${pallet.name}`, itemName, names));
       }
-      const constantItem = palletInfo.constants.find((c) => c.name.toLowerCase() === item.toLowerCase());
-      if (!constantItem) {
-        const constNames = palletInfo.constants.map((c) => c.name);
-        throw new Error(suggestMessage(`constant in ${palletInfo.name}`, item, constNames));
+      printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
+      console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
+      console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
+      if (storageItem.keyTypeId != null) {
+        console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
       }
-      const unsafeApi = clientHandle.client.getUnsafeApi();
-      const runtimeToken = await unsafeApi.runtimeToken;
-      const result = unsafeApi.constants[palletInfo.name][constantItem.name](runtimeToken);
-      const format = opts.output ?? "pretty";
-      printResult(result, format);
-    } finally {
-      clientHandle.destroy();
+      if (storageItem.docs.length) {
+        console.log();
+        printDocs(storageItem.docs);
+      }
+      console.log();
+      if (storageItem.keyTypeId != null) {
+        console.log(`${BOLD}Usage:${RESET}`);
+        console.log(`  dot query.${pallet.name}.${storageItem.name} <key>`);
+        console.log(`  dot query.${pallet.name}.${storageItem.name}              # all entries`);
+      } else {
+        console.log(`${BOLD}Usage:${RESET}`);
+        console.log(`  dot query.${pallet.name}.${storageItem.name}`);
+      }
+      console.log();
+      console.log(`${BOLD}Options:${RESET}`);
+      console.log(`  --limit <n>      Max entries for map queries (0 = unlimited, default: 100)`);
+      console.log();
+      return;
     }
-  });
+    case "const": {
+      const constItem = pallet.constants.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
+      if (!constItem) {
+        const names = pallet.constants.map((c) => c.name);
+        throw new Error(suggestMessage(`constant in ${pallet.name}`, itemName, names));
+      }
+      printHeading(`${pallet.name}.${constItem.name} (Constant)`);
+      console.log(`  ${BOLD}Type:${RESET} ${describeType(meta.lookup, constItem.typeId)}`);
+      if (constItem.docs.length) {
+        console.log();
+        printDocs(constItem.docs);
+      }
+      console.log();
+      console.log(`${BOLD}Usage:${RESET}`);
+      console.log(`  dot const.${pallet.name}.${constItem.name}`);
+      console.log();
+      return;
+    }
+    case "events": {
+      const eventItem = pallet.events.find((e) => e.name.toLowerCase() === itemName.toLowerCase());
+      if (!eventItem) {
+        const names = pallet.events.map((e) => e.name);
+        throw new Error(suggestMessage(`event in ${pallet.name}`, itemName, names));
+      }
+      printHeading(`${pallet.name}.${eventItem.name} (Event)`);
+      const fields = describeEventFields(meta, pallet.name, eventItem.name);
+      console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
+      if (eventItem.docs.length) {
+        console.log();
+        printDocs(eventItem.docs);
+      }
+      console.log();
+      console.log(`${BOLD}Usage:${RESET}`);
+      console.log(`  dot events.${pallet.name}.${eventItem.name}`);
+      console.log();
+      return;
+    }
+    case "errors": {
+      const errorItem = pallet.errors.find((e) => e.name.toLowerCase() === itemName.toLowerCase());
+      if (!errorItem) {
+        const names = pallet.errors.map((e) => e.name);
+        throw new Error(suggestMessage(`error in ${pallet.name}`, itemName, names));
+      }
+      printHeading(`${pallet.name}.${errorItem.name} (Error)`);
+      if (errorItem.docs.length) {
+        printDocs(errorItem.docs);
+      }
+      console.log();
+      console.log(`${BOLD}Usage:${RESET}`);
+      console.log(`  dot errors.${pallet.name}.${errorItem.name}`);
+      console.log();
+      return;
+    }
+  }
+}
+
+// src/commands/const.ts
+async function handleConst(target, opts) {
+  if (!target) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
+    const pallets = listPallets(meta);
+    const withConsts = pallets.filter((p) => p.constants.length > 0);
+    printHeading(`Pallets with constants on ${chainName2} (${withConsts.length})`);
+    for (const p of withConsts) {
+      printItem(p.name, `${p.constants.length} constants`);
+    }
+    console.log();
+    return;
+  }
+  const dotIdx = target.indexOf(".");
+  const pallet = dotIdx === -1 ? target : target.slice(0, dotIdx);
+  const item = dotIdx === -1 ? undefined : target.slice(dotIdx + 1);
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  if (!item) {
+    const meta = await loadMeta(chainName, chainConfig, opts.rpc);
+    const palletNames = getPalletNames(meta);
+    const palletInfo = findPallet(meta, pallet);
+    if (!palletInfo) {
+      throw new Error(suggestMessage("pallet", pallet, palletNames));
+    }
+    if (palletInfo.constants.length === 0) {
+      console.log(`No constants in ${palletInfo.name}.`);
+      return;
+    }
+    printHeading(`${palletInfo.name} Constants`);
+    for (const c of palletInfo.constants) {
+      const typeStr = describeType(meta.lookup, c.typeId);
+      console.log(`  ${CYAN}${c.name}${RESET}${DIM}: ${typeStr}${RESET}`);
+      const summary = firstSentence(c.docs);
+      if (summary) {
+        console.log(`      ${DIM}${summary}${RESET}`);
+      }
+    }
+    console.log();
+    return;
+  }
+  const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+  try {
+    const meta = await getOrFetchMetadata(chainName, clientHandle);
+    const palletNames = getPalletNames(meta);
+    const palletInfo = findPallet(meta, pallet);
+    if (!palletInfo) {
+      throw new Error(suggestMessage("pallet", pallet, palletNames));
+    }
+    const constantItem = palletInfo.constants.find((c) => c.name.toLowerCase() === item.toLowerCase());
+    if (!constantItem) {
+      const constNames = palletInfo.constants.map((c) => c.name);
+      throw new Error(suggestMessage(`constant in ${palletInfo.name}`, item, constNames));
+    }
+    const unsafeApi = clientHandle.client.getUnsafeApi();
+    const runtimeToken = await unsafeApi.runtimeToken;
+    const result = unsafeApi.constants[palletInfo.name][constantItem.name](runtimeToken);
+    const format = opts.output ?? "pretty";
+    printResult(result, format);
+  } finally {
+    clientHandle.destroy();
+  }
 }
 
 // src/commands/focused-inspect.ts
-async function loadMeta(chainName, chainConfig, rpcOverride) {
+async function loadMeta2(chainName, chainConfig, rpcOverride) {
   try {
     return await getOrFetchMetadata(chainName);
   } catch {
@@ -1474,7 +1793,7 @@ async function loadMeta(chainName, chainConfig, rpcOverride) {
     }
   }
 }
-function resolvePallet(meta, palletName) {
+function resolvePallet2(meta, palletName) {
   const palletNames = getPalletNames(meta);
   const pallet = findPallet(meta, palletName);
   if (!pallet) {
@@ -1482,255 +1801,358 @@ function resolvePallet(meta, palletName) {
   }
   return pallet;
 }
-function registerFocusedInspectCommands(cli) {
-  cli.command("call [target]", "List or inspect pallet calls").alias("calls").option("--chain <name>", "Target chain").option("--rpc <url>", "Override RPC endpoint").action(async (target, opts) => {
-    if (!target) {
-      console.log("Usage: dot calls <[Chain.]Pallet[.Call]> [--chain <name>]");
-      console.log("");
-      console.log("Examples:");
-      console.log("  $ dot calls Balances");
-      console.log("  $ dot calls Balances.transfer_allow_death");
-      return;
+async function handleCalls2(target, opts) {
+  if (!target) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta2 = await loadMeta2(chainName2, chainConfig2, opts.rpc);
+    const pallets = listPallets(meta2);
+    const withCalls = pallets.filter((p) => p.calls.length > 0);
+    printHeading(`Pallets with calls on ${chainName2} (${withCalls.length})`);
+    for (const p of withCalls) {
+      printItem(p.name, `${p.calls.length} calls`);
     }
-    const config = await loadConfig();
-    const knownChains = Object.keys(config.chains);
-    const parsed = parseTarget(target, { knownChains, allowPalletOnly: true });
-    const effectiveChain = resolveTargetChain(parsed, opts.chain);
-    const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
-    const meta = await loadMeta(chainName, chainConfig, opts.rpc);
-    const pallet = resolvePallet(meta, parsed.pallet);
-    if (!parsed.item) {
-      if (pallet.calls.length === 0) {
-        console.log(`No calls in ${pallet.name}.`);
-        return;
-      }
-      printHeading(`${pallet.name} Calls`);
-      for (const c of pallet.calls) {
-        const args2 = describeCallArgs(meta, pallet.name, c.name);
-        console.log(`  ${CYAN}${c.name}${RESET}${DIM}${args2}${RESET}`);
-        const summary = firstSentence(c.docs);
-        if (summary) {
-          console.log(`      ${DIM}${summary}${RESET}`);
-        }
-      }
-      console.log();
+    console.log();
+    return;
+  }
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const meta = await loadMeta2(chainName, chainConfig, opts.rpc);
+  const dotIdx = target.indexOf(".");
+  const palletName = dotIdx === -1 ? target : target.slice(0, dotIdx);
+  const itemName = dotIdx === -1 ? undefined : target.slice(dotIdx + 1);
+  const pallet = resolvePallet2(meta, palletName);
+  if (!itemName) {
+    if (pallet.calls.length === 0) {
+      console.log(`No calls in ${pallet.name}.`);
       return;
     }
-    const callItem = pallet.calls.find((c) => c.name.toLowerCase() === parsed.item.toLowerCase());
-    if (!callItem) {
-      const names = pallet.calls.map((c) => c.name);
-      throw new Error(suggestMessage(`call in ${pallet.name}`, parsed.item, names));
+    printHeading(`${pallet.name} Calls`);
+    for (const c of pallet.calls) {
+      const args2 = describeCallArgs(meta, pallet.name, c.name);
+      console.log(`  ${CYAN}${c.name}${RESET}${DIM}${args2}${RESET}`);
+      const summary = firstSentence(c.docs);
+      if (summary) {
+        console.log(`      ${DIM}${summary}${RESET}`);
+      }
     }
-    printHeading(`${pallet.name}.${callItem.name} (Call)`);
-    const args = describeCallArgs(meta, pallet.name, callItem.name);
-    console.log(`  ${BOLD}Args:${RESET} ${args}`);
-    if (callItem.docs.length) {
-      console.log();
-      printDocs(callItem.docs);
+    console.log();
+    return;
+  }
+  const callItem = pallet.calls.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
+  if (!callItem) {
+    const names = pallet.calls.map((c) => c.name);
+    throw new Error(suggestMessage(`call in ${pallet.name}`, itemName, names));
+  }
+  printHeading(`${pallet.name}.${callItem.name} (Call)`);
+  const args = describeCallArgs(meta, pallet.name, callItem.name);
+  console.log(`  ${BOLD}Args:${RESET} ${args}`);
+  if (callItem.docs.length) {
+    console.log();
+    printDocs(callItem.docs);
+  }
+  console.log();
+}
+async function handleEvents2(target, opts) {
+  if (!target) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta2 = await loadMeta2(chainName2, chainConfig2, opts.rpc);
+    const pallets = listPallets(meta2);
+    const withEvents = pallets.filter((p) => p.events.length > 0);
+    printHeading(`Pallets with events on ${chainName2} (${withEvents.length})`);
+    for (const p of withEvents) {
+      printItem(p.name, `${p.events.length} events`);
     }
     console.log();
-  });
-  cli.command("event [target]", "List or inspect pallet events").alias("events").option("--chain <name>", "Target chain").option("--rpc <url>", "Override RPC endpoint").action(async (target, opts) => {
-    if (!target) {
-      console.log("Usage: dot events <[Chain.]Pallet[.Event]> [--chain <name>]");
-      console.log("");
-      console.log("Examples:");
-      console.log("  $ dot events Balances");
-      console.log("  $ dot events Balances.Transfer");
+    return;
+  }
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const meta = await loadMeta2(chainName, chainConfig, opts.rpc);
+  const dotIdx = target.indexOf(".");
+  const palletName = dotIdx === -1 ? target : target.slice(0, dotIdx);
+  const itemName = dotIdx === -1 ? undefined : target.slice(dotIdx + 1);
+  const pallet = resolvePallet2(meta, palletName);
+  if (!itemName) {
+    if (pallet.events.length === 0) {
+      console.log(`No events in ${pallet.name}.`);
       return;
     }
-    const config = await loadConfig();
-    const knownChains = Object.keys(config.chains);
-    const parsed = parseTarget(target, { knownChains, allowPalletOnly: true });
-    const effectiveChain = resolveTargetChain(parsed, opts.chain);
-    const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
-    const meta = await loadMeta(chainName, chainConfig, opts.rpc);
-    const pallet = resolvePallet(meta, parsed.pallet);
-    if (!parsed.item) {
-      if (pallet.events.length === 0) {
-        console.log(`No events in ${pallet.name}.`);
-        return;
+    printHeading(`${pallet.name} Events`);
+    for (const e of pallet.events) {
+      const fields2 = describeEventFields(meta, pallet.name, e.name);
+      console.log(`  ${CYAN}${e.name}${RESET}${DIM}${fields2}${RESET}`);
+      const summary = firstSentence(e.docs);
+      if (summary) {
+        console.log(`      ${DIM}${summary}${RESET}`);
       }
-      printHeading(`${pallet.name} Events`);
-      for (const e of pallet.events) {
-        const fields2 = describeEventFields(meta, pallet.name, e.name);
-        console.log(`  ${CYAN}${e.name}${RESET}${DIM}${fields2}${RESET}`);
-        const summary = firstSentence(e.docs);
-        if (summary) {
-          console.log(`      ${DIM}${summary}${RESET}`);
-        }
-      }
-      console.log();
-      return;
-    }
-    const eventItem = pallet.events.find((e) => e.name.toLowerCase() === parsed.item.toLowerCase());
-    if (!eventItem) {
-      const names = pallet.events.map((e) => e.name);
-      throw new Error(suggestMessage(`event in ${pallet.name}`, parsed.item, names));
     }
-    printHeading(`${pallet.name}.${eventItem.name} (Event)`);
-    const fields = describeEventFields(meta, pallet.name, eventItem.name);
-    console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
-    if (eventItem.docs.length) {
-      console.log();
-      printDocs(eventItem.docs);
+    console.log();
+    return;
+  }
+  const eventItem = pallet.events.find((e) => e.name.toLowerCase() === itemName.toLowerCase());
+  if (!eventItem) {
+    const names = pallet.events.map((e) => e.name);
+    throw new Error(suggestMessage(`event in ${pallet.name}`, itemName, names));
+  }
+  printHeading(`${pallet.name}.${eventItem.name} (Event)`);
+  const fields = describeEventFields(meta, pallet.name, eventItem.name);
+  console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
+  if (eventItem.docs.length) {
+    console.log();
+    printDocs(eventItem.docs);
+  }
+  console.log();
+}
+async function handleErrors2(target, opts) {
+  if (!target) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta2 = await loadMeta2(chainName2, chainConfig2, opts.rpc);
+    const pallets = listPallets(meta2);
+    const withErrors = pallets.filter((p) => p.errors.length > 0);
+    printHeading(`Pallets with errors on ${chainName2} (${withErrors.length})`);
+    for (const p of withErrors) {
+      printItem(p.name, `${p.errors.length} errors`);
     }
     console.log();
-  });
-  cli.command("error [target]", "List or inspect pallet errors").alias("errors").option("--chain <name>", "Target chain").option("--rpc <url>", "Override RPC endpoint").action(async (target, opts) => {
-    if (!target) {
-      console.log("Usage: dot errors <[Chain.]Pallet[.Error]> [--chain <name>]");
-      console.log("");
-      console.log("Examples:");
-      console.log("  $ dot errors Balances");
-      console.log("  $ dot errors Balances.InsufficientBalance");
+    return;
+  }
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const meta = await loadMeta2(chainName, chainConfig, opts.rpc);
+  const dotIdx = target.indexOf(".");
+  const palletName = dotIdx === -1 ? target : target.slice(0, dotIdx);
+  const itemName = dotIdx === -1 ? undefined : target.slice(dotIdx + 1);
+  const pallet = resolvePallet2(meta, palletName);
+  if (!itemName) {
+    if (pallet.errors.length === 0) {
+      console.log(`No errors in ${pallet.name}.`);
       return;
     }
-    const config = await loadConfig();
-    const knownChains = Object.keys(config.chains);
-    const parsed = parseTarget(target, { knownChains, allowPalletOnly: true });
-    const effectiveChain = resolveTargetChain(parsed, opts.chain);
-    const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
-    const meta = await loadMeta(chainName, chainConfig, opts.rpc);
-    const pallet = resolvePallet(meta, parsed.pallet);
-    if (!parsed.item) {
-      if (pallet.errors.length === 0) {
-        console.log(`No errors in ${pallet.name}.`);
-        return;
-      }
-      printHeading(`${pallet.name} Errors`);
-      for (const e of pallet.errors) {
-        console.log(`  ${CYAN}${e.name}${RESET}`);
-        const summary = firstSentence(e.docs);
-        if (summary) {
-          console.log(`      ${DIM}${summary}${RESET}`);
-        }
+    printHeading(`${pallet.name} Errors`);
+    for (const e of pallet.errors) {
+      console.log(`  ${CYAN}${e.name}${RESET}`);
+      const summary = firstSentence(e.docs);
+      if (summary) {
+        console.log(`      ${DIM}${summary}${RESET}`);
       }
-      console.log();
-      return;
-    }
-    const errorItem = pallet.errors.find((e) => e.name.toLowerCase() === parsed.item.toLowerCase());
-    if (!errorItem) {
-      const names = pallet.errors.map((e) => e.name);
-      throw new Error(suggestMessage(`error in ${pallet.name}`, parsed.item, names));
     }
-    printHeading(`${pallet.name}.${errorItem.name} (Error)`);
-    if (errorItem.docs.length) {
-      printDocs(errorItem.docs);
+    console.log();
+    return;
+  }
+  const errorItem = pallet.errors.find((e) => e.name.toLowerCase() === itemName.toLowerCase());
+  if (!errorItem) {
+    const names = pallet.errors.map((e) => e.name);
+    throw new Error(suggestMessage(`error in ${pallet.name}`, itemName, names));
+  }
+  printHeading(`${pallet.name}.${errorItem.name} (Error)`);
+  if (errorItem.docs.length) {
+    printDocs(errorItem.docs);
+  }
+  console.log();
+}
+async function handleStorage2(target, opts) {
+  if (!target) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta2 = await loadMeta2(chainName2, chainConfig2, opts.rpc);
+    const pallets = listPallets(meta2);
+    const withStorage = pallets.filter((p) => p.storage.length > 0);
+    printHeading(`Pallets with storage on ${chainName2} (${withStorage.length})`);
+    for (const p of withStorage) {
+      printItem(p.name, `${p.storage.length} storage`);
     }
     console.log();
-  });
-  cli.command("storage [target]", "List or inspect pallet storage items").option("--chain <name>", "Target chain").option("--rpc <url>", "Override RPC endpoint").action(async (target, opts) => {
-    if (!target) {
-      console.log("Usage: dot storage <[Chain.]Pallet[.Item]> [--chain <name>]");
-      console.log("");
-      console.log("Examples:");
-      console.log("  $ dot storage System");
-      console.log("  $ dot storage System.Account");
+    return;
+  }
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const meta = await loadMeta2(chainName, chainConfig, opts.rpc);
+  const dotIdx = target.indexOf(".");
+  const palletName = dotIdx === -1 ? target : target.slice(0, dotIdx);
+  const itemName = dotIdx === -1 ? undefined : target.slice(dotIdx + 1);
+  const pallet = resolvePallet2(meta, palletName);
+  if (!itemName) {
+    if (pallet.storage.length === 0) {
+      console.log(`No storage items in ${pallet.name}.`);
       return;
     }
-    const config = await loadConfig();
-    const knownChains = Object.keys(config.chains);
-    const parsed = parseTarget(target, { knownChains, allowPalletOnly: true });
-    const effectiveChain = resolveTargetChain(parsed, opts.chain);
-    const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
-    const meta = await loadMeta(chainName, chainConfig, opts.rpc);
-    const pallet = resolvePallet(meta, parsed.pallet);
-    if (!parsed.item) {
-      if (pallet.storage.length === 0) {
-        console.log(`No storage items in ${pallet.name}.`);
+    printHeading(`${pallet.name} Storage`);
+    for (const s of pallet.storage) {
+      const valueType = describeType(meta.lookup, s.valueTypeId);
+      let typeSuffix;
+      if (s.keyTypeId != null) {
+        const keyType = describeType(meta.lookup, s.keyTypeId);
+        typeSuffix = `: ${keyType} → ${valueType}    [map]`;
+      } else {
+        typeSuffix = `: ${valueType}`;
+      }
+      console.log(`  ${CYAN}${s.name}${RESET}${DIM}${typeSuffix}${RESET}`);
+      const summary = firstSentence(s.docs);
+      if (summary) {
+        console.log(`      ${DIM}${summary}${RESET}`);
+      }
+    }
+    console.log();
+    return;
+  }
+  const storageItem = pallet.storage.find((s) => s.name.toLowerCase() === itemName.toLowerCase());
+  if (!storageItem) {
+    const names = pallet.storage.map((s) => s.name);
+    throw new Error(suggestMessage(`storage item in ${pallet.name}`, itemName, names));
+  }
+  printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
+  console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
+  console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
+  if (storageItem.keyTypeId != null) {
+    console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
+  }
+  if (storageItem.docs.length) {
+    console.log();
+    printDocs(storageItem.docs);
+  }
+  console.log();
+}
+async function showItemHelp2(category, target, opts) {
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const meta = await loadMeta2(chainName, chainConfig, opts.rpc);
+  const dotIdx = target.indexOf(".");
+  const palletName = dotIdx === -1 ? target : target.slice(0, dotIdx);
+  const itemName = dotIdx === -1 ? undefined : target.slice(dotIdx + 1);
+  const pallet = resolvePallet2(meta, palletName);
+  if (!itemName) {
+    switch (category) {
+      case "tx":
+        await handleCalls2(target, opts);
+        return;
+      case "query":
+        await handleStorage2(target, opts);
+        return;
+      case "const":
         return;
+      case "events":
+        await handleEvents2(target, opts);
+        return;
+      case "errors":
+        await handleErrors2(target, opts);
+        return;
+    }
+  }
+  switch (category) {
+    case "tx": {
+      const callItem = pallet.calls.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
+      if (!callItem) {
+        const names = pallet.calls.map((c) => c.name);
+        throw new Error(suggestMessage(`call in ${pallet.name}`, itemName, names));
       }
-      printHeading(`${pallet.name} Storage`);
-      for (const s of pallet.storage) {
-        const valueType = describeType(meta.lookup, s.valueTypeId);
-        let typeSuffix;
-        if (s.keyTypeId != null) {
-          const keyType = describeType(meta.lookup, s.keyTypeId);
-          typeSuffix = `: ${keyType} → ${valueType}    [map]`;
-        } else {
-          typeSuffix = `: ${valueType}`;
-        }
-        console.log(`  ${CYAN}${s.name}${RESET}${DIM}${typeSuffix}${RESET}`);
-        const summary = firstSentence(s.docs);
-        if (summary) {
-          console.log(`      ${DIM}${summary}${RESET}`);
-        }
+      printHeading(`${pallet.name}.${callItem.name} (Call)`);
+      const args = describeCallArgs(meta, pallet.name, callItem.name);
+      console.log(`  ${BOLD}Args:${RESET} ${args}`);
+      if (callItem.docs.length) {
+        console.log();
+        printDocs(callItem.docs);
       }
       console.log();
+      console.log(`${BOLD}Usage:${RESET}`);
+      console.log(`  dot tx.${pallet.name}.${callItem.name} --from <account>`);
+      console.log(`  dot tx.${pallet.name}.${callItem.name} --encode`);
+      console.log();
+      console.log(`${BOLD}Options:${RESET}`);
+      console.log(`  --from <name>    Account to sign with`);
+      console.log(`  --dry-run        Estimate fees without submitting`);
+      console.log(`  --encode         Encode call to hex without signing`);
+      console.log(`  --ext <json>     Custom signed extension values as JSON`);
+      console.log();
       return;
     }
-    const storageItem = pallet.storage.find((s) => s.name.toLowerCase() === parsed.item.toLowerCase());
-    if (!storageItem) {
-      const names = pallet.storage.map((s) => s.name);
-      throw new Error(suggestMessage(`storage item in ${pallet.name}`, parsed.item, names));
-    }
-    printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
-    console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
-    console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
-    if (storageItem.keyTypeId != null) {
-      console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
-    }
-    if (storageItem.docs.length) {
+    case "query": {
+      const storageItem = pallet.storage.find((s) => s.name.toLowerCase() === itemName.toLowerCase());
+      if (!storageItem) {
+        const names = pallet.storage.map((s) => s.name);
+        throw new Error(suggestMessage(`storage item in ${pallet.name}`, itemName, names));
+      }
+      printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
+      console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
+      console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
+      if (storageItem.keyTypeId != null) {
+        console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
+      }
+      if (storageItem.docs.length) {
+        console.log();
+        printDocs(storageItem.docs);
+      }
       console.log();
-      printDocs(storageItem.docs);
-    }
-    console.log();
-  });
-  cli.command("pallet [target]", "List all pallets or inspect a specific pallet").alias("pallets").option("--chain <name>", "Target chain").option("--rpc <url>", "Override RPC endpoint").action(async (target, opts) => {
-    const config = await loadConfig();
-    const knownChains = Object.keys(config.chains);
-    let effectiveChain = opts.chain;
-    let palletName;
-    if (target) {
-      const parsed = parseTarget(target, { knownChains, allowPalletOnly: true });
-      effectiveChain = resolveTargetChain(parsed, opts.chain);
-      palletName = parsed.pallet;
+      if (storageItem.keyTypeId != null) {
+        console.log(`${BOLD}Usage:${RESET}`);
+        console.log(`  dot query.${pallet.name}.${storageItem.name} <key>`);
+        console.log(`  dot query.${pallet.name}.${storageItem.name}              # all entries`);
+      } else {
+        console.log(`${BOLD}Usage:${RESET}`);
+        console.log(`  dot query.${pallet.name}.${storageItem.name}`);
+      }
+      console.log();
+      console.log(`${BOLD}Options:${RESET}`);
+      console.log(`  --limit <n>      Max entries for map queries (0 = unlimited, default: 100)`);
+      console.log();
+      return;
     }
-    const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
-    const meta = await loadMeta(chainName, chainConfig, opts.rpc);
-    if (!palletName) {
-      const pallets = listPallets(meta);
-      printHeading(`Pallets on ${chainName} (${pallets.length})`);
-      for (const p of pallets) {
-        const counts2 = [];
-        if (p.storage.length)
-          counts2.push(`${p.storage.length} storage`);
-        if (p.constants.length)
-          counts2.push(`${p.constants.length} constants`);
-        if (p.calls.length)
-          counts2.push(`${p.calls.length} calls`);
-        if (p.events.length)
-          counts2.push(`${p.events.length} events`);
-        if (p.errors.length)
-          counts2.push(`${p.errors.length} errors`);
-        printItem(p.name, counts2.join(", "));
+    case "const": {
+      const constItem = pallet.constants.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
+      if (!constItem) {
+        const names = pallet.constants.map((c) => c.name);
+        throw new Error(suggestMessage(`constant in ${pallet.name}`, itemName, names));
+      }
+      printHeading(`${pallet.name}.${constItem.name} (Constant)`);
+      console.log(`  ${BOLD}Type:${RESET} ${describeType(meta.lookup, constItem.typeId)}`);
+      if (constItem.docs.length) {
+        console.log();
+        printDocs(constItem.docs);
       }
       console.log();
+      console.log(`${BOLD}Usage:${RESET}`);
+      console.log(`  dot const.${pallet.name}.${constItem.name}`);
+      console.log();
       return;
     }
-    const pallet = resolvePallet(meta, palletName);
-    printHeading(`${pallet.name} Pallet`);
-    if (pallet.docs.length) {
-      printDocs(pallet.docs);
+    case "events": {
+      const eventItem = pallet.events.find((e) => e.name.toLowerCase() === itemName.toLowerCase());
+      if (!eventItem) {
+        const names = pallet.events.map((e) => e.name);
+        throw new Error(suggestMessage(`event in ${pallet.name}`, itemName, names));
+      }
+      printHeading(`${pallet.name}.${eventItem.name} (Event)`);
+      const fields = describeEventFields(meta, pallet.name, eventItem.name);
+      console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
+      if (eventItem.docs.length) {
+        console.log();
+        printDocs(eventItem.docs);
+      }
+      console.log();
+      console.log(`${BOLD}Usage:${RESET}`);
+      console.log(`  dot events.${pallet.name}.${eventItem.name}`);
       console.log();
+      return;
     }
-    const counts = [];
-    if (pallet.storage.length)
-      counts.push(`${pallet.storage.length} storage`);
-    if (pallet.constants.length)
-      counts.push(`${pallet.constants.length} constants`);
-    if (pallet.calls.length)
-      counts.push(`${pallet.calls.length} calls`);
-    if (pallet.events.length)
-      counts.push(`${pallet.events.length} events`);
-    if (pallet.errors.length)
-      counts.push(`${pallet.errors.length} errors`);
-    if (counts.length) {
-      console.log(`  ${counts.join(", ")}`);
+    case "errors": {
+      const errorItem = pallet.errors.find((e) => e.name.toLowerCase() === itemName.toLowerCase());
+      if (!errorItem) {
+        const names = pallet.errors.map((e) => e.name);
+        throw new Error(suggestMessage(`error in ${pallet.name}`, itemName, names));
+      }
+      printHeading(`${pallet.name}.${errorItem.name} (Error)`);
+      if (errorItem.docs.length) {
+        printDocs(errorItem.docs);
+      }
+      console.log();
+      console.log(`${BOLD}Usage:${RESET}`);
+      console.log(`  dot errors.${pallet.name}.${errorItem.name}`);
+      console.log();
+      return;
     }
-    console.log();
-  });
+  }
 }
 
 // src/core/hash.ts
@@ -1864,9 +2286,58 @@ function registerHashCommand(cli) {
   });
 }
 
+// src/utils/parse-target.ts
+function parseTarget(input, options) {
+  const parts = input.split(".");
+  if (options?.allowPalletOnly) {
+    switch (parts.length) {
+      case 1:
+        if (!parts[0]) {
+          throw new Error(`Invalid target "${input}". Expected format: Pallet or Pallet.Item (e.g. System or System.Account)`);
+        }
+        return { pallet: parts[0] };
+      case 2:
+        if (!parts[0] || !parts[1]) {
+          throw new Error(`Invalid target "${input}". Expected format: Pallet.Item or Chain.Pallet (e.g. System.Account or kusama.System)`);
+        }
+        if (options.knownChains?.some((c) => c.toLowerCase() === parts[0].toLowerCase())) {
+          return { chain: parts[0], pallet: parts[1] };
+        }
+        return { pallet: parts[0], item: parts[1] };
+      case 3:
+        if (!parts[0] || !parts[1] || !parts[2]) {
+          throw new Error(`Invalid target "${input}". Expected format: Chain.Pallet.Item (e.g. kusama.System.Account)`);
+        }
+        return { chain: parts[0], pallet: parts[1], item: parts[2] };
+      default:
+        throw new Error(`Invalid target "${input}". Expected format: Pallet, Pallet.Item, or Chain.Pallet.Item`);
+    }
+  }
+  switch (parts.length) {
+    case 2:
+      if (!parts[0] || !parts[1]) {
+        throw new Error(`Invalid target "${input}". Expected format: Pallet.Item (e.g. System.Account)`);
+      }
+      return { pallet: parts[0], item: parts[1] };
+    case 3:
+      if (!parts[0] || !parts[1] || !parts[2]) {
+        throw new Error(`Invalid target "${input}". Expected format: Chain.Pallet.Item (e.g. kusama.System.Account)`);
+      }
+      return { chain: parts[0], pallet: parts[1], item: parts[2] };
+    default:
+      throw new Error(`Invalid target "${input}". Expected format: Pallet.Item (e.g. System.Account)`);
+  }
+}
+function resolveTargetChain(target, chainFlag) {
+  if (target.chain && chainFlag) {
+    throw new Error(`Chain specified both as prefix ("${target.chain}") and as --chain flag ("${chainFlag}"). Use one or the other.`);
+  }
+  return target.chain ?? chainFlag;
+}
+
 // src/commands/inspect.ts
 function registerInspectCommand(cli) {
-  cli.command("inspect [target]", "Inspect chain metadata (pallets, storage, constants, calls, events, errors)").option("--chain <name>", "Target chain").option("--rpc <url>", "Override RPC endpoint").action(async (target, opts) => {
+  cli.command("inspect [target]", "Inspect chain metadata (pallets, storage, constants, calls, events, errors)").alias("explore").option("--chain <name>", "Target chain").option("--rpc <url>", "Override RPC endpoint").action(async (target, opts) => {
     const config = await loadConfig();
     const knownChains = Object.keys(config.chains);
     let effectiveChain = opts.chain;
@@ -2386,77 +2857,101 @@ var PAPI_BUILTIN_EXTENSIONS = new Set([
 var NO_DEFAULT = Symbol("no-default");
 
 // src/commands/query.ts
-var DEFAULT_LIMIT = 100;
-function registerQueryCommand(cli) {
-  cli.command("query [target] [...keys]", "Query on-chain storage (e.g. System.Number, System.Account <addr>)").option("--limit <n>", "Max entries to return for map queries (0 = unlimited)", {
-    default: DEFAULT_LIMIT
-  }).action(async (target, keys, opts) => {
-    if (!target) {
-      console.log("Usage: dot query <[Chain.]Pallet.Item> [...keys] [--chain <name>] [--output json]");
-      console.log("");
-      console.log("Examples:");
-      console.log("  $ dot query System.Number                         # plain storage value");
-      console.log("  $ dot query System.Account 5Grw...                # single map entry");
-      console.log("  $ dot query System.Account                        # all entries (limit 100)");
-      console.log("  $ dot query System.Account --limit 10             # first 10 entries");
-      console.log("  $ dot query System.Account --limit 0              # all entries (no limit)");
-      console.log("  $ dot query Assets.Metadata 42 --chain asset-hub");
-      console.log("  $ dot query kusama.System.Account 5Grw...         # chain prefix");
+async function handleQuery(target, keys, opts) {
+  if (!target) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
+    const pallets = listPallets(meta);
+    const withStorage = pallets.filter((p) => p.storage.length > 0);
+    printHeading(`Pallets with storage on ${chainName2} (${withStorage.length})`);
+    for (const p of withStorage) {
+      printItem(p.name, `${p.storage.length} storage items`);
+    }
+    console.log();
+    return;
+  }
+  const dotIdx = target.indexOf(".");
+  if (dotIdx === -1) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
+    const pallet2 = resolvePallet(meta, palletName(target));
+    if (pallet2.storage.length === 0) {
+      console.log(`No storage items in ${pallet2.name}.`);
       return;
     }
-    const config = await loadConfig();
-    const knownChains = Object.keys(config.chains);
-    const parsed = parseTarget(target, { knownChains });
-    const effectiveChain = resolveTargetChain(parsed, opts.chain);
-    const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
-    const pallet = parsed.pallet;
-    const item = parsed.item;
-    const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
-    try {
-      const meta = await getOrFetchMetadata(chainName, clientHandle);
-      const palletNames = getPalletNames(meta);
-      const palletInfo = findPallet(meta, pallet);
-      if (!palletInfo) {
-        throw new Error(suggestMessage("pallet", pallet, palletNames));
+    printHeading(`${pallet2.name} Storage`);
+    for (const s of pallet2.storage) {
+      const valueType = describeType(meta.lookup, s.valueTypeId);
+      let typeSuffix;
+      if (s.keyTypeId != null) {
+        const keyType = describeType(meta.lookup, s.keyTypeId);
+        typeSuffix = `: ${keyType} → ${valueType}    [map]`;
+      } else {
+        typeSuffix = `: ${valueType}`;
       }
-      const storageItem = palletInfo.storage.find((s) => s.name.toLowerCase() === item.toLowerCase());
-      if (!storageItem) {
-        const storageNames = palletInfo.storage.map((s) => s.name);
-        throw new Error(suggestMessage(`storage item in ${palletInfo.name}`, item, storageNames));
-      }
-      const unsafeApi = clientHandle.client.getUnsafeApi();
-      const storageApi = unsafeApi.query[palletInfo.name][storageItem.name];
-      const parsedKeys = parseStorageKeys(meta, palletInfo.name, storageItem, keys);
-      const format = opts.output ?? "pretty";
-      if (storageItem.type === "map" && parsedKeys.length === 0) {
-        const entries = await storageApi.getEntries();
-        const limit = Number(opts.limit);
-        const truncated = limit > 0 && entries.length > limit;
-        const display = truncated ? entries.slice(0, limit) : entries;
-        printResult(display.map((e) => ({
-          keys: e.keyArgs,
-          value: e.value
-        })), format);
-        if (truncated) {
-          console.error(`
+      console.log(`  ${CYAN}${s.name}${RESET}${DIM}${typeSuffix}${RESET}`);
+      const summary = firstSentence(s.docs);
+      if (summary) {
+        console.log(`      ${DIM}${summary}${RESET}`);
+      }
+    }
+    console.log();
+    return;
+  }
+  const pallet = target.slice(0, dotIdx);
+  const item = target.slice(dotIdx + 1);
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+  try {
+    const meta = await getOrFetchMetadata(chainName, clientHandle);
+    const palletNames = getPalletNames(meta);
+    const palletInfo = findPallet(meta, pallet);
+    if (!palletInfo) {
+      throw new Error(suggestMessage("pallet", pallet, palletNames));
+    }
+    const storageItem = palletInfo.storage.find((s) => s.name.toLowerCase() === item.toLowerCase());
+    if (!storageItem) {
+      const storageNames = palletInfo.storage.map((s) => s.name);
+      throw new Error(suggestMessage(`storage item in ${palletInfo.name}`, item, storageNames));
+    }
+    const unsafeApi = clientHandle.client.getUnsafeApi();
+    const storageApi = unsafeApi.query[palletInfo.name][storageItem.name];
+    const parsedKeys = parseStorageKeys(meta, palletInfo.name, storageItem, keys);
+    const format = opts.output ?? "pretty";
+    if (storageItem.type === "map" && parsedKeys.length === 0) {
+      const entries = await storageApi.getEntries();
+      const limit = Number(opts.limit);
+      const truncated = limit > 0 && entries.length > limit;
+      const display = truncated ? entries.slice(0, limit) : entries;
+      printResult(display.map((e) => ({
+        keys: e.keyArgs,
+        value: e.value
+      })), format);
+      if (truncated) {
+        console.error(`
 ${DIM}Showing ${limit} of ${entries.length} entries. Use --limit 0 for all.${RESET}`);
-        }
-      } else {
-        const result = await storageApi.getValue(...parsedKeys);
-        printResult(result, format);
       }
-    } finally {
-      clientHandle.destroy();
+    } else {
+      const result = await storageApi.getValue(...parsedKeys);
+      printResult(result, format);
     }
-  });
+  } finally {
+    clientHandle.destroy();
+  }
+}
+function palletName(name) {
+  return name;
 }
-function parseStorageKeys(meta, palletName, storageItem, args) {
+function parseStorageKeys(meta, palletName2, storageItem, args) {
   if (storageItem.type === "plain" || storageItem.keyTypeId == null) {
     return args.map(parseValue);
   }
   if (args.length === 0)
     return [];
-  const storageEntry = meta.builder.buildStorage(palletName, storageItem.name);
+  const storageEntry = meta.builder.buildStorage(palletName2, storageItem.name);
   const len = storageEntry.len;
   const keyEntry = meta.lookup(storageItem.keyTypeId);
   if (len === 1) {
@@ -2464,11 +2959,11 @@ function parseStorageKeys(meta, palletName, storageItem, args) {
       return [parseTypedArg(meta, keyEntry, args[0])];
     }
     if (keyEntry.type === "struct") {
-      const label = `${palletName}.${storageItem.name} key`;
+      const label = `${palletName2}.${storageItem.name} key`;
       return [parseStructArgs(meta, keyEntry.value, args, label)];
     }
     const typeDesc = describeType(meta.lookup, storageItem.keyTypeId);
-    throw new Error(`${palletName}.${storageItem.name} key expects ${typeDesc}
+    throw new Error(`${palletName2}.${storageItem.name} key expects ${typeDesc}
 ` + `  Pass 1 argument. Got ${args.length}.`);
   }
   if (args.length !== len) {
@@ -2478,7 +2973,7 @@ function parseStorageKeys(meta, palletName, storageItem, args) {
     } else {
       typeDesc = describeType(meta.lookup, storageItem.keyTypeId);
     }
-    throw new Error(`${palletName}.${storageItem.name} expects ${len} key arg(s): (${typeDesc}). Got ${args.length}.`);
+    throw new Error(`${palletName2}.${storageItem.name} expects ${len} key arg(s): (${typeDesc}). Got ${args.length}.`);
   }
   if (keyEntry.type === "tuple") {
     const entries = keyEntry.value;
@@ -2490,156 +2985,180 @@ function parseStorageKeys(meta, palletName, storageItem, args) {
 // src/commands/tx.ts
 import { getViewBuilder as getViewBuilder2 } from "@polkadot-api/view-builder";
 import { Binary as Binary3 } from "polkadot-api";
-function registerTxCommand(cli) {
-  cli.command("tx [target] [...args]", "Submit an extrinsic (e.g. Balances.transferKeepAlive <dest> <amount>)").option("--from <name>", "Account to sign with (required)").option("--dry-run", "Estimate fees without submitting").option("--encode", "Encode call to hex without signing or submitting").option("--ext <json>", `Custom signed extension values as JSON, e.g. '{"ExtName":{"value":...}}'`).action(async (target, args, opts) => {
-    if (!target) {
-      console.log("Usage: dot tx <[Chain.]Pallet.Call|0xCallHex> [...args] --from <account> [--dry-run] [--encode]");
-      console.log("");
-      console.log("Examples:");
-      console.log("  $ dot tx Balances.transferKeepAlive 5FHn... 1000000000000 --from alice");
-      console.log("  $ dot tx System.remark 0xdeadbeef --from alice --dry-run");
-      console.log("  $ dot tx 0x0001076465616462656566 --from alice");
-      console.log("  $ dot tx Assets.force_create 4 owner true 10 --encode --chain people");
-      console.log("  $ dot tx kusama.Balances.transferKeepAlive 5FHn... 1000000000000 --from alice");
-      return;
+async function handleTx(target, args, opts) {
+  if (!target) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
+    const pallets = listPallets(meta);
+    const withCalls = pallets.filter((p) => p.calls.length > 0);
+    printHeading(`Pallets with calls on ${chainName2} (${withCalls.length})`);
+    for (const p of withCalls) {
+      printItem(p.name, `${p.calls.length} calls`);
     }
-    if (!opts.from && !opts.encode) {
-      throw new Error("--from is required (or use --encode to output hex without signing)");
+    console.log();
+    return;
+  }
+  const isRawCall = /^0x[0-9a-fA-F]+$/.test(target);
+  if (!isRawCall && target.indexOf(".") === -1) {
+    const config2 = await loadConfig();
+    const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
+    const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
+    const pallet2 = resolvePallet(meta, target);
+    if (pallet2.calls.length === 0) {
+      console.log(`No calls in ${pallet2.name}.`);
+      return;
     }
-    if (opts.encode && opts.dryRun) {
-      throw new Error("--encode and --dry-run are mutually exclusive");
+    printHeading(`${pallet2.name} Calls`);
+    for (const c of pallet2.calls) {
+      const callArgs = describeCallArgs(meta, pallet2.name, c.name);
+      console.log(`  ${CYAN}${c.name}${RESET}${DIM}${callArgs}${RESET}`);
+      const summary = firstSentence(c.docs);
+      if (summary) {
+        console.log(`      ${DIM}${summary}${RESET}`);
+      }
     }
-    const isRawCall = /^0x[0-9a-fA-F]+$/.test(target);
-    if (opts.encode && isRawCall) {
-      throw new Error("--encode cannot be used with raw call hex (already encoded)");
+    console.log();
+    return;
+  }
+  if (!opts.from && !opts.encode) {
+    if (isRawCall) {
+      throw new Error("--from is required (or use --encode to output hex without signing)");
     }
-    const config = await loadConfig();
-    let effectiveChain = opts.chain;
-    let parsedTarget;
-    if (!isRawCall) {
-      const knownChains = Object.keys(config.chains);
-      parsedTarget = parseTarget(target, { knownChains });
-      effectiveChain = resolveTargetChain(parsedTarget, opts.chain);
+    await showItemHelp("tx", target, opts);
+    return;
+  }
+  if (opts.encode && opts.dryRun) {
+    throw new Error("--encode and --dry-run are mutually exclusive");
+  }
+  if (opts.encode && isRawCall) {
+    throw new Error("--encode cannot be used with raw call hex (already encoded)");
+  }
+  const config = await loadConfig();
+  const effectiveChain = opts.chain;
+  let pallet;
+  let callName;
+  if (!isRawCall) {
+    const dotIdx = target.indexOf(".");
+    pallet = target.slice(0, dotIdx);
+    callName = target.slice(dotIdx + 1);
+  }
+  const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
+  const signer = opts.encode ? undefined : await resolveAccountSigner(opts.from);
+  let clientHandle;
+  if (!opts.encode) {
+    clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+  }
+  try {
+    let meta;
+    if (clientHandle) {
+      meta = await getOrFetchMetadata(chainName, clientHandle);
+    } else {
+      try {
+        meta = await getOrFetchMetadata(chainName);
+      } catch {
+        clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+        meta = await getOrFetchMetadata(chainName, clientHandle);
+      }
     }
-    const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
-    const signer = opts.encode ? undefined : await resolveAccountSigner(opts.from);
-    let clientHandle;
+    let unsafeApi;
+    let txOptions;
     if (!opts.encode) {
-      clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+      const userExtOverrides = parseExtOption(opts.ext);
+      const customSignedExtensions = buildCustomSignedExtensions(meta, userExtOverrides);
+      txOptions = Object.keys(customSignedExtensions).length > 0 ? { customSignedExtensions } : undefined;
+      unsafeApi = clientHandle?.client.getUnsafeApi();
     }
-    try {
-      let meta;
-      if (clientHandle) {
-        meta = await getOrFetchMetadata(chainName, clientHandle);
-      } else {
-        try {
-          meta = await getOrFetchMetadata(chainName);
-        } catch {
-          clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
-          meta = await getOrFetchMetadata(chainName, clientHandle);
-        }
-      }
-      let unsafeApi;
-      let txOptions;
-      if (!opts.encode) {
-        const userExtOverrides = parseExtOption(opts.ext);
-        const customSignedExtensions = buildCustomSignedExtensions(meta, userExtOverrides);
-        txOptions = Object.keys(customSignedExtensions).length > 0 ? { customSignedExtensions } : undefined;
-        unsafeApi = clientHandle?.client.getUnsafeApi();
-      }
-      let tx;
-      let callHex;
-      if (isRawCall) {
-        if (args.length > 0) {
-          throw new Error(`Extra arguments are not allowed when submitting a raw call hex.
+    let tx;
+    let callHex;
+    if (isRawCall) {
+      if (args.length > 0) {
+        throw new Error(`Extra arguments are not allowed when submitting a raw call hex.
 ` + "Usage: dot tx 0x<call_hex> --from <account>");
-        }
-        const callBinary = Binary3.fromHex(target);
-        tx = await unsafeApi.txFromCallData(callBinary);
-        callHex = target;
-      } else {
-        const pallet = parsedTarget.pallet;
-        const callName = parsedTarget.item;
-        const palletNames = getPalletNames(meta);
-        const palletInfo = findPallet(meta, pallet);
-        if (!palletInfo) {
-          throw new Error(suggestMessage("pallet", pallet, palletNames));
-        }
-        const callInfo = palletInfo.calls.find((c) => c.name.toLowerCase() === callName.toLowerCase());
-        if (!callInfo) {
-          const callNames = palletInfo.calls.map((c) => c.name);
-          throw new Error(suggestMessage(`call in ${palletInfo.name}`, callName, callNames));
-        }
-        const callData = parseCallArgs(meta, palletInfo.name, callInfo.name, args);
-        if (opts.encode) {
-          const { codec, location } = meta.builder.buildCall(palletInfo.name, callInfo.name);
-          const encodedArgs = codec.enc(callData);
-          const fullCall = new Uint8Array([location[0], location[1], ...encodedArgs]);
-          console.log(Binary3.fromBytes(fullCall).asHex());
-          return;
-        }
-        tx = unsafeApi.tx[palletInfo.name][callInfo.name](callData);
-        const encodedCall = await tx.getEncodedData();
-        callHex = encodedCall.asHex();
-      }
-      const decodedStr = decodeCall(meta, callHex);
-      if (opts.dryRun) {
-        const signerAddress = toSs58(signer.publicKey);
-        console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
-        console.log(`  ${BOLD}From:${RESET}   ${opts.from} (${signerAddress})`);
-        console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
-        console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
-        try {
-          const fees = await tx.getEstimatedFees(signer?.publicKey, txOptions);
-          console.log(`  ${BOLD}Estimated fees:${RESET} ${fees}`);
-        } catch (err) {
-          console.log(`  ${BOLD}Estimated fees:${RESET} ${YELLOW}unable to estimate${RESET}`);
-          console.log(`  ${DIM}${err.message ?? err}${RESET}`);
-        }
+      }
+      const callBinary = Binary3.fromHex(target);
+      tx = await unsafeApi.txFromCallData(callBinary);
+      callHex = target;
+    } else {
+      const palletNames = getPalletNames(meta);
+      const palletInfo = findPallet(meta, pallet);
+      if (!palletInfo) {
+        throw new Error(suggestMessage("pallet", pallet, palletNames));
+      }
+      const callInfo = palletInfo.calls.find((c) => c.name.toLowerCase() === callName.toLowerCase());
+      if (!callInfo) {
+        const callNames = palletInfo.calls.map((c) => c.name);
+        throw new Error(suggestMessage(`call in ${palletInfo.name}`, callName, callNames));
+      }
+      const callData = parseCallArgs(meta, palletInfo.name, callInfo.name, args);
+      if (opts.encode) {
+        const { codec, location } = meta.builder.buildCall(palletInfo.name, callInfo.name);
+        const encodedArgs = codec.enc(callData);
+        const fullCall = new Uint8Array([location[0], location[1], ...encodedArgs]);
+        console.log(Binary3.fromBytes(fullCall).asHex());
         return;
       }
-      const result = await watchTransaction(tx.signSubmitAndWatch(signer, txOptions));
-      console.log();
+      tx = unsafeApi.tx[palletInfo.name][callInfo.name](callData);
+      const encodedCall = await tx.getEncodedData();
+      callHex = encodedCall.asHex();
+    }
+    const decodedStr = decodeCall(meta, callHex);
+    if (opts.dryRun) {
+      const signerAddress = toSs58(signer.publicKey);
       console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
+      console.log(`  ${BOLD}From:${RESET}   ${opts.from} (${signerAddress})`);
       console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
       console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
-      console.log(`  ${BOLD}Tx:${RESET}     ${result.txHash}`);
-      let dispatchErrorMsg;
-      if (result.ok) {
-        console.log(`  ${BOLD}Status:${RESET} ${GREEN}ok${RESET}`);
-      } else {
-        dispatchErrorMsg = formatDispatchError(result.dispatchError);
-        console.log(`  ${BOLD}Status:${RESET} ${RED}dispatch error${RESET}`);
-        console.log(`  ${BOLD}Error:${RESET}  ${dispatchErrorMsg}`);
+      try {
+        const fees = await tx.getEstimatedFees(signer?.publicKey, txOptions);
+        console.log(`  ${BOLD}Estimated fees:${RESET} ${fees}`);
+      } catch (err) {
+        console.log(`  ${BOLD}Estimated fees:${RESET} ${YELLOW}unable to estimate${RESET}`);
+        console.log(`  ${DIM}${err.message ?? err}${RESET}`);
       }
-      if (result.events && result.events.length > 0) {
-        console.log(`  ${BOLD}Events:${RESET}`);
-        for (const event of result.events) {
-          const name = `${CYAN}${event.type}${RESET}.${CYAN}${event.value?.type ?? ""}${RESET}`;
-          const payload = event.value?.value;
-          if (payload && typeof payload === "object") {
-            const fields = Object.entries(payload).map(([k, v]) => `${k}: ${formatEventValue(v)}`).join(", ");
-            console.log(`    ${name} { ${fields} }`);
-          } else {
-            console.log(`    ${name}`);
-          }
+      return;
+    }
+    const result = await watchTransaction(tx.signSubmitAndWatch(signer, txOptions));
+    console.log();
+    console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
+    console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
+    console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
+    console.log(`  ${BOLD}Tx:${RESET}     ${result.txHash}`);
+    let dispatchErrorMsg;
+    if (result.ok) {
+      console.log(`  ${BOLD}Status:${RESET} ${GREEN}ok${RESET}`);
+    } else {
+      dispatchErrorMsg = formatDispatchError(result.dispatchError);
+      console.log(`  ${BOLD}Status:${RESET} ${RED}dispatch error${RESET}`);
+      console.log(`  ${BOLD}Error:${RESET}  ${dispatchErrorMsg}`);
+    }
+    if (result.events && result.events.length > 0) {
+      console.log(`  ${BOLD}Events:${RESET}`);
+      for (const event of result.events) {
+        const name = `${CYAN}${event.type}${RESET}.${CYAN}${event.value?.type ?? ""}${RESET}`;
+        const payload = event.value?.value;
+        if (payload && typeof payload === "object") {
+          const fields = Object.entries(payload).map(([k, v]) => `${k}: ${formatEventValue(v)}`).join(", ");
+          console.log(`    ${name} { ${fields} }`);
+        } else {
+          console.log(`    ${name}`);
         }
       }
-      const rpcUrl = primaryRpc(opts.rpc ?? chainConfig.rpc);
-      if (rpcUrl) {
-        const blockHash = result.block.hash;
-        console.log(`  ${BOLD}Explorer:${RESET}`);
-        console.log(`    ${DIM}PolkadotJS${RESET}  ${pjsAppsLink(rpcUrl, blockHash)}`);
-        console.log(`    ${DIM}PAPI${RESET}        ${papiLink(rpcUrl, blockHash)}`);
-      }
-      console.log();
-      if (!result.ok) {
-        throw new CliError(`Transaction dispatch error: ${dispatchErrorMsg}`);
-      }
-    } finally {
-      clientHandle?.destroy();
     }
-  });
+    const rpcUrl = primaryRpc(opts.rpc ?? chainConfig.rpc);
+    if (rpcUrl) {
+      const blockHash = result.block.hash;
+      console.log(`  ${BOLD}Explorer:${RESET}`);
+      console.log(`    ${DIM}PolkadotJS${RESET}  ${pjsAppsLink(rpcUrl, blockHash)}`);
+      console.log(`    ${DIM}PAPI${RESET}        ${papiLink(rpcUrl, blockHash)}`);
+    }
+    console.log();
+    if (!result.ok) {
+      throw new CliError(`Transaction dispatch error: ${dispatchErrorMsg}`);
+    }
+  } finally {
+    clientHandle?.destroy();
+  }
 }
 function formatDispatchError(err) {
   if (err.type === "Module" && err.value && typeof err.value === "object") {
@@ -2662,10 +3181,10 @@ function decodeCall(meta, callHex) {
   try {
     const viewBuilder = getViewBuilder2(meta.lookup);
     const decoded = viewBuilder.callDecoder(callHex);
-    const palletName = decoded.pallet.value.name;
+    const palletName2 = decoded.pallet.value.name;
     const callName = decoded.call.value.name;
     const argsStr = formatDecodedArgs(decoded.args.value);
-    return `${palletName}.${callName}${argsStr}`;
+    return `${palletName2}.${callName}${argsStr}`;
   } catch {}
   try {
     return decodeCallFallback(meta, callHex);
@@ -2679,15 +3198,15 @@ function decodeCallFallback(meta, callHex) {
     throw new Error("No RuntimeCall type ID");
   const codec = meta.builder.buildDefinition(callTypeId);
   const decoded = codec.dec(Binary3.fromHex(callHex).asBytes());
-  const palletName = decoded.type;
+  const palletName2 = decoded.type;
   const call = decoded.value;
   const callName = call.type;
   const args = call.value;
   if (args === undefined || args === null) {
-    return `${palletName}.${callName}`;
+    return `${palletName2}.${callName}`;
   }
   const argsStr = formatRawDecoded(args);
-  return `${palletName}.${callName} ${argsStr}`;
+  return `${palletName2}.${callName} ${argsStr}`;
 }
 function formatRawDecoded(value) {
   if (value === undefined || value === null)
@@ -2820,8 +3339,8 @@ function formatEventValue(v) {
   }
   return JSON.stringify(v, (_k, val) => typeof val === "bigint" ? val.toString() : val);
 }
-function parseCallArgs(meta, palletName, callName, args) {
-  const palletMeta = meta.unified.pallets.find((p) => p.name === palletName);
+function parseCallArgs(meta, palletName2, callName, args) {
+  const palletMeta = meta.unified.pallets.find((p) => p.name === palletName2);
   if (!palletMeta?.calls)
     return;
   const callsEntry = meta.lookup(palletMeta.calls.type);
@@ -2832,22 +3351,22 @@ function parseCallArgs(meta, palletName, callName, args) {
     return;
   if (variant.type === "void") {
     if (args.length > 0) {
-      throw new Error(`${palletName}.${callName} takes no arguments, but ${args.length} provided.`);
+      throw new Error(`${palletName2}.${callName} takes no arguments, but ${args.length} provided.`);
     }
     return;
   }
   if (variant.type === "struct") {
-    return parseStructArgs2(meta, variant.value, args, `${palletName}.${callName}`);
+    return parseStructArgs2(meta, variant.value, args, `${palletName2}.${callName}`);
   }
   if (variant.type === "lookupEntry") {
     const inner = variant.value;
     if (inner.type === "struct") {
-      return parseStructArgs2(meta, inner.value, args, `${palletName}.${callName}`);
+      return parseStructArgs2(meta, inner.value, args, `${palletName2}.${callName}`);
     }
     if (inner.type === "void")
       return;
     if (args.length !== 1) {
-      throw new Error(`${palletName}.${callName} takes 1 argument (${describeType(meta.lookup, inner.id)}), but ${args.length} provided.`);
+      throw new Error(`${palletName2}.${callName} takes 1 argument (${describeType(meta.lookup, inner.id)}), but ${args.length} provided.`);
     }
     try {
       return parseTypedArg2(meta, inner, args[0]);
@@ -2859,7 +3378,7 @@ function parseCallArgs(meta, palletName, callName, args) {
   if (variant.type === "tuple") {
     const entries = variant.value;
     if (args.length !== entries.length) {
-      throw new Error(`${palletName}.${callName} takes ${entries.length} arguments, but ${args.length} provided.`);
+      throw new Error(`${palletName2}.${callName} takes ${entries.length} arguments, but ${args.length} provided.`);
     }
     return entries.map((entry, i) => {
       try {
@@ -3252,10 +3771,46 @@ function watchTransaction(observable) {
   });
 }
 
+// src/config/store.ts
+import { access as access3, mkdir as mkdir3, readFile as readFile3, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+var DOT_DIR2 = join3(homedir2(), ".polkadot");
+var CONFIG_PATH2 = join3(DOT_DIR2, "config.json");
+var CHAINS_DIR2 = join3(DOT_DIR2, "chains");
+async function ensureDir3(dir) {
+  await mkdir3(dir, { recursive: true });
+}
+async function fileExists3(path) {
+  try {
+    await access3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadConfig2() {
+  await ensureDir3(DOT_DIR2);
+  if (await fileExists3(CONFIG_PATH2)) {
+    const saved = JSON.parse(await readFile3(CONFIG_PATH2, "utf-8"));
+    return {
+      ...saved,
+      chains: { ...DEFAULT_CONFIG.chains, ...saved.chains }
+    };
+  }
+  await saveConfig2(DEFAULT_CONFIG);
+  return DEFAULT_CONFIG;
+}
+async function saveConfig2(config) {
+  await ensureDir3(DOT_DIR2);
+  await writeFile3(CONFIG_PATH2, `${JSON.stringify(config, null, 2)}
+`);
+}
+
 // src/core/update-notifier.ts
 import { readFileSync } from "node:fs";
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join4 } from "node:path";
 var CACHE_FILE = "update-check.json";
 var STALE_MS = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 5000;
@@ -3311,7 +3866,7 @@ function buildNotificationBox(current, latest) {
 `);
 }
 function getCachePath() {
-  return join3(getConfigDir(), CACHE_FILE);
+  return join4(getConfigDir(), CACHE_FILE);
 }
 function readCache() {
   try {
@@ -3323,8 +3878,8 @@ function readCache() {
 }
 async function writeCache(cache) {
   try {
-    await mkdir3(getConfigDir(), { recursive: true });
-    await writeFile3(getCachePath(), `${JSON.stringify(cache)}
+    await mkdir4(getConfigDir(), { recursive: true });
+    await writeFile4(getCachePath(), `${JSON.stringify(cache)}
 `);
   } catch {}
 }
@@ -3379,6 +3934,67 @@ class CliError2 extends Error {
   }
 }
 
+// src/utils/parse-dot-path.ts
+var CATEGORY_ALIASES = {
+  query: "query",
+  tx: "tx",
+  const: "const",
+  consts: "const",
+  constants: "const",
+  events: "events",
+  event: "events",
+  errors: "errors",
+  error: "errors"
+};
+function matchCategory(segment) {
+  return CATEGORY_ALIASES[segment.toLowerCase()];
+}
+function matchChain(segment, knownChains) {
+  return knownChains.some((c) => c.toLowerCase() === segment.toLowerCase());
+}
+function parseDotPath(input, knownChains = []) {
+  const parts = input.split(".");
+  switch (parts.length) {
+    case 1: {
+      const cat = matchCategory(parts[0]);
+      if (cat)
+        return { category: cat };
+      throw new Error(`Unknown command "${parts[0]}". Expected a category (query, tx, const, events, errors) or a named command.`);
+    }
+    case 2: {
+      const cat = matchCategory(parts[0]);
+      if (cat) {
+        return { category: cat, pallet: parts[1] };
+      }
+      const cat2 = matchCategory(parts[1]);
+      if (cat2 && matchChain(parts[0], knownChains)) {
+        return { chain: parts[0], category: cat2 };
+      }
+      throw new Error(`Unknown command "${input}". Expected format: category.Pallet or Chain.category (e.g. query.System or polkadot.query)`);
+    }
+    case 3: {
+      const cat = matchCategory(parts[0]);
+      if (cat) {
+        return { category: cat, pallet: parts[1], item: parts[2] };
+      }
+      const cat2 = matchCategory(parts[1]);
+      if (cat2 && matchChain(parts[0], knownChains)) {
+        return { chain: parts[0], category: cat2, pallet: parts[2] };
+      }
+      throw new Error(`Unknown command "${input}". Expected format: category.Pallet.Item or Chain.category.Pallet`);
+    }
+    case 4: {
+      const cat = matchCategory(parts[1]);
+      if (cat && matchChain(parts[0], knownChains)) {
+        return { chain: parts[0], category: cat, pallet: parts[2], item: parts[3] };
+      }
+      throw new Error(`Unknown command "${input}". Expected format: Chain.category.Pallet.Item (e.g. polkadot.query.System.Account)`);
+    }
+    default:
+      throw new Error(`Unknown command "${input}". Too many segments. Expected format: [Chain.]category[.Pallet[.Item]]`);
+  }
+}
+
 // src/cli.ts
 startBackgroundCheck(version);
 var cli = cac("dot");
@@ -3390,14 +4006,105 @@ cli.option("--output <format>", "Output format: pretty or json", {
 });
 registerChainCommands(cli);
 registerInspectCommand(cli);
-registerQueryCommand(cli);
-registerConstCommand(cli);
-registerFocusedInspectCommands(cli);
 registerAccountCommands(cli);
-registerTxCommand(cli);
 registerHashCommand(cli);
+cli.command("[dotpath] [...args]").option("--from <name>", "Account to sign with (for tx)").option("--dry-run", "Estimate fees without submitting (for tx)").option("--encode", "Encode call to hex without signing (for tx)").option("--ext <json>", "Custom signed extension values as JSON (for tx)").option("--limit <n>", "Max entries to return for map queries (0 = unlimited)", {
+  default: 100
+}).action(async (dotpath, args, opts) => {
+  if (!dotpath) {
+    printHelp();
+    return;
+  }
+  const config = await loadConfig2();
+  const knownChains = Object.keys(config.chains);
+  let parsed;
+  try {
+    parsed = parseDotPath(dotpath, knownChains);
+  } catch {
+    throw new CliError2(`Unknown command "${dotpath}". Run "dot --help" for available commands.`);
+  }
+  if (parsed.chain && opts.chain) {
+    throw new CliError2(`Chain specified both as prefix ("${parsed.chain}") and as --chain flag ("${opts.chain}"). Use one or the other.`);
+  }
+  const effectiveChain = parsed.chain ?? opts.chain;
+  const handlerOpts = { chain: effectiveChain, rpc: opts.rpc, output: opts.output };
+  const target = parsed.pallet ? parsed.item ? `${parsed.pallet}.${parsed.item}` : parsed.pallet : undefined;
+  if (cli.options.help && parsed.pallet && parsed.item) {
+    await showItemHelp2(parsed.category, target, handlerOpts);
+    return;
+  }
+  switch (parsed.category) {
+    case "query":
+      await handleQuery(target, args, { ...handlerOpts, limit: opts.limit });
+      break;
+    case "tx":
+      if (parsed.pallet && /^0x[0-9a-fA-F]+$/.test(parsed.pallet)) {
+        await handleTx(parsed.pallet, args, {
+          ...handlerOpts,
+          from: opts.from,
+          dryRun: opts.dryRun,
+          encode: opts.encode,
+          ext: opts.ext
+        });
+      } else {
+        await handleTx(target, args, {
+          ...handlerOpts,
+          from: opts.from,
+          dryRun: opts.dryRun,
+          encode: opts.encode,
+          ext: opts.ext
+        });
+      }
+      break;
+    case "const":
+      await handleConst(target, handlerOpts);
+      break;
+    case "events":
+      await handleEvents2(target, handlerOpts);
+      break;
+    case "errors":
+      await handleErrors2(target, handlerOpts);
+      break;
+  }
+});
 cli.option("--help, -h", "Display this message");
 cli.version(version);
+function printHelp() {
+  console.log(`dot/${version} \u2014 Polkadot CLI`);
+  console.log();
+  console.log("Usage:");
+  console.log("  dot <category>[.Pallet[.Item]] [args] [options]");
+  console.log("  dot [Chain.]<category>[.Pallet[.Item]] [args] [options]");
+  console.log();
+  console.log("Categories:");
+  console.log("  query     Query on-chain storage");
+  console.log("  tx        Submit an extrinsic");
+  console.log("  const     Look up or list pallet constants");
+  console.log("  events    List or inspect pallet events");
+  console.log("  errors    List or inspect pallet errors");
+  console.log();
+  console.log("Examples:");
+  console.log("  dot query.System.Account <addr>         Query a storage item");
+  console.log("  dot query.System                        List storage items in System");
+  console.log("  dot tx.System.remark 0xdead --from alice");
+  console.log("  dot const.Balances.ExistentialDeposit");
+  console.log("  dot events.Balances                     List events in Balances");
+  console.log("  dot polkadot.query.System.Number        With chain prefix");
+  console.log();
+  console.log("Commands:");
+  console.log("  inspect [target]   Inspect chain metadata (alias: explore)");
+  console.log("  chain              Manage chain configurations");
+  console.log("  account            Manage accounts");
+  console.log("  hash               Hash utilities");
+  console.log();
+  console.log("Global options:");
+  console.log("  --chain <name>     Target chain (default from config)");
+  console.log("  --rpc <url>        Override RPC endpoint");
+  console.log("  --light-client     Use Smoldot light client");
+  console.log("  --output <format>  Output format: pretty or json");
+  console.log("  --help, -h         Display this message");
+  console.log("  --version          Show version");
+}
 async function showUpdateAndExit(code) {
   await waitForPendingCheck();
   const note = getUpdateNotification(version);
@@ -3422,17 +4129,17 @@ async function main() {
     if (cli.options.version) {
       await showUpdateAndExit(0);
     } else if (cli.options.help) {
-      if (cli.matchedCommandName) {
+      if (cli.matchedCommand) {
         const result = cli.runMatchedCommand();
         if (result && typeof result.then === "function") {
           await result.then(() => showUpdateAndExit(0), handleError);
         }
       } else {
-        cli.outputHelp();
+        printHelp();
         await showUpdateAndExit(0);
       }
-    } else if (!cli.matchedCommandName) {
-      cli.outputHelp();
+    } else if (!cli.matchedCommand) {
+      printHelp();
       await showUpdateAndExit(0);
     } else {
       const result = cli.runMatchedCommand();