bulletin-deploy 0.6.14 → 0.6.16

package/README.md

@@ -70,9 +70,47 @@ Options:
                            (see Telemetry section). Use to isolate test/benchmark/canary
                            runs from real-user traffic in Sentry dashboards. Also readable
                            from DEPLOY_TAG env var.
+  --gh-pages-mirror        After a successful deploy, push the CAR to the current repo's
+                           gh-pages branch as a fast-path HTTP cache for host apps. Opt-in.
+                           See "GitHub Pages mirror" below.
   --help                   Show help
 ```
 
+### GitHub Pages mirror (opt-in, experimental)
+
+Loading a dapp via a smoldot light client is slow. As a short-term cache, `--gh-pages-mirror` pushes the CAR to the current repo's `gh-pages` branch so host apps (dot.li, desktop) can fetch it via HTTP while the chain path catches up.
+
+```bash
+bulletin-deploy --gh-pages-mirror ./dist my-app.dot
+```
+
+After the Bulletin upload + DotNS registration succeed, the CLI commits:
+
+```
+bulletin/my-app.dot.car     # the CAR, byte-for-byte identical to what's on Bulletin
+bulletin/my-app.dot.json    # {domain, cid, toolVersion, deployedAt, encrypted, bulletinRpc, sourceRepo, sourceCommit}
+```
+
+to `gh-pages` and pushes. The mirror URL is printed at the end of the deploy:
+
+```
+Mirror: https://<owner>.github.io/<repo>/bulletin/my-app.dot.car
+```
+
+Requirements:
+
+- **GitHub Pages enabled** on the repo with `gh-pages` as the source branch (one-time, via repo Settings → Pages).
+- **Push permissions.** In CI, set `permissions: contents: write` on the workflow. Locally, your regular git credentials suffice.
+- **CAR ≤ 100 MB** (GitHub's single-file soft limit). Larger CARs are skipped with a log line; a Releases fallback for bigger CARs is a planned follow-up.
+- **Directory deploys only.** Pre-chunked `Array<Uint8Array>` / `Uint8Array` / single-file content doesn't produce a CAR and is skipped with a log line.
+
+Limitations / follow-ups:
+
+- **Discoverability is the caller's problem today.** The URL is printed at deploy time; host apps must be told which `<owner>/<repo>` to fetch from. A DotNS text record (or similar on-chain pointer) is the clean long-term answer and lives in a follow-up.
+- **Encrypted deploys mirror encrypted bytes.** `--password` deploys need the password to decrypt from the mirror too.
+- **Mirror failures are non-fatal.** The source of truth is Bulletin + DotNS; the mirror is a cache. Failures log and let the deploy succeed.
+- **GitHub Pages build latency.** The CAR lands on `gh-pages` immediately; Pages serves it after the build completes (~1–2 min in practice). Hosts should fall back to Bulletin while the 404 window lasts.
+
 ### Playground registry
 
 By default, deploys only upload to Bulletin storage and register the DotNS domain. The **Playground remix registry** is an on-chain app directory that makes your deploy visible in [Polkadot Playground](https://playground.polkadot.cloud).

package/bin/bulletin-deploy

@@ -21,6 +21,7 @@ for (let i = 0; i < args.length; i++) {
   else if (args[i] === "--playground") { flags.playground = true; }
   else if (args[i] === "--js-merkle") { flags.jsMerkle = true; }
   else if (args[i] === "--tag") { flags.tag = args[++i]; }
+  else if (args[i] === "--gh-pages-mirror") { flags.ghPagesMirror = true; }
   else if (args[i] === "--version" || args[i] === "-V") { flags.version = true; }
   else if (args[i] === "--help" || args[i] === "-h") { flags.help = true; }
   else { positional.push(args[i]); }
@@ -47,6 +48,8 @@ Options:
   --playground        Publish to the playground remix registry
   --js-merkle         Use pure-JS merkleization (no IPFS Kubo binary required)
   --tag "..."         Label deploy in telemetry (or set DEPLOY_TAG env var); see Telemetry in README
+  --gh-pages-mirror   After deploy, push the CAR to the current repo's gh-pages branch
+                      at bulletin/<domain>.dot.car (opt-in; also set GH_PAGES_MIRROR=1)
   --version           Show version
   --help              Show this help`);
   process.exit(0);
