@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/completion-verifier-DJA5BhPb.d.ts

@@ -1,414 +0,0 @@
-import { t as DefaultVerdict } from "./verdict-DExhxfgR.js";
-import { c as CostLedgerHandle } from "./cost-ledger-Bv_e8XHY.js";
-import { A as ChatClient, Ft as RawProviderSink } from "./types-D216SgwM.js";
-import { c as AnalystRunInputs, i as AnalystFinding, l as AnalystRunResult, n as AnalystContext, s as AnalystRunEvent, t as Analyst, u as AnalystRunSummary } from "./types-BvDKaULh.js";
-import { i as ExactAnalystRunEvent, o as ExactAnalystRunResult, u as ExactExecutionComponentIdentity } from "./exact-types-DSFFpLLI.js";
-//#region src/analyst/registry.d.ts
-interface AnalystHooks {
-  /** Legacy runs may mutate ctx; exact runs provide a frozen observational context. */
-  onBeforeAnalyze?(args: {
-    analyst: Analyst;
-    ctx: AnalystContext;
-    runId: string;
-  }): void | Promise<void>;
-  /** After every analyst (ok | failed | skipped). Use for telemetry, ingestion, rotation. */
-  onAfterAnalyze?(args: {
-    analyst: Analyst;
-    summary: AnalystRunSummary;
-    findings: AnalystFinding[];
-    runId: string;
-  }): void | Promise<void>;
-  /**
-   * On analyst exception. Hook MAY return findings to convert the
-   * error into structured findings; the summary still reports 'failed'.
-   * Return void to keep the default empty-findings behavior.
-   */
-  onError?(args: {
-    analyst: Analyst;
-    error: Error;
-    runId: string;
-  }): AnalystFinding[] | undefined | Promise<AnalystFinding[] | undefined>;
-  /** Once after registry.run() completes. Use for final aggregation, persistence. */
-  onComplete?(args: {
-    result: AnalystRunResult;
-  }): void | Promise<void>;
-}
-interface BudgetPolicy {
-  /** Overall USD cap across the registry.run(). */
-  totalUsd?: number;
-  /** Per-analyst weight for the default allocator. Missing ids get weight 1. */
-  weights?: Record<string, number>;
-  /**
-   * Custom allocator — receives the analyst, remaining/total budget, and
-   * the count of analysts that will run. Returns the per-analyst budget
-   * (or undefined only when the run has no overall cap). Overrides weights
-   * when set.
-   */
-  allocate?: (args: {
-    analyst: Analyst;
-    totalUsd: number | undefined;
-    remainingUsd: number | undefined;
-    runningCount: number;
-  }) => number | undefined;
-}
-interface AnalystRegistryOptions {
-  /** Shared chat client passed to every LLM analyst via AnalystContext. */
-  chat?: ChatClient;
-  /** Logger callback. Defaults to a no-op. */
-  log?: (msg: string, fields?: Record<string, unknown>) => void;
-  /** Hooks invoked around analyze() — observability + customization seam. */
-  hooks?: AnalystHooks;
-  /** Required identity/config when `runExact` applies `hooks`. */
-  hooksIdentity?: ExactExecutionComponentIdentity;
-  /** Default budget when run() doesn't override. */
-  defaultBudget?: BudgetPolicy;
-  /** Required identity/config when `runExact` provides `chat`. */
-  chatIdentity?: ExactExecutionComponentIdentity;
-}
-interface RegistryRunOpts {
-  /** Restrict to a subset of registered analysts by id. */
-  only?: string[];
-  /** Skip these analysts even if registered. Useful for cheap iteration. */
-  skip?: string[];
-  /** Budget policy — totalUsd + optional weights/allocator. Falls back to options.defaultBudget. */
-  budget?: BudgetPolicy;
-  /** Active-work cap for the complete registry run. Model receipt settlement may follow. */
-  timeoutMs?: number;
-  /** Abort signal — forwarded into every analyst's context. */
-  signal?: AbortSignal;
-  /** Shared paid-call account forwarded to every analyst. */
-  costLedger?: CostLedgerHandle;
-  /** Attribution phase for calls written to `costLedger`. */
-  costPhase?: string;
-  /** Tags echoed into AnalystContext.tags — useful for tracking environment/version in findings. */
-  tags?: Record<string, string>;
-  /**
-   * Prior-run findings made available as retrieval context to every
-   * analyst via `ctx.priorFindings`. The registry forwards the slice
-   * whose `analyst_id` matches each registered analyst so a kind sees
-   * only its own history. Pass `{ '*': findings }` to broadcast to
-   * every analyst (useful when several kinds share the same historical
-   * context). For findings from this run, use `chainFindings` instead.
-   */
-  priorFindings?: ReadonlyArray<AnalystFinding> | Record<string, ReadonlyArray<AnalystFinding>>;
-  /**
-   * Pass findings produced earlier in this registry run to each later analyst
-   * via `ctx.upstreamFindings`. Registration order is dependency order.
-   * Disabled by default because independent analyst suites must opt in.
-   */
-  chainFindings?: boolean;
-}
-/** A caller-selected allocation rule for an exact analyst run. */
-type ExactAnalystBudgetPolicy = {
-  readonly kind: 'equal';
-  readonly totalUsd: number;
-} | {
-  readonly kind: 'weighted';
-  readonly totalUsd: number;
-  /** One explicit weight for every selected analyst id. */
-  readonly weights: Readonly<Record<string, number>>;
-};
-/**
- * Complete per-run analyst policy.
- *
- * Every field is required. `null` explicitly disables an optional resource or context channel.
- * `analystIds` is execution order; it is not filtered through registry insertion order.
- * Missing-input behavior is explicit so callers cannot accidentally inherit it by omission.
- * Exact runs are serial; more elaborate scheduling belongs in the caller's runtime.
- */
-interface ExactRegistryRunOpts {
-  readonly analystIds: readonly string[];
-  readonly budget: ExactAnalystBudgetPolicy | null;
-  readonly totalTimeoutMs: number | null;
-  readonly signal: AbortSignal | null;
-  readonly costLedger: CostLedgerHandle | null;
-  readonly costLedgerIdentity: ExactExecutionComponentIdentity | null;
-  readonly costPhase: string | null;
-  readonly tags: Readonly<Record<string, string>> | null;
-  readonly priorFindings: ReadonlyArray<AnalystFinding> | Readonly<Record<string, ReadonlyArray<AnalystFinding>>> | null;
-  readonly chainFindings: boolean;
-  readonly missingInputMode: 'skip' | 'abort';
-  readonly applyRegistryHooks: boolean;
-  readonly useRegistryChat: boolean;
-}
-/** A post-start exact-run failure; completed work remains attached for accounting and review. */
-declare class ExactAnalystRunExecutionError extends Error {
-  readonly name: string;
-  readonly result: ExactAnalystRunResult;
-  constructor(message: string, result: ExactAnalystRunResult, options?: ErrorOptions);
-}
-declare class AnalystRegistry {
-  private readonly analysts;
-  private readonly options;
-  constructor(options?: AnalystRegistryOptions);
-  register(analyst: Analyst): void;
-  list(): ReadonlyArray<{
-    id: string;
-    description: string;
-    version: string;
-    cost: Analyst['cost'];
-  }>;
-  run(runId: string, inputs: AnalystRunInputs, runOpts?: RegistryRunOpts): Promise<AnalystRunResult>;
-  /** Run exactly the ordered analysts and complete policy supplied by the caller. */
-  runExact(runId: string, inputs: AnalystRunInputs, runOpts: ExactRegistryRunOpts): Promise<ExactAnalystRunResult>;
-  /** Streaming counterpart to {@link runExact}. */
-  runExactStream(runId: string, inputs: AnalystRunInputs, runOpts: ExactRegistryRunOpts): AsyncGenerator<ExactAnalystRunEvent, void, void>;
-  /**
-   * Streaming counterpart to `run()`. Emits `AnalystRunEvent` values
-   * in real time — `run-started`, then per-analyst `skipped` /
-   * `started` / `completed`, then a terminal `run-completed` whose
-   * payload is the full `AnalystRunResult`. UIs use this to render
-   * progress; persistence consumers use `run()` and read the result.
-   *
-   * Hooks (`onBeforeAnalyze` / `onAfterAnalyze` / `onError` /
-   * `onComplete`) fire as before — streaming is additive, not a hook
-   * replacement.
-   */
-  runStream(runId: string, inputs: AnalystRunInputs, runOpts?: RegistryRunOpts): AsyncGenerator<AnalystRunEvent, void, void>;
-  private normalizeLegacyPlan;
-  private normalizeExactPlan;
-  private executePlanStream;
-  private selectAnalysts;
-  private selectExactAnalysts;
-  private routeInput;
-}
-/** Validate the canonical exact-run policy before any analyst can start. */
-declare function assertExactRegistryRunOpts(value: unknown): asserts value is ExactRegistryRunOpts;
-//#endregion
-//#region src/artifact-validator.d.ts
-/**
- * Artifact validators.
- *
- * Generic "score a produced artifact" primitive. Tax uses it for PDF form
- * correctness, research for sourced briefs, browser for task assertions, coding
- * for social posts. One interface, many validators; all plug into
- * `BenchmarkRunner` the same way.
- *
- * A validator receives an `Artifact` (file on disk, JSON blob, text, binary)
- * plus a `ValidationContext` (scenario id, the turns that produced it) and
- * returns a `ValidationResult` with pass/fail + 0..1 score + structured
- * issues.
- */
-interface Artifact {
-  /** Logical kind — validators type-guard on this */
-  kind: 'file' | 'json' | 'text' | 'binary' | string;
-  /** Filesystem-style path, optional */
-  path?: string;
-  /** String content for text/json/file kinds */
-  content?: string;
-  /** Binary content (if kind === 'binary') */
-  bytes?: Uint8Array;
-  /** Caller-supplied metadata (mimeType, sha256, size, etc.) */
-  metadata?: Record<string, unknown>;
-}
-interface ValidationContext {
-  scenarioId: string;
-  turnIndex?: number;
-  /** Prior artifacts for multi-artifact scenarios */
-  priorArtifacts?: Artifact[];
-  /** Free-form hints the validator uses for domain-specific checks */
-  hints?: Record<string, unknown>;
-}
-interface ValidationIssue {
-  severity: 'error' | 'warning' | 'info';
-  message: string;
-  /** Optional path into the artifact (e.g. JSON path or byte offset) */
-  locus?: string;
-}
-interface ValidationResult {
-  pass: boolean;
-  /** 0–1 normalized score. Validators should be monotonic in pass-ness. */
-  score: number;
-  issues: ValidationIssue[];
-  /** Diagnostic payload for reporters */
-  evidence?: Record<string, unknown>;
-}
-interface ArtifactValidator {
-  /** Stable identifier for the validator; appears in reports. */
-  name: string;
-  /** Optional description for human-facing reports. */
-  description?: string;
-  /** Called once per artifact; validators are expected to be pure + idempotent. */
-  validate(artifact: Artifact, context: ValidationContext): Promise<ValidationResult>;
-}
-/**
- * Run every validator on the same artifact; aggregate pass as AND, score as
- * (weighted) mean, issues concatenated. Weights default to 1 each.
- */
-declare function composeValidators(validators: ArtifactValidator[], options?: {
-  name?: string;
-  weights?: number[];
-}): ArtifactValidator;
-/** Pass if the artifact body matches a provided regex. */
-declare function regexMatch(name: string, pattern: RegExp): ArtifactValidator;
-/** Pass if JSON parses and every required key is present. */
-declare function jsonHasKeys(name: string, requiredPaths: string[]): ArtifactValidator;
-/** Pass if min ≤ byte length ≤ max. */
-declare function byteLengthRange(name: string, min: number, max: number): ArtifactValidator;
-/** Pass if the artifact contains every required substring (case-insensitive by default). */
-declare function containsAll(name: string, required: string[], options?: {
-  caseSensitive?: boolean;
-}): ArtifactValidator;
-//#endregion
-//#region src/completion-verifier.d.ts
-/** What kind of produced state can satisfy a requirement structurally. */
-type SatisfiedBy = 'artifact' | 'proposal' | 'tool-call' | 'any';
-interface CompletionRequirement {
-  /** Stable id from the task gold (e.g. a persona's `expected_requirements[].req_id`). */
-  reqId: string;
-  /** Human-readable description of the required deliverable. */
-  title: string;
-  /** Optional kind/category hint, matched against a produced item's kind. */
-  category?: string;
-  /** What produced state satisfies this requirement. Defaults to 'any'. */
-  satisfiedBy?: SatisfiedBy;
-}
-interface TaskGold {
-  taskId: string;
-  requirements: CompletionRequirement[];
-}
-interface ProducedProposal {
-  id: string;
-  title: string;
-  status: 'pending' | 'approved' | 'rejected';
-  /** Optional persisted body — when present, enables a correctness check. */
-  content?: string;
-}
-/** Everything observable about what a run actually produced. */
-interface ProducedState {
-  /** Persisted vault artifacts. Reuses the shared `Artifact` shape. */
-  artifacts: Artifact[];
-  /** Proposals / filings the agent created. */
-  proposals: ProducedProposal[];
-  /** Names of tools the agent invoked. */
-  toolCalls: string[];
-}
-interface RequirementCheck {
-  reqId: string;
-  title: string;
-  /** A produced item of the right kind matched the requirement, non-empty. */
-  structurallyPresent: boolean;
-  /**
-   * Whether the matched item actually fulfils the requirement. `null` when
-   * not structurally present, when the matched item carries no content
-   * to assess, or when the correctness check itself failed (`unmeasured`).
-   */
-  correct: boolean | null;
-  /** structurallyPresent && !unmeasured && correct !== false. */
-  satisfied: boolean;
-  /**
-   * Set when the correctness check itself errored (LLM call failure or an
-   * unparseable response after retry). The requirement's fulfilment is
-   * UNKNOWN — `correct` stays null, `satisfied` is false, and
-   * `completionVerdict` excludes the row from `completionRate`'s
-   * denominator. Never folded into a zero: a synthetic zero is
-   * indistinguishable from a real failure (see `JudgeParseError`).
-   */
-  unmeasured?: true;
-  /** Why the correctness check could not be measured (present iff `unmeasured`). */
-  unmeasuredReason?: string;
-  /** Human-readable evidence for the verdict. */
-  evidence: string[];
-}
-/** Extends the substrate verdict spine: `valid` = `fullyComplete` and
- *  `score` = `completionRate` — derived in `completionVerdict()`, the one
- *  place those equalities hold by construction. */
-interface CompletionVerdict extends DefaultVerdict {
-  taskId: string;
-  requirements: RequirementCheck[];
-  /** satisfied / MEASURABLE requirements (unmeasured rows leave the denominator). */
-  completionRate: number;
-  /** Every measurable requirement satisfied (false when anything is unmeasured). */
-  fullyComplete: boolean;
-  /** Requirements whose correctness check errored — reported, never scored as zero. */
-  unmeasuredCount: number;
-}
-/**
- * Construct a `CompletionVerdict` from the per-requirement checks, deriving
- * `completionRate` / `fullyComplete` and the spine fields (`valid` =
- * `fullyComplete`, `score` = `completionRate`) in one place. Throws on zero
- * requirements — a verdict over nothing is a misconfiguration, mirroring
- * `verifyCompletion`'s gold-spec guard.
- */
-declare function completionVerdict(input: {
-  taskId: string;
-  requirements: RequirementCheck[];
-}): CompletionVerdict;
-/**
- * Decides whether a produced item's content actually fulfils a requirement.
- * Injected so the structural verifier stays pure and unit-testable; the
- * production implementation is `createLlmCorrectnessChecker`.
- */
-type CorrectnessChecker = (requirement: CompletionRequirement, content: string) => Promise<{
-  correct: boolean;
-  reason: string;
-}>;
-/**
- * Verify whether a run completed the task. `checkCorrectness` is injected —
- * `createLlmCorrectnessChecker` for production, a deterministic stub in tests.
- *
- * Throws on a gold spec with no requirements: an eval task that requires
- * nothing is a misconfiguration, not a vacuously-complete task.
- */
-declare function verifyCompletion(gold: TaskGold, state: ProducedState, checkCorrectness: CorrectnessChecker): Promise<CompletionVerdict>;
-interface LlmCorrectnessCheckerOpts {
-  model?: string;
-  /** Optional ledger for direct use. */
-  costLedger?: CostLedgerHandle;
-  costPhase?: string;
-  costTags?: Record<string, string>;
-  signal?: AbortSignal;
-  /** Max chars of artifact content sent to the checker. */
-  maxContentChars?: number;
-  /**
-   * Checker LLM calls per requirement before giving up (parse failures and
-   * call errors both consume attempts). The failure then surfaces as an
-   * `unmeasured` requirement, never a zero.
-   */
-  maxAttempts?: number;
-  /**
-   * Forensic capture of every checker request/response/error — without it a
-   * checker failure is unauditable (the agent-turn raws never contain the
-   * checker's own calls). Same sink contract as `LlmClient`.
-   */
-  rawSink?: RawProviderSink;
-}
-/**
- * Parse the correctness checker's model response. Tolerates a response
- * truncated mid-JSON (max_tokens cap) by auto-closing the prefix — the
- * verdict boolean usually lands in the first few tokens, so a recovered
- * prefix with a boolean `correct` is a real measurement, not a guess.
- * Fails loud (JudgeParseError) when no boolean verdict is recoverable.
- */
-declare function parseCorrectnessResponse(raw: string): {
-  correct: boolean;
-  reason: string;
-};
-/**
- * Production `CorrectnessChecker` — one LLM call per matched artifact,
- * deterministic (temperature 0), structured JSON out. Judges fulfilment
- * only: a plan, a gesture, or a description of what should be done does not
- * fulfil a requirement — the artifact must BE the deliverable.
- */
-declare function createLlmCorrectnessChecker(chat: ChatClient, opts?: LlmCorrectnessCheckerOpts): CorrectnessChecker;
-/**
- * Deterministic `CorrectnessChecker` — the no-LLM counterpart to
- * `createLlmCorrectnessChecker`. A produced item fulfils a requirement when its
- * content is substantive (≥ `minContentLength` chars) AND recalls ≥ `minRecall`
- * of the requirement title's significant tokens. No network.
- *
- * Polarity-blind: token recall credits a negation that contains the
- * requirement's tokens ("I will NOT produce the comparison" recalls every token
- * of "produce the comparison"). The structural match stage is ALSO lexical, so
- * pairing the two collapses to a single gameable gate. Use this only as an
- * opt-in structural pre-filter or for tasks whose requirements have no polarity
- * to invert; for produced-state grading the correctness checker MUST be semantic
- * (`createLlmCorrectnessChecker`). See the anti-game fixtures in the test suite.
- */
-declare function createTokenRecallChecker(opts?: {
-  minRecall?: number;
-  minContentLength?: number;
-}): CorrectnessChecker;
-//#endregion
-export { ExactAnalystRunExecutionError as A, jsonHasKeys as C, AnalystRegistryOptions as D, AnalystRegistry as E, RegistryRunOpts as M, assertExactRegistryRunOpts as N, BudgetPolicy as O, containsAll as S, AnalystHooks as T, ValidationContext as _, ProducedProposal as a, byteLengthRange as b, SatisfiedBy as c, createLlmCorrectnessChecker as d, createTokenRecallChecker as f, ArtifactValidator as g, Artifact as h, LlmCorrectnessCheckerOpts as i, ExactRegistryRunOpts as j, ExactAnalystBudgetPolicy as k, TaskGold as l, verifyCompletion as m, CompletionVerdict as n, ProducedState as o, parseCorrectnessResponse as p, CorrectnessChecker as r, RequirementCheck as s, CompletionRequirement as t, completionVerdict as u, ValidationIssue as v, regexMatch as w, composeValidators as x, ValidationResult as y };
-//# sourceMappingURL=completion-verifier-DJA5BhPb.d.ts.map

