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

package/dist/commands/deploy.js

@@ -15,15 +15,16 @@
 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, METADATA_REPRESENTATION as R, analyzeScript, assertChainId, checkRegistryDeps, dependencySetupCalls, deployOneOfOne, deploySeries, discoverDeployBlock, encodeFieldRenderer, encodeTag, expectedChainComplete, makeHotSender, makePublicClient, makeWalletClient, normalizeAttributes, onchainUriSetupCalls, oneOfOneImageAbi, parseTraitPairs, planResume, predictClone, prepareCodeSetup, prepareDeployOneOfOne, prepareDeploySeries, prepareDeploySeriesCode, redactRpcUrl, resolveChain, resolveDepRegistryPointer, resolveGenerator, resolveRecommendedTransferValidator, resolveRpcUrl, resolveSeedSource, resolveSeriesCodeFactory, saltFor, seriesCodeAbi, seriesCodeFactoryAbi, tryReadContract, } from '@artblocks/abx-sdk';
+import { DEFAULT_CHAIN_KEY, DEP_RESOLUTION, METADATA_FIELD as F, METADATA_REPRESENTATION as R, analyzeScript, assertChainId, checkRegistryDeps, dependencySetupCalls, deployOneOfOne, deploySeries, deployOneOfOneEdition, deployEditionImage, discoverDeployBlock, encodeFieldRenderer, encodeTag, expectedChainComplete, makeHotSender, makePublicClient, makeWalletClient, normalizeAttributes, onchainUriSetupCalls, oneOfOneImageAbi, oneOfOneEditionAbi, parseTraitPairs, planResume, predictClone, prepareCodeSetup, prepareDeployOneOfOne, prepareDeploySeries, prepareDeploySeriesCode, prepareDeployOneOfOneEdition, prepareDeployEditionImage, prepareDeployEditionCode, redactRpcUrl, resolveChain, resolveDepRegistryPointer, resolveGenerator, resolveRecommendedTransferValidator, resolveRpcUrl, resolveSeedSource, resolveSeriesCodeFactory, saltFor, seriesCodeAbi, seriesCodeFactoryAbi, tryReadContract, } from '@artblocks/abx-sdk';
 import { DIRECT_URL_BACKENDS, contentTypeFromPath, decideImageContentLane, hashContent, isTurboArweave, resolveBackend, validateRenderStorageCombo, } from '@artblocks/abx-storage';
 import { DEFAULT_PORT, artContentHash, generateArt, resolveBaseUrl, startTokenApiServer } from '@artblocks/abx-token-api';
 import { encodeFunctionData, toHex, zeroAddress } from 'viem';
-import { CHAIN, explorerBase, assertTurboFundsForUpload, backendResolution, collectContentLocators, ensureArweaveIdentityForUpload, factoryAddress, faucetHint, localIndexer, loopbackBaseUrl, noteArweavePlan, noteStorageReadiness, rendererAddress, seriesFactoryAddress, storageOptions, storageOverrides, storageSignerChoice, } from '../config.js';
+import { CHAIN, explorerBase, assertTurboFundsForUpload, backendResolution, collectContentLocators, ensureArweaveIdentityForUpload, factoryAddress, faucetHint, localIndexer, loopbackBaseUrl, noteArweavePlan, noteStorageReadiness, rendererAddress, seriesFactoryAddress, oneOfOneEditionFactoryAddress, editionFactoryAddress, editionCodeFactoryAddress, storageOptions, storageOverrides, storageSignerChoice, } from '../config.js';
 import { parseDepFlag } from '../deps.js';
 import { isDryRun, parseSaltFlag, refuseStrayFlags, warnSignWithoutFor } from '../flags.js';
+import { isEditionContract } from '../kind.js';
 import { jsonSafe, withJson } from '../jsonout.js';
-import { bold, c, dim, ensureFactory, ensureRenderer, ensureSeedSource, ensureSeriesCodeFactory, ensureSeriesFactory, g, info, keepAlive, ok, p, portInUse, printServing, registerAndIndexLocally, reindexAfterDeploy, step, warn, } from '../output.js';
+import { bold, c, dim, ensureFactory, ensureRenderer, ensureSeedSource, ensureSeriesCodeFactory, ensureSeriesFactory, ensureOneOfOneEditionFactory, ensureEditionFactory, ensureEditionCodeFactory, g, info, keepAlive, ok, p, portInUse, printServing, registerAndIndexLocally, reindexAfterDeploy, step, warn, } from '../output.js';
 import { AUTHORSHIP_DEPLOY_FIELDS, ONCHAIN_PROJECT_SOFT_LIMIT, authorshipContractFields, computeContentPlan, envStagingSender, parseCompress, parseTransferValidatorValue, previewImageStaging, sessionStagingSender, stageImageField, stageImageFieldsBatch, } from '../ownerops.js';
 import { canonicalLabel } from '../remote.js';
 import { confirmSend, gatedSend, laneFromFlags } from '../riskgate.js';
@@ -31,9 +32,11 @@ import { describeSchema, parseSchemaSpecs } from '../schema.js';
 import { parseSeriesTraits } from '../series-traits.js';
 import { decodeOnChainJson } from '../served.js';
 import { openWalletSession, signHotSequence, signTx } from '../signer.js';
-// Product dimensions — what you can launch. One concrete contract exists today
-// (the 1/1 image); this table is the seam future implementations slot into, so
-// `abx deploy --type <dimension>` is stable while the contracts grow under it.
+// Product dimensions — what you can launch. Two concrete contract FAMILIES exist today: the 721
+// ladder (`--type`, below — 1/1 image or Series) and, orthogonally, ERC-1155 editions (`--copies`,
+// on ANY of the three deploy commands — see `parseCopies`). `--type` picks among unique-token
+// shapes; `--copies` switches uniqueness for copies of the same shape. They are independent knobs,
+// which is why editions get no entry of their own here rather than a fourth dimension.
 export const DIMENSIONS = {
     '1of1': { label: '1/1 image NFT', aliases: ['one-of-one', 'oneofone', '1-of-1'] },
     series: { label: 'multi-token image Series', aliases: ['multi', 'collection'] },
@@ -46,6 +49,43 @@ export function resolveDimension(type) {
     }
     return key;
 }
