@artblocks/abx-cli 0.1.0-alpha.20 → 0.1.0-alpha.21

package/dist/commands/deploy.js

@@ -1190,13 +1190,15 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
     const dryRun = isDryRun(flags);
     const onchainImage = !!flags['onchain-image'];
     // Pure flag-combo validation — checked BEFORE any chain read (predict/factory/renderer all touch
-    // the network), same reasoning every other "this combo can never work" refusal in this file uses
-    // (e.g. the localhost-URL checks). Sequential staging (chunk tx → deploy) can't be split across
-    // the wallet-session/cold lanes in this pass (see the module-level scope note) — refuse rather
-    // than half-build it.
-    if (onchainImage && lane !== 'send') {
-        throw new Error('--onchain-image on an edition deploy is wired for the hot lane only right now (a funded ABX_DEPLOYER_PK) — ' +
-            'drop --onchain-image (off-chain custody or --onchain-uri still work on every lane), or switch to the hot lane. Tracked as a follow-up.');
+    // the network), same reasoning every other "this combo can never work" refusal in this file uses.
+    // Staging is a SEQUENCE (chunk write(s) → the deploy that references the manifest) where each tx's
+    // receipt feeds the next, so it cannot be signed offline in one run — the cold lane is refused on
+    // every lineage, 721 and edition alike. The wallet lane CAN do it (one session signs the chunk
+    // writes and the deploy); this edition path was hot-lane-only purely because it lacked that
+    // session branch, which it now has.
+    if (onchainImage && lane === 'unsigned') {
+        throw new Error('Staging an on-chain image (--onchain-image) needs interactive signing — each chunk tx feeds ' +
+            "the next, so it can't run on the cold lane (--unsigned). Use the hot lane (a funded key) or --sign (browser wallet).");
     }
     if (dryRun)
         assertPreviewDeployer(flags);
@@ -1273,18 +1275,23 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
     }
     step(`Deploy an edition of "${name}" to ${CHAIN}`);
     let bakedImage;
+    // On the WALLET lane staging cannot happen here — it has to run inside the sign session, after the
+    // connect, so the connecting wallet pays for and owns every chunk write. `stageNow` is the hot-lane
+    // (and dry-run) path; the session branch below calls the same helper with a session-backed sender.
+    const stageOnChainImage = async (sender) => {
+        const { field, note } = await stageImageField(flags.image, parseCompress(flags.compress), sender);
+        bakedImage = field;
+        info(note);
+    };
     if (onchainImage) {
         if (!flags.image)
             throw new Error('--onchain-image needs --image <path> (the bytes to put on-chain)');
         step('Stage on-chain image');
-        if (dryRun) {
+        if (dryRun)
             info(previewImageStaging(flags.image, parseCompress(flags.compress)));
-        }
-        else {
-            const { field, note } = await stageImageField(flags.image, parseCompress(flags.compress), envStagingSender());
-            bakedImage = field;
-            info(note);
-        }
+        else if (lane === 'send')
+            await stageOnChainImage(envStagingSender());
+        // lane === 'sign' → staged inside the wallet session further down.
     }
     const explicitSalt = parseSaltFlag(flags.salt);
     const noMint = flags['no-mint'] !== undefined;
@@ -1295,6 +1302,21 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
     const minter = flags.minter ?? zeroAddress;
     const primaryPayee = flags['primary-payee'] ?? zeroAddress;
     const paused = flags.unpaused === undefined;