package/dist/completion-verifier-DJA5BhPb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"completion-verifier-DJA5BhPb.d.ts","names":[],"sources":["../src/analyst/registry.ts","../src/artifact-validator.ts","../src/completion-verifier.ts"],"mappings":"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"}

package/dist/control.d.ts

@@ -1,3 +0,0 @@
-import { $ as ControlRunResult, J as ControlActionOutcome, Q as ControlEvalResult, X as ControlContext, Y as ControlBudget, Z as ControlDecision, at as StopDecision, ct as runAgentControlLoop, dt as subjectiveEval, et as ControlRuntimeConfig, it as ControlStopPolicies, lt as stopOnNoProgress, nt as ControlSeverity, ot as allCriticalPassed, q as ControlActionFailureMode, rt as ControlStep, st as objectiveEval, tt as ControlRuntimeError, ut as stopOnRepeatedAction } from "./feedback-trajectory-CacHpxsp.js";
-import { A as ActionExecutionPolicy, M as evaluateActionPolicy, _ as ProposeReviewReport, a as ProposeReviewControlAction, c as ProposeReviewControlState, g as ProposeReviewConfig, i as scoreFromEvals, j as ActionPolicyDecision, k as runProposeReview, n as RunEvidenceMetadata, o as ProposeReviewControlConfig, r as controlRunToRunRecord, s as ProposeReviewControlResult, t as ControlRunToRunRecordOptions, u as runProposeReviewAsControlLoop } from "./run-evidence-Dhi3C81V.js";
-export { type ActionExecutionPolicy, type ActionPolicyDecision, type ControlActionFailureMode, type ControlActionOutcome, type ControlBudget, type ControlContext, type ControlDecision, type ControlEvalResult, type ControlRunResult, type ControlRunToRunRecordOptions, type ControlRuntimeConfig, type ControlRuntimeError, type ControlSeverity, type ControlStep, type ControlStopPolicies, type ProposeReviewConfig, type ProposeReviewControlAction, type ProposeReviewControlConfig, type ProposeReviewControlResult, type ProposeReviewControlState, type ProposeReviewReport, type RunEvidenceMetadata, type StopDecision, allCriticalPassed, controlRunToRunRecord, evaluateActionPolicy, objectiveEval, runAgentControlLoop, runProposeReview, runProposeReviewAsControlLoop, scoreFromEvals, stopOnNoProgress, stopOnRepeatedAction, subjectiveEval };

