@openvtc/trust-tasks 0.16.10 → 0.17.0

package/dist/persona/profile/get/1.0/payload.d.ts

@@ -2,7 +2,7 @@
  * Generated by scripts/build-ts-bindings.mjs — DO NOT EDIT BY HAND.
  * Source: specs/persona/profile/get/1.0/payload.schema.json
  */
-import type { Attribute, ClaimType, Ext, Profile, ProfileEntry, ProofRung, Provenance, Ulid, ValueType, Version_PersonaV0_1 as Version } from "../../../../_shared/components.js";
+import type { ClaimType, Ext, Profile, ProfileEntry, ProofRung, Provenance, ResolvedClaim, Ulid, ValueType, Version_PersonaV0_1 as Version } from "../../../../_shared/components.js";
 /**
  * Read one profile, either as composed (the entries the holder wrote) or as resolved (the claims it would actually present).
  */
@@ -22,13 +22,15 @@ export interface PersonaProfileGetResponsePayload {
     /**
      * Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable.
      *
+     * Typed as `ResolvedClaim` rather than `Attribute`: a profile is a projection and may contain `inline` values, which have no pool record and therefore no `attributeId`, `version` or `updatedAt`. The pool record's shape requires all three, so it cannot describe such an entry at all.
+     *
      * @maxItems 256
      */
-    resolved?: Attribute[];
+    resolved?: ResolvedClaim[];
     ext?: Ext;
 }
 /** Shared definitions this specification references, re-exported under the names it used to declare them with. */
-export type { Attribute, ClaimType, Ext, Profile, ProfileEntry, ProofRung, Provenance, Ulid, ValueType, Version };
+export type { ClaimType, Ext, Profile, ProfileEntry, ProofRung, Provenance, ResolvedClaim, Ulid, ValueType, Version };
 /** Trust Task type URI. */
 export declare const TYPE_URI: "https://trusttasks.org/spec/persona/profile/get/1.0";
 /** Stable alias for this specification's request payload shape. */
@@ -83,9 +85,9 @@ export declare const PAYLOAD_SCHEMA: {
                     readonly type: "array";
                     readonly maxItems: 256;
                     readonly items: {
-                        readonly $ref: "#/$defs/Attribute";
+                        readonly $ref: "#/$defs/ResolvedClaim";
                     };
-                    readonly description: "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable.";
+                    readonly description: "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable.\n\nTyped as `ResolvedClaim` rather than `Attribute`: a profile is a projection and may contain `inline` values, which have no pool record and therefore no `attributeId`, `version` or `updatedAt`. The pool record's shape requires all three, so it cannot describe such an entry at all.";
                 };
                 readonly ext: {
                     readonly $ref: "#/$defs/Ext";
@@ -102,15 +104,16 @@ export declare const PAYLOAD_SCHEMA: {
                 readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
             };
         };
