vigiles 2.0.0 → 2.2.0

package/dist/refs.d.ts

@@ -0,0 +1,44 @@
+/** An inline code span with its 1-based source line. */
+export interface Span {
+    readonly text: string;
+    readonly line: number;
+}
+/**
+ * Extract inline code spans, skipping fenced code blocks (R1). Returns each
+ * span's trimmed text and 1-based line.
+ */
+export declare function inlineSpans(markdown: string): Span[];
+/** A parsed file-qualified reference. */
+export interface SymbolRef {
+    readonly file: string;
+    readonly symbol: string;
+    readonly line: number;
+}
+/** A reference that failed verification. */
+export interface SymbolRefError extends SymbolRef {
+    readonly reason: string;
+}
+/** Extract the `vigiles:symbol` references from a markdown file. */
+export declare function symbolRefs(markdown: string): SymbolRef[];
+/**
+ * Verify the file-qualified symbol references in a markdown file: the named
+ * file must exist and define the named symbol. `basePath` is the directory the
+ * paths resolve against (the instruction file's own directory).
+ */
+export declare function verifySymbolRefs(markdown: string, basePath: string): SymbolRefError[];
+/**
+ * Whether a span looks like a *code reference* that ought to carry a
+ * file-qualified mark — a scoped name, or an identifier that isn't a bare
+ * lowercase prose word. A function-call form `` `foo(args)` `` is treated as a
+ * reference to its callee `foo`. Paths/filenames are excluded (they are `file`
+ * refs).
+ */
+export declare function isCodeShaped(text: string): boolean;
+/**
+ * Code-shaped inline references that are NOT yet marked — the spans the
+ * enforcement hook makes the agent mark as `` `vigiles:symbol path.ext#symbol` ``
+ * or opt out of with `<!-- vigiles:ignore -->` (or `<!-- vigiles:ignore-file -->`
+ * for the whole file).
+ */
+export declare function unmarkedCodeRefs(markdown: string): Span[];
+//# sourceMappingURL=refs.d.ts.map

