@artblocks/abx-cli 0.1.0-alpha.41 → 0.1.0-alpha.43

package/dist/commands/deploy.js

@@ -15,7 +15,7 @@
 import { createHash } from 'node:crypto';
 import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { basename, extname, join as joinPath, resolve as resolvePath } from 'node:path';
-import { DEFAULT_CHAIN_KEY, DEP_RESOLUTION, METADATA_FIELD as F, contentIdFromLocator, METADATA_REPRESENTATION as R, analyzeScript, assertChainId, checkRegistryDeps, dependencySetupCalls, deployOneOfOne, deploySeries, deployOneOfOneEdition, deployEditionImage, discoverDeployBlock, encodeFieldRenderer, encodeTag, expectedChainComplete, makeHotSender, makePublicClient, makeWalletClient, normalizeAttributes, onchainUriSetupCalls, oneOfOneImageAbi, oneOfOneEditionAbi, editionCodeAbi, parseTraitPairs, planResume, planEditionResume, predictClone, probeSeedSource, prepareCodeSetup, prepareDeployOneOfOne, prepareDeploySeries, prepareDeploySeriesCode, prepareDeployOneOfOneEdition, prepareDeployEditionImage, prepareDeployEditionCode, redactRpcUrl, resolveChain, resolveDepRegistryPointer, resolveGenerator, probeTransferValidator, resolveRecommendedTransferValidator, resolveRpcUrl, resolveSeedSource, resolveSeriesCodeFactory, saltFor, seriesCodeAbi, seriesCodeFactoryAbi, tryReadContract, AbxServiceClient, } from '@artblocks/abx-sdk';
+import { DEFAULT_CHAIN_KEY, DEP_RESOLUTION, METADATA_FIELD as F, contentIdFromLocator, METADATA_REPRESENTATION as R, analyzeScript, assertChainId, checkRegistryDeps, dependencySetupCalls, DEFAULT_TX_GAS_BUDGET, MEASURED_ESTIMATE_GAS_ALLOWANCE, SETUP_LEG_GAS, estimateChunkGasForBytes, packCallsByGas, deployOneOfOne, deploySeries, deployOneOfOneEdition, deployEditionImage, discoverDeployBlock, encodeFieldRenderer, encodeTag, expectedChainComplete, makeHotSender, makePublicClient, makeWalletClient, normalizeAttributes, onchainUriSetupCalls, oneOfOneImageAbi, oneOfOneEditionAbi, editionCodeAbi, parseTraitPairs, planResume, planEditionResume, predictClone, probeSeedSource, prepareCodeSetup, prepareDeployOneOfOne, prepareDeploySeries, prepareDeploySeriesCode, prepareDeployOneOfOneEdition, prepareDeployEditionImage, prepareDeployEditionCode, redactRpcUrl, resolveChain, resolveDepRegistryPointer, resolveGenerator, probeTransferValidator, resolveRecommendedTransferValidator, resolveRpcUrl, resolveSeedSource, resolveSeriesCodeFactory, saltFor, seriesCodeAbi, seriesCodeFactoryAbi, tryReadContract, AbxServiceClient, } from '@artblocks/abx-sdk';
 import { DIRECT_URL_BACKENDS, contentTypeFromPath, decideImageContentLane, hashContent, isTurboArweave, resolveBackend, validateRenderStorageCombo, } from '@artblocks/abx-storage';
 import { DEFAULT_PORT, contentHash, generateContent, resolveBaseUrl, startTokenApiServer } from '@artblocks/abx-token-api';
 import { encodeFunctionData, getAddress, toHex, zeroAddress } from 'viem';
@@ -34,7 +34,7 @@ import { describeSchema, editionSchemaAdvisory, parseSchemaSpecs } from '../sche
 import { parseSeriesTraits } from '../series-traits.js';
 import { decodeOnChainJson } from '../served.js';
 import { openWalletSession, signHotSequence, signTx } from '../signer.js';
-// ── plan-object warning capture (issue #123) ─────────────────────────────────────────────────────
+// ── plan-object warning capture ──────────────────────────────────────────────────────────────────
 // The structured `--json` plan object (deploy-plan.ts) reports "the warnings the lane raised"
 // alongside every other computed field — but ~400 `warn()` call sites in this file exist purely as
 // human prose, and rewriting each to ALSO push onto a collector would be exactly the kind of
@@ -926,10 +926,22 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
     // never disagree. Counts TX signatures only: a storage upload signed by a connected wallet
     // (Arweave via --storage-signer eth) is a message signature, not a transaction, and is already
     // named separately (see the `remoteEthUpload` narration) — it does not add to this count.
+    // Also captures the plan object's `custody.image` file metadata: the SAME
+    // bytes read here for the tx-count math, hashed/typed locally (no chain read) — never re-derived
+    // at the emit site below.
+    let planImageFile = null;
     const approvals = onchainImage
         ? (() => {
-            const plan = computeContentPlan(readFileSync(resolvePath(flags.image)), parseCompress(flags.compress)).plan;
-            return (plan.mode === 'single' ? 1 : plan.txCount) + 1; // staging tx(s) + the deploy tx
+            const bytes = readFileSync(resolvePath(flags.image));
+            const compress = parseCompress(flags.compress);
+            const contentPlan = computeContentPlan(bytes, compress);
+            planImageFile = {
+                bytes: bytes.length,
+                stagedBytes: contentPlan.stagedBytes,
+                mimeType: contentTypeFromPath(resolvePath(flags.image)),
+                contentHash: hashContent(bytes),
+            };
+            return (contentPlan.plan.mode === 'single' ? 1 : contentPlan.plan.txCount) + 1; // staging tx(s) + the deploy tx
         })()
         : 1;
     // Mint-on-deploy is the default; --no-mint defers it so you can stand up + warm
