@layerzerolabs/build-utils-rust 0.2.113

package/src/resolve/index.ts

@@ -0,0 +1,122 @@
+/**
+ * Vendor @layerzerolabs Cargo dependencies from node_modules into a flat
+ * dependencies/ directory with rewritten path deps, so a Rust package builds
+ * without the rest of the monorepo.
+ */
+
+import { copyFile, mkdir, rm } from 'fs/promises';
+import { join, relative, resolve } from 'path';
+
+import { logger } from '../logger';
+import { discoverPackages, isCrate, type VendorTarget } from './discover';
+import type { CollectedTree } from './io';
+import { collectFiles } from './io';
+import type { RewriteContext } from './rewrite';
+import { rewriteCargoTomls } from './rewrite';
+
+// ─── Path Map ───
+
+/** Maps each crate's npm package source path to its vendored dependencies/ location. */
+export const buildDependenciesPathMap = (targets: VendorTarget[]): Map<string, string> => {
+    const pathMap = new Map<string, string>();
+
+    for (const { npmPkgDir, depsPkgDir, tree } of targets) {
+        for (const dir of tree.manifestDirs) {
+            pathMap.set(join(npmPkgDir, dir), join(depsPkgDir, dir));
+            logger.trace(`map ${join(npmPkgDir, dir)} -> ${join(depsPkgDir, dir)}`);
+        }
+    }
+    logger.debug(`built dependency path map: ${pathMap.size} entries`);
+    return pathMap;
+};
+
+// ─── File Operations ───
+
+/** Copy a collected tree into destRoot. */
+const copyCollected = async (
+    srcRoot: string,
+    destRoot: string,
+    tree: CollectedTree,
+): Promise<void> => {
+    await mkdir(destRoot, { recursive: true });
+    await Promise.all(tree.dirs.map((dir) => mkdir(join(destRoot, dir), { recursive: true })));
+    await Promise.all(
+        tree.files.map((file) => copyFile(join(srcRoot, file), join(destRoot, file))),
+    );
+};
+
+/** Resolves the Cargo root: `cargoDir` if provided, else `packageRoot`. Throws if no Cargo.toml. */
+const resolveCargoRoot = async (packageRoot: string, cargoDir?: string): Promise<string> => {
+    if (cargoDir) {
+        const resolved = resolve(packageRoot, cargoDir);
+        if (!(await isCrate(resolved))) {
+            throw new Error(`--cargo-dir ${cargoDir} does not contain a Cargo.toml`);
+        }
+        return resolved;
+    }
+
+    if (!(await isCrate(packageRoot))) {
+        throw new Error(`${packageRoot} does not contain a Cargo.toml`);
+    }
+
+    return packageRoot;
+};
+
+// ─── Public API ───
+
+/**
+ * Entry point: vendor every @layerzerolabs Cargo crate reachable through node_modules
+ * into dependencies/, with path deps rewritten to resolve locally.
+ *
+ * @param cwd       pnpm package root (where node_modules/ lives). Default: process.cwd()
+ * @param cargoDir  Cargo crate directory to vendor into. Default: packageRoot
+ */
+export const resolveDependencies = async ({
+    cwd,
+    cargoDir,
+}: { cwd?: string; cargoDir?: string } = {}): Promise<void> => {
+    const packageRoot = resolve(cwd ?? process.cwd());
+
+    const depsRoot = join(await resolveCargoRoot(packageRoot, cargoDir), 'dependencies');
+
+    const discovered = new Map<string, string>();
+    await discoverPackages(packageRoot, discovered, new Set());
+
+    if (discovered.size === 0) {
+        logger.info('No @layerzerolabs namespaced Cargo dependencies found in node_modules');
+        return;
+    }
+
+    // Rebuild dependencies/ from scratch each run.
+    await rm(depsRoot, { recursive: true, force: true });
+    await mkdir(depsRoot, { recursive: true });
+
+    // Collect each package's tree once — copy, path map, and rewrite all reuse it.
+    const targets: VendorTarget[] = await Promise.all(
+        Array.from(discovered, async ([pkgName, npmPkgDir]) => {
+            const tree = await collectFiles(npmPkgDir);
+            logger.debug(
+                `${pkgName}: collected ${tree.files.length} files, ${tree.dirs.length} dirs`,
+            );
+            return { pkgName, npmPkgDir, depsPkgDir: join(depsRoot, pkgName), tree };
+        }),
+    );
+
+    const ctx: RewriteContext = {
+        pathMap: buildDependenciesPathMap(targets),
+        discovered,
+    };
+    logger.debug(`path map: ${ctx.pathMap.size} entries`);
+
+    await Promise.all(
+        targets.map(async ({ pkgName, npmPkgDir, depsPkgDir, tree }) => {
+            await copyCollected(npmPkgDir, depsPkgDir, tree);
+            await rewriteCargoTomls(npmPkgDir, depsPkgDir, tree, ctx);
+            logger.debug(`  ${pkgName} -> ${npmPkgDir}`);
+        }),
+    );
+
+    logger.info(
+        `Resolved ${discovered.size} Cargo dependencies into ${relative(packageRoot, depsRoot) || './dependencies/'}`,
+    );
+};

