@ai-ecoverse/slicc-spectrum 1.62.2 → 1.64.0

package/dist/types/app/composer.d.ts

@@ -9,7 +9,7 @@ import '@adobe/spectrum-wc-icons/swc-icon-file.js';
 import '@adobe/spectrum-wc-icons/swc-icon-file-text.js';
 import '@adobe/spectrum-wc-icons/swc-icon-lock.js';
 import { type PropertyValues, type TemplateResult } from 'lit';
-import type { Attachment, Outgoing, SendMode, SliccModel } from '../model/types.js';
+import type { Attachment, Outgoing, SendMode, SliccModel, VaultPort } from '../model/types.js';
 import { ThemedElement } from './base.js';
 export declare const limit: number;
 export interface Choice {
@@ -42,6 +42,7 @@ export declare function trigger(text: string, caret: number): {
     start: number;
     query: string;
 } | null;
+export declare function blocked(vault: VaultPort): string | null;
 export declare class SliccComposer extends ThemedElement {
     #private;
     static properties: {
@@ -63,6 +64,15 @@ export declare class SliccComposer extends ThemedElement {
         blocked: {
             state: boolean;
         };
+        sharing: {
+            state: boolean;
+        };
+        secretError: {
+            state: boolean;
+        };
+        secretField: {
+            state: boolean;
+        };
         agent: {};
     };
     value: string;
@@ -70,12 +80,16 @@ export declare class SliccComposer extends ThemedElement {
     popup: Popup | null;
     dictating: boolean;
     blocked: boolean;
+    sharing: boolean;
+    secretError: string | null;
+    secretField: string | null;
     agent: string;
     constructor();
     static styles: import("lit").CSSResult[];
     protected willUpdate(changed: PropertyValues<this>): void;
     connectedCallback(): void;
     protected firstUpdated(): void;
+    disconnectedCallback(): void;
     protected updated(changed: Map<string, unknown>): void;
     protected subscribe(model: SliccModel): Array<() => void>;
     focus(): void;
@@ -85,7 +99,7 @@ export declare class SliccComposer extends ThemedElement {
     detach(id: string): void;
     screenshot(): Promise<void>;
     attachPath(path: string): Promise<void>;
-    shareSecret(name: string): void;
+    shareSecret(name: string, field?: HTMLInputElement | null): Promise<void>;
     openPopup(kind: 'file' | 'secret'): void;
     pick(choice: Choice): void;
     dictate(): void;

package/dist/types/app/messages.d.ts

@@ -21,6 +21,7 @@ import '@adobe/spectrum-wc-icons/swc-icon-edit.js';
 import '@adobe/spectrum-wc-icons/swc-icon-file.js';
 import '@adobe/spectrum-wc-icons/swc-icon-file-text.js';
 import '@adobe/spectrum-wc-icons/swc-icon-globe-grid.js';
+import '@adobe/spectrum-wc-icons/swc-icon-info-circle.js';
 import '@adobe/spectrum-wc-icons/swc-icon-lock.js';
 import '@adobe/spectrum-wc-icons/swc-icon-plugin.js';
 import '@adobe/spectrum-wc-icons/swc-icon-search.js';

package/dist/types/app/monitor.d.ts

@@ -5,6 +5,7 @@ import '@adobe/spectrum-wc/components/status-light/swc-status-light.js';
 import '@adobe/spectrum-wc-icons/swc-icon-alert-triangle.js';
 import '@adobe/spectrum-wc-icons/swc-icon-alert-diamond.js';
 import '@adobe/spectrum-wc-icons/swc-icon-chevron-right.js';
+import '@adobe/spectrum-wc-icons/swc-icon-copy.js';
 import { type TemplateResult } from 'lit';
 import type { MonitorSection, MonitorStatus, SliccModel } from '../model/types.js';
 import { ModelElement } from './base.js';
@@ -27,8 +28,16 @@ export declare class SliccMonitor extends ModelElement {
         expanded: {
             state: boolean;
         };
+        copied: {
+            state: boolean;
+        };
     };
     expanded: Record<string, boolean>;
+    copied: {
+        id: string;
+        text: string;
+        done: boolean;
+    } | null;
     constructor();
     static styles: import("lit").CSSResult[];
     protected subscribe(model: SliccModel): Array<() => void>;

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

@@ -1,9 +1,13 @@
 import '@adobe/spectrum-wc/components/badge/swc-badge.js';
 import '@adobe/spectrum-wc/components/button/swc-button.js';
+import '@adobe/spectrum-wc/components/progress-circle/swc-progress-circle.js';
 import '@adobe/spectrum-wc/components/status-light/swc-status-light.js';
 import '@adobe/spectrum-wc-icons/swc-icon-alert-triangle.js';
+import '@adobe/spectrum-wc-icons/swc-icon-info-circle.js';
+import '@spectrum-web-components/menu/sp-menu-item.js';
+import '@spectrum-web-components/picker/sp-picker.js';
 import { nothing, type PropertyValues, type TemplateResult } from 'lit';
-import type { AuditEntry, LinkedDevice, PolicyNotice, SecretView, SliccModel, VaultPort } from '../model/types.js';
+import type { AuditEntry, ImportCandidate, ImportKind, LinkedDevice, PendingRequest, PolicyEntry, SecretView, SliccModel, VaultPort } from '../model/types.js';
 import { ThemedElement } from './base.js';
 import { type PopupDetail } from './vault.js';
 export declare function until(at: number, now?: number): string;
@@ -11,10 +15,42 @@ export declare function who(entry: {
     uid: number | null;
     tag: string | null;
 }): string;
+export declare function asker(request: PendingRequest): string;
+export declare function asking(request: PendingRequest): TemplateResult;
+export declare function byName(a: SecretView, b: SecretView): number;
 export declare function sourceLine(secret: SecretView, devices: readonly LinkedDevice[]): string;
 export declare function revealed(name: string, entries: readonly AuditEntry[], now?: number, more?: boolean): TemplateResult | null;
+export declare function changes(entry: PolicyEntry, devices: readonly LinkedDevice[]): string[][];
 export declare function auditLine(entry: AuditEntry, devices: readonly LinkedDevice[]): TemplateResult;
 export declare function merged(...pages: ReadonlyArray<readonly AuditEntry[]>): AuditEntry[];
+export declare function replaceable(secret: SecretView): boolean;
+export declare function filename(now?: number): string;
+export declare function download(bytes: Uint8Array, name: string, root: Node): void;
+export type SecretForm = {
+    kind: 'add';
+} | {
+    kind: 'replace';
+    name: string;
+} | {
+    kind: 'import';
+} | {
+    kind: 'export';
+};
+export type Said = {
+    kind: 'saved';
+    name: string;
+} | {
+    kind: 'imported';
+    imported: number;
+    skipped: {
+        name: string;
+        reason?: string;
+    }[];
+} | {
+    kind: 'exported';
+    file: string;
+};
+export declare function exported(at: number | null | undefined): TemplateResult | typeof nothing;
 export declare function prompt(text: string): string;
 export declare class SliccSecrets extends ThemedElement {
     #private;
@@ -37,10 +73,37 @@ export declare class SliccSecrets extends ThemedElement {
         popup: {
             state: boolean;
         };
-        acking: {
+        failure: {
             state: boolean;
         };
-        failure: {
+        form: {
+            state: boolean;
+        };
+        busy: {
+            state: boolean;
+        };
+        problem: {
+            state: boolean;
+        };
+        invalid: {
+            state: boolean;
+        };
+        said: {
+            state: boolean;
+        };
+        acting: {
+            state: boolean;
+        };
+        importKind: {
+            state: boolean;
+        };
+        candidates: {
+            state: boolean;
+        };
+        picked: {
+            state: boolean;
+        };
+        again: {
             state: boolean;
         };
     };
@@ -49,15 +112,33 @@ export declare class SliccSecrets extends ThemedElement {
     loading: boolean;
     reveals: boolean;
     popup: PopupDetail | null;
-    acking: ReadonlySet<string>;
     failure: string | null;
+    form: SecretForm | null;
+    busy: boolean;
+    problem: string | null;
+    invalid: string | null;
+    said: Said | null;
+    acting: ReadonlySet<string>;
+    importKind: ImportKind;
+    candidates: readonly ImportCandidate[] | null;
+    picked: ReadonlySet<string>;
+    again: boolean;
     constructor();
-    static styles: import("lit").CSSResult;
+    static styles: import("lit").CSSResult[];
     disconnectedCallback(): void;
     protected willUpdate(changed: PropertyValues): void;
     protected updated(): void;
     protected subscribe(model: SliccModel): Array<() => void>;
+    open(form: SecretForm | null): void;
+    save(vault: VaultPort): Promise<void>;
+    removeSecret(vault: VaultPort, secret: SecretView, trigger?: HTMLElement | null): Promise<void>;
+    restoreSecret(vault: VaultPort, secret: SecretView): Promise<void>;
+    cancelRequest(vault: VaultPort, id: string): Promise<void>;
+    lockVault(vault: VaultPort): Promise<void>;
+    dismissBackup(vault: VaultPort): Promise<void>;
+    answer(id: string): void;
+    read(vault: VaultPort): Promise<void>;
+    exportAll(vault: VaultPort, trigger?: HTMLElement | null): Promise<void>;
     showOlder(vault: VaultPort, entries: readonly AuditEntry[]): Promise<void>;
-    acknowledge(vault: VaultPort, notice: PolicyNotice): Promise<void>;
     render(): TemplateResult | typeof nothing;
 }

package/dist/types/app/value-request.d.ts

@@ -0,0 +1,47 @@
+import '@adobe/spectrum-wc/components/button/swc-button.js';
+import '@adobe/spectrum-wc-icons/swc-icon-alert-triangle.js';
+import '@spectrum-web-components/alert-dialog/sp-alert-dialog.js';
+import { type PropertyValues } from 'lit';
+import type { PendingRequest, SliccModel, VaultPort } from '../model/types.js';
+import { ThemedElement } from './base.js';
+export declare function valueRequests(vault: VaultPort | undefined, now: number): PendingRequest[];
+export declare class SliccValueRequest extends ThemedElement {
+    #private;
+    static properties: {
+        model: {
+            attribute: boolean;
+        };
+        now: {
+            state: boolean;
+        };
+        busy: {
+            state: boolean;
+        };
+        problem: {
+            state: boolean;
+        };
+        blocked: {
+            state: boolean;
+        };
+    };
+    now: number;
+    busy: boolean;
+    problem: {
+        id: string;
+        text: string;
+        field?: string;
+    } | null;
+    blocked: boolean;
+    constructor();
+    static styles: import("lit").CSSResult[];
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected subscribe(model: SliccModel): Array<() => void>;
+    reopen(id: string): void;
+    later(id: string): void;
+    save(request: PendingRequest): Promise<void>;
+    cancelRequest(request: PendingRequest): Promise<void>;
+    protected willUpdate(changed: PropertyValues): void;
+    protected updated(changed: PropertyValues): void;
+    render(): unknown;
+}

package/dist/types/app/vault.d.ts

@@ -1,19 +1,25 @@
 import { LitElement, type PropertyValues } from 'lit';
-import type { ButtonConfig, ExecGrant, ExitName, LinkedDevice, PopupIntent, PopupResult, PopupState, Rule, SliccModel, VaultPort, Widening } from '../model/types.js';
+import type { ButtonConfig, ExecGrant, ExecMode, ExitName, LinkedDevice, PolicyChange, PopupIntent, PopupState, Rule, SliccModel, VaultPort, Widening } from '../model/types.js';
 export declare function devicesOf(model: SliccModel | null): readonly LinkedDevice[];
 export declare function deviceName(id: string, devices: readonly LinkedDevice[]): string;
 export declare function exitLabel(exit: ExitName, devices: readonly LinkedDevice[]): string;
 export declare function list(items: readonly string[]): string;
 export declare function ruleLine(rule: Rule): string;
 export declare function shellWord(word: string): string;
-export declare function execLine(grant: ExecGrant): string;
+export declare function execLine(exec: ExecMode | ExecGrant, argv?: readonly string[][]): string | null;
+export declare function changeLine(change: PolicyChange, devices: readonly LinkedDevice[]): string;
 export declare function widening(change: Widening, devices: readonly LinkedDevice[]): string;
+export declare function failureText(error: unknown): string;
+export declare function fieldOf(error: unknown, field: string): string | null;
+export declare function away(vault: VaultPort): boolean;
+export declare function take(input: HTMLInputElement): string;
+export declare function clearValues(root: ParentNode): void;
+export declare const fieldStyles: import("lit").CSSResult;
 export declare function tabbables(root: ParentNode, stop: Element, out?: Array<HTMLElement | null>): Array<HTMLElement | null>;
 export declare function sequential(order: Array<HTMLElement | null>): Array<HTMLElement | null>;
 export interface PopupDetail {
     intent: PopupIntent;
     state: PopupState;
-    result?: PopupResult;
 }
 export declare class SliccVaultButton extends LitElement {
     #private;

package/dist/types/dummy/vault.d.ts

@@ -1,10 +1,12 @@
 import { Emitter } from '../model/emitter.js';
-import type { AuditEntry, AuditPage, ButtonConfig, ButtonEvent, ButtonMessage, PolicyNotice, SecretView, VaultButton, VaultEvents, VaultList, VaultPort, VaultStatus } from '../model/types.js';
+import type { AuditEntry, AuditPage, Availability, ButtonConfig, ButtonEvent, ButtonMessage, ErrorCode, ImportKind, ImportPick, ImportResult, PolicyNotice, PopupIntent, RecordKind, RefusedRule, RequestState, SealResult, SecretView, VaultButton, VaultEvents, VaultList, VaultPort, VaultStatus } from '../model/types.js';
 import type { Clock } from './clock.js';
-export type VaultScenario = 'empty' | 'secrets' | 'notice' | 'locked';
+export type VaultScenario = 'empty' | 'secrets' | 'policy' | 'notice' | 'locked' | 'request' | 'backup' | 'waiting';
 export declare function vaultSecrets(now?: number): SecretView[];
 export declare function vaultAudit(now?: number): AuditEntry[];
 export declare function vaultOlder(now?: number): AuditEntry[];
+export declare function vaultRefused(): RefusedRule[];
+export declare function vaultPolicy(now?: number): AuditEntry;
 export declare function vaultNotice(now?: number): PolicyNotice;
 export declare function vaultFixtures(scenario: VaultScenario, now?: number): {
     status: VaultStatus;
@@ -18,25 +20,44 @@ export declare class DummyVaultButton implements VaultButton {
     post(message: ButtonMessage): void;
     listen(listener: (event: ButtonEvent) => void): () => void;
 }
+export interface DummyImport {
+    kind: ImportKind;
+    size: number;
+    password: boolean;
+    pick?: ImportPick[];
+}
 export declare class DummyVault extends Emitter<VaultEvents> implements VaultPort {
     #private;
     buttons: DummyVaultButton[];
+    puts: {
+        name: string;
+        request?: string;
+    }[];
+    cancelled: string[];
+    imports: DummyImport[];
+    exported: number;
     acknowledged: string[];
     constructor(scenario: VaultScenario, time: Clock);
-    status(): VaultStatus;
-    list(): VaultList;
-    audit(before?: number, limit?: number): Promise<AuditPage>;
+    status(): VaultStatus | null;
+    list(): VaultList | null;
+    availability(): Availability;
+    arrive(): void;
+    fail(code: ErrorCode, message: string): void;
     acknowledge(notice: string): Promise<void>;
+    dismissBackupReminder(): Promise<void>;
+    audit(before?: number, limit?: number): Promise<AuditPage>;
+    put(name: string, value: string, request?: string): Promise<SealResult>;
+    cancel(request: string): Promise<RequestState>;
+    remove(name: string, kind?: RecordKind): Promise<SealResult>;
+    restore(name: string, kind?: RecordKind): Promise<SealResult>;
+    import(kind: ImportKind, bytes: Uint8Array, options?: {
+        password?: string;
+        pick?: ImportPick[];
+    }): Promise<ImportResult>;
+    export(passphrase: string): Promise<Uint8Array>;
+    lock(): Promise<void>;
     button(): DummyVaultButton;
     autoLabel(): string;
-    autoIntent(): {
-        kind: 'unlock';
-    } | {
-        kind: 'manage';
-    };
-    answer(intent: Exclude<ButtonConfig['intent'], 'auto'>): Promise<{
-        name: string;
-        placeholder: string;
-        state: 'active';
-    } | null>;
+    autoIntent(): PopupIntent;
+    answer(intent: PopupIntent): Promise<void>;
 }

package/dist/types/dummy.d.ts

@@ -18,4 +18,4 @@ export { DummyTabs, tabsFixtures } from './dummy/tabs.js';
 export type { DummyUpdatesOptions, PackageConfirm, PackageScenario, UpdateScenario, } from './dummy/updates.js';
 export { DummyUpdates, packageFixtures, updateFixtures } from './dummy/updates.js';
 export type { VaultScenario } from './dummy/vault.js';
-export { DummyVault, DummyVaultButton, vaultAudit, vaultFixtures, vaultNotice, vaultOlder, vaultSecrets, } from './dummy/vault.js';
+export { DummyVault, DummyVaultButton, vaultAudit, vaultFixtures, vaultNotice, vaultOlder, vaultPolicy, vaultRefused, vaultSecrets, } from './dummy/vault.js';

package/dist/types/model/types.d.ts

@@ -16,6 +16,10 @@ export interface Agent {
     title?: string;
 }
 export type ToolStatus = 'running' | 'done' | 'error' | 'cancelled';
+export interface ToolNote {
+    severity: 'error' | 'warn' | 'info';
+    text: string;
+}
 export interface ToolCall {
     id: string;
     name: string;
@@ -32,6 +36,7 @@ export interface ToolCall {
         before: string;
         after: string;
     };
+    notes?: ToolNote[];
 }
 export type AttachmentKind = 'image' | 'text' | 'file' | 'secret';
 export interface Attachment {
@@ -489,6 +494,8 @@ export interface MonitorAlert {
     title: string;
     detail: string;
     severity: 'warn' | 'error';
+    command?: string;
+    commandLabel?: string;
 }
 export interface MonitorSnapshot {
     vitals: MonitorVital[];
@@ -815,19 +822,32 @@ export interface FollowPort extends Subscribable<{
 export type DeviceId = string;
 export type RecordKind = 'secret' | 'grant' | 'model' | 'mcp';
 export type RecordState = 'active' | 'inert' | 'removed';
-export type RecordSource = 'popup' | 'process' | `jerk:${string}@${DeviceId}` | `oauth:${string}` | `import:${string}`;
+export type RecordSource = 'settings' | 'popup' | 'process' | `jerk:${string}@${DeviceId}` | `oauth:${string}` | `import:${string}`;
 export type LockMode = 'auto' | 'passkey' | 'passphrase';
 export type RequestKind = 'value' | 'oauth' | 'jerk-seal';
-export type ExitName = 'vault-direct' | 'local-proxy' | 'cli-v' | 'tailscale' | 'local-link' | `device:${DeviceId}`;
+export type RequestState = 'pending' | 'done' | 'cancelled' | 'expired';
+export type ErrorCode = 'EINVAL' | 'ENOENT' | 'EACCES' | 'EEXIST' | 'EAGAIN' | 'ETIMEDOUT' | 'ENOTCONN' | 'ENOTSUP';
+export interface VaultError {
+    code: ErrorCode;
+    message: string;
+}
+export type VaultFailure = Error & VaultError;
+export type ExitName = 'page' | 'proxy' | 'vault-direct' | 'local-proxy' | 'cli-v' | 'tailscale' | 'local-link' | `device:${DeviceId}`;
 export type ExecGrant = boolean | {
     argv: string[][];
 };
+export type ExecMode = false | 'any' | 'argv' | 'shell';
 export interface Rule {
     domain: string;
     header: string;
     methods: string[];
     paths: string[];
 }
+export interface RefusedRule {
+    secret: string;
+    rule: Rule;
+    reason: string;
+}
 export interface SecretView {
     name: string;
     kind: RecordKind;
@@ -839,8 +859,9 @@ export interface SecretView {
     account?: string;
     domains: string[];
     rules: Rule[];
-    exits: ExitName[];
-    exec: ExecGrant;
+    exits?: ExitName[];
+    exec: ExecMode | ExecGrant;
+    execArgv?: string[][];
     createdAt: number;
     usedAt?: number;
     expiresAt?: number;
@@ -857,15 +878,25 @@ export interface PendingRequest {
     createdAt: number;
     expiresAt: number;
 }
+export interface ScrubState {
+    needed: boolean;
+    version: number;
+    ready: boolean;
+}
+export type BackupReminder = 'due' | 'dismissed' | null;
 export interface VaultStatus {
     version: string;
     protocol: 1;
     origin: string;
     locked: boolean;
     lock: LockMode;
+    scrub?: ScrubState;
     waiting: PendingRequest[];
-    notices: number;
+    notices?: number;
+    exportedAt?: number | null;
+    backupReminder?: BackupReminder;
 }
+export type Availability = 'connecting' | 'waiting' | 'locked' | 'ready';
 export type Widening = {
     kind: 'rule';
     secret: string;
@@ -894,6 +925,27 @@ export type Widening = {
     from: number;
     to: number;
 };
+export type PolicyChange = {
+    kind: 'rule';
+    secret: string;
+    rule: Rule;
+    change: 'added' | 'removed';
+} | {
+    kind: 'exec';
+    secret: string;
+    from: ExecMode;
+    to: ExecMode;
+} | {
+    kind: 'exits';
+    secret: string;
+    from: ExitName[] | null;
+    to: ExitName[] | null;
+} | {
+    kind: 'limits';
+    field: string;
+    from: number;
+    to: number;
+};
 export type PolicyFile = '/etc/fnox/config.toml' | '/etc/slicc/secrets-policy.toml';
 export interface PolicyNotice {
     id: string;
@@ -921,7 +973,8 @@ export interface InjectionEntry extends AuditBase {
 }
 export interface RevealEntry extends AuditBase {
     type: 'materialize';
-    grant: ExecGrant;
+    grant?: ExecGrant;
+    exec?: ExecMode;
     path: string;
     argv: string;
     argvSha256: string;
@@ -939,6 +992,10 @@ export interface SealEntry extends AuditBase {
 export interface RemoveEntry extends AuditBase {
     type: 'remove' | 'restore';
 }
+export interface RefreshEntry extends AuditBase {
+    type: 'refresh';
+    grant?: string;
+}
 export interface PolicyEntry {
     type: 'policy';
     seq: number;
@@ -947,23 +1004,62 @@ export interface PolicyEntry {
     file: PolicyFile;
     sha256: string;
     accepted: boolean;
-    widened: Widening[];
+    widened?: Widening[];
+    changes?: PolicyChange[];
     warning?: string;
 }
-export type AuditEntry = InjectionEntry | RevealEntry | SealEntry | RemoveEntry | PolicyEntry;
+export type AuditEntry = InjectionEntry | RevealEntry | SealEntry | RemoveEntry | RefreshEntry | PolicyEntry;
 export interface AuditPage {
     audit: AuditEntry[];
     more: boolean;
     next?: number;
 }
+export interface ExitPolicyView {
+    file: '/etc/slicc/secrets-policy.toml';
+    sha256: string | null;
+    restricted: {
+        name: string;
+        exits: ExitName[];
+    }[];
+}
 export interface VaultList {
     secrets: SecretView[];
-    notices: PolicyNotice[];
+    notices?: PolicyNotice[];
+    refused?: RefusedRule[];
     audit: AuditEntry[];
     auditMore: boolean;
+    exits?: ExitPolicyView;
 }
+export interface SealResult {
+    name: string;
+    placeholder: string;
+    state: RecordState;
+}
+export type ImportKind = 'bundle' | 'keepass' | 'six';
+export interface ImportCandidate {
+    name: string;
+    kind?: RecordKind;
+    exists: boolean;
+    suggestedRules?: string;
+    refused?: string;
+}
+export type ImportPick = string | {
+    name: string;
+    kind: RecordKind;
+};
+export type ImportResult = {
+    stage: 'pick';
+    candidates: ImportCandidate[];
+} | {
+    stage: 'done';
+    imported: SealResult[];
+    skipped: string[];
+    reasons?: Record<string, string>;
+};
 export type PopupIntent = {
     kind: 'unlock';
+} | {
+    kind: 'protect';
 } | {
     kind: 'enter';
     name: string;
@@ -1044,12 +1140,25 @@ export interface VaultEvents {
     status: VaultStatus;
     list: VaultList;
     notice: PolicyNotice;
+    availability: Availability;
 }
 export interface VaultPort extends Subscribable<VaultEvents> {
     status(): VaultStatus | null;
     list(): VaultList | null;
     audit(before?: number, limit?: number): Promise<AuditPage>;
-    acknowledge(notice: string): Promise<void>;
+    acknowledge?(notice: string): Promise<void>;
+    availability?(): Availability;
+    put?(name: string, value: string, request?: string): Promise<SealResult>;
+    cancel?(request: string): Promise<RequestState>;
+    remove?(name: string, kind?: RecordKind): Promise<SealResult>;
+    restore?(name: string, kind?: RecordKind): Promise<SealResult>;
+    import?(kind: ImportKind, bytes: Uint8Array, options?: {
+        password?: string;
+        pick?: ImportPick[];
+    }): Promise<ImportResult>;
+    export?(passphrase: string): Promise<Uint8Array>;
+    lock?(): Promise<void>;
+    dismissBackupReminder?(): Promise<void>;
     button(): VaultButton;
 }
 export interface SliccModel {

package/dist/types/model/values.d.ts

@@ -0,0 +1,5 @@
+import type { ErrorCode, VaultFailure } from './types.js';
+export declare function valueProblem(value: string): string | null;
+export declare function nameProblem(name: string): string | null;
+export declare function vaultFailure(code: ErrorCode, message: string): VaultFailure;
+export declare function isVaultFailure(error: unknown): error is VaultFailure;

package/dist/types/ui.d.ts

@@ -13,6 +13,7 @@ import { SliccNetwork } from './app/network.js';
 import { SliccNotices } from './app/notices.js';
 import { SliccSecrets } from './app/secrets.js';
 import { SliccUpdates } from './app/updates.js';
+import { SliccValueRequest } from './app/value-request.js';
 import { SliccVaultButton } from './app/vault.js';
 import { SliccCodeView, SliccDiffView } from './components/code-view.js';
 import { SliccDock } from './components/dock.js';
@@ -33,5 +34,6 @@ export type { GitStatusEntry } from './components/file-tree.js';
 export type { Listener, Subscribable } from './model/emitter.js';
 export { Emitter } from './model/emitter.js';
 export type * from './model/types.js';
-export { SliccAgents, SliccApp, SliccApprovals, SliccBrowser, SliccChanges, SliccChat, SliccCodeView, SliccComposer, SliccConfirm, SliccDiffPanel, SliccDiffView, SliccDock, SliccFiles, SliccFileTree, SliccFileView, SliccFollow, SliccNetwork, SliccNotices, SliccPrompt, SliccSecrets, SliccUpdates, SliccVaultButton, };
+export { isVaultFailure } from './model/values.js';
+export { SliccAgents, SliccApp, SliccApprovals, SliccBrowser, SliccChanges, SliccChat, SliccCodeView, SliccComposer, SliccConfirm, SliccDiffPanel, SliccDiffView, SliccDock, SliccFiles, SliccFileTree, SliccFileView, SliccFollow, SliccNetwork, SliccNotices, SliccPrompt, SliccSecrets, SliccUpdates, SliccValueRequest, SliccVaultButton, };
 export declare function define(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-spectrum",
-  "version": "1.62.2",
+  "version": "1.64.0",
   "description": "Web components for SLICC on Spectrum Web Components: the terminal, the app shell and its surfaces",
   "type": "module",
   "license": "Apache-2.0",
@@ -53,7 +53,7 @@
     "pretest": "npm run build && playwright-core install --no-shell chromium",
     "test": "node --test --test-global-setup=node_modules/@ai-ecoverse/slicc-shared-web/harness/global.mjs 'test/integration/*.test.mjs'",
     "test:unit": "NODE_NO_WARNINGS=1 mcr -c node_modules/@ai-ecoverse/slicc-shared-web/mcr.config.mjs node --test 'test/unit/**/*.test.mjs'",
-    "typecheck": "tsc",
+    "typecheck": "tsc && tsc -p compat",
     "lint": "slicc-lint",
     "format": "biome check --write ."
   },
@@ -74,6 +74,7 @@
     "@adobe/spectrum-wc-icons": "2.0.0-beta.4",
     "@ai-ecoverse/slicc-kernel": "1.69.0",
     "@ai-ecoverse/slicc-shared-web": "1.13.1",
+    "@ai-ecoverse/slicc-vault": "1.1.0",
     "@ai-ecoverse/wasm-bash": "5.3.0-17",
     "@ai-ecoverse/wasm-coreutils": "9.7.0-3",
     "@biomejs/biome": "2.5.15",