moonwall 1.0.0-dev.0

package/dist/cli/internal/cmdFunctions/tempLogs.js

@@ -0,0 +1,37 @@
+import path from "node:path";
+import fs from "node:fs";
+export function clearNodeLogs(silent = true) {
+    const dirPath = path.join(process.cwd(), "tmp", "node_logs");
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+    const files = fs.readdirSync(dirPath);
+    for (const file of files) {
+        !silent && console.log(`Deleting log: ${file}`);
+        if (file.endsWith(".log")) {
+            fs.unlinkSync(path.join(dirPath, file));
+        }
+    }
+}
+export function reportLogLocation(silent = false) {
+    const dirPath = path.join(process.cwd(), "tmp", "node_logs");
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+    const result = fs.readdirSync(dirPath);
+    let consoleMessage = "";
+    let filePath = "";
+    try {
+        filePath = process.env.MOON_ZOMBIE_DIR
+            ? process.env.MOON_ZOMBIE_DIR
+            : process.env.MOON_LOG_LOCATION
+                ? process.env.MOON_LOG_LOCATION
+                : path.join(dirPath, result.find((file) => path.extname(file) === ".log") || "no_logs_found");
+        consoleMessage = `  🪵   Log location: ${filePath}`;
+    }
+    catch (e) {
+        console.error(e);
+    }
+    !silent && console.log(consoleMessage);
+    return filePath.trim();
+}

package/dist/cli/internal/commandParsers.d.ts

@@ -0,0 +1,59 @@
+import type { ChopsticksLaunchSpec, DevLaunchSpec, RepoSpec, ZombieLaunchSpec, LaunchOverrides } from "../../api/types/index.js";
+export declare function parseZombieCmd(launchSpec: ZombieLaunchSpec): {
+    cmd: string;
+};
+export declare class LaunchCommandParser {
+    private args;
+    private cmd;
+    private launch;
+    private launchSpec;
+    private launchOverrides?;
+    constructor(options: {
+        launchSpec: DevLaunchSpec;
+        additionalRepos?: RepoSpec[];
+        launchOverrides?: LaunchOverrides;
+    });
+    private overrideArg;
+    withPorts(): Promise<this>;
+    withDefaultForkConfig(): LaunchCommandParser;
+    withLaunchOverrides(): LaunchCommandParser;
+    private print;
+    private applyForkOptions;
+    /**
+     * Cache startup artifacts if enabled in launchSpec.
+     * This uses an Effect-based service that caches artifacts by binary hash.
+     *
+     * When cacheStartupArtifacts is enabled, this generates:
+     * 1. Precompiled WASM for the runtime
+     * 2. Raw chain spec to skip genesis WASM compilation
+     *
+     * This reduces startup from ~3s to ~200ms (~10x improvement).
+     */
+    withStartupCache(): Promise<LaunchCommandParser>;
+    build(): {
+        cmd: string;
+        args: string[];
+        launch: boolean;
+    };
+    static create(options: {
+        launchSpec: DevLaunchSpec;
+        additionalRepos?: RepoSpec[];
+        launchOverrides?: LaunchOverrides;
+        verbose?: boolean;
+    }): Promise<{
+        cmd: string;
+        args: string[];
+        launch: boolean;
+    }>;
+}
+export declare function parseChopsticksRunCmd(launchSpecs: ChopsticksLaunchSpec[]): {
+    cmd: string;
+    args: string[];
+    launch: boolean;
+};
+/**
+ * Get a free port with availability checking
+ * Uses async port allocation for better collision avoidance
+ */
+export declare const getFreePort: () => Promise<number>;
+//# sourceMappingURL=commandParsers.d.ts.map