@@ -1061,7 +1073,7 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
         // could act on that the actual deploy will not land at. `saltPinned` still says why.
         emit(jsonSafe({
             command: 'deploy', dryRun: true, sent: false, address: explicitSalt ? predicted : null, chain: CHAIN, chainId: resolveChain(CHAIN).id, factory, salt, saltPinned: !!explicitSalt, name, symbol,
-            // The structured plan (issue #123) — built from the SAME locals the readout above just
+            // The structured plan — built from the SAME locals the readout above just
             // printed; nothing here is re-derived or newly computed. `deployer` is a real wallet address
             // regardless of salt pinning (only the PREDICTED CONTRACT address carries that caveat, and
             // this plan doesn't repeat it — see `address`, above), so roles are safe to report unconditionally.
@@ -1069,7 +1081,7 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
                 schemaVersion: DEPLOY_PLAN_SCHEMA_VERSION,
                 family: '1of1',
                 lane,
-                transactions: { approvals, legs: onchainImage ? ['onchain-image-staging'] : null },
+                transactions: { approvals, legs: onchainImage ? ['onchain-image-staging', 'deploy'] : null },
                 // The 1/1 lane's InitParams has no minter/primaryPayee field at all — `null` here means
                 // "no concept on this lane", not "unset".
                 roles: { signer: deployer, owner: deployer, royaltyReceiver: deployer, primaryPayee: null, minter: null },
@@ -1083,6 +1095,8 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
                     // "nothing baked", not an empty string to interpret.
                     tokenUriBase: params.tokenURIBase || null,
                     contractUriBase: params.contractURIBase || null,
+                    renderer: onChainUri ? renderer : null,
+                    image: planImageFile,
                 },
                 mint: { deferred: noMint, count: noMint ? 0 : 1, amountPerId: null, recipient: noMint ? null : deployer },
                 estimate: { ethApprox: null, gasApprox: null }, // the 1/1 lane computes no cost estimate
@@ -1216,7 +1230,7 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
             schemaVersion: DEPLOY_PLAN_SCHEMA_VERSION,
             family: '1of1',
             lane,
-            transactions: { approvals, legs: onchainImage ? ['onchain-image-staging'] : null },
+            transactions: { approvals, legs: onchainImage ? ['onchain-image-staging', 'deploy'] : null },
             roles: { signer: deployerAddr ?? null, owner: deployerAddr ?? null, royaltyReceiver: deployerAddr ?? null, primaryPayee: null, minter: null },
             royalty: { bps: royaltyBps, capBps: maxRoyaltyBps, burnable },
             custody: {
@@ -1227,6 +1241,8 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
                 // carries `params` out to this scope) — never a new decision, the identical ternary.
                 tokenUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/t`,
                 contractUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/c`,
+                renderer: onChainUri ? renderer : null,
+                image: planImageFile,
             },
             mint: { deferred: noMint, count: noMint ? 0 : 1, amountPerId: null, recipient: noMint ? null : deployerAddr ?? null },
             estimate: { ethApprox: null, gasApprox: null },
@@ -1522,10 +1538,21 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
     // The edition paths shipped without this and without the readout line below, so `--copies` previews
     // silently dropped the approval count the skill promises "every preview" prints — leaving an agent
     // with nothing to tell the creator about how many wallet prompts to expect.
+    // Also captures `custody.image` file metadata — see the 1/1 twin's identical
+    // local for why it's computed here rather than re-derived at the emit site.
+    let planImageFile = null;
     const approvals = onchainImage
         ? (() => {
-            const plan = computeContentPlan(readFileSync(resolvePath(flags.image)), parseCompress(flags.compress)).plan;
-            return (plan.mode === 'single' ? 1 : plan.txCount) + 1;
+            const bytes = readFileSync(resolvePath(flags.image));
+            const compress = parseCompress(flags.compress);
+            const contentPlan = computeContentPlan(bytes, compress);
+            planImageFile = {
+                bytes: bytes.length,
+                stagedBytes: contentPlan.stagedBytes,
+                mimeType: contentTypeFromPath(resolvePath(flags.image)),
+                contentHash: hashContent(bytes),
+            };
+            return (contentPlan.plan.mode === 'single' ? 1 : contentPlan.plan.txCount) + 1;
         })()
         : 1;
     if (onChainUri) {
@@ -1625,7 +1652,7 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
                 schemaVersion: DEPLOY_PLAN_SCHEMA_VERSION,
                 family: '1of1-edition',
                 lane,
-                transactions: { approvals, legs: onchainImage ? ['onchain-image-staging'] : null },
+                transactions: { approvals, legs: onchainImage ? ['onchain-image-staging', 'deploy'] : null },
                 roles: {
                     signer: deployer, owner: deployer, royaltyReceiver: deployer,
                     primaryPayee: primaryPayee !== zeroAddress ? primaryPayee : null,
@@ -1638,6 +1665,8 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
                     backend: !onChainUri && !onchainImage ? backendResolution(storageOverrides(flags)).backend : null,
                     tokenUriBase: params.tokenURIBase || null,
                     contractUriBase: params.contractURIBase || null,
+                    renderer: onChainUri ? renderer : null,
+                    image: planImageFile,
                 },
                 mint: { deferred: mintAmount === 0n, count: mintAmount > 0n ? 1 : 0, amountPerId: mintAmount.toString(), recipient: mintAmount > 0n ? deployer : null },
                 estimate: { ethApprox: null, gasApprox: null },
@@ -1722,7 +1751,7 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
             schemaVersion: DEPLOY_PLAN_SCHEMA_VERSION,
             family: '1of1-edition',
             lane,
-            transactions: { approvals, legs: onchainImage ? ['onchain-image-staging'] : null },
+            transactions: { approvals, legs: onchainImage ? ['onchain-image-staging', 'deploy'] : null },
             roles: {
                 signer: deployerAddr ?? null, owner: deployerAddr ?? null, royaltyReceiver: deployerAddr ?? null,
                 primaryPayee: primaryPayee !== zeroAddress ? primaryPayee : null,
@@ -1735,6 +1764,8 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
                 backend: !onChainUri && !onchainImage ? backendResolution(storageOverrides(flags)).backend : null,
                 tokenUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/t`,
                 contractUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/c`,
+                renderer: onChainUri ? renderer : null,
+                image: planImageFile,
             },
             mint: { deferred: mintAmount === 0n, count: mintAmount > 0n ? 1 : 0, amountPerId: mintAmount.toString(), recipient: mintAmount > 0n ? deployerAddr ?? null : null },
             estimate: { ethApprox: null, gasApprox: null },
@@ -2224,7 +2255,7 @@ export async function cmdDeploySeriesBody(flags, emit) {
                 lane,
                 // A staged on-chain collection is many chunk-write txs, one per file — that per-token detail
                 // is printed above (`previewImageStaging`), not re-derived here; `legs` just names the shape.
-                transactions: { approvals, legs: onchainImage ? ['onchain-image-staging (per token)'] : null },
+                transactions: { approvals, legs: onchainImage ? ['onchain-image-staging (per token)', 'deploy'] : null },
                 roles: {
                     signer: deployer, owner: deployer, royaltyReceiver: deployer,
                     primaryPayee: primaryPayee !== zeroAddress ? primaryPayee : null,
@@ -2237,6 +2268,10 @@ export async function cmdDeploySeriesBody(flags, emit) {
                     backend: offchainImageOnchainJson || !onChainUri ? backendId : null,
                     tokenUriBase: params.tokenURIBase || null,
                     contractUriBase: params.contractURIBase || null,
+                    renderer: onChainUri ? renderer : null,
+                    // Series stages ONE FILE PER TOKEN under --onchain-image — no single-file shape fits (see
+                    // this field's own doc comment) — so this stays null even when `imageOnChain` is true.
+                    image: null,
                 },
                 mint: { deferred: mintCount === 0, count: mintCount, amountPerId: null, recipient: mintCount > 0 ? deployer : null },
                 estimate: { ethApprox: null, gasApprox: null },
@@ -2355,7 +2390,7 @@ export async function cmdDeploySeriesBody(flags, emit) {
             schemaVersion: DEPLOY_PLAN_SCHEMA_VERSION,
             family: 'series',
             lane,
-            transactions: { approvals, legs: onchainImage ? ['onchain-image-staging (per token)'] : null },
+            transactions: { approvals, legs: onchainImage ? ['onchain-image-staging (per token)', 'deploy'] : null },
             roles: {
                 signer: deployerAddr ?? null, owner: deployerAddr ?? null, royaltyReceiver: deployerAddr ?? null,
                 primaryPayee: primaryPayee !== zeroAddress ? primaryPayee : null,
@@ -2368,6 +2403,8 @@ export async function cmdDeploySeriesBody(flags, emit) {
                 backend: offchainImageOnchainJson || !onChainUri ? backendId : null,
                 tokenUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/t`,
                 contractUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/c`,
+                renderer: onChainUri ? renderer : null,
+                image: null, // per-token staging — see the dry-run emit's identical comment
             },
             mint: { deferred: mintCount === 0, count: mintCount, amountPerId: null, recipient: mintCount > 0 ? deployerAddr ?? null : null },
             estimate: { ethApprox: null, gasApprox: null },
@@ -2819,7 +2856,7 @@ export async function cmdDeployEditionImageBody(flags, emit) {
                 schemaVersion: DEPLOY_PLAN_SCHEMA_VERSION,
                 family: 'series-edition',
                 lane,
-                transactions: { approvals, legs: onchainImage ? ['onchain-image-staging (per id)'] : null },
+                transactions: { approvals, legs: onchainImage ? ['onchain-image-staging (per id)', 'deploy'] : null },
                 roles: {
                     signer: deployer, owner: deployer, royaltyReceiver: deployer,
                     primaryPayee: primaryPayee !== zeroAddress ? primaryPayee : null,
@@ -2832,6 +2869,10 @@ export async function cmdDeployEditionImageBody(flags, emit) {
                     backend: !onchainImage && (offchainImageOnchainJson || !onChainUri) ? backendId : null,
                     tokenUriBase: params.tokenURIBase || null,
                     contractUriBase: params.contractURIBase || null,
+                    renderer: onChainUri ? renderer : null,
+                    // Series-edition stages ONE FILE PER id under --onchain-image — no single-file shape fits
+                    // (see this field's own doc comment) — so this stays null even when `imageOnChain` is true.
+                    image: null,
                 },
                 mint: {
                     deferred: effectiveMintCount === 0,
@@ -2915,7 +2956,7 @@ export async function cmdDeployEditionImageBody(flags, emit) {
             schemaVersion: DEPLOY_PLAN_SCHEMA_VERSION,
             family: 'series-edition',
             lane,
-            transactions: { approvals, legs: onchainImage ? ['onchain-image-staging (per id)'] : null },
+            transactions: { approvals, legs: onchainImage ? ['onchain-image-staging (per id)', 'deploy'] : null },
             roles: {
                 signer: deployerAddr ?? null, owner: deployerAddr ?? null, royaltyReceiver: deployerAddr ?? null,
                 primaryPayee: primaryPayee !== zeroAddress ? primaryPayee : null,
@@ -2928,6 +2969,8 @@ export async function cmdDeployEditionImageBody(flags, emit) {
                 backend: !onchainImage && (offchainImageOnchainJson || !onChainUri) ? backendId : null,
                 tokenUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/t`,
                 contractUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/c`,
+                renderer: onChainUri ? renderer : null,
+                image: null, // per-id staging — see the dry-run emit's identical comment
             },
             mint: {
                 deferred: effectiveMintCount === 0,
@@ -3245,6 +3288,76 @@ export const DEPLOY_SERIES_FLAGS = new Set([
 // module has finished evaluating.
 export const DEPLOY_EDITION_FLAGS = new Set([...DEPLOY_FLAGS, 'copies', 'mint-amount', 'minter', 'primary-payee', 'unpaused']);
 export const DEPLOY_SERIES_EDITION_FLAGS = new Set([...DEPLOY_SERIES_FLAGS, 'copies', 'mint-amount']);
+export const chunkSetupLeg = (index, hex, data) => {
+    const bytes = (hex.length - 2) / 2;
+    return { calls: [data], gas: estimateChunkGasForBytes(bytes), label: `script chunk [${index}] (${bytes} bytes)`, kind: 'chunk', chunkBytes: [bytes] };
+};
+export const schemaSetupLeg = (key, data) => ({
+    calls: [data], gas: SETUP_LEG_GAS.schema, label: `param schema '${key}'`, kind: 'schema', schemaKey: key,
+});
+export const depsSetupLeg = (calls) => ({
+    calls, gas: calls.length * SETUP_LEG_GAS.dependency, label: `${calls.length} dependency declaration(s)`, kind: 'deps',
+});
+export const uriSetupLeg = (calls) => ({
+    calls, gas: calls.length * SETUP_LEG_GAS.onchainUri, label: 'on-chain URI wiring', kind: 'uri',
+});
+export const mintSetupLeg = (data) => ({ calls: [data], gas: SETUP_LEG_GAS.mint, label: 'reserve mint', kind: 'mint' });
+/** `SetupLegsCore` (resume.ts's id-agnostic four leg groups, shared by both 721 and EditionCode) →
+ *  the gas-batching shape above — schemas individually (resume diffs them per-key too), deps and
+ *  on-chain-URI as one atomic leg apiece (resume diffs them as one group too — see resume.ts's
+ *  `planCoreLegs`). Mints are NOT included here: their shape differs by lane (721 whole-total vs
+ *  EditionCode per-id vs a `--resume` shortfall) — every caller builds its own mint legs. */
+export function coreSetupLegs(legs) {
+    return {
+        chunks: legs.chunks.map((c) => chunkSetupLeg(c.index, c.hex, c.data)),
+        config: [
+            ...legs.schemas.map((s) => schemaSetupLeg(s.key, s.data)),
+            ...(legs.deps.calls.length ? [depsSetupLeg(legs.deps.calls)] : []),
+            ...(legs.uri.calls.length ? [uriSetupLeg(legs.uri.calls)] : []),
+        ],
+    };
+}
+/**
+ * Split three ordered leg groups into gas-bounded batches — chunks, then config, then mints, NEVER
+ * mixed (see the module note above). Refuses BEFORE building anything if a single leg's own gas
+ * estimate alone exceeds the binding `eth_estimateGas` ceiling: batching only helps when the problem
+ * is too MANY legs, not one leg too big, and that case must never reach a raw "gas limit too high".
+ * Deterministic in the legs' `.gas` values alone (never their `.calls`), so calling this once early
+ * (to size `approvals`, before an owner is even known) and again later with the real calldata
+ * produces the IDENTICAL batch shape both times — no drift between what's previewed and what's sent.
+ */
+export function planCodeSetupBatches(groups) {
+    const all = [...groups.chunks, ...groups.config, ...groups.mints];
+    if (all.length === 0)
+        return [];
+    const oversized = all.find((leg) => leg.gas > MEASURED_ESTIMATE_GAS_ALLOWANCE);
+    if (oversized) {
+        throw new Error(`setup leg — ${oversized.label} — needs ~${oversized.gas.toLocaleString()} gas on its own, which exceeds the ` +
+            `~${MEASURED_ESTIMATE_GAS_ALLOWANCE.toLocaleString()} eth_estimateGas ceiling every transaction is bound by ` +
+            `(that RPC allowance is the binding constraint — not the higher block gas limit). No amount of batching can ` +
+            `make ONE leg fit a transaction by itself — shrink it before deploying (a smaller chunk size, fewer items in ` +
+            `this leg), then re-run.`);
+    }
+    const total = all.reduce((g, l) => g + l.gas, 0);
+    if (total <= DEFAULT_TX_GAS_BUDGET)
+        return [all]; // fits one tx — unchanged common-case behavior
+    return [...packCallsByGas(groups.chunks), ...packCallsByGas(groups.config), ...packCallsByGas(groups.mints)].filter((b) => b.length > 0);
+}
+/** Turn ordered setup-leg batches into the actual `prepareCodeSetup` transactions — rebuilding each
+ *  batch's chunk/schema/dependency/on-chain-URI labeling from its OWN legs, since a batch born from
+ *  the split may carry only part of a group (see {@link planCodeSetupBatches}). */
+export function codeSetupTxsFromBatches(batches, args) {
+    return batches.map((batch) => prepareCodeSetup({
+        contract: args.contract,
+        chainId: args.chainId,
+        calls: batch.flatMap((l) => l.calls),
+        chunkCount: batch.filter((l) => l.kind === 'chunk').length,
+        chunkBytes: batch.filter((l) => l.kind === 'chunk').flatMap((l) => l.chunkBytes ?? []),
+        schemaKeys: batch.filter((l) => l.kind === 'schema').map((l) => l.schemaKey),
+        deps: batch.some((l) => l.kind === 'deps') ? args.deps : [],
+        onchainUri: batch.some((l) => l.kind === 'uri'),
+    }));
+}
 export async function cmdDeployCode(flags) {
     // `--resume` targets an EXISTING contract — its standard (721 or edition) was fixed at THAT
     // contract's own deploy, so `--copies` (a creation-time choice) is nonsensical alongside it.
@@ -3686,7 +3799,7 @@ export async function cmdDeployCodeBody(flags, emit) {
     if (flags['image-renderer'] || flags['attributes-renderer']) {
         warn(`${bold('renderer check — yours to verify')} (the CLI confirms code at the address, NOT that render() behaves): an IAbxFieldRenderer must ` +
             `${bold('NEVER revert')} for any token/param state incl. the collection surface (tokenId = type(uint256).max) — a revert bricks the WHOLE tokenURI (no try/catch) — ` +
-            `and must return the right content-type (image → ${bold('image/svg+xml')} · attributes → a JSON array). Review the render function + forge-test it before shipping. Invariants: reference/code-projects.md.`);
+            `and must return the right content-type (image → ${bold('image/svg+xml')} · attributes → a JSON array). Review the render function + forge-test it before shipping. Invariants: reference/code.md.`);
     }
     // ── Surfaces disposition — resolve EVERY product dimension explicitly, up front ──────────────
     // A code project has four surfaces that each land somewhere (or nowhere). A real session shipped
@@ -3790,10 +3903,50 @@ export async function cmdDeployCodeBody(flags, emit) {
     // one whenever a dependency leg rode the multicall alongside a renderer-only (`foldIntoInit`) fold.
     const depLegs = deps.length + (depRegistry ? 1 : 0);
     const setupLen = scriptChunks.length + schemas.length + depLegs + (onchainUriLegs?.length ?? 0) + setupMintCount;
-    const approvals = 1 + (setupLen > 0 ? 1 : 0); // deploy tx + (a setup multicall only if something rides it)
-    // Ordered legs riding that setup multicall (if any), for the plan object's `transactions.legs` —
-    // the SAME booleans `setupLen`/`setupBits` (the dry-run's own `transactions:` line, below) already
-    // use, so this can't drift from the tx the wallet actually signs.
+    // The setup legs, GROUPED. The normal deploy flattens them; `--resume` diffs them against chain
+    // state and sends only what is missing (see resume.ts). One builder for both, so a resume can never
+    // drift from what a fresh deploy would have written — a second implementation of this sequence is
+    // the failure mode a repair verb most easily introduces. Moved up here (it used to sit right before
+    // `preparedFor`, far below) so `approvals`/`planSetupLegs`/the dry-run's tx-count line can all size
+    // themselves off the SAME gas-bounded batch plan `preparedFor` actually sends — see
+    // `planCodeSetupBatches`'s own doc for why calling it here with a placeholder owner and again below
+    // with the real one can never disagree (it's a pure function of each leg's `.gas`, never its
+    // `.calls`, and owner only ever appears in a mint call's calldata, never its gas).
+    const setupLegGroups = (owner) => ({
+        chunks: scriptChunks.map((chunk, i) => ({
+            index: i,
+            hex: chunk,
+            data: encodeFunctionData({ abi: seriesCodeAbi, functionName: 'setScriptChunk', args: [BigInt(i), chunk] }),
+        })),
+        schemas: schemas.map(({ key, paramType, auth, authAddress, lockAfter, min, max, selectOptions }) => ({
+            key,
+            data: encodeFunctionData({ abi: seriesCodeAbi, functionName: 'setParamSchema', args: [encodeTag(key), paramType, auth, authAddress, lockAfter, min, max, selectOptions] }),
+        })),
+        deps: { count: deps.length, registry: depRegistry ?? null, calls: dependencySetupCalls(deps, depRegistry) },
+        // program lane only: animation_url field · the URI renderers (before the mints)
+        uri: { calls: onchainUriLegs ?? [], animationField: onchainUriLegs?.length ? F.animationUrl : null },
+        // The INTENDED TOTAL, not a count to add — a resume mints the shortfall. `mintCount` covers both
+        // lanes: folded-into-init (renderer-only) and setup-carried, since either way it is what the
+        // creator asked for.
+        mints: { intendedTotal: mintCount, data: encodeFunctionData({ abi: seriesCodeAbi, functionName: 'mint', args: [owner] }) },
+    });
+    // Gas-bounded setup-transaction batches for a FRESH deploy — chunks, then config, then mints, never
+    // mixed (see `planCodeSetupBatches`). `owner` is irrelevant to the batch SHAPE (only a mint call's
+    // calldata embeds it, never its gas), so `zeroAddress` here is a placeholder that's never sent —
+    // it exists purely so `approvals`/`planSetupLegs` (and the dry-run prose) can report the REAL
+    // transaction count before a deployer is even known, with zero risk of drifting from what
+    // `preparedFor` below actually builds and sends.
+    const freshDeployBatches = planCodeSetupBatches({
+        ...coreSetupLegs(setupLegGroups(zeroAddress)),
+        mints: Array.from({ length: setupMintCount }, () => mintSetupLeg('0x')),
+    });
+    const approvals = 1 + freshDeployBatches.length; // deploy tx + however many gas-bounded setup batches
+    // Ordered legs riding the setup (if any), for the plan object's `transactions.legs` — GROUP names,
+    // not a literal per-transaction count (a group can span more than one batch — see deploy-plan.ts's
+    // own doc comment on `legs`). The SAME booleans `setupLen`/`setupBits` (the dry-run's own
+    // `transactions:` line, below) already use, so this can't drift from the tx(es) the wallet actually
+    // signs. Always ends with `'deploy'` when non-null — the setup batch(es) (if any) ride AHEAD of the
+    // deploy tx, never instead of it.
     const planSetupLegs = setupLen > 0
         ? [
             scriptChunks.length ? 'chunks' : null,
@@ -3801,6 +3954,7 @@ export async function cmdDeployCodeBody(flags, emit) {
             depLegs ? 'dependencies' : null,
             onchainUriLegs ? 'onchain-uri' : null,
             setupMintCount ? 'mints' : null,
+            'deploy',
         ].filter((leg) => leg !== null)
         : null;
     // opt-in --confirm: one y/N before ANY upload or send (no-op without --confirm; never blocks scripts).
@@ -3918,8 +4072,12 @@ export async function cmdDeployCodeBody(flags, emit) {
             onchainUriLegs ? 'on-chain-uri' : '',
             setupMintCount ? 'mints' : '',
         ].filter(Boolean).join('/');
-        info(`transactions: ${1 + (setupLen > 0 ? 1 : 0)} (deploy${foldIntoInit ? ' — on-chain-uri wiring + mint fold into it' : ''}${setupLen > 0 ? ` + one setup multicall: ${setupBits}` : ''})` +
-            (foldIntoInit && setupLen === 0 ? ` ${dim('— single transaction, fully self-contained')}` : ''));
+        info(`transactions: ${approvals} (deploy${foldIntoInit ? ' — on-chain-uri wiring + mint fold into it' : ''}` +
+            (freshDeployBatches.length > 0
+                ? ` + ${freshDeployBatches.length} setup ${freshDeployBatches.length === 1 ? 'transaction' : 'transactions (gas-bounded)'}: ${setupBits}`
+                : '') +
+            ')' +
+            (foldIntoInit && freshDeployBatches.length === 0 ? ` ${dim('— single transaction, fully self-contained')}` : ''));
         info(`approvals   ${approvals} wallet approval(s)`); // TX signatures only; the same number the tx-count line above implies
         // Best-effort cost guidance (owner: a bonus in dry-run, never a blocker — silently skip if the
         // RPC can't price gas; see cli-ux-decisions). On-chain byte storage dominates a template drop,
@@ -4105,6 +4263,9 @@ export async function cmdDeployCodeBody(flags, emit) {
                     backend: dirUpload ? dirUpload.backend.id : null,
                     tokenUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/t`,
                     contractUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/c`,
+                    renderer: onChainUri ? metadataRenderer : null,
+                    // This lane has no single `--image` file — see `surfaces.thumbnail` below instead.
+                    image: null,
                 },
                 mint: { deferred: mintCount === 0, count: mintCount, amountPerId: null, recipient: mintCount > 0 ? deployer : null },
                 estimate: planEstimate ?? { ethApprox: null, gasApprox: null },
@@ -4168,47 +4329,21 @@ export async function cmdDeployCodeBody(flags, emit) {
         tokenFields: [],
         contractFields,
     });
-    // The setup legs, GROUPED. The normal deploy flattens them; `--resume` diffs them against chain
-    // state and sends only what is missing (see resume.ts). One builder for both, so a resume can never
-    // drift from what a fresh deploy would have written — a second implementation of this sequence is
-    // the failure mode a repair verb most easily introduces.
-    const setupLegGroups = (owner) => ({
-        chunks: scriptChunks.map((chunk, i) => ({
-            index: i,
-            hex: chunk,
-            data: encodeFunctionData({ abi: seriesCodeAbi, functionName: 'setScriptChunk', args: [BigInt(i), chunk] }),
-        })),
-        schemas: schemas.map(({ key, paramType, auth, authAddress, lockAfter, min, max, selectOptions }) => ({
-            key,
-            data: encodeFunctionData({ abi: seriesCodeAbi, functionName: 'setParamSchema', args: [encodeTag(key), paramType, auth, authAddress, lockAfter, min, max, selectOptions] }),
-        })),
-        deps: { count: deps.length, registry: depRegistry ?? null, calls: dependencySetupCalls(deps, depRegistry) },
-        // program lane only: animation_url field · the URI renderers (before the mints)
-        uri: { calls: onchainUriLegs ?? [], animationField: onchainUriLegs?.length ? F.animationUrl : null },
-        // The INTENDED TOTAL, not a count to add — a resume mints the shortfall. `mintCount` covers both
-        // lanes: folded-into-init (renderer-only) and setup-carried, since either way it is what the
-        // creator asked for.
-        mints: { intendedTotal: mintCount, data: encodeFunctionData({ abi: seriesCodeAbi, functionName: 'mint', args: [owner] }) },
-    });
-    const setupCalls = (owner) => {
-        const g = setupLegGroups(owner);
-        return [
-            ...g.chunks.map((c) => c.data),
-            ...g.schemas.map((x) => x.data),
-            ...g.deps.calls,
-            ...g.uri.calls,
-            // folded mints ride init, not here — so this uses setupMintCount, not the intended total.
-            ...Array.from({ length: setupMintCount }, () => g.mints.data),
-        ];
-    };
+    // `setupLegGroups` (the shared, resume-compatible builder) and the fresh-deploy batch shape
+    // (`freshDeployBatches`) are hoisted above — see the comment there for why. Build the REAL
+    // transactions for the actual signer from the SAME batch shape (identical `.gas` sequence ⇒
+    // identical split — see `planCodeSetupBatches`'s doc), this time with real mint calldata.
     const cid = resolveChain(CHAIN).id;
     const preparedFor = async (owner) => {
         const salt = parseSaltFlag(flags.salt) ?? saltFor(owner);
         const clone = (await publicClient.readContract({ address: factory, abi: seriesCodeFactoryAbi, functionName: 'predictDeterministicAddress', args: [salt] }));
-        const calls = setupCalls(owner);
-        const txs = [prepareDeploySeriesCode({ factory, params: initParamsFor(owner), salt, chainId: cid, clone })];
-        if (calls.length)
-            txs.push(prepareCodeSetup({ contract: clone, calls, chainId: cid, chunkCount: scriptChunks.length, chunkBytes: scriptChunks.map((h) => (h.length - 2) / 2), schemaKeys: schemas.map((x) => x.key), deps: deps.map((d) => d.display), onchainUri: onChainUri && hasProgram }));
+        const g = setupLegGroups(owner);
+        const batches = planCodeSetupBatches({
+            ...coreSetupLegs(g),
+            mints: Array.from({ length: setupMintCount }, () => mintSetupLeg(g.mints.data)),
+        });
+        const setupTxs = codeSetupTxsFromBatches(batches, { contract: clone, chainId: cid, deps: deps.map((d) => d.display) });
+        const txs = [prepareDeploySeriesCode({ factory, params: initParamsFor(owner), salt, chainId: cid, clone }), ...setupTxs];
         return { clone, txs };
     };
     // ── --resume: finish an EXISTING contract, deploy nothing ──────────────────────────────────
@@ -4337,7 +4472,9 @@ export async function cmdDeployCodeBody(flags, emit) {
             lane,
             roles: { signer: owner, owner, royaltyReceiver: null, primaryPayee: null, minter: null },
             royalty: null,
-            custody: { onChainUri, imageOnChain: null, backend: null, tokenUriBase: null, contractUriBase: null },
+            // renderer/image: null — both are InitParams facts fixed at the ORIGINAL deploy (like
+            // royalty/mint above); a resume doesn't re-read or re-decide either here.
+            custody: { onChainUri, imageOnChain: null, backend: null, tokenUriBase: null, contractUriBase: null, renderer: null, image: null },
             mint: null,
             warnings: planWarnings.slice(),
             // Still reflects what THIS invocation's flags say about every marketplace-facing surface —
@@ -4364,19 +4501,46 @@ export async function cmdDeployCodeBody(flags, emit) {
             console.log('');
             return;
         }
-        const tx = prepareCodeSetup({
+        // Reconstruct `plan.calls` (one flat, ORDERED array) back into the four leg groups it was built
+        // from — chunks, schemas, deps, uri, in that exact order (resume.ts's `planCoreLegs` guarantees
+        // it; see its module doc) — using the counts `plan.sending` already reports, so this can't drift
+        // from what the diff actually decided to send. Mints (whatever is left) are appended by
+        // `planResume`/`planEditionResume` AFTER these four, also guaranteed by resume.ts.
+        let resumeCallPtr = 0;
+        const takeResumeCalls = (n) => {
+            const slice = plan.calls.slice(resumeCallPtr, resumeCallPtr + n);
+            resumeCallPtr += n;
+            return slice;
+        };
+        const missingChunkCalls = takeResumeCalls(plan.sending.chunkIndices.length);
+        const missingSchemaCalls = takeResumeCalls(plan.sending.schemaKeys.length);
+        const missingDepsCalls = takeResumeCalls(plan.sending.deps ? legs.deps.calls.length : 0);
+        const missingUriCalls = takeResumeCalls(plan.sending.uri ? legs.uri.calls.length : 0);
+        const missingMintCalls = takeResumeCalls(plan.sending.mints);
+        // Same gas-bounded batching a fresh deploy uses (`planCodeSetupBatches`) — a `--resume` whose
+        // setup never landed AT ALL is missing exactly as much as a fresh deploy would have sent, so it
+        // needs the identical split to clear the same `eth_estimateGas` ceiling.
+        const resumeBatches = planCodeSetupBatches({
+            chunks: missingChunkCalls.map((data, i) => {
+                const bytes = plan.sending.chunkBytes[i];
+                return { calls: [data], gas: estimateChunkGasForBytes(bytes), label: `script chunk [${plan.sending.chunkIndices[i]}] (${bytes} bytes)`, kind: 'chunk', chunkBytes: [bytes] };
+            }),
+            config: [
+                ...missingSchemaCalls.map((data, i) => schemaSetupLeg(plan.sending.schemaKeys[i], data)),
+                ...(missingDepsCalls.length ? [depsSetupLeg(missingDepsCalls)] : []),
+                ...(missingUriCalls.length ? [uriSetupLeg(missingUriCalls)] : []),
+            ],
+            mints: missingMintCalls.map(mintSetupLeg),
+        });
+        const setupTxs = codeSetupTxsFromBatches(resumeBatches, {
             contract: target,
-            calls: plan.calls,
             chainId: resolveChain(CHAIN).id,
-            chunkCount: plan.sending.chunkIndices.length,
-            chunkBytes: plan.sending.chunkBytes,
-            schemaKeys: plan.sending.schemaKeys,
             deps: plan.sending.deps ? deps.map((d) => d.display) : [],
-            onchainUri: plan.sending.uri,
         });
-        // A resume always sends its missing legs as ONE setup-multicall tx — one wallet approval — so
-        // `transactions.legs` names WHICH groups ride it, from the same `plan.sending` flags that build
-        // the tx above (never re-derived).
+        // `transactions.legs` names WHICH groups ride the setup, from the same `plan.sending` flags that
+        // build the batches above (never re-derived) — GROUP names, not a literal per-transaction count
+        // (see deploy-plan.ts's own doc comment on `legs`; a `--resume` may now send more than one setup
+        // transaction, same as a fresh deploy).
         const resumeLegs = [
             plan.sending.chunkIndices.length ? 'chunks' : null,
             plan.sending.schemaKeys.length ? 'param-schemas' : null,
@@ -4388,39 +4552,49 @@ export async function cmdDeployCodeBody(flags, emit) {
         // This used to be its own hand-rolled copy of that exact shape (a dry-run print then confirmSend
         // then signTx, duplicated from ownerops.ts's `runWrite`); a deploy-family write is a write like
         // any other, so it takes the identical gate (the preview also gains the `to`/`owner` lines
-        // `runWrite`'s preview always printed).
+        // `runWrite`'s preview always printed) — called once per gas-bounded batch, in order.
         if (isDryRun(flags)) {
             emit(jsonSafe({
                 command: 'deploy-code', kind: isEdition ? 'edition-code' : 'code', resumed: target, chain: CHAIN, chainId: resolveChain(CHAIN).id, dryRun: true, sent: false, complete: false, sentLegs: plan.calls.length,
                 plan: {
                     ...resumePlanBase,
-                    transactions: { approvals: 1, legs: resumeLegs },
+                    transactions: { approvals: setupTxs.length, legs: resumeLegs },
                     estimate: { ethApprox: null, gasApprox: null },
                     resume: { target, sentLegs: plan.calls.length, complete: false },
                 },
             }));
         }
-        const result = await gatedSend(() => tx, flags, { chainKey: CHAIN, expectedSigner: owner });
-        if (!result) {
-            if (isDryRun(flags))
-                return;
-            console.log(`\n${dim('  unsigned — broadcast it, then re-run `abx verify ' + target + '` to confirm the setup completed.')}\n`);
+        let lastResult = null;
+        for (const tx of setupTxs) {
+            const result = await gatedSend(() => tx, flags, { chainKey: CHAIN, expectedSigner: owner });
+            if (result) {
+                ok(`${tx.summary}`);
+                lastResult = result;
+            }
+        }
+        if (isDryRun(flags))
+            return;
+        if (!lastResult) {
+            // The cold ('unsigned') lane: every batch printed its own unsigned tx above (in order — they
+            // target the SAME already-existing contract, so unlike a fresh deploy's deploy→setup dependency
+            // there's no reason to withhold the later ones). Nothing was broadcast, so there is no block to
+            // scan from and no indexing to do yet.
+            console.log(`\n${dim(`  unsigned — broadcast ${setupTxs.length > 1 ? 'these, in order,' : 'it'} then re-run \`abx verify ${target}\` to confirm the setup completed.`)}\n`);
             emit(jsonSafe({
                 command: 'deploy-code', kind: isEdition ? 'edition-code' : 'code', resumed: target, chain: CHAIN, chainId: resolveChain(CHAIN).id, sent: false, complete: false, sentLegs: plan.calls.length,
                 plan: {
                     ...resumePlanBase,
-                    transactions: { approvals: 1, legs: resumeLegs },
+                    transactions: { approvals: setupTxs.length, legs: resumeLegs },
                     estimate: { ethApprox: null, gasApprox: null },
                     resume: { target, sentLegs: plan.calls.length, complete: false },
                 },
             }));
             return;
         }
-        ok(`${tx.summary}`);
         // Locals, not the outer clone/deployBlock: this branch never falls through to the deploy path, and
         // the authoritative scan floor is still the clone's CREATION block (getCode search), not this
         // repair tx's block — flooring the resolver above the deploy would hide the `code` field again.
-        const resumedFloor = (await discoverDeployBlock(publicClient, target)) ?? result.blockNumber;
+        const resumedFloor = (await discoverDeployBlock(publicClient, target)) ?? lastResult.blockNumber;
         emit(jsonSafe({
             command: 'deploy-code',
             kind: isEdition ? 'edition-code' : 'code',
@@ -4432,10 +4606,10 @@ export async function cmdDeployCodeBody(flags, emit) {
             sent: true,
             complete: true,
             sentLegs: plan.calls.length,
-            txHash: result.txHash,
+            txHash: lastResult.txHash,
             plan: {
                 ...resumePlanBase,
-                transactions: { approvals: 1, legs: resumeLegs },
+                transactions: { approvals: setupTxs.length, legs: resumeLegs },
                 estimate: { ethApprox: null, gasApprox: null },
                 resume: { target, sentLegs: plan.calls.length, complete: true },
             },
@@ -4563,6 +4737,8 @@ export async function cmdDeployCodeBody(flags, emit) {
                 backend: dirUpload ? dirUpload.backend.id : null,
                 tokenUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/t`,
                 contractUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/c`,
+                renderer: onChainUri ? metadataRenderer : null,
+                image: null, // see `surfaces.thumbnail`
             },
             mint: { deferred: mintCount === 0, count: mintCount, amountPerId: null, recipient: mintCount > 0 ? deployerAddr ?? null : null },
             // Unlike the dry run, the sent path computes no cost estimate (the gas-guidance try/catch is
@@ -5004,10 +5180,11 @@ export async function cmdDeployEditionCodeBody(flags, emit) {
     const minter = flags.minter ?? zeroAddress;
     const primaryPayee = flags['primary-payee'] ?? zeroAddress;
     const explicitSalt = parseSaltFlag(flags.salt);
-    // Always TWO transactions (deploy + one setup multicall) — this leaner lane skips the 721 code
-    // lane's "fold reserve mints + renderers into init" micro-optimization (only reachable there for
-    // a renderer-only, no-program drop, which this function refuses anyway — every edition-code
-    // deploy has a program).
+    // Normally TWO transactions (deploy + one gas-bounded setup batch) — this leaner lane skips the
+    // 721 code lane's "fold reserve mints + renderers into init" micro-optimization (only reachable
+    // there for a renderer-only, no-program drop, which this function refuses anyway — every
+    // edition-code deploy has a program). A setup large enough to miss the `eth_estimateGas` ceiling
+    // (a big script) splits into MORE than one setup transaction — see `planCodeSetupBatches`.
     const initParamsFor = (owner) => ({
         owner,
         name,
@@ -5033,55 +5210,42 @@ export async function cmdDeployEditionCodeBody(flags, emit) {
         tokenFields: [],
         contractFields,
     });
-    const setupCallsFor = (owner) => {
-        const calls = [];
-        for (let i = 0; i < scriptChunks.length; i++) {
-            calls.push(encodeFunctionData({ abi: seriesCodeAbi, functionName: 'setScriptChunk', args: [BigInt(i), scriptChunks[i]] }));
-        }
-        for (const s of schemas) {
-            calls.push(encodeFunctionData({
-                abi: seriesCodeAbi,
-                functionName: 'setParamSchema',
-                args: [encodeTag(s.key), s.paramType, s.auth, s.authAddress, s.lockAfter, s.min, s.max, s.selectOptions],
-            }));
-        }
-        // Dependency legs, ordered (index 0 = the runtime) + the SOFT registry pointer when one resolved.
-        // Built by the SDK's shared `dependencySetupCalls` — the same function the 721 lane uses — so the
-        // two lanes can never encode `setDependency` differently.
-        calls.push(...dependencySetupCalls(deps, depRegistry));
-        calls.push(...onchainUriLegs);
-        // Reserve mints: one `mint(to, id, amount)` per premint id — the edition twin of the 721 lane's
-        // N identical `mint(owner)` calls, one id finer (a specific amount of copies, not just "one").
-        for (let id = 0; id < mintCount; id++) {
-            calls.push(encodeFunctionData({ abi: oneOfOneEditionAbi, functionName: 'mint', args: [owner, BigInt(id), mintAmount] }));
-        }
-        return calls;
-    };
+    // Gas-bounded setup-transaction legs — script chunks, schemas, deps, on-chain-URI wiring are all
+    // OWNER-INDEPENDENT (only a mint call's calldata embeds the owner+id+amount; its gas is a flat
+    // constant regardless), so they're built once, up front, and reused both to size
+    // `approvals`/`planSetupLegs` now and to build the real transactions in `preparedFor` below —
+    // identical `.gas` sequence ⇒ identical split (see `planCodeSetupBatches`'s own doc for why that
+    // can never drift).
+    const chunkLegs = scriptChunks.map((chunk, i) => chunkSetupLeg(i, chunk, encodeFunctionData({ abi: seriesCodeAbi, functionName: 'setScriptChunk', args: [BigInt(i), chunk] })));
+    const depCallsForEdition = dependencySetupCalls(deps, depRegistry);
+    const configLegs = [
+        ...schemas.map((s) => schemaSetupLeg(s.key, encodeFunctionData({ abi: seriesCodeAbi, functionName: 'setParamSchema', args: [encodeTag(s.key), s.paramType, s.auth, s.authAddress, s.lockAfter, s.min, s.max, s.selectOptions] }))),
+        ...(depCallsForEdition.length ? [depsSetupLeg(depCallsForEdition)] : []),
+        ...(onchainUriLegs.length ? [uriSetupLeg(onchainUriLegs)] : []),
+    ];
+    // Reserve mints: one `mint(to, id, amount)` per premint id — the edition twin of the 721 lane's N
+    // identical `mint(owner)` calls, one id finer (a specific amount of copies, not just "one").
+    const mintLegsFor = (owner) => Array.from({ length: mintCount }, (_, id) => mintSetupLeg(encodeFunctionData({ abi: oneOfOneEditionAbi, functionName: 'mint', args: [owner, BigInt(id), mintAmount] })));
+    // `owner` is irrelevant to the batch SHAPE (see the comment above), so `zeroAddress` here is a
+    // placeholder used purely to size `approvals` before a deployer is known — never sent.
+    const editionSetupBatches = planCodeSetupBatches({ chunks: chunkLegs, config: configLegs, mints: mintLegsFor(zeroAddress) });
     const preparedFor = async (owner) => {
         const salt = explicitSalt ?? saltFor(owner);
         const clone = await predictClone(publicClient, { factory, salt });
-        const calls = setupCallsFor(owner);
-        const txs = [prepareDeployEditionCode({ factory, params: initParamsFor(owner), salt, chainId, clone })];
-        if (calls.length) {
-            txs.push(prepareCodeSetup({
-                contract: clone,
-                calls,
-                chainId,
-                chunkCount: scriptChunks.length,
-                chunkBytes: scriptChunks.map((h) => (h.length - 2) / 2),
-                schemaKeys: schemas.map((s) => s.key),
-                onchainUri: onChainUri,
-            }));
-        }
+        const setupTxs = codeSetupTxsFromBatches(planCodeSetupBatches({ chunks: chunkLegs, config: configLegs, mints: mintLegsFor(owner) }), { contract: clone, chainId, deps: deps.map((d) => d.display) });
+        const txs = [prepareDeployEditionCode({ factory, params: initParamsFor(owner), salt, chainId, clone }), ...setupTxs];
         return { clone, txs };
     };
-    // deps ride the same single setup multicall as chunks/schemas/mints, so they don't add an approval —
-    // but they must be COUNTED in the "is there a setup multicall at all" test, or a deps-only project
-    // (a script with no schemas and no premints) would report 1 approval and send 2 transactions.
-    const depLegCount = dependencySetupCalls(deps, depRegistry).length;
-    const approvals = 1 + (scriptChunks.length + schemas.length + depLegCount + onchainUriLegs.length + mintCount > 0 ? 1 : 0);
-    // Ordered legs riding the setup multicall (if any) — same booleans `approvals` above uses, so the
-    // plan object's `transactions.legs` can never drift from the tx the wallet actually signs.
+    // deps ride the same setup batch as chunks/schemas/mints when everything fits one transaction, so
+    // they don't add an approval on their own — but they must be COUNTED in the "is there a setup
+    // transaction at all" test, or a deps-only project (a script with no schemas and no premints) would
+    // report 1 approval and send 2 transactions.
+    const depLegCount = depCallsForEdition.length;
+    const approvals = 1 + editionSetupBatches.length; // deploy tx + however many gas-bounded setup batches
+    // Ordered legs riding the setup (if any) — GROUP names, not a literal per-transaction count (see
+    // deploy-plan.ts's own doc comment on `legs`); same booleans `approvals` above is built from, so the
+    // plan object's `transactions.legs` can never drift from the tx(es) the wallet actually signs.
+    // Always ends with `'deploy'` when non-null.
     const planSetupLegs = approvals > 1
         ? [
             scriptChunks.length ? 'chunks' : null,
@@ -5089,6 +5253,7 @@ export async function cmdDeployEditionCodeBody(flags, emit) {
             depLegCount ? 'dependencies' : null,
             onchainUriLegs.length ? 'onchain-uri' : null,
             mintCount ? 'mints' : null,
+            'deploy',
         ].filter((leg) => leg !== null)
         : null;
     if (!dryRun) {
@@ -5129,7 +5294,8 @@ export async function cmdDeployEditionCodeBody(flags, emit) {
         printSeedSourcePlan(seedSource, chainId);
         info(`PostParam schema(s): ${schemas.length ? schemas.map((s) => describeSchema(s)).join(', ') : 'none'}`);
         info(`mint: ${mintCount > 0 ? `${mintCount} id(s) × ${mintAmount} cop${mintAmount === 1n ? 'y' : 'ies'} → ${deployer ?? 'your wallet'} at deploy` : 'deferred (mint later / external minter)'}`);
-        info(`transactions: 2 — deploy + setup multicall (${[scriptChunks.length ? 'script chunks' : null, schemas.length ? 'schemas' : null, onChainUri ? 'on-chain URI wiring' : null, mintCount > 0 ? 'reserve mints' : null].filter(Boolean).join(' + ') || 'nothing else'})`);
+        info(`transactions: ${approvals} — deploy + ${editionSetupBatches.length} setup ${editionSetupBatches.length === 1 ? 'transaction' : 'transactions (gas-bounded)'} ` +
+            `(${[scriptChunks.length ? 'script chunks' : null, schemas.length ? 'schemas' : null, onChainUri ? 'on-chain URI wiring' : null, mintCount > 0 ? 'reserve mints' : null].filter(Boolean).join(' + ') || 'nothing else'})`);
         info(`approvals   ${approvals} wallet approval(s)`); // parity with the 721 code twin — it had this only in the --confirm sentence
         if (!explicitSalt && deployer) {
             console.log(`\n  ${bold('salt')}  ${g(salt)}`);
@@ -5155,6 +5321,8 @@ export async function cmdDeployEditionCodeBody(flags, emit) {
                     backend: dirUpload ? dirUpload.backend.id : null,
                     tokenUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/t`,
                     contractUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/c`,
+                    renderer: onChainUri ? metadataRenderer : null,
+                    image: null, // no single --image file on this lane (see custody.image's own doc comment)
                 },
                 mint: {
                     deferred: mintCount === 0,
@@ -5254,6 +5422,8 @@ export async function cmdDeployEditionCodeBody(flags, emit) {
                 backend: dirUpload ? dirUpload.backend.id : null,
                 tokenUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/t`,
                 contractUriBase: onChainUri && !hasPublicUrl ? null : `${baseUrl}/c`,
+                renderer: onChainUri ? metadataRenderer : null,
+                image: null,
             },
             mint: {
                 deferred: mintCount === 0,