@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/internal/ConfigDependencyScanner.js

@@ -1,330 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigDependencyScanner = void 0;
-const promises_1 = require("node:fs/promises");
-const node_module_1 = require("node:module");
-const node_path_1 = __importDefault(require("node:path"));
-const node_url_1 = require("node:url");
-const EvidenceParser_1 = require("../parsers/EvidenceParser");
-const EcmaScriptSyntax_1 = require("../adapters/ecmascript/EcmaScriptSyntax");
-const SourcePath_1 = require("./SourcePath");
-/**
- * Finds static local and package-resolution dependencies of one evaluated config.
- *
- * It records dependencies before reads and resolution complete, allowing watch
- * mode to observe a repaired import rather than remaining stuck on a failed scan.
- */
-class ConfigDependencyScanner {
-    configFile;
-    dependencies = new Map();
-    scanned = new Set();
-    parser = new EvidenceParser_1.EvidenceParser({ concurrency: 1 });
-    /** Creates a dependency scanner for one configuration entry file.
-     *
-     * The scanner owns a private parser and closes it after `scan` completes, so callers receive only serializable watch dependencies.
-     */
-    constructor(configFile) {
-        this.configFile = configFile;
-    }
-    /** Scans the configuration and every statically reachable local module.
-     *
-     * Parser resources close on both success and failure, while already discovered dependencies remain available through `list` for watch recovery.
-     */
-    async scan() {
-        try {
-            if (programmingType(this.configFile) !== undefined)
-                await this.watchModuleScope(node_path_1.default.resolve(this.configFile));
-            await this.scanFile(node_path_1.default.resolve(this.configFile));
-            return this.list();
-        }
-        finally {
-            await this.parser.close();
-        }
-    }
-    /** Returns ordered dependencies discovered before a failed read or parse.
-     *
-     * Watch setup uses this partial result so a repaired module or package boundary can restart a failed configuration cycle.
-     */
-    list() {
-        return Array.from(this.dependencies.values()).sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
-    }
-    /** Watches and parses one physical module once, then follows its static specifiers.
-     *
-     * Logical and real paths are both retained because symlink changes can alter resolution even when the parsed physical file is unchanged.
-     */
-    async scanFile(file) {
-        const logical = SourcePath_1.SourcePath.slash(node_path_1.default.resolve(file));
-        this.watch(logical, false);
-        this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.dirname(logical)), true);
-        const physical = SourcePath_1.SourcePath.slash(await (0, promises_1.realpath)(logical));
-        this.watch(physical, false);
-        this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.dirname(physical)), true);
-        if (logical === SourcePath_1.SourcePath.slash(node_path_1.default.resolve(this.configFile)) &&
-            programmingType(physical) !== undefined)
-            await this.watchModuleScope(physical);
-        if (this.scanned.has(physical))
-            return;
-        this.scanned.add(physical);
-        const type = programmingType(physical);
-        if (type === undefined)
-            return;
-        const content = await (0, promises_1.readFile)(physical, "utf8");
-        const specifiers = await this.parser.parse({ type, file: physical, content }, collectSpecifiers);
-        for (const specifier of specifiers)
-            for (const resolved of await this.resolve(physical, specifier))
-                await this.scanFile(resolved);
-    }
-    /** Resolves one static specifier while recording paths that can alter its resolution.
-     *
-     * Local, file URL, and package forms use their respective Node-compatible lookup paths before recursive scanning continues.
-     */
-    async resolve(owner, specifier) {
-        if (specifier.startsWith("node:") || (0, node_module_1.isBuiltin)(specifier))
-            return [];
-        if (specifier.startsWith("file:"))
-            return this.resolveExact((0, node_url_1.fileURLToPath)(specifier));
-        if (specifier.startsWith(".") || node_path_1.default.isAbsolute(specifier)) {
-            const base = node_path_1.default.resolve(node_path_1.default.dirname(owner), specifier);
-            try {
-                return await this.resolvePath(base);
-            }
-            catch (cause) {
-                try {
-                    return await this.resolveExact((0, node_module_1.createRequire)(owner).resolve(specifier));
-                }
-                catch {
-                    throw cause;
-                }
-            }
-        }
-        await this.watchPackageResolution(owner, packageSpecifier(specifier));
-        try {
-            return this.resolveExact((0, node_module_1.createRequire)(owner).resolve(specifier));
-        }
-        catch (cause) {
-            await this.watchMissingPackage(owner, specifier);
-            throw new Error(`Could not resolve configuration import '${specifier}' from ${owner}.`, { cause });
-        }
-    }
-    /** Watches package boundaries whose module mode changes temporary config evaluation.
-     *
-     * The nearest `package.json` controls Node module kind, so its appearance or replacement must invalidate the configuration dependency set.
-     */
-    async watchModuleScope(file) {
-        let directory = node_path_1.default.dirname(file);
-        for (;;) {
-            const manifest = SourcePath_1.SourcePath.slash(node_path_1.default.join(directory, "package.json"));
-            this.watch(manifest, false);
-            try {
-                if ((await (0, promises_1.stat)(manifest)).isFile())
-                    return;
-            }
-            catch (cause) {
-                if (!absent(cause))
-                    throw cause;
-            }
-            const parent = node_path_1.default.dirname(directory);
-            if (parent === directory)
-                return;
-            directory = parent;
-        }
-    }
-    /** Watches each `node_modules` candidate searched by Node package resolution.
-     *
-     * A package installed higher in the directory tree can make a previously unresolved configuration import valid.
-     */
-    async watchPackageResolution(owner, packageName) {
-        let directory = node_path_1.default.dirname(owner);
-        for (;;) {
-            const nodeModules = SourcePath_1.SourcePath.slash(node_path_1.default.join(directory, "node_modules"));
-            const packageDirectory = SourcePath_1.SourcePath.slash(node_path_1.default.join(nodeModules, packageName));
-            this.watch(packageDirectory, false);
-            this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.join(packageDirectory, "package.json")), false);
-            const parent = node_path_1.default.dirname(directory);
-            if (parent === directory)
-                return;
-            directory = parent;
-        }
-    }
-    /** Validates an exact resolved module and watches its parent for deletion or replacement.
-     *
-     * The parent dependency lets watch mode notice a module that disappears after resolution has succeeded.
-     */
-    async resolveExact(file) {
-        const location = SourcePath_1.SourcePath.slash(node_path_1.default.resolve(file));
-        this.watch(location, false);
-        this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.dirname(location)), true);
-        if ((await (0, promises_1.stat)(location)).isFile())
-            return [location];
-        throw new Error(`Configuration module '${location}' is not a file.`);
-    }
-    /** Tries TypeScript-aware local extension candidates in deterministic order.
-     *
-     * The ordered candidates mirror supported config imports so a newly created higher-precedence file can restart resolution.
-     */
-    async resolvePath(base) {
-        const candidates = moduleCandidates(base);
-        for (const candidate of candidates) {
-            this.watch(SourcePath_1.SourcePath.slash(candidate), false);
-            try {
-                if ((await (0, promises_1.stat)(candidate)).isFile())
-                    return [candidate];
-            }
-            catch (cause) {
-                if (!absent(cause))
-                    throw cause;
-            }
-        }
-        this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.dirname(base)), true);
-        throw new Error(`Could not resolve local configuration module '${base}'.`);
-    }
-    /** Retains recursive missing package paths so installation or repair restarts the watch cycle.
-     *
-     * Failed package resolution still establishes dependencies on every searched package root instead of becoming a terminal blind spot.
-     */
-    async watchMissingPackage(owner, specifier) {
-        const packageName = packageSpecifier(specifier);
-        let directory = node_path_1.default.dirname(owner);
-        for (;;) {
-            const nodeModules = SourcePath_1.SourcePath.slash(node_path_1.default.join(directory, "node_modules"));
-            this.watch(nodeModules, true);
-            this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.join(nodeModules, packageName)), true);
-            const parent = node_path_1.default.dirname(directory);
-            if (parent === directory)
-                return;
-            directory = parent;
-        }
-    }
-    /** Merges duplicate dependencies and upgrades them to recursive observation when needed.
-     *
-     * A path reached through several import routes retains the strongest watch requirement without duplicate entries.
-     */
-    watch(location, recursive) {
-        const previous = this.dependencies.get(location);
-        this.dependencies.set(location, {
-            path: location,
-            recursive: recursive || previous?.recursive === true,
-        });
-    }
-}
-exports.ConfigDependencyScanner = ConfigDependencyScanner;
-/** Extracts only statically knowable imports and rejects dynamic dependency expressions.
- *
- * Configuration watching can follow a fixed dependency graph, but dynamic `import` or `require` arguments require runtime execution and therefore fail visibly.
- */
-function collectSpecifiers(session) {
-    const output = new Set();
-    for (const statement of session.root.namedChildren) {
-        if (statement.type !== "import_statement" &&
-            statement.type !== "export_statement")
-            continue;
-        if (EcmaScriptSyntax_1.EcmaScriptSyntax.token(statement, "type"))
-            continue;
-        const direct = EcmaScriptSyntax_1.EcmaScriptSyntax.module(statement.childForFieldName("source"));
-        if (direct !== undefined)
-            output.add(direct);
-        else if (statement.type === "import_statement") {
-            const literal = statement.descendantsOfType("string").at(-1);
-            const nested = EcmaScriptSyntax_1.EcmaScriptSyntax.module(literal ?? null);
-            if (nested !== undefined)
-                output.add(nested);
-        }
-    }
-    for (const call of session.root.descendantsOfType("call_expression")) {
-        const callee = call.childForFieldName("function");
-        if (callee?.text !== "import" && callee?.text !== "require")
-            continue;
-        const argumentsNode = call.childForFieldName("arguments");
-        const argument = argumentsNode === null
-            ? undefined
-            : argumentsNode.namedChildren.find((child) => child.type === "string");
-        const specifier = EcmaScriptSyntax_1.EcmaScriptSyntax.module(argument ?? null);
-        if (specifier === undefined)
-            throw new Error(`Configuration ${callee.text}() dependencies require one static string literal.`);
-        output.add(specifier);
-    }
-    return Array.from(output);
-}
-/** Chooses a parser only for JavaScript-family modules relevant to configuration imports.
- *
- * Non-code files can be resolved as dependencies but are not recursively parsed for module specifiers.
- */
-function programmingType(file) {
-    const extension = node_path_1.default.extname(file).toLowerCase();
-    if ([".ts", ".tsx", ".cts", ".mts"].includes(extension))
-        return "typescript";
-    if ([".js", ".jsx", ".cjs", ".mjs"].includes(extension))
-        return "javascript";
-    return undefined;
-}
-/** Produces the supported local TypeScript and JavaScript extension fallback order.
- *
- * Local import resolution uses this ordered list to match configuration evaluation and register each candidate for watch recovery.
- */
-function moduleCandidates(base) {
-    const extension = node_path_1.default.extname(base).toLowerCase();
-    if (extension === ".js" || extension === ".jsx")
-        return unique([
-            replaceExtension(base, ".ts"),
-            replaceExtension(base, ".tsx"),
-            base,
-        ]);
-    if (extension === ".mjs")
-        return unique([replaceExtension(base, ".mts"), base]);
-    if (extension === ".cjs")
-        return unique([replaceExtension(base, ".cts"), base]);
-    if (extension !== "")
-        return [base];
-    const extensions = [
-        ".ts",
-        ".tsx",
-        ".mts",
-        ".cts",
-        ".js",
-        ".jsx",
-        ".mjs",
-        ".cjs",
-        ".json",
-    ];
-    return unique([
-        base,
-        ...extensions.map((value) => base + value),
-        ...extensions.map((value) => node_path_1.default.join(base, "index" + value)),
-    ]);
-}
-/** Replaces an existing extension without applying path normalization.
- *
- * Candidate generation preserves the authored base path while trying TypeScript counterparts for JavaScript spellings.
- */
-function replaceExtension(file, extension) {
-    return file.slice(0, -node_path_1.default.extname(file).length) + extension;
-}
-/** Retains each candidate's first occurrence while eliminating fallback duplicates.
- *
- * This preserves deterministic resolution precedence when extension substitution produces the same path twice.
- */
-function unique(values) {
-    return Array.from(new Set(values));
-}
-/** Extracts the package root so subpath resolution watches the owning package boundary.
- *
- * Scoped specifiers retain their first two segments; ordinary packages retain only the first segment.
- */
-function packageSpecifier(specifier) {
-    const segments = specifier.split("/");
-    return specifier.startsWith("@")
-        ? segments.slice(0, 2).join("/")
-        : (segments[0] ?? specifier);
-}
-/** Identifies expected missing-path errors that resolution can continue past.
- *
- * Resolution probes may skip absent candidates, whereas permission and other filesystem failures must remain diagnostic.
- */
-function absent(cause) {
-    return (cause instanceof Error &&
-        "code" in cause &&
-        (cause.code === "ENOENT" || cause.code === "ENOTDIR"));
-}

