@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/generated/settingsSchemaTypes.d.ts

@@ -0,0 +1,105 @@
+export type ConfigPath = readonly (string | number)[];
+declare const HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "Notification", "UserPromptSubmit", "UserPromptExpansion", "SessionStart", "SessionEnd", "Stop", "StopFailure", "SubagentStart", "SubagentStop", "PreCompact", "PostCompact", "PermissionRequest", "PermissionDenied", "Setup", "TeammateIdle", "TaskCreated", "TaskCompleted", "Elicitation", "ElicitationResult", "ConfigChange", "WorktreeCreate", "WorktreeRemove", "InstructionsLoaded", "CwdChanged", "FileChanged", "MessageDisplay", "DirectoryAdded", "PreModelSwitch", "PostModelSwitch"];
+type HookEventWord = (typeof HOOK_EVENTS)[number];
+declare const HOOK_ENTRY_TYPES: readonly ["command", "prompt", "agent", "http", "mcp_tool"];
+export type HookEntryType = (typeof HOOK_ENTRY_TYPES)[number];
+declare const HOOK_SHELLS: readonly ["bash", "powershell"];
+declare const HOOK_ENTRY_FIELDS: {
+    readonly command: {
+        readonly if: "string?";
+        readonly timeout: "seconds?";
+        readonly statusMessage: "string?";
+        readonly once: "boolean?";
+        readonly command: "text";
+        readonly shell: "shell?";
+        readonly async: "boolean?";
+        readonly asyncRewake: "boolean?";
+    };
+    readonly prompt: {
+        readonly if: "string?";
+        readonly timeout: "seconds?";
+        readonly statusMessage: "string?";
+        readonly once: "boolean?";
+        readonly prompt: "text";
+        readonly model: "string?";
+    };
+    readonly agent: {
+        readonly if: "string?";
+        readonly timeout: "seconds?";
+        readonly statusMessage: "string?";
+        readonly once: "boolean?";
+        readonly prompt: "text";
+        readonly model: "string?";
+    };
+    readonly http: {
+        readonly if: "string?";
+        readonly timeout: "seconds?";
+        readonly statusMessage: "string?";
+        readonly once: "boolean?";
+        readonly url: "text";
+        readonly headers: "stringRecord?";
+        readonly allowedEnvVars: "stringList?";
+    };
+    readonly mcp_tool: {
+        readonly if: "string?";
+        readonly timeout: "seconds?";
+        readonly statusMessage: "string?";
+        readonly once: "boolean?";
+        readonly server: "string";
+        readonly tool: "string";
+        readonly input: "record?";
+    };
+};
+type HookFieldBaseValue<B> = B extends "text" | "string" ? string : B extends "shell" ? (typeof HOOK_SHELLS)[number] : B extends "boolean" ? boolean : B extends "seconds" ? number : B extends "stringRecord" ? Record<string, string> : B extends "stringList" ? string[] : B extends "record" ? Record<string, unknown> : never;
+type HookFieldValue<K> = K extends `${infer B}?` ? HookFieldBaseValue<B> : HookFieldBaseValue<K>;
+type Flat<O> = {
+    [K in keyof O]: O[K];
+};
+type HookEntryOf<T extends HookEntryType, F = (typeof HOOK_ENTRY_FIELDS)[T]> = Flat<{
+    type: T;
+} & {
+    -readonly [K in keyof F as F[K] extends `${string}?` ? never : K]: HookFieldValue<F[K]>;
+} & {
+    -readonly [K in keyof F as F[K] extends `${string}?` ? K : never]?: HookFieldValue<F[K]>;
+}>;
+export type HookEntry = {
+    [T in HookEntryType]: HookEntryOf<T>;
+}[HookEntryType];
+export type HookMatcherEntry = {
+    matcher?: string;
+    hooks: HookEntry[];
+};
+export type HooksConfig = Partial<Record<HookEventWord, HookMatcherEntry[]>>;
+declare const HOOKS_CLASSIFICATION_OUTCOMES: readonly ["loaded", "loaded-partial", "rejected"];
+export type HooksClassificationOutcome = (typeof HOOKS_CLASSIFICATION_OUTCOMES)[number];
+declare const HOOKS_DROPPED_PIECE_CODES: readonly ["hooks-not-object", "unknown-event", "event-not-array", "matcher-invalid", "entry-invalid"];
+export type HooksDroppedPieceCode = (typeof HOOKS_DROPPED_PIECE_CODES)[number];
+declare const HOOKS_REJECTION_CODES: readonly ["guard-outside-hooks", "hooks-is-matcher", "guard-under-unknown-event", "guard-event-not-array", "guard-matcher-invalid", "guard-entry-invalid"];
+export type HooksRejectionCode = (typeof HOOKS_REJECTION_CODES)[number];
+export interface HooksDroppedPiece {
+    readonly code: HooksDroppedPieceCode;
+    readonly path: ConfigPath;
+    readonly field?: string;
+}
+export interface HooksRejection {
+    readonly code: HooksRejectionCode;
+    readonly path: ConfigPath;
+    readonly field?: string;
+}
+export type HooksClassification = {
+    readonly outcome: "loaded";
+    readonly hooks: HooksConfig | undefined;
+    readonly dropped: readonly [];
+    readonly rejections: readonly [];
+} | {
+    readonly outcome: "loaded-partial";
+    readonly hooks: HooksConfig | undefined;
+    readonly dropped: readonly HooksDroppedPiece[];
+    readonly rejections: readonly [];
+} | {
+    readonly outcome: "rejected";
+    readonly hooks: undefined;
+    readonly dropped: readonly [];
+    readonly rejections: readonly HooksRejection[];
+};
+export {};