package/dist/control.js

@@ -1,2 +0,0 @@
-import { c as scoreFromEvals, d as runAgentControlLoop, f as stopOnNoProgress, l as allCriticalPassed, m as subjectiveEval, n as runProposeReviewAsControlLoop, o as runProposeReview, p as stopOnRepeatedAction, s as controlRunToRunRecord, u as objectiveEval, y as evaluateActionPolicy } from "./propose-review-control-dSNPjFUH.js";
-export { allCriticalPassed, controlRunToRunRecord, evaluateActionPolicy, objectiveEval, runAgentControlLoop, runProposeReview, runProposeReviewAsControlLoop, scoreFromEvals, stopOnNoProgress, stopOnRepeatedAction, subjectiveEval };

package/dist/dataset-C8xaLXdY.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dataset-C8xaLXdY.d.ts","names":[],"sources":["../src/dataset.ts"],"mappings":";;;;;;;;;;;;;;;;;;KAiBY;KACA;UAEK;EACf;;EAEA;EACA,QAAQ;EACR,aAAa;;EAEb;;;;;;;;;;EAUA;EACA,OAAO;;UAGQ;EACf;EACA;EACA;EACA;EACA;;EAEA;;UAGe;EACf;EACA,YAAY;;EAEZ;EACA;EACA,aAAa,OAAO;;UAGL;EACf,QAAQ;EACR,aAAa;;EAEb;EACA;;EAEA,UAAU,UAAU;;EAEpB;;;cAMW,2BAA2B;EACtC,YAAY;;cAOD;WACF;WACA,YAAY;UACb;UACA;EAER,YAAY;IACV;IACA,YAAY;IACZ,WAAW;IACX;;;EASF,gBAAgB;MAIZ;;;;;EAQJ,MAAM,UAAS,eAAoB;;;;;EAqB7B,YAAY,QAAQ;;EAgB1B,MAAM,YAAW;IAAU;IAAc;OAA0B;EAWnE;EAIA,IAAI,UAAU;EAQd,OAAO;;;;;EAWP;SAQO,UACL,eACA,UAAU,KAAK,oEACd;;iBAaiB,cAAc,WAAW,oBAAoB"}