+// ── --copies: the flag that routes a deploy to its ERC-1155 edition twin ─────────────────────────
+// The kernel (specs/protocol — the parity plan): a Series is many UNIQUE tokens; an Edition is many
+// COPIES of a token. The creator's trigger word is "copies" — nobody says "ERC-1155" or "1155",
+// and this flag is the only surface that exists: no `--standard` flag, no separate top-level
+// commands. Absent → the 721 lane, byte-identical to before `--copies` existed.
+/** Parse `--copies <N|open>` into the `editionSize` InitParams field (`0n` = open/uncapped). Throws
+ *  with a pointed message on anything else — a bare `--copies` (no value), a non-integer, or the
+ *  literal `0` (which already has an on-chain meaning — "open" says the same thing without the
+ *  ambiguity of "did they mean zero copies, or unlimited?"). */
+export function parseCopies(raw) {
+    if (raw === undefined)
+        throw new Error('--copies needs a value: a positive integer (copies per id), or "open" for an uncapped edition.');
+    const v = raw.trim();
+    if (v === 'true')
+        throw new Error('--copies needs a value: a positive integer (copies per id), or "open" for an uncapped edition — a bare --copies has neither.');
+    if (v.toLowerCase() === 'open')
+        return 0n;
+    if (!/^\d+$/.test(v))
+        throw new Error(`--copies must be a positive integer (copies per id) or "open" (uncapped); got '${raw}'.`);
+    if (v === '0')
+        throw new Error(`--copies 0 is ambiguous with the on-chain meaning of 0 (open/uncapped) — say what you mean: --copies open.`);
+    return BigInt(v);
+}
+/** `--copies 1` is legal — a single-copy ERC-1155 edition — but it is almost never what a creator
+ *  actually wants (the plain 721 lane makes a simpler, more marketplace-familiar token for exactly
+ *  one copy). Advisory only; never refused — `--copies` exists precisely so nobody has to reach for
+ *  a different flag to get an edition. */
+export function copiesOneNote(cmd) {
+    return `--copies 1 makes a single-copy ERC-1155 edition. If you want one unique token, drop --copies — \`abx ${cmd}\` (no --copies) is the simpler, more marketplace-familiar 721 lane.`;
+}
+/** A non-negative-integer flag (`--mint-amount`, …) — the shared parse + bound-check so every
+ *  edition flag that takes "a count" reports the same, plain-language rejection. */
+export function parseNonNegativeIntFlag(raw, flag) {
+    if (!/^\d+$/.test(raw.trim()) || raw.trim() === '')
+        throw new Error(`--${flag} must be a non-negative integer; got '${raw}'.`);
+    return BigInt(raw.trim());
+}
 /**
  * A `--dry-run` computes the deterministic deploy address, which is a pure function of
  * (factory, salt, deployer) — so it needs a deployer even though it signs nothing. Resolve it the
@@ -468,6 +508,17 @@ export function describeTraits(traits, onchain) {
 }
 // ── deploy (+ optionally serve) ──────────────────────────────────────────────
 export async function cmdDeploy(flags, serveAfter) {
+    // `--copies <N|open>` routes to the ERC-1155 edition twin (OneOfOneEdition) — the flagship
+    // edition product: a priced open/limited edition of ONE artwork. Checked before anything else
+    // touches `flags`, so the 721 lane (`cmdDeployBody`) below is reached ONLY when `--copies` is
+    // absent, and is otherwise untouched by this feature — byte-identical to before editions shipped.
+    if (flags.copies !== undefined) {
+        if (serveAfter) {
+            throw new Error('`abx demo` has no --copies — demo is the zero-argument 721 1/1 walkthrough. Deploy an edition directly: ' +
+                '`abx deploy --copies <n|open> [--image <path>] --name "…" --symbol …` (see `abx help deploy`).');
+        }
+        return withJson(flags, async (emit) => cmdDeployOneOfOneEditionBody(flags, emit));
+    }
     // `--json`: the deployed ADDRESS is the value a program came for (B19). Narration goes to stderr,
     // so `ADDR=$(abx deploy … --json | jq -r .address)` works without parsing a success banner.
     return withJson(flags, async (emit) => cmdDeployBody(flags, serveAfter, emit));
@@ -993,7 +1044,11 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
         attributes: offChainTraits,
     };
     indexer.register(baseReg);
-    const { state, elapsedMs } = await reindexAfterDeploy(indexer, clone);
+    // Only the demo path (`abx demo`) reaches `walkthroughReadBack` below, and only its off-chain-
+    // custody branch reads `token.tokenURI` off `state` — the on-chain-URI branch there does its own
+    // independent `readContract`, so skip the ask when `onChainUri` too. A real `abx deploy` never
+    // asks for it (SDK default: off).
+    const { state, elapsedMs } = await reindexAfterDeploy(indexer, clone, { readUriDocuments: serveAfter && !onChainUri });
     if (serveAfter) {
         if (state.eventCount > 0)
             ok(`read ${bold(String(state.eventCount))} events straight off ${CHAIN} in ${elapsedMs}ms — no API key, no company's server`);
@@ -1092,6 +1147,309 @@ export async function cmdDeployBody(flags, serveAfter, emit) {
     printServing(url, clone);
     keepAlive();
 }
+// ── deploy --copies: OneOfOneEdition (the flagship ERC-1155 product) ─────────────────────────────
+// Copies of ONE artwork — a priced open/limited edition. The edition twin of `cmdDeployBody`,
+// reusing every standard-agnostic helper it does (content custody, traits, authorship fields, the
+// `--721c`/`--1155c`-shared validator resolution, salt prediction, signing lanes) but written as its
+// own function rather than threaded into `cmdDeployBody` with `if (copies)` branches throughout —
+// so the 721 lane, above, stays provably byte-identical whether or not editions exist.
+//
+// v1 scope (reported, not hidden): `--onchain-image` (chunk-store staging) is wired for the hot
+// lane only — the wallet-lane session dance `cmdDeployBody` uses for it is a bigger lift than this
+// pass covers; staging + a wallet-signed deploy in two SEPARATE steps isn't offered here rather than
+// half-build it. Every other custody/signing combination the 1/1 lane supports works identically.
+// (`DEPLOY_EDITION_FLAGS` — the allowlist this function's `refuseStrayFlags` checks against — is
+// declared further down, alongside `DEPLOY_FLAGS`/`DEPLOY_SERIES_FLAGS`/`DEPLOY_CODE_FLAGS`: it
+// spreads `DEPLOY_FLAGS`, so it must come AFTER that declaration at module scope, same reason
+// `DEPLOY_SERIES_EDITION_FLAGS` sits next to it rather than beside `cmdDeployEditionImageBody`.)
+export async function cmdDeployOneOfOneEditionBody(flags, emit) {
+    refuseStrayFlags(flags, DEPLOY_EDITION_FLAGS, 'deploy');
+    warnSignWithoutFor(flags);
+    // `--type` is the 721 lane's OWN dimension seam (cmdDeployBody redirects `--type series` to
+    // `deploy-series`) — it never even reaches this function for that redirect, since --copies routes
+    // here before --type is ever inspected. Refuse the confusing combination explicitly rather than
+    // silently ignore it (a creator combining them almost certainly means the multi-artwork edition —
+    // `deploy-series --copies`, not this 1/1-edition lane).
+    if (flags.type !== undefined && resolveDimension(flags.type) === 'series') {
+        throw new Error("--type series + --copies: this is the 1/1-edition lane (one artwork, copies of it) — for N artworks each with copies, " +
+            'use `abx deploy-series --copies <n|open> --dir <folder>` instead. Drop --type here.');
+    }
+    const editionSize = parseCopies(flags.copies);
+    const name = flags.name ?? 'ABX Edition';
+    const symbol = flags.symbol ?? 'ABXE';
+    const royaltyBps = Number(flags['royalty-bps'] ?? 500);
+    const port = Number(flags.port ?? process.env.ABX_PORT ?? DEFAULT_PORT);
+    const baseUrl = flags['public-base-url'] ?? resolveBaseUrl(port);
+    const traits = parseDeployTraits(flags);
+    console.log(bold(`\n  ABX Self-Host Toolkit — deploy edition\n  ${dim(editionSize === 0n
+        ? 'OneOfOneEdition (ERC-1155) — an OPEN edition of one artwork, served from chain alone'
+        : `OneOfOneEdition (ERC-1155) — ${editionSize} cop${editionSize === 1n ? 'y' : 'ies'} of one artwork, served from chain alone`)}`));
+    if (editionSize === 1n)
+        info(copiesOneNote('deploy'));
+    const lane = laneFromFlags(flags);
+    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.');
+    }
+    if (dryRun)
+        assertPreviewDeployer(flags);
+    const publicClient = makePublicClient({ chainKey: CHAIN });
+    await assertChainId(CHAIN, { allowUnreachable: dryRun });
+    // --721c reuses the SAME flag + value grammar to enroll ERC-1155C instead — see the locked
+    // decision in the parity plan (P0): editions ship 1155C at launch with the 721C UX, unchanged.
+    const transferValidator = await resolveTransferValidatorFlag(flags, publicClient, dryRun, '1155C');
+    assertRealIdentity(flags, { name, symbol, dryRun });
+    if (!dryRun) {
+        let signer = flags.for;
+        if (!signer && lane === 'send') {
+            try {
+                signer = makeWalletClient({ chainKey: CHAIN }).account.address;
+            }
+            catch {
+                /* no key yet — later steps handle it */
+            }
+        }
+        if (signer)
+            await warnUnfunded(publicClient, signer);
+    }
+    step('Trust anchor');
+    let factory;
+    if (dryRun) {
+        const existing = oneOfOneEditionFactoryAddress(flags.factory);
+        if (!existing) {
+            info('no canonical 1/1-edition factory for this chain yet — a real deploy would deploy the trust anchor first.');
+            console.log(`\n  ${g('dry run')} ${dim('— nothing sent.')}\n`);
+            return;
+        }
+        factory = existing;
+        if (!(await previewFactoryLive(publicClient, factory, '1/1-edition factory')))
+            return;
+        info(`would reuse canonical 1/1-edition factory ${factory}`);
+    }
+    else {
+        factory = await ensureOneOfOneEditionFactory(flags.factory, !!flags['bootstrap-factory']);
+    }
+    const hasPublicUrl = !!(flags['public-base-url'] || process.env.ABX_PUBLIC_BASE_URL);
+    const onChainUri = !!flags['onchain-uri'] || onchainImage;
+    const traitsOnchain = traits.length > 0 && (!!flags['traits-onchain'] || onChainUri);
+    let renderer = zeroAddress;
+    if (onChainUri) {
+        step('On-chain renderer');
+        if (dryRun) {
+            renderer = rendererAddress(flags.renderer) ?? zeroAddress;
+            info(renderer === zeroAddress ? 'would deploy the canonical renderer first' : `would use renderer ${renderer}`);
+        }
+        else {
+            renderer = await ensureRenderer(flags.renderer);
+        }
+    }
+    if (!onChainUri) {
+        const loopback = loopbackBaseUrl(baseUrl);
+        if (!hasPublicUrl || loopback) {
+            const devAllow = process.env.ABX_DEV_ALLOW_LOCALHOST_URI === '1';
+            const msg = `Off-chain metadata needs a PUBLIC resolver URL baked on-chain — ${hasPublicUrl ? baseUrl : 'localhost'} resolves for no one. ` +
+                `Pick a real path:\n    • Fully on-chain (SVG art):     --onchain-uri\n    • Fully on-chain (any media):   --onchain-image --compress fastlz\n    • Hosted resolver:              --public-base-url https://your.domain`;
+            if (!devAllow) {
+                if (dryRun)
+                    warn(`would REFUSE to deploy — ${msg}`);
+                else
+                    throw new Error(msg);
+            }
+            else {
+                warn(`DEV ONLY (ABX_DEV_ALLOW_LOCALHOST_URI): baking ${bold(baseUrl)} on-chain — resolves only on THIS machine.`);
+            }
+        }
+    }
+    if (onChainUri && !imageResolvesWithoutServer(flags, onchainImage)) {
+        warn(`${bold('--onchain-uri puts the metadata JSON on-chain, not the image.')} With '${backendResolution(storageOverrides(flags)).backend}' custody the image is only ` +
+            `a keccak256 anchor, so ${bold('uri(0)')} will serve a PLACEHOLDER. Two ways to a real image with no server: ${bold('--backend arweave')} (or ipfs/cloud) bakes the URL on-chain, or ${bold('--onchain-image --compress fastlz')} puts the bytes themselves on-chain.`);
+    }
+    step(`Deploy an edition of "${name}" to ${CHAIN}`);
+    let bakedImage;
+    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) {
+            info(previewImageStaging(flags.image, parseCompress(flags.compress)));
+        }
+        else {
+            const { field, note } = await stageImageField(flags.image, parseCompress(flags.compress), envStagingSender());
+            bakedImage = field;
+            info(note);
+        }
+    }
+    const explicitSalt = parseSaltFlag(flags.salt);
+    const noMint = flags['no-mint'] !== undefined;
+    if (noMint && flags['mint-amount'] !== undefined) {
+        throw new Error('--no-mint and --mint-amount disagree — drop one. (--no-mint defers ALL minting at deploy; --mint-amount sets how many copies mint at deploy.)');
+    }
+    const mintAmount = noMint ? 0n : flags['mint-amount'] !== undefined ? parseNonNegativeIntFlag(flags['mint-amount'], 'mint-amount') : 1n;
+    const minter = flags.minter ?? zeroAddress;
+    const primaryPayee = flags['primary-payee'] ?? zeroAddress;
+    const paused = flags.unpaused === undefined;
+    const buildForDeployer = async (deployer) => {
+        const salt = explicitSalt ?? saltFor(deployer);
+        const clone = await predictClone(publicClient, { factory, salt });
+        const { tokenFields, contentNote } = bakedImage
+            ? { tokenFields: [bakedImage], contentNote: 'content: image staged ON-CHAIN via reader (self-resolving, no custody)' }
+            : onchainImage
+                ? { tokenFields: [], contentNote: 'content: image would be staged ON-CHAIN via reader (chunk store) — dry run skips the staging write' }
+                : await prepareContent(flags.image, clone, storageOverrides(flags), !dryRun, onChainUri);
+        if (flags.description && (onChainUri || flags['description-onchain'])) {
+            tokenFields.push({ field: encodeTag(F.description), representation: encodeTag(R.inline), value: toHex(flags.description) });
+        }
+        if (traitsOnchain)
+            tokenFields.push(attributesInlineField(traits));
+        const params = {
+            owner: deployer,
+            mintTo: mintAmount > 0n ? deployer : zeroAddress,
+            mintAmount,
+            name,
+            symbol,
+            tokenURIBase: onChainUri && !hasPublicUrl ? '' : `${baseUrl}/t`,
+            tokenURIRenderer: renderer,
+            contractURIBase: onChainUri && !hasPublicUrl ? '' : `${baseUrl}/c`,
+            contractURIRenderer: renderer,
+            royaltyReceiver: deployer,
+            royaltyBps,
+            transferValidator,
+            editionSize,
+            primaryPayee,
+            minter,
+            paused,
+            tokenFields,
+            contractFields: authorshipContractFields(flags),
+        };
+        return { clone, params, salt, contentNote };
+    };
+    let clone;
+    let blockNumber;
+    if (dryRun) {
+        let deployer;
+        if (flags.for)
+            deployer = flags.for;
+        else {
+            try {
+                deployer = makeWalletClient({ chainKey: CHAIN }).account.address;
+            }
+            catch {
+                throw new Error('dry run needs a deployer address to compute the deterministic deploy address — pass --for 0x.. ' +
+                    '(a preview signs nothing, so no key is needed). For the REAL deploy with no key in .env, use the ' +
+                    'wallet lane: --sign --for 0x.. (you approve in your own wallet).');
+            }
+        }
+        const { clone: predicted, params, salt, contentNote } = await buildForDeployer(deployer);
+        info(`deployer ${deployer}`);
+        await warnUnfunded(publicClient, deployer);
+        if (explicitSalt)
+            info(`deterministic address: ${predicted}`);
+        info(`name    "${name}"${flags.name ? '' : dim('  (default — pass --name)')}`);
+        info(`symbol  ${symbol}${flags.symbol ? '' : dim('  (default — pass --symbol)')}`);
+        info(`copies  ${editionSize === 0n ? 'open (uncapped)' : editionSize.toString()}`);
+        info(describeDeployField('description', flags.description, onChainUri || !!flags['description-onchain']));
+        authorshipReadout(flags).forEach((line) => info(line));
+        info(describeTraits(traits, traitsOnchain));
+        info(`royalty ${royaltyBps / 100}% → ${deployer}${flags['royalty-bps'] ? '' : dim('  (default 5%)')}`);
+        info(contentNote);
+        info(`tokenURI base   ${params.tokenURIBase || dim('(empty — resolves on-chain via the renderer)')}`);
+        info(`contractURI base ${params.contractURIBase || dim('(empty — resolves on-chain via the renderer)')}`);
+        info(mintAmount > 0n ? `mint: ${mintAmount} cop${mintAmount === 1n ? 'y' : 'ies'} of #0 → ${deployer} at deploy` : 'mint: deferred (--no-mint, or --mint-amount 0)');
+        if (minter !== zeroAddress)
+            info(`minter  ${minter}`);
+        if (primaryPayee !== zeroAddress)
+            info(`primary payee  ${primaryPayee}`);
+        info(`paused  ${paused}${flags.unpaused ? '' : dim('  (default — pass --unpaused to open at deploy)')}`);
+        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}`)}.`);
+        }
+        info(dim('the values above are exactly what a real deploy writes — nothing else is added.'));
+        console.log(`\n  ${g('dry run')} ${dim('— nothing sent, no bytes stored. Re-run without --dry-run to deploy.')}\n`);
+        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}%.` +
+        (transferValidator !== zeroAddress ? ` ERC-1155C: enrolled at deploy, permanently (validator ${transferValidator}).` : ''), flags);
+    if (lane === 'send') {
+        const { wallet, account } = makeWalletClient({ chainKey: CHAIN });
+        const { clone: predicted, params, salt, contentNote } = await buildForDeployer(account.address);
+        info(`deterministic address: ${predicted}`);
+        info(describeDeployField('description', flags.description, onChainUri || !!flags['description-onchain']));
+        authorshipReadout(flags).forEach((line) => info(line));
+        info(describeTraits(traits, traitsOnchain));
+        info(contentNote);
+        info(mintAmount > 0n ? `mint: ${mintAmount} cop${mintAmount === 1n ? 'y' : 'ies'} of #0 → ${account.address} at deploy` : 'mint: deferred — mint later with `abx mint`');
+        const send = makeHotSender({ wallet, account, publicClient });
+        const r = await deployOneOfOneEdition(send, publicClient, { factory, params, salt });
+        clone = predicted;
+        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.
+        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);
+            return prepareDeployOneOfOneEdition({ factory, params, salt, chainId: resolveChain(CHAIN).id, clone: predicted });
+        }, { lane, chainKey: CHAIN, yes: !!flags.yes, expectedSigner: flags.for, port: flags.port ? Number(flags.port) : undefined, signUrlFile: flags['sign-url-file'] });
+        if (!result) {
+            console.log(`\n${dim(`  unsigned — broadcast it, then: abx add <clone> --factory ${factory} --from-block <deployBlock>`)}\n`);
+            return;
+        }
+        clone = result.prepared.fields.clone;
+        blockNumber = result.blockNumber;
+        ok(`deployed ${clone}`);
+    }
+    emit(jsonSafe({ command: 'deploy', kind: '1of1-edition', copies: editionSize.toString(), address: clone, chain: CHAIN, chainId: resolveChain(CHAIN).id, factory, deployBlock: blockNumber, name, symbol }));
+    step('Index it — replay the event spine from chain');
+    const indexer = localIndexer();
+    const offChainTraits = !traitsOnchain && traits.length ? JSON.stringify(traits) : undefined;
+    const baseReg = {
+        address: clone,
+        chainKey: CHAIN,
+        fromBlock: blockNumber.toString(),
+        factory,
+        label: name,
+        description: flags.description,
+        externalUrl: flags['external-url'],
+        attributes: offChainTraits,
+    };
+    indexer.register(baseReg);
+    const { state, elapsedMs } = await reindexAfterDeploy(indexer, clone);
+    if (state.eventCount > 0)
+        ok(`reconstructed ${state.eventCount} events in ${elapsedMs}ms — no provider involved`);
+    info(`name "${state.name}" · owner ${state.owner} · canonical: ${canonicalLabel(state.isCanonical)}`);
+    const contentLocators = !onChainUri && !onchainImage ? await collectContentLocators(state, resolveBackend(storageOptions(storageOverrides(flags)))) : {};
+    if (Object.keys(contentLocators).length) {
+        indexer.register({ ...baseReg, contentLocators: JSON.stringify(contentLocators) });
+        info(`content locator: image → ${Object.values(contentLocators)[0]} ${dim('(durable; points off this node)')}`);
+    }
+    if (onChainUri) {
+        if (imageEndsUpOnChain(flags, onchainImage)) {
+            console.log(`\n${g('Done — fully on-chain.')} ${dim('The edition self-resolves; no server or hosting needed.')}`);
+        }
+        else {
+            console.log(`\n${g('Done — metadata on-chain.')} ${dim('uri(0) resolves from the chain with no server.')}`);
+        }
+        console.log(`  ${bold(`abx tokenuri ${clone}`)}  ${dim('# read uri(0) straight from the contract + decode the JSON')}`);
+    }
+    else {
+        console.log(`\n${g('Done.')} ${bold(`abx verify ${clone}`)} ${dim('to confirm integrity · ')}${bold('abx serve')}${dim(' to host LOCALLY')}`);
+    }
+    if (mintAmount === 0n)
+        console.log(`  ${bold(`abx mint ${clone} --amount <n>`)}  ${dim('# issue the first copies of #0')}`);
+    console.log(`  ${bold(`abx minter configure ${clone} --token-id 0 --price <eth> --allocation <n>`)}  ${dim('# set up the priced sale on the shared edition minter')}`);
+    console.log(`  ${bold(`abx refresh ${clone}`)}  ${dim('# nudge marketplaces to index it')}\n`);
+}
 // ── deploy-series ─────────────────────────────────────────────────────────────
 // Point at a directory of media and deploy a multi-token Series. Each file becomes a
 // token (`0..N-1`, natural-sorted) — a token's metadata is its token id, and tokens mint
