@tangle-network/agent-eval 0.77.0 → 0.79.0

package/dist/authenticity/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/authenticity/index.ts"],"sourcesContent":["/**\n * Authenticity — \"is this real, or convincing BS?\"\n *\n * Pass/build-style scoring rewards anything that compiles and renders, so an\n * agent can ship a polished frontend with a FAKE in-browser engine and zero of\n * the required on-chain/contract work, and outscore a half-finished real\n * implementation. This module scores what buildability does not: did the agent\n * actually build the intended thing on the intended infra, or fake it.\n *\n * Two layers:\n *   - DETERMINISTIC `scoreAuthenticity` — calibrated by construction (no LLM,\n *     trustworthy today). Structural signals over the produced files, driven by\n *     a domain `AuthenticitySignals` config: required artifact present, real\n *     implementation of the hard part, real infra calls, wiring, fake-shim\n *     detection, mock/stub density.\n *   - LLM NUANCE `scoreAuthenticityNuance` — mocked% / fake% / unique% for the\n *     \"looks real but is hollow\" cases structure can't see.\n *\n * `gateRealness` is the anti-Goodhart gate: a submission missing the required\n * artifact (or faking it) is capped and cannot rank high regardless of how\n * buildable it is. Domain-agnostic; ships a Solidity/Fhenix preset.\n *\n * Input is the produced-state currency: `{ path, content }[]` — exactly what\n * `extractProducedState(...).artifacts` yields, so any consumer can feed a run's\n * produced state straight in.\n */\n\nexport interface ProducedFile {\n  path: string\n  content?: string\n}\n\nexport interface AuthenticitySignals {\n  /** Human label for the domain (e.g. 'fhenix-fhe'). */\n  label: string\n  /** A file the task REQUIRES (e.g. /\\.sol$/ for an on-chain task). */\n  requiredArtifact?: RegExp\n  /** Vendored/3rd-party paths to exclude from required-artifact detection. */\n  vendored?: RegExp\n  /** Real implementation of the hard part, inside the required artifact\n   *  (e.g. Fhenix encrypted types + FHE.* ops). Matched against content, so it\n   *  fails on comments/strings only if the regex is written tightly. */\n  realImpl: RegExp\n  /** Real use of the intended client infra (e.g. cofhejs.encrypt() calls). */\n  realInfra: RegExp\n  /** Evidence the artifact is actually wired/used (e.g. contract writes). */\n  wiring?: RegExp\n  /** A fake shim standing in for the real thing — matched on file path AND body. */\n  fakeShim: RegExp\n  /** Mock/stub/TODO markers. Defaults to a generic set. */\n  mock?: RegExp\n  /** Score weights (default 40/25/20/15). */\n  weights?: { artifact?: number; impl?: number; infra?: number; wiring?: number }\n}\n\nexport interface AuthenticityResult {\n  /** Deterministic realness, 0 (BS) … 100 (real on real infra). */\n  realness: number\n  requiredArtifactPresent: boolean\n  requiredArtifactCount: number\n  usesRealImpl: boolean\n  realInfra: boolean\n  wired: boolean\n  fakeShim: boolean\n  /** mock/stub markers per 1000 LOC, capped at 100. */\n  mockDensity: number\n  /** Human-readable BS flags — what's missing or faked. */\n  flags: string[]\n}\n\nconst DEFAULT_MOCK =\n  /\\bmock|\\bfake|\\bdummy|\\bstub\\b|simulat|hardcoded|placeholder|TODO|not\\s+implemented|FIXME/i\n\nfunction basename(p: string): string {\n  return p.split('/').pop() ?? p\n}\n\n/** Deterministic authenticity scan of produced files. Pure — same files in,\n *  same score out. No LLM, no IO. */\nexport function scoreAuthenticity(\n  files: readonly ProducedFile[],\n  signals: AuthenticitySignals,\n): AuthenticityResult {\n  const w = {\n    artifact: signals.weights?.artifact ?? 40,\n    impl: signals.weights?.impl ?? 25,\n    infra: signals.weights?.infra ?? 20,\n    wiring: signals.weights?.wiring ?? 15,\n  }\n  const mockRe = signals.mock ?? DEFAULT_MOCK\n\n  const required = signals.requiredArtifact\n    ? files.filter(\n        (f) => signals.requiredArtifact!.test(f.path) && !(signals.vendored?.test(f.path) ?? false),\n      )\n    : []\n  const others = signals.requiredArtifact ? files.filter((f) => !required.includes(f)) : files\n\n  const requiredText = required.map((f) => f.content ?? '').join('\\n')\n  const otherText = others.map((f) => f.content ?? '').join('\\n')\n  const allText = files.map((f) => f.content ?? '').join('\\n')\n\n  const requiredArtifactPresent = signals.requiredArtifact ? required.length > 0 : true\n  // Real impl looked for in the required artifact when there is one, else anywhere.\n  const usesRealImpl = signals.realImpl.test(signals.requiredArtifact ? requiredText : allText)\n  const realInfra = signals.realInfra.test(allText)\n  const wired = signals.wiring ? signals.wiring.test(otherText || allText) : false\n  const fakeShim = files.some(\n    (f) => signals.fakeShim.test(basename(f.path)) || signals.fakeShim.test(f.content ?? ''),\n  )\n\n  const mockHits = (\n    allText.match(\n      new RegExp(mockRe.source, mockRe.flags.includes('g') ? mockRe.flags : `${mockRe.flags}g`),\n    ) ?? []\n  ).length\n  const loc = Math.max(1, allText.split('\\n').length)\n  const mockDensity = Math.min(100, Math.round((mockHits / loc) * 1000))\n\n  let realness = 0\n  if (requiredArtifactPresent) realness += w.artifact\n  if (usesRealImpl) realness += w.impl\n  if (realInfra) realness += w.infra\n  if (wired) realness += w.wiring\n  if (fakeShim) realness -= 25\n  realness -= Math.min(20, mockDensity)\n  realness = Math.max(0, Math.min(100, realness))\n\n  const flags: string[] = []\n  if (signals.requiredArtifact && !requiredArtifactPresent) {\n    flags.push(\n      `NO_REQUIRED_ARTIFACT: task needs ${signals.label} artifact (${signals.requiredArtifact}); none produced`,\n    )\n  }\n  if (requiredArtifactPresent && signals.requiredArtifact && !usesRealImpl) {\n    flags.push('ARTIFACT_NO_REAL_IMPL: required artifact exists but lacks the real implementation')\n  }\n  if (fakeShim) flags.push('FAKE_SHIM: ships a client-side stand-in simulating the real infra')\n  if (!realInfra && !requiredArtifactPresent)\n    flags.push('NO_REAL_INFRA: no real infra calls — cosmetic at best')\n  if (mockDensity >= 8)\n    flags.push(`HIGH_MOCK_DENSITY: ${mockDensity} mock/stub markers per 1000 LOC`)\n  if (signals.wiring && requiredArtifactPresent && !wired)\n    flags.push('NOT_WIRED: artifact exists but is never used by the client')\n\n  return {\n    realness,\n    requiredArtifactPresent,\n    requiredArtifactCount: required.length,\n    usesRealImpl,\n    realInfra,\n    wired,\n    fakeShim,\n    mockDensity,\n    flags,\n  }\n}\n\nexport interface RealnessGate {\n  gated: boolean\n  reason?: string\n}\n\n/** Anti-Goodhart gate: a required-artifact-missing or faked submission is\n *  capped and cannot rank high regardless of buildability. */\nexport function gateRealness(\n  r: AuthenticityResult,\n  opts: { floor?: number; requireArtifact?: boolean } = {},\n): RealnessGate {\n  const floor = opts.floor ?? 30\n  if ((opts.requireArtifact ?? true) && !r.requiredArtifactPresent) {\n    return { gated: true, reason: 'required artifact missing' }\n  }\n  if (r.fakeShim && !r.usesRealImpl) {\n    return { gated: true, reason: 'fake shim with no real implementation' }\n  }\n  if (r.realness < floor)\n    return { gated: true, reason: `realness ${r.realness} below floor ${floor}` }\n  return { gated: false }\n}\n\n// ── LLM nuance layer ─────────────────────────────────────────────────────────\n\nexport interface AuthenticityNuance {\n  /** 0 (nothing mocked) … 100 (entirely mocked). */\n  mockedPct: number\n  /** 0 (genuine) … 100 (a hollow facade / cargo-culted). */\n  fakePct: number\n  /** 0 (boilerplate/template clone) … 100 (distinctive real work). */\n  uniquePct: number\n  verdict: string\n}\n\n/** A minimal completion fn — inject your model caller (router/tcloud). Keeps\n *  this module free of any specific LLM client. */\nexport type CompleteFn = (system: string, user: string) => Promise<string>\n\nfunction fileDigest(\n  files: readonly ProducedFile[],\n  opts: { maxFiles?: number; perFile?: number; prioritize?: RegExp } = {},\n): string {\n  const maxFiles = opts.maxFiles ?? 14\n  const perFile = opts.perFile ?? 1200\n  // Lead with the required-artifact files (e.g. .sol) so a truncated digest\n  // never hides the very thing the judge must assess.\n  const ordered = opts.prioritize\n    ? [...files].sort(\n        (a, b) => Number(opts.prioritize!.test(b.path)) - Number(opts.prioritize!.test(a.path)),\n      )\n    : files\n  return ordered\n    .slice(0, maxFiles)\n    .map((f) => `// ${f.path}\\n${(f.content ?? '').slice(0, perFile)}`)\n    .join('\\n\\n')\n}\n\nfunction clampPct(v: unknown): number {\n  const n = typeof v === 'number' ? v : Number(v)\n  return Number.isFinite(n) ? Math.max(0, Math.min(100, Math.round(n))) : 0\n}\n\n/**\n * LLM nuance scoring — judges the \"looks real but is hollow\" axis structure\n * misses. Inject a `complete` caller; returns mocked/fake/unique % + a verdict.\n * Fail-soft: a bad/unparseable response yields a worst-case (fully-fake) read,\n * never a false pass.\n */\nexport async function scoreAuthenticityNuance(\n  files: readonly ProducedFile[],\n  complete: CompleteFn,\n  opts: { intent?: string; prioritize?: RegExp } = {},\n): Promise<AuthenticityNuance> {\n  const system =\n    'You audit whether an agent BUILT THE REAL THING or faked it. Be skeptical: ' +\n    'a pretty UI, cosmetic labels, simulated/in-memory stand-ins for real infra, ' +\n    'and cargo-culted imports do NOT count as real. Respond with ONLY JSON: ' +\n    '{\"mockedPct\":0-100,\"fakePct\":0-100,\"uniquePct\":0-100,\"verdict\":\"one sentence\"}. ' +\n    'mockedPct = how much is mocked/stubbed; fakePct = how hollow/facade it is; ' +\n    'uniquePct = how distinctive vs boilerplate.'\n  const user =\n    (opts.intent ? `Intended deliverable: ${opts.intent}\\n\\n` : '') +\n    `Produced files:\\n${fileDigest(files, { prioritize: opts.prioritize })}`\n  try {\n    const raw = await complete(system, user)\n    const m = raw.match(/\\{[\\s\\S]*\\}/)\n    if (!m)\n      return { mockedPct: 100, fakePct: 100, uniquePct: 0, verdict: 'unparseable judge response' }\n    const j = JSON.parse(m[0]) as Record<string, unknown>\n    return {\n      mockedPct: clampPct(j.mockedPct),\n      fakePct: clampPct(j.fakePct),\n      uniquePct: clampPct(j.uniquePct),\n      verdict: typeof j.verdict === 'string' ? j.verdict : '',\n    }\n  } catch (err) {\n    return {\n      mockedPct: 100,\n      fakePct: 100,\n      uniquePct: 0,\n      verdict: `judge error: ${err instanceof Error ? err.message : String(err)}`,\n    }\n  }\n}\n\n// Domain `AuthenticitySignals` (e.g. a Solidity/Fhenix preset) live in the\n// CONSUMER, not the substrate — this module stays domain-agnostic.\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/authenticity/index.ts"],"sourcesContent":["/**\n * Authenticity — \"is this real, or convincing BS?\"\n *\n * Pass/build-style scoring rewards anything that compiles and renders, so an\n * agent can ship a polished frontend with a FAKE in-browser engine and zero of\n * the required on-chain/contract work, and outscore a half-finished real\n * implementation. This module scores what buildability does not: did the agent\n * actually build the intended thing on the intended infra, or fake it.\n *\n * Two layers:\n *   - DETERMINISTIC `scoreAuthenticity` — calibrated by construction (no LLM,\n *     trustworthy today). Structural signals over the produced files, driven by\n *     a domain `AuthenticitySignals` config: required artifact present, real\n *     implementation of the hard part, real infra calls, wiring, fake-shim\n *     detection, mock/stub density.\n *   - LLM NUANCE `scoreAuthenticityNuance` — mocked% / fake% / unique% for the\n *     \"looks real but is hollow\" cases structure can't see.\n *\n * `gateRealness` is the anti-Goodhart gate: a submission missing the required\n * artifact (or faking it) is capped and cannot rank high regardless of how\n * buildable it is. Domain-agnostic; ships a Solidity/Fhenix preset.\n *\n * Input is the produced-state currency: `{ path, content }[]` — exactly what\n * `extractProducedState(...).artifacts` yields, so any consumer can feed a run's\n * produced state straight in.\n */\n\nexport interface ProducedFile {\n  path: string\n  content?: string\n}\n\nexport interface AuthenticitySignals {\n  /** Human label for the domain (e.g. 'fhenix-fhe'). */\n  label: string\n  /** A file the task REQUIRES (e.g. /\\.sol$/ for an on-chain task). */\n  requiredArtifact?: RegExp\n  /** Vendored/3rd-party paths to exclude from required-artifact detection. */\n  vendored?: RegExp\n  /** Real implementation of the hard part, inside the required artifact\n   *  (e.g. Fhenix encrypted types + FHE.* ops). Matched against content, so it\n   *  fails on comments/strings only if the regex is written tightly. */\n  realImpl: RegExp\n  /** Real use of the intended client infra (e.g. cofhejs.encrypt() calls). */\n  realInfra: RegExp\n  /** Evidence the artifact is actually wired/used (e.g. contract writes). */\n  wiring?: RegExp\n  /** A fake shim standing in for the real thing — matched on file path AND body. */\n  fakeShim: RegExp\n  /** Mock/stub/TODO markers. Defaults to a generic set. */\n  mock?: RegExp\n  /** Score weights (default 40/25/20/15). */\n  weights?: { artifact?: number; impl?: number; infra?: number; wiring?: number }\n}\n\nexport interface AuthenticityResult {\n  /** Deterministic realness, 0 (BS) … 100 (real on real infra). */\n  realness: number\n  requiredArtifactPresent: boolean\n  requiredArtifactCount: number\n  usesRealImpl: boolean\n  realInfra: boolean\n  wired: boolean\n  /** The required artifact is actually referenced/imported by other (non-artifact)\n   *  files — i.e. wired into the rest of the system, not dead code. Domain-agnostic:\n   *  a deliverable nothing else uses is suspect in any vertical. */\n  artifactReferenced: boolean\n  /** Convenience: the artifact is connected to the running system, via either the\n   *  domain wiring signal OR a structural reference. */\n  artifactWired: boolean\n  fakeShim: boolean\n  /** mock/stub markers per 1000 LOC, capped at 100. */\n  mockDensity: number\n  /** Human-readable BS flags — what's missing or faked. */\n  flags: string[]\n}\n\nconst DEFAULT_MOCK =\n  /\\bmock|\\bfake|\\bdummy|\\bstub\\b|simulat|hardcoded|placeholder|TODO|not\\s+implemented|FIXME/i\n\nfunction basename(p: string): string {\n  return p.split('/').pop() ?? p\n}\n\nfunction escapeRe(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/** Top-level symbols a source file declares (contract/library/class/etc.), used to\n *  test whether other files reference the artifact. Language-agnostic keyword set. */\nfunction declaredNames(content: string): string[] {\n  const names = new Set<string>()\n  const re =\n    /\\b(?:contract|library|interface|abstract\\s+contract|class|enum|struct|module|package)\\s+([A-Za-z_]\\w*)/g\n  let m: RegExpExecArray | null\n  while ((m = re.exec(content))) {\n    const name = m[1]\n    if (name && name.length >= 4) names.add(name)\n  }\n  return [...names]\n}\n\n/** Is a required artifact referenced/imported by any non-artifact file? Catches the\n *  \"decorative / dead-code artifact\" facade (a real-looking deliverable nothing in\n *  the running system imports, deploys, or calls). Purely structural — no domain. */\nfunction isArtifactReferenced(\n  required: readonly ProducedFile[],\n  others: readonly ProducedFile[],\n): boolean {\n  if (!required.length || !others.length) return false\n  return required.some((rf) => {\n    const stem = rf.path.replace(/\\.[^.]+$/, '') // import-path stem (no ext)\n    const base = basename(rf.path) // filename incl. ext\n    const names = declaredNames(rf.content ?? '')\n    return others.some((o) => {\n      const c = o.content ?? ''\n      if (!c) return false\n      if (c.includes(base) || c.includes(stem)) return true // import of the path\n      return names.some((n) => new RegExp(`\\\\b${escapeRe(n)}\\\\b`).test(c)) // symbol reference\n    })\n  })\n}\n\n/** Deterministic authenticity scan of produced files. Pure — same files in,\n *  same score out. No LLM, no IO. */\nexport function scoreAuthenticity(\n  files: readonly ProducedFile[],\n  signals: AuthenticitySignals,\n): AuthenticityResult {\n  const w = {\n    artifact: signals.weights?.artifact ?? 40,\n    impl: signals.weights?.impl ?? 25,\n    infra: signals.weights?.infra ?? 20,\n    wiring: signals.weights?.wiring ?? 15,\n  }\n  const mockRe = signals.mock ?? DEFAULT_MOCK\n\n  const required = signals.requiredArtifact\n    ? files.filter(\n        (f) => signals.requiredArtifact!.test(f.path) && !(signals.vendored?.test(f.path) ?? false),\n      )\n    : []\n  const others = signals.requiredArtifact ? files.filter((f) => !required.includes(f)) : files\n\n  const requiredText = required.map((f) => f.content ?? '').join('\\n')\n  const otherText = others.map((f) => f.content ?? '').join('\\n')\n  const allText = files.map((f) => f.content ?? '').join('\\n')\n\n  const requiredArtifactPresent = signals.requiredArtifact ? required.length > 0 : true\n  // Real impl looked for in the required artifact when there is one, else anywhere.\n  const usesRealImpl = signals.realImpl.test(signals.requiredArtifact ? requiredText : allText)\n  const realInfra = signals.realInfra.test(allText)\n  const wired = signals.wiring ? signals.wiring.test(otherText || allText) : false\n  // Structural: is the required artifact actually used by the rest of the system?\n  const artifactReferenced = isArtifactReferenced(required, others)\n  const artifactWired = wired || artifactReferenced\n  const fakeShim = files.some(\n    (f) => signals.fakeShim.test(basename(f.path)) || signals.fakeShim.test(f.content ?? ''),\n  )\n\n  const mockHits = (\n    allText.match(\n      new RegExp(mockRe.source, mockRe.flags.includes('g') ? mockRe.flags : `${mockRe.flags}g`),\n    ) ?? []\n  ).length\n  const loc = Math.max(1, allText.split('\\n').length)\n  const mockDensity = Math.min(100, Math.round((mockHits / loc) * 1000))\n\n  // A real-looking artifact that nothing in the system imports/deploys/calls is\n  // decorative (dead code) — a common facade. We REPORT this (flag + signal) but do\n  // NOT auto-penalize the score: structural reference detection is noisy (an ABI or\n  // placeholder-address file makes a dead contract look \"referenced\", while a strong\n  // contract-only submission looks \"dead\"), so a score penalty manufactures false\n  // negatives on legitimately-partial work. Gate on it only via opts.requireArtifactWired,\n  // and let the LLM-nuance layer resolve the ambiguous middle band.\n  const decorativeArtifact = requiredArtifactPresent && usesRealImpl && !artifactWired\n\n  let realness = 0\n  if (requiredArtifactPresent) realness += w.artifact\n  if (usesRealImpl) realness += w.impl\n  if (realInfra) realness += w.infra\n  if (wired) realness += w.wiring\n  if (fakeShim) realness -= 25\n  realness -= Math.min(20, mockDensity)\n  realness = Math.max(0, Math.min(100, realness))\n\n  const flags: string[] = []\n  if (signals.requiredArtifact && !requiredArtifactPresent) {\n    flags.push(\n      `NO_REQUIRED_ARTIFACT: task needs ${signals.label} artifact (${signals.requiredArtifact}); none produced`,\n    )\n  }\n  if (requiredArtifactPresent && signals.requiredArtifact && !usesRealImpl) {\n    flags.push('ARTIFACT_NO_REAL_IMPL: required artifact exists but lacks the real implementation')\n  }\n  if (fakeShim) flags.push('FAKE_SHIM: ships a client-side stand-in simulating the real infra')\n  if (!realInfra && !requiredArtifactPresent)\n    flags.push('NO_REAL_INFRA: no real infra calls — cosmetic at best')\n  if (mockDensity >= 8)\n    flags.push(`HIGH_MOCK_DENSITY: ${mockDensity} mock/stub markers per 1000 LOC`)\n  if (signals.wiring && requiredArtifactPresent && !wired)\n    flags.push('NOT_WIRED: artifact exists but is never used by the client')\n  if (decorativeArtifact)\n    flags.push(\n      'DEAD_ARTIFACT: required artifact is not referenced/imported anywhere — decorative or dead code',\n    )\n\n  return {\n    realness,\n    requiredArtifactPresent,\n    requiredArtifactCount: required.length,\n    usesRealImpl,\n    realInfra,\n    wired,\n    artifactReferenced,\n    artifactWired,\n    fakeShim,\n    mockDensity,\n    flags,\n  }\n}\n\nexport interface RealnessGate {\n  gated: boolean\n  reason?: string\n}\n\n/** Anti-Goodhart gate: a required-artifact-missing or faked submission is\n *  capped and cannot rank high regardless of buildability. */\nexport function gateRealness(\n  r: AuthenticityResult,\n  opts: { floor?: number; requireArtifact?: boolean; requireArtifactWired?: boolean } = {},\n): RealnessGate {\n  const floor = opts.floor ?? 30\n  if ((opts.requireArtifact ?? true) && !r.requiredArtifactPresent) {\n    return { gated: true, reason: 'required artifact missing' }\n  }\n  if (r.fakeShim && !r.usesRealImpl) {\n    return { gated: true, reason: 'fake shim with no real implementation' }\n  }\n  // Opt-in (default off): a vertical where the deliverable MUST be wired into the\n  // running system can reject a decorative/dead artifact. Off by default because a\n  // contract-only (incomplete-but-real) submission is legitimately partial, not fake.\n  if (\n    opts.requireArtifactWired &&\n    r.requiredArtifactPresent &&\n    r.usesRealImpl &&\n    !r.artifactWired\n  ) {\n    return { gated: true, reason: 'required artifact present but never wired into the system' }\n  }\n  if (r.realness < floor)\n    return { gated: true, reason: `realness ${r.realness} below floor ${floor}` }\n  return { gated: false }\n}\n\n// ── LLM nuance layer ─────────────────────────────────────────────────────────\n\nexport interface AuthenticityNuance {\n  /** 0 (nothing mocked) … 100 (entirely mocked). */\n  mockedPct: number\n  /** 0 (genuine) … 100 (a hollow facade / cargo-culted). */\n  fakePct: number\n  /** 0 (boilerplate/template clone) … 100 (distinctive real work). */\n  uniquePct: number\n  verdict: string\n}\n\n/** A minimal completion fn — inject your model caller (router/tcloud). Keeps\n *  this module free of any specific LLM client. */\nexport type CompleteFn = (system: string, user: string) => Promise<string>\n\nfunction fileDigest(\n  files: readonly ProducedFile[],\n  opts: { maxFiles?: number; perFile?: number; prioritize?: RegExp } = {},\n): string {\n  const maxFiles = opts.maxFiles ?? 14\n  const perFile = opts.perFile ?? 1200\n  // Lead with the required-artifact files (e.g. .sol) so a truncated digest\n  // never hides the very thing the judge must assess.\n  const ordered = opts.prioritize\n    ? [...files].sort(\n        (a, b) => Number(opts.prioritize!.test(b.path)) - Number(opts.prioritize!.test(a.path)),\n      )\n    : files\n  return ordered\n    .slice(0, maxFiles)\n    .map((f) => `// ${f.path}\\n${(f.content ?? '').slice(0, perFile)}`)\n    .join('\\n\\n')\n}\n\nfunction clampPct(v: unknown): number {\n  const n = typeof v === 'number' ? v : Number(v)\n  return Number.isFinite(n) ? Math.max(0, Math.min(100, Math.round(n))) : 0\n}\n\n/**\n * LLM nuance scoring — judges the \"looks real but is hollow\" axis structure\n * misses. Inject a `complete` caller; returns mocked/fake/unique % + a verdict.\n * Fail-soft: a bad/unparseable response yields a worst-case (fully-fake) read,\n * never a false pass.\n */\nexport async function scoreAuthenticityNuance(\n  files: readonly ProducedFile[],\n  complete: CompleteFn,\n  opts: { intent?: string; prioritize?: RegExp } = {},\n): Promise<AuthenticityNuance> {\n  const system =\n    'You audit whether an agent BUILT THE REAL THING or faked it. Be skeptical: ' +\n    'a pretty UI, cosmetic labels, simulated/in-memory stand-ins for real infra, ' +\n    'and cargo-culted imports do NOT count as real. Respond with ONLY JSON: ' +\n    '{\"mockedPct\":0-100,\"fakePct\":0-100,\"uniquePct\":0-100,\"verdict\":\"one sentence\"}. ' +\n    'mockedPct = how much is mocked/stubbed; fakePct = how hollow/facade it is; ' +\n    'uniquePct = how distinctive vs boilerplate.'\n  const user =\n    (opts.intent ? `Intended deliverable: ${opts.intent}\\n\\n` : '') +\n    `Produced files:\\n${fileDigest(files, { prioritize: opts.prioritize })}`\n  try {\n    const raw = await complete(system, user)\n    const m = raw.match(/\\{[\\s\\S]*\\}/)\n    if (!m)\n      return { mockedPct: 100, fakePct: 100, uniquePct: 0, verdict: 'unparseable judge response' }\n    const j = JSON.parse(m[0]) as Record<string, unknown>\n    return {\n      mockedPct: clampPct(j.mockedPct),\n      fakePct: clampPct(j.fakePct),\n      uniquePct: clampPct(j.uniquePct),\n      verdict: typeof j.verdict === 'string' ? j.verdict : '',\n    }\n  } catch (err) {\n    return {\n      mockedPct: 100,\n      fakePct: 100,\n      uniquePct: 0,\n      verdict: `judge error: ${err instanceof Error ? err.message : String(err)}`,\n    }\n  }\n}\n\n// ── Realness-direct LLM judge ─────────────────────────────────────────────────\n\nexport interface RealnessJudgment {\n  /** 0 (facade/simulator) … 100 (real implementation on the intended infra). */\n  isReal: number\n  rationale: string\n}\n\n/**\n * Ask an LLM to rate realness DIRECTLY on a 0-100 scale — the axis that matched\n * human blind-labels in validation (F1 0.80→0.88 on the gray band; a fakePct/\n * hollowness proxy over-penalized \"real core + stubbed periphery\" partials, and a\n * weak judge model over-flagged — use a strong one). Domain-agnostic skeleton; the\n * consumer supplies `intent` (what the deliverable should be) and `rubric` (domain\n * specifics of real-vs-fake). Fail-closed: a bad response reads as fully fake.\n */\nexport async function judgeRealnessLlm(\n  files: readonly ProducedFile[],\n  complete: CompleteFn,\n  opts: { intent?: string; rubric?: string; prioritize?: RegExp } = {},\n): Promise<RealnessJudgment> {\n  const system =\n    \"You are a skeptical auditor. Rate how REAL an agent's build is vs the intended \" +\n    'deliverable, 0-100. A genuine implementation of the HARD part on the intended ' +\n    'infrastructure is SUBSTANTIALLY REAL (>=50) even if peripheral layers are stubbed; ' +\n    'a pure simulator / facade / branded-type stand-in / no-op-stubbed dependency with ' +\n    'no real implementation is FAKE (<=25). Judge the core on its merits and note the ' +\n    'runtime. ' +\n    (opts.rubric ? `Domain rubric: ${opts.rubric} ` : '') +\n    'Respond with ONLY JSON: {\"isReal\":0-100,\"why\":\"one sentence\"}.'\n  const user =\n    (opts.intent ? `Intended deliverable: ${opts.intent}\\n\\n` : '') +\n    `Produced files:\\n${fileDigest(files, { prioritize: opts.prioritize })}`\n  try {\n    const raw = await complete(system, user)\n    const m = raw.match(/\\{[\\s\\S]*\\}/)\n    if (!m) return { isReal: 0, rationale: 'unparseable judge response' }\n    const j = JSON.parse(m[0]) as Record<string, unknown>\n    return {\n      isReal: clampPct(j.isReal),\n      rationale: typeof j.why === 'string' ? j.why : '',\n    }\n  } catch (err) {\n    return {\n      isReal: 0,\n      rationale: `judge error: ${err instanceof Error ? err.message : String(err)}`,\n    }\n  }\n}\n\n// ── Blended pipeline: deterministic for the clean extremes, LLM for the gray band ─\n\nexport type RealnessBand = 'clean-real' | 'clean-fake' | 'gray'\n\nexport interface BlendedRealness extends AuthenticityResult {\n  /** Final realness after (only-when-needed) LLM adjudication, 0…100. */\n  blendedRealness: number\n  band: RealnessBand\n  /** True iff the LLM judge was actually consulted (gray band only). */\n  consultedLlm: boolean\n  /** Present iff the LLM was consulted. */\n  judgment?: RealnessJudgment\n}\n\n/**\n * Score realness using the cheapest sufficient signal: trust the deterministic\n * scorer on the CLEAN extremes (obvious fakes / obviously-real-and-wired), and only\n * spend an LLM call on the GRAY band — cells that look real structurally but carry\n * fakeness markers (a fake shim, an unwired/dead artifact, high mock density) or land\n * mid-range. This caps LLM cost at the fraction of cells static analysis can't\n * resolve, which matters at multi-vertical / multi-partner scale.\n *\n * Domain-agnostic: the gray-band TRIGGER is structural; the LLM judges via the\n * consumer-supplied `intent`. Fail-closed (a bad LLM response reads as fully fake).\n */\nexport async function scoreRealnessBlended(\n  files: readonly ProducedFile[],\n  signals: AuthenticitySignals,\n  complete: CompleteFn,\n  opts: {\n    intent?: string\n    rubric?: string\n    grayBand?: [number, number]\n    mockGrayThreshold?: number\n  } = {},\n): Promise<BlendedRealness> {\n  const det = scoreAuthenticity(files, signals)\n  const [lo, hi] = opts.grayBand ?? [30, 70]\n  const mockGray = opts.mockGrayThreshold ?? 8\n\n  // Structural conflict: a real artifact whose RUNTIME authenticity static analysis\n  // can't settle — a fake shim is present, or it isn't wired to a real client (could\n  // be a decorative contract next to a simulator, OR an incomplete-but-real build),\n  // or mock density is high. Empirically (21 labeled cells) this routes 100% of the\n  // deterministic errors to the LLM while leaving an error-free clean band.\n  const conflict =\n    det.requiredArtifactPresent &&\n    det.usesRealImpl &&\n    (det.fakeShim || !det.wired || det.mockDensity >= mockGray)\n  const midRange = det.realness >= lo && det.realness <= hi\n\n  let band: RealnessBand\n  if (conflict || midRange) band = 'gray'\n  else if (det.realness < lo) band = 'clean-fake'\n  else band = 'clean-real'\n\n  if (band !== 'gray') {\n    return { ...det, blendedRealness: det.realness, band, consultedLlm: false }\n  }\n\n  // In the gray band the LLM read dominates (that's why we paid for it), with the\n  // deterministic score as a light anchor. Weights 0.25/0.75 validated against blind\n  // human labels (F1 0.88 vs 0.80 deterministic-only).\n  const judgment = await judgeRealnessLlm(files, complete, {\n    intent: opts.intent,\n    rubric: opts.rubric,\n    prioritize: signals.requiredArtifact,\n  })\n  const blendedRealness = Math.max(\n    0,\n    Math.min(100, Math.round(0.25 * det.realness + 0.75 * judgment.isReal)),\n  )\n  return { ...det, blendedRealness, band, consultedLlm: true, judgment }\n}\n\n// Domain `AuthenticitySignals` (e.g. a Solidity/Fhenix preset) live in the\n// CONSUMER, not the substrate — this module stays domain-agnostic.\n"],"mappings":"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","names":[]}

package/dist/benchmarks/index.d.ts

@@ -1,4 +1,4 @@
-export { B as BENCHMARK_SPLIT_SEED, a as BenchmarkAdapter, b as BenchmarkDatasetItem, c as BenchmarkEvaluation, d as deterministicSplit, e as routing } from '../index-DsnOpCO6.js';
-import '../run-record-BgTFzO2r.js';
+export { B as BENCHMARK_SPLIT_SEED, a as BenchmarkAdapter, b as BenchmarkDatasetItem, c as BenchmarkEvaluation, d as deterministicSplit, e as routing } from '../index-B1RKber3.js';
+import '../run-record-sItO5ftF.js';
 import '../errors-Dwqw-T_m.js';
 import '../schema-m0gsnbt3.js';

package/dist/campaign/index.d.ts

@@ -1,16 +1,16 @@
 import { A as AnalyzeTracesOptions, a as AnalyzeTracesInput, b as AnalyzeTracesResult } from '../analyst-t7zZS3TV.js';
-import { S as Scenario, M as MutableSurface, b as DispatchContext, a as JudgeConfig, I as ImprovementDriver, q as ProposeContext, J as JudgeScore, L as LabeledScenarioStore, r as LabeledScenarioWrite, s as LabeledScenarioSampleArgs, t as LabeledScenarioRecord, u as LabelTrust, v as LabeledScenarioSource, f as CampaignResult, h as CodeSurface } from '../types-Bba0vl1V.js';
-export { C as CampaignAggregates, c as CampaignArtifactWriter, d as CampaignCellResult, e as CampaignCostMeter, w as CampaignTokenUsage, g as CampaignTraceWriter, D as DispatchFn, G as Gate, i as GateContext, j as GateDecision, k as GateResult, l as GenerationCandidate, m as GenerationRecord, x as JudgeAggregate, n as JudgeDimension, o as Mutator, O as OptimizerConfig, P as ParetoParent, y as ProposedCandidate, R as RedactionStatus, z as ScenarioAggregate, p as SessionScript, T as TraceSpan, A as isProposedCandidate, B as labelTrustRank } from '../types-Bba0vl1V.js';
-import { a as RunCampaignOptions, b as RunImprovementLoopOptions, C as CampaignStorage } from '../run-improvement-loop-BqYH2vCR.js';
-export { d as GepaDriverConstraints, G as GepaDriverOptions, O as OpenAutoPrOptions, e as OpenAutoPrResult, R as RunImprovementLoopResult, h as RunOptimizationOptions, j as RunOptimizationResult, k as countSentenceEdits, l as defaultRenderDiff, m as extractH2Sections, f as fsCampaignStorage, g as gepaDriver, i as inMemoryCampaignStorage, o as openAutoPr, r as runCampaign, c as runImprovementLoop, n as runOptimization, s as surfaceHash } from '../run-improvement-loop-BqYH2vCR.js';
-export { A as AxisEvidence, a as AxisVerdict, B as BuildEvidenceVectorOptions, k as BuildLoopProvenanceArgs, D as DefaultProductionGateOptions, l as EmitLoopProvenanceArgs, m as EmitLoopProvenanceResult, E as EvidenceVector, b as EvolutionaryDriverOptions, H as HeldOutGateOptions, n as LoopProvenanceBackend, o as LoopProvenanceCandidate, L as LoopProvenanceRecord, O as ObjectiveSource, P as ParetoSignificanceGateOptions, c as PromotionObjective, d as PromotionPolicy, R as RunEvalOptions, e as buildEvidenceVector, q as buildLoopProvenanceRecord, f as composeGate, g as defaultProductionGate, s as emitLoopProvenance, h as evolutionaryDriver, i as heldOutGate, t as loopProvenanceSpans, p as paretoPolicy, j as paretoSignificanceGate, u as provenanceRecordPath, v as provenanceSpansPath, r as runEval, w as surfaceContentHash } from '../provenance-B-TFszPW.js';
+import { S as Scenario, M as MutableSurface, b as DispatchContext, a as JudgeConfig, I as ImprovementDriver, q as ProposeContext, J as JudgeScore, L as LabeledScenarioStore, r as LabeledScenarioWrite, s as LabeledScenarioSampleArgs, t as LabeledScenarioRecord, u as LabelTrust, v as LabeledScenarioSource, f as CampaignResult, h as CodeSurface } from '../types-QHG0KnkF.js';
+export { C as CampaignAggregates, c as CampaignArtifactWriter, d as CampaignCellResult, e as CampaignCostMeter, w as CampaignTokenUsage, g as CampaignTraceWriter, D as DispatchFn, G as Gate, i as GateContext, j as GateDecision, k as GateResult, l as GenerationCandidate, m as GenerationRecord, x as JudgeAggregate, n as JudgeDimension, o as Mutator, O as OptimizerConfig, P as ParetoParent, y as ProposedCandidate, R as RedactionStatus, z as ScenarioAggregate, p as SessionScript, T as TraceSpan, A as isProposedCandidate, B as labelTrustRank } from '../types-QHG0KnkF.js';
+import { a as RunCampaignOptions, b as RunImprovementLoopOptions, C as CampaignStorage } from '../run-improvement-loop-Bgu4C59E.js';
+export { d as GepaDriverConstraints, G as GepaDriverOptions, O as OpenAutoPrOptions, e as OpenAutoPrResult, R as RunImprovementLoopResult, h as RunOptimizationOptions, j as RunOptimizationResult, k as countSentenceEdits, l as defaultRenderDiff, m as extractH2Sections, f as fsCampaignStorage, g as gepaDriver, i as inMemoryCampaignStorage, o as openAutoPr, r as runCampaign, c as runImprovementLoop, n as runOptimization, s as surfaceHash } from '../run-improvement-loop-Bgu4C59E.js';
+export { A as AxisEvidence, a as AxisVerdict, B as BuildEvidenceVectorOptions, k as BuildLoopProvenanceArgs, D as DefaultProductionGateOptions, l as EmitLoopProvenanceArgs, m as EmitLoopProvenanceResult, E as EvidenceVector, b as EvolutionaryDriverOptions, H as HeldOutGateOptions, n as LoopProvenanceBackend, o as LoopProvenanceCandidate, L as LoopProvenanceRecord, O as ObjectiveSource, P as ParetoSignificanceGateOptions, c as PromotionObjective, d as PromotionPolicy, R as RunEvalOptions, e as buildEvidenceVector, q as buildLoopProvenanceRecord, f as composeGate, g as defaultProductionGate, s as emitLoopProvenance, h as evolutionaryDriver, i as heldOutGate, t as loopProvenanceSpans, p as paretoPolicy, j as paretoSignificanceGate, u as provenanceRecordPath, v as provenanceSpansPath, r as runEval, w as surfaceContentHash } from '../provenance-CEAJI9rm.js';
 import { L as LlmClientOptions } from '../llm-client-DbjLfz-K.js';
-import { c as TraceAnalystKindSpec } from '../kind-factory-DW9XWPvM.js';
-import { c as AnalystFinding } from '../types-CRD68aH7.js';
+import { c as TraceAnalystKindSpec } from '../kind-factory-DqV2t1Xk.js';
+import { c as AnalystFinding } from '../types-DRvV0zRo.js';
 import { a as PairedBootstrapResult } from '../statistics-B7yCbi9i.js';
-import { A as AgentProfile, B as BackendIntegrityReport, C as CompletionRequirement, R as RuntimeEventLike, a as CompletionVerdict, P as ProducedState, b as CorrectnessChecker } from '../agent-profile-DYRboYWu.js';
+import { A as AgentProfile, B as BackendIntegrityReport, C as CompletionRequirement, R as RuntimeEventLike, a as CompletionVerdict, P as ProducedState, b as CorrectnessChecker } from '../agent-profile-aSEaJ9Pl.js';
 import { A as AgentEvalError } from '../errors-Dwqw-T_m.js';
-import { b as RunSplitTag, R as RunRecord } from '../run-record-BgTFzO2r.js';
+import { b as RunSplitTag, R as RunRecord } from '../run-record-sItO5ftF.js';
 import '@ax-llm/ax';
 import '../store-GmBE2pZZ.js';
 import '../red-team-DW9Ca_tj.js';
@@ -19,8 +19,8 @@ import '../store-CKUAgsJz.js';
 import '../schema-m0gsnbt3.js';
 import '../pareto-E-pembql.js';
 import '../hosted/index.js';
-import '../insight-report-Df3lxYXM.js';
-import '../summary-report-ByiOUrHj.js';
+import '../insight-report-dlpEzQDi.js';
+import '../summary-report-BTaXq1TS.js';
 import '../failure-cluster-CL7IVgkJ.js';
 import '../judge-calibration-DilmB3Ml.js';
 import '../raw-provider-sink-C46HDghv.js';

package/dist/campaign/index.js

@@ -10,7 +10,7 @@ import {
   paretoPolicy,
   paretoSignificanceGate,
   runEval
-} from "../chunk-XPILG2CA.js";
+} from "../chunk-GXHLRXDI.js";
 import {
   agentProfileHash,
   estimateCost,
@@ -39,7 +39,7 @@ import {
   runOptimization,
   surfaceContentHash,
   surfaceHash
-} from "../chunk-JYE3WOTE.js";
+} from "../chunk-RPLZ4OIB.js";
 import {
   assertRealBackend,
   fsCampaignStorage,
@@ -51,7 +51,7 @@ import {
   AnalystRegistry,
   DEFAULT_TRACE_ANALYST_KINDS,
   createTraceAnalystKind
-} from "../chunk-WYIHD6EB.js";
+} from "../chunk-CF67I6QY.js";
 import "../chunk-YV7J7X5N.js";
 import {
   callLlm
@@ -67,7 +67,7 @@ import {
 import "../chunk-PC4UYEBM.js";
 import {
   validateRunRecord
-} from "../chunk-F3SRAAZO.js";
+} from "../chunk-KWRRMR3J.js";
 import "../chunk-VSMTAMNK.js";
 import {
   AgentEvalError

package/dist/{chunk-7W4SM7FD.js → chunk-5LVWPNS5.js}

@@ -4,7 +4,7 @@ import {
   computeFindingId,
   createTraceAnalystKind,
   makeFinding
-} from "./chunk-WYIHD6EB.js";
+} from "./chunk-CF67I6QY.js";
 import {
   LlmClient,
   callLlmJson
@@ -24,6 +24,93 @@ function createAnalystAi(config) {
   });
 }
 