package/dist/cli/internal/commandParsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandParsers.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/commandParsers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,eAAe,EAEhB,iCAAiC;AAYlC,wBAAgB,cAAc,CAAC,UAAU,EAAE,gBAAgB;;EAO1D;AAqBD,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,IAAI,CAAW;IACvB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,eAAe,CAAC,CAAkB;gBAE9B,OAAO,EAAE;QACnB,UAAU,EAAE,aAAa,CAAC;QAC1B,eAAe,CAAC,EAAE,QAAQ,EAAE,CAAC;QAC7B,eAAe,CAAC,EAAE,eAAe,CAAC;KACnC;IAWD,OAAO,CAAC,WAAW;IAWb,SAAS;IA8Bf,qBAAqB,IAAI,mBAAmB;IAQ5C,mBAAmB,IAAI,mBAAmB;IAO1C,OAAO,CAAC,KAAK;IAMb,OAAO,CAAC,gBAAgB;IAgBxB;;;;;;;;;OASG;IACG,gBAAgB,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAmFtD,KAAK,IAAI;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE;WAQ5C,MAAM,CAAC,OAAO,EAAE;QAC3B,UAAU,EAAE,aAAa,CAAC;QAC1B,eAAe,CAAC,EAAE,QAAQ,EAAE,CAAC;QAC7B,eAAe,CAAC,EAAE,eAAe,CAAC;QAClC,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB;aAbe,MAAM;cAAQ,MAAM,EAAE;gBAAU,OAAO;;CA0BxD;AAED,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,oBAAoB,EAAE,GAAG;IAC1E,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;CACjB,CAoDA;AA8BD;;;GAGG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,MAAM,CA2BlD,CAAC"}

package/dist/cli/internal/commandParsers.js