package/lib/internal/FileGlob.d.ts

@@ -1,24 +0,0 @@
-/**
- * Matches the restricted Evidence glob language: `*`, `**`, `?`, and ordered negation.
- *
- * The matcher operates on portable path segments, keeping selection independent
- * of host separator conventions and refusing patterns that escape a population root.
- */
-export declare class FileGlob {
-    private readonly patterns;
-    /** Compiles ordered patterns and requires at least one positive selection baseline.
-     *
-     * A population with only exclusions would have no defined initial set, so configuration validation rejects it at construction.
-     */
-    constructor(patterns: readonly string[]);
-    /** Applies every matching pattern in declaration order.
-     *
-     * Later matching positives or exclusions replace the inclusion decision made by earlier patterns.
-     */
-    matches(location: string): boolean;
-    /** Determines whether a directory can contain a selected descendant.
-     *
-     * Discovery uses this conservative result to prune traversal without excluding descendants restored by a later positive pattern.
-     */
-    couldMatchDescendant(directory: string): boolean;
-}

package/lib/internal/FileGlob.js

@@ -1,148 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileGlob = void 0;
-/**
- * Matches the restricted Evidence glob language: `*`, `**`, `?`, and ordered negation.
- *
- * The matcher operates on portable path segments, keeping selection independent
- * of host separator conventions and refusing patterns that escape a population root.
- */
-class FileGlob {
-    patterns;
-    /** Compiles ordered patterns and requires at least one positive selection baseline.
-     *
-     * A population with only exclusions would have no defined initial set, so configuration validation rejects it at construction.
-     */
-    constructor(patterns) {
-        this.patterns = patterns.map(compile);
-        if (!this.patterns.some((pattern) => !pattern.exclude))
-            throw new Error("The files array must contain at least one positive glob.");
-    }
-    /** Applies every matching pattern in declaration order.
-     *
-     * Later matching positives or exclusions replace the inclusion decision made by earlier patterns.
-     */
-    matches(location) {
-        const segments = split(location);
-        let included = false;
-        for (const pattern of this.patterns)
-            if (match(pattern.segments, segments, false))
-                included = !pattern.exclude;
-        return included;
-    }
-    /** Determines whether a directory can contain a selected descendant.
-     *
-     * Discovery uses this conservative result to prune traversal without excluding descendants restored by a later positive pattern.
-     */
-    couldMatchDescendant(directory) {
-        const prefix = split(directory);
-        let possible = false;
-        for (const pattern of this.patterns)
-            if (!pattern.exclude) {
-                if (match(pattern.segments, prefix, true))
-                    possible = true;
-            }
-            else if (pattern.segments.at(-1) === "**" &&
-                match(pattern.segments, prefix, false))
-                possible = false;
-        return possible;
-    }
-}
-exports.FileGlob = FileGlob;
-/** Parses one authored glob into normalized segments while rejecting ambiguous root escapes.
- *
- * `FileGlob` uses the result for portable matching relative to one selected population root.
- */
-function compile(raw) {
-    if (raw.trim() === "")
-        throw new Error("Glob strings must not be empty.");
-    const exclude = raw.startsWith("!");
-    let value = (exclude ? raw.slice(1) : raw).replaceAll("\\", "/");
-    while (value.startsWith("./"))
-        value = value.slice(2);
-    if (value === "")
-        throw new Error("The exclusion marker '!' must be followed by a glob.");
-    if (value.startsWith("/") || /^[A-Za-z]:/.test(value))
-        throw new Error(`Glob '${raw}' must be relative to its population root.`);
-    if (value.endsWith("/"))
-        value = value.slice(0, -1);
-    const segments = value.split("/");
-    if (segments.includes("") || segments.includes(".."))
-        throw new Error(`Glob '${raw}' contains an empty segment or escapes its root.`);
-    return { segments, exclude };
-}
-/** Splits a candidate path into portable relative segments without filesystem resolution.
- *
- * Matching operates on these normalized segments so Windows and POSIX separators have identical selection semantics.
- */
-function split(value) {
-    let normalized = value.replaceAll("\\", "/");
-    while (normalized.startsWith("./"))
-        normalized = normalized.slice(2);
-    normalized = normalized.replace(/^\/+|\/+$/g, "");
-    return normalized === "" || normalized === "." ? [] : normalized.split("/");
-}
-/** Matches a pattern with memoized globstar branches bounded by the pattern and path grid.
- *
- * Memoization prevents repeated `**` branches from causing exponential discovery work for long paths.
- */
-function match(pattern, segments, descendant) {
-    const memo = new Map();
-    return visit(0, 0);
-    function visit(patternIndex, pathIndex) {
-        const key = `${patternIndex}:${pathIndex}`;
-        const cached = memo.get(key);
-        if (cached !== undefined)
-            return cached;
-        const token = pattern[patternIndex];
-        const segment = segments[pathIndex];
-        let result;
-        if (descendant && pathIndex === segments.length)
-            result = patternIndex < pattern.length;
-        else if (token === undefined)
-            result = pathIndex === segments.length;
-        else if (token === "**")
-            result =
-                visit(patternIndex + 1, pathIndex) ||
-                    (segment !== undefined && visit(patternIndex, pathIndex + 1));
-        else
-            result =
-                segment !== undefined &&
-                    matchSegment(token, segment) &&
-                    visit(patternIndex + 1, pathIndex + 1);
-        memo.set(key, result);
-        return result;
-    }
-}
-/**
- * Matches one segment where star and question mark never cross a separator boundary.
- *
- * A question mark consumes one Unicode code point, as in the Go matcher.
- */
-function matchSegment(pattern, value) {
-    const tokens = Array.from(pattern);
-    const characters = Array.from(value);
-    let patternIndex = 0;
-    let valueIndex = 0;
-    let starPattern = -1;
-    let starValue = 0;
-    while (valueIndex < characters.length)
-        if (tokens[patternIndex] === "*") {
-            starPattern = patternIndex++;
-            starValue = valueIndex;
-        }
-        else if (tokens[patternIndex] === "?" ||
-            tokens[patternIndex] === characters[valueIndex]) {
-            patternIndex++;
-            valueIndex++;
-        }
-        else if (starPattern >= 0) {
-            patternIndex = starPattern + 1;
-            valueIndex = ++starValue;
-        }
-        else
-            return false;
-    while (tokens[patternIndex] === "*")
-        patternIndex++;
-    return patternIndex === tokens.length;
-}