@@ -83,6 +86,7 @@ try {
       password: flags.password,
       jsMerkle: flags.jsMerkle,
       tag: flags.tag,
+      ghPagesMirror: flags.ghPagesMirror,
     });
 
     const output = process.env.GITHUB_OUTPUT;

package/dist/bug-report.js

@@ -2,10 +2,10 @@ import {
   classifyErrorArea,
   isInteractive,
   promptYesNo
-} from "./chunk-O24K3T6Z.js";
+} from "./chunk-BGLOVKHX.js";
 import {
   VERSION
-} from "./chunk-4DFHLH3R.js";
+} from "./chunk-LF3XAUCI.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/bug-report.ts

package/dist/{chunk-6OJJ47RG.js → chunk-3C7PWPPG.js}

@@ -4,7 +4,7 @@ import {
 import {
   captureWarning,
   withSpan
-} from "./chunk-4DFHLH3R.js";
+} from "./chunk-LF3XAUCI.js";
 
 // src/dotns.ts
 import crypto from "crypto";

package/dist/{chunk-O24K3T6Z.js → chunk-BGLOVKHX.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-4DFHLH3R.js";
+} from "./chunk-LF3XAUCI.js";
 
 // src/version-check.ts
 import { execSync, execFileSync } from "child_process";

package/dist/{chunk-6YXRLX5V.js → chunk-K7TA53E2.js}

@@ -5,7 +5,11 @@ import {
   fetchNonce,
   popStatusName,
   validateDomainLabel
-} from "./chunk-6OJJ47RG.js";
+} from "./chunk-3C7PWPPG.js";
+import {
+  MirrorSkipped,
+  mirrorToGitHubPages
+} from "./chunk-UZVOH3HB.js";
 import {
   merkleizeJS
 } from "./chunk-QILGABSF.js";
@@ -28,7 +32,7 @@ import {
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-4DFHLH3R.js";
+} from "./chunk-LF3XAUCI.js";
 
 // src/deploy.ts
 import { Buffer } from "buffer";
@@ -849,7 +853,7 @@ async function storeDirectory(directoryPath, provider = {}, password, jsMerkle)
   const storageCid = await withSpan("deploy.chunk-upload", "1b. chunk-upload", { "deploy.chunks.total": carChunks.length, "deploy.car.bytes": carContent.length }, async () => {
     return storeChunkedContent(carChunks, provider);
   });
