@topgunbuild/core 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/HLC.ts
 var _HLC = class _HLC {
   constructor(nodeId) {
@@ -87,7 +94,17 @@ _HLC.MAX_DRIFT = 6e4;
 var HLC = _HLC;
 
 // src/utils/hash.ts
-function hashString(str) {
+var nativeHash = null;
+var nativeLoadAttempted = false;
+function tryLoadNative() {
+  if (nativeLoadAttempted) return;
+  nativeLoadAttempted = true;
+  try {
+    nativeHash = __require("@topgunbuild/native");
+  } catch {
+  }
+}
+function fnv1aHash(str) {
   let hash = 2166136261;
   for (let i = 0; i < str.length; i++) {
     hash ^= str.charCodeAt(i);
@@ -95,6 +112,13 @@ function hashString(str) {
   }
   return hash >>> 0;
 }
+function hashString(str) {
+  tryLoadNative();
+  if (nativeHash && nativeHash.isNativeHashAvailable()) {
+    return nativeHash.hashString(str);
+  }
+  return fnv1aHash(str);
+}
 function combineHashes(hashes) {
   let result = 0;
   for (const h of hashes) {
@@ -102,6 +126,18 @@ function combineHashes(hashes) {
   }
   return result >>> 0;
 }
+function isUsingNativeHash() {
+  tryLoadNative();
+  return nativeHash?.isNativeHashAvailable() === true;
+}
+function disableNativeHash() {
+  nativeHash = null;
+  nativeLoadAttempted = true;
+}
+function resetNativeHash() {
+  nativeHash = null;
+  nativeLoadAttempted = false;
+}
 
 // src/MerkleTree.ts
 var MerkleTree = class {
@@ -925,12 +961,13 @@ var ORMap = class {
 };
 
 // src/serializer.ts
-import { encode, decode } from "@msgpack/msgpack";
+import { pack, unpack } from "msgpackr";
 function serialize(data) {
-  return encode(data);
+  return pack(data);
 }
 function deserialize(data) {
-  return decode(data);
+  const buffer = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+  return unpack(buffer);
 }
 
 // src/predicate.ts
@@ -1021,9 +1058,16 @@ function evaluatePredicate(predicate, data) {
 
 // src/schemas.ts
 import { z } from "zod";
+var WriteConcernSchema = z.enum([
+  "FIRE_AND_FORGET",
+  "MEMORY",
+  "APPLIED",
+  "REPLICATED",
+  "PERSISTED"
+]);
 var TimestampSchema = z.object({
-  millis: z.number(),
-  counter: z.number(),
+  millis: z.union([z.number(), z.bigint()]).transform(Number),
+  counter: z.union([z.number(), z.bigint()]).transform(Number),
   nodeId: z.string()
 });
 var LWWRecordSchema = z.object({
@@ -1072,7 +1116,10 @@ var ClientOpSchema = z.object({
   opType: z.string().optional(),
   record: LWWRecordSchema.nullable().optional(),
   orRecord: ORMapRecordSchema.nullable().optional(),
-  orTag: z.string().nullable().optional()
+  orTag: z.string().nullable().optional(),
+  // Write Concern fields (Phase 5.01)
+  writeConcern: WriteConcernSchema.optional(),
+  timeout: z.number().optional()
 });
 var AuthMessageSchema = z.object({
   type: z.literal("AUTH"),
@@ -1099,7 +1146,10 @@ var ClientOpMessageSchema = z.object({
 var OpBatchMessageSchema = z.object({
   type: z.literal("OP_BATCH"),
   payload: z.object({
-    ops: z.array(ClientOpSchema)
+    ops: z.array(ClientOpSchema),
+    // Batch-level Write Concern (can be overridden per-op)
+    writeConcern: WriteConcernSchema.optional(),
+    timeout: z.number().optional()
   })
 });
 var SyncInitMessageSchema = z.object({
@@ -1197,6 +1247,11 @@ var PongMessageSchema = z.object({
   serverTime: z.number()
   // Server's Date.now() (for clock skew detection)
 });
+var BatchMessageSchema = z.object({
+  type: z.literal("BATCH"),
+  count: z.number(),
+  data: z.instanceof(Uint8Array)
+});
 var ORMapSyncInitSchema = z.object({
   type: z.literal("ORMAP_SYNC_INIT"),
   mapName: z.string(),
@@ -1270,6 +1325,40 @@ var ORMapPushDiffSchema = z.object({
     }))
   })
 });
+var PartitionMapRequestSchema = z.object({
+  type: z.literal("PARTITION_MAP_REQUEST"),
+  payload: z.object({
+    currentVersion: z.number().optional()
+  }).optional()
+});
+var OpResultSchema = z.object({
+  opId: z.string(),
+  success: z.boolean(),
+  achievedLevel: WriteConcernSchema,
+  error: z.string().optional()
+});
+var OpAckMessageSchema = z.object({
+  type: z.literal("OP_ACK"),
+  payload: z.object({
+    /** ID of the last operation in the batch (for backwards compatibility) */
+    lastId: z.string(),
+    /** Write Concern level achieved (for simple ACKs) */
+    achievedLevel: WriteConcernSchema.optional(),
+    /** Per-operation results (for batch operations with mixed Write Concern) */
+    results: z.array(OpResultSchema).optional()
+  })
+});
+var OpRejectedMessageSchema = z.object({
+  type: z.literal("OP_REJECTED"),
+  payload: z.object({
+    /** Operation ID that was rejected */
+    opId: z.string(),
+    /** Reason for rejection */
+    reason: z.string(),
+    /** Error code */
+    code: z.number().optional()
+  })
+});
 var MessageSchema = z.discriminatedUnion("type", [
   AuthMessageSchema,
   QuerySubMessageSchema,
@@ -1296,12 +1385,107 @@ var MessageSchema = z.discriminatedUnion("type", [
   ORMapSyncRespLeafSchema,
   ORMapDiffRequestSchema,
   ORMapDiffResponseSchema,
-  ORMapPushDiffSchema
+  ORMapPushDiffSchema,
+  // Phase 4: Partition Map
+  PartitionMapRequestSchema
 ]);
+
+// src/types/WriteConcern.ts
+var WriteConcern = /* @__PURE__ */ ((WriteConcern2) => {
+  WriteConcern2["FIRE_AND_FORGET"] = "FIRE_AND_FORGET";
+  WriteConcern2["MEMORY"] = "MEMORY";
+  WriteConcern2["APPLIED"] = "APPLIED";
+  WriteConcern2["REPLICATED"] = "REPLICATED";
+  WriteConcern2["PERSISTED"] = "PERSISTED";
+  return WriteConcern2;
+})(WriteConcern || {});
+var DEFAULT_WRITE_CONCERN_TIMEOUT = 5e3;
+var WRITE_CONCERN_ORDER = [
+  "FIRE_AND_FORGET" /* FIRE_AND_FORGET */,
+  "MEMORY" /* MEMORY */,
+  "APPLIED" /* APPLIED */,
+  "REPLICATED" /* REPLICATED */,
+  "PERSISTED" /* PERSISTED */
+];
+function isWriteConcernAchieved(achieved, target) {
+  const targetIndex = WRITE_CONCERN_ORDER.indexOf(target);
+  const achievedIndex = Math.max(
+    ...Array.from(achieved).map((l) => WRITE_CONCERN_ORDER.indexOf(l))
+  );
+  return achievedIndex >= targetIndex;
+}
+function getHighestWriteConcernLevel(achieved) {
+  for (let i = WRITE_CONCERN_ORDER.length - 1; i >= 0; i--) {
+    if (achieved.has(WRITE_CONCERN_ORDER[i])) {
+      return WRITE_CONCERN_ORDER[i];
+    }
+  }
+  return "FIRE_AND_FORGET" /* FIRE_AND_FORGET */;
+}
+
+// src/types/cluster.ts
+var DEFAULT_CONNECTION_POOL_CONFIG = {
+  maxConnectionsPerNode: 1,
+  connectionTimeoutMs: 5e3,
+  healthCheckIntervalMs: 1e4,
+  reconnectDelayMs: 1e3,
+  maxReconnectDelayMs: 3e4,
+  maxReconnectAttempts: 5
+};
+var DEFAULT_PARTITION_ROUTER_CONFIG = {
+  fallbackMode: "forward",
+  mapRefreshIntervalMs: 3e4,
+  maxMapStalenessMs: 6e4
+};
+var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+  failureThreshold: 5,
+  resetTimeoutMs: 3e4
+};
+var PartitionState = /* @__PURE__ */ ((PartitionState2) => {
+  PartitionState2["STABLE"] = "STABLE";
+  PartitionState2["MIGRATING"] = "MIGRATING";
+  PartitionState2["SYNC"] = "SYNC";
+  PartitionState2["FAILED"] = "FAILED";
+  return PartitionState2;
+})(PartitionState || {});
+var DEFAULT_MIGRATION_CONFIG = {
+  batchSize: 10,
+  batchIntervalMs: 5e3,
+  transferChunkSize: 65536,
+  // 64KB
+  maxRetries: 3,
+  syncTimeoutMs: 3e4,
+  parallelTransfers: 4
+};
+var ConsistencyLevel = /* @__PURE__ */ ((ConsistencyLevel2) => {
+  ConsistencyLevel2["STRONG"] = "STRONG";
+  ConsistencyLevel2["QUORUM"] = "QUORUM";
+  ConsistencyLevel2["EVENTUAL"] = "EVENTUAL";
+  return ConsistencyLevel2;
+})(ConsistencyLevel || {});
+var DEFAULT_REPLICATION_CONFIG = {
+  defaultConsistency: "EVENTUAL" /* EVENTUAL */,
+  queueSizeLimit: 1e4,
+  batchSize: 100,
+  batchIntervalMs: 50,
+  ackTimeoutMs: 5e3,
+  maxRetries: 3
+};
+var PARTITION_COUNT = 271;
+var DEFAULT_BACKUP_COUNT = 1;
 export {
   AuthMessageSchema,
+  BatchMessageSchema,
   ClientOpMessageSchema,
   ClientOpSchema,
+  ConsistencyLevel,
+  DEFAULT_BACKUP_COUNT,
+  DEFAULT_CIRCUIT_BREAKER_CONFIG,
+  DEFAULT_CONNECTION_POOL_CONFIG,
+  DEFAULT_MIGRATION_CONFIG,
+  DEFAULT_PARTITION_ROUTER_CONFIG,
+  DEFAULT_REPLICATION_CONFIG,
+  DEFAULT_WRITE_CONCERN_TIMEOUT,
   HLC,
   LWWMap,
   LWWRecordSchema,
@@ -1321,7 +1505,13 @@ export {
   ORMapSyncRespBucketsSchema,
   ORMapSyncRespLeafSchema,
   ORMapSyncRespRootSchema,
+  OpAckMessageSchema,
   OpBatchMessageSchema,
+  OpRejectedMessageSchema,
+  OpResultSchema,
+  PARTITION_COUNT,
+  PartitionMapRequestSchema,
+  PartitionState,
   PingMessageSchema,
   PongMessageSchema,
   PredicateNodeSchema,
@@ -1339,13 +1529,21 @@ export {
   TopicPubSchema,
   TopicSubSchema,
   TopicUnsubSchema,
+  WRITE_CONCERN_ORDER,
+  WriteConcern,
+  WriteConcernSchema,
   combineHashes,
   compareTimestamps,
   deserialize,
+  disableNativeHash,
   evaluatePredicate,
+  getHighestWriteConcernLevel,
   hashORMapEntry,
   hashORMapRecord,
   hashString,
+  isUsingNativeHash,
+  isWriteConcernAchieved,
+  resetNativeHash,
   serialize,
   timestampToString
 };