hyperspace-sdk-ts 3.1.1 → 3.1.3

package/dist/math.d.ts

@@ -42,3 +42,7 @@ export declare function koopmanExtrapolate(past: number[], current: number[], st
  * Pulls the thought towards the context along the geodesic by `resonanceFactor` [0, 1].
  */
 export declare function contextResonance(thought: number[], globalContext: number[], resonanceFactor: number, c?: number): number[];
+export declare function generateOrthogonalMatrix(dimension: number, seedBytes: Uint8Array): number[][];
+export declare function generateLorentzMatrix(dimension: number, seedBytes: Uint8Array): number[][];
+export declare function projectVector(v: number[], projectionMatrix: number[][]): number[];
+export declare function injectAnisotropicNoise(vector: number[], noiseSeed: Uint8Array, sigma?: number): number[];

package/dist/math.js

@@ -21,6 +21,10 @@ exports.localEntropy = localEntropy;
 exports.lyapunovConvergence = lyapunovConvergence;
 exports.koopmanExtrapolate = koopmanExtrapolate;
 exports.contextResonance = contextResonance;
+exports.generateOrthogonalMatrix = generateOrthogonalMatrix;
+exports.generateLorentzMatrix = generateLorentzMatrix;
+exports.projectVector = projectVector;
+exports.injectAnisotropicNoise = injectAnisotropicNoise;
 function dot(a, b) {
     let sum = 0;
     for (let i = 0; i < a.length; i++)
@@ -232,3 +236,149 @@ function contextResonance(thought, globalContext, resonanceFactor, c = 1.0) {
     const appliedPull = pullDir.map(v => v * factor);
     return expMap(thought, appliedPull, c);
 }
+function generateOrthogonalMatrix(dimension, seedBytes) {
+    const crypto = require('crypto');
+    const matrix = [];
+    let currentHash = crypto.createHash('sha256').update(seedBytes).digest();
+    let hashOffset = 0;
+    for (let i = 0; i < dimension; i++) {
+        const row = [];
+        for (let j = 0; j < dimension; j++) {
+            if (hashOffset >= 32) {
+                currentHash = crypto.createHash('sha256').update(currentHash).digest();
+                hashOffset = 0;
+            }
+            const val = (currentHash.readUInt32LE(hashOffset) / 4294967296.0) * 2.0 - 1.0;
+            row.push(val);
+            hashOffset += 4;
+        }
+        matrix.push(row);
+    }
+    // Gram-Schmidt Orthonormalization with Reorthogonalization (twice is enough)
+    for (let i = 0; i < dimension; i++) {
+        let v = matrix[i];
+        for (let j = 0; j < i; j++) {
+            const u = matrix[j];
+            let uDotV = dot(u, v);
+            v = v.map((vi, k) => vi - uDotV * u[k]);
+            // Re-project to eliminate floating-point leakage
+            uDotV = dot(u, v);
+            v = v.map((vi, k) => vi - uDotV * u[k]);
+        }
+        const vNorm = norm(v);
+        if (vNorm > 1e-15) {
+            matrix[i] = v.map(vi => vi / vNorm);
+        }
+        else {
+            matrix[i] = new Array(dimension).fill(0);
+            matrix[i][i] = 1.0;
+        }
+    }
+    return matrix;
+}
+function generateLorentzMatrix(dimension, seedBytes) {
+    const d = dimension - 1;
+    const crypto = require('crypto');
+    const rSeed = crypto.createHash('sha256').update(seedBytes).update("spatial").digest();
+    const R = generateOrthogonalMatrix(d, rSeed);
+    const bSeed = crypto.createHash('sha256').update(seedBytes).update("boost").digest();
+    let beta = [];
+    let currentHash = bSeed;
+    let hashOffset = 0;
+    for (let i = 0; i < d; i++) {
+        if (hashOffset >= 32) {
+            currentHash = crypto.createHash('sha256').update(currentHash).digest();
+            hashOffset = 0;
+        }
+        const val = (currentHash.readUInt32LE(hashOffset) / 4294967296.0) * 2.0 - 1.0;
+        beta.push(val);
+        hashOffset += 4;
+    }
+    const betaNorm = norm(beta);
+    if (betaNorm > 1e-15) {
+        beta = beta.map(v => (v / betaNorm) * 0.1);
+    }
+    else {
+        beta = new Array(d).fill(0);
+        beta[0] = 0.1;
+    }
+    const betaSq = dot(beta, beta);
+    const gamma = 1.0 / Math.sqrt(1.0 - betaSq);
+    const Lambda_B = [];
+    for (let i = 0; i < dimension; i++) {
+        Lambda_B.push(new Array(dimension).fill(0));
+    }
+    Lambda_B[0][0] = gamma;
+    for (let j = 1; j < dimension; j++) {
+        Lambda_B[0][j] = -gamma * beta[j - 1];
+        Lambda_B[j][0] = -gamma * beta[j - 1];
+    }
+    const factor = (gamma - 1.0) / betaSq;
+    for (let i = 1; i < dimension; i++) {
+        for (let j = 1; j < dimension; j++) {
+            const delta = i === j ? 1.0 : 0.0;
+            Lambda_B[i][j] = delta + factor * beta[i - 1] * beta[j - 1];
+        }
+    }
+    const Lambda_R = [];
+    for (let i = 0; i < dimension; i++) {
+        Lambda_R.push(new Array(dimension).fill(0));
+    }
+    Lambda_R[0][0] = 1.0;
+    for (let i = 1; i < dimension; i++) {
+        for (let j = 1; j < dimension; j++) {
+            Lambda_R[i][j] = R[i - 1][j - 1];
+        }
+    }
+    const Lambda = [];
+    for (let i = 0; i < dimension; i++) {
+        const row = [];
+        for (let j = 0; j < dimension; j++) {
+            let sum = 0;
+            for (let k = 0; k < dimension; k++) {
+                sum += Lambda_R[i][k] * Lambda_B[k][j];
+            }
+            row.push(sum);
+        }
+        Lambda.push(row);
+    }
+    return Lambda;
+}
+function projectVector(v, projectionMatrix) {
+    const dimension = v.length;
+    const projected = new Array(dimension).fill(0);
+    for (let j = 0; j < dimension; j++) {
+        let sum = 0;
+        for (let i = 0; i < dimension; i++) {
+            sum += v[i] * projectionMatrix[i][j];
+        }
+        projected[j] = sum;
+    }
+    return projected;
+}
+function injectAnisotropicNoise(vector, noiseSeed, sigma = 0.02) {
+    if (sigma <= 0.0)
+        return [...vector];
+    const crypto = require('crypto');
+    const vecBytes = Buffer.from(vector.toString());
+    const hash = crypto.createHash('sha256').update(noiseSeed).update(vecBytes).digest();
+    let currentHash = hash;
+    const noise = [];
+    for (let i = 0; i < vector.length; i++) {
+        if (currentHash.length < 16) {
+            currentHash = crypto.createHash('sha256').update(currentHash).digest();
+        }
+        const u1 = Math.max(1e-15, (currentHash.readUInt32LE(0) + 1) / 4294967296);
+        const u2 = Math.max(1e-15, (currentHash.readUInt32LE(4) + 1) / 4294967296);
+        const z0 = Math.sqrt(-2.0 * Math.log(u1)) * Math.cos(2.0 * Math.PI * u2);
+        noise.push(z0 * sigma);
+        currentHash = currentHash.subarray(8);
+    }
+    const noisy = vector.map((v, i) => v + noise[i]);
+    const origNorm = norm(vector);
+    const noisyNorm = norm(noisy);
+    if (noisyNorm > 1e-15) {
+        return noisy.map(v => (v / noisyNorm) * origNorm);
+    }
+    return noisy;
+}

package/dist/proto/hyperspace_grpc_pb.js

@@ -70,6 +70,28 @@ function deserialize_hyperspace_ConfigUpdate(buffer_arg) {
   return hyperspace_pb.ConfigUpdate.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_hyperspace_CountRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.CountRequest)) {
+    throw new Error('Expected argument of type hyperspace.CountRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_CountRequest(buffer_arg) {
+  return hyperspace_pb.CountRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_CountResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.CountResponse)) {
+    throw new Error('Expected argument of type hyperspace.CountResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_CountResponse(buffer_arg) {
+  return hyperspace_pb.CountResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_hyperspace_CreateCollectionRequest(arg) {
   if (!(arg instanceof hyperspace_pb.CreateCollectionRequest)) {
     throw new Error('Expected argument of type hyperspace.CreateCollectionRequest');
@@ -191,6 +213,17 @@ function deserialize_hyperspace_FindSemanticClustersResponse(buffer_arg) {
   return hyperspace_pb.FindSemanticClustersResponse.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_hyperspace_FreezeCollectionRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.FreezeCollectionRequest)) {
+    throw new Error('Expected argument of type hyperspace.FreezeCollectionRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_FreezeCollectionRequest(buffer_arg) {
+  return hyperspace_pb.FreezeCollectionRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_hyperspace_GetConceptParentsRequest(arg) {
   if (!(arg instanceof hyperspace_pb.GetConceptParentsRequest)) {
     throw new Error('Expected argument of type hyperspace.GetConceptParentsRequest');
@@ -246,6 +279,50 @@ function deserialize_hyperspace_GetNodeRequest(buffer_arg) {
   return hyperspace_pb.GetNodeRequest.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_hyperspace_GetPointsRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.GetPointsRequest)) {
+    throw new Error('Expected argument of type hyperspace.GetPointsRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetPointsRequest(buffer_arg) {
+  return hyperspace_pb.GetPointsRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetPointsResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.GetPointsResponse)) {
+    throw new Error('Expected argument of type hyperspace.GetPointsResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetPointsResponse(buffer_arg) {
+  return hyperspace_pb.GetPointsResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetSubsumptionTreeRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.GetSubsumptionTreeRequest)) {
+    throw new Error('Expected argument of type hyperspace.GetSubsumptionTreeRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetSubsumptionTreeRequest(buffer_arg) {
+  return hyperspace_pb.GetSubsumptionTreeRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetSubsumptionTreeResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.GetSubsumptionTreeResponse)) {
+    throw new Error('Expected argument of type hyperspace.GetSubsumptionTreeResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetSubsumptionTreeResponse(buffer_arg) {
+  return hyperspace_pb.GetSubsumptionTreeResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_hyperspace_GraphNode(arg) {
   if (!(arg instanceof hyperspace_pb.GraphNode)) {
     throw new Error('Expected argument of type hyperspace.GraphNode');
@@ -257,6 +334,17 @@ function deserialize_hyperspace_GraphNode(buffer_arg) {
   return hyperspace_pb.GraphNode.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_hyperspace_HealthCheckResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.HealthCheckResponse)) {
+    throw new Error('Expected argument of type hyperspace.HealthCheckResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_HealthCheckResponse(buffer_arg) {
+  return hyperspace_pb.HealthCheckResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_hyperspace_InsertRequest(arg) {
   if (!(arg instanceof hyperspace_pb.InsertRequest)) {
     throw new Error('Expected argument of type hyperspace.InsertRequest');
@@ -356,6 +444,28 @@ function deserialize_hyperspace_ReplicationRequest(buffer_arg) {
   return hyperspace_pb.ReplicationRequest.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_hyperspace_ScrollRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.ScrollRequest)) {
+    throw new Error('Expected argument of type hyperspace.ScrollRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_ScrollRequest(buffer_arg) {
+  return hyperspace_pb.ScrollRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_ScrollResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.ScrollResponse)) {
+    throw new Error('Expected argument of type hyperspace.ScrollResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_ScrollResponse(buffer_arg) {
+  return hyperspace_pb.ScrollResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_hyperspace_SearchMultiCollectionRequest(arg) {
   if (!(arg instanceof hyperspace_pb.SearchMultiCollectionRequest)) {
     throw new Error('Expected argument of type hyperspace.SearchMultiCollectionRequest');
@@ -510,6 +620,28 @@ function deserialize_hyperspace_TraverseResponse(buffer_arg) {
   return hyperspace_pb.TraverseResponse.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_hyperspace_UnfreezeCollectionRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.UnfreezeCollectionRequest)) {
+    throw new Error('Expected argument of type hyperspace.UnfreezeCollectionRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_UnfreezeCollectionRequest(buffer_arg) {
+  return hyperspace_pb.UnfreezeCollectionRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_UpdatePayloadRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.UpdatePayloadRequest)) {
+    throw new Error('Expected argument of type hyperspace.UpdatePayloadRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_UpdatePayloadRequest(buffer_arg) {
+  return hyperspace_pb.UpdatePayloadRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_hyperspace_VectorizeRequest(arg) {
   if (!(arg instanceof hyperspace_pb.VectorizeRequest)) {
     throw new Error('Expected argument of type hyperspace.VectorizeRequest');
@@ -579,6 +711,28 @@ createCollection: {
     responseSerialize: serialize_hyperspace_CollectionStatsResponse,
     responseDeserialize: deserialize_hyperspace_CollectionStatsResponse,
   },
+  freezeCollection: {
+    path: '/hyperspace.Database/FreezeCollection',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.FreezeCollectionRequest,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_FreezeCollectionRequest,
+    requestDeserialize: deserialize_hyperspace_FreezeCollectionRequest,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  unfreezeCollection: {
+    path: '/hyperspace.Database/UnfreezeCollection',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.UnfreezeCollectionRequest,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_UnfreezeCollectionRequest,
+    requestDeserialize: deserialize_hyperspace_UnfreezeCollectionRequest,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
   // Insert vectors
 insert: {
     path: '/hyperspace.Database/Insert',
@@ -647,6 +801,51 @@ delete: {
     responseSerialize: serialize_hyperspace_DeleteResponse,
     responseDeserialize: deserialize_hyperspace_DeleteResponse,
   },
+  // Extended Data Ops
+getPoints: {
+    path: '/hyperspace.Database/GetPoints',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.GetPointsRequest,
+    responseType: hyperspace_pb.GetPointsResponse,
+    requestSerialize: serialize_hyperspace_GetPointsRequest,
+    requestDeserialize: deserialize_hyperspace_GetPointsRequest,
+    responseSerialize: serialize_hyperspace_GetPointsResponse,
+    responseDeserialize: deserialize_hyperspace_GetPointsResponse,
+  },
+  updatePayload: {
+    path: '/hyperspace.Database/UpdatePayload',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.UpdatePayloadRequest,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_UpdatePayloadRequest,
+    requestDeserialize: deserialize_hyperspace_UpdatePayloadRequest,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  scroll: {
+    path: '/hyperspace.Database/Scroll',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.ScrollRequest,
+    responseType: hyperspace_pb.ScrollResponse,
+    requestSerialize: serialize_hyperspace_ScrollRequest,
+    requestDeserialize: deserialize_hyperspace_ScrollRequest,
+    responseSerialize: serialize_hyperspace_ScrollResponse,
+    responseDeserialize: deserialize_hyperspace_ScrollResponse,
+  },
+  count: {
+    path: '/hyperspace.Database/Count',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.CountRequest,
+    responseType: hyperspace_pb.CountResponse,
+    requestSerialize: serialize_hyperspace_CountRequest,
+    requestDeserialize: deserialize_hyperspace_CountRequest,
+    responseSerialize: serialize_hyperspace_CountResponse,
+    responseDeserialize: deserialize_hyperspace_CountResponse,
+  },
   // Search (ANN)
 search: {
     path: '/hyperspace.Database/Search',
@@ -739,6 +938,17 @@ getNode: {
     responseSerialize: serialize_hyperspace_FindSemanticClustersResponse,
     responseDeserialize: deserialize_hyperspace_FindSemanticClustersResponse,
   },
+  getSubsumptionTree: {
+    path: '/hyperspace.Database/GetSubsumptionTree',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.GetSubsumptionTreeRequest,
+    responseType: hyperspace_pb.GetSubsumptionTreeResponse,
+    requestSerialize: serialize_hyperspace_GetSubsumptionTreeRequest,
+    requestDeserialize: deserialize_hyperspace_GetSubsumptionTreeRequest,
+    responseSerialize: serialize_hyperspace_GetSubsumptionTreeResponse,
+    responseDeserialize: deserialize_hyperspace_GetSubsumptionTreeResponse,
+  },
   // Stream statistics for TUI (Global or Collection tailored)
 monitor: {
     path: '/hyperspace.Database/Monitor',
@@ -880,6 +1090,18 @@ syncPush: {
     responseSerialize: serialize_hyperspace_SyncPushResponse,
     responseDeserialize: deserialize_hyperspace_SyncPushResponse,
   },
+  // Health Status
+healthCheck: {
+    path: '/hyperspace.Database/HealthCheck',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.Empty,
+    responseType: hyperspace_pb.HealthCheckResponse,
+    requestSerialize: serialize_hyperspace_Empty,
+    requestDeserialize: deserialize_hyperspace_Empty,
+    responseSerialize: serialize_hyperspace_HealthCheckResponse,
+    responseDeserialize: deserialize_hyperspace_HealthCheckResponse,
+  },
 };
 
 exports.DatabaseClient = grpc.makeGenericClientConstructor(DatabaseService, 'Database');