package/dist/generated/settingsSchemaTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/toolNameTables.d.ts

@@ -1,2 +1,3 @@
 export declare const CORE_PROTOCOL_PREFIXES: readonly ["mcp__", "a2a__"];
 export declare const CORE_SKILL_TOOL_NAME: "Skill";
+export declare const CORE_BOUND_GRANT_ABSENCES: readonly ["not_bindable", "unreadable"];

package/dist/generated/toolNameTables.js

@@ -1,2 +1,3 @@
 export const CORE_PROTOCOL_PREFIXES = ["mcp__", "a2a__"];
 export const CORE_SKILL_TOOL_NAME = "Skill";
+export const CORE_BOUND_GRANT_ABSENCES = ["not_bindable", "unreadable"];

package/dist/hitl/allowRuleShadow.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from '../env/uiLanguage.js';
 export interface ApprovalAllowRuleShadowMember {
     readonly member?: string;
     readonly known: boolean;
@@ -11,11 +12,16 @@ export interface AllowRuleShadowedWireMember {
     readonly omitted?: number;
 }
 export interface ApprovalAllowRuleShadow {
-    readonly source: 'allow_rule_shadowed' | 'legacy_shadowed_rule';
+    readonly source: 'allow_rule_shadowed';
     readonly members: readonly ApprovalAllowRuleShadowMember[];
     readonly unreadable?: true;
 }
+export declare const RETIRED_SHADOW_EVIDENCE_LABEL: Readonly<{
+    readonly frame: "persistedRuleShadowed";
+    readonly row: "riskDescriptor.shadowedRule";
+}>;
+export declare function retiredAllowRuleShadowKeyPresent(carrier: object | null | undefined, leg: 'frame' | 'row'): boolean;
 export declare function readAllowRuleShadowFromWire(carrier: object | null | undefined, leg: 'frame' | 'row'): ApprovalAllowRuleShadow | undefined;
 export declare function readApprovalAllowRuleShadow(card: object | null | undefined): ApprovalAllowRuleShadow | undefined;
 export declare function approvalAllowRuleShadowed(card: object | null | undefined): boolean;
-export declare function allowRuleShadowSentence(card: object | null | undefined): string | undefined;
+export declare function allowRuleShadowSentence(card: object | null | undefined, lang?: UiLanguage): string | undefined;

package/dist/hitl/allowRuleShadow.js

@@ -1,5 +1,6 @@
 import { CORE_ALLOW_RULE_MEMBERS } from '../generated/engineFactTables.js';
 import { quoteUntrustedForSentence } from '../displayUntrusted.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 const KNOWN_MEMBERS = new Set(CORE_ALLOW_RULE_MEMBERS);
 function freezeMember(m) {
     return Object.freeze({ ...m });
@@ -76,20 +77,27 @@ function readNewKeyValue(raw) {
         return unreadable();
     return Object.freeze({ source: 'allow_rule_shadowed', members: Object.freeze(members) });
 }
-function readLegacyValue(raw) {
-    if (typeof raw !== 'string' || raw.trim() === '')
-        return undefined;
-    return Object.freeze({
-        source: 'legacy_shadowed_rule',
-        members: Object.freeze([freezeMember({ member: 'persisted', known: true, entries: Object.freeze([raw]) })]),
-    });
-}
 function ownValue(v, key) {
     return Object.hasOwn(v, key) ? v[key] : undefined;
 }
 function keyValue(v, key) {
     return v[key];
 }
+const RETIRED_SHADOW_KEY = Object.freeze({ frame: 'persistedRuleShadowed', row: 'shadowedRule' });
+export const RETIRED_SHADOW_EVIDENCE_LABEL = Object.freeze({ frame: 'persistedRuleShadowed', row: 'riskDescriptor.shadowedRule' });
+export function retiredAllowRuleShadowKeyPresent(carrier, leg) {
+    try {
+        if (typeof carrier !== 'object' || carrier === null)
+            return false;
+        const host = leg === 'row' ? keyValue(carrier, 'riskDescriptor') : carrier;
+        if (typeof host !== 'object' || host === null)
+            return false;
+        return RETIRED_SHADOW_KEY[leg] in host;
+    }
+    catch {
+        return true;
+    }
+}
 function readMemberAt(arr, i) {
     const d = Object.getOwnPropertyDescriptor(arr, i);
     return d !== undefined && 'value' in d ? readMemberRecord(d.value) : freezeMember({ known: false, malformed: true });
@@ -105,10 +113,7 @@ export function readAllowRuleShadowFromWire(carrier, leg) {
         }
         if (host === undefined)
             return undefined;
-        const fresh = readNewKeyValue(keyValue(host, 'allowRuleShadowed'));
-        if (fresh !== undefined)
-            return fresh;
-        return readLegacyValue(keyValue(host, leg === 'row' ? 'shadowedRule' : 'persistedRuleShadowed'));
+        return readNewKeyValue(keyValue(host, 'allowRuleShadowed'));
     }
     catch {
         return unreadable();
@@ -119,7 +124,7 @@ function readStampedValue(raw) {
         return unreadable();
     const source = ownValue(raw, 'source');
     const members = ownValue(raw, 'members');
-    if ((source !== 'allow_rule_shadowed' && source !== 'legacy_shadowed_rule') || !Array.isArray(members))
+    if (source !== 'allow_rule_shadowed' || !Array.isArray(members))
         return unreadable();
     const length = members.length;
     if (typeof length !== 'number' || !Number.isSafeInteger(length))
@@ -158,8 +163,7 @@ export function approvalAllowRuleShadowed(card) {
 const ENTRY_MAX = 4096;
 const MEMBER_MAX = 64;
 const ENTRIES_SHOWN = 5;
-const UNREADABLE_LINE = 'An allow rule matched this call but cannot clear it; which rule could not be read, so this one is confirmed individually.';
-function legacySingleEntry(shadow) {
+function singlePersistedEntry(shadow) {
     if (shadow.unreadable === true || shadow.members.length !== 1)
         return undefined;
     const m = shadow.members[0];
@@ -169,12 +173,12 @@ function legacySingleEntry(shadow) {
         return undefined;
     return quoteUntrustedForSentence(m.entries[0], ENTRY_MAX);
 }
-function memberPhrase(m) {
+function memberPhrase(m, lang) {
     const memberWord = m.member === undefined ? undefined : KNOWN_MEMBERS.has(m.member) ? m.member : quoteUntrustedForSentence(m.member, MEMBER_MAX);
-    const word = memberWord ?? 'an unrecognised source';
+    const word = memberWord ?? msg('approval.card.shadow.unrecognisedSource');
     const entries = m.entries ?? [];
     if (m.malformed === true && entries.length === 0)
-        return `${word} (could not be read)`;
+        return renderMessage(msg('approval.card.shadow.memberUnreadable', { word }), lang);
     const listed = entries
         .map((e) => quoteUntrustedForSentence(e, ENTRY_MAX))
         .filter((e) => e !== undefined)
@@ -184,25 +188,28 @@ function memberPhrase(m) {
     if (listed.length > 0)
         parts.push(listed.join(', '));
     if (notListed > 0)
-        parts.push(listed.length > 0 ? `and ${String(notListed)} more not listed` : `${String(notListed)} not listed`);
+        parts.push(renderMessage(listed.length > 0 ? msg('approval.card.shadow.moreNotListed', { count: notListed }) : msg('approval.card.shadow.notListed', { count: notListed }), lang));
     if (m.malformed === true)
-        parts.push('part of it could not be read');
-    return parts.length > 0 ? `${word}: ${parts.join('; ')}` : word;
+        parts.push(renderMessage(msg('approval.card.shadow.partUnreadable'), lang));
+    return parts.length > 0
+        ? renderMessage(msg('approval.card.shadow.memberWithParts', { word, parts: parts.join(renderMessage(msg('approval.card.shadow.partJoin'), lang)) }), lang)
+        : typeof word === 'string'
+            ? word
+            : renderMessage(word, lang);
 }
-export function allowRuleShadowSentence(card) {
+export function allowRuleShadowSentence(card, lang) {
     const shadow = readApprovalAllowRuleShadow(card);
     if (shadow === undefined)
         return undefined;
     try {
         if (shadow.unreadable === true || shadow.members.length === 0)
-            return UNREADABLE_LINE;
-        const legacy = legacySingleEntry(shadow);
-        if (legacy !== undefined) {
-            return `Your saved permission rule ${legacy} still exists — it just cannot clear this particular call, so this one is confirmed individually.`;
-        }
-        return `Allow rules matched this call but cannot clear it, so this one is confirmed individually — ${shadow.members.map(memberPhrase).join(' · ')}.`;
+            return renderMessage(msg('approval.card.shadow.unreadable'), lang);
+        const single = singlePersistedEntry(shadow);
+        if (single !== undefined)
+            return renderMessage(msg('approval.card.shadow.single', { entry: single }), lang);
+        return renderMessage(msg('approval.card.shadow.several', { members: shadow.members.map((m) => memberPhrase(m, lang)).join(' · ') }), lang);
     }
     catch {
-        return UNREADABLE_LINE;
+        return renderMessage(msg('approval.card.shadow.unreadable'), lang);
     }
 }

package/dist/hitl/approvalCardReading.d.ts

@@ -0,0 +1,15 @@
+import type { ApprovalCardRequest } from './toolApprovalWire.js';
+export declare function readRequiresRealApproval(carrier: object | null | undefined): boolean;
+export interface ApprovalWindowKeys {
+    readonly expiresInMs?: number;
+    readonly expiresAtMs?: number;
+    readonly serverNowMs?: number;
+    readonly receivedAtMs?: number;
+}
+export interface ApprovalWindowReadOpts {
+    readonly windowIsCurrent?: boolean;
+    readonly receivedAtMs?: number;
+    readonly unknownShape?: boolean;
+}
+export declare function approvalWindowKeysOf(carrier: object | null | undefined, opts?: ApprovalWindowReadOpts | null): Readonly<ApprovalWindowKeys>;
+export declare function probeCauseRowsOf(card: Pick<ApprovalCardRequest, 'probeCause'> | null | undefined): readonly string[] | undefined;

package/dist/hitl/approvalCardReading.js

@@ -0,0 +1,154 @@
+import { displayUntrusted } from '../displayUntrusted.js';
+import { guardedRead, readOwnDataValue } from '../ownKey.js';
+export function readRequiresRealApproval(carrier) {
+    if (typeof carrier !== 'object' || carrier === null)
+        return false;
+    let failed = false;
+    let failure;
+    try {
+        if (carrier.requiresRealApproval === true)
+            return true;
+    }
+    catch (e) {
+        failed = true;
+        failure = e;
+    }
+    try {
+        const risk = carrier.risk;
+        if (typeof risk === 'object' && risk !== null && risk.requiresRealApproval === true)
+            return true;
+    }
+    catch (e) {
+        if (!failed)
+            failure = e;
+        failed = true;
+    }
+    if (failed)
+        throw failure;
+    return false;
+}
+const EMPTY = Object.freeze({});
+const UNKNOWN_SHAPE_COHERENCE_TOLERANCE_MS = 1_000;
+function nonNegativeFinite(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined;
+}
+export function approvalWindowKeysOf(carrier, opts) {
+    if (typeof carrier !== 'object' || carrier === null)
+        return EMPTY;
+    if (typeof opts !== 'object' || opts === null)
+        return EMPTY;
+    let current;
+    let anchor;
+    let unknownShape;
+    try {
+        current = opts.windowIsCurrent;
+        anchor = opts.receivedAtMs;
+        unknownShape = opts.unknownShape;
+    }
+    catch {
+        return EMPTY;
+    }
+    if (current !== true)
+        return EMPTY;
+    const read = (key) => {
+        try {
+            return nonNegativeFinite(carrier[key]);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const inMs = read('expiresInMs');
+    const atMs = read('expiresAtMs');
+    const nowMs = read('serverNowMs');
+    if (unknownShape === true) {
+        if (inMs === undefined || atMs === undefined || nowMs === undefined)
+            return EMPTY;
+        if (atMs <= 0 || nowMs <= 0)
+            return EMPTY;
+        if (Math.abs(inMs - Math.max(0, atMs - nowMs)) > UNKNOWN_SHAPE_COHERENCE_TOLERANCE_MS)
+            return EMPTY;
+    }
+    const receivedAtMs = nonNegativeFinite(anchor);
+    const out = {};
+    if (inMs !== undefined)
+        out.expiresInMs = inMs;
+    if (atMs !== undefined)
+        out.expiresAtMs = atMs;
+    if (nowMs !== undefined)
+        out.serverNowMs = nowMs;
+    if ((inMs !== undefined || atMs !== undefined) && receivedAtMs !== undefined)
+        out.receivedAtMs = receivedAtMs;
+    return Object.freeze(out);
+}
+const PROBE_CAUSE_SHOWN_MAX = 8;
+const PROBE_CAUSE_ENTRY_MAX = 200;
+function own(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    return guardedRead(() => readOwnDataValue(v, key));
+}
+function readOperands(v) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    const shown = own(v, 'shown');
+    const isList = guardedRead(() => Array.isArray(shown));
+    if (isList !== true)
+        return undefined;
+    const length = own(shown, 'length');
+    if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
+        return undefined;
+    const items = [];
+    for (let i = 0; i < length; i++) {
+        const item = own(shown, String(i));
+        if (typeof item !== 'string')
+            return undefined;
+        items.push(item);
+    }
+    const total = own(v, 'total');
+    if (typeof total !== 'number' || !Number.isSafeInteger(total) || total < 0 || total < items.length)
+        return undefined;
+    return { shown: items, total };
+}
+function operandsText(label, o) {
+    const shown = o.shown.slice(0, PROBE_CAUSE_SHOWN_MAX).map((p) => displayUntrusted(p, { max: PROBE_CAUSE_ENTRY_MAX }));
+    if (shown.length === 0)
+        return `${label}: ${String(o.total)} total`;
+    const more = o.total - shown.length;
+    return more > 0 ? `${label}: ${shown.join(', ')} (+${String(more)} more)` : `${label}: ${shown.join(', ')}`;
+}
+export function probeCauseRowsOf(card) {
+    try {
+        if (typeof card !== 'object' || card === null)
+            return undefined;
+        const cause = own(card, 'probeCause');
+        if (typeof cause !== 'object' || cause === null)
+            return undefined;
+        if (guardedRead(() => Array.isArray(cause)) !== false)
+            return undefined;
+        const code = own(cause, 'code');
+        if (typeof code !== 'string' || code === '')
+            return undefined;
+        const roots = readOperands(own(cause, 'roots'));
+        if (roots === undefined)
+            return undefined;
+        let fd;
+        try {
+            fd = Object.getOwnPropertyDescriptor(cause, 'further');
+        }
+        catch {
+            return undefined;
+        }
+        if (fd === undefined || (Object.hasOwn(fd, 'value') && fd.value === undefined))
+            return Object.freeze([operandsText('roots', roots)]);
+        if (!Object.hasOwn(fd, 'value'))
+            return undefined;
+        const further = readOperands(fd.value);
+        if (further === undefined)
+            return undefined;
+        return Object.freeze([operandsText('roots', roots), operandsText('further', further)]);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/hitl/approvalCardReasons.d.ts

@@ -0,0 +1,14 @@
+import type { UiLanguage } from '../env/uiLanguage.js';
+import { type DenialLimitFallback } from './toolApprovalWire.js';
+export declare const APPROVAL_CARD_REASON_SOURCES: readonly ["payload_unreadable", "prior_cards", "message", "mandated", "mandate", "origin", "denial_limit", "probe", "allow_rule_shadow", "classifier_no_ruling", "bound_grants", "more"];
+export type ApprovalCardReasonSource = (typeof APPROVAL_CARD_REASON_SOURCES)[number];
+export interface ApprovalCardReasonLine {
+    readonly source: ApprovalCardReasonSource;
+    readonly text: string;
+}
+export interface ApprovalCardReasonsOptions {
+    readonly maxLines?: number;
+}
+export declare const APPROVAL_CARD_REASONS_DEFAULT_MAX_LINES = 4;
+export declare function denialLimitFallbackDetail(v: DenialLimitFallback | null | undefined, lang?: UiLanguage): string | undefined;
+export declare function approvalCardReasons(card: object | null | undefined, opts?: ApprovalCardReasonsOptions | null, lang?: UiLanguage): readonly ApprovalCardReasonLine[];

package/dist/hitl/approvalCardReasons.js

@@ -0,0 +1,119 @@
+import { displayUntrusted } from '../displayUntrusted.js';
+import { msg, renderMessage } from '../i18n/translate.js';
+import { approvalMandateDetail, askOriginNoteOf } from '../gateVocabulary.js';
+import { readAskOrigin, readOwnDataValue, guardedRead } from '../ownKey.js';
+import { allowRuleShadowSentence } from './allowRuleShadow.js';
+import { mandatedApprovalDetailOf } from './automaticAnswerVerdict.js';
+import { approvalBoundGrantsDetail, approvalIsMandated, approvalPriorCardsDetail, askProbeReasonDetail, classifierNoRulingDetail, readApprovalBoundGrants, readApprovalClassifierNoRuling, readApprovalMandate, readDenialLimitFallback, } from './toolApprovalWire.js';
+export const APPROVAL_CARD_REASON_SOURCES = Object.freeze([
+    'payload_unreadable',
+    'prior_cards',
+    'message',
+    'mandated',
+    'mandate',
+    'origin',
+    'denial_limit',
+    'probe',
+    'allow_rule_shadow',
+    'classifier_no_ruling',
+    'bound_grants',
+    'more',
+]);
+export const APPROVAL_CARD_REASONS_DEFAULT_MAX_LINES = 4;
+const MESSAGE_DISPLAY_MAX = 300;
+function payloadUnreadableDetail(lang) {
+    return renderMessage(msg('approval.card.payloadUnreadable'), lang);
+}
+function moreDetail(n, lang) {
+    return renderMessage(n === 1 ? msg('approval.card.more.one') : msg('approval.card.more.other', { count: n }), lang);
+}
+export function denialLimitFallbackDetail(v, lang) {
+    const d = readDenialLimitFallback(v);
+    if (d === undefined)
+        return undefined;
+    const limit = displayUntrusted(d.limit, { max: 24 });
+    return renderMessage(d.autoDenyAfterMs > 0
+        ? msg('approval.card.denialLimit.withAutoDeny', { consecutive: d.consecutive, total: d.total, limit, seconds: Math.round(d.autoDenyAfterMs / 1000) })
+        : msg('approval.card.denialLimit.plain', { consecutive: d.consecutive, total: d.total, limit }), lang);
+}
+function ownData(card, key) {
+    return guardedRead(() => readOwnDataValue(card, key));
+}
+function readMaxLines(opts) {
+    const raw = typeof opts === 'object' && opts !== null ? guardedRead(() => readOwnDataValue(opts, 'maxLines')) : undefined;
+    return typeof raw === 'number' && Number.isSafeInteger(raw) && raw >= 1 ? raw : APPROVAL_CARD_REASONS_DEFAULT_MAX_LINES;
+}
+export function approvalCardReasons(card, opts, lang) {
+    if (typeof card !== 'object' || card === null)
+        return Object.freeze([]);
+    const raw = [];
+    const add = (source, read) => {
+        let text;
+        try {
+            text = read();
+        }
+        catch {
+            text = undefined;
+        }
+        raw.push({ source, text });
+    };
+    let denialLimitReadable = false;
+    try {
+        denialLimitReadable = readDenialLimitFallback(ownData(card, 'denialLimitFallback')) !== undefined;
+    }
+    catch {
+        denialLimitReadable = false;
+    }
+    add('payload_unreadable', () => (ownData(card, 'cardPayloadUnreadable') === true ? payloadUnreadableDetail(lang) : undefined));
+    add('prior_cards', () => approvalPriorCardsDetail(card, lang));
+    add('message', () => {
+        const engineMessage = ownData(card, 'message');
+        if (typeof engineMessage !== 'string' || engineMessage.trim() === '')
+            return undefined;
+        const tool = ownData(card, 'toolName');
+        if (typeof tool === 'string' && engineMessage.trim() === `approval required for "${tool}"`)
+            return undefined;
+        return displayUntrusted(engineMessage, { max: MESSAGE_DISPLAY_MAX });
+    });
+    add('mandated', () => (approvalIsMandated(card) ? mandatedApprovalDetailOf(card, lang) : undefined));
+    add('mandate', () => {
+        const word = readApprovalMandate(card);
+        return word !== undefined ? approvalMandateDetail(word, lang) : undefined;
+    });
+    add('origin', () => {
+        const origin = readAskOrigin(card);
+        if (origin === undefined)
+            return undefined;
+        if (origin === 'denial_limit_fallback' && denialLimitReadable)
+            return undefined;
+        return askOriginNoteOf(origin, lang);
+    });
+    add('denial_limit', () => denialLimitFallbackDetail(ownData(card, 'denialLimitFallback'), lang));
+    add('probe', () => askProbeReasonDetail(card, lang));
+    add('allow_rule_shadow', () => allowRuleShadowSentence(card, lang));
+    add('classifier_no_ruling', () => {
+        const word = readApprovalClassifierNoRuling(card);
+        return word !== undefined ? classifierNoRulingDetail(word, lang) : undefined;
+    });
+    add('bound_grants', () => {
+        const grants = readApprovalBoundGrants(card);
+        return grants !== undefined ? approvalBoundGrantsDetail(grants, lang) : undefined;
+    });
+    const seen = new Set();
+    const lines = [];
+    for (const r of raw) {
+        if (r.text === undefined)
+            continue;
+        const text = displayUntrusted(r.text);
+        if (text === '' || seen.has(text))
+            continue;
+        seen.add(text);
+        lines.push(Object.freeze({ source: r.source, text }));
+    }
+    const max = readMaxLines(opts);
+    if (lines.length <= max)
+        return Object.freeze(lines);
+    const kept = lines.slice(0, max - 1);
+    kept.push(Object.freeze({ source: 'more', text: moreDetail(lines.length - kept.length, lang) }));
+    return Object.freeze(kept);
+}