@hawkeyexl/manni 4.5.0 → 4.7.0

package/dist/{chunk-HQFVJDEN.js → chunk-QQNPVW3J.js}

@@ -22,29 +22,27 @@ import {
   runRelocate,
   runVendorSchema,
   terminalConfirm
-} from "./chunk-QCBICNKC.js";
-import {
-  collect,
-  configOption,
-  explicitFalse,
-  readStdin,
-  reportConfig,
-  rowsToFindings,
-  runValidate,
-  splitList
-} from "./chunk-NAZRLJAK.js";
+} from "./chunk-CR3HZERW.js";
 import {
   LOCATION_EXTERNAL_SCHEMA,
   LOCATION_PAGE_SCHEMA,
   Validator,
   applyRelocation,
+  collect,
+  configOption,
+  explicitFalse,
   isParamName,
   keyHome,
   offerPrompt,
   planRelocation,
+  readStdin,
   relocateFailed,
-  relocationContext
-} from "./chunk-HVFR66GQ.js";
+  relocationContext,
+  reportConfig,
+  rowsToFindings,
+  runValidate,
+  splitList
+} from "./chunk-5UB47BEV.js";
 import {
   COMMON_FORMATS,
   COMMON_FORMAT_LIST,
@@ -60,7 +58,7 @@ import {
   isQueryFormat,
   isReportFormat,
   render
-} from "./chunk-TCC737IS.js";
+} from "./chunk-5VWDIWOH.js";
 import {
   DocmetaError,
   STDIN_LABEL,
@@ -70,7 +68,7 @@ import {
   schemaLoadOptions,
   supportedExtensions,
   toJsonText
-} from "./chunk-527HHQPS.js";
+} from "./chunk-MSMB6XOS.js";
 import {
   fail
 } from "./chunk-YEUYKR62.js";
@@ -79,13 +77,15 @@ import {
   shouldColor
 } from "./chunk-RNVYGWIC.js";
 import {
-  LOCAL_FLAG_HELP,
   notice,
   warn
-} from "./chunk-Q35YIDBV.js";
+} from "./chunk-HX44GB4Z.js";
+import {
+  LOCAL_FLAG_HELP
+} from "./chunk-QCHVR4ZM.js";
 import {
   package_default
-} from "./chunk-6XTQDFGP.js";
+} from "./chunk-YSCZL4U5.js";
 import {
   programName
 } from "./chunk-OWBRDNRZ.js";
@@ -1523,4 +1523,4 @@ export {
   parseQueryParams,
   buildProgram
 };
-//# sourceMappingURL=chunk-HQFVJDEN.js.map
+//# sourceMappingURL=chunk-QQNPVW3J.js.map

package/dist/chunk-TPVOOTMN.js

