@push.rocks/smartsecret 1.0.2 → 1.2.0

package/ts/smartsecret.kernelstore.ts

@@ -0,0 +1,664 @@
+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,
+  type INormalizedSmartSecretKernelOperationOptions,
+  type ISmartSecretKernelDomainErrorResult,
+  type ISmartSecretKernelLegacyDeleteParams,
+  type ISmartSecretKernelOperationOptions,
+  type ISmartSecretKernelStoreOptions,
+  type TSmartSecretKernelCommands,
+} from './smartsecret.kernel.protocol.js';
+
+export type {
+  ISmartSecretKernelOperationOptions,
+  ISmartSecretKernelStoreOptions,
+} from './smartsecret.kernel.protocol.js';
+
+const legacyReceiptBrand = Symbol('SmartSecretDevIdpV1LegacyReceipt');
+const kernelStoreConstructionToken = Symbol('SmartSecretKernelStoreConstruction');
+
+export type TDevIdpV1LegacyReceipt = {
+  readonly [legacyReceiptBrand]: true;
+};
+
+export interface IDevIdpV1LegacyRead {
+  readonly value: Uint8Array;
+  readonly receipt: TDevIdpV1LegacyReceipt;
+}
+
+type TStoreLifecycleState = 'ready' | 'closing' | 'closed';
+type TReceiptState = 'available' | 'deleting' | 'consumed';
+
+interface IOperationContext {
+  readonly deadline: number;
+  readonly signal?: AbortSignal;
+  readonly mutation: boolean;
+  dispatched: boolean;
+}
+
+interface IBridgeRequestOptions {
+  readonly timeoutMs: number;
+  readonly signal?: AbortSignal;
+}
+
+interface ILegacyReceiptRecord {
+  readonly generation: symbol;
+  readonly params: ISmartSecretKernelLegacyDeleteParams;
+  state: TReceiptState;
+  deletionPromise?: Promise<'deleted' | 'alreadyAbsent'>;
+}
+
+interface IDeferred<T> {
+  readonly promise: Promise<T>;
+  readonly resolve: (valueArg: T | PromiseLike<T>) => void;
+  readonly reject: (reasonArg?: unknown) => void;
+}
+
+type TOperationOutcome<T> =
+  | { succeeded: true; value: T }
+  | { succeeded: false; error: SmartSecretKernelStoreError };
+
+const createDeferred = <T>(): IDeferred<T> => {
+  let resolve: (valueArg: T | PromiseLike<T>) => void = () => {};
+  let reject: (reasonArg?: unknown) => void = () => {};
+  const promise = new Promise<T>((resolveArg, rejectArg) => {
+    resolve = resolveArg;
+    reject = rejectArg;
+  });
+  return { promise, resolve, reject };
+};
+
+const createOperationContext = (
+  optionsArg: INormalizedSmartSecretKernelOperationOptions,
+  mutationArg: boolean,
+): IOperationContext => ({
+  deadline: performance.now() + optionsArg.timeoutMs,
+  ...(optionsArg.signal === undefined ? {} : { signal: optionsArg.signal }),
+  mutation: mutationArg,
+  dispatched: false,
+});
+
+const isSupportedRuntime = (): boolean => {
+  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 {
+  public readonly service: string;
+
+  private readonly mutex: plugins.smartipc.NamedMutex;
+  private readonly bridge: plugins.smartrust.RustBridge<TSmartSecretKernelCommands>;
+  private readonly generation = Symbol('SmartSecretKernelStoreGeneration');
+  private readonly receiptRecords = new WeakMap<
+    TDevIdpV1LegacyReceipt,
+    ILegacyReceiptRecord
+  >();
+
+  private lifecycleState: TStoreLifecycleState = 'ready';
+  private poisoned = false;
+  private operationTail: Promise<void> = Promise.resolve();
+  private closePromise: Promise<void> | undefined;
+  private terminationPromise: Promise<boolean> | undefined;
+
+  private constructor(
+    constructionTokenArg: symbol,
+    serviceArg: string,
+    mutexArg: plugins.smartipc.NamedMutex,
+    bridgeArg: plugins.smartrust.RustBridge<TSmartSecretKernelCommands>,
+  ) {
+    if (constructionTokenArg !== kernelStoreConstructionToken) {
+      throw createSmartSecretKernelStoreError('INVALID_ARGUMENT');
+    }
+    this.service = serviceArg;
+    this.mutex = mutexArg;
+    this.bridge = bridgeArg;
+  }
+
+  public static async create(
+    optionsArg: ISmartSecretKernelStoreOptions,
+  ): Promise<SmartSecretKernelStore> {
+    const options = normalizeSmartSecretKernelStoreOptions(optionsArg);
+    if (!isSupportedRuntime()) {
+      throw createSmartSecretKernelStoreError('UNSUPPORTED_RUNTIME');
+    }
+
+    const serviceDescription = deriveSmartSecretKernelServiceDescription(options.service);
+    let mutex: plugins.smartipc.NamedMutex;
+    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<TSmartSecretKernelCommands>({
+      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,
+    );
+  }
+
+  public getEntry(
+    accountArg: string,
+    optionsArg?: ISmartSecretKernelOperationOptions,
+  ): Promise<Uint8Array | null> {
+    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;
+    }));
+  }
+
+  public setEntry(
+    accountArg: string,
+    valueArg: Uint8Array,
+    optionsArg?: ISmartSecretKernelOperationOptions,
+  ): Promise<void> {
+    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: string;
+    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);
+      }
+    }));
+  }
+
+  public deleteEntry(
+    accountArg: string,
+    optionsArg?: ISmartSecretKernelOperationOptions,
+  ): Promise<boolean> {
+    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;
+    }));
+  }
+
+  public readDevIdpV1Legacy(
+    accountArg: string,
+    optionsArg?: ISmartSecretKernelOperationOptions,
+  ): Promise<IDevIdpV1LegacyRead | null> {
+    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: TDevIdpV1LegacyReceipt = 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 });
+    }));
+  }
+
+  public deleteDevIdpV1Legacy(
+    receiptArg: TDevIdpV1LegacyReceipt,
+    optionsArg?: ISmartSecretKernelOperationOptions,
+  ): Promise<'deleted' | 'alreadyAbsent'> {
+    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: unknown) => {
+        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;
+  }
+
+  public close(): Promise<void> {
+    if (this.closePromise) return this.closePromise;
+    this.lifecycleState = 'closing';
+    const operationTail = this.operationTail;
+    this.closePromise = (async (): Promise<void> => {
+      await operationTail;
+      const terminated = await this.terminateBridgeConfirmed();
+      this.lifecycleState = 'closed';
+      if (!terminated) {
+        this.poisoned = true;
+        throw createSmartSecretKernelStoreError('WORKER_INTEGRITY_FAILED');
+      }
+    })();
+    return this.closePromise;
+  }
+
+  private assertCanReserve(): void {
+    if (this.poisoned) {
+      throw createSmartSecretKernelStoreError('STORE_POISONED');
+    }
+    if (this.lifecycleState !== 'ready') {
+      throw createSmartSecretKernelStoreError('STORE_CLOSED');
+    }
+  }
+
+  private reserveOperation<T>(
+    contextArg: IOperationContext,
+    operationArg: () => Promise<T>,
+  ): Promise<T> {
+    this.assertCanReserve();
+
+    const predecessor = this.operationTail;
+    const tailGate = createDeferred<void>();
+    const publicResult = createDeferred<T>();
+    this.operationTail = tailGate.promise;
+
+    let queuedFailure: SmartSecretKernelStoreError | undefined;
+    let queueTimer: ReturnType<typeof setTimeout> | undefined;
+    let abortListener: (() => void) | undefined;
+
+    const failWhileQueued = (codeArg: 'OPERATION_ABORTED' | 'OPERATION_TIMEOUT'): void => {
+      if (queuedFailure) return;
+      queuedFailure = createSmartSecretKernelStoreError(codeArg);
+      publicResult.reject(queuedFailure);
+    };
+    const removeQueueWatchers = (): void => {
+      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 (): Promise<void> => {
+      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;
+  }
+
+  private requireLegacyService(): void {
+    if (this.service !== smartSecretKernelLegacyService) {
+      throw createSmartSecretKernelStoreError('INVALID_ARGUMENT');
+    }
+  }
+
+  private requireReceiptRecord(
+    receiptArg: TDevIdpV1LegacyReceipt,
+  ): ILegacyReceiptRecord {
+    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;
+  }
+
+  private remainingMilliseconds(contextArg: IOperationContext): number {
+    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));
+  }
+
+  private createBridgeRequestOptions(
+    contextArg: IOperationContext,
+  ): IBridgeRequestOptions {
+    const timeoutMs = this.remainingMilliseconds(contextArg);
+    return {
+      timeoutMs,
+      ...(contextArg.signal === undefined ? {} : { signal: contextArg.signal }),
+    };
+  }
+
+  private async acquireKernelLease(
+    contextArg: IOperationContext,
+  ): Promise<plugins.smartipc.NamedMutexLease> {
+    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');
+    }
+  }
+
+  private async withKernelLease<T>(
+    contextArg: IOperationContext,
+    operationArg: () => Promise<T>,
+  ): Promise<T> {
+    const lease = await this.acquireKernelLease(contextArg);
+    let outcome: TOperationOutcome<T>;
+    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;
+  }
+
+  private async dispatchRead<T>(
+    contextArg: IOperationContext,
+    dispatchArg: (requestOptionsArg: IBridgeRequestOptions) => Promise<T>,
+  ): Promise<T> {
+    const requestOptions = this.createBridgeRequestOptions(contextArg);
+    contextArg.dispatched = true;
+    try {
+      return await dispatchArg(requestOptions);
+    } catch {
+      await this.poisonAndTerminate();
+      throw createSmartSecretKernelStoreError('WORKER_INTEGRITY_FAILED');
+    }
+  }
+
+  private async dispatchMutation<T>(
+    contextArg: IOperationContext,
+    dispatchArg: (requestOptionsArg: IBridgeRequestOptions) => Promise<T>,
+  ): Promise<T> {
+    const requestOptions = this.createBridgeRequestOptions(contextArg);
+    contextArg.dispatched = true;
+    try {
+      return await dispatchArg(requestOptions);
+    } catch {
+      await this.poisonAndTerminate();
+      throw createSmartSecretKernelStoreError('MUTATION_OUTCOME_UNKNOWN');
+    }
+  }
+
+  private async throwDomainError(
+    domainErrorArg: ISmartSecretKernelDomainErrorResult,
+    contextArg: IOperationContext,
+  ): Promise<never> {
+    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');
+  }
+
+  private terminateBridgeConfirmed(): Promise<boolean> {
+    if (this.terminationPromise) return this.terminationPromise;
+    let termination: Promise<void>;
+    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;
+  }
+
+  private async poisonAndTerminate(): Promise<void> {
+    this.poisoned = true;
+    await this.terminateBridgeConfirmed();
+  }
+}