{"version":3,"sources":["../src/hooks/useEvalMode.ts","../src/hooks/useEvalShadow.ts","../src/hooks/useHostBridge.ts","../src/lib/appToolConfirmation.ts","../src/hooks/useRegisterAppTools.ts","../src/lib/appToolFailure.ts","../src/lib/appToolResult.ts","../src/lib/settingsDiff.ts","../src/lib/appCommand.ts","../src/lib/dataSummary.ts","../src/lib/appToolData.ts","../src/lib/createToolset.ts","../src/lib/pendingWriteOverlay.ts","../src/lib/resultBudget.ts","../src/utils/paramReaders.ts","../src/utils/strictParamReaders.ts"],"names":["useRef","useLayoutEffect","useEffect","useState","useCallback","sanitizeExtra","decoration","read"],"mappings":"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","file":"index.cjs","sourcesContent":["import { useEffect, useLayoutEffect, useRef } from 'react';\n\ntype UseEvalModeParams = {\n  getState: () => unknown;\n  applyOverrides: (overrides: Record<string, unknown>) => void;\n};\n\n/**\n * Exposes `window.__evalGetAppState` and `__evalSetAppState` for the grader when\n * `__askCorvaEvalMode` is set; a no-op in production. Helpers attach to the top\n * window (DC apps run in a same-origin iframe the harness polls), falling back\n * to the own window when the top is cross-origin.\n */\nexport function useEvalMode({ getState, applyOverrides }: UseEvalModeParams): void {\n  const applyRef = useRef(applyOverrides);\n  const getStateRef = useRef(getState);\n\n  useLayoutEffect(() => {\n    applyRef.current = applyOverrides;\n    getStateRef.current = getState;\n  });\n\n  useEffect(() => {\n    if (!window.__askCorvaEvalMode) return undefined;\n\n    let target: Window = window.top ?? window;\n\n    const attach = (): void => {\n      target.__evalGetAppState = () => getStateRef.current();\n      target.__evalSetAppState = async overrides => {\n        applyRef.current(overrides);\n      };\n    };\n\n    try {\n      attach();\n    } catch {\n      target = window;\n      attach();\n    }\n\n    return () => {\n      try {\n        delete target.__evalGetAppState;\n        delete target.__evalSetAppState;\n      } catch {\n        // cross-origin delete — nothing was attached there anyway\n      }\n    };\n  }, []);\n}\n","import { useCallback, useState } from 'react';\n\nimport type { AppToolSettingChangeFn } from '../types';\n\ntype UseEvalShadowParams = {\n  onSettingChange: AppToolSettingChangeFn;\n  /** Setting keys mirrored into the shadow in eval mode; MUST be reference-stable. */\n  shadowKeys: ReadonlySet<string>;\n};\n\ntype UseEvalShadowResult = {\n  evalShadow: Record<string, unknown>;\n  wrappedOnSettingChange: AppToolSettingChangeFn;\n};\n\n/**\n * Eval-mode shadow: a synchronous source of truth for setting keys, immune to\n * prop round-trip drift. In production `__askCorvaEvalMode` is unset and the\n * shadow stays empty.\n */\nexport function useEvalShadow({\n  onSettingChange,\n  shadowKeys,\n}: UseEvalShadowParams): UseEvalShadowResult {\n  const [evalShadow, setEvalShadow] = useState<Record<string, unknown>>({});\n\n  const wrappedOnSettingChange = useCallback<AppToolSettingChangeFn>(\n    (key, value) => {\n      onSettingChange(key, value);\n\n      if (window.__askCorvaEvalMode && shadowKeys.has(key)) {\n        setEvalShadow(prev => ({ ...prev, [key]: value }));\n      }\n    },\n    [onSettingChange, shadowKeys],\n  );\n\n  return { evalShadow, wrappedOnSettingChange };\n}\n","import { useCallback, useRef } from 'react';\n\n/**\n * Receiver side of the class-host bridge: the class hands over a typed object\n * (or null) via `onBridgeReady`; tools reach it through `getBridge`. Both\n * callbacks are reference-stable.\n */\nexport function useHostBridge<T>(): {\n  getBridge: () => T | null;\n  onBridgeReady: (bridge: T | null) => void;\n} {\n  const bridgeRef = useRef<T | null>(null);\n\n  const onBridgeReady = useCallback((bridge: T | null) => {\n    bridgeRef.current = bridge;\n  }, []);\n\n  const getBridge = useCallback(() => bridgeRef.current, []);\n\n  return { getBridge, onBridgeReady };\n}\n","import type {\n  AppTool,\n  AppToolCancelledResult,\n  AppToolConfirmFn,\n} from '../types';\n\n/** The user was asked and said no. */\nexport const CONFIRMATION_DECLINED_CODE = 'user_cancelled';\n\n/**\n * There was nobody to ask: the host registered app tools without a confirmation\n * adapter. Distinct from a decline because the operator can fix it, and the agent\n * should not tell the user they refused something they never saw.\n */\nexport const CONFIRMATION_UNAVAILABLE_CODE = 'confirmation_unavailable';\n\nexport type ConfirmationDecision = 'run' | 'declined' | 'unavailable';\n\ntype ResolveConfirmationParams = {\n  tool: AppTool;\n  params: Record<string, unknown>;\n  confirm: AppToolConfirmFn | null;\n  isEvalMode: boolean;\n};\n\n/**\n * True when a tool declares any intent to gate — deliberately either half, not\n * both. A half-declaration is a broken gate, and treating it as \"no gate\" is how\n * a tool whose author asked for confirmation writes without one.\n */\nexport function isConfirmationGated(tool: AppTool): boolean {\n  return Boolean(tool.confirmationPolicy || tool.confirmation);\n}\n\n/**\n * Decides whether a gated call may reach its handler.\n *\n * The one outcome this must never produce is `run` because no host adapter was\n * present. A destructive write that proceeds for want of anyone to ask is exactly\n * the failure the gate exists to prevent, so an unavailable host declines.\n */\nexport async function resolveConfirmation({\n  tool,\n  params,\n  confirm,\n  isEvalMode,\n}: ResolveConfirmationParams): Promise<ConfirmationDecision> {\n  const { confirmationPolicy, confirmation } = tool;\n\n  if (!confirmationPolicy && !confirmation) return 'run';\n\n  // A half-declaration cannot be honoured and must not be waved through — not\n  // even in eval mode, where a silent 'run' would let the harness prove a gate\n  // that production does not have. `checkToolConformance` catches this at test\n  // time; this is the runtime net for the tool that never met it.\n  if (!confirmationPolicy || !confirmation) return 'unavailable';\n\n  // The harness drives thousands of calls with no operator behind them; a gate\n  // that blocked there would stall every scenario instead of proving anything.\n  if (isEvalMode) return 'run';\n\n  // A predicate or a modal that throws (an unmounted host, a bad param read) must\n  // not surface as a raw transport error — the envelope exists so the agent can\n  // explain the outcome. Failing closed keeps the guarantee either way.\n  try {\n    const isRequested =\n      confirmationPolicy === 'REQUIRED' || confirmation.shouldRequest(params);\n\n    if (!isRequested) return 'run';\n\n    if (!confirm) return 'unavailable';\n\n    const isConfirmed = await confirm(confirmation.getRequest(params));\n\n    return isConfirmed ? 'run' : 'declined';\n  } catch {\n    return 'unavailable';\n  }\n}\n\ntype CancelledParams = {\n  toolName: string;\n  decision: Exclude<ConfirmationDecision, 'run'>;\n};\n\n/**\n * Reports a call that never ran. `nextAction` is `NONE` in both cases: a decline\n * is not an invitation to retry, and a missing adapter will not appear because the\n * agent asked again.\n */\nexport function appToolCancelled({\n  toolName,\n  decision,\n}: CancelledParams): AppToolCancelledResult {\n  const isDeclined = decision === 'declined';\n\n  return {\n    success: true,\n    outcome: 'CANCELLED',\n    executed: false,\n    toolName,\n    code: isDeclined ? CONFIRMATION_DECLINED_CODE : CONFIRMATION_UNAVAILABLE_CODE,\n    message: isDeclined\n      ? 'The user declined this action, so nothing was changed.'\n      : 'This action needs confirmation and this host cannot request it, so nothing was changed.',\n    nextAction: { type: 'NONE' },\n  };\n}\n","import { useEffect, useLayoutEffect, useRef } from 'react';\n\nimport {\n  appToolCancelled,\n  isConfirmationGated,\n  resolveConfirmation,\n} from '../lib/appToolConfirmation';\nimport type {\n  AppTool,\n  AppToolConfirmFn,\n  AppToolRegisterFn,\n  AppToolResult,\n} from '../types';\n\nexport type RegisterAppToolsOptions = {\n  /**\n   * How this host asks the user. A host that cannot ask passes nothing, and a\n   * gated call then declines rather than proceeding unconfirmed.\n   */\n  confirm?: AppToolConfirmFn | null;\n};\n\n/**\n * Registers app tools through the host callback. The registry receives proxies\n * that read the latest tools per render, so re-registration happens only when\n * the roster (names/order) changes; cleanup re-registers an empty list.\n */\nexport function useRegisterAppTools(\n  registerAppTools: AppToolRegisterFn | null,\n  tools: AppTool[],\n  options: RegisterAppToolsOptions = {},\n): void {\n  const confirm = options.confirm ?? null;\n  const confirmRef = useRef<AppToolConfirmFn | null>(confirm);\n  const latestToolsRef = useRef<AppTool[]>(tools);\n\n  useLayoutEffect(() => {\n    latestToolsRef.current = tools;\n    confirmRef.current = confirm;\n  });\n\n  const rosterKey = tools.map(tool => tool.name).join('|');\n\n  useEffect(() => {\n    if (!registerAppTools) return undefined;\n\n    const proxies: AppTool[] = latestToolsRef.current.map(registered => {\n      const { name } = registered;\n      const readLatest = (): AppTool =>\n        latestToolsRef.current.find(tool => tool.name === name) ?? registered;\n\n      const runHandler = async (\n        params: Record<string, unknown>,\n      ): Promise<AppToolResult> => {\n        const current = readLatest();\n\n        if (!isConfirmationGated(current)) return current.handler(params);\n\n        const decision = await resolveConfirmation({\n          tool: current,\n          params,\n          confirm: confirmRef.current,\n          isEvalMode: Boolean(window.__askCorvaEvalMode),\n        });\n\n        if (decision !== 'run') {\n          return appToolCancelled({ toolName: current.name, decision });\n        }\n\n        return current.handler(params);\n      };\n\n      return {\n        ...registered,\n        getSchema: () => {\n          const current = readLatest();\n\n          return current.getSchema\n            ? current.getSchema()\n            : { description: current.description, parameters: current.parameters };\n        },\n        handler: runHandler,\n      };\n    });\n\n    registerAppTools(proxies);\n\n    return () => {\n      registerAppTools([]);\n    };\n  }, [registerAppTools, rosterKey]);\n}\n","import type {\n  AppToolFailurePayload,\n  AppToolFailureResult,\n  AppToolResult,\n  AppToolResultExtra,\n  NextAction,\n} from '../types';\n\n// Written only by this builder — never smuggled in through `extra`.\nconst RESERVED_FAILURE_KEYS = new Set([\n  'success',\n  'error',\n  'outcome',\n  'message',\n  'toolName',\n  'code',\n  'nextAction',\n  'params',\n]);\n\n/**\n * Bounds an advertised wait. `delayMs: number` cannot express \"positive and sane\"\n * in the type, and both ends are harmful: a zero or negative delay reads as\n * \"call again immediately\", and an hour-long one strands the user while a page\n * fetch finishes.\n */\nexport const MIN_WAIT_DELAY_MS = 500;\nexport const MAX_WAIT_DELAY_MS = 60_000;\n\nexport function boundWaitDelay(nextAction: NextAction): NextAction {\n  if (nextAction.type !== 'WAIT') return nextAction;\n\n  const { delayMs } = nextAction;\n\n  if (!Number.isFinite(delayMs)) {\n    throw new RangeError('WAIT delayMs must be a finite number');\n  }\n\n  return {\n    type: 'WAIT',\n    delayMs: Math.min(\n      Math.max(Math.round(delayMs), MIN_WAIT_DELAY_MS),\n      MAX_WAIT_DELAY_MS,\n    ),\n  };\n}\n\nfunction sanitizeExtra(\n  extra: AppToolResultExtra | undefined,\n): AppToolResultExtra {\n  if (!extra) return {};\n\n  return Object.fromEntries(\n    Object.entries(extra).filter(([key]) => !RESERVED_FAILURE_KEYS.has(key)),\n  );\n}\n\n/**\n * A refusal the agent can act on rather than merely report.\n *\n * The request was understood and the app declined — a call that never executed\n * (a throw, a vanished iframe, a timeout) belongs to the transport's error\n * channel instead. `outcome` says which kind of refusal it is, `code` names the\n * specific one for evals and branching, `nextAction` names the only move that can\n * change the answer, and `message` is the half the agent quotes.\n */\nexport function appToolFailure(\n  message: string,\n  payload: AppToolFailurePayload,\n): AppToolFailureResult {\n  const { toolName, outcome, code, nextAction, params, extra } = payload;\n\n  return {\n    ...sanitizeExtra(extra),\n    success: false,\n    outcome,\n    toolName,\n    // `error` keeps the pre-contract runtime and the eval graders working.\n    error: message,\n    message,\n    code,\n    nextAction: boundWaitDelay(nextAction),\n    ...(params && { params }),\n  };\n}\n\n/**\n * A command whose writer was never wired up.\n *\n * Hosts pass setters optionally (`onSettingChange?.(key, value)`), so a tool can\n * be registered, do nothing, and report success — the worst outcome available,\n * because the agent tells the user a setting changed. This is a real dependency\n * failure and no argument can fix it.\n */\nexport function writerUnavailable({\n  toolName,\n  code,\n  writer,\n}: {\n  toolName: string;\n  code: string;\n  writer: string;\n}): AppToolResult {\n  return appToolFailure(\n    `This app instance cannot apply the change: its ${writer} callback is not wired up.`,\n    {\n      toolName,\n      code,\n      outcome: 'DEPENDENCY',\n      nextAction: { type: 'NONE' },\n      params: { writer },\n    },\n  );\n}\n","import type {\n  AppToolErrorPayload,\n  AppToolLegacyErrorResult,\n  AppToolReadyResult,\n  AppToolResultExtra,\n  AppToolSuccessPayload,\n} from '../types';\n\n// Reserved envelope keys are written only by the builders — never smuggled via `extra`.\nconst RESERVED_ENVELOPE_KEYS = new Set([\n  'success',\n  'error',\n  'outcome',\n  'message',\n  'toolName',\n  'changed',\n  'resultingState',\n]);\n\nfunction sanitizeExtra(extra: AppToolResultExtra | undefined): AppToolResultExtra {\n  if (!extra) return {};\n\n  return Object.fromEntries(\n    Object.entries(extra).filter(([key]) => !RESERVED_ENVELOPE_KEYS.has(key)),\n  );\n}\n\n/**\n * A command that did what it was asked.\n *\n * `changed` must be the real diff: echoing a value the app already held tells the\n * agent it moved something it did not, and the agent repeats that to the user.\n * `message` is where a no-op says so.\n */\nexport function appToolSuccess(payload: AppToolSuccessPayload = {}): AppToolReadyResult {\n  const { changed, resultingState, message, extra } = payload;\n\n  return {\n    ...sanitizeExtra(extra),\n    success: true,\n    outcome: 'READY',\n    ...(message && { message }),\n    ...(changed && { changed }),\n    ...('resultingState' in payload && { resultingState }),\n  };\n}\n\n/**\n * The v1 refusal: a sentence and nothing else. Kept for the apps that predate the\n * contract; the conformance suite flags it, because an agent cannot branch on it.\n */\nexport function appToolError(\n  error: string,\n  payload: AppToolErrorPayload = {},\n): AppToolLegacyErrorResult {\n  return {\n    ...sanitizeExtra(payload.extra),\n    success: false,\n    error,\n  };\n}\n","/**\n * What a command actually changed, against what the app already held.\n *\n * `changed: { severeDataDelay: 60 }` when the setting was already 60 tells the\n * agent it moved something it did not, and the agent then reports that to the\n * user. A command's `changed` is a diff or it is fiction.\n */\nexport type ValueEquality = (left: unknown, right: unknown) => boolean;\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;\n  const prototype = Object.getPrototypeOf(value);\n  return prototype === Object.prototype || prototype === null;\n}\n\n/** Value equality for JSON-shaped settings, independent of object identity. */\nexport function jsonValueEqual(left: unknown, right: unknown): boolean {\n  if (Object.is(left, right)) return true;\n\n  if (Array.isArray(left) || Array.isArray(right)) {\n    return Array.isArray(left) && Array.isArray(right) &&\n      left.length === right.length &&\n      left.every((value, index) => jsonValueEqual(value, right[index]));\n  }\n\n  if (!isPlainRecord(left) || !isPlainRecord(right)) return false;\n\n  const leftKeys = Object.keys(left);\n  const rightKeys = Object.keys(right);\n\n  return leftKeys.length === rightKeys.length &&\n    leftKeys.every(key =>\n      Object.prototype.hasOwnProperty.call(right, key) &&\n      jsonValueEqual(left[key], right[key]),\n    );\n}\n\nexport function diffSettings<Current extends object>({\n  requested,\n  current,\n  equals = Object.is,\n}: {\n  requested: Record<string, unknown>;\n  current: Current;\n  equals?: ValueEquality;\n}): { changed: Record<string, unknown>; isNoOp: boolean } {\n  const changed = Object.fromEntries(\n    Object.entries(requested).filter(([key, value]) =>\n      !equals(Reflect.get(current, key), value),\n    ),\n  );\n\n  return { changed, isNoOp: !Object.keys(changed).length };\n}\n\n/** The message a no-op command returns, so \"nothing happened\" is stated once. */\nexport const NO_OP_MESSAGE = 'The app already had the requested values; nothing changed.';\n","import type {\n  AppToolFailureResult,\n  AppToolResult,\n  AppToolSuccessPayload,\n} from '../types';\n\nimport { appToolFailure } from './appToolFailure';\nimport { appToolSuccess } from './appToolResult';\nimport {\n  diffSettings,\n  jsonValueEqual,\n  NO_OP_MESSAGE,\n  type ValueEquality,\n} from './settingsDiff';\n\nexport type AppCommandPatch<State extends object> = {\n  [Key in Extract<keyof State, string>]?: State[Key];\n};\n\ntype RequireStringStateKey<State extends object> =\n  [Extract<keyof State, string>] extends [never]\n    ? { readonly __appCommandRequiresStringKey: never }\n    : object;\n\nexport type AppCommandAccepted<State extends object, Meta = undefined> = {\n  ok: true;\n  /** Complete desired values for every key this command owns. */\n  requested: AppCommandPatch<State>;\n  /** App-specific, already-validated information passed only to the writer. */\n  meta?: Meta;\n};\n\nexport type AppCommandRejected = {\n  ok: false;\n  result: AppToolFailureResult;\n};\n\nexport type AppCommandPreparation<\n  State extends object,\n  Meta = undefined,\n> = AppCommandAccepted<State, Meta> | AppCommandRejected;\n\nexport type AppCommandWriteContext<\n  State extends object,\n  Meta = undefined,\n  ScopeToken = unknown,\n> = {\n  /** Scope/version that was validated and must be used by the writer. */\n  scopeToken: ScopeToken;\n  /** Effective rendered state used for validation. */\n  before: State;\n  /** Host-confirmed state used for changed/no-op truth. */\n  confirmedBefore: State;\n  requested: AppCommandPatch<State>;\n  changed: Record<string, unknown>;\n  meta: Meta | undefined;\n};\n\nexport type AppCommandUnconfirmedContext<\n  State extends object,\n  Meta = undefined,\n  ScopeToken = unknown,\n> = AppCommandWriteContext<State, Meta, ScopeToken> & {\n  after: State;\n  unconfirmedKeys: string[];\n};\n\nexport type AppCommandSuccessContext<\n  State extends object,\n  Meta = undefined,\n  ScopeToken = unknown,\n> = AppCommandWriteContext<State, Meta, ScopeToken> & {\n  after: State;\n  actualChanged: Record<string, unknown>;\n};\n\nexport type RunAppCommandOptions<\n  State extends object,\n  Meta = undefined,\n  ResultingState = State,\n  ScopeToken = unknown,\n> = {\n  toolName: string;\n  /** Stable scope/version token; re-read immediately before write to close races. */\n  readScopeToken: () => ScopeToken | Promise<ScopeToken>;\n  /** Reads the effective rendered state. Pending writes belong in this source. */\n  readState: (scopeToken: ScopeToken) => State | Promise<State>;\n  /** Host props without pending/eval overlays; defaults to `readState`. */\n  readConfirmedState?: (scopeToken: ScopeToken) => State | Promise<State>;\n  /** Strict parsing and all cross-field validation happen here, before `write`. */\n  prepare: (\n    current: State,\n  ) => AppCommandPreparation<State, Meta> | Promise<AppCommandPreparation<State, Meta>>;\n  /** Receives only a completely validated plan. */\n  write: (context: AppCommandWriteContext<State, Meta, ScopeToken>) => void | Promise<void>;\n  /**\n   * App-owned post-write view. For an asynchronous host this may include pending\n   * intent; eventual host acceptance must still be proved by an echo test/live probe.\n   */\n  readBack?: (scopeToken: ScopeToken) => State | Promise<State>;\n  equals?: ValueEquality;\n  scopeEquals?: (left: ScopeToken, right: ScopeToken) => boolean;\n  selectResultingState?: (state: State) => ResultingState;\n  noOpMessage?: string;\n  decorateNoOp?: (\n    current: State,\n  ) => Pick<AppToolSuccessPayload, 'message' | 'extra'>;\n  decorateSuccess?: (\n    context: AppCommandSuccessContext<State, Meta, ScopeToken>,\n  ) => Pick<AppToolSuccessPayload, 'message' | 'extra'>;\n  onUnconfirmed?: (\n    context: AppCommandUnconfirmedContext<State, Meta, ScopeToken>,\n  ) => AppToolFailureResult;\n} & RequireStringStateKey<State>;\n\nfunction stateValue(state: object, key: string): unknown {\n  return Reflect.get(state, key);\n}\n\nfunction pickKeys<State extends object>(\n  state: State,\n  keys: Record<string, unknown>,\n): Record<string, unknown> {\n  return Object.fromEntries(\n    Object.keys(keys).map(key => [key, stateValue(state, key)]),\n  );\n}\n\n/**\n * One safe command transaction: plan everything, diff, write once, then prove the\n * state that actually became visible. Domain parsing and ownership stay in the app.\n */\nexport async function runAppCommand<\n  State extends object,\n  Meta = undefined,\n  ResultingState = State,\n  ScopeToken = unknown,\n>({\n  toolName,\n  readScopeToken,\n  readState,\n  readConfirmedState = readState,\n  prepare,\n  write,\n  readBack = readState,\n  equals = jsonValueEqual,\n  scopeEquals = Object.is,\n  selectResultingState,\n  noOpMessage = NO_OP_MESSAGE,\n  decorateNoOp,\n  decorateSuccess,\n  onUnconfirmed,\n}: RunAppCommandOptions<State, Meta, ResultingState, ScopeToken>): Promise<AppToolResult> {\n  const selectResult = (state: State): unknown =>\n    selectResultingState ? selectResultingState(state) : state;\n  const scopeBefore = await readScopeToken();\n  const before = await readState(scopeBefore);\n  const confirmedBefore = await readConfirmedState(scopeBefore);\n  const prepared = await prepare(before);\n  const scopeBeforeWrite = await readScopeToken();\n  if (!scopeEquals(scopeBefore, scopeBeforeWrite)) {\n    return appToolFailure(\n      'The app scope changed while the command was being prepared.',\n      {\n        toolName,\n        code: `${toolName}.scope_changed`,\n        outcome: 'CONFLICT',\n        nextAction: { type: 'REFRESH_STATE' },\n      },\n    );\n  }\n\n  if (!prepared.ok) return prepared.result;\n\n  const confirmedDiff = diffSettings({\n    requested: prepared.requested,\n    current: confirmedBefore,\n    equals,\n  });\n  const effectiveDiff = diffSettings({\n    requested: prepared.requested,\n    current: before,\n    equals,\n  });\n  const changed = { ...confirmedDiff.changed, ...effectiveDiff.changed };\n  const isNoOp = !Object.keys(changed).length;\n\n  if (isNoOp) {\n    const decoration = decorateNoOp?.(before);\n    return appToolSuccess({\n      changed: {},\n      resultingState: selectResult(before),\n      message: decoration?.message ?? noOpMessage,\n      extra: decoration?.extra,\n    });\n  }\n\n  const writeContext: AppCommandWriteContext<State, Meta, ScopeToken> = {\n    scopeToken: scopeBefore,\n    before,\n    confirmedBefore,\n    requested: prepared.requested,\n    changed,\n    meta: prepared.meta,\n  };\n\n  await write(writeContext);\n  const scopeAfterWrite = await readScopeToken();\n  if (!scopeEquals(scopeBefore, scopeAfterWrite)) {\n    return appToolFailure(\n      'The app scope changed while the command was being applied.',\n      {\n        toolName,\n        code: `${toolName}.scope_changed`,\n        outcome: 'CONFLICT',\n        nextAction: { type: 'REFRESH_STATE' },\n      },\n    );\n  }\n\n  const after = await readBack(scopeBefore);\n  const scopeAfterReadBack = await readScopeToken();\n  if (!scopeEquals(scopeBefore, scopeAfterReadBack)) {\n    return appToolFailure(\n      'The app scope changed while the command result was being confirmed.',\n      {\n        toolName,\n        code: `${toolName}.scope_changed`,\n        outcome: 'CONFLICT',\n        nextAction: { type: 'REFRESH_STATE' },\n      },\n    );\n  }\n  const unconfirmedKeys = Object.entries(changed)\n    .filter(([key, value]) => !equals(stateValue(after, key), value))\n    .map(([key]) => key);\n\n  if (unconfirmedKeys.length) {\n    const context = { ...writeContext, after, unconfirmedKeys };\n    if (onUnconfirmed) return onUnconfirmed(context);\n\n    return appToolFailure(\n      'The app did not confirm every requested change.',\n      {\n        toolName,\n        code: `${toolName}.write_not_confirmed`,\n        outcome: 'CONFLICT',\n        nextAction: { type: 'REFRESH_STATE' },\n        params: { fields: unconfirmedKeys },\n      },\n    );\n  }\n\n  const actualChanged = pickKeys(after, changed);\n  const decoration = decorateSuccess?.({\n    ...writeContext,\n    after,\n    actualChanged,\n  });\n\n  return appToolSuccess({\n    changed: actualChanged,\n    resultingState: selectResult(after),\n    message: decoration?.message,\n    extra: decoration?.extra,\n  });\n}\n","import type {\n  DataCoverage,\n  FieldSummary,\n  GoalSummary,\n  GroupSummary,\n  NumericSummary,\n  RatioSummary,\n  SampleRows,\n  WeightedSummary,\n} from '../types';\n\n/**\n * Default ceiling on rows returned to the agent. A data digest exists so the\n * agent does not have to page through raw rows; handing it thousands of them\n * blows the turn's context for no gain.\n */\nexport const DEFAULT_ROW_LIMIT = 200;\n\n// Serialized decimals only. `Number()` also accepts JavaScript literal syntax, so\n// a stray '0x10' would silently become 16 and '0b10' would become 2 — a data value\n// that looks like nothing of the sort must stay non-numeric.\nconst JSON_NUMBER = /^-?(0|[1-9]\\d*)(\\.\\d+)?([eE][+-]?\\d+)?$/;\n\nfunction toFiniteNumber(value: unknown): number | null {\n  if (typeof value === 'number') return Number.isFinite(value) ? value : null;\n\n  // Numeric strings are routine in Corva payloads (unix timestamps, metric\n  // values serialized by the API), and dropping them would understate `count`.\n  if (typeof value === 'string') {\n    const trimmed = value.trim();\n\n    if (!JSON_NUMBER.test(trimmed)) return null;\n\n    const parsed = Number(trimmed);\n\n    return Number.isFinite(parsed) ? parsed : null;\n  }\n\n  return null;\n}\n\n/**\n * Aggregate raw values into one honest summary. `count` is how many values were\n * actually numeric — the agent needs it to say \"averaged over N\", and a blank\n * or non-numeric cell must not be counted as a zero.\n */\nexport function summarizeNumbers(values: readonly unknown[]): NumericSummary {\n  const numbers = values\n    .map(toFiniteNumber)\n    .filter((value): value is number => value !== null);\n\n  if (!numbers.length) {\n    return { count: 0, average: null, min: null, max: null, sum: 0 };\n  }\n\n  const sum = numbers.reduce((total, value) => total + value, 0);\n\n  return {\n    count: numbers.length,\n    average: sum / numbers.length,\n    min: Math.min(...numbers),\n    max: Math.max(...numbers),\n    sum,\n  };\n}\n\n/**\n * Weighted summary for a per-entity average — a column already holding \"average\n * connection time for this well\" cannot be averaged again across wells: wells\n * with 12 connections and 200 connections would count the same. Weighting by\n * the event count gives the figure a user computing by hand would get\n * (combined time ÷ combined event count).\n *\n * `weightedAverage` is null when no row carries both a value and a weight, so a\n * caller must fall back to `average` and say which basis it used.\n */\nexport function summarizeWeighted({\n  values,\n  weights,\n}: {\n  values: readonly unknown[];\n  weights: readonly unknown[];\n}): WeightedSummary {\n  const unweighted = summarizeNumbers(values);\n\n  const pairs = values\n    .map((value, index) => ({\n      value: toFiniteNumber(value),\n      weight: toFiniteNumber(weights[index]),\n    }))\n    .filter(\n      (pair): pair is { value: number; weight: number } =>\n        pair.value !== null && pair.weight !== null && pair.weight > 0,\n    );\n\n  // Values present but unweighable — reported, never absorbed into the figure.\n  const missingWeightCount = unweighted.count - pairs.length;\n\n  if (!pairs.length) {\n    return {\n      ...unweighted,\n      weightedAverage: null,\n      weightTotal: 0,\n      weightedCount: 0,\n      missingWeightCount,\n    };\n  }\n\n  const weightTotal = pairs.reduce((total, pair) => total + pair.weight, 0);\n  const weightedSum = pairs.reduce(\n    (total, pair) => total + pair.value * pair.weight,\n    0,\n  );\n\n  return {\n    ...unweighted,\n    weightedAverage: weightedSum / weightTotal,\n    weightTotal,\n    weightedCount: pairs.length,\n    missingWeightCount,\n  };\n}\n\n/**\n * The exact cross-entity average from a total and a count column:\n * sum(total) / sum(count). Prefer this over weighting per-entity averages —\n * `tripping_connection_time` / `tripping_connection_count` beats re-weighting\n * `tripping_connection_average`, because the means were already rounded and a\n * missing weight would drop the entity entirely.\n */\nexport function summarizeRatio({\n  rows,\n  numeratorField,\n  denominatorField,\n}: {\n  rows: readonly Record<string, unknown>[];\n  numeratorField: string;\n  denominatorField: string;\n}): RatioSummary {\n  const pairs = rows.map((row) => ({\n    numerator: toFiniteNumber(row[numeratorField]),\n    denominator: toFiniteNumber(row[denominatorField]),\n  }));\n\n  const isUsable = (pair: {\n    numerator: number | null;\n    denominator: number | null;\n  }): pair is { numerator: number; denominator: number } =>\n    pair.numerator !== null &&\n    pair.denominator !== null &&\n    pair.denominator > 0;\n\n  const usable = pairs.filter(isUsable);\n\n  // A row carrying one half of the ratio cannot contribute, and that is a gap in\n  // the figure rather than a row that never existed.\n  const missingPartCount = pairs.filter(\n    (pair) =>\n      !isUsable(pair) && (pair.numerator !== null || pair.denominator !== null),\n  ).length;\n\n  const numeratorTotal = usable.reduce(\n    (total, pair) => total + pair.numerator,\n    0,\n  );\n  const denominatorTotal = usable.reduce(\n    (total, pair) => total + pair.denominator,\n    0,\n  );\n\n  return {\n    ratio: denominatorTotal > 0 ? numeratorTotal / denominatorTotal : null,\n    numeratorTotal,\n    denominatorTotal,\n    contributingRowCount: usable.length,\n    missingPartCount,\n  };\n}\n\n/**\n * Per-field summaries over the rows the app currently has loaded.\n *\n * `weightOf` is the app's say in how a field must be aggregated: it names the\n * field carrying that field's weights (an event count, an interval length, a\n * stage count) or null for a plain mean. Only the app knows which of its metrics\n * are per-entity averages, while deciding what that means for the resulting\n * figure — and stating the basis it used — is the same everywhere, so it lives\n * here instead of being re-derived in every app.\n */\nexport function summarizeField({\n  rows,\n  field,\n  weightField,\n  ratioFields,\n}: {\n  rows: readonly Record<string, unknown>[];\n  field: string;\n  weightField?: string | null;\n  ratioFields?: { numerator: string; denominator: string } | null;\n}): FieldSummary {\n  const values = rows.map((row) => row[field]);\n  const base = summarizeNumbers(values);\n\n  if (ratioFields) {\n    const ratio = summarizeRatio({\n      rows,\n      numeratorField: ratioFields.numerator,\n      denominatorField: ratioFields.denominator,\n    });\n\n    if (ratio.ratio !== null) {\n      return {\n        ...base,\n        ...ratio,\n        ratio: ratio.ratio,\n        averageBasis: 'ratio',\n        numeratorField: ratioFields.numerator,\n        denominatorField: ratioFields.denominator,\n        isRatioComplete: ratio.missingPartCount === 0,\n      };\n    }\n  }\n\n  if (weightField) {\n    const weighted = summarizeWeighted({\n      values,\n      weights: rows.map((row) => row[weightField]),\n    });\n\n    if (weighted.weightedAverage !== null) {\n      return {\n        ...weighted,\n        weightedAverage: weighted.weightedAverage,\n        averageBasis: 'weights',\n        weightField,\n        isWeightComplete: weighted.missingWeightCount === 0,\n      };\n    }\n  }\n\n  // Neither exact path was available: an honest per-row mean, and it is the\n  // caller's job to say so when the field is a mean of means.\n  return { ...base, averageBasis: 'rows' };\n}\n\n/**\n * Per-field summaries over the rows the app currently has loaded.\n *\n * `ratioOf` and `weightOf` are the app's say in how a field must be aggregated,\n * in that order of preference: a total/count pair is exact, weighting a\n * per-entity average is a good approximation, and a plain mean is neither.\n * Only the app knows which of its metrics are per-entity averages, while what\n * that means for the resulting figure — and stating the basis it used — is the\n * same everywhere, so it lives here instead of in every app.\n */\nexport function summarizeFields({\n  rows,\n  fields,\n  weightOf,\n  weightBy,\n  ratioOf,\n}: {\n  rows: readonly Record<string, unknown>[];\n  fields: readonly string[];\n  weightOf?: (field: string) => string | null;\n  /** Simple form of `weightOf` for callers with a static mapping. */\n  weightBy?: Record<string, string>;\n  ratioOf?: (\n    field: string,\n  ) => { numerator: string; denominator: string } | null;\n}): Record<string, FieldSummary> {\n  return Object.fromEntries(\n    fields.map((field) => [\n      field,\n      summarizeField({\n        rows,\n        field,\n        weightField: weightOf?.(field) ?? weightBy?.[field] ?? null,\n        ratioFields: ratioOf?.(field) ?? null,\n      }),\n    ]),\n  );\n}\n\n/**\n * How much of what was asked the digest actually covers.\n *\n * `isComplete` is derived, never declared: it is the one field that separates\n * \"the average of everything shown\" from \"the average of page one\", and the\n * envelope reads it to decide READY against PARTIAL — so an app cannot claim\n * completeness over a set it only partly analysed. A named omission is itself\n * incompleteness, even when the counts happen to line up.\n */\nexport function buildCoverage({\n  requestedEntities,\n  analysedEntities,\n  requestedRows,\n  analysedRows,\n  omissions,\n}: {\n  requestedEntities: number;\n  analysedEntities: number;\n  requestedRows?: number;\n  analysedRows: number;\n  omissions?: readonly string[];\n}): DataCoverage {\n  const isValidCount = (value: number): boolean => Number.isInteger(value) && value >= 0;\n  const isRowsComplete = requestedRows === undefined || analysedRows === requestedRows;\n  const areEntityCountsValid =\n    isValidCount(requestedEntities) &&\n    isValidCount(analysedEntities) &&\n    analysedEntities <= requestedEntities;\n  const areRowCountsValid =\n    isValidCount(analysedRows) && (requestedRows === undefined ||\n      (isValidCount(requestedRows) && analysedRows <= requestedRows));\n\n  if (!areEntityCountsValid || !areRowCountsValid) {\n    throw new RangeError(\n      'coverage counts must be non-negative integers and analysed counts cannot exceed requested counts',\n    );\n  }\n\n  return {\n    requestedEntities,\n    analysedEntities,\n    ...(requestedRows !== undefined && { requestedRows }),\n    analysedRows,\n    isComplete:\n      analysedEntities === requestedEntities &&\n      isRowsComplete &&\n      !omissions?.length,\n    ...(omissions?.length && { omissions: [...omissions] }),\n  };\n}\n\n/**\n * Example rows, in their own block with their own counts.\n *\n * `totalAnalysed` is what the aggregates were computed over, `returned` is what\n * fitted in the turn, and `truncated` states the gap. Kept apart from the\n * aggregates because a capped list sitting beside them gets quoted as the\n * dataset — \"these are the wells\" about page one of forty.\n */\nexport function buildSampleRows<Row>({\n  rows,\n  totalAnalysed,\n  limit = DEFAULT_ROW_LIMIT,\n}: {\n  rows: readonly Row[];\n  totalAnalysed: number;\n  limit?: number;\n}): SampleRows<Row> {\n  if (!Number.isInteger(totalAnalysed) || totalAnalysed < 0) {\n    throw new RangeError('totalAnalysed must be a non-negative integer');\n  }\n\n  if (rows.length > totalAnalysed) {\n    throw new RangeError('sample rows cannot exceed totalAnalysed');\n  }\n\n  if (!Number.isFinite(limit)) {\n    throw new RangeError('sample limit must be finite');\n  }\n\n  const safeLimit = Math.max(0, Math.floor(limit));\n  const items = rows.slice(0, safeLimit);\n\n  return {\n    items,\n    returned: items.length,\n    totalAnalysed,\n    truncated: items.length < totalAnalysed,\n  };\n}\n\n/**\n * Same summaries, computed per group — \"average per well\", \"total hours per\n * operation\", \"ROP per hole section\". Grouping lives here because an agent\n * re-deriving it from returned rows can only see the rows that survived the row\n * cap, which silently turns a per-group figure into a partial one.\n *\n * Rows whose group field is empty are reported as `ungroupedRowCount` rather than\n * bucketed under a made-up key.\n */\nexport function summarizeGroups({\n  rows,\n  fields,\n  groupBy,\n  weightOf,\n  weightBy,\n  ratioOf,\n}: {\n  rows: readonly Record<string, unknown>[];\n  fields: readonly string[];\n  groupBy: string;\n  weightOf?: (field: string) => string | null;\n  weightBy?: Record<string, string>;\n  ratioOf?: (\n    field: string,\n  ) => { numerator: string; denominator: string } | null;\n}): { groups: GroupSummary[]; ungroupedRowCount: number } {\n  // Insertion-ordered, so groups come back in the order the data presented them\n  // instead of an alphabetical order nobody asked for.\n  const buckets = new Map<string, Record<string, unknown>[]>();\n  let ungroupedRowCount = 0;\n\n  rows.forEach((row) => {\n    const rawKey = row[groupBy];\n    const isGroupable =\n      typeof rawKey === 'string'\n        ? rawKey !== ''\n        : typeof rawKey === 'number' || typeof rawKey === 'boolean';\n\n    // An object would stringify to `[object Object]` and collapse unrelated rows\n    // into one bucket that reads like a real group.\n    if (!isGroupable) {\n      ungroupedRowCount += 1;\n\n      return;\n    }\n\n    const key = String(rawKey);\n    const bucket = buckets.get(key);\n\n    if (bucket) {\n      bucket.push(row);\n\n      return;\n    }\n\n    buckets.set(key, [row]);\n  });\n\n  const groups = [...buckets].map(([key, groupRows]) => ({\n    key,\n    rowCount: groupRows.length,\n    metrics: summarizeFields({\n      rows: groupRows,\n      fields,\n      weightOf,\n      weightBy,\n      ratioOf,\n    }),\n  }));\n\n  return { groups, ungroupedRowCount };\n}\n\n/**\n * A figure against the target the app displays for it. `direction` decides what\n * \"met\" means: a connection time of 4.2 beats a goal of 5, an ROP of 4.2 does\n * not, and the sign of the delta alone cannot tell them apart.\n */\nexport function summarizeGoal({\n  metric,\n  target,\n  actual,\n  direction,\n  source,\n}: {\n  metric: string;\n  target: number | null;\n  actual: number | null;\n  direction: GoalSummary['direction'];\n  source?: string;\n}): GoalSummary {\n  const isComparable = target !== null && actual !== null;\n  let isMet: boolean | null = null;\n\n  if (isComparable) {\n    isMet = direction === 'higher_is_better'\n      ? actual >= target\n      : actual <= target;\n  }\n\n  return {\n    metric,\n    target,\n    actual,\n    direction,\n    delta: isComparable ? actual - target : null,\n    isMet,\n    ...(source && { source }),\n  };\n}\n","import type {\n  AppToolDataNotReadyPayload,\n  AppToolDataPartialResult,\n  AppToolDataPayload,\n  AppToolDataReadyResult,\n  AppToolNotReadyResult,\n  AppToolResultExtra,\n  DataProvenance,\n} from '../types';\n\nimport { boundWaitDelay } from './appToolFailure';\nimport { buildCoverage } from './dataSummary';\n\n// Written only by the builders below — never smuggled in through `extra`.\nconst RESERVED_DATA_KEYS = new Set([\n  'success',\n  'error',\n  'outcome',\n  'isDataReady',\n  'message',\n  'toolName',\n  'code',\n  'nextAction',\n  'params',\n  'scope',\n  'coverage',\n  'units',\n  'summary',\n  'sampleRows',\n  'goals',\n  'provenance',\n]);\n\nfunction sanitizeExtra(\n  extra: AppToolResultExtra | undefined,\n): AppToolResultExtra {\n  if (!extra) return {};\n\n  return Object.fromEntries(\n    Object.entries(extra).filter(([key]) => !RESERVED_DATA_KEYS.has(key)),\n  );\n}\n\nfunction buildProvenance(\n  provenance: AppToolDataPayload['provenance'],\n  now: () => string,\n): DataProvenance {\n  return {\n    source: provenance?.source ?? 'LOADED_APP_STATE',\n    computedAt: provenance?.computedAt ?? now(),\n  };\n}\n\nconst isoNow = (): string => new Date().toISOString();\n\n/**\n * Result envelope for a data digest.\n *\n * The outcome is DERIVED from coverage rather than declared: an app cannot report\n * READY over a set it only partly analysed, which is the failure mode that makes\n * \"the average of page one\" read as the average of everything.\n */\nexport function appToolData<\n  Summary extends object,\n  Row = unknown,\n  Filters = Record<string, unknown>,\n>(\n  payload: AppToolDataPayload<Summary, Row, Filters>,\n  now: () => string = isoNow,\n):\n  | AppToolDataReadyResult<Summary, Row, Filters>\n  | AppToolDataPartialResult<Summary, Row, Filters> {\n  const {\n    scope,\n    coverage: coverageInput,\n    units,\n    summary,\n    sampleRows,\n    goals,\n    code,\n    message,\n    extra,\n  } = payload;\n\n  const coverage = buildCoverage(coverageInput);\n\n  const result = {\n    ...sanitizeExtra(extra),\n    scope,\n    coverage,\n    units,\n    summary,\n    ...(sampleRows && { sampleRows }),\n    ...(goals && { goals }),\n    provenance: buildProvenance(payload.provenance, now),\n    ...(code && { code }),\n    ...(message && { message }),\n  };\n\n  if (coverage.isComplete) {\n    return {\n      ...result,\n      success: true,\n      outcome: 'READY',\n      // Compatibility with readers written against the first contract.\n      isDataReady: true,\n    };\n  }\n\n  return {\n    ...result,\n    success: true,\n    outcome: 'PARTIAL',\n    isDataReady: false,\n  };\n}\n\n/**\n * The handler ran and there is nothing true to report yet — still loading, no\n * asset in scope, a pipeline that never populated.\n *\n * A completed call, not a failure: routing this through the transport's error\n * channel takes the real failure path, which on some branches stops the agent's\n * turn altogether. And reporting zeros instead is what turns \"no data\" into a\n * confidently wrong answer.\n */\nexport function appToolDataNotReady<Filters = Record<string, unknown>>(\n  message: string,\n  payload: AppToolDataNotReadyPayload<Filters>,\n): AppToolNotReadyResult {\n  const { code, nextAction, params, scope, extra } = payload;\n\n  return {\n    ...sanitizeExtra(extra),\n    success: true,\n    outcome: 'NOT_READY',\n    isDataReady: false,\n    message,\n    code,\n    nextAction: boundWaitDelay(nextAction),\n    ...(params && { params }),\n    ...(scope && { scope }),\n  };\n}\n","import type { AppTool, AppToolFactory } from '../types';\n\n/** Composes per-tool factories into the app's single `createAllTools(deps)`. */\nexport function createToolset<Deps>(\n  factories: ReadonlyArray<AppToolFactory<Deps>>,\n): (deps: Deps) => AppTool[] {\n  return deps => factories.map(factory => factory(deps));\n}\n","import { jsonValueEqual, type ValueEquality } from './settingsDiff';\n\ntype PendingEntry = {\n  sequence: number;\n  value: unknown;\n};\n\nexport type PendingWriteSnapshot = Record<string, readonly unknown[]>;\nexport type PendingHostUpdate<State extends object> =\n  | { origin?: 'auto' }\n  | { origin: 'external'; changedKeys: readonly Extract<keyof State, string>[] };\n\nexport type PendingWriteOverlay<State extends object> = {\n  /** Clears pending intent whenever the rendered entity/time/view scope changes. */\n  setScope(scope: unknown): void;\n  /** Call immediately before/with the app-owned writer. */\n  record<Key extends Extract<keyof State, string>>(key: Key, value: State[Key], hostState: State): void;\n  /** Feed each new host-confirmed snapshot before reading effective state. */\n  reconcile(hostState: State, update?: PendingHostUpdate<State>): void;\n  /** Host props plus only the newest still-pending value per key. */\n  getEffective(hostState: State): State;\n  /** Diagnostic/test view; values are ordered oldest to newest. */\n  getPending(): PendingWriteSnapshot;\n  clear(): void;\n};\n\n/**\n * Tracks host-round-trip writes without confusing an older echo with the newest\n * intent. It never observes eval shadow and it owns no React lifecycle.\n */\nexport function createPendingWriteOverlay<\n  State extends object,\n>({\n  initialScope,\n  equals = jsonValueEqual,\n  scopeEquals = Object.is,\n}: {\n  initialScope?: unknown;\n  equals?: ValueEquality;\n  /** Scope tokens are identities by default; customize only for normalized value tokens. */\n  scopeEquals?: ValueEquality;\n} = {}): PendingWriteOverlay<State> {\n  const queues = new Map<string, PendingEntry[]>();\n  const observedHostValues = new Map<string, unknown>();\n  let scope = initialScope;\n  let sequence = 0;\n\n  const clear = (): void => {\n    queues.clear();\n    observedHostValues.clear();\n  };\n\n  const reconcile = (\n    hostState: State,\n    update: PendingHostUpdate<State> = {},\n  ): void => {\n    const externalKeys = update.origin === 'external'\n      ? new Set(update.changedKeys.map(String))\n      : null;\n\n    queues.forEach((queue, key) => {\n      const hostValue = Reflect.get(hostState, key);\n      const previousHostValue = observedHostValues.get(key);\n\n      if (externalKeys?.has(key)) {\n        queues.delete(key);\n        observedHostValues.delete(key);\n        return;\n      }\n\n      if (equals(previousHostValue, hostValue)) return;\n\n      observedHostValues.set(key, hostValue);\n      const matchingIndex = queue.findIndex(entry => equals(entry.value, hostValue));\n\n      if (matchingIndex < 0) {\n        queues.delete(key);\n        observedHostValues.delete(key);\n        return;\n      }\n      queue.splice(0, matchingIndex + 1);\n\n      if (!queue.length) {\n        queues.delete(key);\n        observedHostValues.delete(key);\n      }\n    });\n  };\n\n  return {\n    setScope(nextScope) {\n      if (scopeEquals(scope, nextScope)) return;\n      scope = nextScope;\n      clear();\n    },\n    record(key, value, hostState) {\n      // The host may have moved since the command's earlier read. Retire stale\n      // intent against this writer-adjacent snapshot before appending the new\n      // intent, otherwise the next read can discard both as one unmatched queue.\n      reconcile(hostState);\n      const stringKey = String(key);\n      const queue = queues.get(stringKey) ?? [];\n      if (!queue.length) {\n        observedHostValues.set(\n          stringKey,\n          Reflect.get(hostState, stringKey),\n        );\n      }\n      queue.push({ sequence: ++sequence, value });\n      queues.set(stringKey, queue);\n    },\n    reconcile,\n    getEffective(hostState) {\n      reconcile(hostState);\n      const pending = Object.fromEntries(\n        [...queues.entries()].map(([key, queue]) => [key, queue[queue.length - 1].value]),\n      );\n\n      return { ...hostState, ...pending };\n    },\n    getPending() {\n      return Object.fromEntries(\n        [...queues.entries()].map(([key, queue]) => [\n          key,\n          queue\n            .slice()\n            .sort((left, right) => left.sequence - right.sequence)\n            .map(entry => entry.value),\n        ]),\n      );\n    },\n    clear,\n  };\n}\n","export type ResultBudget = {\n  bytes: number;\n  maxBytes: number;\n  withinBudget: boolean;\n};\n\nexport type CappedItems<Item, Identity extends string | number> = {\n  items: Item[];\n  returned: number;\n  total: number;\n  truncated: boolean;\n  omittedIdentities: Identity[];\n};\n\nexport type CappedEntityRows<Row, Identity extends string | number> = {\n  rows: Row[];\n  returned: number;\n  total: number;\n  truncated: boolean;\n  coveredEntityIds: Identity[];\n  omittedEntityIds: Identity[];\n  omittedRowsByEntity: Array<{ entityId: Identity; count: number }>;\n};\n\nfunction requireLimit(value: number, name: string): void {\n  if (!Number.isInteger(value) || value < 0) {\n    throw new RangeError(`${name} must be a non-negative integer`);\n  }\n}\n\n/** Exact UTF-8 size of a JSON tool result; throws for non-serializable values. */\nexport function measureSerializedBytes(value: unknown): number {\n  const serialized = JSON.stringify(value);\n  if (serialized === undefined) {\n    throw new TypeError('result must be JSON-serializable');\n  }\n\n  return new TextEncoder().encode(serialized).byteLength;\n}\n\nexport function checkResultBudget(\n  value: unknown,\n  maxBytes: number,\n): ResultBudget {\n  requireLimit(maxBytes, 'maxBytes');\n  const bytes = measureSerializedBytes(value);\n\n  return { bytes, maxBytes, withinBudget: bytes <= maxBytes };\n}\n\n/** Caps a named catalogue and preserves the identities that were not returned. */\nexport function capNamedItems<Item, Identity extends string | number>(\n  items: readonly Item[],\n  limit: number,\n  getIdentity: (item: Item) => Identity,\n): CappedItems<Item, Identity> {\n  requireLimit(limit, 'limit');\n  const returnedItems = items.slice(0, limit);\n\n  return {\n    items: returnedItems,\n    returned: returnedItems.length,\n    total: items.length,\n    truncated: returnedItems.length < items.length,\n    omittedIdentities: items.slice(limit).map(getIdentity),\n  };\n}\n\n/**\n * Fair row cap: round-robin across entities so an early entity cannot consume the\n * whole payload. The caller receives exact omissions instead of a bare boolean.\n */\nexport function capRowsByEntity<Row, Identity extends string | number>({\n  rows,\n  getEntityId,\n  perEntityLimit,\n  totalLimit,\n}: {\n  rows: readonly Row[];\n  getEntityId: (row: Row) => Identity;\n  perEntityLimit: number;\n  totalLimit: number;\n}): CappedEntityRows<Row, Identity> {\n  requireLimit(perEntityLimit, 'perEntityLimit');\n  requireLimit(totalLimit, 'totalLimit');\n\n  const groups = new Map<Identity, Row[]>();\n  rows.forEach(row => {\n    const entityId = getEntityId(row);\n    const group = groups.get(entityId) ?? [];\n    group.push(row);\n    groups.set(entityId, group);\n  });\n\n  const selected: Row[] = [];\n  let round = 0;\n  while (selected.length < totalLimit && round < perEntityLimit) {\n    let added = false;\n    groups.forEach(group => {\n      if (selected.length >= totalLimit || round >= group.length) return;\n      selected.push(group[round]);\n      added = true;\n    });\n    if (!added) break;\n    round += 1;\n  }\n\n  const selectedCounts = new Map<Identity, number>();\n  selected.forEach(row => {\n    const id = getEntityId(row);\n    selectedCounts.set(id, (selectedCounts.get(id) ?? 0) + 1);\n  });\n\n  const coveredEntityIds = [...groups.keys()].filter(id => selectedCounts.has(id));\n  const omittedRowsByEntity = [...groups.entries()]\n    .map(([entityId, group]) => ({\n      entityId,\n      count: group.length - (selectedCounts.get(entityId) ?? 0),\n    }))\n    .filter(item => item.count > 0);\n\n  return {\n    rows: selected,\n    returned: selected.length,\n    total: rows.length,\n    truncated: selected.length < rows.length,\n    coveredEntityIds,\n    omittedEntityIds: [...groups.keys()].filter(id => !selectedCounts.has(id)),\n    omittedRowsByEntity,\n  };\n}\n","/**\n * Typed readers for a tool's untyped `params` (`Record<string, unknown>`) — the\n * single ingress where the model's arguments are narrowed, so handlers stay\n * cast-free. Numbers are coerced from strings (the model sometimes serializes\n * numeric arguments as `\"123\"`).\n */\n\ntype Params = Record<string, unknown> | undefined;\n\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nexport function getString(params: Params, key: string): string | null {\n  const value = params?.[key];\n\n  return typeof value === 'string' ? value : null;\n}\n\nexport function getNumber(params: Params, key: string): number | null {\n  const value = params?.[key];\n\n  if (typeof value === 'number' && Number.isFinite(value)) return value;\n\n  if (typeof value === 'string' && value.trim()) {\n    const parsed = Number(value);\n\n    if (Number.isFinite(parsed)) return parsed;\n  }\n\n  return null;\n}\n\nexport function getBoolean(params: Params, key: string): boolean | null {\n  const value = params?.[key];\n\n  return typeof value === 'boolean' ? value : null;\n}\n\nexport function getRecord(params: Params, key: string): Record<string, unknown> | null {\n  const value = params?.[key];\n\n  return isRecord(value) ? value : null;\n}\n\n/** Numeric array with non-finite entries dropped; `[]` when absent or not an array. */\nexport function getNumberArray(params: Params, key: string): number[] {\n  const value = params?.[key];\n\n  if (!Array.isArray(value)) return [];\n\n  return value\n    .map(item => (typeof item === 'number' ? item : Number(item)))\n    .filter((item): item is number => Number.isFinite(item));\n}\n\n/** String array filtered to string entries; `[]` when absent or not an array. */\nexport function getStringArray(params: Params, key: string): string[] {\n  const value = params?.[key];\n\n  if (!Array.isArray(value)) return [];\n\n  return value.filter((item): item is string => typeof item === 'string');\n}\n\n/** Array filtered to entries that pass `guard`; `[]` when absent or not an array. */\nexport function getTypedArray<T>(\n  params: Params,\n  key: string,\n  guard: (value: unknown) => value is T,\n): T[] {\n  const value = params?.[key];\n\n  if (!Array.isArray(value)) return [];\n\n  return value.filter(guard);\n}\n","/**\n * Three-state readers for a tool's untyped `params`.\n *\n * The lenient `get*` readers collapse \"absent\" and \"garbage\" into `null`, which\n * hides a whole class of silent bug: a handler that guards with `value === null`\n * treats `{ moderateDataDelay: 'banana' }` as \"not sent\", ignores it, applies the\n * OTHER arguments in the same call, and reports success — so the agent believes a\n * threshold it never set. Absent means the caller said nothing; invalid means the\n * caller said something wrong, and those need different answers.\n */\n\ntype Params = Record<string, unknown> | undefined;\n\nexport type ParamRead<T> =\n  | { state: 'absent' }\n  | { state: 'valid'; value: T }\n  | { state: 'invalid'; received: unknown };\n\nconst ABSENT = { state: 'absent' } as const;\n\n/**\n * JSON numbers only — no numeric strings. `Number('0x10')` is 16 and `Number('')`\n * is 0, so accepting strings quietly widens a numeric field into JS literal\n * syntax; a threshold is worth rejecting rather than guessing at.\n */\nexport function readNumber(params: Params, key: string): ParamRead<number> {\n  if (!params || !(key in params)) return ABSENT;\n\n  const value = params[key];\n\n  if (value === undefined) return ABSENT;\n\n  return typeof value === 'number' && Number.isFinite(value)\n    ? { state: 'valid', value }\n    : { state: 'invalid', received: value };\n}\n\nexport function readBoolean(params: Params, key: string): ParamRead<boolean> {\n  if (!params || !(key in params)) return ABSENT;\n\n  const value = params[key];\n\n  if (value === undefined) return ABSENT;\n\n  return typeof value === 'boolean'\n    ? { state: 'valid', value }\n    : { state: 'invalid', received: value };\n}\n\nexport function readString(params: Params, key: string): ParamRead<string> {\n  if (!params || !(key in params)) return ABSENT;\n\n  const value = params[key];\n\n  if (value === undefined) return ABSENT;\n\n  return typeof value === 'string' && value.trim()\n    ? { state: 'valid', value }\n    : { state: 'invalid', received: value };\n}\n\n/** One of a closed set of values, so a handler does not re-check the enum itself. */\nexport function readEnum<T extends string>(\n  params: Params,\n  key: string,\n  allowed: readonly T[],\n): ParamRead<T> {\n  const read = readString(params, key);\n\n  if (read.state !== 'valid') return read;\n\n  const match = allowed.find(option => option === read.value);\n\n  return match ? { state: 'valid', value: match } : { state: 'invalid', received: read.value };\n}\n\n/** The value when the caller sent a usable one, else null. */\nexport function valueOf<T>(read: ParamRead<T>): T | null {\n  return read.state === 'valid' ? read.value : null;\n}\n\nexport function isSent<T>(read: ParamRead<T>): boolean {\n  return read.state !== 'absent';\n}\n\n/**\n * The first argument the caller got wrong, so a handler can reject the whole call\n * before applying any of it. Reporting one field at a time is enough: the agent\n * fixes it and re-sends, and a partial apply is what this prevents.\n */\nexport function firstInvalid(\n  reads: Record<string, ParamRead<unknown>>,\n): { field: string; received: unknown } | null {\n  const entry = Object.entries(reads).find(([, read]) => read.state === 'invalid');\n\n  if (!entry) return null;\n\n  const [field, read] = entry;\n\n  return { field, received: read.state === 'invalid' ? read.received : null };\n}\n\n/** Whether the caller sent at least one of a set where one is required. */\nexport function hasAnyOf(reads: Record<string, ParamRead<unknown>>, fields: readonly string[]): boolean {\n  return fields.some(field => reads[field] && isSent(reads[field]));\n}\n"]}