@plurnk/plurnk-contracts 6.0.1 → 7.0.1

package/dist/src/Validator.js

@@ -21,11 +21,10 @@ import capabilityDescriptorSchema from "../schema/CapabilityDescriptor.json" wit
 import capabilityPolicySchema from "../schema/CapabilityPolicy.json" with { type: "json" };
 import capabilityProjectionSchema from "../schema/CapabilityProjection.json" with { type: "json" };
 import capabilitySelectorSchema from "../schema/CapabilitySelector.json" with { type: "json" };
-import workerOwnerSchema from "../schema/WorkerOwner.json" with { type: "json" };
+import sessionOwnerSchema from "../schema/SessionOwner.json" with { type: "json" };
 import clientDisplayCapabilitiesSchema from "../schema/ClientDisplayCapabilities.json" with { type: "json" };
 import mcpServerDefinitionSchema from "../schema/McpServerDefinition.json" with { type: "json" };
 import skillDefinitionSchema from "../schema/SkillDefinition.json" with { type: "json" };
-import a2aAgentDefinitionSchema from "../schema/A2aAgentDefinition.json" with { type: "json" };
 import mcpOAuthSchema from "../schema/McpOAuth.json" with { type: "json" };
 import clientInteractionRequestSchema from "../schema/ClientInteractionRequest.json" with { type: "json" };
 import clientInteractionProjectionSchema from "../schema/ClientInteractionProjection.json" with { type: "json" };
@@ -46,129 +45,16 @@ import mcpOAuthBeginResultSchema from "../schema/McpOAuthBeginResult.json" with
 import functionalityPreparationActivitySchema from "../schema/FunctionalityPreparationActivity.json" with { type: "json" };
 import modelReadinessSchema from "../schema/ModelReadiness.json" with { type: "json" };
 import modelRouteSchema from "../schema/ModelRoute.json" with { type: "json" };
-import aguiDiscoverySchema from "../schema/AguiDiscovery.json" with { type: "json" };
-import aguiClientConformanceSchema from "../schema/AguiClientConformance.json" with { type: "json" };
-import aguiConformanceKitSchema from "../schema/AguiConformanceKit.json" with { type: "json" };
+import acpDiscoverySchema from "../schema/AcpDiscovery.json" with { type: "json" };
 import providerAccountingSchema from "../schema/ProviderAccounting.json" with { type: "json" };
 import providerRequestAccountingSchema from "../schema/ProviderRequestAccounting.json" with { type: "json" };
 import providerUsageSchema from "../schema/ProviderUsage.json" with { type: "json" };
 import providerCostSchema from "../schema/ProviderCost.json" with { type: "json" };
-export class InvalidNoticeError extends TypeError {
-}
 export class InvalidProblemDetailsError extends TypeError {
 }
-export class InvalidProblemProjectionError extends TypeError {
-}
 export class InvalidOperationResultError extends TypeError {
 }