package/lib/internal/IConfigDependencyScan.d.ts

@@ -1,25 +0,0 @@
-import type { IEvidenceSourceDependency } from "../structures/IEvidenceSourceDependency";
-/**
- * Dependencies found while scanning a configuration module graph.
- *
- * A failure does not erase prior discoveries: watch mode needs these paths to
- * observe the repair that makes evaluation possible again.
- */
-export interface IConfigDependencyScan {
-    /**
-     * File and directory dependencies that must invalidate configuration evaluation.
-     *
-     * `ConfigDependencyScanner` records resolved module files, package boundaries,
-     * and missing resolution candidates here so watch mode can rerun evaluation
-     * after either a content edit or a filesystem-topology repair.
-     */
-    dependencies: IEvidenceSourceDependency[];
-    /**
-     * Read, parse, or resolution failure after recoverable dependencies were recorded.
-     *
-     * Omission means scanning completed. When present, callers retain
-     * `dependencies` instead of replacing them with an empty watch set that
-     * could miss the change which repairs the configuration graph.
-     */
-    cause?: unknown;
-}

package/lib/internal/IConfigPackageScope.d.ts

@@ -1,16 +0,0 @@
-/**
- * Nearest package metadata relevant to the configuration evaluator's module decision.
- *
- * `configModule` reads this parsed projection while walking upward from a config
- * file. It models only the package field that can change the temporary
- * evaluator project's compiler module kind.
- */
-export interface IConfigPackageScope {
-    /**
-     * Node package module mode at this package boundary.
-     *
-     * The evaluator selects `ESNext` only when this value is `"module"`; omission
-     * and every other value retain the CommonJS fallback for an unqualified config.
-     */
-    type?: string;
-}

