@mercuryo-ai/agentbrowse 0.2.50

package/dist/secrets/protected-fill.js

@@ -0,0 +1,446 @@
+import { AgentbrowseAssistiveRuntimeMissingError } from '../assistive-runtime.js';
+import { getSurface, getTarget } from '../runtime-state.js';
+import { createAcceptanceProbe, waitForAcceptanceProbe } from '../commands/action-acceptance.js';
+import { applyActionWithFallbacks } from '../commands/action-executor.js';
+import { normalizePageSignature, readLocatorDomSignature, } from '../commands/descriptor-validation.js';
+import { assertStoredBindingStillValid, resolvePreparedLocatorCandidates, resolveInteractionRoots, } from '../commands/interaction-kernel.js';
+import { resolveProtectedFieldPolicy } from './field-policy.js';
+import { protectedBindingKey } from './protected-bindings.js';
+import { resolveAssistedProtectedFieldValues } from './protected-field-values.js';
+import { resolveDeterministicProtectedBindingValue } from './protected-value-adapters.js';
+import { sortProtectedBindingsForExecution } from './fill-ordering.js';
+function actionForTarget(target) {
+    if (target.controlFamily === 'select') {
+        return 'select';
+    }
+    if (target.allowedActions.includes('fill')) {
+        return 'fill';
+    }
+    if (target.allowedActions.includes('type')) {
+        return 'type';
+    }
+    if (target.allowedActions.includes('select')) {
+        return 'select';
+    }
+    return 'fill';
+}
+function formatCardExpiry(month, year) {
+    const normalizedMonth = month.trim().padStart(2, '0');
+    const normalizedYear = year.trim().length > 2 ? year.trim().slice(-2) : year.trim().padStart(2, '0');
+    return `${normalizedMonth}/${normalizedYear}`;
+}
+function resolveBindingValue(fields, target, protectedValues, fieldPolicies, assistedValues) {
+    if (fields.length === 1) {
+        const field = fields[0];
+        const policy = resolveProtectedFieldPolicy(fieldPolicies, field.fieldKey);
+        const deterministicValue = resolveDeterministicProtectedBindingValue(field, protectedValues, target);
+        if (policy === 'llm_assisted') {
+            const assistedValue = assistedValues.get(protectedBindingKey(field));
+            if (typeof assistedValue === 'string' && assistedValue.length > 0) {
+                return assistedValue;
+            }
+            throw new Error('assisted_value_resolution_failed');
+        }
+        if (typeof deterministicValue === 'string' && deterministicValue.length > 0) {
+            return deterministicValue;
+        }
+        if ((field.valueHint ?? 'direct') !== 'direct') {
+            throw new Error('deterministic_only_resolution_failed');
+        }
+        const value = protectedValues[field.fieldKey];
+        if (typeof value === 'string' && value.length > 0) {
+            return value;
+        }
+        throw new Error('missing_protected_value');
+    }
+    const includesExpiry = fields.some((field) => field.fieldKey === 'exp_month') &&
+        fields.some((field) => field.fieldKey === 'exp_year') &&
+        fields.length === 2;
+    if (includesExpiry) {
+        const month = protectedValues.exp_month;
+        const year = protectedValues.exp_year;
+        if (typeof month === 'string' &&
+            month.length > 0 &&
+            typeof year === 'string' &&
+            year.length > 0) {
+            return formatCardExpiry(month, year);
+        }
+        throw new Error('missing_protected_value');
+    }
+    throw new Error('unsupported_protected_field_group');
+}
+function flattenFilledFields(fieldKeys, targetRef) {
+    return fieldKeys.map((fieldKey) => ({
+        fieldKey,
+        targetRef,
+    }));
+}
+function buildProtectedValidationDetails(validationText) {
+    return validationText ? { validationTextRedacted: true } : {};
+}
+function shouldIgnoreNativeInvalidForTarget(target) {
+    return Array.isArray(target.framePath) && target.framePath.length > 0;
+}
+async function readValidationState(locator) {
+    const payload = await locator
+        .evaluate((element) => {
+        if (!(element instanceof HTMLElement)) {
+            return null;
+        }
+        const maybeControl = element instanceof HTMLInputElement ||
+            element instanceof HTMLTextAreaElement ||
+            element instanceof HTMLSelectElement
+            ? element
+            : null;
+        const validationMessage = maybeControl?.validationMessage?.trim() ?? '';
+        const describedByIds = (element.getAttribute('aria-describedby') ?? '')
+            .split(/\s+/)
+            .map((value) => value.trim())
+            .filter(Boolean);
+        const describedByText = describedByIds
+            .map((id) => element.ownerDocument?.getElementById(id)?.textContent?.trim() ?? '')
+            .filter(Boolean)
+            .join(' ');
+        const ariaInvalid = element.getAttribute('aria-invalid') === 'true';
+        const candidate = validationMessage || describedByText || '';
+        return {
+            validationText: candidate || undefined,
+            ariaInvalid,
+            invalid: ariaInvalid ||
+                Boolean(maybeControl &&
+                    typeof maybeControl.checkValidity === 'function' &&
+                    maybeControl.checkValidity() === false),
+        };
+    })
+        .catch(() => null);
+    if (!payload) {
+        return {
+            invalid: false,
+        };
+    }
+    return {
+        invalid: payload.invalid,
+        validationText: payload.validationText ||
+            (payload.ariaInvalid ? 'Field rejected by client-side validation.' : undefined),
+    };
+}
+function groupBindingsByTarget(fillableForm, session) {
+    const grouped = new Map();
+    for (const field of fillableForm.fields) {
+        const target = getTarget(session, field.targetRef);
+        if (!target) {
+            return null;
+        }
+        const existing = grouped.get(field.targetRef);
+        if (existing) {
+            existing.fields.push(field);
+            existing.fieldKeys.push(field.fieldKey);
+            continue;
+        }
+        grouped.set(field.targetRef, {
+            targetRef: field.targetRef,
+            fields: [field],
+            fieldKeys: [field.fieldKey],
+            target,
+        });
+    }
+    return sortProtectedBindingsForExecution(fillableForm.purpose, [...grouped.values()]);
+}
+async function prepareBindings(session, page, fillableForm) {
+    const groupedBindings = groupBindingsByTarget(fillableForm, session);
+    if (!groupedBindings) {
+        const firstField = fillableForm.fields[0];
+        return {
+            kind: 'binding_stale',
+            targetRef: firstField?.targetRef ?? 'unknown',
+            fieldKeys: firstField ? [firstField.fieldKey] : [],
+            reason: 'target_missing',
+            attempts: [],
+        };
+    }
+    const preparedBindings = [];
+    for (const binding of groupedBindings) {
+        const attempts = [];
+        const { target } = binding;
+        if (target.lifecycle !== 'live') {
+            return {
+                kind: 'binding_stale',
+                targetRef: binding.targetRef,
+                fieldKeys: [...binding.fieldKeys],
+                reason: 'target_not_live',
+                attempts,
+            };
+        }
+        if (target.pageSignature && normalizePageSignature(page.url()) !== target.pageSignature) {
+            attempts.push('stale.page-signature:before-fill');
+            return {
+                kind: 'binding_stale',
+                targetRef: binding.targetRef,
+                fieldKeys: [...binding.fieldKeys],
+                reason: 'page_signature_mismatch',
+                attempts,
+            };
+        }
+        const surface = target.surfaceRef ? getSurface(session, target.surfaceRef) : null;
+        const { baseRoot, locatorRoot, surfaceRoot } = await resolveInteractionRoots(page, target, surface, attempts);
+        let resolvedLocator = null;
+        let sawDomSignatureMismatch = false;
+        let sawBlockedTarget = false;
+        const action = actionForTarget(target);
+        const resolution = await resolvePreparedLocatorCandidates({
+            target,
+            action,
+            baseRoot,
+            locatorRoot,
+            surfaceRoot,
+            attempts,
+            prepareOptions: {
+                allowReadonlyFallback: action === 'fill' && target.controlFamily === 'datepicker',
+            },
+            onPreparedLocator: async (preparedLocator, strategy) => {
+                if (target.domSignature) {
+                    const liveSignature = await readLocatorDomSignature(preparedLocator).catch(() => null);
+                    if (liveSignature && liveSignature !== target.domSignature) {
+                        sawDomSignatureMismatch = true;
+                        attempts.push(`domSignature.mismatch:${strategy}`);
+                        return false;
+                    }
+                }
+                resolvedLocator = preparedLocator;
+                attempts.push(`resolve:${strategy}`);
+                return true;
+            },
+        });
+        if (resolution.sawDisabledTarget || resolution.sawReadonlyTarget) {
+            sawBlockedTarget = true;
+        }
+        if (!resolvedLocator) {
+            return {
+                kind: 'binding_stale',
+                targetRef: binding.targetRef,
+                fieldKeys: [...binding.fieldKeys],
+                reason: sawDomSignatureMismatch
+                    ? 'dom_signature_mismatch'
+                    : sawBlockedTarget
+                        ? 'target_blocked'
+                        : 'locator_resolution_failed',
+                attempts,
+            };
+        }
+        preparedBindings.push({
+            targetRef: binding.targetRef,
+            fields: [...binding.fields],
+            fieldKeys: [...binding.fieldKeys],
+            action,
+            target,
+            root: locatorRoot,
+            locator: resolvedLocator,
+            attempts,
+        });
+    }
+    return preparedBindings;
+}
+function staleReasonFromError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes('page_signature_mismatch')) {
+        return 'page_signature_mismatch';
+    }
+    if (message.includes('dom_signature_mismatch')) {
+        return 'dom_signature_mismatch';
+    }
+    if (message.includes('locator_resolution_failed')) {
+        return 'locator_resolution_failed';
+    }
+    return null;
+}
+export async function executeProtectedFill(params) {
+    const preparedBindings = await prepareBindings(params.session, params.page, params.fillableForm);
+    if (!Array.isArray(preparedBindings)) {
+        return preparedBindings;
+    }
+    let assistedValues;
+    try {
+        assistedValues = await resolveAssistedProtectedFieldValues({
+            session: params.session,
+            page: params.page,
+            bindings: preparedBindings.map((binding) => ({
+                binding: binding.fields[0],
+                target: binding.target,
+            })),
+            protectedValues: params.protectedValues,
+            fieldPolicies: params.fieldPolicies,
+        });
+    }
+    catch (error) {
+        const assistiveRuntimeMissing = error instanceof AgentbrowseAssistiveRuntimeMissingError ||
+            (error instanceof Error && error.name === 'AgentbrowseAssistiveRuntimeMissingError');
+        if (assistiveRuntimeMissing) {
+            assistedValues = new Map();
+            for (const binding of preparedBindings) {
+                for (const field of binding.fields) {
+                    const deterministicValue = resolveDeterministicProtectedBindingValue(field, params.protectedValues, binding.target) ??
+                        ((field.valueHint ?? 'direct') === 'direct'
+                            ? params.protectedValues[field.fieldKey]
+                            : null);
+                    if (typeof deterministicValue !== 'string' || deterministicValue.trim().length === 0) {
+                        continue;
+                    }
+                    assistedValues.set(protectedBindingKey(field), deterministicValue.trim());
+                }
+            }
+        }
+        else {
+            return {
+                kind: 'unexpected_error',
+                reason: 'assisted_value_resolution_failed',
+            };
+        }
+    }
+    const filledFields = [];
+    for (const binding of preparedBindings) {
+        let actionValue;
+        let acceptanceProbe = null;
+        let acceptanceResult = null;
+        try {
+            actionValue = resolveBindingValue(binding.fields, binding.target, params.protectedValues, params.fieldPolicies, assistedValues);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message === 'missing_protected_value') {
+                return {
+                    kind: 'unexpected_error',
+                    reason: 'missing_protected_value',
+                };
+            }
+            if (message === 'deterministic_only_resolution_failed') {
+                return {
+                    kind: 'unexpected_error',
+                    reason: 'deterministic_only_resolution_failed',
+                };
+            }
+            if (message === 'assisted_value_resolution_failed') {
+                return {
+                    kind: 'unexpected_error',
+                    reason: 'assisted_value_resolution_failed',
+                };
+            }
+            return {
+                kind: 'unexpected_error',
+                reason: 'unsupported_protected_field_group',
+            };
+        }
+        try {
+            acceptanceProbe = await createAcceptanceProbe({
+                session: params.session,
+                page: params.page,
+                target: binding.target,
+                action: binding.action,
+                actionValue,
+                locator: binding.locator,
+                beforePageObservation: null,
+            });
+            await applyActionWithFallbacks(params.page, binding.root, binding.locator, binding.action, actionValue, binding.attempts, binding.target.controlFamily, {
+                guards: {
+                    assertStillValid: async (stage) => {
+                        await assertStoredBindingStillValid(params.page, binding.locator, binding.target, stage, {
+                            errorForReason: (reason, validationStage) => `binding_stale:${reason}:${validationStage}`,
+                        });
+                    },
+                },
+            });
+            if (acceptanceProbe) {
+                acceptanceResult = await waitForAcceptanceProbe(acceptanceProbe);
+                const acceptance = acceptanceResult;
+                if (!acceptance.accepted) {
+                    const validationState = await readValidationState(acceptanceProbe.readLocator);
+                    return {
+                        kind: 'validation_failed',
+                        filledFields,
+                        fieldErrors: binding.fieldKeys.map((fieldKey) => ({
+                            fieldKey,
+                            targetRef: binding.targetRef,
+                            reason: validationState.validationText
+                                ? 'client_validation_rejected'
+                                : 'value_not_applied',
+                            ...buildProtectedValidationDetails(validationState.validationText),
+                        })),
+                    };
+                }
+                const validationState = await readValidationState(acceptanceProbe.readLocator);
+                if (validationState.invalid && !shouldIgnoreNativeInvalidForTarget(binding.target)) {
+                    return {
+                        kind: 'validation_failed',
+                        filledFields,
+                        fieldErrors: binding.fieldKeys.map((fieldKey) => ({
+                            fieldKey,
+                            targetRef: binding.targetRef,
+                            reason: 'client_validation_rejected',
+                            ...buildProtectedValidationDetails(validationState.validationText),
+                        })),
+                    };
+                }
+            }
+            filledFields.push(...flattenFilledFields(binding.fieldKeys, binding.targetRef));
+        }
+        catch (error) {
+            if (acceptanceProbe) {
+                acceptanceResult =
+                    acceptanceResult ?? (await waitForAcceptanceProbe(acceptanceProbe).catch(() => null));
+                if (acceptanceResult?.accepted) {
+                    const validationState = await readValidationState(acceptanceProbe.readLocator);
+                    if (validationState.invalid && !shouldIgnoreNativeInvalidForTarget(binding.target)) {
+                        return {
+                            kind: 'validation_failed',
+                            filledFields,
+                            fieldErrors: binding.fieldKeys.map((fieldKey) => ({
+                                fieldKey,
+                                targetRef: binding.targetRef,
+                                reason: 'client_validation_rejected',
+                                ...buildProtectedValidationDetails(validationState.validationText),
+                            })),
+                        };
+                    }
+                    filledFields.push(...flattenFilledFields(binding.fieldKeys, binding.targetRef));
+                    continue;
+                }
+            }
+            const staleReason = staleReasonFromError(error);
+            if (staleReason) {
+                return {
+                    kind: 'binding_stale',
+                    targetRef: binding.targetRef,
+                    fieldKeys: [...binding.fieldKeys],
+                    reason: staleReason,
+                    attempts: [...binding.attempts],
+                };
+            }
+            return {
+                kind: 'unexpected_error',
+                reason: 'action_failed',
+            };
+        }
+    }
+    return {
+        kind: 'success',
+        filledFields,
+    };
+}
+export const __testProtectedFill = {
+    actionForTarget,
+    formatCardExpiry,
+    resolveBindingValue: (fieldKeys, protectedValues, target) => resolveBindingValue(fieldKeys.map((fieldKey) => ({
+        fieldKey,
+        targetRef: 't_test',
+        valueHint: 'direct',
+    })), target ??
+        {
+            ref: 't_test',
+            pageRef: 'p0',
+            capability: 'actionable',
+            lifecycle: 'live',
+            availability: { state: 'available' },
+            allowedActions: ['fill'],
+            locatorCandidates: [],
+            createdAt: 0,
+        }, protectedValues, undefined, new Map()),
+};

