# tools/core/resolvers/artifact.resolver.ts

> 84 lines of code and 16 definitions.

Tree: Coordination tree
Language: typescript
Layer: infrastructure
Canonical: https://banes-lab.com/anatomy/coordination#file-coordination-tools-core-resolvers-artifact-resolver-ts
Source text: https://banes-lab.com/assets/sources/source.73f82ad8f28ccd2475690a8ca509e46bf3f7b62b2fc7f358f689da41ff7e620f.generated.txt

## Definitions

- `unresolved` (lexical_declaration, line 48)
- `resolveArtifactRoots` (lexical_declaration, line 52, exported)
- `isDirectory` (lexical_declaration, line 37)
- `ArtifactRoot` (interface_declaration, line 6, exported)
- `toPosix` (lexical_declaration, line 14)
- `rel` (lexical_declaration, line 15)
- `i` (lexical_declaration, line 20)
- `readField` (lexical_declaration, line 26)
- `current` (lexical_declaration, line 27)
- `out` (lexical_declaration, line 56, exported)
- `bindingAbs` (lexical_declaration, line 59, exported)
- `parsed` (lexical_declaration, line 66, exported)
- `bound` (lexical_declaration, line 74, exported)
- `boundAbs` (lexical_declaration, line 80, exported)
- `boundRel` (lexical_declaration, line 81, exported)
- `path` (lexical_declaration, line 89, exported)

## Used by

- [tools/core/steps/source.step.ts](https://banes-lab.com/source/coordination/tools/core/steps/source.step.ts.md)
- [tools/rules/declaration.rule.ts](https://banes-lab.com/source/coordination/tools/rules/declaration.rule.ts.md)

## Source

```typescript
import type { ArtifactRootData, TaxonomyData } from "../types/taxonomy.types.ts";
import { existsSync, readFileSync, statSync } from "node:fs";

import { relative, resolve, sep } from "node:path";

export interface ArtifactRoot {
    readonly key: string;
    readonly path: string;
    readonly binding: string;
    readonly field: string;
    readonly unresolved: string | null;
}

const toPosix = function toPosix(root: string, path: string): string {
    const rel = relative(root, path);
    if (sep === "/") {
        return rel;
    }
    let out = "";
    for (let i = 0; i < rel.length; i += 1) {
        out += rel[i] === sep ? "/" : rel[i];
    }
    return out;
};

const readField = function readField(source: unknown, field: readonly string[]): string | null {
    let current: unknown = source;
    for (const key of field) {
        if (typeof current !== "object" || current === null) {
            return null;
        }
        current = (current as Record<string, unknown>)[key];
    }
    return typeof current === "string" ? current : null;
};

const isDirectory = function isDirectory(absolute: string): boolean {
    if (!existsSync(absolute)) {
        return false;
    }
    try {
        return statSync(absolute).isDirectory();
    } catch {
        return false;
    }
};

const unresolved = function unresolved(key: string, data: ArtifactRootData, reason: string): ArtifactRoot {
    return { binding: data.binding, field: data.field.join("."), key, path: "", unresolved: reason };
};

export const resolveArtifactRoots = function resolveArtifactRoots(
    repoRoot: string,
    data: TaxonomyData,
): ArtifactRoot[] {
    const out: ArtifactRoot[] = [];

    for (const [key, entry] of Object.entries(data.artifactRoots)) {
        const bindingAbs = resolve(repoRoot, entry.binding);

        if (!existsSync(bindingAbs)) {
            out.push(unresolved(key, entry, `binding file ${entry.binding} does not exist`));
            continue;
        }

        let parsed: unknown;
        try {
            parsed = JSON.parse(readFileSync(bindingAbs, "utf8"));
        } catch (error) {
            out.push(unresolved(key, entry, `binding file ${entry.binding} is not valid JSON: ${String(error)}`));
            continue;
        }

        const bound = readField(parsed, entry.field);
        if (bound === null) {
            out.push(unresolved(key, entry, `field ${entry.field.join(".")} is absent or not a string`));
            continue;
        }

        const boundAbs = resolve(repoRoot, bound);
        const boundRel = toPosix(repoRoot, boundAbs);

        if (boundRel.startsWith("..")) {
            out.push(unresolved(key, entry, `${entry.field.join(".")} resolves to ${bound}, outside the repository`));
            continue;
        }

        for (const subtree of entry.subtrees) {
            const path = boundRel.length === 0 ? subtree : `${boundRel}/${subtree}`;
            if (!isDirectory(resolve(repoRoot, path))) {
                out.push(unresolved(key, entry, `subtree ${path} does not exist`));
                continue;
            }
            out.push({ binding: entry.binding, field: entry.field.join("."), key, path, unresolved: null });
        }
    }

    return out;
};
```