bulletin-deploy 0.13.2 → 0.14.0-rc.1

package/dist/auth-config.js

@@ -9,10 +9,10 @@ import {
   getPeopleChainEndpoints,
   hasPersistedSession,
   resolveBulletinEndpoints
-} from "./chunk-RVSHGN74.js";
+} from "./chunk-7XC2U7R4.js";
 import "./chunk-TSPERKUS.js";
-import "./chunk-7PDAOD6W.js";
-import "./chunk-KQOQN5CN.js";
+import "./chunk-4IPJMCP5.js";
+import "./chunk-S2NLQSLC.js";
 import "./chunk-3ZEMX4WD.js";
 import "./chunk-ZOC4GITL.js";
 export {

package/dist/bug-report.js

@@ -10,10 +10,10 @@ import {
   offerBugReport,
   scrubSecrets,
   setDeployContext
-} from "./chunk-HAFE24QD.js";
-import "./chunk-RRBDBTOF.js";
-import "./chunk-7PDAOD6W.js";
-import "./chunk-KQOQN5CN.js";
+} from "./chunk-VDH5EBI2.js";
+import "./chunk-ZPJAJJBD.js";
+import "./chunk-4IPJMCP5.js";
+import "./chunk-S2NLQSLC.js";
 export {
   buildCliFlagsSummary,
   buildLabels,

package/dist/{chunk-YKWQMXWJ.js → chunk-447MJ2ZY.js}

@@ -9,10 +9,16 @@ import {
   setBulletinEndpoints,
   storeDirectory,
   storeFile
-} from "./chunk-SRCUUO5A.js";
+} from "./chunk-WVDMUB6R.js";
 import {
-  DotNS
-} from "./chunk-3QQ3KC6Q.js";
+  DotNS,
+  TX_KIND_SKIPPED
+} from "./chunk-URSX5FBI.js";
+import {
+  setDeployAttribute,
+  withManifestSpan,
+  withSpan
+} from "./chunk-4IPJMCP5.js";
 import {
   DEFAULT_ENV_ID,
   getPopSelfServeConfig,
@@ -40,19 +46,29 @@ async function publishManifest(opts) {
       `Manifest size preflight failed: ${failing}. Shrink displayName / description / paths or override BULLETIN_TEXT_BUDGET.`
     );
   }
