@holonograph/client 0.6.0 → 0.8.0

package/dist/index.js

@@ -4010,6 +4010,13 @@ var ALL_SUBSTRATE_COLUMN_SEMANTICS = ["deployment-state", "diagnostic"];
 var SubstrateColumnSemanticSchema = external_exports.enum(ALL_SUBSTRATE_COLUMN_SEMANTICS);
 var ALL_EMISSION_EXPECTATIONS = ["always", "conditional"];
 var EmissionExpectationSchema = external_exports.enum(ALL_EMISSION_EXPECTATIONS);
+var CoOccurrenceEmissionSchema = external_exports.object({
+ whenever: external_exports.string().min(1)
+});
+var EmissionExpectationDeclarationSchema = external_exports.union([
+ EmissionExpectationSchema,
+ CoOccurrenceEmissionSchema
+]);
 var SubstrateColumnStatusSchema = external_exports.enum(["active", "forward-declared", "deprecated"]);
 var SubstrateColumnSchema = external_exports.object({
  id: external_exports.string().min(1).max(128),
@@ -4021,7 +4028,7 @@ var SubstrateColumnSchema = external_exports.object({
 
  values: external_exports.array(external_exports.string().min(1)).min(1).optional(),
 
- emissionExpectation: EmissionExpectationSchema.optional(),
+ emissionExpectation: EmissionExpectationDeclarationSchema.optional(),
 
  status: SubstrateColumnStatusSchema.optional()
 });
@@ -4097,9 +4104,46 @@ new Set(
  PLATFORM_SYSTEM_ROLE_SURFACES.map((s) => s.surfaceId)
 );
 
+var RubricDispatchSchema = external_exports.object({
+
+ facet: external_exports.string().min(1).max(128),
+
+ refsFrom: external_exports.string().min(1),
+
+ refs: external_exports.record(external_exports.string().min(1), external_exports.string().min(1)).optional()
+});
+var ALL_RUBRIC_DEFAULT_REASONS = [
+ "facet-tag-absent",
+ "unmatched-value",
+ "no-bespoke-ref",
+ "pin-unresolved"
+];
+var RubricDefaultReasonSchema = external_exports.enum(ALL_RUBRIC_DEFAULT_REASONS);
+var ALL_RUBRIC_SOURCES = ["facet", "default"];
+var RubricSourceSchema = external_exports.enum(ALL_RUBRIC_SOURCES);
+var JUDGE_RUBRIC_SOURCE_COLUMN_ID = "judge.rubric_source";
+var JUDGE_RUBRIC_DEFAULT_REASON_COLUMN_ID = "judge.rubric_default_reason";
+var JUDGE_RUBRIC_FACET_COLUMN_ID = "judge.rubric_facet";
+function normalizeFacetValue(raw) {
+ return raw.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function rubricDispatchColumns(resolved) {
+ const columns = {
+ [JUDGE_RUBRIC_SOURCE_COLUMN_ID]: resolved.source
+ };
+ if (resolved.reason !== void 0) {
+ columns[JUDGE_RUBRIC_DEFAULT_REASON_COLUMN_ID] = resolved.reason;
+ }
+ if (resolved.facetValue !== null && resolved.facetValue.length > 0) {
+ columns[JUDGE_RUBRIC_FACET_COLUMN_ID] = resolved.facetValue;
+ }
+ return columns;
+}
+
 var JUDGE_RUBRIC_HASH_COLUMN_ID = "judge.rubric_hash";
 var JUDGE_CONTEXT_SCOPE_COLUMN_ID = "judge.context_scope";
 var JUDGE_MODEL_COLUMN_ID = "judge.model";
+var JUDGE_GROUNDING_CAPS_COLUMN_ID = "judge.grounding_caps";
 var JUDGE_RESERVED_COLUMN_NAMESPACE_PREFIX = "judge.";
 var JUDGE_CONTEXT_SCOPES = [
  "rubric_actual",
@@ -4108,13 +4152,15 @@ var JUDGE_CONTEXT_SCOPES = [
  "full_generating_prompt"
 ];
 var JudgeContextScopeSchema = external_exports.enum(JUDGE_CONTEXT_SCOPES);
-external_exports.object({
+var JudgeIdentitySchema = external_exports.object({
 
  rubricHash: external_exports.string().min(1).optional(),
 
  contextScope: JudgeContextScopeSchema.optional(),
 
- model: external_exports.string().min(1).optional()
+ model: external_exports.string().min(1).optional(),
+
+ groundingCaps: external_exports.string().min(1).optional()
 });
 function judgeIdentityColumns(identity) {
  const columns = {};
@@ -4122,8 +4168,36 @@ function judgeIdentityColumns(identity) {
  if (identity.contextScope !== void 0)
  columns[JUDGE_CONTEXT_SCOPE_COLUMN_ID] = identity.contextScope;
  if (identity.model !== void 0) columns[JUDGE_MODEL_COLUMN_ID] = identity.model;
+ if (identity.groundingCaps !== void 0)
+ columns[JUDGE_GROUNDING_CAPS_COLUMN_ID] = identity.groundingCaps;
  return columns;
 }
+var JudgeLensIdentityObservationSchema = external_exports.object({
+
+ rubricHash: external_exports.array(external_exports.string().min(1)).optional(),
+
+ contextScope: external_exports.array(external_exports.string().min(1)).optional(),
+
+ model: external_exports.array(external_exports.string().min(1)).optional(),
+
+ groundingCaps: external_exports.array(external_exports.string().min(1)).optional()
+});
+var DimensionJudgeIdentitySchema = external_exports.object({
+
+ rubricHash: external_exports.string().min(1).optional(),
+
+ contextScope: JudgeContextScopeSchema.optional(),
+
+ model: external_exports.string().min(1).optional(),
+
+ groundingCaps: external_exports.string().min(1).optional(),
+
+ rubricSource: RubricSourceSchema.optional(),
+
+ rubricFacet: external_exports.string().min(1).optional(),
+
+ rubricDefaultReason: external_exports.string().min(1).optional()
+});
 
 var CannedMessageRefSchema = external_exports.string().min(1).max(256);
 var ALL_GATE_FAILURE_ACTIONS = ["retry", "flag", "block"];
@@ -4187,6 +4261,14 @@ var ValueDomainSchema = external_exports.discriminatedUnion("kind", [
  values: external_exports.array(external_exports.string().min(1)).min(1)
  })
 ]);
+var SCORING_CODOMAIN = {
+ "llm-judge": { min: 0, max: 10 },
+ "exact-match": { min: 0, max: 1 },
+ custom: null
+};
+function scoringCodomain(strategy) {
+ return SCORING_CODOMAIN[strategy];
+}
 var GradingDimensionSchema = external_exports.object({
 
  id: DimensionIdSchema,
@@ -4201,7 +4283,57 @@ var GradingDimensionSchema = external_exports.object({
 
  gatePolicy: GatePolicySchema.optional(),
 
- valueDomain: ValueDomainSchema.optional()
+ valueDomain: ValueDomainSchema.optional(),
+
+ rubricDispatch: RubricDispatchSchema.optional()
+}).superRefine((dimension, ctx) => {
+ const codomain = scoringCodomain(dimension.scoring);
+ if (codomain === null) return;
+ const check = (value, path) => {
+ if (value === void 0) return;
+ if (value < codomain.min || value > codomain.max) {
+ ctx.addIssue({
+ code: external_exports.ZodIssueCode.custom,
+ path,
+ message: `passThreshold ${String(value)} is outside the ${dimension.scoring} codomain [${String(codomain.min)}, ${String(codomain.max)}]. ` + (dimension.scoring === "llm-judge" ? `The llm-judge scorer emits a 0\u201310 score; a threshold on another scale never gates as intended. ` : `exact-match emits 1 (pass) or 0 (fail). `) + `Declare passThreshold within [${String(codomain.min)}, ${String(codomain.max)}].`
+ });
+ }
+ };
+ check(dimension.passThreshold, ["passThreshold"]);
+ check(dimension.gatePolicy?.passThreshold, ["gatePolicy", "passThreshold"]);
+ if (dimension.rubricDispatch !== void 0) {
+ if (dimension.scoring !== "llm-judge") {
+ ctx.addIssue({
+ code: external_exports.ZodIssueCode.custom,
+ path: ["rubricDispatch"],
+ message: `rubricDispatch is only valid on an 'llm-judge' dimension (this dimension is '${dimension.scoring}'); only the llm-judge scorer resolves a rubric.`
+ });
+ }
+ if (dimension.rubricRef === void 0 || dimension.rubricRef === "") {
+ ctx.addIssue({
+ code: external_exports.ZodIssueCode.custom,
+ path: ["rubricDispatch"],
+ message: `a dimension with rubricDispatch must also declare 'rubricRef' \u2014 it is the REQUIRED default rubric an unknown/unmatched facet falls back to.`
+ });
+ }
+ const refs = dimension.rubricDispatch.refs;
+ if (refs !== void 0) {
+ const byNormalized = new Map();
+ for (const key of Object.keys(refs)) {
+ const norm = normalizeFacetValue(key);
+ const prior = byNormalized.get(norm);
+ if (prior !== void 0) {
+ ctx.addIssue({
+ code: external_exports.ZodIssueCode.custom,
+ path: ["rubricDispatch", "refs", key],
+ message: `rubricDispatch.refs keys '${prior}' and '${key}' normalize to the same facet value '${norm}' \u2014 an ambiguous pin. Give them distinct normalized values.`
+ });
+ } else {
+ byNormalized.set(norm, key);
+ }
+ }
+ }
+ }
 });
 var SurfaceStatusSchema = external_exports.enum(["active", "forward-declared", "deprecated"]);
 var RemovalSupersededBySchema = external_exports.object({
@@ -4230,6 +4362,41 @@ var RemovedCohortTagSchema = RemovalProvenanceSchema.extend({
 
  tag: CohortTagSchema
 });
+var TrajectoryPolicySchema = external_exports.object({
+
+ conversationIdColumn: external_exports.string().min(1).optional(),
+
+ refusalPatterns: external_exports.array(external_exports.string().min(1)).optional(),
+
+ reaskPatterns: external_exports.array(external_exports.string().min(1)).optional(),
+
+ availableTools: external_exports.array(external_exports.string().min(1)).optional(),
+
+ nullKeyValues: external_exports.array(external_exports.string().min(1)).optional(),
+
+ coarseKeyPatterns: external_exports.array(external_exports.string().min(1)).optional()
+});
+var ALL_POST_OUTCOME_STAGE_KINDS = [
+ "deferred-delivery",
+ "filter",
+ "cache",
+ "rate-limit",
+ "fan-in",
+ "other"
+];
+var PostOutcomeStageKindSchema = external_exports.enum(ALL_POST_OUTCOME_STAGE_KINDS);
+var ALL_POST_OUTCOME_OBSERVABILITIES = ["declared", "reconciled"];
+var PostOutcomeObservabilitySchema = external_exports.enum(ALL_POST_OUTCOME_OBSERVABILITIES);
+var PostOutcomeStageSchema = external_exports.object({
+
+ kind: PostOutcomeStageKindSchema,
+
+ observability: PostOutcomeObservabilitySchema.default("declared"),
+
+ description: external_exports.string().optional(),
+
+ settleMs: external_exports.number().int().positive().optional()
+});
 var SurfaceDeclarationSchema = external_exports.object({
 
  id: SurfaceIdSchema,
@@ -4248,7 +4415,11 @@ var SurfaceDeclarationSchema = external_exports.object({
 
  removedDimensions: external_exports.array(RemovedDimensionSchema).default([]),
 
- removedCohortTags: external_exports.array(RemovedCohortTagSchema).default([])
+ removedCohortTags: external_exports.array(RemovedCohortTagSchema).default([]),
+
+ trajectoryPolicy: TrajectoryPolicySchema.optional(),
+
+ postOutcomeStages: external_exports.array(external_exports.string().min(1)).optional()
 });
 var PricingEntrySchema = external_exports.object({
 
@@ -4282,7 +4453,9 @@ external_exports.object({
 
  description: external_exports.string().optional(),
 
- surfaces: external_exports.array(SurfaceDeclarationSchema).min(1),
+ surfaces: external_exports.array(SurfaceDeclarationSchema),
+
+ postOutcomeStages: external_exports.record(external_exports.string().min(1), PostOutcomeStageSchema).optional(),
 
  routings: external_exports.array(SurfaceRoutingSchema).optional(),
 
@@ -4290,7 +4463,42 @@ external_exports.object({
 
  systemSurfaces: SystemSurfacesSchema.optional()
 });
+var RESERVED_COLUMN_IDS = new Set([
+
+ "lens_version",
+ "light_source_identifier",
+ "run_mode",
+ "correlation_id",
+ "provenance",
+ "timestamp",
+
+ "light_source_served_model"
+
+]);
 var SERVED_MODEL_COLUMN_ID = "light_source_served_model";
+function normalizeColumnId(colId) {
+ return colId.toLowerCase().replace(/[._-]/g, "");
+}
+var CANONICAL_APPARATUS_FACET_IDS = [
+ ...RESERVED_COLUMN_IDS,
+ JUDGE_RUBRIC_HASH_COLUMN_ID,
+ JUDGE_CONTEXT_SCOPE_COLUMN_ID,
+ JUDGE_MODEL_COLUMN_ID
+];
+var NORMALIZED_APPARATUS_FACETS = new Map(
+ CANONICAL_APPARATUS_FACET_IDS.map((id) => [normalizeColumnId(id), id])
+);
+new Set(
+ [
+ SERVED_MODEL_COLUMN_ID,
+ JUDGE_RUBRIC_HASH_COLUMN_ID,
+ JUDGE_CONTEXT_SCOPE_COLUMN_ID,
+ JUDGE_MODEL_COLUMN_ID
+ ].map(normalizeColumnId)
+);
+function isApparatusFacetSpelling(colId) {
+ return NORMALIZED_APPARATUS_FACETS.has(normalizeColumnId(colId));
+}
 
 var LightSourceRoleSchema = external_exports.enum(["system", "user", "assistant", "tool"]);
 var LightSourceContentBlockSchema = external_exports.discriminatedUnion("kind", [
@@ -4739,7 +4947,8 @@ var LightSnapshotSchema = external_exports.object({
  rawRequestOmitted: external_exports.boolean().optional(),
 
  rawResponsePresence: external_exports.enum(["present", "omitted-by-policy", "pending-attach", "failed-attach"]).optional()
-});
+
+}).passthrough();
 var DimensionResultSchema = external_exports.object({
  dimensionId: DimensionIdSchema,
  passed: external_exports.boolean(),
@@ -4750,8 +4959,11 @@ var DimensionResultSchema = external_exports.object({
 
  score: external_exports.number().optional(),
 
- rationale: external_exports.string().optional()
-});
+ rationale: external_exports.string().optional(),
+
+ judge: DimensionJudgeIdentitySchema.optional()
+
+}).passthrough();
 var ALL_GATE_ACTIONS_TAKEN = [
  "pass",
  "retry-then-pass",
@@ -4761,6 +4973,21 @@ var ALL_GATE_ACTIONS_TAKEN = [
  "block"
 ];
 var GateActionTakenSchema = external_exports.enum(ALL_GATE_ACTIONS_TAKEN);
+var DispatchDecisionSchema = external_exports.object({
+
+ dimensionId: DimensionIdSchema,
+
+ scoringStrategy: external_exports.string(),
+
+ dispatchOccurred: external_exports.boolean(),
+
+ rubricResolution: external_exports.object({
+ attempted: external_exports.boolean(),
+ succeeded: external_exports.boolean(),
+ rubricHash: external_exports.string().optional(),
+ failureSubtype: external_exports.enum(["unloadable-rubric", "never-dispatched", "missing-ref"]).optional()
+ }).optional()
+});
 var GateOutcomeSchema = external_exports.object({
 
  action: GateActionTakenSchema,
@@ -4778,7 +5005,9 @@ var GateOutcomeSchema = external_exports.object({
  })
  ).default([]),
 
- actionDetails: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+ actionDetails: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+
+ dispatchDecisions: external_exports.array(DispatchDecisionSchema).optional()
 });
 var SurfaceSnapshotSchema = external_exports.object({
  surfaceId: SurfaceIdSchema,
@@ -4799,7 +5028,8 @@ var SurfaceSnapshotSchema = external_exports.object({
  ).default([]),
 
  gateOutcome: GateOutcomeSchema.optional()
-});
+
+}).passthrough();
 var EvaluationEventKindSchema = external_exports.enum([
  "evaluation",
  "availability.transition",
@@ -4858,7 +5088,9 @@ var NoiseFloorCalibrationSchema = external_exports.object({
 
  perFixtureDimension: external_exports.array(NoiseFloorPerFixtureDimensionSchema),
 
- perDimensionPooled: external_exports.array(NoiseFloorPerDimensionPooledSchema)
+ perDimensionPooled: external_exports.array(NoiseFloorPerDimensionPooledSchema),
+
+ calibratedUnderJudgeIdentity: JudgeLensIdentityObservationSchema.optional()
 });
 var VarianceDecompositionConfidenceIntervalSchema = external_exports.object({
  lower: external_exports.number().min(0),
@@ -4873,6 +5105,110 @@ var VarianceLensVersionEntrySchema = external_exports.object({
 
  meanScore: external_exports.number()
 });
+var FloorFreshnessSchema = external_exports.object({
+ state: external_exports.enum(["fresh", "stale", "undeterminable"]),
+
+ comparedFacets: external_exports.array(external_exports.string()),
+
+ changedFacets: external_exports.array(external_exports.string()),
+
+ ambiguousFacets: external_exports.array(external_exports.string())
+});
+var PhrasingBandRegionSchema = external_exports.object({
+
+ bandMean: external_exports.number().min(0),
+
+ bandMax: external_exports.number().min(0)
+});
+external_exports.object({
+
+ version: external_exports.string().min(1),
+
+ frozenAt: external_exports.string().min(1),
+
+ measuredUnder: external_exports.object({
+ judge: external_exports.string().min(1),
+ rubricVersion: external_exports.string().min(1)
+ }),
+
+ boundaries: external_exports.object({
+
+ ceilingLo: external_exports.number(),
+
+ floorHi: external_exports.number(),
+
+ midMeasuredRange: external_exports.object({ lo: external_exports.number(), hi: external_exports.number() })
+ }),
+ regions: external_exports.object({
+ ceiling: PhrasingBandRegionSchema,
+ mid: PhrasingBandRegionSchema,
+ floor: PhrasingBandRegionSchema
+ })
+});
+var FloorRegionSchema = external_exports.object({
+
+ region: external_exports.enum(["ceiling", "mid", "floor"]),
+
+ calibrationRegion: external_exports.enum(["ceiling", "mid", "floor"]).optional(),
+
+ calibrationScoreCount: external_exports.number().int().min(0).optional(),
+
+ bandMean: external_exports.number().min(0),
+
+ bandMax: external_exports.number().min(0),
+
+ bandExtrapolated: external_exports.boolean(),
+
+ calibrationBandExtrapolated: external_exports.boolean().optional(),
+
+ windowStraddlesBoundary: external_exports.boolean().optional(),
+
+ counterfactualSigmaAgentDelta: external_exports.number().nullable(),
+
+ counterfactualUnavailableReason: external_exports.enum(["no_calibration_scores", "calibration_region_degenerate"]).optional(),
+
+ curveProvenance: external_exports.object({
+ version: external_exports.string(),
+ judge: external_exports.string(),
+ rubricVersion: external_exports.string()
+ })
+});
+var LensCompositeCorrectionSchema = external_exports.object({
+
+ correctedVarianceLens: external_exports.number().min(0),
+
+ reattributedFromResidual: external_exports.number(),
+
+ compositeGroupCount: external_exports.number().int().min(1),
+
+ bracketedFacets: external_exports.array(external_exports.string()),
+
+ bracketedFacetLevels: external_exports.array(external_exports.object({ facet: external_exports.string(), distinctLevels: external_exports.number().int().min(1) })).optional(),
+
+ conservationHolds: external_exports.boolean(),
+
+ partitionRelationship: external_exports.enum([
+ "degenerate",
+ "identical",
+ "judge-refines-version",
+ "version-refines-judge",
+ "cross-cutting"
+ ])
+});
+var ApparatusFacetDriftSchema = external_exports.object({
+ facet: external_exports.string(),
+ basis: external_exports.enum(["reserved-namespace", "declared-control"]),
+
+ control: ControlAttributeSchema.optional()
+});
+var ApparatusResidualContaminationSchema = external_exports.object({
+
+ contaminated: external_exports.boolean(),
+
+ driftedFacets: external_exports.array(ApparatusFacetDriftSchema),
+
+ scope: external_exports.enum(["reserved-only", "contract-resolved"]).optional()
+});
 var VarianceDecompositionSchema = external_exports.object({
  dimensionId: DimensionIdSchema,
 
@@ -4903,7 +5239,17 @@ var VarianceDecompositionSchema = external_exports.object({
 
  sigmaAgentCI: VarianceDecompositionConfidenceIntervalSchema,
 
- caveats: external_exports.array(external_exports.string()).default([])
+ caveats: external_exports.array(external_exports.string()).default([]),
+
+ floorFreshness: FloorFreshnessSchema.optional(),
+
+ floorRegion: FloorRegionSchema.optional(),
+
+ lensCompositeCorrection: LensCompositeCorrectionSchema.optional(),
+
+ apparatusResidualContamination: ApparatusResidualContaminationSchema.optional(),
+
+ decompositionMethodVersion: external_exports.string().optional()
 });
 var LifecycleTransitionStatusSchema = external_exports.enum([
  "draft",
@@ -4952,7 +5298,8 @@ var EvalRecommendationVerdictSchema = external_exports.enum([
  "contaminated",
  "insufficient-n",
  "degenerate",
- "instrument-limited"
+ "instrument-limited",
+ "stale-floor"
 ]);
 var EvalRecommendationCheckSchema = external_exports.object({
  name: external_exports.string().min(1).max(128),
@@ -5368,115 +5715,1010 @@ external_exports.object({
 external_exports.enum(["classificationMode"]);
 external_exports.enum(["prefix-match", "absent-defaulted"]);
 
-var HolonographGradeAfterReportError = class extends Error {
- constructor() {
- super(
- "gradeObserver: cannot grade observers after reportOutcome has flushed. Call gradeObserver(...) for each observer FIRST, then call reportOutcome(...) once."
- );
- this.name = "HolonographGradeAfterReportError";
- }
-};
-var HolonographObserverNotFoundError = class extends Error {
- constructor(lightSourceId, known) {
- super(
- `gradeObserver: no observer record matches lightSourceId "${lightSourceId}". Known observers: ${known.length > 0 ? known.join(", ") : "<none>"}`
- );
- this.name = "HolonographObserverNotFoundError";
- }
-};
-var HolonographNoObserversError = class extends Error {
- constructor() {
- super(
- "gradeObserver: this response has no observer records \u2014 the routing was single-vendor. Use reportOutcome(...) to grade the primary."
- );
- this.name = "HolonographNoObserversError";
- }
-};
-var HolonographMarkerPairingWarningError = class extends Error {
- constructor(pairing) {
- super(
- `availability.mark: server reported pairing severity "${pairing.severity}"` + (pairing.note !== null ? ` \u2014 ${pairing.note}` : "") + (pairing.unpairedClosers.length > 0 ? ` (unpaired closers: ${pairing.unpairedClosers.join(", ")})` : "")
- );
- this.pairing = pairing;
- this.name = "HolonographMarkerPairingWarningError";
- }
- pairing;
-};
+var RELIABILITY_DISPOSITIONS = ["flagged", "assessed", "not-applicable"];
+var ReliabilityDispositionSchema = external_exports.enum(RELIABILITY_DISPOSITIONS);
+var RELIABILITY_FIRING_STAGES = ["config", "score", "window"];
+var ReliabilityFiringStageSchema = external_exports.enum(RELIABILITY_FIRING_STAGES);
+var ReliabilityCorpusFindingSchema = external_exports.object({
 
-var InProcessTransport = class {
- mediator;
- gateExecutor;
- store;
- constructor(opts) {
- this.mediator = opts.mediator;
- this.gateExecutor = opts.gateExecutor;
- this.store = opts.store;
- }
- async dispatch(req) {
- return this.gateExecutor ? this.gateExecutor.callWithGates(req) : this.mediator.call(req);
- }
- async appendEvent(event) {
- if (!this.store) return event.eventId;
- return this.store.append(event);
- }
+ entryId: external_exports.string().min(1),
 
- get topology() {
- return this.mediator.topology;
- }
-};
+ failureMode: external_exports.string().min(1),
 
-var BoundedEmitBuffer = class {
- capacity;
- items = [];
- _offeredTotal = 0;
- _droppedTotal = 0;
+ disposition: ReliabilityDispositionSchema,
 
- constructor(capacity) {
- if (!Number.isInteger(capacity) || capacity < 1) {
- throw new RangeError(
- `BoundedEmitBuffer capacity must be a positive integer, got ${String(capacity)}`
- );
- }
- this.capacity = capacity;
- }
+ remediation: external_exports.string().min(1).nullable(),
 
- offer(item) {
- this._offeredTotal += 1;
- if (this.items.length >= this.capacity) {
- this._droppedTotal += 1;
- return false;
- }
- this.items.push(item);
- return true;
- }
+ firesAt: ReliabilityFiringStageSchema,
 
- drain() {
- if (this.items.length === 0) return [];
- const out = this.items;
- this.items = [];
- return out;
- }
+ tier: external_exports.literal("deterministic"),
 
- get size() {
- return this.items.length;
- }
+ evidence: external_exports.record(external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean()])).optional()
+});
+external_exports.object({
 
- get maxSize() {
- return this.capacity;
- }
+ corpusVersion: external_exports.string().min(1),
 
- get offeredTotal() {
- return this._offeredTotal;
- }
+ corpusHash: external_exports.string().min(1),
 
- get droppedTotal() {
- return this._droppedTotal;
- }
-};
+ findings: external_exports.array(ReliabilityCorpusFindingSchema)
+});
+var ReliabilityCorpusEntryRateSchema = external_exports.object({
+ entryId: external_exports.string().min(1),
 
-var CompletenessAccounting = class {
- constructor(lensVersion, config, hooks = {}) {
- this.lensVersion = lensVersion;
+ evaluated: external_exports.number().int().nonnegative(),
+
+ flagged: external_exports.number().int().nonnegative(),
+
+ assessed: external_exports.number().int().nonnegative(),
+
+ notApplicable: external_exports.number().int().nonnegative(),
+
+ firingRateAmongApplicable: external_exports.number().min(0).max(1).nullable()
+});
+var ReliabilityCorpusRatesSchema = external_exports.object({
+ corpusVersion: external_exports.string().min(1),
+ corpusHash: external_exports.string().min(1),
+
+ evaluationCount: external_exports.number().int().nonnegative(),
+ perEntry: external_exports.array(ReliabilityCorpusEntryRateSchema)
+});
+var TraceClaimCheckSchema = external_exports.object({
+
+ tool: external_exports.string().min(1),
+
+ invoked: external_exports.boolean(),
+ disposition: external_exports.enum(["corroborated", "contradicted"])
+});
+var TRACE_CORROBORATION_DISPOSITIONS = [
+ "contradicted",
+ "corroborated",
+ "no-marker-to-check",
+ "not-applicable"
+];
+var TraceCorroborationDispositionSchema = external_exports.enum(TRACE_CORROBORATION_DISPOSITIONS);
+var TraceCorroborationSchema = external_exports.object({
+
+ disposition: TraceCorroborationDispositionSchema,
+
+ tier: external_exports.literal("deterministic"),
+
+ claims: external_exports.array(TraceClaimCheckSchema)
+});
+var MatchTierSchema = external_exports.discriminatedUnion("kind", [
+
+ external_exports.object({ kind: external_exports.literal("exact") }),
+
+ external_exports.object({ kind: external_exports.literal("normalized") }),
+
+ external_exports.object({ kind: external_exports.literal("fuzzy"), threshold: external_exports.number().min(0).max(1) })
+]);
+var GROUNDING_CLAIM_DISPOSITIONS = [
+ "present-in-scope",
+ "truncated-out",
+ "not-found"
+];
+var GroundingClaimDispositionSchema = external_exports.enum(GROUNDING_CLAIM_DISPOSITIONS);
+var GroundingClaimCheckSchema = external_exports.object({
+
+ datum: external_exports.string().min(1),
+ disposition: GroundingClaimDispositionSchema,
+
+ matchTier: MatchTierSchema.optional(),
+
+ charOffset: external_exports.number().int().nonnegative().optional()
+});
+var GROUNDING_COVERAGE_DISPOSITIONS = [
+ "present-in-scope",
+ "truncated-out",
+ "not-found",
+ "no-marker-to-check",
+ "not-applicable"
+];
+var GroundingCoverageDispositionSchema = external_exports.enum(GROUNDING_COVERAGE_DISPOSITIONS);
+var GroundingCoverageSchema = external_exports.object({
+ disposition: GroundingCoverageDispositionSchema,
+
+ tier: external_exports.literal("deterministic"),
+
+ claims: external_exports.array(GroundingClaimCheckSchema)
+});
+var VERDICT_RELIABILITY_TIERS = ["question", "trust", "review"];
+var VerdictReliabilityTierSchema = external_exports.enum(VERDICT_RELIABILITY_TIERS);
+external_exports.object({
+
+ tier: VerdictReliabilityTierSchema,
+
+ drivers: external_exports.array(external_exports.string()),
+
+ trace: TraceCorroborationSchema,
+
+ grounding: GroundingCoverageSchema
+});
+var VerdictReliabilityTierTallySchema = external_exports.object({
+ question: external_exports.number().int().nonnegative(),
+ trust: external_exports.number().int().nonnegative(),
+ review: external_exports.number().int().nonnegative(),
+ total: external_exports.number().int().nonnegative()
+});
+var FlaggedVerdictSchema = external_exports.object({
+
+ eventId: external_exports.string().min(1),
+
+ correlationId: external_exports.string().min(1).optional(),
+
+ occurredAt: external_exports.string().min(1),
+ surfaceId: external_exports.string().min(1),
+ dimensionId: external_exports.string().min(1),
+
+ drivers: external_exports.array(external_exports.string())
+});
+external_exports.object({
+
+ eventCount: external_exports.number().int().nonnegative(),
+
+ tierTally: VerdictReliabilityTierTallySchema,
+
+ flagged: external_exports.array(FlaggedVerdictSchema),
+
+ corpusRates: ReliabilityCorpusRatesSchema
+});
+var ESCALATION_REASONS = ["both-checks-not-applicable"];
+var EscalationReasonSchema = external_exports.enum(ESCALATION_REASONS);
+external_exports.object({
+
+ targetEventId: external_exports.string().min(1),
+ surfaceId: external_exports.string().min(1),
+ dimensionId: external_exports.string().min(1),
+
+ reason: EscalationReasonSchema
+});
+var JudgeVerdictSchema = external_exports.object({
+
+ score: external_exports.number().optional(),
+
+ passed: external_exports.boolean()
+});
+external_exports.object({
+
+ targetEventId: external_exports.string().min(1),
+ surfaceId: external_exports.string().min(1),
+ dimensionId: external_exports.string().min(1),
+
+ blind: external_exports.literal(true),
+
+ firstVerdict: JudgeVerdictSchema,
+
+ secondVerdict: JudgeVerdictSchema,
+
+ secondJudge: JudgeIdentitySchema,
+
+ secondJudgeInstrumentVersion: external_exports.string().min(1)
+});
+external_exports.object({
+ escalatedCount: external_exports.number().int().nonnegative(),
+ agreeCount: external_exports.number().int().nonnegative(),
+ disagreeCount: external_exports.number().int().nonnegative(),
+ agreementRate: external_exports.number().min(0).max(1).nullable()
+});
+
+var TrajectoryPredicateSchema = external_exports.enum([
+ "p3-disclaim-then-recover",
+ "p2-user-reask",
+ "p1-and-t4"
+]);
+var TrajectoryEvidenceRoleSchema = external_exports.enum([
+ "refusal",
+ "recovery",
+ "user-reask",
+ "availability-unused"
+]);
+var TrajectoryFindingEvidenceSchema = external_exports.object({
+
+ turnIndex: external_exports.number().int().nonnegative(),
+
+ eventId: external_exports.string().min(1),
+
+ occurredAt: external_exports.string().min(1),
+
+ role: TrajectoryEvidenceRoleSchema,
+
+ note: external_exports.string().max(512).optional()
+});
+var TrajectoryFindingSchema = external_exports.object({
+
+ predicate: TrajectoryPredicateSchema,
+
+ conversationId: external_exports.string().min(1),
+
+ surfaceId: SurfaceIdSchema,
+
+ offendingTurnIndices: external_exports.array(external_exports.number().int().nonnegative()).min(1),
+
+ evidence: external_exports.array(TrajectoryFindingEvidenceSchema).min(1),
+
+ detectedAt: external_exports.string().min(1).optional()
+});
+external_exports.object({
+
+ trajectoryCount: external_exports.number().int().nonnegative(),
+
+ nullKeyEventCount: external_exports.number().int().nonnegative(),
+
+ coarseKeyEventCount: external_exports.number().int().nonnegative(),
+
+ evaluatedTurnCount: external_exports.number().int().nonnegative(),
+
+ noOutputTextTurnCount: external_exports.number().int().nonnegative(),
+
+ predicatesEvaluated: external_exports.array(TrajectoryPredicateSchema),
+
+ findings: external_exports.array(TrajectoryFindingSchema)
+});
+
+var LessonsDraftingSurfaceKeySchema = external_exports.enum([
+ "skillDrafting",
+ "lessonDrafting",
+ "fixtureGeneration"
+]);
+LessonsDraftingSurfaceKeySchema.options;
+var LessonsCapabilityStatusSchema = external_exports.enum(["available", "unavailable", "degraded"]);
+var LessonsCapabilityReasonSchema = external_exports.enum(["opted-out", "enablement-changed"]);
+external_exports.object({
+ status: LessonsCapabilityStatusSchema,
+
+ reason: LessonsCapabilityReasonSchema.optional(),
+
+ missingKeys: external_exports.array(LessonsDraftingSurfaceKeySchema).optional()
+});
+
+var ALL_FINDING_SOURCES = [
+ "verdict-reliability",
+ "judge-liveness",
+ "trajectory",
+ "orthogonality-hypothesis",
+ "coverage-gap",
+ "quarantine-candidate",
+ "retirement-candidate",
+ "dark-mass-blindspot",
+ "emission-gap",
+ "reach-gap"
+];
+var FindingSourceSchema = external_exports.enum(ALL_FINDING_SOURCES);
+var ALL_FINDING_GRAINS = ["run", "conversation", "structural"];
+var FindingGrainSchema = external_exports.enum(ALL_FINDING_GRAINS);
+var FindingRefSchema = external_exports.object({
+ primary: external_exports.object({
+ grain: FindingGrainSchema,
+
+ id: external_exports.string().min(1)
+ }),
+ attributes: external_exports.object({
+ source: FindingSourceSchema,
+ surfaceId: SurfaceIdSchema,
+ dimensionId: DimensionIdSchema.optional(),
+
+ driver: external_exports.string().min(1).optional(),
+
+ predicate: external_exports.string().min(1).optional(),
+
+ axis: external_exports.string().min(1).optional(),
+
+ clusterId: external_exports.string().min(1).optional()
+ })
+});
+var ALL_TRIAGE_DISPOSITIONS = ["confirmed-defect", "false-alarm", "acknowledged"];
+var TriageDispositionSchema = external_exports.enum(ALL_TRIAGE_DISPOSITIONS);
+var TriageRecordSchema = external_exports.object({
+
+ findingRef: FindingRefSchema,
+ disposition: TriageDispositionSchema,
+
+ rationale: external_exports.string().min(1),
+
+ approverId: external_exports.string().min(1),
+
+ occurredAt: external_exports.string().datetime(),
+
+ evidenceSnapshotRef: external_exports.string().min(1).optional(),
+
+ asOf: external_exports.string().datetime().optional(),
+
+ proposalRef: external_exports.string().min(1).optional()
+});
+var ALL_TRIAGE_STATES = [
+ "untriaged",
+ "confirmed-defect",
+ "false-alarm",
+ "acknowledged",
+ "resolved"
+];
+var TriageStateSchema = external_exports.enum(ALL_TRIAGE_STATES);
+var ALL_PROPOSAL_KINDS = [
+ "grounding-cap-bump",
+ "adjust-threshold",
+ "fix-rubric-ref",
+ "gate-dimension",
+ "predicate-downweight",
+ "retire-surface",
+ "release-from-quarantine",
+ "declare-axis",
+ "author-fixture"
+];
+var ProposalKindSchema = external_exports.enum(ALL_PROPOSAL_KINDS);
+var ALL_PROPOSAL_STATUSES = ["pending", "approved", "rejected"];
+var ProposalStatusSchema = external_exports.enum(ALL_PROPOSAL_STATUSES);
+var ALL_PROPOSAL_AVAILABILITIES = ["minted", "none-for-source", "not-applicable"];
+external_exports.enum(ALL_PROPOSAL_AVAILABILITIES);
+external_exports.object({
+ proposalRef: external_exports.string().min(1),
+ kind: ProposalKindSchema,
+
+ findingRef: FindingRefSchema,
+
+ summary: external_exports.string().min(1),
+
+ approverId: external_exports.string().min(1),
+ occurredAt: external_exports.string().datetime(),
+ status: ProposalStatusSchema.default("pending")
+});
+var ALL_ATTENTION_SEVERITIES = ["alarm", "needs-review", "coverage"];
+var AttentionSeveritySchema = external_exports.enum(ALL_ATTENTION_SEVERITIES);
+var VerdictReliabilityEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("verdict-reliability"),
+
+ driver: external_exports.string().min(1),
+
+ sampleCorrelationIds: external_exports.array(external_exports.string().min(1)),
+
+ sampleEventIds: external_exports.array(external_exports.string().min(1))
+});
+var OrthogonalityEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("orthogonality-hypothesis"),
+
+ axis: external_exports.string().min(1),
+
+ etaSquared: external_exports.number()
+});
+var TrajectoryEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("trajectory"),
+
+ predicate: TrajectoryPredicateSchema,
+
+ conversationId: external_exports.string().min(1)
+});
+var JudgeDispatchReasonSchema = external_exports.enum([
+ "never-dispatched",
+ "unloadable-rubric",
+ "missing-ref",
+ "unspecified"
+]);
+var JudgeLivenessEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("judge-liveness"),
+
+ variant: external_exports.enum(["not-dispatching", "not-lens-dispatched"]),
+
+ dimensionId: DimensionIdSchema.optional(),
+
+ observedCount: external_exports.number().int().nonnegative().optional(),
+
+ dominantReason: JudgeDispatchReasonSchema.optional(),
+
+ surfaceId: SurfaceIdSchema.optional(),
+
+ inlineCount: external_exports.number().int().nonnegative().optional()
+});
+var CoverageGapEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("coverage-gap"),
+
+ altitude: external_exports.enum(["surface", "dimension"]),
+
+ surfaceStatus: external_exports.enum(["active", "deprecated"])
+});
+var RetirementCandidateEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("retirement-candidate"),
+
+ surfaceStatus: external_exports.enum(["active", "deprecated"])
+});
+var QuarantineCandidateEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("quarantine-candidate"),
+
+ candidateStream: external_exports.literal("parse-anomaly-frequent")
+});
+var EmissionGapEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("emission-gap"),
+
+ variant: external_exports.enum(["deployment-broken", "co-occurrence-gap", "no-events"]),
+
+ columnId: external_exports.string().min(1),
+
+ whenever: external_exports.string().min(1).optional()
+});
+var ReachGapEvidenceSchema = external_exports.object({
+ kind: external_exports.literal("reach-gap"),
+
+ variant: external_exports.enum(["horizon", "shortfall"]),
+
+ surfaceId: SurfaceIdSchema,
+
+ unobservedStageCount: external_exports.number().int().nonnegative().optional(),
+
+ hasSuppressingStage: external_exports.boolean().optional(),
+
+ darkRate: external_exports.number().optional(),
+
+ darkCount: external_exports.number().int().nonnegative().optional()
+});
+var AttentionEvidenceSchema = external_exports.discriminatedUnion("kind", [
+ VerdictReliabilityEvidenceSchema,
+ OrthogonalityEvidenceSchema,
+ TrajectoryEvidenceSchema,
+ JudgeLivenessEvidenceSchema,
+ CoverageGapEvidenceSchema,
+ RetirementCandidateEvidenceSchema,
+ QuarantineCandidateEvidenceSchema,
+ EmissionGapEvidenceSchema,
+ ReachGapEvidenceSchema
+]);
+var AttentionFindingSchema = external_exports.object({
+ findingRef: FindingRefSchema,
+
+ findingKey: external_exports.string().min(1),
+ source: FindingSourceSchema,
+ severity: AttentionSeveritySchema,
+
+ count: external_exports.number().int().positive(),
+
+ firstSeen: external_exports.string().min(1),
+
+ lastSeen: external_exports.string().min(1),
+ evidence: AttentionEvidenceSchema
+});
+AttentionFindingSchema.extend({
+
+ triageState: TriageStateSchema,
+
+ latestTriage: TriageRecordSchema.optional()
+});
+var ExemplarJudgeDecisionSchema = external_exports.object({
+ passed: external_exports.boolean(),
+
+ expected: external_exports.string().optional(),
+
+ actual: external_exports.string().optional(),
+
+ rationale: external_exports.string().optional()
+});
+var VerdictReliabilityExemplarSchema = external_exports.object({
+ source: external_exports.literal("verdict-reliability"),
+ eventId: external_exports.string().min(1),
+ correlationId: external_exports.string().min(1).optional(),
+ occurredAt: external_exports.string().min(1),
+ dimensionId: DimensionIdSchema,
+
+ driver: external_exports.string().min(1),
+ judge: ExemplarJudgeDecisionSchema,
+
+ prompt: external_exports.string().optional(),
+
+ response: external_exports.string().optional(),
+
+ traceClaims: external_exports.array(TraceClaimCheckSchema),
+
+ groundingClaims: external_exports.array(GroundingClaimCheckSchema)
+});
+var OrthogonalityGroupSchema = external_exports.object({
+
+ value: external_exports.string().min(1),
+
+ meanScore: external_exports.number(),
+
+ count: external_exports.number().int().nonnegative()
+});
+var InstrumentPartitionCellSchema = external_exports.object({
+
+ identity: external_exports.string().min(1),
+
+ n: external_exports.number().int().nonnegative(),
+
+ meanScore: external_exports.number()
+});
+var OrthogonalityExemplarSchema = external_exports.object({
+ source: external_exports.literal("orthogonality-hypothesis"),
+ dimensionId: DimensionIdSchema,
+
+ axis: external_exports.string().min(1),
+
+ etaSquared: external_exports.number(),
+
+ etaSquaredExpectedUnderNull: external_exports.number().nullable(),
+
+ omegaSquared: external_exports.number(),
+
+ adjustedPValue: external_exports.number().nullable(),
+
+ pValue: external_exports.number().nullable(),
+
+ scoredEventCount: external_exports.number().int().nonnegative(),
+
+ analyzedGroupCount: external_exports.number().int().nonnegative(),
+
+ groupsTruncated: external_exports.boolean(),
+
+ groupTimeOverlap: external_exports.number(),
+
+ instrumentHeterogeneous: external_exports.boolean(),
+
+ instrumentPartition: external_exports.array(InstrumentPartitionCellSchema),
+
+ identifierLike: external_exports.boolean(),
+
+ effectSizeUncertain: external_exports.boolean(),
+
+ scoreMax: external_exports.number().positive().nullable(),
+
+ groups: external_exports.array(OrthogonalityGroupSchema)
+});
+var TrajectoryTurnDetailSchema = external_exports.object({
+
+ turnIndex: external_exports.number().int().nonnegative(),
+
+ eventId: external_exports.string().min(1),
+ occurredAt: external_exports.string().min(1),
+ role: TrajectoryEvidenceRoleSchema,
+
+ note: external_exports.string().optional(),
+
+ text: external_exports.string().nullable()
+});
+var TrajectoryExemplarSchema = external_exports.object({
+ source: external_exports.literal("trajectory"),
+ conversationId: external_exports.string().min(1),
+ surfaceId: SurfaceIdSchema,
+
+ predicate: TrajectoryPredicateSchema,
+
+ predicatesFired: external_exports.array(TrajectoryPredicateSchema),
+
+ turns: external_exports.array(TrajectoryTurnDetailSchema)
+});
+var JudgeDispatchFailureBreakdownSchema = external_exports.object({
+ unloadableRubric: external_exports.number().int().nonnegative(),
+ missingRef: external_exports.number().int().nonnegative(),
+ neverDispatched: external_exports.number().int().nonnegative(),
+ unspecified: external_exports.number().int().nonnegative()
+});
+var JudgeLivenessExemplarSchema = external_exports.object({
+ source: external_exports.literal("judge-liveness"),
+
+ variant: external_exports.enum(["not-dispatching", "not-lens-dispatched"]),
+
+ dimensionId: DimensionIdSchema.optional(),
+
+ observedCount: external_exports.number().int().nonnegative().optional(),
+
+ dispatchedCount: external_exports.number().int().nonnegative().optional(),
+
+ failureSubtypes: JudgeDispatchFailureBreakdownSchema.optional(),
+
+ dominantReason: JudgeDispatchReasonSchema.optional(),
+
+ failureAction: external_exports.enum(["retry", "flag", "block"]).nullable().optional(),
+
+ rubricRef: external_exports.string().optional(),
+
+ surfaceId: SurfaceIdSchema.optional(),
+
+ inlineDimensionIds: external_exports.array(DimensionIdSchema).optional()
+});
+var CoverageGapExemplarSchema = external_exports.object({
+ source: external_exports.literal("coverage-gap"),
+
+ altitude: external_exports.enum(["surface", "dimension"]),
+ surfaceId: SurfaceIdSchema,
+
+ dimensionId: DimensionIdSchema.optional(),
+ surfaceStatus: external_exports.enum(["active", "deprecated"]),
+
+ observedEventCount: external_exports.number().int().nonnegative(),
+
+ surfaceEventCount: external_exports.number().int().nonnegative(),
+
+ declaredDimensionCount: external_exports.number().int().nonnegative(),
+
+ observedFrom: external_exports.string().min(1),
+
+ observedTo: external_exports.string().min(1)
+});
+var RetirementCandidateExemplarSchema = external_exports.object({
+ source: external_exports.literal("retirement-candidate"),
+ surfaceId: SurfaceIdSchema,
+ surfaceStatus: external_exports.enum(["active", "deprecated"]),
+
+ structuralConsumerCount: external_exports.number().int().nonnegative(),
+
+ declaredDimensionCount: external_exports.number().int().nonnegative(),
+
+ lastCapturedAt: external_exports.string().min(1)
+});
+var QuarantineParseAnomalySchema = external_exports.object({
+
+ field: external_exports.string().min(1),
+
+ recoveredAs: external_exports.string().min(1),
+
+ recoveryStrategy: external_exports.string().min(1),
+
+ rawValue: external_exports.string().nullable()
+});
+var QuarantineCandidateExemplarSchema = external_exports.object({
+ source: external_exports.literal("quarantine-candidate"),
+ surfaceId: SurfaceIdSchema,
+
+ candidateStream: external_exports.literal("parse-anomaly-frequent"),
+
+ count: external_exports.number().int().nonnegative(),
+
+ lifecycleState: QuarantineLifecycleStateSchema,
+
+ firstSeen: external_exports.string().min(1),
+
+ lastSeen: external_exports.string().min(1),
+
+ anomalies: external_exports.array(QuarantineParseAnomalySchema)
+});
+var EmissionGapExemplarSchema = external_exports.object({
+ source: external_exports.literal("emission-gap"),
+ variant: external_exports.enum(["deployment-broken", "co-occurrence-gap", "no-events"]),
+ surfaceId: SurfaceIdSchema,
+ columnId: external_exports.string().min(1),
+
+ control: ControlAttributeSchema,
+
+ visibility: VisibilityAttributeSchema,
+
+ description: external_exports.string().optional(),
+
+ observedEventCount: external_exports.number().int().nonnegative(),
+
+ emittedCount: external_exports.number().int().nonnegative(),
+
+ whenever: external_exports.string().min(1).optional(),
+
+ conditionMatchedCount: external_exports.number().int().nonnegative().optional(),
+
+ observedFrom: external_exports.string().min(1),
+
+ observedTo: external_exports.string().min(1),
+
+ renameCandidate: external_exports.string().min(1).optional()
+});
+var ReachGapStageSchema = external_exports.object({
+
+ id: external_exports.string().min(1),
+
+ kind: PostOutcomeStageKindSchema,
+
+ observability: PostOutcomeObservabilitySchema,
+
+ description: external_exports.string().optional()
+});
+var ReachShortfallSchema = external_exports.object({
+ delivered: external_exports.number().int().nonnegative(),
+ dark: external_exports.number().int().nonnegative(),
+ inFlight: external_exports.number().int().nonnegative(),
+
+ settled: external_exports.number().int().nonnegative(),
+
+ darkRate: external_exports.number().nullable(),
+
+ medianDarkAgeMs: external_exports.number().nullable(),
+
+ byLastStage: external_exports.array(
+ external_exports.object({ stageId: external_exports.string().nullable(), dark: external_exports.number().int().nonnegative() })
+ )
+});
+var ReachGapExemplarSchema = external_exports.object({
+ source: external_exports.literal("reach-gap"),
+
+ variant: external_exports.enum(["horizon", "shortfall"]),
+ surfaceId: SurfaceIdSchema,
+
+ scoredOutcomeCount: external_exports.number().int().nonnegative(),
+
+ stages: external_exports.array(ReachGapStageSchema),
+
+ unobservedStageCount: external_exports.number().int().nonnegative().optional(),
+
+ hasSuppressingStage: external_exports.boolean().optional(),
+
+ shortfall: ReachShortfallSchema.optional(),
+
+ observedFrom: external_exports.string().min(1),
+
+ observedTo: external_exports.string().min(1)
+});
+var AttentionExemplarSchema = external_exports.discriminatedUnion("source", [
+ VerdictReliabilityExemplarSchema,
+ OrthogonalityExemplarSchema,
+ TrajectoryExemplarSchema,
+ JudgeLivenessExemplarSchema,
+ CoverageGapExemplarSchema,
+ RetirementCandidateExemplarSchema,
+ QuarantineCandidateExemplarSchema,
+ EmissionGapExemplarSchema,
+ ReachGapExemplarSchema
+]);
+var AttentionSampleRefSchema = external_exports.object({
+ eventId: external_exports.string().min(1),
+ correlationId: external_exports.string().min(1).optional(),
+ occurredAt: external_exports.string().min(1)
+});
+external_exports.object({
+ findingKey: external_exports.string().min(1),
+ exemplar: AttentionExemplarSchema.nullable(),
+ sampleCount: external_exports.number().int().nonnegative(),
+ samples: external_exports.array(AttentionSampleRefSchema),
+
+ reAdjudicable: external_exports.boolean().optional()
+});
+
+var ReachFootprintSchema = external_exports.object({
+
+ correlationId: external_exports.string().min(1),
+
+ surfaceId: SurfaceIdSchema,
+
+ stageId: external_exports.string().min(1),
+
+ occurredAt: external_exports.string().datetime()
+});
+external_exports.union([
+ ReachFootprintSchema,
+ external_exports.object({ footprints: external_exports.array(ReachFootprintSchema).min(1) })
+]);
+var ALL_REACH_DISPOSITIONS = [
+ "in-flight",
+ "delivered",
+ "dark",
+ "superseded",
+ "expired"
+];
+external_exports.enum(ALL_REACH_DISPOSITIONS);
+
+var FacetCoverageEntrySchema = external_exports.object({
+ facet: external_exports.string().min(1),
+ scoredCount: external_exports.number().int().nonnegative(),
+ source: external_exports.enum(["facet", "default"]),
+ defaultReason: RubricDefaultReasonSchema.optional()
+});
+var FacetDefaultBreakdownSchema = external_exports.object({
+
+ total: external_exports.number().int().nonnegative(),
+
+ noBespokeRef: external_exports.number().int().nonnegative(),
+
+ unmatchedValue: external_exports.number().int().nonnegative(),
+
+ pinUnresolved: external_exports.number().int().nonnegative()
+});
+var FacetCoverageReportSchema = external_exports.object({
+ surfaceId: SurfaceIdSchema,
+ dimensionId: DimensionIdSchema,
+
+ facet: external_exports.string().min(1),
+
+ scoredCount: external_exports.number().int().nonnegative(),
+
+ scoredOnDefault: external_exports.number().int().nonnegative(),
+
+ untaggedCount: external_exports.number().int().nonnegative(),
+
+ facetsSeen: external_exports.number().int().nonnegative(),
+
+ bespokeCount: external_exports.number().int().nonnegative(),
+
+ defaultOnly: FacetDefaultBreakdownSchema,
+
+ facets: external_exports.array(FacetCoverageEntrySchema)
+});
+external_exports.object({
+ reports: external_exports.array(FacetCoverageReportSchema)
+});
+
+var MULTIPLEX_RUN_MAX_VENDORS = 8;
+var MultiplexRunTokensSchema = external_exports.object({
+ input: external_exports.number().nonnegative(),
+ output: external_exports.number().nonnegative(),
+ cacheRead: external_exports.number().nonnegative().optional(),
+ cacheWrite: external_exports.number().nonnegative().optional()
+});
+external_exports.object({
+
+ sourceEventId: external_exports.string().min(1).optional(),
+
+ sourceCorrelationId: external_exports.string().min(1).optional(),
+
+ targetSurfaceId: external_exports.string().min(1).optional(),
+
+ vendorIds: external_exports.array(external_exports.string().min(1)).min(2).max(MULTIPLEX_RUN_MAX_VENDORS),
+
+ label: external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/, "label must match [A-Za-z0-9._-]"),
+
+ approverId: external_exports.string().min(1),
+
+ acknowledgedEstimateUsd: external_exports.number().nonnegative().optional()
+}).refine((b) => b.sourceEventId === void 0 !== (b.sourceCorrelationId === void 0), {
+ message: "provide exactly one of sourceEventId or sourceCorrelationId"
+});
+var MultiplexRunVendorEstimateSchema = external_exports.object({
+ vendorId: external_exports.string(),
+ estimatedUsd: external_exports.number().nonnegative().nullable(),
+ priced: external_exports.boolean()
+});
+var MultiplexRunEstimateSchema = external_exports.object({
+ totalUsd: external_exports.number().nonnegative(),
+ thresholdUsd: external_exports.number().nonnegative(),
+ perVendor: external_exports.array(MultiplexRunVendorEstimateSchema),
+ basis: external_exports.literal("source-tokens"),
+ sourceTokens: MultiplexRunTokensSchema,
+
+ unpricedVendorIds: external_exports.array(external_exports.string())
+});
+var MultiplexRunDimensionSchema = external_exports.object({
+ dimensionId: external_exports.string(),
+ passed: external_exports.boolean(),
+
+ score: external_exports.number().nullable()
+});
+var MultiplexRunLegSchema = external_exports.object({
+ vendorId: external_exports.string(),
+ role: external_exports.enum(["primary", "observer"]),
+ callId: external_exports.string(),
+ correlationId: external_exports.string(),
+ occurredAt: external_exports.string(),
+
+ servedModel: external_exports.string().nullable(),
+
+ response: external_exports.string().nullable(),
+ tokens: MultiplexRunTokensSchema,
+ latencyMs: external_exports.number().nullable(),
+ costUsd: external_exports.number().nullable(),
+
+ dimensions: external_exports.array(MultiplexRunDimensionSchema),
+
+ gateAction: external_exports.string().optional()
+});
+var MultiplexRunFailureSchema = external_exports.object({
+ vendorId: external_exports.string(),
+ error: external_exports.string()
+});
+external_exports.discriminatedUnion("status", [
+ external_exports.object({
+ status: external_exports.literal("confirmation-required"),
+ estimate: MultiplexRunEstimateSchema
+ }),
+ external_exports.object({
+ status: external_exports.literal("ran"),
+ correlationId: external_exports.string(),
+ surfaceId: external_exports.string(),
+ label: external_exports.string(),
+ estimate: MultiplexRunEstimateSchema,
+ legs: external_exports.array(MultiplexRunLegSchema),
+ failed: external_exports.array(MultiplexRunFailureSchema).optional(),
+ scoredDuringRun: external_exports.boolean()
+ })
+]);
+
+var HolonographGradeAfterReportError = class extends Error {
+ constructor() {
+ super(
+ "gradeObserver: cannot grade observers after reportOutcome has flushed. Call gradeObserver(...) for each observer FIRST, then call reportOutcome(...) once."
+ );
+ this.name = "HolonographGradeAfterReportError";
+ }
+};
+var HolonographObserverNotFoundError = class extends Error {
+ constructor(lightSourceId, known) {
+ super(
+ `gradeObserver: no observer record matches lightSourceId "${lightSourceId}". Known observers: ${known.length > 0 ? known.join(", ") : "<none>"}`
+ );
+ this.name = "HolonographObserverNotFoundError";
+ }
+};
+var HolonographNoObserversError = class extends Error {
+ constructor() {
+ super(
+ "gradeObserver: this response has no observer records \u2014 the routing was single-vendor. Use reportOutcome(...) to grade the primary."
+ );
+ this.name = "HolonographNoObserversError";
+ }
+};
+var HolonographMarkerPairingWarningError = class extends Error {
+ constructor(pairing) {
+ super(
+ `availability.mark: server reported pairing severity "${pairing.severity}"` + (pairing.note !== null ? ` \u2014 ${pairing.note}` : "") + (pairing.unpairedClosers.length > 0 ? ` (unpaired closers: ${pairing.unpairedClosers.join(", ")})` : "")
+ );
+ this.pairing = pairing;
+ this.name = "HolonographMarkerPairingWarningError";
+ }
+ pairing;
+};
+
+var InProcessTransport = class {
+ mediator;
+ gateExecutor;
+ store;
+ constructor(opts) {
+ this.mediator = opts.mediator;
+ this.gateExecutor = opts.gateExecutor;
+ this.store = opts.store;
+ }
+ async dispatch(req) {
+ return this.gateExecutor ? this.gateExecutor.callWithGates(req) : this.mediator.call(req);
+ }
+ async appendEvent(event) {
+ if (!this.store) return event.eventId;
+ return this.store.append(event);
+ }
+
+ get topology() {
+ return this.mediator.topology;
+ }
+};
+
+var BoundedEmitBuffer = class {
+ capacity;
+ items = [];
+ _offeredTotal = 0;
+ _droppedTotal = 0;
+
+ constructor(capacity) {
+ if (!Number.isInteger(capacity) || capacity < 1) {
+ throw new RangeError(
+ `BoundedEmitBuffer capacity must be a positive integer, got ${String(capacity)}`
+ );
+ }
+ this.capacity = capacity;
+ }
+
+ offer(item) {
+ this._offeredTotal += 1;
+ if (this.items.length >= this.capacity) {
+ this._droppedTotal += 1;
+ return false;
+ }
+ this.items.push(item);
+ return true;
+ }
+
+ drain() {
+ if (this.items.length === 0) return [];
+ const out = this.items;
+ this.items = [];
+ return out;
+ }
+
+ get size() {
+ return this.items.length;
+ }
+
+ get maxSize() {
+ return this.capacity;
+ }
+
+ get offeredTotal() {
+ return this._offeredTotal;
+ }
+
+ get droppedTotal() {
+ return this._droppedTotal;
+ }
+};
+
+var CompletenessAccounting = class {
+ constructor(lensVersion, config, hooks = {}) {
+ this.lensVersion = lensVersion;
  this.config = config;
  this.hooks = hooks;
  }
@@ -6290,12 +7532,22 @@ var HolonographClient = class {
 
  onUnknownColumn;
 
+ onUnknownColumnExplicit;
+
+ unknownColumnDeprecationWarned = false;
+
  declaredColumns;
 
  warnedColumns = new Set();
 
  refreshedColumnsOnce = false;
 
+ onCoverageDivergence;
+
+ coverageDivergenceChecked = false;
+
+ emitNonBlocking;
+
  messages;
 
  contract;
@@ -6330,6 +7582,9 @@ var HolonographClient = class {
  this.lensVersion = options.lensVersion;
  this.substrate = options.substrate;
  this.onUnknownColumn = isHttpOptions(options) ? options.onUnknownColumn ?? "warn" : "ignore";
+ this.onUnknownColumnExplicit = isHttpOptions(options) && options.onUnknownColumn !== void 0;
+ this.onCoverageDivergence = isHttpOptions(options) ? options.onCoverageDivergence ?? "warn" : "ignore";
+ this.emitNonBlocking = isHttpOptions(options) && options.emit?.mode !== void 0 && options.emit.mode !== "sync";
  this.messages = { create: (req) => this.messagesCreate(req) };
  this.contract = { register: (c) => this.registerContract(c) };
  this.availability = { mark: (req, opts) => this.markAvailability(req, opts) };
@@ -6411,10 +7666,13 @@ var HolonographClient = class {
  return this.declaredColumns;
  }
 
- apparatusStampedColumns(light, judgeIdentity) {
+ apparatusStampedColumns(light, judgeIdentity, rubricDispatch) {
  const columns = { ...this.substrate.columns };
  if (light.servedModel !== void 0) columns[SERVED_MODEL_COLUMN_ID] = light.servedModel;
  if (judgeIdentity !== void 0) Object.assign(columns, judgeIdentityColumns(judgeIdentity));
+ if (rubricDispatch !== void 0) {
+ Object.assign(columns, rubricDispatchColumns(rubricDispatch));
+ }
  return columns;
  }
 
@@ -6426,14 +7684,31 @@ var HolonographClient = class {
  (k) => k !== SERVED_MODEL_COLUMN_ID && !k.startsWith(JUDGE_RESERVED_COLUMN_NAMESPACE_PREFIX)
  );
  if (keys.length === 0) return;
+ const apparatusSpellArounds = keys.filter((k) => isApparatusFacetSpelling(k));
+ const substrateKeys = keys.filter((k) => !isApparatusFacetSpelling(k));
+ if (apparatusSpellArounds.length > 0) {
+ if (this.onUnknownColumn === "throw") {
+ throw new Error(
+ `Holonograph: substrate column(s) collide with apparatus-owned lens identity: ${apparatusSpellArounds.join(", ")}. These normalize to columns the apparatus stamps itself (read the 'judge.*' / 'light_source_served_model' columns) \u2014 remove them from your substrate. (onUnknownColumn: 'throw')`
+ );
+ }
+ const toWarn2 = apparatusSpellArounds.filter((k) => !this.warnedColumns.has(k));
+ if (toWarn2.length > 0) {
+ for (const k of toWarn2) this.warnedColumns.add(k);
+ console.warn(
+ `Holonograph: substrate column(s) collide with apparatus-owned lens identity: ${toWarn2.join(", ")}. The apparatus stamps its own identity ('judge.*', 'light_source_served_model'); a substrate look-alike is not read as an axis \u2014 read the apparatus-stamped columns instead. (onUnknownColumn: 'throw' to block, 'ignore' to silence.)`
+ );
+ }
+ }
+ if (substrateKeys.length === 0) return;
  const declared = await this.fetchDeclaredColumns();
  if (declared === null || declared.size === 0) return;
- let unknown = keys.filter((k) => !declared.has(k));
+ let unknown = substrateKeys.filter((k) => !declared.has(k));
  if (unknown.length > 0 && !this.refreshedColumnsOnce) {
  this.refreshedColumnsOnce = true;
  const refreshed = await this.fetchDeclaredColumns(true);
  if (refreshed === null || refreshed.size === 0) return;
- unknown = keys.filter((k) => !refreshed.has(k));
+ unknown = substrateKeys.filter((k) => !refreshed.has(k));
  }
  if (unknown.length === 0) return;
  if (this.onUnknownColumn === "throw") {
@@ -6447,6 +7722,42 @@ var HolonographClient = class {
  console.warn(
  `Holonograph: substrate column(s) declared in no surface contract: ${toWarn.join(", ")}. They are still emitted, but the lens won't recognize them \u2014 declare them on the contract or fix the typo. (onUnknownColumn: 'throw' to block, 'ignore' to silence.)`
  );
+ if (!this.onUnknownColumnExplicit && !this.unknownColumnDeprecationWarned) {
+ this.unknownColumnDeprecationWarned = true;
+ console.warn(
+ `Holonograph: DEPRECATION \u2014 the default onUnknownColumn will change from 'warn' to 'throw' in the next @holonograph/client major, so an undeclared substrate column will be REJECTED rather than logged. Declare your columns on the surface contract, or set onUnknownColumn: 'warn' explicitly to keep warn-and-continue. (This notice fires once.)`
+ );
+ }
+ }
+
+ async maybeSurfaceCoverageDivergence() {
+ const getEmission = this.transport.getEmission?.bind(this.transport);
+ if (this.onCoverageDivergence === "ignore" || this.emitNonBlocking || // never block the fast-resolve emit modes
+ this.coverageDivergenceChecked || getEmission === void 0) {
+ return;
+ }
+ this.coverageDivergenceChecked = true;
+ const audit = await getEmission().catch(() => void 0);
+ if (audit === void 0) return;
+ const undeclared = [];
+ const missing = [];
+ const apparatus = [];
+ for (const surface of audit.surfaces) {
+ for (const col of surface.undeclaredObserved) undeclared.push(`${surface.surfaceId}.${col}`);
+ for (const row of surface.columns) {
+ if (row.verdict === "missing") missing.push(`${surface.surfaceId}.${row.columnId}`);
+ }
+ for (const col of surface.apparatusObserved) apparatus.push(`${surface.surfaceId}.${col}`);
+ }
+ if (undeclared.length === 0 && missing.length === 0) return;
+ const parts = [];
+ if (undeclared.length > 0) parts.push(`emitted-but-undeclared: ${undeclared.join(", ")}`);
+ if (missing.length > 0) {
+ parts.push(`declared-but-never-emitted (missing): ${missing.join(", ")}`);
+ }
+ console.warn(
+ `Holonograph: declared-vs-emitted coverage divergence \u2014 ${parts.join("; ")}. See GET /holonograph/emission for the full audit` + (apparatus.length > 0 ? ` (apparatus columns observed: ${apparatus.join(", ")})` : "") + `. (onCoverageDivergence: 'ignore' to silence.)`
+ );
  }
  async registerContract(contract) {
  if (typeof this.transport.postContract !== "function") {
@@ -6520,6 +7831,7 @@ var HolonographClient = class {
  };
  if (d.score !== void 0) dim.score = d.score;
  if (d.rationale !== void 0) dim.rationale = d.rationale;
+ if (d.judge !== void 0) dim.judge = d.judge;
  return dim;
  }),
  cohortTags: primaryCohortTags,
@@ -6544,12 +7856,17 @@ var HolonographClient = class {
  substrate: {
  ...this.substrate,
  lightSourceIdentifier: callResult.record.lightSourceId,
- columns: this.apparatusStampedColumns(callResult.record.light, outcome.judgeIdentity)
+ columns: this.apparatusStampedColumns(
+ callResult.record.light,
+ outcome.judgeIdentity,
+ outcome.rubricDispatch
+ )
  },
  surface
  });
  await this.validateSubstrateColumns(event.substrate?.columns);
  await this.transport.appendEvent(event);
+ await this.maybeSurfaceCoverageDivergence();
  if (callResult.observerRecords && callResult.observerRecords.length > 0) {
  const siblingCohortTags = baseCohortTags;
  for (const observerRecord of callResult.observerRecords) {
@@ -6589,6 +7906,7 @@ var HolonographClient = class {
  };
  if (d.score !== void 0) dim.score = d.score;
  if (d.rationale !== void 0) dim.rationale = d.rationale;
+ if (d.judge !== void 0) dim.judge = d.judge;
  return dim;
  }),
  cohortTags: observerCohortTags,