-  return { storageCid, ipfsCid };
+  return { storageCid, ipfsCid, carBytes: carContent };
 }
 async function estimateUploadBytes(content) {
   try {
@@ -892,6 +896,7 @@ async function deploy(content, domainName = null, options = {}) {
     }
     let cid;
     let ipfsCid;
+    let mirrorCarBytes;
     console.log("\n" + "=".repeat(60));
     console.log(`DEPLOYING TO TESTNET                    v${VERSION}`);
     console.log("=".repeat(60));
@@ -995,6 +1000,7 @@ async function deploy(content, domainName = null, options = {}) {
             const dirResult = await storeDirectory(contentPath, providerWithReconnect, options.password, options.jsMerkle);
             cid = dirResult.storageCid;
             ipfsCid = dirResult.ipfsCid;
+            mirrorCarBytes = dirResult.carBytes;
           } else {
             console.log(`
    Mode: File`);
@@ -1056,6 +1062,38 @@ async function deploy(content, domainName = null, options = {}) {
         await dotns.setContenthash(name, contenthashHex);
         dotns.disconnect();
       });
+      if (options.ghPagesMirror) {
+        console.log("\n" + "=".repeat(60));
+        console.log("GitHub Pages mirror");
+        console.log("=".repeat(60));
+        if (!mirrorCarBytes) {
+          console.log("   Skipped: --gh-pages-mirror only supports directory deploys (no CAR captured for this content type).");
+        } else {
+          await withSpan("deploy.gh-pages-mirror", "3b. gh-pages-mirror", { "deploy.domain": name }, async () => {
+            try {
+              const mirror = await mirrorToGitHubPages({
+                domain: name,
+                carBytes: mirrorCarBytes,
+                cid,
+                toolVersion: VERSION,
+                bulletinRpc: options.rpc ?? process.env.BULLETIN_RPC ?? DEFAULT_BULLETIN_RPC,
+                encrypted: Boolean(options.password)
+              });
+              console.log(`   Mirror: ${mirror.url}`);
+              console.log(`   Manifest: https://${mirror.owner}.github.io/${mirror.repo}/${mirror.manifestPath}`);
+              setDeployAttribute("deploy.gh_pages_url", mirror.url);
+            } catch (err) {
+              if (err instanceof MirrorSkipped) {
+                console.log(`   Skipped: ${err.message}`);
+              } else {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.log(`   Failed (non-fatal): ${msg}`);
+                captureWarning("gh-pages mirror failed", { error: msg.slice(0, 200) });
+              }
+            }
+          });
+        }
+      }
       if (options.playground) {
         console.log("\n" + "=".repeat(60));
         console.log("Playground Registry");

package/dist/{chunk-4DFHLH3R.js → chunk-LF3XAUCI.js}

@@ -7,7 +7,7 @@ import * as path from "path";
 // package.json
 var package_default = {
   name: "bulletin-deploy",
-  version: "0.6.14",
+  version: "0.6.16",
   private: false,
   repository: {
     type: "git",
@@ -35,7 +35,7 @@ var package_default = {
     "cdm.json"
   ],
   scripts: {
-    build: "tsup src/index.ts src/deploy.ts src/dotns.ts src/pool.ts src/telemetry.ts src/merkle.ts src/version-check.ts src/bug-report.ts --format esm --dts --clean --target node22",
+    build: "tsup src/index.ts src/deploy.ts src/dotns.ts src/pool.ts src/telemetry.ts src/merkle.ts src/gh-pages-mirror.ts src/version-check.ts src/bug-report.ts --format esm --dts --clean --target node22",
     prepare: "npm run build",
     test: "npm run build && node --test test/test.js test/pool.test.js test/helpers/e2e-helpers.test.js",
     "test:e2e": "npm run build && node --test test/e2e.test.js",

package/dist/chunk-UZVOH3HB.js

@@ -0,0 +1,183 @@
+// src/gh-pages-mirror.ts
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var GH_PAGES_MIRROR_MAX_BYTES = 100 * 1024 * 1024;
+var GH_PAGES_MIRROR_DIR = "bulletin";
+var GH_PAGES_MIRROR_BRANCH = "gh-pages";
+var MirrorSkipped = class extends Error {
+  constructor(reason) {
+    super(reason);
+    this.name = "MirrorSkipped";
+  }
+};
+function parseGitRemoteUrl(url) {
+  const trimmed = url.trim();
+  const ssh = trimmed.match(/^git@[^:]+:([^/]+)\/(.+?)(?:\.git)?$/);
+  if (ssh) return { owner: ssh[1], repo: ssh[2] };
+  const https = trimmed.match(/^https?:\/\/(?:[^@]*@)?[^/]+\/([^/]+)\/(.+?)(?:\.git)?$/);
+  if (https) return { owner: https[1], repo: https[2] };
+  return null;
+}
+function resolveOwnerRepo(repoPath) {
+  const envRepo = process.env.GITHUB_REPOSITORY;
+  if (envRepo && envRepo.includes("/")) {
+    const [owner, repo] = envRepo.split("/");
+    if (owner && repo) return { owner, repo };
+  }
+  try {
+    const url = execSync("git config --get remote.origin.url", {
+      cwd: repoPath,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return parseGitRemoteUrl(url);
+  } catch {
+    return null;
+  }
+}
+function resolveSourceCommit(repoPath) {
+  if (process.env.GITHUB_SHA) return process.env.GITHUB_SHA;
+  try {
+    return execSync("git rev-parse HEAD", {
+      cwd: repoPath,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function normalizeDomainFilename(domain) {
+  const label = domain.endsWith(".dot") ? domain.slice(0, -4) : domain;
+  if (!/^[a-z0-9-]+$/.test(label)) {
+    throw new Error(`Invalid domain label for mirror filename: ${JSON.stringify(domain)}`);
+  }
+  return `${label}.dot`;
+}
+function mirrorUrl(owner, repo, domainFilename) {
+  return `https://${owner}.github.io/${repo}/${GH_PAGES_MIRROR_DIR}/${domainFilename}.car`;
+}
+function buildManifest(input) {
+  return {
+    domain: normalizeDomainFilename(input.domain),
+    cid: input.cid,
+    toolVersion: input.toolVersion,
+    deployedAt: input.deployedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    encrypted: input.encrypted,
+    bulletinRpc: input.bulletinRpc,
+    sourceRepo: input.sourceRepo,
+    sourceCommit: input.sourceCommit
+  };
+}
+function runGit(args, cwd, extraEnv = {}) {
+  return execSync(`git ${args.join(" ")}`, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, ...extraEnv }
+  }).trim();
+}
+function pushRemoteUrl(owner, repo, token) {
+  const authedOwner = token ? `x-access-token:${token}@github.com` : "github.com";
+  return `https://${authedOwner}/${owner}/${repo}.git`;
+}
+async function mirrorToGitHubPages(input) {
+  const repoPath = input.repoPath ?? process.cwd();
+  const ownerRepo = resolveOwnerRepo(repoPath);
+  if (!ownerRepo) {
+    throw new MirrorSkipped("no GitHub repo detected (GITHUB_REPOSITORY unset and no github.com remote)");
+  }
+  if (input.carBytes.length > GH_PAGES_MIRROR_MAX_BYTES) {
+    const mb = (input.carBytes.length / 1024 / 1024).toFixed(1);
+    throw new MirrorSkipped(`CAR is ${mb} MB; GitHub limits single files to 100 MB. Mirror skipped.`);
+  }
+  const domainFilename = normalizeDomainFilename(input.domain);
+  const { owner, repo } = ownerRepo;
+  const sourceCommit = input.sourceCommit ?? resolveSourceCommit(repoPath);
+  const sourceRepo = input.sourceRepo ?? `${owner}/${repo}`;
+  const manifest = buildManifest({ ...input, sourceCommit, sourceRepo });
+  const workTree = fs.mkdtempSync(path.join(os.tmpdir(), "bulletin-mirror-"));
+  const token = input.githubToken ?? process.env.GITHUB_TOKEN;
+  try {
+    let branchExists = false;
+    try {
+      execSync(`git ls-remote --exit-code --heads origin ${GH_PAGES_MIRROR_BRANCH}`, {
+        cwd: repoPath,
+        stdio: ["ignore", "ignore", "ignore"]
+      });
+      branchExists = true;
+    } catch {
+      branchExists = false;
+    }
+    if (branchExists) {
+      runGit(["fetch", "origin", `${GH_PAGES_MIRROR_BRANCH}:${GH_PAGES_MIRROR_BRANCH}`, "--depth=1"], repoPath);
+      runGit(["worktree", "add", workTree, GH_PAGES_MIRROR_BRANCH], repoPath);
+    } else {
+      runGit(["worktree", "add", "--detach", workTree, "HEAD"], repoPath);
+      runGit(["checkout", "--orphan", GH_PAGES_MIRROR_BRANCH], workTree);
+      runGit(["rm", "-rf", "--quiet", "."], workTree);
+    }
+    const mirrorDir = path.join(workTree, GH_PAGES_MIRROR_DIR);
+    fs.mkdirSync(mirrorDir, { recursive: true });
+    const carPath = path.join(mirrorDir, `${domainFilename}.car`);
+    const manifestPath = path.join(mirrorDir, `${domainFilename}.json`);
+    fs.writeFileSync(carPath, input.carBytes);
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+    runGit(["-c", `user.email=bulletin-deploy@noreply.github.com`, "-c", "user.name=bulletin-deploy", "add", GH_PAGES_MIRROR_DIR], workTree);
+    const status = runGit(["status", "--porcelain"], workTree);
+    if (status.length === 0) {
+      return {
+        url: mirrorUrl(owner, repo, domainFilename),
+        owner,
+        repo,
+        carPath: path.posix.join(GH_PAGES_MIRROR_DIR, `${domainFilename}.car`),
+        manifestPath: path.posix.join(GH_PAGES_MIRROR_DIR, `${domainFilename}.json`)
+      };
+    }
+    runGit(
+      [
+        "-c",
+        "user.email=bulletin-deploy@noreply.github.com",
+        "-c",
+        "user.name=bulletin-deploy",
+        "commit",
+        "-m",
+        `"mirror(bulletin): ${domainFilename} @ ${input.cid.slice(0, 12)}"`
+      ],
+      workTree
+    );
+    runGit(["push", pushRemoteUrl(owner, repo, token), `HEAD:${GH_PAGES_MIRROR_BRANCH}`], workTree);
+    return {
+      url: mirrorUrl(owner, repo, domainFilename),
+      owner,
+      repo,
+      carPath: path.posix.join(GH_PAGES_MIRROR_DIR, `${domainFilename}.car`),
+      manifestPath: path.posix.join(GH_PAGES_MIRROR_DIR, `${domainFilename}.json`)
+    };
+  } finally {
+    try {
+      runGit(["worktree", "remove", "--force", workTree], repoPath);
+    } catch {
+    }
+    try {
+      fs.rmSync(workTree, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+export {
+  GH_PAGES_MIRROR_MAX_BYTES,
+  GH_PAGES_MIRROR_DIR,
+  GH_PAGES_MIRROR_BRANCH,
+  MirrorSkipped,
+  parseGitRemoteUrl,
+  resolveOwnerRepo,
+  resolveSourceCommit,
+  normalizeDomainFilename,
+  mirrorUrl,
+  buildManifest,
+  mirrorToGitHubPages
+};

package/dist/deploy.d.ts

@@ -53,6 +53,7 @@ declare function merkleize(directoryPath: string, outputCarPath: string): Promis
 declare function storeDirectory(directoryPath: string, provider?: ExistingProvider, password?: string, jsMerkle?: boolean): Promise<{
     storageCid: string;
     ipfsCid: string;
+    carBytes: Uint8Array;
 }>;
 interface DeployOptions {
     playground?: boolean;
@@ -76,6 +77,14 @@ interface DeployOptions {
     tag?: string;
     /** Custom telemetry attributes, merged into the deploy span. Overrides auto-detected values. */
     attributes?: Record<string, string>;
+    /**
+     * Opt-in: after a successful deploy, push the CAR to the current repo's
+     * `gh-pages` branch under `bulletin/<domain>.dot.car` so hosts can fetch it
+     * via `https://<owner>.github.io/<repo>/bulletin/<domain>.dot.car` as a
+     * fast-path cache. Non-fatal on failure. See docs/… for the discoverability
+     * caveat.
+     */
+    ghPagesMirror?: boolean;
 }
 declare function estimateUploadBytes(content: DeployContent): Promise<number | null>;
 declare function deploy(content: DeployContent, domainName?: string | null, options?: DeployOptions): Promise<DeployResult>;

package/dist/deploy.js

@@ -23,11 +23,12 @@ import {
   storeChunkedContent,
   storeDirectory,
   storeFile
-} from "./chunk-6YXRLX5V.js";
-import "./chunk-6OJJ47RG.js";
+} from "./chunk-K7TA53E2.js";
+import "./chunk-3C7PWPPG.js";
+import "./chunk-UZVOH3HB.js";
 import "./chunk-QILGABSF.js";
 import "./chunk-JHNW2EKY.js";
-import "./chunk-4DFHLH3R.js";
+import "./chunk-LF3XAUCI.js";
 import "./chunk-QGM4M3NI.js";
 export {
   DEFAULT_BULLETIN_RPC,

package/dist/dotns.js

@@ -29,9 +29,9 @@ import {
   simulateUserStatus,
   stripTrailingDigits,
   validateDomainLabel
-} from "./chunk-6OJJ47RG.js";
+} from "./chunk-3C7PWPPG.js";
 import "./chunk-JHNW2EKY.js";
-import "./chunk-4DFHLH3R.js";
+import "./chunk-LF3XAUCI.js";
 import "./chunk-QGM4M3NI.js";
 export {
   CONNECTION_TIMEOUT_MS,

package/dist/gh-pages-mirror.d.ts

@@ -0,0 +1,51 @@
+declare const GH_PAGES_MIRROR_MAX_BYTES: number;
+declare const GH_PAGES_MIRROR_DIR = "bulletin";
+declare const GH_PAGES_MIRROR_BRANCH = "gh-pages";
+interface MirrorInput {
+    domain: string;
+    carBytes: Uint8Array;
+    cid: string;
+    toolVersion: string;
+    bulletinRpc: string;
+    encrypted: boolean;
+    deployedAt?: string;
+    sourceCommit?: string;
+    sourceRepo?: string;
+    repoPath?: string;
+    githubToken?: string;
+}
+interface MirrorResult {
+    url: string;
+    owner: string;
+    repo: string;
+    carPath: string;
+    manifestPath: string;
+}
+interface MirrorManifest {
+    domain: string;
+    cid: string;
+    toolVersion: string;
+    deployedAt: string;
+    encrypted: boolean;
+    bulletinRpc: string;
+    sourceRepo?: string;
+    sourceCommit?: string;
+}
+declare class MirrorSkipped extends Error {
+    constructor(reason: string);
+}
+declare function parseGitRemoteUrl(url: string): {
+    owner: string;
+    repo: string;
+} | null;
+declare function resolveOwnerRepo(repoPath: string): {
+    owner: string;
+    repo: string;
+} | null;
+declare function resolveSourceCommit(repoPath: string): string | undefined;
+declare function normalizeDomainFilename(domain: string): string;
+declare function mirrorUrl(owner: string, repo: string, domainFilename: string): string;
+declare function buildManifest(input: Omit<MirrorInput, "carBytes" | "repoPath" | "githubToken">): MirrorManifest;
+declare function mirrorToGitHubPages(input: MirrorInput): Promise<MirrorResult>;
+
+export { GH_PAGES_MIRROR_BRANCH, GH_PAGES_MIRROR_DIR, GH_PAGES_MIRROR_MAX_BYTES, type MirrorInput, type MirrorManifest, type MirrorResult, MirrorSkipped, buildManifest, mirrorToGitHubPages, mirrorUrl, normalizeDomainFilename, parseGitRemoteUrl, resolveOwnerRepo, resolveSourceCommit };

package/dist/gh-pages-mirror.js

@@ -0,0 +1,27 @@
+import {
+  GH_PAGES_MIRROR_BRANCH,
+  GH_PAGES_MIRROR_DIR,
+  GH_PAGES_MIRROR_MAX_BYTES,
+  MirrorSkipped,
+  buildManifest,
+  mirrorToGitHubPages,
+  mirrorUrl,
+  normalizeDomainFilename,
+  parseGitRemoteUrl,
+  resolveOwnerRepo,
+  resolveSourceCommit
+} from "./chunk-UZVOH3HB.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  GH_PAGES_MIRROR_BRANCH,
+  GH_PAGES_MIRROR_DIR,
+  GH_PAGES_MIRROR_MAX_BYTES,
+  MirrorSkipped,
+  buildManifest,
+  mirrorToGitHubPages,
+  mirrorUrl,
+  normalizeDomainFilename,
+  parseGitRemoteUrl,
+  resolveOwnerRepo,
+  resolveSourceCommit
+};

package/dist/index.js

@@ -1,9 +1,10 @@
 import {
   deploy
-} from "./chunk-6YXRLX5V.js";
+} from "./chunk-K7TA53E2.js";
 import {
   DotNS
-} from "./chunk-6OJJ47RG.js";
+} from "./chunk-3C7PWPPG.js";
+import "./chunk-UZVOH3HB.js";
 import {
   merkleizeJS
 } from "./chunk-QILGABSF.js";
@@ -14,7 +15,7 @@ import {
   fetchPoolAuthorizations,
   selectAccount
 } from "./chunk-JHNW2EKY.js";
-import "./chunk-4DFHLH3R.js";
+import "./chunk-LF3XAUCI.js";
 import "./chunk-QGM4M3NI.js";
 export {
   DotNS,

package/dist/telemetry.js

@@ -18,7 +18,7 @@ import {
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-4DFHLH3R.js";
+} from "./chunk-LF3XAUCI.js";
 import "./chunk-QGM4M3NI.js";
 export {
   VERSION,

package/dist/version-check.js

@@ -8,8 +8,8 @@ import {
   isPreReleaseVersion,
   preReleaseWarning,
   promptYesNo
-} from "./chunk-O24K3T6Z.js";
-import "./chunk-4DFHLH3R.js";
+} from "./chunk-BGLOVKHX.js";
+import "./chunk-LF3XAUCI.js";
 import "./chunk-QGM4M3NI.js";
 export {
   assessVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulletin-deploy",
-  "version": "0.6.14",
+  "version": "0.6.16",
   "private": false,
   "repository": {
     "type": "git",
@@ -28,7 +28,7 @@
     "cdm.json"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/deploy.ts src/dotns.ts src/pool.ts src/telemetry.ts src/merkle.ts src/version-check.ts src/bug-report.ts --format esm --dts --clean --target node22",
+    "build": "tsup src/index.ts src/deploy.ts src/dotns.ts src/pool.ts src/telemetry.ts src/merkle.ts src/gh-pages-mirror.ts src/version-check.ts src/bug-report.ts --format esm --dts --clean --target node22",
     "prepare": "npm run build",
     "test": "npm run build && node --test test/test.js test/pool.test.js test/helpers/e2e-helpers.test.js",
     "test:e2e": "npm run build && node --test test/e2e.test.js",