@@ -0,0 +1,532 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_CAPTURE_DIR,
+  compileRedactPatterns
+} from "./chunk-CU57HT2E.js";
+import {
+  JEV,
+  JEV_OUT_OF_LOOP
+} from "./chunk-BWCWTHYS.js";
+import {
+  TracevalsError
+} from "./chunk-UKZNLVJW.js";
+import {
+  EXECUTION_GRANTS,
+  configuredGrants,
+  isExecutionGrant,
+  unknownGrantsMessage
+} from "./chunk-YNHZHSSM.js";
+import {
+  FAMILY_CONFIG_NAMES,
+  findConfigFileSync,
+  readConfigFileSync
+} from "./chunk-XKBEHKWO.js";
+import {
+  assertKnownProvider
+} from "./chunk-QCHVR4ZM.js";
+import {
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+
+// src/tracevals/core/config.ts
+import { Ajv2020 as Ajv20202 } from "ajv/dist/2020.js";
+
+// src/tracevals/core/config-schema.json
+var config_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "manni:tracevals:config",
+  title: "tracevals section of manni.config.yaml",
+  description: "Settings for manni tracevals, held under the `tracevals` key of the config file shared by the manni family of tools. Sibling keys belong to other tools and are not validated here.",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    provider: {
+      type: "string",
+      minLength: 1,
+      description: "Which provider judges out of the loop, and extracts rules: auto, anthropic, openai, claude-cli, or llama-cpp. jev only decides, so it is refused here; name it as conformance.hook.provider. Overrides the family's top-level `providers.provider` for tracevals only. Connection settings \u2014 an endpoint, an API key's environment variable, the Claude CLI command \u2014 live in that top-level `providers:` map, never here."
+    },
+    model: {
+      type: "string",
+      minLength: 1,
+      description: "The model within `provider`, which must be named at this level. Unset, the inference library's default for the winning provider is used; manni pins no model id of its own."
+    },
+    judge: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        ensembleRuns: { type: "integer", minimum: 1 },
+        temperature: { type: "number", minimum: 0, maximum: 2 },
+        zones: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            autoPass: { type: "number", minimum: 0, maximum: 1 },
+            autoFail: { type: "number", minimum: 0, maximum: 1 }
+          }
+        },
+        cacheDir: { type: "string" },
+        maxTurns: { type: "integer", minimum: 1, description: "Stop after this many ensemble runs. A cached ensemble spends none. Unset means unbounded; the remaining evals report `skipped` with the reason `turn budget` rather than aborting the run." },
+        redact: {
+          type: "array",
+          description: "Extra regular expressions scrubbed from the session digest before it is sent to a judge provider. Applied on top of the built-in secret shapes, never instead of them; each source is compiled with the `g` flag, and a match is replaced with `[redacted]`. Pattern matching is best-effort \u2014 --deterministic-only is the only setting that guarantees nothing leaves the machine.",
+          items: { type: "string", minLength: 1 }
+        }
+      }
+    },
+    execution: {
+      type: "object",
+      additionalProperties: false,
+      description: "Operator grant for executing content-authored code.",
+      properties: {
+        allow: {
+          type: "array",
+          items: { enum: ["frontmatter-commands"] },
+          default: ["frontmatter-commands"],
+          description: "Which content-authored code a run may execute. Absent, every grant holds; list fewer to narrow it, or write [] to run none. frontmatter-commands lets `command` evals declared in an artifact's front matter run; without it they report `skipped` with a reason, never `pass`."
+        }
+      }
+    },
+    render: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        maxBlockChars: { type: "integer", minimum: 100 },
+        maxTotalChars: {
+          type: "integer",
+          minimum: 1e3,
+          description: "Upper bound on the rendered digest, in characters. The timeline always keeps at least 200 characters, so a very long header can push the digest past this bound by up to 200."
+        }
+      }
+    },
+    history: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        file: { type: "string" }
+      }
+    },
+    capture: {
+      type: "object",
+      additionalProperties: false,
+      description: "Session manifests \u2014 sha256 of every instruction artifact plus the git SHA, recorded at session start by `manni tracevals capture` and read back by `run` to make staleness exact instead of an mtime guess. See ADR 01024.",
+      properties: {
+        dir: {
+          type: "string",
+          minLength: 1,
+          description: "Directory manifests are written to and looked for, resolved against the project root. `run` also accepts one placed beside the trace as `<trace>.manifest.json`, and --manifest names one outright."
+        }
+      }
+    },
+    fill: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        confidenceThreshold: { type: "number", minimum: 0, maximum: 1 },
+        maxEvalsPerArtifact: { type: "integer", minimum: 1 },
+        temperature: { type: "number", minimum: 0, maximum: 2 },
+        cacheDir: { type: "string" },
+        maxTurns: { type: "integer", minimum: 1, description: "Stop after this many inference calls, one per artifact filled. A cached artifact spends none. Unset means unbounded." }
+      }
+    },
+    calibrate: {
+      type: "object",
+      additionalProperties: false,
+      description: "Settings for `manni tracevals calibrate` \u2014 measuring the tool's verdicts against a human's answers. See ADR 01022.",
+      properties: {
+        labels: {
+          type: "string",
+          minLength: 1,
+          description: "Default labels sidecar, resolved against this config file's directory. Overridden by --labels."
+        },
+        maxFalsePass: {
+          type: "integer",
+          minimum: 0,
+          description: "Fail the calibration run (exit 1) above this many false passes \u2014 labelled fail, judged pass. Unset by default: a calibration run is a measurement, not a gate."
+        },
+        maxFalseFail: {
+          type: "integer",
+          minimum: 0,
+          description: "Fail the calibration run above this many false fails \u2014 labelled pass, judged fail."
+        },
+        maxReview: {
+          type: "integer",
+          minimum: 0,
+          description: "Fail the calibration run above this many needs-review outcomes across the whole corpus."
+        },
+        sweep: {
+          type: "object",
+          additionalProperties: false,
+          description: "Values --sweep tries on each axis, one axis at a time with the others held at their configured value. The corpus is judged once at the largest ensembleRuns here and every cell is re-scored from those cached runs, so the grid costs nothing beyond that one run.",
+          properties: {
+            ensembleRuns: {
+              type: "array",
+              minItems: 1,
+              items: { type: "integer", minimum: 1 }
+            },
+            autoPass: {
+              type: "array",
+              minItems: 1,
+              items: { type: "number", minimum: 0, maximum: 1 }
+            },
+            autoFail: {
+              type: "array",
+              minItems: 1,
+              items: { type: "number", minimum: 0, maximum: 1 }
+            }
+          }
+        }
+      }
+    },
+    conformance: {
+      type: "object",
+      additionalProperties: false,
+      description: "Checking each turn against the rules the files that govern the agent declare. Present, even as {}, it puts tracevals in play under Claude Code hooks; absent, tracevals stays out of them.",
+      properties: {
+        hook: {
+          type: "object",
+          additionalProperties: false,
+          description: "The judge inside a Stop or SubagentStop hook. Each key falls back to the top-level one of the same name.",
+          properties: {
+            provider: {
+              type: "string",
+              minLength: 1,
+              description: "The provider that judges inside a hook. Default: tracevals.provider. jev is accepted here, and only here."
+            },
+            model: {
+              type: "string",
+              minLength: 1,
+              description: "The model that judges inside a hook. Default: tracevals.model."
+            },
+            runs: {
+              type: "integer",
+              minimum: 1,
+              description: "Judge calls per rule inside a hook. A rule blocks only when every run scores it not followed at the bar. jev makes one call and ignores it. Default 1."
+            }
+          }
+        },
+        include: {
+          type: "array",
+          description: "Globs, relative to the project root, naming files that govern agents beyond the known formats. Each applies to every turn.",
+          items: { type: "string", minLength: 1 }
+        },
+        exclude: {
+          type: "array",
+          description: "Globs, relative to the project root, naming files never treated as rule sources, in any format. It removes plan, spec and output style files too. It also matches the sources `prompt`, `plan` and `system-prompt` by name.",
+          items: { type: "string", minLength: 1 }
+        },
+        plans: {
+          type: "array",
+          default: [],
+          description: "Globs, relative to the project root, naming files that say what to build, beyond the known spec formats. Each is a rule source once the session touches it.",
+          items: { type: "string", minLength: 1 }
+        }
+      }
+    },
+    failOnReview: { type: "boolean" },
+    plugins: {
+      type: "array",
+      description: "Modules imported before evals are planned, so one calling registerGrader() can add a grader kind the built-ins do not cover. A relative or absolute path resolves against this file's directory, not the working directory; a bare package name resolves the way an import from this file's directory would. Load order is significant: a later entry wins a colliding kind.",
+      items: { type: "string", minLength: 1 }
+    },
+    reportUnusedArtifacts: {
+      type: "boolean",
+      description: "List every skill and agent the session was offered and never used, rather than only counting them. Off by default: a real roster runs to hundreds of skills."
+    }
+  }
+};
+
+// src/tracevals/calibrate/labels.ts
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { parse as parseYaml } from "yaml";
+
+// src/tracevals/calibrate/labels-schema.json
+var labels_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "manni:tracevals:calibration-labels",
+  title: "manni tracevals calibration labels",
+  description: "Ground truth for `manni tracevals calibrate`: what a human decided a given eval should have produced on a given trace. A sidecar rather than an eval field, because a label belongs to a corpus and a reviewer, not to the artifact \u2014 and because the eval vocabulary is docmeta's, vendored byte-identical, with `inlineEval` closed to additions (ADR 01010).",
+  type: "object",
+  additionalProperties: false,
+  required: ["version", "labels"],
+  properties: {
+    version: {
+      const: 1,
+      description: "Format version. Pinned so a future shape change is an explicit migration rather than a silently-reinterpreted file."
+    },
+    labels: {
+      type: "array",
+      minItems: 1,
+      description: "One entry per (trace, artifact, eval) you have judged by hand.",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["trace", "artifact", "eval", "expected"],
+        properties: {
+          trace: {
+            type: "string",
+            minLength: 1,
+            description: "Path to the trace file, resolved against this file's own directory \u2014 not the working directory."
+          },
+          artifact: {
+            type: "string",
+            minLength: 1,
+            description: "Artifact name as the report shows it: a skill name, a subagent_type, or a project-rules filename such as CLAUDE.md."
+          },
+          type: {
+            enum: ["skill", "agent", "project-rules", "slash-command"],
+            description: "Optional disambiguator, needed when one name resolves to two kinds of artifact \u2014 a skill and an agent, or a skill and the slash command that types it. Every `ArtifactType` the resolver can produce belongs here: a label whose type this rejects has no way to name the artifact it means."
+          },
+          eval: {
+            type: "string",
+            minLength: 1,
+            description: "The eval's id. Shorthand entries with no declared id get a positional one (eval-1, eval-2, ...), so labelling those is only as stable as the order they are written in."
+          },
+          expected: {
+            enum: ["pass", "fail", "needs-review"],
+            description: "What you decided. `needs-review` means you found it genuinely ambiguous and want the tool to defer too."
+          },
+          note: {
+            type: "string",
+            description: "Why you decided that. Carried into the disagreement report, where it is the whole reason a disagreement is actionable."
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/tracevals/calibrate/labels.ts
+var labelsSchema = labels_schema_default;
+var DEFAULT_LABELS_FILE = "tracevals/labels.yaml";
+var ajv = new Ajv2020({ allErrors: true });
+var validate = ajv.compile(labelsSchema);
+var labelKey = (traceFile, artifact, evalName, type) => `${traceFile}\0${type ?? ""}\0${artifact}\0${evalName}`;
+function parseLabels(text, file) {
+  let raw;
+  try {
+    raw = parseYaml(text);
+  } catch (err) {
+    throw new TracevalsError(
+      `could not parse ${file}: ${errorMessage(err)}`
+    );
+  }
+  if (raw === null || raw === void 0) {
+    throw new TracevalsError(`invalid labels file ${file}: it is empty`);
+  }
+  if (!validate(raw)) {
+    const detail = (validate.errors ?? []).map((e) => `${e.instancePath || "/"} ${e.message ?? "invalid"}`).join("; ");
+    const empty = (validate.errors ?? []).some(
+      (e) => e.instancePath === "/labels" && e.keyword === "minItems"
+    );
+    throw new TracevalsError(
+      empty ? `invalid labels file ${file}: it must carry at least one label \u2014 an empty one measures nothing` : `invalid labels file ${file}: ${detail}`
+    );
+  }
+  const base = dirname(resolve(file));
+  const labels = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of raw.labels) {
+    const traceFile = resolve(base, entry.trace);
+    const type = entry.type;
+    const key = labelKey(
+      traceFile,
+      entry.artifact,
+      entry.eval,
+      type
+    );
+    if (seen.has(key)) {
+      throw new TracevalsError(
+        `invalid labels file ${file}: duplicate label for ${entry.artifact ?? "?"} \u203A ${entry.eval ?? "?"} on ${entry.trace ?? "?"}`
+      );
+    }
+    seen.add(key);
+    labels.push({
+      trace: entry.trace,
+      traceFile,
+      artifact: entry.artifact,
+      ...type !== void 0 ? { type } : {},
+      eval: entry.eval,
+      expected: entry.expected,
+      ...entry.note !== void 0 ? { note: entry.note } : {}
+    });
+  }
+  return labels;
+}
+async function loadLabels(file) {
+  let text;
+  try {
+    text = await readFile(file, "utf-8");
+  } catch (err) {
+    throw new TracevalsError(
+      `could not read labels file ${file}: ${errorMessage(err)}`
+    );
+  }
+  return parseLabels(text, file);
+}
+
+// src/tracevals/core/config.ts
+var configSchema = config_schema_default;
+var DEFAULT_CONFIG_FILENAME = FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml";
+var CONFIG_SECTION_KEY = "tracevals";
+var CONFIG_SECTION_KEY_PATH = `/${CONFIG_SECTION_KEY}`;
+var CONFIG_FILE = {
+  section: CONFIG_SECTION_KEY,
+  legacyNames: [],
+  toError: (message) => new TracevalsError(message)
+};
+var ajv2 = new Ajv20202({ allErrors: true, verbose: true });
+var validate2 = ajv2.compile(configSchema);
+function camelCaseHint(key, parentSchema) {
+  const camel = key.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+  if (camel === key || parentSchema === null || typeof parentSchema !== "object") {
+    return "";
+  }
+  const properties = parentSchema.properties;
+  return properties !== null && typeof properties === "object" && Object.hasOwn(properties, camel) ? `; did you mean "${camel}"?` : "";
+}
+function movedProviderHint(instancePath, keyword) {
+  return instancePath === "/provider" && keyword === "type" ? `; "provider" is now a provider name; per-provider settings moved to the top-level providers: map` : "";
+}
+function parseConfig(raw, file = {}) {
+  const source = file.source ?? DEFAULT_CONFIG_FILENAME;
+  const unknownGrants = configuredGrants(raw).filter((g) => !isExecutionGrant(g));
+  if (unknownGrants.length > 0) {
+    throw new TracevalsError(`${source}: ${unknownGrantsMessage(unknownGrants)}`);
+  }
+  if (!validate2(raw)) {
+    const detail = (validate2.errors ?? []).map((e) => {
+      const extra = e.keyword === "additionalProperties" ? e.params.additionalProperty : void 0;
+      return extra !== void 0 ? `unknown key "${extra}"${camelCaseHint(extra, e.parentSchema)}` : `${CONFIG_SECTION_KEY_PATH}${e.instancePath} ${e.message ?? "is invalid"}` + movedProviderHint(e.instancePath, e.keyword);
+    }).join("; ");
+    throw new TracevalsError(`${source}: ${detail}`);
+  }
+  const r = raw;
+  const provider = r.provider ?? null;
+  if (provider !== null) {
+    if (provider === JEV) throw new TracevalsError(JEV_OUT_OF_LOOP);
+    assertKnownProvider(provider, (message) => new TracevalsError(message));
+  }
+  const hookProvider = r.conformance?.hook?.provider ?? null;
+  if (hookProvider !== null) {
+    assertKnownProvider(hookProvider, (message) => new TracevalsError(message), { decisions: true });
+  }
+  const config = {
+    provider,
+    model: r.model ?? null,
+    providers: file.providers ?? {},
+    configSource: source,
+    judge: {
+      ensembleRuns: r.judge?.ensembleRuns ?? 3,
+      temperature: r.judge?.temperature ?? 0,
+      zones: {
+        autoPass: r.judge?.zones?.autoPass ?? 0.8,
+        autoFail: r.judge?.zones?.autoFail ?? 0.8
+      },
+      cacheDir: r.judge?.cacheDir ?? ".manni/tracevals/cache",
+      // `null`, not a number: unbounded is a state, and any number here would
+      // be a ceiling nobody asked for.
+      maxTurns: r.judge?.maxTurns ?? null,
+      // Always a list: the render site concatenates nothing onto it, but a
+      // hole here would be a special case in every consumer.
+      redact: [...r.judge?.redact ?? []]
+    },
+    render: {
+      maxBlockChars: r.render?.maxBlockChars ?? 2e3,
+      maxTotalChars: r.render?.maxTotalChars ?? 15e4
+    },
+    execution: { allow: [...r.execution?.allow ?? EXECUTION_GRANTS] },
+    history: {
+      file: r.history?.file ?? ".manni/tracevals/history.jsonl"
+    },
+    capture: {
+      // Beside the judge cache, under the state directory that already travels
+      // with the project — which is what puts a manifest next to its trace in
+      // the CI patterns the docs describe.
+      dir: r.capture?.dir ?? DEFAULT_CAPTURE_DIR
+    },
+    fill: {
+      // 0.7 matches the manuscript's calibration bar for judged agreement.
+      confidenceThreshold: r.fill?.confidenceThreshold ?? 0.7,
+      maxEvalsPerArtifact: r.fill?.maxEvalsPerArtifact ?? 8,
+      temperature: r.fill?.temperature ?? 0,
+      // Separate from the judge cache: different key scheme and value shape.
+      cacheDir: r.fill?.cacheDir ?? ".manni/tracevals/cache/fill",
+      maxTurns: r.fill?.maxTurns ?? null
+    },
+    calibrate: {
+      labels: r.calibrate?.labels ?? DEFAULT_LABELS_FILE,
+      sweep: {
+        // Spans the range rather than filling it: the first sweep judges the
+        // corpus at the largest value here, so a wide grid is the one part of
+        // calibration that does cost money.
+        ensembleRuns: [...r.calibrate?.sweep?.ensembleRuns ?? [1, 3, 5]],
+        autoPass: [
+          ...r.calibrate?.sweep?.autoPass ?? [0.5, 0.6, 0.7, 0.8, 0.9, 0.95]
+        ],
+        autoFail: [
+          ...r.calibrate?.sweep?.autoFail ?? [0.5, 0.6, 0.7, 0.8, 0.9, 0.95]
+        ]
+      }
+    },
+    failOnReview: r.failOnReview ?? true,
+    // Always a list, never undefined: the read site concatenates `--require`
+    // onto it, and a hole there would be a special case in every caller.
+    plugins: [...r.plugins ?? []],
+    // An observation, not a gate: listing it is opt-in because a real roster
+    // runs to hundreds of skills (ADR 01016).
+    reportUnusedArtifacts: r.reportUnusedArtifacts ?? false,
+    conformance: r.conformance === void 0 ? null : {
+      hook: {
+        provider: hookProvider,
+        model: r.conformance.hook?.model ?? null,
+        runs: r.conformance.hook?.runs ?? 1
+      },
+      include: [...r.conformance.include ?? []],
+      exclude: [...r.conformance.exclude ?? []],
+      plans: [...r.conformance.plans ?? []]
+    }
+  };
+  compileRedactPatterns(config.judge.redact);
+  for (const key of ["maxFalsePass", "maxFalseFail", "maxReview"]) {
+    if (typeof r.calibrate?.[key] === "number") {
+      config.calibrate[key] = r.calibrate[key];
+    }
+  }
+  return config;
+}
+async function discoverConfig(dir = process.cwd(), lookup = {}) {
+  if (lookup.noConfig === true) {
+    return { config: parseConfig({}), dir, collections: [] };
+  }
+  const file = await Promise.resolve().then(
+    () => lookup.configPath === void 0 ? findConfigFileSync(dir, CONFIG_FILE) : readConfigFileSync(lookup.configPath, dir, CONFIG_FILE)
+  );
+  if (file === null) return { config: parseConfig({}), dir, collections: [] };
+  return {
+    config: parseConfig(file.value ?? {}, {
+      source: file.source,
+      ...file.providers !== void 0 ? { providers: file.providers } : {}
+    }),
+    dir: file.dir,
+    collections: file.collections,
+    path: file.path
+  };
+}
+async function loadConfig(dir = process.cwd(), lookup = {}) {
+  return (await discoverConfig(dir, lookup)).config;
+}
+
+export {
+  DEFAULT_LABELS_FILE,
+  labelKey,
+  parseLabels,
+  loadLabels,
+  DEFAULT_CONFIG_FILENAME,
+  CONFIG_SECTION_KEY,
+  parseConfig,
+  discoverConfig,
+  loadConfig
+};
+//# sourceMappingURL=chunk-TPVOOTMN.js.map