package/lib/internal/IEvaluateTypeScriptConfigOptions.d.ts

@@ -1,16 +0,0 @@
-/**
- * Optional diagnostic routing for isolated TypeScript configuration evaluation.
- *
- * `evaluateTypeScriptConfig` passes this sink to its child evaluator so callers
- * can collect or redirect compiler and runtime output without changing the
- * evaluated configuration result.
- */
-export interface IEvaluateTypeScriptConfigOptions {
-    /**
-     * Receives each stdout or stderr chunk emitted by the evaluator process.
-     *
-     * When omitted, evaluation writes diagnostics to the parent process's stderr
-     * and preserves the child process's original formatting.
-     */
-    writeDiagnostic?: ((content: string) => void) | undefined;
-}

package/lib/internal/IFileGlobPattern.d.ts

@@ -1,22 +0,0 @@
-/**
- * One normalized include or exclusion rule in the ordered Evidence glob program.
- *
- * `FileGlob` creates these records while compiling configured file patterns,
- * then applies them in order to determine a path's current inclusion decision.
- */
-export interface IFileGlobPattern {
-    /**
-     * Portable relative path segments interpreted by the limited glob matcher.
-     *
-     * Compilation removes the exclusion marker and normalizes separators before
-     * storing these tokens, so matching never depends on host path separators.
-     */
-    segments: string[];
-    /**
-     * Whether a matching rule clears the current inclusion decision.
-     *
-     * This is true for patterns authored with `!`; a later positive rule can
-     * restore a path because `FileGlob` evaluates every rule in declaration order.
-     */
-    exclude: boolean;
-}