package/src/resolve/io.ts

@@ -0,0 +1,69 @@
+import { readdir, realpath, stat } from 'fs/promises';
+import { basename, dirname, extname, join } from 'path';
+
+import { logger } from '../logger';
+import { COPY_EXTENSIONS, removeExcludedFiles } from './exclude';
+
+export const tryRealpath = async (path: string): Promise<string | undefined> => {
+    try {
+        return await realpath(path);
+    } catch {
+        return undefined;
+    }
+};
+
+export const tryIsDirectory = async (path: string): Promise<boolean> => {
+    try {
+        return (await stat(path)).isDirectory();
+    } catch {
+        return false;
+    }
+};
+
+export const tryReaddir = async (dir: string): Promise<string[]> => {
+    try {
+        return await readdir(dir);
+    } catch {
+        return [];
+    }
+};
+
+export interface CollectedTree {
+    /** directories containing copyable content, relative to root (no empties) */
+    dirs: string[];
+    /** copyable files (COPY_EXTENSIONS), relative to root (excluded subtrees pruned) */
+    files: string[];
+    /** dirs that directly contain a Cargo.toml (crate roots), relative to root; '.' is the root */
+    manifestDirs: string[];
+}
+
+/**
+ * Walk `root` once, applying exclusion per level and keeping only COPY_EXTENSIONS files.
+ * Also records `manifestDirs` (dirs holding a Cargo.toml) so consumers don't re-scan.
+ */
+export const collectFiles = async (root: string, relativePath = ''): Promise<CollectedTree> => {
+    const dirs: string[] = [];
+    const files: string[] = [];
+    const manifestDirs: string[] = [];
+
+    const rawFileNames = await tryReaddir(join(root, relativePath));
+    const fileNames = removeExcludedFiles(rawFileNames).map((e) => join(relativePath, e));
+
+    for (const file of fileNames) {
+        if (await tryIsDirectory(join(root, file))) {
+            const subDir = await collectFiles(root, file);
+            if (subDir.files.length > 0) {
+                dirs.push(file, ...subDir.dirs);
+                files.push(...subDir.files);
+                manifestDirs.push(...subDir.manifestDirs);
+            } else {
+                logger.trace(`skip empty dir ${file}`);
+            }
+        } else if (COPY_EXTENSIONS.has(extname(file))) {
+            files.push(file);
+            if (basename(file) === 'Cargo.toml') manifestDirs.push(dirname(file));
+            logger.trace(`collect ${file}`);
+        }
+    }
+    return { dirs, files, manifestDirs };
+};

package/src/resolve/rewrite.ts