@@ -1113,6 +1471,11 @@ export const tokenFieldOf = (tokenId, f) => ({
     value: f.value,
 });
 export async function cmdDeploySeries(flags) {
+    // `--copies <N|open>` routes to EditionImage — N ids from the folder × copies each. See the
+    // module note on `cmdDeployOneOfOneEditionBody` for why this is a separate function rather than
+    // `if (copies)` branches threaded through `cmdDeploySeriesBody` (byte-identical 721 lane).
+    if (flags.copies !== undefined)
+        return withJson(flags, async (emit) => cmdDeployEditionImageBody(flags, emit));
     return withJson(flags, async (emit) => cmdDeploySeriesBody(flags, emit));
 }
 export async function cmdDeploySeriesBody(flags, emit) {
@@ -1630,40 +1993,324 @@ export async function cmdDeploySeriesBody(flags, emit) {
     }
     console.log(`  ${bold(`abx refresh ${clone}`)}  ${dim('# nudge marketplaces once metadata is live')}\n`);
 }
-// ── deploy-code ──────────────────────────────────────────────────────────────
-/**
- * `abx deploy-code` — deploy a code project ({SeriesCode}) end to end, hot lane:
- * the canonical factory + seed source from the manifest, fat initialize (the `code`
- * field rides it in directory mode), then ONE post-deploy multicall for the script
- * chunks (template mode) + any PostParam schemas, optional reserve mints, and local
- * register + index. Grown directly from the Sepolia drop rehearsal
- * (`packages/cli/scripts/code-drop-rehearsal.ts`).
- *
- * Modes (exactly one):
- *   --script <file>    template mode — the program stored on-chain in chunks
- *   --code-dir <dir>   directory mode — the build uploaded via the storage backend
- *                      (`putDirectory`; ipfs/arweave), its root as the `code` field
- *
- * Schemas: --schema key:Type:Auth[,key:Type:Auth…] (e.g. palette:HexColor:TokenOwner).
- * Seeds: canonical randomizer by default; --no-seed opts out.
- */
-// ── the demo walkthrough: teaching sections, demo-only ────────────────────────
+// ── deploy-series --copies: EditionImage ──────────────────────────────────────────────────────────
+// N distinct artworks (one per file, like a Series) × copies each. The edition twin of
+// `cmdDeploySeriesBody`, kept as its OWN function for the same reason `cmdDeployOneOfOneEditionBody`
+// is (byte-identical 721 lane — see that function's module note).
 //