+  return withManifestSpan(config.domain, () => publishManifestBody(opts, config, sourcePath));
+}
+async function publishManifestBody(opts, config, sourcePath) {
   const configDir = path.dirname(sourcePath);
   const envId = opts.env ?? DEFAULT_ENV_ID;
   const { doc } = await loadEnvironments();
   const resolved = resolveEndpoints(doc, envId);
   const popSelfServe = getPopSelfServeConfig(doc, envId);
   setBulletinEndpoints(resolveBulletinEndpoints(resolved.bulletin, opts.rpc));
+  setDeployAttribute("deploy.manifest.executable_count", String(config.executables.length));
   const iconAbs = path.resolve(configDir, config.icon.path);
   const iconBytes = await readFileOrThrow(iconAbs, "icon");
   console.log(`
 Manifest publish \u2014 ${config.domain}`);
   console.log(`  Loaded config: ${sourcePath}`);
   console.log(`  Uploading icon (${iconBytes.length} B)\u2026`);
-  const iconCid = await storeFile(iconBytes, { hashCode: BLAKE2B_256_MULTIHASH_CODE });
+  setDeployAttribute("deploy.manifest.icon_bytes", String(iconBytes.length));
+  const iconCid = await withSpan(
+    "deploy.manifest.icon-upload",
+    "manifest icon upload",
+    { "deploy.manifest.icon_bytes": String(iconBytes.length) },
+    () => storeFile(iconBytes, { hashCode: BLAKE2B_256_MULTIHASH_CODE })
+  );
   console.log(`  Icon CID: ${iconCid}`);
   const executableCids = {};
   for (const exec of config.executables) {
@@ -74,37 +90,61 @@ Manifest publish \u2014 ${config.domain}`);
     const rootManifest = composeRoot(config, iconCid);
     const rootJson = JSON.stringify(rootManifest);
     console.log(`  Writing root manifest text record on ${config.domain} (${Buffer.byteLength(rootJson, "utf8")} B)\u2026`);
-    await dotns.setTextRecord(baseLabel, "manifest", rootJson);
+    const rootTextRes = await dotns.setTextRecord(baseLabel, "manifest", rootJson);
+    let recordsWritten = 0;
+    let recordsSkipped = 0;
+    let subnamesRegistered = 0;
+    if (rootTextRes.txHash === TX_KIND_SKIPPED) recordsSkipped++;
+    else recordsWritten++;
     let textRecordsWritten = 1;
     for (const exec of config.executables) {
       const cid = executableCids[exec.kind];
       if (!cid) throw new NonRetryableError(`Internal: missing CID for executable kind '${exec.kind}'`);
-      const ownership = await dotns.checkSubdomainOwnership(exec.kind, baseLabel);
-      if (!ownership.owned) {
-        if (ownership.owner) {
-          throw new NonRetryableError(
-            `Subname ${exec.kind}.${config.domain} is owned by ${ownership.owner}, not the publisher. Aborting.`
-          );
+      await withSpan(
+        "deploy.manifest.executable",
+        `manifest executable ${exec.kind}`,
+        { "deploy.manifest.executable_kind": exec.kind },
+        async () => {
+          const ownership = await dotns.checkSubdomainOwnership(exec.kind, baseLabel);
+          const { registered } = await registerOrEnsureResolver(dotns, ownership, exec.kind, baseLabel, config.domain);
+          if (registered) subnamesRegistered++;
+          const subContenthash = `0x${encodeContenthash(cid)}`;
+          console.log(`  Setting contenthash on ${exec.kind}.${config.domain} \u2192 ${cid}\u2026`);
+          const contenthashRes = await dotns.setContenthash(`${exec.kind}.${baseLabel}`, subContenthash);
+          if (contenthashRes.skipped) recordsSkipped++;
+          const execManifest = composeExecutable(exec);
+          const execJson = JSON.stringify(execManifest);
+          console.log(`  Writing executable manifest on ${exec.kind}.${config.domain} (${Buffer.byteLength(execJson, "utf8")} B)\u2026`);
+          const execTextRes = await dotns.setTextRecord(`${exec.kind}.${baseLabel}`, "executable", execJson);
+          if (execTextRes.txHash === TX_KIND_SKIPPED) recordsSkipped++;
+          else recordsWritten++;
         }
-        console.log(`  Registering subname ${exec.kind}.${config.domain}\u2026`);
-        await dotns.registerSubdomain(exec.kind, baseLabel);
-      }
-      await dotns.ensureContentResolver(`${exec.kind}.${baseLabel}`);
-      const subContenthash = `0x${encodeContenthash(cid)}`;
-      console.log(`  Setting contenthash on ${exec.kind}.${config.domain} \u2192 ${cid}\u2026`);
-      await dotns.setContenthash(`${exec.kind}.${baseLabel}`, subContenthash);
-      const execManifest = composeExecutable(exec);
-      const execJson = JSON.stringify(execManifest);
-      console.log(`  Writing executable manifest on ${exec.kind}.${config.domain} (${Buffer.byteLength(execJson, "utf8")} B)\u2026`);
-      await dotns.setTextRecord(`${exec.kind}.${baseLabel}`, "executable", execJson);
+      );
       textRecordsWritten++;
     }
+    setDeployAttribute("deploy.manifest.text_records_written", String(recordsWritten));
+    setDeployAttribute("deploy.manifest.text_records_skipped", String(recordsSkipped));
+    setDeployAttribute("deploy.manifest.subnames_registered", String(subnamesRegistered));
     console.log(`  \u2713 ${textRecordsWritten} text record${textRecordsWritten === 1 ? "" : "s"} written.`);
     return { iconCid, executableCids, textRecordsWritten };
   } finally {
     dotns.disconnect();
   }
 }
+async function registerOrEnsureResolver(dotns, ownership, execKind, baseLabel, domain) {
+  if (!ownership.owned) {
+    if (ownership.owner) {
+      throw new NonRetryableError(
+        `Subname ${execKind}.${domain} is owned by ${ownership.owner}, not the publisher. Aborting.`
+      );
+    }
+    console.log(`  Registering subname ${execKind}.${domain}\u2026`);
+    await dotns.registerSubdomain(execKind, baseLabel);
+    return { registered: true };
+  }
+  await dotns.ensureContentResolver(`${execKind}.${baseLabel}`);
+  return { registered: false };
+}
 async function readFileOrThrow(p, label) {
   try {
     return await fs.readFile(p);
@@ -165,5 +205,6 @@ function stripDotSuffix(domain) {
 }
 
 export {
-  publishManifest
+  publishManifest,
+  registerOrEnsureResolver
 };

package/dist/{chunk-7PDAOD6W.js → chunk-4IPJMCP5.js}

@@ -1,7 +1,7 @@
 import {
   package_default,
   writeRunState
-} from "./chunk-KQOQN5CN.js";
+} from "./chunk-S2NLQSLC.js";
 
 // src/memory-report.ts
 import * as fs2 from "fs";
@@ -309,7 +309,7 @@ function getDeployAttributes(domain) {
   return attrs;
 }
 function isExpectedError(msg) {
-  return /personhood|owned by|owner mismatch|reserved for original|invalid domain label|not authorized for bulletin|insufficient balance|insufficient funds|quota exhausted|insufficient .* authorization|bip39 mnemonic|ipfs cli not installed|base name is \d+ chars|NameNotAvailable|name must be lowercase/i.test(msg);
+  return /personhood|owned by|owner mismatch|reserved for original|invalid domain label|not authorized for bulletin|insufficient balance|insufficient funds|quota exhausted|insufficient .* authorization|bip39 mnemonic|ipfs cli not installed|base name is \d+ chars|cannot register it|NameNotAvailable|name must be lowercase/i.test(msg);
 }
 function classifyDeployError(msg) {
   if (isExpectedError(msg)) return "user";
@@ -348,6 +348,15 @@ var ERROR_KIND_RULES = [
   [/No contract deployed at .+ returned empty success data/i, "naming.contract_unavailable"],
   [/Contract call returned empty data — contract=/i, "naming.contract_unavailable"],
   [/Domain\s+\S+\.dot\s+is already owned by\s+0x[a-fA-F0-9]+/i, "naming.already_owned"],
+  // #1185: formatUnregistrableReason's distinctive phrase — present in both
+  // the unregistered ("...is not registered, and bulletin-deploy cannot
+  // register it: ...") and owned-by-another-account ("...is owned by
+  // 0x..., and bulletin-deploy cannot register it for a different account:
+  // ...") variants, so one rule classifies both. Ordered before
+  // naming.subdomain_orphan (a different message shape entirely) and after
+  // naming.already_owned (whose "already owned by 0x..." phrasing this rule
+  // never produces, so there's no overlap either way).
+  [/cannot register it/i, "naming.governance_reserved"],
   [/Cannot deploy\s+[\w.-]+\.dot:\s*parent\s+[\w.-]+\.dot\s+is owned by/i, "naming.subdomain_orphan"],
   [/Post-deploy verification failed for .+: on-chain contenthash is /i, "verify.contenthash_mismatch"],
   [/Deploy verification failed:\s*DAG-PB root.+not finalised/i, "verify.dagpb_not_finalised"],
@@ -576,6 +585,42 @@ async function withDeploySpan(domain, fn) {
     }
   }
 }
+async function withManifestSpan(domain, fn) {
+  if (!Sentry) return fn();
+  const savedRootSpan = deployRootSpan;
+  const attrs = { ...getDeployAttributes(domain), "deploy.domain": domain };
+  try {
+    return await Sentry.startSpan(
+      { op: "deploy.manifest.publish", name: `manifest ${domain}`, attributes: attrs },
+      async (span) => {
+        deployRootSpan = span;
+        span.setAttribute("deploy.tool_version", VERSION);
+        span.setAttribute("deploy.domain", domain);
+        Sentry.setTags({
+          "deploy.repo": String(attrs["deploy.repo"] ?? ""),
+          "deploy.domain": domain
+        });
+        try {
+          const result = await fn();
+          span.setAttribute("deploy.manifest.status", "ok");
+          return result;
+        } catch (error) {
+          const msg = error.message ?? String(error);
+          setDeployErrorOnSpan(span, msg);
+          span.setAttribute("deploy.manifest.status", "error");
+          span.setStatus({ code: 2, message: "internal_error" });
+          throw error;
+        }
+      }
+    );
+  } finally {
+    deployRootSpan = savedRootSpan;
+    try {
+      await Sentry.flush(5e3);
+    } catch {
+    }
+  }
+}
 function setDeployReportContext(patch) {
   reportContext = { ...reportContext, ...patch };
 }
@@ -788,6 +833,7 @@ export {
   withSpan,
   sampleMemory,
   withDeploySpan,
+  withManifestSpan,
   setDeployReportContext,
   setDeployAttribute,
   setDeployError,

package/dist/{chunk-RVSHGN74.js → chunk-7XC2U7R4.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-TSPERKUS.js";
 import {
   VERSION
-} from "./chunk-7PDAOD6W.js";
+} from "./chunk-4IPJMCP5.js";
 import {
   loadEnvironments
 } from "./chunk-3ZEMX4WD.js";

package/dist/{chunk-64FAP55R.js → chunk-BB5EMKB5.js}

@@ -1,6 +1,6 @@
 import {
   captureWarning
-} from "./chunk-7PDAOD6W.js";
+} from "./chunk-4IPJMCP5.js";
 
 // src/chunk-probe.ts
 import { Twox128, Blake2128Concat, decAnyMetadata, unifyMetadata } from "@polkadot-api/substrate-bindings";

package/dist/{chunk-2E2KHTF2.js → chunk-KMDZ3ZV6.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-GRPLHUYC.js";
 import {
   DOT_DAPP_ID
-} from "./chunk-RVSHGN74.js";
+} from "./chunk-7XC2U7R4.js";
 
 // src/sss-allowance-cache.ts
 import { mkdir, readFile, writeFile, unlink } from "fs/promises";

package/dist/{chunk-KQOQN5CN.js → chunk-S2NLQSLC.js}

@@ -6,7 +6,7 @@ import * as path from "path";
 // package.json
 var package_default = {
   name: "bulletin-deploy",
-  version: "0.13.2",
+  version: "0.14.0-rc.1",
   private: false,
   repository: {
     type: "git",

package/dist/{chunk-3QQ3KC6Q.js → chunk-URSX5FBI.js}

@@ -11,7 +11,7 @@ import {
   setDeploySentryTag,
   truncateAddress,
   withSpan
-} from "./chunk-7PDAOD6W.js";
+} from "./chunk-4IPJMCP5.js";
 import {
   validateContractAddresses
 } from "./chunk-3ZEMX4WD.js";
@@ -578,28 +578,121 @@ function sanitizeDomainLabel(label) {
   console.log(`   Domain label sanitized: "${label}" \u2192 "${stripped}" (normalized trailing digits to 0)`);
   return stripped;
 }
-function validateDomainLabel(label, opts = {}) {
-  if (!/^[a-z0-9-]{3,63}$/.test(label)) throw new Error("Invalid domain label: must be 3-63 chars and contain only lowercase letters, digits, and hyphens");
-  if (label.startsWith("-") || label.endsWith("-")) throw new Error("Invalid domain label: cannot start or end with hyphen");
-  const sanitized = opts.skipSanitize ? label : sanitizeDomainLabel(label);
-  if (!opts.skipSanitize && /-\d+$/.test(sanitized)) {
-    const baseWithHyphen = sanitized.replace(/\d+$/, "");
-    const dropHyphen = sanitized.replace(/-(\d+)$/, "$1");
-    const insertSegment = sanitized.replace(/-(\d+)$/, "-pr$1");
-    throw new Error(
-      `Invalid domain label: "${sanitized}" \u2014 dotns base-name extraction leaves a trailing hyphen ("${baseWithHyphen}"), which the registry rejects with PopError("Name must be lowercase ASCII DNS label"). Drop the hyphen before the digits (e.g. "${dropHyphen}") or add a non-digit segment between (e.g. "${insertSegment}").`
-    );
+function classifyLabelStatus(label) {
+  const trailingDigits = countTrailingDigits(label);
+  const baseLength = label.length - trailingDigits;
+  if (trailingDigits === 1 || trailingDigits > 2 || baseLength <= 5) {
+    return { status: ProofOfPersonhoodStatus.Reserved, trailingDigits, baseLength };
   }
-  if (opts.checkReserved !== false) {
-    const classification = classifyDotnsLabel(sanitized);
-    if (classification.status === ProofOfPersonhoodStatus.Reserved) {
-      const sanitizeTrail = label !== sanitized ? `Input "${label}" was sanitized to "${sanitized}" (excess trailing digits trimmed). ` : "";
-      throw new NonRetryableError(
-        `${sanitizeTrail}Invalid domain label "${sanitized}": ${classification.message}`
-      );
-    }
+  if (baseLength <= 8) {
+    return { status: trailingDigits === 2 ? ProofOfPersonhoodStatus.ProofOfPersonhoodLite : ProofOfPersonhoodStatus.ProofOfPersonhoodFull, trailingDigits, baseLength };
+  }
+  return { status: ProofOfPersonhoodStatus.NoStatus, trailingDigits, baseLength };
+}
+function tierDescriptionFor(status) {
+  if (status === ProofOfPersonhoodStatus.NoStatus) return "open to any account";
+  if (status === ProofOfPersonhoodStatus.ProofOfPersonhoodLite) return "requires Personhood Lite";
+  if (status === ProofOfPersonhoodStatus.ProofOfPersonhoodFull) return "requires Personhood Full";
+  return "unavailable";
+}
+function noStatusFallbackBase(base) {
+  return `${base.padEnd(9, "x").slice(0, 9)}00`;
+}
+function buildLabelAlternatives(label) {
+  const trailingRun = label.slice(label.length - countTrailingDigits(label));
+  const base = stripTrailingDigits(label);
+  const twoDigitSuffix = trailingRun.length >= 2 ? trailingRun.slice(-2) : trailingRun.padStart(2, "0");
+  const noStatusBase = noStatusFallbackBase(base.replace(/[^a-z0-9-]/g, "x"));
+  const candidateLabels = [
+    `${base}${twoDigitSuffix}`,
+    // (a) 2 trailing digits
+    base,
+    // (b) 0 trailing digits
+    noStatusBase
+    // (c) NoStatus-safe fallback
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const alternatives = [];
+  for (const candidate of candidateLabels) {
+    if (seen.has(candidate)) continue;
+    seen.add(candidate);
+    if (!/^[a-z0-9-]{3,63}$/.test(candidate)) continue;
+    if (candidate.startsWith("-") || candidate.endsWith("-")) continue;
+    if (/-\d+$/.test(candidate)) continue;
+    const { status, baseLength } = classifyLabelStatus(candidate);
+    if (status === ProofOfPersonhoodStatus.Reserved) continue;
+    alternatives.push({ label: candidate, baseLength, status, tierDescription: tierDescriptionFor(status) });
+  }
+  return alternatives;
+}
+function formatAlternativesList(alternatives) {
+  return alternatives.map((a) => `  - ${a.label}.dot \u2014 base ${a.baseLength}, ${a.tierDescription}`).join("\n");
+}
+function classifyRegistrability(label) {
+  const { trailingDigits, baseLength } = classifyLabelStatus(label);
+  if (trailingDigits !== 0 && trailingDigits !== 2) {
+    const digitWord = trailingDigits === 1 ? "digit" : "digits";
+    return {
+      registrable: false,
+      rule: "trailing-digits",
+      message: `Name has ${trailingDigits} trailing ${digitWord}; DotNS allows exactly 0 or 2 trailing digits. Use a base name with no trailing digits or a 2-digit suffix.`
+    };
+  }
+  if (/-\d+$/.test(label)) {
+    const baseWithHyphen = label.replace(/\d+$/, "");
+    return {
+      registrable: false,
+      rule: "hyphen-base",
+      message: `dotns-cli's base-name extraction leaves a trailing hyphen ("${baseWithHyphen}"), which the registry rejects with PopError("Name must be lowercase ASCII DNS label").`
+    };
+  }
+  if (baseLength <= 5) {
+    return {
+      registrable: false,
+      rule: "reserved-base",
+      message: `Base name is ${baseLength} char${baseLength === 1 ? "" : "s"}; DotNS reserves base names of 5 chars or fewer for governance (PopRules).`
+    };
+  }
+  return { registrable: true };
+}
+function formatUnregistrableReason(args) {
+  const { label, registrability, existingOwner } = args;
+  const alternatives = buildLabelAlternatives(label);
+  const alternativesBlock = alternatives.length > 0 ? `
+
+Alternatively, use a name you can register yourself:
+${formatAlternativesList(alternatives)}` : "";
+  if (existingOwner === null) {
+    return `${label}.dot is not registered, and bulletin-deploy cannot register it: ${registrability.message}
+
+Names like this can only be registered by an account whitelisted on the DotNS controller:
+  - Request whitelisting at https://github.com/paritytech/dotns/issues/new/choose
+  - From the whitelisted account: dotns register domain -n ${label} --governance
+  - Transfer it to this signer if they differ
+Then re-run this deploy unchanged.` + alternativesBlock;
   }
-  return sanitized;
+  return `${label}.dot is owned by ${existingOwner}, and bulletin-deploy cannot register it for a different account: ${registrability.message}
+
+This signer does not hold that name. If you control ${existingOwner}'s key, redeploy with that account (e.g. via --mnemonic) to update its content directly.` + alternativesBlock;
+}
+function decideRegistrabilityOutcome(args) {
+  const { label, registrability, existingOwner, selfAddress } = args;
+  if (existingOwner !== null && existingOwner === selfAddress) {
+    return { canProceed: true, plannedAction: "already-owned-by-us" };
+  }
+  if (registrability.registrable) {
+    return { canProceed: true, plannedAction: "register" };
+  }
+  return {
+    canProceed: false,
+    plannedAction: "abort",
+    reason: formatUnregistrableReason({ label, registrability, existingOwner, selfAddress })
+  };
+}
+function validateDomainLabel(label) {
+  if (!/^[a-z0-9-]{3,63}$/.test(label)) throw new Error("Invalid domain label: must be 3-63 chars and contain only lowercase letters, digits, and hyphens");
+  if (label.startsWith("-") || label.endsWith("-")) throw new Error("Invalid domain label: cannot start or end with hyphen");
+  return label;
 }
 function isCommitmentMature(chainNowSeconds, commitTimestampSeconds, minimumAgeSeconds) {
   return chainNowSeconds > commitTimestampSeconds + minimumAgeSeconds;
@@ -608,26 +701,27 @@ function isCommitmentTimingBarerevert(msg) {
   return /bare-revert.*\(empty 0x\)/i.test(msg) || /commitment.*too new.*expired/i.test(msg) || /expired.*commitment/i.test(msg);
 }
 function classifyDotnsLabel(label) {
-  const totalLength = label.length;
-  const trailingDigits = countTrailingDigits(label);
-  if (trailingDigits === 1 || trailingDigits > 2) {
-    return {
-      status: ProofOfPersonhoodStatus.Reserved,
-      message: `Name has ${trailingDigits} trailing digit${trailingDigits === 1 ? "" : "s"}; DotNS allows exactly 0 or 2 trailing digits. Use a base name with no trailing digits or a 2-digit suffix.`
-    };
-  }
-  const baselength = totalLength - trailingDigits;
-  if (baselength <= 5) {
+  const { status, trailingDigits, baseLength } = classifyLabelStatus(label);
+  if (status === ProofOfPersonhoodStatus.Reserved) {
+    if (trailingDigits === 1 || trailingDigits > 2) {
+      return {
+        status,
+        message: `Name has ${trailingDigits} trailing digit${trailingDigits === 1 ? "" : "s"}; DotNS allows exactly 0 or 2 trailing digits. Use a base name with no trailing digits or a 2-digit suffix.`
+      };
+    }
+    const alternatives = buildLabelAlternatives(label);
+    const suggestion = alternatives.length > 0 ? `
+
+Use a name you can register instead:
+${formatAlternativesList(alternatives)}` : "";
     return {
-      status: ProofOfPersonhoodStatus.Reserved,
-      message: `Base name is ${baselength} char${baselength === 1 ? "" : "s"}; DotNS reserves base names of 5 chars or fewer for governance (PopRules). Use a base name of 6+ chars \u2014 role prefixes like 'rc<N>pool' / 'rc<N>dir' / 'nightly-<role>' work well.`
+      status,
+      message: `Base name is ${baseLength} char${baseLength === 1 ? "" : "s"}; DotNS reserves base names of 5 chars or fewer for governance (PopRules).${suggestion}`
     };
   }
-  if (baselength >= 6 && baselength <= 8) {
-    if (trailingDigits === 2) return { status: ProofOfPersonhoodStatus.ProofOfPersonhoodLite, message: "Requires Light personhood verification" };
-    return { status: ProofOfPersonhoodStatus.ProofOfPersonhoodFull, message: "Requires Full personhood verification" };
-  }
-  return { status: ProofOfPersonhoodStatus.NoStatus, message: "Available to all" };
+  if (status === ProofOfPersonhoodStatus.ProofOfPersonhoodLite) return { status, message: "Requires Light personhood verification" };
+  if (status === ProofOfPersonhoodStatus.ProofOfPersonhoodFull) return { status, message: "Requires Full personhood verification" };
+  return { status, message: "Available to all" };
 }
 function canRegister(requiredStatus, userStatus) {
   if (requiredStatus === ProofOfPersonhoodStatus.Reserved) return false;
@@ -640,8 +734,8 @@ function canRegister(requiredStatus, userStatus) {
   return true;
 }
 function exampleNoStatusLabel(label) {
-  const base = stripTrailingDigits(validateDomainLabel(label, { checkReserved: false })).replace(/[^a-z0-9-]/g, "x");
-  return `${base.padEnd(9, "x").slice(0, 9)}00.dot`;
+  const base = stripTrailingDigits(label).replace(/[^a-z0-9-]/g, "x");
+  return `${noStatusFallbackBase(base)}.dot`;
 }
 function parseDomainName(input) {
   const name = input.replace(/\.dot$/, "");
@@ -651,7 +745,7 @@ function parseDomainName(input) {
     return { isSubdomain: false, label: sanitized, sublabel: null, parentLabel: null, fullName: `${sanitized}.dot` };
   }
   if (parts.length === 2) {
-    const sanitizedSub = validateDomainLabel(parts[0], { checkReserved: false, skipSanitize: true });
+    const sanitizedSub = validateDomainLabel(parts[0]);
     const sanitizedParent = validateDomainLabel(parts[1]);
     const fullLabel = `${sanitizedSub}.${sanitizedParent}`;
     return { isSubdomain: true, label: fullLabel, sublabel: sanitizedSub, parentLabel: sanitizedParent, fullName: `${fullLabel}.dot` };
@@ -1887,6 +1981,9 @@ var DotNS = class {
       label
     );
   }
+  // `skipped` (#1187): set true on the pre-check fast path so callers (e.g.
+  // manifest publish's telemetry counters) can tell a no-op skip from a real
+  // on-chain write without a second read of their own.
   async setContenthash(domainName, contenthashHex, opts = {}) {
     return withSpan("deploy.dotns.set-contenthash", "2b. set-contenthash", {}, async () => {
       this.ensureConnected();
@@ -1907,7 +2004,7 @@ var DotNS = class {
         if (current === expected) {
           console.log(`   Contenthash already set: ${ipfsCid} \u2014 skipping tx`);
           setDeployAttribute("deploy.dotns.contenthash_unchanged", "true");
-          return { node };
+          return { node, skipped: true };
         }
       } catch (_) {
       }
@@ -1979,7 +2076,7 @@ var DotNS = class {
       }
       console.log(`   Verified on-chain: ${ipfsCid}
 `);
-      return { node };
+      return { node, skipped: false };
     });
   }
   /**
@@ -2498,29 +2595,39 @@ var DotNS = class {
       const trailingDigits = countTrailingDigits(validated);
       const baselength = validated.length - trailingDigits;
       const classification = classifyDotnsLabel(validated);
-      if (classification.status === ProofOfPersonhoodStatus.Reserved) {
-        const sanitizeTrail = label !== validated ? `Input "${label}" was sanitized to "${validated}" (excess trailing digits trimmed). ` : "";
-        return {
-          label: validated,
-          classification,
-          userStatus: 0,
-          trailingDigits,
-          baselength,
-          isAvailable: false,
-          existingOwner: null,
-          isBaseNameReserved: false,
-          reservationOwner: null,
-          isTestnet: false,
-          canProceed: false,
-          reason: `${sanitizeTrail}${classification.message}`,
-          plannedAction: "abort",
-          needsPopUpgrade: false
-        };
-      }
+      const registrability = classifyRegistrability(validated);
       const baseName = stripTrailingDigits(validated);
       const [userStatus, baseReservation, ownership, isTestnet, signerFreeBalance] = await Promise.all([
         this.getUserPopStatus(),
-        withTimeout(this.contractCall(this._contracts.POP_RULES, POP_RULES_ABI, "isBaseNameReserved", [baseName]), 3e4, "isBaseNameReserved"),
+        // Non-fatal (#1185): deleting the early Reserved abort above widens
+        // what reaches this call — every 1-digit, 3+-digit, hyphen-base, and
+        // short-base label now hits isBaseNameReserved where previously only
+        // "registrable" labels did. A hyphen-adjacent base (e.g. from
+        // `foo--88`, where stripTrailingDigits only removes ONE trailing
+        // hyphen) can revert here; treat a revert/empty-data the same as
+        // "not reserved" rather than failing preflight over a read that is
+        // advisory context, not an authorization gate. Uses the same
+        // this.contractCall the pre-#1185 code used (not contractCallNullable
+        // — a different RPC path with its own stub surface); only the
+        // fatal-vs-non-fatal handling changes, via a plain try/catch.
+        //
+        // Code review finding: a blanket catch-all here would also swallow a
+        // genuine RPC/connection failure (timeout, WS drop) and silently
+        // default to "not reserved" — fail-open on network noise, not just
+        // on a real revert. Rethrow anything that looks like the read itself
+        // never completed; only default when the dry-run call DID complete
+        // (a revert or empty-data response).
+        (async () => {
+          try {
+            return await withTimeout(this.contractCall(this._contracts.POP_RULES, POP_RULES_ABI, "isBaseNameReserved", [baseName]), 3e4, "isBaseNameReserved");
+          } catch (e) {
+            const msg = e?.message ?? String(e);
+            if (/timed out after \d+ms|heartbeat timeout|WS halt|Unable to connect|ChainHead disjointed|websocket.*closed|socket closed|disconnect/i.test(msg)) {
+              throw e;
+            }
+            return [false, zeroAddress, 0n];
+          }
+        })(),
         this.checkOwnership(validated),
         this.isTestnet(),
         this.readFreeBalance(this.substrateAddress)
@@ -2567,6 +2674,28 @@ var DotNS = class {
           signerFreeBalance
         };
       }
+      if (!registrability.registrable) {
+        const decision = decideRegistrabilityOutcome({ label: validated, registrability, existingOwner, selfAddress });
+        if (!decision.canProceed) {
+          return {
+            label: validated,
+            classification,
+            userStatus,
+            trailingDigits,
+            baselength,
+            isAvailable: true,
+            existingOwner,
+            isBaseNameReserved: isReserved,
+            reservationOwner,
+            isTestnet,
+            canProceed: false,
+            reason: decision.reason,
+            plannedAction: "abort",
+            needsPopUpgrade: false,
+            signerFreeBalance
+          };
+        }
+      }
       let transferFeeNative = 0n;
       if (transferRecipientH160) {
         try {
@@ -2790,10 +2919,10 @@ var DotNS = class {
     return withSpan("deploy.dotns.register", `2a. register ${label}.dot`, {}, async () => {
       if (!this.connected) await this.connect(options);
       label = validateDomainLabel(label);
-      const preClassification = classifyDotnsLabel(label);
-      const preRequiredStatus = preClassification.status;
-      if (preRequiredStatus === ProofOfPersonhoodStatus.Reserved) {
-        throw new Error(preClassification.message);
+      const registrability = classifyRegistrability(label);
+      if (!registrability.registrable) {
+        const decision = decideRegistrabilityOutcome({ label, registrability, existingOwner: null, selfAddress: this.evmAddress.toLowerCase() });
+        throw new NonRetryableError(decision.reason);
       }
       const isTestnet = await this.isTestnet();
       const registerAliasState = isTestnet && this._popSelfServe?.stateAwareGuidance === true && this.substrateAddress ? await this.classifyAliasAccountState(this.substrateAddress) : null;
@@ -2817,9 +2946,6 @@ var DotNS = class {
         this.ensureNotRegistered(label)
       ]);
       const requiredStatus = classification.requiredStatus;
-      if (requiredStatus === ProofOfPersonhoodStatus.Reserved) {
-        throw new Error(classification.message);
-      }
       const userStatus = await this.getUserPopStatus();
       if (!canRegister(requiredStatus, userStatus)) {
         rejectIneligible(requiredStatus, userStatus);
@@ -3018,6 +3144,10 @@ export {
   countTrailingDigits,
   stripTrailingDigits,
   sanitizeDomainLabel,
+  buildLabelAlternatives,
+  classifyRegistrability,
+  formatUnregistrableReason,
+  decideRegistrabilityOutcome,
   validateDomainLabel,
   isCommitmentMature,
   isCommitmentTimingBarerevert,