-export class InvalidEntryReadResultError extends TypeError {
-}
-export class InvalidTextRegionError extends TypeError {
-}
-export class InvalidRangeExtentError extends TypeError {
-}
-export class InvalidCapabilityDescriptorError extends TypeError {
-}
-export class InvalidCapabilityPolicyError extends TypeError {
-}
-export class InvalidWorkerOwnerError extends TypeError {
-}
-export class InvalidProposalProjectionError extends TypeError {
-}
-export class InvalidClientDisplayCapabilitiesError extends TypeError {
-}
-export class InvalidMcpServerDefinitionError extends TypeError {
-}
-export class InvalidSkillDefinitionError extends TypeError {
-}
-export class InvalidA2aAgentDefinitionError extends TypeError {
-}
-export class InvalidMcpOAuthError extends TypeError {
-}
-export class InvalidClientInteractionRequestError extends TypeError {
-}
-export class InvalidClientInteractionProjectionError extends TypeError {
-}
-export class InvalidClientInteractionResolutionError extends TypeError {
-}
-export class InvalidEffortError extends TypeError {
-}
-export class InvalidModelCatalogPageError extends TypeError {
-}
-export class InvalidModelCatalogQueryError extends TypeError {
-}
-export class InvalidFunctionalityListResultError extends TypeError {
-}
-export class InvalidFunctionalityDiscoverResultError extends TypeError {
-}
-export class InvalidFunctionalityMutationResultError extends TypeError {
-}
-export class InvalidRollbackReportError extends TypeError {
-}
-export class InvalidModelReadinessError extends TypeError {
-}
-export class InvalidModelRouteError extends TypeError {
-}
-export class InvalidAguiDiscoveryError extends TypeError {
-}
-export class InvalidAguiClientConformanceError extends TypeError {
-}
-export class InvalidAguiConformanceKitError extends TypeError {
-}
-export class InvalidJsonSchemaInstanceError extends TypeError {
-}
-export class InvalidParsedPathError extends TypeError {
-}
-export class InvalidPlurnkStatementError extends TypeError {
-}
 export default class Validator {
-    static #position = Validator.#compile(positionSchema);
-    static #lineMarker = Validator.#compile(lineMarkerSchema);
-    static #textLineMarker = Validator.#compile(textLineMarkerSchema);
-    static #parsedPath = Validator.#compile(parsedPathSchema);
-    static #matcherBody = Validator.#compile(matcherBodySchema);
-    static #sendBody = Validator.#compile(sendBodySchema);
-    static #plurnkStatement = Validator.#withRefs(plurnkStatementSchema, [
-        positionSchema,
-        lineMarkerSchema,
-        textLineMarkerSchema,
-        parsedPathSchema,
-        matcherBodySchema,
-        sendBodySchema,
-        resourceSelectionSchema,
-    ]);
-    static #notice = Validator.#compile(noticeSchema);
-    static #problemDetails = Validator.#compile(problemDetailsSchema);
-    static #problemProjection = Validator.#compile(problemProjectionSchema);
-    static #operationResult = Validator.#withRefs(operationResultSchema, [problemDetailsSchema, rangeExtentSchema]);
-    static #entryReadResult = Validator.#withRefs(entryReadResultSchema, [problemDetailsSchema]);
-    static #textRegion = Validator.#compile(textRegionSchema);
-    static #rangeExtent = Validator.#compile(rangeExtentSchema);
-    static #capabilityDescriptor = Validator.#withRefs(capabilityDescriptorSchema, [capabilitySelectorSchema]);
-    static #capabilityPolicy = Validator.#withRefs(capabilityPolicySchema, [capabilitySelectorSchema]);
-    static #workerOwner = Validator.#compile(workerOwnerSchema);
-    static #proposalProjection = Validator.#withRefs(proposalProjectionSchema, [proposalDispositionSchema, capabilityPolicySchema, capabilitySelectorSchema]);
-    static #clientDisplayCapabilities = Validator.#compile(clientDisplayCapabilitiesSchema);
-    static #mcpServerDefinition = Validator.#withRefs(mcpServerDefinitionSchema, [mcpOAuthSchema]);
-    static #a2aAgentDefinition = Validator.#compile(a2aAgentDefinitionSchema);
-    static #skillDefinition = Validator.#compile(skillDefinitionSchema);
-    static #mcpOAuth = Validator.#compile(mcpOAuthSchema);
-    static #clientInteractionRequest = Validator.#compile(clientInteractionRequestSchema);
-    static #clientInteractionProjection = Validator.#withRefs(clientInteractionProjectionSchema, [clientInteractionRequestSchema]);
-    static #clientInteractionResolution = Validator.#compile(clientInteractionResolutionSchema);
-    static #effort = Validator.#compile(effortSchema);
-    static #providerRequestAccounting = Validator.#withRefs(providerRequestAccountingSchema, [providerUsageSchema, providerCostSchema]);
-    static #modelReadiness = Validator.#compile(modelReadinessSchema);
-    static #modelCatalogPage = Validator.#withRefs(modelCatalogPageSchema, [modelReadinessSchema, effortSchema]);
-    static #functionalityListResult = Validator.#withRefs(functionalityListResultSchema, [functionalityDefinitionStateSchema, functionalityProvenanceSchema, problemDetailsSchema]);
-    static #functionalityDiscoverResult = Validator.#withRefs(functionalityDiscoverResultSchema, [functionalityCandidateSchema, functionalityProvenanceSchema]);
-    static #functionalityMutationResult = Validator.#withRefs(functionalityMutationResultSchema, [functionalityDefinitionStateSchema, functionalityProvenanceSchema, problemDetailsSchema]);
-    static #rollbackReport = Validator.#compile(rollbackReportSchema);
-    static #modelCatalogQuery = Validator.#compile(modelCatalogQuerySchema);
-    static #modelRoute = Validator.#withRefs(modelRouteSchema, [effortSchema]);
-    static #aguiDiscovery = Validator.#withRefs(aguiDiscoverySchema, [clientDisplayCapabilitiesSchema]);
-    static #aguiClientConformance = Validator.#compile(aguiClientConformanceSchema);
-    static #aguiConformanceKit = Validator.#compile(aguiConformanceKitSchema);
     static #jsonSchemaValidators = new WeakMap();
     static #publicSchemas = [
         applicationOperationEventSchema,
