@wenathlan/devthink 2.0.12 → 2.0.14

package/dist/security.d.ts

@@ -0,0 +1,534 @@
+/**
+ * The security module of the 1.1.90 consolidation: every correlated variation of the trust boundary logic interned in this one file, so the module family carries one surface without duplicate variations.
+ * The correlation is the trust boundary cluster: originpolicy holds the origin consent posture (the denydefault refusal, the exact origin automation allowlist with no wildcard expansion, the per site originprofiles, the consent windows bound in time, the mid run revocation and the sensitive class classification); inboundguard holds the entry gate of the background (the schemastrict command validation, the origincheck verdicts, the connectallow sender list that ships empty and the ratelimit buckets that defer past bound commands); maskinputs holds the field shape recognizer that keeps typed, form and stored values out of every log, observation and export behind the redaction marker; immutablelog holds the append only hash chained run log with its completion seal and its read time tamper detection; phishguard holds the lookalike watch that blocks credential steps on origins resembling granted ones under the user threshold; secretvault holds the vault seam (values enter through put and leave at the last possible moment before a credential field, records carry the digest only, and the leak scan refuses plaintext secrets in plans); and transparency holds the grant grammar the transparency page renders (the grant rows, the consent window history, the connectallow list and the permdiff of installed updates).
+ * No window, threshold, shape list, bucket bound or retention is ever hardcoded anywhere in the family: every bound stays the user's choice, no security decision ever widens past the human review, and no secret value ever reaches a storage writer, a log entry, a memory record or an export path.
+ */
+import type { actionkind, automationallowlistentry, classconsent, consentwindow, consentscope, deniedevidence, originprofile, revokerunevent, sensitiveclass, toolstep } from "./types.js";
+/**
+ * Origin consent policy logic of the 1.1.61 family.
+ * The trust boundary rules live here: the denydefault posture that refuses every ungranted origin, the per origin automation allowlist with exact origin matching and no wildcard expansion, the per site originprofiles that grant and deny single action kinds, the consentwindows that bind every grant in time with a named boundary, the mid run revokerun that halts the pending step and every queued step as a terminal session event, and the sensitive class classification that routes payment, credential, delete and publish steps through one fresh consent prompt per class per origin.
+ * No duration, boundary, kind list or class list is ever hardcoded: every window, profile and consent stays the user's choice, the active tab grant counts as exactly one explicit single origin grant, and no security decision ever bypasses the human review.
+ */
+/** The documented posture of the 1.1.61 family: every origin the user never granted stays refused by default. */
+export declare const denydefaultposture: "denydefault";
+/** Reads whether two origins match exactly: the allowlist binds every grant to one exact origin with no wildcard expansion, so a star, an empty segment or a scheme wildcard never covers any origin. */
+export declare function exactorigin(origin: string, entry: string): boolean;
+/** Refuses wildcard patterns as allowlist entries before any matching runs: no wildcard expansion exists because every grant binds to one exact origin. */
+export declare function wildcardentry(entry: string): boolean;
+/** Checks one origin against the per origin automation allowlist under the denydefault posture: an origin absent from the allowlist stays refused, the active tab origin counts as exactly one explicit single origin grant, and no wildcard expansion ever widens an entry. */
+export declare function allowlistcheck(input: {
+    origin: string;
+    allowlist: automationallowlistentry[];
+    profileid?: string;
+    sessionorigin?: string;
+}): {
+    allowed: boolean;
+    reason: string;
+};
+/** Builds one per site origin profile with its kind grants and denials; the profile consults before every sensitive kind on its origin. */
+export declare function originprofileof(input: {
+    profileid?: string;
+    origin: string;
+    grants?: actionkind[];
+    denials?: actionkind[];
+    now: number;
+}): originprofile;
+/** Grants or denies one action kind on one origin profile; a kind already sitting on the opposite list moves so the lists never overlap. */
+export declare function profilekind(input: {
+    profile: originprofile;
+    kind: actionkind;
+    decision: "grant" | "deny";
+    now: number;
+}): originprofile;
+/** Consults the per origin profile before one sensitive kind: an explicit denial refuses the kind on that origin, an explicit grant allows it while the fresh class consent gate still routes sensitive classes through their prompt, and an absent profile leaves the decision to the class consent gate. */
+export declare function profilegrade(input: {
+    profile: originprofile | undefined;
+    kind: actionkind;
+    sensitive: boolean;
+}): {
+    allowed: boolean;
+    consult: boolean;
+    reason: string;
+};
+/** Classifies one step into the sensitive classes: payment, credential, delete and publish kinds take their table class, the kind options refine the class when they carry card or credential field shapes, and uploads, downloads and evaluate grade sensitive by default without a named class. */
+export declare function sensitiveclassesof(step: Pick<toolstep, "kind" | "value" | "options">): {
+    classes: sensitiveclass[];
+    bydefault: boolean;
+    sensitive: boolean;
+    reason: string;
+};
+/** Reads whether one fresh class consent covers a class on an origin: each sensitive class needs its own fresh prompt per origin, an expired consent covers nothing and a consent of another class never widens. */
+export declare function classconsentcovers(consents: classconsent[], origin: string, sensitiveclass: sensitiveclass, now: number): boolean;
+/** Reads which fresh class consents one sensitive step still needs on its origin: every class the classification names needs its own prompt and a default sensitive grade without classes needs the plain sensitive prompt that the window itself carries. */
+export declare function missingclassconsents(input: {
+    origin: string;
+    classes: sensitiveclass[];
+    bydefault: boolean;
+    consents: classconsent[];
+    now: number;
+}): {
+    needed: boolean;
+    missing: sensitiveclass[];
+    reason: string;
+};
+/** Opens one consent window bound in time: the duration stays the user's positive choice, the boundary names itself in plain language and no window ever defaults to unlimited. */
+export declare function openconsentwindow(input: {
+    id?: string;
+    sessionid: string;
+    origin: string;
+    duration: number;
+    kinds: actionkind[];
+    now: number;
+    boundary?: string;
+}): consentwindow;
+/** Reads the state of one consent window at a time: an active window reports its remaining time while a window past its duration boundary reports its expiry. */
+export declare function consentwindowstate(window: consentwindow, now: number): {
+    state: "active" | "expired";
+    remaining: number;
+    reason: string;
+};
+/** Checks one step against its consent window: the window scopes to exactly one session and one origin, an expired window suspends the run mid step, and a step outside the window scope or past its boundary never dispatches. */
+export declare function windowgatesstep(input: {
+    window: consentwindow | undefined;
+    sessionid: string;
+    origin: string;
+    now: number;
+}): {
+    allowed: boolean;
+    suspended: boolean;
+    reason: string;
+};
+/** Closes every consent window past its duration boundary: the expired windows keep their records for the audit trail while their grants bind no step anymore. */
+export declare function expireconsentwindows(windows: consentwindow[], now: number): consentwindow[];
+/** Renews a consent window only through a new explicit prompt: the renewal opens a brand new window record with its own duration and boundary while the old window stays closed in the history. */
+export declare function renewconsentwindow(input: {
+    window: consentwindow;
+    duration: number;
+    kinds: actionkind[];
+    now: number;
+}): {
+    renewed: consentwindow;
+    closed: consentwindow;
+};
+/** Revokes one run mid step as a terminal session event: the pending step and every queued step halt without executing, and the record names the acting user and the reason. */
+export declare function revokerun(input: {
+    id?: string;
+    sessionid: string;
+    runid: string;
+    pendingstepid?: string;
+    queuedstepids?: string[];
+    actor: string;
+    reason?: string;
+    now: number;
+}): revokerunevent;
+/** Reads which steps one revocation halted with the pending step first: the rollback list the confirm dialog names before the user confirms. */
+export declare function haltedstepsof(revocation: revokerunevent): {
+    pending?: string;
+    queued: string[];
+};
+/** Builds one consent scope grant that names the origin, the kinds and the boundary in a single record; the session start writes it into the immutable log. */
+export declare function scopegrantof(input: {
+    origin: string;
+    kinds: actionkind[];
+    boundary: string;
+    now: number;
+}): consentscope;
+/** Builds one denied step evidence without navigation: the origin, the action kind and the deny reason in plain language. */
+export declare function deniedevidenceof(input: {
+    origin: string;
+    kind: string;
+    reason: string;
+    now: number;
+}): deniedevidence;
+/** Builds the consent prompt text of one pending sensitive step: the exact origin, the kind, the class badge and the consent window duration the user chooses; the prompt always names a boundary and never defaults to unlimited. */
+export declare function consentprompttext(input: {
+    origin: string;
+    kind: string;
+    classes: sensitiveclass[];
+    bydefault: boolean;
+    duration: number;
+}): string;
+/** Builds the denydefault notice of one origin for the popup: ungranted origins stay refused until the user grants them. */
+export declare function denydefaultnotice(origin: string): string;
+/** Builds the origin profile summary of the active tab for the popup: the granted and denied kinds the per site profile carries. */
+export declare function profilesummary(profile: originprofile | undefined): string;
+/** Builds the safedefaults profile of an unknown origin: the initial originprofile the executor applies when no profile exists grants the documented read kinds only and denies every sensitive class kind, so a first visit never runs a payment, credential, delete or publish step until the user edits the profile. */
+export declare function safedefaultprofile(input: {
+    origin: string;
+    now: number;
+    profileid?: string;
+}): originprofile;
+/** Reads whether one action kind sits inside the reads only baseline of the safedefaults posture. */
+export declare function safedefaultreadkind(kind: actionkind): boolean;
+/** Builds the safedefaults notice of an unknown origin for the popup: the notice links to the originprofile editor because only the user widens a safedefaults profile. */
+export declare function safedefaultnotice(origin: string): string;
+import type { connectallowentry, deferredevent, origincheckverdict, ratelimitbucket, schemaerror } from "./types.js";
+/**
+ * Inbound guard logic of the 1.1.62 family.
+ * Every message, command and connection that enters the background passes this guard chain: schemastrict validates each inbound command against its declared grammar and rejects unknown fields with the path and the expected shape, origincheck verdicts guard every runtime message and every port connection, connectallow holds the external senders the user allowed and ships empty by default so every unknown sender drops without handler execution, and the ratelimit buckets bound automation commands per origin and per session by deferring every command that exceeds its bucket until the window resets.
+ * No bound, window or sender list is ever hardcoded: the buckets stay user configured values with no hidden ceiling, and the connectallow list holds user managed entries only.
+ */
+/** The field shapes schemastrict understands: strings, numbers, booleans, plain objects and arrays, beside the absent marker a field the grammar never declared expects. */
+export type schemashape = "string" | "number" | "boolean" | "object" | "array" | "absent";
+/** Validates one inbound command under schemastrict: every field the grammar declares keeps its expected shape, a missing required field errors with its path, and a field the grammar never declared errors with the expected shape absent so the command never dispatches. */
+export declare function schemacheck(input: {
+    command: Record<string, unknown>;
+    schema: Record<string, schemashape>;
+    required?: string[];
+}): {
+    valid: boolean;
+    errors: schemaerror[];
+};
+/** Validates one inbound command envelope: the kind must be a non-empty string the dispatch registry knows, so an unknown command kind refuses before any handler runs. */
+export declare function envelopecheck(input: {
+    command: Record<string, unknown>;
+    knownkinds: readonly string[];
+}): {
+    valid: boolean;
+    errors: schemaerror[];
+};
+/** Checks one inbound runtime message or port connection through origincheck: an internal sender of this extension accepts, an external sender accepts only when its sender id sits in the connectallow list the user manages, and every other sender drops without handler execution. */
+export declare function origincheckof(input: {
+    senderid?: string;
+    senderorigin?: string;
+    extensionid: string;
+    connectallow: connectallowentry[];
+}): origincheckverdict;
+/** Checks one port connection through the same origincheck grammar: only ports of this extension or of allowed external senders accept, and every other port closes at the handshake. */
+export declare function portaccept(input: {
+    portname: string;
+    senderid?: string;
+    senderorigin?: string;
+    extensionid: string;
+    connectallow: connectallowentry[];
+}): origincheckverdict;
+/** Builds one connectallow entry: the external sender id the user allows, its display name and its optional origin scope; the list ships empty by default. */
+export declare function connectallowentryof(input: {
+    senderid: string;
+    displayname: string;
+    origin?: string;
+    now: number;
+}): connectallowentry;
+/** The empty connectallow list the extension ships with: no external sender accepts until the user adds its entry. */
+export declare const emptyconnectallow: connectallowentry[];
+/** Validates the user configured ratelimit bucket bounds: the limit and the window stay positive user values because no hidden ceiling exists. */
+export declare function bucketboundsvalid(limit: number, window: number): {
+    valid: boolean;
+    reason: string;
+};
+/** Builds one ratelimit bucket per origin and per session with its user configured bound and window. */
+export declare function bucketof(input: {
+    origin: string;
+    sessionid: string;
+    limit: number;
+    window: number;
+    now: number;
+}): ratelimitbucket;
+/** Consumes one command from its bucket: a command inside its bound consumes, a command past its bound defers until the window resets, and a window past its reset starts a fresh window. */
+export declare function bucketconsume(input: {
+    bucket: ratelimitbucket;
+    now: number;
+}): {
+    allowed: boolean;
+    deferred: boolean;
+    bucket: ratelimitbucket;
+    resetsat: number;
+    reason: string;
+};
+/** Builds one deferred command event: the step the bucket deferred with the reason and the reset time it waits for. */
+export declare function deferredeventof(input: {
+    stepid: string;
+    kind: string;
+    origin: string;
+    reason: string;
+    resetsat: number;
+    now: number;
+    id?: string;
+}): deferredevent;
+/** Reads whether one deferred command may retry: the deferral holds until its bucket window resets. */
+export declare function deferredready(deferred: deferredevent, now: number): boolean;
+import type { maskrule, observation, runsettings } from "./types.js";
+/**
+ * Mask inputs logic of the 1.1.61 family.
+ * The masking rules live here: typed values, form values and stored values never reach a log, an observation or an export unmasked when their field shapes match the documented password, token, card and secret families or the shapes the user configured; the observation schema keeps its field shapes while the values behind masked shapes carry their redaction marker instead.
+ * No shape list is closed: the documented four families stay the recognition baseline and the user extends them through the global maskshapes setting and the per origin mask rules, because a sensitive field shape stays the user's knowledge, never the engine's guess.
+ */
+/** The documented mask shape families the recognizer reads by default: password, token, card and secret field shapes; the user extends the list, never narrows the recognition below it. */
+export declare const defaultmaskshapes: readonly string[];
+/** The redaction marker every masked value carries; the marker stays visible so a review sees that a value existed without reading it. */
+export declare const maskmarker = "[redacted]";
+/** Reads the shape family one field name matches: password, token, card and secret shapes recognize by name while every other field keeps its value. */
+export declare function fieldshapekind(name: string): "password" | "token" | "card" | "secret" | undefined;
+/** Reads the effective mask shapes of one origin: the documented four families, the global user configured shapes and the per origin mask rules join into one recognition list. */
+export declare function shapesof(input: {
+    settings?: runsettings;
+    rules: maskrule[];
+    origin?: string;
+}): string[];
+/** Reads whether one field name matches the effective shapes: the documented recognizer runs first and the configured shapes match by substring. */
+export declare function maskingfield(name: string, shapes: string[]): boolean;
+/** Masks one value behind the redaction marker; an empty value stays empty because nothing existed to redact. */
+export declare function maskvalue(value: string): string;
+/** Masks one named field when its shape matches: the field keeps its name while its value carries the redaction marker. */
+export declare function maskfield(input: {
+    name: string;
+    value: string;
+    shapes: string[];
+}): string;
+/** Masks the typed values of one record deeply: every key whose shape matches keeps its key while its string value carries the redaction marker, and nested records walk the same rule. */
+export declare function maskrecord(record: Record<string, unknown>, shapes: string[]): Record<string, unknown>;
+/** Masks the typed value and the reviewed options of one step before they reach any log writer: a step whose target or kind names a masked shape keeps its shape while the typed value carries the redaction marker. */
+export declare function masktypedvalues(input: {
+    step: Pick<toolstep, "kind" | "target" | "value" | "options">;
+    shapes: string[];
+}): {
+    value?: string;
+    options?: string;
+};
+/** Masks one captured form state: every field keeps its name and type while a value behind a masked shape carries the redaction marker, so the observation schema keeps its field shapes but masks their values. */
+export declare function maskformstate<T extends {
+    name: string;
+    value: string;
+}>(fields: T[], shapes: string[]): Array<T & {
+    value: string;
+}>;
+/** Masks one observation payload before logging: the schema keeps every field shape while the option lists of fields whose names match a masked shape carry the redaction marker instead of their entries. */
+export declare function maskobservation(shot: observation, shapes: string[]): observation;
+/** Masks the stored values of one storage record: the keys keep their names while a value behind a masked shape carries the redaction marker. */
+export declare function maskstoredvalues(record: Record<string, string>, shapes: string[]): Record<string, string>;
+/** Excludes masked values from every export of the run record: a value that already carries the redaction marker stays visible as evidence a value existed, while any raw value behind a masked shape carries the marker before the export leaves the browser. */
+export declare function maskexport(record: Record<string, unknown>, shapes: string[]): Record<string, unknown>;
+import type { immutablelogentry, logeventkind, loghash, sealedlog, storedrunlog } from "./types.js";
+/** Derives the hash chain link of one log entry: the sha-256 over the predecessor hash and the canonical entry body, written once at append time. */
+export declare function entryhashof(input: {
+    previous: string;
+    entry: Omit<immutablelogentry, "hash">;
+}): Promise<loghash>;
+/** Builds one log entry with its chain link derived at append time: the event kind, the summary, the origin and step provenance and the time. */
+export declare function logentryof(input: {
+    id?: string;
+    runid: string;
+    kind: logeventkind;
+    summary: string;
+    origin: string;
+    stepid?: string;
+    at: number;
+    previous: string;
+}): Promise<immutablelogentry>;
+/** Opens one empty run log: the first entry of the log chains to the genesis hash of exactly sixty-four zeros. */
+export declare function openrunlog(input: {
+    runid: string;
+    sessionid: string;
+    now: number;
+}): storedrunlog;
+/** Reads the hash of the last entry of one log: the value the next append chains to, with the genesis hash for an empty log. */
+export declare function lasthashof(log: storedrunlog): string;
+/** Appends one event to the run log inside a single storage transaction the caller persists: the entry hash chains to its predecessor and is written at append time, and a sealed log refuses every append because the seal is terminal. */
+export declare function appendlogentry(input: {
+    log: storedrunlog;
+    kind: logeventkind;
+    summary: string;
+    origin: string;
+    stepid?: string;
+    at: number;
+    id?: string;
+}): Promise<storedrunlog>;
+/** Seals one run log at completion with a final hash: the seal chains to the last entry hash and closes the log with no later append. */
+export declare function sealrunlog(log: storedrunlog, now: number): Promise<{
+    log: storedrunlog;
+    seal: sealedlog;
+}>;
+/** Verifies the whole hash chain of one log at read time: every entry hash must chain to its predecessor and match its own body, so tampering with any summary, provenance or link stays detectable as tamper evidence. */
+export declare function verifylogchain(entries: immutablelogentry[]): Promise<{
+    valid: boolean;
+    brokenat?: number;
+    reason: string;
+}>;
+/** Reads one run log only through chain verification: a verified chain returns its entries while a chain with a broken link refuses the read entirely. */
+export declare function readverifiedlog(log: storedrunlog): Promise<{
+    ok: boolean;
+    entries: immutablelogentry[];
+    reason: string;
+}>;
+/** Reads the verification status of one stored run log for the panel: the chain validity, the entry count, the broken link when one exists and the seal hash at completion. */
+export declare function chainreportof(log: storedrunlog): Promise<{
+    runid: string;
+    valid: boolean;
+    entries: number;
+    brokenat?: number;
+    reason: string;
+    sealhash?: string;
+    sealedat?: number;
+}>;
+/** Exports one run log as an audit record only after the chain verifies: the entries, the chain status and the seal hash travel together while a broken link refuses the export. */
+export declare function exportlogchain(log: storedrunlog): Promise<{
+    runid: string;
+    entries: number;
+    chainvalid: boolean;
+    reason: string;
+    sealhash?: string;
+    sealedat?: number;
+    log: immutablelogentry[];
+}>;
+import type { phishverdict } from "./types.js";
+/**
+ * Phishguard logic of the 1.1.62 family.
+ * The lookalike watch lives here: before a credential step runs on a new origin, the guard compares the login target against every granted origin and measures the lookalike distance between their host labels, so a lookalike origin that sits close to a granted origin under the user threshold blocks the step and the deny event names the matched known origin.
+ * The threshold stays the user's choice between zero and one with no engine default, and the distance reads the host label order from the registrable side so a padded subdomain never hides a lookalike.
+ */
+/** Reads whether one step is a login or credential step: the credential kind families and the field shapes that carry passwords, tokens and secrets mark the step for the phishguard watch. */
+export declare function credentialstep(step: Pick<toolstep, "kind" | "target" | "value" | "options">): boolean;
+/** Splits one origin into its host labels from the registrable side: the comparison reads com.example.pay from https://pay.example.com so the distance weighs the distinguishing labels first. */
+export declare function originlabels(origin: string): string[];
+/** Measures the normalized lookalike distance between two origins in the zero to one range: identical origins carry zero, and every label edit moves the distance toward one. */
+export declare function lookalikedistance(one: string, two: string): number;
+/** Validates the phishguard threshold as a user choice between zero and one: no engine default exists and the boundary the user picks stays the only block line. */
+export declare function phishthresholdvalid(threshold: number): {
+    valid: boolean;
+    reason: string;
+};
+/** Renders one phishguard verdict for a login origin: the closest granted origin carries the distance, and a distance that crosses the user threshold blocks the step while the deny event names the matched known origin. */
+export declare function phishverdictof(input: {
+    origin: string;
+    granted: string[];
+    threshold: number;
+    now: number;
+}): phishverdict;
+/** Reads whether one stored phishguard verdict stays inside its freshness window: a verdict past the window leaves the live set while its record survives for the audit trail. */
+export declare function verdictfresh(verdict: phishverdict, now: number, freshness: number | undefined): boolean;
+/** Builds the plain language phishguard notice the surfaces show before a login step: the verdict, the matched origin and the threshold in one line. */
+export declare function phishnotetext(verdict: phishverdict): string;
+import type { secretvaultentry } from "./types.js";
+/**
+ * Secret vault logic of the 1.1.62 family.
+ * The vault seam lives here: secrets enter through put and leave through fetch at the last possible moment before a credential field, while the persisted records carry only the label, the exact origin scope, the profile workspace, the provenance and the sha-256 verification digest — no plaintext value ever reaches a storage writer, a log entry, a memory record or an export path.
+ * The scan paths refuse secrets in plain sight: a step option, a variable or a plan text whose value digests to a stored vault entry is a leak that refuses the plan, and a raw typed value behind a masked field shape never rides a step at all.
+ * Honest limit: the browser offers no vault hardware, so the seam rides the session storage area the background wires, which keeps values in memory only and never persists them to disk; the persistence layer stores metadata alone, mirroring the immutablelog seam honesty.
+ */
+/** The digest prefix every stored vault digest carries so raw values never persist anywhere. */
+export declare const vaultdigestprefix = "sha256:";
+/** Derives the sha-256 verification digest of one secret value through the platform crypto seam; the digest persists while the value never does. */
+export declare function vaultdigestof(value: string): Promise<string>;
+/** Builds one vault record from its metadata: the label, the exact origin scope, the profile workspace and the provenance; the digest verifies the value behind the seam without ever carrying it. */
+export declare function vaultentryof(input: {
+    label: string;
+    scope: string;
+    profileid: string;
+    provenance: "user" | "session";
+    digest: string;
+    now: number;
+    vaultid?: string;
+}): secretvaultentry;
+/** Creates an in memory vault seam: values live in the map only, which is the honest fallback the background wraps with the session storage area that never persists to disk. */
+export declare function inmemoryvault(): {
+    put(vaultid: string, value: string): Promise<void>;
+    fetch(vaultid: string): Promise<string | undefined>;
+    drop(vaultid: string): Promise<void>;
+};
+/** Stores one secret behind the vault seam and returns its metadata record alone: the value enters the seam and no return path carries it. */
+export declare function vaultstore(input: {
+    seam: {
+        put(vaultid: string, value: string): Promise<void>;
+    };
+    label: string;
+    scope: string;
+    profileid: string;
+    provenance: "user" | "session";
+    value: string;
+    now: number;
+}): Promise<secretvaultentry>;
+/** Reads one secret from the vault seam at the last possible moment before its credential field: the value returns to the dispatching caller only, never to a log writer, and the record stamps its last use. */
+export declare function vaultvaluefor(input: {
+    seam: {
+        fetch(vaultid: string): Promise<string | undefined>;
+    };
+    entry: secretvaultentry;
+}): Promise<{
+    ok: boolean;
+    value?: string;
+    reason: string;
+    used?: secretvaultentry;
+}>;
+/** Drops one secret from the vault seam; the metadata record leaves with it because a deleted secret leaves no trace a surface could read. */
+export declare function vaultdelete(input: {
+    seam: {
+        drop(vaultid: string): Promise<void>;
+    };
+    entry: secretvaultentry;
+}): Promise<{
+    dropped: boolean;
+    label: string;
+    reason: string;
+}>;
+/** Reads whether one vault record covers an origin: the scope binds to exactly one origin, so a secret of one site never rides another site. */
+export declare function vaultcovers(entry: secretvaultentry, origin: string): boolean;
+/** Scans candidate step values, variables and plan texts for leaked secrets: a candidate whose sha-256 digest matches a stored vault digest is a leak the plan refuses, because a plaintext secret outside the vault never rides a step, a variable or a plan. */
+export declare function secretleakscan(input: {
+    candidates: string[];
+    entries: secretvaultentry[];
+}): Promise<{
+    leaks: string[];
+    reason: string;
+}>;
+/** Reads whether one step carries a raw typed value behind a masked field shape: a credential step names its vault label instead, because a raw password or token value never rides a step option. */
+export declare function secretshapecarrying(step: Pick<toolstep, "kind" | "target" | "value" | "options">): {
+    carries: boolean;
+    reason: string;
+};
+/** Builds the vault view the surfaces render: the labels, scopes, provenance and last use times only, because no surface ever displays or exports a secret value. */
+export declare function vaultview(entries: secretvaultentry[]): Array<{
+    vaultid: string;
+    label: string;
+    scope: string;
+    provenance: string;
+    createdat: number;
+    lastusedat?: number;
+}>;
+/** Builds the plain language prompt of one credential step: the label the vault carries, never the value. */
+export declare function vaultprompttext(entry: secretvaultentry, origin: string): string;
+import type { permdiffrecord, transparencygrant } from "./types.js";
+/**
+ * Transparency logic of the 1.1.62 family.
+ * The transparencypage grammar lives here: every active grant reads as one row with its origin, scope and boundary, every consent window ever granted stays listed with its expiry even after it closed, the connectallow entries list with their senders, and the permdiff of each installed update records the added and removed permissions between two versions.
+ * The revoke actions stay one descriptor per grant row, because every listed grant revokes from the same page that shows it.
+ */
+/** Computes the permdiff between two permission versions: the permissions the new version added, the permissions it removed and the computed time; an unchanged set carries empty lists while the record still lands for the audit trail. */
+export declare function permissiondiff(input: {
+    from: string[];
+    to: string[];
+    fromversion: string;
+    toversion: string;
+    now: number;
+}): permdiffrecord;
+/** Reads whether one permdiff record reports a change between its versions; an unchanged permission set still records for the audit trail. */
+export declare function permdiffchanged(diff: permdiffrecord): boolean;
+/** Builds the plain language summary of one permdiff record for the transparencypage. */
+export declare function permdiffsummary(diff: permdiffrecord): string;
+/** Builds the transparency grant rows of every active grant: each allowlist origin carries its profile workspace scope and its grant time, and each originprofile carries its per kind scope. */
+export declare function transparencygrants(input: {
+    allowlist: automationallowlistentry[];
+    profiles: originprofile[];
+}): transparencygrant[];
+/** Builds the revoke action descriptor of one transparency grant row: every listed grant revokes from the same page that shows it. */
+export declare function revokeaction(grant: transparencygrant): {
+    action: "revoke";
+    origin: string;
+    scope: string;
+};
+/** Lists every consent window ever granted with its expiry: closed windows stay listed beside the active ones because the transparency page shows the whole grant history. */
+export declare function windowhistory(windows: consentwindow[]): Array<{
+    id: string;
+    origin: string;
+    state: string;
+    boundary: string;
+    startedat: number;
+    expiresat: number;
+}>;
+/** Lists the connectallow entries with their senders: the display names, the sender ids and the origin scopes the user allowed. */
+export declare function connectallowlist(entries: connectallowentry[]): Array<{
+    senderid: string;
+    displayname: string;
+    origin?: string;
+    addedat: number;
+}>;
+//# sourceMappingURL=security.d.ts.map