@push.rocks/smartsecret 1.0.2 → 1.2.0

package/dist_ts/smartsecret.kernelstore.js

@@ -0,0 +1,442 @@
+import * as plugins from './smartsecret.plugins.js';
+import { SmartSecretKernelStoreError, createSmartSecretKernelStoreError, } from './smartsecret.kernel.error.js';
+import { deriveSmartSecretKernelEntryDescription, deriveSmartSecretKernelMutexNamespace, deriveSmartSecretKernelServiceDescription, encodeCanonicalBase64Url, normalizeDevIdpV1LegacyAccount, normalizeSmartSecretKernelAccount, normalizeSmartSecretKernelOperationOptions, normalizeSmartSecretKernelStoreOptions, normalizeSmartSecretKernelValue, parseSmartSecretKernelDeleteResult, parseSmartSecretKernelGetResult, parseSmartSecretKernelLegacyDeleteResult, parseSmartSecretKernelLegacyReadResult, parseSmartSecretKernelSetResult, smartSecretKernelDefaultTimeoutMs, smartSecretKernelLegacyService, smartSecretKernelMaximumMessageBytes, } from './smartsecret.kernel.protocol.js';
+const legacyReceiptBrand = Symbol('SmartSecretDevIdpV1LegacyReceipt');
+const kernelStoreConstructionToken = Symbol('SmartSecretKernelStoreConstruction');
+const createDeferred = () => {
+    let resolve = () => { };
+    let reject = () => { };
+    const promise = new Promise((resolveArg, rejectArg) => {
+        resolve = resolveArg;
+        reject = rejectArg;
+    });
+    return { promise, resolve, reject };
+};
+const createOperationContext = (optionsArg, mutationArg) => ({
+    deadline: performance.now() + optionsArg.timeoutMs,
+    ...(optionsArg.signal === undefined ? {} : { signal: optionsArg.signal }),
+    mutation: mutationArg,
+    dispatched: false,
+});
+const isSupportedRuntime = () => {
+    const versionParts = process.versions.node.split('.');
+    return (versionParts[0] === '25'
+        && process.platform === 'linux'
+        && process.arch === 'x64');
+};
+/**
+ * Strict Linux kernel-keyring storage for small same-UID process secrets.
+ *
+ * This class deliberately has no filesystem, Secret Service, or executable
+ * discovery fallback. Use create() so the Rust worker is ready before access.
+ */
+export class SmartSecretKernelStore {
+    constructor(constructionTokenArg, serviceArg, mutexArg, bridgeArg) {
+        this.generation = Symbol('SmartSecretKernelStoreGeneration');
+        this.receiptRecords = new WeakMap();
+        this.lifecycleState = 'ready';
+        this.poisoned = false;
+        this.operationTail = Promise.resolve();
+        if (constructionTokenArg !== kernelStoreConstructionToken) {
+            throw createSmartSecretKernelStoreError('INVALID_ARGUMENT');
+        }
+        this.service = serviceArg;
+        this.mutex = mutexArg;
+        this.bridge = bridgeArg;
+    }
+    static async create(optionsArg) {
+        const options = normalizeSmartSecretKernelStoreOptions(optionsArg);
+        if (!isSupportedRuntime()) {
+            throw createSmartSecretKernelStoreError('UNSUPPORTED_RUNTIME');
+        }
+        const serviceDescription = deriveSmartSecretKernelServiceDescription(options.service);
+        let mutex;
+        try {
+            mutex = new plugins.smartipc.NamedMutex(deriveSmartSecretKernelMutexNamespace(options.service));
+        }
+        catch {
+            throw createSmartSecretKernelStoreError('MUTEX_FAILED');
+        }
+        const packageRoot = plugins.path.resolve(plugins.path.dirname(plugins.url.fileURLToPath(import.meta.url)), '..');
+        const binaryPath = plugins.path.join(packageRoot, 'dist_rust', 'smartsecret-kernel_linux_amd64');
+        const bridge = new plugins.smartrust.RustBridge({
+            binaryName: 'smartsecret-kernel',
+            binaryPath,
+            localPaths: [],
+            searchSystemPath: false,
+            cliArgs: ['--service-ring-description', serviceDescription],
+            requestTimeoutMs: smartSecretKernelDefaultTimeoutMs,
+            readyTimeoutMs: smartSecretKernelDefaultTimeoutMs,
+            maxPayloadSize: smartSecretKernelMaximumMessageBytes,
+        });
+        let spawned = false;
+        try {
+            spawned = await bridge.spawn();
+        }
+        catch {
+            spawned = false;
+        }
+        if (!spawned) {
+            let cleanupConfirmed = true;
+            try {
+                await bridge.terminate({ gracePeriodMs: 0 });
+            }
+            catch {
+                cleanupConfirmed = false;
+            }
+            throw createSmartSecretKernelStoreError(cleanupConfirmed ? 'WORKER_UNAVAILABLE' : 'WORKER_INTEGRITY_FAILED');
+        }
+        return new SmartSecretKernelStore(kernelStoreConstructionToken, options.service, mutex, bridge);
+    }
+    getEntry(accountArg, optionsArg) {
+        const account = normalizeSmartSecretKernelAccount(accountArg);
+        const options = normalizeSmartSecretKernelOperationOptions(optionsArg);
+        const context = createOperationContext(options, false);
+        const description = deriveSmartSecretKernelEntryDescription(this.service, account);
+        return this.reserveOperation(context, () => this.withKernelLease(context, async () => {
+            const parsed = await this.dispatchRead(context, async (requestOptionsArg) => parseSmartSecretKernelGetResult(await this.bridge.sendCommand('getEntry', { description }, requestOptionsArg)));
+            if (parsed.kind === 'domainError') {
+                return this.throwDomainError(parsed.domainError, context);
+            }
+            return parsed.found ? parsed.value : null;
+        }));
+    }
+    setEntry(accountArg, valueArg, optionsArg) {
+        const account = normalizeSmartSecretKernelAccount(accountArg);
+        const options = normalizeSmartSecretKernelOperationOptions(optionsArg);
+        const context = createOperationContext(options, true);
+        const description = deriveSmartSecretKernelEntryDescription(this.service, account);
+        const value = normalizeSmartSecretKernelValue(valueArg);
+        let encodedValue;
+        try {
+            encodedValue = encodeCanonicalBase64Url(value);
+        }
+        finally {
+            value.fill(0);
+        }
+        return this.reserveOperation(context, () => this.withKernelLease(context, async () => {
+            const parsed = await this.dispatchMutation(context, async (requestOptionsArg) => parseSmartSecretKernelSetResult(await this.bridge.sendCommand('setEntry', { description, value: encodedValue }, requestOptionsArg)));
+            if (parsed.kind === 'domainError') {
+                return this.throwDomainError(parsed.domainError, context);
+            }
+        }));
+    }
+    deleteEntry(accountArg, optionsArg) {
+        const account = normalizeSmartSecretKernelAccount(accountArg);
+        const options = normalizeSmartSecretKernelOperationOptions(optionsArg);
+        const context = createOperationContext(options, true);
+        const description = deriveSmartSecretKernelEntryDescription(this.service, account);
+        return this.reserveOperation(context, () => this.withKernelLease(context, async () => {
+            const parsed = await this.dispatchMutation(context, async (requestOptionsArg) => parseSmartSecretKernelDeleteResult(await this.bridge.sendCommand('deleteEntry', { description }, requestOptionsArg)));
+            if (parsed.kind === 'domainError') {
+                return this.throwDomainError(parsed.domainError, context);
+            }
+            return parsed.deleted;
+        }));
+    }
+    readDevIdpV1Legacy(accountArg, optionsArg) {
+        this.requireLegacyService();
+        const account = normalizeDevIdpV1LegacyAccount(accountArg);
+        const options = normalizeSmartSecretKernelOperationOptions(optionsArg);
+        const context = createOperationContext(options, false);
+        return this.reserveOperation(context, () => this.withKernelLease(context, async () => {
+            const parsed = await this.dispatchRead(context, async (requestOptionsArg) => parseSmartSecretKernelLegacyReadResult(await this.bridge.sendCommand('readDevIdpV1Legacy', { account }, requestOptionsArg), account));
+            if (parsed.kind === 'domainError') {
+                return this.throwDomainError(parsed.domainError, context);
+            }
+            if (!parsed.found)
+                return null;
+            const receipt = Object.freeze({
+                [legacyReceiptBrand]: true,
+            });
+            this.receiptRecords.set(receipt, {
+                generation: this.generation,
+                params: Object.freeze(parsed.receiptParams),
+                state: 'available',
+            });
+            return Object.freeze({ value: parsed.value, receipt });
+        }));
+    }
+    deleteDevIdpV1Legacy(receiptArg, optionsArg) {
+        this.requireLegacyService();
+        const options = normalizeSmartSecretKernelOperationOptions(optionsArg);
+        const record = this.requireReceiptRecord(receiptArg);
+        if (record.state === 'deleting') {
+            if (record.deletionPromise)
+                return record.deletionPromise;
+            return Promise.reject(createSmartSecretKernelStoreError('RECEIPT_INVALID'));
+        }
+        if (record.state === 'consumed') {
+            return Promise.reject(createSmartSecretKernelStoreError('RECEIPT_INVALID'));
+        }
+        this.assertCanReserve();
+        const context = createOperationContext(options, true);
+        record.state = 'deleting';
+        const operationPromise = this.reserveOperation(context, () => this.withKernelLease(context, async () => {
+            const parsed = await this.dispatchMutation(context, async (requestOptionsArg) => parseSmartSecretKernelLegacyDeleteResult(await this.bridge.sendCommand('deleteDevIdpV1Legacy', record.params, requestOptionsArg)));
+            if (parsed.kind === 'domainError') {
+                return this.throwDomainError(parsed.domainError, context);
+            }
+            return parsed.status;
+        }));
+        const trackedPromise = operationPromise.then((statusArg) => {
+            record.state = 'consumed';
+            return statusArg;
+        }, (errorArg) => {
+            const publicError = errorArg instanceof SmartSecretKernelStoreError
+                ? errorArg
+                : createSmartSecretKernelStoreError('WORKER_INTEGRITY_FAILED');
+            if (!context.dispatched
+                && (publicError.code === 'OPERATION_ABORTED'
+                    || publicError.code === 'OPERATION_TIMEOUT')) {
+                record.state = 'available';
+                record.deletionPromise = undefined;
+            }
+            else {
+                record.state = 'consumed';
+            }
+            throw publicError;
+        });
+        record.deletionPromise = trackedPromise;
+        return trackedPromise;
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.lifecycleState = 'closing';
+        const operationTail = this.operationTail;
+        this.closePromise = (async () => {
+            await operationTail;
+            const terminated = await this.terminateBridgeConfirmed();
+            this.lifecycleState = 'closed';
+            if (!terminated) {
+                this.poisoned = true;
+                throw createSmartSecretKernelStoreError('WORKER_INTEGRITY_FAILED');
+            }
+        })();
+        return this.closePromise;
+    }
+    assertCanReserve() {
+        if (this.poisoned) {
+            throw createSmartSecretKernelStoreError('STORE_POISONED');
+        }
+        if (this.lifecycleState !== 'ready') {
+            throw createSmartSecretKernelStoreError('STORE_CLOSED');
+        }
+    }
+    reserveOperation(contextArg, operationArg) {
+        this.assertCanReserve();
+        const predecessor = this.operationTail;
+        const tailGate = createDeferred();
+        const publicResult = createDeferred();
+        this.operationTail = tailGate.promise;
+        let queuedFailure;
+        let queueTimer;
+        let abortListener;
+        const failWhileQueued = (codeArg) => {
+            if (queuedFailure)
+                return;
+            queuedFailure = createSmartSecretKernelStoreError(codeArg);
+            publicResult.reject(queuedFailure);
+        };
+        const removeQueueWatchers = () => {
+            if (queueTimer) {
+                clearTimeout(queueTimer);
+                queueTimer = undefined;
+            }
+            if (abortListener) {
+                contextArg.signal?.removeEventListener('abort', abortListener);
+                abortListener = undefined;
+            }
+        };
+        if (contextArg.signal?.aborted) {
+            failWhileQueued('OPERATION_ABORTED');
+        }
+        else {
+            abortListener = () => failWhileQueued('OPERATION_ABORTED');
+            contextArg.signal?.addEventListener('abort', abortListener, { once: true });
+            queueTimer = setTimeout(() => failWhileQueued('OPERATION_TIMEOUT'), Math.max(0, contextArg.deadline - performance.now()));
+        }
+        const execution = predecessor.then(async () => {
+            removeQueueWatchers();
+            if (queuedFailure) {
+                tailGate.resolve();
+                return;
+            }
+            try {
+                if (this.poisoned) {
+                    throw createSmartSecretKernelStoreError('STORE_POISONED');
+                }
+                publicResult.resolve(await operationArg());
+            }
+            catch (errorArg) {
+                if (errorArg instanceof SmartSecretKernelStoreError) {
+                    publicResult.reject(errorArg);
+                }
+                else {
+                    await this.poisonAndTerminate();
+                    publicResult.reject(createSmartSecretKernelStoreError(contextArg.mutation && contextArg.dispatched
+                        ? 'MUTATION_OUTCOME_UNKNOWN'
+                        : 'WORKER_INTEGRITY_FAILED'));
+                }
+            }
+            finally {
+                tailGate.resolve();
+            }
+        });
+        void execution.catch(async () => {
+            removeQueueWatchers();
+            await this.poisonAndTerminate();
+            publicResult.reject(createSmartSecretKernelStoreError(contextArg.mutation && contextArg.dispatched
+                ? 'MUTATION_OUTCOME_UNKNOWN'
+                : 'WORKER_INTEGRITY_FAILED'));
+            tailGate.resolve();
+        });
+        return publicResult.promise;
+    }
+    requireLegacyService() {
+        if (this.service !== smartSecretKernelLegacyService) {
+            throw createSmartSecretKernelStoreError('INVALID_ARGUMENT');
+        }
+    }
+    requireReceiptRecord(receiptArg) {
+        if (receiptArg === null || typeof receiptArg !== 'object') {
+            throw createSmartSecretKernelStoreError('RECEIPT_INVALID');
+        }
+        const record = this.receiptRecords.get(receiptArg);
+        if (!record || record.generation !== this.generation) {
+            throw createSmartSecretKernelStoreError('RECEIPT_INVALID');
+        }
+        return record;
+    }
+    remainingMilliseconds(contextArg) {
+        if (contextArg.signal?.aborted) {
+            throw createSmartSecretKernelStoreError('OPERATION_ABORTED');
+        }
+        const remaining = contextArg.deadline - performance.now();
+        if (remaining <= 0) {
+            throw createSmartSecretKernelStoreError('OPERATION_TIMEOUT');
+        }
+        return Math.max(1, Math.ceil(remaining));
+    }
+    createBridgeRequestOptions(contextArg) {
+        const timeoutMs = this.remainingMilliseconds(contextArg);
+        return {
+            timeoutMs,
+            ...(contextArg.signal === undefined ? {} : { signal: contextArg.signal }),
+        };
+    }
+    async acquireKernelLease(contextArg) {
+        const timeoutMs = this.remainingMilliseconds(contextArg);
+        try {
+            return await this.mutex.acquire({
+                timeoutMs,
+                ...(contextArg.signal === undefined ? {} : { signal: contextArg.signal }),
+            });
+        }
+        catch (errorArg) {
+            if (errorArg instanceof plugins.smartipc.NamedMutexError) {
+                if (errorArg.code === 'ABORTED') {
+                    throw createSmartSecretKernelStoreError('OPERATION_ABORTED');
+                }
+                if (errorArg.code === 'TIMEOUT') {
+                    throw createSmartSecretKernelStoreError('OPERATION_TIMEOUT');
+                }
+            }
+            throw createSmartSecretKernelStoreError('MUTEX_FAILED');
+        }
+    }
+    async withKernelLease(contextArg, operationArg) {
+        const lease = await this.acquireKernelLease(contextArg);
+        let outcome;
+        try {
+            outcome = { succeeded: true, value: await operationArg() };
+        }
+        catch (errorArg) {
+            if (errorArg instanceof SmartSecretKernelStoreError) {
+                outcome = { succeeded: false, error: errorArg };
+            }
+            else {
+                await this.poisonAndTerminate();
+                outcome = {
+                    succeeded: false,
+                    error: createSmartSecretKernelStoreError(contextArg.mutation && contextArg.dispatched
+                        ? 'MUTATION_OUTCOME_UNKNOWN'
+                        : 'WORKER_INTEGRITY_FAILED'),
+                };
+            }
+        }
+        try {
+            await lease.release();
+        }
+        catch {
+            await this.poisonAndTerminate();
+            throw createSmartSecretKernelStoreError(contextArg.mutation ? 'MUTATION_OUTCOME_UNKNOWN' : 'MUTEX_FAILED');
+        }
+        if (!outcome.succeeded)
+            throw outcome.error;
+        return outcome.value;
+    }
+    async dispatchRead(contextArg, dispatchArg) {
+        const requestOptions = this.createBridgeRequestOptions(contextArg);
+        contextArg.dispatched = true;
+        try {
+            return await dispatchArg(requestOptions);
+        }
+        catch {
+            await this.poisonAndTerminate();
+            throw createSmartSecretKernelStoreError('WORKER_INTEGRITY_FAILED');
+        }
+    }
+    async dispatchMutation(contextArg, dispatchArg) {
+        const requestOptions = this.createBridgeRequestOptions(contextArg);
+        contextArg.dispatched = true;
+        try {
+            return await dispatchArg(requestOptions);
+        }
+        catch {
+            await this.poisonAndTerminate();
+            throw createSmartSecretKernelStoreError('MUTATION_OUTCOME_UNKNOWN');
+        }
+    }
+    async throwDomainError(domainErrorArg, contextArg) {
+        if (domainErrorArg.code === 'KERNEL_UNAVAILABLE') {
+            throw createSmartSecretKernelStoreError('KERNEL_UNAVAILABLE');
+        }
+        if (domainErrorArg.code === 'ROOT_CONFLICT') {
+            throw createSmartSecretKernelStoreError('ROOT_CONFLICT');
+        }
+        if (domainErrorArg.code === 'ENTRY_CORRUPT') {
+            throw createSmartSecretKernelStoreError('ENTRY_CORRUPT');
+        }
+        if (domainErrorArg.code === 'SOURCE_CHANGED') {
+            throw createSmartSecretKernelStoreError('SOURCE_CHANGED');
+        }
+        if (domainErrorArg.code === 'MUTATION_OUTCOME_UNKNOWN'
+            && contextArg.mutation) {
+            await this.poisonAndTerminate();
+            throw createSmartSecretKernelStoreError('MUTATION_OUTCOME_UNKNOWN');
+        }
+        await this.poisonAndTerminate();
+        throw createSmartSecretKernelStoreError('WORKER_INTEGRITY_FAILED');
+    }
+    terminateBridgeConfirmed() {
+        if (this.terminationPromise)
+            return this.terminationPromise;
+        let termination;
+        try {
+            termination = this.bridge.terminate({ gracePeriodMs: 0 });
+        }
+        catch {
+            this.terminationPromise = Promise.resolve(false);
+            return this.terminationPromise;
+        }
+        this.terminationPromise = termination.then(() => true, () => false);
+        return this.terminationPromise;
+    }
+    async poisonAndTerminate() {
+        this.poisoned = true;
+        await this.terminateBridgeConfirmed();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartsecret.kernelstore.js","sourceRoot":"","sources":["../ts/smartsecret.kernelstore.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartsecret.keyring.d.ts

@@ -0,0 +1,81 @@
+import { type ISmartSecretEnvelopeV1 } from './smartsecret.keyring.protocol.js';
+export type TSmartSecretKekStatus = 'active' | 'retired' | 'revoked';
+export interface ISmartSecretKekDescriptor {
+    version: number;
+    status: TSmartSecretKekStatus;
+    credentialPath?: string;
+    expectedFingerprint?: `sha256:${string}`;
+    createdAt: number;
+    activatedAt: number;
+    retiredAt?: number;
+    revokedAt?: number;
+    escrowReference?: string;
+    escrowedAt?: number;
+    recoveryTestedAt?: number;
+}
+export interface ISmartSecretKeyringConfig {
+    keyringId: string;
+    keys: readonly ISmartSecretKekDescriptor[];
+}
+export interface ISmartSecretKekInspection {
+    version: number;
+    status: TSmartSecretKekStatus;
+    expectedFingerprint?: `sha256:${string}`;
+    createdAt: number;
+    activatedAt: number;
+    retiredAt?: number;
+    revokedAt?: number;
+    escrowReference?: string;
+    escrowedAt?: number;
+    recoveryTestedAt?: number;
+}
+export interface ISmartSecretKeyringInspection {
+    keyringId: string;
+    activeVersion: number;
+    keys: ISmartSecretKekInspection[];
+}
+export interface IEncryptSmartSecretEnvelopeOptions {
+    envelopeId: string;
+    plaintext: Uint8Array;
+    context: Uint8Array;
+    createdAt?: number;
+}
+export interface IDecryptSmartSecretEnvelopeOptions {
+    envelope: unknown;
+    expectedEnvelopeId: string;
+    context: Uint8Array;
+}
+export interface IRewrapSmartSecretEnvelopeOptions {
+    envelope: unknown;
+    expectedEnvelopeId: string;
+    context: Uint8Array;
+    targetVersion?: number;
+}
+export interface ISmartSecretRecoverySelfTestResult {
+    keyringId: string;
+    version: number;
+    status: 'active' | 'retired';
+    fingerprint: `sha256:${string}`;
+    testedAt: number;
+}
+/**
+ * A Linux-only, immutable KEK snapshot for strict DEK/KEK envelopes.
+ * Envelope persistence and compare-and-swap coordination remain consumer responsibilities.
+ */
+export declare class SmartSecretKeyring {
+    private readonly keyringId;
+    private readonly descriptors;
+    private readonly activeVersion;
+    private readonly loadedKeys;
+    private destroyed;
+    private constructor();
+    static create(configArg: ISmartSecretKeyringConfig): Promise<SmartSecretKeyring>;
+    private requireAlive;
+    private requireEnvelopeKey;
+    inspect(): ISmartSecretKeyringInspection;
+    destroy(): void;
+    encryptEnvelope(optionsArg: IEncryptSmartSecretEnvelopeOptions): Promise<ISmartSecretEnvelopeV1>;
+    decryptEnvelope(optionsArg: IDecryptSmartSecretEnvelopeOptions): Promise<Uint8Array>;
+    rewrapEnvelope(optionsArg: IRewrapSmartSecretEnvelopeOptions): Promise<ISmartSecretEnvelopeV1>;
+    recoverySelfTest(versionArg: number): Promise<ISmartSecretRecoverySelfTestResult>;
+}

package/dist_ts/smartsecret.keyring.error.d.ts

@@ -0,0 +1,17 @@
+export type TSmartSecretKeyringErrorCode = 'AUTHENTICATION_FAILED' | 'CONFIG_INVALID' | 'CONTEXT_MISMATCH' | 'CRYPTO_OPERATION_FAILED' | 'CREDENTIAL_FILE_INVALID' | 'DESTROYED' | 'ENVELOPE_ID_MISMATCH' | 'ENVELOPE_INVALID' | 'KEK_FINGERPRINT_MISMATCH' | 'KEK_UNAVAILABLE' | 'INVALID_ARGUMENT' | 'PLATFORM_UNSUPPORTED' | 'SIZE_LIMIT_EXCEEDED' | 'TARGET_VERSION_MISMATCH';
+export interface ISmartSecretKeyringErrorJson {
+    name: 'SmartSecretKeyringError';
+    code: TSmartSecretKeyringErrorCode;
+    message: string;
+}
+declare const inspectSymbol: unique symbol;
+/** A code-only error that intentionally retains no operation values or causes. */
+export declare class SmartSecretKeyringError extends Error {
+    readonly code: TSmartSecretKeyringErrorCode;
+    readonly cause: undefined;
+    constructor(codeArg: TSmartSecretKeyringErrorCode);
+    toJSON(): ISmartSecretKeyringErrorJson;
+    [inspectSymbol](): ISmartSecretKeyringErrorJson;
+}
+export declare const createSmartSecretKeyringError: (codeArg: TSmartSecretKeyringErrorCode) => SmartSecretKeyringError;
+export {};

package/dist_ts/smartsecret.keyring.error.js

@@ -0,0 +1,46 @@
+const inspectSymbol = Symbol.for('nodejs.util.inspect.custom');
+const errorCodes = new Set([
+    'AUTHENTICATION_FAILED',
+    'CONFIG_INVALID',
+    'CONTEXT_MISMATCH',
+    'CRYPTO_OPERATION_FAILED',
+    'CREDENTIAL_FILE_INVALID',
+    'DESTROYED',
+    'ENVELOPE_ID_MISMATCH',
+    'ENVELOPE_INVALID',
+    'KEK_FINGERPRINT_MISMATCH',
+    'KEK_UNAVAILABLE',
+    'INVALID_ARGUMENT',
+    'PLATFORM_UNSUPPORTED',
+    'SIZE_LIMIT_EXCEEDED',
+    'TARGET_VERSION_MISMATCH',
+]);
+/** A code-only error that intentionally retains no operation values or causes. */
+export class SmartSecretKeyringError extends Error {
+    constructor(codeArg) {
+        const code = errorCodes.has(codeArg) ? codeArg : 'INVALID_ARGUMENT';
+        const message = `SmartSecret keyring operation failed (${code}).`;
+        super(message);
+        this.name = 'SmartSecretKeyringError';
+        this.code = code;
+        this.stack = `${this.name}: ${message}`;
+        Object.defineProperty(this, 'cause', {
+            configurable: false,
+            enumerable: false,
+            value: undefined,
+            writable: false,
+        });
+    }
+    toJSON() {
+        return {
+            name: 'SmartSecretKeyringError',
+            code: this.code,
+            message: this.message,
+        };
+    }
+    [inspectSymbol]() {
+        return this.toJSON();
+    }
+}
+export const createSmartSecretKeyringError = (codeArg) => new SmartSecretKeyringError(codeArg);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzZWNyZXQua2V5cmluZy5lcnJvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c2VjcmV0LmtleXJpbmcuZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBc0JBLE1BQU0sYUFBYSxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsNEJBQTRCLENBQUMsQ0FBQztBQUMvRCxNQUFNLFVBQVUsR0FBRyxJQUFJLEdBQUcsQ0FBK0I7SUFDdkQsdUJBQXVCO0lBQ3ZCLGdCQUFnQjtJQUNoQixrQkFBa0I7SUFDbEIseUJBQXlCO0lBQ3pCLHlCQUF5QjtJQUN6QixXQUFXO0lBQ1gsc0JBQXNCO0lBQ3RCLGtCQUFrQjtJQUNsQiwwQkFBMEI7SUFDMUIsaUJBQWlCO0lBQ2pCLGtCQUFrQjtJQUNsQixzQkFBc0I7SUFDdEIscUJBQXFCO0lBQ3JCLHlCQUF5QjtDQUMxQixDQUFDLENBQUM7QUFFSCxrRkFBa0Y7QUFDbEYsTUFBTSxPQUFPLHVCQUF3QixTQUFRLEtBQUs7SUFJaEQsWUFBWSxPQUFxQztRQUMvQyxNQUFNLElBQUksR0FBRyxVQUFVLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLGtCQUFrQixDQUFDO1FBQ3BFLE1BQU0sT0FBTyxHQUFHLHlDQUF5QyxJQUFJLElBQUksQ0FBQztRQUNsRSxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsSUFBSSxHQUFHLHlCQUF5QixDQUFDO1FBQ3RDLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQ2pCLElBQUksQ0FBQyxLQUFLLEdBQUcsR0FBRyxJQUFJLENBQUMsSUFBSSxLQUFLLE9BQU8sRUFBRSxDQUFDO1FBQ3hDLE1BQU0sQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLE9BQU8sRUFBRTtZQUNuQyxZQUFZLEVBQUUsS0FBSztZQUNuQixVQUFVLEVBQUUsS0FBSztZQUNqQixLQUFLLEVBQUUsU0FBUztZQUNoQixRQUFRLEVBQUUsS0FBSztTQUNoQixDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU0sTUFBTTtRQUNYLE9BQU87WUFDTCxJQUFJLEVBQUUseUJBQXlCO1lBQy9CLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSTtZQUNmLE9BQU8sRUFBRSxJQUFJLENBQUMsT0FBTztTQUN0QixDQUFDO0lBQ0osQ0FBQztJQUVNLENBQUMsYUFBYSxDQUFDO1FBQ3BCLE9BQU8sSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO0lBQ3ZCLENBQUM7Q0FDRjtBQUVELE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUFHLENBQzNDLE9BQXFDLEVBQ1osRUFBRSxDQUFDLElBQUksdUJBQXVCLENBQUMsT0FBTyxDQUFDLENBQUMifQ==