@@ -180,9 +66,7 @@ export default class Validator {
         matcherBodySchema,
         sendBodySchema,
         resourceSelectionSchema,
-        aguiDiscoverySchema,
-        aguiClientConformanceSchema,
-        aguiConformanceKitSchema,
+        acpDiscoverySchema,
         clientDisplayCapabilitiesSchema,
         clientInteractionProjectionSchema,
         clientInteractionRequestSchema,
@@ -202,11 +86,11 @@ export default class Validator {
         mcpOAuthSchema,
         mcpServerDefinitionSchema,
         skillDefinitionSchema,
-        a2aAgentDefinitionSchema,
         capabilityDescriptorSchema,
         capabilityPolicySchema,
         capabilityProjectionSchema,
         capabilitySelectorSchema,
+        sessionOwnerSchema,
         modelCatalogPageSchema,
         modelCatalogQuerySchema,
         modelReadinessSchema,
@@ -222,6 +106,7 @@ export default class Validator {
         providerUsageSchema,
         providerCostSchema,
         rangeExtentSchema,
+        textRegionSchema,
         effortSchema,
     ];
     // The exact schema behind a `$ref` a Functionality family declares as its definition
@@ -230,7 +115,7 @@ export default class Validator {
         const schema = Validator.#publicSchemas.find((candidate) => Validator.#schemaId(candidate) === ref);
         return schema === undefined ? null : schema;
     }
-    // {§wire-entrypoint} A schema document is an object, naming its dialect in `$schema` or taking the validator's
+    // {§text-region} A schema document is an object, naming its dialect in `$schema` or taking the validator's
     // default; every validator compiles one, the checked-in documents and the dynamic ones callers own alike. What
     // the document then means is the validator's to read, its declared dialect included.
     static #schemaDocument(value) {
@@ -262,178 +147,21 @@ export default class Validator {
         }
         return validator;
     }
-    // {§wire-entrypoint} The schema's acceptance is the proof a value has its wire type: a guard over the result of
+    // {§text-region} The schema's acceptance is the proof a value has its wire type: a guard over the result of
     // validating that value, the one place a validated `unknown` takes its type. The caller names the type the
     // schema it validated against generates; the predicate is where it appears.
     // oxlint-disable-next-line typescript/no-unnecessary-type-parameters -- a type predicate's parameter appears once by nature
     static #accepted(value, result) {
         return result.valid;
     }
