@ayni.org/ayni-ui-core 0.1.0 → 0.3.0

package/dist/proofOfTrustDesign.d.ts

@@ -0,0 +1,350 @@
+import { type TrustResult } from './homeDesign.js';
+import type { Accreditation, CredentialCard, TrustDetails } from './trustDetails.js';
+export declare const PROOF_OF_TRUST_DESIGN: {
+    /** the card itself; on a phone it takes the screen, with no border and no radius */
+    readonly card: {
+        readonly maxWidth: 760;
+        readonly radius: 18;
+    };
+    readonly head: {
+        readonly gap: 6;
+        readonly paddingY: 12;
+        readonly paddingRight: 14;
+        readonly paddingLeft: 18;
+        readonly dotSize: 10;
+        readonly didFontSize: 12;
+        readonly toolIconSize: 15;
+        readonly closeIconSize: 18;
+    };
+    readonly body: {
+        readonly paddingTop: 18;
+        readonly paddingX: 22;
+        readonly paddingBottom: 22;
+        readonly gap: 18;
+    };
+    readonly verdict: {
+        readonly gap: 10;
+        readonly paddingY: 12;
+        readonly paddingX: 16;
+        readonly radius: 14;
+        readonly borderWidth: 2;
+        readonly iconSize: 22;
+        /** the share of the verdict's colour mixed into the background */
+        readonly tint: 0.08;
+        readonly labelFontSize: 18;
+        readonly labelWeight: 700;
+        readonly labelSpacing: 0.06;
+        readonly subFontSize: 12;
+    };
+    readonly reasons: {
+        readonly fontSize: 14;
+        readonly paddingLeft: 18;
+    };
+    readonly loading: {
+        readonly gap: 8;
+        readonly fontSize: 13;
+        readonly iconSize: 16;
+    };
+    /** one identity step: its node on the line, then who it is */
+    readonly step: {
+        readonly gap: 16;
+        readonly paddingBottom: 22;
+        readonly bodyGap: 8;
+    };
+    /** the line that joins a step's node to the next one */
+    readonly line: {
+        readonly left: 15;
+        readonly top: 32;
+        readonly width: 2;
+        readonly okShare: 0.4;
+    };
+    readonly node: {
+        readonly size: 32;
+        readonly borderWidth: 2;
+        readonly iconSize: 16;
+    };
+    readonly kicker: {
+        readonly fontSize: 11;
+        readonly fontWeight: 700;
+        readonly letterSpacing: 0.08;
+        readonly paddingTop: 7;
+    };
+    readonly identity: {
+        readonly gap: 14;
+        readonly avatarSize: 56;
+        readonly avatarRadius: 14;
+        readonly avatarFontSize: 18;
+        readonly textGap: 4;
+    };
+    readonly name: {
+        readonly fontSize: 20;
+        readonly fontWeight: 700;
+        readonly gap: 8;
+        readonly lineHeight: 1.2;
+        readonly iconSize: 18;
+    };
+    readonly facts: {
+        readonly gap: 14;
+        readonly columnGap: 2;
+        readonly fontSize: 13;
+        readonly linkGap: 3;
+        readonly linkIconSize: 11;
+    };
+    readonly provenance: {
+        readonly fontSize: 13;
+    };
+    readonly section: {
+        readonly paddingTop: 12;
+        readonly titleMarginBottom: 8;
+        readonly titleFontSize: 12;
+        readonly titleWeight: 700;
+        readonly titleSpacing: 0.08;
+        readonly titleGap: 8;
+        readonly iconSize: 16;
+    };
+    readonly count: {
+        readonly minWidth: 20;
+        readonly height: 20;
+        readonly paddingX: 6;
+        readonly radius: 10;
+        readonly fontSize: 11;
+        readonly tint: 0.14;
+    };
+    readonly row: {
+        readonly gap: 10;
+        readonly paddingY: 7;
+        readonly fontSize: 14;
+        readonly titleWeight: 600;
+        readonly titleGap: 6;
+        readonly titleIconSize: 14;
+        readonly linkIconSize: 12;
+    };
+    readonly valid: {
+        readonly gap: 4;
+        readonly fontSize: 13;
+        readonly fontWeight: 600;
+        readonly iconSize: 14;
+    };
+    readonly role: {
+        readonly fontSize: 11;
+        readonly fontWeight: 700;
+        readonly letterSpacing: 0.05;
+        readonly paddingY: 2;
+        readonly paddingX: 8;
+        readonly radius: 6;
+        readonly tint: 0.12;
+        readonly ecosystemTint: 0.14;
+    };
+    readonly tag: {
+        readonly fontSize: 11;
+        readonly fontWeight: 600;
+        readonly radius: 6;
+        readonly paddingY: 1;
+        readonly paddingX: 6;
+        readonly tint: 0.12;
+    };
+    readonly claims: {
+        readonly marginTop: 2;
+        readonly rowGap: 2;
+        readonly columnGap: 12;
+        readonly fontSize: 13;
+    };
+    readonly endpoint: {
+        readonly fontSize: 12;
+    };
+    readonly actions: {
+        readonly gap: 10;
+        readonly paddingTop: 14;
+    };
+};
+export type ProofOfTrustDesign = typeof PROOF_OF_TRUST_DESIGN;
+/** Which colour role paints what on the Proof of Trust. */
+export declare const PROOF_OF_TRUST_COLORS: {
+    readonly view: {
+        readonly background: "surface";
+    };
+    readonly card: {
+        readonly background: "bg";
+        readonly border: "border";
+    };
+    readonly did: {
+        readonly text: "muted";
+    };
+    readonly verdictSub: {
+        readonly text: "muted";
+    };
+    readonly reasons: {
+        readonly text: "danger";
+    };
+    readonly loading: {
+        readonly text: "muted";
+    };
+    readonly line: {
+        readonly ok: "ok";
+        readonly rest: "border";
+    };
+    readonly node: {
+        readonly ok: "ok";
+        readonly bad: "danger";
+        readonly background: "bg";
+    };
+    readonly kicker: {
+        readonly text: "muted";
+    };
+    readonly nameIcon: {
+        readonly color: "muted";
+    };
+    readonly facts: {
+        readonly text: "muted";
+    };
+    readonly provenance: {
+        readonly text: "muted";
+    };
+    readonly section: {
+        readonly border: "border";
+        readonly title: "muted";
+    };
+    readonly count: {
+        readonly background: "accent";
+        readonly text: "accent";
+    };
+    readonly valid: {
+        readonly ok: "ok";
+        readonly bad: "danger";
+    };
+    readonly role: {
+        readonly text: "accent";
+        readonly ecosystem: "warning";
+    };
+    readonly tag: {
+        readonly text: "accent";
+    };
+    readonly claims: {
+        readonly key: "muted";
+    };
+};
+/** The verdict the card shows: the registry's answer once loaded, the agent's last known result before. */
+export declare function verdictOf(details: Pick<TrustDetails, 'trusted'> | null | undefined, fallback: TrustResult): TrustResult;
+/** The icon and the colour of a verdict: those of the trust mark. */
+export declare const VERDICT_MARK: {
+    readonly trusted: {
+        readonly icon: "shield-check";
+        readonly color: "ok";
+    };
+    readonly untrusted: {
+        readonly icon: "shield-alert";
+        readonly color: "danger";
+    };
+    readonly unverified: {
+        readonly icon: "shield-question";
+        readonly color: "warning";
+    };
+};
+/** A DID short enough for one line: its two ends. */
+export declare function shortDid(did: string): string;
+export declare function schemaLabel(title: string): string;
+/** The DID in the Verana search, from the graph's address. */
+export declare function didSearchUrl(graphUrl: string, did: string): string;
+/**
+ * The wording of the card, in English: the browser's translation files hold the same keys (a test compares the
+ * English one with this), and the app, which speaks English for now, reads it from here.
+ */
+export declare const PROOF_OF_TRUST_COPY: {
+    readonly title: "Proof of Trust";
+    readonly loading: "Checking the registry";
+    readonly copyDid: "Copy the DID";
+    readonly openInGraph: "Open in the Verana search";
+    readonly evaluated: "Evaluated {{time}}";
+    readonly block: "block {{block}}";
+    readonly service: "Service";
+    readonly operatedBy: "Operated by";
+    readonly selfIssued: "Self-issued";
+    readonly issuedBy: "Issued by {{name}}";
+    readonly issuedByUnknown: "Issuer accredited";
+    readonly since: "since {{time}}";
+    readonly validUntil: "valid until {{time}}";
+    readonly minimumAge: "Minimum age {{age}}";
+    readonly registryId: "Registry id";
+    readonly jurisdiction: "Jurisdiction";
+    readonly alsoPresents: "Also presents";
+    readonly verified: "verified";
+    readonly invalid: "invalid";
+    readonly accreditations: "Accreditations";
+    readonly endpoints: "Endpoints in the DID Document";
+    readonly governance: "Governance";
+    readonly ecosystem: "Ecosystem";
+    readonly root: "accredited by the ecosystem";
+    readonly egf: "Governance framework";
+    readonly cgf: "Corporate governance framework";
+    readonly corporation: "Corporation {{id}}";
+    readonly via: "via {{chain}}";
+    readonly 'role.ECOSYSTEM': "Ecosystem";
+    readonly 'role.ISSUER_GRANTOR': "Issuer grantor";
+    readonly 'role.VERIFIER_GRANTOR': "Verifier grantor";
+    readonly 'role.ISSUER': "Issuer";
+    readonly 'role.VERIFIER': "Verifier";
+    readonly 'role.HOLDER': "Holder";
+};
+export type ProofOfTrustKey = keyof typeof PROOF_OF_TRUST_COPY;
+/** The wording of a verdict and of the reasons behind one that is not "trusted" (the browser's `trust.*` keys). */
+export declare const TRUST_COPY: {
+    readonly trusted: "Trusted";
+    readonly untrusted: "Untrusted";
+    readonly unverified: "Could not verify";
+    readonly 'reasons.not-trusted': "The Verana registry does not vouch for this service.";
+    readonly 'reasons.did-not-found': "The DID is unknown to the registry.";
+    readonly 'reasons.resolution-unavailable': "The trust resolution service could not be reached.";
+    readonly 'reasons.no-service-credential': "No service credential was found.";
+};
+/** A text of the card with its values in place: what the renderer's translator returns. */
+export type ProofOfTrustText = (key: ProofOfTrustKey, values?: Record<string, string | number>) => string;
+/** Fills the `{{name}}` places of a text. */
+export declare function fillText(template: string, values?: Record<string, string | number>): string;
+/** The card's wording in English, for a renderer with no translation files. */
+export declare const proofOfTrustEnglish: ProofOfTrustText;
+/** One identity step as the card draws it: who the credential names, and what it says about them. */
+export interface IdentityStepView {
+    kind: 'service' | 'operator';
+    valid: boolean;
+    /** "Service · ECS-Service" */
+    kicker: string;
+    name: string;
+    logo?: string;
+    /** the icon before an operator's name */
+    nameIcon?: 'building' | 'user';
+    flag?: string;
+    countryCode?: string;
+    /** a service: its type, as a tag */
+    tag?: string;
+    description?: string;
+    /** a service: the facts on one line; an operator: one per line */
+    factsLayout: 'row' | 'column';
+    facts: {
+        label?: string;
+        value: string;
+    }[];
+    links: {
+        label: 'terms' | 'privacy';
+        url: string;
+    }[];
+    /** "Issued by … · ecosystem · since … · valid until …" */
+    provenance: string;
+}
+/**
+ * An identity credential as its step shows it (UI-TRUST-003). `t` gives the wording, `day` writes a date; the
+ * terms and privacy links carry a label the renderer words itself (they are the column's).
+ */
+export declare function identityStepOf(kind: 'service' | 'operator', card: CredentialCard, t: ProofOfTrustText, day: (iso: string) => string): IdentityStepView;
+/** The line under another credential the DID presents: its issuer, its ecosystem, its end. */
+export declare function otherCredentialLine(card: CredentialCard, t: ProofOfTrustText, when: (iso: string) => string): string;
+/**
+ * The line of an accreditation: its ecosystem, then the grantors between the ecosystem's root and this participant
+ * (none means the ecosystem accredited it directly), then its state when it is not active.
+ */
+export declare function accreditationLine(a: Accreditation, t: ProofOfTrustText): string;
+/** The claims of a non-identity credential, flat key and value, strings and numbers only. */
+export declare function claimRows(claims: Record<string, unknown>): {
+    key: string;
+    value: string;
+    link: boolean;
+}[];