package/dist/default-registry-Bf8Woqmq.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"default-registry-Bf8Woqmq.d.ts","names":[],"sources":["../src/trace-analyst/behavioral-metrics.ts","../src/analyst/behavioral-analyst.ts","../src/analyst/kind-factory.ts","../src/analyst/default-registry.ts"],"mappings":";;;;;;KAoBY;UAMK;EACf,MAAM;EACN;;EAEA;;EAEA,UAAU;;UAGK;;EAEf;EACA;;EAEA,gBAAgB;;EAEhB;EACA;EACA,eAAe;EACf;EACA;;EAEA;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA,sBAAsB;EACtB,uBAAuB;;;;;;iBAoFT,oBAAoB,gBAAgB,qBAAqB;;;UC9GxD;;EAEf;;EAEA;;;;;;iBA+Dc,yBACd,SAAS,mBACT;EAAQ;EAAoB;IAC3B;;iBAkCa,kBACd,UAAS,2BACR,oBAAoB;;;;UCrHN;EACf;EACA;EACA;EACA;;EAEA,sBAAsB,SAAS;;EAE/B;;EAEA,WAAW;;EAEX,kBACE,OAAO,oBACP,SAAS,wCACe;EAC1B,SAAS,QAAQ;EACjB,eAAe,KAAK,mBAAmB,SAAS,mBAAmB;EACnE;EACA;;UAGe;EACf,QAAQ;;EAER;EACA;;;iBAIoB,gBAAgB;EACpC,YAAY;EACZ,QAAQ;EACR,OAAO;EACP,SAAS;EACT;IACE,QAAQ;;iBAgFI,mBACd,YAAY,wBACZ,SAAS,4BACR,oBAAoB;iBA+QP,oBAAoB,OAAO;iBAe3B,uBAAuB,UAAU;;;UCnahC;;;;;;EAMf,SAAS;EACT,uBAAuB;;EAEvB;EACA,aAAa;EACb,WAAW;;iBAGG,4BACd,UAAS,gCACR"}