@topgunbuild/core 0.2.1 → 0.4.0

package/dist/index.mjs

@@ -970,6 +970,935 @@ function deserialize(data) {
   return unpack(buffer);
 }
 
+// src/PNCounter.ts
+var PNCounterImpl = class {
+  constructor(config) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.nodeId = config.nodeId;
+    this.state = config.initialState ?? {
+      positive: /* @__PURE__ */ new Map(),
+      negative: /* @__PURE__ */ new Map()
+    };
+  }
+  /**
+   * Get the current counter value.
+   * Value = sum(positive) - sum(negative)
+   */
+  get() {
+    let sum = 0;
+    for (const v of this.state.positive.values()) sum += v;
+    for (const v of this.state.negative.values()) sum -= v;
+    return sum;
+  }
+  /**
+   * Increment by 1 and return the new value.
+   */
+  increment() {
+    return this.addAndGet(1);
+  }
+  /**
+   * Decrement by 1 and return the new value.
+   */
+  decrement() {
+    return this.addAndGet(-1);
+  }
+  /**
+   * Add a delta (positive or negative) and return the new value.
+   * @param delta The amount to add (can be negative)
+   */
+  addAndGet(delta) {
+    if (delta === 0) return this.get();
+    if (delta > 0) {
+      const current = this.state.positive.get(this.nodeId) ?? 0;
+      this.state.positive.set(this.nodeId, current + delta);
+    } else {
+      const current = this.state.negative.get(this.nodeId) ?? 0;
+      this.state.negative.set(this.nodeId, current + Math.abs(delta));
+    }
+    const newValue = this.get();
+    this.notifyListeners(newValue);
+    return newValue;
+  }
+  /**
+   * Get a copy of the current state for synchronization.
+   */
+  getState() {
+    return {
+      positive: new Map(this.state.positive),
+      negative: new Map(this.state.negative)
+    };
+  }
+  /**
+   * Merge remote state into this counter.
+   * Takes the maximum value for each node in both positive and negative counters.
+   * This operation is commutative, associative, and idempotent (CRDT properties).
+   *
+   * @param remote The remote state to merge
+   */
+  merge(remote) {
+    let changed = false;
+    for (const [nodeId, value] of remote.positive) {
+      const current = this.state.positive.get(nodeId) ?? 0;
+      if (value > current) {
+        this.state.positive.set(nodeId, value);
+        changed = true;
+      }
+    }
+    for (const [nodeId, value] of remote.negative) {
+      const current = this.state.negative.get(nodeId) ?? 0;
+      if (value > current) {
+        this.state.negative.set(nodeId, value);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.notifyListeners(this.get());
+    }
+  }
+  /**
+   * Subscribe to value changes.
+   * The listener is immediately called with the current value.
+   *
+   * @param listener Callback function receiving the new value
+   * @returns Unsubscribe function
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.get());
+    return () => this.listeners.delete(listener);
+  }
+  notifyListeners(value) {
+    for (const listener of this.listeners) {
+      try {
+        listener(value);
+      } catch (e) {
+      }
+    }
+  }
+  /**
+   * Get the node ID of this counter instance.
+   */
+  getNodeId() {
+    return this.nodeId;
+  }
+  // ============================================
+  // Serialization
+  // ============================================
+  /**
+   * Serialize state to binary format (msgpack).
+   */
+  static serialize(state) {
+    const obj = {
+      p: Object.fromEntries(state.positive),
+      n: Object.fromEntries(state.negative)
+    };
+    return serialize(obj);
+  }
+  /**
+   * Deserialize binary data to state.
+   */
+  static deserialize(data) {
+    const obj = deserialize(data);
+    return {
+      positive: new Map(Object.entries(obj.p)),
+      negative: new Map(Object.entries(obj.n))
+    };
+  }
+  /**
+   * Convert state to plain object (for JSON/network).
+   */
+  static stateToObject(state) {
+    return {
+      p: Object.fromEntries(state.positive),
+      n: Object.fromEntries(state.negative)
+    };
+  }
+  /**
+   * Convert plain object to state.
+   */
+  static objectToState(obj) {
+    return {
+      positive: new Map(Object.entries(obj.p)),
+      negative: new Map(Object.entries(obj.n))
+    };
+  }
+};
+
+// src/Ringbuffer.ts
+var Ringbuffer = class {
+  // Next sequence to write
+  constructor(capacity) {
+    this.headSequence = 0n;
+    // Oldest available sequence
+    this.tailSequence = 0n;
+    if (capacity < 1) {
+      throw new Error("Capacity must be >= 1");
+    }
+    this._capacity = capacity;
+    this.buffer = new Array(capacity);
+  }
+  /**
+   * Add item to buffer, returns sequence number.
+   */
+  add(item) {
+    const sequence = this.tailSequence;
+    const index = Number(sequence % BigInt(this._capacity));
+    this.buffer[index] = item;
+    this.tailSequence++;
+    if (this.tailSequence - this.headSequence > this._capacity) {
+      this.headSequence = this.tailSequence - BigInt(this._capacity);
+    }
+    return sequence;
+  }
+  /**
+   * Read item at sequence.
+   * Returns undefined if sequence is out of range.
+   */
+  read(sequence) {
+    if (sequence < this.headSequence || sequence >= this.tailSequence) {
+      return void 0;
+    }
+    const index = Number(sequence % BigInt(this._capacity));
+    return this.buffer[index];
+  }
+  /**
+   * Read range of items (inclusive).
+   * Automatically clamps to available range.
+   */
+  readRange(startSeq, endSeq) {
+    const items = [];
+    const actualStart = startSeq < this.headSequence ? this.headSequence : startSeq;
+    const actualEnd = endSeq >= this.tailSequence ? this.tailSequence - 1n : endSeq;
+    for (let seq = actualStart; seq <= actualEnd; seq++) {
+      const item = this.read(seq);
+      if (item !== void 0) {
+        items.push(item);
+      }
+    }
+    return items;
+  }
+  /**
+   * Read from sequence with limit.
+   */
+  readFrom(startSeq, limit = 100) {
+    const endSeq = startSeq + BigInt(limit) - 1n;
+    return this.readRange(startSeq, endSeq);
+  }
+  /**
+   * Get the oldest available sequence number.
+   */
+  getHeadSequence() {
+    return this.headSequence;
+  }
+  /**
+   * Get the next sequence number to be written.
+   */
+  getTailSequence() {
+    return this.tailSequence;
+  }
+  /**
+   * Get the number of items currently in the buffer.
+   */
+  size() {
+    return Number(this.tailSequence - this.headSequence);
+  }
+  /**
+   * Get the maximum capacity of the buffer.
+   */
+  getCapacity() {
+    return this._capacity;
+  }
+  /**
+   * Clear all items from the buffer.
+   */
+  clear() {
+    this.buffer = new Array(this._capacity);
+    this.headSequence = 0n;
+    this.tailSequence = 0n;
+  }
+  /**
+   * Check if a sequence is available in the buffer.
+   */
+  isAvailable(sequence) {
+    return sequence >= this.headSequence && sequence < this.tailSequence;
+  }
+  /**
+   * Get remaining capacity before oldest entries are overwritten.
+   */
+  remainingCapacity() {
+    return this._capacity - this.size();
+  }
+};
+
+// src/EventJournal.ts
+var DEFAULT_EVENT_JOURNAL_CONFIG = {
+  capacity: 1e4,
+  ttlMs: 0,
+  // Infinite
+  persistent: true,
+  includeMaps: [],
+  excludeMaps: []
+};
+var EventJournalImpl = class {
+  constructor(config = {}) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.config = { ...DEFAULT_EVENT_JOURNAL_CONFIG, ...config };
+    this.buffer = new Ringbuffer(this.config.capacity);
+    if (this.config.ttlMs > 0) {
+      this.startTTLCleanup();
+    }
+  }
+  /**
+   * Append event to journal.
+   * Returns the event with assigned sequence number.
+   * Returns event with sequence -1n if map is filtered out.
+   */
+  append(eventData) {
+    if (!this.shouldCapture(eventData.mapName)) {
+      return { ...eventData, sequence: -1n };
+    }
+    const event = {
+      ...eventData,
+      sequence: 0n
+      // Will be set by buffer
+    };
+    const sequence = this.buffer.add(event);
+    event.sequence = sequence;
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (e) {
+        console.error("EventJournal listener error:", e);
+      }
+    }
+    return event;
+  }
+  /**
+   * Read events from sequence with optional limit.
+   */
+  readFrom(sequence, limit = 100) {
+    return this.buffer.readFrom(sequence, limit);
+  }
+  /**
+   * Read events in range (inclusive).
+   */
+  readRange(startSeq, endSeq) {
+    return this.buffer.readRange(startSeq, endSeq);
+  }
+  /**
+   * Get latest sequence number.
+   * Returns 0n if no events have been added.
+   */
+  getLatestSequence() {
+    const tail = this.buffer.getTailSequence();
+    return tail > 0n ? tail - 1n : 0n;
+  }
+  /**
+   * Get oldest available sequence number.
+   */
+  getOldestSequence() {
+    return this.buffer.getHeadSequence();
+  }
+  /**
+   * Subscribe to new events.
+   * Optionally replay events from a specific sequence.
+   *
+   * @param listener Callback for each event
+   * @param fromSequence Optional sequence to start replay from
+   * @returns Unsubscribe function
+   */
+  subscribe(listener, fromSequence) {
+    if (fromSequence !== void 0) {
+      const events = this.readFrom(fromSequence, this.config.capacity);
+      for (const event of events) {
+        try {
+          listener(event);
+        } catch (e) {
+          console.error("EventJournal replay error:", e);
+        }
+      }
+    }
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * Get capacity information.
+   */
+  getCapacity() {
+    return {
+      used: this.buffer.size(),
+      total: this.buffer.getCapacity()
+    };
+  }
+  /**
+   * Force compaction.
+   * Note: The ringbuffer handles eviction automatically.
+   * This method is provided for explicit cleanup of old events.
+   */
+  async compact() {
+  }
+  /**
+   * Check if a map should be captured.
+   */
+  shouldCapture(mapName) {
+    const { includeMaps, excludeMaps } = this.config;
+    if (excludeMaps && excludeMaps.includes(mapName)) {
+      return false;
+    }
+    if (includeMaps && includeMaps.length > 0) {
+      return includeMaps.includes(mapName);
+    }
+    return true;
+  }
+  /**
+   * Start TTL cleanup timer.
+   */
+  startTTLCleanup() {
+    const interval = Math.min(this.config.ttlMs, 6e4);
+    this.ttlTimer = setInterval(() => {
+      this.compact();
+    }, interval);
+  }
+  /**
+   * Dispose resources.
+   */
+  dispose() {
+    if (this.ttlTimer) {
+      clearInterval(this.ttlTimer);
+      this.ttlTimer = void 0;
+    }
+    this.listeners.clear();
+  }
+  /**
+   * Get all current listeners count (for testing).
+   */
+  getListenerCount() {
+    return this.listeners.size;
+  }
+  /**
+   * Get configuration (for testing).
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/EntryProcessor.ts
+import { z } from "zod";
+var EntryProcessorDefSchema = z.object({
+  name: z.string().min(1).max(100),
+  code: z.string().min(1).max(1e4),
+  // Max 10KB code
+  args: z.unknown().optional()
+});
+var FORBIDDEN_PATTERNS = [
+  /\beval\b/,
+  /\bFunction\b/,
+  /\bprocess\b/,
+  /\bglobal\b/,
+  /\brequire\b/,
+  /\bimport\b/,
+  /\bfetch\b/,
+  /\bXMLHttpRequest\b/,
+  /\bsetTimeout\b/,
+  /\bsetInterval\b/,
+  /\bsetImmediate\b/
+];
+function validateProcessorCode(code) {
+  for (const pattern of FORBIDDEN_PATTERNS) {
+    if (pattern.test(code)) {
+      return {
+        valid: false,
+        error: `Forbidden pattern detected: ${pattern.source}`
+      };
+    }
+  }
+  return { valid: true };
+}
+var BuiltInProcessors = {
+  /**
+   * Increment numeric value by delta.
+   * If value doesn't exist, starts from 0.
+   */
+  INCREMENT: (delta = 1) => ({
+    name: "builtin:increment",
+    code: `
+      const current = value ?? 0;
+      const newValue = current + args;
+      return { value: newValue, result: newValue };
+    `,
+    args: delta
+  }),
+  /**
+   * Decrement numeric value by delta.
+   * If value doesn't exist, starts from 0.
+   */
+  DECREMENT: (delta = 1) => ({
+    name: "builtin:decrement",
+    code: `
+      const current = value ?? 0;
+      const newValue = current - args;
+      return { value: newValue, result: newValue };
+    `,
+    args: delta
+  }),
+  /**
+   * Decrement with floor (won't go below 0).
+   * Returns both the new value and whether it was floored.
+   */
+  DECREMENT_FLOOR: (delta = 1) => ({
+    name: "builtin:decrement_floor",
+    code: `
+      const current = value ?? 0;
+      const target = current - args;
+      const newValue = Math.max(0, target);
+      return {
+        value: newValue,
+        result: { newValue, wasFloored: target < 0 }
+      };
+    `,
+    args: delta
+  }),
+  /**
+   * Multiply numeric value by factor.
+   * If value doesn't exist, starts from 1.
+   */
+  MULTIPLY: (factor) => ({
+    name: "builtin:multiply",
+    code: `
+      const current = value ?? 1;
+      const newValue = current * args;
+      return { value: newValue, result: newValue };
+    `,
+    args: factor
+  }),
+  /**
+   * Set value only if key doesn't exist.
+   * Returns true if value was set, false if key already existed.
+   */
+  PUT_IF_ABSENT: (newValue) => ({
+    name: "builtin:put_if_absent",
+    code: `
+      if (value !== undefined) {
+        return { value, result: false };
+      }
+      return { value: args, result: true };
+    `,
+    args: newValue
+  }),
+  /**
+   * Replace value only if key exists.
+   * Returns the old value if replaced, undefined otherwise.
+   */
+  REPLACE: (newValue) => ({
+    name: "builtin:replace",
+    code: `
+      if (value === undefined) {
+        return { value: undefined, result: undefined };
+      }
+      return { value: args, result: value };
+    `,
+    args: newValue
+  }),
+  /**
+   * Replace value only if it matches expected value.
+   * Returns true if replaced, false otherwise.
+   */
+  REPLACE_IF_EQUALS: (expectedValue, newValue) => ({
+    name: "builtin:replace_if_equals",
+    code: `
+      if (JSON.stringify(value) === JSON.stringify(args.expected)) {
+        return { value: args.newValue, result: true };
+      }
+      return { value, result: false };
+    `,
+    args: { expected: expectedValue, newValue }
+  }),
+  /**
+   * Delete entry only if value matches.
+   * Returns true if deleted, false otherwise.
+   */
+  DELETE_IF_EQUALS: (expectedValue) => ({
+    name: "builtin:delete_if_equals",
+    code: `
+      if (JSON.stringify(value) === JSON.stringify(args)) {
+        return { value: undefined, result: true };
+      }
+      return { value, result: false };
+    `,
+    args: expectedValue
+  }),
+  /**
+   * Append item to array.
+   * Creates array if it doesn't exist.
+   * Returns new array length.
+   */
+  ARRAY_PUSH: (item) => ({
+    name: "builtin:array_push",
+    code: `
+      const arr = value ?? [];
+      arr.push(args);
+      return { value: arr, result: arr.length };
+    `,
+    args: item
+  }),
+  /**
+   * Remove last item from array.
+   * Returns the removed item or undefined.
+   */
+  ARRAY_POP: () => ({
+    name: "builtin:array_pop",
+    code: `
+      if (!value || value.length === 0) {
+        return { value: value ?? [], result: undefined };
+      }
+      const removed = value.pop();
+      return { value, result: removed };
+    `
+  }),
+  /**
+   * Remove item from array by value (first occurrence).
+   * Returns true if item was found and removed.
+   */
+  ARRAY_REMOVE: (item) => ({
+    name: "builtin:array_remove",
+    code: `
+      if (!value) {
+        return { value: [], result: false };
+      }
+      const idx = value.findIndex(v => JSON.stringify(v) === JSON.stringify(args));
+      if (idx === -1) {
+        return { value, result: false };
+      }
+      value.splice(idx, 1);
+      return { value, result: true };
+    `,
+    args: item
+  }),
+  /**
+   * Update nested property using dot notation path.
+   * Creates intermediate objects if they don't exist.
+   */
+  SET_PROPERTY: (path, propValue) => ({
+    name: "builtin:set_property",
+    code: `
+      const obj = value ?? {};
+      const parts = args.path.split('.');
+      let current = obj;
+      for (let i = 0; i < parts.length - 1; i++) {
+        current[parts[i]] = current[parts[i]] ?? {};
+        current = current[parts[i]];
+      }
+      current[parts[parts.length - 1]] = args.value;
+      return { value: obj, result: obj };
+    `,
+    args: { path, value: propValue }
+  }),
+  /**
+   * Delete nested property using dot notation path.
+   * Returns the deleted value or undefined.
+   */
+  DELETE_PROPERTY: (path) => ({
+    name: "builtin:delete_property",
+    code: `
+      if (!value) {
+        return { value, result: undefined };
+      }
+      const parts = args.split('.');
+      let current = value;
+      for (let i = 0; i < parts.length - 1; i++) {
+        if (!current[parts[i]]) {
+          return { value, result: undefined };
+        }
+        current = current[parts[i]];
+      }
+      const lastKey = parts[parts.length - 1];
+      const deleted = current[lastKey];
+      delete current[lastKey];
+      return { value, result: deleted };
+    `,
+    args: path
+  }),
+  /**
+   * Get current value without modifying it.
+   * Useful for conditional reads.
+   */
+  GET: () => ({
+    name: "builtin:get",
+    code: `
+      return { value, result: value };
+    `
+  }),
+  /**
+   * Conditional update based on version/timestamp.
+   * Only updates if current version matches expected.
+   * Useful for optimistic locking.
+   */
+  CONDITIONAL_UPDATE: (expectedVersion, newData) => ({
+    name: "builtin:conditional_update",
+    code: `
+      if (!value || value.version !== args.expectedVersion) {
+        return {
+          value,
+          result: { updated: false, conflict: true }
+        };
+      }
+      const updated = {
+        ...value,
+        ...args.newData,
+        version: (value.version ?? 0) + 1,
+      };
+      return {
+        value: updated,
+        result: { updated: true, conflict: false }
+      };
+    `,
+    args: { expectedVersion, newData }
+  }),
+  /**
+   * Merge object properties into existing value.
+   * Shallow merge only.
+   */
+  MERGE: (properties) => ({
+    name: "builtin:merge",
+    code: `
+      const merged = { ...(value ?? {}), ...args };
+      return { value: merged, result: merged };
+    `,
+    args: properties
+  })
+};
+var DEFAULT_PROCESSOR_RATE_LIMITS = {
+  maxExecutionsPerSecond: 100,
+  maxCodeSizeBytes: 10240,
+  // 10KB
+  maxArgsSizeBytes: 1048576
+  // 1MB
+};
+
+// src/ConflictResolver.ts
+import { z as z2 } from "zod";
+var ConflictResolverDefSchema = z2.object({
+  name: z2.string().min(1).max(100),
+  code: z2.string().max(5e4).optional(),
+  priority: z2.number().int().min(0).max(100).default(50),
+  keyPattern: z2.string().optional()
+});
+var RESOLVER_FORBIDDEN_PATTERNS = [
+  /\beval\b/,
+  /\bFunction\b/,
+  /\bprocess\b/,
+  /\bglobal\b/,
+  /\brequire\b/,
+  /\bimport\b/,
+  /\bfetch\b/,
+  /\bXMLHttpRequest\b/,
+  /\bsetTimeout\b/,
+  /\bsetInterval\b/,
+  /\bsetImmediate\b/
+];
+function validateResolverCode(code) {
+  for (const pattern of RESOLVER_FORBIDDEN_PATTERNS) {
+    if (pattern.test(code)) {
+      return {
+        valid: false,
+        error: `Forbidden pattern detected: ${pattern.source}`
+      };
+    }
+  }
+  return { valid: true };
+}
+var DEFAULT_RESOLVER_RATE_LIMITS = {
+  maxResolversPerClient: 50,
+  maxCodeSizeBytes: 5e4
+  // 50KB
+};
+function compareHLCTimestamps(a, b) {
+  return HLC.compare(a, b);
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (typeof sourceVal === "object" && sourceVal !== null && typeof targetVal === "object" && targetVal !== null && !Array.isArray(sourceVal)) {
+      result[key] = deepMerge(
+        targetVal,
+        sourceVal
+      );
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+var BuiltInResolvers = {
+  /**
+   * Standard Last-Write-Wins - accept if remote timestamp is newer.
+   */
+  LWW: () => ({
+    name: "builtin:lww",
+    fn: (ctx) => {
+      if (!ctx.localTimestamp) {
+        return { action: "accept", value: ctx.remoteValue };
+      }
+      const cmp = compareHLCTimestamps(ctx.remoteTimestamp, ctx.localTimestamp);
+      if (cmp > 0) {
+        return { action: "accept", value: ctx.remoteValue };
+      }
+      return { action: "local" };
+    },
+    priority: 0
+    // Lowest priority - fallback
+  }),
+  /**
+   * First-Write-Wins - reject if local value exists.
+   * Useful for booking systems, unique constraints.
+   */
+  FIRST_WRITE_WINS: () => ({
+    name: "builtin:first_write_wins",
+    fn: (ctx) => {
+      if (ctx.localValue !== void 0) {
+        return { action: "reject", reason: "Entry already exists" };
+      }
+      return { action: "accept", value: ctx.remoteValue };
+    },
+    priority: 100
+  }),
+  /**
+   * Numeric minimum - keep lowest value.
+   * Useful for auction systems (lowest bid wins).
+   */
+  NUMERIC_MIN: () => ({
+    name: "builtin:numeric_min",
+    fn: (ctx) => {
+      const local = ctx.localValue ?? Infinity;
+      const remote = ctx.remoteValue;
+      return { action: "merge", value: Math.min(local, remote) };
+    },
+    priority: 50
+  }),
+  /**
+   * Numeric maximum - keep highest value.
+   * Useful for high score tracking.
+   */
+  NUMERIC_MAX: () => ({
+    name: "builtin:numeric_max",
+    fn: (ctx) => {
+      const local = ctx.localValue ?? -Infinity;
+      const remote = ctx.remoteValue;
+      return { action: "merge", value: Math.max(local, remote) };
+    },
+    priority: 50
+  }),
+  /**
+   * Non-negative - reject if value would be negative.
+   * Useful for inventory systems.
+   */
+  NON_NEGATIVE: () => ({
+    name: "builtin:non_negative",
+    fn: (ctx) => {
+      if (typeof ctx.remoteValue !== "number" || ctx.remoteValue < 0) {
+        return { action: "reject", reason: "Value cannot be negative" };
+      }
+      return { action: "accept", value: ctx.remoteValue };
+    },
+    priority: 90
+  }),
+  /**
+   * Array union - merge arrays by taking union of elements.
+   * Useful for tags, categories.
+   */
+  ARRAY_UNION: () => ({
+    name: "builtin:array_union",
+    fn: (ctx) => {
+      const local = ctx.localValue ?? [];
+      const remote = ctx.remoteValue ?? [];
+      const merged = [.../* @__PURE__ */ new Set([...local, ...remote])];
+      return { action: "merge", value: merged };
+    },
+    priority: 50
+  }),
+  /**
+   * Deep merge - recursively merge objects.
+   * Remote values take precedence at leaf level.
+   */
+  DEEP_MERGE: () => ({
+    name: "builtin:deep_merge",
+    fn: (ctx) => {
+      const local = ctx.localValue ?? {};
+      const remote = ctx.remoteValue;
+      const merged = deepMerge(local, remote);
+      return { action: "merge", value: merged };
+    },
+    priority: 50
+  }),
+  /**
+   * Server-only - reject all client writes.
+   * Useful for server-controlled state.
+   */
+  SERVER_ONLY: () => ({
+    name: "builtin:server_only",
+    fn: (ctx) => {
+      if (ctx.auth?.roles?.includes("server") || ctx.remoteNodeId.startsWith("server:")) {
+        return { action: "accept", value: ctx.remoteValue };
+      }
+      return { action: "reject", reason: "Only server can write to this entry" };
+    },
+    priority: 100
+  }),
+  /**
+   * Owner-only - only the original creator can modify.
+   * Requires value to have an `ownerId` property.
+   */
+  OWNER_ONLY: () => ({
+    name: "builtin:owner_only",
+    fn: (ctx) => {
+      if (!ctx.localValue) {
+        return { action: "accept", value: ctx.remoteValue };
+      }
+      const ownerId = ctx.localValue.ownerId;
+      if (ownerId && ctx.auth?.userId !== ownerId) {
+        return { action: "reject", reason: "Only owner can modify this entry" };
+      }
+      return { action: "accept", value: ctx.remoteValue };
+    },
+    priority: 95
+  }),
+  /**
+   * Immutable - reject any modifications after initial write.
+   */
+  IMMUTABLE: () => ({
+    name: "builtin:immutable",
+    fn: (ctx) => {
+      if (ctx.localValue !== void 0) {
+        return { action: "reject", reason: "Entry is immutable" };
+      }
+      return { action: "accept", value: ctx.remoteValue };
+    },
+    priority: 100
+  }),
+  /**
+   * Version check - only accept if version increments by 1.
+   * Useful for optimistic locking.
+   */
+  VERSION_INCREMENT: () => ({
+    name: "builtin:version_increment",
+    fn: (ctx) => {
+      const localVersion = ctx.localValue?.version ?? 0;
+      const remoteVersion = ctx.remoteValue?.version ?? 0;
+      if (remoteVersion !== localVersion + 1) {
+        return {
+          action: "reject",
+          reason: `Version conflict: expected ${localVersion + 1}, got ${remoteVersion}`
+        };
+      }
+      return { action: "accept", value: ctx.remoteValue };
+    },
+    priority: 90
+  })
+};
+
 // src/predicate.ts
 var Predicates = class {
   static equal(attribute, value) {
@@ -1057,31 +1986,31 @@ function evaluatePredicate(predicate, data) {
 }
 
 // src/schemas.ts
-import { z } from "zod";
-var WriteConcernSchema = z.enum([
+import { z as z3 } from "zod";
+var WriteConcernSchema = z3.enum([
   "FIRE_AND_FORGET",
   "MEMORY",
   "APPLIED",
   "REPLICATED",
   "PERSISTED"
 ]);
-var TimestampSchema = z.object({
-  millis: z.number(),
-  counter: z.number(),
-  nodeId: z.string()
+var TimestampSchema = z3.object({
+  millis: z3.union([z3.number(), z3.bigint()]).transform(Number),
+  counter: z3.union([z3.number(), z3.bigint()]).transform(Number),
+  nodeId: z3.string()
 });
-var LWWRecordSchema = z.object({
-  value: z.any().nullable(),
+var LWWRecordSchema = z3.object({
+  value: z3.any().nullable(),
   timestamp: TimestampSchema,
-  ttlMs: z.number().optional()
+  ttlMs: z3.number().optional()
 });
-var ORMapRecordSchema = z.object({
-  value: z.any(),
+var ORMapRecordSchema = z3.object({
+  value: z3.any(),
   timestamp: TimestampSchema,
-  tag: z.string(),
-  ttlMs: z.number().optional()
+  tag: z3.string(),
+  ttlMs: z3.number().optional()
 });
-var PredicateOpSchema = z.enum([
+var PredicateOpSchema = z3.enum([
   "eq",
   "neq",
   "gt",
@@ -1094,266 +2023,438 @@ var PredicateOpSchema = z.enum([
   "or",
   "not"
 ]);
-var PredicateNodeSchema = z.lazy(() => z.object({
+var PredicateNodeSchema = z3.lazy(() => z3.object({
   op: PredicateOpSchema,
-  attribute: z.string().optional(),
-  value: z.any().optional(),
-  children: z.array(PredicateNodeSchema).optional()
+  attribute: z3.string().optional(),
+  value: z3.any().optional(),
+  children: z3.array(PredicateNodeSchema).optional()
 }));
-var QuerySchema = z.object({
-  where: z.record(z.string(), z.any()).optional(),
+var QuerySchema = z3.object({
+  where: z3.record(z3.string(), z3.any()).optional(),
   predicate: PredicateNodeSchema.optional(),
-  sort: z.record(z.string(), z.enum(["asc", "desc"])).optional(),
-  limit: z.number().optional(),
-  offset: z.number().optional()
-});
-var ClientOpSchema = z.object({
-  id: z.string().optional(),
-  mapName: z.string(),
-  key: z.string(),
+  sort: z3.record(z3.string(), z3.enum(["asc", "desc"])).optional(),
+  limit: z3.number().optional(),
+  offset: z3.number().optional()
+});
+var ClientOpSchema = z3.object({
+  id: z3.string().optional(),
+  mapName: z3.string(),
+  key: z3.string(),
   // Permissive opType to match ServerCoordinator behavior logic
   // It can be 'REMOVE', 'OR_ADD', 'OR_REMOVE' or undefined/other (implies PUT/LWW)
-  opType: z.string().optional(),
+  opType: z3.string().optional(),
   record: LWWRecordSchema.nullable().optional(),
   orRecord: ORMapRecordSchema.nullable().optional(),
-  orTag: z.string().nullable().optional(),
+  orTag: z3.string().nullable().optional(),
   // Write Concern fields (Phase 5.01)
   writeConcern: WriteConcernSchema.optional(),
-  timeout: z.number().optional()
+  timeout: z3.number().optional()
 });
-var AuthMessageSchema = z.object({
-  type: z.literal("AUTH"),
-  token: z.string()
+var AuthMessageSchema = z3.object({
+  type: z3.literal("AUTH"),
+  token: z3.string()
 });
-var QuerySubMessageSchema = z.object({
-  type: z.literal("QUERY_SUB"),
-  payload: z.object({
-    queryId: z.string(),
-    mapName: z.string(),
+var QuerySubMessageSchema = z3.object({
+  type: z3.literal("QUERY_SUB"),
+  payload: z3.object({
+    queryId: z3.string(),
+    mapName: z3.string(),
     query: QuerySchema
   })
 });
-var QueryUnsubMessageSchema = z.object({
-  type: z.literal("QUERY_UNSUB"),
-  payload: z.object({
-    queryId: z.string()
+var QueryUnsubMessageSchema = z3.object({
+  type: z3.literal("QUERY_UNSUB"),
+  payload: z3.object({
+    queryId: z3.string()
   })
 });
-var ClientOpMessageSchema = z.object({
-  type: z.literal("CLIENT_OP"),
+var ClientOpMessageSchema = z3.object({
+  type: z3.literal("CLIENT_OP"),
   payload: ClientOpSchema
 });
-var OpBatchMessageSchema = z.object({
-  type: z.literal("OP_BATCH"),
-  payload: z.object({
-    ops: z.array(ClientOpSchema),
+var OpBatchMessageSchema = z3.object({
+  type: z3.literal("OP_BATCH"),
+  payload: z3.object({
+    ops: z3.array(ClientOpSchema),
     // Batch-level Write Concern (can be overridden per-op)
     writeConcern: WriteConcernSchema.optional(),
-    timeout: z.number().optional()
+    timeout: z3.number().optional()
   })
 });
-var SyncInitMessageSchema = z.object({
-  type: z.literal("SYNC_INIT"),
-  mapName: z.string(),
-  lastSyncTimestamp: z.number().optional()
+var SyncInitMessageSchema = z3.object({
+  type: z3.literal("SYNC_INIT"),
+  mapName: z3.string(),
+  lastSyncTimestamp: z3.number().optional()
 });
-var SyncRespRootMessageSchema = z.object({
-  type: z.literal("SYNC_RESP_ROOT"),
-  payload: z.object({
-    mapName: z.string(),
-    rootHash: z.number(),
+var SyncRespRootMessageSchema = z3.object({
+  type: z3.literal("SYNC_RESP_ROOT"),
+  payload: z3.object({
+    mapName: z3.string(),
+    rootHash: z3.number(),
     timestamp: TimestampSchema
   })
 });
-var SyncRespBucketsMessageSchema = z.object({
-  type: z.literal("SYNC_RESP_BUCKETS"),
-  payload: z.object({
-    mapName: z.string(),
-    path: z.string(),
-    buckets: z.record(z.string(), z.number())
+var SyncRespBucketsMessageSchema = z3.object({
+  type: z3.literal("SYNC_RESP_BUCKETS"),
+  payload: z3.object({
+    mapName: z3.string(),
+    path: z3.string(),
+    buckets: z3.record(z3.string(), z3.number())
   })
 });
-var SyncRespLeafMessageSchema = z.object({
-  type: z.literal("SYNC_RESP_LEAF"),
-  payload: z.object({
-    mapName: z.string(),
-    path: z.string(),
-    records: z.array(z.object({
-      key: z.string(),
+var SyncRespLeafMessageSchema = z3.object({
+  type: z3.literal("SYNC_RESP_LEAF"),
+  payload: z3.object({
+    mapName: z3.string(),
+    path: z3.string(),
+    records: z3.array(z3.object({
+      key: z3.string(),
       record: LWWRecordSchema
     }))
   })
 });
-var MerkleReqBucketMessageSchema = z.object({
-  type: z.literal("MERKLE_REQ_BUCKET"),
-  payload: z.object({
-    mapName: z.string(),
-    path: z.string()
+var MerkleReqBucketMessageSchema = z3.object({
+  type: z3.literal("MERKLE_REQ_BUCKET"),
+  payload: z3.object({
+    mapName: z3.string(),
+    path: z3.string()
   })
 });
-var LockRequestSchema = z.object({
-  type: z.literal("LOCK_REQUEST"),
-  payload: z.object({
-    requestId: z.string(),
-    name: z.string(),
-    ttl: z.number().optional()
+var LockRequestSchema = z3.object({
+  type: z3.literal("LOCK_REQUEST"),
+  payload: z3.object({
+    requestId: z3.string(),
+    name: z3.string(),
+    ttl: z3.number().optional()
   })
 });
-var LockReleaseSchema = z.object({
-  type: z.literal("LOCK_RELEASE"),
-  payload: z.object({
-    requestId: z.string().optional(),
-    name: z.string(),
-    fencingToken: z.number()
+var LockReleaseSchema = z3.object({
+  type: z3.literal("LOCK_RELEASE"),
+  payload: z3.object({
+    requestId: z3.string().optional(),
+    name: z3.string(),
+    fencingToken: z3.number()
   })
 });
-var TopicSubSchema = z.object({
-  type: z.literal("TOPIC_SUB"),
-  payload: z.object({
-    topic: z.string()
+var TopicSubSchema = z3.object({
+  type: z3.literal("TOPIC_SUB"),
+  payload: z3.object({
+    topic: z3.string()
   })
 });
-var TopicUnsubSchema = z.object({
-  type: z.literal("TOPIC_UNSUB"),
-  payload: z.object({
-    topic: z.string()
+var TopicUnsubSchema = z3.object({
+  type: z3.literal("TOPIC_UNSUB"),
+  payload: z3.object({
+    topic: z3.string()
   })
 });
-var TopicPubSchema = z.object({
-  type: z.literal("TOPIC_PUB"),
-  payload: z.object({
-    topic: z.string(),
-    data: z.any()
+var TopicPubSchema = z3.object({
+  type: z3.literal("TOPIC_PUB"),
+  payload: z3.object({
+    topic: z3.string(),
+    data: z3.any()
   })
 });
-var TopicMessageEventSchema = z.object({
-  type: z.literal("TOPIC_MESSAGE"),
-  payload: z.object({
-    topic: z.string(),
-    data: z.any(),
-    publisherId: z.string().optional(),
-    timestamp: z.number()
+var TopicMessageEventSchema = z3.object({
+  type: z3.literal("TOPIC_MESSAGE"),
+  payload: z3.object({
+    topic: z3.string(),
+    data: z3.any(),
+    publisherId: z3.string().optional(),
+    timestamp: z3.number()
   })
 });
-var PingMessageSchema = z.object({
-  type: z.literal("PING"),
-  timestamp: z.number()
+var PNCounterStateObjectSchema = z3.object({
+  p: z3.record(z3.string(), z3.number()),
+  // positive counts per node
+  n: z3.record(z3.string(), z3.number())
+  // negative counts per node
+});
+var CounterRequestSchema = z3.object({
+  type: z3.literal("COUNTER_REQUEST"),
+  payload: z3.object({
+    name: z3.string()
+  })
+});
+var CounterSyncSchema = z3.object({
+  type: z3.literal("COUNTER_SYNC"),
+  payload: z3.object({
+    name: z3.string(),
+    state: PNCounterStateObjectSchema
+  })
+});
+var CounterResponseSchema = z3.object({
+  type: z3.literal("COUNTER_RESPONSE"),
+  payload: z3.object({
+    name: z3.string(),
+    state: PNCounterStateObjectSchema
+  })
+});
+var CounterUpdateSchema = z3.object({
+  type: z3.literal("COUNTER_UPDATE"),
+  payload: z3.object({
+    name: z3.string(),
+    state: PNCounterStateObjectSchema
+  })
+});
+var PingMessageSchema = z3.object({
+  type: z3.literal("PING"),
+  timestamp: z3.number()
   // Client's Date.now()
 });
-var PongMessageSchema = z.object({
-  type: z.literal("PONG"),
-  timestamp: z.number(),
+var PongMessageSchema = z3.object({
+  type: z3.literal("PONG"),
+  timestamp: z3.number(),
   // Echo back client's timestamp
-  serverTime: z.number()
+  serverTime: z3.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 BatchMessageSchema = z3.object({
+  type: z3.literal("BATCH"),
+  count: z3.number(),
+  data: z3.instanceof(Uint8Array)
 });
-var ORMapSyncInitSchema = z.object({
-  type: z.literal("ORMAP_SYNC_INIT"),
-  mapName: z.string(),
-  rootHash: z.number(),
-  bucketHashes: z.record(z.string(), z.number()),
+var ORMapSyncInitSchema = z3.object({
+  type: z3.literal("ORMAP_SYNC_INIT"),
+  mapName: z3.string(),
+  rootHash: z3.number(),
+  bucketHashes: z3.record(z3.string(), z3.number()),
   // path -> hash
-  lastSyncTimestamp: z.number().optional()
+  lastSyncTimestamp: z3.number().optional()
 });
-var ORMapSyncRespRootSchema = z.object({
-  type: z.literal("ORMAP_SYNC_RESP_ROOT"),
-  payload: z.object({
-    mapName: z.string(),
-    rootHash: z.number(),
+var ORMapSyncRespRootSchema = z3.object({
+  type: z3.literal("ORMAP_SYNC_RESP_ROOT"),
+  payload: z3.object({
+    mapName: z3.string(),
+    rootHash: z3.number(),
     timestamp: TimestampSchema
   })
 });
-var ORMapSyncRespBucketsSchema = z.object({
-  type: z.literal("ORMAP_SYNC_RESP_BUCKETS"),
-  payload: z.object({
-    mapName: z.string(),
-    path: z.string(),
-    buckets: z.record(z.string(), z.number())
+var ORMapSyncRespBucketsSchema = z3.object({
+  type: z3.literal("ORMAP_SYNC_RESP_BUCKETS"),
+  payload: z3.object({
+    mapName: z3.string(),
+    path: z3.string(),
+    buckets: z3.record(z3.string(), z3.number())
   })
 });
-var ORMapMerkleReqBucketSchema = z.object({
-  type: z.literal("ORMAP_MERKLE_REQ_BUCKET"),
-  payload: z.object({
-    mapName: z.string(),
-    path: z.string()
+var ORMapMerkleReqBucketSchema = z3.object({
+  type: z3.literal("ORMAP_MERKLE_REQ_BUCKET"),
+  payload: z3.object({
+    mapName: z3.string(),
+    path: z3.string()
   })
 });
-var ORMapSyncRespLeafSchema = z.object({
-  type: z.literal("ORMAP_SYNC_RESP_LEAF"),
-  payload: z.object({
-    mapName: z.string(),
-    path: z.string(),
-    entries: z.array(z.object({
-      key: z.string(),
-      records: z.array(ORMapRecordSchema),
-      tombstones: z.array(z.string())
+var ORMapSyncRespLeafSchema = z3.object({
+  type: z3.literal("ORMAP_SYNC_RESP_LEAF"),
+  payload: z3.object({
+    mapName: z3.string(),
+    path: z3.string(),
+    entries: z3.array(z3.object({
+      key: z3.string(),
+      records: z3.array(ORMapRecordSchema),
+      tombstones: z3.array(z3.string())
       // Tombstone tags for this key's records
     }))
   })
 });
-var ORMapDiffRequestSchema = z.object({
-  type: z.literal("ORMAP_DIFF_REQUEST"),
-  payload: z.object({
-    mapName: z.string(),
-    keys: z.array(z.string())
+var ORMapDiffRequestSchema = z3.object({
+  type: z3.literal("ORMAP_DIFF_REQUEST"),
+  payload: z3.object({
+    mapName: z3.string(),
+    keys: z3.array(z3.string())
   })
 });
-var ORMapDiffResponseSchema = z.object({
-  type: z.literal("ORMAP_DIFF_RESPONSE"),
-  payload: z.object({
-    mapName: z.string(),
-    entries: z.array(z.object({
-      key: z.string(),
-      records: z.array(ORMapRecordSchema),
-      tombstones: z.array(z.string())
+var ORMapDiffResponseSchema = z3.object({
+  type: z3.literal("ORMAP_DIFF_RESPONSE"),
+  payload: z3.object({
+    mapName: z3.string(),
+    entries: z3.array(z3.object({
+      key: z3.string(),
+      records: z3.array(ORMapRecordSchema),
+      tombstones: z3.array(z3.string())
     }))
   })
 });
-var ORMapPushDiffSchema = z.object({
-  type: z.literal("ORMAP_PUSH_DIFF"),
-  payload: z.object({
-    mapName: z.string(),
-    entries: z.array(z.object({
-      key: z.string(),
-      records: z.array(ORMapRecordSchema),
-      tombstones: z.array(z.string())
+var ORMapPushDiffSchema = z3.object({
+  type: z3.literal("ORMAP_PUSH_DIFF"),
+  payload: z3.object({
+    mapName: z3.string(),
+    entries: z3.array(z3.object({
+      key: z3.string(),
+      records: z3.array(ORMapRecordSchema),
+      tombstones: z3.array(z3.string())
     }))
   })
 });
-var OpResultSchema = z.object({
-  opId: z.string(),
-  success: z.boolean(),
+var PartitionMapRequestSchema = z3.object({
+  type: z3.literal("PARTITION_MAP_REQUEST"),
+  payload: z3.object({
+    currentVersion: z3.number().optional()
+  }).optional()
+});
+var EntryProcessorSchema = z3.object({
+  name: z3.string().min(1).max(100),
+  code: z3.string().min(1).max(1e4),
+  args: z3.unknown().optional()
+});
+var EntryProcessRequestSchema = z3.object({
+  type: z3.literal("ENTRY_PROCESS"),
+  requestId: z3.string(),
+  mapName: z3.string(),
+  key: z3.string(),
+  processor: EntryProcessorSchema
+});
+var EntryProcessBatchRequestSchema = z3.object({
+  type: z3.literal("ENTRY_PROCESS_BATCH"),
+  requestId: z3.string(),
+  mapName: z3.string(),
+  keys: z3.array(z3.string()),
+  processor: EntryProcessorSchema
+});
+var EntryProcessResponseSchema = z3.object({
+  type: z3.literal("ENTRY_PROCESS_RESPONSE"),
+  requestId: z3.string(),
+  success: z3.boolean(),
+  result: z3.unknown().optional(),
+  newValue: z3.unknown().optional(),
+  error: z3.string().optional()
+});
+var EntryProcessKeyResultSchema = z3.object({
+  success: z3.boolean(),
+  result: z3.unknown().optional(),
+  newValue: z3.unknown().optional(),
+  error: z3.string().optional()
+});
+var EntryProcessBatchResponseSchema = z3.object({
+  type: z3.literal("ENTRY_PROCESS_BATCH_RESPONSE"),
+  requestId: z3.string(),
+  results: z3.record(z3.string(), EntryProcessKeyResultSchema)
+});
+var JournalEventTypeSchema = z3.enum(["PUT", "UPDATE", "DELETE"]);
+var JournalEventDataSchema = z3.object({
+  sequence: z3.string(),
+  // bigint as string
+  type: JournalEventTypeSchema,
+  mapName: z3.string(),
+  key: z3.string(),
+  value: z3.unknown().optional(),
+  previousValue: z3.unknown().optional(),
+  timestamp: TimestampSchema,
+  nodeId: z3.string(),
+  metadata: z3.record(z3.string(), z3.unknown()).optional()
+});
+var JournalSubscribeRequestSchema = z3.object({
+  type: z3.literal("JOURNAL_SUBSCRIBE"),
+  requestId: z3.string(),
+  fromSequence: z3.string().optional(),
+  // bigint as string
+  mapName: z3.string().optional(),
+  types: z3.array(JournalEventTypeSchema).optional()
+});
+var JournalUnsubscribeRequestSchema = z3.object({
+  type: z3.literal("JOURNAL_UNSUBSCRIBE"),
+  subscriptionId: z3.string()
+});
+var JournalEventMessageSchema = z3.object({
+  type: z3.literal("JOURNAL_EVENT"),
+  event: JournalEventDataSchema
+});
+var JournalReadRequestSchema = z3.object({
+  type: z3.literal("JOURNAL_READ"),
+  requestId: z3.string(),
+  fromSequence: z3.string(),
+  limit: z3.number().optional(),
+  mapName: z3.string().optional()
+});
+var JournalReadResponseSchema = z3.object({
+  type: z3.literal("JOURNAL_READ_RESPONSE"),
+  requestId: z3.string(),
+  events: z3.array(JournalEventDataSchema),
+  hasMore: z3.boolean()
+});
+var ConflictResolverSchema = z3.object({
+  name: z3.string().min(1).max(100),
+  code: z3.string().max(5e4),
+  priority: z3.number().int().min(0).max(100).optional(),
+  keyPattern: z3.string().optional()
+});
+var RegisterResolverRequestSchema = z3.object({
+  type: z3.literal("REGISTER_RESOLVER"),
+  requestId: z3.string(),
+  mapName: z3.string(),
+  resolver: ConflictResolverSchema
+});
+var RegisterResolverResponseSchema = z3.object({
+  type: z3.literal("REGISTER_RESOLVER_RESPONSE"),
+  requestId: z3.string(),
+  success: z3.boolean(),
+  error: z3.string().optional()
+});
+var UnregisterResolverRequestSchema = z3.object({
+  type: z3.literal("UNREGISTER_RESOLVER"),
+  requestId: z3.string(),
+  mapName: z3.string(),
+  resolverName: z3.string()
+});
+var UnregisterResolverResponseSchema = z3.object({
+  type: z3.literal("UNREGISTER_RESOLVER_RESPONSE"),
+  requestId: z3.string(),
+  success: z3.boolean(),
+  error: z3.string().optional()
+});
+var MergeRejectedMessageSchema = z3.object({
+  type: z3.literal("MERGE_REJECTED"),
+  mapName: z3.string(),
+  key: z3.string(),
+  attemptedValue: z3.unknown(),
+  reason: z3.string(),
+  timestamp: TimestampSchema
+});
+var ListResolversRequestSchema = z3.object({
+  type: z3.literal("LIST_RESOLVERS"),
+  requestId: z3.string(),
+  mapName: z3.string().optional()
+});
+var ListResolversResponseSchema = z3.object({
+  type: z3.literal("LIST_RESOLVERS_RESPONSE"),
+  requestId: z3.string(),
+  resolvers: z3.array(z3.object({
+    mapName: z3.string(),
+    name: z3.string(),
+    priority: z3.number().optional(),
+    keyPattern: z3.string().optional()
+  }))
+});
+var OpResultSchema = z3.object({
+  opId: z3.string(),
+  success: z3.boolean(),
   achievedLevel: WriteConcernSchema,
-  error: z.string().optional()
+  error: z3.string().optional()
 });
-var OpAckMessageSchema = z.object({
-  type: z.literal("OP_ACK"),
-  payload: z.object({
+var OpAckMessageSchema = z3.object({
+  type: z3.literal("OP_ACK"),
+  payload: z3.object({
     /** ID of the last operation in the batch (for backwards compatibility) */
-    lastId: z.string(),
+    lastId: z3.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()
+    results: z3.array(OpResultSchema).optional()
   })
 });
-var OpRejectedMessageSchema = z.object({
-  type: z.literal("OP_REJECTED"),
-  payload: z.object({
+var OpRejectedMessageSchema = z3.object({
+  type: z3.literal("OP_REJECTED"),
+  payload: z3.object({
     /** Operation ID that was rejected */
-    opId: z.string(),
+    opId: z3.string(),
     /** Reason for rejection */
-    reason: z.string(),
+    reason: z3.string(),
     /** Error code */
-    code: z.number().optional()
+    code: z3.number().optional()
   })
 });
-var MessageSchema = z.discriminatedUnion("type", [
+var MessageSchema = z3.discriminatedUnion("type", [
   AuthMessageSchema,
   QuerySubMessageSchema,
   QueryUnsubMessageSchema,
@@ -1379,7 +2480,31 @@ var MessageSchema = z.discriminatedUnion("type", [
   ORMapSyncRespLeafSchema,
   ORMapDiffRequestSchema,
   ORMapDiffResponseSchema,
-  ORMapPushDiffSchema
+  ORMapPushDiffSchema,
+  // Phase 4: Partition Map
+  PartitionMapRequestSchema,
+  // Phase 5.2: PN Counter
+  CounterRequestSchema,
+  CounterSyncSchema,
+  // Phase 5.03: Entry Processor
+  EntryProcessRequestSchema,
+  EntryProcessBatchRequestSchema,
+  EntryProcessResponseSchema,
+  EntryProcessBatchResponseSchema,
+  // Phase 5.04: Event Journal
+  JournalSubscribeRequestSchema,
+  JournalUnsubscribeRequestSchema,
+  JournalEventMessageSchema,
+  JournalReadRequestSchema,
+  JournalReadResponseSchema,
+  // Phase 5.05: Conflict Resolver
+  RegisterResolverRequestSchema,
+  RegisterResolverResponseSchema,
+  UnregisterResolverRequestSchema,
+  UnregisterResolverResponseSchema,
+  MergeRejectedMessageSchema,
+  ListResolversRequestSchema,
+  ListResolversResponseSchema
 ]);
 
 // src/types/WriteConcern.ts
@@ -1414,17 +2539,105 @@ function getHighestWriteConcernLevel(achieved) {
   }
   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,
+  BuiltInProcessors,
+  BuiltInResolvers,
   ClientOpMessageSchema,
   ClientOpSchema,
+  ConflictResolverDefSchema,
+  ConflictResolverSchema,
+  ConsistencyLevel,
+  CounterRequestSchema,
+  CounterResponseSchema,
+  CounterSyncSchema,
+  CounterUpdateSchema,
+  DEFAULT_BACKUP_COUNT,
+  DEFAULT_CIRCUIT_BREAKER_CONFIG,
+  DEFAULT_CONNECTION_POOL_CONFIG,
+  DEFAULT_EVENT_JOURNAL_CONFIG,
+  DEFAULT_MIGRATION_CONFIG,
+  DEFAULT_PARTITION_ROUTER_CONFIG,
+  DEFAULT_PROCESSOR_RATE_LIMITS,
+  DEFAULT_REPLICATION_CONFIG,
+  DEFAULT_RESOLVER_RATE_LIMITS,
   DEFAULT_WRITE_CONCERN_TIMEOUT,
+  EntryProcessBatchRequestSchema,
+  EntryProcessBatchResponseSchema,
+  EntryProcessKeyResultSchema,
+  EntryProcessRequestSchema,
+  EntryProcessResponseSchema,
+  EntryProcessorDefSchema,
+  EntryProcessorSchema,
+  EventJournalImpl,
+  FORBIDDEN_PATTERNS,
   HLC,
+  JournalEventDataSchema,
+  JournalEventMessageSchema,
+  JournalEventTypeSchema,
+  JournalReadRequestSchema,
+  JournalReadResponseSchema,
+  JournalSubscribeRequestSchema,
+  JournalUnsubscribeRequestSchema,
   LWWMap,
   LWWRecordSchema,
+  ListResolversRequestSchema,
+  ListResolversResponseSchema,
   LockReleaseSchema,
   LockRequestSchema,
+  MergeRejectedMessageSchema,
   MerkleReqBucketMessageSchema,
   MerkleTree,
   MessageSchema,
@@ -1443,6 +2656,11 @@ export {
   OpBatchMessageSchema,
   OpRejectedMessageSchema,
   OpResultSchema,
+  PARTITION_COUNT,
+  PNCounterImpl,
+  PNCounterStateObjectSchema,
+  PartitionMapRequestSchema,
+  PartitionState,
   PingMessageSchema,
   PongMessageSchema,
   PredicateNodeSchema,
@@ -1451,6 +2669,10 @@ export {
   QuerySchema,
   QuerySubMessageSchema,
   QueryUnsubMessageSchema,
+  RESOLVER_FORBIDDEN_PATTERNS,
+  RegisterResolverRequestSchema,
+  RegisterResolverResponseSchema,
+  Ringbuffer,
   SyncInitMessageSchema,
   SyncRespBucketsMessageSchema,
   SyncRespLeafMessageSchema,
@@ -1460,11 +2682,15 @@ export {
   TopicPubSchema,
   TopicSubSchema,
   TopicUnsubSchema,
+  UnregisterResolverRequestSchema,
+  UnregisterResolverResponseSchema,
   WRITE_CONCERN_ORDER,
   WriteConcern,
   WriteConcernSchema,
   combineHashes,
+  compareHLCTimestamps,
   compareTimestamps,
+  deepMerge,
   deserialize,
   disableNativeHash,
   evaluatePredicate,
@@ -1476,6 +2702,8 @@ export {
   isWriteConcernAchieved,
   resetNativeHash,
   serialize,
-  timestampToString
+  timestampToString,
+  validateProcessorCode,
+  validateResolverCode
 };
 //# sourceMappingURL=index.mjs.map