@intomind/sdk 0.0.0-stage → 1.4.1

package/src/digest.ts

@@ -0,0 +1,115 @@
+/**
+ * The two digests the contract names, both synchronous.
+ *
+ * The update service reports a CRC-32 over the bytes it has accepted, and a
+ * head blob carries a SHA-256 of everything before it. Both are computed
+ * here rather than through a platform interface because `crypto.subtle` is
+ * asynchronous in a browser and the codec is not, and because a decoder that
+ * has to await a digest cannot refuse a bad blob where it reads it.
+ */
+
+// CRC-32, IEEE 802.3, the same polynomial zlib uses. Four bits at a time,
+// which keeps the table at sixteen entries.
+const CRC_POLY = 0xedb88320;
+
+const CRC_TABLE = (() => {
+  const t = new Uint32Array(16);
+  for (let i = 0; i < 16; i++) {
+    let c = i;
+    for (let k = 0; k < 4; k++) c = c & 1 ? (CRC_POLY ^ (c >>> 1)) >>> 0 : c >>> 1;
+    t[i] = c;
+  }
+  return t;
+})();
+
+/** Running CRC-32, for a transfer that arrives in pieces. */
+export class Crc32 {
+  private state = 0xffffffff;
+
+  /** Fold more bytes into the running checksum, and return this so calls chain. */
+  update(data: Uint8Array): this {
+    let c = this.state;
+    for (let i = 0; i < data.length; i++) {
+      c = (c ^ data[i]!) >>> 0;
+      c = (CRC_TABLE[c & 0xf]! ^ (c >>> 4)) >>> 0;
+      c = (CRC_TABLE[c & 0xf]! ^ (c >>> 4)) >>> 0;
+    }
+    this.state = c;
+    return this;
+  }
+
+  /** The checksum over every slice folded in so far. */
+  finish(): number {
+    return (this.state ^ 0xffffffff) >>> 0;
+  }
+}
+
+/** CRC-32 of one slice. */
+export function crc32(data: Uint8Array): number {
+  return new Crc32().update(data).finish();
+}
+
+const K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+/** SHA-256 of one slice, as thirty two bytes. */
+export function sha256(data: Uint8Array): Uint8Array {
+  const h = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+  ]);
+  // Message, a one bit, zeros, then the length in bits as a 64 bit count.
+  const bitLength = BigInt(data.length) * 8n;
+  const padded = new Uint8Array(((data.length + 9 + 63) >> 6) << 6);
+  padded.set(data);
+  padded[data.length] = 0x80;
+  new DataView(padded.buffer).setBigUint64(padded.length - 8, bitLength, false);
+
+  const w = new Uint32Array(64);
+  const block = new DataView(padded.buffer);
+  for (let at = 0; at < padded.length; at += 64) {
+    for (let i = 0; i < 16; i++) w[i] = block.getUint32(at + i * 4, false);
+    for (let i = 16; i < 64; i++) {
+      const a = w[i - 15]!;
+      const b = w[i - 2]!;
+      const s0 = (rotr(a, 7) ^ rotr(a, 18) ^ (a >>> 3)) >>> 0;
+      const s1 = (rotr(b, 17) ^ rotr(b, 19) ^ (b >>> 10)) >>> 0;
+      w[i] = (w[i - 16]! + s0 + w[i - 7]! + s1) >>> 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h as unknown as number[];
+    for (let i = 0; i < 64; i++) {
+      const s1 = (rotr(e!, 6) ^ rotr(e!, 11) ^ rotr(e!, 25)) >>> 0;
+      const ch = ((e! & f!) ^ (~e! & g!)) >>> 0;
+      const t1 = (hh! + s1 + ch + K[i]! + w[i]!) >>> 0;
+      const s0 = (rotr(a!, 2) ^ rotr(a!, 13) ^ rotr(a!, 22)) >>> 0;
+      const maj = ((a! & b!) ^ (a! & c!) ^ (b! & c!)) >>> 0;
+      const t2 = (s0 + maj) >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = (d! + t1) >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (t1 + t2) >>> 0;
+    }
+    const round = [a!, b!, c!, d!, e!, f!, g!, hh!];
+    for (let i = 0; i < 8; i++) h[i] = (h[i]! + round[i]!) >>> 0;
+  }
+
+  const out = new Uint8Array(32);
+  const view = new DataView(out.buffer);
+  for (let i = 0; i < 8; i++) view.setUint32(i * 4, h[i]!, false);
+  return out;
+}
+
+function rotr(x: number, n: number): number {
+  return ((x >>> n) | (x << (32 - n))) >>> 0;
+}