+// src/analyst/chat-client.ts
+function createChatClient(opts) {
+  switch (opts.transport) {
+    case "router":
+      return wrapLlmClient(
+        opts.transport,
+        opts.defaultModel,
+        new LlmClient({
+          baseUrl: opts.baseUrl ?? "https://router.tangle.tools/v1",
+          apiKey: opts.apiKey
+        })
+      );
+    case "cli-bridge":
+      return wrapLlmClient(
+        opts.transport,
+        opts.defaultModel,
+        new LlmClient({
+          baseUrl: opts.baseUrl ?? "http://127.0.0.1:3344/v1",
+          apiKey: opts.bearer ?? ""
+        })
+      );
+    case "direct-provider":
+      return wrapLlmClient(
+        opts.transport,
+        opts.defaultModel,
+        new LlmClient({
+          baseUrl: opts.baseUrl,
+          apiKey: opts.apiKey
+        })
+      );
+    case "sandbox-sdk":
+      return {
+        transport: "sandbox-sdk",
+        defaultModel: opts.defaultModel,
+        chat: async (req, callOpts) => opts.chat(resolveModel(req, opts.defaultModel), callOpts)
+      };
+    case "mock":
+      return {
+        transport: "mock",
+        defaultModel: opts.defaultModel,
+        chat: async (req, callOpts) => opts.handler(resolveModel(req, opts.defaultModel), callOpts)
+      };
+  }
+}
+function wrapLlmClient(transport, defaultModel, inner) {
+  return {
+    transport,
+    defaultModel,
+    chat: async (req, callOpts) => {
+      const resolved = resolveModel(req, defaultModel);
+      const call = inner.call({
+        model: resolved.model,
+        messages: req.messages,
+        jsonMode: req.jsonMode,
+        jsonSchema: req.jsonSchema,
+        temperature: req.temperature,
+        maxTokens: req.maxTokens,
+        timeoutMs: req.timeoutMs
+      });
+      if (!callOpts?.signal) return await call;
+      return await Promise.race([call, abortAsRejection(callOpts.signal)]);
+    }
+  };
+}
+function abortAsRejection(signal) {
+  if (signal.aborted) return Promise.reject(toAbortError(signal));
+  return new Promise((_, reject) => {
+    signal.addEventListener("abort", () => reject(toAbortError(signal)), { once: true });
+  });
+}
+function toAbortError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error) return reason;
+  const e = new Error("ChatClient.chat: aborted");
+  e.name = "AbortError";
+  return e;
+}
+function resolveModel(req, defaultModel) {
+  if (req.model) return req;
+  if (!defaultModel) {
+    throw new Error(
+      "ChatClient.chat: no model on request and no defaultModel on the client. Either pass req.model or bind defaultModel at createChatClient()."
+    );
+  }
+  return { ...req, model: defaultModel };
+}
+
 // src/trace-analyst/behavioral-metrics.ts
 var INPUT_GROWTH_FACTOR = 3;
 var MIN_TOOL_CALLS = 3;