@@ -0,0 +1,210 @@
+/**
+ * Rewrite a vendored Cargo.toml's path deps into the flat dependencies/ layout,
+ * operating on the parsed TOML (via smol-toml) rather than text.
+ */
+
+import { readFile, writeFile } from 'fs/promises';
+import { dirname, join, relative } from 'path';
+import { parse, stringify } from 'smol-toml';
+
+import { logger } from '../logger';
+import { isWorkspaceRoot } from './discover';
+import { hasExcludedSegment } from './exclude';
+import { type CollectedTree, tryRealpath } from './io';
+
+/** Bundled resolution state passed through the rewrite pipeline. */
+export interface RewriteContext {
+    pathMap: Map<string, string>;
+    discovered: Map<string, string>;
+}
+
+type Table = Record<string, unknown>;
+
+/** A dependency spec that carries a `path` — an inline table like `{ path = "…" }`. */
+type PathDepSpec = Table & { path: string };
+
+const isTable = (value: unknown): value is Table =>
+    typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const DEP_TABLE_KEYS = ['dependencies', 'dev-dependencies', 'build-dependencies'] as const;
+
+/**
+ * Dependency specs that declare a `path`, across every dependency table (plus
+ * `[workspace.dependencies]` when `includeWorkspaceDeps`). Specs are live references
+ * into `manifest`, so mutating `.path` updates it.
+ */
+const pathDepSpecs = (manifest: Table, includeWorkspaceDeps: boolean): PathDepSpec[] => {
+    // The root manifest and each [target.'cfg(...)'] table both hold DEP_TABLE_KEYS tables.
+    const containers = [
+        manifest,
+        ...(isTable(manifest.target) ? Object.values(manifest.target).filter(isTable) : []),
+    ];
+
+    const depTables = [
+        ...containers.flatMap((container) => DEP_TABLE_KEYS.map((key) => container[key])),
+        ...(includeWorkspaceDeps && isTable(manifest.workspace)
+            ? [manifest.workspace.dependencies]
+            : []),
+    ];
+
+    return depTables
+        .filter(isTable)
+        .flatMap((table) => Object.values(table))
+        .filter((spec): spec is PathDepSpec => isTable(spec) && typeof spec.path === 'string');
+};
+
+/**
+ * Drop literal `members` / `default-members` entries whose path contains an excluded
+ * directory segment (e.g. `tests/mock_vault`) — those dirs are never vendored, so the
+ * member would dangle and fail Cargo's workspace load. Globs (`tests/*`) are kept; Cargo
+ * re-expands them to a harmless empty match. Returns true if any member was removed.
+ */
+export const pruneExcludedLiteralMembers = (manifest: Table): boolean => {
+    const workspace = manifest.workspace;
+    if (!isTable(workspace)) return false;
+
+    let changed = false;
+    for (const key of ['members', 'default-members'] as const) {
+        const members = workspace[key];
+        if (!Array.isArray(members)) continue;
+
+        // Keep everything except literal (non-glob) members inside an excluded dir.
+        const kept = members.filter(
+            (m) => typeof m !== 'string' || m.includes('*') || !hasExcludedSegment(m),
+        );
+
+        if (kept.length !== members.length) {
+            workspace[key] = kept;
+            changed = true;
+        }
+    }
+    return changed;
+};
+
+/** Rebase every path dep in `manifest` into the flat dependencies/ layout. Returns true if any changed. */
+export const rewritePathDeps = async (
+    manifest: Table,
+    originalDir: string,
+    manifestDir: string,
+    ctx: RewriteContext,
+    includeWorkspaceDeps: boolean,
+): Promise<boolean> => {
+    let changed = false;
+    for (const spec of pathDepSpecs(manifest, includeWorkspaceDeps)) {
+        const target =
+            (await resolveViaRealpath(originalDir, spec.path, ctx.pathMap)) ??
+            resolveViaNameFallback(spec.path, ctx);
+        if (!target) continue;
+
+        const rewritten = relative(manifestDir, target);
+        if (rewritten === spec.path) continue;
+
+        logger.trace(`rewrite path dep ${spec.path} -> ${rewritten}`);
+        spec.path = rewritten;
+        changed = true;
+    }
+
+    return changed;
+};
+
+/**
+ * Delete the `[workspace]` / `[patch.*]` / `[profile.*]` tables — invalid or ignored in a
+ * vendored dependency (only honored at the real workspace root). Returns true if any was removed.
+ */
+export const stripRootOnlyTables = (manifest: Table): boolean => {
+    let changed = false;
+    for (const table of ['workspace', 'patch', 'profile'] as const) {
+        if (manifest[table] != null) {
+            delete manifest[table];
+            changed = true;
+        }
+    }
+    return changed;
+};
+
+/**
+ * Rewrite one vendored Cargo.toml in place: rebase its path deps, then strip the root-only
+ * tables — or, for a preserved workspace root (`stripRootTables = false`), prune excluded
+ * members instead. Re-serialized only if something changed.
+ *
+ * @param originalDir    source crate dir the manifest was copied from
+ * @param cargoTomlPath  the vendored Cargo.toml to rewrite
+ */
+export const rewriteCargoToml = async (
+    originalDir: string,
+    cargoTomlPath: string,
+    ctx: RewriteContext,
+    stripRootTables = true,
+): Promise<void> => {
+    const manifest = parse(await readFile(cargoTomlPath, 'utf-8'));
+
+    const pathsChanged = await rewritePathDeps(
+        manifest,
+        originalDir,
+        dirname(cargoTomlPath),
+        ctx,
+        !stripRootTables,
+    );
+
+    const tablesChanged = stripRootTables
+        ? stripRootOnlyTables(manifest)
+        : pruneExcludedLiteralMembers(manifest);
+
+    if (pathsChanged || tablesChanged) {
+        await writeFile(cargoTomlPath, stringify(manifest));
+        logger.debug(`rewrote ${cargoTomlPath}`);
+    }
+};
+
+/** Primary resolution: realpath the path through pnpm symlinks, then look it up in pathMap. */
+const resolveViaRealpath = async (
+    originalDir: string,
+    pathValue: string,
+    pathMap: Map<string, string>,
+): Promise<string | undefined> => {
+    const resolvedPath = await tryRealpath(join(originalDir, pathValue));
+    return resolvedPath ? pathMap.get(resolvedPath) : undefined;
+};
+
+/** Fallback: match the path's leaf dir name against a discovered package (for already-`dependencies/…` paths). */
+const resolveViaNameFallback = (pathValue: string, ctx: RewriteContext): string | undefined => {
+    const segments = pathValue.split('/').filter(Boolean);
+    const leafDir = segments.at(-1);
+    if (!leafDir) return undefined;
+
+    for (const [pkgName, realPath] of ctx.discovered) {
+        // Direct match: "dependencies/utils-solana-rbac" → match "utils-solana-rbac"
+        if (pkgName === leafDir) {
+            return ctx.pathMap.get(realPath);
+        }
+        // Subdir match: "dependencies/utils-solana-rbac/macros" → match parent
+        const parentDir = segments.at(-2);
+        if (parentDir && pkgName === parentDir) {
+            const subTarget = ctx.pathMap.get(join(realPath, leafDir));
+            if (subTarget) return subTarget;
+        }
+    }
+    return undefined;
+};
+
+/**
+ * Rewrite every Cargo.toml in a copied dependency tree. The root manifest keeps its
+ * root-only tables when it's a workspace (members inherit from them); all others strip them.
+ */
+export const rewriteCargoTomls = async (
+    srcRoot: string,
+    destRoot: string,
+    tree: CollectedTree,
+    ctx: RewriteContext,
+): Promise<void> => {
+    for (const manifestDir of tree.manifestDirs) {
+        const preserve = manifestDir === '.' && (await isWorkspaceRoot(destRoot));
+
+        await rewriteCargoToml(
+            join(srcRoot, manifestDir),
+            join(destRoot, manifestDir, 'Cargo.toml'),
+            ctx,
+            !preserve,
+        );
+    }
+};

