@telorun/analyzer 0.1.1

package/dist/schema-compat.js

@@ -0,0 +1,234 @@
+import AjvModule from "ajv";
+import addFormats from "ajv-formats";
+const Ajv = AjvModule.default ?? AjvModule;
+/** Creates a configured AJV instance (allErrors, strict: false, with formats).
+ *  Called once for the module-level instance and once per DefinitionRegistry instance. */
+export function createAjv() {
+    const instance = new Ajv({ allErrors: true, strict: false });
+    addFormats.default
+        ? addFormats.default(instance)
+        : addFormats(instance);
+    return instance;
+}
+const ajv = createAjv();
+/** Conservative structural JSON Schema compatibility check.
+ *  Only flags definite mismatches: missing required fields and primitive type conflicts.
+ *  Ambiguous cases (anyOf/oneOf/etc.) are treated as compatible. */
+export function checkSchemaCompatibility(source, target) {
+    const issues = [];
+    checkObject(source, target, "", issues);
+    return { compatible: issues.length === 0, issues };
+}
+function checkObject(source, target, path, issues) {
+    const targetRequired = target.required ?? [];
+    const sourceProps = source.properties ?? {};
+    const targetProps = target.properties ?? {};
+    for (const field of targetRequired) {
+        if (!(field in sourceProps)) {
+            issues.push(`${path}/${field}: required by target but missing from source`);
+            continue;
+        }
+        const srcProp = sourceProps[field];
+        const tgtProp = targetProps[field];
+        if (tgtProp && srcProp) {
+            checkProperty(srcProp, tgtProp, `${path}/${field}`, issues);
+        }
+    }
+}
+function checkProperty(source, target, path, issues) {
+    // Only flag definite primitive type clashes; skip anyOf/oneOf/allOf
+    if (source.type &&
+        target.type &&
+        typeof source.type === "string" &&
+        typeof target.type === "string" &&
+        source.type !== target.type) {
+        issues.push(`${path}: type mismatch — source is '${source.type}', target expects '${target.type}'`);
+        return;
+    }
+    if (target.type === "object" && source.type === "object") {
+        checkObject(source, target, path, issues);
+    }
+}
+export function formatSingleError(err) {
+    const p = err.instancePath || "/";
+    return `${p} ${err.message ?? "is invalid"}`;
+}
+export function formatAjvErrors(errors) {
+    if (!errors || errors.length === 0)
+        return "Unknown schema error";
+    return errors.map(formatSingleError).join("; ");
+}
+/** Converts an AJV error object to a dotted path string compatible with PositionIndex keys.
+ *  e.g. instancePath "/config/routes/0/handler" → "config.routes[0].handler"
+ *  For "required" keyword errors, appends the missing property to the parent path. */
+function ajvErrorToPath(err) {
+    const instancePath = (err.instancePath ?? "");
+    const parts = instancePath.split("/").filter((p) => p !== "");
+    let result = "";
+    for (const part of parts) {
+        if (/^\d+$/.test(part)) {
+            result += `[${part}]`;
+        }
+        else {
+            result += result ? `.${part}` : part;
+        }
+    }
+    if (err.keyword === "required" && err.params?.missingProperty) {
+        const missing = err.params.missingProperty;
+        result += result ? `.${missing}` : missing;
+    }
+    return result;
+}
+/** Validate actual data against a JSON Schema. Returns issues with path info, or empty array if valid. */
+export function validateAgainstSchema(data, schema) {
+    let validate;
+    try {
+        validate = ajv.compile(schema);
+    }
+    catch {
+        return [];
+    }
+    if (validate(data))
+        return [];
+    return (validate.errors ?? []).map((err) => ({
+        message: formatSingleError(err),
+        path: ajvErrorToPath(err),
+    }));
+}
+/** Resolves a JSON Pointer (RFC 6901, must start with "/") into a schema object.
+ *  Returns undefined when any segment along the path is missing or not an object. */
+export function navigateJsonPointer(schema, pointer) {
+    const segments = pointer.split("/").slice(1); // drop leading empty string from "/"
+    let current = schema;
+    for (const seg of segments) {
+        if (current === null || typeof current !== "object")
+            return undefined;
+        current = current[seg];
+    }
+    return current;
+}
+/** Navigate a JSON Schema following a `walkCelExpressions`-style path
+ *  (e.g. `port`, `routes[0].handler.when`).
+ *  Dot-separated segments navigate `properties`; `[N]` indices navigate `items`.
+ *  Stops and returns the current node when a union type (`anyOf`/`oneOf`) is reached.
+ *  Returns `undefined` if any segment cannot be resolved. */
+export function navigateSchemaToExprPath(schema, path) {
+    if (!path)
+        return schema;
+    let current = schema;
+    for (const part of path.split(".")) {
+        if (!current || typeof current !== "object")
+            return undefined;
+        if (current.anyOf || current.oneOf)
+            return current;
+        const m = part.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\[\d+\])*)$/);
+        if (!m)
+            return undefined;
+        const [, ident, indices] = m;
+        const props = current.properties;
+        if (!props || !(ident in props))
+            return undefined;
+        current = props[ident];
+        if (!current)
+            return undefined;
+        const indexCount = (indices.match(/\[/g) ?? []).length;
+        for (let i = 0; i < indexCount; i++) {
+            if (!current || typeof current !== "object")
+                return undefined;
+            if (current.anyOf || current.oneOf)
+                return current;
+            if (!current.items)
+                return undefined;
+            current = current.items;
+        }
+    }
+    return current;
+}
+/** Map a JSON Schema type annotation to a CEL type string. */
+export function jsonSchemaToCelType(schema) {
+    if (!schema || typeof schema !== "object")
+        return "dyn";
+    if (schema.anyOf || schema.oneOf || schema.allOf)
+        return "dyn";
+    if (Array.isArray(schema.type))
+        return "dyn";
+    switch (schema.type) {
+        case "integer": return "int";
+        case "number": return "double";
+        case "string": return "string";
+        case "boolean": return "bool";
+        case "array": return "list";
+        case "object": return "map";
+        case "null": return "null_type";
+    }
+    if (schema.properties)
+        return "map";
+    if (schema.items)
+        return "list";
+    return "dyn";
+}
+/** Check whether a CEL return type is compatible with a JSON Schema type constraint. */
+export function celTypeSatisfiesJsonSchema(celType, schema) {
+    if (celType === "dyn")
+        return true;
+    if (!schema.type && !schema.anyOf && !schema.oneOf && !schema.allOf)
+        return true;
+    if (schema.anyOf || schema.oneOf || schema.allOf)
+        return true;
+    const schemaTypes = Array.isArray(schema.type) ? schema.type : [schema.type];
+    const accepted = {
+        int: ["integer", "number"],
+        uint: ["integer", "number"],
+        double: ["number"],
+        string: ["string"],
+        bool: ["boolean"],
+        list: ["array"],
+        map: ["object"],
+        null_type: ["null"],
+        timestamp: ["string"],
+        duration: ["string"],
+        bytes: ["string"],
+    };
+    const compatibleWith = accepted[celType];
+    if (!compatibleWith)
+        return true; // unknown CEL type — don't flag
+    return compatibleWith.some((t) => schemaTypes.includes(t));
+}
+/** Return a literal placeholder value of the correct schema type for AJV. */
+export function celPlaceholderForSchema(schema) {
+    if (schema.default !== undefined)
+        return schema.default;
+    switch (schema.type) {
+        case "integer":
+        case "number": return schema.minimum ?? 0;
+        case "string": return "";
+        case "boolean": return false;
+        case "array": return [];
+        case "object": return {};
+        default: return null;
+    }
+}
+const CEL_PURE_RE = /^\s*\$\{\{[^}]*\}\}\s*$/;
+/** Deep-clone `data`, replacing every pure CEL template string (`${{ expr }}`) with a
+ *  schema-appropriate placeholder so AJV can validate non-CEL fields without false positives. */
+export function substituteCelFields(data, schema) {
+    if (typeof data === "string" && CEL_PURE_RE.test(data)) {
+        return celPlaceholderForSchema(schema);
+    }
+    if (Array.isArray(data)) {
+        const itemSchema = (schema.items ?? {});
+        return data.map((item) => substituteCelFields(item, itemSchema));
+    }
+    if (data !== null && typeof data === "object") {
+        const props = (schema.properties ?? {});
+        const addlProps = schema.additionalProperties && typeof schema.additionalProperties === "object"
+            ? schema.additionalProperties
+            : undefined;
+        const result = {};
+        for (const [k, v] of Object.entries(data)) {
+            result[k] = substituteCelFields(v, (props[k] ?? addlProps ?? {}));
+        }
+        return result;
+    }
+    return data;
+}

