@recoillink/cli 0.0.0-stage → 45.0.1

package/bundle/748.index.js

@@ -0,0 +1,672 @@
+export const id = 748;
+export const ids = [748];
+export const modules = {
+
+/***/ 60367:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  createSvmForkManager: () => (/* reexport */ createSvmForkManager),
+  parseSvmForkConfig: () => (/* reexport */ parseSvmForkConfig)
+});
+
+// UNUSED EXPORTS: PrintableSvmTransactionSchema, SURFPOOL_MIN_VERSION, SolanaCluster, SurfpoolDatasourceMode, SvmForkManager, SvmRawForkConfigSchema, runSurfpoolNode
+
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(35317);
+// EXTERNAL MODULE: external "node:fs"
+var external_node_fs_ = __webpack_require__(73024);
+// EXTERNAL MODULE: external "node:net"
+var external_node_net_ = __webpack_require__(77030);
+// EXTERNAL MODULE: external "node:os"
+var external_node_os_ = __webpack_require__(48161);
+// EXTERNAL MODULE: external "node:path"
+var external_node_path_ = __webpack_require__(76760);
+// EXTERNAL MODULE: ../forking-sdk/dist/index.js + 3 modules
+var dist = __webpack_require__(65310);
+// EXTERNAL MODULE: ../utils/dist/logging.js
+var logging = __webpack_require__(94523);
+// EXTERNAL MODULE: ../utils/dist/typeof.js
+var dist_typeof = __webpack_require__(73689);
+// EXTERNAL MODULE: ../utils/dist/validation.js
+var validation = __webpack_require__(21387);
+// EXTERNAL MODULE: ../svm-sdk/dist/rpc.js + 9 modules
+var dist_rpc = __webpack_require__(48080);
+;// CONCATENATED MODULE: ../svm-sdk/dist/fork/surfpool-node.js
+// eslint-disable-next-line import/no-nodejs-modules
+
+// eslint-disable-next-line import/no-nodejs-modules
+
+// eslint-disable-next-line import/no-nodejs-modules
+
+// eslint-disable-next-line import/no-nodejs-modules
+
+// eslint-disable-next-line import/no-nodejs-modules
+
+
+
+
+const logger = logging/* rootLogger */.Jk.child({ module: 'surfpool-node' });
+// Minimum acceptable local `surfpool` version; aligned with the docker image
+// `surfpool/surfpool:1.5.0` used by the container runner in test infra.
+const SURFPOOL_MIN_VERSION = '1.5.0';
+// Install guidance surfaced whenever a compatible `surfpool` binary is missing.
+// Points at the pinned, checksum-verified release rather than the mutable
+// `run.surfpool.run` installer, so an operator (or agent) never pipes remote
+// code to a shell.
+const SURFPOOL_INSTALL_GUIDANCE = `Install a pinned surfpool ${SURFPOOL_MIN_VERSION}+ release from ` +
+    'https://github.com/txtx/surfpool/releases and verify its SHA-256 checksum; ' +
+    'do not pipe the mutable run.surfpool.run installer to a shell.';
+// Env var surfpool reads for its fork datasource. Passing the (possibly
+// credential-bearing) upstream URL this way keeps it out of the process argv.
+const SURFPOOL_DATASOURCE_RPC_URL_ENV = 'SURFPOOL_DATASOURCE_RPC_URL';
+// Per-probe RPC timeout so a single hung request fails fast and the bounded
+// readiness loop can continue.
+const RPC_PROBE_TIMEOUT_MS = 5000;
+// Cap on the retained tail of surfpool stderr, surfaced in exit errors.
+const STDERR_TAIL_MAX = 8192;
+const REDACTED_DATASOURCE_URL = '<redacted-datasource-url>';
+// URL userinfo credentials (scheme://user:pass@host). A defense-in-depth
+// backstop that scrubs a reformatted/percent-encoded credential the exact
+// datasource-URL match would miss.
+const URL_USERINFO_CREDENTIALS_RE = /\/\/[^/@\s]+:[^/@\s]+@/g;
+/**
+ * Scrubs secrets from surfpool stderr before it is embedded in a surfaced error.
+ * surfpool prints stderr verbatim (not shell-escaped), so the known
+ * credential-bearing datasource URL is removed by exact-string replacement;
+ * stripping URL userinfo credentials is a backstop for any other credential URL.
+ */
+function redactSurfpoolStderr(detail, datasourceUrl) {
+    const withoutDatasource = (0,dist_typeof/* isNullish */.u)(datasourceUrl)
+        ? detail
+        : detail.split(datasourceUrl).join(REDACTED_DATASOURCE_URL);
+    return withoutDatasource.replace(URL_USERINFO_CREDENTIALS_RE, '//<redacted>@');
+}
+const SurfpoolDatasourceMode = {
+    Fork: 'fork',
+    Network: 'network',
+    Offline: 'offline',
+};
+const SolanaCluster = {
+    Mainnet: 'mainnet',
+    Devnet: 'devnet',
+    Testnet: 'testnet',
+};
+const SURFPOOL_BINARY_PATHS = [
+    (0,external_node_path_.join)((0,external_node_os_.homedir)(), '.cargo/bin'),
+    '/opt/homebrew/bin',
+    '/usr/local/bin',
+];
+function parseVersion(version) {
+    const match = version.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return null;
+    const [, major, minor, patch] = match;
+    (0,validation/* assert */.v)(major && minor && patch, `Invalid surfpool version: ${version}`);
+    return {
+        major: parseInt(major, 10),
+        minor: parseInt(minor, 10),
+        patch: parseInt(patch, 10),
+    };
+}
+function meetsMinVersion(version, min) {
+    if (version.major !== min.major)
+        return version.major > min.major;
+    if (version.minor !== min.minor)
+        return version.minor > min.minor;
+    return version.patch >= min.patch;
+}
+function getSurfpoolVersion(binaryPath) {
+    try {
+        const output = (0,external_child_process_.execFileSync)(binaryPath, ['--version'], {
+            encoding: 'utf-8',
+        });
+        const match = output.match(/surfpool\s+(\d+\.\d+\.\d+)/);
+        return match?.[1] ?? null;
+    }
+    catch (error) {
+        logger.debug({ err: error }, `failed to get surfpool version at ${binaryPath}`);
+        return null;
+    }
+}
+function findSurfpoolCandidates() {
+    const candidates = [];
+    for (const basePath of SURFPOOL_BINARY_PATHS) {
+        const binaryPath = (0,external_node_path_.join)(basePath, 'surfpool');
+        if ((0,external_node_fs_.existsSync)(binaryPath)) {
+            const version = getSurfpoolVersion(binaryPath);
+            if (version) {
+                candidates.push({ path: binaryPath, version });
+            }
+        }
+    }
+    try {
+        const result = (0,external_child_process_.execSync)('which surfpool', { encoding: 'utf-8' }).trim();
+        if (result && (0,external_node_fs_.existsSync)(result)) {
+            const version = getSurfpoolVersion(result);
+            if (version && !candidates.some((c) => c.path === result)) {
+                candidates.push({ path: result, version });
+            }
+        }
+    }
+    catch (error) {
+        logger.debug({ err: error }, 'surfpool not found in PATH');
+    }
+    return candidates;
+}
+function buildSurfpoolArgs(config, datasource, bindHost) {
+    const args = [
+        'start',
+        '--no-tui',
+        '--no-studio',
+        '--no-deploy',
+        '--host',
+        bindHost,
+        '--port',
+        String(config.rpcPort),
+    ];
+    if (!(0,dist_typeof/* isNullish */.u)(config.wsPort)) {
+        args.push('--ws-port', String(config.wsPort));
+    }
+    if (datasource.mode === SurfpoolDatasourceMode.Network) {
+        args.push('--network', datasource.network);
+    }
+    else if (datasource.mode === SurfpoolDatasourceMode.Offline) {
+        args.push('--offline');
+    }
+    // Fork mode: the datasource URL is passed via the SURFPOOL_DATASOURCE_RPC_URL
+    // env (see buildSurfpoolDatasourceEnv) rather than argv.
+    if (config.skipSignatureVerification) {
+        args.push('--skip-signature-verification');
+    }
+    if (config.skipBlockhashCheck) {
+        args.push('--skip-blockhash-check');
+    }
+    if (config.airdrops && config.airdrops.addresses.length > 0) {
+        for (const address of config.airdrops.addresses) {
+            args.push('--airdrop', address);
+        }
+        args.push('--airdrop-amount', config.airdrops.lamports.toString());
+    }
+    return args;
+}
+/**
+ * Spawn env carrying surfpool's fork datasource URL. Empty for network/offline
+ * datasources, which take no credentials and are expressed via argv flags.
+ */
+function buildSurfpoolDatasourceEnv(datasource) {
+    if (datasource.mode !== SurfpoolDatasourceMode.Fork) {
+        return {};
+    }
+    return { [SURFPOOL_DATASOURCE_RPC_URL_ENV]: datasource.rpcUrl };
+}
+/**
+ * Per-attempt abort signal that fires after `timeoutMs`, or immediately when
+ * `parent` aborts (so a caller cancelling the readiness loop also cancels the
+ * in-flight probe request). Composed manually to stay usable on Node <17, which
+ * lacks `AbortSignal.timeout`/`AbortSignal.any`. `dispose` clears the timer and
+ * detaches the parent listener so nothing lingers between attempts.
+ */
+function probeTimeoutSignal(timeoutMs, parent) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const onParentAbort = () => controller.abort();
+    if (parent) {
+        if (parent.aborted) {
+            controller.abort();
+        }
+        else {
+            parent.addEventListener('abort', onParentAbort, { once: true });
+        }
+    }
+    const dispose = () => {
+        clearTimeout(timer);
+        parent?.removeEventListener('abort', onParentAbort);
+    };
+    return { signal: controller.signal, dispose };
+}
+async function waitForSolanaRpcReady(rpcUrl, signal) {
+    const rpc = (0,dist_rpc/* createRpc */.C8)(rpcUrl);
+    await (0,dist/* waitUntilReady */.bs)(async () => {
+        const { signal: probeSignal, dispose } = probeTimeoutSignal(RPC_PROBE_TIMEOUT_MS, signal);
+        try {
+            const health = await rpc.getHealth().send({ abortSignal: probeSignal });
+            (0,validation/* assert */.v)(health === 'ok', `surfpool RPC not healthy: ${health}`);
+        }
+        finally {
+            dispose();
+        }
+    }, { attempts: 60, baseRetryMs: 1000, signal });
+}
+/**
+ * Rejects if `port` on 127.0.0.1 is already bound. A bind-test up front closes
+ * the port-collision race: proving RPC health after spawn can otherwise pass
+ * against an unrelated node already listening on the port, before our freshly
+ * spawned child fails with EADDRINUSE.
+ */
+async function assertPortAvailable(port) {
+    await new Promise((resolve, reject) => {
+        const server = (0,external_node_net_.createServer)();
+        server.once('error', (error) => {
+            const code = 'code' in error ? error.code : undefined;
+            reject(code === 'EADDRINUSE'
+                ? new Error(`port ${port} is already in use`)
+                : error);
+        });
+        server.once('listening', () => {
+            server.close(() => resolve());
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+// A single process-level `exit` hook kills every still-running fork, rather than
+// one listener per fork — which would trip MaxListenersExceededWarning past ten
+// forks and retain each child's closure until process exit. A fork joins the
+// registry on start and leaves when it is killed or its child exits.
+const runningForkKills = new Set();
+let forkExitHookInstalled = false;
+function trackForkExit(killFork) {
+    runningForkKills.add(killFork);
+    if (!forkExitHookInstalled) {
+        forkExitHookInstalled = true;
+        process.once('exit', () => {
+            for (const kill of Array.from(runningForkKills)) {
+                kill();
+            }
+        });
+    }
+    return () => {
+        runningForkKills.delete(killFork);
+    };
+}
+async function startLocalSurfpool(config, binaryPath, waitForRpcReady = waitForSolanaRpcReady) {
+    // Fail fast if any bind port is taken, before spawning, so we never treat
+    // another process's RPC as our fork and never spawn a doomed child that would
+    // fail to bind an occupied ws port.
+    await assertPortAvailable(config.rpcPort);
+    if (!(0,dist_typeof/* isNullish */.u)(config.wsPort)) {
+        await assertPortAvailable(config.wsPort);
+    }
+    const args = buildSurfpoolArgs(config, config.datasource, '127.0.0.1');
+    // Suppress surfpool's own logs (its default ./.surfpool/logs dir would clutter
+    // the working dir); startup/bind failures still surface on stderr, drained below.
+    args.push('--log-level', 'none');
+    const proc = (0,external_child_process_.spawn)(binaryPath, args, {
+        stdio: ['ignore', 'ignore', 'pipe'],
+        detached: false,
+        env: { ...process.env, ...buildSurfpoolDatasourceEnv(config.datasource) },
+    });
+    // Drain stderr into a bounded tail; reading it also keeps the pipe from
+    // filling and blocking the child.
+    let stderrTail = '';
+    proc.stderr?.on('data', (chunk) => {
+        stderrTail = (stderrTail + chunk.toString()).slice(-STDERR_TAIL_MAX);
+    });
+    const rpcUrl = `http://127.0.0.1:${config.rpcPort}`;
+    const datasourceUrl = config.datasource.mode === SurfpoolDatasourceMode.Fork
+        ? config.datasource.rpcUrl
+        : undefined;
+    const kill = () => {
+        // Leave the process-exit registry whenever the child is gone (killed here,
+        // or exited/errored below) so a dead fork never keeps being tracked.
+        untrackFork();
+        if (config.keepRunning) {
+            return;
+        }
+        if ((0,dist_typeof/* isNullish */.u)(proc.exitCode)) {
+            proc.kill('SIGTERM');
+        }
+    };
+    const untrackFork = trackForkExit(kill);
+    // A failed spawn (e.g. ENOENT) emits `error` with no guaranteed `exit`, so the
+    // readiness race must reject on it — otherwise readiness burns the full probe
+    // timeout and reports a misleading RPC error instead of the real spawn failure.
+    // Attach synchronously here so no `error` can fire before a listener exists.
+    const errored = new Promise((_, reject) => {
+        proc.once('error', (error) => {
+            untrackFork();
+            logger.debug({ err: error }, 'surfpool process error');
+            reject(error);
+        });
+    });
+    // A spawn error arriving after readiness (or exit) has already settled the race
+    // must not surface as an unhandled rejection.
+    errored.catch(() => { });
+    // Capture the child's exit synchronously after spawn rather than lazily inside
+    // `waitForReady`: `exit` is not replayed, so a caller that waits after the
+    // child has already exited must still observe it instead of polling to the
+    // readiness bound. Rejecting here also drops the fork from the exit registry.
+    const exited = new Promise((_, reject) => {
+        proc.once('exit', (code, signal) => {
+            untrackFork();
+            const detail = redactSurfpoolStderr(stderrTail.trim(), datasourceUrl);
+            reject(new Error(`surfpool exited before its RPC was ready (code=${code}, signal=${signal})` +
+                (detail ? `: ${detail}` : '')));
+        });
+    });
+    // A later exit (e.g. on kill once readiness has won) must not surface as an
+    // unhandled rejection after the race settles.
+    exited.catch(() => { });
+    const waitForReady = async () => {
+        // Abort the readiness probe the instant the race settles so no retry timer
+        // keeps polling a dead port after an early exit or spawn error wins.
+        const controller = new AbortController();
+        try {
+            await Promise.race([
+                waitForRpcReady(rpcUrl, controller.signal),
+                exited,
+                errored,
+            ]);
+        }
+        finally {
+            controller.abort();
+        }
+    };
+    return { node: { rpcUrl, kill }, waitForReady };
+}
+// A caller-supplied binary is an explicit choice, so failures name the specific
+// cause (missing / not executable / too old) instead of the generic auto-
+// discovery "no compatible binary" message, which would otherwise report the
+// substituted "unknown" version and hide the real problem.
+function resolveExplicitBinary(binaryPath, min) {
+    (0,validation/* assert */.v)((0,external_node_fs_.existsSync)(binaryPath), `surfpool binary not found at ${binaryPath}`);
+    const version = getSurfpoolVersion(binaryPath);
+    (0,validation/* assert */.v)(version, `surfpool binary at ${binaryPath} could not be run (check it is executable and 'surfpool --version' works).`);
+    const parsed = parseVersion(version);
+    (0,validation/* assert */.v)(parsed && meetsMinVersion(parsed, min), `surfpool at ${binaryPath} is version ${version} but ${SURFPOOL_MIN_VERSION}+ is required. ` +
+        SURFPOOL_INSTALL_GUIDANCE);
+    return { path: binaryPath, version };
+}
+function resolveDiscoveredBinary(min) {
+    const candidates = findSurfpoolCandidates();
+    const match = candidates.find((candidate) => {
+        const parsed = parseVersion(candidate.version);
+        return parsed !== null && meetsMinVersion(parsed, min);
+    });
+    (0,validation/* assert */.v)(match, candidates.length === 0
+        ? `surfpool ${SURFPOOL_MIN_VERSION}+ is required but no surfpool binary was found on PATH. ` +
+            SURFPOOL_INSTALL_GUIDANCE
+        : `surfpool ${SURFPOOL_MIN_VERSION}+ is required but only found version(s) ` +
+            `${candidates.map((c) => c.version).join(', ')}. ` +
+            SURFPOOL_INSTALL_GUIDANCE);
+    return match;
+}
+/**
+ * Starts a surfpool node from a locally-installed `surfpool` binary (version
+ * {@link SURFPOOL_MIN_VERSION} or newer) and waits for its RPC to be ready.
+ * An explicit `config.binaryPath` is validated up front with a specific error;
+ * otherwise the PATH is searched and an install-guidance error is thrown if no
+ * compatible binary is found.
+ */
+async function runSurfpoolNode(config) {
+    const min = parseVersion(SURFPOOL_MIN_VERSION);
+    (0,validation/* assert */.v)(min, `Invalid SURFPOOL_MIN_VERSION: ${SURFPOOL_MIN_VERSION}`);
+    const match = config.binaryPath
+        ? resolveExplicitBinary(config.binaryPath, min)
+        : resolveDiscoveredBinary(min);
+    logger.debug(`Using local surfpool binary: ${match.path} (v${match.version})`);
+    const { node, waitForReady } = await startLocalSurfpool(config, match.path);
+    try {
+        await waitForReady();
+    }
+    catch (error) {
+        node.kill();
+        throw error;
+    }
+    return node;
+}
+//# sourceMappingURL=surfpool-node.js.map
+// EXTERNAL MODULE: ../../node_modules/.pnpm/@solana+codecs-strings@8.2.0_@typescript+typescript6@6.0.2_fastestsmallesttextencoderdecoder@1.0.22/node_modules/@solana/codecs-strings/dist/index.node.mjs
+var index_node = __webpack_require__(48990);
+// EXTERNAL MODULE: ../../node_modules/.pnpm/@solana+transactions@8.2.0_@typescript+typescript6@6.0.2_fastestsmallesttextencoderdecoder@1.0.22/node_modules/@solana/transactions/dist/index.node.mjs
+var dist_index_node = __webpack_require__(11508);
+// EXTERNAL MODULE: ../../node_modules/.pnpm/@solana+transaction-messages@8.2.0_@typescript+typescript6@6.0.2_fastestsmallesttextencoderdecoder@1.0.22/node_modules/@solana/transaction-messages/dist/index.node.mjs
+var transaction_messages_dist_index_node = __webpack_require__(13464);
+// EXTERNAL MODULE: ../utils/dist/async.js
+var dist_async = __webpack_require__(14918);
+// EXTERNAL MODULE: ../svm-sdk/dist/accounts/address-lookup-table.js
+var address_lookup_table = __webpack_require__(96971);
+// EXTERNAL MODULE: ../svm-sdk/dist/constants.js
+var constants = __webpack_require__(94327);
+// EXTERNAL MODULE: ../svm-sdk/dist/tx.js
+var tx = __webpack_require__(55960);
+// EXTERNAL MODULE: ../svm-sdk/dist/fork/impersonation.js
+var impersonation = __webpack_require__(44391);
+;// CONCATENATED MODULE: ../svm-sdk/dist/fork/svm-fork-manager.js
+
+
+
+
+
+
+
+
+const svm_fork_manager_logger = logging/* rootLogger */.Jk.child({ module: 'svm-fork-manager' });
+const RPC_COMMITMENT = 'confirmed';
+const POLL_INTERVAL_MS = 500;
+const POLL_MAX_ATTEMPTS = 60;
+const RESOLVE_ALT_CONCURRENCY = 4;
+const base58Encoder = (0,index_node/* getBase58Encoder */.nZ)();
+const transactionDecoder = (0,dist_index_node/* getTransactionDecoder */.BX)();
+const compiledMessageDecoder = (0,transaction_messages_dist_index_node/* getCompiledTransactionMessageDecoder */.fr)();
+/**
+ * Fetches the addresses stored in each address-lookup table referenced by a
+ * compiled message, producing the map kit needs to decompile the message and
+ * re-compress it against the same tables. Returns `undefined` for a message
+ * that uses no lookup tables (so callers can skip compression entirely).
+ */
+async function resolveForkLookupTables(rpc, compiledMessage) {
+    const lookups = 'addressTableLookups' in compiledMessage
+        ? compiledMessage.addressTableLookups
+        : undefined;
+    if ((0,dist_typeof/* isNullish */.u)(lookups) || lookups.length === 0) {
+        return undefined;
+    }
+    const entries = await (0,dist_async/* concurrentMap */.q1)(RESOLVE_ALT_CONCURRENCY, lookups, async (lookup) => {
+        const state = await (0,address_lookup_table/* fetchAddressLookupTableState */.a)(rpc, lookup.lookupTableAddress);
+        return [lookup.lookupTableAddress, state.addresses];
+    });
+    return Object.fromEntries(entries);
+}
+/**
+ * Rebuilds the wire transaction to replay against a fork.
+ *
+ * `transaction_base58` is serialized without the compute-budget instruction
+ * (an external executor — Squads / file submitter — prepends it from
+ * `computeUnits`, defaulting to {@link DEFAULT_COMPUTE_UNITS}). Replaying it
+ * verbatim leaves the tx under the runtime per-instruction default, so a tx that
+ * consumes more than that (e.g. a program upgrade) fails on the fork even though
+ * real execution succeeds. To match live/Squads execution exactly, every replay
+ * tx is decoded and re-emitted with the same `SetComputeUnitLimit` an external
+ * executor would prepend — using `computeUnits` when set, `DEFAULT_COMPUTE_UNITS`
+ * otherwise (mirroring `buildTransactionMessage`/`transactionToInstructions`).
+ *
+ * Any address-lookup-table compression in the source tx is preserved: the
+ * message is re-compressed against the same tables before compiling, so an
+ * ALT-heavy tx (e.g. cross-collateral reconciliation) stays under the 1232-byte
+ * packet limit instead of being re-emitted with the accounts inlined. The zero
+ * DEFAULT_BLOCKHASH is preserved and accepted because the fork runs with
+ * `skipBlockhashCheck` and the send uses `skipPreflight`.
+ */
+async function buildForkReplayTransaction(rpc, transaction) {
+    const wireBytes = base58Encoder.encode(transaction.transaction_base58);
+    const decoded = transactionDecoder.decode(wireBytes);
+    const units = transaction.computeUnits ?? constants/* DEFAULT_COMPUTE_UNITS */.I1;
+    const compiledMessage = compiledMessageDecoder.decode(decoded.messageBytes);
+    (0,validation/* assert */.v)(compiledMessage.version !== 1, 'v1 fork replay requires header-based compute budget support');
+    const addressLookupTables = await resolveForkLookupTables(rpc, compiledMessage);
+    const message = (0,transaction_messages_dist_index_node/* decompileTransactionMessage */.mm)(compiledMessage, {
+        addressesByLookupTableAddress: addressLookupTables,
+    });
+    const withComputeBudget = (0,transaction_messages_dist_index_node/* prependTransactionMessageInstructions */.rR)((0,tx/* getComputeBudgetInstructions */.oR)(units), message);
+    if ((0,dist_typeof/* isNullish */.u)(addressLookupTables)) {
+        return (0,dist_index_node/* getBase64EncodedWireTransaction */.RO)((0,dist_index_node/* compileTransaction */.i5)(withComputeBudget));
+    }
+    // Only versioned (v0) messages reference lookup tables, so a defined ALT map
+    // implies a non-legacy message; narrow so kit's compressor accepts it.
+    (0,validation/* assert */.v)(withComputeBudget.version === 0, 'address-lookup tables require a v0 transaction');
+    const recompressed = (0,transaction_messages_dist_index_node/* compressTransactionMessageUsingAddressLookupTables */.Zg)(withComputeBudget, addressLookupTables);
+    return (0,dist_index_node/* getBase64EncodedWireTransaction */.RO)((0,dist_index_node/* compileTransaction */.i5)(recompressed));
+}
+/**
+ * Ensures the fork airdrops SOL to the fixed fork-only impersonation fee payer
+ * at boot, so keyless impersonated applies can pay fees. surfpool airdrops a
+ * single amount to every address, so the fee payer is merged into the caller's
+ * address list and the amount is raised to at least the impersonation buffer.
+ */
+function withImpersonationAirdrop(airdrops) {
+    const feePayer = impersonation/* FORK_IMPERSONATION_FEE_PAYER */.P.address;
+    if (!airdrops) {
+        return {
+            addresses: [feePayer],
+            lamports: impersonation/* FORK_IMPERSONATION_AIRDROP_LAMPORTS */.X,
+        };
+    }
+    const addresses = airdrops.addresses.includes(feePayer)
+        ? airdrops.addresses
+        : [...airdrops.addresses, feePayer];
+    const lamports = airdrops.lamports > impersonation/* FORK_IMPERSONATION_AIRDROP_LAMPORTS */.X
+        ? airdrops.lamports
+        : impersonation/* FORK_IMPERSONATION_AIRDROP_LAMPORTS */.X;
+    return { addresses, lamports };
+}
+class RunningSvmFork {
+    node;
+    rpc;
+    rpcUrl;
+    constructor(node, rpc, rpcUrl) {
+        this.node = node;
+        this.rpc = rpc;
+        this.rpcUrl = rpcUrl;
+    }
+}
+async function startSvmFork(config) {
+    const runNode = config.runNode ?? runSurfpoolNode;
+    const node = await runNode({
+        datasource: {
+            mode: SurfpoolDatasourceMode.Fork,
+            rpcUrl: config.upstreamRpcUrl,
+        },
+        rpcPort: config.rpcPort,
+        wsPort: config.wsPort,
+        airdrops: withImpersonationAirdrop(config.airdrops),
+        skipSignatureVerification: true,
+        skipBlockhashCheck: true,
+        image: config.image,
+        binaryPath: config.binaryPath,
+        keepRunning: config.keepRunning,
+    });
+    return new RunningSvmFork(node, (0,dist_rpc/* createRpc */.C8)(node.rpcUrl), node.rpcUrl);
+}
+class SvmForkManager {
+    config;
+    running;
+    constructor(config) {
+        this.config = config;
+    }
+    get requireRunning() {
+        const running = this.running;
+        (0,validation/* assert */.v)(running, `Fork not started for chain ${this.config.chainName}`);
+        return running;
+    }
+    async start() {
+        this.running = await startSvmFork(this.config);
+    }
+    async applyForkConfig(config) {
+        const { rpc } = this.requireRunning;
+        for (const transaction of config.transactions) {
+            await this.submitTransaction(rpc, transaction);
+        }
+    }
+    getForkedChainMetadata() {
+        return {
+            rpcUrls: [{ http: this.requireRunning.rpcUrl }],
+            blocks: { confirmations: 1 },
+        };
+    }
+    kill() {
+        this.running?.node.kill();
+    }
+    async submitTransaction(rpc, transaction) {
+        const wireTransaction = await buildForkReplayTransaction(rpc, transaction);
+        svm_fork_manager_logger.debug({ annotation: transaction.annotation }, 'replaying transaction against fork');
+        const signature = await rpc
+            .sendTransaction(wireTransaction, {
+            encoding: 'base64',
+            skipPreflight: true,
+            maxRetries: 0n,
+            preflightCommitment: RPC_COMMITMENT,
+        })
+            .send();
+        const status = await (0,dist_async/* pollAsync */.kp)(async () => {
+            const { value } = await rpc.getSignatureStatuses([signature]).send();
+            const result = value[0];
+            (0,validation/* assert */.v)(result, `transaction ${signature} not processed yet`);
+            // A failed tx is terminal: resolve immediately so the assert below
+            // surfaces the failure instead of polling until the attempts run out.
+            if (!(0,dist_typeof/* isNullish */.u)(result.err)) {
+                return result;
+            }
+            // kit 6.x can report `processed` before `confirmed`; wait for the
+            // configured commitment so a dependent next tx doesn't race an
+            // unconfirmed one.
+            const confirmation = result.confirmationStatus;
+            (0,validation/* assert */.v)(confirmation === RPC_COMMITMENT || confirmation === 'finalized', `transaction ${signature} not yet ${RPC_COMMITMENT} (status: ${confirmation})`);
+            return result;
+        }, POLL_INTERVAL_MS, POLL_MAX_ATTEMPTS);
+        (0,validation/* assert */.v)((0,dist_typeof/* isNullish */.u)(status.err), `fork replay transaction ${signature} failed: ${JSON.stringify(status.err, (_key, value) => (typeof value === 'bigint' ? value.toString() : value))}`);
+        if (transaction.waitForSlotAdvance) {
+            const confirmedSlot = status.slot;
+            await (0,dist_async/* pollAsync */.kp)(async () => {
+                const slot = await rpc.getSlot({ commitment: RPC_COMMITMENT }).send();
+                (0,validation/* assert */.v)(slot > confirmedSlot, `slot ${slot} has not advanced past ${confirmedSlot}`);
+            }, POLL_INTERVAL_MS, POLL_MAX_ATTEMPTS);
+        }
+    }
+}
+function createSvmForkManager(config) {
+    return new SvmForkManager(config);
+}
+//# sourceMappingURL=svm-fork-manager.js.map
+// EXTERNAL MODULE: ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/classic/schemas.js + 7 modules
+var schemas = __webpack_require__(58228);
+;// CONCATENATED MODULE: ../svm-sdk/dist/fork/svm-fork-config.js
+
+const PrintableSvmTransactionSchema = schemas/* object */.Ik({
+    annotation: schemas/* string */.Yj().optional(),
+    instructions: schemas/* array */.YO(schemas/* unknown */.L5()).optional(),
+    computeUnits: schemas/* number */.ai().optional(),
+    transaction_base58: schemas/* string */.Yj(),
+    message_base58: schemas/* string */.Yj().optional(),
+    waitForSlotAdvance: schemas/* boolean */.zM().optional(),
+});
+const SvmRawForkConfigSchema = schemas/* union */.KC([
+    schemas/* object */.Ik({ transactions: schemas/* array */.YO(PrintableSvmTransactionSchema) }),
+    schemas/* object */.Ik({ path: schemas/* string */.Yj() }),
+]);
+/**
+ * Parses a per-chain SVM fork-config slice. A `path` reference loads the
+ * `warp apply --submitter file` output (a `PrintableSvmTransaction[]`) via the
+ * injected file reader; inline `transactions` are used directly.
+ */
+function parseSvmForkConfig(raw, fileReader) {
+    const parsed = SvmRawForkConfigSchema.parse(raw);
+    if ('path' in parsed) {
+        const transactions = schemas/* array */.YO(PrintableSvmTransactionSchema)
+            .parse(fileReader(parsed.path));
+        return { transactions };
+    }
+    return { transactions: parsed.transactions };
+}
+//# sourceMappingURL=svm-fork-config.js.map
+;// CONCATENATED MODULE: ../svm-sdk/dist/fork/index.js
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ })
+
+};