@artblocks/abx-cli 0.1.0-alpha.16 → 0.1.0-alpha.18

package/CHANGELOG.md

@@ -1,5 +1,390 @@
 # @artblocks/abx-cli
 
+## 0.1.0-alpha.18
+
+### Minor Changes
+
+- 11fa933: Phase 5 interface unifications: the self resolver becomes a named remote, doctor absorbs the
+  version/install/provenance ladder, deploy previews stop showing addresses they can't keep,
+  approvals are counted honestly, render×storage combos are validated once, and storage config gets
+  a real probe.
+
+  - **Self resolver is a named remote (breaking, client-side only)**: the CLIENT credential for the
+    local/self resolver moves from `ABX_RESOLVER_ADMIN_TOKEN` to the named-remote grammar
+    (`ABX_REMOTE_SELF_URL` / `ABX_REMOTE_SELF_TOKEN` — "self" is just a conventional remote name, zero
+    special-casing). The SERVER side (token-api control-plane auth, `provision.ts`, the Fly.io secret)
+    keeps its old name — it's the service's own config, not a client credential, so deployed resolvers
+    need no change. The old client var, if still set, is now a pointed `CliError` naming both new vars
+    (no silent fallback); `abx doctor` flags it too, and the near-miss `_KEY`-vs-`_TOKEN` detector keeps
+    working under the unified grammar.
+  - **`abx doctor` absorbs the version/install/provenance ladder** the skill used to only teach in
+    prose: one new ✓/✗ block for binary provenance (source checkout / npm install / npx — the silent-
+    stale-npx-cache trap), npm currency (reuses the existing cached update check), and skill↔CLI
+    version match (reuses `abx skill`'s own discovery). Each row names the exact fix.
+  - **Deploy previews stop showing addresses they can't keep**: `--dry-run` (`deploy` /
+    `deploy-series` / `deploy-code`) **without `--salt`** no longer prints a "deterministic address" —
+    that salt was just freshly, randomly reserved, so the address was real for that one preview and
+    never reproducible by a plain re-run. It now prints the salt itself, prominently, plus how to pin
+    it: re-run with `--salt <shown>` (guaranteed same address), or `abx predict --salt <shown> --for
+<signer>`. **With `--salt`, the address prints exactly as before** (it IS stable) — `abx predict`
+    is unchanged. The same rule applies to `--json`: without `--salt`, `address` reports `null` rather
+    than a value the real deploy won't land at (`saltPinned` still says why).
+  - **`approvals` — a labeled, honest signature count**: every deploy-family `--dry-run` preview and
+    `--confirm` summary now carries one uniform `approvals N wallet approval(s)` line/clause — the
+    number of **wallet TX signatures** the real run will ask for (a connected-wallet storage upload,
+    e.g. Arweave via `--storage-signer eth`, is a message signature, not a transaction, and stays
+    listed separately, as it already was). It's derived from the exact same staging/setup-multicall
+    math that sizes the wallet-lane session's own `total`, so the two can never disagree — this caught
+    (and fixed) `deploy-code`'s wallet-lane session `total` being hardcoded to `2` even on the 1-tx path
+    (no chunks/schema/deps/on-chain-uri legs/setup-carried mints), which would have shown "transaction
+    1 of 2" and then silently never asked for a second.
+  - **One validator for render×storage combos**: `@artblocks/abx-storage` gains
+    `validateRenderStorageCombo()` (`content-plan.ts`) — the single source of truth for two known-bad
+    configurations, each checked against the ACTUAL fact that makes it bad (not against an unrelated
+    flag): (1) `--image-base` needs a backend that can overwrite a stable per-token key in place; an
+    ipfs/arweave-_shaped URL_ is refused regardless of this deploy's own `--backend`, because those are
+    content-addressed — a re-upload gets a new address, so no fixed URL can point at it. (2) publishing
+    a render to a resolver that doesn't share this machine's disk needs a backend that can hand back a
+    public URL at all — `fs` (or `cloud` with no public base) can't. `deploy-code` wires this into BOTH
+    its real-run refusal (`--image-base`) and a new `render/storage ✓|✗ <reason>` dry-run row;
+    `requirePublishableBackend` (the existing `abx render --remote` / `abx effects` guard) now consults
+    the same validator for its ok/not-ok decision, so the two surfaces can't drift apart.
+  - **`abx storage show --check`**: a real read/write against the resolved storage config, not just
+    "is it configured." `cloud` PUTs a tiny object through the signed API and GETs it back over the
+    PUBLIC base with a plain unsigned fetch — the only check that catches the R2/S3
+    endpoint-vs-public-base trap (`health()` alone only proves the API credentials work); on failure
+    both URLs print, so the mismatch is visible. `ipfs`/`fs` reuse their existing `health()` verbatim
+    (gateway/API reachability, dir writability — no upload, no pin — reused, not reimplemented).
+    `arweave` adds an identity+balance READ, never a paid upload. Exit code is meaningful (0 ok / 1 any
+    ✗) so a script can gate a launch on it. `abx doctor`'s storage row now runs the same fuller probe
+    (bounded to 1.5s, matching its other fast network checks) instead of a bare `health()` call.
+
+### Patch Changes
+
+- 11fa933: The remaining phases of the simplification refactor that hadn't yet gotten a changeset: the CLI's
+  internal module split, the token-api/effects/mint-page convergence on the SDK, the shipped skill's
+  rewrite for the simplified surface, and a new SDK README.
+
+  - **`abx`'s `main.ts` split into domain command modules** (`commands/{deploy,project,reads,service,
+scaffold,storage}.ts`, shared `output.ts`/`errors.ts`), with one exit-discipline rule
+    (`process.exitCode` + return, or a typed `CliError`, everywhere — bare `process.exit` only at the
+    entry guard, the top-level catch, and the keep-alive SIGINT handler). Purely internal: a 207-fixture
+    byte-diff matrix (every help text, dry-run, error path, and exit code) confirmed identical output
+    before and after.
+  - **token-api / effects / mint-page converge on the SDK**: `@artblocks/abx-storage` gains one
+    `resolveGatewayBase` (`readiness.ts`), replacing three near-identical copies (two in token-api, one
+    inline in storage itself); token-api exports `buildGeneratorDocument` so the CLI's `abx preview`
+    consumes the real generator-document assembler instead of a hand-kept duplicate; the effects runner
+    now resolves its config via the SDK's `readEnv` and gets a `makePublicClient` fallback transport, so
+    `ABX_RPC_URL` accepts a comma-separated failover list like every other RPC var; the scaffolded
+    mint-page app now imports ABIs from `@artblocks/abx-sdk/abi` and a browser-safe `makePublicClient` +
+    typed `readSaleConfig` instead of hand-rolled fetch/decode, and pins its generated `package.json` to
+    the SDK's _resolved_ version via a new `@artblocks/abx-sdk/package.json` export (alpha version
+    counters diverge per package under changesets, so pinning the CLI's own number could produce an
+    unsatisfiable range).
+  - **The shipped skill (`.claude/skills/abx-self-host/`) is rewritten for the surface phases 0–5
+    actually shipped**: every warning made obsolete by an enforcement is deleted rather than softened —
+    predict-only deploy-preview addresses, the `approvals N` line, the single `ABX_REMOTE_SELF_*`
+    credential grammar, `doctor`'s version/provenance ladder, `storage show --check`, the render/storage
+    combo validator's dry-run row, and `ABX_DEPLOYER_PK` as the only key name. Retired names swept from
+    `dev-loop-test`, the agent-eval scenarios, and spec prose. The skill ships bundled inside this CLI
+    package (co-versioned via `SKILL.md` frontmatter), so it rides this same patch.
+  - **New `packages/sdk/README.md`**: what the SDK is, the send-injection model (`PreparedTx` +
+    `SendTx`, `makeHotSender` for a hot key, bring-your-own for a wallet/multisig), a complete
+    deploy → upload → mint → read walkthrough against real exports, and browser-use notes (explicit
+    `rpcUrls`, no env, the `/node` subpath is Node-only). Included in the npm tarball automatically
+    (README is one of the files npm always packs, regardless of the `files` allowlist).
+
+- 11fa933: Two ripouts, no functional loss: the retired `params.keys` read fallback in `abx state`, and the `abx changelog` command.
+
+  **`abx state`'s legacy `params.keys` fallback.** On-chain param enumeration (`contractParamKeys` /
+  `tokenParamKeys` / `paramSchemaKeys`) shipped a while back and every project deployed since enumerates
+  its own param surface — nothing writes the old `params.keys` CSV any more. The only thing still reading
+  it was `abx state`, so it could keep describing the handful of pre-enumeration testnet projects that
+  predate the switch. That reader (`readLegacyParamsKeys`) and its `legacy`-branching in `cmdStateBody`
+  are gone; `abx state` now shows exactly what it reads from on-chain enumeration, an empty PostParams
+  list for a pre-enumeration contract included. (The repoint guard that refuses to point a legacy token's
+  field renderer at the canonical generator is a separate, still-live safeguard — untouched.)
+
+  **`abx changelog`.** A `CHANGELOG.md`-reading command that duplicated what any agent or human can do by
+  reading the file that already ships with the package (`package.json` `files`) — one more command to
+  document and maintain for a read `cat` already covers. `CHANGELOG.md` keeps shipping; the update-nag
+  banner and the docs now point at the file and at npm's version list
+  (`https://www.npmjs.com/package/@artblocks/abx-cli?activeTab=versions`) instead of a command.
+
+- 11fa933: The extraction phase of the simplification refactor: business logic that lived only inside the CLI
+  is now importable — the CLI calls the same functions you can.
+
+  **Into the SDK:** the five trust-anchor bootstraps (`ensureFactory`, `ensureSeriesFactory`,
+  `ensureSeriesCodeFactory`, `ensureRenderer`, `ensureSeedSource` — `anchors.ts`, on the same
+  injected-`send` + `onEvent` pattern as `ensureChunkStore`, with a typed `AnchorUnavailableError`),
+  `detectCanonicalFactory`/`resolveScanFloor`, the on-chain-URI setup composer (`onchain-uri.ts`),
+  interrupted-deploy resume planning (`resume.ts`), migration plan/parity reconciliation
+  (`migrate.ts`), the `abx.js` static analyzer (`inspect.ts`), dependency setup legs (`deps.ts`),
+  content-staging plans (`staging.ts` — `planStagedContent`, `stageFieldContent` with `StagingEvent`),
+  `mintedTokenIds`, and a typed `readSaleConfig` for the fixed-price minter.
+
+  **Into storage:** `uploadAndLocate`, `repinNodeCustody` (the byte-custody half of migration),
+  `decideImageContentLane`, `assessStorageReadiness`/`assessTurboFunds` (the Arweave/Turbo funding
+  math), and `awaitLocatorReady` (poll a locator until it serves).
+
+  **CLI hardening that fell out of the dedup:** one risk gate (`gatedSend`) now guards every write —
+  `--dry-run` and `--confirm` mean the same thing on every command, all owner-ops gain `--confirm`,
+  and a write reaching the send lane under `--dry-run` is structurally impossible (grep-enforced by
+  test). One `CHAIN` source of truth; one memoized local-indexer accessor.
+
+- 11fa933: Phase 1 of the simplification refactor: one transaction shape with one send-injection point, and an SDK that never touches `.env` or a Node-only global on its own. Two related passes, same release.
+
+  **One transaction shape, one executor.** `StagingTx`/`SendStagingTx` are gone — everything is a `PreparedTx` sent through a single `SendTx`. New `execute.ts` carries `makeHotSender` (pins the nonce once, detects an under-estimated gas limit against a just-deployed target, throws a typed `TxRevertedError` instead of reporting a reverted tx as confirmed) plus `pinGas`/`waitForCodeAt`, moved from the CLI (`gas.ts` is gone) with their design comments intact. Every `deployX` is now `prepareDeployX` (pure) + `deployX(send, ...)`; the CLI's hot lane and `abx deploy-code --resume` both delegate to the same sender instead of hand-rolling their own nonce/gas loop — the class of bug that reported a burned, reverted transaction as a successful deploy can't recur in a second call site because there is no longer a second implementation.
+
+  **The SDK never loads `.env` implicitly.** `loadDotEnv`/`parseEnvContent` moved to a new `@artblocks/abx-sdk/node` subpath — the only module that touches `node:fs`/`node:path`. The package's main entry is now browser-bundle-safe (a permanent esbuild smoke test guards it); a host calls `loadDotEnv()` once at startup (the CLI's `main()`, the effects runner's `main()`) and the SDK core reads whatever's already in `process.env` through a tiny `readEnv` that no-ops outside Node. `ClientOptions` gained `rpcUrls?: string[]` and `makeWalletClient`/`envSigningKey` gained a `privateKey`/`override` escape — explicit config now wins outright over env resolution, following the same override → env → manifest precedence `deployments.ts` already used for contract addresses.
+
+  **Single signing-key name.** `ABX_DEPLOYER_PK` is the only env var the SDK reads for a hot key — `SEPOLIA_FUNDED_PK` and `SEPOLIA_WALLET_PK` (earlier-alpha names) are no longer consulted. A caller with one of the old names set now gets a `MissingSigningKeyError` that names the new one explicitly and says the old ones are retired, rather than a plain "no key found" that leaves an upgrader hunting for why a key that's clearly _there_ isn't being read. Sandbox/e2e scripts and test fixtures move to the new name too.
+
+  **Shared, environment-neutral utilities.** New `sdk/src/util.ts`: `sleep`, a `linearBackoffDelay` helper (service.ts's retry ladder and the effects runner's resolver poll both use it now instead of hand-rolled backoff math), `parseDataUri` (replaces three near-identical `data:` URI regexes across the CLI and the tokenURI probe with one permissive parser), and `tryReadContract` (replaces three near-identical try/read-return-undefined helpers; the CLI's "no contract at this address" diagnostic still wraps it where that mattered). `Buffer` is gone from the SDK core (chunk hex-encoding and param base64-encoding now use viem's `bytesToHex` and a ~12-line dependency-free base64 codec) — nothing in the SDK's main import graph is Node-only any more.
+
+- Updated dependencies [11fa933]
+- Updated dependencies [11fa933]
+- Updated dependencies [11fa933]
+- Updated dependencies [11fa933]
+  - @artblocks/abx-sdk@0.1.0-alpha.10
+  - @artblocks/abx-storage@0.1.0-alpha.10
+  - @artblocks/abx-token-api@0.1.0-alpha.13
+  - @artblocks/abx-indexer@0.1.0-alpha.11
+
+## 0.1.0-alpha.17
+
+### Patch Changes
+
+- df298d8: `abx attach` takes several `<key> <uri>` pairs and sends ONE transaction
+
+  The safety half of backlog B20. The CLI's most-documented flow — mint, then attach each artifact, then
+  refresh — sent one transaction per step with **no all-or-nothing boundary**, so a failure partway
+  through left a permanently half-written token, and a mint cannot be undone. An integrator hit exactly
+  that and folded 8 operations into 1 transaction (846,556 gas) using the SDK's `batchOps` — a primitive
+  the CLI already shipped and did not call. Now it calls it.
+
+  ```bash
+  abx attach 0x… stems ipfs://…/stems.wav score ipfs://…/score.pdf readme ar://…
+  # → 3 artifacts, one multicall: a revert lands NONE of them
+  ```
+
+  Three things make the batch safe rather than merely shorter:
+
+  - **Every pair is validated before anything is sent.** A bad locator in pair 5 stops pair 1 — otherwise
+    batching would defeat its own purpose.
+  - **A key repeated inside one batch is refused.** A field holds one active value, so the later write
+    would silently win — the same full-column-upsert hazard that was a real bug in the resolver's
+    `register` and a real trap in `lock-field`.
+  - **A single pair is unchanged.** `batchOps` passes a lone op through untouched, so the one-artifact
+    case sends the identical plain field transaction it always did — no multicall wrapper, no new gas.
+
+  An odd number of positionals is refused and names the dangling argument, rather than silently ignoring
+  it.
+
+  Still open in B20, and recorded there rather than quietly skipped: batching **`set-field` across several
+  fields** needs a flag-grammar decision first (`attach` batched cleanly because its arguments are
+  positional pairs; `set-field` takes one `--field` with a correlated `--text`/`--value`, and the parser
+  has no notion of correlated repeats). Same for an all-or-nothing "mint and configure" — mint and
+  configure are separate commands, so that needs a verb that owns both.
+
+- df298d8: `abx deploy-code --resume <address>` — finish a deploy whose setup transaction failed
+
+  Closes backlog B15. A code project deploys in **two** transactions: create the clone, then one atomic
+  `multicall` carrying the script chunks, the PostParam schemas, the dependency declarations, the
+  on-chain-URI legs, and any reserve mints. There is no rollback. When the second one fails you own a
+  live-but-unusable contract — and the CREATE2 salt reserved for its address is **spent**, so the dry
+  run's pinned-salt reproduce command can never be run again. One reporter session produced three
+  orphaned contracts from three attempts; another produced five.
+
+  The useful half of that report is that those contracts were **recoverable, not lost**: resending the
+  setup with an adequate gas limit completed one, after which `abx verify` reported chain-complete and the
+  token returned its on-chain `animation_url`. The tester did it by hand with `cast`. We deliberately
+  never documented that as a recipe — telling a creator to hand-assemble a multicall is worse than telling
+  them nothing — so this is the verb.
+
+  ```bash
+  abx deploy-code --resume 0x… <the same content flags the original deploy used> --dry-run
+  ```
+
+  It deploys nothing. It reads what the contract already holds and sends only the missing legs, in one
+  transaction — safe to run twice, and if nothing is missing it sends nothing and says so. Three judgments
+  carry it:
+
+  - **Chunks compare by content, not by count.** A count check would call a chunk "present" when a hand
+    repair wrote different bytes at that index — and a hand repair with `cast` is exactly what happened.
+  - **A schema that already exists is left alone.** Re-writing one is an upsert that can strand values
+    already stored under it; that hazard belongs to `set-schema` and its guard, never to a repair.
+  - **Mints are a shortfall against current supply, never a re-send.** `mint` is the one non-idempotent
+    leg, and a token cannot be un-minted.
+
+  `--salt`, `--721c`, `--bootstrap-factory` and `--mint-all` are refused rather than ignored: they all
+  describe how a contract is _created_, and this creates nothing. ERC-721C especially — enrollment is
+  deploy-time-only and permanent, so silently accepting the flag would imply it can be added later.
+
+  It shares the deploy's own setup-leg builder, so a resume can never drift from what a fresh deploy would
+  have written — a second implementation of that sequence is the failure mode a repair verb most easily
+  introduces. Signing goes through the same choke point as every other write, so `--sign` / `--unsigned` /
+  the owner check / the chain-id guard all apply, and `--dry-run` previews the repair (one bug found and
+  fixed while building this: the deploy's dry-run block returned first, so `--resume … --dry-run` printed a
+  fresh-deploy plan with a newly-reserved salt and a different predicted address).
+
+  15 tests, including every diff branch and the four refusals.
+
+- df298d8: `--json` on every value-emitting command: `mint`, `deploy`, `deploy-series`, `deploy-code`, `state`, `verify`
+
+  Closes backlog B19. The rule it enforces, from an integrator who drove the CLI from a server: **a value
+  a program needs must be obtainable without parsing prose.** They had to regex-scrape ANSI-coloured
+  stdout for every value — and an escape code was captured into a locator, written into a _stored_ player
+  URL, and 404'd in production. The cause was found only by inspecting stored bytes.
+
+  Under `--json`, **stdout carries exactly one JSON document and nothing else.** Every narration line the
+  command would print for a human moves to **stderr** — diverted, not suppressed, because a human
+  watching a deploy still wants to see it while a program redirecting stdout still gets a clean parse.
+  (The update check already wrote to stderr for exactly this reason; this carries the instinct through to
+  the values themselves.)
+
+  - **`mint --json`** → `{tokenIds, txHash, blockNumber, sent, …}`. The token ids come from the mint's own
+    `Transfer(from=0x0)` logs, not from re-reading `nextTokenId` afterwards — a concurrent mint would make
+    that answer wrong, and a number that is usually right is worse than no number. A `--count N` batch
+    reports all N.
+  - **`deploy` / `deploy-series` / `deploy-code --json`** → the address, emitted _the moment it is known_
+    rather than at the end, so a failure in the indexing steps that follow still leaves the caller with
+    the address of a contract that really exists. That matters most for `deploy-code`, which is two
+    transactions: if the setup tx fails, the address of the live-but-incomplete contract is exactly what a
+    recovery needs (backlog B15). With `--dry-run` it reports the **predicted** address plus
+    `saltPinned` — false meaning a plain re-run reserves a fresh salt and lands elsewhere, so a caller
+    must not treat it as reserved.
+  - **`state --json`** → the on-chain snapshot as data, with canonical **names** for param types and auth
+    legs rather than raw Solidity enum indices (a caller must not have to know the enum ordering), and
+    `undefined` (getter absent) kept distinct from a zero address (present, deliberately unset).
+  - **`verify --json`** → the findings, with `ok` matching the exit code. This is the one command a CI job
+    would gate on, since it already exits non-zero on a byte mismatch. The tri-states stay tri-states:
+    `canonical` and each check's `verified` are `true | false | null`, because collapsing "couldn't check"
+    into "failed" would report a normal state as a failure.
+
+  The mechanism is a single shared helper (`withJson`) rather than a `quiet` flag threaded through every
+  command body — deliberately, since the alternative is touching dozens of call sites where the one that
+  gets missed is a stray line that corrupts a parse, i.e. the exact failure being fixed. A command that
+  emits no payload leaves stdout **empty** and exits non-zero rather than printing a `{}` a caller would
+  trust. 8 tests cover the channel contract itself, including that the swap is restored when a body
+  throws.
+
+- df298d8: `abx storage status <locator>` — is it retrievable yet, or only accepted?
+
+  Backlog B21, and the second half of a gap two independent integrations hit eight days apart. An upload
+  service answers "accepted" the moment it holds your bytes; a gateway serves them only once they
+  propagate, and on Arweave that runs to minutes. Nothing in the upload result distinguished the two, so
+  the natural implementation — upload during a mint, write the locator into the token — mints a token
+  that renders broken for the first minutes of its life.
+
+  The first reporter rebuilt this layer themselves (ranged GETs, a propagating/ready model, retry ladders
+  lengthened after measuring real times) and concluded "every serious integrator will rebuild some
+  version of this." The second published 32 renders and found **32/32 404ing on `arweave.net` while 22/32
+  already served from `permagate.io` and `vilenarios.com`**, with the uploader reporting `CONFIRMED`
+  throughout — and the expensive part is what a creator does next, since a placeholder on a fresh drop
+  reads as a failed render, so you re-run `abx render --force` and re-upload everything for nothing.
+
+  That second observation shapes the design: propagation is **per-gateway**, so the check probes the
+  gateway your project actually uses _plus two others_, which buys a third verdict the reporters' own
+  two-state model couldn't express.
+
+  - **`ready`** — your gateway serves the bytes. Safe to reference.
+  - **`propagating`** — another gateway serves them, so the data **provably exists** on the network and
+    yours is merely behind. Waiting is the fix, and the command says plainly not to re-upload.
+  - **`unreachable`** — nothing probed serves them. Deliberately _not_ called propagating: from outside,
+    a locator that is still settling and one that is simply wrong look identical, and reporting the
+    friendlier of the two is how a tool teaches someone to ignore it. When every gateway rejects the id
+    itself (a 4xx that isn't 404) rather than just missing it, that _is_ evidence, and the output says
+    "malformed locator, waiting will not fix it" — the inverse mistake of waiting out a typo costs more
+    than a needless re-upload.
+
+  Accepts every form a locator arrives in (`ar://`, `ipfs://`, a gateway URL, a bare txid/CID, with a
+  directory path suffix), reads **headers only** via a ranged request with the body cancelled — so
+  checking a 40 MB asset doesn't download it — and **exits non-zero unless ready**, which makes waiting a
+  one-liner instead of a retry ladder: `until abx storage status <loc> --json; do sleep 10; done`.
+
+  The primitive is `locatorStatus()` in `@artblocks/abx-storage`, not CLI-only (per B20): anything
+  programmatic should call it in-process rather than spawning the CLI per check. `abx render`'s existing
+  propagation note now points at the command, so the advisory has an answer attached.
+
+- df298d8: `abx tokens <address>` — every token's owner, seed, and params, from chain alone
+
+  The most obvious post-deploy question about a generative collection — _what did the seeds actually
+  deal?_ — had no command. `abx verify` reports per-token minted/render status but no seed; `abx
+tokenuri` prints one token and the seed lives inside its base64 `animation_url`; `abx inspect` is
+  pre-deploy and static. An agent's workaround was to start `abx serve`, `GET /api/project/<addr>`,
+  base64-decode each `tokenURI`, base64-decode the `animation_url` inside it, then regex
+  `0x[0-9a-f]{64}` out of the resulting HTML — 32 times. Every input to that was already a plain
+  contract read.
+
+  `abx tokens <address> [--json] [--from <id>] [--limit <n>]` is chain-only: no indexer projection, no
+  running resolver, no event scan. The params store maintains its own key lists inside its write paths
+  (`tokenParamKeys` / `contractParamKeys`) and `seed` is a reserved param read by name, so the whole
+  listing is `eth_call`s — available to anyone with an RPC URL, including before any indexing has
+  happened. Seeds print in full (truncating the one value the command exists for would repeat the
+  `tokenuri` bug); `--json` emits `{tokenId, owner, seed, params}` per token, contract-scope params
+  once on the parent rather than copied into every row.
+
+  It reports honestly across all three token types rather than failing: a 1/1 has no params extension
+  and says so (owners still list), a pre-enumeration project still yields seeds and flags that params
+  can't be enumerated, and an id whose `ownerOf` reverts is `null` — not "not minted", because a
+  burned id and an unminted id revert identically and a chain-only read can't tell them apart.
+
+  Two things it deliberately is not. It is not a trait spread: a trait comes from running the script
+  against the seed, which is `abx render`'s job — the token-scope _param_ spread it does print is
+  labelled as such. And the reader is in the **SDK** (`listTokens`), not just the CLI, so a
+  programmatic integrator gets it without reimplementing it.
+
+  Backlog B25 (from the 2026-08-04 tester batch, feedback `dcfdc6f4`).
+
+- df298d8: `abx tokenuri --fetch` — follow the URL the contract commits to and print what is actually served
+
+  Closes backlog B14. No command printed the served JSON body: `tokenuri` read the chain, `verify`
+  re-hashed bytes, `status` reported the indexing lifecycle — each a different slice, none of them the
+  document a marketplace actually reads. An agent in a cold sweep fell back to raw `curl` for exactly
+  this, which is the tell that a command was missing.
+
+  ```bash
+  abx tokenuri 0x… --fetch          # GET the baked URL, print the served body + HTTP status
+  abx tokenuri 0x… --fetch --json   # {tokenURI, onChain, served: {url, status, contentType, body}}
+  ```
+
+  It also answers the question a _warning_ could not, which is why the other half of B14 stays declined.
+  "Nothing tells you the provider you registered with isn't the base baked on-chain" is a real gap, but
+  the obvious check — compare the remote's base URL to the on-chain one — false-positives on the common
+  custom-domain case (a baked `meta.artist.xyz` fronting `api.provider.xyz`), and a warning that cries
+  wolf on the correct setup is worse than none. Fetching what the **baked** base returns makes the
+  mismatch self-evident instead: you see the other provider's 404, or another project's document, with no
+  guessing and no false positive.
+
+  Three judgments worth naming:
+
+  - **A `data:` URI is not a failure.** It IS the document, and a fully-on-chain project's whole point is
+    that there is no server to ask — so it reports "nothing to fetch" and exits 0. Treating it as an error
+    would punish the strongest configuration the protocol offers.
+  - **A dead host and a served error are different answers**, because they route to different fixes ("your
+    provider said no" vs "the URL a marketplace will ask is unreachable").
+  - **A non-2xx says it is about the SERVICE, never a mistyped path** — the URL came from the chain, so it
+    is right by construction, and the readout points at `abx status --remote` for the lifecycle.
+
+  Under `--json` the body is verbatim and untruncated and a non-2xx exits non-zero, so CI can gate on it;
+  the human readout clips at 1200 chars and says how many it clipped. The fetch itself lives in
+  `src/served.ts` with an injectable `fetch`, since `main.ts` exports nothing — the same reason
+  `scaffold.ts` was extracted.
+
+  This retired the last two `curl` recommendations in the shipped skill: verifying an attach is now
+  `abx tokenuri <addr> --fetch` (the served document carries the `artifacts` manifest), and the skill's
+  claim that `tokenuri` "follows" the URL — previously true only of `contracturi` — is now accurate.
+
+- Updated dependencies [df298d8]
+- Updated dependencies [df298d8]
+- Updated dependencies [df298d8]
+  - @artblocks/abx-sdk@0.1.0-alpha.9
+  - @artblocks/abx-token-api@0.1.0-alpha.12
+  - @artblocks/abx-storage@0.1.0-alpha.9
+  - @artblocks/abx-indexer@0.1.0-alpha.10
+
 ## 0.1.0-alpha.16
 
 ### Patch Changes

package/dist/commands/deploy.d.ts

@@ -0,0 +1,181 @@
+import { SelfHostIndexer } from '@artblocks/abx-indexer';
+import { type Address, type OnChainFieldInput, type OpenSeaAttribute, type ProjectState, type PublicClient, type SeriesTokenFieldInput } from '@artblocks/abx-sdk';
+import { type Hex } from 'viem';
+import { type StorageOverrides } from '../config.js';
+import { type Flags } from '../flags.js';
+export declare const DIMENSIONS: Record<string, {
+    label: string;
+    aliases: string[];
+}>;
+export declare function resolveDimension(type: string): string;
+/**
+ * A `--dry-run` computes the deterministic deploy address, which is a pure function of
+ * (factory, salt, deployer) — so it needs a deployer even though it signs nothing. Resolve it the
+ * same way the preview will (`--for`, else an env key) and fail EARLY with the fix if neither
+ * exists, rather than after the preview has printed several steps of work.
+ */
+/**
+ * A dry run only checks whether a factory address is CONFIGURED, not whether it has code on this
+ * chain — and the manifest always has an address, so a chain where the trust anchor isn't deployed
+ * (a private/local chain, or a wrong-network RPC) sailed past this and died inside
+ * `predictDeterministicAddress` with a raw `returned no data ("0x")` and a list of ABI hypotheses.
+ * The real deploy and `abx predict` both explain that case; a preview of the same deploy must too.
+ * Returns false when the caller should stop (message already printed).
+ */
+export declare function previewFactoryLive(client: PublicClient, factory: Address, label: string): Promise<boolean>;
+/**
+ * Placeholder-identity guard, shared by ALL THREE deploy commands. `name`/`symbol` are written
+ * on-chain as the public collection identity and are effectively permanent, so a real deploy must
+ * never bake a tool default silently: warn in a preview, HARD-STOP a real send unless `--yes`.
+ *
+ * It was duplicated per command, and `deploy-series` simply never got a copy — its default
+ * "ABX Series"/"ABXS" went on-chain with at most a warning, while the skill promises the CLI
+ * refuses demo defaults. (deploy-code's copy even said "mirror deploy/deploy-series", which made
+ * the gap look closed.) One predicate now, like `loopbackBaseUrl()`, so a fourth command can't drift.
+ */
+export declare function assertRealIdentity(flags: Flags, o: {
+    name: string;
+    symbol: string;
+    dryRun: boolean;
+}): void;
+export declare function assertPreviewDeployer(flags: Flags): void;
+export declare function warnUnfunded(publicClient: PublicClient, address: Address): Promise<void>;
+export declare function shArg(v: string): string;
+export declare function deployCommandLine(flags: Flags, salt: string): string;
+export declare function deploySeriesCommandLine(flags: Flags, salt: string): string;
+export declare function deployCodeCommandLine(flags: Flags, salt: string): string;
+export declare const imageKeccakField: (value: Hex) => OnChainFieldInput;
+export declare const imageInlineField: (svg: string) => OnChainFieldInput;
+/** An `image` field pointing at an off-chain URL (the renderer emits it verbatim). */
+export declare const imageUrlField: (url: string) => OnChainFieldInput;
+/** An `image` field as a `url-template` — `{id}` is substituted with the tokenId at render, so ONE
+ *  (collection-scope) field addresses a whole pinned directory / Arweave manifest. */
+export declare const imageUrlTemplateField: (template: string) => OnChainFieldInput;
+export declare const looksLikeSvg: (s: string) => boolean;
+/**
+ * Does the IMAGE itself end up on-chain for this deploy? Two ways it can:
+ *   • `--onchain-image` — the bytes are staged in the chunk store and read back via a `reader` field.
+ *   • `--onchain-uri` with an SVG — v1 inlines SVG directly as a data: URI (raster cannot be).
+ * Anything else falls through to keccak256 custody, and the on-chain renderer serves its PLACEHOLDER
+ * image. This distinction is the difference between a token that is durable and one that only looks
+ * durable, so it must be computed from the actual file — never inferred from the flag alone (the
+ * success banner used to claim "fully on-chain, no hosting needed" for a keccak-anchored raster).
+ */
+/**
+ * Will `tokenURI` resolve to the creator's REAL image, with nothing to keep running?
+ *
+ * Three ways yes, and they are not the same promise: the bytes are on-chain
+ * ({@link imageEndsUpOnChain}), or they sit at a durable public URL that the on-chain JSON points at
+ * (a direct-URL backend — the "no server" pattern). Only `fs` custody under `--onchain-uri` fails,
+ * because the renderer then holds a hash and nothing can serve it. Keep this separate from
+ * "fully on-chain": conflating them is what let a keccak-anchored raster ship under a permanence
+ * banner it did not earn.
+ */
+export declare function imageResolvesWithoutServer(flags: Flags, onchainImage: boolean): boolean;
+export declare function imageEndsUpOnChain(flags: Flags, onchainImage: boolean): boolean;
+/** A browser wallet reached through an open sign session, used as the Turbo (Arweave) upload
+ *  identity so the wallet's own credits pay — `signMessage` returns the `0x` EIP-191 signature. */
+export type RemoteEthUpload = {
+    address: Address;
+    signMessage: (message: Uint8Array) => Promise<string>;
+};
+export declare function prepareContent(imagePath: string | undefined, clone: Address, overrides: StorageOverrides, store?: boolean, // false for --dry-run: compute the hash but don't custody bytes
+onChain?: boolean, // true (--onchain-uri): put the image ON-CHAIN (inline SVG) so it self-resolves
+remoteEth?: RemoteEthUpload, // wallet-lane Turbo uploads: sign+pay with the connected browser wallet
+walletAddr?: string): Promise<{
+    tokenFields: OnChainFieldInput[];
+    contentNote: string;
+}>;
+/**
+ * Real OpenSea traits supplied by the creator, from `--attributes <file.json>` (canonical array or
+ * `{name: value}` map) and/or `--traits "Background=Blue; Edition=3"` (quick inline form). These are
+ * the marketplace trait array — NOT a place for protocol facts. Empty when neither flag is given.
+ */
+export declare function parseDeployTraits(flags: Flags): OpenSeaAttribute[];
+/** Encode creator traits as the on-chain `attributes` field (inline JSON bytes) — for `--traits-onchain`. */
+export declare const attributesInlineField: (attrs: OpenSeaAttribute[]) => OnChainFieldInput;
+/** Warn when IPFS/Arweave custody is pointed at a LOCAL gateway: the served image URL
+ *  (`<gateway>/ipfs/<cid>`) would resolve only on this machine, so marketplaces/wallets can't
+ *  load it — a pinning service + a PUBLIC gateway is part of operating off-chain custody. */
+export declare function localGatewayWarning(flags: Flags): string | null;
+/** A readout line for an optional creator text field — states exactly what's written (and where),
+ *  or that NOTHING is, so the deploy never silently invents one. */
+export declare function describeDeployField(label: string, value: string | undefined, onchain: boolean): string;
+/** Readout lines for whichever authorship/rights fields a deploy will write (always on-chain,
+ *  inline collection fields). Empty when none are set — so the readout stays quiet by default. */
+export declare function authorshipReadout(flags: Flags): string[];
+/** A readout line for creator traits — the exact traits written (and where), or that none are. */
+export declare function describeTraits(traits: OpenSeaAttribute[], onchain: boolean): string;
+export declare function cmdDeploy(flags: Flags, serveAfter: boolean): Promise<void>;
+export declare function cmdDeployBody(flags: Flags, serveAfter: boolean, emit: (p: Record<string, unknown>) => void): Promise<void>;
+export declare const tokenFieldOf: (tokenId: number, f: OnChainFieldInput) => SeriesTokenFieldInput;
+export declare function cmdDeploySeries(flags: Flags): Promise<void>;
+export declare function cmdDeploySeriesBody(flags: Flags, emit: (p: Record<string, unknown>) => void): Promise<void>;
+/**
+ * `abx deploy-code` — deploy a code project ({SeriesCode}) end to end, hot lane:
+ * the canonical factory + seed source from the manifest, fat initialize (the `code`
+ * field rides it in directory mode), then ONE post-deploy multicall for the script
+ * chunks (template mode) + any PostParam schemas, optional reserve mints, and local
+ * register + index. Grown directly from the Sepolia drop rehearsal
+ * (`packages/cli/scripts/code-drop-rehearsal.ts`).
+ *
+ * Modes (exactly one):
+ *   --script <file>    template mode — the program stored on-chain in chunks
+ *   --code-dir <dir>   directory mode — the build uploaded via the storage backend
+ *                      (`putDirectory`; ipfs/arweave), its root as the `code` field
+ *
+ * Schemas: --schema key:Type:Auth[,key:Type:Auth…] (e.g. palette:HexColor:TokenOwner).
+ * Seeds: canonical randomizer by default; --no-seed opts out.
+ */
+/**
+ * The deterministic part of a projection: everything that is a pure function of the chain.
+ * Deliberately EXCLUDES `reconstructedAt`, `rpcUrl` and `toBlock` — a timestamp, the endpoint that
+ * happened to answer, and the head at scan time all legitimately differ between two replays, so
+ * folding them in would make the rebuild proof fail for reasons that aren't about correctness.
+ */
+export declare function projectionFingerprint(s: ProjectState): string;
+/**
+ * Print the reconstructed spine — the point being that this list IS the database. Rendered inside
+ * the index step (no header of its own: "Index it — replay the event spine" immediately followed by
+ * a separate "The event spine" step read as a stutter).
+ */
+export declare function walkthroughSpine(state: ProjectState): void;
+/**
+ * [4] The claim, demonstrated: delete the local projection and rebuild it from the chain.
+ *
+ * This is the one step that can't be faked by good output — it drops the projection for real
+ * (registration kept), confirms it's gone, replays from the deploy block, and compares a
+ * fingerprint of everything chain-derived. If ABX's premise is wrong, this step fails loudly.
+ */
+export declare function walkthroughRebuild(indexer: SelfHostIndexer, address: Address, before: ProjectState): Promise<void>;
+/**
+ * [5] Read the token back the way a marketplace would.
+ *
+ * Which is genuinely a different act per lane, so it reads from the real source in each case rather
+ * than always going through the local server:
+ *   • fully on-chain → call `tokenURI(0)` on the contract. That IS what a marketplace does, and on
+ *     this lane the whole answer (art included) comes back from the chain with nothing else running.
+ *   • off-chain custody → fetch the resolver, because that's what the baked URI points at.
+ * Reading the on-chain lane over HTTP would have quietly implied the local server was load-bearing
+ * when it isn't — the opposite of the lesson.
+ */
+export declare function walkthroughReadBack(state: ProjectState, baseUrl: string, onChainUri: boolean): Promise<void>;
+/** Every flag `deploy-code` recognizes — so an unsupported/typo'd one warns instead of silently
+ *  no-opping. Keep in lockstep with the flags read below + the storageOverrides/lane helpers. */
+export declare const DEPLOY_CODE_FLAGS: Set<string>;
+export declare const SHARED_DEPLOY_FLAGS: string[];
+export declare const DEPLOY_FLAGS: Set<string>;
+export declare const DEPLOY_SERIES_FLAGS: Set<string>;
+export declare function cmdDeployCode(flags: Flags): Promise<void>;
+export declare function cmdDeployCodeBody(flags: Flags, emit: (p: Record<string, unknown>) => void): Promise<void>;
+/**
+ * Resolve `--721c` into the InitParams `transferValidator`. Absent → `zeroAddress`: a plain
+ * ERC-721, byte-for-byte the pre-721C deploy — no prompts, no output, no mention of 721C.
+ * `--721c` / `--721c recommended` → the per-chain recommended validator (refused, naming the
+ * chains that have one, when the manifest has no entry); `--721c 0x…` → checksum-validated AND
+ * pre-checked for code on this chain (the factory would revert `InvalidTransferValidator()` —
+ * surface it before any upload/staging/gas). When enrolling, prints the one plain statement of
+ * what enforcement means — once, adapted to the chosen validator.
+ */
+export declare function resolveTransferValidatorFlag(flags: Flags, publicClient: PublicClient, dryRun: boolean): Promise<Address>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"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"}