@openvtc/trust-tasks 0.8.2 → 0.10.0

package/dist/trust-task-control/0.1/payload.js

@@ -6,16 +6,247 @@
 export const TYPE_URI = "https://trusttasks.org/spec/trust-task-control/0.1";
 /** Trust Task response type URI (request type URI + "#response"). */
 export const RESPONSE_TYPE_URI = "https://trusttasks.org/spec/trust-task-control/0.1#response";
+/**
+ * This specification's payload schema, as a value.
+ *
+ * SPEC.md §7.2 item 2 is performed against this. It is shipped as data
+ * rather than only as a `.json` file because TypeScript types are erased
+ * at runtime: without a schema a consumer has nothing to validate, and
+ * every REQUIRED payload member is optional in practice. Cross-file
+ * `$ref`s are already inlined, so it needs no resolver.
+ */
+export const PAYLOAD_SCHEMA = {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://trusttasks.org/spec/trust-task-control/0.1",
+    "title": "Trust Task Control — payload",
+    "description": "The task-control request defined at SPEC.md §12: a producer withdrawing, pausing, or resuming work a consumer has already accepted.\n\nThis is a REQUEST, not a response. A consumer that stops work on its own initiative does not send one of these — it returns a trust-task-error carrying `cancelled`, so that a withdrawal and a refusal remain distinguishable to every party and to any auditor reading the retained documents afterwards.\n\nThe operation takes effect through SPEC.md §7.2 item 12: a valid, authorized control operation is one of the conditions a consumer re-evaluates immediately before each irreversible or externally visible effect. There is no separate race protocol.",
+    "type": "object",
+    "additionalProperties": false,
+    "required": [
+        "operation",
+        "target"
+    ],
+    "properties": {
+        "operation": {
+            "enum": [
+                "cancel",
+                "suspend",
+                "resume"
+            ],
+            "description": "The control operation requested.\n\n`cancel` stops the task permanently: it is terminal, and a cancelled task MUST NOT be resumed, retried, or cancelled again (SPEC.md §12.3). `suspend` halts further effects while preserving the consumer's current execution state — it does not undo work already performed. `resume` continues a suspended task from the state the consumer holds; a consumer MUST NOT resume after the target document's `expiresAt` (SPEC.md §12.5).\n\nThis is a discriminating field. A consumer that does not recognize a value MUST reject the document rather than apply a default — silently downgrading an unrecognized operation to a known one would let a producer's intent be replaced by the consumer's guess."
+        },
+        "target": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "id"
+            ],
+            "description": "The specific Trust Task document this operation applies to. Per SPEC.md §12.2, `threadId`, `parentThreadId` and ceremony membership MUST NOT identify the target on their own: more than one document can occur in a single exchange or enactment.",
+            "properties": {
+                "id": {
+                    "type": "string",
+                    "minLength": 1,
+                    "description": "The `id` of the target Trust Task document. The sole identifying member."
+                },
+                "typeUri": {
+                    "type": "string",
+                    "format": "uri",
+                    "minLength": 1,
+                    "description": "The target document's `type`, including any `#request` fragment. RECOMMENDED. A consumer that holds the named `id` under a different specification can then detect the mismatch rather than acting on a coincidence of identifiers."
+                }
+            }
+        },
+        "reason": {
+            "type": "string",
+            "description": "Human-readable explanation of why the operation was requested. Non-normative; intended for operator UI and audit records. A consumer MUST NOT condition its handling of the operation on this value."
+        },
+        "ext": {
+            "type": "object",
+            "description": "Vendor-namespaced extension data per SPEC.md §4.5.1. Every immediate child key MUST be a reverse-DNS prefix the producer controls."
+        }
+    },
+    "$defs": {
+        "Response": {
+            "$anchor": "response",
+            "title": "Trust Task Control — response payload",
+            "description": "What the consumer did. The `outcome` is the load-bearing member: it is what tells the producer whether a compensating action is required, since SPEC.md §12.4 declines to require rollback.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "operation",
+                "target",
+                "outcome"
+            ],
+            "properties": {
+                "operation": {
+                    "enum": [
+                        "cancel",
+                        "suspend",
+                        "resume"
+                    ],
+                    "description": "Echoed from the request, so the response is self-describing when retained apart from it."
+                },
+                "target": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": [
+                        "id"
+                    ],
+                    "description": "Echoed from the request.",
+                    "properties": {
+                        "id": {
+                            "type": "string",
+                            "minLength": 1
+                        },
+                        "typeUri": {
+                            "type": "string",
+                            "format": "uri",
+                            "minLength": 1
+                        }
+                    }
+                },
+                "outcome": {
+                    "enum": [
+                        "applied",
+                        "appliedWithEffects",
+                        "alreadyCompleted",
+                        "unknownTask"
+                    ],
+                    "description": "`applied` — the operation took effect and NO irreversible or externally visible effect had occurred. The only outcome that means the task left no trace.\n\n`appliedWithEffects` — the operation took effect, but effects had already occurred before it did. `effects` describes them. A consumer MUST NOT report `applied` in this case (SPEC.md §12.3).\n\n`alreadyCompleted` — the task finished before the control document was processed. Not a cancellation; whether to compensate is the producer's own decision.\n\n`unknownTask` — the consumer holds no record of the target `id`, either because it never received it or because its acceptance window has lapsed. A consumer that records the operation as a tombstone against a not-yet-arrived document reports `applied`, not this."
+                },
+                "effects": {
+                    "type": "array",
+                    "description": "What was created, changed, disclosed, or exercised before the operation took hold. A consumer MUST populate this where `outcome` is `appliedWithEffects` or `alreadyCompleted` — a producer cannot decide whether to compensate without it — and the specification's Conformance section carries that requirement normatively. It is not expressed as a conditional schema because the registry's Rust code generator does not support if/then/else. The framework does not constrain how a task describes its own effects.",
+                    "items": {
+                        "type": "object",
+                        "additionalProperties": false,
+                        "required": [
+                            "description"
+                        ],
+                        "properties": {
+                            "description": {
+                                "type": "string",
+                                "minLength": 1,
+                                "description": "Human-readable statement of the effect that occurred."
+                            },
+                            "ref": {
+                                "type": "string",
+                                "description": "An identifier for the effect where one exists — a credential id, a record identifier, a transaction reference — so a compensating task can name it."
+                            },
+                            "reversible": {
+                                "type": "boolean",
+                                "description": "Whether the consumer believes this effect can be compensated by a further Trust Task. Advisory. Absent means unknown, which a producer SHOULD treat as no weaker than `false`."
+                            }
+                        }
+                    }
+                },
+                "ext": {
+                    "type": "object",
+                    "description": "Vendor-namespaced extension data per SPEC.md §4.5.1."
+                }
+            }
+        }
+    }
+};
+/** As {@link PAYLOAD_SCHEMA}, for the success-response variant. */
+export const RESPONSE_PAYLOAD_SCHEMA = {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$ref": "#/$defs/Response",
+    "$defs": {
+        "Response": {
+            "$anchor": "response",
+            "title": "Trust Task Control — response payload",
+            "description": "What the consumer did. The `outcome` is the load-bearing member: it is what tells the producer whether a compensating action is required, since SPEC.md §12.4 declines to require rollback.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+                "operation",
+                "target",
+                "outcome"
+            ],
+            "properties": {
+                "operation": {
+                    "enum": [
+                        "cancel",
+                        "suspend",
+                        "resume"
+                    ],
+                    "description": "Echoed from the request, so the response is self-describing when retained apart from it."
+                },
+                "target": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": [
+                        "id"
+                    ],
+                    "description": "Echoed from the request.",
+                    "properties": {
+                        "id": {
+                            "type": "string",
+                            "minLength": 1
+                        },
+                        "typeUri": {
+                            "type": "string",
+                            "format": "uri",
+                            "minLength": 1
+                        }
+                    }
+                },
+                "outcome": {
+                    "enum": [
+                        "applied",
+                        "appliedWithEffects",
+                        "alreadyCompleted",
+                        "unknownTask"
+                    ],
+                    "description": "`applied` — the operation took effect and NO irreversible or externally visible effect had occurred. The only outcome that means the task left no trace.\n\n`appliedWithEffects` — the operation took effect, but effects had already occurred before it did. `effects` describes them. A consumer MUST NOT report `applied` in this case (SPEC.md §12.3).\n\n`alreadyCompleted` — the task finished before the control document was processed. Not a cancellation; whether to compensate is the producer's own decision.\n\n`unknownTask` — the consumer holds no record of the target `id`, either because it never received it or because its acceptance window has lapsed. A consumer that records the operation as a tombstone against a not-yet-arrived document reports `applied`, not this."
+                },
+                "effects": {
+                    "type": "array",
+                    "description": "What was created, changed, disclosed, or exercised before the operation took hold. A consumer MUST populate this where `outcome` is `appliedWithEffects` or `alreadyCompleted` — a producer cannot decide whether to compensate without it — and the specification's Conformance section carries that requirement normatively. It is not expressed as a conditional schema because the registry's Rust code generator does not support if/then/else. The framework does not constrain how a task describes its own effects.",
+                    "items": {
+                        "type": "object",
+                        "additionalProperties": false,
+                        "required": [
+                            "description"
+                        ],
+                        "properties": {
+                            "description": {
+                                "type": "string",
+                                "minLength": 1,
+                                "description": "Human-readable statement of the effect that occurred."
+                            },
+                            "ref": {
+                                "type": "string",
+                                "description": "An identifier for the effect where one exists — a credential id, a record identifier, a transaction reference — so a compensating task can name it."
+                            },
+                            "reversible": {
+                                "type": "boolean",
+                                "description": "Whether the consumer believes this effect can be compensated by a further Trust Task. Advisory. Absent means unknown, which a producer SHOULD treat as no weaker than `false`."
+                            }
+                        }
+                    }
+                },
+                "ext": {
+                    "type": "object",
+                    "description": "Vendor-namespaced extension data per SPEC.md §4.5.1."
+                }
+            }
+        }
+    }
+};
 /**
  * SPEC.md §7.2 policy for the request variant, from this specification's
  * front matter. Pass to `consumeInbound` — items 5b, 7 and 8 are
- * per-specification and cannot be derived from the document alone.
+ * per-specification and cannot be derived from the document alone, and
+ * item 2 needs the schema this carries.
  */
 export const SPEC = {
     typeUri: TYPE_URI,
     isBearer: false,
     isProofRequired: true,
     isRecipientRequired: true,
+    payloadSchema: PAYLOAD_SCHEMA,
 };
 /**
  * SPEC.md §7.2 policy for the success-response variant. `isRecipientRequired`
@@ -27,5 +258,6 @@ export const RESPONSE_SPEC = {
     isBearer: false,
     isProofRequired: true,
     isRecipientRequired: true,
+    payloadSchema: RESPONSE_PAYLOAD_SCHEMA,
 };
 //# sourceMappingURL=payload.js.map

package/dist/trust-task-control/0.1/payload.js.map

@@ -1 +1 @@
-{"version":3,"file":"payload.js","sourceRoot":"","sources":["../../../src/trust-task-control/0.1/payload.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAwFH,2BAA2B;AAC3B,MAAM,CAAC,MAAM,QAAQ,GAAG,oDAA6D,CAAC;AAKtF,qEAAqE;AACrE,MAAM,CAAC,MAAM,iBAAiB,GAAG,6DAAsE,CAAC;AAKxG;;;;GAIG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,KAAK;IACf,eAAe,EAAE,IAAI;IACrB,mBAAmB,EAAE,IAAI;CACjB,CAAC;AAEX;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,OAAO,EAAE,iBAAiB;IAC1B,QAAQ,EAAE,KAAK;IACf,eAAe,EAAE,IAAI;IACrB,mBAAmB,EAAE,IAAI;CACjB,CAAC"}
+{"version":3,"file":"payload.js","sourceRoot":"","sources":["../../../src/trust-task-control/0.1/payload.ts"],"names":[],"mappings":"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"}

package/dist/trust-task-discovery/0.1/payload.d.ts

@@ -43,16 +43,222 @@ export type Payload = TrustTaskDiscoveryPayload;
 export declare const RESPONSE_TYPE_URI: "https://trusttasks.org/spec/trust-task-discovery/0.1#response";
 /** Stable alias for this specification's success-response payload shape. */
 export type Response = TrustTaskDiscoveryResponsePayload;
