unified-ble-manager 4.0.0-alpha.0

package/lib/commonjs/backends/corebluetooth/corebluetooth-backend.js

@@ -0,0 +1,696 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CoreBluetoothBackend = void 0;
+var _capabilities = require("../../backend-contract/capabilities.js");
+var _errors = require("../../backend-contract/errors.js");
+var _identity = require("../../backend-contract/identity.js");
+var _primitives = require("../../backend-contract/primitives.js");
+var _boundedStream = require("../../core/bounded-stream.js");
+var _corebluetoothOperationDispatcher = require("./corebluetooth-operation-dispatcher.js");
+var _corebluetoothOperationLifecycle = require("./corebluetooth-operation-lifecycle.js");
+var _corebluetoothHandles = require("./corebluetooth-handles.js");
+var _corebluetoothGattOperations = require("./corebluetooth-gatt-operations.js");
+var _corebluetoothConnectionControls = require("./corebluetooth-connection-controls.js");
+var _corebluetoothProvider = require("./corebluetooth-provider.js");
+var _corebluetoothIdentity = require("./corebluetooth-identity.js");
+var _corebluetoothStreamLimits = require("./corebluetooth-stream-limits.js");
+// src/backends/corebluetooth/corebluetooth-backend.ts
+// src/backends/corebluetooth/corebluetooth-backend.ts
+
+let nextBackendInstance = 1;
+function allocateBackendInstance() {
+  const current = nextBackendInstance;
+  nextBackendInstance += 1;
+  return current;
+}
+
+/**
+ * First-party CoreBluetooth backend for explicitly selected macOS Node or
+ * Electron-main hosts. It uses only the typed direct addon boundary; the
+ * transitional BlePort and Base64 facade are not in this execution path.
+ */
+class CoreBluetoothBackend {
+  features = (0, _capabilities.createFeatureRegistry)([]);
+  eventStreams = new Set();
+  stateStreams = new Set();
+  peerIdsByNativeId = new Map();
+  nativeIdsByPeerId = new Map();
+  connectionsByNativeId = new Map();
+  subscriptions = new Map();
+  attached = false;
+  admissionClosed = false;
+  destroyed = false;
+  destroyResult = null;
+  scanGroup = null;
+  backendGeneration = 1;
+  adapterGeneration = 1;
+  nextPeer = 1;
+  nextScan = 1;
+  nextConnection = 1;
+  nextLease = 1;
+  nextDatabase = 1;
+  nextSubscription = 1;
+  nextIngressOrdinal = 1;
+  constructor(boundary, now, hostKind, identityOptions = _corebluetoothIdentity.coreBluetoothIdentityOptions) {
+    this.boundary = boundary;
+    this.now = now;
+    this.hostKind = hostKind;
+    this.identityOptions = identityOptions;
+    this.backendInstanceId = (0, _primitives.opaqueId)(`${this.identityOptions.backendInstancePrefix}-${allocateBackendInstance()}`, 'backend-instance', this.identityOptions.attachmentScope);
+    this.dispatcher = new _corebluetoothOperationDispatcher.CoreBluetoothOperationDispatcher(now);
+    this.operationLifecycle = new _corebluetoothOperationLifecycle.CoreBluetoothOperationLifecycle(now);
+    this.adapterStateSnapshot = boundary.adapterSnapshot();
+    this.gattOperations = new _corebluetoothGattOperations.CoreBluetoothGattOperations(this);
+    this.connectionControls = new _corebluetoothConnectionControls.CoreBluetoothConnectionControls(this);
+    this.adapter = {
+      currentState: async () => this.adapterState(),
+      watchState: async () => this.watchAdapterState()
+    };
+    this.scanner = {
+      start: (options, clientId) => this.startScan(options, clientId),
+      join: (leaseId, token, clientId) => this.joinScan(leaseId, token, clientId)
+    };
+    this.connections = {
+      connect: (peerId, clientId, options) => this.connect(peerId, clientId, options),
+      readRssi: (connection, request) => this.connectionControls.readRssi(connection, request),
+      requestMtu: (connection, request) => this.connectionControls.requestMtu(connection, request)
+    };
+    this.gatt = {
+      discover: (connection, options) => this.gattOperations.discover(connection, options),
+      read: (path, request) => this.gattOperations.read(path, request),
+      write: (path, request) => this.gattOperations.write(path, request),
+      readDescriptor: (path, request) => this.gattOperations.readDescriptor(path, request),
+      writeDescriptor: (path, request) => this.gattOperations.writeDescriptor(path, request),
+      subscribe: (path, request) => this.gattOperations.subscribe(path, request),
+      unsubscribe: (subscription, operation) => this.gattOperations.unsubscribe(subscription, operation)
+    };
+    this.disconnectListener = boundary.onDisconnect((nativePeerId, safeMessage) => {
+      this.handleDisconnect(nativePeerId, safeMessage);
+    });
+    this.scanFailureListener = boundary.onScanFailure?.(safeMessage => {
+      this.handleScanFailure(safeMessage);
+    }) ?? null;
+    this.adapterStateListener = boundary.onAdapterState(state => {
+      this.handleAdapterState(state);
+    });
+  }
+  get identity() {
+    const attachment = this.attachment();
+    return Object.freeze({
+      registeredBackendId: this.identityOptions.registeredBackendId,
+      registeredPlatformId: this.identityOptions.registeredPlatformId,
+      attachment,
+      versions: (0, _primitives.negotiateCoreVersions)(_corebluetoothProvider.coreBluetoothCompatibility, _corebluetoothProvider.coreBluetoothCompatibility),
+      runtime: Object.freeze({
+        hostKind: this.hostKind,
+        implementationVersion: this.identityOptions.implementationVersion,
+        diagnostics: Object.freeze({
+          boundary: 'corebluetooth-direct-v1'
+        })
+      })
+    });
+  }
+  async attach(request) {
+    this.assertUsable('corebluetooth.attach');
+    if (this.attached) {
+      throw (0, _errors.contractError)('lifecycle.invalid-state', 'core', 'corebluetooth.attach');
+    }
+    (0, _primitives.negotiateCoreVersions)(_corebluetoothProvider.coreBluetoothCompatibility, request.coreCompatibility);
+    this.attached = true;
+    const identity = this.identity;
+    return Object.freeze({
+      attachment: identity.attachment,
+      identity
+    });
+  }
+  events() {
+    this.assertUsable('corebluetooth.events');
+    const stream = new _boundedStream.CoreBoundedStream(_corebluetoothStreamLimits.backendEventLimits, 'error');
+    this.eventStreams.add(stream);
+    return stream;
+  }
+  resourceCounters() {
+    let subscriptionConsumers = 0;
+    let retainedByteBuffers = 0;
+    for (const physical of this.subscriptions.values()) {
+      subscriptionConsumers += physical.consumers.size;
+      for (const consumer of physical.consumers) {
+        retainedByteBuffers += consumer.stream.retainedPayloadBytes();
+      }
+    }
+    return {
+      activeScanControllers: (0, _primitives.resourceCount)(this.scanGroup === null ? 0 : 1),
+      scanConsumers: (0, _primitives.resourceCount)(this.scanGroup?.consumers.size ?? 0),
+      chooserSessions: (0, _primitives.resourceCount)(0),
+      connectionLeases: (0, _primitives.resourceCount)([...this.connectionsByNativeId.values()].filter(record => record.lease !== null).length),
+      physicalLinks: (0, _primitives.resourceCount)([...this.connectionsByNativeId.values()].filter(record => record.state === 'connected').length),
+      databaseSnapshots: (0, _primitives.resourceCount)([...this.connectionsByNativeId.values()].filter(record => record.database !== null).length),
+      physicalCccdEnablements: (0, _primitives.resourceCount)(this.subscriptions.size),
+      subscriptionConsumers: (0, _primitives.resourceCount)(subscriptionConsumers),
+      queuedOperations: (0, _primitives.resourceCount)(0),
+      dispatchedOperations: (0, _primitives.resourceCount)(this.dispatcher.activeCount()),
+      retainedByteBuffers: (0, _primitives.resourceCount)(retainedByteBuffers),
+      restorationRecords: (0, _primitives.resourceCount)(0),
+      orphanedIpcOwners: (0, _primitives.resourceCount)(0)
+    };
+  }
+  destroy() {
+    if (this.destroyResult === null) {
+      const destruction = this.destroyInternal();
+      this.destroyResult = destruction.then(result => {
+        if (result.state === 'release-failed') {
+          this.destroyResult = null;
+        }
+        return result;
+      });
+    }
+    return this.destroyResult;
+  }
+  attachment() {
+    const backendGeneration = (0, _primitives.opaqueId)(String(this.backendGeneration), 'backend-generation', this.identityOptions.attachmentScope);
+    const adapterId = (0, _primitives.opaqueId)(this.identityOptions.adapterNativeId, 'adapter', this.identityOptions.attachmentScope);
+    const adapterState = this.adapterState();
+    return Object.freeze({
+      attachmentId: (0, _primitives.opaqueId)(`${String(this.backendInstanceId)}:${this.backendGeneration}:${this.adapterGeneration}`, 'attachment', this.identityOptions.attachmentScope),
+      backendInstanceId: this.backendInstanceId,
+      backendGeneration,
+      adapter: Object.freeze({
+        adapterId,
+        displayName: this.identityOptions.adapterDisplayName,
+        state: adapterState,
+        adapterGeneration: (0, _primitives.opaqueId)(String(this.adapterGeneration), 'adapter-generation', this.identityOptions.attachmentScope),
+        limitations: Object.freeze([...this.identityOptions.limitations])
+      })
+    });
+  }
+  assertUsable(operation) {
+    if (this.admissionClosed || this.destroyed) {
+      throw (0, _errors.contractError)('lifecycle.destroyed', 'core', operation);
+    }
+  }
+  adapterState() {
+    const state = this.adapterStateSnapshot;
+    return Object.freeze({
+      availability: state.availability,
+      authorization: state.authorization,
+      power: state.power,
+      backendGeneration: (0, _primitives.opaqueId)(String(this.backendGeneration), 'backend-generation', this.identityOptions.attachmentScope),
+      updatedAt: (0, _primitives.monotonicTimestamp)(this.now()),
+      safeReason: state.safeReason
+    });
+  }
+  watchAdapterState() {
+    const stream = new _boundedStream.CoreBoundedStream(_corebluetoothStreamLimits.adapterStateLimits, 'latest');
+    this.stateStreams.add(stream);
+    return Object.freeze({
+      initial: this.adapterState(),
+      transitions: stream
+    });
+  }
+  identifiers() {
+    const attachment = this.attachment();
+    return (0, _primitives.createAttachmentBoundIdFactory)({
+      attachmentId: attachment.attachmentId,
+      backendInstanceId: attachment.backendInstanceId,
+      backendGeneration: attachment.backendGeneration,
+      adapterId: attachment.adapter.adapterId,
+      adapterGeneration: attachment.adapter.adapterGeneration
+    });
+  }
+  async startScan(options, _clientId) {
+    this.assertUsable('corebluetooth.scan.start');
+    if (this.scanGroup !== null) {
+      throw (0, _errors.contractError)('scan.already-active', 'scan', 'corebluetooth.scan.start');
+    }
+    this.operationLifecycle.assertAdmission(options, 'corebluetooth.scan.start');
+    const identifiers = this.identifiers();
+    const ordinal = this.nextScan;
+    this.nextScan += 1;
+    const consumer = {
+      scanSessionId: identifiers.scanSessionId(`corebluetooth-scan-session-${ordinal}`),
+      leaseId: identifiers.leaseId(`corebluetooth-scan-lease-${ordinal}`),
+      shareToken: options.sharing.allowSharing ? identifiers.scanShareToken(`corebluetooth-scan-share-${ordinal}`) : null,
+      options,
+      stream: new _boundedStream.CoreBoundedStream(options.delivery, options.delivery.overflowPolicy),
+      abort: null,
+      deadlineTimer: null
+    };
+    const group = {
+      ownerLeaseId: consumer.leaseId,
+      shareToken: consumer.shareToken,
+      consumers: new Map([[String(consumer.leaseId), consumer]]),
+      state: 'starting'
+    };
+    this.scanGroup = group;
+    const abort = () => this.stopScanConsumer(consumer).then(result => {
+      if (result.state === 'release-failed') {
+        console.error('[CoreBluetoothBackend.scan.abort] Native scan cleanup requires retry:', result.failures);
+      }
+    }).catch(error => {
+      console.error('[CoreBluetoothBackend.scan.abort] Native scan cleanup rejected:', error);
+    });
+    consumer.abort = abort;
+    options.signal?.addEventListener('abort', abort, {
+      once: true
+    });
+    if (options.deadline !== null) {
+      consumer.deadlineTimer = setTimeout(abort, Math.max(0, options.deadline - this.now()));
+    }
+    try {
+      await this.boundary.startScan(advertisement => this.handleAdvertisement(advertisement), options.filter.serviceUuids);
+    } catch (error) {
+      this.releaseScanConsumerAdmission(consumer);
+      this.scanGroup = null;
+      throw this.operationLifecycle.platformError('scan.start-failed', 'scan', 'corebluetooth.scan.start', error);
+    }
+    if (this.scanGroup !== group || group.state === 'failed') {
+      throw (0, _errors.contractError)('platform.failure', 'scan', 'corebluetooth.scan.start-failed');
+    }
+    if (group.state !== 'starting' || options.signal?.aborted === true) {
+      await this.stopScanConsumer(consumer);
+      throw (0, _errors.contractError)('operation.aborted', 'scan', 'corebluetooth.scan.start');
+    }
+    group.state = 'active';
+    return new _corebluetoothHandles.CoreBluetoothScanLease(this, consumer);
+  }
+  async joinScan(leaseId, token, _clientId) {
+    this.assertUsable('corebluetooth.scan.join');
+    const group = this.scanGroup;
+    if (group === null || group.state !== 'active' || group.ownerLeaseId !== leaseId || group.shareToken !== token) {
+      throw (0, _errors.contractError)('ownership.denied', 'scan', 'corebluetooth.scan.join');
+    }
+    const owner = group.consumers.get(String(group.ownerLeaseId));
+    if (owner === undefined) {
+      throw (0, _errors.contractError)('lifecycle.invariant-violation', 'scan', 'corebluetooth.scan.join.owner');
+    }
+    const identifiers = this.identifiers();
+    const ordinal = this.nextScan;
+    this.nextScan += 1;
+    const consumer = {
+      scanSessionId: owner.scanSessionId,
+      leaseId: identifiers.leaseId(`corebluetooth-scan-lease-${ordinal}`),
+      shareToken: null,
+      options: owner.options,
+      stream: new _boundedStream.CoreBoundedStream(owner.options.delivery, owner.options.delivery.overflowPolicy),
+      abort: null,
+      deadlineTimer: null
+    };
+    group.consumers.set(String(consumer.leaseId), consumer);
+    return new _corebluetoothHandles.CoreBluetoothScanLease(this, consumer);
+  }
+  async stopScanConsumer(consumer) {
+    const group = this.scanGroup;
+    if (group === null || !group.consumers.has(String(consumer.leaseId))) {
+      this.releaseScanConsumerAdmission(consumer);
+      consumer.stream.closeWithReason('owner-released');
+      return _corebluetoothHandles.releasedCleanup;
+    }
+    if (consumer.leaseId !== group.ownerLeaseId) {
+      group.consumers.delete(String(consumer.leaseId));
+      consumer.stream.closeWithReason('owner-released');
+      return _corebluetoothHandles.releasedCleanup;
+    }
+    group.state = 'stopping';
+    for (const current of group.consumers.values()) {
+      this.releaseScanConsumerAdmission(current);
+      current.stream.closeWithReason('owner-released');
+    }
+    try {
+      await this.boundary.stopScan();
+    } catch (error) {
+      return (0, _corebluetoothHandles.cleanupFailure)('scan', 'corebluetooth.scan.stop', error);
+    }
+    group.consumers.clear();
+    this.scanGroup = null;
+    return _corebluetoothHandles.releasedCleanup;
+  }
+  releaseScanConsumerAdmission(consumer) {
+    if (consumer.abort !== null) {
+      consumer.options.signal?.removeEventListener('abort', consumer.abort);
+      consumer.abort = null;
+    }
+    if (consumer.deadlineTimer !== null) {
+      clearTimeout(consumer.deadlineTimer);
+      consumer.deadlineTimer = null;
+    }
+  }
+  handleAdvertisement(advertisement) {
+    const group = this.scanGroup;
+    if (group === null || group.state !== 'active') {
+      return;
+    }
+    const peerId = this.peerIdForNativeId(advertisement.nativePeerId);
+    const observation = this.createObservation(advertisement, peerId);
+    for (const consumer of group.consumers.values()) {
+      if ((0, _corebluetoothHandles.matchesScan)(consumer.options, observation)) {
+        consumer.stream.emit(observation, (0, _corebluetoothHandles.advertisementByteLength)(observation), String(peerId));
+      }
+    }
+  }
+  handleScanFailure(safeMessage) {
+    const group = this.scanGroup;
+    if (group === null || group.state === 'failed') {
+      return;
+    }
+    group.state = 'failed';
+    for (const consumer of group.consumers.values()) {
+      this.releaseScanConsumerAdmission(consumer);
+      consumer.stream.closeWithReason('source-failed');
+    }
+    group.consumers.clear();
+    this.scanGroup = null;
+    console.error('[CoreBluetoothBackend.handleScanFailure] Native scan failed:', safeMessage);
+  }
+  async connect(peerId, clientId, options) {
+    this.assertUsable('corebluetooth.connect');
+    this.operationLifecycle.assertAdmission(options, 'corebluetooth.connect');
+    const nativePeerId = this.nativeIdsByPeerId.get(String(peerId));
+    if (nativePeerId === undefined) {
+      throw (0, _errors.contractError)('connection.not-found', 'connection', 'corebluetooth.connect.peer');
+    }
+    const existing = this.connectionsByNativeId.get(nativePeerId);
+    if (existing !== undefined && existing.state !== 'disconnected' && existing.state !== 'lost') {
+      throw (0, _errors.contractError)('connection.already-owned', 'connection', 'corebluetooth.connect.owner');
+    }
+    const identifiers = this.identifiers();
+    const record = {
+      nativePeerId,
+      peerId,
+      connectionId: identifiers.connectionId(`corebluetooth-connection-${this.nextConnection}`),
+      connectionGeneration: (0, _primitives.opaqueId)(`corebluetooth-connection-generation-${this.nextConnection}`, 'connection-generation', 'corebluetooth'),
+      ownerLeaseId: identifiers.leaseId(`corebluetooth-connection-lease-${this.nextLease}`),
+      ownerClientId: clientId,
+      state: 'connecting',
+      database: null,
+      lease: null
+    };
+    this.nextConnection += 1;
+    this.nextLease += 1;
+    this.connectionsByNativeId.set(nativePeerId, record);
+    try {
+      await this.operationLifecycle.awaitBoundaryOperation(options, 'corebluetooth.connect', () => this.boundary.connect(nativePeerId), async () => {
+        if (this.boundary.connectionState(nativePeerId) === 'connected') {
+          await this.boundary.disconnect(nativePeerId);
+        }
+      });
+    } catch (error) {
+      this.connectionsByNativeId.delete(nativePeerId);
+      throw error;
+    }
+    if (this.admissionClosed) {
+      await this.boundary.disconnect(nativePeerId);
+      this.connectionsByNativeId.delete(nativePeerId);
+      throw (0, _errors.contractError)('operation.cancelled-by-destroy', 'connection', 'corebluetooth.connect.destroyed');
+    }
+    record.state = 'connected';
+    const connection = new _corebluetoothHandles.CoreBluetoothConnection(this, record);
+    const lease = new _corebluetoothHandles.CoreBluetoothConnectionLease(this, record, connection);
+    record.lease = lease;
+    return lease;
+  }
+  async releaseConnectionLease(lease) {
+    const record = lease.record;
+    if (record.lease !== lease) {
+      return _corebluetoothHandles.releasedCleanup;
+    }
+    return this.disconnect(record, 'corebluetooth.connection.release');
+  }
+  async disconnect(record, operation) {
+    if (record.state === 'disconnected' || record.state === 'lost') {
+      return _corebluetoothHandles.releasedCleanup;
+    }
+    record.state = 'disconnecting';
+    const subscriptionCleanup = await this.removeConnectionSubscriptions(record, 'connection-lost');
+    const failures = [...subscriptionCleanup.failures];
+    try {
+      await this.boundary.disconnect(record.nativePeerId);
+    } catch (error) {
+      record.state = 'connected';
+      failures.push((0, _corebluetoothHandles.cleanupFailureDetail)('connection', operation, error));
+      return Object.freeze({
+        state: 'release-failed',
+        failures: Object.freeze(failures)
+      });
+    }
+    this.invalidateRecord(record);
+    return failures.length === 0 ? _corebluetoothHandles.releasedCleanup : Object.freeze({
+      state: 'release-failed',
+      failures: Object.freeze(failures)
+    });
+  }
+  handleDisconnect(nativePeerId, safeMessage) {
+    const record = this.connectionsByNativeId.get(nativePeerId);
+    if (record === undefined || record.state === 'disconnected' || record.state === 'lost') {
+      return;
+    }
+    const connectionPath = (0, _corebluetoothHandles.connectionPathFor)(this.attachment(), record);
+    this.invalidateRecord(record);
+    const attachment = this.attachment();
+    this.broadcastEvent({
+      attachment,
+      attachmentId: attachment.attachmentId,
+      kind: 'connection-lost',
+      connection: connectionPath,
+      ingressOrdinal: this.nextIngressOrdinal
+    });
+    this.nextIngressOrdinal += 1;
+    if (safeMessage !== null) {
+      console.error('[CoreBluetoothBackend.handleDisconnect] Native link loss:', safeMessage);
+    }
+  }
+  handleAdapterState(state) {
+    this.adapterStateSnapshot = state;
+    if (this.destroyed) {
+      return;
+    }
+    if (state.power === 'resetting' || state.availability === 'unavailable') {
+      this.advanceGeneration();
+      return;
+    }
+    const snapshot = this.adapterState();
+    for (const stream of this.stateStreams) {
+      stream.emit(snapshot, 96, String(snapshot.backendGeneration));
+    }
+    const attachment = this.attachment();
+    this.broadcastEvent({
+      attachment,
+      attachmentId: attachment.attachmentId,
+      kind: 'adapter-state',
+      ingressOrdinal: this.nextIngressOrdinal
+    });
+    this.nextIngressOrdinal += 1;
+  }
+  advanceGeneration() {
+    this.backendGeneration += 1;
+    this.adapterGeneration += 1;
+    if (this.scanGroup !== null) {
+      for (const consumer of this.scanGroup.consumers.values()) {
+        this.releaseScanConsumerAdmission(consumer);
+        consumer.stream.closeWithReason('source-failed');
+      }
+      this.scanGroup = null;
+    }
+    for (const physical of this.subscriptions.values()) {
+      for (const subscription of physical.consumers) {
+        subscription.stream.closeWithReason('source-failed');
+        subscription.removed = true;
+      }
+    }
+    this.subscriptions.clear();
+    for (const record of this.connectionsByNativeId.values()) {
+      this.invalidateRecord(record);
+    }
+    this.peerIdsByNativeId.clear();
+    this.nativeIdsByPeerId.clear();
+    const attachment = this.attachment();
+    this.broadcastEvent({
+      attachment,
+      attachmentId: attachment.attachmentId,
+      kind: 'backend-restarted',
+      ingressOrdinal: this.nextIngressOrdinal
+    });
+    this.nextIngressOrdinal += 1;
+  }
+  invalidateRecord(record) {
+    record.state = 'lost';
+    record.database?.invalidate();
+    record.database = null;
+    record.lease?.markReleased();
+    record.lease = null;
+    this.connectionsByNativeId.delete(record.nativePeerId);
+    for (const physical of [...this.subscriptions.values()]) {
+      if (physical.address.nativePeerId !== record.nativePeerId) {
+        continue;
+      }
+      for (const consumer of physical.consumers) {
+        consumer.stream.closeWithReason('connection-lost');
+        consumer.removed = true;
+      }
+      physical.consumers.clear();
+      this.subscriptions.delete(physical.key);
+    }
+  }
+  async removeConnectionSubscriptions(record, reason) {
+    const failures = [];
+    for (const physical of [...this.subscriptions.values()]) {
+      if (physical.address.nativePeerId !== record.nativePeerId) {
+        continue;
+      }
+      for (const consumer of physical.consumers) {
+        consumer.stream.closeWithReason(reason);
+        consumer.removed = true;
+      }
+      physical.consumers.clear();
+      const cleanup = await this.gattOperations.stopPhysicalSubscription(physical);
+      failures.push(...cleanup.failures);
+    }
+    return failures.length === 0 ? _corebluetoothHandles.releasedCleanup : Object.freeze({
+      state: 'release-failed',
+      failures: Object.freeze(failures)
+    });
+  }
+  requireConnection(connection, operation) {
+    if (!(connection instanceof _corebluetoothHandles.CoreBluetoothConnection)) {
+      throw (0, _errors.contractError)('ownership.denied', 'connection', operation);
+    }
+    const record = connection.record;
+    if (record.state !== 'connected' || this.connectionsByNativeId.get(record.nativePeerId) !== record || !(0, _identity.attachmentRecordsEqual)(connection.attachment, this.attachment())) {
+      throw (0, _errors.contractError)('connection.stale', 'connection', operation);
+    }
+    return record;
+  }
+  databaseForPath(path, operation) {
+    for (const record of this.connectionsByNativeId.values()) {
+      const database = record.database;
+      if (database !== null && database.matchesPath(path)) {
+        database.assertCurrent(operation);
+        return database;
+      }
+    }
+    throw (0, _errors.contractError)('gatt.stale-handle', 'gatt', operation);
+  }
+  peerIdForNativeId(nativePeerId) {
+    const existing = this.peerIdsByNativeId.get(nativePeerId);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const peerId = (0, _primitives.opaqueId)(`corebluetooth-peer-${this.backendGeneration}-${this.nextPeer}`, 'peer', 'corebluetooth');
+    this.nextPeer += 1;
+    this.peerIdsByNativeId.set(nativePeerId, peerId);
+    this.nativeIdsByPeerId.set(String(peerId), nativePeerId);
+    return peerId;
+  }
+  createObservation(advertisement, peerId) {
+    const unavailable = Object.freeze({
+      state: 'unavailable',
+      reason: 'CoreBluetooth boundary does not expose this advertisement field',
+      provenance: 'not-provided'
+    });
+    const serviceUuids = advertisement.serviceUuids === null ? unavailable : Object.freeze({
+      state: 'present',
+      value: Object.freeze(advertisement.serviceUuids.map(_primitives.canonicalUuid)),
+      provenance: 'observed'
+    });
+    return Object.freeze({
+      peerId,
+      observedAt: (0, _primitives.monotonicTimestamp)(this.now()),
+      source: 'platform-derived',
+      ingressOrdinal: this.nextIngressOrdinal++,
+      localName: advertisement.localName === null ? unavailable : Object.freeze({
+        state: 'present',
+        value: advertisement.localName,
+        provenance: 'observed'
+      }),
+      rssi: advertisement.rssi === null ? unavailable : Object.freeze({
+        state: 'present',
+        value: advertisement.rssi,
+        provenance: 'observed'
+      }),
+      txPower: unavailable,
+      connectable: unavailable,
+      appearance: unavailable,
+      serviceUuids,
+      solicitedServiceUuids: unavailable,
+      overflowServiceUuids: unavailable,
+      serviceData: unavailable,
+      manufacturerData: unavailable,
+      rawRecord: unavailable,
+      scanResponseRecord: unavailable
+    });
+  }
+  assertGattSnapshot(snapshot) {
+    const serviceOccurrences = new Set();
+    for (const service of snapshot.services) {
+      if (!Number.isInteger(service.occurrence) || service.occurrence < 0 || serviceOccurrences.has(service.occurrence)) {
+        throw (0, _errors.contractError)('protocol.malformed', 'gatt', 'corebluetooth.gatt.snapshot.service-occurrence');
+      }
+      serviceOccurrences.add(service.occurrence);
+      const characteristicOccurrences = new Set();
+      for (const characteristic of service.characteristics) {
+        if (!Number.isInteger(characteristic.occurrence) || characteristic.occurrence < 0 || characteristicOccurrences.has(characteristic.occurrence)) {
+          throw (0, _errors.contractError)('protocol.malformed', 'gatt', 'corebluetooth.gatt.snapshot.characteristic-occurrence');
+        }
+        characteristicOccurrences.add(characteristic.occurrence);
+      }
+    }
+  }
+  broadcastEvent(event) {
+    for (const stream of this.eventStreams) {
+      stream.emit(event, 128);
+    }
+  }
+  async destroyInternal() {
+    this.admissionClosed = true;
+    this.dispatcher.cancelAll();
+    const failures = [];
+    if (this.scanGroup !== null) {
+      const owner = this.scanGroup.consumers.get(String(this.scanGroup.ownerLeaseId));
+      if (owner !== undefined) {
+        const cleanup = await this.stopScanConsumer(owner);
+        failures.push(...cleanup.failures);
+      }
+    }
+    for (const physical of [...this.subscriptions.values()]) {
+      for (const subscription of physical.consumers) {
+        subscription.stream.closeWithReason('owner-released');
+        subscription.removed = true;
+      }
+      physical.consumers.clear();
+      const cleanup = await this.gattOperations.stopPhysicalSubscription(physical);
+      failures.push(...cleanup.failures);
+    }
+    for (const record of [...this.connectionsByNativeId.values()]) {
+      const cleanup = await this.disconnect(record, 'corebluetooth.destroy.connection');
+      failures.push(...cleanup.failures);
+    }
+    if (failures.length > 0) {
+      return Object.freeze({
+        state: 'release-failed',
+        failures: Object.freeze(failures)
+      });
+    }
+    try {
+      this.disconnectListener();
+      this.scanFailureListener?.();
+      this.adapterStateListener();
+      await this.boundary.destroy();
+    } catch (error) {
+      return (0, _corebluetoothHandles.cleanupFailure)('boundary', 'corebluetooth.destroy.boundary', error);
+    }
+    this.destroyed = true;
+    for (const stream of this.eventStreams) {
+      stream.closeWithReason('owner-released');
+    }
+    this.eventStreams.clear();
+    for (const stream of this.stateStreams) {
+      stream.closeWithReason('owner-released');
+    }
+    this.stateStreams.clear();
+    return _corebluetoothHandles.releasedCleanup;
+  }
+}
+exports.CoreBluetoothBackend = CoreBluetoothBackend;
+//# sourceMappingURL=corebluetooth-backend.js.map