-    static validatePosition(value) {
-        return Validator.#validate(Validator.#position, value);
-    }
-    static validateLineMarker(value) {
-        return Validator.#validate(Validator.#lineMarker, value);
-    }
-    static validateTextLineMarker(value) {
-        return Validator.#validate(Validator.#textLineMarker, value);
-    }
-    static validateParsedPath(value) {
-        return Validator.#validate(Validator.#parsedPath, value);
-    }
-    static validateMatcherBody(value) {
-        return Validator.#validate(Validator.#matcherBody, value);
-    }
-    static validateSendBody(value) {
-        return Validator.#validate(Validator.#sendBody, value);
-    }
-    static validatePlurnkStatement(value) {
-        return Validator.#validate(Validator.#plurnkStatement, value);
-    }
-    static validateNotice(value) {
-        return Validator.#validate(Validator.#notice, value);
-    }
-    static validateProblemDetails(value) {
-        return Validator.#validate(Validator.#problemDetails, value);
-    }
-    static validateProblemProjection(value) {
-        return Validator.#validate(Validator.#problemProjection, value);
-    }
-    static validateOperationResult(value) {
-        return Validator.#validate(Validator.#operationResult, value);
-    }
-    static validateEntryReadResult(value) {
-        const result = Validator.#validate(Validator.#entryReadResult, value);
-        if (!Validator.#accepted(value, result))
-            return result;
-        const entry = value.entry;
-        if (entry === null)
-            return result;
-        for (const [name, channel] of Object.entries(entry.channels)) {
-            const returnedLength = Array.from(channel.content).length;
-            if (channel.contentOffset + returnedLength !== channel.contentLength) {
-                return {
-                    valid: false,
-                    errors: [{
-                            keyword: "entry-read-suffix",
-                            instanceLocation: `/entry/channels/${name}`,
-                            keywordLocation: "#/$defs/channel",
-                            error: "contentOffset plus the returned Unicode-code-point length must equal contentLength",
-                        }],
-                };
-            }
-        }
-        return result;
-    }
-    static validateTextRegion(value) {
-        return Validator.#validate(Validator.#textRegion, value);
-    }
-    static validateRangeExtent(value) {
-        return Validator.#validate(Validator.#rangeExtent, value);
-    }
-    static validateCapabilityDescriptor(value) {
-        return Validator.#validate(Validator.#capabilityDescriptor, value);
-    }
-    static validateCapabilityPolicy(value) {
-        return Validator.#validate(Validator.#capabilityPolicy, value);
-    }
-    static validateWorkerOwner(value) {
-        return Validator.#validate(Validator.#workerOwner, value);
-    }
-    static assertWorkerOwner(value) {
-        const result = Validator.validateWorkerOwner(value);
-        if (!Validator.#accepted(value, result))
-            throw new InvalidWorkerOwnerError(`invalid WorkerOwner: ${JSON.stringify(result.errors)}`);
-        return value;
-    }
-    static validateProposalProjection(value) {
-        return Validator.#validate(Validator.#proposalProjection, value);
-    }
-    static validateClientDisplayCapabilities(value) {
-        return Validator.#validate(Validator.#clientDisplayCapabilities, value);
-    }
-    static validateMcpServerDefinition(value) {
-        return Validator.#validate(Validator.#mcpServerDefinition, value);
-    }
-    static validateA2aAgentDefinition(value) {
-        return Validator.#validate(Validator.#a2aAgentDefinition, value);
-    }
-    static validateSkillDefinition(value) {
-        return Validator.#validate(Validator.#skillDefinition, value);
-    }
-    static validateMcpOAuth(value) {
-        return Validator.#validate(Validator.#mcpOAuth, value);
-    }
-    static validateClientInteractionRequest(value) {
-        return Validator.#validate(Validator.#clientInteractionRequest, value);
-    }
-    static validateClientInteractionProjection(value) {
-        return Validator.#validate(Validator.#clientInteractionProjection, value);
-    }
-    static validateClientInteractionResolution(value) {
-        return Validator.#validate(Validator.#clientInteractionResolution, value);
-    }
-    static validateEffort(value) {
-        return Validator.#validate(Validator.#effort, value);
-    }
-    static validateProviderRequestAccounting(value) {
-        return Validator.#validate(Validator.#providerRequestAccounting, value);
-    }
-    static validateModelCatalogPage(value) {
-        return Validator.#validate(Validator.#modelCatalogPage, value);
-    }
-    static validateModelCatalogQuery(value) {
-        return Validator.#validate(Validator.#modelCatalogQuery, value);
-    }
-    static validateFunctionalityListResult(value) {
-        return Validator.#validate(Validator.#functionalityListResult, value);
-    }
-    static validateFunctionalityDiscoverResult(value) {
-        return Validator.#validate(Validator.#functionalityDiscoverResult, value);
-    }
-    static validateFunctionalityMutationResult(value) {
-        return Validator.#validate(Validator.#functionalityMutationResult, value);
-    }
-    static validateRollbackReport(value) {
-        return Validator.#validate(Validator.#rollbackReport, value);
-    }
-    static assertRollbackReport(value) {
-        const result = Validator.validateRollbackReport(value);
+    // oxlint-disable-next-line typescript/no-unnecessary-type-parameters -- schema assertion returns the type the validated schema generates
+    static #assert(schema, label, value, ErrorClass = TypeError) {
+        const result = Validator.validateJsonSchemaInstance(schema, value);
         if (!Validator.#accepted(value, result)) {
-            throw new InvalidRollbackReportError(`invalid RollbackReport: ${JSON.stringify(result.errors)}`);
+            throw new ErrorClass(`invalid ${label}: ${JSON.stringify(result.errors)}`);
         }
         return value;
     }
-    static validateModelReadiness(value) {
-        const result = Validator.#validate(Validator.#modelReadiness, value);
-        if (!Validator.#accepted(value, result))
-            return result;
-        const readiness = value;
-        if (readiness.ready !== (readiness.causes.length === 0)) {
-            return {
-                valid: false,
-                errors: [{
-                        keyword: "model-readiness",
-                        instanceLocation: "",
-                        keywordLocation: "#",
-                        error: "ready must be true exactly when causes is empty",
-                    }],
-            };
-        }
-        return result;
-    }
-    static validateModelRoute(value) {
-        return Validator.#validate(Validator.#modelRoute, value);
-    }
-    static validateAguiDiscovery(value) {
-        return Validator.#validate(Validator.#aguiDiscovery, value);
-    }
-    static validateAguiClientConformance(value) {
-        return Validator.#validate(Validator.#aguiClientConformance, value);
-    }
-    static validateAguiConformanceKit(value) {
-        return Validator.#validate(Validator.#aguiConformanceKit, value);
-    }
     static validateJsonSchemaInstance(schema, value) {
         let validator = Validator.#jsonSchemaValidators.get(schema);
         if (validator === undefined) {
@@ -443,327 +171,178 @@ export default class Validator {
             validator = Validator.#withRefs(structuredClone(schema), Validator.#publicSchemas);
             Validator.#jsonSchemaValidators.set(schema, validator);
         }
-        return Validator.#validate(validator, value);
+        const result = validator.validate(value);
+        return { valid: result.valid, errors: result.errors };
     }
-    static assertNotice(value) {
-        const result = Validator.validateNotice(value);
-        if (!Validator.#accepted(value, result))
-            throw new InvalidNoticeError(`invalid Notice: ${JSON.stringify(result.errors)}`);
+    static assertJsonSchemaInstance(label, schema, value) {
+        const result = Validator.validateJsonSchemaInstance(schema, value);
+        if (!result.valid) {
+            throw new TypeError(`${label} does not satisfy its JSON Schema: ${JSON.stringify(result.errors)}`);
+        }
         return value;
     }
+    static validateParsedPath(value) {
+        return Validator.validateJsonSchemaInstance(parsedPathSchema, value);
+    }
+    static validatePlurnkStatement(value) {
+        return Validator.validateJsonSchemaInstance(plurnkStatementSchema, value);
+    }
+    static validateEffort(value) {
+        return Validator.validateJsonSchemaInstance(effortSchema, value);
+    }
+    static assertSessionOwner(value) {
+        return Validator.#assert(sessionOwnerSchema, "SessionOwner", value);
+    }
+    static assertRollbackReport(value) {
+        return Validator.#assert(rollbackReportSchema, "RollbackReport", value);
+    }
+    static assertNotice(value) {
+        return Validator.#assert(noticeSchema, "Notice", value);
+    }
     static assertProblemDetails(value) {
-        const result = Validator.validateProblemDetails(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidProblemDetailsError(`invalid RFC 9457 Problem Details: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(problemDetailsSchema, "RFC 9457 Problem Details", value, InvalidProblemDetailsError);
     }
     static assertProblemProjection(value) {
-        const result = Validator.validateProblemProjection(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidProblemProjectionError(`invalid model Problem projection: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(problemProjectionSchema, "model Problem projection", value);
     }
     static assertOperationResult(value) {
-        const result = Validator.validateOperationResult(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidOperationResultError(`invalid operation result: ${JSON.stringify(result.errors)}`);
+        const exact = Validator.#assert(operationResultSchema, "operation result", value, InvalidOperationResultError);
+        if (exact.problem !== undefined && exact.problem.status !== exact.status) {
+            throw new InvalidOperationResultError(`operation result status ${exact.status} does not match problem status ${exact.problem.status}`);
         }
-        if (value.problem !== undefined && value.problem.status !== value.status) {
-            throw new InvalidOperationResultError(`operation result status ${value.status} does not match problem status ${value.problem.status}`);
-        }
-        if (value.range !== undefined) {
+        if (exact.range !== undefined) {
             try {
-                Validator.assertRangeExtent(value.range);
+                Validator.assertRangeExtent(exact.range);
             }
             catch (cause) {
                 throw new InvalidOperationResultError("operation result contains an invalid RangeExtent", { cause });
             }
         }
-        return value;
+        return exact;
     }
     static assertEntryReadResult(value) {
-        const result = Validator.validateEntryReadResult(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidEntryReadResultError(`invalid EntryReadResult: ${JSON.stringify(result.errors)}`);
-        }
-        if ("problem" in value && value.problem.status !== value.status) {
-            throw new InvalidEntryReadResultError(`EntryReadResult status ${value.status} does not match problem status ${value.problem.status}`);
+        const exact = Validator.#assert(entryReadResultSchema, "EntryReadResult", value);
+        if ("problem" in exact && exact.problem.status !== exact.status) {
+            throw new TypeError(`EntryReadResult status ${exact.status} does not match problem status ${exact.problem.status}`);
+        }
+        if (exact.entry !== null) {
+            for (const [name, channel] of Object.entries(exact.entry.channels)) {
+                const returnedLength = Array.from(channel.content).length;
+                if (channel.contentOffset + returnedLength !== channel.contentLength) {
+                    throw new TypeError(`invalid EntryReadResult: /entry/channels/${name} contentOffset plus the returned Unicode-code-point length must equal contentLength`);
+                }
+            }
         }
-        return value;
+        return exact;
     }
     static assertTextRegion(value) {
-        const result = Validator.validateTextRegion(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidTextRegionError(`invalid TextRegion: ${JSON.stringify(result.errors)}`);
-        }
-        if (value.endLine < value.startLine
-            || (value.endLine === value.startLine && value.endColumn < value.startColumn)) {
-            throw new InvalidTextRegionError("TextRegion ends before it starts");
+        const exact = Validator.#assert(textRegionSchema, "TextRegion", value);
+        if (exact.endLine < exact.startLine
+            || (exact.endLine === exact.startLine && exact.endColumn < exact.startColumn)) {
+            throw new TypeError("TextRegion ends before it starts");
         }
-        return value;
+        return exact;
     }
     static assertRangeExtent(value) {
-        const result = Validator.validateRangeExtent(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidRangeExtentError(`invalid RangeExtent: ${JSON.stringify(result.errors)}`);
-        }
-        if (value.returned !== undefined) {
-            const [first, last] = value.returned;
-            if (first > last || last > value.total) {
-                throw new InvalidRangeExtentError("RangeExtent returned positions must be ordered within total");
+        const exact = Validator.#assert(rangeExtentSchema, "RangeExtent", value);
+        if (exact.returned !== undefined) {
+            const [first, last] = exact.returned;
+            if (first > last || last > exact.total) {
+                throw new TypeError("RangeExtent returned positions must be ordered within total");
             }
         }
-        return value;
+        return exact;
     }
     static assertCapabilityDescriptor(value) {
-        const result = Validator.validateCapabilityDescriptor(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidCapabilityDescriptorError(`invalid CapabilityDescriptor: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(capabilityDescriptorSchema, "CapabilityDescriptor", value);
     }
     static assertCapabilityPolicy(value) {
-        const result = Validator.validateCapabilityPolicy(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidCapabilityPolicyError(`invalid CapabilityPolicy: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(capabilityPolicySchema, "CapabilityPolicy", value);
     }
     static assertProposalProjection(value) {
-        const result = Validator.validateProposalProjection(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidProposalProjectionError(`invalid ProposalProjection: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(proposalProjectionSchema, "ProposalProjection", value);
     }
     static assertClientDisplayCapabilities(value) {
-        const result = Validator.validateClientDisplayCapabilities(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidClientDisplayCapabilitiesError(`invalid ClientDisplayCapabilities: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(clientDisplayCapabilitiesSchema, "ClientDisplayCapabilities", value);
     }
     static assertMcpServerDefinition(value) {
-        const result = Validator.validateMcpServerDefinition(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidMcpServerDefinitionError(`invalid MCP server definition: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
-    }
-    static assertA2aAgentDefinition(value) {
-        const result = Validator.validateA2aAgentDefinition(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidA2aAgentDefinitionError(`invalid A2A agent definition: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(mcpServerDefinitionSchema, "MCP server definition", value);
     }
     static assertSkillDefinition(value) {
-        const result = Validator.validateSkillDefinition(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidSkillDefinitionError(`invalid Skill definition: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(skillDefinitionSchema, "Skill definition", value);
     }
     static assertMcpOAuth(value) {
-        const result = Validator.validateMcpOAuth(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidMcpOAuthError(`invalid MCP OAuth settings: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(mcpOAuthSchema, "MCP OAuth settings", value);
     }
     static assertClientInteractionRequest(value) {
-        const result = Validator.validateClientInteractionRequest(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidClientInteractionRequestError(`invalid ClientInteractionRequest: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(clientInteractionRequestSchema, "ClientInteractionRequest", value);
     }
     static assertClientInteractionProjection(value) {
-        const result = Validator.validateClientInteractionProjection(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidClientInteractionProjectionError(`invalid ClientInteractionProjection: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(clientInteractionProjectionSchema, "ClientInteractionProjection", value);
     }
     static assertClientInteractionResolution(value) {
-        const result = Validator.validateClientInteractionResolution(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidClientInteractionResolutionError(`invalid ClientInteractionResolution: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(clientInteractionResolutionSchema, "ClientInteractionResolution", value);
     }
     static assertParsedPath(value) {
-        const result = Validator.validateParsedPath(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidParsedPathError(`invalid ParsedPath: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(parsedPathSchema, "ParsedPath", value);
     }
     static assertPlurnkStatement(value) {
-        const result = Validator.validatePlurnkStatement(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidPlurnkStatementError(`invalid PlurnkStatement: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(plurnkStatementSchema, "PlurnkStatement", value);
     }
     static assertEffort(value) {
-        const result = Validator.validateEffort(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidEffortError(`invalid Effort: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(effortSchema, "Effort", value);
     }
     static assertModelCatalogPage(value) {
-        const result = Validator.validateModelCatalogPage(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidModelCatalogPageError(`invalid ModelCatalogPage: ${JSON.stringify(result.errors)}`);
-        }
-        const page = value;
+        const page = Validator.#assert(modelCatalogPageSchema, "ModelCatalogPage", value);
         const selectors = new Set();
         for (const item of page.items) {
             Validator.assertModelReadiness(item.readiness);
             if (item.selector !== `${item.provider}/${item.model}`) {
-                throw new InvalidModelCatalogPageError("ModelCatalogPage item selector must equal provider/model");
+                throw new TypeError("ModelCatalogPage item selector must equal provider/model");
             }
             if (selectors.has(item.selector)) {
-                throw new InvalidModelCatalogPageError("ModelCatalogPage item selectors must be unique");
+                throw new TypeError("ModelCatalogPage item selectors must be unique");
             }
             selectors.add(item.selector);
         }
         const pageEnd = page.offset + page.items.length;
         if (page.items.length > 0 && pageEnd > page.total) {
-            throw new InvalidModelCatalogPageError("ModelCatalogPage items extend beyond total");
+            throw new TypeError("ModelCatalogPage items extend beyond total");
         }
         if (page.nextOffset !== undefined) {
             if (page.nextOffset !== pageEnd || page.nextOffset >= page.total) {
-                throw new InvalidModelCatalogPageError("ModelCatalogPage nextOffset must equal the page end and leave remaining items");
+                throw new TypeError("ModelCatalogPage nextOffset must equal the page end and leave remaining items");
             }
         }
         else if (page.offset < page.total && pageEnd < page.total) {
-            throw new InvalidModelCatalogPageError("ModelCatalogPage omits nextOffset before total");
+            throw new TypeError("ModelCatalogPage omits nextOffset before total");
         }
         return page;
     }
     static assertFunctionalityListResult(value) {
-        const result = Validator.validateFunctionalityListResult(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidFunctionalityListResultError(`invalid FunctionalityListResult: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(functionalityListResultSchema, "FunctionalityListResult", value);
     }
     static assertFunctionalityDiscoverResult(value) {
-        const result = Validator.validateFunctionalityDiscoverResult(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidFunctionalityDiscoverResultError(`invalid FunctionalityDiscoverResult: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(functionalityDiscoverResultSchema, "FunctionalityDiscoverResult", value);
     }
     static assertFunctionalityMutationResult(value) {
-        const result = Validator.validateFunctionalityMutationResult(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidFunctionalityMutationResultError(`invalid FunctionalityMutationResult: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(functionalityMutationResultSchema, "FunctionalityMutationResult", value);
     }
     static assertModelCatalogQuery(value) {
-        const result = Validator.validateModelCatalogQuery(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidModelCatalogQueryError(`invalid ModelCatalogQuery: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
+        return Validator.#assert(modelCatalogQuerySchema, "ModelCatalogQuery", value);
     }
     static assertModelReadiness(value) {
-        const result = Validator.validateModelReadiness(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidModelReadinessError(`invalid ModelReadiness: ${JSON.stringify(result.errors)}`);
+        const readiness = Validator.#assert(modelReadinessSchema, "ModelReadiness", value);
+        if (readiness.ready !== (readiness.causes.length === 0)) {
+            throw new TypeError("invalid ModelReadiness: ready must be true exactly when causes is empty");
         }
-        return value;
+        return readiness;
     }
     static assertModelRoute(value) {
-        const result = Validator.validateModelRoute(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidModelRouteError(`invalid ModelRoute: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
-    }
-    static assertAguiDiscovery(value) {
-        const result = Validator.validateAguiDiscovery(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidAguiDiscoveryError(`invalid AG-UI discovery manifest: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
-    }
-    static assertAguiClientConformance(discoveryValue, conformanceValue) {
-        const discovery = Validator.assertAguiDiscovery(discoveryValue);
-        const result = Validator.validateAguiClientConformance(conformanceValue);
-        if (!Validator.#accepted(conformanceValue, result)) {
-            throw new InvalidAguiClientConformanceError(`invalid AG-UI client conformance: ${JSON.stringify(result.errors)}`);
-        }
-        const conformance = conformanceValue;
-        const mismatch = (kind) => {
-            const installed = Object.keys(discovery[kind]).toSorted();
-            const accounted = Object.keys(conformance[kind]).toSorted();
-            return installed.length === accounted.length
-                && installed.every((name, index) => name === accounted[index])
-                ? []
-                : [
-                    ...installed.filter((name) => !Object.hasOwn(conformance[kind], name)).map((name) => `missing ${kind.slice(0, -1)} '${name}'`),
-                    ...accounted.filter((name) => !Object.hasOwn(discovery[kind], name)).map((name) => `unknown ${kind.slice(0, -1)} '${name}'`),
-                ];
-        };
-        const mismatches = [...mismatch("actions"), ...mismatch("notifications")];
-        if (mismatches.length > 0) {
-            throw new InvalidAguiClientConformanceError(`AG-UI client conformance does not account for the installed surface: ${mismatches.join(", ")}`);
-        }
-        const missingDimensions = [];
-        for (const kind of ["actions", "notifications"]) {
-            const baseline = kind === "actions"
-                ? ["projection", "success", "failure"]
-                : ["framing", "projection"];
-            for (const [name, disposition] of Object.entries(conformance[kind])) {
-                const required = disposition.posture === "native"
-                    ? [...baseline, "admission", "presentation"]
-                    : disposition.posture === "generic"
-                        ? baseline
-                        : ["failure"];
-                for (const dimension of required) {
-                    if (!disposition.dimensions.some((declared) => declared === dimension)) {
-                        missingDimensions.push(`${kind.slice(0, -1)} '${name}' lacks ${dimension}`);
-                    }
-                }
-            }
-        }
-        if (missingDimensions.length > 0) {
-            throw new InvalidAguiClientConformanceError(`AG-UI client conformance omits required dimensions: ${missingDimensions.join(", ")}`);
-        }
-        return conformance;
+        return Validator.#assert(modelRouteSchema, "ModelRoute", value);
     }
-    static assertAguiConformanceKit(value) {
-        const result = Validator.validateAguiConformanceKit(value);
-        if (!Validator.#accepted(value, result)) {
-            throw new InvalidAguiConformanceKitError(`invalid AG-UI conformance kit: ${JSON.stringify(result.errors)}`);
-        }
-        const kit = value;
-        for (const specimens of [kit.transport, kit.lifecycles]) {
-            const names = specimens.map(({ name }) => name);
-            if (new Set(names).size !== names.length) {
-                throw new InvalidAguiConformanceKitError("AG-UI conformance specimen names must be unique within their family");
-            }
-        }
-        return kit;
-    }
-    static assertJsonSchemaInstance(label, schema, value) {
-        const result = Validator.validateJsonSchemaInstance(schema, value);
-        if (!result.valid) {
-            throw new InvalidJsonSchemaInstanceError(`${label} does not satisfy its JSON Schema: ${JSON.stringify(result.errors)}`);
-        }
-        return value;
-    }
-    static #validate(validator, value) {
-        const result = validator.validate(value);
-        return { valid: result.valid, errors: result.errors };
+    static assertAcpDiscovery(value) {
+        return Validator.#assert(acpDiscoverySchema, "ACP discovery manifest", value);
     }
 }
 //# sourceMappingURL=Validator.js.map