package/dist/refs.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inlineSpans = inlineSpans;
+exports.symbolRefs = symbolRefs;
+exports.verifySymbolRefs = verifySymbolRefs;
+exports.isCodeShaped = isCodeShaped;
+exports.unmarkedCodeRefs = unmarkedCodeRefs;
+/**
+ * vigiles — file-qualified symbol reference verification (variant A).
+ *
+ * A reference names both the file and the symbol, as an inline code span:
+ *
+ *     See `src/config.ts#parseConfig` for the loader.
+ *     Render with `app/models/user.rb#full_name`.
+ *
+ * We parse *that one named file* and check it defines the symbol. No
+ * project-wide index, no cross-file resolution, no autoloader chasing, no
+ * ambiguity (the file disambiguates). Because the `path.ext#symbol` shape is
+ * unmistakable and deliberately written, it is a *declared* reference — like
+ * `vigiles:file` / `vigiles:cmd` — so a broken one is an **error**, not an
+ * inferred-prose warning. The author names the file; vigiles proves the symbol.
+ *
+ * R1 (cross-compat): only inline code spans are read. Fenced code blocks are
+ * never touched, so rustdoc doctests / typescript-docs-verifier keep working.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const symbols_js_1 = require("./symbols.js");
+const FENCE = /^\s*```/;
+const SPAN = /`([^`\n]+)`/g;
+/**
+ * Extract inline code spans, skipping fenced code blocks (R1). Returns each
+ * span's trimmed text and 1-based line.
+ */
+function inlineSpans(markdown) {
+    const spans = [];
+    let inFence = false;
+    const lines = markdown.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        if (FENCE.test(lines[i])) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        for (const m of lines[i].matchAll(SPAN)) {
+            spans.push({ text: m[1].trim(), line: i + 1 });
+        }
+    }
+    return spans;
+}
+// A file-qualified symbol reference: `<path>.<ext>` then `#`/`::` then a symbol.
+// Requires a real file extension before the separator, so a bare scoped symbol
+// An explicit `vigiles:symbol <path>.<ext>#<symbol>` directive inside a code
+// span. The literal `vigiles:symbol` prefix means zero detection heuristic — a
+// span either carries it or it does not — consistent with the rest of vigiles'
+// markers. The mark is self-contained (file + symbol in one inline token), so
+// it binds unambiguously even in a long line with several references.
+const SYMBOL_MARK = /^vigiles:symbol\s+([\w@./-]+\.[A-Za-z0-9]+)(?:#|::)([A-Za-z_]\w*[?!]?)$/;
+/** Extract the `vigiles:symbol` references from a markdown file. */
+function symbolRefs(markdown) {
+    const refs = [];
+    for (const span of inlineSpans(markdown)) {
+        const m = SYMBOL_MARK.exec(span.text);
+        if (m)
+            refs.push({ file: m[1], symbol: m[2], line: span.line });
+    }
+    return refs;
+}
+/**
+ * Verify the file-qualified symbol references in a markdown file: the named
+ * file must exist and define the named symbol. `basePath` is the directory the
+ * paths resolve against (the instruction file's own directory).
+ */
+function verifySymbolRefs(markdown, basePath) {
+    const errors = [];
+    for (const ref of symbolRefs(markdown)) {
+        const full = (0, node_path_1.resolve)(basePath, ref.file);
+        if (!(0, node_fs_1.existsSync)(full)) {
+            errors.push({ ...ref, reason: `File not found: "${ref.file}"` });
+        }
+        else if ((0, symbols_js_1.langForFile)(ref.file) === null) {
+            errors.push({
+                ...ref,
+                reason: `Unsupported language for symbol check: "${ref.file}"`,
+            });
+        }
+        else if (!(0, symbols_js_1.fileDefinesSymbol)(full, ref.symbol)) {
+            errors.push({
+                ...ref,
+                reason: `"${ref.symbol}" is not defined in ${ref.file}`,
+            });
+        }
+    }
+    return errors;
+}
+// ---------------------------------------------------------------------------
+// Enforcement: force code references to carry the file-qualified mark
+// ---------------------------------------------------------------------------
+const PATH_LIKE = /[/\\]|\.[A-Za-z0-9]+$/; // a path or a bare filename
+const PLAIN_ID = /^[A-Za-z_]\w*$/;
+const SCOPED = /^[A-Za-z_]\w*(?:#|::)[\w?!]+$/;
+const IGNORE_FILE = /<!--\s*vigiles:ignore-file\s*-->/;
+const IGNORE_LINE = /<!--\s*vigiles:ignore\s*-->/;
+/**
+ * Whether a span looks like a *code reference* that ought to carry a
+ * file-qualified mark — a scoped name, or an identifier that isn't a bare
+ * lowercase prose word. A function-call form `` `foo(args)` `` is treated as a
+ * reference to its callee `foo`. Paths/filenames are excluded (they are `file`
+ * refs).
+ */
+function isCodeShaped(text) {
+    const callee = text.replace(/\s*\([^)]*\)\s*$/, ""); // `foo(args)` → `foo`
+    if (SCOPED.test(callee))
+        return true;
+    if (!PLAIN_ID.test(callee))
+        return false;
+    const hasUnderscore = callee.includes("_");
+    const hasCamel = /[a-z][A-Z]/.test(callee);
+    const isPascal = /^[A-Z][a-z]/.test(callee);
+    const isScreaming = /^[A-Z][A-Z0-9_]+$/.test(callee);
+    return hasUnderscore || hasCamel || isPascal || isScreaming;
+}
+/**
+ * Code-shaped inline references that are NOT yet marked — the spans the
+ * enforcement hook makes the agent mark as `` `vigiles:symbol path.ext#symbol` ``
+ * or opt out of with `<!-- vigiles:ignore -->` (or `<!-- vigiles:ignore-file -->`
+ * for the whole file).
+ */
+function unmarkedCodeRefs(markdown) {
+    if (IGNORE_FILE.test(markdown))
+        return [];
+    const lines = markdown.split("\n");
+    return inlineSpans(markdown).filter((span) => {
+        if (IGNORE_LINE.test(lines[span.line - 1] ?? ""))
+            return false;
+        if (SYMBOL_MARK.test(span.text))
+            return false; // already a vigiles:symbol mark
+        if (PATH_LIKE.test(span.text))
+            return false; // a path/filename → file ref
+        return isCodeShaped(span.text);
+    });
+}
+//# sourceMappingURL=refs.js.map

package/dist/session.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Post-session audit: analyze what an agent changed vs. what specs expected.
+ *
+ * Compares the git diff (files changed since a base ref) against the spec
+ * surface area (keyFiles, commands, tracked inputs). Reports:
+ * - Files modified that aren't in any spec's keyFiles
+ * - Specs whose inputs changed (may need recompile)
+ *
+ * Read-only analysis. No commands executed, no files modified.
+ */
+import type { SidecarManifest } from "./sidecar.js";
+/**
+ * Get files changed since a base ref (commit, branch, or HEAD~N).
+ * Returns paths relative to the repo root.
+ *
+ * Uses execFileSync with an argv array — `baseRef` is passed as a separate
+ * argument so shell metacharacters can't escape into command execution.
+ * `--no-renames` keeps both source and destination paths visible (without it,
+ * `git mv old.ts new.ts` would only report `new.ts`).
+ *
+ * Throws on git failure (e.g., invalid baseRef) so a typo doesn't silently
+ * masquerade as "no changes" and suppress real findings downstream.
+ */
+export declare function gitChangedFiles(basePath: string, baseRef: string): string[];
+/**
+ * Get the most recent commit hash. Returns null if not a git repo.
+ */
+export declare function gitHead(basePath: string): string | null;
+/**
+ * Find a reasonable base ref for session analysis.
+ *
+ * Strategy:
+ * 1. If `--base` is provided, use it directly.
+ * 2. If sidecar manifests exist, use the most recent compiledAt commit.
+ * 3. Fall back to HEAD (shows only uncommitted changes).
+ */
+export declare function resolveBaseRef(explicitBase?: string): string;
+/** Aggregated surface area from all specs via sidecar manifests. */
+export interface SpecSurface {
+    /** All files declared in any spec's keyFiles. */
+    keyFiles: Set<string>;
+    /** All files tracked as inputs to any spec. */
+    trackedInputs: Set<string>;
+    /** All spec source files. */
+    specFiles: Set<string>;
+    /** All compiled targets. */
+    targets: Set<string>;
+    /** Map: file → which spec targets track it. */
+    fileToSpecs: Map<string, string[]>;
+    /** Loaded manifests. */
+    manifests: SidecarManifest[];
+}
+/**
+ * Load all sidecar manifests and build the aggregate spec surface area.
+ */
+export declare function loadSpecSurface(basePath: string): SpecSurface;
+/**
+ * Load keyFiles from compiled markdown files. Reads each target's
+ * "## Key Files" section and extracts the file paths.
+ */
+export declare function loadKeyFilesFromSpecs(basePath: string): Set<string>;
+/** A finding about a file not tracked by any spec. */
+interface UntrackedFinding {
+    type: "untracked-file";
+    file: string;
+    message: string;
+}
+/** A finding about a file tracked by one or more specs. */
+interface TrackedFinding {
+    type: "stale-spec" | "spec-modified" | "target-modified";
+    file: string;
+    message: string;
+    specs: string[];
+}
+/** A single finding from session analysis. */
+export type SessionFinding = UntrackedFinding | TrackedFinding;
+/** Full session analysis result. */
+export interface SessionReport {
+    /** Git base ref used for comparison. */
+    baseRef: string;
+    /** All files changed since baseRef. */
+    changedFiles: string[];
+    /** Files changed that are tracked by at least one spec. */
+    trackedChanges: string[];
+    /** Files changed that are NOT tracked by any spec. */
+    untrackedChanges: string[];
+    /** Individual findings. */
+    findings: SessionFinding[];
+}
+/**
+ * Analyze a session: compare changed files against spec surface area.
+ */
+export declare function analyzeSession(basePath: string, baseRef: string): SessionReport;
+/** Format a session report as human-readable text. */
+export declare function formatSessionReport(report: SessionReport): string;
+export {};
+//# sourceMappingURL=session.d.ts.map

package/dist/session.js

@@ -0,0 +1,306 @@
+"use strict";
+/**
+ * Post-session audit: analyze what an agent changed vs. what specs expected.
+ *
+ * Compares the git diff (files changed since a base ref) against the spec
+ * surface area (keyFiles, commands, tracked inputs). Reports:
+ * - Files modified that aren't in any spec's keyFiles
+ * - Specs whose inputs changed (may need recompile)
+ *
+ * Read-only analysis. No commands executed, no files modified.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitChangedFiles = gitChangedFiles;
+exports.gitHead = gitHead;
+exports.resolveBaseRef = resolveBaseRef;
+exports.loadSpecSurface = loadSpecSurface;
+exports.loadKeyFilesFromSpecs = loadKeyFilesFromSpecs;
+exports.analyzeSession = analyzeSession;
+exports.formatSessionReport = formatSessionReport;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const sidecar_js_1 = require("./sidecar.js");
+// ---------------------------------------------------------------------------
+// Git helpers
+// ---------------------------------------------------------------------------
+/**
+ * Get files changed since a base ref (commit, branch, or HEAD~N).
+ * Returns paths relative to the repo root.
+ *
+ * Uses execFileSync with an argv array — `baseRef` is passed as a separate
+ * argument so shell metacharacters can't escape into command execution.
+ * `--no-renames` keeps both source and destination paths visible (without it,
+ * `git mv old.ts new.ts` would only report `new.ts`).
+ *
+ * Throws on git failure (e.g., invalid baseRef) so a typo doesn't silently
+ * masquerade as "no changes" and suppress real findings downstream.
+ */
+function gitChangedFiles(basePath, baseRef) {
+    const exec = (args) => (0, node_child_process_1.execFileSync)("git", args, {
+        cwd: basePath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    let diffOutput;
+    try {
+        diffOutput = exec([
+            "diff",
+            "--name-only",
+            "--no-renames",
+            baseRef,
+            "--",
+            ".",
+        ]);
+    }
+    catch (e) {
+        const detail = e instanceof Error ? e.message : String(e);
+        throw new Error(`git diff failed for baseRef "${baseRef}": ${detail}`, {
+            cause: e,
+        });
+    }
+    let untrackedOutput = "";
+    try {
+        untrackedOutput = exec([
+            "ls-files",
+            "--others",
+            "--exclude-standard",
+            "--",
+            ".",
+        ]);
+    }
+    catch {
+        // ls-files failure is non-fatal — diff already succeeded
+    }
+    const files = new Set();
+    if (diffOutput) {
+        for (const f of diffOutput.split("\n"))
+            files.add(f);
+    }
+    if (untrackedOutput) {
+        for (const f of untrackedOutput.split("\n"))
+            files.add(f);
+    }
+    return [...files].sort();
+}
+/**
+ * Get the most recent commit hash. Returns null if not a git repo.
+ */
+function gitHead(basePath) {
+    try {
+        return (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
+            cwd: basePath,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find a reasonable base ref for session analysis.
+ *
+ * Strategy:
+ * 1. If `--base` is provided, use it directly.
+ * 2. If sidecar manifests exist, use the most recent compiledAt commit.
+ * 3. Fall back to HEAD (shows only uncommitted changes).
+ */
+function resolveBaseRef(explicitBase) {
+    if (explicitBase)
+        return explicitBase;
+    return "HEAD";
+}
+/**
+ * Load all sidecar manifests and build the aggregate spec surface area.
+ */
+function loadSpecSurface(basePath) {
+    const surface = {
+        keyFiles: new Set(),
+        trackedInputs: new Set(),
+        specFiles: new Set(),
+        targets: new Set(),
+        fileToSpecs: new Map(),
+        manifests: [],
+    };
+    (0, sidecar_js_1.iterateSidecars)(basePath, (_target, manifest) => {
+        surface.manifests.push(manifest);
+        surface.targets.add(manifest.target);
+        surface.specFiles.add(manifest.specFile);
+        for (const file of Object.keys(manifest.files)) {
+            surface.trackedInputs.add(file);
+            const specs = surface.fileToSpecs.get(file);
+            if (specs) {
+                specs.push(manifest.target);
+            }
+            else {
+                surface.fileToSpecs.set(file, [manifest.target]);
+            }
+        }
+    });
+    return surface;
+}
+/**
+ * Load keyFiles from compiled markdown files. Reads each target's
+ * "## Key Files" section and extracts the file paths.
+ */
+function loadKeyFilesFromSpecs(basePath) {
+    const keyFiles = new Set();
+    (0, sidecar_js_1.iterateSidecars)(basePath, (_target, manifest) => {
+        const targetPath = (0, node_path_1.resolve)(basePath, manifest.target);
+        if (!(0, node_fs_1.existsSync)(targetPath))
+            return;
+        try {
+            // Normalize CRLF → LF so the regex works on Windows checkouts.
+            const content = (0, node_fs_1.readFileSync)(targetPath, "utf-8").replace(/\r\n/g, "\n");
+            const keyFilesMatch = content.match(/## Key Files\n\n((?:- `[^`]+` — .+\n?)+)/);
+            if (keyFilesMatch) {
+                const lines = keyFilesMatch[1].split("\n");
+                for (const line of lines) {
+                    const pathMatch = line.match(/^- `([^`]+)`/);
+                    if (pathMatch)
+                        keyFiles.add(pathMatch[1]);
+                }
+            }
+        }
+        catch {
+            // Skip unreadable files
+        }
+    });
+    return keyFiles;
+}
+/**
+ * Analyze a session: compare changed files against spec surface area.
+ */
+function analyzeSession(basePath, baseRef) {
+    const changedFiles = gitChangedFiles(basePath, baseRef);
+    const surface = loadSpecSurface(basePath);
+    const keyFiles = loadKeyFilesFromSpecs(basePath);
+    const trackedChanges = [];
+    const untrackedChanges = [];
+    const findings = [];
+    for (const file of changedFiles) {
+        const isTracked = surface.trackedInputs.has(file) || keyFiles.has(file);
+        // Treat any *.md.spec.ts as a spec even when sidecars haven't been
+        // written yet — without this, the first compile after `vigiles init`
+        // would silently drop the spec edit from the session report.
+        const isSpec = surface.specFiles.has(file) || file.endsWith(".md.spec.ts");
+        const isTarget = surface.targets.has(file);
+        const affectedSpecs = surface.fileToSpecs.get(file);
+        if (isTarget) {
+            findings.push({
+                type: "target-modified",
+                file,
+                message: `Compiled output modified directly — edit the .spec.ts source instead`,
+                specs: affectedSpecs ?? [],
+            });
+            trackedChanges.push(file);
+        }
+        else if (isSpec) {
+            findings.push({
+                type: "spec-modified",
+                file,
+                message: "Spec modified — run `vigiles compile` to update output",
+                specs: affectedSpecs ?? [],
+            });
+            trackedChanges.push(file);
+        }
+        else if (isTracked) {
+            findings.push({
+                type: "stale-spec",
+                file,
+                message: `Tracked input changed — affected specs may need recompile`,
+                specs: affectedSpecs ?? [],
+            });
+            trackedChanges.push(file);
+        }
+        else if (!file.startsWith(".vigiles/") && !isIgnoredFile(file)) {
+            // Agent modified a file not in any spec
+            untrackedChanges.push(file);
+            findings.push({
+                type: "untracked-file",
+                file,
+                message: "Modified file not tracked by any spec",
+            });
+        }
+    }
+    return {
+        baseRef,
+        changedFiles,
+        trackedChanges,
+        untrackedChanges,
+        findings,
+    };
+}
+/** Files that are always expected to change and shouldn't be flagged. */
+function isIgnoredFile(file) {
+    return (file === "package-lock.json" ||
+        file === "yarn.lock" ||
+        file === "pnpm-lock.yaml" ||
+        file === "bun.lockb" ||
+        file.startsWith("node_modules/") ||
+        file.startsWith("dist/") ||
+        file.startsWith(".git/"));
+}
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+/** Format a session report as human-readable text. */
+function formatSessionReport(report) {
+    if (report.changedFiles.length === 0) {
+        return "No changes detected since " + report.baseRef;
+    }
+    const lines = [];
+    lines.push(`Session analysis (${String(report.changedFiles.length)} files changed since ${report.baseRef}):`);
+    lines.push("");
+    const stale = report.findings.filter((f) => f.type === "stale-spec");
+    const untracked = report.findings.filter((f) => f.type === "untracked-file");
+    const targetMods = report.findings.filter((f) => f.type === "target-modified");
+    const specMods = report.findings.filter((f) => f.type === "spec-modified");
+    if (targetMods.length > 0) {
+        lines.push("  Compiled outputs modified directly:");
+        for (const f of targetMods) {
+            lines.push(`    ${f.file} — edit the .spec.ts source instead`);
+        }
+        lines.push("");
+    }
+    if (specMods.length > 0) {
+        lines.push("  Specs modified:");
+        for (const f of specMods) {
+            lines.push(`    ${f.file} — run vigiles compile`);
+        }
+        lines.push("");
+    }
+    if (stale.length > 0) {
+        lines.push("  Tracked inputs changed (specs may need recompile):");
+        for (const f of stale) {
+            const specList = f.specs.join(", ") || "unknown";
+            lines.push(`    ${f.file} (affects ${specList})`);
+        }
+        lines.push("");
+    }
+    if (untracked.length > 0) {
+        lines.push("  Files not tracked by any spec:");
+        for (const f of untracked) {
+            lines.push(`    ${f.file}`);
+        }
+        lines.push("");
+    }
+    // Summary
+    const issues = targetMods.length + stale.length;
+    if (issues === 0 && untracked.length === 0) {
+        lines.push("  All changes are within spec surface area.");
+    }
+    else {
+        const parts = [];
+        if (targetMods.length > 0)
+            parts.push(`${String(targetMods.length)} compiled output(s) edited directly`);
+        if (stale.length > 0)
+            parts.push(`${String(stale.length)} input(s) changed`);
+        if (untracked.length > 0)
+            parts.push(`${String(untracked.length)} untracked file(s)`);
+        lines.push("  Summary: " + parts.join(", "));
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=session.js.map

package/dist/sidecar.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Per-spec sidecar manifests stored at `.vigiles/<target>.inputs.json`.
+ *
+ * Used by the post-session audit to know which targets exist and which
+ * spec source / inputs each one tracks. The compile pipeline writes
+ * these whenever a spec is built; readers (currently only session.ts)
+ * consume them at audit time.
+ *
+ * This module is the ONLY place sidecars live now — the freshness rule
+ * doesn't depend on them anymore.
+ */
+export interface SidecarManifest {
+    /** The spec source file (relative to basePath). */
+    specFile: string;
+    /** The compilation target (e.g., "CLAUDE.md"). */
+    target: string;
+    /** ISO 8601 timestamp of last compilation. */
+    compiledAt: string;
+    /** Per-file SHA-256 hashes (truncated, 16 hex chars). */
+    files: Record<string, string>;
+}
+export declare function sidecarPath(basePath: string, target: string): string;
+export declare function writeSidecarManifest(basePath: string, manifest: SidecarManifest): void;
+export declare function readSidecarManifest(basePath: string, target: string): SidecarManifest | null;
+export declare function computePerFileHashes(inputFiles: string[], basePath: string): Record<string, string>;
+/**
+ * Iterate all sidecar manifests under `.vigiles/`, including nested
+ * directories. Handles directory-not-found and read errors gracefully.
+ *
+ * Recurses so that nested targets (e.g. `.github/copilot-instructions.md`,
+ * which lives at `.vigiles/.github/copilot-instructions.md.inputs.json`)
+ * are not silently skipped.
+ */
+export declare function iterateSidecars(basePath: string, fn: (target: string, manifest: SidecarManifest) => void): void;
+//# sourceMappingURL=sidecar.d.ts.map