agentera 3.0.0-dev.8 → 3.0.0-dev.80

package/dist/eval/glossaryEvaluationSuccessReport.js

@@ -0,0 +1,297 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveSourceRoot } from "../core/sourceRoot.js";
+import { canonicalDigest, GLOSSARY_EVALUATION_SCHEMA_VERSION, GLOSSARY_METRIC_IDS, glossaryEvaluationAuthorityPath, glossaryEvaluationBehaviorFixturePath, glossaryEvaluationCaseCounts, glossaryEvaluationHoldoutPath, glossaryEvaluationLabelDigest, loadGlossaryEvaluationAuthority, loadGlossaryEvaluationBehaviorFixture, loadGlossaryEvaluationHoldout, mapping, metricRule, sha256, validateFrozenGlossaryBehaviorFixture, validateFrozenGlossaryHoldout, validateGlossaryEvaluationAuthority, wilsonLowerBound, } from "./glossaryEvaluation.js";
+const MAX_SUCCESS_REPORT_UTF8_BYTES = 1_048_576;
+const POLICY_PATH = "references/artifacts/glossary-entry-contract.yaml";
+const SUCCESS_REPORT_FIELDS = [
+    "schemaVersion",
+    "status",
+    "report",
+    "authority",
+    "policy",
+    "holdout",
+    "behavior_fixture",
+    "observations",
+    "metrics",
+    "metrics_sha256",
+    "gates",
+    "denominator_counts",
+];
+function record(value) {
+    return mapping(value);
+}
+function exactFields(value, expected) {
+    const fields = Object.keys(value);
+    return fields.length === expected.length && expected.every((field) => Object.hasOwn(value, field));
+}
+function same(value, expected) {
+    try {
+        return canonicalDigest(value) === canonicalDigest(expected);
+    }
+    catch {
+        return false;
+    }
+}
+function isLowerSha256(value) {
+    return typeof value === "string" && /^[a-f0-9]{64}$/u.test(value);
+}
+function nonNegativeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function positiveInteger(value) {
+    return nonNegativeInteger(value) && value > 0;
+}
+function probability(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function currentBindings(root) {
+    try {
+        const authorityPath = glossaryEvaluationAuthorityPath(root);
+        const holdoutPath = glossaryEvaluationHoldoutPath(root);
+        const behaviorPath = glossaryEvaluationBehaviorFixturePath(root);
+        const authorityBytes = fs.readFileSync(authorityPath);
+        const holdoutBytes = fs.readFileSync(holdoutPath);
+        const behaviorBytes = fs.readFileSync(behaviorPath);
+        const authority = loadGlossaryEvaluationAuthority(root);
+        const holdout = loadGlossaryEvaluationHoldout(root);
+        const behavior = loadGlossaryEvaluationBehaviorFixture(root);
+        if (validateGlossaryEvaluationAuthority(authority).length > 0 ||
+            validateFrozenGlossaryHoldout(authority, holdout, holdoutBytes).length > 0 ||
+            validateFrozenGlossaryBehaviorFixture(authority, holdout, behavior, behaviorBytes).length > 0) {
+            return null;
+        }
+        return {
+            authority,
+            authorityBytes,
+            holdout,
+            holdoutBytes,
+            behavior,
+            behaviorBytes,
+            policyBytes: fs.readFileSync(path.join(root, POLICY_PATH)),
+            holdoutCaseCounts: glossaryEvaluationCaseCounts(holdout),
+            behaviorCaseCounts: glossaryEvaluationCaseCounts(behavior),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function passedMetric(value, expectedMetric, authority) {
+    const source = record(value);
+    if (source === null || source.metric !== expectedMetric)
+        return null;
+    const uncertainty = record(source.uncertainty);
+    const thresholds = record(source.thresholds);
+    const gates = record(source.gates);
+    if (uncertainty === null || thresholds === null || gates === null)
+        return null;
+    const numerator = source.numerator;
+    const denominator = source.denominator;
+    const pointEstimate = source.point_estimate;
+    const lowerBound = uncertainty.lower_bound;
+    const rule = metricRule(authority, expectedMetric);
+    if (!nonNegativeInteger(numerator) ||
+        !positiveInteger(denominator) ||
+        numerator > denominator ||
+        !probability(pointEstimate) ||
+        !probability(lowerBound) ||
+        pointEstimate !== numerator / denominator ||
+        lowerBound !== wilsonLowerBound(numerator, denominator, rule.confidence) ||
+        denominator < rule.minimumSampleSize ||
+        pointEstimate < rule.pointEstimateMinimum ||
+        lowerBound < rule.lowerBoundMinimum ||
+        uncertainty.method !== rule.uncertaintyMethod ||
+        uncertainty.confidence !== rule.confidence ||
+        uncertainty.one_sided !== true ||
+        thresholds.minimum_sample_size !== rule.minimumSampleSize ||
+        thresholds.point_estimate_minimum !== rule.pointEstimateMinimum ||
+        thresholds.lower_bound_minimum !== rule.lowerBoundMinimum ||
+        gates.denominator_nonzero !== true ||
+        gates.sample_sufficient !== true ||
+        gates.point_threshold !== true ||
+        gates.uncertainty_threshold !== true ||
+        source.status !== "pass" ||
+        !Array.isArray(source.failure_reasons) ||
+        source.failure_reasons.length !== 0) {
+        return null;
+    }
+    const metric = {
+        metric: expectedMetric,
+        numerator,
+        denominator,
+        point_estimate: pointEstimate,
+        uncertainty: {
+            method: rule.uncertaintyMethod,
+            confidence: rule.confidence,
+            one_sided: true,
+            lower_bound: lowerBound,
+        },
+        thresholds: {
+            minimum_sample_size: rule.minimumSampleSize,
+            point_estimate_minimum: rule.pointEstimateMinimum,
+            lower_bound_minimum: rule.lowerBoundMinimum,
+        },
+        gates: {
+            denominator_nonzero: true,
+            sample_sufficient: true,
+            point_threshold: true,
+            uncertainty_threshold: true,
+        },
+        status: "pass",
+        failure_reasons: [],
+    };
+    return same(source, metric) ? metric : null;
+}
+function validObservationSeams(value, counts) {
+    const seams = Array.isArray(value) ? value : null;
+    const expected = [
+        ["discovery_recall", "discovery", "mineExplicitGlossaryCandidates", false],
+        ["scope_accuracy", "scope", "mineExplicitGlossaryCandidates", true],
+        ["inferred_review_precision", "inferred_review", "mineRecurringGlossaryCandidates+personalGlossaryDecision.v2", false],
+        ["explicit_admission_precision", "explicit_admission", "mineExplicitGlossaryCandidates+personalGlossaryDecision.v2", false],
+    ];
+    if (seams === null || seams.length !== expected.length)
+        return false;
+    return expected.every(([metric, family, producer, hasAbstentions], index) => {
+        const seam = record(seams[index]);
+        if (seam === null || !exactFields(seam, hasAbstentions
+            ? ["metric", "producer", "cases", "candidates", "abstentions"]
+            : ["metric", "producer", "cases", "candidates"]))
+            return false;
+        const candidates = seam.candidates;
+        const abstentions = seam.abstentions;
+        return seam.metric === metric &&
+            seam.producer === producer &&
+            seam.cases === counts[family] &&
+            nonNegativeInteger(candidates) &&
+            candidates <= counts[family] &&
+            (!hasAbstentions || (nonNegativeInteger(abstentions) &&
+                candidates + abstentions <= counts[family]));
+    });
+}
+function validBindings(source, bindings) {
+    const expectedAuthority = {
+        schema_version: bindings.authority.schema_version,
+        path: "references/analysis/personal-glossary-evaluation-authority.yaml",
+        sha256: sha256(bindings.authorityBytes),
+    };
+    const expectedPolicy = { path: POLICY_PATH, sha256: sha256(bindings.policyBytes) };
+    const expectedHoldout = {
+        id: bindings.holdout.holdout_id,
+        status: bindings.holdout.status,
+        fixture_sha256: sha256(bindings.holdoutBytes),
+        labels_sha256: glossaryEvaluationLabelDigest(bindings.holdout),
+        provenance: bindings.holdout.provenance,
+        case_counts: bindings.holdoutCaseCounts,
+    };
+    const expectedBehavior = {
+        id: bindings.behavior.fixture_id,
+        status: bindings.behavior.status,
+        path: "references/analysis/personal-glossary-evaluation-corpus.yaml",
+        fixture_sha256: sha256(bindings.behaviorBytes),
+        provenance: bindings.behavior.provenance,
+        case_counts: bindings.behaviorCaseCounts,
+    };
+    const observations = record(source.observations);
+    return same(source.authority, expectedAuthority) &&
+        same(source.policy, expectedPolicy) &&
+        same(source.holdout, expectedHoldout) &&
+        same(source.behavior_fixture, expectedBehavior) &&
+        observations !== null &&
+        exactFields(observations, [
+            "schema_version",
+            "source",
+            "sha256",
+            "holdout_fixture_sha256",
+            "behavior_fixture_sha256",
+            "case_counts",
+            "seams",
+            "effects",
+        ]) &&
+        observations.schema_version === "agentera.personalGlossaryEvaluationObservations.v2" &&
+        observations.source === "current_product_behavior" &&
+        isLowerSha256(observations.sha256) &&
+        observations.holdout_fixture_sha256 === expectedHoldout.fixture_sha256 &&
+        observations.behavior_fixture_sha256 === expectedBehavior.fixture_sha256 &&
+        same(observations.case_counts, bindings.holdoutCaseCounts) &&
+        same(observations.effects, []) &&
+        validObservationSeams(observations.seams, bindings.holdoutCaseCounts);
+}
+function validReleaseReport(source, metrics) {
+    const expectedReport = {
+        exploratory: { release_authorizing: false, status: "report_only", metrics },
+        release_gate: {
+            release_authorizing: true,
+            release_authorized: true,
+            status: "pass",
+            failure_reasons: [],
+        },
+    };
+    const expectedGates = {
+        explicit_admission: {
+            metric: "explicit_admission_precision",
+            status: "pass",
+            qualification_blocker: true,
+            outcome: "explicit_automatic_admission_only",
+        },
+        inferred_review: {
+            metric: "inferred_review_precision",
+            status: "pass",
+            outcome: "review_suggestions_only",
+        },
+        inferred_automatic_admission: {
+            status: "disabled",
+            enabled: false,
+            measured_result: "cannot_enable",
+        },
+        release_authorizing: "pass",
+    };
+    const denominatorCounts = Object.fromEntries(metrics.map(({ metric, denominator }) => [metric, denominator]));
+    return same(source.report, expectedReport) &&
+        same(source.gates, expectedGates) &&
+        same(source.denominator_counts, denominatorCounts);
+}
+/**
+ * Accept only the current, complete, successful glossary evaluator report.
+ * This parser reads authority inputs but never imports or runs the evaluator.
+ */
+export function validateGlossaryEvaluationSuccessReport(result, root = resolveSourceRoot()) {
+    if (result.returncode !== 0 || Buffer.byteLength(result.stdout, "utf8") > MAX_SUCCESS_REPORT_UTF8_BYTES) {
+        return null;
+    }
+    let source;
+    try {
+        source = record(JSON.parse(result.stdout));
+    }
+    catch {
+        return null;
+    }
+    if (source === null ||
+        !exactFields(source, SUCCESS_REPORT_FIELDS) ||
+        source.schemaVersion !== GLOSSARY_EVALUATION_SCHEMA_VERSION ||
+        source.status !== "pass") {
+        return null;
+    }
+    const bindings = currentBindings(root);
+    if (bindings === null || !validBindings(source, bindings))
+        return null;
+    const sourceMetrics = source.metrics;
+    if (!Array.isArray(sourceMetrics) || sourceMetrics.length !== GLOSSARY_METRIC_IDS.length)
+        return null;
+    const metrics = [];
+    for (const [index, metric] of GLOSSARY_METRIC_IDS.entries()) {
+        const passed = passedMetric(sourceMetrics[index], metric, bindings.authority);
+        if (passed === null)
+            return null;
+        metrics.push(passed);
+    }
+    const metricsSha256 = source.metrics_sha256;
+    if (!isLowerSha256(metricsSha256) ||
+        metricsSha256 !== canonicalDigest(metrics) ||
+        canonicalDigest(sourceMetrics) !== canonicalDigest(metrics) ||
+        !validReleaseReport(source, metrics)) {
+        return null;
+    }
+    return { metrics, metrics_sha256: metricsSha256 };
+}

package/dist/eval/hybridRouteEvaluation.js

@@ -0,0 +1,155 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { loadYamlMapping } from "../core/yaml.js";
+import { resolveSourceRoot } from "../core/sourceRoot.js";
+import { resolveRouteRequest } from "../registries/hybridRoute.js";
+import { validateRouteReceiptSubmission } from "../registries/hybridRouteReceipt.js";
+function mapping(value, source) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${source} must be a mapping`);
+    return value;
+}
+function requiredString(value, source) {
+    if (typeof value !== "string" || !value)
+        throw new Error(`${source} must be a non-empty string`);
+    return value;
+}
+function cases(value, source) {
+    if (!Array.isArray(value))
+        throw new Error(`${source} must be a list`);
+    return value;
+}
+function elapsedMs(start) {
+    return Number(process.hrtime.bigint() - start) / 1_000_000;
+}
+function percentile(values) {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((left, right) => left - right);
+    return sorted[Math.ceil(sorted.length * 0.95) - 1];
+}
+function hashFile(file) {
+    return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+function nullableFixtureReceipt(receipt) {
+    return {
+        version: null,
+        request_sha256: null,
+        semantic_capsule_sha256: null,
+        outcome: null,
+        capability: null,
+        compound: null,
+        question: null,
+        remainder_span: null,
+        ...receipt,
+    };
+}
+/** Runs the complete frozen synthetic conformance corpus without invoking a semantic host. */
+export function evaluateHybridRoute(sourceRoot = resolveSourceRoot()) {
+    const contractPath = path.join(sourceRoot, "references/cli/hybrid-route-contract.yaml");
+    const corpusPath = path.join(sourceRoot, "fixtures/routing/hybrid-corpus.yaml");
+    const phrasePath = path.join(sourceRoot, "skills/agentera/route-phrases.yaml");
+    const skillPath = path.join(sourceRoot, "skills/agentera/SKILL.md");
+    const contract = loadYamlMapping(fs.readFileSync(contractPath, "utf8"));
+    const corpus = loadYamlMapping(fs.readFileSync(corpusPath, "utf8"));
+    const evaluation = mapping(contract.evaluation, "contract.evaluation");
+    const targetGates = mapping(evaluation.target_gates, "contract.evaluation.target_gates");
+    const routeCases = cases(corpus.route_cases, "corpus.route_cases");
+    const receiptCases = cases(corpus.receipt_cases, "corpus.receipt_cases");
+    const results = [];
+    const deterministicTimings = [];
+    const receiptTimings = [];
+    for (const routeCase of routeCases) {
+        const start = process.hrtime.bigint();
+        const observed = resolveRouteRequest(routeCase.request, sourceRoot);
+        const elapsed = elapsedMs(start);
+        deterministicTimings.push(elapsed);
+        const passed = observed.outcome === routeCase.expected.phase1
+            && (observed.outcome !== "deterministic_selection" || (observed.tier === routeCase.expected.tier && observed.capability === routeCase.expected.capability));
+        const harmfulMisroute = observed.outcome === "deterministic_selection"
+            && (routeCase.expected.phase1 !== "deterministic_selection" || observed.capability !== routeCase.expected.capability);
+        results.push({
+            case_id: routeCase.id,
+            partition: routeCase.partition,
+            evaluation_tier: "deterministic",
+            routing_tier: observed.outcome === "deterministic_selection" ? observed.tier : "deterministic_abstention",
+            expected_outcome: routeCase.expected.phase1,
+            observed_outcome: observed.outcome,
+            ...(observed.outcome === "deterministic_selection" ? { capability: observed.capability } : {}),
+            status: passed ? "pass" : "fail",
+            ...(passed ? {} : { failure_tier: "deterministic" }),
+            harmful_misroute: harmfulMisroute,
+            elapsed_ms: elapsed,
+        });
+    }
+    for (const receiptCase of receiptCases) {
+        const start = process.hrtime.bigint();
+        let terminal = "invalid_receipt";
+        try {
+            const receipt = receiptCase.valid ? nullableFixtureReceipt(receiptCase.receipt) : receiptCase.receipt;
+            terminal = validateRouteReceiptSubmission({ request: receiptCase.request, receipt }, sourceRoot).outcome;
+        }
+        catch {
+            terminal = "invalid_receipt";
+        }
+        const elapsed = elapsedMs(start);
+        receiptTimings.push(elapsed);
+        const passed = terminal === receiptCase.expected_terminal;
+        const harmfulMisroute = terminal === "selected" && receiptCase.expected_terminal !== "selected";
+        results.push({
+            case_id: receiptCase.id,
+            partition: receiptCase.partition,
+            evaluation_tier: "receipt_validation",
+            routing_tier: "semantic_receipt_validation",
+            expected_outcome: receiptCase.expected_terminal,
+            observed_outcome: terminal,
+            status: passed ? "pass" : "fail",
+            ...(passed ? {} : { failure_tier: "receipt_validation" }),
+            harmful_misroute: harmfulMisroute,
+            elapsed_ms: elapsed,
+        });
+    }
+    const failed = results.filter(({ status }) => status === "fail");
+    const harmfulMisroutes = results.filter((result) => result.harmful_misroute === true).length;
+    return {
+        schemaVersion: "agentera.hybrid_route_evaluation.v1",
+        status: failed.length === 0 ? "pass" : "fail",
+        authority: {
+            contract_version: requiredString(contract.schema_version, "contract.schema_version"),
+            protocol_sha256: hashFile(contractPath),
+            phrase_authority_sha256: hashFile(phrasePath),
+            shared_skill_sha256: hashFile(skillPath),
+        },
+        corpus: {
+            schema_version: requiredString(corpus.schema_version, "corpus.schema_version"),
+            content_sha256: hashFile(corpusPath),
+            partitions: corpus.partitions,
+            case_count: results.length,
+        },
+        results,
+        aggregate_metrics: {
+            passed: results.length - failed.length,
+            failed: failed.length,
+            harmful_misroutes: {
+                scope: "deterministic_and_receipt_validation_conformance",
+                target: targetGates.harmful_misroutes,
+                observed: harmfulMisroutes,
+                status: harmfulMisroutes === 0 ? "pass" : "fail",
+                taxonomy: evaluation.harmful_misroute_taxonomy,
+            },
+        },
+        model_context: {
+            status: "unmeasured",
+            reason: "host_dependent",
+            samples: 0,
+            distributions: {},
+        },
+        latency: {
+            deterministic_phase1: { sample_count: deterministicTimings.length, p95_ms: percentile(deterministicTimings), target: targetGates.deterministic_phase1_p95 },
+            receipt_validation: { sample_count: receiptTimings.length, p95_ms: percentile(receiptTimings), target: targetGates.receipt_validation_p95 },
+            semantic_model: { status: "unmeasured", reason: "host_dependent" },
+            end_to_end: { status: "unmeasured", reason: "host_dependent" },
+        },
+    };
+}

package/dist/eval/semanticEval.js

@@ -169,4 +169,3 @@ export function main(argv = [], out = (l) => process.stdout.write(l)) {
     out(pyJsonIndent(report) + "\n");
     return report.status === "pass" ? 0 : 1;
 }
-//# sourceMappingURL=semanticEval.js.map

package/dist/eval/semanticFixtures.js

@@ -236,4 +236,3 @@ export function pyRepr(value) {
     }
     return "'" + value.replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'";
 }
-//# sourceMappingURL=semanticFixtures.js.map

package/dist/hooks/common.js

@@ -1,19 +1,13 @@
-import crypto from "node:crypto";
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
-import { expanduser, resolvePath } from "../core/paths.js";
 import { ARTIFACT_PROTOCOL_PATHS, normalizeArtifactMappingKeys, normalizeArtifactProtocolId, } from "../registries/artifactProtocolIds.js";
-import { resolveCandidate } from "../state/installRoot.js";
 /**
- * Shared utilities for agentera hooks. Faithful TS port of hooks/common.py:
- * compaction retention caps, runtime-local session bookmark paths, and artifact
- * path resolution.
+ * Shared utilities for compaction retention caps and artifact path resolution.
  */
 export { loadYamlMapping, loadYamlMappingFile, } from "../core/yaml.js";
 export const MAX_FULL_ENTRIES = 10;
 export const MAX_ONELINE_ENTRIES = 40;
-export const MAX_TOTAL_ENTRIES = MAX_FULL_ENTRIES + MAX_ONELINE_ENTRIES;
+export const MAX_TOTAL_ENTRIES = 50;
 export function applyRetentionCaps(fullEntries, archiveEntries, opts = {}) {
     const maxFull = opts.maxFull ?? MAX_FULL_ENTRIES;
     const maxOneline = opts.maxOneline ?? MAX_ONELINE_ENTRIES;
@@ -21,52 +15,6 @@ export function applyRetentionCaps(fullEntries, archiveEntries, opts = {}) {
     const cappedArchive = archiveEntries.slice(0, maxOneline);
     return [...fullEntries.slice(0, maxFull), ...cappedArchive].slice(0, maxTotal);
 }
-export function resolveAgenteraDataHome(env = process.env, home = os.homedir()) {
-    const configured = env.AGENTERA_HOME;
-    if (configured) {
-        return expanduser(configured);
-    }
-    const [root] = resolveCandidate(null, { env, home });
-    return root;
-}
-export function resolveSessionPath(projectRoot, env = process.env, home = os.homedir()) {
-    const dataHome = resolveAgenteraDataHome(env, home);
-    const resolved = resolvePath(projectRoot);
-    const digest = crypto.createHash("sha256").update(resolved, "utf8").digest("hex").slice(0, 16);
-    const name = path.basename(projectRoot);
-    const slug = name.replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^[.-]+|[.-]+$/g, "") || "project";
-    return path.join(dataHome, "sessions", `${slug}-${digest}`, "session.yaml");
-}
-export function sessionBookmarkToOneline(entry) {
-    return {
-        timestamp: String(entry.timestamp ?? ""),
-        artifacts: [],
-        summary: String(entry.summary ?? ""),
-        kind: "oneline",
-    };
-}
-export function compactSessionBookmarkEntries(entries, opts = {}) {
-    const maxFull = opts.maxFull ?? MAX_FULL_ENTRIES;
-    const maxOneline = opts.maxOneline ?? MAX_ONELINE_ENTRIES;
-    const maxTotal = opts.maxTotal ?? MAX_TOTAL_ENTRIES;
-    const convert = opts.toOneline ?? sessionBookmarkToOneline;
-    const ordered = [...entries].sort((a, b) => {
-        const ta = String(a.timestamp ?? "");
-        const tb = String(b.timestamp ?? "");
-        return ta < tb ? 1 : ta > tb ? -1 : 0;
-    });
-    const full = [];
-    const archive = [];
-    for (const entry of ordered) {
-        if (entry.kind === "full" && full.length < maxFull) {
-            full.push(entry);
-        }
-        else {
-            archive.push(convert(entry));
-        }
-    }
-    return applyRetentionCaps(full, archive, { maxFull, maxOneline, maxTotal });
-}
 export const DEFAULT_ARTIFACT_PATHS = { ...ARTIFACT_PROTOCOL_PATHS };
 function stripQuotes(value) {
     return value.replace(/^['"]|['"]$/g, "");
@@ -131,7 +79,7 @@ export function resolveArtifactPath(projectRoot, artifact, overrides = null) {
     return path.join(projectRoot, DEFAULT_ARTIFACT_PATHS[artifactId] ?? `.agentera/${artifactId}.yaml`);
 }
 export function loadArtifactOverrides(projectRoot) {
-    const yamlPath = path.join(projectRoot, ".agentera", "docs.yaml");
+    const yamlPath = path.join(projectRoot, ARTIFACT_PROTOCOL_PATHS.docs);
     if (fs.existsSync(yamlPath)) {
         const mapping = parseDocsYamlMapping(fs.readFileSync(yamlPath, "utf8"));
         if (Object.keys(mapping).length > 0) {
@@ -140,4 +88,3 @@ export function loadArtifactOverrides(projectRoot) {
     }
     return null;
 }
-//# sourceMappingURL=common.js.map