unified-ble-manager 4.0.0-alpha.0

package/lib/commonjs/backend-contract/index.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BackendContractError", {
+  enumerable: true,
+  get: function () {
+    return _errors.BackendContractError;
+  }
+});
+Object.defineProperty(exports, "assertAttachedBackend", {
+  enumerable: true,
+  get: function () {
+    return _backend.assertAttachedBackend;
+  }
+});
+Object.defineProperty(exports, "assertBackendEvent", {
+  enumerable: true,
+  get: function () {
+    return _backend.assertBackendEvent;
+  }
+});
+Object.defineProperty(exports, "assertCoreVersionsAccepted", {
+  enumerable: true,
+  get: function () {
+    return _primitives.assertCoreVersionsAccepted;
+  }
+});
+Object.defineProperty(exports, "assertCurrentPath", {
+  enumerable: true,
+  get: function () {
+    return _gatt.assertCurrentPath;
+  }
+});
+Object.defineProperty(exports, "assertPathMatchesAttachment", {
+  enumerable: true,
+  get: function () {
+    return _gatt.assertPathMatchesAttachment;
+  }
+});
+Object.defineProperty(exports, "attachBackend", {
+  enumerable: true,
+  get: function () {
+    return _backend.attachBackend;
+  }
+});
+Object.defineProperty(exports, "attachmentRecordsEqual", {
+  enumerable: true,
+  get: function () {
+    return _identity.attachmentRecordsEqual;
+  }
+});
+Object.defineProperty(exports, "byteLimit", {
+  enumerable: true,
+  get: function () {
+    return _primitives.byteLimit;
+  }
+});
+Object.defineProperty(exports, "canonicalUuid", {
+  enumerable: true,
+  get: function () {
+    return _primitives.canonicalUuid;
+  }
+});
+Object.defineProperty(exports, "capacity", {
+  enumerable: true,
+  get: function () {
+    return _primitives.capacity;
+  }
+});
+Object.defineProperty(exports, "contractError", {
+  enumerable: true,
+  get: function () {
+    return _errors.contractError;
+  }
+});
+Object.defineProperty(exports, "createAttachmentBoundIdFactory", {
+  enumerable: true,
+  get: function () {
+    return _primitives.createAttachmentBoundIdFactory;
+  }
+});
+Object.defineProperty(exports, "createBackendOperationDispatch", {
+  enumerable: true,
+  get: function () {
+    return _operations.createBackendOperationDispatch;
+  }
+});
+Object.defineProperty(exports, "createFeatureRegistry", {
+  enumerable: true,
+  get: function () {
+    return _capabilities.createFeatureRegistry;
+  }
+});
+Object.defineProperty(exports, "createIpcOperationIdFactory", {
+  enumerable: true,
+  get: function () {
+    return _primitives.createIpcOperationIdFactory;
+  }
+});
+Object.defineProperty(exports, "createOperationSettlementCoordinator", {
+  enumerable: true,
+  get: function () {
+    return _operations.createOperationSettlementCoordinator;
+  }
+});
+Object.defineProperty(exports, "deadline", {
+  enumerable: true,
+  get: function () {
+    return _primitives.deadline;
+  }
+});
+Object.defineProperty(exports, "monotonicTimestamp", {
+  enumerable: true,
+  get: function () {
+    return _primitives.monotonicTimestamp;
+  }
+});
+Object.defineProperty(exports, "negotiateCoreVersions", {
+  enumerable: true,
+  get: function () {
+    return _primitives.negotiateCoreVersions;
+  }
+});
+Object.defineProperty(exports, "negotiateVersion", {
+  enumerable: true,
+  get: function () {
+    return _primitives.negotiateVersion;
+  }
+});
+Object.defineProperty(exports, "opaqueId", {
+  enumerable: true,
+  get: function () {
+    return _primitives.opaqueId;
+  }
+});
+Object.defineProperty(exports, "ownBytes", {
+  enumerable: true,
+  get: function () {
+    return _primitives.ownBytes;
+  }
+});
+Object.defineProperty(exports, "rebindAttachmentBoundId", {
+  enumerable: true,
+  get: function () {
+    return _primitives.rebindAttachmentBoundId;
+  }
+});
+Object.defineProperty(exports, "resourceCount", {
+  enumerable: true,
+  get: function () {
+    return _primitives.resourceCount;
+  }
+});
+Object.defineProperty(exports, "validateFeatureRegistration", {
+  enumerable: true,
+  get: function () {
+    return _capabilities.validateFeatureRegistration;
+  }
+});
+Object.defineProperty(exports, "version", {
+  enumerable: true,
+  get: function () {
+    return _primitives.version;
+  }
+});
+Object.defineProperty(exports, "versionRange", {
+  enumerable: true,
+  get: function () {
+    return _primitives.versionRange;
+  }
+});
+var _backend = require("./backend.js");
+var _capabilities = require("./capabilities.js");
+var _errors = require("./errors.js");
+var _gatt = require("./gatt.js");
+var _identity = require("./identity.js");
+var _operations = require("./operations.js");
+var _primitives = require("./primitives.js");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/backend-contract/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_backend","require","_capabilities","_errors","_gatt","_identity","_operations","_primitives"],"sourceRoot":"../../../src","sources":["backend-contract/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAAA,QAAA,GAAAC,OAAA;AAYA,IAAAC,aAAA,GAAAD,OAAA;AASA,IAAAE,OAAA,GAAAF,OAAA;AAiBA,IAAAG,KAAA,GAAAH,OAAA;AAoBA,IAAAI,SAAA,GAAAJ,OAAA;AAkBA,IAAAK,WAAA,GAAAL,OAAA;AAwDA,IAAAM,WAAA,GAAAN,OAAA","ignoreList":[]}