package/src/index.ts

@@ -0,0 +1,103 @@
+/**
+ * The IntoMind instrument client, for a browser and for Node.
+ *
+ * The protocol, the session, and the timebase do no input and no output.
+ * They are handed bytes that arrived and they hand back bytes to send,
+ * which means they work over whatever Bluetooth stack you already have and
+ * can be tested without one. `web-bluetooth.ts` is the browser transport,
+ * and it is the only file in this package that touches a radio.
+ *
+ * ```ts
+ * import { requestAndConnect } from "@intomind/sdk";
+ *
+ * const device = await requestAndConnect({
+ *   onEvent(event) {
+ *     if (event.type === "samples") write(event.batch);
+ *     // Written down, never smoothed over.
+ *     if (event.type === "gap") writeGap(event.gap);
+ *   },
+ * });
+ * await device.send(device.session.startStream());
+ * ```
+ *
+ * What a device can do is what the device says it can do. Nothing here
+ * holds a table of hardware, and a capability is a bit the device reports
+ * rather than a version number this package compares against.
+ */
+
+export * as protocol from "./protocol.ts";
+
+export {
+  CAPABILITIES,
+  CAPABILITIES_HIGH,
+  DeviceInfo,
+  EMBED_SCALE,
+  FILL,
+  GAIN_BY_CODE,
+  Invalid,
+  MODES,
+  NAME_MAX_COMPOSED,
+  NAME_PREFIX,
+  NO_ENCODER_ID,
+  OPCODES,
+  PRODUCT_NAME,
+  ProtocolError,
+  RATE_BY_CODE,
+  Reserved,
+  SERVICE,
+  Truncated,
+  VERSION,
+  buildHead,
+  composeName,
+  continuity,
+  decodeHead,
+  decodeModelInterval,
+  decodeNameParts,
+  decodePacket,
+  displayNames,
+  evaluateHead,
+  microvolts,
+  nameFits,
+  quantizeEmbedding,
+  uuid,
+} from "./protocol.ts";
+
+export type {
+  CapabilityHighName,
+  CapabilityName,
+  Continuity,
+  ModeName,
+  ModelInterval,
+  Envelope,
+  HeadBlob,
+  HeadEntry,
+  OpcodeName,
+  Packet,
+  Prediction,
+  Refusal,
+  Request,
+  Response,
+  Status,
+  UpdateResponse,
+} from "./protocol.ts";
+
+export { Batch, NoDeviceInfo, NotCapable, Session, SessionError } from "./session.ts";
+export type { Command, Event, Gap } from "./session.ts";
+
+export { Exchange, MAX_SKEW_PPM, MAX_SKEW_STDERR_PPM, Timebase } from "./timebase.ts";
+export type { Fit } from "./timebase.ts";
+
+export {
+  ChecksumMismatch,
+  OffsetMismatch,
+  Refused,
+  Rejected,
+  Transfer,
+  TransferError,
+  Unexpected,
+  activate,
+} from "./transfer.ts";
+export type { Step } from "./transfer.ts";
+
+export { Connection, NoBluetooth, connect, hostClock, requestAndConnect, requestDevice } from "./web-bluetooth.ts";
+export type { ConnectOptions, RequestOptions } from "./web-bluetooth.ts";