package/dist/secrets/protected-value-adapters.d.ts

@@ -0,0 +1,4 @@
+import type { TargetDescriptor } from '../runtime-state.js';
+import type { FillableFormFieldBinding } from './types.js';
+export declare function resolveDeterministicProtectedBindingValue(binding: Pick<FillableFormFieldBinding, 'fieldKey' | 'valueHint'>, protectedValues: Record<string, string>, target?: Pick<TargetDescriptor, 'label' | 'displayLabel' | 'context'>): string | null;
+//# sourceMappingURL=protected-value-adapters.d.ts.map

package/dist/secrets/protected-value-adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protected-value-adapters.d.ts","sourceRoot":"","sources":["../../src/secrets/protected-value-adapters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,wBAAwB,EAAwB,MAAM,YAAY,CAAC;AAwFjF,wBAAgB,yCAAyC,CACvD,OAAO,EAAE,IAAI,CAAC,wBAAwB,EAAE,UAAU,GAAG,WAAW,CAAC,EACjE,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACvC,MAAM,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAAC,GACpE,MAAM,GAAG,IAAI,CAqEf"}

package/dist/secrets/protected-value-adapters.js

@@ -0,0 +1,118 @@
+function normalizeWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function splitFullName(value) {
+    return normalizeWhitespace(value)
+        .split(' ')
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+function directStoredValue(protectedValues, fieldKey) {
+    const value = protectedValues[fieldKey];
+    return typeof value === 'string' && value.trim().length > 0 ? value : null;
+}
+function parseIsoDate(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value.trim());
+    if (!match) {
+        return null;
+    }
+    const year = match[1];
+    const month = match[2];
+    const day = match[3];
+    if (!year || !month || !day) {
+        return null;
+    }
+    return { year, month, day };
+}
+function monthName(month) {
+    const names = [
+        'January',
+        'February',
+        'March',
+        'April',
+        'May',
+        'June',
+        'July',
+        'August',
+        'September',
+        'October',
+        'November',
+        'December',
+    ];
+    return names[Number(month) - 1] ?? month;
+}
+function monthShortName(month) {
+    return monthName(month).slice(0, 3);
+}
+function monthProjectionStyle(target) {
+    const context = [target?.label, target?.displayLabel, target?.context?.hintText]
+        .filter(Boolean)
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+    if (/\bjanuary\b|\bfebruary\b|\bmarch\b|\bapril\b|\bmay\b|\bjune\b|\bjuly\b|\baugust\b|\bseptember\b|\boctober\b|\bnovember\b|\bdecember\b/.test(context)) {
+        return 'name';
+    }
+    if (/\bjan\b|\bfeb\b|\bmar\b|\bapr\b|\bjun\b|\bjul\b|\baug\b|\bsep\b|\boct\b|\bnov\b|\bdec\b/.test(context)) {
+        return 'short';
+    }
+    return 'numeric';
+}
+export function resolveDeterministicProtectedBindingValue(binding, protectedValues, target) {
+    if (binding.fieldKey === 'date_of_birth') {
+        const dateOfBirth = directStoredValue(protectedValues, 'date_of_birth');
+        if (!dateOfBirth) {
+            return null;
+        }
+        const valueHint = binding.valueHint ?? 'direct';
+        if (valueHint === 'direct') {
+            return dateOfBirth;
+        }
+        const parsed = parseIsoDate(dateOfBirth);
+        if (!parsed) {
+            return null;
+        }
+        if (valueHint === 'date_of_birth.day') {
+            return String(Number(parsed.day));
+        }
+        if (valueHint === 'date_of_birth.year') {
+            return parsed.year;
+        }
+        if (valueHint === 'date_of_birth.month') {
+            const style = monthProjectionStyle(target);
+            if (style === 'name') {
+                return monthName(parsed.month);
+            }
+            if (style === 'short') {
+                return monthShortName(parsed.month);
+            }
+            return parsed.month;
+        }
+        return null;
+    }
+    if (binding.fieldKey !== 'full_name') {
+        return binding.valueHint === 'direct'
+            ? directStoredValue(protectedValues, binding.fieldKey)
+            : null;
+    }
+    const fullName = directStoredValue(protectedValues, 'full_name');
+    if (!fullName) {
+        return null;
+    }
+    const valueHint = binding.valueHint ?? 'direct';
+    if (valueHint === 'direct') {
+        return fullName;
+    }
+    const parts = splitFullName(fullName);
+    if (parts.length === 0) {
+        return null;
+    }
+    if (valueHint === 'full_name.given') {
+        return parts[0] ?? fullName;
+    }
+    if (valueHint === 'full_name.family') {
+        return parts.length > 1 ? (parts.at(-1) ?? fullName) : fullName;
+    }
+    return null;
+}