@@ -959,95 +1046,9 @@ function createSemanticConceptJudge(options = {}) {
   return (input) => runSemanticConceptJudge(input, options);
 }
 
-// src/analyst/chat-client.ts
-function createChatClient(opts) {
-  switch (opts.transport) {
-    case "router":
-      return wrapLlmClient(
-        opts.transport,
-        opts.defaultModel,
-        new LlmClient({
-          baseUrl: opts.baseUrl ?? "https://router.tangle.tools/v1",
-          apiKey: opts.apiKey
-        })
-      );
-    case "cli-bridge":
-      return wrapLlmClient(
-        opts.transport,
-        opts.defaultModel,
-        new LlmClient({
-          baseUrl: opts.baseUrl ?? "http://127.0.0.1:3344/v1",
-          apiKey: opts.bearer ?? ""
-        })
-      );
-    case "direct-provider":
-      return wrapLlmClient(
-        opts.transport,
-        opts.defaultModel,
-        new LlmClient({
-          baseUrl: opts.baseUrl,
-          apiKey: opts.apiKey
-        })
-      );
-    case "sandbox-sdk":
-      return {
-        transport: "sandbox-sdk",
-        defaultModel: opts.defaultModel,
-        chat: async (req, callOpts) => opts.chat(resolveModel(req, opts.defaultModel), callOpts)
-      };
-    case "mock":
-      return {
-        transport: "mock",
-        defaultModel: opts.defaultModel,
-        chat: async (req, callOpts) => opts.handler(resolveModel(req, opts.defaultModel), callOpts)
-      };
-  }
-}
-function wrapLlmClient(transport, defaultModel, inner) {
-  return {
-    transport,
-    defaultModel,
-    chat: async (req, callOpts) => {
-      const resolved = resolveModel(req, defaultModel);
-      const call = inner.call({
-        model: resolved.model,
-        messages: req.messages,
-        jsonMode: req.jsonMode,
-        jsonSchema: req.jsonSchema,
-        temperature: req.temperature,
-        maxTokens: req.maxTokens,
-        timeoutMs: req.timeoutMs
-      });
-      if (!callOpts?.signal) return await call;
-      return await Promise.race([call, abortAsRejection(callOpts.signal)]);
-    }
-  };
-}
-function abortAsRejection(signal) {
-  if (signal.aborted) return Promise.reject(toAbortError(signal));
-  return new Promise((_, reject) => {
-    signal.addEventListener("abort", () => reject(toAbortError(signal)), { once: true });
-  });
-}
-function toAbortError(signal) {
-  const reason = signal.reason;
-  if (reason instanceof Error) return reason;
-  const e = new Error("ChatClient.chat: aborted");
-  e.name = "AbortError";
-  return e;
-}
-function resolveModel(req, defaultModel) {
-  if (req.model) return req;
-  if (!defaultModel) {
-    throw new Error(
-      "ChatClient.chat: no model on request and no defaultModel on the client. Either pass req.model or bind defaultModel at createChatClient()."
-    );
-  }
-  return { ...req, model: defaultModel };
-}
-
 export {
   createAnalystAi,
+  createChatClient,
   computeTraceMetrics,
   deriveEfficiencyFindings,
   behavioralAnalyst,
@@ -1069,7 +1070,6 @@ export {
   DEFAULT_COMPLEXITY_WEIGHTS,
   SEMANTIC_CONCEPT_JUDGE_VERSION,
   runSemanticConceptJudge,
-  createSemanticConceptJudge,
-  createChatClient
+  createSemanticConceptJudge
 };
-//# sourceMappingURL=chunk-7W4SM7FD.js.map
+//# sourceMappingURL=chunk-5LVWPNS5.js.map

package/dist/chunk-5LVWPNS5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/analyst/ax-service.ts","../src/analyst/chat-client.ts","../src/trace-analyst/behavioral-metrics.ts","../src/analyst/behavioral-analyst.ts","../src/analyst/default-registry.ts","../src/concurrency.ts","../src/locked-jsonl-appender.ts","../src/analyst/findings-store.ts","../src/analyst/kinds/skill-usage.ts","../src/run-score.ts","../src/run-critic.ts","../src/semantic-concept-judge.ts"],"sourcesContent":["import type { AxAIService } from '@ax-llm/ax'\nimport { ai } from '@ax-llm/ax'\n\nexport interface CreateAnalystAiConfig {\n  /** OpenAI-compatible API key forwarded as `Authorization: Bearer`.\n   *  cli-bridge ignores the value on loopback but Ax requires a non-empty string. */\n  apiKey: string\n  /** OpenAI-compatible base URL — e.g. `https://router.tangle.tools/v1` or a\n   *  cli-bridge loopback. */\n  baseUrl: string\n  /** Model id forwarded to the analyst actor + responder. */\n  model: string\n  /** Ax provider name. Defaults to the OpenAI-compatible client. */\n  provider?: 'openai' | 'anthropic'\n}\n\n/**\n * Construct the `AxAIService` an analyst kind calls through\n * (`createTraceAnalystKind({ ai })`).\n *\n * Ax's `ai()` pins `config.model` to the OpenAI catalog enum, but every\n * OpenAI-compatible router an analyst points at (router.tangle.tools,\n * cli-bridge) accepts arbitrary model ids (claude-code/sonnet, openai/gpt-5.4,\n * …). Consumers were each re-rolling `ai({ name, apiKey, apiURL, config })`\n * behind an `as (a: any) => any` cast to dodge the enum; this is the one\n * canonical constructor so they don't have to — and don't take a direct\n * `@ax-llm/ax` dependency for it.\n */\nexport function createAnalystAi(config: CreateAnalystAiConfig): AxAIService {\n  return ai({\n    name: config.provider ?? 'openai',\n    apiKey: config.apiKey,\n    apiURL: config.baseUrl,\n    config: { model: config.model },\n  })\n}\n","/**\n * ChatClient — the single LLM abstraction analysts call.\n *\n * agent-eval already ships an `LlmClient` (OpenAI-compatible, retry,\n * graceful JSON-schema degrade) and judges that talk to `TCloud`. Two\n * mixed patterns force every analyst author to pick a transport, which\n * couples analyst code to runtime concerns (cli-bridge vs router vs\n * sandbox-sdk) it shouldn't know about.\n *\n * `ChatClient` is one interface every analyst takes via `AnalystContext.chat`.\n * The operator decides at the registry boundary which transport binds\n * to it. Analyst code stays transport-agnostic; swapping production\n * (sandbox-sdk) for local dev (cli-bridge) or tests (mock) is a one-\n * line factory call.\n *\n * Designed to coexist: existing `LlmClient` callers and existing\n * `TCloud`-based judges keep working untouched. New analyst code uses\n * `ChatClient`. When old call sites migrate, they pick up budgeting,\n * cancellation, and unified telemetry for free.\n */\n\nimport {\n  type LlmCallRequest,\n  type LlmCallResult,\n  LlmClient,\n  type LlmClientOptions,\n} from '../llm-client'\n\n/**\n * Unified chat interface. Mirrors LlmCallRequest/Result so the OpenAI-\n * compatible mental model stays. Two methods: a one-shot `chat()` and\n * an `streamChat()` for future agentic loops (not yet exposed).\n */\nexport interface ChatClient {\n  /** Display name of the bound transport — included in telemetry. */\n  readonly transport: ChatTransport\n  /** Default model when caller omits — operators bind this per environment. */\n  readonly defaultModel?: string\n\n  chat(req: ChatRequest, opts?: ChatCallOpts): Promise<ChatResponse>\n}\n\nexport type ChatTransport =\n  | 'router' // router.tangle.tools — production paid models\n  | 'sandbox-sdk' // box.streamPrompt() — chat completion via sandbox SDK\n  | 'cli-bridge' // local cli-bridge for dev / local-only runs\n  | 'direct-provider' // direct OpenAI / Anthropic / etc. — bypass router\n  | 'mock' // test-time injection\n\nexport interface ChatRequest extends Omit<LlmCallRequest, 'model'> {\n  /** Optional — falls back to ChatClient.defaultModel. */\n  model?: string\n}\n\nexport type ChatResponse = LlmCallResult\n\nexport interface ChatCallOpts {\n  /** Cancel the in-flight request. */\n  signal?: AbortSignal\n  /** Hard USD ceiling for this single call (informational; the underlying transport may not enforce). */\n  maxCostUsd?: number\n  /** Correlation tag carried into request headers when the transport allows. */\n  correlationId?: string\n}\n\n// ── Factory ─────────────────────────────────────────────────────────\n\nexport type CreateChatClientOpts =\n  | RouterTransportOpts\n  | CliBridgeTransportOpts\n  | DirectProviderTransportOpts\n  | SandboxSdkTransportOpts\n  | MockTransportOpts\n\ninterface BaseTransportOpts {\n  defaultModel?: string\n}\n\nexport interface RouterTransportOpts extends BaseTransportOpts {\n  transport: 'router'\n  baseUrl?: string\n  apiKey: string\n}\n\nexport interface CliBridgeTransportOpts extends BaseTransportOpts {\n  transport: 'cli-bridge'\n  baseUrl?: string\n  bearer?: string\n}\n\nexport interface DirectProviderTransportOpts extends BaseTransportOpts {\n  transport: 'direct-provider'\n  baseUrl: string\n  apiKey: string\n}\n\n/**\n * Sandbox-SDK transport. Provided as a thin pass-through: the caller\n * supplies a callable that mimics LlmClient.chat() against an already-\n * configured Sandbox handle. We don't import the SDK here to keep\n * agent-eval dep-free of @tangle-network/sandbox.\n */\nexport interface SandboxSdkTransportOpts extends BaseTransportOpts {\n  transport: 'sandbox-sdk'\n  chat: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>\n}\n\n/**\n * Mock transport for tests. The handler receives the request and returns\n * whatever the test wants. No retries, no JSON-schema degrade.\n */\nexport interface MockTransportOpts extends BaseTransportOpts {\n  transport: 'mock'\n  handler: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>\n}\n\n/**\n * Build a ChatClient bound to a specific transport. The returned client\n * is safe to share across analysts in a single registry run.\n */\nexport function createChatClient(opts: CreateChatClientOpts): ChatClient {\n  switch (opts.transport) {\n    case 'router':\n      return wrapLlmClient(\n        opts.transport,\n        opts.defaultModel,\n        new LlmClient({\n          baseUrl: opts.baseUrl ?? 'https://router.tangle.tools/v1',\n          apiKey: opts.apiKey,\n        } as LlmClientOptions),\n      )\n    case 'cli-bridge':\n      return wrapLlmClient(\n        opts.transport,\n        opts.defaultModel,\n        new LlmClient({\n          baseUrl: opts.baseUrl ?? 'http://127.0.0.1:3344/v1',\n          apiKey: opts.bearer ?? '',\n        } as LlmClientOptions),\n      )\n    case 'direct-provider':\n      return wrapLlmClient(\n        opts.transport,\n        opts.defaultModel,\n        new LlmClient({\n          baseUrl: opts.baseUrl,\n          apiKey: opts.apiKey,\n        } as LlmClientOptions),\n      )\n    case 'sandbox-sdk':\n      return {\n        transport: 'sandbox-sdk',\n        defaultModel: opts.defaultModel,\n        chat: async (req, callOpts) => opts.chat(resolveModel(req, opts.defaultModel), callOpts),\n      }\n    case 'mock':\n      return {\n        transport: 'mock',\n        defaultModel: opts.defaultModel,\n        chat: async (req, callOpts) => opts.handler(resolveModel(req, opts.defaultModel), callOpts),\n      }\n  }\n}\n\nfunction wrapLlmClient(\n  transport: ChatTransport,\n  defaultModel: string | undefined,\n  inner: LlmClient,\n): ChatClient {\n  return {\n    transport,\n    defaultModel,\n    chat: async (req, callOpts) => {\n      const resolved = resolveModel(req, defaultModel)\n      // LlmClient.call doesn't accept an external AbortSignal today (it\n      // owns its own AbortController for the per-attempt timeout). We\n      // race the response against the caller's signal so awaiting code\n      // unblocks on abort. The in-flight HTTP request still runs to its\n      // own timeoutMs — when LlmClient grows a signal parameter, wire\n      // it directly here and drop the race.\n      const call = inner.call({\n        model: resolved.model!,\n        messages: req.messages,\n        jsonMode: req.jsonMode,\n        jsonSchema: req.jsonSchema,\n        temperature: req.temperature,\n        maxTokens: req.maxTokens,\n        timeoutMs: req.timeoutMs,\n      })\n      if (!callOpts?.signal) return await call\n      return await Promise.race([call, abortAsRejection(callOpts.signal)])\n    },\n  }\n}\n\nfunction abortAsRejection(signal: AbortSignal): Promise<never> {\n  if (signal.aborted) return Promise.reject(toAbortError(signal))\n  return new Promise<never>((_, reject) => {\n    signal.addEventListener('abort', () => reject(toAbortError(signal)), { once: true })\n  })\n}\n\nfunction toAbortError(signal: AbortSignal): Error {\n  const reason = (signal as { reason?: unknown }).reason\n  if (reason instanceof Error) return reason\n  const e = new Error('ChatClient.chat: aborted')\n  e.name = 'AbortError'\n  return e\n}\n\nfunction resolveModel(req: ChatRequest, defaultModel: string | undefined): ChatRequest {\n  if (req.model) return req\n  if (!defaultModel) {\n    throw new Error(\n      'ChatClient.chat: no model on request and no defaultModel on the client. ' +\n        'Either pass req.model or bind defaultModel at createChatClient().',\n    )\n  }\n  return { ...req, model: defaultModel }\n}\n","/**\n * Deterministic behavioral metrics over OTLP spans — pure arithmetic, no LLM.\n *\n * These are the model-independent multiplier: the four trace-quality signals a\n * tolerant analyzer (e.g. HALO) re-derives per run inside the model — token\n * growth, output decay, tool monoculture, missing self-verification — computed\n * here once, in TypeScript, with zero model judgment. A finding that falls out\n * of arithmetic is trivially model-agnostic and cannot hallucinate the trend.\n *\n * General, not trace-specific: the detectors key off token trajectories and\n * tool usage present in any agentic OTLP trace, not any one benchmark.\n */\n\nimport type { TraceAnalystSpan } from './types'\n\nexport type SuboptimalCode =\n  | 'monotonic-input-growth'\n  | 'output-length-decay'\n  | 'single-tool-dependency'\n  | 'no-self-verification'\n\nexport interface SuboptimalSignal {\n  code: SuboptimalCode\n  severity: 'high' | 'medium' | 'low'\n  /** Human-readable claim, with the backing numbers inlined. */\n  detail: string\n  /** The exact figures the detector fired on — auditable, no model in the loop. */\n  evidence: Record<string, number | string | boolean>\n}\n\nexport interface BehavioralMetrics {\n  llmCallCount: number\n  inputTokenTrajectory: number[]\n  outputTokenTrajectory: number[]\n  toolHistogram: Record<string, number>\n  totalToolCalls: number\n  distinctTools: number\n  /** distinct/total tool calls; 1.0 when there are no tool calls. */\n  toolDiversityRatio: number\n  hasSelfVerification: boolean\n  signals: SuboptimalSignal[]\n}\n\n/** ≥ this input-token growth ratio across a run, with no compression, fires. */\nconst INPUT_GROWTH_FACTOR = 3\n/** Tool-usage signals need at least this many calls to be meaningful. */\nconst MIN_TOOL_CALLS = 3\n/** Tool names matching this are self-verification, not state mutation. */\nconst VERIFY_RE = /verif|eval|inspect|check|assert|validat|review|confirm/i\n\nfunction num(v: unknown): number | null {\n  return typeof v === 'number' && Number.isFinite(v) ? v : null\n}\nfunction inputTokensOf(s: TraceAnalystSpan): number | null {\n  return num(s.attributes['llm.input_tokens']) ?? num(s.attributes['llm.usage.input_tokens'])\n}\nfunction outputTokensOf(s: TraceAnalystSpan): number | null {\n  return num(s.attributes['llm.output_tokens']) ?? num(s.attributes['llm.usage.output_tokens'])\n}\nfunction stepOf(s: TraceAnalystSpan): number | null {\n  return num(s.attributes.step)\n}\nfunction toolNameOf(s: TraceAnalystSpan): string | null {\n  if (s.tool_name) return s.tool_name\n  const t = s.attributes['tool.name']\n  return typeof t === 'string' && t.length > 0 ? t : null\n}\n\n/**\n * Reduce a span list to behavioral metrics + fired suboptimality signals.\n * Pure + deterministic: same spans → same output, on any machine, no model.\n */\nexport function computeTraceMetrics(spans: readonly TraceAnalystSpan[]): BehavioralMetrics {\n  // Order by step (when present) then start_time so trajectories reflect run order.\n  const ordered = [...spans].sort((a, b) => {\n    const sa = stepOf(a)\n    const sb = stepOf(b)\n    if (sa !== null && sb !== null && sa !== sb) return sa - sb\n    return a.start_time.localeCompare(b.start_time)\n  })\n\n  const inputTokenTrajectory: number[] = []\n  const outputTokenTrajectory: number[] = []\n  const toolHistogram: Record<string, number> = {}\n  let hasSelfVerification = false\n\n  for (const s of ordered) {\n    const inT = inputTokensOf(s)\n    if (inT !== null) inputTokenTrajectory.push(inT)\n    const outT = outputTokensOf(s)\n    if (outT !== null) outputTokenTrajectory.push(outT)\n    const tool = toolNameOf(s)\n    if (tool) {\n      toolHistogram[tool] = (toolHistogram[tool] ?? 0) + 1\n      if (VERIFY_RE.test(tool)) hasSelfVerification = true\n    }\n  }\n\n  const totalToolCalls = Object.values(toolHistogram).reduce((a, b) => a + b, 0)\n  const distinctTools = Object.keys(toolHistogram).length\n  const toolDiversityRatio = totalToolCalls === 0 ? 1 : distinctTools / totalToolCalls\n\n  const signals: SuboptimalSignal[] = []\n\n  if (inputTokenTrajectory.length >= 3) {\n    const first = inputTokenTrajectory[0]!\n    const last = inputTokenTrajectory[inputTokenTrajectory.length - 1]!\n    const growth = first > 0 ? last / first : 0\n    if (last > first && growth >= INPUT_GROWTH_FACTOR) {\n      signals.push({\n        code: 'monotonic-input-growth',\n        severity: 'high',\n        detail: `LLM input tokens grew ${growth.toFixed(1)}x (${first}→${last}) across ${inputTokenTrajectory.length} calls — full history re-sent each step with no compression.`,\n        evidence: {\n          first,\n          last,\n          growth_x: Number(growth.toFixed(2)),\n          calls: inputTokenTrajectory.length,\n        },\n      })\n    }\n  }\n\n  if (outputTokenTrajectory.length >= 3) {\n    const first = outputTokenTrajectory[0]!\n    const last = outputTokenTrajectory[outputTokenTrajectory.length - 1]!\n    if (last < first) {\n      signals.push({\n        code: 'output-length-decay',\n        severity: 'medium',\n        detail: `LLM output tokens shrank ${first}→${last} over ${outputTokenTrajectory.length} calls — less planning/reasoning per step as context grows.`,\n        evidence: { first, last, calls: outputTokenTrajectory.length },\n      })\n    }\n  }\n\n  if (totalToolCalls >= MIN_TOOL_CALLS && distinctTools === 1) {\n    const only = Object.keys(toolHistogram)[0]!\n    signals.push({\n      code: 'single-tool-dependency',\n      severity: 'medium',\n      detail: `All ${totalToolCalls} tool calls are \\`${only}\\` — no tool diversity and no fallback path.`,\n      evidence: { tool: only, calls: totalToolCalls, distinct_tools: 1 },\n    })\n  }\n\n  if (totalToolCalls >= MIN_TOOL_CALLS && !hasSelfVerification) {\n    signals.push({\n      code: 'no-self-verification',\n      severity: 'medium',\n      detail: `${totalToolCalls} tool calls and none verify/inspect/check state — the agent never validates its own actions.`,\n      evidence: { tool_calls: totalToolCalls, verification_calls: 0 },\n    })\n  }\n\n  return {\n    llmCallCount: inputTokenTrajectory.length,\n    inputTokenTrajectory,\n    outputTokenTrajectory,\n    toolHistogram,\n    totalToolCalls,\n    distinctTools,\n    toolDiversityRatio,\n    hasSelfVerification,\n    signals,\n  }\n}\n","/**\n * `behavioralAnalyst` — a DETERMINISTIC analyst (cost.kind = 'deterministic',\n * never calls the LLM). It produces the efficiency/behavioral findings a\n * tolerant agentic analyzer (HALO) re-derives per run inside the model —\n * context bloat, output decay, tool monoculture, missing self-verification —\n * directly from arithmetic over spans (`computeTraceMetrics`).\n *\n * Why it matters: these findings are model-agnostic BY CONSTRUCTION (no model\n * in the loop), so they cannot return 0 on a weak model the way the Ax-RLM\n * does — and they are strictly more reliable than HALO, which spends tokens\n * re-deriving the same numbers and can hallucinate the trend. The agentic\n * RLM kinds remain for SEMANTIC findings that genuinely need a model; this\n * analyst owns the behavioral class.\n */\n\nimport {\n  type BehavioralMetrics,\n  computeTraceMetrics,\n  type SuboptimalCode,\n} from '../trace-analyst/behavioral-metrics'\nimport type { TraceAnalysisStore } from '../trace-analyst/store'\nimport type { TraceAnalystSpan } from '../trace-analyst/types'\nimport { type Analyst, type AnalystFinding, makeFinding } from './types'\n\nconst RECOMMENDED_ACTION: Record<SuboptimalCode, string> = {\n  'monotonic-input-growth':\n    'Add a context-budget instruction: once prior context exceeds a threshold, summarize earlier steps into a short status line instead of re-sending full history.',\n  'output-length-decay':\n    'Require a minimum planning/reasoning budget per step so late steps do not degrade into terse, error-prone commands.',\n  'single-tool-dependency':\n    'Direct the agent to use the full toolset (verify / inspect / alternate actions), not a single execute call, and to plan a fallback when a call returns an unexpected result.',\n  'no-self-verification':\n    'After every state-mutating action, verify the result (eval / inspect / assert) before proceeding.',\n}\n\nconst ANALYST_ID = 'efficiency-behavioral'\n\n/**\n * Map computed signals → structured AnalystFindings. Pure: no LLM, no clock\n * dependence beyond `produced_at` (overridable for deterministic tests).\n */\nexport function deriveEfficiencyFindings(\n  metrics: BehavioralMetrics,\n  opts: { analystId?: string; producedAt?: string } = {},\n): AnalystFinding[] {\n  const analystId = opts.analystId ?? ANALYST_ID\n  return metrics.signals.map((sig) =>\n    makeFinding({\n      analyst_id: analystId,\n      area: 'efficiency',\n      subject: sig.code, // kebab — passes the cluster grammar; stable key for diffFindings\n      claim: sig.detail,\n      severity: sig.severity,\n      // Deterministic arithmetic over spans, not a model judgment → certain.\n      confidence: 1,\n      evidence_refs: [\n        {\n          kind: 'metric',\n          uri: `metric://efficiency/${sig.code}`,\n          excerpt: JSON.stringify(sig.evidence),\n        },\n      ],\n      recommended_action: RECOMMENDED_ACTION[sig.code],\n      metadata: { deterministic: true, evidence: sig.evidence },\n      ...(opts.producedAt ? { produced_at: opts.producedAt } : {}),\n    }),\n  )\n}\n\n/** The deterministic behavioral/efficiency analyst (no LLM, any-model). */\nexport function behavioralAnalyst(): Analyst<TraceAnalysisStore> {\n  return {\n    id: ANALYST_ID,\n    description:\n      'Deterministic behavioral/efficiency findings over OTLP spans — token-growth, output-decay, tool-monoculture, missing self-verification. Zero LLM; model-agnostic by construction.',\n    inputKind: 'trace-store',\n    cost: { kind: 'deterministic' },\n    version: '1.0.0',\n    async analyze(store) {\n      const overview = await store.getOverview()\n      const spans: TraceAnalystSpan[] = []\n      for (const traceId of overview.sample_trace_ids) {\n        const viewed = await store.viewTrace({ trace_id: traceId })\n        if (viewed.spans) spans.push(...viewed.spans)\n      }\n      return deriveEfficiencyFindings(computeTraceMetrics(spans))\n    },\n  }\n}\n","/**\n * `buildDefaultAnalystRegistry` — the canonical analyst suite, so consumers\n * stop hand-wiring `new AnalystRegistry()` + per-kind `createTraceAnalystKind`.\n *\n * The deterministic `behavioralAnalyst` is ALWAYS registered (it needs no\n * model and is model-agnostic by construction). The agentic RLM kinds are\n * registered only when an `ai` service is supplied — so a caller with no LLM\n * still gets the full behavioral/efficiency diagnosis, and the substrate's\n * \"any model (including no model)\" guarantee holds at the suite level.\n */\n\nimport type { AxAIService } from '@ax-llm/ax'\nimport { behavioralAnalyst } from './behavioral-analyst'\nimport { createTraceAnalystKind, type TraceAnalystKindSpec } from './kind-factory'\nimport { DEFAULT_TRACE_ANALYST_KINDS } from './kinds'\nimport { AnalystRegistry, type AnalystRegistryOptions } from './registry'\n\nexport interface DefaultAnalystRegistryOptions {\n  /** Ax service for the agentic RLM kinds. Omit → only the deterministic analyst. */\n  ai?: AxAIService\n  /** Model for the agentic kinds (falls back to the ai service default). */\n  model?: string\n  /** Which agentic kinds to register when `ai` is present. Default = the shipped suite. */\n  kinds?: readonly TraceAnalystKindSpec[]\n  /** Set false to omit the deterministic behavioral analyst (default: include). */\n  includeBehavioral?: boolean\n  /** Forwarded to the AnalystRegistry constructor (signal, tags, priorFindings). */\n  registry?: AnalystRegistryOptions\n}\n\nexport function buildDefaultAnalystRegistry(\n  opts: DefaultAnalystRegistryOptions = {},\n): AnalystRegistry {\n  const registry = new AnalystRegistry(opts.registry)\n  if (opts.includeBehavioral !== false) {\n    registry.register(behavioralAnalyst())\n  }\n  if (opts.ai) {\n    const kinds = opts.kinds ?? DEFAULT_TRACE_ANALYST_KINDS\n    for (const spec of kinds) {\n      registry.register(createTraceAnalystKind(spec, { ai: opts.ai, model: opts.model }))\n    }\n  }\n  return registry\n}\n","/**\n * concurrency — small primitives the evolution loop needs.\n *\n * `Mutex` is a zero-dep async lock with FIFO fairness. The evolution loop\n * uses it to serialise checkout/build/commit sequences inside a single\n * pool slot, and to gate concurrent JSONL writers (see\n * `lockedJsonlReferenceReplayStore`).\n *\n * Deliberately minimal — no priority queue, no timeouts. If you need\n * those, swap to `async-mutex` at the call site.\n */\n\nexport class Mutex {\n  private locked = false\n  private readonly waiters: Array<() => void> = []\n\n  async acquire(): Promise<() => void> {\n    if (!this.locked) {\n      this.locked = true\n      return () => this.release()\n    }\n    return new Promise<() => void>((resolve) => {\n      this.waiters.push(() => {\n        resolve(() => this.release())\n      })\n    })\n  }\n\n  private release(): void {\n    const next = this.waiters.shift()\n    if (next) {\n      next()\n    } else {\n      this.locked = false\n    }\n  }\n\n  async runExclusive<T>(fn: () => Promise<T> | T): Promise<T> {\n    const release = await this.acquire()\n    try {\n      return await fn()\n    } finally {\n      release()\n    }\n  }\n\n  /** True iff someone holds the lock right now. Diagnostics only. */\n  get isLocked(): boolean {\n    return this.locked\n  }\n\n  /** Pending waiter count. Diagnostics only. */\n  get pending(): number {\n    return this.waiters.length\n  }\n}\n","/**\n * LockedJsonlAppender — mutex-serialized JSONL append helper for arbitrary\n * payloads. The reference-replay store does the same thing for typed\n * `ReferenceReplayRun` rows; this is the generic version used by\n * `MutationTelemetry`, `TrialTelemetry`, and any other consumer that wants\n * append-only durable telemetry without rolling its own lock.\n *\n * Locks are per absolute file path (process-local). Cross-process\n * concurrency is NOT addressed — that's an fcntl/flock problem.\n */\n\nimport { appendFileSync, existsSync, mkdirSync } from 'node:fs'\nimport { dirname } from 'node:path'\nimport { Mutex } from './concurrency'\n\nconst mutexes = new Map<string, Mutex>()\n\nfunction getMutex(path: string): Mutex {\n  let m = mutexes.get(path)\n  if (!m) {\n    m = new Mutex()\n    mutexes.set(path, m)\n  }\n  return m\n}\n\nexport class LockedJsonlAppender {\n  private readonly mutex: Mutex\n  constructor(public readonly path: string) {\n    this.mutex = getMutex(path)\n    if (!existsSync(dirname(path))) {\n      mkdirSync(dirname(path), { recursive: true })\n    }\n  }\n\n  async append(entry: unknown): Promise<void> {\n    const line = `${JSON.stringify(entry)}\\n`\n    await this.mutex.runExclusive(() => {\n      appendFileSync(this.path, line)\n    })\n  }\n}\n\n/** Reset all internal mutex state — tests only. */\nexport function resetLockedAppendersForTesting(): void {\n  mutexes.clear()\n}\n","/**\n * FindingsStore — durable persistence for AnalystFinding rows + a diff\n * helper so we can answer \"what changed since the last run?\" without\n * recomputing analysts.\n *\n * On-disk shape is JSONL: one finding per line, append-only, locked via\n * LockedJsonlAppender. Operators get crash-safety (no partial JSON),\n * cheap reads (sequential parse), and trivial backup (rsync the file).\n *\n * Reads are non-locking: a reader sees a consistent snapshot of all\n * fully-written lines and skips an incomplete trailing line if the\n * writer is mid-append. Cross-process locking is intentionally out of\n * scope (see locked-jsonl-appender.ts).\n *\n * The store is run-scoped: callers pass `runId` on append and on load,\n * which keeps multi-run files cleanly partitioned. The `diffFindings`\n * helper compares two run-id sets using stable `finding_id` semantics —\n * the diff is the cross-run signal the regression dashboard renders.\n */\n\nimport { existsSync, readFileSync } from 'node:fs'\n\nimport { LockedJsonlAppender } from '../locked-jsonl-appender'\nimport type { AnalystFinding } from './types'\n\n/**\n * One persisted row. We attach `run_id` on disk so a single file can\n * hold multiple runs and the diff helper can query without re-walking\n * separate files.\n */\nexport interface PersistedFinding extends AnalystFinding {\n  run_id: string\n}\n\nexport class FindingsStore {\n  private readonly appender: LockedJsonlAppender\n\n  constructor(public readonly path: string) {\n    this.appender = new LockedJsonlAppender(path)\n  }\n\n  async append(runId: string, findings: AnalystFinding[]): Promise<void> {\n    for (const f of findings) {\n      const row: PersistedFinding = { ...f, run_id: runId }\n      await this.appender.append(row)\n    }\n  }\n\n  /** Load every persisted finding. Discards malformed trailing lines silently. */\n  loadAll(): PersistedFinding[] {\n    if (!existsSync(this.path)) return []\n    const raw = readFileSync(this.path, 'utf8')\n    if (!raw) return []\n    const out: PersistedFinding[] = []\n    for (const line of raw.split('\\n')) {\n      if (!line) continue\n      try {\n        out.push(JSON.parse(line) as PersistedFinding)\n      } catch {\n        // Skip torn trailing line — the lock guarantees no torn lines\n        // mid-file, only at EOF when a writer is in-flight.\n      }\n    }\n    return out\n  }\n\n  /** Filter to a single run. */\n  loadRun(runId: string): PersistedFinding[] {\n    return this.loadAll().filter((r) => r.run_id === runId)\n  }\n}\n\n// ── Cross-run diff ──────────────────────────────────────────────────\n\nexport interface FindingsDiff {\n  /** New finding ids in `current` that weren't in `previous`. */\n  appeared: PersistedFinding[]\n  /** Finding ids in `previous` that aren't in `current`. */\n  disappeared: PersistedFinding[]\n  /** Same finding id present in both runs and unchanged per the materiality test. */\n  persisted: PersistedFinding[]\n  /**\n   * Same finding id in both runs but at least one non-identity field\n   * shifted per `DiffPolicy.isMaterial`. Reported as [previous, current].\n   */\n  changed: Array<{ previous: PersistedFinding; current: PersistedFinding }>\n}\n\nexport interface DiffPolicy {\n  /**\n   * Predicate that decides whether two findings (same finding_id) count\n   * as a material change. Defaults to {@link defaultIsMaterial}: severity\n   * shift, confidence Δ > 0.05, or evidence count change. Compliance /\n   * perf consumers MAY supply a stricter predicate (e.g. rationale text\n   * diff, metric Δ thresholds).\n   */\n  isMaterial?: (previous: AnalystFinding, current: AnalystFinding) => boolean\n}\n\n/**\n * Default materiality test. Deliberately narrow so LLM-reword churn\n * doesn't flood the diff. Stricter tests are opt-in via DiffPolicy.\n */\nexport function defaultIsMaterial(a: AnalystFinding, b: AnalystFinding): boolean {\n  if (a.severity !== b.severity) return true\n  if (Math.abs((a.confidence ?? 0) - (b.confidence ?? 0)) > 0.05) return true\n  if (a.evidence_refs.length !== b.evidence_refs.length) return true\n  return false\n}\n\n/**\n * Diff two findings sets by stable finding_id. Callers typically load\n * the two run-id slices from the same store and pass them in.\n */\nexport function diffFindings(\n  previous: PersistedFinding[],\n  current: PersistedFinding[],\n  policy: DiffPolicy = {},\n): FindingsDiff {\n  const isMaterial = policy.isMaterial ?? defaultIsMaterial\n  const prevById = new Map(previous.map((f) => [f.finding_id, f]))\n  const curById = new Map(current.map((f) => [f.finding_id, f]))\n\n  const appeared: PersistedFinding[] = []\n  const disappeared: PersistedFinding[] = []\n  const persisted: PersistedFinding[] = []\n  const changed: FindingsDiff['changed'] = []\n\n  for (const [id, cur] of curById) {\n    const prev = prevById.get(id)\n    if (!prev) {\n      appeared.push(cur)\n      continue\n    }\n    if (isMaterial(prev, cur)) {\n      changed.push({ previous: prev, current: cur })\n    } else {\n      persisted.push(cur)\n    }\n  }\n  for (const [id, prev] of prevById) {\n    if (!curById.has(id)) disappeared.push(prev)\n  }\n  return { appeared, disappeared, persisted, changed }\n}\n","/**\n * Skill-usage analyst — a DETERMINISTIC `Analyst` over a Claude/Codex skill\n * library + its trace corpus. Unlike the trace-store kinds (failure-mode,\n * improvement, ...) this kind calls no LLM: it mines real usage and skill\n * structure and emits findings by rule.\n *\n * It exists because the naive \"Skill-tool invocation count\" lies low — it\n * misses orchestrated sub-dispatch (a leaf skill run BY /pursue or /governor\n * logs under the parent), slash-command entry, local-script bypass, and\n * on-disk artifacts. The 2026-05-30 skill audit found 39/53 skills at zero\n * direct invocations, yet only one was a genuine cut: the rest were\n * measurement-invisible or discovery-limited. This analyst encodes that\n * lesson as a multi-signal usage model so a cheap repeatable pass can keep\n * the library honest, and so the expensive audit workflow's verdicts can\n * GEPA-distill it toward agreement (see `gold/skill-verdicts.gold.jsonl`).\n *\n * Report-building (`buildSkillUsageReport`, an fs scan) is separated from\n * finding emission (`SkillUsageAnalyst.analyze`, pure) so the slow scan runs\n * once at the registry boundary and the rule logic stays unit-testable.\n */\n\nimport { type Dirent, existsSync, readdirSync, readFileSync, statSync } from 'node:fs'\nimport { join } from 'node:path'\nimport type { Analyst, AnalystContext, AnalystFinding, AnalystSeverity } from '../types'\nimport { computeFindingId } from '../types'\n\n// ── Input model ──────────────────────────────────────────────────────\n\nexport type SkillKind = 'public' | 'private'\n\n/** One skill's multi-signal usage + structure. All counts are deterministic. */\nexport interface SkillUsageRecord {\n  name: string\n  kind: SkillKind\n  /** Absolute path to the skill's SKILL.md. */\n  path: string\n  lines: number\n  /** `\"skill\":\"<name>\"` Skill-tool invocations across the trace corpus. */\n  directInvocations: number\n  /** `<command-name>/<name>` slash invocations across the trace corpus. */\n  slashInvocations: number\n  /** Sibling skills whose SKILL.md dispatches to this one (`/<name>`). Proxy\n   *  for orchestrated sub-dispatch the per-skill counter cannot see. */\n  inboundRefs: number\n  /** On-disk artifacts attributable to the skill (e.g. `.evolve/<name>/**`). */\n  artifactCount: number\n  /** Tangle-private reference count in the body (leak signal for public skills). */\n  tanglePrivateRefs: number\n  hasReferencesDir: boolean\n  hasEvalsDir: boolean\n  /** Body mentions `skill-runs.jsonl` (visible to /reflect + /governor). */\n  logsRuns: boolean\n  /** Description carries an explicit `Triggers:` clause / trigger phrases. */\n  hasTriggerPhrases: boolean\n}\n\nexport interface SkillUsageReport {\n  generatedFromTraces: number\n  records: SkillUsageRecord[]\n}\n\nexport interface SkillUsageScanConfig {\n  /** Dirs holding `*.jsonl` transcripts (Claude `~/.claude/projects`, Codex sessions). */\n  transcriptDirs: string[]\n  /** Skill roots to scan; each dir directly under `root` with a `SKILL.md` is a skill. */\n  skillRoots: { root: string; kind: SkillKind }[]\n  /** Roots scanned for `<root>/.evolve/<skill>` artifact dirs. */\n  artifactRoots?: string[]\n  /** Token-prefixed mappings: skill name → extra artifact subpaths under an artifactRoot\n   *  (e.g. reflect → `.evolve/reflections`). Catches non-eponymous artifact dirs. */\n  artifactAliases?: Record<string, string[]>\n  /** Cap files read per transcript dir (bounds a huge corpus); 0 = unbounded. */\n  maxTranscriptsPerDir?: number\n}\n\n// ── Deterministic thresholds ─────────────────────────────────────────\n\n/** Anthropic's authoring guidance keeps SKILL.md short; past this with no\n *  `references/` split the body burns context budget every session. */\nconst BLOAT_LINE_THRESHOLD = 300\n\nconst TANGLE_PRIVATE_RE =\n  /\\b(cli-bridge|tangletools|ops-board|drew-gtr-pro|@tangle-network\\/|~\\/company|tangle\\.tools|gtm-agent)\\b|\\bkimi\\b|\\btcloud\\b/gi\nconst TRIGGER_RE = /triggers?\\s*[:-]/i\n\n// ── Report builder (fs scan — slow, runs once at the registry boundary) ──\n\nfunction listSkillDirs(root: string): { name: string; path: string }[] {\n  if (!existsSync(root)) return []\n  const out: { name: string; path: string }[] = []\n  for (const entry of readdirSync(root, { withFileTypes: true })) {\n    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue\n    const skillMd = join(root, entry.name, 'SKILL.md')\n    if (existsSync(skillMd)) out.push({ name: entry.name, path: skillMd })\n  }\n  return out\n}\n\nfunction walkJsonl(dir: string, cap: number): string[] {\n  if (!existsSync(dir)) return []\n  const files: string[] = []\n  const stack = [dir]\n  while (stack.length) {\n    const cur = stack.pop()!\n    let entries: Dirent[]\n    try {\n      entries = readdirSync(cur, { withFileTypes: true })\n    } catch {\n      continue\n    }\n    for (const e of entries) {\n      const full = join(cur, e.name)\n      if (e.isDirectory()) stack.push(full)\n      else if (e.name.endsWith('.jsonl')) {\n        files.push(full)\n        if (cap > 0 && files.length >= cap) return files\n      }\n    }\n  }\n  return files\n}\n\nfunction frontmatterDescription(body: string): string {\n  const fm = /^---\\n([\\s\\S]*?)\\n---/.exec(body)\n  const block = fm?.[1] ?? ''\n  const m = /description:\\s*(.+)/i.exec(block)\n  return m?.[1] ?? ''\n}\n\nfunction countArtifacts(roots: string[], name: string, aliases: string[]): number {\n  let n = 0\n  for (const root of roots) {\n    const candidates = [join(root, '.evolve', name), ...aliases.map((a) => join(root, a))]\n    for (const dir of candidates) {\n      if (!existsSync(dir)) continue\n      try {\n        if (statSync(dir).isDirectory()) n += readdirSync(dir).length\n        else n += 1\n      } catch {\n        /* unreadable — skip */\n      }\n    }\n  }\n  return n\n}\n\n/** Scan the corpus + skill roots into a {@link SkillUsageReport}. Deterministic. */\nexport function buildSkillUsageReport(config: SkillUsageScanConfig): SkillUsageReport {\n  const skills = config.skillRoots.flatMap(({ root, kind }) =>\n    listSkillDirs(root).map((s) => ({ ...s, kind })),\n  )\n  const names = skills.map((s) => s.name)\n\n  // One pass over the corpus accumulating direct + slash counts per skill.\n  const direct = new Map<string, number>(names.map((n) => [n, 0]))\n  const slash = new Map<string, number>(names.map((n) => [n, 0]))\n  const skillRe = /\"skill\"\\s*:\\s*\"([a-z0-9_:-]+)\"/g\n  const cmdRe = /<command-name>\\/?([a-z0-9_:-]+)<\\/command-name>/g\n  let transcripts = 0\n  for (const dir of config.transcriptDirs) {\n    for (const file of walkJsonl(dir, config.maxTranscriptsPerDir ?? 0)) {\n      transcripts += 1\n      let data: string\n      try {\n        data = readFileSync(file, 'utf8')\n      } catch {\n        continue\n      }\n      for (const m of data.matchAll(skillRe)) {\n        const g = m[1]\n        if (!g) continue\n        const n = g.split(':').pop() ?? g\n        const prev = direct.get(n)\n        if (prev !== undefined) direct.set(n, prev + 1)\n      }\n      for (const m of data.matchAll(cmdRe)) {\n        const g = m[1]\n        if (g === undefined) continue\n        const prev = slash.get(g)\n        if (prev !== undefined) slash.set(g, prev + 1)\n      }\n    }\n  }\n\n  // Read each skill body once; compute structure + inbound refs across siblings.\n  const bodies = new Map<string, string>()\n  for (const s of skills) {\n    try {\n      bodies.set(s.name, readFileSync(s.path, 'utf8'))\n    } catch {\n      bodies.set(s.name, '')\n    }\n  }\n  const inbound = new Map<string, number>(names.map((n) => [n, 0]))\n  for (const target of names) {\n    const ref = new RegExp(`/${target}\\\\b|\\\\[\\\\[${target}\\\\]\\\\]`)\n    for (const s of skills) {\n      if (s.name === target) continue\n      if (ref.test(bodies.get(s.name) ?? '')) inbound.set(target, inbound.get(target)! + 1)\n    }\n  }\n\n  const records: SkillUsageRecord[] = skills.map((s) => {\n    const body = bodies.get(s.name) ?? ''\n    const dir = s.path.replace(/\\/SKILL\\.md$/, '')\n    return {\n      name: s.name,\n      kind: s.kind,\n      path: s.path,\n      lines: body ? body.split('\\n').length : 0,\n      directInvocations: direct.get(s.name) ?? 0,\n      slashInvocations: slash.get(s.name) ?? 0,\n      inboundRefs: inbound.get(s.name) ?? 0,\n      artifactCount: countArtifacts(\n        config.artifactRoots ?? [],\n        s.name,\n        config.artifactAliases?.[s.name] ?? [],\n      ),\n      tanglePrivateRefs: (body.match(TANGLE_PRIVATE_RE) ?? []).length,\n      hasReferencesDir: existsSync(join(dir, 'references')),\n      hasEvalsDir: existsSync(join(dir, 'evals')),\n      logsRuns: body.includes('skill-runs.jsonl'),\n      hasTriggerPhrases: TRIGGER_RE.test(frontmatterDescription(body) || body.slice(0, 600)),\n    }\n  })\n  return { generatedFromTraces: transcripts, records }\n}\n\n// ── Finding emission (pure — unit-testable, no LLM, no fs) ────────────\n\nconst ANALYST_ID = 'skill-usage'\n\nfunction finding(\n  area: string,\n  subject: string,\n  claim: string,\n  severity: AnalystSeverity,\n  confidence: number,\n  producedAt: string,\n  recommended: string,\n  evidenceUri: string,\n  rationale?: string,\n): AnalystFinding {\n  return {\n    schema_version: '1.0.0',\n    finding_id: computeFindingId({ analyst_id: ANALYST_ID, area, subject, claim }),\n    analyst_id: ANALYST_ID,\n    produced_at: producedAt,\n    severity,\n    area,\n    claim,\n    rationale,\n    evidence_refs: [{ kind: 'artifact', uri: evidenceUri }],\n    recommended_action: recommended,\n    confidence,\n    subject,\n  }\n}\n\n/** Pure rule pass over a report → findings. Exported for direct/unit use. */\nexport function emitSkillUsageFindings(\n  report: SkillUsageReport,\n  producedAt: string,\n): AnalystFinding[] {\n  const out: AnalystFinding[] = []\n  for (const r of report.records) {\n    const directTotal = r.directInvocations + r.slashInvocations\n    const trueUsage = directTotal + r.inboundRefs + r.artifactCount\n\n    // 1. Dead: no usage signal of ANY kind. The only real deprecation candidate.\n    if (trueUsage === 0) {\n      out.push(\n        finding(\n          'skill-usage',\n          r.name,\n          `Skill '${r.name}' has zero usage across all signals (direct, slash, inbound-refs, artifacts)`,\n          'high',\n          0.6,\n          producedAt,\n          'Confirm the skill covers a real recurring job; if not, deprecate. Zero true usage is the only deterministic deprecation candidate.',\n          r.path,\n          'No Skill-tool call, no slash invocation, no sibling dispatches to it, and no on-disk artifacts.',\n        ),\n      )\n    } else if (directTotal === 0 && r.inboundRefs + r.artifactCount > 0) {\n      // 2. Measurement-invisible: real use via orchestration/artifacts, never invoked directly.\n      out.push(\n        finding(\n          'skill-usage',\n          r.name,\n          `Skill '${r.name}' shows 0 direct invocations but is used via orchestration/artifacts (inbound=${r.inboundRefs}, artifacts=${r.artifactCount})`,\n          'info',\n          0.8,\n          producedAt,\n          'Do NOT treat as unused — usage is real but logged under parent skills or on disk. Strengthen direct-invocation discovery only if direct use is desired.',\n          r.path,\n          'The Skill-tool counter undercounts orchestrated/chained leaf skills.',\n        ),\n      )\n    }\n\n    // 3. Discovery gap: low direct use AND weak trigger surface.\n    if (directTotal <= 2 && !r.hasTriggerPhrases) {\n      out.push(\n        finding(\n          'discoverability',\n          r.name,\n          `Skill '${r.name}' is rarely invoked directly and its description has no explicit trigger phrases`,\n          'medium',\n          0.7,\n          producedAt,\n          'Add a `Triggers:` clause with verbatim user phrases to the frontmatter description so the model auto-invokes it.',\n          r.path,\n        ),\n      )\n    }\n\n    // 4. Public-repo leak.\n    if (r.kind === 'public' && r.tanglePrivateRefs > 0) {\n      out.push(\n        finding(\n          'safety',\n          r.name,\n          `Public skill '${r.name}' carries ${r.tanglePrivateRefs} Tangle-private reference(s)`,\n          'high',\n          0.75,\n          producedAt,\n          'Sanitize incidental internal refs (cli-bridge/kimi/tcloud/~company/private repos) or relocate to a private repo. Verify @tangle-network/* refs are to PUBLISHED packages before treating as a leak.',\n          r.path,\n        ),\n      )\n    }\n\n    // 5. Bloat / no progressive disclosure.\n    if (r.lines > BLOAT_LINE_THRESHOLD && !r.hasReferencesDir) {\n      out.push(\n        finding(\n          'maintainability',\n          r.name,\n          `Skill '${r.name}' is ${r.lines} lines with no references/ split (progressive disclosure)`,\n          'medium',\n          0.8,\n          producedAt,\n          `Split detail into references/ loaded on demand; keep SKILL.md a short overview. ${r.lines} lines load into every session's context budget.`,\n          r.path,\n        ),\n      )\n    }\n\n    // 6. No evals (Anthropic's \">=3 evals before docs\" rule).\n    if (!r.hasEvalsDir) {\n      out.push(\n        finding(\n          'data-quality',\n          r.name,\n          `Skill '${r.name}' ships no evals/`,\n          'low',\n          0.6,\n          producedAt,\n          'Add evals/evals.json with >=3 scenarios proving the skill beats baseline; gives regression coverage.',\n          r.path,\n        ),\n      )\n    }\n\n    // 7. No run logging → invisible to /reflect and /governor.\n    if (!r.logsRuns) {\n      out.push(\n        finding(\n          'observability',\n          r.name,\n          `Skill '${r.name}' never appends to .evolve/skill-runs.jsonl`,\n          'low',\n          0.55,\n          producedAt,\n          'Append one run line to .evolve/skill-runs.jsonl on completion, or declare it a non-logging leaf, so the self-improvement loop can see it ran.',\n          r.path,\n        ),\n      )\n    }\n  }\n  return out\n}\n\n// ── The Analyst ──────────────────────────────────────────────────────\n\nexport class SkillUsageAnalyst implements Analyst<SkillUsageReport> {\n  readonly id = ANALYST_ID\n  readonly description =\n    'Deterministic multi-signal skill-usage analysis: flags dead skills, measurement-invisible (orchestrated) usage, discovery gaps, public-repo leaks, bloat, missing evals, and missing run-logging.'\n  readonly inputKind = 'custom' as const\n  readonly cost = { kind: 'deterministic' as const, est_usd_per_run: 0 }\n  readonly version = '1.0.0'\n\n  async analyze(input: SkillUsageReport, ctx: AnalystContext): Promise<AnalystFinding[]> {\n    const producedAt = ctx.tags?.producedAt ?? new Date().toISOString()\n    ctx.log?.(\n      `skill-usage: ${input.records.length} skills over ${input.generatedFromTraces} transcripts`,\n    )\n    return emitSkillUsageFindings(input, producedAt)\n  }\n}\n\nexport const SKILL_USAGE_ANALYST = new SkillUsageAnalyst()\n","export interface RunScore {\n  success: number\n  goalProgress: number\n  repoGroundedness: number\n  driftPenalty: number\n  toolUseQuality: number\n  patchQuality: number\n  testReality: number\n  finalGate: number\n  reviewerBlockers: number\n  costUsd: number\n  wallSeconds: number\n  notes?: string[]\n}\n\nexport interface RunScoreWeights {\n  success: number\n  goalProgress: number\n  repoGroundedness: number\n  driftPenalty: number\n  toolUseQuality: number\n  patchQuality: number\n  testReality: number\n  finalGate: number\n  reviewerBlockers: number\n  costUsd: number\n  wallSeconds: number\n}\n\nexport const DEFAULT_RUN_SCORE_WEIGHTS: RunScoreWeights = {\n  success: 4,\n  goalProgress: 2,\n  repoGroundedness: 1.5,\n  driftPenalty: -1.5,\n  toolUseQuality: 1,\n  patchQuality: 1.25,\n  testReality: 1.5,\n  finalGate: 3,\n  reviewerBlockers: -2,\n  costUsd: -0.2,\n  wallSeconds: -0.1,\n}\n\nexport function aggregateRunScore(score: RunScore, weights: Partial<RunScoreWeights> = {}): number {\n  const w = { ...DEFAULT_RUN_SCORE_WEIGHTS, ...weights }\n  return (\n    w.success * clamp01(score.success) +\n    w.goalProgress * clamp01(score.goalProgress) +\n    w.repoGroundedness * clamp01(score.repoGroundedness) +\n    w.driftPenalty * clamp01(score.driftPenalty) +\n    w.toolUseQuality * clamp01(score.toolUseQuality) +\n    w.patchQuality * clamp01(score.patchQuality) +\n    w.testReality * clamp01(score.testReality) +\n    w.finalGate * clamp01(score.finalGate) +\n    w.reviewerBlockers * clamp01(score.reviewerBlockers) +\n    w.costUsd * Math.max(0, finiteOrZero(score.costUsd)) +\n    w.wallSeconds * Math.max(0, finiteOrZero(score.wallSeconds) / 60)\n  )\n}\n\nexport function clamp01(value: number): number {\n  if (!Number.isFinite(value)) return 0\n  return Math.max(0, Math.min(1, value))\n}\n\nfunction finiteOrZero(value: number): number {\n  return Number.isFinite(value) ? value : 0\n}\n","import { NotFoundError } from './errors'\nimport { aggregateRunScore, clamp01, type RunScore, type RunScoreWeights } from './run-score'\nimport type { Artifact, BudgetLedgerEntry, Run, Span, TraceEvent, TraceStore } from './trace'\n\nexport interface RunTrace {\n  run: Run\n  spans: Span[]\n  events: TraceEvent[]\n  artifacts: Artifact[]\n  budget: BudgetLedgerEntry[]\n}\n\nexport interface RunCriticOptions {\n  weights?: Partial<RunScoreWeights>\n  driftPatterns?: RegExp[]\n}\n\nconst DEFAULT_DRIFT_PATTERNS = [\n  /https?:\\/\\//i,\n  /\\btitle:\\s/i,\n  /\\bsummary:\\s/i,\n  /\\burl:\\s/i,\n  /\\bnpm package usage\\b/i,\n  /\\bnews\\b/i,\n]\n\nexport class RunCritic {\n  private readonly weights?: Partial<RunScoreWeights>\n  private readonly driftPatterns: RegExp[]\n\n  constructor(options: RunCriticOptions = {}) {\n    this.weights = options.weights\n    this.driftPatterns = options.driftPatterns ?? DEFAULT_DRIFT_PATTERNS\n  }\n\n  async score(store: TraceStore, runId: string): Promise<RunScore> {\n    const run = await store.getRun(runId)\n    if (!run) throw new NotFoundError(`run ${runId} not found`)\n    const [spans, events, artifacts, budget] = await Promise.all([\n      store.spans({ runId }),\n      store.events({ runId }),\n      store.artifacts(runId),\n      store.budget(runId),\n    ])\n    return this.scoreTrace({ run, spans, events, artifacts, budget })\n  }\n\n  scoreTrace(trace: RunTrace): RunScore {\n    const notes: string[] = []\n    const llmSpans = trace.spans.filter(\n      (s): s is Extract<Span, { kind: 'llm' }> => s.kind === 'llm',\n    )\n    const toolSpans = trace.spans.filter(\n      (s): s is Extract<Span, { kind: 'tool' }> => s.kind === 'tool',\n    )\n    const judgeSpans = trace.spans.filter(\n      (s): s is Extract<Span, { kind: 'judge' }> => s.kind === 'judge',\n    )\n    const sandboxSpans = trace.spans.filter(\n      (s): s is Extract<Span, { kind: 'sandbox' }> => s.kind === 'sandbox',\n    )\n    const finalGateSpans = judgeSpans.filter(\n      (span) => span.dimension === 'final_gate' || span.attributes?.finalGate === true,\n    )\n\n    const success =\n      trace.run.outcome?.pass === true ? 1 : trace.run.status === 'completed' ? 0.5 : 0\n    if (!success) notes.push('run did not complete with pass=true')\n\n    const judgeAverage = judgeSpans.length\n      ? judgeSpans.reduce((sum, span) => sum + normalizeJudgeScore(span.score), 0) /\n        judgeSpans.length\n      : undefined\n    const outcomeScore =\n      typeof trace.run.outcome?.score === 'number'\n        ? clamp01(\n            trace.run.outcome.score > 1 ? trace.run.outcome.score / 100 : trace.run.outcome.score,\n          )\n        : undefined\n    const goalProgress = outcomeScore ?? judgeAverage ?? success\n\n    const successfulTools = toolSpans.filter((span) => span.status !== 'error').length\n    const toolUseQuality = toolSpans.length === 0 ? 0 : successfulTools / toolSpans.length\n    if (toolSpans.length === 0) notes.push('no tool spans recorded')\n\n    const patchEvidence =\n      trace.artifacts.length +\n      toolSpans.filter((span) => /write|edit|patch|apply/i.test(span.toolName)).length\n    const patchQuality = patchEvidence > 0 ? clamp01(patchEvidence / 4) : 0\n    if (!patchQuality) notes.push('no artifact or edit evidence recorded')\n\n    const sandboxTests = sandboxSpans.filter(\n      (span) => typeof span.testsTotal === 'number' && span.testsTotal > 0,\n    )\n    const testReality = sandboxTests.length\n      ? sandboxTests.reduce(\n          (sum, span) => sum + (span.testsPassed ?? 0) / Math.max(1, span.testsTotal ?? 1),\n          0,\n        ) / sandboxTests.length\n      : toolSpans.some((span) =>\n            /\\btest|vitest|pytest|jest|build|tsc\\b/i.test(JSON.stringify(span.args)),\n          )\n        ? 0.4\n        : 0\n    if (!testReality) notes.push('no real test/build evidence recorded')\n\n    const blockerSpans = judgeSpans.filter((span) => isBlockingJudge(span))\n    const finalGateBlockers = finalGateSpans.filter((span) => isBlockingJudge(span))\n    const finalGate = finalGateSpans.length ? (finalGateBlockers.length ? 0 : 1) : success\n    if (finalGateBlockers.length)\n      notes.push(`final gate blocked by ${finalGateBlockers.length} reviewer(s)`)\n    else if (!finalGateSpans.length) notes.push('no final gate judgment recorded')\n\n    const reviewerBlockers = judgeSpans.length ? blockerSpans.length / judgeSpans.length : 0\n    if (reviewerBlockers) notes.push(`detected ${blockerSpans.length} blocking reviewer signal(s)`)\n\n    const positiveGroundingSignals =\n      patchEvidence +\n      sandboxSpans.length +\n      llmSpans.filter((span) => looksRepoGrounded(span.output ?? '')).length\n    const driftSignals =\n      llmSpans.filter((span) => this.isDrift(span.output ?? '')).length +\n      trace.events.filter((event) => this.isDrift(JSON.stringify(event.payload))).length\n    const repoGroundedness =\n      positiveGroundingSignals + driftSignals === 0\n        ? 0\n        : positiveGroundingSignals / (positiveGroundingSignals + driftSignals)\n    const driftPenalty =\n      positiveGroundingSignals + driftSignals === 0\n        ? 0\n        : driftSignals / (positiveGroundingSignals + driftSignals)\n    if (driftSignals > 0) notes.push(`detected ${driftSignals} drift signal(s)`)\n\n    const costUsd = trace.budget.length\n      ? Math.max(\n          ...trace.budget\n            .filter((entry: BudgetLedgerEntry) => entry.dimension === 'usd')\n            .map((entry: BudgetLedgerEntry) => entry.consumed),\n          0,\n        )\n      : llmSpans.reduce((sum, span) => sum + (span.costUsd ?? 0), 0)\n    const wallSeconds =\n      trace.run.endedAt && trace.run.startedAt\n        ? Math.max(0, (trace.run.endedAt - trace.run.startedAt) / 1000)\n        : 0\n\n    return {\n      success,\n      goalProgress,\n      repoGroundedness,\n      driftPenalty,\n      toolUseQuality,\n      patchQuality,\n      testReality,\n      finalGate,\n      reviewerBlockers,\n      costUsd,\n      wallSeconds,\n      notes,\n    }\n  }\n\n  rank(score: RunScore): number {\n    return aggregateRunScore(score, this.weights)\n  }\n\n  private isDrift(text: string): boolean {\n    return this.driftPatterns.some((pattern) => pattern.test(text))\n  }\n}\n\nfunction normalizeJudgeScore(score: number): number {\n  return score > 1 ? clamp01(score / 10) : clamp01(score)\n}\n\nfunction looksRepoGrounded(text: string): boolean {\n  return /(?:src\\/|tests?\\/|package\\.json|tsconfig|\\.ts\\b|\\.tsx\\b|git status|pnpm |npm |vitest|pytest|jest)/i.test(\n    text,\n  )\n}\n\nfunction isBlockingJudge(span: Extract<Span, { kind: 'judge' }>): boolean {\n  return (\n    span.attributes?.blocking === true ||\n    span.attributes?.verdict === 'BLOCKING' ||\n    positiveNumber(span.attributes?.blockingFindings) ||\n    positiveNumber(span.attributes?.highFindings) ||\n    span.score <= 2\n  )\n}\n\nfunction positiveNumber(value: unknown): boolean {\n  return typeof value === 'number' && value > 0\n}\n","/**\n * Semantic concept judge — \"does the built artifact actually implement\n * the features the user asked for?\"\n *\n * Distinct from the domain/code/coherence judges in `judges.ts`:\n *   - those judges score free-form conversational agent outputs along\n *     quality dimensions (accuracy, depth, etc.)\n *   - this judge scores a *built artifact* (served HTML + source files)\n *     against an explicit list of expected concepts, returning per-concept\n *     {present, score 0-10, evidence, severity}.\n *\n * The judge is strict about distinguishing (a) a working implementation\n * from (b) a keyword-present stub. \"// TODO: mint button\" is NOT present.\n * Only real, functional, wired-up code counts.\n *\n * Use via {@link createSemanticConceptJudge} or directly via\n * {@link runSemanticConceptJudge}. Soft-fails (available=false) on LLM\n * or JSON-parse errors so the caller can treat that as \"layer skipped\"\n * rather than \"layer failed\" in a multi-layer pipeline.\n */\n\nimport { callLlmJson, type LlmClientOptions } from './llm-client'\nimport type { Severity } from './multi-layer-verifier'\n\n// ─── Types ──────────────────────────────────────────────────────────────\n\n/**\n * Implementation complexity class for weighted scoring.\n *\n * - `render` (default): the concept is a UI surface that displays static\n *   data — render a list, show a counter, lay out a button. Single-file\n *   work, no external integration.\n * - `integrate`: the concept requires wiring a real external system —\n *   wallet connect (wagmi + RainbowKit + chain config), payment provider\n *   (Stripe Elements + intent + webhook), an API client with auth.\n *   Multi-file, library-knowledge, runtime correctness matters.\n * - `compute`: the concept requires algorithmic work — solver, simulator,\n *   constraint propagation, ML inference. Correctness > UI polish.\n *\n * Default weights (when applied via `weightConcepts: 'complexity'`):\n *   render=1.0, integrate=2.0, compute=2.5\n *\n * Cross-vertical scoring without complexity weighting silently inflates\n * the rate of UI-heavy verticals (healthcare, fintech dashboards) vs\n * integration-heavy verticals (DeFi, wallets) — all concepts treated\n * equally even though the agent does 2-3x the work for `integrate`.\n */\nexport type ConceptComplexity = 'render' | 'integrate' | 'compute'\n\nexport interface ConceptSpec {\n  name: string\n  /** Short hints that help the judge; not used for matching. */\n  keywords?: string[]\n  /** Optional explicit weight; default 1.0. Overrides complexity-derived weight. */\n  weight?: number\n  /** Implementation complexity class. Default `render`. */\n  complexity?: ConceptComplexity\n}\n\nexport interface ConceptFinding {\n  concept: string\n  present: boolean\n  /** 0..10. 10 = production-ready; 7 = functional thin; 4 = partial; 0 = absent. */\n  score: number\n  evidence: string\n  severity: Severity\n}\n\nexport interface SemanticConceptJudgeInput {\n  /** Full natural-language prompt the agent was handed. */\n  userRequest: string\n  /** Rendered HTML the preview returns (UI artifacts). Optional. */\n  servedHtml?: string\n  /** Top-level source files from the agent's workdir. */\n  sourceFiles: Array<{ path: string; content: string }>\n  /** The expected concept list. */\n  expectedConcepts: ConceptSpec[]\n  /** Free-form metadata (id, difficulty) to inject into the prompt. */\n  artifactLabel?: string\n  artifactDescription?: string\n}\n\nexport interface SemanticConceptJudgeResult {\n  kind: 'semantic-concept'\n  version: string\n  /** Normalized 0..1 score — mean of per-concept scores / 10. */\n  score: number\n  presentCount: number\n  totalCount: number\n  findings: ConceptFinding[]\n  summary: string\n  durationMs: number\n  costUsd: number | null\n  /** False on LLM/JSON error — treat as \"skipped / unable to judge\" in pipelines. */\n  available: boolean\n  error?: string\n}\n\n/**\n * Score-aggregation strategy. `mean` averages 0-10 scores uniformly.\n * `complexity` applies the default weight table (render=1, integrate=2,\n * compute=2.5) unless a concept has an explicit `weight`. `explicit`\n * honors only `weight` (defaulting to 1 for unspecified).\n */\nexport type ConceptWeightStrategy = 'mean' | 'complexity' | 'explicit'\n\nexport const DEFAULT_COMPLEXITY_WEIGHTS: Record<ConceptComplexity, number> = {\n  render: 1.0,\n  integrate: 2.0,\n  compute: 2.5,\n}\n\nexport interface SemanticConceptJudgeOptions {\n  /** Model id to call. Default 'claude-sonnet-4-6' via agent-eval defaults. */\n  model?: string\n  /** Per-call timeout. Default 180s. */\n  timeoutMs?: number\n  /** Pipeline budget for the prompt (source blob truncation). Default 45000. */\n  maxSourceChars?: number\n  /** Per-file cap before inclusion. Default 20000. */\n  maxPerFileChars?: number\n  /** HTML cap. Default 30000. */\n  maxHtmlChars?: number\n  /** LlmClient config (baseUrl, apiKey, authHeader, …). */\n  llm?: LlmClientOptions\n  /**\n   * Score aggregation strategy. Default `mean` — uniform average across\n   * concepts. Cross-vertical comparisons should use `complexity` to\n   * neutralize the integrate-vs-render asymmetry.\n   */\n  weightConcepts?: ConceptWeightStrategy\n  /** Override the default complexity → weight table. */\n  complexityWeights?: Partial<Record<ConceptComplexity, number>>\n}\n\n// ─── Prompt assembly ────────────────────────────────────────────────────\n\nexport const SEMANTIC_CONCEPT_JUDGE_VERSION = 'semantic-concept-judge-v1-2026-04-24'\n\nconst DEFAULT_MAX_SOURCE = 45_000\nconst DEFAULT_MAX_HTML = 30_000\nconst DEFAULT_MAX_PER_FILE = 20_000\nconst DEFAULT_TIMEOUT = 180_000\nconst DEFAULT_MODEL = 'claude-sonnet-4-6'\n\nconst SEMANTIC_SCHEMA = {\n  type: 'object',\n  additionalProperties: false,\n  required: ['summary', 'concepts'],\n  properties: {\n    summary: { type: 'string', minLength: 20, maxLength: 600 },\n    concepts: {\n      type: 'array',\n      minItems: 1,\n      items: {\n        type: 'object',\n        additionalProperties: false,\n        required: ['concept', 'present', 'score', 'evidence', 'severity'],\n        properties: {\n          concept: { type: 'string', minLength: 1, maxLength: 120 },\n          present: { type: 'boolean' },\n          score: { type: 'number', minimum: 0, maximum: 10 },\n          evidence: { type: 'string', minLength: 5, maxLength: 400 },\n          severity: { type: 'string', enum: ['critical', 'major', 'minor', 'info'] },\n        },\n      },\n    },\n  },\n}\n\nfunction truncate(body: string, cap: number, label: string): string {\n  if (body.length <= cap) return body\n  return `${body.slice(0, cap)}\\n… [truncated ${body.length - cap} chars of ${label}]`\n}\n\nfunction buildPrompt(\n  input: SemanticConceptJudgeInput,\n  opts: Required<SemanticConceptJudgeOptions>,\n): string {\n  const sourceBlob = input.sourceFiles\n    .filter((f) => f.content.length <= opts.maxPerFileChars)\n    .map((f) => `--- FILE: ${f.path} ---\\n${f.content}`)\n    .join('\\n\\n')\n\n  const html = input.servedHtml ?? ''\n\n  return `You are a strict code-review judge evaluating whether an agent's 0-to-1 build actually implements the features the user asked for.\n\nYou MUST distinguish:\n  (a) WORKING code that implements the concept (rendered UI, wired handler, real API call),\n  (b) KEYWORD-PRESENT stub (comments mentioning the concept, variable names, TODOs),\n  (c) ABSENT (concept nowhere).\n\nA comment like \"// TODO: add mint button\" is NOT present — score 2-3. Only count a concept as present if there is real functional code: a rendered component, a call handler wired to state or a network call, a computed value actually used.\n\nUSER REQUEST (what the agent was asked to build):\n${input.userRequest}\n\n${input.artifactLabel ? `ARTIFACT METADATA:\\n  name: ${input.artifactLabel}\\n  description: ${input.artifactDescription ?? ''}\\n\\n` : ''}EXPECTED CONCEPTS (each must be graded independently):\n${input.expectedConcepts\n  .map(\n    (c, i) =>\n      `  ${i + 1}. \"${c.name}\"${c.keywords?.length ? ` — hints: [${c.keywords.slice(0, 6).join(' | ')}]` : ''}`,\n  )\n  .join('\\n')}\n\n${html ? `SERVED HTML (what the preview returns when hit):\\n${truncate(html, opts.maxHtmlChars, 'HTML')}\\n\\n` : ''}SOURCE FILES (the agent's workdir):\n${truncate(sourceBlob, opts.maxSourceChars, 'source')}\n\nFor EACH concept, return:\n  - concept: the concept name as given (match exactly)\n  - present: boolean — does a working implementation exist?\n  - score: 0-10 — 10 = production-ready; 7 = functional but thin; 4 = partial/stubbed; 2 = keyword-only comment; 0 = absent\n  - evidence: cite \"<file>:<line>\" or \"served-html:<selector>\" pointing at the strongest supporting code. If the concept is absent or stubbed, explain what's missing.\n  - severity:\n      \"info\" when present: true AND score >= 7\n      \"minor\" when present: true AND 4 <= score < 7\n      \"major\" when present: false OR score < 4\n      \"critical\" when the concept is not only absent but a core user flow depends on it\n\nAlso produce a \"summary\" (one sentence, 20-600 chars): overall verdict on whether this is a shippable implementation of the user request vs a keyword-dense placeholder.\n\nBE SKEPTICAL. Keyword matching already passed — your job is to catch what keyword matching misses. If the agent shipped a working build, say so. If it shipped a stub, say so. Don't grade on effort.\n\nReturn STRICT JSON. No prose outside the JSON.`\n}\n\n// ─── Runner ─────────────────────────────────────────────────────────────\n\n/**\n * Run the semantic concept judge. Soft-fails to available=false on\n * LLM/JSON errors — callers in a MultiLayerVerifier pipeline can treat\n * that as \"skip\" rather than \"fail.\"\n */\nexport async function runSemanticConceptJudge(\n  input: SemanticConceptJudgeInput,\n  options: SemanticConceptJudgeOptions = {},\n): Promise<SemanticConceptJudgeResult> {\n  const start = Date.now()\n  const totalCount = input.expectedConcepts.length\n\n  if (totalCount === 0) {\n    return {\n      kind: 'semantic-concept',\n      version: SEMANTIC_CONCEPT_JUDGE_VERSION,\n      score: 0,\n      presentCount: 0,\n      totalCount: 0,\n      findings: [],\n      summary: 'no expected concepts declared',\n      durationMs: 0,\n      costUsd: null,\n      available: false,\n      error: 'no expected concepts declared',\n    }\n  }\n\n  const opts: Required<SemanticConceptJudgeOptions> = {\n    model: options.model ?? DEFAULT_MODEL,\n    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT,\n    maxSourceChars: options.maxSourceChars ?? DEFAULT_MAX_SOURCE,\n    maxPerFileChars: options.maxPerFileChars ?? DEFAULT_MAX_PER_FILE,\n    maxHtmlChars: options.maxHtmlChars ?? DEFAULT_MAX_HTML,\n    llm: options.llm ?? {},\n    weightConcepts: options.weightConcepts ?? 'mean',\n    complexityWeights: { ...DEFAULT_COMPLEXITY_WEIGHTS, ...(options.complexityWeights ?? {}) },\n  }\n\n  // Build a name → weight map for aggregation. Mean strategy keeps every\n  // weight at 1 (uniform average). Complexity strategy reads the table\n  // and lets an explicit `weight` override. Explicit strategy uses ONLY\n  // the spec's `weight` (defaulting to 1).\n  const weightForConcept = (spec: ConceptSpec): number => {\n    if (opts.weightConcepts === 'mean') return 1\n    if (spec.weight != null) return spec.weight\n    if (opts.weightConcepts === 'complexity') {\n      return opts.complexityWeights[spec.complexity ?? 'render'] ?? 1\n    }\n    return 1\n  }\n  const weightByName = new Map<string, number>(\n    input.expectedConcepts.map((c) => [c.name, weightForConcept(c)]),\n  )\n\n  try {\n    const { value, result } = await callLlmJson<{\n      summary: string\n      concepts: ConceptFinding[]\n    }>(\n      {\n        model: opts.model,\n        messages: [\n          {\n            role: 'system',\n            content:\n              'You are a strict code-review judge. Return strict JSON only. No prose outside the JSON. A keyword in a comment is NOT a working implementation.',\n          },\n          { role: 'user', content: buildPrompt(input, opts) },\n        ],\n        jsonSchema: { name: 'semantic_concept_judge', schema: SEMANTIC_SCHEMA },\n        temperature: 0,\n        timeoutMs: opts.timeoutMs,\n      },\n      opts.llm,\n    )\n\n    if (!value?.concepts || !Array.isArray(value.concepts)) {\n      throw new Error('judge returned malformed response — expected array under \"concepts\"')\n    }\n\n    const findings: ConceptFinding[] = value.concepts.map((c) => ({\n      concept: String(c.concept),\n      present: Boolean(c.present),\n      score: Math.max(0, Math.min(10, Number(c.score ?? 0))),\n      evidence: String(c.evidence ?? ''),\n      severity: (['critical', 'major', 'minor', 'info'] as const).includes(c.severity)\n        ? c.severity\n        : 'info',\n    }))\n\n    const presentCount = findings.filter((f) => f.present && f.score >= 7).length\n    let weightSum = 0\n    let weightedScoreSum = 0\n    for (const f of findings) {\n      const w = weightByName.get(f.concept) ?? 1\n      weightSum += w\n      weightedScoreSum += w * f.score\n    }\n    const scoreAvg =\n      weightSum > 0\n        ? weightedScoreSum / weightSum\n        : findings.reduce((a, f) => a + f.score, 0) / Math.max(1, findings.length)\n\n    return {\n      kind: 'semantic-concept',\n      version: SEMANTIC_CONCEPT_JUDGE_VERSION,\n      score: Number((scoreAvg / 10).toFixed(3)),\n      presentCount,\n      totalCount,\n      findings,\n      summary: String(value.summary ?? ''),\n      durationMs: Date.now() - start,\n      costUsd: result.costUsd ?? null,\n      available: true,\n    }\n  } catch (err) {\n    return {\n      kind: 'semantic-concept',\n      version: SEMANTIC_CONCEPT_JUDGE_VERSION,\n      score: 0,\n      presentCount: 0,\n      totalCount,\n      findings: [],\n      summary: '',\n      durationMs: Date.now() - start,\n      costUsd: null,\n      available: false,\n      error: err instanceof Error ? err.message : String(err),\n    }\n  }\n}\n\n/**\n * Factory: pin LLM options once, return a closure that accepts inputs.\n * Convenient for pipelines that want to share a single LlmClient config.\n */\nexport function createSemanticConceptJudge(\n  options: SemanticConceptJudgeOptions = {},\n): (input: SemanticConceptJudgeInput) => Promise<SemanticConceptJudgeResult> {\n  return (input) => runSemanticConceptJudge(input, options)\n}\n"],"mappings":";;;;;;;;;;;;;;;;AACA,SAAS,UAAU;AA2BZ,SAAS,gBAAgB,QAA4C;AAC1E,SAAO,GAAG;AAAA,IACR,MAAM,OAAO,YAAY;AAAA,IACzB,QAAQ,OAAO;AAAA,IACf,QAAQ,OAAO;AAAA,IACf,QAAQ,EAAE,OAAO,OAAO,MAAM;AAAA,EAChC,CAAC;AACH;;;ACqFO,SAAS,iBAAiB,MAAwC;AACvE,UAAQ,KAAK,WAAW;AAAA,IACtB,KAAK;AACH,aAAO;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,IAAI,UAAU;AAAA,UACZ,SAAS,KAAK,WAAW;AAAA,UACzB,QAAQ,KAAK;AAAA,QACf,CAAqB;AAAA,MACvB;AAAA,IACF,KAAK;AACH,aAAO;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,IAAI,UAAU;AAAA,UACZ,SAAS,KAAK,WAAW;AAAA,UACzB,QAAQ,KAAK,UAAU;AAAA,QACzB,CAAqB;AAAA,MACvB;AAAA,IACF,KAAK;AACH,aAAO;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,IAAI,UAAU;AAAA,UACZ,SAAS,KAAK;AAAA,UACd,QAAQ,KAAK;AAAA,QACf,CAAqB;AAAA,MACvB;AAAA,IACF,KAAK;AACH,aAAO;AAAA,QACL,WAAW;AAAA,QACX,cAAc,KAAK;AAAA,QACnB,MAAM,OAAO,KAAK,aAAa,KAAK,KAAK,aAAa,KAAK,KAAK,YAAY,GAAG,QAAQ;AAAA,MACzF;AAAA,IACF,KAAK;AACH,aAAO;AAAA,QACL,WAAW;AAAA,QACX,cAAc,KAAK;AAAA,QACnB,MAAM,OAAO,KAAK,aAAa,KAAK,QAAQ,aAAa,KAAK,KAAK,YAAY,GAAG,QAAQ;AAAA,MAC5F;AAAA,EACJ;AACF;AAEA,SAAS,cACP,WACA,cACA,OACY;AACZ,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,MAAM,OAAO,KAAK,aAAa;AAC7B,YAAM,WAAW,aAAa,KAAK,YAAY;AAO/C,YAAM,OAAO,MAAM,KAAK;AAAA,QACtB,OAAO,SAAS;AAAA,QAChB,UAAU,IAAI;AAAA,QACd,UAAU,IAAI;AAAA,QACd,YAAY,IAAI;AAAA,QAChB,aAAa,IAAI;AAAA,QACjB,WAAW,IAAI;AAAA,QACf,WAAW,IAAI;AAAA,MACjB,CAAC;AACD,UAAI,CAAC,UAAU,OAAQ,QAAO,MAAM;AACpC,aAAO,MAAM,QAAQ,KAAK,CAAC,MAAM,iBAAiB,SAAS,MAAM,CAAC,CAAC;AAAA,IACrE;AAAA,EACF;AACF;AAEA,SAAS,iBAAiB,QAAqC;AAC7D,MAAI,OAAO,QAAS,QAAO,QAAQ,OAAO,aAAa,MAAM,CAAC;AAC9D,SAAO,IAAI,QAAe,CAAC,GAAG,WAAW;AACvC,WAAO,iBAAiB,SAAS,MAAM,OAAO,aAAa,MAAM,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC;AAAA,EACrF,CAAC;AACH;AAEA,SAAS,aAAa,QAA4B;AAChD,QAAM,SAAU,OAAgC;AAChD,MAAI,kBAAkB,MAAO,QAAO;AACpC,QAAM,IAAI,IAAI,MAAM,0BAA0B;AAC9C,IAAE,OAAO;AACT,SAAO;AACT;AAEA,SAAS,aAAa,KAAkB,cAA+C;AACrF,MAAI,IAAI,MAAO,QAAO;AACtB,MAAI,CAAC,cAAc;AACjB,UAAM,IAAI;AAAA,MACR;AAAA,IAEF;AAAA,EACF;AACA,SAAO,EAAE,GAAG,KAAK,OAAO,aAAa;AACvC;;;AC/KA,IAAM,sBAAsB;AAE5B,IAAM,iBAAiB;AAEvB,IAAM,YAAY;AAElB,SAAS,IAAI,GAA2B;AACtC,SAAO,OAAO,MAAM,YAAY,OAAO,SAAS,CAAC,IAAI,IAAI;AAC3D;AACA,SAAS,cAAc,GAAoC;AACzD,SAAO,IAAI,EAAE,WAAW,kBAAkB,CAAC,KAAK,IAAI,EAAE,WAAW,wBAAwB,CAAC;AAC5F;AACA,SAAS,eAAe,GAAoC;AAC1D,SAAO,IAAI,EAAE,WAAW,mBAAmB,CAAC,KAAK,IAAI,EAAE,WAAW,yBAAyB,CAAC;AAC9F;AACA,SAAS,OAAO,GAAoC;AAClD,SAAO,IAAI,EAAE,WAAW,IAAI;AAC9B;AACA,SAAS,WAAW,GAAoC;AACtD,MAAI,EAAE,UAAW,QAAO,EAAE;AAC1B,QAAM,IAAI,EAAE,WAAW,WAAW;AAClC,SAAO,OAAO,MAAM,YAAY,EAAE,SAAS,IAAI,IAAI;AACrD;AAMO,SAAS,oBAAoB,OAAuD;AAEzF,QAAM,UAAU,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,GAAG,MAAM;AACxC,UAAM,KAAK,OAAO,CAAC;AACnB,UAAM,KAAK,OAAO,CAAC;AACnB,QAAI,OAAO,QAAQ,OAAO,QAAQ,OAAO,GAAI,QAAO,KAAK;AACzD,WAAO,EAAE,WAAW,cAAc,EAAE,UAAU;AAAA,EAChD,CAAC;AAED,QAAM,uBAAiC,CAAC;AACxC,QAAM,wBAAkC,CAAC;AACzC,QAAM,gBAAwC,CAAC;AAC/C,MAAI,sBAAsB;AAE1B,aAAW,KAAK,SAAS;AACvB,UAAM,MAAM,cAAc,CAAC;AAC3B,QAAI,QAAQ,KAAM,sBAAqB,KAAK,GAAG;AAC/C,UAAM,OAAO,eAAe,CAAC;AAC7B,QAAI,SAAS,KAAM,uBAAsB,KAAK,IAAI;AAClD,UAAM,OAAO,WAAW,CAAC;AACzB,QAAI,MAAM;AACR,oBAAc,IAAI,KAAK,cAAc,IAAI,KAAK,KAAK;AACnD,UAAI,UAAU,KAAK,IAAI,EAAG,uBAAsB;AAAA,IAClD;AAAA,EACF;AAEA,QAAM,iBAAiB,OAAO,OAAO,aAAa,EAAE,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC;AAC7E,QAAM,gBAAgB,OAAO,KAAK,aAAa,EAAE;AACjD,QAAM,qBAAqB,mBAAmB,IAAI,IAAI,gBAAgB;AAEtE,QAAM,UAA8B,CAAC;AAErC,MAAI,qBAAqB,UAAU,GAAG;AACpC,UAAM,QAAQ,qBAAqB,CAAC;AACpC,UAAM,OAAO,qBAAqB,qBAAqB,SAAS,CAAC;AACjE,UAAM,SAAS,QAAQ,IAAI,OAAO,QAAQ;AAC1C,QAAI,OAAO,SAAS,UAAU,qBAAqB;AACjD,cAAQ,KAAK;AAAA,QACX,MAAM;AAAA,QACN,UAAU;AAAA,QACV,QAAQ,yBAAyB,OAAO,QAAQ,CAAC,CAAC,MAAM,KAAK,SAAI,IAAI,YAAY,qBAAqB,MAAM;AAAA,QAC5G,UAAU;AAAA,UACR;AAAA,UACA;AAAA,UACA,UAAU,OAAO,OAAO,QAAQ,CAAC,CAAC;AAAA,UAClC,OAAO,qBAAqB;AAAA,QAC9B;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAEA,MAAI,sBAAsB,UAAU,GAAG;AACrC,UAAM,QAAQ,sBAAsB,CAAC;AACrC,UAAM,OAAO,sBAAsB,sBAAsB,SAAS,CAAC;AACnE,QAAI,OAAO,OAAO;AAChB,cAAQ,KAAK;AAAA,QACX,MAAM;AAAA,QACN,UAAU;AAAA,QACV,QAAQ,4BAA4B,KAAK,SAAI,IAAI,SAAS,sBAAsB,MAAM;AAAA,QACtF,UAAU,EAAE,OAAO,MAAM,OAAO,sBAAsB,OAAO;AAAA,MAC/D,CAAC;AAAA,IACH;AAAA,EACF;AAEA,MAAI,kBAAkB,kBAAkB,kBAAkB,GAAG;AAC3D,UAAM,OAAO,OAAO,KAAK,aAAa,EAAE,CAAC;AACzC,YAAQ,KAAK;AAAA,MACX,MAAM;AAAA,MACN,UAAU;AAAA,MACV,QAAQ,OAAO,cAAc,qBAAqB,IAAI;AAAA,MACtD,UAAU,EAAE,MAAM,MAAM,OAAO,gBAAgB,gBAAgB,EAAE;AAAA,IACnE,CAAC;AAAA,EACH;AAEA,MAAI,kBAAkB,kBAAkB,CAAC,qBAAqB;AAC5D,YAAQ,KAAK;AAAA,MACX,MAAM;AAAA,MACN,UAAU;AAAA,MACV,QAAQ,GAAG,cAAc;AAAA,MACzB,UAAU,EAAE,YAAY,gBAAgB,oBAAoB,EAAE;AAAA,IAChE,CAAC;AAAA,EACH;AAEA,SAAO;AAAA,IACL,cAAc,qBAAqB;AAAA,IACnC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;;AC9IA,IAAM,qBAAqD;AAAA,EACzD,0BACE;AAAA,EACF,uBACE;AAAA,EACF,0BACE;AAAA,EACF,wBACE;AACJ;AAEA,IAAM,aAAa;AAMZ,SAAS,yBACd,SACA,OAAoD,CAAC,GACnC;AAClB,QAAM,YAAY,KAAK,aAAa;AACpC,SAAO,QAAQ,QAAQ;AAAA,IAAI,CAAC,QAC1B,YAAY;AAAA,MACV,YAAY;AAAA,MACZ,MAAM;AAAA,MACN,SAAS,IAAI;AAAA;AAAA,MACb,OAAO,IAAI;AAAA,MACX,UAAU,IAAI;AAAA;AAAA,MAEd,YAAY;AAAA,MACZ,eAAe;AAAA,QACb;AAAA,UACE,MAAM;AAAA,UACN,KAAK,uBAAuB,IAAI,IAAI;AAAA,UACpC,SAAS,KAAK,UAAU,IAAI,QAAQ;AAAA,QACtC;AAAA,MACF;AAAA,MACA,oBAAoB,mBAAmB,IAAI,IAAI;AAAA,MAC/C,UAAU,EAAE,eAAe,MAAM,UAAU,IAAI,SAAS;AAAA,MACxD,GAAI,KAAK,aAAa,EAAE,aAAa,KAAK,WAAW,IAAI,CAAC;AAAA,IAC5D,CAAC;AAAA,EACH;AACF;AAGO,SAAS,oBAAiD;AAC/D,SAAO;AAAA,IACL,IAAI;AAAA,IACJ,aACE;AAAA,IACF,WAAW;AAAA,IACX,MAAM,EAAE,MAAM,gBAAgB;AAAA,IAC9B,SAAS;AAAA,IACT,MAAM,QAAQ,OAAO;AACnB,YAAM,WAAW,MAAM,MAAM,YAAY;AACzC,YAAM,QAA4B,CAAC;AACnC,iBAAW,WAAW,SAAS,kBAAkB;AAC/C,cAAM,SAAS,MAAM,MAAM,UAAU,EAAE,UAAU,QAAQ,CAAC;AAC1D,YAAI,OAAO,MAAO,OAAM,KAAK,GAAG,OAAO,KAAK;AAAA,MAC9C;AACA,aAAO,yBAAyB,oBAAoB,KAAK,CAAC;AAAA,IAC5D;AAAA,EACF;AACF;;;AC1DO,SAAS,4BACd,OAAsC,CAAC,GACtB;AACjB,QAAM,WAAW,IAAI,gBAAgB,KAAK,QAAQ;AAClD,MAAI,KAAK,sBAAsB,OAAO;AACpC,aAAS,SAAS,kBAAkB,CAAC;AAAA,EACvC;AACA,MAAI,KAAK,IAAI;AACX,UAAM,QAAQ,KAAK,SAAS;AAC5B,eAAW,QAAQ,OAAO;AACxB,eAAS,SAAS,uBAAuB,MAAM,EAAE,IAAI,KAAK,IAAI,OAAO,KAAK,MAAM,CAAC,CAAC;AAAA,IACpF;AAAA,EACF;AACA,SAAO;AACT;;;AChCO,IAAM,QAAN,MAAY;AAAA,EACT,SAAS;AAAA,EACA,UAA6B,CAAC;AAAA,EAE/C,MAAM,UAA+B;AACnC,QAAI,CAAC,KAAK,QAAQ;AAChB,WAAK,SAAS;AACd,aAAO,MAAM,KAAK,QAAQ;AAAA,IAC5B;AACA,WAAO,IAAI,QAAoB,CAAC,YAAY;AAC1C,WAAK,QAAQ,KAAK,MAAM;AACtB,gBAAQ,MAAM,KAAK,QAAQ,CAAC;AAAA,MAC9B,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAAA,EAEQ,UAAgB;AACtB,UAAM,OAAO,KAAK,QAAQ,MAAM;AAChC,QAAI,MAAM;AACR,WAAK;AAAA,IACP,OAAO;AACL,WAAK,SAAS;AAAA,IAChB;AAAA,EACF;AAAA,EAEA,MAAM,aAAgB,IAAsC;AAC1D,UAAM,UAAU,MAAM,KAAK,QAAQ;AACnC,QAAI;AACF,aAAO,MAAM,GAAG;AAAA,IAClB,UAAE;AACA,cAAQ;AAAA,IACV;AAAA,EACF;AAAA;AAAA,EAGA,IAAI,WAAoB;AACtB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,IAAI,UAAkB;AACpB,WAAO,KAAK,QAAQ;AAAA,EACtB;AACF;;;AC5CA,SAAS,gBAAgB,YAAY,iBAAiB;AACtD,SAAS,eAAe;AAGxB,IAAM,UAAU,oBAAI,IAAmB;AAEvC,SAAS,SAAS,MAAqB;AACrC,MAAI,IAAI,QAAQ,IAAI,IAAI;AACxB,MAAI,CAAC,GAAG;AACN,QAAI,IAAI,MAAM;AACd,YAAQ,IAAI,MAAM,CAAC;AAAA,EACrB;AACA,SAAO;AACT;AAEO,IAAM,sBAAN,MAA0B;AAAA,EAE/B,YAA4B,MAAc;AAAd;AAC1B,SAAK,QAAQ,SAAS,IAAI;AAC1B,QAAI,CAAC,WAAW,QAAQ,IAAI,CAAC,GAAG;AAC9B,gBAAU,QAAQ,IAAI,GAAG,EAAE,WAAW,KAAK,CAAC;AAAA,IAC9C;AAAA,EACF;AAAA,EAL4B;AAAA,EADX;AAAA,EAQjB,MAAM,OAAO,OAA+B;AAC1C,UAAM,OAAO,GAAG,KAAK,UAAU,KAAK,CAAC;AAAA;AACrC,UAAM,KAAK,MAAM,aAAa,MAAM;AAClC,qBAAe,KAAK,MAAM,IAAI;AAAA,IAChC,CAAC;AAAA,EACH;AACF;AAGO,SAAS,iCAAuC;AACrD,UAAQ,MAAM;AAChB;;;AC1BA,SAAS,cAAAA,aAAY,oBAAoB;AAclC,IAAM,gBAAN,MAAoB;AAAA,EAGzB,YAA4B,MAAc;AAAd;AAC1B,SAAK,WAAW,IAAI,oBAAoB,IAAI;AAAA,EAC9C;AAAA,EAF4B;AAAA,EAFX;AAAA,EAMjB,MAAM,OAAO,OAAe,UAA2C;AACrE,eAAW,KAAK,UAAU;AACxB,YAAM,MAAwB,EAAE,GAAG,GAAG,QAAQ,MAAM;AACpD,YAAM,KAAK,SAAS,OAAO,GAAG;AAAA,IAChC;AAAA,EACF;AAAA;AAAA,EAGA,UAA8B;AAC5B,QAAI,CAACC,YAAW,KAAK,IAAI,EAAG,QAAO,CAAC;AACpC,UAAM,MAAM,aAAa,KAAK,MAAM,MAAM;AAC1C,QAAI,CAAC,IAAK,QAAO,CAAC;AAClB,UAAM,MAA0B,CAAC;AACjC,eAAW,QAAQ,IAAI,MAAM,IAAI,GAAG;AAClC,UAAI,CAAC,KAAM;AACX,UAAI;AACF,YAAI,KAAK,KAAK,MAAM,IAAI,CAAqB;AAAA,MAC/C,QAAQ;AAAA,MAGR;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,QAAQ,OAAmC;AACzC,WAAO,KAAK,QAAQ,EAAE,OAAO,CAAC,MAAM,EAAE,WAAW,KAAK;AAAA,EACxD;AACF;AAiCO,SAAS,kBAAkB,GAAmB,GAA4B;AAC/E,MAAI,EAAE,aAAa,EAAE,SAAU,QAAO;AACtC,MAAI,KAAK,KAAK,EAAE,cAAc,MAAM,EAAE,cAAc,EAAE,IAAI,KAAM,QAAO;AACvE,MAAI,EAAE,cAAc,WAAW,EAAE,cAAc,OAAQ,QAAO;AAC9D,SAAO;AACT;AAMO,SAAS,aACd,UACA,SACA,SAAqB,CAAC,GACR;AACd,QAAM,aAAa,OAAO,cAAc;AACxC,QAAM,WAAW,IAAI,IAAI,SAAS,IAAI,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;AAC/D,QAAM,UAAU,IAAI,IAAI,QAAQ,IAAI,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;AAE7D,QAAM,WAA+B,CAAC;AACtC,QAAM,cAAkC,CAAC;AACzC,QAAM,YAAgC,CAAC;AACvC,QAAM,UAAmC,CAAC;AAE1C,aAAW,CAAC,IAAI,GAAG,KAAK,SAAS;AAC/B,UAAM,OAAO,SAAS,IAAI,EAAE;AAC5B,QAAI,CAAC,MAAM;AACT,eAAS,KAAK,GAAG;AACjB;AAAA,IACF;AACA,QAAI,WAAW,MAAM,GAAG,GAAG;AACzB,cAAQ,KAAK,EAAE,UAAU,MAAM,SAAS,IAAI,CAAC;AAAA,IAC/C,OAAO;AACL,gBAAU,KAAK,GAAG;AAAA,IACpB;AAAA,EACF;AACA,aAAW,CAAC,IAAI,IAAI,KAAK,UAAU;AACjC,QAAI,CAAC,QAAQ,IAAI,EAAE,EAAG,aAAY,KAAK,IAAI;AAAA,EAC7C;AACA,SAAO,EAAE,UAAU,aAAa,WAAW,QAAQ;AACrD;;;AC3HA,SAAsB,cAAAC,aAAY,aAAa,gBAAAC,eAAc,gBAAgB;AAC7E,SAAS,YAAY;AAyDrB,IAAM,uBAAuB;AAE7B,IAAM,oBACJ;AACF,IAAM,aAAa;AAInB,SAAS,cAAc,MAAgD;AACrE,MAAI,CAACC,YAAW,IAAI,EAAG,QAAO,CAAC;AAC/B,QAAM,MAAwC,CAAC;AAC/C,aAAW,SAAS,YAAY,MAAM,EAAE,eAAe,KAAK,CAAC,GAAG;AAC9D,QAAI,CAAC,MAAM,YAAY,KAAK,CAAC,MAAM,eAAe,EAAG;AACrD,UAAM,UAAU,KAAK,MAAM,MAAM,MAAM,UAAU;AACjD,QAAIA,YAAW,OAAO,EAAG,KAAI,KAAK,EAAE,MAAM,MAAM,MAAM,MAAM,QAAQ,CAAC;AAAA,EACvE;AACA,SAAO;AACT;AAEA,SAAS,UAAU,KAAa,KAAuB;AACrD,MAAI,CAACA,YAAW,GAAG,EAAG,QAAO,CAAC;AAC9B,QAAM,QAAkB,CAAC;AACzB,QAAM,QAAQ,CAAC,GAAG;AAClB,SAAO,MAAM,QAAQ;AACnB,UAAM,MAAM,MAAM,IAAI;AACtB,QAAI;AACJ,QAAI;AACF,gBAAU,YAAY,KAAK,EAAE,eAAe,KAAK,CAAC;AAAA,IACpD,QAAQ;AACN;AAAA,IACF;AACA,eAAW,KAAK,SAAS;AACvB,YAAM,OAAO,KAAK,KAAK,EAAE,IAAI;AAC7B,UAAI,EAAE,YAAY,EAAG,OAAM,KAAK,IAAI;AAAA,eAC3B,EAAE,KAAK,SAAS,QAAQ,GAAG;AAClC,cAAM,KAAK,IAAI;AACf,YAAI,MAAM,KAAK,MAAM,UAAU,IAAK,QAAO;AAAA,MAC7C;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,uBAAuB,MAAsB;AACpD,QAAM,KAAK,wBAAwB,KAAK,IAAI;AAC5C,QAAM,QAAQ,KAAK,CAAC,KAAK;AACzB,QAAM,IAAI,uBAAuB,KAAK,KAAK;AAC3C,SAAO,IAAI,CAAC,KAAK;AACnB;AAEA,SAAS,eAAe,OAAiB,MAAc,SAA2B;AAChF,MAAI,IAAI;AACR,aAAW,QAAQ,OAAO;AACxB,UAAM,aAAa,CAAC,KAAK,MAAM,WAAW,IAAI,GAAG,GAAG,QAAQ,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC;AACrF,eAAW,OAAO,YAAY;AAC5B,UAAI,CAACA,YAAW,GAAG,EAAG;AACtB,UAAI;AACF,YAAI,SAAS,GAAG,EAAE,YAAY,EAAG,MAAK,YAAY,GAAG,EAAE;AAAA,YAClD,MAAK;AAAA,MACZ,QAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAGO,SAAS,sBAAsB,QAAgD;AACpF,QAAM,SAAS,OAAO,WAAW;AAAA,IAAQ,CAAC,EAAE,MAAM,KAAK,MACrD,cAAc,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,GAAG,KAAK,EAAE;AAAA,EACjD;AACA,QAAM,QAAQ,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI;AAGtC,QAAM,SAAS,IAAI,IAAoB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AAC/D,QAAM,QAAQ,IAAI,IAAoB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AAC9D,QAAM,UAAU;AAChB,QAAM,QAAQ;AACd,MAAI,cAAc;AAClB,aAAW,OAAO,OAAO,gBAAgB;AACvC,eAAW,QAAQ,UAAU,KAAK,OAAO,wBAAwB,CAAC,GAAG;AACnE,qBAAe;AACf,UAAI;AACJ,UAAI;AACF,eAAOC,cAAa,MAAM,MAAM;AAAA,MAClC,QAAQ;AACN;AAAA,MACF;AACA,iBAAW,KAAK,KAAK,SAAS,OAAO,GAAG;AACtC,cAAM,IAAI,EAAE,CAAC;AACb,YAAI,CAAC,EAAG;AACR,cAAM,IAAI,EAAE,MAAM,GAAG,EAAE,IAAI,KAAK;AAChC,cAAM,OAAO,OAAO,IAAI,CAAC;AACzB,YAAI,SAAS,OAAW,QAAO,IAAI,GAAG,OAAO,CAAC;AAAA,MAChD;AACA,iBAAW,KAAK,KAAK,SAAS,KAAK,GAAG;AACpC,cAAM,IAAI,EAAE,CAAC;AACb,YAAI,MAAM,OAAW;AACrB,cAAM,OAAO,MAAM,IAAI,CAAC;AACxB,YAAI,SAAS,OAAW,OAAM,IAAI,GAAG,OAAO,CAAC;AAAA,MAC/C;AAAA,IACF;AAAA,EACF;AAGA,QAAM,SAAS,oBAAI,IAAoB;AACvC,aAAW,KAAK,QAAQ;AACtB,QAAI;AACF,aAAO,IAAI,EAAE,MAAMA,cAAa,EAAE,MAAM,MAAM,CAAC;AAAA,IACjD,QAAQ;AACN,aAAO,IAAI,EAAE,MAAM,EAAE;AAAA,IACvB;AAAA,EACF;AACA,QAAM,UAAU,IAAI,IAAoB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AAChE,aAAW,UAAU,OAAO;AAC1B,UAAM,MAAM,IAAI,OAAO,IAAI,MAAM,aAAa,MAAM,QAAQ;AAC5D,eAAW,KAAK,QAAQ;AACtB,UAAI,EAAE,SAAS,OAAQ;AACvB,UAAI,IAAI,KAAK,OAAO,IAAI,EAAE,IAAI,KAAK,EAAE,EAAG,SAAQ,IAAI,QAAQ,QAAQ,IAAI,MAAM,IAAK,CAAC;AAAA,IACtF;AAAA,EACF;AAEA,QAAM,UAA8B,OAAO,IAAI,CAAC,MAAM;AACpD,UAAM,OAAO,OAAO,IAAI,EAAE,IAAI,KAAK;AACnC,UAAM,MAAM,EAAE,KAAK,QAAQ,gBAAgB,EAAE;AAC7C,WAAO;AAAA,MACL,MAAM,EAAE;AAAA,MACR,MAAM,EAAE;AAAA,MACR,MAAM,EAAE;AAAA,MACR,OAAO,OAAO,KAAK,MAAM,IAAI,EAAE,SAAS;AAAA,MACxC,mBAAmB,OAAO,IAAI,EAAE,IAAI,KAAK;AAAA,MACzC,kBAAkB,MAAM,IAAI,EAAE,IAAI,KAAK;AAAA,MACvC,aAAa,QAAQ,IAAI,EAAE,IAAI,KAAK;AAAA,MACpC,eAAe;AAAA,QACb,OAAO,iBAAiB,CAAC;AAAA,QACzB,EAAE;AAAA,QACF,OAAO,kBAAkB,EAAE,IAAI,KAAK,CAAC;AAAA,MACvC;AAAA,MACA,oBAAoB,KAAK,MAAM,iBAAiB,KAAK,CAAC,GAAG;AAAA,MACzD,kBAAkBD,YAAW,KAAK,KAAK,YAAY,CAAC;AAAA,MACpD,aAAaA,YAAW,KAAK,KAAK,OAAO,CAAC;AAAA,MAC1C,UAAU,KAAK,SAAS,kBAAkB;AAAA,MAC1C,mBAAmB,WAAW,KAAK,uBAAuB,IAAI,KAAK,KAAK,MAAM,GAAG,GAAG,CAAC;AAAA,IACvF;AAAA,EACF,CAAC;AACD,SAAO,EAAE,qBAAqB,aAAa,QAAQ;AACrD;AAIA,IAAME,cAAa;AAEnB,SAAS,QACP,MACA,SACA,OACA,UACA,YACA,YACA,aACA,aACA,WACgB;AAChB,SAAO;AAAA,IACL,gBAAgB;AAAA,IAChB,YAAY,iBAAiB,EAAE,YAAYA,aAAY,MAAM,SAAS,MAAM,CAAC;AAAA,IAC7E,YAAYA;AAAA,IACZ,aAAa;AAAA,IACb;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,eAAe,CAAC,EAAE,MAAM,YAAY,KAAK,YAAY,CAAC;AAAA,IACtD,oBAAoB;AAAA,IACpB;AAAA,IACA;AAAA,EACF;AACF;AAGO,SAAS,uBACd,QACA,YACkB;AAClB,QAAM,MAAwB,CAAC;AAC/B,aAAW,KAAK,OAAO,SAAS;AAC9B,UAAM,cAAc,EAAE,oBAAoB,EAAE;AAC5C,UAAM,YAAY,cAAc,EAAE,cAAc,EAAE;AAGlD,QAAI,cAAc,GAAG;AACnB,UAAI;AAAA,QACF;AAAA,UACE;AAAA,UACA,EAAE;AAAA,UACF,UAAU,EAAE,IAAI;AAAA,UAChB;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,EAAE;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF,WAAW,gBAAgB,KAAK,EAAE,cAAc,EAAE,gBAAgB,GAAG;AAEnE,UAAI;AAAA,QACF;AAAA,UACE;AAAA,UACA,EAAE;AAAA,UACF,UAAU,EAAE,IAAI,iFAAiF,EAAE,WAAW,eAAe,EAAE,aAAa;AAAA,UAC5I;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,EAAE;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAGA,QAAI,eAAe,KAAK,CAAC,EAAE,mBAAmB;AAC5C,UAAI;AAAA,QACF;AAAA,UACE;AAAA,UACA,EAAE;AAAA,UACF,UAAU,EAAE,IAAI;AAAA,UAChB;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,EAAE;AAAA,QACJ;AAAA,MACF;AAAA,IACF;AAGA,QAAI,EAAE,SAAS,YAAY,EAAE,oBAAoB,GAAG;AAClD,UAAI;AAAA,QACF;AAAA,UACE;AAAA,UACA,EAAE;AAAA,UACF,iBAAiB,EAAE,IAAI,aAAa,EAAE,iBAAiB;AAAA,UACvD;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,EAAE;AAAA,QACJ;AAAA,MACF;AAAA,IACF;AAGA,QAAI,EAAE,QAAQ,wBAAwB,CAAC,EAAE,kBAAkB;AACzD,UAAI;AAAA,QACF;AAAA,UACE;AAAA,UACA,EAAE;AAAA,UACF,UAAU,EAAE,IAAI,QAAQ,EAAE,KAAK;AAAA,UAC/B;AAAA,UACA;AAAA,UACA;AAAA,UACA,mFAAmF,EAAE,KAAK;AAAA,UAC1F,EAAE;AAAA,QACJ;AAAA,MACF;AAAA,IACF;AAGA,QAAI,CAAC,EAAE,aAAa;AAClB,UAAI;AAAA,QACF;AAAA,UACE;AAAA,UACA,EAAE;AAAA,UACF,UAAU,EAAE,IAAI;AAAA,UAChB;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,EAAE;AAAA,QACJ;AAAA,MACF;AAAA,IACF;AAGA,QAAI,CAAC,EAAE,UAAU;AACf,UAAI;AAAA,QACF;AAAA,UACE;AAAA,UACA,EAAE;AAAA,UACF,UAAU,EAAE,IAAI;AAAA,UAChB;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,EAAE;AAAA,QACJ;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAIO,IAAM,oBAAN,MAA6D;AAAA,EACzD,KAAKA;AAAA,EACL,cACP;AAAA,EACO,YAAY;AAAA,EACZ,OAAO,EAAE,MAAM,iBAA0B,iBAAiB,EAAE;AAAA,EAC5D,UAAU;AAAA,EAEnB,MAAM,QAAQ,OAAyB,KAAgD;AACrF,UAAM,aAAa,IAAI,MAAM,eAAc,oBAAI,KAAK,GAAE,YAAY;AAClE,QAAI;AAAA,MACF,gBAAgB,MAAM,QAAQ,MAAM,gBAAgB,MAAM,mBAAmB;AAAA,IAC/E;AACA,WAAO,uBAAuB,OAAO,UAAU;AAAA,EACjD;AACF;AAEO,IAAM,sBAAsB,IAAI,kBAAkB;;;ACtXlD,IAAM,4BAA6C;AAAA,EACxD,SAAS;AAAA,EACT,cAAc;AAAA,EACd,kBAAkB;AAAA,EAClB,cAAc;AAAA,EACd,gBAAgB;AAAA,EAChB,cAAc;AAAA,EACd,aAAa;AAAA,EACb,WAAW;AAAA,EACX,kBAAkB;AAAA,EAClB,SAAS;AAAA,EACT,aAAa;AACf;AAEO,SAAS,kBAAkB,OAAiB,UAAoC,CAAC,GAAW;AACjG,QAAM,IAAI,EAAE,GAAG,2BAA2B,GAAG,QAAQ;AACrD,SACE,EAAE,UAAU,QAAQ,MAAM,OAAO,IACjC,EAAE,eAAe,QAAQ,MAAM,YAAY,IAC3C,EAAE,mBAAmB,QAAQ,MAAM,gBAAgB,IACnD,EAAE,eAAe,QAAQ,MAAM,YAAY,IAC3C,EAAE,iBAAiB,QAAQ,MAAM,cAAc,IAC/C,EAAE,eAAe,QAAQ,MAAM,YAAY,IAC3C,EAAE,cAAc,QAAQ,MAAM,WAAW,IACzC,EAAE,YAAY,QAAQ,MAAM,SAAS,IACrC,EAAE,mBAAmB,QAAQ,MAAM,gBAAgB,IACnD,EAAE,UAAU,KAAK,IAAI,GAAG,aAAa,MAAM,OAAO,CAAC,IACnD,EAAE,cAAc,KAAK,IAAI,GAAG,aAAa,MAAM,WAAW,IAAI,EAAE;AAEpE;AAEO,SAAS,QAAQ,OAAuB;AAC7C,MAAI,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACpC,SAAO,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,KAAK,CAAC;AACvC;AAEA,SAAS,aAAa,OAAuB;AAC3C,SAAO,OAAO,SAAS,KAAK,IAAI,QAAQ;AAC1C;;;AClDA,IAAM,yBAAyB;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,YAAN,MAAgB;AAAA,EACJ;AAAA,EACA;AAAA,EAEjB,YAAY,UAA4B,CAAC,GAAG;AAC1C,SAAK,UAAU,QAAQ;AACvB,SAAK,gBAAgB,QAAQ,iBAAiB;AAAA,EAChD;AAAA,EAEA,MAAM,MAAM,OAAmB,OAAkC;AAC/D,UAAM,MAAM,MAAM,MAAM,OAAO,KAAK;AACpC,QAAI,CAAC,IAAK,OAAM,IAAI,cAAc,OAAO,KAAK,YAAY;AAC1D,UAAM,CAAC,OAAO,QAAQ,WAAW,MAAM,IAAI,MAAM,QAAQ,IAAI;AAAA,MAC3D,MAAM,MAAM,EAAE,MAAM,CAAC;AAAA,MACrB,MAAM,OAAO,EAAE,MAAM,CAAC;AAAA,MACtB,MAAM,UAAU,KAAK;AAAA,MACrB,MAAM,OAAO,KAAK;AAAA,IACpB,CAAC;AACD,WAAO,KAAK,WAAW,EAAE,KAAK,OAAO,QAAQ,WAAW,OAAO,CAAC;AAAA,EAClE;AAAA,EAEA,WAAW,OAA2B;AACpC,UAAM,QAAkB,CAAC;AACzB,UAAM,WAAW,MAAM,MAAM;AAAA,MAC3B,CAAC,MAA2C,EAAE,SAAS;AAAA,IACzD;AACA,UAAM,YAAY,MAAM,MAAM;AAAA,MAC5B,CAAC,MAA4C,EAAE,SAAS;AAAA,IAC1D;AACA,UAAM,aAAa,MAAM,MAAM;AAAA,MAC7B,CAAC,MAA6C,EAAE,SAAS;AAAA,IAC3D;AACA,UAAM,eAAe,MAAM,MAAM;AAAA,MAC/B,CAAC,MAA+C,EAAE,SAAS;AAAA,IAC7D;AACA,UAAM,iBAAiB,WAAW;AAAA,MAChC,CAAC,SAAS,KAAK,cAAc,gBAAgB,KAAK,YAAY,cAAc;AAAA,IAC9E;AAEA,UAAM,UACJ,MAAM,IAAI,SAAS,SAAS,OAAO,IAAI,MAAM,IAAI,WAAW,cAAc,MAAM;AAClF,QAAI,CAAC,QAAS,OAAM,KAAK,qCAAqC;AAE9D,UAAM,eAAe,WAAW,SAC5B,WAAW,OAAO,CAAC,KAAK,SAAS,MAAM,oBAAoB,KAAK,KAAK,GAAG,CAAC,IACzE,WAAW,SACX;AACJ,UAAM,eACJ,OAAO,MAAM,IAAI,SAAS,UAAU,WAChC;AAAA,MACE,MAAM,IAAI,QAAQ,QAAQ,IAAI,MAAM,IAAI,QAAQ,QAAQ,MAAM,MAAM,IAAI,QAAQ;AAAA,IAClF,IACA;AACN,UAAM,eAAe,gBAAgB,gBAAgB;AAErD,UAAM,kBAAkB,UAAU,OAAO,CAAC,SAAS,KAAK,WAAW,OAAO,EAAE;AAC5E,UAAM,iBAAiB,UAAU,WAAW,IAAI,IAAI,kBAAkB,UAAU;AAChF,QAAI,UAAU,WAAW,EAAG,OAAM,KAAK,wBAAwB;AAE/D,UAAM,gBACJ,MAAM,UAAU,SAChB,UAAU,OAAO,CAAC,SAAS,0BAA0B,KAAK,KAAK,QAAQ,CAAC,EAAE;AAC5E,UAAM,eAAe,gBAAgB,IAAI,QAAQ,gBAAgB,CAAC,IAAI;AACtE,QAAI,CAAC,aAAc,OAAM,KAAK,uCAAuC;AAErE,UAAM,eAAe,aAAa;AAAA,MAChC,CAAC,SAAS,OAAO,KAAK,eAAe,YAAY,KAAK,aAAa;AAAA,IACrE;AACA,UAAM,cAAc,aAAa,SAC7B,aAAa;AAAA,MACX,CAAC,KAAK,SAAS,OAAO,KAAK,eAAe,KAAK,KAAK,IAAI,GAAG,KAAK,cAAc,CAAC;AAAA,MAC/E;AAAA,IACF,IAAI,aAAa,SACjB,UAAU;AAAA,MAAK,CAAC,SACZ,yCAAyC,KAAK,KAAK,UAAU,KAAK,IAAI,CAAC;AAAA,IACzE,IACA,MACA;AACN,QAAI,CAAC,YAAa,OAAM,KAAK,sCAAsC;AAEnE,UAAM,eAAe,WAAW,OAAO,CAAC,SAAS,gBAAgB,IAAI,CAAC;AACtE,UAAM,oBAAoB,eAAe,OAAO,CAAC,SAAS,gBAAgB,IAAI,CAAC;AAC/E,UAAM,YAAY,eAAe,SAAU,kBAAkB,SAAS,IAAI,IAAK;AAC/E,QAAI,kBAAkB;AACpB,YAAM,KAAK,yBAAyB,kBAAkB,MAAM,cAAc;AAAA,aACnE,CAAC,eAAe,OAAQ,OAAM,KAAK,iCAAiC;AAE7E,UAAM,mBAAmB,WAAW,SAAS,aAAa,SAAS,WAAW,SAAS;AACvF,QAAI,iBAAkB,OAAM,KAAK,YAAY,aAAa,MAAM,8BAA8B;AAE9F,UAAM,2BACJ,gBACA,aAAa,SACb,SAAS,OAAO,CAAC,SAAS,kBAAkB,KAAK,UAAU,EAAE,CAAC,EAAE;AAClE,UAAM,eACJ,SAAS,OAAO,CAAC,SAAS,KAAK,QAAQ,KAAK,UAAU,EAAE,CAAC,EAAE,SAC3D,MAAM,OAAO,OAAO,CAAC,UAAU,KAAK,QAAQ,KAAK,UAAU,MAAM,OAAO,CAAC,CAAC,EAAE;AAC9E,UAAM,mBACJ,2BAA2B,iBAAiB,IACxC,IACA,4BAA4B,2BAA2B;AAC7D,UAAM,eACJ,2BAA2B,iBAAiB,IACxC,IACA,gBAAgB,2BAA2B;AACjD,QAAI,eAAe,EAAG,OAAM,KAAK,YAAY,YAAY,kBAAkB;AAE3E,UAAM,UAAU,MAAM,OAAO,SACzB,KAAK;AAAA,MACH,GAAG,MAAM,OACN,OAAO,CAAC,UAA6B,MAAM,cAAc,KAAK,EAC9D,IAAI,CAAC,UAA6B,MAAM,QAAQ;AAAA,MACnD;AAAA,IACF,IACA,SAAS,OAAO,CAAC,KAAK,SAAS,OAAO,KAAK,WAAW,IAAI,CAAC;AAC/D,UAAM,cACJ,MAAM,IAAI,WAAW,MAAM,IAAI,YAC3B,KAAK,IAAI,IAAI,MAAM,IAAI,UAAU,MAAM,IAAI,aAAa,GAAI,IAC5D;AAEN,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA,EAEA,KAAK,OAAyB;AAC5B,WAAO,kBAAkB,OAAO,KAAK,OAAO;AAAA,EAC9C;AAAA,EAEQ,QAAQ,MAAuB;AACrC,WAAO,KAAK,cAAc,KAAK,CAAC,YAAY,QAAQ,KAAK,IAAI,CAAC;AAAA,EAChE;AACF;AAEA,SAAS,oBAAoB,OAAuB;AAClD,SAAO,QAAQ,IAAI,QAAQ,QAAQ,EAAE,IAAI,QAAQ,KAAK;AACxD;AAEA,SAAS,kBAAkB,MAAuB;AAChD,SAAO,qGAAqG;AAAA,IAC1G;AAAA,EACF;AACF;AAEA,SAAS,gBAAgB,MAAiD;AACxE,SACE,KAAK,YAAY,aAAa,QAC9B,KAAK,YAAY,YAAY,cAC7B,eAAe,KAAK,YAAY,gBAAgB,KAChD,eAAe,KAAK,YAAY,YAAY,KAC5C,KAAK,SAAS;AAElB;AAEA,SAAS,eAAe,OAAyB;AAC/C,SAAO,OAAO,UAAU,YAAY,QAAQ;AAC9C;;;ACvFO,IAAM,6BAAgE;AAAA,EAC3E,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,SAAS;AACX;AA2BO,IAAM,iCAAiC;AAE9C,IAAM,qBAAqB;AAC3B,IAAM,mBAAmB;AACzB,IAAM,uBAAuB;AAC7B,IAAM,kBAAkB;AACxB,IAAM,gBAAgB;AAEtB,IAAM,kBAAkB;AAAA,EACtB,MAAM;AAAA,EACN,sBAAsB;AAAA,EACtB,UAAU,CAAC,WAAW,UAAU;AAAA,EAChC,YAAY;AAAA,IACV,SAAS,EAAE,MAAM,UAAU,WAAW,IAAI,WAAW,IAAI;AAAA,IACzD,UAAU;AAAA,MACR,MAAM;AAAA,MACN,UAAU;AAAA,MACV,OAAO;AAAA,QACL,MAAM;AAAA,QACN,sBAAsB;AAAA,QACtB,UAAU,CAAC,WAAW,WAAW,SAAS,YAAY,UAAU;AAAA,QAChE,YAAY;AAAA,UACV,SAAS,EAAE,MAAM,UAAU,WAAW,GAAG,WAAW,IAAI;AAAA,UACxD,SAAS,EAAE,MAAM,UAAU;AAAA,UAC3B,OAAO,EAAE,MAAM,UAAU,SAAS,GAAG,SAAS,GAAG;AAAA,UACjD,UAAU,EAAE,MAAM,UAAU,WAAW,GAAG,WAAW,IAAI;AAAA,UACzD,UAAU,EAAE,MAAM,UAAU,MAAM,CAAC,YAAY,SAAS,SAAS,MAAM,EAAE;AAAA,QAC3E;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,SAAS,MAAc,KAAa,OAAuB;AAClE,MAAI,KAAK,UAAU,IAAK,QAAO;AAC/B,SAAO,GAAG,KAAK,MAAM,GAAG,GAAG,CAAC;AAAA,oBAAkB,KAAK,SAAS,GAAG,aAAa,KAAK;AACnF;AAEA,SAAS,YACP,OACA,MACQ;AACR,QAAM,aAAa,MAAM,YACtB,OAAO,CAAC,MAAM,EAAE,QAAQ,UAAU,KAAK,eAAe,EACtD,IAAI,CAAC,MAAM,aAAa,EAAE,IAAI;AAAA,EAAS,EAAE,OAAO,EAAE,EAClD,KAAK,MAAM;AAEd,QAAM,OAAO,MAAM,cAAc;AAEjC,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUP,MAAM,WAAW;AAAA;AAAA,EAEjB,MAAM,gBAAgB;AAAA,UAA+B,MAAM,aAAa;AAAA,iBAAoB,MAAM,uBAAuB,EAAE;AAAA;AAAA,IAAS,EAAE;AAAA,EACtI,MAAM,iBACL;AAAA,IACC,CAAC,GAAG,MACF,KAAK,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,EAAE,UAAU,SAAS,mBAAc,EAAE,SAAS,MAAM,GAAG,CAAC,EAAE,KAAK,KAAK,CAAC,MAAM,EAAE;AAAA,EAC3G,EACC,KAAK,IAAI,CAAC;AAAA;AAAA,EAEX,OAAO;AAAA,EAAqD,SAAS,MAAM,KAAK,cAAc,MAAM,CAAC;AAAA;AAAA,IAAS,EAAE;AAAA,EAChH,SAAS,YAAY,KAAK,gBAAgB,QAAQ,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBrD;AASA,eAAsB,wBACpB,OACA,UAAuC,CAAC,GACH;AACrC,QAAM,QAAQ,KAAK,IAAI;AACvB,QAAM,aAAa,MAAM,iBAAiB;AAE1C,MAAI,eAAe,GAAG;AACpB,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO;AAAA,MACP,cAAc;AAAA,MACd,YAAY;AAAA,MACZ,UAAU,CAAC;AAAA,MACX,SAAS;AAAA,MACT,YAAY;AAAA,MACZ,SAAS;AAAA,MACT,WAAW;AAAA,MACX,OAAO;AAAA,IACT;AAAA,EACF;AAEA,QAAM,OAA8C;AAAA,IAClD,OAAO,QAAQ,SAAS;AAAA,IACxB,WAAW,QAAQ,aAAa;AAAA,IAChC,gBAAgB,QAAQ,kBAAkB;AAAA,IAC1C,iBAAiB,QAAQ,mBAAmB;AAAA,IAC5C,cAAc,QAAQ,gBAAgB;AAAA,IACtC,KAAK,QAAQ,OAAO,CAAC;AAAA,IACrB,gBAAgB,QAAQ,kBAAkB;AAAA,IAC1C,mBAAmB,EAAE,GAAG,4BAA4B,GAAI,QAAQ,qBAAqB,CAAC,EAAG;AAAA,EAC3F;AAMA,QAAM,mBAAmB,CAAC,SAA8B;AACtD,QAAI,KAAK,mBAAmB,OAAQ,QAAO;AAC3C,QAAI,KAAK,UAAU,KAAM,QAAO,KAAK;AACrC,QAAI,KAAK,mBAAmB,cAAc;AACxC,aAAO,KAAK,kBAAkB,KAAK,cAAc,QAAQ,KAAK;AAAA,IAChE;AACA,WAAO;AAAA,EACT;AACA,QAAM,eAAe,IAAI;AAAA,IACvB,MAAM,iBAAiB,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,iBAAiB,CAAC,CAAC,CAAC;AAAA,EACjE;AAEA,MAAI;AACF,UAAM,EAAE,OAAO,OAAO,IAAI,MAAM;AAAA,MAI9B;AAAA,QACE,OAAO,KAAK;AAAA,QACZ,UAAU;AAAA,UACR;AAAA,YACE,MAAM;AAAA,YACN,SACE;AAAA,UACJ;AAAA,UACA,EAAE,MAAM,QAAQ,SAAS,YAAY,OAAO,IAAI,EAAE;AAAA,QACpD;AAAA,QACA,YAAY,EAAE,MAAM,0BAA0B,QAAQ,gBAAgB;AAAA,QACtE,aAAa;AAAA,QACb,WAAW,KAAK;AAAA,MAClB;AAAA,MACA,KAAK;AAAA,IACP;AAEA,QAAI,CAAC,OAAO,YAAY,CAAC,MAAM,QAAQ,MAAM,QAAQ,GAAG;AACtD,YAAM,IAAI,MAAM,0EAAqE;AAAA,IACvF;AAEA,UAAM,WAA6B,MAAM,SAAS,IAAI,CAAC,OAAO;AAAA,MAC5D,SAAS,OAAO,EAAE,OAAO;AAAA,MACzB,SAAS,QAAQ,EAAE,OAAO;AAAA,MAC1B,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC;AAAA,MACrD,UAAU,OAAO,EAAE,YAAY,EAAE;AAAA,MACjC,UAAW,CAAC,YAAY,SAAS,SAAS,MAAM,EAAY,SAAS,EAAE,QAAQ,IAC3E,EAAE,WACF;AAAA,IACN,EAAE;AAEF,UAAM,eAAe,SAAS,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE;AACvE,QAAI,YAAY;AAChB,QAAI,mBAAmB;AACvB,eAAW,KAAK,UAAU;AACxB,YAAM,IAAI,aAAa,IAAI,EAAE,OAAO,KAAK;AACzC,mBAAa;AACb,0BAAoB,IAAI,EAAE;AAAA,IAC5B;AACA,UAAM,WACJ,YAAY,IACR,mBAAmB,YACnB,SAAS,OAAO,CAAC,GAAG,MAAM,IAAI,EAAE,OAAO,CAAC,IAAI,KAAK,IAAI,GAAG,SAAS,MAAM;AAE7E,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO,QAAQ,WAAW,IAAI,QAAQ,CAAC,CAAC;AAAA,MACxC;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS,OAAO,MAAM,WAAW,EAAE;AAAA,MACnC,YAAY,KAAK,IAAI,IAAI;AAAA,MACzB,SAAS,OAAO,WAAW;AAAA,MAC3B,WAAW;AAAA,IACb;AAAA,EACF,SAAS,KAAK;AACZ,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO;AAAA,MACP,cAAc;AAAA,MACd;AAAA,MACA,UAAU,CAAC;AAAA,MACX,SAAS;AAAA,MACT,YAAY,KAAK,IAAI,IAAI;AAAA,MACzB,SAAS;AAAA,MACT,WAAW;AAAA,MACX,OAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAAA,IACxD;AAAA,EACF;AACF;AAMO,SAAS,2BACd,UAAuC,CAAC,GACmC;AAC3E,SAAO,CAAC,UAAU,wBAAwB,OAAO,OAAO;AAC1D;","names":["existsSync","existsSync","existsSync","readFileSync","existsSync","readFileSync","ANALYST_ID"]}