+/**
+ * This specification's payload schema, as a value.
+ *
+ * SPEC.md §7.2 item 2 is performed against this. It is shipped as data
+ * rather than only as a `.json` file because TypeScript types are erased
+ * at runtime: without a schema a consumer has nothing to validate, and
+ * every REQUIRED payload member is optional in practice. Cross-file
+ * `$ref`s are already inlined, so it needs no resolver.
+ */
+export declare const PAYLOAD_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://trusttasks.org/spec/trust-task-discovery/0.1";
+    readonly title: "Trust Task Discovery — payload";
+    readonly description: "Request payload for the framework-defined trust-task-discovery exchange. Carries zero or more slug-glob patterns the discoverer wants the responder to filter against. The response payload schema is reachable via $anchor: 'response'.";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly patterns: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly description: "Slug-glob pattern. Matches: '*' (every slug); '<prefix>/*' (any slug starting with '<prefix>/' — e.g. 'acl/*' matches 'acl/grant', 'acl/revoke', 'acl/grant/sub'); otherwise an exact slug match. Wildcards anywhere other than as a trailing segment are not interpreted — the only sigils are the trailing '/*' and the bare '*'.";
+            };
+            readonly description: "Patterns are ORed: a slug matches the query if at least one pattern matches it. If the array is omitted or empty, the responder MUST treat the query as ['*'] — return every supported task.";
+        };
+    };
+    readonly $defs: {
+        readonly Response: {
+            readonly $anchor: "response";
+            readonly title: "Trust Task Discovery — response payload";
+            readonly description: "List of bare Type URIs the responding party supports. Carried in a Trust Task document whose type is https://trusttasks.org/spec/trust-task-discovery/0.1#response.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["supportedTypes"];
+            readonly properties: {
+                readonly supportedTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly oneOf: readonly [{
+                            readonly type: "string";
+                            readonly format: "uri";
+                            readonly description: "Shorthand form: a bare Type URI string. Equivalent to an object with only the `type` member set.";
+                        }, {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["type"];
+                            readonly properties: {
+                                readonly type: {
+                                    readonly type: "string";
+                                    readonly format: "uri";
+                                    readonly description: "A bare Type URI (no #request or #response fragment). The responder supports both request and response variants of every entry it lists.";
+                                };
+                                readonly requiredExt: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+                                    };
+                                    readonly minItems: 1;
+                                    readonly uniqueItems: true;
+                                    readonly description: "Reverse-DNS `ext` namespaces this responder requires on inbound documents of this Type URI as a matter of local policy (SPEC.md §4.5.1, §7.2). A producer that does not populate every listed namespace will receive a `malformed_request` rejection. Optional; reserved-but-recognized in 0.1, RECOMMENDED in future revisions for responders that enforce such policies.";
+                                };
+                            };
+                            readonly description: "Object form: lists a Type URI together with optional capability annotations.";
+                        }];
+                        readonly description: "An entry in the supportedTypes list. SHORTHAND: a bare Type URI string. EXPANDED: an object with `type` and optional capability annotations (`requiredExt`).";
+                    };
+                    readonly description: "Each entry's Type URI MUST match at least one of the request's patterns (if any were supplied). Order is not significant. Duplicates by Type URI are not permitted, regardless of whether the entry is in shorthand or expanded form.";
+                };
+                readonly frameworkVersion: {
+                    readonly type: "string";
+                    readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$";
+                    readonly description: "MAJOR.MINOR version of the Trust Tasks framework specification (SPEC.md) the responder targets. Lets a discoverer at framework version X reason about forward-minor compatibility (SPEC.md §5.2). Optional in 0.1; RECOMMENDED in future revisions.";
+                };
+            };
+        };
+    };
+};
+/** As {@link PAYLOAD_SCHEMA}, for the success-response variant. */
+export declare const RESPONSE_PAYLOAD_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $ref: "#/$defs/Response";
+    readonly $defs: {
+        readonly Response: {
+            readonly $anchor: "response";
+            readonly title: "Trust Task Discovery — response payload";
+            readonly description: "List of bare Type URIs the responding party supports. Carried in a Trust Task document whose type is https://trusttasks.org/spec/trust-task-discovery/0.1#response.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["supportedTypes"];
+            readonly properties: {
+                readonly supportedTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly oneOf: readonly [{
+                            readonly type: "string";
+                            readonly format: "uri";
+                            readonly description: "Shorthand form: a bare Type URI string. Equivalent to an object with only the `type` member set.";
+                        }, {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["type"];
+                            readonly properties: {
+                                readonly type: {
+                                    readonly type: "string";
+                                    readonly format: "uri";
+                                    readonly description: "A bare Type URI (no #request or #response fragment). The responder supports both request and response variants of every entry it lists.";
+                                };
+                                readonly requiredExt: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+                                    };
+                                    readonly minItems: 1;
+                                    readonly uniqueItems: true;
+                                    readonly description: "Reverse-DNS `ext` namespaces this responder requires on inbound documents of this Type URI as a matter of local policy (SPEC.md §4.5.1, §7.2). A producer that does not populate every listed namespace will receive a `malformed_request` rejection. Optional; reserved-but-recognized in 0.1, RECOMMENDED in future revisions for responders that enforce such policies.";
+                                };
+                            };
+                            readonly description: "Object form: lists a Type URI together with optional capability annotations.";
+                        }];
+                        readonly description: "An entry in the supportedTypes list. SHORTHAND: a bare Type URI string. EXPANDED: an object with `type` and optional capability annotations (`requiredExt`).";
+                    };
+                    readonly description: "Each entry's Type URI MUST match at least one of the request's patterns (if any were supplied). Order is not significant. Duplicates by Type URI are not permitted, regardless of whether the entry is in shorthand or expanded form.";
+                };
+                readonly frameworkVersion: {
+                    readonly type: "string";
+                    readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$";
+                    readonly description: "MAJOR.MINOR version of the Trust Tasks framework specification (SPEC.md) the responder targets. Lets a discoverer at framework version X reason about forward-minor compatibility (SPEC.md §5.2). Optional in 0.1; RECOMMENDED in future revisions.";
+                };
+            };
+        };
+    };
+};
 /**
  * SPEC.md §7.2 policy for the request variant, from this specification's
  * front matter. Pass to `consumeInbound` — items 5b, 7 and 8 are
- * per-specification and cannot be derived from the document alone.
+ * per-specification and cannot be derived from the document alone, and
+ * item 2 needs the schema this carries.
  */
 export declare const SPEC: {
     readonly typeUri: "https://trusttasks.org/spec/trust-task-discovery/0.1";
     readonly isBearer: false;
     readonly isProofRequired: false;
     readonly isRecipientRequired: true;
+    readonly payloadSchema: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $id: "https://trusttasks.org/spec/trust-task-discovery/0.1";
+        readonly title: "Trust Task Discovery — payload";
+        readonly description: "Request payload for the framework-defined trust-task-discovery exchange. Carries zero or more slug-glob patterns the discoverer wants the responder to filter against. The response payload schema is reachable via $anchor: 'response'.";
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly patterns: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "Slug-glob pattern. Matches: '*' (every slug); '<prefix>/*' (any slug starting with '<prefix>/' — e.g. 'acl/*' matches 'acl/grant', 'acl/revoke', 'acl/grant/sub'); otherwise an exact slug match. Wildcards anywhere other than as a trailing segment are not interpreted — the only sigils are the trailing '/*' and the bare '*'.";
+                };
+                readonly description: "Patterns are ORed: a slug matches the query if at least one pattern matches it. If the array is omitted or empty, the responder MUST treat the query as ['*'] — return every supported task.";
+            };
+        };
+        readonly $defs: {
+            readonly Response: {
+                readonly $anchor: "response";
+                readonly title: "Trust Task Discovery — response payload";
+                readonly description: "List of bare Type URIs the responding party supports. Carried in a Trust Task document whose type is https://trusttasks.org/spec/trust-task-discovery/0.1#response.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["supportedTypes"];
+                readonly properties: {
+                    readonly supportedTypes: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly oneOf: readonly [{
+                                readonly type: "string";
+                                readonly format: "uri";
+                                readonly description: "Shorthand form: a bare Type URI string. Equivalent to an object with only the `type` member set.";
+                            }, {
+                                readonly type: "object";
+                                readonly additionalProperties: false;
+                                readonly required: readonly ["type"];
+                                readonly properties: {
+                                    readonly type: {
+                                        readonly type: "string";
+                                        readonly format: "uri";
+                                        readonly description: "A bare Type URI (no #request or #response fragment). The responder supports both request and response variants of every entry it lists.";
+                                    };
+                                    readonly requiredExt: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+                                        };
+                                        readonly minItems: 1;
+                                        readonly uniqueItems: true;
+                                        readonly description: "Reverse-DNS `ext` namespaces this responder requires on inbound documents of this Type URI as a matter of local policy (SPEC.md §4.5.1, §7.2). A producer that does not populate every listed namespace will receive a `malformed_request` rejection. Optional; reserved-but-recognized in 0.1, RECOMMENDED in future revisions for responders that enforce such policies.";
+                                    };
+                                };
+                                readonly description: "Object form: lists a Type URI together with optional capability annotations.";
+                            }];
+                            readonly description: "An entry in the supportedTypes list. SHORTHAND: a bare Type URI string. EXPANDED: an object with `type` and optional capability annotations (`requiredExt`).";
+                        };
+                        readonly description: "Each entry's Type URI MUST match at least one of the request's patterns (if any were supplied). Order is not significant. Duplicates by Type URI are not permitted, regardless of whether the entry is in shorthand or expanded form.";
+                    };
+                    readonly frameworkVersion: {
+                        readonly type: "string";
+                        readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$";
+                        readonly description: "MAJOR.MINOR version of the Trust Tasks framework specification (SPEC.md) the responder targets. Lets a discoverer at framework version X reason about forward-minor compatibility (SPEC.md §5.2). Optional in 0.1; RECOMMENDED in future revisions.";
+                    };
+                };
+            };
+        };
+    };
 };
 /**
  * SPEC.md §7.2 policy for the success-response variant. `isRecipientRequired`
@@ -64,5 +270,60 @@ export declare const RESPONSE_SPEC: {
     readonly isBearer: false;
     readonly isProofRequired: false;
     readonly isRecipientRequired: true;
+    readonly payloadSchema: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $ref: "#/$defs/Response";
+        readonly $defs: {
+            readonly Response: {
+                readonly $anchor: "response";
+                readonly title: "Trust Task Discovery — response payload";
+                readonly description: "List of bare Type URIs the responding party supports. Carried in a Trust Task document whose type is https://trusttasks.org/spec/trust-task-discovery/0.1#response.";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["supportedTypes"];
+                readonly properties: {
+                    readonly supportedTypes: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly oneOf: readonly [{
+                                readonly type: "string";
+                                readonly format: "uri";
+                                readonly description: "Shorthand form: a bare Type URI string. Equivalent to an object with only the `type` member set.";
+                            }, {
+                                readonly type: "object";
+                                readonly additionalProperties: false;
+                                readonly required: readonly ["type"];
+                                readonly properties: {
+                                    readonly type: {
+                                        readonly type: "string";
+                                        readonly format: "uri";
+                                        readonly description: "A bare Type URI (no #request or #response fragment). The responder supports both request and response variants of every entry it lists.";
+                                    };
+                                    readonly requiredExt: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                            readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
+                                        };
+                                        readonly minItems: 1;
+                                        readonly uniqueItems: true;
+                                        readonly description: "Reverse-DNS `ext` namespaces this responder requires on inbound documents of this Type URI as a matter of local policy (SPEC.md §4.5.1, §7.2). A producer that does not populate every listed namespace will receive a `malformed_request` rejection. Optional; reserved-but-recognized in 0.1, RECOMMENDED in future revisions for responders that enforce such policies.";
+                                    };
+                                };
+                                readonly description: "Object form: lists a Type URI together with optional capability annotations.";
+                            }];
+                            readonly description: "An entry in the supportedTypes list. SHORTHAND: a bare Type URI string. EXPANDED: an object with `type` and optional capability annotations (`requiredExt`).";
+                        };
+                        readonly description: "Each entry's Type URI MUST match at least one of the request's patterns (if any were supplied). Order is not significant. Duplicates by Type URI are not permitted, regardless of whether the entry is in shorthand or expanded form.";
+                    };
+                    readonly frameworkVersion: {
+                        readonly type: "string";
+                        readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$";
+                        readonly description: "MAJOR.MINOR version of the Trust Tasks framework specification (SPEC.md) the responder targets. Lets a discoverer at framework version X reason about forward-minor compatibility (SPEC.md §5.2). Optional in 0.1; RECOMMENDED in future revisions.";
+                    };
+                };
+            };
+        };
+    };
 };
 //# sourceMappingURL=payload.d.ts.map

package/dist/trust-task-discovery/0.1/payload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/trust-task-discovery/0.1/payload.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AACD;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAChD;;OAEG;IACH,cAAc,EAAE,CACZ,MAAM,GACN;QACE;;WAEG;QACH,IAAI,EAAE,MAAM,CAAC;QACb;;;;WAIG;QACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;KACrC,CACJ,EAAE,CAAC;IACJ;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,2BAA2B;AAC3B,eAAO,MAAM,QAAQ,EAAG,sDAA+D,CAAC;AAExF,mEAAmE;AACnE,MAAM,MAAM,OAAO,GAAG,yBAAyB,CAAC;AAEhD,qEAAqE;AACrE,eAAO,MAAM,iBAAiB,EAAG,+DAAwE,CAAC;AAE1G,4EAA4E;AAC5E,MAAM,MAAM,QAAQ,GAAG,iCAAiC,CAAC;AAEzD;;;;GAIG;AACH,eAAO,MAAM,IAAI;;;;;CAKP,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;CAKhB,CAAC"}
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/trust-task-discovery/0.1/payload.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AACD;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAChD;;OAEG;IACH,cAAc,EAAE,CACZ,MAAM,GACN;QACE;;WAEG;QACH,IAAI,EAAE,MAAM,CAAC;QACb;;;;WAIG;QACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;KACrC,CACJ,EAAE,CAAC;IACJ;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,2BAA2B;AAC3B,eAAO,MAAM,QAAQ,EAAG,sDAA+D,CAAC;AAExF,mEAAmE;AACnE,MAAM,MAAM,OAAO,GAAG,yBAAyB,CAAC;AAEhD,qEAAqE;AACrE,eAAO,MAAM,iBAAiB,EAAG,+DAAwE,CAAC;AAE1G,4EAA4E;AAC5E,MAAM,MAAM,QAAQ,GAAG,iCAAiC,CAAC;AAEzD;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EjB,CAAC;AAEX,mEAAmE;AACnE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6D1B,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMP,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMhB,CAAC"}