package/lib/internal/IPackageManifest.d.ts

@@ -1,16 +0,0 @@
-/**
- * Installed Evidence package manifest fields required by the version command.
- *
- * `EvidenceCommand` validates this narrow projection before reporting its own
- * package version, keeping malformed installed metadata an actionable command
- * failure instead of loading project configuration.
- */
-export interface IPackageManifest {
-    /**
-     * Published package version presented by the command.
-     *
-     * This value comes from the installed package manifest and is returned as the
-     * version command's output rather than being derived from the running project.
-     */
-    version: string;
-}

package/lib/internal/IPendingEvidenceTag.d.ts

@@ -1,36 +0,0 @@
-/**
- * A recognized documentation annotation before semantic attachment.
- *
- * Parser offsets remain relative to normalized documentation so the mapper can
- * recover the original source range after multiline bodies are assembled.
- */
-export interface IPendingEvidenceTag {
-    /**
-     * Annotation spelling, including link and review variants with distinct later rules.
-     *
-     * Attachment dispatch uses this value to choose target parsing and graph
-     * handling without re-reading the normalized documentation text.
-     */
-    kind: "evidence" | "link" | "evidenceExclude" | "evidenceReview" | "evidenceExcludeReview";
-    /**
-     * Continued body text without the tag marker.
-     *
-     * The mapper joins continuation lines before target parsing while retaining
-     * offsets into the normalized documentation carrier.
-     */
-    body: string;
-    /**
-     * Inclusive UTF-16 offset of the annotation in normalized documentation.
-     *
-     * Source mapping combines this boundary with the carrier's normalized text to
-     * recover the authored location for diagnostics.
-     */
-    start: number;
-    /**
-     * Exclusive UTF-16 offset immediately after the tag's continued body.
-     *
-     * Together with {@link start}, this forms the half-open annotation range used
-     * when translating normalized offsets back to source positions.
-     */
-    end: number;
-}

package/lib/internal/ITreeSitterAssetLock.d.ts

@@ -1,23 +0,0 @@
-import type { tags } from "typia";
-/**
- * Serialized ownership record for one cross-process grammar cache transfer.
- *
- * The token prevents an old owner from deleting a lock reacquired after a crash;
- * the PID permits stale-lock recovery when that owner is no longer alive.
- */
-export interface ITreeSitterAssetLock {
-    /**
-     * Positive operating-system process ID that acquired the transfer lock.
-     *
-     * Stale-lock recovery checks whether this owner remains alive before allowing
-     * another process to replace the serialized cache record.
-     */
-    pid: number & tags.Type<"uint32"> & tags.Minimum<1>;
-    /**
-     * Random acquisition token checked before releasing a lock with the same path.
-     *
-     * It prevents a former owner from deleting a lock that another process
-     * acquired after crash recovery reused the path.
-     */
-    token: string;
-}