@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/wire/index.d.ts

@@ -1,12 +1,12 @@
-import { b as CustomTokenPricing, c as CostLedgerHandle } from "../cost-ledger-CO7UyEcQ.js";
-import { x as ChatClient } from "../types-DBZ7keha.js";
-import { s as TraceStore } from "../store-C4avFjIi.js";
-import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-DkaDj0dj.js";
+import { a as CostLedgerHandle, p as CustomTokenPricing } from "../cost-ledger-Jk62OBfF.js";
+import { x as ChatClient } from "../types-D-mgRzlh.js";
+import { s as TraceStore } from "../store-B3nWRy3B.js";
+import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-BWmhRBGu.js";
 import { z } from "zod";
 import { ServerType } from "@hono/node-server";
 import { Hono } from "hono";
 //#region src/wire/schemas.d.ts
-export declare const RubricDimensionSchema: z.ZodObject<{
+declare const RubricDimensionSchema: z.ZodObject<{
   id: z.ZodString;
   description: z.ZodString;
   weight: z.ZodDefault<z.ZodNumber>;
@@ -17,7 +17,7 @@ declare const FailureModeSchema: z.ZodObject<{
   id: z.ZodString;
   description: z.ZodString;
 }, z.core.$strip>;
-export declare const RubricSchema: z.ZodObject<{
+declare const RubricSchema: z.ZodObject<{
   name: z.ZodString;
   description: z.ZodString;
   systemPrompt: z.ZodString;
@@ -37,7 +37,7 @@ export declare const RubricSchema: z.ZodObject<{
     description: z.ZodString;
   }, z.core.$strip>>>;
 }, z.core.$strip>;
-export declare const JudgeRequestSchema: z.ZodObject<{
+declare const JudgeRequestSchema: z.ZodObject<{
   rubricName: z.ZodOptional<z.ZodString>;
   rubric: z.ZodOptional<z.ZodObject<{
     name: z.ZodString;
@@ -63,7 +63,7 @@ export declare const JudgeRequestSchema: z.ZodObject<{
   context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   model: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export declare const JudgeResultSchema: z.ZodObject<{
+declare const JudgeResultSchema: z.ZodObject<{
   composite: z.ZodNumber;
   dimensions: z.ZodRecord<z.ZodString, z.ZodNumber>;
   failureModes: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -84,7 +84,7 @@ declare const RubricInfoSchema: z.ZodObject<{
   failureModes: z.ZodDefault<z.ZodArray<z.ZodString>>;
   rubricVersion: z.ZodString;
 }, z.core.$strip>;
-export declare const ListRubricsResponseSchema: z.ZodObject<{
+declare const ListRubricsResponseSchema: z.ZodObject<{
   rubrics: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
@@ -97,19 +97,15 @@ export declare const ListRubricsResponseSchema: z.ZodObject<{
     rubricVersion: z.ZodString;
   }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const VersionResponseSchema: z.ZodObject<{
+declare const VersionResponseSchema: z.ZodObject<{
   package: z.ZodString;
   version: z.ZodString;
   wireVersion: z.ZodString;
   apiSurface: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
-export declare const HealthResponseSchema: z.ZodObject<{
-  status: z.ZodLiteral<"ok">;
-  uptimeSec: z.ZodNumber;
-}, z.core.$strip>;
 /**
- * Minimal `TraceEvent` shape that the production runtime emits.
- * Matches `trace/schema.ts` `TraceEvent` but is duplicated here as a
+ * Minimal `WireTraceEvent` shape that the production runtime emits.
+ * Matches `trace/schema.ts` `WireTraceEvent` but is duplicated here as a
  * wire schema so non-TypeScript clients can validate without depending
  * on internal types.
  */
@@ -130,7 +126,7 @@ export declare const TraceEventSchema: z.ZodObject<{
   timestamp: z.ZodNumber;
   payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
-export declare const TracesIngestRequestSchema: z.ZodObject<{
+declare const TracesIngestRequestSchema: z.ZodObject<{
   events: z.ZodArray<z.ZodObject<{
     eventId: z.ZodString;
     runId: z.ZodString;
@@ -149,7 +145,7 @@ export declare const TracesIngestRequestSchema: z.ZodObject<{
     payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
   }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const TracesIngestResponseSchema: z.ZodObject<{
+declare const TracesIngestResponseSchema: z.ZodObject<{
   accepted: z.ZodNumber;
   rejected: z.ZodNumber;
   errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -282,15 +278,15 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
   updatedAt: z.ZodOptional<z.ZodString>;
   metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
-export declare const FeedbackIngestResponseSchema: z.ZodObject<{
+declare const FeedbackIngestResponseSchema: z.ZodObject<{
   id: z.ZodString;
   persisted: z.ZodBoolean;
 }, z.core.$strip>;
-export type TraceEvent = z.infer<typeof TraceEventSchema>;
-export type TracesIngestRequest = z.infer<typeof TracesIngestRequestSchema>;
-export type TracesIngestResponse = z.infer<typeof TracesIngestResponseSchema>;
-export type FeedbackTrajectory = z.infer<typeof FeedbackTrajectorySchema>;
-export type FeedbackIngestResponse = z.infer<typeof FeedbackIngestResponseSchema>;
+type WireTraceEvent = z.infer<typeof TraceEventSchema>;
+type TracesIngestRequest = z.infer<typeof TracesIngestRequestSchema>;
+type TracesIngestResponse = z.infer<typeof TracesIngestResponseSchema>;
+type WireFeedbackTrajectory = z.infer<typeof FeedbackTrajectorySchema>;
+type FeedbackIngestResponse = z.infer<typeof FeedbackIngestResponseSchema>;
 export declare const ErrorResponseSchema: z.ZodObject<{
   error: z.ZodObject<{
     code: z.ZodString;
@@ -298,15 +294,15 @@ export declare const ErrorResponseSchema: z.ZodObject<{
     details: z.ZodOptional<z.ZodUnknown>;
   }, z.core.$strip>;
 }, z.core.$strip>;
-export type RubricDimension = z.infer<typeof RubricDimensionSchema>;
-export type FailureMode = z.infer<typeof FailureModeSchema>;
-export type Rubric = z.infer<typeof RubricSchema>;
-export type JudgeRequest = z.infer<typeof JudgeRequestSchema>;
-export type JudgeResult = z.infer<typeof JudgeResultSchema>;
-export type RubricInfo = z.infer<typeof RubricInfoSchema>;
-export type ListRubricsResponse = z.infer<typeof ListRubricsResponseSchema>;
-export type VersionResponse = z.infer<typeof VersionResponseSchema>;
-export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+type WireRubricDimension = z.infer<typeof RubricDimensionSchema>;
+type WireFailureMode = z.infer<typeof FailureModeSchema>;
+type Rubric = z.infer<typeof RubricSchema>;
+type JudgeRequest = z.infer<typeof JudgeRequestSchema>;
+type JudgeResult = z.infer<typeof JudgeResultSchema>;
+type RubricInfo = z.infer<typeof RubricInfoSchema>;
+type ListRubricsResponse = z.infer<typeof ListRubricsResponseSchema>;
+type VersionResponse = z.infer<typeof VersionResponseSchema>;
+type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
 /**
  * Bump the major on any breaking change to a request/response schema — the
  * Python client compares majors and refuses a mismatch. Bump the minor when a
@@ -314,24 +310,6 @@ export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
  * can detect but does not have to act on.
  */
 export declare const WIRE_VERSION = "1.1.0";
-/**
- * The digest scheme `hashRubric` mints, named inside the value it produces.
- * A consumer holding a tag from an earlier release reads a different scheme
- * here and can tell "this package changed how it hashes" from "the rubric
- * changed" — the two are indistinguishable when the value is an untagged hex
- * string.
- */
-export declare const RUBRIC_VERSION_SCHEME = "sha256-rfc8785";
-/**
- * Stable identity of a rubric, as `<name>@sha256-rfc8785:<hex>`. Two scores
- * are comparable when this matches exactly.
- *
- * The digest comes from `hashCanonical`, this package's only canonical-JSON
- * encoder (RFC 8785). RFC 8785 orders keys by UTF-16 code unit, which is a
- * property of the value alone — so the same rubric produces the same tag on
- * every machine, which a locale-collated key order does not guarantee.
- */
-export declare function hashRubric(rubric: Rubric): string;
 //#endregion
 //#region src/wire/handlers.d.ts
 /** Caller-fixable error. The transport renders this to 4xx + ErrorResponse. */
@@ -341,7 +319,7 @@ export declare class WireError extends Error {
   readonly details?: unknown;
   constructor(code: string, message: string, status?: number, details?: unknown);
 }
-export interface HandleJudgeOptions {
+interface HandleJudgeOptions {
   costLedger?: CostLedgerHandle;
   costPhase?: string;
   /**
@@ -355,9 +333,6 @@ export interface HandleJudgeOptions {
   pricing?: CustomTokenPricing;
   signal?: AbortSignal;
 }
-export declare function handleJudge(req: JudgeRequest, options?: HandleJudgeOptions): Promise<JudgeResult>;
-export declare function handleListRubrics(): ListRubricsResponse;
-export declare function handleVersion(): VersionResponse;
 /**
  * Pluggable stores the wire layer routes ingestion writes into. Both
  * are optional — when omitted, the corresponding endpoint returns 503.
@@ -366,344 +341,10 @@ export declare function handleVersion(): VersionResponse;
  * `FileSystemFeedbackTrajectoryStore` here. Tests substitute in-memory
  * stores.
  */
-export interface IngestionStores {
+interface IngestionStores {
   traceStore?: TraceStore;
   feedbackStore?: FeedbackTrajectoryStore;
 }
-/**
- * `POST /v1/traces/ingest` — accept a batch of `TraceEvent`s from the
- * production runtime. Best-effort: each event is appended independently;
- * one bad event does not poison the batch.
- *
- * Idempotency: the underlying store is append-only; consumers retrying
- * the same payload will get duplicate events. Consumers should
- * de-duplicate by `eventId` downstream — production traces frequently
- * land via at-least-once buses (Kafka, SQS) where dedup is unavoidable.
- */
-export declare function handleTracesIngest(req: TracesIngestRequest, stores: IngestionStores): Promise<TracesIngestResponse>;
-/**
- * `POST /v1/feedback` — accept a single `FeedbackTrajectory` from the
- * production runtime. Idempotent on `id`: re-posting the same trajectory
- * replaces the prior record.
- */
-export declare function handleFeedbackIngest(req: FeedbackTrajectory, stores: IngestionStores): Promise<FeedbackIngestResponse>;
-//#endregion
-//#region node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/specification-extension.d.ts
-type IExtensionName = `x-${string}`;
-type IExtensionType = any;
-type ISpecificationExtension = {
-  [extensionName: IExtensionName]: IExtensionType;
-};
-//#endregion
-//#region node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/oas-common.d.ts
-interface ServerObject extends ISpecificationExtension {
-  url: string;
-  description?: string;
-  variables?: {
-    [v: string]: ServerVariableObject;
-  };
-}
-interface ServerVariableObject extends ISpecificationExtension {
-  enum?: string[] | boolean[] | number[];
-  default: string | boolean | number;
-  description?: string;
-}
-//#endregion
-//#region node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/openapi31.d.ts
-interface OpenAPIObject extends ISpecificationExtension {
-  openapi: string;
-  info: InfoObject;
-  servers?: ServerObject[];
-  paths?: PathsObject;
-  components?: ComponentsObject;
-  security?: SecurityRequirementObject[];
-  tags?: TagObject[];
-  externalDocs?: ExternalDocumentationObject;
-  webhooks?: PathsObject;
-}
-interface InfoObject extends ISpecificationExtension {
-  title: string;
-  description?: string;
-  termsOfService?: string;
-  contact?: ContactObject;
-  license?: LicenseObject;
-  version: string;
-}
-interface ContactObject extends ISpecificationExtension {
-  name?: string;
-  url?: string;
-  email?: string;
-}
-interface LicenseObject extends ISpecificationExtension {
-  name: string;
-  identifier?: string;
-  url?: string;
-}
-interface ComponentsObject extends ISpecificationExtension {
-  schemas?: {
-    [schema: string]: SchemaObject | ReferenceObject;
-  };
-  responses?: {
-    [response: string]: ResponseObject | ReferenceObject;
-  };
-  parameters?: {
-    [parameter: string]: ParameterObject | ReferenceObject;
-  };
-  examples?: {
-    [example: string]: ExampleObject | ReferenceObject;
-  };
-  requestBodies?: {
-    [request: string]: RequestBodyObject | ReferenceObject;
-  };
-  headers?: {
-    [header: string]: HeaderObject | ReferenceObject;
-  };
-  securitySchemes?: {
-    [securityScheme: string]: SecuritySchemeObject | ReferenceObject;
-  };
-  links?: {
-    [link: string]: LinkObject | ReferenceObject;
-  };
-  callbacks?: {
-    [callback: string]: CallbackObject | ReferenceObject;
-  };
-  pathItems?: {
-    [pathItem: string]: PathItemObject | ReferenceObject;
-  };
-}
-interface PathsObject extends ISpecificationExtension {
-  [path: string]: PathItemObject;
-}
-interface PathItemObject extends ISpecificationExtension {
-  $ref?: string;
-  summary?: string;
-  description?: string;
-  get?: OperationObject;
-  put?: OperationObject;
-  post?: OperationObject;
-  delete?: OperationObject;
-  options?: OperationObject;
-  head?: OperationObject;
-  patch?: OperationObject;
-  trace?: OperationObject;
-  servers?: ServerObject[];
-  parameters?: (ParameterObject | ReferenceObject)[];
-}
-interface OperationObject extends ISpecificationExtension {
-  tags?: string[];
-  summary?: string;
-  description?: string;
-  externalDocs?: ExternalDocumentationObject;
-  operationId?: string;
-  parameters?: (ParameterObject | ReferenceObject)[];
-  requestBody?: RequestBodyObject | ReferenceObject;
-  responses?: ResponsesObject;
-  callbacks?: CallbacksObject;
-  deprecated?: boolean;
-  security?: SecurityRequirementObject[];
-  servers?: ServerObject[];
-}
-interface ExternalDocumentationObject extends ISpecificationExtension {
-  description?: string;
-  url: string;
-}
-type ParameterLocation = 'query' | 'header' | 'path' | 'cookie';
-type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
-interface BaseParameterObject extends ISpecificationExtension {
-  description?: string;
-  required?: boolean;
-  deprecated?: boolean;
-  allowEmptyValue?: boolean;
-  style?: ParameterStyle;
-  explode?: boolean;
-  allowReserved?: boolean;
-  schema?: SchemaObject | ReferenceObject;
-  examples?: {
-    [param: string]: ExampleObject | ReferenceObject;
-  };
-  example?: any;
-  content?: ContentObject;
-}
-interface ParameterObject extends BaseParameterObject {
-  name: string;
-  in: ParameterLocation;
-}
-interface RequestBodyObject extends ISpecificationExtension {
-  description?: string;
-  content: ContentObject;
-  required?: boolean;
-}
-interface ContentObject {
-  [mediatype: string]: MediaTypeObject;
-}
-interface MediaTypeObject extends ISpecificationExtension {
-  schema?: SchemaObject | ReferenceObject;
-  examples?: ExamplesObject;
-  example?: any;
-  encoding?: EncodingObject;
-}
-interface EncodingObject extends ISpecificationExtension {
-  [property: string]: EncodingPropertyObject | any;
-}
-interface EncodingPropertyObject {
-  contentType?: string;
-  headers?: {
-    [key: string]: HeaderObject | ReferenceObject;
-  };
-  style?: string;
-  explode?: boolean;
-  allowReserved?: boolean;
-  [key: string]: any;
-}
-interface ResponsesObject extends ISpecificationExtension {
-  default?: ResponseObject | ReferenceObject;
-  [statuscode: string]: ResponseObject | ReferenceObject | any;
-}
-interface ResponseObject extends ISpecificationExtension {
-  description: string;
-  headers?: HeadersObject;
-  content?: ContentObject;
-  links?: LinksObject;
-}
-interface CallbacksObject extends ISpecificationExtension {
-  [name: string]: CallbackObject | ReferenceObject | any;
-}
-interface CallbackObject extends ISpecificationExtension {
-  [name: string]: PathItemObject | any;
-}
-interface HeadersObject {
-  [name: string]: HeaderObject | ReferenceObject;
-}
-interface ExampleObject {
-  summary?: string;
-  description?: string;
-  value?: any;
-  externalValue?: string;
-  [property: string]: any;
-}
-interface LinksObject {
-  [name: string]: LinkObject | ReferenceObject;
-}
-interface LinkObject extends ISpecificationExtension {
-  operationRef?: string;
-  operationId?: string;
-  parameters?: LinkParametersObject;
-  requestBody?: any | string;
-  description?: string;
-  server?: ServerObject;
-  [property: string]: any;
-}
-interface LinkParametersObject {
-  [name: string]: any | string;
-}
-interface HeaderObject extends BaseParameterObject {
-  $ref?: string;
-}
-interface TagObject extends ISpecificationExtension {
-  name: string;
-  description?: string;
-  externalDocs?: ExternalDocumentationObject;
-  [extension: string]: any;
-}
-interface ExamplesObject {
-  [name: string]: ExampleObject | ReferenceObject;
-}
-interface ReferenceObject {
-  $ref: string;
-  summary?: string;
-  description?: string;
-}
-type SchemaObjectType = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array';
-interface SchemaObject extends ISpecificationExtension {
-  $ref?: string;
-  discriminator?: DiscriminatorObject;
-  readOnly?: boolean;
-  writeOnly?: boolean;
-  xml?: XmlObject;
-  externalDocs?: ExternalDocumentationObject;
-  example?: any;
-  examples?: any[];
-  deprecated?: boolean;
-  type?: SchemaObjectType | SchemaObjectType[];
-  format?: 'int32' | 'int64' | 'float' | 'double' | 'byte' | 'binary' | 'date' | 'date-time' | 'password' | string;
-  allOf?: (SchemaObject | ReferenceObject)[];
-  oneOf?: (SchemaObject | ReferenceObject)[];
-  anyOf?: (SchemaObject | ReferenceObject)[];
-  not?: SchemaObject | ReferenceObject;
-  items?: SchemaObject | ReferenceObject;
-  properties?: {
-    [propertyName: string]: SchemaObject | ReferenceObject;
-  };
-  additionalProperties?: SchemaObject | ReferenceObject | boolean;
-  propertyNames?: SchemaObject | ReferenceObject;
-  description?: string;
-  default?: any;
-  title?: string;
-  multipleOf?: number;
-  maximum?: number;
-  const?: any;
-  exclusiveMaximum?: number;
-  minimum?: number;
-  exclusiveMinimum?: number;
-  maxLength?: number;
-  minLength?: number;
-  pattern?: string;
-  maxItems?: number;
-  minItems?: number;
-  uniqueItems?: boolean;
-  maxProperties?: number;
-  minProperties?: number;
-  required?: string[];
-  enum?: any[];
-  prefixItems?: (SchemaObject | ReferenceObject)[];
-  contentMediaType?: string;
-  contentEncoding?: string;
-}
-interface DiscriminatorObject {
-  propertyName: string;
-  mapping?: {
-    [key: string]: string;
-  };
-}
-interface XmlObject extends ISpecificationExtension {
-  name?: string;
-  namespace?: string;
-  prefix?: string;
-  attribute?: boolean;
-  wrapped?: boolean;
-}
-type SecuritySchemeType = 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
-interface SecuritySchemeObject extends ISpecificationExtension {
-  type: SecuritySchemeType;
-  description?: string;
-  name?: string;
-  in?: string;
-  scheme?: string;
-  bearerFormat?: string;
-  flows?: OAuthFlowsObject;
-  openIdConnectUrl?: string;
-}
-interface OAuthFlowsObject extends ISpecificationExtension {
-  implicit?: OAuthFlowObject;
-  password?: OAuthFlowObject;
-  clientCredentials?: OAuthFlowObject;
-  authorizationCode?: OAuthFlowObject;
-}
-interface OAuthFlowObject extends ISpecificationExtension {
-  authorizationUrl?: string;
-  tokenUrl?: string;
-  refreshUrl?: string;
-  scopes: ScopesObject;
-}
-interface ScopesObject extends ISpecificationExtension {
-  [scope: string]: any;
-}
-interface SecurityRequirementObject {
-  [name: string]: string[];
-}
-//#endregion
-//#region src/wire/openapi.d.ts
-export declare function buildOpenApi(packageVersion: string): OpenAPIObject;
 //#endregion
 //#region src/wire/rpc.d.ts
 interface RpcRequest {
@@ -726,26 +367,6 @@ interface RpcOptions {
   judgeModel?: string;
 }
 export declare function dispatchRpc(req: RpcRequest, options?: RpcOptions): Promise<RpcSuccess | RpcError>;
-/** Read one JSON request from stdin, write one JSON response to stdout. */
-export declare function runRpcOnce(method?: string, options?: RpcOptions): Promise<number>;
-/** Read JSONL requests from stdin, write JSONL responses to stdout. */
-export declare function runRpcBatch(method?: string, options?: RpcOptions): Promise<number>;
-//#endregion
-//#region src/wire/rubrics.d.ts
-/** Get a built-in rubric by name, or undefined. */
-export declare function getBuiltinRubric(name: string): Rubric | undefined;
-/** List built-in rubrics with their stable versions. */
-export declare function listBuiltinRubrics(): {
-  name: string;
-  description: string;
-  dimensions: {
-    id: string;
-    description: string;
-    weight: number;
-  }[];
-  failureModes: string[];
-  rubricVersion: string;
-}[];
 //#endregion
 //#region src/wire/server.d.ts
 interface CreateAppOptions {
@@ -798,5 +419,5 @@ interface StartedServer {
  */
 export declare function startServerAsync(opts?: ServeOptions): Promise<StartedServer>;
 //#endregion
-export type { RpcOptions, ServeOptions, StartedServer };
+export type { ErrorResponse, FeedbackIngestResponse, HandleJudgeOptions, IngestionStores, JudgeRequest, JudgeResult, ListRubricsResponse, RpcOptions, Rubric, RubricInfo, ServeOptions, StartedServer, TracesIngestRequest, TracesIngestResponse, VersionResponse, WireFailureMode, WireFeedbackTrajectory, WireRubricDimension, WireTraceEvent };
 //# sourceMappingURL=index.d.ts.map

package/dist/wire/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["WireFeedbackTrajectory"],"sources":["../../src/wire/schemas.ts","../../src/wire/handlers.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/specification-extension.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/oas-common.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/openapi31.d.ts","../../src/wire/openapi.ts","../../src/wire/rpc.ts","../../src/wire/rubrics.ts","../../src/wire/server.ts"],"x_google_ignoreList":[2,3,4],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/wire/schemas.ts","../../src/wire/handlers.ts","../../src/wire/rpc.ts","../../src/wire/server.ts"],"mappings":";;;;;;;;cAoBa,uBAAqB,EAAA;;;;;;GAkBD,EAAA,KAAA;cAE3B,mBAAiB,EAAA;;;GAKM,EAAA,KAAA;cAIhB,cAAY,EAAA;;;;;;;;;;;;;;;;;;;GA6BL,EAAA,KAAA;cAIP,oBAAkB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAwBL,EAAA,KAAA;cAEb,mBAAiB,EAAA;;;;;;;;;GA6BL,EAAA,KAAA;cAInB,kBAAgB,EAAA;;;;;;;;;;GAcE,EAAA,KAAA;cAEX,2BAAyB,EAAA;;;;;;;;;;;;GAIL,EAAA,KAAA;cAIpB,uBAAqB,EAAA;;;;;GAWL,EAAA,KAAA;;;;;;;qBAiBhB,kBAAgB,EAAA;;;;;;;;;;;;;;;;GA0BD,EAAA,KAAA;cAEf,2BAAyB,EAAA;;;;;;;;;;;;;;;;;;GAQL,EAAA,KAAA;cAEpB,4BAA0B,EAAA;;;;;;;GAiBL,EAAA,KAAA;qBA2DrB,0BAAwB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BD,EAAA,KAAA;cAEvB,8BAA4B,EAAA;;;GAKL,EAAA,KAAA;KAExB,iBAAiB,EAAE,aAAa;KAChC,sBAAsB,EAAE,aAAa;KACrC,uBAAuB,EAAE,aAAa;KACtC,yBAAyB,EAAE,aAAa;KACxC,yBAAyB,EAAE,aAAa;qBAIvC,qBAAmB,EAAA;;;;;;GAcL,EAAA,KAAA;KAIf,sBAAsB,EAAE,aAAa;KACrC,kBAAkB,EAAE,aAAa;KACjC,SAAS,EAAE,aAAa;KACxB,eAAe,EAAE,aAAa;KAC9B,cAAc,EAAE,aAAa;KAC7B,aAAa,EAAE,aAAa;KAC5B,sBAAsB,EAAE,aAAa;KACrC,kBAAkB,EAAE,aAAa;KACjC,gBAAgB,EAAE,aAAa;;;;;;;qBAU9B;;;;qBChWA,kBAAkB;WAEX;WAEA;WACA;EAJlB,YACkB,cAChB,iBACgB,iBACA;;UAgJH;EACf,aAAa;EACb;;;;;;EAMA,OAAO;EACP;;EAEA,UAAU;EACV,SAAS;;;;;;;;;;UAsGM;EACf,aAAa;EACb,gBAAgB;;;;UC5RR;EACR;EACA;;UAGQ;EACR;;UAGQ;EACR;IAAS;IAAc;IAAiB;;;UAGzB;;EAEf,OAAO;EACP;;wBAGoB,YACpB,KAAK,YACL,UAAS,aACR,QAAQ,aAAa;;;UCNd;;EAER,SAAS;;;;;;EAMT,OAAO;;EAEP;;;;;;;;;;EAUA;IACE,mBAAmB,4BAA4B;;;wBAMnC,UAAU,OAAM,mBAAqB,0BAAA,+BAAA;UA0IpC,qBAAqB;;EAEpC;;EAEA;;wBAGc,YAAY,OAAM,eAAoB;UAUrC;EACf,QAAQ;;;;EAIR;;EAEA;;EAEA,SAAS;;;;;;;wBAQK,iBAAiB,OAAM,eAAoB,QAAQ"}

package/dist/wire/index.js

@@ -1,2 +1,2 @@
-import { A as WIRE_VERSION, C as RUBRIC_VERSION_SCHEME, D as TracesIngestRequestSchema, E as TraceEventSchema, O as TracesIngestResponseSchema, S as ListRubricsResponseSchema, T as RubricSchema, _ as FeedbackIngestResponseSchema, a as runRpcBatch, b as JudgeRequestSchema, c as WireError, d as handleListRubrics, f as handleTracesIngest, g as ErrorResponseSchema, h as listBuiltinRubrics, i as dispatchRpc, j as hashRubric, k as VersionResponseSchema, l as handleFeedbackIngest, m as getBuiltinRubric, n as startServer, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi, t as createApp, u as handleJudge, v as FeedbackTrajectorySchema, w as RubricDimensionSchema, x as JudgeResultSchema, y as HealthResponseSchema } from "../server-DbcC7xMl.js";
-export { ErrorResponseSchema, FeedbackIngestResponseSchema, FeedbackTrajectorySchema, HealthResponseSchema, JudgeRequestSchema, JudgeResultSchema, ListRubricsResponseSchema, RUBRIC_VERSION_SCHEME, RubricDimensionSchema, RubricSchema, TraceEventSchema, TracesIngestRequestSchema, TracesIngestResponseSchema, VersionResponseSchema, WIRE_VERSION, WireError, buildOpenApi, createApp, dispatchRpc, getBuiltinRubric, handleFeedbackIngest, handleJudge, handleListRubrics, handleTracesIngest, handleVersion, hashRubric, listBuiltinRubrics, runRpcBatch, runRpcOnce, startServer, startServerAsync };
+import { a as dispatchRpc, c as WireError, d as FeedbackTrajectorySchema, f as TraceEventSchema, n as startServer, p as WIRE_VERSION, r as startServerAsync, t as createApp, u as ErrorResponseSchema } from "../server-DoVbqqtJ.js";
+export { ErrorResponseSchema, FeedbackTrajectorySchema, TraceEventSchema, WIRE_VERSION, WireError, createApp, dispatchRpc, startServer, startServerAsync };

package/docs/changes/jev-evidence-review.md

@@ -5,7 +5,7 @@
 thresholds and result policy. Review identity includes authored option order; request JSON is
 not sorted before dispatch. Missing or partial negative evidence cannot become a clean review.
 
-The optional `examples/jev-behavior-review.ts` recipe covers reward gaming, evaluator tampering,
+The optional behavior-review recipe (its example file is not in this tree) covers reward gaming, evaluator tampering,
 policy/authorization/data-boundary breaches, injection-following, contradicted completion,
 oversight bypass, matched-baseline anomalies and cross-run behavior. It composes the existing
 `jevAnalyst`; the taxonomy is not installed in the generic evaluator and is not a calibrated

package/docs/changes/jev-product-adoption.md

@@ -9,7 +9,7 @@ Native extension metadata is preserved, not projected away; lossy non-JSON metad
 before consumers persist an apparently valid but changed observation. Already-paid receipts remain
 recorded when answer validation fails.
 
-`examples/jev-decision-benchmark.ts` compares caller-defined classifier configurations with the
+The decision-benchmark recipe (its example file is not in this tree) compares caller-defined classifier configurations with the
 existing matrix runner. It separates independent expected labels from model input, retains
 abstention, records complete observations and paid failures, and groups results by configuration.
 It is a recipe, not another optimizer or universal scoring policy.

package/docs/changes/jev-recorded-evidence.md

@@ -21,4 +21,4 @@ No live validation is relaxed. The shared implementation has one question/result
 
 Consumer order: publish the actual package version containing this export, update affected dependency pins/lockfiles, then replace archive-only calls to the live request validator. Do not invent a version or install an unpublished source import. Preserve output-vs-text consistency checks, tenant authorization, served-model policy, receipt ownership and the existing action archive. A historical decoder is not permission to repeat paid work.
 
-`tests/jev-recorded-request.test.ts` writes an observation to disk, reads it twice through the real parsers, rejects contradictory results, and confirms that the live path still rejects historical-only requests. No provider, database, scheduler, migration or new package dependency is added.
+The recorded-request test, which is no longer in this tree, writes an observation to disk, reads it twice through the real parsers, rejects contradictory results, and confirms that the live path still rejects historical-only requests. No provider, database, scheduler, migration or new package dependency is added.

package/docs/design/mlbenchmarks-book-review.md

@@ -111,7 +111,7 @@ These are implementation findings, not an assessment of adoption in every consum
 | Concern | Checked implementation | Assessment and remaining gap |
 | --- | --- | --- |
 | Statistical comparisons | [statistics](../../src/statistics/index.ts), [paired decisions](../../src/paired-promotion-decision.ts), [heldout pairing](../../src/campaign/gates/statistical-heldout.ts) | Present. Paired tests, uncertainty, exact binary methods, multiplicity, and power do not need replacement. Claim scope and independent sampling units need stronger binding. |
-| Cluster-aware design | [power](../../src/experiment/power.ts), [registered rule AST](../../src/experiment/ast.ts) | Present. The high-level campaign path does not automatically select these methods from a declared generalization target. |
+| Cluster-aware design | [power](../../src/experiment/power.ts), [registered rule AST](../../src/experiment/ast/) | Present. The high-level campaign path does not automatically select these methods from a declared generalization target. |
 | Executable preregistration | [define/seal/open](../../src/experiment/define.ts), [acceptance tests](../../tests/experiment/preregistration-acceptance.test.ts) | Present. Extend this rule representation instead of creating a second experiment language. |
 | Sequential testing | [sequential gate](../../src/campaign/gates/sequential.ts), [e-process](../../src/statistics/sequential-eprocess.ts) | Present. Optional stopping within a valid stream differs from adapting hypotheses across streams or counting dependent replicas as independent evidence. |
 | Search/final separation | [selfImprove](../../src/contract/self-improve.ts), [method comparison](../../src/campaign/presets/compare-optimization-methods.ts) | Present within calls. Final cases are withheld from method inputs. A persistent cross-campaign exposure policy is missing from these paths. |