-        readonly Attribute: {
-            readonly title: "Attribute";
-            readonly description: "One atomic fact a holder keeps about themselves. Several attributes MAY share a `type` — three phone numbers, a legal name and a preferred name — which is why `attributeId` is the identity of a fact and `type` is not. The pool is flat and unordered; ordering is a profile's concern.";
+        readonly ResolvedClaim: {
+            readonly title: "ResolvedClaim";
+            readonly description: "One line of a profile AFTER resolution: what the profile would present at this entry, rather than how the entry is written.\n\nDistinct from `Attribute` because a profile is a PROJECTION and may contain values that have no pool record behind them. An `inline` entry is a value the holder keeps in one profile and nowhere else — it has no `attributeId`, no `version` and no `updatedAt`, because there is no pool attribute to have them. Describing a resolved profile with the pool record's shape therefore cannot represent one at all, which leaves a maintainer choosing between synthesising an `attributeId` — a false claim about where a value lives — and omitting the entry, which returns a profile that appears to present less than it does. Neither is acceptable, so the projection gets its own shape.\n\nThe three pool members are consequently OPTIONAL and their absence is meaningful: it says this value is inline. Their PRESENCE is equally informative — `version` alongside a pinned entry is what lets a holder see that a profile is frozen at v3 while the pool has moved on.";
             readonly type: "object";
             readonly additionalProperties: false;
-            readonly required: readonly ["attributeId", "type", "valueType", "value", "provenance", "version", "updatedAt"];
+            readonly required: readonly ["type", "valueType", "provenance"];
             readonly properties: {
                 readonly attributeId: {
                     readonly $ref: "#/$defs/Ulid";
+                    readonly description: "The pool attribute this entry resolves against. ABSENT for an `inline` entry, which is the whole distinction this member draws.";
                 };
                 readonly type: {
                     readonly $ref: "#/$defs/ClaimType";
@@ -119,35 +122,33 @@ export declare const PAYLOAD_SCHEMA: {
                     readonly $ref: "#/$defs/ValueType";
                 };
                 readonly value: {
-                    readonly description: "The fact itself, agreeing with `valueType`. Encrypted at rest by the maintainer. Absent when the caller asked for a metadata-only view, and absent when a credential-backed value could not be re-derived — a consumer MUST NOT conflate the two and MUST read `stale` to tell them apart.";
+                    readonly description: "What this entry would present, with any override applied. Absent when `stale`, because a claim that could not be re-derived MUST NOT be disclosed and MUST NOT be shown as though it would be.";
                 };
                 readonly label: {
                     readonly type: "string";
                     readonly maxLength: 128;
-                    readonly description: "The holder's own words for this attribute, shown in a picker. Never disclosed to a verifier; it is a note to self.";
+                    readonly description: "The holder's own words, from the override where one is given and from the pool attribute otherwise. Never disclosed to a verifier.";
                 };
                 readonly provenance: {
                     readonly $ref: "#/$defs/Provenance";
                 };
                 readonly stale: {
                     readonly type: "boolean";
-                    readonly description: "Present and true when a `credentialBacked` value could not be re-derived. `staleReason` says why. A maintainer MUST refuse to disclose a stale attribute.";
+                    readonly description: "Present and true when this entry cannot be presented — a credential-backed value that could not be re-derived, or a pin naming a version the maintainer no longer holds. Surfaced rather than omitted so a holder learns why a disclosure would be short.";
                 };
                 readonly staleReason: {
                     readonly type: "string";
                     readonly enum: readonly ["revoked", "expired", "archived", "deleted", "notFound"];
-                    readonly description: "Why re-derivation failed. Present only alongside `stale`.";
+                    readonly description: "Why the entry cannot be presented. Present only alongside `stale`.";
                 };
                 readonly version: {
                     readonly $ref: "#/$defs/Version";
-                };
-                readonly createdAt: {
-                    readonly type: "string";
-                    readonly format: "date-time";
+                    readonly description: "The pool attribute's version this entry resolved to — the pinned one for a pinned entry, the current one otherwise. ABSENT for an `inline` entry.";
                 };
                 readonly updatedAt: {
                     readonly type: "string";
                     readonly format: "date-time";
+                    readonly description: "When the pool attribute behind this entry was last written. ABSENT for an `inline` entry.";
                 };
             };
         };
@@ -383,9 +384,9 @@ export declare const RESPONSE_PAYLOAD_SCHEMA: {
                     readonly type: "array";
                     readonly maxItems: 256;
                     readonly items: {
-                        readonly $ref: "#/$defs/Attribute";
+                        readonly $ref: "#/$defs/ResolvedClaim";
                     };
-                    readonly description: "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable.";
+                    readonly description: "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable.\n\nTyped as `ResolvedClaim` rather than `Attribute`: a profile is a projection and may contain `inline` values, which have no pool record and therefore no `attributeId`, `version` or `updatedAt`. The pool record's shape requires all three, so it cannot describe such an entry at all.";
                 };
                 readonly ext: {
                     readonly $ref: "#/$defs/Ext";
@@ -402,15 +403,16 @@ export declare const RESPONSE_PAYLOAD_SCHEMA: {
                 readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
             };
         };
-        readonly Attribute: {
-            readonly title: "Attribute";
-            readonly description: "One atomic fact a holder keeps about themselves. Several attributes MAY share a `type` — three phone numbers, a legal name and a preferred name — which is why `attributeId` is the identity of a fact and `type` is not. The pool is flat and unordered; ordering is a profile's concern.";
+        readonly ResolvedClaim: {
+            readonly title: "ResolvedClaim";
+            readonly description: "One line of a profile AFTER resolution: what the profile would present at this entry, rather than how the entry is written.\n\nDistinct from `Attribute` because a profile is a PROJECTION and may contain values that have no pool record behind them. An `inline` entry is a value the holder keeps in one profile and nowhere else — it has no `attributeId`, no `version` and no `updatedAt`, because there is no pool attribute to have them. Describing a resolved profile with the pool record's shape therefore cannot represent one at all, which leaves a maintainer choosing between synthesising an `attributeId` — a false claim about where a value lives — and omitting the entry, which returns a profile that appears to present less than it does. Neither is acceptable, so the projection gets its own shape.\n\nThe three pool members are consequently OPTIONAL and their absence is meaningful: it says this value is inline. Their PRESENCE is equally informative — `version` alongside a pinned entry is what lets a holder see that a profile is frozen at v3 while the pool has moved on.";
             readonly type: "object";
             readonly additionalProperties: false;
-            readonly required: readonly ["attributeId", "type", "valueType", "value", "provenance", "version", "updatedAt"];
+            readonly required: readonly ["type", "valueType", "provenance"];
             readonly properties: {
                 readonly attributeId: {
                     readonly $ref: "#/$defs/Ulid";
+                    readonly description: "The pool attribute this entry resolves against. ABSENT for an `inline` entry, which is the whole distinction this member draws.";
                 };
                 readonly type: {
                     readonly $ref: "#/$defs/ClaimType";
@@ -419,35 +421,33 @@ export declare const RESPONSE_PAYLOAD_SCHEMA: {
                     readonly $ref: "#/$defs/ValueType";
                 };
                 readonly value: {
-                    readonly description: "The fact itself, agreeing with `valueType`. Encrypted at rest by the maintainer. Absent when the caller asked for a metadata-only view, and absent when a credential-backed value could not be re-derived — a consumer MUST NOT conflate the two and MUST read `stale` to tell them apart.";
+                    readonly description: "What this entry would present, with any override applied. Absent when `stale`, because a claim that could not be re-derived MUST NOT be disclosed and MUST NOT be shown as though it would be.";
                 };
                 readonly label: {
                     readonly type: "string";
                     readonly maxLength: 128;
-                    readonly description: "The holder's own words for this attribute, shown in a picker. Never disclosed to a verifier; it is a note to self.";
+                    readonly description: "The holder's own words, from the override where one is given and from the pool attribute otherwise. Never disclosed to a verifier.";
                 };
                 readonly provenance: {
                     readonly $ref: "#/$defs/Provenance";
                 };
                 readonly stale: {
                     readonly type: "boolean";
-                    readonly description: "Present and true when a `credentialBacked` value could not be re-derived. `staleReason` says why. A maintainer MUST refuse to disclose a stale attribute.";
+                    readonly description: "Present and true when this entry cannot be presented — a credential-backed value that could not be re-derived, or a pin naming a version the maintainer no longer holds. Surfaced rather than omitted so a holder learns why a disclosure would be short.";
                 };
                 readonly staleReason: {
                     readonly type: "string";
                     readonly enum: readonly ["revoked", "expired", "archived", "deleted", "notFound"];
-                    readonly description: "Why re-derivation failed. Present only alongside `stale`.";
+                    readonly description: "Why the entry cannot be presented. Present only alongside `stale`.";
                 };
                 readonly version: {
                     readonly $ref: "#/$defs/Version";
-                };
-                readonly createdAt: {
-                    readonly type: "string";
-                    readonly format: "date-time";
+                    readonly description: "The pool attribute's version this entry resolved to — the pinned one for a pinned entry, the current one otherwise. ABSENT for an `inline` entry.";
                 };
                 readonly updatedAt: {
                     readonly type: "string";
                     readonly format: "date-time";
+                    readonly description: "When the pool attribute behind this entry was last written. ABSENT for an `inline` entry.";
                 };
             };
         };
@@ -712,9 +712,9 @@ export declare const SPEC: {
                         readonly type: "array";
                         readonly maxItems: 256;
                         readonly items: {
-                            readonly $ref: "#/$defs/Attribute";
+                            readonly $ref: "#/$defs/ResolvedClaim";
                         };
-                        readonly description: "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable.";
+                        readonly description: "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable.\n\nTyped as `ResolvedClaim` rather than `Attribute`: a profile is a projection and may contain `inline` values, which have no pool record and therefore no `attributeId`, `version` or `updatedAt`. The pool record's shape requires all three, so it cannot describe such an entry at all.";
                     };
                     readonly ext: {
                         readonly $ref: "#/$defs/Ext";
@@ -731,15 +731,16 @@ export declare const SPEC: {
                     readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
                 };
             };
-            readonly Attribute: {
-                readonly title: "Attribute";
-                readonly description: "One atomic fact a holder keeps about themselves. Several attributes MAY share a `type` — three phone numbers, a legal name and a preferred name — which is why `attributeId` is the identity of a fact and `type` is not. The pool is flat and unordered; ordering is a profile's concern.";
+            readonly ResolvedClaim: {
+                readonly title: "ResolvedClaim";
+                readonly description: "One line of a profile AFTER resolution: what the profile would present at this entry, rather than how the entry is written.\n\nDistinct from `Attribute` because a profile is a PROJECTION and may contain values that have no pool record behind them. An `inline` entry is a value the holder keeps in one profile and nowhere else — it has no `attributeId`, no `version` and no `updatedAt`, because there is no pool attribute to have them. Describing a resolved profile with the pool record's shape therefore cannot represent one at all, which leaves a maintainer choosing between synthesising an `attributeId` — a false claim about where a value lives — and omitting the entry, which returns a profile that appears to present less than it does. Neither is acceptable, so the projection gets its own shape.\n\nThe three pool members are consequently OPTIONAL and their absence is meaningful: it says this value is inline. Their PRESENCE is equally informative — `version` alongside a pinned entry is what lets a holder see that a profile is frozen at v3 while the pool has moved on.";
                 readonly type: "object";
                 readonly additionalProperties: false;
-                readonly required: readonly ["attributeId", "type", "valueType", "value", "provenance", "version", "updatedAt"];
+                readonly required: readonly ["type", "valueType", "provenance"];
                 readonly properties: {
                     readonly attributeId: {
                         readonly $ref: "#/$defs/Ulid";
+                        readonly description: "The pool attribute this entry resolves against. ABSENT for an `inline` entry, which is the whole distinction this member draws.";
                     };
                     readonly type: {
                         readonly $ref: "#/$defs/ClaimType";
@@ -748,35 +749,33 @@ export declare const SPEC: {
                         readonly $ref: "#/$defs/ValueType";
                     };
                     readonly value: {
-                        readonly description: "The fact itself, agreeing with `valueType`. Encrypted at rest by the maintainer. Absent when the caller asked for a metadata-only view, and absent when a credential-backed value could not be re-derived — a consumer MUST NOT conflate the two and MUST read `stale` to tell them apart.";
+                        readonly description: "What this entry would present, with any override applied. Absent when `stale`, because a claim that could not be re-derived MUST NOT be disclosed and MUST NOT be shown as though it would be.";
                     };
                     readonly label: {
                         readonly type: "string";
                         readonly maxLength: 128;
-                        readonly description: "The holder's own words for this attribute, shown in a picker. Never disclosed to a verifier; it is a note to self.";
+                        readonly description: "The holder's own words, from the override where one is given and from the pool attribute otherwise. Never disclosed to a verifier.";
                     };
                     readonly provenance: {
                         readonly $ref: "#/$defs/Provenance";
                     };
                     readonly stale: {
                         readonly type: "boolean";
-                        readonly description: "Present and true when a `credentialBacked` value could not be re-derived. `staleReason` says why. A maintainer MUST refuse to disclose a stale attribute.";
+                        readonly description: "Present and true when this entry cannot be presented — a credential-backed value that could not be re-derived, or a pin naming a version the maintainer no longer holds. Surfaced rather than omitted so a holder learns why a disclosure would be short.";
                     };
                     readonly staleReason: {
                         readonly type: "string";
                         readonly enum: readonly ["revoked", "expired", "archived", "deleted", "notFound"];
-                        readonly description: "Why re-derivation failed. Present only alongside `stale`.";
+                        readonly description: "Why the entry cannot be presented. Present only alongside `stale`.";
                     };
                     readonly version: {
                         readonly $ref: "#/$defs/Version";
-                    };
-                    readonly createdAt: {
-                        readonly type: "string";
-                        readonly format: "date-time";
+                        readonly description: "The pool attribute's version this entry resolved to — the pinned one for a pinned entry, the current one otherwise. ABSENT for an `inline` entry.";
                     };
                     readonly updatedAt: {
                         readonly type: "string";
                         readonly format: "date-time";
+                        readonly description: "When the pool attribute behind this entry was last written. ABSENT for an `inline` entry.";
                     };
                 };
             };
@@ -1023,9 +1022,9 @@ export declare const RESPONSE_SPEC: {
                         readonly type: "array";
                         readonly maxItems: 256;
                         readonly items: {
-                            readonly $ref: "#/$defs/Attribute";
+                            readonly $ref: "#/$defs/ResolvedClaim";
                         };
-                        readonly description: "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable.";
+                        readonly description: "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable.\n\nTyped as `ResolvedClaim` rather than `Attribute`: a profile is a projection and may contain `inline` values, which have no pool record and therefore no `attributeId`, `version` or `updatedAt`. The pool record's shape requires all three, so it cannot describe such an entry at all.";
                     };
                     readonly ext: {
                         readonly $ref: "#/$defs/Ext";
@@ -1042,15 +1041,16 @@ export declare const RESPONSE_SPEC: {
                     readonly pattern: "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$";
                 };
             };
-            readonly Attribute: {
-                readonly title: "Attribute";
-                readonly description: "One atomic fact a holder keeps about themselves. Several attributes MAY share a `type` — three phone numbers, a legal name and a preferred name — which is why `attributeId` is the identity of a fact and `type` is not. The pool is flat and unordered; ordering is a profile's concern.";
+            readonly ResolvedClaim: {
+                readonly title: "ResolvedClaim";
+                readonly description: "One line of a profile AFTER resolution: what the profile would present at this entry, rather than how the entry is written.\n\nDistinct from `Attribute` because a profile is a PROJECTION and may contain values that have no pool record behind them. An `inline` entry is a value the holder keeps in one profile and nowhere else — it has no `attributeId`, no `version` and no `updatedAt`, because there is no pool attribute to have them. Describing a resolved profile with the pool record's shape therefore cannot represent one at all, which leaves a maintainer choosing between synthesising an `attributeId` — a false claim about where a value lives — and omitting the entry, which returns a profile that appears to present less than it does. Neither is acceptable, so the projection gets its own shape.\n\nThe three pool members are consequently OPTIONAL and their absence is meaningful: it says this value is inline. Their PRESENCE is equally informative — `version` alongside a pinned entry is what lets a holder see that a profile is frozen at v3 while the pool has moved on.";
                 readonly type: "object";
                 readonly additionalProperties: false;
-                readonly required: readonly ["attributeId", "type", "valueType", "value", "provenance", "version", "updatedAt"];
+                readonly required: readonly ["type", "valueType", "provenance"];
                 readonly properties: {
                     readonly attributeId: {
                         readonly $ref: "#/$defs/Ulid";
+                        readonly description: "The pool attribute this entry resolves against. ABSENT for an `inline` entry, which is the whole distinction this member draws.";
                     };
                     readonly type: {
                         readonly $ref: "#/$defs/ClaimType";
@@ -1059,35 +1059,33 @@ export declare const RESPONSE_SPEC: {
                         readonly $ref: "#/$defs/ValueType";
                     };
                     readonly value: {
-                        readonly description: "The fact itself, agreeing with `valueType`. Encrypted at rest by the maintainer. Absent when the caller asked for a metadata-only view, and absent when a credential-backed value could not be re-derived — a consumer MUST NOT conflate the two and MUST read `stale` to tell them apart.";
+                        readonly description: "What this entry would present, with any override applied. Absent when `stale`, because a claim that could not be re-derived MUST NOT be disclosed and MUST NOT be shown as though it would be.";
                     };
                     readonly label: {
                         readonly type: "string";
                         readonly maxLength: 128;
-                        readonly description: "The holder's own words for this attribute, shown in a picker. Never disclosed to a verifier; it is a note to self.";
+                        readonly description: "The holder's own words, from the override where one is given and from the pool attribute otherwise. Never disclosed to a verifier.";
                     };
                     readonly provenance: {
                         readonly $ref: "#/$defs/Provenance";
                     };
                     readonly stale: {
                         readonly type: "boolean";
-                        readonly description: "Present and true when a `credentialBacked` value could not be re-derived. `staleReason` says why. A maintainer MUST refuse to disclose a stale attribute.";
+                        readonly description: "Present and true when this entry cannot be presented — a credential-backed value that could not be re-derived, or a pin naming a version the maintainer no longer holds. Surfaced rather than omitted so a holder learns why a disclosure would be short.";
                     };
                     readonly staleReason: {
                         readonly type: "string";
                         readonly enum: readonly ["revoked", "expired", "archived", "deleted", "notFound"];
-                        readonly description: "Why re-derivation failed. Present only alongside `stale`.";
+                        readonly description: "Why the entry cannot be presented. Present only alongside `stale`.";
                     };
                     readonly version: {
                         readonly $ref: "#/$defs/Version";
-                    };
-                    readonly createdAt: {
-                        readonly type: "string";
-                        readonly format: "date-time";
+                        readonly description: "The pool attribute's version this entry resolved to — the pinned one for a pinned entry, the current one otherwise. ABSENT for an `inline` entry.";
                     };
                     readonly updatedAt: {
                         readonly type: "string";
                         readonly format: "date-time";
+                        readonly description: "When the pool attribute behind this entry was last written. ABSENT for an `inline` entry.";
                     };
                 };
             };

package/dist/persona/profile/get/1.0/payload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../../../src/persona/profile/get/1.0/payload.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../../../src/persona/profile/get/1.0/payload.ts"],"names":[],"mappings":"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"}

package/dist/persona/profile/get/1.0/payload.js

@@ -56,9 +56,9 @@ export const PAYLOAD_SCHEMA = {
                     "type": "array",
                     "maxItems": 256,
                     "items": {
-                        "$ref": "#/$defs/Attribute"
+                        "$ref": "#/$defs/ResolvedClaim"
                     },
-                    "description": "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable."
+                    "description": "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable.\n\nTyped as `ResolvedClaim` rather than `Attribute`: a profile is a projection and may contain `inline` values, which have no pool record and therefore no `attributeId`, `version` or `updatedAt`. The pool record's shape requires all three, so it cannot describe such an entry at all."
                 },
                 "ext": {
                     "$ref": "#/$defs/Ext"
@@ -75,23 +75,20 @@ export const PAYLOAD_SCHEMA = {
                 "pattern": "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$"
             }
         },
-        "Attribute": {
-            "title": "Attribute",
-            "description": "One atomic fact a holder keeps about themselves. Several attributes MAY share a `type` — three phone numbers, a legal name and a preferred name — which is why `attributeId` is the identity of a fact and `type` is not. The pool is flat and unordered; ordering is a profile's concern.",
+        "ResolvedClaim": {
+            "title": "ResolvedClaim",
+            "description": "One line of a profile AFTER resolution: what the profile would present at this entry, rather than how the entry is written.\n\nDistinct from `Attribute` because a profile is a PROJECTION and may contain values that have no pool record behind them. An `inline` entry is a value the holder keeps in one profile and nowhere else — it has no `attributeId`, no `version` and no `updatedAt`, because there is no pool attribute to have them. Describing a resolved profile with the pool record's shape therefore cannot represent one at all, which leaves a maintainer choosing between synthesising an `attributeId` — a false claim about where a value lives — and omitting the entry, which returns a profile that appears to present less than it does. Neither is acceptable, so the projection gets its own shape.\n\nThe three pool members are consequently OPTIONAL and their absence is meaningful: it says this value is inline. Their PRESENCE is equally informative — `version` alongside a pinned entry is what lets a holder see that a profile is frozen at v3 while the pool has moved on.",
             "type": "object",
             "additionalProperties": false,
             "required": [
-                "attributeId",
                 "type",
                 "valueType",
-                "value",
-                "provenance",
-                "version",
-                "updatedAt"
+                "provenance"
             ],
             "properties": {
                 "attributeId": {
-                    "$ref": "#/$defs/Ulid"
+                    "$ref": "#/$defs/Ulid",
+                    "description": "The pool attribute this entry resolves against. ABSENT for an `inline` entry, which is the whole distinction this member draws."
                 },
                 "type": {
                     "$ref": "#/$defs/ClaimType"
@@ -100,19 +97,19 @@ export const PAYLOAD_SCHEMA = {
                     "$ref": "#/$defs/ValueType"
                 },
                 "value": {
-                    "description": "The fact itself, agreeing with `valueType`. Encrypted at rest by the maintainer. Absent when the caller asked for a metadata-only view, and absent when a credential-backed value could not be re-derived — a consumer MUST NOT conflate the two and MUST read `stale` to tell them apart."
+                    "description": "What this entry would present, with any override applied. Absent when `stale`, because a claim that could not be re-derived MUST NOT be disclosed and MUST NOT be shown as though it would be."
                 },
                 "label": {
                     "type": "string",
                     "maxLength": 128,
-                    "description": "The holder's own words for this attribute, shown in a picker. Never disclosed to a verifier; it is a note to self."
+                    "description": "The holder's own words, from the override where one is given and from the pool attribute otherwise. Never disclosed to a verifier."
                 },
                 "provenance": {
                     "$ref": "#/$defs/Provenance"
                 },
                 "stale": {
                     "type": "boolean",
-                    "description": "Present and true when a `credentialBacked` value could not be re-derived. `staleReason` says why. A maintainer MUST refuse to disclose a stale attribute."
+                    "description": "Present and true when this entry cannot be presented — a credential-backed value that could not be re-derived, or a pin naming a version the maintainer no longer holds. Surfaced rather than omitted so a holder learns why a disclosure would be short."
                 },
                 "staleReason": {
                     "type": "string",
@@ -123,18 +120,16 @@ export const PAYLOAD_SCHEMA = {
                         "deleted",
                         "notFound"
                     ],
-                    "description": "Why re-derivation failed. Present only alongside `stale`."
+                    "description": "Why the entry cannot be presented. Present only alongside `stale`."
                 },
                 "version": {
-                    "$ref": "#/$defs/Version"
-                },
-                "createdAt": {
-                    "type": "string",
-                    "format": "date-time"
+                    "$ref": "#/$defs/Version",
+                    "description": "The pool attribute's version this entry resolved to — the pinned one for a pinned entry, the current one otherwise. ABSENT for an `inline` entry."
                 },
                 "updatedAt": {
                     "type": "string",
-                    "format": "date-time"
+                    "format": "date-time",
+                    "description": "When the pool attribute behind this entry was last written. ABSENT for an `inline` entry."
                 }
             }
         },
@@ -426,9 +421,9 @@ export const RESPONSE_PAYLOAD_SCHEMA = {
                     "type": "array",
                     "maxItems": 256,
                     "items": {
-                        "$ref": "#/$defs/Attribute"
+                        "$ref": "#/$defs/ResolvedClaim"
                     },
-                    "description": "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable."
+                    "description": "Present only when `resolve` was true: the claims this profile would present, in entry order, with overrides applied and pinned versions honoured. A credential-backed claim whose backing could not be re-derived appears carrying `stale`, because a holder inspecting a profile needs to see that it has stopped being fully presentable.\n\nTyped as `ResolvedClaim` rather than `Attribute`: a profile is a projection and may contain `inline` values, which have no pool record and therefore no `attributeId`, `version` or `updatedAt`. The pool record's shape requires all three, so it cannot describe such an entry at all."
                 },
                 "ext": {
                     "$ref": "#/$defs/Ext"
@@ -445,23 +440,20 @@ export const RESPONSE_PAYLOAD_SCHEMA = {
                 "pattern": "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$"
             }
         },
-        "Attribute": {
-            "title": "Attribute",
-            "description": "One atomic fact a holder keeps about themselves. Several attributes MAY share a `type` — three phone numbers, a legal name and a preferred name — which is why `attributeId` is the identity of a fact and `type` is not. The pool is flat and unordered; ordering is a profile's concern.",
+        "ResolvedClaim": {
+            "title": "ResolvedClaim",
+            "description": "One line of a profile AFTER resolution: what the profile would present at this entry, rather than how the entry is written.\n\nDistinct from `Attribute` because a profile is a PROJECTION and may contain values that have no pool record behind them. An `inline` entry is a value the holder keeps in one profile and nowhere else — it has no `attributeId`, no `version` and no `updatedAt`, because there is no pool attribute to have them. Describing a resolved profile with the pool record's shape therefore cannot represent one at all, which leaves a maintainer choosing between synthesising an `attributeId` — a false claim about where a value lives — and omitting the entry, which returns a profile that appears to present less than it does. Neither is acceptable, so the projection gets its own shape.\n\nThe three pool members are consequently OPTIONAL and their absence is meaningful: it says this value is inline. Their PRESENCE is equally informative — `version` alongside a pinned entry is what lets a holder see that a profile is frozen at v3 while the pool has moved on.",
             "type": "object",
             "additionalProperties": false,
             "required": [
-                "attributeId",
                 "type",
                 "valueType",
-                "value",
-                "provenance",
-                "version",
-                "updatedAt"
+                "provenance"
             ],
             "properties": {
                 "attributeId": {
-                    "$ref": "#/$defs/Ulid"
+                    "$ref": "#/$defs/Ulid",
+                    "description": "The pool attribute this entry resolves against. ABSENT for an `inline` entry, which is the whole distinction this member draws."
                 },
                 "type": {
                     "$ref": "#/$defs/ClaimType"
@@ -470,19 +462,19 @@ export const RESPONSE_PAYLOAD_SCHEMA = {
                     "$ref": "#/$defs/ValueType"
                 },
                 "value": {
-                    "description": "The fact itself, agreeing with `valueType`. Encrypted at rest by the maintainer. Absent when the caller asked for a metadata-only view, and absent when a credential-backed value could not be re-derived — a consumer MUST NOT conflate the two and MUST read `stale` to tell them apart."
+                    "description": "What this entry would present, with any override applied. Absent when `stale`, because a claim that could not be re-derived MUST NOT be disclosed and MUST NOT be shown as though it would be."
                 },
                 "label": {
                     "type": "string",
                     "maxLength": 128,
-                    "description": "The holder's own words for this attribute, shown in a picker. Never disclosed to a verifier; it is a note to self."
+                    "description": "The holder's own words, from the override where one is given and from the pool attribute otherwise. Never disclosed to a verifier."
                 },
                 "provenance": {
                     "$ref": "#/$defs/Provenance"
                 },
                 "stale": {
                     "type": "boolean",
-                    "description": "Present and true when a `credentialBacked` value could not be re-derived. `staleReason` says why. A maintainer MUST refuse to disclose a stale attribute."
+                    "description": "Present and true when this entry cannot be presented — a credential-backed value that could not be re-derived, or a pin naming a version the maintainer no longer holds. Surfaced rather than omitted so a holder learns why a disclosure would be short."
                 },
                 "staleReason": {
                     "type": "string",
@@ -493,18 +485,16 @@ export const RESPONSE_PAYLOAD_SCHEMA = {
                         "deleted",
                         "notFound"
                     ],
-                    "description": "Why re-derivation failed. Present only alongside `stale`."
+                    "description": "Why the entry cannot be presented. Present only alongside `stale`."
                 },
                 "version": {
-                    "$ref": "#/$defs/Version"
-                },
-                "createdAt": {
-                    "type": "string",
-                    "format": "date-time"
+                    "$ref": "#/$defs/Version",
+                    "description": "The pool attribute's version this entry resolved to — the pinned one for a pinned entry, the current one otherwise. ABSENT for an `inline` entry."
                 },
                 "updatedAt": {
                     "type": "string",
-                    "format": "date-time"
+                    "format": "date-time",
+                    "description": "When the pool attribute behind this entry was last written. ABSENT for an `inline` entry."
                 }
             }
         },