@@ -0,0 +1,305 @@
+import { createLogger } from "../../util/index.js";
+import path from "node:path";
+import net from "node:net";
+import { Effect } from "effect";
+import { standardRepos } from "../lib/repoDefinitions/index.js";
+import { shardManager } from "../lib/shardManager.js";
+import invariant from "tiny-invariant";
+import { StartupCacheService, StartupCacheServiceLive } from "./effect/index.js";
+const logger = createLogger({ name: "commandParsers" });
+export function parseZombieCmd(launchSpec) {
+    if (launchSpec) {
+        return { cmd: launchSpec.configPath };
+    }
+    throw new Error("No ZombieSpec found in config. Are you sure your moonwall.config.json file has the correct 'configPath' in zombieSpec?");
+}
+function fetchDefaultArgs(binName, additionalRepos = []) {
+    let defaultArgs;
+    const repos = [...standardRepos(), ...additionalRepos];
+    for (const repo of repos) {
+        const foundBin = repo.binaries.find((bin) => bin.name === binName);
+        if (foundBin) {
+            defaultArgs = foundBin.defaultArgs;
+            break;
+        }
+    }
+    if (!defaultArgs) {
+        defaultArgs = ["--dev"];
+    }
+    return defaultArgs;
+}
+export class LaunchCommandParser {
+    args;
+    cmd;
+    launch;
+    launchSpec;
+    launchOverrides;
+    constructor(options) {
+        const { launchSpec, additionalRepos, launchOverrides } = options;
+        this.launchSpec = launchSpec;
+        this.launchOverrides = launchOverrides;
+        this.launch = !launchSpec.running ? true : launchSpec.running;
+        this.cmd = launchSpec.binPath;
+        this.args = launchSpec.options
+            ? [...launchSpec.options]
+            : fetchDefaultArgs(path.basename(launchSpec.binPath), additionalRepos);
+    }
+    overrideArg(newArg) {
+        const newArgKey = newArg.split("=")[0];
+        const existingIndex = this.args.findIndex((arg) => arg.startsWith(`${newArgKey}=`));
+        if (existingIndex !== -1) {
+            this.args[existingIndex] = newArg;
+        }
+        else {
+            this.args.push(newArg);
+        }
+    }
+    async withPorts() {
+        // In RECYCLE mode, the node is already running
+        if (process.env.MOON_RECYCLE === "true") {
+            const existingPort = process.env.MOONWALL_RPC_PORT;
+            if (existingPort) {
+                this.overrideArg(`--rpc-port=${existingPort}`);
+            }
+            return this;
+        }
+        if (this.launchSpec.ports) {
+            const ports = this.launchSpec.ports;
+            if (ports.p2pPort) {
+                this.overrideArg(`--port=${ports.p2pPort}`);
+            }
+            if (ports.wsPort) {
+                this.overrideArg(`--ws-port=${ports.wsPort}`);
+            }
+            if (ports.rpcPort) {
+                this.overrideArg(`--rpc-port=${ports.rpcPort}`);
+            }
+        }
+        else {
+            const freePort = (await getFreePort()).toString();
+            // Always pin the rpc port so the provider endpoint matches exactly the spawned node.
+            process.env.MOONWALL_RPC_PORT = freePort;
+            this.overrideArg(`--rpc-port=${freePort}`);
+        }
+        return this;
+    }
+    withDefaultForkConfig() {
+        const forkOptions = this.launchSpec.defaultForkConfig;
+        if (forkOptions) {
+            this.applyForkOptions(forkOptions);
+        }
+        return this;
+    }
+    withLaunchOverrides() {
+        if (this.launchOverrides?.forkConfig) {
+            this.applyForkOptions(this.launchOverrides.forkConfig);
+        }
+        return this;
+    }
+    print() {
+        logger.debug(`Command to run: ${this.cmd}`);
+        logger.debug(`Arguments: ${this.args.join(" ")}`);
+        return this;
+    }
+    applyForkOptions(forkOptions) {
+        if (forkOptions.url) {
+            invariant(forkOptions.url.startsWith("http"), "Fork URL must start with http:// or https://");
+            this.overrideArg(`--fork-chain-from-rpc=${forkOptions.url}`);
+        }
+        if (forkOptions.blockHash) {
+            this.overrideArg(`--block=${forkOptions.blockHash}`);
+        }
+        if (forkOptions.stateOverridePath) {
+            this.overrideArg(`--fork-state-overrides=${forkOptions.stateOverridePath}`);
+        }
+        if (forkOptions.verbose) {
+            this.overrideArg("-llazy-loading=trace");
+        }
+    }
+    /**
+     * Cache startup artifacts if enabled in launchSpec.
+     * This uses an Effect-based service that caches artifacts by binary hash.
+     *
+     * When cacheStartupArtifacts is enabled, this generates:
+     * 1. Precompiled WASM for the runtime
+     * 2. Raw chain spec to skip genesis WASM compilation
+     *
+     * This reduces startup from ~3s to ~200ms (~10x improvement).
+     */
+    async withStartupCache() {
+        if (!this.launchSpec.cacheStartupArtifacts) {
+            return this;
+        }
+        // Skip for Docker images
+        if (this.launchSpec.useDocker) {
+            logger.warn("Startup caching is not supported for Docker images, skipping");
+            return this;
+        }
+        // Extract chain argument from existing args (e.g., "--chain=moonbase-dev")
+        const chainArg = this.args.find((arg) => arg.startsWith("--chain"));
+        // Check if using --dev flag
+        const hasDevFlag = this.args.includes("--dev");
+        // Extract chain name from --chain=XXX or --chain XXX
+        const existingChainName = chainArg?.match(/--chain[=\s]?(\S+)/)?.[1];
+        // We can generate raw chain spec for both --dev mode and explicit --chain=XXX
+        const canGenerateRawSpec = hasDevFlag || !!existingChainName;
+        const cacheDir = this.launchSpec.startupCacheDir || path.join(process.cwd(), "tmp", "startup-cache");
+        const program = StartupCacheService.pipe(Effect.flatMap((service) => service.getCachedArtifacts({
+            binPath: this.launchSpec.binPath,
+            chainArg,
+            cacheDir,
+            // Generate raw chain spec for faster startup (works for both --dev and --chain=XXX)
+            generateRawChainSpec: canGenerateRawSpec,
+            // Pass dev mode flag for proper chain name detection
+            isDevMode: hasDevFlag,
+        })), Effect.provide(StartupCacheServiceLive));
+        try {
+            const result = await Effect.runPromise(program);
+            // --wasmtime-precompiled expects a DIRECTORY, not a file path
+            // Get the directory containing the precompiled wasm
+            const precompiledDir = path.dirname(result.precompiledPath);
+            this.overrideArg(`--wasmtime-precompiled=${precompiledDir}`);
+            // If we have a raw chain spec, use it for ~10x faster startup
+            if (result.rawChainSpecPath) {
+                if (hasDevFlag) {
+                    // Remove --dev flag and add equivalent flags
+                    this.args = this.args.filter((arg) => arg !== "--dev");
+                    this.overrideArg(`--chain=${result.rawChainSpecPath}`);
+                    // Add flags that --dev would normally set
+                    this.overrideArg("--alice");
+                    this.overrideArg("--force-authoring");
+                    this.overrideArg("--rpc-cors=all");
+                    // Use a deterministic node key for consistency
+                    this.overrideArg("--node-key=0000000000000000000000000000000000000000000000000000000000000001");
+                }
+                else if (existingChainName) {
+                    // Replace original --chain=XXX with --chain=<raw-spec-path>
+                    this.overrideArg(`--chain=${result.rawChainSpecPath}`);
+                }
+                logger.debug(`Using raw chain spec for ~10x faster startup: ${result.rawChainSpecPath}`);
+            }
+            // Set cache directory env var for metadata caching in provider factories
+            process.env.MOONWALL_CACHE_DIR = precompiledDir;
+            logger.debug(result.fromCache
+                ? `Using cached precompiled WASM: ${result.precompiledPath}`
+                : `Precompiled WASM created: ${result.precompiledPath}`);
+        }
+        catch (error) {
+            // Log warning but continue without precompilation
+            logger.warn(`WASM precompilation failed, continuing without: ${error}`);
+        }
+        return this;
+    }
+    build() {
+        return {
+            cmd: this.cmd,
+            args: this.args,
+            launch: this.launch,
+        };
+    }
+    static async create(options) {
+        const parser = new LaunchCommandParser(options);
+        const parsed = await parser
+            .withPorts()
+            .then((p) => p.withDefaultForkConfig().withLaunchOverrides())
+            .then((p) => p.withStartupCache());
+        if (options.verbose) {
+            parsed.print();
+        }
+        return parsed.build();
+    }
+}
+export function parseChopsticksRunCmd(launchSpecs) {
+    const launch = !launchSpecs[0].running ? true : launchSpecs[0].running;
+    if (launchSpecs.length === 1) {
+        const chopsticksCmd = "node";
+        const chopsticksArgs = [
+            "node_modules/@acala-network/chopsticks/chopsticks.cjs",
+            `--config=${launchSpecs[0].configPath}`,
+            `--host=${launchSpecs[0].address ?? "127.0.0.1"}`,
+        ];
+        const mode = launchSpecs[0].buildBlockMode ? launchSpecs[0].buildBlockMode : "manual";
+        const num = mode === "batch" ? "Batch" : mode === "instant" ? "Instant" : "Manual";
+        chopsticksArgs.push(`--build-block-mode=${num}`);
+        if (launchSpecs[0].wsPort) {
+            chopsticksArgs.push(`--port=${launchSpecs[0].wsPort}`);
+        }
+        if (launchSpecs[0].wasmOverride) {
+            chopsticksArgs.push(`--wasm-override=${launchSpecs[0].wasmOverride}`);
+        }
+        if (launchSpecs[0].allowUnresolvedImports) {
+            chopsticksArgs.push("--allow-unresolved-imports");
+        }
+        return {
+            cmd: chopsticksCmd,
+            args: chopsticksArgs,
+            launch,
+        };
+    }
+    const chopsticksCmd = "node";
+    const chopsticksArgs = ["node_modules/@acala-network/chopsticks/chopsticks.cjs", "xcm"];
+    for (const spec of launchSpecs) {
+        const type = spec.type ? spec.type : "parachain";
+        switch (type) {
+            case "parachain":
+                chopsticksArgs.push(`--parachain=${spec.configPath}`);
+                break;
+            case "relaychain":
+                chopsticksArgs.push(`--relaychain=${spec.configPath}`);
+        }
+    }
+    return {
+        cmd: chopsticksCmd,
+        args: chopsticksArgs,
+        launch,
+    };
+}
+/**
+ * Check if a port is available for use
+ */
+const isPortAvailable = async (port) => {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.listen(port, () => {
+            server.once("close", () => resolve(true));
+            server.close();
+        });
+        server.on("error", () => resolve(false));
+    });
+};
+/**
+ * Get the next available port starting from a given port
+ */
+const getNextAvailablePort = async (startPort) => {
+    let port = startPort;
+    while (port <= 65535) {
+        if (await isPortAvailable(port)) {
+            return port;
+        }
+        port++;
+    }
+    throw new Error(`No available ports found starting from ${startPort}`);
+};
+/**
+ * Get a free port with availability checking
+ * Uses async port allocation for better collision avoidance
+ */
+export const getFreePort = async () => {
+    // Get shard information from centralized manager
+    const shardIndex = shardManager.getShardIndex();
+    const totalShards = shardManager.getTotalShards();
+    // Use VITEST_POOL_ID as additional offset if available
+    const poolId = parseInt(process.env.VITEST_POOL_ID || "0", 10);
+    // Calculate port with better isolation between shards
+    // Base port 10000 + (shard * 1000) + (pool * 100) + deterministic offset
+    const basePort = 10000;
+    const shardOffset = shardIndex * 1000;
+    const poolOffset = poolId * 100;
+    // Use a deterministic but unique offset based on environment
+    const processOffset = process.pid % 50;
+    const calculatedPort = basePort + shardOffset + poolOffset + processOffset;
+    // Ensure we stay within a reasonable port range
+    const startPort = Math.min(calculatedPort, 60000 + shardIndex * 100 + poolId);
+    logger.debug(`Port calculation: shard=${shardIndex + 1}/${totalShards}, pool=${poolId}, final=${startPort}`);
+    return getNextAvailablePort(startPort);
+};

