refactor(uint64): replace custom Uint64 class with bigint

src/annotation/backend.ts

@@ -33,7 +33,6 @@ import type {
   AnnotationId,
   SerializedAnnotations,
 } from "#src/annotation/index.js";
-import { fixAnnotationAfterStructuredCloning } from "#src/annotation/index.js";
 import type { ChunkManager } from "#src/chunk_manager/backend.js";
 import {
   Chunk,
@@ -67,7 +66,6 @@ import {
 import type { TransformedSource } from "#src/sliceview/base.js";
 import { registerNested, WatchableValue } from "#src/trackable_value.js";
 import type { Borrowed } from "#src/util/disposable.js";
-import type { Uint64 } from "#src/util/uint64.js";
 import {
   getBasePriority,
   getPriorityTier,
@@ -153,7 +151,7 @@ export class AnnotationGeometryChunk extends GeometryChunkMixin(
 
 export class AnnotationSubsetGeometryChunk extends GeometryChunkMixin(Chunk) {
   declare source: AnnotationSubsetGeometryChunkSource;
-  objectId: Uint64;
+  objectId: bigint;
 }
 
 @registerSharedObject(ANNOTATION_METADATA_CHUNK_SOURCE_RPC_ID)
@@ -193,14 +191,14 @@ class AnnotationSubsetGeometryChunkSource extends ChunkSource {
   parent: Borrowed<AnnotationSource> | undefined = undefined;
   declare chunks: Map<string, AnnotationSubsetGeometryChunk>;
   relationshipIndex: number;
-  getChunk(objectId: Uint64) {
+  getChunk(objectId: bigint) {
     const key = getObjectKey(objectId);
     const { chunks } = this;
     let chunk = chunks.get(key);
     if (chunk === undefined) {
       chunk = this.getNewChunk_(AnnotationSubsetGeometryChunk);
       chunk.initialize(key);
-      chunk.objectId = objectId.clone();
+      chunk.objectId = objectId;
       this.addChunk(chunk);
     }
     return chunk;
@@ -303,9 +301,7 @@ registerRPC(ANNOTATION_REFERENCE_DELETE_RPC_ID, function (x: any) {
 registerRPC(ANNOTATION_COMMIT_UPDATE_RPC_ID, function (x: any) {
   const obj = <AnnotationSource>this.get(x.id);
   const annotationId: AnnotationId | undefined = x.annotationId;
-  const newAnnotation: Annotation | null = fixAnnotationAfterStructuredCloning(
-    x.newAnnotation,
-  );
+  const newAnnotation: Annotation | null = x.newAnnotation;
 
   let promise: Promise<Annotation | null>;
   if (annotationId === undefined) {

src/annotation/frontend_source.ts

@@ -37,7 +37,6 @@ import {
   AnnotationType,
   annotationTypeHandlers,
   annotationTypes,
-  fixAnnotationAfterStructuredCloning,
   makeAnnotationId,
   makeAnnotationPropertySerializers,
 } from "#src/annotation/index.js";
@@ -250,7 +249,7 @@ export class AnnotationMetadataChunk extends Chunk {
   annotation: Annotation | null;
   constructor(source: Borrowed<AnnotationMetadataChunkSource>, x: any) {
     super(source);
-    this.annotation = fixAnnotationAfterStructuredCloning(x.annotation);
+    this.annotation = x.annotation;
   }
 }
 
@@ -1008,8 +1007,7 @@ registerRPC(ANNOTATION_COMMIT_UPDATE_RESULT_RPC_ID, function (x) {
   if (error !== undefined) {
     source.handleFailedUpdate(annotationId, error);
   } else {
-    const newAnnotation: Annotation | null =
-      fixAnnotationAfterStructuredCloning(x.newAnnotation);
+    const newAnnotation: Annotation | null = x.newAnnotation;
     source.handleSuccessfulUpdate(annotationId, newAnnotation);
   }
 });

src/annotation/index.ts

@@ -40,6 +40,7 @@ import {
   expectArray,
   parseArray,
   parseFixedLengthArray,
+  parseUint64,
   verifyEnumString,
   verifyFiniteFloat,
   verifyFiniteNonNegativeFloat,
@@ -54,7 +55,6 @@ import {
 import { parseDataTypeValue } from "#src/util/lerp.js";
 import { getRandomHexString } from "#src/util/random.js";
 import { NullarySignal, Signal } from "#src/util/signal.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 export type AnnotationId = string;
 
@@ -642,7 +642,7 @@ export interface AnnotationBase {
   id: AnnotationId;
   type: AnnotationType;
 
-  relatedSegments?: Uint64[][];
+  relatedSegments?: BigUint64Array[];
   properties: any[];
 }
 
@@ -1017,7 +1017,7 @@ export function annotationToJson(
   const { relatedSegments } = annotation;
   if (relatedSegments?.some((x) => x.length !== 0)) {
     result.segments = relatedSegments.map((segments) =>
-      segments.map((x) => x.toString()),
+      Array.from(segments, (x) => x.toString()),
     );
   }
   if (schema.properties.length !== 0) {
@@ -1053,11 +1053,20 @@ function restoreAnnotation(
       return schema.relationships.map(() => []);
     }
     if (schema.relationships.length === 1 && !Array.isArray(a[0])) {
-      return [parseArray(a, (x) => Uint64.parseString(x))];
+      return [
+        parseFixedLengthArray(new BigUint64Array(a.length), a, parseUint64),
+      ];
     }
     return parseArray(
       expectArray(relObj, schema.relationships.length),
-      (segments) => parseArray(segments, (y) => Uint64.parseString(y)),
+      (segments) => {
+        segments = expectArray(segments);
+        return parseFixedLengthArray(
+          new BigUint64Array(segments.length),
+          segments,
+          parseUint64,
+        );
+      },
     );
   });
   const properties = verifyObjectProperty(obj, "props", (propsObj) => {
@@ -1438,24 +1447,3 @@ export class AnnotationSerializer {
     return serializeAnnotations(this.annotations, this.propertySerializers);
   }
 }
-
-export function fixAnnotationAfterStructuredCloning(obj: Annotation | null) {
-  if (obj == null) {
-    return obj;
-  }
-  const { relatedSegments } = obj;
-  if (relatedSegments !== undefined) {
-    for (
-      let i = 0, numRelationships = relatedSegments.length;
-      i < numRelationships;
-      ++i
-    ) {
-      const segments = relatedSegments[i];
-      if (segments === undefined) continue;
-      relatedSegments[i] = segments.map(
-        (x: { low: number; high: number }) => new Uint64(x.low, x.high),
-      );
-    }
-  }
-  return obj;
-}

src/annotation/renderlayer.ts

@@ -126,7 +126,6 @@ import type { MessageList } from "#src/util/message_list.js";
 import { MessageSeverity } from "#src/util/message_list.js";
 import type { AnyConstructor, MixinConstructor } from "#src/util/mixin.js";
 import { NullarySignal } from "#src/util/signal.js";
-import type { Uint64 } from "#src/util/uint64.js";
 import { withSharedVisibility } from "#src/visibility_priority/frontend.js";
 import { GLBuffer } from "#src/webgl/buffer.js";
 import type { ParameterizedContextDependentShaderGetter } from "#src/webgl/dynamic_shader.js";
@@ -639,8 +638,7 @@ function AnnotationRenderLayer<
         pickId = renderContext.pickIDs.register(
           this,
           chunk.numPickIds,
-          0,
-          0,
+          0n,
           chunk,
         );
       }
@@ -701,7 +699,7 @@ function AnnotationRenderLayer<
 
     updateMouseState(
       mouseState: MouseSelectionState,
-      _pickedValue: Uint64,
+      _pickedValue: bigint,
       pickedOffset: number,
       data: any,
     ) {

src/async_computation/encode_compressed_segmentation.ts

@@ -38,16 +38,7 @@ registerAsyncComputation(
   encodeCompressedSegmentationUint64,
   async (rawData, shape, blockSize) => {
     tempBuffer.clear();
-    encodeChannelsUint64(
-      tempBuffer,
-      blockSize,
-      new BigUint64Array(
-        rawData.buffer,
-        rawData.byteOffset,
-        rawData.length / 2,
-      ),
-      shape,
-    );
+    encodeChannelsUint64(tempBuffer, blockSize, rawData, shape);
     return { value: tempBuffer.view };
   },
 );

src/datasource/brainmaps/backend.ts

@@ -84,14 +84,14 @@ import { kInfinityVec, kZeroVec, vec3, vec3Key } from "#src/util/geom.js";
 import {
   parseArray,
   parseFixedLengthArray,
+  parseUint64,
   verifyObject,
   verifyObjectProperty,
   verifyOptionalString,
   verifyString,
   verifyStringArray,
 } from "#src/util/json.js";
 import { defaultStringCompare } from "#src/util/string.js";
-import { Uint64 } from "#src/util/uint64.js";
 import * as vector from "#src/util/vector.js";
 import {
   decodeZIndexCompressed,
@@ -215,13 +215,8 @@ function getFragmentCorner(
   yBits: number,
   zBits: number,
 ): Uint32Array {
-  const id = new Uint64();
-  if (!id.tryParseString(fragmentId, 16)) {
-    throw new Error(
-      `Couldn't parse fragmentId ${fragmentId} as hex-encoded Uint64`,
-    );
-  }
-  return decodeZIndexCompressed(id.toBigInt(), xBits, yBits, zBits);
+  const value = parseUint64(BigInt("0x" + fragmentId));
+  return decodeZIndexCompressed(value, xBits, yBits, zBits);
 }
 
 interface BrainmapsMultiscaleManifestChunk extends MultiscaleManifestChunk {
@@ -383,9 +378,8 @@ function decodeBatchMeshResponse(
     if (index + headerSize > length) {
       throw new Error("Invalid batch mesh fragment response.");
     }
-    const objectIdLow = dataView.getUint32(index, /*littleEndian=*/ true);
-    const objectIdHigh = dataView.getUint32(index + 4, /*littleEndian=*/ true);
-    const objectIdString = new Uint64(objectIdLow, objectIdHigh).toString();
+    const objectId = dataView.getBigUint64(index, /*littleEndian=*/ true);
+    const objectIdString = objectId.toString();
     const prefix = objectIdString + "\0";
     index += 8;
     const fragmentKeyLength = dataView.getUint32(index, /*littleEndian=*/ true);
@@ -892,11 +886,11 @@ function parseBrainmapsAnnotationId(idPrefix: string, fullId: string) {
   return id;
 }
 
-function parseObjectLabels(obj: any): Uint64[][] | undefined {
+function parseObjectLabels(obj: any): BigUint64Array[] | undefined {
   if (obj == null) {
     return undefined;
   }
-  return [parseArray(obj, (x) => Uint64.parseString("" + x, 10))];
+  return [BigUint64Array.from(parseArray(obj, parseUint64))];
 }
 
 function parseAnnotation(
@@ -1064,7 +1058,7 @@ function annotationToBrainmaps(annotation: Annotation): any {
   const objectLabels =
     annotation.relatedSegments === undefined
       ? undefined
-      : annotation.relatedSegments[0].map((x) => x.toString());
+      : Array.from(annotation.relatedSegments[0], (x) => x.toString());
   switch (annotation.type) {
     case AnnotationType.LINE: {
       const { pointA, pointB } = annotation;