package/lib/commonjs/backend-contract/operations.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBackendOperationDispatch = createBackendOperationDispatch;
+exports.createOperationSettlementCoordinator = createOperationSettlementCoordinator;
+// src/backend-contract/operations.ts
+
+function createBackendOperationDispatch(handle, completion, requestCancellation) {
+  return {
+    handle,
+    completion,
+    requestCancellation
+  };
+}
+class DefaultOperationSettlementCoordinator {
+  settled = false;
+  cancellationAcknowledgement = null;
+  constructor(handle) {
+    this.handle = handle;
+  }
+  complete(result) {
+    if (this.settled) {
+      throw new Error('operation completion was already settled');
+    }
+    this.settled = true;
+    return result;
+  }
+  acknowledgeCancellation(state) {
+    if (this.cancellationAcknowledgement !== null) {
+      return this.cancellationAcknowledgement;
+    }
+    this.cancellationAcknowledgement = {
+      handle: this.handle,
+      state: this.settled ? 'already-terminal' : state
+    };
+    return this.cancellationAcknowledgement;
+  }
+}
+function createOperationSettlementCoordinator(handle) {
+  return new DefaultOperationSettlementCoordinator(handle);
+}
+//# sourceMappingURL=operations.js.map

package/lib/commonjs/backend-contract/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createBackendOperationDispatch","handle","completion","requestCancellation","DefaultOperationSettlementCoordinator","settled","cancellationAcknowledgement","constructor","complete","result","Error","acknowledgeCancellation","state","createOperationSettlementCoordinator"],"sourceRoot":"../../../src","sources":["backend-contract/operations.ts"],"mappings":";;;;;;;AAAA;;AAsCO,SAASA,8BAA8BA,CAC5CC,MAAkD,EAClDC,UAA2B,EAC3BC,mBAA2E,EAC7B;EAC9C,OAAO;IAAEF,MAAM;IAAEC,UAAU;IAAEC;EAAoB,CAAC;AACpD;AAOA,MAAMC,qCAAqC,CAE3C;EACUC,OAAO,GAAG,KAAK;EACfC,2BAA2B,GAAmD,IAAI;EAC1FC,WAAWA,CAAkBN,MAAkD,EAAE;IAAA,KAApDA,MAAkD,GAAlDA,MAAkD;EAAG;EAClFO,QAAQA,CAACC,MAAc,EAAU;IAC/B,IAAI,IAAI,CAACJ,OAAO,EAAE;MAChB,MAAM,IAAIK,KAAK,CAAC,0CAA0C,CAAC;IAC7D;IACA,IAAI,CAACL,OAAO,GAAG,IAAI;IACnB,OAAOI,MAAM;EACf;EACAE,uBAAuBA,CACrBC,KAAuD,EACd;IACzC,IAAI,IAAI,CAACN,2BAA2B,KAAK,IAAI,EAAE;MAC7C,OAAO,IAAI,CAACA,2BAA2B;IACzC;IACA,IAAI,CAACA,2BAA2B,GAAG;MAAEL,MAAM,EAAE,IAAI,CAACA,MAAM;MAAEW,KAAK,EAAE,IAAI,CAACP,OAAO,GAAG,kBAAkB,GAAGO;IAAM,CAAC;IAC5G,OAAO,IAAI,CAACN,2BAA2B;EACzC;AACF;AACO,SAASO,oCAAoCA,CAClDZ,MAAkD,EACE;EACpD,OAAO,IAAIG,qCAAqC,CAACH,MAAM,CAAC;AAC1D","ignoreList":[]}