package/dist/secrets/types.d.ts

@@ -0,0 +1,70 @@
+export declare const LOGIN_FIELD_KEYS: readonly ["username", "password"];
+export declare const IDENTITY_FIELD_KEYS: readonly ["full_name", "document_number", "date_of_birth", "nationality", "issue_date", "expiry_date", "issuing_country"];
+export declare const PAYMENT_CARD_FIELD_KEYS: readonly ["cardholder", "pan", "exp_month", "exp_year", "cvv"];
+export type StoredSecretKind = 'login' | 'identity' | 'payment_card';
+export declare const STORED_SECRET_FIELD_KEYS_BY_KIND: {
+    readonly login: readonly ["username", "password"];
+    readonly identity: readonly ["full_name", "document_number", "date_of_birth", "nationality", "issue_date", "expiry_date", "issuing_country"];
+    readonly payment_card: readonly ["cardholder", "pan", "exp_month", "exp_year", "cvv"];
+};
+export type LoginFieldKey = (typeof LOGIN_FIELD_KEYS)[number];
+export type IdentityFieldKey = (typeof IDENTITY_FIELD_KEYS)[number];
+export type PaymentCardFieldKey = (typeof PAYMENT_CARD_FIELD_KEYS)[number];
+export type StoredSecretFieldKey = LoginFieldKey | IdentityFieldKey | PaymentCardFieldKey;
+export type StoredSecretScope = 'site' | 'global';
+export type ProtectedFieldPolicy = 'deterministic_only' | 'llm_assisted';
+export declare const PROTECTED_BINDING_VALUE_HINTS: readonly ["direct", "full_name.given", "full_name.family", "date_of_birth.day", "date_of_birth.month", "date_of_birth.year"];
+export type ProtectedBindingValueHint = (typeof PROTECTED_BINDING_VALUE_HINTS)[number];
+export type StoredSecretApplicabilityTarget = 'host' | 'site' | 'global';
+export interface StoredSecretApplicability {
+    target: StoredSecretApplicabilityTarget;
+    value?: string;
+}
+export type StoredSecretFieldPolicies = Partial<Record<StoredSecretFieldKey, ProtectedFieldPolicy>>;
+export interface StoredSecretMetadata {
+    storedSecretRef: string;
+    kind: StoredSecretKind;
+    scope: StoredSecretScope;
+    displayName: string;
+    fieldKeys: StoredSecretFieldKey[];
+    fieldPolicies?: StoredSecretFieldPolicies;
+    intentRequired: boolean;
+    applicability: StoredSecretApplicability;
+    preferredForMerchantKeys?: string[];
+}
+export interface SecretCatalogSnapshot {
+    source: 'mock' | 'remote_api';
+    host: string;
+    syncedAt: string;
+    storedSecrets: StoredSecretMetadata[];
+}
+export interface FillableFormFieldBinding {
+    fieldKey: StoredSecretFieldKey;
+    targetRef: string;
+    label?: string;
+    required?: boolean;
+    valueHint?: ProtectedBindingValueHint;
+}
+export interface FillableFormStoredSecretCandidate {
+    storedSecretRef: string;
+    kind: StoredSecretKind;
+    scope: StoredSecretScope;
+    displayName: string;
+    matchConfidence: 'high' | 'medium' | 'low';
+    intentRequired: boolean;
+    fieldKeys?: StoredSecretFieldKey[];
+    fieldPolicies?: StoredSecretFieldPolicies;
+}
+export type FillableFormPresence = 'present' | 'unknown' | 'absent';
+export interface PersistedFillableForm {
+    fillRef: string;
+    pageRef: string;
+    scopeRef?: string;
+    purpose: string;
+    presence?: FillableFormPresence;
+    scopeEpoch?: number;
+    fields: FillableFormFieldBinding[];
+    storedSecretCandidates: FillableFormStoredSecretCandidate[];
+    observedAt: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/secrets/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/secrets/types.ts"],"names":[],"mappings":"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"}

package/dist/secrets/types.js

@@ -0,0 +1,30 @@
+export const LOGIN_FIELD_KEYS = ['username', 'password'];
+export const IDENTITY_FIELD_KEYS = [
+    'full_name',
+    'document_number',
+    'date_of_birth',
+    'nationality',
+    'issue_date',
+    'expiry_date',
+    'issuing_country',
+];
+export const PAYMENT_CARD_FIELD_KEYS = [
+    'cardholder',
+    'pan',
+    'exp_month',
+    'exp_year',
+    'cvv',
+];
+export const STORED_SECRET_FIELD_KEYS_BY_KIND = {
+    login: LOGIN_FIELD_KEYS,
+    identity: IDENTITY_FIELD_KEYS,
+    payment_card: PAYMENT_CARD_FIELD_KEYS,
+};
+export const PROTECTED_BINDING_VALUE_HINTS = [
+    'direct',
+    'full_name.given',
+    'full_name.family',
+    'date_of_birth.day',
+    'date_of_birth.month',
+    'date_of_birth.year',
+];