+    // Same wallet-signature math as the 721 twin (see `cmdDeployBody`): staging tx(s) + the deploy tx.
+    // 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.
+    const approvals = onchainImage
+        ? (() => {
+            const plan = computeContentPlan(readFileSync(resolvePath(flags.image)), parseCompress(flags.compress)).plan;
+            return (plan.mode === 'single' ? 1 : plan.txCount) + 1;
+        })()
+        : 1;
+    if (onChainUri) {
+        info(`uri()/contractURI() resolve ON-CHAIN via the renderer — no resolver, no server, no localhost.`);
+        if (!hasPublicUrl)
+            info('off-chain fallback pointer left empty (the renderer is authoritative); set --public-base-url to bake one anyway.');
+    }
     const buildForDeployer = async (deployer) => {
         const salt = explicitSalt ?? saltFor(deployer);
         const clone = await predictClone(publicClient, { factory, salt });
@@ -1367,6 +1389,7 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
         if (primaryPayee !== zeroAddress)
             info(`primary payee  ${primaryPayee}`);
         info(`paused  ${paused}${flags.unpaused ? '' : dim('  (default — pass --unpaused to open at deploy)')}`);
+        info(`approvals   ${approvals} wallet approval(s)`); // parity with the 721 twin — TX signatures only
         if (!explicitSalt) {
             console.log(`\n  ${bold('salt')}  ${g(salt)}`);
             info(`address: pinned by salt — re-run with ${bold(`--salt ${salt}`)} (same address), or ${bold(`abx predict --salt ${salt} --for ${deployer} --copies ${flags.copies}`)}.`);
@@ -1376,7 +1399,7 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
         emit(jsonSafe({ command: 'deploy', kind: '1of1-edition', copies: editionSize.toString(), dryRun: true, sent: false, address: explicitSalt ? predicted : null, chain: CHAIN, chainId: resolveChain(CHAIN).id, factory, salt, saltPinned: !!explicitSalt, name, symbol }));
         return;
     }
-    await confirmSend(`About to deploy an edition of "${name}" (${symbol}) — ${editionSize === 0n ? 'open' : editionSize.toString()} copies${flags.image ? ' with your image' : ' (generative demo art)'}; mint: ${mintAmount > 0n ? `${mintAmount} at deploy` : 'deferred'}; owner+royalty: your wallet @ ${royaltyBps / 100}%.` +
+    await confirmSend(`About to deploy an edition of "${name}" (${symbol}) — ${editionSize === 0n ? 'open' : editionSize.toString()} copies${flags.image ? ' with your image' : ' (generative demo art)'}; mint: ${mintAmount > 0n ? `${mintAmount} at deploy` : 'deferred'}; approvals: ${approvals} wallet approval(s); owner+royalty: your wallet @ ${royaltyBps / 100}%.` +
         (transferValidator !== zeroAddress ? ` ERC-1155C: enrolled at deploy, permanently (validator ${transferValidator}).` : ''), flags);
     if (lane === 'send') {
         const { wallet, account } = makeWalletClient({ chainKey: CHAIN });
@@ -1394,8 +1417,39 @@ export async function cmdDeployOneOfOneEditionBody(flags, emit) {
         ok(`deployed ${clone}`);
         info(`tx ${explorerBase()}/tx/${r.txHash}  (block ${blockNumber})`);
     }
+    else if (lane === 'sign' && onchainImage) {
+        // Wallet lane + on-chain staging: ONE sign session signs every chunk write AND the deploy, so the
+        // connecting wallet pays for and owns all of it. Staging can't precede the connect, so it runs
+        // inside the session and the deploy then bakes in the resulting manifest field.
+        // `--onchain-image` implies on-chain resolution, so nothing points at baseUrl — mirrors the 721 1/1.
+        info('a wallet will become the owner; the edition resolves from chain — no URI base is baked in.');
+        const session = await openWalletSession({
+            chainKey: CHAIN,
+            expectedSigner: flags.for,
+            total: approvals, // the SAME staging-tx math the preview's `approvals` line reports
+            port: flags.port ? Number(flags.port) : undefined,
+            signUrlFile: flags['sign-url-file'],
+        });
+        let r;
+        try {
+            const signer = await session.connect();
+            await stageOnChainImage(sessionStagingSender(session)); // sets bakedImage, read by buildForDeployer
+            const { clone: predicted, params, salt, contentNote } = await buildForDeployer(signer);
+            info(contentNote);
+            info(mintAmount > 0n ? `mint: ${mintAmount} cop${mintAmount === 1n ? 'y' : 'ies'} of #0 → ${signer} at deploy` : 'mint: deferred — mint later with `abx mint`');
+            const sent = await session.send(prepareDeployOneOfOneEdition({ factory, params, salt, chainId: resolveChain(CHAIN).id, clone: predicted }));
+            r = { txHash: sent.txHash, blockNumber: sent.receipt.blockNumber };
+            clone = predicted;
+        }
+        finally {
+            session.close();
+        }
+        blockNumber = r.blockNumber;
+        ok(`deployed ${clone}`);
+        info(`tx ${explorerBase()}/tx/${r.txHash}  (block ${blockNumber})`);
+    }
     else {
-        // wallet lane (no on-chain-image staging — refused above) or the cold lane: a single deploy tx.
+        // wallet lane without staging, or the cold lane: a single deploy tx.
         info(onChainUri ? 'a wallet will become the owner; the token resolves from chain — no URI base is baked in.' : `a wallet will become the owner; URIs point at ${baseUrl}`);
         const result = await signTx(async (signer) => {
             const { clone: predicted, params, salt } = await buildForDeployer(signer);
@@ -1570,6 +1624,10 @@ export async function cmdDeploySeriesBody(flags, emit) {
     if (onChainUri) {
         step('On-chain renderer');
         renderer = dryRun ? (rendererAddress(flags.renderer) ?? zeroAddress) : await ensureRenderer(flags.renderer);
+        // Say WHICH renderer, like the 1/1 lane does. Both series lanes printed the step header with
+        // nothing under it, while the skill's confirm-readout template implies an address is quotable
+        // there — so an agent relaying the readout had a blank line to explain.
+        info(renderer === zeroAddress ? 'would deploy the canonical renderer first' : `${dryRun ? 'would use' : 'using'} renderer ${renderer}`);
     }
     // Off-chain custody bakes the resolver URL on-chain — a localhost URL resolves for no one.
     // (Not a concern with --onchain-uri: the renderer is authoritative and resolves from chain.)
@@ -1607,6 +1665,16 @@ export async function cmdDeploySeriesBody(flags, emit) {
     const offchainImageOnchainJson = onChainUri && !onchainImage && directUrlBackend;
     const backend = (offchainImageOnchainJson || !onChainUri) && !dryRun ? resolveBackend(opts) : undefined;
     const tokenPaths = slots.map((s, i) => ({ tokenId: i, name: s, path: joinPath(dirPath, s) }));
+    // Say WHICH backend holds the bytes, exactly as the 1/1 lane does. Both Series lanes resolved a
+    // backend and never named it, so a creator asking for "images on IPFS" had no way to confirm from
+    // the preview that their collection would actually pin there — the flag was accepted in silence.
+    if (!onchainImage && (offchainImageOnchainJson || !onChainUri)) {
+        const sr = backendResolution(overrides);
+        info(`storage: ${sr.backend} ${dim(`(${sr.source === 'flag' ? '--backend' : sr.source === 'env' ? 'env' : 'default'})`)} — byte custody for the image(s)`);
+        const gwWarn = localGatewayWarning(flags);
+        if (gwWarn)
+            warn(gwWarn);
+    }
     // Wallet-signature count for THIS deploy — the same per-token chunk math that sizes the
     // wallet-lane session `total` below (B2), computed ONCE so preview/confirm text and the real
     // session can never disagree. TX signatures only — see the 1/1's `approvals` for the same note
@@ -2019,9 +2087,6 @@ export async function cmdDeployEditionImageBody(flags, emit) {
         : `EditionImage (ERC-1155) — N ids from the folder × ${editionSize} cop${editionSize === 1n ? 'y' : 'ies'} each`)}`));
     if (editionSize === 1n)
         info(copiesOneNote('deploy-series'));
-    if (flags['onchain-image']) {
-        throw new Error('--onchain-image is not yet supported for edition deploys (--copies) — use --onchain-uri (inline SVG) or off-chain custody (--backend ipfs|arweave|cloud) instead. Tracked as a follow-up.');
-    }
     if (!flags.dir) {
         throw new Error('abx deploy-series --copies <n|open> --dir <media-dir> [--count N] [--mint-all | --mint-count N | --no-mint] [--mint-amount N] ' +
             '[--onchain-uri (inline SVG) | --backend ipfs|arweave|cloud (off-chain, hosted resolver) | --public-base-url https://…] ' +
@@ -2044,6 +2109,15 @@ export async function cmdDeployEditionImageBody(flags, emit) {
         assertPreviewDeployer(flags);
     assertRealIdentity(flags, { name, symbol, dryRun });
     const lane = laneFromFlags(flags);
+    const onchainImage = !!flags['onchain-image'];
+    const compress = parseCompress(flags.compress);
+    // Staging is a SEQUENCE (chunk writes → the deploy that references each manifest) where every tx's
+    // receipt feeds the next, so it can't be signed offline in one run. Refused on the cold lane for the
+    // same reason on every lineage, 721 and edition alike; hot + wallet both work.
+    if (onchainImage && lane === 'unsigned') {
+        throw new Error('Staging on-chain images (--onchain-image) needs interactive signing — each chunk tx feeds ' +
+            "the next, so it can't run on the cold lane (--unsigned). Use the hot lane (a funded key) or --sign (browser wallet).");
+    }
     const publicClient = makePublicClient({ chainKey: CHAIN });
     await assertChainId(CHAIN, { allowUnreachable: dryRun });
     const transferValidator = await resolveTransferValidatorFlag(flags, publicClient, dryRun, '1155C');
@@ -2060,7 +2134,12 @@ export async function cmdDeployEditionImageBody(flags, emit) {
     if (effectiveMintCount > 0 && mintAmount === 0n) {
         throw new Error('--mint-amount 0 with ids being pre-minted at deploy makes no sense — pass a positive --mint-amount, or drop --mint-all/--mint-count to defer minting entirely.');
     }
-    const onChainUri = !!flags['onchain-uri'];
+    // `--onchain-image` IMPLIES on-chain resolution — bytes on-chain behind a renderer that has no
+    // reason to defer to a server. Every sibling lane already reads it that way (the 1/1, the
+    // 1/1-edition, the 721 Series); this one didn't, which was harmless only while `--onchain-image`
+    // was refused here. Now that it's wired, omitting it would demand a `--public-base-url` for a drop
+    // whose bytes are already on-chain — incoherent, and it would bake a resolver URL nobody needs.
+    const onChainUri = !!flags['onchain-uri'] || onchainImage;
     const minter = flags.minter ?? zeroAddress;
     const paused = flags.unpaused === undefined;
     const primaryPayee = flags['primary-payee'] ?? zeroAddress;
@@ -2087,6 +2166,10 @@ export async function cmdDeployEditionImageBody(flags, emit) {
     if (onChainUri) {
         step('On-chain renderer');
         renderer = dryRun ? (rendererAddress(flags.renderer) ?? zeroAddress) : await ensureRenderer(flags.renderer);
+        // Say WHICH renderer, like the 1/1 lane does. Both series lanes printed the step header with
+        // nothing under it, while the skill's confirm-readout template implies an address is quotable
+        // there — so an agent relaying the readout had a blank line to explain.
+        info(renderer === zeroAddress ? 'would deploy the canonical renderer first' : `${dryRun ? 'would use' : 'using'} renderer ${renderer}`);
     }
     if (!onChainUri) {
         const loopback = loopbackBaseUrl(baseUrl);
@@ -2109,22 +2192,118 @@ export async function cmdDeployEditionImageBody(flags, emit) {
     const overrides = storageOverrides(flags);
     const opts = storageOptions(overrides);
     const backendId = overrides.backend ?? process.env.ABX_STORAGE_BACKEND ?? 'fs';
-    const backend = !onChainUri && !dryRun ? resolveBackend(opts) : undefined;
+    // Pattern 2 — image off-chain on a durable backend, JSON rendered on-chain, NOTHING to run. Ported
+    // from the 721 Series twin, which has had it all along; `EditionImage` shipped without it, so a
+    // multi-artwork RASTER edition had no no-server option at all and `--onchain-uri` just refused the
+    // art. That pushed a cold agent into deploying one contract PER artwork to get permanence (B28).
+    // Nothing on-chain needed changing: `EditionImageInitParams` already takes `contractFields`, and the
+    // renderer's `url-template` substitutes `{id}` from whatever id it is called with — `uri(id)` on a
+    // 1155 reaches it exactly as `tokenURI(id)` does on a 721.
+    const directUrlBackend = backendId === 'ipfs' || backendId === 'arweave' || backendId === 'cloud';
+    const offchainImageOnchainJson = onChainUri && !onchainImage && directUrlBackend;
+    const backend = (offchainImageOnchainJson || (!onChainUri && !onchainImage)) && !dryRun ? resolveBackend(opts) : undefined;
     const tokenPaths = slots.map((s, i) => ({ tokenId: i, name: s, path: joinPath(dirPath, s) }));
+    // Say WHICH backend holds the bytes, exactly as the 1/1 lane does. Both Series lanes resolved a
+    // backend and never named it, so a creator asking for "images on IPFS" had no way to confirm from
+    // the preview that their collection would actually pin there — the flag was accepted in silence.
+    if (!onchainImage && (offchainImageOnchainJson || !onChainUri)) {
+        const sr = backendResolution(overrides);
+        info(`storage: ${sr.backend} ${dim(`(${sr.source === 'flag' ? '--backend' : sr.source === 'env' ? 'env' : 'default'})`)} — byte custody for the image(s)`);
+        const gwWarn = localGatewayWarning(flags);
+        if (gwWarn)
+            warn(gwWarn);
+    }
     const seriesTraits = parseSeriesTraits(flags.attributes ? readFileSync(resolvePath(process.cwd(), flags.attributes), 'utf8') : undefined, slots);
     const seriesTraitsOnchain = seriesTraits.size > 0 && (!!flags['traits-onchain'] || onChainUri);
     const offChainTokenTraits = seriesTraits.size && !seriesTraitsOnchain
         ? JSON.stringify(Object.fromEntries([...seriesTraits].map(([id, a]) => [String(id), a])))
         : undefined;
+    // Wallet-signature count for THIS deploy — parity with the 721 Series twin, which prints it and
+    // whose count the skill promises "every preview" shows. Same per-id chunk math as that twin, so the
+    // preview, the confirm text, and the wallet session's `total` can never disagree.
+    const approvals = onchainImage
+        ? tokenPaths.reduce((n, { path }) => {
+            const plan = computeContentPlan(readFileSync(path), compress).plan;
+            return n + (plan.mode === 'single' ? 1 : plan.txCount);
+        }, 0) + 1 // + the deploy tx
+        : 1;
     const tokenFields = [];
-    const buildFields = async () => {
+    // Collection-scope fields the image lane may add (the O(1) `url-template`). Kept separate from the
+    // authorship fields and CONCATENATED at the params site — never assigned over them, or an
+    // `--artist`/`--license` value would silently vanish whenever pattern 2 is in play.
+    let imageContractFields = [];
+    const buildFields = async (stage) => {
+        // Pattern 1: the bytes themselves on-chain, staged into the shared chunk store per id, each id's
+        // field pointing at its manifest. Ported from the 721 Series twin — the edition lane refused this
+        // outright before (B28), though nothing on-chain prevented it.
+        if (onchainImage) {
+            const { fields } = await stageImageFieldsBatch(tokenPaths.map((s) => s.path), compress, stage, flags['chunk-store']);
+            tokenPaths.forEach(({ tokenId }, i) => tokenFields.push(tokenFieldOf(tokenId, fields[i])));
+            if (seriesTraitsOnchain)
+                for (const [tokenId, attrs] of seriesTraits)
+                    tokenFields.push(tokenFieldOf(tokenId, attributesInlineField(attrs)));
+            info(`uri()/contractURI() resolve ON-CHAIN via the renderer — the image BYTES are on-chain too, nothing off-chain at all.`);
+            return;
+        }
+        // Pattern 2: one durable upload per id, then a locator on-chain instead of the bytes.
+        if (offchainImageOnchainJson) {
+            const exts = tokenPaths.map(({ path }) => extname(path).toLowerCase());
+            const uniform = exts[0] !== '' && exts.every((e) => e === exts[0]);
+            if (dryRun || !backend) {
+                if (uniform) {
+                    imageContractFields = [imageUrlTemplateField(`<${backendId}-dir>/{id}${exts[0]}`)];
+                    info(`would upload ${tokenPaths.length} file(s) as ONE ${backendId} directory → collection image url-template <${backendId}-dir>/{id}${exts[0]} (O(1))`);
+                }
+                else {
+                    for (const { tokenId } of tokenPaths)
+                        tokenFields.push(tokenFieldOf(tokenId, imageUrlField(`<${backendId}-url-${tokenId}>`)));
+                    info(`would upload ${tokenPaths.length} file(s) to ${backendId} → per-id url image fields (mixed extensions, O(N))`);
+                }
+            }
+            else if (uniform && backend.putDirectory) {
+                // O(1) directory-base: upload the folder renamed to {id}{ext}; ONE collection url-template.
+                const entries = tokenPaths.map(({ tokenId, path }) => ({ name: `${tokenId}${exts[0]}`, bytes: new Uint8Array(readFileSync(path)), contentType: contentTypeFromPath(path) }));
+                const { base } = await backend.putDirectory(entries);
+                const template = `${base}/{id}${exts[0]}`;
+                imageContractFields = [imageUrlTemplateField(template)];
+                info(`uploaded ${entries.length} file(s) as one ${backendId} directory`);
+                info(`collection image (url-template): ${template}  ${dim('— one field covers every id (O(1))')}`);
+            }
+            else {
+                // mixed extensions (or no directory support): per-id url fields (O(N)).
+                for (const { tokenId, name: fname, path } of tokenPaths) {
+                    const bytes = new Uint8Array(readFileSync(path));
+                    const hash = hashContent(bytes);
+                    await backend.put(hash, { bytes, contentType: contentTypeFromPath(path) });
+                    const locator = (await backend.locator?.(hash)) ?? '';
+                    if (!locator)
+                        throw new Error(`backend ${backendId} returned no public locator for id ${tokenId} — a durable backend (ipfs/arweave/cloud) is required for --onchain-uri image hosting`);
+                    tokenFields.push(tokenFieldOf(tokenId, imageUrlField(locator)));
+                    info(`id ${tokenId} ← ${fname} → ${locator}`);
+                }
+                info(`mixed file extensions → per-id url fields (O(N)); a uniform extension enables the O(1) directory template`);
+            }
+            if (seriesTraitsOnchain)
+                for (const [tokenId, attrs] of seriesTraits)
+                    tokenFields.push(tokenFieldOf(tokenId, attributesInlineField(attrs)));
+            info(`uri()/contractURI() resolve ON-CHAIN via the renderer — the image bytes live on ${backendId}, so there is still no server to run.`);
+            return;
+        }
         for (const { tokenId, name: fname, path } of tokenPaths) {
             const bytes = new Uint8Array(readFileSync(path));
             const contentType = contentTypeFromPath(path);
             if (onChainUri) {
                 const text = Buffer.from(bytes).toString('utf8');
                 if (!looksLikeSvg(text)) {
-                    throw new Error(`--onchain-uri inlines SVG only; id ${tokenId} "${fname}" is ${contentType}. Drop --onchain-uri for off-chain custody instead.`);
+                    // Name the real alternatives, the way the 721 twin's version of this refusal does — a bare
+                    // "drop --onchain-uri" once sent a cold agent fanning a 3-artwork edition out into THREE
+                    // separate contracts to find permanence. The `--backend` route is now the first suggestion
+                    // because it IS available on this lane (see `offchainImageOnchainJson` above).
+                    throw new Error(`--onchain-uri inlines SVG only; id ${tokenId} "${fname}" is ${contentType}. For raster art in ONE edition contract:\n` +
+                        `    • No server, images off-chain:  add --backend arweave (or ipfs/cloud) — the image URL is baked into the on-chain JSON\n` +
+                        `    • Host the metadata yourself:   drop --onchain-uri and pass --public-base-url https://your.domain\n` +
+                        `    • Keep it SVG:                  supply SVG art and --onchain-uri inlines every id on-chain\n` +
+                        `    • Bytes fully on-chain:         --onchain-image --compress fastlz (hot or --sign lane; --unsigned is refused)`);
                 }
                 tokenFields.push(tokenFieldOf(tokenId, imageInlineField(text)));
             }
@@ -2139,14 +2318,24 @@ export async function cmdDeployEditionImageBody(flags, emit) {
         if (seriesTraitsOnchain)
             for (const [tokenId, attrs] of seriesTraits)
                 tokenFields.push(tokenFieldOf(tokenId, attributesInlineField(attrs)));
+        // AFTER the per-id content actually validated — stating "resolves ON-CHAIN, no server" and then
+        // refusing the very art that was passed reads as the tool contradicting itself.
+        if (onChainUri) {
+            info(`uri()/contractURI() resolve ON-CHAIN via the renderer — no resolver, no server, no localhost.`);
+            if (!hasPublicUrl)
+                info('off-chain fallback pointer left empty (the renderer is authoritative); set --public-base-url to bake one anyway.');
+        }
     };
     if (!dryRun) {
         const custody = onChainUri ? 'inline SVG on-chain' : `off-chain custody (${backendId})`;
         await confirmSend(`About to deploy an edition series "${name}" (${symbol}) — ${count} id(s) × ${editionSize === 0n ? 'open' : editionSize.toString()} cop${editionSize === 1n ? 'y' : 'ies'} each; ${custody}; ` +
-            `mint: ${effectiveMintCount > 0 ? `${effectiveMintCount} id(s) × ${mintAmount} at deploy` : 'deferred'}; owner+royalty: your wallet @ ${royaltyBps / 100}%.` +
+            `mint: ${effectiveMintCount > 0 ? `${effectiveMintCount} id(s) × ${mintAmount} at deploy` : 'deferred'}; approvals: ${approvals} wallet approval(s); owner+royalty: your wallet @ ${royaltyBps / 100}%.` +
             (transferValidator !== zeroAddress ? ` ERC-1155C: enrolled at deploy, permanently (validator ${transferValidator}).` : ''), flags);
     }
-    await buildFields();
+    // `--onchain-image` defers field-building to a lane branch below: the hot lane stages with the env
+    // key, the wallet lane inside its sign session. Every other custody mode can build up front.
+    if (!onchainImage)
+        await buildFields();
     const buildForDeployer = async (deployer) => {
         const salt = explicitSalt ?? saltFor(deployer);
         const clone = await predictClone(publicClient, { factory, salt });
@@ -2170,7 +2359,9 @@ export async function cmdDeployEditionImageBody(flags, emit) {
             mintCount: effectiveMintCount,
             mintAmount,
             tokenFields,
-            contractFields: authorshipContractFields(flags),
+            // Concatenate — the image lane's collection-scope url-template rides ALONGSIDE the authorship
+            // fields. Assigning either over the other would silently drop the creator's --artist/--license.
+            contractFields: [...authorshipContractFields(flags), ...imageContractFields],
         };
         return { clone, params, salt };
     };
@@ -2204,6 +2395,10 @@ export async function cmdDeployEditionImageBody(flags, emit) {
             info(`minter  ${minter}`);
         if (primaryPayee !== zeroAddress)
             info(`primary payee  ${primaryPayee}`);
+        // `paused` gates whether the public can mint at all — the 1/1-edition twin prints it and an
+        // edition sale is the point of the lane, so it belongs in the readout, not just in the params.
+        info(`paused  ${paused}${flags.unpaused ? '' : dim('  (default — pass --unpaused to open at deploy)')}`);
+        info(`approvals   ${approvals} wallet approval(s)`); // parity with the 721 Series twin
         if (!explicitSalt) {
             console.log(`\n  ${bold('salt')}  ${g(salt)}`);
             info(`address: pinned by salt — re-run with ${bold(`--salt ${salt}`)} (same address).`);
@@ -2214,6 +2409,9 @@ export async function cmdDeployEditionImageBody(flags, emit) {
     }
     if (lane === 'send') {
         const { wallet, account } = makeWalletClient({ chainKey: CHAIN });
+        // hot lane: the env key stages every id up front (deployer-independent), then deploys.
+        if (onchainImage)
+            await buildFields(envStagingSender());
         const { clone: predicted, params, salt } = await buildForDeployer(account.address);
         info(`deterministic address: ${predicted}`);
         info(`mint: ${effectiveMintCount > 0 ? `${effectiveMintCount} id(s) × ${mintAmount} cop${mintAmount === 1n ? 'y' : 'ies'} → ${account.address} at deploy` : 'deferred'}`);
@@ -2224,6 +2422,35 @@ export async function cmdDeployEditionImageBody(flags, emit) {
         ok(`deployed ${clone}`);
         info(`tx ${explorerBase()}/tx/${r.txHash}  (block ${blockNumber})`);
     }
+    else if (lane === 'sign' && onchainImage) {
+        // Wallet lane + on-chain staging: ONE session signs every chunk write across all ids AND the
+        // deploy. The connecting wallet pays for (and owns) it; staging can't precede the connect, so it
+        // runs inside the session and the deploy then bakes in every id's manifest.
+        info(`a wallet will become the owner; it will approve ${approvals - 1} staging tx(s) + the deploy in one session.`);
+        const session = await openWalletSession({
+            chainKey: CHAIN,
+            expectedSigner: flags.for,
+            total: approvals, // the SAME staging-tx math the preview's `approvals` line reports
+            port: flags.port ? Number(flags.port) : undefined,
+            signUrlFile: flags['sign-url-file'],
+        });
+        let r;
+        try {
+            const signer = await session.connect();
+            await buildFields(sessionStagingSender(session));
+            const { clone: predicted, params, salt } = await buildForDeployer(signer);
+            info(`mint: ${effectiveMintCount > 0 ? `${effectiveMintCount} id(s) × ${mintAmount} cop${mintAmount === 1n ? 'y' : 'ies'} → ${signer} at deploy` : 'deferred'}`);
+            const sent = await session.send(prepareDeployEditionImage({ factory, params, salt, chainId: resolveChain(CHAIN).id, clone: predicted }));
+            r = { txHash: sent.txHash, blockNumber: sent.receipt.blockNumber };
+            clone = predicted;
+        }
+        finally {
+            session.close();
+        }
+        blockNumber = r.blockNumber;
+        ok(`deployed ${clone}`);
+        info(`tx ${explorerBase()}/tx/${r.txHash}  (block ${blockNumber})`);
+    }
     else {
         info(onChainUri ? 'a wallet will become the owner; the tokens resolve from chain — no URI base is baked in.' : `a wallet will become the owner; URIs point at ${baseUrl}`);
         const result = await signTx(async (signer) => {
@@ -3657,10 +3884,6 @@ export async function cmdDeployEditionCodeBody(flags, emit) {
     }
     if (!flags.script)
         throw new Error(usage);
-    if (flags.dep || flags['dep-registry']) {
-        throw new Error('--dep/--dep-registry are not yet supported for edition code deploys (--copies) — ship a self-contained script ' +
-            '(no external dependency declarations) for now, or drop --copies for the 721 lane. Tracked as a follow-up.');
-    }
     if (flags['image-renderer'] || flags['attributes-renderer'] || flags['image-base']) {
         throw new Error('--image-renderer/--attributes-renderer/--image-base are not yet supported for edition code deploys (--copies). Tracked as a follow-up.');
     }
@@ -3763,6 +3986,43 @@ export async function cmdDeployEditionCodeBody(flags, emit) {
             info('off-chain fallback pointer left empty (the renderer is authoritative); set --public-base-url to bake one anyway.');
     }
     const schemas = parseSchemaSpecs(flags.schema);
+    // Dependencies — same shape as the 721 SeriesCode twin (see its block for the full reasoning).
+    // `EditionCode` already inherits the `Dependencies` extension and calls `_initDependencies()`, and
+    // the legs are the same `setDependency`/`setDependencyRegistry` calls on the same ABI, so this was
+    // never a contract gap: only the CLI refused it (B28). It matters because "an edition of my p5
+    // sketch, with p5 coming from the chain" is a thing creators ask for directly, and the refusal sent
+    // them to the 721 lane (unique tokens) or to shipping a sketch whose library never loads.
+    const deps = parseDepFlag(flags.dep);
+    const hasRegistryDeps = deps.some((d) => d.resolution === DEP_RESOLUTION.registry);
+    const depPointer = hasRegistryDeps
+        ? resolveDepRegistryPointer(flags['dep-registry'], chainId)
+        : { registry: null, source: 'none' };
+    const depRegistry = depPointer.registry;
+    if (deps.length) {
+        step('Dependencies');
+        deps.forEach((d, i) => info(`[${i}] ${bold(d.display)} ${dim(d.resolution === DEP_RESOLUTION.registry ? '(registry name@version)' : '(on-chain data contract — read directly)')}${i === 0 ? dim(' · index 0 = the runtime') : ''}`));
+        if (hasRegistryDeps) {
+            if (depRegistry) {
+                info(`registry pointer → ${depRegistry} ${dim(depPointer.source === 'flag' ? '(--dep-registry)' : "(the chain's AB Dependency Registry — soft, non-validating)")}`);
+                const { checks, rpcOk } = await checkRegistryDeps(publicClient, depRegistry, deps);
+                for (const chk of checks) {
+                    if (chk.status === 'found') {
+                        ok(chk.details.availableOnChain
+                            ? `${chk.dep} — on registry; ON-CHAIN bytes available (${chk.details.scriptCount} chunk(s)) — chain-complete capable`
+                            : `${chk.dep} — on registry; served from CDN ${chk.details.preferredCDN || '(none listed)'} ${dim('— the normal production path, not a degradation')}`);
+                    }
+                    else if (chk.status === 'not-found') {
+                        warn(`${bold(chk.dep)} NOT FOUND on registry ${depRegistry} — the resolver won't resolve it from there. Deploy proceeds (you may intend a custom registry / a pending addition); double-check the exact name@version spelling.`);
+                    }
+                }
+                if (!rpcOk)
+                    info('registry check skipped (RPC unreachable) — the deploy does not depend on it.');
+            }
+            else {
+                warn('no dependency registry known for this chain — skipping the setDependencyRegistry leg (the pointer is SOFT; the resolver falls back to its built-in CDN map). Pass --dep-registry 0x… or run `abx set-dependency-registry` later.');
+            }
+        }
+    }
     step('Content');
     const scriptPath = flags.script;
     const source = readFileSync(resolvePath(scriptPath), 'utf8');
@@ -3823,6 +4083,10 @@ export async function cmdDeployEditionCodeBody(flags, emit) {
                 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").
@@ -3849,7 +4113,11 @@ export async function cmdDeployEditionCodeBody(flags, emit) {
         }
         return { clone, txs };
     };
-    const approvals = 1 + (scriptChunks.length + schemas.length + onchainUriLegs.length + mintCount > 0 ? 1 : 0);
+    // 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);
     if (!dryRun) {
         await confirmSend(`About to deploy an edition code project "${name}" (${symbol}) — script ${bytes.length} bytes → ${scriptChunks.length} chunk(s); ` +
             `up to ${max} id(s) × ${editionSize === 0n ? 'open' : editionSize.toString()} cop${editionSize === 1n ? 'y' : 'ies'} each; ` +
@@ -3885,6 +4153,7 @@ export async function cmdDeployEditionCodeBody(flags, emit) {
         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 (script chunks${schemas.length ? ' + schemas' : ''}${onChainUri ? ' + on-chain URI wiring' : ''}${mintCount > 0 ? ' + reserve mints' : ''})`);
+        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)}`);
             info(`address: pinned by salt — re-run with ${bold(`--salt ${salt}`)} (same address).`);