package/lib/commonjs/backend-contract/primitives.js

@@ -0,0 +1,244 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applicableVersionAxesEqual = applicableVersionAxesEqual;
+exports.assertCoreVersionsAccepted = assertCoreVersionsAccepted;
+exports.byteLimit = byteLimit;
+exports.canonicalUuid = canonicalUuid;
+exports.capacity = capacity;
+exports.createAttachmentBoundIdFactory = createAttachmentBoundIdFactory;
+exports.createIpcOperationIdFactory = createIpcOperationIdFactory;
+exports.deadline = deadline;
+exports.monotonicTimestamp = monotonicTimestamp;
+exports.negotiateCoreVersions = negotiateCoreVersions;
+exports.negotiateVersion = negotiateVersion;
+exports.opaqueId = opaqueId;
+exports.ownBytes = ownBytes;
+exports.rebindAttachmentBoundId = rebindAttachmentBoundId;
+exports.resourceCount = resourceCount;
+exports.snapshotApplicableVersionAxes = snapshotApplicableVersionAxes;
+exports.version = version;
+exports.versionRange = versionRange;
+var _errors = require("./errors.js");
+// src/backend-contract/primitives.ts
+
+function assertNonEmptyString(value, label) {
+  if (value.length === 0) {
+    throw new Error(`${label} must be non-empty`);
+  }
+}
+function assertNonNegativeSafeInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative safe integer`);
+  }
+}
+function opaqueId(value, kind, scope) {
+  assertNonEmptyString(value, kind);
+  assertNonEmptyString(scope, `${kind} scope`);
+  return value;
+}
+function runtimeScopedOpaqueId(value, kind, scope) {
+  assertNonEmptyString(value, kind);
+  assertNonEmptyString(scope, `${kind} scope`);
+  return value;
+}
+function attachmentScope(binding) {
+  const values = [binding.attachmentId, binding.backendInstanceId, binding.backendGeneration, binding.adapterId, binding.adapterGeneration];
+  for (const value of values) {
+    assertNonEmptyString(String(value), 'attachment binding value');
+  }
+  return values.map(value => String(value)).join(':');
+}
+function createAttachmentBoundIdFactory(binding) {
+  const scope = attachmentScope(binding);
+  return {
+    connectionId: value => runtimeScopedOpaqueId(value, 'connection', scope),
+    leaseId: value => runtimeScopedOpaqueId(value, 'lease', scope),
+    scanShareToken: value => runtimeScopedOpaqueId(value, 'scan-share-token', scope),
+    scanSessionId: value => runtimeScopedOpaqueId(value, 'scan-session', scope),
+    databaseId: value => runtimeScopedOpaqueId(value, 'gatt-database', scope),
+    subscriptionId: value => runtimeScopedOpaqueId(value, 'subscription', scope),
+    operationCorrelation: value => runtimeScopedOpaqueId(value, 'core-operation', scope),
+    backendOperationHandle: value => runtimeScopedOpaqueId(value, 'backend-operation', scope)
+  };
+}
+/** Creates renderer-local IPC correlation IDs scoped to one already-attached backend generation. */
+function createIpcOperationIdFactory(scope) {
+  return {
+    ipcOperationCorrelation: value => runtimeScopedOpaqueId(value, 'ipc-operation', scope),
+    ipcDispatchEpoch: value => runtimeScopedOpaqueId(value, 'ipc-dispatch-epoch', scope)
+  };
+}
+function rebindAttachmentBoundId(id, source, target) {
+  if (attachmentScope(source) !== attachmentScope(target)) {
+    throw new Error('attachment rebinding requires the identical attachment tuple');
+  }
+  return id;
+}
+function canonicalUuid(value) {
+  const normalized = value.toLowerCase();
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(normalized)) {
+    throw new Error('UUID must be canonical lowercase 128-bit form');
+  }
+  return normalized;
+}
+function byteLimit(value) {
+  assertNonNegativeSafeInteger(value, 'byte limit');
+  return value;
+}
+function capacity(value) {
+  assertNonNegativeSafeInteger(value, 'capacity');
+  if (value === 0) {
+    throw new Error('capacity must be greater than zero');
+  }
+  return value;
+}
+function resourceCount(value) {
+  assertNonNegativeSafeInteger(value, 'resource count');
+  return value;
+}
+function monotonicTimestamp(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error('monotonic timestamp must be finite and non-negative');
+  }
+  return value;
+}
+function deadline(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error('deadline must be finite and non-negative');
+  }
+  return value;
+}
+function ownBytes(bytes, maximumBytes) {
+  if (bytes.byteLength > maximumBytes) {
+    throw (0, _errors.contractError)('bytes.too-large', 'boundary', 'primitives.own-bytes');
+  }
+  return new Uint8Array(bytes);
+}
+function version(axis, value) {
+  assertNonNegativeSafeInteger(value, `${axis} version`);
+  return {
+    axis,
+    value
+  };
+}
+function versionRange(minimum, maximum) {
+  if (minimum.axis !== maximum.axis) {
+    throw (0, _errors.contractError)('protocol.malformed', 'core', 'version-range.axes');
+  }
+  if (minimum.value > maximum.value) {
+    throw (0, _errors.contractError)('protocol.malformed', 'core', 'version-range.minimum');
+  }
+  return {
+    axis: minimum.axis,
+    minimum,
+    maximum
+  };
+}
+function negotiateVersion(localRange, remoteRange) {
+  assertNegotiationRange(localRange);
+  assertNegotiationRange(remoteRange);
+  if (localRange.axis !== remoteRange.axis) {
+    throw (0, _errors.contractError)('protocol.malformed', 'core', 'version-negotiate.axes');
+  }
+  const selectedValue = Math.min(localRange.maximum.value, remoteRange.maximum.value);
+  if (selectedValue < localRange.minimum.value || selectedValue < remoteRange.minimum.value) {
+    throw (0, _errors.contractError)('protocol.incompatible', 'core', `version-negotiate.${localRange.axis}`);
+  }
+  return {
+    axis: localRange.axis,
+    selected: version(localRange.axis, selectedValue),
+    localRange,
+    remoteRange
+  };
+}
+function assertNegotiationRange(range) {
+  if (range.axis !== range.minimum.axis || range.axis !== range.maximum.axis || !Number.isSafeInteger(range.minimum.value) || range.minimum.value < 0 || !Number.isSafeInteger(range.maximum.value) || range.maximum.value < 0 || range.minimum.value > range.maximum.value) {
+    throw (0, _errors.contractError)('protocol.malformed', 'core', `version-negotiate.${range.axis}.range`);
+  }
+}
+function negotiateCoreVersions(local, remote) {
+  return {
+    backendContract: negotiateVersion(local.backendContract, remote.backendContract),
+    capabilitySchema: negotiateVersion(local.capabilitySchema, remote.capabilitySchema),
+    eventSchema: negotiateVersion(local.eventSchema, remote.eventSchema),
+    traceFormat: negotiateVersion(local.traceFormat, remote.traceFormat)
+  };
+}
+function assertCoreVersionsAccepted(versions, offer) {
+  assertVersionAccepted(versions.backendContract, offer.backendContract);
+  assertVersionAccepted(versions.capabilitySchema, offer.capabilitySchema);
+  assertVersionAccepted(versions.eventSchema, offer.eventSchema);
+  assertVersionAccepted(versions.traceFormat, offer.traceFormat);
+}
+function applicableVersionAxesEqual(left, right) {
+  if (!negotiatedVersionEqual(left.backendContract, right.backendContract) || !negotiatedVersionEqual(left.capabilitySchema, right.capabilitySchema) || !negotiatedVersionEqual(left.eventSchema, right.eventSchema) || !negotiatedVersionEqual(left.traceFormat, right.traceFormat)) {
+    return false;
+  }
+  if ('nativeProtocol' in left || 'nativeProtocol' in right) {
+    return 'nativeProtocol' in left && 'nativeProtocol' in right && negotiatedVersionEqual(left.nativeProtocol, right.nativeProtocol);
+  }
+  if ('ipcProtocol' in left || 'ipcProtocol' in right) {
+    return 'ipcProtocol' in left && 'ipcProtocol' in right && negotiatedVersionEqual(left.ipcProtocol, right.ipcProtocol);
+  }
+  return true;
+}
+function snapshotApplicableVersionAxes(versions) {
+  const core = {
+    backendContract: snapshotNegotiatedVersion(versions.backendContract),
+    capabilitySchema: snapshotNegotiatedVersion(versions.capabilitySchema),
+    eventSchema: snapshotNegotiatedVersion(versions.eventSchema),
+    traceFormat: snapshotNegotiatedVersion(versions.traceFormat)
+  };
+  if ('nativeProtocol' in versions) {
+    return Object.freeze({
+      ...core,
+      nativeProtocol: snapshotNegotiatedVersion(versions.nativeProtocol)
+    });
+  }
+  if ('ipcProtocol' in versions) {
+    return Object.freeze({
+      ...core,
+      ipcProtocol: snapshotNegotiatedVersion(versions.ipcProtocol)
+    });
+  }
+  return Object.freeze(core);
+}
+function negotiatedVersionEqual(left, right) {
+  return left.axis === right.axis && left.selected.axis === right.selected.axis && left.selected.value === right.selected.value && versionRangeEqual(left.localRange, right.localRange) && versionRangeEqual(left.remoteRange, right.remoteRange);
+}
+function versionRangeEqual(left, right) {
+  return left.axis === right.axis && left.minimum.axis === right.minimum.axis && left.minimum.value === right.minimum.value && left.maximum.axis === right.maximum.axis && left.maximum.value === right.maximum.value;
+}
+function snapshotNegotiatedVersion(versionValue) {
+  return Object.freeze({
+    axis: versionValue.axis,
+    selected: Object.freeze({
+      axis: versionValue.selected.axis,
+      value: versionValue.selected.value
+    }),
+    localRange: snapshotVersionRange(versionValue.localRange),
+    remoteRange: snapshotVersionRange(versionValue.remoteRange)
+  });
+}
+function snapshotVersionRange(range) {
+  return Object.freeze({
+    axis: range.axis,
+    minimum: Object.freeze({
+      axis: range.minimum.axis,
+      value: range.minimum.value
+    }),
+    maximum: Object.freeze({
+      axis: range.maximum.axis,
+      value: range.maximum.value
+    })
+  });
+}
+function assertVersionAccepted(selected, range) {
+  if (selected.axis !== range.axis || selected.selected.value < range.minimum.value || selected.selected.value > range.maximum.value) {
+    throw (0, _errors.contractError)('protocol.incompatible', 'core', `version-accepted.${selected.axis}`);
+  }
+}
+//# sourceMappingURL=primitives.js.map

package/lib/commonjs/backend-contract/primitives.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","assertNonEmptyString","value","label","length","Error","assertNonNegativeSafeInteger","Number","isSafeInteger","opaqueId","kind","scope","runtimeScopedOpaqueId","attachmentScope","binding","values","attachmentId","backendInstanceId","backendGeneration","adapterId","adapterGeneration","String","map","join","createAttachmentBoundIdFactory","connectionId","leaseId","scanShareToken","scanSessionId","databaseId","subscriptionId","operationCorrelation","backendOperationHandle","createIpcOperationIdFactory","ipcOperationCorrelation","ipcDispatchEpoch","rebindAttachmentBoundId","id","source","target","canonicalUuid","normalized","toLowerCase","test","byteLimit","capacity","resourceCount","monotonicTimestamp","isFinite","deadline","ownBytes","bytes","maximumBytes","byteLength","contractError","Uint8Array","version","axis","versionRange","minimum","maximum","negotiateVersion","localRange","remoteRange","assertNegotiationRange","selectedValue","Math","min","selected","range","negotiateCoreVersions","local","remote","backendContract","capabilitySchema","eventSchema","traceFormat","assertCoreVersionsAccepted","versions","offer","assertVersionAccepted","applicableVersionAxesEqual","left","right","negotiatedVersionEqual","nativeProtocol","ipcProtocol","snapshotApplicableVersionAxes","core","snapshotNegotiatedVersion","Object","freeze","versionRangeEqual","versionValue","snapshotVersionRange"],"sourceRoot":"../../../src","sources":["backend-contract/primitives.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/backend-contract/restoration.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=restoration.js.map

package/lib/commonjs/backend-contract/restoration.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["backend-contract/restoration.ts"],"mappings":"","ignoreList":[]}

package/lib/commonjs/backend-contract/serializable.js

@@ -0,0 +1,173 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializableRecordsEqual = serializableRecordsEqual;
+exports.snapshotSerializableRecord = snapshotSerializableRecord;
+exports.utf8ByteLength = utf8ByteLength;
+var _errors = require("./errors.js");
+var _primitives = require("./primitives.js");
+// src/backend-contract/serializable.ts
+
+const textEncoder = new TextEncoder();
+
+/** Deep-copies a serializable record while measuring its deterministic wire-size budget. */
+function snapshotSerializableRecord(record) {
+  const activeObjects = new WeakSet();
+  const snapshot = snapshotRecord(record, activeObjects);
+  return {
+    value: snapshot.value,
+    byteLength: snapshot.byteLength
+  };
+}
+function utf8ByteLength(value) {
+  return textEncoder.encode(value).byteLength;
+}
+
+/** Compares serializable records recursively, including owned byte contents. */
+function serializableRecordsEqual(left, right) {
+  const leftEntries = Object.entries(left);
+  const rightKeys = Object.keys(right);
+  if (leftEntries.length !== rightKeys.length) {
+    return false;
+  }
+  for (const [key, leftValue] of leftEntries) {
+    const rightValue = right[key];
+    if (!Object.prototype.hasOwnProperty.call(right, key) || rightValue === undefined || !serializableValuesEqual(leftValue, rightValue)) {
+      return false;
+    }
+  }
+  return true;
+}
+function snapshotValue(value, activeObjects) {
+  if (value === null) {
+    return {
+      value: null,
+      byteLength: 4
+    };
+  }
+  if (typeof value === 'boolean') {
+    return {
+      value,
+      byteLength: value ? 4 : 5
+    };
+  }
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) {
+      throw (0, _errors.contractError)('protocol.malformed', 'boundary', 'serializable.snapshot.number');
+    }
+    return {
+      value,
+      byteLength: utf8ByteLength(String(value))
+    };
+  }
+  if (typeof value === 'string') {
+    return {
+      value,
+      byteLength: quotedStringByteLength(value)
+    };
+  }
+  if (value instanceof Uint8Array) {
+    const copied = (0, _primitives.ownBytes)(value, (0, _primitives.byteLimit)(value.byteLength));
+    return {
+      value: copied,
+      byteLength: value.byteLength
+    };
+  }
+  if (isSerializableArray(value)) {
+    if (activeObjects.has(value)) {
+      throw (0, _errors.contractError)('protocol.malformed', 'boundary', 'serializable.snapshot.cycle');
+    }
+    activeObjects.add(value);
+    try {
+      const items = [];
+      let byteLength = 2;
+      for (const item of value) {
+        const itemSnapshot = snapshotValue(item, activeObjects);
+        if (items.length > 0) {
+          byteLength += 1;
+        }
+        items.push(itemSnapshot.value);
+        byteLength += itemSnapshot.byteLength;
+      }
+      return {
+        value: Object.freeze(items),
+        byteLength
+      };
+    } finally {
+      activeObjects.delete(value);
+    }
+  }
+  return snapshotRecord(value, activeObjects);
+}
+function isSerializableArray(value) {
+  return Array.isArray(value);
+}
+function serializableValuesEqual(left, right) {
+  if (left === null || typeof left !== 'object') {
+    return left === right;
+  }
+  if (left instanceof Uint8Array) {
+    if (!(right instanceof Uint8Array) || left.byteLength !== right.byteLength) {
+      return false;
+    }
+    for (let index = 0; index < left.byteLength; index += 1) {
+      if (left[index] !== right[index]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (isSerializableArray(left)) {
+    if (!isSerializableArray(right) || left.length !== right.length) {
+      return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+      const leftValue = left[index];
+      const rightValue = right[index];
+      if (leftValue === undefined || rightValue === undefined || !serializableValuesEqual(leftValue, rightValue)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (right === null || typeof right !== 'object' || right instanceof Uint8Array || isSerializableArray(right)) {
+    return false;
+  }
+  return serializableRecordsEqual(left, right);
+}
+function snapshotRecord(record, activeObjects) {
+  if (activeObjects.has(record)) {
+    throw (0, _errors.contractError)('protocol.malformed', 'boundary', 'serializable.snapshot.cycle');
+  }
+  activeObjects.add(record);
+  try {
+    const result = {};
+    let byteLength = 2;
+    let entryCount = 0;
+    for (const [key, value] of Object.entries(record)) {
+      const valueSnapshot = snapshotValue(value, activeObjects);
+      if (entryCount > 0) {
+        byteLength += 1;
+      }
+      result[key] = valueSnapshot.value;
+      byteLength += quotedStringByteLength(key) + 1 + valueSnapshot.byteLength;
+      entryCount += 1;
+    }
+    return {
+      value: Object.freeze(result),
+      byteLength
+    };
+  } finally {
+    activeObjects.delete(record);
+  }
+}
+function quotedStringByteLength(value) {
+  const serialized = JSON.stringify(value);
+  if (serialized === undefined) {
+    throw (0, _errors.contractError)('protocol.malformed', 'boundary', 'serializable.snapshot.string');
+  }
+  return utf8ByteLength(serialized);
+}
+//# sourceMappingURL=serializable.js.map