package/dist/cli/internal/deriveTestIds.d.ts

@@ -0,0 +1,8 @@
+interface DeriveTestIdsOptions {
+    rootDir: string;
+    singlePrefix?: boolean;
+    prefixPhrase?: string;
+}
+export declare function deriveTestIds(params: DeriveTestIdsOptions): Promise<void>;
+export {};
+//# sourceMappingURL=deriveTestIds.d.ts.map

package/dist/cli/internal/deriveTestIds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveTestIds.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/deriveTestIds.ts"],"names":[],"mappings":"AAMA,UAAU,oBAAoB;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAsB,aAAa,CAAC,MAAM,EAAE,oBAAoB,iBAiD/D"}

package/dist/cli/internal/deriveTestIds.js

@@ -0,0 +1,123 @@
+import chalk from "chalk";
+import fs from "node:fs";
+import { confirm } from "@inquirer/prompts";
+import path from "node:path";
+import { hasSuiteDefinition, replaceSuiteId } from "./testIdParser.js";
+export async function deriveTestIds(params) {
+    const usedPrefixes = new Set();
+    const { rootDir, singlePrefix } = params;
+    try {
+        await fs.promises.access(rootDir, fs.constants.R_OK);
+    }
+    catch (_error) {
+        console.error(`🔴 Error accessing directory ${chalk.bold(`/${rootDir}`)}, please make sure this exists`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`🟢 Processing ${rootDir} ...`);
+    const topLevelDirs = getTopLevelDirs(rootDir);
+    const foldersToRename = [];
+    if (singlePrefix) {
+        const prefix = generatePrefix(rootDir, usedPrefixes, params.prefixPhrase);
+        foldersToRename.push({ prefix, dir: "." });
+    }
+    else {
+        for (const dir of topLevelDirs) {
+            const prefix = generatePrefix(dir, usedPrefixes, params.prefixPhrase);
+            foldersToRename.push({ prefix, dir });
+        }
+    }
+    const result = await confirm({
+        message: `This will rename ${foldersToRename.length} suites IDs in ${rootDir}, continue?`,
+    });
+    if (!result) {
+        console.log("🔴 Aborted");
+        return;
+    }
+    for (const folder of foldersToRename) {
+        const { prefix, dir } = folder;
+        process.stdout.write(`🟢 Changing suite ${dir} to use prefix ${chalk.bold(`(${prefix})`)} ....`);
+        generateId(path.join(rootDir, dir), rootDir, prefix);
+        process.stdout.write(" Done ✅\n");
+    }
+    console.log(`🏁 Finished renaming rootdir ${chalk.bold(`/${rootDir}`)}`);
+}
+function getTopLevelDirs(rootDir) {
+    return fs
+        .readdirSync(rootDir)
+        .filter((dir) => fs.statSync(path.join(rootDir, dir)).isDirectory());
+}
+function generatePrefix(directory, usedPrefixes, rootPrefix) {
+    const sanitizedDir = directory.replace(/[-_ ]/g, "").toUpperCase();
+    let prefix = rootPrefix ?? sanitizedDir[0];
+    let additionalIndex = 1;
+    while (usedPrefixes.has(prefix) && additionalIndex < sanitizedDir.length) {
+        prefix += rootPrefix?.[additionalIndex] ?? sanitizedDir[additionalIndex];
+        additionalIndex++;
+    }
+    let numericSuffix = 0;
+    while (usedPrefixes.has(prefix)) {
+        if (numericSuffix < 10) {
+            numericSuffix++;
+            prefix = sanitizedDir[0] + numericSuffix.toString();
+        }
+        else {
+            let lastChar = prefix.slice(-1).charCodeAt(0);
+            if (lastChar >= 90) {
+                // 'Z'
+                lastChar = 65; // 'A'
+            }
+            else {
+                lastChar++;
+            }
+            prefix = sanitizedDir[0] + String.fromCharCode(lastChar);
+        }
+    }
+    usedPrefixes.add(prefix);
+    return prefix;
+}
+function generateId(directory, rootDir, prefix) {
+    const contents = fs.readdirSync(directory);
+    contents.sort((a, b) => {
+        const aIsDir = fs.statSync(path.join(directory, a)).isDirectory();
+        const bIsDir = fs.statSync(path.join(directory, b)).isDirectory();
+        if (aIsDir && !bIsDir)
+            return -1;
+        if (!aIsDir && bIsDir)
+            return 1;
+        return customFileSort(a, b);
+    });
+    let fileCount = 1;
+    let subDirCount = 1;
+    for (const item of contents) {
+        const fullPath = path.join(directory, item);
+        if (fs.statSync(fullPath).isDirectory()) {
+            const subDirPrefix = `0${subDirCount}`.slice(-2);
+            generateId(fullPath, rootDir, prefix + subDirPrefix);
+            subDirCount++;
+        }
+        else {
+            const fileContent = fs.readFileSync(fullPath, "utf-8");
+            if (hasSuiteDefinition(fileContent)) {
+                const newId = prefix + `0${fileCount}`.slice(-2);
+                const updatedContent = replaceSuiteId(fileContent, newId);
+                if (updatedContent) {
+                    fs.writeFileSync(fullPath, updatedContent);
+                }
+            }
+            fileCount++;
+        }
+    }
+}
+function hasSpecialCharacters(filename) {
+    return /[ \t!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]+/.test(filename);
+}
+function customFileSort(a, b) {
+    const aHasSpecialChars = hasSpecialCharacters(a);
+    const bHasSpecialChars = hasSpecialCharacters(b);
+    if (aHasSpecialChars && !bHasSpecialChars)
+        return -1;
+    if (!aHasSpecialChars && bHasSpecialChars)
+        return 1;
+    return a.localeCompare(b, undefined, { sensitivity: "accent" });
+}

package/dist/cli/internal/effect/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Effect-TS services for Moonwall node management
+ * Re-exported from services/ for backward compatibility
+ */
+export * from "../../../services/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/internal/effect/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/internal/effect/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,2CAA2C"}

package/dist/cli/internal/effect/index.js

@@ -0,0 +1,5 @@
+/**
+ * Effect-TS services for Moonwall node management
+ * Re-exported from services/ for backward compatibility
+ */
+export * from "../../../services/index.js";

package/dist/cli/internal/fileCheckers.d.ts

@@ -0,0 +1,11 @@
+export declare function checkExists(path: string): Promise<boolean>;
+export declare function downloadBinsIfMissing(binPath: string): Promise<void>;
+export declare function checkListeningPorts(processId: number): {
+    binName: string;
+    processId: number;
+    ports: string[];
+};
+export declare function checkAlreadyRunning(binaryName: string): number[];
+export declare function promptAlreadyRunning(pids: number[]): Promise<void>;
+export declare function checkAccess(path: string): void;
+//# sourceMappingURL=fileCheckers.d.ts.map

package/dist/cli/internal/fileCheckers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileCheckers.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/fileCheckers.ts"],"names":[],"mappings":"AAOA,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,oBA0B7C;AAED,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,MAAM,iBAuC1D;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM;;;;EA0BpD;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAgBhE;AAED,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,iBAgCxD;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,QAQvC"}