-// `abx demo` is a TEACHING command, not a shortcut — the docs point a first-time reader here to
-// learn what the toolkit does on their behalf. Its old form asserted the interesting claims
-// ("reconstructed 9 events — no provider involved") without ever showing them, which made it a
-// smoke test wearing a demo's clothes. These sections demonstrate instead: print the spine the
-// chain now holds, throw the local projection away and rebuild it, then read the token back the way
-// a marketplace would. They run only for `demo` (never `deploy`), and never pause — an agent or CI
-// run has to behave identically.
-/**
- * The deterministic part of a projection: everything that is a pure function of the chain.
- * Deliberately EXCLUDES `reconstructedAt`, `rpcUrl` and `toBlock` — a timestamp, the endpoint that
- * happened to answer, and the head at scan time all legitimately differ between two replays, so
- * folding them in would make the rebuild proof fail for reasons that aren't about correctness.
- */
-export function projectionFingerprint(s) {
-    const canonical = {
+// v1 scope (reported, not hidden): custody is off-chain (keccak + optional backend upload, ONE
+// `backend.put` per file) or `--onchain-uri` (inline SVG). `cmdDeploySeriesBody`'s O(1) uniform-
+// extension directory upload and `--onchain-image` chunk staging are NOT ported here — both are
+// real engineering (a shared chunk store / a shared directory manifest across N ids), and a per-file
+// fallback already works correctly, just at O(N) upload calls instead of O(1). Tracked as a follow-up.
+// (`DEPLOY_SERIES_EDITION_FLAGS` is declared further down, beside `DEPLOY_EDITION_FLAGS` — see that
+// const's own note on why.)
+export async function cmdDeployEditionImageBody(flags, emit) {
+    refuseStrayFlags(flags, DEPLOY_SERIES_EDITION_FLAGS, 'deploy-series');
+    warnSignWithoutFor(flags);
+    const editionSize = parseCopies(flags.copies);
+    const name = flags.name ?? 'ABX Edition Series';
+    const symbol = flags.symbol ?? 'ABXES';
+    const royaltyBps = Number(flags['royalty-bps'] ?? 500);
+    const port = Number(flags.port ?? process.env.ABX_PORT ?? DEFAULT_PORT);
+    const baseUrl = flags['public-base-url'] ?? resolveBaseUrl(port);
+    console.log(bold(`\n  ABX Self-Host Toolkit — deploy edition series\n  ${dim(editionSize === 0n
+        ? 'EditionImage (ERC-1155) — N ids from the folder, each an OPEN edition'
+        : `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://…] ' +
+            '[--minter 0x..] [--primary-payee 0x..] [--unpaused] [--721c recommended|0x..] --name "Title" --symbol SYM');
+    }
+    const dirPath = resolvePath(flags.dir);
+    const files = readdirSync(dirPath)
+        .filter((f) => !f.startsWith('.') && statSync(joinPath(dirPath, f)).isFile())
+        .sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+    if (files.length === 0)
+        throw new Error(`no media files in ${dirPath}`);
+    const count = flags.count ? Number(flags.count) : files.length;
+    if (!Number.isInteger(count) || count <= 0)
+        throw new Error('--count must be a positive integer');
+    if (count > files.length)
+        throw new Error(`--count ${count} exceeds the ${files.length} media file(s) in ${dirPath}`);
+    const slots = files.slice(0, count);
+    const dryRun = isDryRun(flags);
+    if (dryRun)
+        assertPreviewDeployer(flags);
+    assertRealIdentity(flags, { name, symbol, dryRun });
+    const lane = laneFromFlags(flags);
+    const publicClient = makePublicClient({ chainKey: CHAIN });
+    await assertChainId(CHAIN, { allowUnreachable: dryRun });
+    const transferValidator = await resolveTransferValidatorFlag(flags, publicClient, dryRun, '1155C');
+    // Mint timing: `mintCount` ids premint (SAME meaning as the 721 lane's --mint-all/--mint-count —
+    // how many DISTINCT ids), `mintAmount` is the NEW knob: copies of EACH premint id.
+    const mintCount = flags['mint-all'] !== undefined ? count : flags['mint-count'] ? Number(flags['mint-count']) : 0;
+    if (mintCount > count)
+        throw new Error(`--mint-count ${mintCount} exceeds the series size ${count}`);
+    if (flags['no-mint'] !== undefined && (flags['mint-all'] !== undefined || flags['mint-count'] !== undefined)) {
+        throw new Error('--no-mint contradicts --mint-all/--mint-count — drop one.');
+    }
+    const effectiveMintCount = flags['no-mint'] !== undefined ? 0 : mintCount;
+    const mintAmount = effectiveMintCount > 0 ? (flags['mint-amount'] !== undefined ? parseNonNegativeIntFlag(flags['mint-amount'], 'mint-amount') : 1n) : 0n;
+    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'];
+    const minter = flags.minter ?? zeroAddress;
+    const paused = flags.unpaused === undefined;
+    const primaryPayee = flags['primary-payee'] ?? zeroAddress;
+    const explicitSalt = parseSaltFlag(flags.salt);
+    const hasPublicUrl = !!(flags['public-base-url'] || process.env.ABX_PUBLIC_BASE_URL);
+    step('Trust anchor');
+    let factory;
+    if (dryRun) {
+        const existing = editionFactoryAddress(flags.factory);
+        if (!existing) {
+            info('no canonical edition factory for this chain yet — a real deploy would deploy the trust anchor first.');
+            console.log(`\n  ${g('dry run')} ${dim('— nothing sent.')}\n`);
+            return;
+        }
+        factory = existing;
+        if (!(await previewFactoryLive(publicClient, factory, 'edition factory')))
+            return;
+        info(`would reuse canonical edition factory ${factory}`);
+    }
+    else {
+        factory = await ensureEditionFactory(flags.factory, !!flags['bootstrap-factory']);
+    }
+    let renderer = zeroAddress;
+    if (onChainUri) {
+        step('On-chain renderer');
+        renderer = dryRun ? (rendererAddress(flags.renderer) ?? zeroAddress) : await ensureRenderer(flags.renderer);
+    }
+    if (!onChainUri) {
+        const loopback = loopbackBaseUrl(baseUrl);
+        if (!hasPublicUrl || loopback) {
+            const devAllow = process.env.ABX_DEV_ALLOW_LOCALHOST_URI === '1';
+            const msg = `Off-chain metadata needs a PUBLIC resolver URL baked on-chain — ${hasPublicUrl ? baseUrl : 'localhost'} resolves for no one. ` +
+                `Pick a real path:\n    • Fully on-chain (SVG art):     --onchain-uri\n    • Hosted resolver:              --public-base-url https://your.domain`;
+            if (!devAllow) {
+                if (dryRun)
+                    warn(`would REFUSE to deploy — ${msg}`);
+                else
+                    throw new Error(msg);
+            }
+            else {
+                warn(`DEV ONLY (ABX_DEV_ALLOW_LOCALHOST_URI): baking ${bold(baseUrl)} on-chain — resolves only on THIS machine.`);
+            }
+        }
+    }
+    step(`Prepare ${count} id(s) from ${basename(dirPath)}/`);
+    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;
+    const tokenPaths = slots.map((s, i) => ({ tokenId: i, name: s, path: joinPath(dirPath, s) }));
+    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;
+    const tokenFields = [];
+    const buildFields = async () => {
+        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.`);
+                }
+                tokenFields.push(tokenFieldOf(tokenId, imageInlineField(text)));
+            }
+            else {
+                const hash = hashContent(bytes);
+                if (backend)
+                    await backend.put(hash, { bytes, contentType });
+                tokenFields.push(tokenFieldOf(tokenId, imageKeccakField(hash)));
+            }
+            info(`id ${tokenId} ← ${fname} ${dim(`(${bytes.length}B ${contentType})`)}`);
+        }
+        if (seriesTraitsOnchain)
+            for (const [tokenId, attrs] of seriesTraits)
+                tokenFields.push(tokenFieldOf(tokenId, attributesInlineField(attrs)));
+    };
+    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}%.` +
+            (transferValidator !== zeroAddress ? ` ERC-1155C: enrolled at deploy, permanently (validator ${transferValidator}).` : ''), flags);
+    }
+    await buildFields();
+    const buildForDeployer = async (deployer) => {
+        const salt = explicitSalt ?? saltFor(deployer);
+        const clone = await predictClone(publicClient, { factory, salt });
+        const params = {
+            owner: deployer,
+            name,
+            symbol,
+            tokenURIBase: onChainUri && !hasPublicUrl ? '' : `${baseUrl}/t`,
+            tokenURIRenderer: renderer,
+            contractURIBase: onChainUri && !hasPublicUrl ? '' : `${baseUrl}/c`,
+            contractURIRenderer: renderer,
+            royaltyReceiver: deployer,
+            royaltyBps,
+            transferValidator,
+            maxInvocations: count,
+            editionSize,
+            primaryPayee,
+            minter,
+            paused,
+            mintTo: effectiveMintCount > 0 ? deployer : zeroAddress,
+            mintCount: effectiveMintCount,
+            mintAmount,
+            tokenFields,
+            contractFields: authorshipContractFields(flags),
+        };
+        return { clone, params, salt };
+    };
+    let clone;
+    let blockNumber;
+    if (dryRun) {
+        let deployer;
+        if (flags.for)
+            deployer = flags.for;
+        else {
+            try {
+                deployer = makeWalletClient({ chainKey: CHAIN }).account.address;
+            }
+            catch {
+                throw new Error('dry run needs a deployer address to compute the deterministic deploy address — pass --for 0x.. (a preview signs nothing).');
+            }
+        }
+        const { clone: predicted, params, salt } = await buildForDeployer(deployer);
+        info(`deployer ${deployer}`);
+        await warnUnfunded(publicClient, deployer);
+        if (explicitSalt)
+            info(`deterministic address: ${predicted}`);
+        info(`name    "${name}"${flags.name ? '' : dim('  (default — pass --name)')}`);
+        info(`symbol  ${symbol}${flags.symbol ? '' : dim('  (default — pass --symbol)')}`);
+        info(`ids     ${count} (id-space cap)`);
+        info(`copies  ${editionSize === 0n ? 'open (uncapped) per id' : `${editionSize} per id`}`);
+        info(`royalty ${royaltyBps / 100}% → ${deployer}${flags['royalty-bps'] ? '' : dim('  (default 5%)')}`);
+        info(`tokenURI base   ${params.tokenURIBase || dim('(empty — resolves on-chain via the renderer)')}`);
+        info(`mint: ${effectiveMintCount > 0 ? `${effectiveMintCount} id(s) × ${mintAmount} cop${mintAmount === 1n ? 'y' : 'ies'} → ${deployer} at deploy` : 'deferred'}`);
+        if (minter !== zeroAddress)
+            info(`minter  ${minter}`);
+        if (primaryPayee !== zeroAddress)
+            info(`primary payee  ${primaryPayee}`);
+        if (!explicitSalt) {
+            console.log(`\n  ${bold('salt')}  ${g(salt)}`);
+            info(`address: pinned by salt — re-run with ${bold(`--salt ${salt}`)} (same address).`);
+        }
+        console.log(`\n  ${g('dry run')} ${dim('— nothing sent, no bytes stored. Re-run without --dry-run to deploy.')}\n`);
+        emit(jsonSafe({ command: 'deploy-series', kind: 'edition', copies: editionSize.toString(), ids: count, dryRun: true, sent: false, address: explicitSalt ? predicted : null, chain: CHAIN, chainId: resolveChain(CHAIN).id, factory, salt, saltPinned: !!explicitSalt, name, symbol }));
+        return;
+    }
+    if (lane === 'send') {
+        const { wallet, account } = makeWalletClient({ chainKey: CHAIN });
+        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'}`);
+        const send = makeHotSender({ wallet, account, publicClient });
+        const r = await deployEditionImage(send, publicClient, { factory, params, salt });
+        clone = predicted;
+        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) => {
+            const { clone: predicted, params, salt } = await buildForDeployer(signer);
+            return prepareDeployEditionImage({ factory, params, salt, chainId: resolveChain(CHAIN).id, clone: predicted });
+        }, { lane, chainKey: CHAIN, yes: !!flags.yes, expectedSigner: flags.for, port: flags.port ? Number(flags.port) : undefined, signUrlFile: flags['sign-url-file'] });
+        if (!result) {
+            console.log(`\n${dim(`  unsigned — broadcast it, then: abx add <clone> --factory ${factory} --from-block <deployBlock>`)}\n`);
+            return;
+        }
+        clone = result.prepared.fields.clone;
+        blockNumber = result.blockNumber;
+        ok(`deployed ${clone}`);
+    }
+    emit(jsonSafe({ command: 'deploy-series', kind: 'edition', copies: editionSize.toString(), ids: count, address: clone, chain: CHAIN, chainId: resolveChain(CHAIN).id, factory, deployBlock: blockNumber, name, symbol }));
+    step('Index it — replay the event spine from chain');
+    const indexer = localIndexer();
+    const offChainTraits = !seriesTraitsOnchain && offChainTokenTraits ? offChainTokenTraits : undefined;
+    const baseReg = {
+        address: clone,
+        chainKey: CHAIN,
+        fromBlock: blockNumber.toString(),
+        factory,
+        label: name,
+        description: flags.description,
+        externalUrl: flags['external-url'],
+        tokenAttributes: offChainTraits,
+    };
+    indexer.register(baseReg);
+    const { state, elapsedMs } = await reindexAfterDeploy(indexer, clone);
+    if (state.eventCount > 0)
+        ok(`reconstructed ${state.eventCount} events in ${elapsedMs}ms — no provider involved`);
+    info(`name "${state.name}" · owner ${state.owner} · canonical: ${canonicalLabel(state.isCanonical)}`);
+    const contentLocators = !onChainUri ? await collectContentLocators(state, resolveBackend(storageOptions(storageOverrides(flags)))) : {};
+    if (Object.keys(contentLocators).length) {
+        indexer.register({ ...baseReg, contentLocators: JSON.stringify(contentLocators) });
+    }
+    const isRemoteBase = !/^https?:\/\/(localhost|127\.0\.0\.1)\b/i.test(baseUrl);
+    if (onChainUri) {
+        console.log(`\n${g('Done — fully on-chain.')} ${dim('Every id self-resolves; no server needed.')}`);
+        console.log(`  ${bold(`abx tokenuri ${clone} --token 0`)}  ${dim('# read uri(0) straight from the contract')}`);
+    }
+    else {
+        console.log(`\n${g('Edition series deployed.')} ${effectiveMintCount > 0 ? '' : dim('(deferred mint — warm the resolver, then mint)')}`);
+        if (isRemoteBase)
+            console.log(`  ${bold(`abx add ${clone} --remote`)}  ${dim('# register with the hosted resolver')}`);
+        else
+            console.log(`  ${bold('abx serve')}  ${dim('# stand up the resolver locally')}`);
+    }
+    console.log(`  ${bold(`abx mint ${clone} --token-id <id> --amount <n>`)}  ${dim('# mint more copies of an id')}`);
+    console.log(`  ${bold(`abx minter configure ${clone} --token-id <id> --price <eth> --allocation <n>`)}  ${dim('# set up a priced sale for one id')}`);
+    console.log(`  ${bold(`abx refresh ${clone}`)}  ${dim('# nudge marketplaces once metadata is live')}\n`);
+}
+// ── deploy-code ──────────────────────────────────────────────────────────────
+/**
+ * `abx deploy-code` — deploy a code project ({SeriesCode}) end to end, hot lane:
+ * the canonical factory + seed source from the manifest, fat initialize (the `code`
+ * field rides it in directory mode), then ONE post-deploy multicall for the script
+ * chunks (template mode) + any PostParam schemas, optional reserve mints, and local
+ * register + index. Grown directly from the Sepolia drop rehearsal
+ * (`packages/cli/scripts/code-drop-rehearsal.ts`).
+ *
+ * Modes (exactly one):
+ *   --script <file>    template mode — the program stored on-chain in chunks
+ *   --code-dir <dir>   directory mode — the build uploaded via the storage backend
+ *                      (`putDirectory`; ipfs/arweave), its root as the `code` field
+ *
+ * Schemas: --schema key:Type:Auth[,key:Type:Auth…] (e.g. palette:HexColor:TokenOwner).
+ * Seeds: canonical randomizer by default; --no-seed opts out.
+ */
+// ── the demo walkthrough: teaching sections, demo-only ────────────────────────
+//
+// `abx demo` is a TEACHING command, not a shortcut — the docs point a first-time reader here to
+// learn what the toolkit does on their behalf. Its old form asserted the interesting claims
+// ("reconstructed 9 events — no provider involved") without ever showing them, which made it a
+// smoke test wearing a demo's clothes. These sections demonstrate instead: print the spine the
+// chain now holds, throw the local projection away and rebuild it, then read the token back the way
+// a marketplace would. They run only for `demo` (never `deploy`), and never pause — an agent or CI
+// run has to behave identically.
+/**
+ * The deterministic part of a projection: everything that is a pure function of the chain.
+ * Deliberately EXCLUDES `reconstructedAt`, `rpcUrl` and `toBlock` — a timestamp, the endpoint that
+ * happened to answer, and the head at scan time all legitimately differ between two replays, so
+ * folding them in would make the rebuild proof fail for reasons that aren't about correctness.
+ */
+export function projectionFingerprint(s) {
+    const canonical = {
         address: s.address.toLowerCase(),
         name: s.name,
         symbol: s.symbol,
@@ -1839,7 +2486,30 @@ export const DEPLOY_SERIES_FLAGS = new Set([
     ...AUTHORSHIP_DEPLOY_FIELDS.map(([flag]) => flag),
     ...SHARED_DEPLOY_FLAGS,
 ]);
+// The two edition allowlists that SPREAD an existing 721 allowlist (`DEPLOY_FLAGS`/
+// `DEPLOY_SERIES_FLAGS`) — declared here, AFTER both, so the spread isn't a module-scope
+// use-before-declaration (a plain function-body reference to a later `const` is fine; a spread
+// inside another top-level `const`'s OWN initializer is evaluated immediately, in declaration
+// order, so it isn't). `cmdDeployOneOfOneEditionBody`/`cmdDeployEditionImageBody` reference these
+// by name from higher up in the file — safe, since neither is CALLED until well after the whole
+// 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 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.
+    // Refused HERE, before either body runs, so the message is specific rather than either body's
+    // own (unrelated) stray-flag refusal: `cmdDeployEditionCodeBody` doesn't recognize --resume at
+    // all yet, and `cmdDeployCodeBody` would otherwise reject bare --copies as an unrecognized flag.
+    if (flags.resume !== undefined && flags.copies !== undefined) {
+        throw new Error('--resume cannot be combined with --copies: the target already exists (and its standard was fixed at ITS OWN ' +
+            'deploy); --copies only chooses a standard at CREATION time. Drop --copies — `abx deploy-code --resume <address> …` ' +
+            'reads what the target already is.');
+    }
+    // `--copies <N|open>` routes to EditionCode. See the module note on `cmdDeployOneOfOneEditionBody`
+    // for why this is a separate function rather than `if (copies)` branches (byte-identical 721 lane).
+    if (flags.copies !== undefined)
+        return withJson(flags, async (emit) => cmdDeployEditionCodeBody(flags, emit));
     return withJson(flags, async (emit) => cmdDeployCodeBody(flags, emit));
 }
 export async function cmdDeployCodeBody(flags, emit) {
@@ -2682,6 +3352,8 @@ export async function cmdDeployCodeBody(flags, emit) {
         // Deploy-time-only flags are refused rather than ignored: --salt/--721c/--bootstrap-factory all
         // describe how a contract is CREATED, and this creates nothing. 721C especially — enrollment is
         // permanent and deploy-time-only, so accepting the flag here would imply it can be added later.
+        // (--copies + --resume is refused earlier, at cmdDeployCode's dispatch — before this function
+        // even runs — so `flags.copies` is guaranteed undefined here; see that guard's own comment.)
         for (const [flag, why] of [
             ['salt', 'the address already exists, so no salt is used'],
             ['721c', 'ERC-721C enrollment is deploy-time-only and PERMANENT — it cannot be added to an existing collection'],
@@ -2691,6 +3363,18 @@ export async function cmdDeployCodeBody(flags, emit) {
             if (flags[flag] !== undefined)
                 throw new Error(`--resume cannot be combined with --${flag}: ${why}.`);
         }
+        // Edition resume is NOT supported: the SDK's `planResume`/`ResumeReader` (resume.ts) assume the
+        // 721 shape throughout — a single sequential `mint(address)` shortfall against a whole-contract
+        // `totalSupply()`, neither of which exists on EditionCode (`mint(address,uint256,uint256)` per id,
+        // no whole-contract total — see tokens.ts's `TokenListing.totalSupply` doc). Refuse cleanly rather
+        // than diff against the wrong shape and silently under- or over-report what's missing.
+        if (await isEditionContract(publicClient, target)) {
+            throw new Error(`--resume ${target}: this is an EditionCode contract, and resume isn't wired for editions yet — the diff logic ` +
+                `(packages/sdk/src/resume.ts) assumes the 721 shape (one sequential mint, one whole-contract totalSupply), ` +
+                `neither of which an edition has. If the setup multicall is what failed, the safest path right now is a hand-` +
+                `assembled resend (the SAME idea resume.ts automates for 721 — see its class-level doc comment) or filing this ` +
+                `as a gap: edition resume needs its own ResumeReader/SetupLegs shape (per-id totalSupply, a (to,id,amount) mint leg).`);
+        }
         const owner = await publicClient
             .readContract({ address: target, abi: seriesCodeAbi, functionName: 'owner' })
             .catch(() => undefined);
@@ -2929,16 +3613,362 @@ export async function cmdDeployCodeBody(flags, emit) {
     console.log(`\n  ${bold('Verify after minting token 0:')} ${bold(`abx verify ${clone}`)} ${dim('— confirms the thumbnail is a real render, not the placeholder')}`);
     console.log(`  ${dim('live view:')} ${baseUrl}/a/${chainId}/${clone}/0   ${dim('· tokenURI:')} abx tokenuri ${clone}\n`);
 }
+// ── deploy-code --copies: EditionCode ─────────────────────────────────────────────────────────────
+// A generative/code drop as copies — the full generative stack (on-chain script, PostParams, a
+// mint-time seed) minus the parts this pass deliberately did not port (see below). Kept as its own
+// function for the same byte-identical-721-lane reason as the other two edition bodies.
+//
+// v1 scope (reported, not hidden), each refused in code rather than silently ignored:
+//   • `--code-dir` (directory-build code drops) — not ported; use `--script`.
+//   • `--dep` / `--dep-registry` (declared code dependencies) — not ported; ship a self-contained
+//     script (the skill already recommends zero-dependency vanilla JS as the cleanest option).
+//   • `--image-renderer` / `--attributes-renderer` / `--image-base` (the in-chain-Solidity-art and
+//     deterministic-off-chain-thumbnail lanes) — not ported.
+//   • `--no-delegation` — refused outright: EditionCode has no TokenOwner-leg delegation to opt out
+//     of (its auth leg generalizes to "any holder", per the parity plan's ConfigurableParams note).
+//   • `--resume` — refused (see the `isEditionContract` guard in `cmdDeployCodeBody`'s own --resume
+//     handling): the SDK's resume.ts assumes the 721 mint/supply shape throughout.
+// Every other combination `--script` + `--onchain-uri`/`--public-base-url` supports on the 721 lane
+// (schemas, seed opt-out, mint timing, royalty, identity fields, --721c→1155C) works here too.
+export const DEPLOY_CODE_EDITION_FLAGS = new Set([
+    'script', 'name', 'symbol', 'description', 'external-url', 'description-onchain',
+    ...AUTHORSHIP_DEPLOY_FIELDS.map(([flag]) => flag),
+    'max', 'mint-count', 'mint-all', 'no-mint', 'mint-amount', 'unpaused', 'minter', 'primary-payee', 'royalty-bps', '721c',
+    'schema', 'no-seed',
+    'public-base-url', 'onchain-uri', 'generator', 'renderer', 'port',
+    'sign', 'unsigned', 'for', 'salt', 'factory', 'bootstrap-factory', 'sign-url-file',
+    'dry-run', 'confirm', 'yes', 'json', 'copies',
+    // v1-scope-cut flags: kept in the ALLOWLIST (not stray) so they reach this function's own
+    // pointed refusal below, rather than the generic "unrecognized flag" `refuseStrayFlags` would
+    // give them otherwise — a real but less helpful refusal (it doesn't say WHY, or the way out).
+    // (`resume` is NOT here: --resume + --copies is refused earlier, at cmdDeployCode's dispatch —
+    // this function never runs with flags.resume set, so listing it here would just be dead.)
+    'code-dir', 'dep', 'dep-registry', 'image-renderer', 'attributes-renderer', 'image-base', 'no-delegation',
+]);
+export async function cmdDeployEditionCodeBody(flags, emit) {
+    const usage = 'abx deploy-code --copies <n|open> --script <file> --name "Title" --symbol SYM (--public-base-url https://your.resolver.domain | --onchain-uri) ' +
+        '[--description "<s>"] [--external-url <url>] [--max N] [--mint-count N | --mint-all] [--mint-amount N] ' +
+        '[--schema key:Type:Auth,…] [--no-seed] [--unpaused] [--minter 0x..] [--primary-payee 0x..] [--royalty-bps N] [--721c recommended|0x..]';
+    refuseStrayFlags(flags, DEPLOY_CODE_EDITION_FLAGS, 'deploy-code');
+    warnSignWithoutFor(flags);
+    const editionSize = parseCopies(flags.copies);
+    if (flags['code-dir']) {
+        throw new Error('--code-dir is not yet supported for edition code deploys (--copies) — use --script (on-chain chunks) instead. Tracked as a follow-up.');
+    }
+    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.');
+    }
+    // Not a scope cut — semantically refused: EditionCode has no TokenOwner-leg delegation to opt
+    // out of. Its Params auth leg generalizes to "any holder" (balanceOf(sender, id) > 0) instead of
+    // the 721 delegate.xyz leg --no-delegation exists to disable (see EditionCodeInitParams's own
+    // doc comment — it has no `disableTokenOwnerDelegation` field at all).
+    if (flags['no-delegation'] !== undefined) {
+        throw new Error('--no-delegation has nothing to disable on an EditionCode: its Params auth leg generalizes to "any holder" ' +
+            '(balanceOf(sender, id) > 0) instead of the 721 TokenOwner leg\'s delegate.xyz resolution --no-delegation opts out ' +
+            'of. Drop the flag.');
+    }
+    const dryRun = isDryRun(flags);
+    const name = flags.name ?? 'ABX Edition Code';
+    const symbol = flags.symbol ?? 'ABXEC';
+    assertRealIdentity(flags, { name, symbol, dryRun });
+    const max = Number(flags.max ?? 16);
+    if (!Number.isInteger(max) || max <= 0)
+        throw new Error('--max must be a positive integer');
+    if (flags['no-mint'] !== undefined && (flags['mint-all'] !== undefined || flags['mint-count'] !== undefined)) {
+        throw new Error('--no-mint contradicts --mint-all/--mint-count — drop one.');
+    }
+    const mintCount = flags['no-mint'] !== undefined ? 0 : flags['mint-all'] !== undefined ? max : Number(flags['mint-count'] ?? 0);
+    if (mintCount > max)
+        throw new Error(`--mint-count ${mintCount} exceeds --max ${max}`);
+    const mintAmount = mintCount > 0 ? (flags['mint-amount'] !== undefined ? parseNonNegativeIntFlag(flags['mint-amount'], 'mint-amount') : 1n) : 0n;
+    if (mintCount > 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 paused = flags.unpaused === undefined;
+    const royaltyBps = Number(flags['royalty-bps'] ?? 500);
+    const port = Number(flags.port ?? process.env.ABX_PORT ?? DEFAULT_PORT);
+    const baseUrl = (flags['public-base-url'] ?? resolveBaseUrl(port)).replace(/\/$/, '');
+    const hasPublicUrl = !!(flags['public-base-url'] || process.env.ABX_PUBLIC_BASE_URL);
+    const onChainUri = !!flags['onchain-uri'];
+    console.log(bold(`\n  ABX Self-Host Toolkit — deploy edition code project\n  ${dim(editionSize === 0n
+        ? 'EditionCode (ERC-1155) — a program is the content; each id an OPEN edition'
+        : `EditionCode (ERC-1155) — a program is the content; ${editionSize} cop${editionSize === 1n ? 'y' : 'ies'} of each id`)}`));
+    if (editionSize === 1n)
+        info(copiesOneNote('deploy-code'));
+    if (!onChainUri && (!hasPublicUrl || loopbackBaseUrl(baseUrl))) {
+        const devAllow = process.env.ABX_DEV_ALLOW_LOCALHOST_URI === '1';
+        const msg = `A code project resolves its metadata + live view through your resolver, so this deploy bakes that resolver's PUBLIC URL on-chain — ${hasPublicUrl ? baseUrl : 'localhost'} resolves for no one. ` +
+            `Pick a real path:\n    • Fully on-chain, no server:  --onchain-uri\n    • Hosted resolver:            abx deploy-resolver --provider fly --domain meta.you.xyz, then --public-base-url https://meta.you.xyz`;
+        if (!devAllow) {
+            if (dryRun)
+                warn(`would REFUSE to deploy — ${msg}`);
+            else
+                throw new Error(msg);
+        }
+        else {
+            warn(`DEV ONLY (ABX_DEV_ALLOW_LOCALHOST_URI): baking ${bold(baseUrl)} on-chain — resolves only on THIS machine; not a real NFT.`);
+        }
+    }
+    const publicClient = makePublicClient({ chainKey: CHAIN });
+    await assertChainId(CHAIN, { allowUnreachable: dryRun });
+    const chainId = dryRun ? resolveChain(CHAIN).id : (await publicClient.getChainId());
+    const transferValidator = await resolveTransferValidatorFlag(flags, publicClient, dryRun, '1155C');
+    step('Trust anchor');
+    let factory;
+    if (dryRun) {
+        const existing = editionCodeFactoryAddress(flags.factory);
+        if (!existing) {
+            info('no canonical EditionCode factory for this chain yet — a real deploy would deploy the trust anchor first (or --bootstrap-factory).');
+            console.log(`\n  ${g('dry run')} ${dim('— nothing sent.')}\n`);
+            return;
+        }
+        factory = existing;
+        info(`would reuse canonical EditionCode factory ${factory}`);
+    }
+    else {
+        factory = await ensureEditionCodeFactory(publicClient, flags.factory, !!flags['bootstrap-factory']);
+    }
+    const seedSource = flags['no-seed'] !== undefined
+        ? zeroAddress
+        : dryRun
+            ? (resolveSeedSource(chainId) ?? zeroAddress)
+            : await ensureSeedSource(publicClient);
+    let generator = zeroAddress;
+    let metadataRenderer = zeroAddress;
+    if (onChainUri) {
+        step('On-chain URI');
+        const knownGenerator = resolveGenerator(chainId, flags.generator);
+        if (!knownGenerator) {
+            throw new Error(`--onchain-uri needs the canonical AbxGenerator for '${CHAIN}', and none is configured. Set ABX_GENERATOR / --generator, ` +
+                `or check the shipped manifest (packages/sdk/src/deployments.ts).`);
+        }
+        generator = knownGenerator;
+        if (!dryRun) {
+            const generatorCode = await publicClient.getCode({ address: generator });
+            if (!generatorCode || generatorCode === '0x')
+                throw new Error(`the configured generator ${generator} has no code on '${CHAIN}' — check ABX_GENERATOR / --generator / the RPC endpoint.`);
+        }
+        info(dryRun ? `would point animation_url at the canonical generator ${generator} (computed on-chain)` : `animation_url computes ON-CHAIN via the canonical generator ${generator}`);
+        metadataRenderer = dryRun ? (rendererAddress(flags.renderer) ?? zeroAddress) : await ensureRenderer(flags.renderer);
+        info(metadataRenderer === zeroAddress
+            ? 'would deploy the canonical metadata renderer first, then set the URI renderers to it in the setup multicall'
+            : `uri()/contractURI() resolve ON-CHAIN via the renderer ${metadataRenderer} — no resolver in the token's graph.`);
+        if (!hasPublicUrl)
+            info('off-chain fallback pointer left empty (the renderer is authoritative); set --public-base-url to bake one anyway.');
+    }
+    const schemas = parseSchemaSpecs(flags.schema);
+    step('Content');
+    const scriptPath = flags.script;
+    const source = readFileSync(resolvePath(scriptPath), 'utf8');
+    const bytes = new TextEncoder().encode(source);
+    const CHUNK = 22_000; // SSTORE2 headroom
+    const scriptChunks = [];
+    for (let off = 0; off < bytes.length; off += CHUNK)
+        scriptChunks.push(toHex(bytes.slice(off, off + CHUNK)));
+    ok(`script ${bytes.length} bytes → ${scriptChunks.length} on-chain chunk(s)`);
+    const contractFields = [];
+    if (flags.description)
+        contractFields.push({ field: encodeTag(F.description), representation: encodeTag(R.inline), value: toHex(String(flags.description)) });
+    if (flags['external-url'])
+        contractFields.push({ field: encodeTag(F.externalUrl), representation: encodeTag(R.inline), value: toHex(String(flags['external-url'])) });
+    contractFields.push(...authorshipContractFields(flags));
+    const onchainUriLegs = onChainUri ? onchainUriSetupCalls({ generator, metadataRenderer }) : [];
+    step('Deploy');
+    const lane = laneFromFlags(flags);
+    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).
+    const initParamsFor = (owner) => ({
+        owner,
+        name,
+        symbol,
+        tokenURIBase: onChainUri && !hasPublicUrl ? '' : `${baseUrl}/t`,
+        tokenURIRenderer: zeroAddress,
+        contractURIBase: onChainUri && !hasPublicUrl ? '' : `${baseUrl}/c`,
+        contractURIRenderer: zeroAddress,
+        royaltyReceiver: owner,
+        royaltyBps,
+        transferValidator,
+        maxInvocations: BigInt(max),
+        editionSize,
+        primaryPayee,
+        minter,
+        paused,
+        seedSource,
+        mintTo: zeroAddress,
+        mintCount: 0n,
+        mintAmount: 0n,
+        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],
+            }));
+        }
+        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;
+    };
+    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,
+            }));
+        }
+        return { clone, txs };
+    };
+    const approvals = 1 + (scriptChunks.length + schemas.length + 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; ` +
+            `${onChainUri ? `tokenURI ON-CHAIN via the renderer (generator ${generator})` : `resolver base ${baseUrl}`}; ` +
+            `mint: ${mintCount > 0 ? `${mintCount} 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);
+    }
+    if (dryRun) {
+        let deployer = null;
+        if (flags.for)
+            deployer = flags.for;
+        else {
+            try {
+                deployer = makeWalletClient({ chainKey: CHAIN }).account.address;
+            }
+            catch {
+                deployer = null;
+            }
+        }
+        const salt = deployer ? (explicitSalt ?? saltFor(deployer)) : null;
+        const predicted = salt ? await predictClone(publicClient, { factory, salt }) : null;
+        const shownAddr = explicitSalt ? predicted : null;
+        step(`Deploy plan — up to ${max} id(s), ${editionSize === 0n ? 'open' : editionSize.toString()} cop${editionSize === 1n ? 'y' : 'ies'} each, to ${CHAIN}`);
+        if (deployer)
+            info(`deployer ${deployer}`);
+        else
+            info(`deployer: ${dim('not set')} — pass ${bold('--for 0x..')} to preview the exact deterministic address.`);
+        if (shownAddr)
+            info(`deterministic address: ${shownAddr}`);
+        info(`name "${name}" · symbol ${symbol} · max ${max} id(s) · royalty ${royaltyBps / 100}%`);
+        info(`content: script ${bytes.length} bytes → ${scriptChunks.length} on-chain chunk(s)`);
+        info(`seed source: ${seedSource === zeroAddress ? 'none (--no-seed / not configured)' : seedSource}`);
+        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' : ''})`);
+        if (!explicitSalt && deployer) {
+            console.log(`\n  ${bold('salt')}  ${g(salt)}`);
+            info(`address: pinned by salt — re-run with ${bold(`--salt ${salt}`)} (same address).`);
+        }
+        console.log(`\n  ${g('dry run')} ${dim('— nothing sent.')}\n`);
+        emit(jsonSafe({ command: 'deploy-code', kind: 'edition-code', copies: editionSize.toString(), dryRun: true, sent: false, address: shownAddr, chain: CHAIN, chainId, factory, name, symbol }));
+        return;
+    }
+    let clone;
+    let deployBlock;
+    if (lane === 'unsigned') {
+        const signer = flags.for;
+        if (!signer)
+            throw new Error('--unsigned needs --for <signer> — the salt guard and ownership are keyed to the signing address');
+        const { clone: predicted, txs } = await preparedFor(signer);
+        for (const tx of txs)
+            await signTx(() => tx, { lane, chainKey: CHAIN, yes: !!flags.yes, expectedSigner: signer });
+        console.log(`\n${dim(`  unsigned — broadcast in order, then: abx add ${predicted} --factory ${factory} --from-block <deployBlock>`)}\n`);
+        return;
+    }
+    if (lane === 'sign') {
+        const session = await openWalletSession({ chainKey: CHAIN, expectedSigner: flags.for, total: approvals, port: flags.port ? Number(flags.port) : undefined, signUrlFile: flags['sign-url-file'] });
+        try {
+            const signer = await session.connect();
+            const { clone: predicted, txs } = await preparedFor(signer);
+            let first;
+            for (const tx of txs) {
+                const sent = await session.send(tx);
+                if (first === undefined)
+                    first = sent.receipt.blockNumber;
+            }
+            clone = predicted;
+            deployBlock = first ?? 0n;
+        }
+        finally {
+            session.close();
+        }
+    }
+    else {
+        const { account } = makeWalletClient({ chainKey: CHAIN });
+        const { clone: predicted, txs } = await preparedFor(account.address);
+        const results = await signHotSequence(txs, { chainKey: CHAIN, yes: !!flags.yes });
+        clone = predicted;
+        deployBlock = results[0]?.blockNumber ?? 0n;
+    }
+    const discovered = await discoverDeployBlock(publicClient, clone);
+    if (discovered !== null)
+        deployBlock = discovered;
+    ok(`EditionCode live: ${clone} ${dim(`(from block ${deployBlock})`)}`);
+    emit(jsonSafe({ command: 'deploy-code', kind: 'edition-code', copies: editionSize.toString(), address: clone, chain: CHAIN, chainId, factory, deployBlock, name, symbol, onChainUri }));
+    step('Index');
+    await registerAndIndexLocally(clone, { 'from-block': deployBlock.toString(), factory, label: name });
+    if (onChainUri) {
+        step('On-chain URI');
+        ok(`uri()/contractURI() resolve ON-CHAIN via the renderer ${metadataRenderer} — any RPC returns the metadata, no server in the graph`);
+        info(`animation_url computes on-chain via the generator ${generator} — it enumerates this token's params from chain, so there is no key list to maintain`);
+        console.log(`  ${bold(`abx tokenuri ${clone} --token 0`)}  ${dim('# reads uri(0) + decodes the JSON straight from the contract')}`);
+    }
+    const isRemoteBase = !/^https?:\/\/(localhost|127\.0\.0\.1)\b/i.test(baseUrl);
+    console.log(`\n${g('Edition code project deployed.')} ${dim(onChainUri ? 'tokenURI is on-chain; a resolver remains the kinder serving path (live view + thumbnail publishing):' : 'It resolves through your resolver — keep it running:')}`);
+    if (isRemoteBase)
+        console.log(`  ${bold(`abx add ${clone} --remote`)}  ${dim('# register with the hosted resolver')}`);
+    else
+        console.log(`  ${bold('abx serve')}  ${dim('# stand up the resolver locally')}`);
+    console.log(`  ${bold(`abx mint ${clone} --token-id <id> --amount <n>`)}  ${dim('# mint more copies of an id')}`);
+    console.log(`  ${bold(`abx minter configure ${clone} --token-id <id> --price <eth> --allocation <n>`)}  ${dim('# set up a priced sale for one id')}`);
+    console.log(`  ${bold(`abx refresh ${clone}`)}  ${dim('# nudge marketplaces once metadata is live')}\n`);
+}
 /**
  * Resolve `--721c` into the InitParams `transferValidator`. Absent → `zeroAddress`: a plain
- * ERC-721, byte-for-byte the pre-721C deploy — no prompts, no output, no mention of 721C.
- * `--721c` / `--721c recommended` → the per-chain recommended validator (refused, naming the
- * chains that have one, when the manifest has no entry); `--721c 0x…` → checksum-validated AND
- * pre-checked for code on this chain (the factory would revert `InvalidTransferValidator()` —
- * surface it before any upload/staging/gas). When enrolling, prints the one plain statement of
- * what enforcement means — once, adapted to the chosen validator.
+ * ERC-721 (or, on an edition deploy, a plain ERC-1155), byte-for-byte the pre-721C deploy — no
+ * prompts, no output, no mention of 721C. `--721c` / `--721c recommended` → the per-chain
+ * recommended validator (refused, naming the chains that have one, when the manifest has no
+ * entry); `--721c 0x…` → checksum-validated AND pre-checked for code on this chain (the factory
+ * would revert `InvalidTransferValidator()` — surface it before any upload/staging/gas). When
+ * enrolling, prints the one plain statement of what enforcement means — once, adapted to the
+ * chosen validator.
+ *
+ * `standard` picks only the WORDING (`ERC-721C` vs `ERC-1155C`) — the flag, the value grammar, and
+ * the resolved validator address are identical either way (the SAME `InitParams.transferValidator`
+ * opt-in per the parity plan's locked decision 3: 1155C ships with the same UX as 721C). Editions
+ * pass `'1155C'`; every 721 call site keeps the default, so their output is unchanged.
  */