package/dist/scope-resolver.d.ts

@@ -0,0 +1,5 @@
+/** Evaluate a JSON Path (RFC 9535) expression against a resource config and return the
+ *  string values found. These are the referenced resource names at that call site.
+ *  Returns [] when the path matches nothing or yields non-string values. Never throws. */
+export declare function resolveScope(config: Record<string, any>, scope: string): string[];
+//# sourceMappingURL=scope-resolver.d.ts.map

package/dist/scope-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-resolver.d.ts","sourceRoot":"","sources":["../src/scope-resolver.ts"],"names":[],"mappings":"AAEA;;0FAE0F;AAC1F,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAOjF"}

package/dist/scope-resolver.js

@@ -0,0 +1,13 @@
+import { JSONPath } from "jsonpath-plus";
+/** Evaluate a JSON Path (RFC 9535) expression against a resource config and return the
+ *  string values found. These are the referenced resource names at that call site.
+ *  Returns [] when the path matches nothing or yields non-string values. Never throws. */
+export function resolveScope(config, scope) {
+    try {
+        const results = JSONPath({ path: scope, json: config, resultType: "value" });
+        return results.filter((v) => typeof v === "string");
+    }
+    catch {
+        return [];
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,64 @@
+/** Matches LSP DiagnosticSeverity values exactly.
+ *  https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#diagnosticSeverity */
+export declare const DiagnosticSeverity: {
+    readonly Error: 1;
+    readonly Warning: 2;
+    readonly Information: 3;
+    readonly Hint: 4;
+};
+export type DiagnosticSeverity = (typeof DiagnosticSeverity)[keyof typeof DiagnosticSeverity];
+export interface Position {
+    /** 0-based line number */
+    line: number;
+    /** 0-based character offset */
+    character: number;
+}
+export interface Range {
+    start: Position;
+    end: Position;
+}
+/** Maps a dotted field path (e.g. "config.handler", "kind") to its source Range.
+ *  Built from the YAML AST before conversion to plain objects, so positions reflect
+ *  the actual text locations in the source file. */
+export type PositionIndex = Map<string, Range>;
+/** LSP-compatible Diagnostic shape. range is optional because parsed YAML may not carry
+ *  position info when only the parsed object (not raw text) is available. */
+export interface AnalysisDiagnostic {
+    range?: Range;
+    severity?: DiagnosticSeverity;
+    code?: string | number;
+    /** e.g. "telo-analyzer" */
+    source?: string;
+    message: string;
+    /** Telo-specific extras such as { resource: { kind, name }, path } */
+    data?: unknown;
+}
+export interface ManifestAdapter {
+    supports(url: string): boolean;
+    read(url: string): Promise<{
+        text: string;
+        source: string;
+    }>;
+    resolveRelative(base: string, relative: string): string;
+}
+export interface LoadOptions {
+    /** When true, each YAML document is passed through the CEL precompiler before being
+     *  returned. All `${{ expr }}` template strings are replaced with `CompiledValue` wrappers
+     *  so the kernel can evaluate them at runtime. Leave unset (false) for static analysis —
+     *  the analyzer works on raw strings and does not need compiled values. */
+    compile?: boolean;
+}
+export interface AnalysisOptions {
+    strictContexts?: boolean;
+}
+/** Pre-seeded state for incremental analysis. Passed to StaticAnalyzer.analyze() so it does
+ *  not rebuild from scratch on every call. The provided instances are mutated — new definitions
+ *  and aliases found in the analysed manifests are registered into them. A single context can
+ *  be reused across successive analyze() calls and accumulates state over time, which is the
+ *  intended pattern for browser editors (persistent state across edits) and the kernel (live
+ *  registry updated as resources are registered at runtime). */
+export interface AnalysisContext {
+    aliases?: import("./alias-resolver.js").AliasResolver;
+    definitions?: import("./definition-registry.js").DefinitionRegistry;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;qHACqH;AACrH,eAAO,MAAM,kBAAkB;;;;;CAKrB,CAAC;AACX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE9F,MAAM,WAAW,QAAQ;IACvB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,QAAQ,CAAC;CACf;AAED;;oDAEoD;AACpD,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAE/C;6EAC6E;AAC7E,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,2BAA2B;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7D,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;CACzD;AAED,MAAM,WAAW,WAAW;IAC1B;;;+EAG2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;gEAKgE;AAChE,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,qBAAqB,EAAE,aAAa,CAAC;IACtD,WAAW,CAAC,EAAE,OAAO,0BAA0B,EAAE,kBAAkB,CAAC;CACrE"}

package/dist/types.js

@@ -0,0 +1,8 @@
+/** Matches LSP DiagnosticSeverity values exactly.
+ *  https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#diagnosticSeverity */
+export const DiagnosticSeverity = {
+    Error: 1,
+    Warning: 2,
+    Information: 3,
+    Hint: 4,
+};

package/dist/validate-cel-context.d.ts

@@ -0,0 +1,24 @@
+import type { ASTNode } from "@marcbachmann/cel-js";
+/**
+ * Extract all member-access chains from a CEL AST.
+ * Returns arrays like ["request", "query", "name"] for `request.query.name`.
+ * Chains that start with a call or non-identifier root are ignored.
+ * Bound variables in comprehension macros (filter, map, exists, all, exists_one) are excluded.
+ */
+export declare function extractAccessChains(node: ASTNode): string[][];
+/**
+ * Check whether a member-access chain accesses only fields declared in a JSON Schema.
+ * Returns an error string if a field is unknown in a schema that declares explicit
+ * properties without `additionalProperties: true`.
+ * Returns null when the chain is valid or the schema is too open to judge.
+ */
+export declare function validateChainAgainstSchema(chain: string[], schema: Record<string, any>): string | null;
+/**
+ * Returns true when a CEL expression path (from walkCelExpressions, e.g. "routes[0].handler.inputs.name")
+ * falls within the container region of a context scope (e.g. "$.routes[*].handler").
+ *
+ * The container is derived by stripping the last dot-separated segment from the scope, so that
+ * sibling fields within the same parent (e.g. routes[*].response) also match.
+ */
+export declare function pathMatchesScope(exprPath: string, scope: string): boolean;
+//# sourceMappingURL=validate-cel-context.d.ts.map

package/dist/validate-cel-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-cel-context.d.ts","sourceRoot":"","sources":["../src/validate-cel-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,EAAE,EAAE,CAI7D;AAwED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,MAAM,GAAG,IAAI,CAiBf;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAsBzE"}

package/dist/validate-cel-context.js

@@ -0,0 +1,136 @@
+/**
+ * Extract all member-access chains from a CEL AST.
+ * Returns arrays like ["request", "query", "name"] for `request.query.name`.
+ * Chains that start with a call or non-identifier root are ignored.
+ * Bound variables in comprehension macros (filter, map, exists, all, exists_one) are excluded.
+ */
+export function extractAccessChains(node) {
+    const chains = [];
+    visitNode(node, chains, new Set());
+    return chains;
+}
+// CEL comprehension macros that bind a variable: list.filter(x, ...), list.map(x, ...), etc.
+const COMPREHENSION_METHODS = new Set(["filter", "map", "exists", "all", "exists_one"]);
+function visitNode(node, chains, boundVars) {
+    const chain = extractChain(node, boundVars);
+    if (chain !== null) {
+        chains.push(chain);
+        return; // don't recurse into parts of an already-collected chain
+    }
+    // Comprehension macros bind a variable in their body — handle them specially
+    // AST shape: { op: "rcall", args: [methodName, receiver, [boundVarId, body, ...]] }
+    if (node.op === "rcall" &&
+        Array.isArray(node.args) &&
+        typeof node.args[0] === "string" &&
+        COMPREHENSION_METHODS.has(node.args[0])) {
+        const receiver = node.args[1];
+        const comprehensionArgs = node.args[2];
+        if (isASTNode(receiver))
+            visitNode(receiver, chains, boundVars);
+        if (Array.isArray(comprehensionArgs) &&
+            comprehensionArgs.length >= 2 &&
+            isASTNode(comprehensionArgs[0]) &&
+            comprehensionArgs[0].op === "id") {
+            const newBoundVars = new Set(boundVars);
+            newBoundVars.add(comprehensionArgs[0].args);
+            for (let i = 1; i < comprehensionArgs.length; i++) {
+                const arg = comprehensionArgs[i];
+                if (isASTNode(arg))
+                    visitNode(arg, chains, newBoundVars);
+            }
+        }
+        return;
+    }
+    const args = node.args;
+    if (Array.isArray(args)) {
+        for (const arg of args) {
+            if (isASTNode(arg)) {
+                visitNode(arg, chains, boundVars);
+            }
+            else if (Array.isArray(arg)) {
+                for (const item of arg) {
+                    if (isASTNode(item))
+                        visitNode(item, chains, boundVars);
+                }
+            }
+        }
+    }
+}
+function isASTNode(v) {
+    return v !== null && typeof v === "object" && "op" in v;
+}
+/** Returns the member-access chain for a node if it is purely an id or "." chain; else null. */
+function extractChain(node, boundVars) {
+    if (node.op === "id") {
+        const name = node.args;
+        if (boundVars.has(name))
+            return null; // bound by a comprehension macro, not a free access
+        return [name];
+    }
+    if (node.op === ".") {
+        const [obj, field] = node.args;
+        const parent = extractChain(obj, boundVars);
+        if (parent !== null)
+            return [...parent, field];
+    }
+    return null;
+}
+/**
+ * Check whether a member-access chain accesses only fields declared in a JSON Schema.
+ * Returns an error string if a field is unknown in a schema that declares explicit
+ * properties without `additionalProperties: true`.
+ * Returns null when the chain is valid or the schema is too open to judge.
+ */
+export function validateChainAgainstSchema(chain, schema) {
+    let current = schema;
+    for (let i = 0; i < chain.length; i++) {
+        const key = chain[i];
+        if (!current || typeof current !== "object")
+            return null;
+        // Open schema: no properties declared or explicitly allows additional properties
+        const props = current.properties;
+        if (!props)
+            return null;
+        if (current.additionalProperties === true)
+            return null;
+        if (!(key in props)) {
+            const path = chain.slice(0, i + 1).join(".");
+            const available = Object.keys(props).join(", ");
+            return `'${path}' is not defined (available: ${available})`;
+        }
+        current = props[key];
+    }
+    return null;
+}
+/**
+ * Returns true when a CEL expression path (from walkCelExpressions, e.g. "routes[0].handler.inputs.name")
+ * falls within the container region of a context scope (e.g. "$.routes[*].handler").
+ *
+ * The container is derived by stripping the last dot-separated segment from the scope, so that
+ * sibling fields within the same parent (e.g. routes[*].response) also match.
+ */
+export function pathMatchesScope(exprPath, scope) {
+    const stripped = scope.startsWith("$.") ? scope.slice(2) : scope;
+    const lastDot = stripped.lastIndexOf(".");
+    if (lastDot <= 0)
+        return false;
+    const container = stripped.slice(0, lastDot); // e.g. "routes[*]"
+    // Split on wildcard array segments; each [*] must match a concrete [N] in exprPath
+    const parts = container.split("[*]");
+    let remaining = exprPath;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (!remaining.startsWith(part))
+            return false;
+        remaining = remaining.slice(part.length);
+        if (i < parts.length - 1) {
+            // Expect a concrete array index like [0], [12], ...
+            const m = remaining.match(/^\[\d+\]/);
+            if (!m)
+                return false;
+            remaining = remaining.slice(m[0].length);
+        }
+    }
+    // Expression must end here or continue into a child path
+    return remaining === "" || remaining[0] === "." || remaining[0] === "[";
+}

package/dist/validate-references.d.ts

@@ -0,0 +1,19 @@
+import type { ResourceManifest } from "@telorun/sdk";
+import { type AnalysisDiagnostic, type AnalysisContext } from "./types.js";
+/**
+ * Phase 3 — Reference validation.
+ *
+ * For each x-telo-ref slot in every non-system resource, validates:
+ *   1. Structural — the value has string `kind` and `name` fields.
+ *   2. Kind — the alias-resolved kind satisfies the x-telo-ref constraint
+ *             (abstract: must extend the target; concrete: must equal it exactly).
+ *   3. Resolution — a resource with that name exists in the visible manifest set
+ *                   (outer manifests + scope manifests for in-scope ref paths).
+ *
+ * Ref values with keys beyond kind/name/metadata are treated as inline resources
+ * pending Phase 2 normalization and are skipped without error.
+ *
+ * Returns an empty array when `context.aliases` or `context.definitions` is absent.
+ */
+export declare function validateReferences(resources: ResourceManifest[], context: AnalysisContext): AnalysisDiagnostic[];
+//# sourceMappingURL=validate-references.d.ts.map

package/dist/validate-references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-references.d.ts","sourceRoot":"","sources":["../src/validate-references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrD,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AA6C/F;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,EAAE,eAAe,GACvB,kBAAkB,EAAE,CAoPtB"}