package/dist/proofOfTrustDesign.js

@@ -0,0 +1,264 @@
+import { flagOf } from './flag.js';
+import { TRUST_MARK } from './homeDesign.js';
+export const PROOF_OF_TRUST_DESIGN = {
+    /** the card itself; on a phone it takes the screen, with no border and no radius */
+    card: { maxWidth: 760, radius: 18 },
+    head: {
+        gap: 6,
+        paddingY: 12,
+        paddingRight: 14,
+        paddingLeft: 18,
+        dotSize: 10,
+        didFontSize: 12,
+        toolIconSize: 15,
+        closeIconSize: 18,
+    },
+    body: { paddingTop: 18, paddingX: 22, paddingBottom: 22, gap: 18 },
+    verdict: {
+        gap: 10,
+        paddingY: 12,
+        paddingX: 16,
+        radius: 14,
+        borderWidth: 2,
+        iconSize: 22,
+        /** the share of the verdict's colour mixed into the background */
+        tint: 0.08,
+        labelFontSize: 18,
+        labelWeight: 700,
+        labelSpacing: 0.06,
+        subFontSize: 12,
+    },
+    reasons: { fontSize: 14, paddingLeft: 18 },
+    loading: { gap: 8, fontSize: 13, iconSize: 16 },
+    /** one identity step: its node on the line, then who it is */
+    step: { gap: 16, paddingBottom: 22, bodyGap: 8 },
+    /** the line that joins a step's node to the next one */
+    line: { left: 15, top: 32, width: 2, okShare: 0.4 },
+    node: { size: 32, borderWidth: 2, iconSize: 16 },
+    kicker: { fontSize: 11, fontWeight: 700, letterSpacing: 0.08, paddingTop: 7 },
+    identity: { gap: 14, avatarSize: 56, avatarRadius: 14, avatarFontSize: 18, textGap: 4 },
+    name: { fontSize: 20, fontWeight: 700, gap: 8, lineHeight: 1.2, iconSize: 18 },
+    facts: { gap: 14, columnGap: 2, fontSize: 13, linkGap: 3, linkIconSize: 11 },
+    provenance: { fontSize: 13 },
+    section: {
+        paddingTop: 12,
+        titleMarginBottom: 8,
+        titleFontSize: 12,
+        titleWeight: 700,
+        titleSpacing: 0.08,
+        titleGap: 8,
+        iconSize: 16,
+    },
+    count: { minWidth: 20, height: 20, paddingX: 6, radius: 10, fontSize: 11, tint: 0.14 },
+    row: { gap: 10, paddingY: 7, fontSize: 14, titleWeight: 600, titleGap: 6, titleIconSize: 14, linkIconSize: 12 },
+    valid: { gap: 4, fontSize: 13, fontWeight: 600, iconSize: 14 },
+    role: {
+        fontSize: 11,
+        fontWeight: 700,
+        letterSpacing: 0.05,
+        paddingY: 2,
+        paddingX: 8,
+        radius: 6,
+        tint: 0.12,
+        ecosystemTint: 0.14,
+    },
+    tag: { fontSize: 11, fontWeight: 600, radius: 6, paddingY: 1, paddingX: 6, tint: 0.12 },
+    claims: { marginTop: 2, rowGap: 2, columnGap: 12, fontSize: 13 },
+    endpoint: { fontSize: 12 },
+    actions: { gap: 10, paddingTop: 14 },
+};
+/** Which colour role paints what on the Proof of Trust. */
+export const PROOF_OF_TRUST_COLORS = {
+    view: { background: 'surface' },
+    card: { background: 'bg', border: 'border' },
+    did: { text: 'muted' },
+    verdictSub: { text: 'muted' },
+    reasons: { text: 'danger' },
+    loading: { text: 'muted' },
+    line: { ok: 'ok', rest: 'border' },
+    node: { ok: 'ok', bad: 'danger', background: 'bg' },
+    kicker: { text: 'muted' },
+    nameIcon: { color: 'muted' },
+    facts: { text: 'muted' },
+    provenance: { text: 'muted' },
+    section: { border: 'border', title: 'muted' },
+    count: { background: 'accent', text: 'accent' },
+    valid: { ok: 'ok', bad: 'danger' },
+    role: { text: 'accent', ecosystem: 'warning' },
+    tag: { text: 'accent' },
+    claims: { key: 'muted' },
+};
+/** The verdict the card shows: the registry's answer once loaded, the agent's last known result before. */
+export function verdictOf(details, fallback) {
+    if (!details)
+        return fallback;
+    return details.trusted === null ? 'unverified' : details.trusted ? 'trusted' : 'untrusted';
+}
+/** The icon and the colour of a verdict: those of the trust mark. */
+export const VERDICT_MARK = TRUST_MARK;
+/** A DID short enough for one line: its two ends. */
+export function shortDid(did) {
+    return did.length > 48 ? `${did.slice(0, 22)}…${did.slice(-20)}` : did;
+}
+/** ECS schema titles as people read them on the wallet cards. */
+const ECS_LABEL = {
+    ServiceCredential: 'ECS-Service',
+    OrganizationCredential: 'ECS-Organization',
+    PersonaCredential: 'ECS-Persona',
+    UserAgentCredential: 'ECS-UserAgent',
+};
+export function schemaLabel(title) {
+    return ECS_LABEL[title] ?? title;
+}
+/** The DID in the Verana search, from the graph's address. */
+export function didSearchUrl(graphUrl, did) {
+    return `${graphUrl.replace(/graph\./, 'search.')}/?q=${encodeURIComponent(did)}`;
+}
+/**
+ * The wording of the card, in English: the browser's translation files hold the same keys (a test compares the
+ * English one with this), and the app, which speaks English for now, reads it from here.
+ */
+export const PROOF_OF_TRUST_COPY = {
+    title: 'Proof of Trust',
+    loading: 'Checking the registry',
+    copyDid: 'Copy the DID',
+    openInGraph: 'Open in the Verana search',
+    evaluated: 'Evaluated {{time}}',
+    block: 'block {{block}}',
+    service: 'Service',
+    operatedBy: 'Operated by',
+    selfIssued: 'Self-issued',
+    issuedBy: 'Issued by {{name}}',
+    issuedByUnknown: 'Issuer accredited',
+    since: 'since {{time}}',
+    validUntil: 'valid until {{time}}',
+    minimumAge: 'Minimum age {{age}}',
+    registryId: 'Registry id',
+    jurisdiction: 'Jurisdiction',
+    alsoPresents: 'Also presents',
+    verified: 'verified',
+    invalid: 'invalid',
+    accreditations: 'Accreditations',
+    endpoints: 'Endpoints in the DID Document',
+    governance: 'Governance',
+    ecosystem: 'Ecosystem',
+    root: 'accredited by the ecosystem',
+    egf: 'Governance framework',
+    cgf: 'Corporate governance framework',
+    corporation: 'Corporation {{id}}',
+    via: 'via {{chain}}',
+    'role.ECOSYSTEM': 'Ecosystem',
+    'role.ISSUER_GRANTOR': 'Issuer grantor',
+    'role.VERIFIER_GRANTOR': 'Verifier grantor',
+    'role.ISSUER': 'Issuer',
+    'role.VERIFIER': 'Verifier',
+    'role.HOLDER': 'Holder',
+};
+/** The wording of a verdict and of the reasons behind one that is not "trusted" (the browser's `trust.*` keys). */
+export const TRUST_COPY = {
+    trusted: 'Trusted',
+    untrusted: 'Untrusted',
+    unverified: 'Could not verify',
+    'reasons.not-trusted': 'The Verana registry does not vouch for this service.',
+    'reasons.did-not-found': 'The DID is unknown to the registry.',
+    'reasons.resolution-unavailable': 'The trust resolution service could not be reached.',
+    'reasons.no-service-credential': 'No service credential was found.',
+};
+/** Fills the `{{name}}` places of a text. */
+export function fillText(template, values = {}) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_, name) => String(values[name] ?? ''));
+}
+/** The card's wording in English, for a renderer with no translation files. */
+export const proofOfTrustEnglish = (key, values) => fillText(PROOF_OF_TRUST_COPY[key], values);
+const text = (v) => (typeof v === 'string' && v ? v : undefined);
+/**
+ * An identity credential as its step shows it (UI-TRUST-003). `t` gives the wording, `day` writes a date; the
+ * terms and privacy links carry a label the renderer words itself (they are the column's).
+ */
+export function identityStepOf(kind, card, t, day) {
+    const c = card.claims;
+    const facts = [];
+    const links = [];
+    if (kind === 'service') {
+        if (typeof c.minimumAgeRequired === 'number' && c.minimumAgeRequired > 0)
+            facts.push({ value: t('minimumAge', { age: c.minimumAgeRequired }) });
+        const terms = text(c.termsAndConditionsUri);
+        const privacy = text(c.privacyPolicyUri);
+        if (terms)
+            links.push({ label: 'terms', url: terms });
+        if (privacy)
+            links.push({ label: 'privacy', url: privacy });
+    }
+    else {
+        const address = text(c.address);
+        if (address)
+            facts.push({ value: address });
+        if (c.registryId)
+            facts.push({ label: t('registryId'), value: String(c.registryId) });
+        if (c.lei)
+            facts.push({ label: 'LEI', value: String(c.lei) });
+        if (c.legalJurisdiction)
+            facts.push({ label: t('jurisdiction'), value: String(c.legalJurisdiction) });
+    }
+    const provenance = [
+        card.selfIssued
+            ? t('selfIssued')
+            : card.issuer.name
+                ? t('issuedBy', { name: card.issuer.name })
+                : t('issuedByUnknown'),
+        card.ecosystem.name,
+        card.issuedAt ? t('since', { time: day(card.issuedAt) }) : undefined,
+        card.validUntil ? t('validUntil', { time: day(card.validUntil) }) : undefined,
+    ]
+        .filter(Boolean)
+        .join(' · ');
+    const countryCode = text(c.countryCode);
+    return {
+        kind,
+        valid: card.valid,
+        kicker: `${t(kind === 'service' ? 'service' : 'operatedBy')} · ${schemaLabel(card.schemaTitle)}`,
+        name: String(c.name ?? ''),
+        logo: text(c.logoUri) ?? text(c.avatarUri),
+        nameIcon: kind === 'operator' ? (card.ecsSchema === 'PersonaCredential' ? 'user' : 'building') : undefined,
+        flag: flagOf(countryCode) || undefined,
+        countryCode,
+        tag: kind === 'service' ? text(c.type) : undefined,
+        description: kind === 'service' ? text(c.description) : undefined,
+        factsLayout: kind === 'service' ? 'row' : 'column',
+        facts,
+        links,
+        provenance,
+    };
+}
+/** The line under another credential the DID presents: its issuer, its ecosystem, its end. */
+export function otherCredentialLine(card, t, when) {
+    return [
+        card.issuer.name ? t('issuedBy', { name: card.issuer.name }) : undefined,
+        card.ecosystem.name,
+        card.validUntil ? t('validUntil', { time: when(card.validUntil) }) : undefined,
+    ]
+        .filter(Boolean)
+        .join(' · ');
+}
+/**
+ * The line of an accreditation: its ecosystem, then the grantors between the ecosystem's root and this participant
+ * (none means the ecosystem accredited it directly), then its state when it is not active.
+ */
+export function accreditationLine(a, t) {
+    const grantors = a.chain.filter((c) => c.participantId !== a.participantId && c.role !== 'ECOSYSTEM');
+    return [
+        a.ecosystem.name ?? `${t('ecosystem')} ${a.ecosystem.id}`,
+        grantors.length
+            ? t('via', { chain: grantors.map((c) => c.who.name ?? t(`role.${c.role}`)).join(' → ') })
+            : t('root'),
+        a.state !== 'ACTIVE' ? a.state.toLowerCase() : undefined,
+    ]
+        .filter(Boolean)
+        .join(' · ');
+}
+/** The claims of a non-identity credential, flat key and value, strings and numbers only. */
+export function claimRows(claims) {
+    return Object.entries(claims)
+        .filter(([k, v]) => k !== 'id' && !/Sri$/.test(k) && (typeof v === 'string' || typeof v === 'number'))
+        .map(([key, v]) => ({ key, value: String(v), link: /^https?:\/\//.test(String(v)) }));
+}

package/dist/reducer.d.ts

@@ -4,9 +4,11 @@ export interface Reduction {
     transcript: Transcript;
     session: SessionRecord;
     /** signals the shell reacts to (title, badge, sound) */
-    signals: ('message' | 'bound' | 'closed' | 'token' | 'approval')[];
+    signals: ('message' | 'bound' | 'closed' | 'token' | 'approval' | 'identified')[];
 }
 export declare function emptyTranscript(sessionId: string): Transcript;
+/** The five closed states of a flow (flow profile §5.2). */
+export declare function isClosedFlow(state: unknown): boolean;
 export declare function reduce(transcript: Transcript, session: SessionRecord, event: AgUiEvent, fromRun: boolean, isOnScreen: boolean): Reduction;
 /** History messages (MessagesSnapshot shape) to transcript messages (UI-CONV-012). */
 export declare function toTranscriptMessage(m: Record<string, unknown>): TranscriptMessage;

package/dist/reducer.js

@@ -7,6 +7,10 @@ export function emptyTranscript(sessionId) {
     return { sessionId, messages: [], oldestLoadedId: null, complete: false, run: null, routed: {}, reactions: {} };
 }
 const now = () => new Date().toISOString();
+/** The five closed states of a flow (flow profile §5.2). */
+export function isClosedFlow(state) {
+    return (state === 'completed' || state === 'declined' || state === 'cancelled' || state === 'failed' || state === 'expired');
+}
 function upsertMessage(messages, message) {
     const index = messages.findIndex((m) => m.id === message.id);
     if (index < 0)
@@ -116,17 +120,28 @@ export function reduce(transcript, session, event, fromRun, isOnScreen) {
             const id = String(event.messageId);
             // a late artifact replaces its generating placeholder at the initiation position (UI-CONV-006)
             let messages = t.messages;
+            let routed = t.routed;
+            // a flow card sits at the flow's open time and is replaced in place at its close (UI-CONV-021, PROF-MAP-007);
+            // once closed it takes over from the "continue on your phone" card of the same flow (UI-CAP-005)
+            const flowAt = activityType === ACTIVITY.flow && typeof content.openedAt === 'string' ? content.openedAt : at;
+            if (activityType === ACTIVITY.flow && content.flowId && isClosedFlow(content.state)) {
+                routed = Object.fromEntries(Object.entries(routed).filter(([, r]) => r.flowId !== content.flowId));
+                // a credential issued in this conversation identifies its controller on the rail (D37)
+                if (content.kind === 'issue' && content.state === 'completed')
+                    signals.push('identified');
+            }
             if (activityType === ACTIVITY.attachment && content.entryId) {
                 messages = messages.filter((m) => !(m.role === 'activity' && m.activityType === ACTIVITY.generating && m.content.entryId === content.entryId));
             }
             t = {
                 ...t,
+                routed,
                 messages: upsertMessage(messages, {
                     id,
                     role: 'activity',
                     activityType,
                     content,
-                    at,
+                    at: flowAt,
                     entryId: content.entryId,
                 }),
             };
@@ -200,6 +215,7 @@ export function reduce(transcript, session, event, fromRun, isOnScreen) {
                                 status: String(value.status),
                                 message: value.message,
                                 at,
+                                flowId: typeof value.flowId === 'string' ? value.flowId : undefined,
                             },
                         },
                     };