-export async function resolveTransferValidatorFlag(flags, publicClient, dryRun) {
+export async function resolveTransferValidatorFlag(flags, publicClient, dryRun, standard = '721C') {
     const raw = flags['721c'];
     if (raw === undefined)
         return zeroAddress;
@@ -2967,8 +3997,8 @@ export async function resolveTransferValidatorFlag(flags, publicClient, dryRun)
     }
     // The one plain statement — printed once, only when enrolling. Never appears un-enrolled.
     info(validator === resolveRecommendedTransferValidator(chainId)
-        ? `ERC-721C enforcement: only owner-initiated transfers and OpenSea-authorized sales will transfer; other marketplaces/operators are blocked. Manage with \`abx set-transfer-validator\`.`
-        : `ERC-721C enforcement: every non-mint transfer is checked by validator ${validator} — its policy decides which operators may transfer. Manage with \`abx set-transfer-validator\`.`);
+        ? `ERC-${standard}: only owner-initiated transfers and OpenSea-authorized sales will transfer; other marketplaces/operators are blocked. Manage with \`abx set-transfer-validator\`.`
+        : `ERC-${standard}: every non-mint transfer is checked by validator ${validator} — its policy decides which operators may transfer. Manage with \`abx set-transfer-validator\`.`);
     return validator;
 }
 //# sourceMappingURL=deploy.js.map