package/tests/resolve/discover.test.ts

@@ -0,0 +1,206 @@
+import { mkdirSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { buildDependenciesPathMap } from '../../src/resolve';
+import {
+    discoverPackages,
+    isCrate,
+    isWorkspaceRoot,
+    type VendorTarget,
+} from '../../src/resolve/discover';
+import { collectFiles } from '../../src/resolve/io';
+
+const TMP = join(__dirname, '__tmp_discover__');
+
+const createFile = (path: string, content = '') => {
+    mkdirSync(join(path, '..'), { recursive: true });
+    writeFileSync(path, content);
+};
+
+const createCrate = (path: string, cargoContent = '[package]\nname = "test"') => {
+    mkdirSync(path, { recursive: true });
+    writeFileSync(join(path, 'Cargo.toml'), cargoContent);
+};
+
+beforeEach(() => mkdirSync(TMP, { recursive: true }));
+afterEach(() => rmSync(TMP, { recursive: true, force: true }));
+
+describe('isCrate', () => {
+    it('returns true for directory with Cargo.toml', async () => {
+        createCrate(join(TMP, 'my-crate'));
+        expect(await isCrate(join(TMP, 'my-crate'))).toBe(true);
+    });
+
+    it('returns false for directory without Cargo.toml', async () => {
+        mkdirSync(join(TMP, 'not-a-crate'), { recursive: true });
+        expect(await isCrate(join(TMP, 'not-a-crate'))).toBe(false);
+    });
+
+    it('returns false for nonexistent path', async () => {
+        expect(await isCrate(join(TMP, 'nope'))).toBe(false);
+    });
+
+    it('returns false for a file', async () => {
+        createFile(join(TMP, 'a-file'), 'hello');
+        expect(await isCrate(join(TMP, 'a-file'))).toBe(false);
+    });
+});
+
+describe('discoverPackages', () => {
+    it('discovers @layerzerolabs packages with Cargo.toml from node_modules', async () => {
+        // Simulate: TMP/node_modules/@layerzerolabs/my-crate/Cargo.toml
+        const cratePath = join(TMP, 'node_modules', '@layerzerolabs', 'my-crate');
+        createCrate(cratePath);
+
+        const discovered = new Map<string, string>();
+        await discoverPackages(TMP, discovered, new Set());
+
+        expect(discovered.size).toBe(1);
+        expect(discovered.has('my-crate')).toBe(true);
+    });
+
+    it('skips packages without Cargo.toml', async () => {
+        const pkgPath = join(TMP, 'node_modules', '@layerzerolabs', 'ts-only-pkg');
+        mkdirSync(pkgPath, { recursive: true });
+        writeFileSync(join(pkgPath, 'package.json'), '{}');
+
+        const discovered = new Map<string, string>();
+        await discoverPackages(TMP, discovered, new Set());
+
+        expect(discovered.size).toBe(0);
+    });
+
+    it('discovers transitive deps by recursing into package node_modules', async () => {
+        // Root depends on pkg-a, pkg-a depends on pkg-b
+        const pkgA = join(TMP, 'node_modules', '@layerzerolabs', 'pkg-a');
+        const pkgB = join(pkgA, 'node_modules', '@layerzerolabs', 'pkg-b');
+        createCrate(pkgA);
+        createCrate(pkgB);
+
+        const discovered = new Map<string, string>();
+        await discoverPackages(TMP, discovered, new Set());
+
+        expect(discovered.size).toBe(2);
+        expect(discovered.has('pkg-a')).toBe(true);
+        expect(discovered.has('pkg-b')).toBe(true);
+    });
+
+    it('deduplicates packages seen through multiple paths', async () => {
+        // Both pkg-a and pkg-b depend on shared (via symlinks in real pnpm,
+        // but here we just put it in both node_modules)
+        const pkgA = join(TMP, 'node_modules', '@layerzerolabs', 'pkg-a');
+        const shared = join(TMP, 'node_modules', '@layerzerolabs', 'shared');
+        const sharedViaA = join(pkgA, 'node_modules', '@layerzerolabs', 'shared');
+        createCrate(pkgA);
+        createCrate(shared);
+        createCrate(sharedViaA);
+
+        const discovered = new Map<string, string>();
+        await discoverPackages(TMP, discovered, new Set());
+
+        // "shared" discovered once from root, not duplicated from pkg-a's copy
+        expect(discovered.size).toBe(2); // pkg-a + shared
+    });
+});
+
+describe('isWorkspaceRoot', () => {
+    it('returns true when Cargo.toml has a [workspace] table', async () => {
+        createCrate(join(TMP, 'ws'), '[workspace]\nmembers = ["contracts/*"]');
+        expect(await isWorkspaceRoot(join(TMP, 'ws'))).toBe(true);
+    });
+
+    it('returns true for a virtual manifest ([workspace] without [package])', async () => {
+        createCrate(join(TMP, 'virtual'), '[workspace]\nresolver = "2"\nmembers = ["a"]');
+        expect(await isWorkspaceRoot(join(TMP, 'virtual'))).toBe(true);
+    });
+
+    it('returns false for a bare [package] (standalone single crate)', async () => {
+        createCrate(join(TMP, 'leaf'), '[package]\nname = "leaf"');
+        expect(await isWorkspaceRoot(join(TMP, 'leaf'))).toBe(false);
+    });
+
+    it('returns false when there is no Cargo.toml', async () => {
+        mkdirSync(join(TMP, 'empty'), { recursive: true });
+        expect(await isWorkspaceRoot(join(TMP, 'empty'))).toBe(false);
+    });
+});
+
+describe('buildDependenciesPathMap', () => {
+    // Build a VendorTarget by collecting the crate's tree (same input the pipeline feeds it).
+    const toTarget = async (
+        pkgName: string,
+        npmPkgDir: string,
+        depsDir: string,
+    ): Promise<VendorTarget> => ({
+        pkgName,
+        npmPkgDir,
+        depsPkgDir: join(depsDir, pkgName),
+        tree: await collectFiles(npmPkgDir),
+    });
+
+    it('maps discovered packages to dependencies/ targets', async () => {
+        const depsDir = join(TMP, 'dependencies');
+        // A discovered package always has a root Cargo.toml (isCrate-verified), so its
+        // '.' manifest dir maps the package root to its dependencies/ target.
+        const rbac = join(TMP, 'rbac');
+        const oapp = join(TMP, 'oapp');
+        createCrate(rbac);
+        createCrate(oapp);
+        const targets = [
+            await toTarget('utils-solana-rbac', rbac, depsDir),
+            await toTarget('oapp-solana-impl', oapp, depsDir),
+        ];
+
+        const pathMap = buildDependenciesPathMap(targets);
+
+        expect(pathMap.get(rbac)).toBe(join(depsDir, 'utils-solana-rbac'));
+        expect(pathMap.get(oapp)).toBe(join(depsDir, 'oapp-solana-impl'));
+    });
+
+    it('includes subdirectories with Cargo.toml (macros/)', async () => {
+        const depsDir = join(TMP, 'dependencies');
+        const crateDir = join(TMP, 'real-crate');
+        createCrate(crateDir);
+        createCrate(join(crateDir, 'macros'));
+
+        const pathMap = buildDependenciesPathMap([await toTarget('my-crate', crateDir, depsDir)]);
+
+        expect(pathMap.get(crateDir)).toBe(join(depsDir, 'my-crate'));
+        expect(pathMap.get(join(crateDir, 'macros'))).toBe(join(depsDir, 'my-crate', 'macros'));
+    });
+
+    it('skips excluded directories like node_modules and target', async () => {
+        const depsDir = join(TMP, 'dependencies');
+        const crateDir = join(TMP, 'real-crate');
+        createCrate(crateDir);
+        createCrate(join(crateDir, 'node_modules')); // should be excluded
+        createCrate(join(crateDir, 'target')); // should be excluded
+
+        const pathMap = buildDependenciesPathMap([await toTarget('my-crate', crateDir, depsDir)]);
+
+        expect(pathMap.size).toBe(1); // only the root, no subdirs
+    });
+
+    it('maps every crate dir (incl. deeply nested) to its dependencies/ target', async () => {
+        const depsDir = join(TMP, 'dependencies');
+        const crateDir = join(TMP, 'protocol-stellar');
+        createCrate(crateDir, '[workspace]\nmembers = ["contracts/*", "contracts/oapps/*"]');
+        createCrate(join(crateDir, 'contracts', 'utils'));
+        createCrate(join(crateDir, 'contracts', 'oapps'));
+        createCrate(join(crateDir, 'contracts', 'oapps', 'oft-core'));
+
+        const pathMap = buildDependenciesPathMap([
+            await toTarget('protocol-stellar', crateDir, depsDir),
+        ]);
+
+        expect(pathMap.get(crateDir)).toBe(join(depsDir, 'protocol-stellar'));
+        expect(pathMap.get(join(crateDir, 'contracts', 'utils'))).toBe(
+            join(depsDir, 'protocol-stellar', 'contracts', 'utils'),
+        );
+        // the deep member — the case the old one-level scan missed
+        expect(pathMap.get(join(crateDir, 'contracts', 'oapps', 'oft-core'))).toBe(
+            join(depsDir, 'protocol-stellar', 'contracts', 'oapps', 'oft-core'),
+        );
+    });
+});

package/tests/resolve/fixtures/index.ts

@@ -0,0 +1,6 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+const FIXTURES_DIR = new URL('.', import.meta.url).pathname;
+
+export const fixture = (name: string): string => readFileSync(join(FIXTURES_DIR, name), 'utf-8');

package/tests/resolve/fixtures/minimal.toml

@@ -0,0 +1,2 @@
+[package]
+name = "test-crate"

package/tests/resolve/fixtures/mixed-deps.toml

@@ -0,0 +1,4 @@
+[dependencies]
+anchor-lang = { version = "0.32.1" }
+rbac = { path = "../../dependencies/utils-solana-rbac" }
+num_enum = { version = "0.7" }

package/tests/resolve/fixtures/multi-path-deps.toml

@@ -0,0 +1,9 @@
+[package]
+name = "my-crate"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+pkg-a = { path = "dependencies/pkg-a" }
+pkg-b = { path = "dependencies/pkg-b" }
+pkg-c = { path = "dependencies/pkg-c" }

package/tests/resolve/fixtures/multi-section-path-deps.toml

@@ -0,0 +1,13 @@
+[package]
+name = "my-crate"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anchor-lang = { version = "0.32.1" }
+
+[dev-dependencies]
+test-utils = { path = "dependencies/test-utils" }
+
+[build-dependencies]
+codegen = { path = "dependencies/codegen-utils" }

package/tests/resolve/fixtures/no-path-deps.toml

@@ -0,0 +1,3 @@
+[dependencies]
+anchor-lang = { version = "0.32.1" }
+num_enum = { version = "0.7" }

package/tests/resolve/fixtures/oapp-with-stale-deps.toml

@@ -0,0 +1,5 @@
+[package]
+name = "oapp"
+
+[dependencies]
+rbac = { path = "dependencies/utils-solana-rbac" }

package/tests/resolve/fixtures/patch-multi-registry.toml

@@ -0,0 +1,22 @@
+[package]
+name = "my-crate"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anchor-lang = { version = "0.32.1" }
+
+[patch.crates-io]
+anchor-lang = { git = "https://github.com/example/anchor.git", rev = "deadbeef" }
+
+[patch."https://github.com/solana-labs/solana.git"]
+solana-program = { path = "../solana-program" }
+
+[profile.dev]
+opt-level = 1
+
+[profile.dev.package."*"]
+opt-level = 3
+
+[profile.release]
+overflow-checks = true