@semiont/event-sourcing 0.2.28-build.40

package/dist/index.js

@@ -0,0 +1,1170 @@
+import { promises, createReadStream } from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import crypto, { createHash } from 'crypto';
+import { resourceId, isSystemEvent, isResourceEvent, didToAgent, findBodyItem } from '@semiont/core';
+import { resourceUri, annotationUri } from '@semiont/api-client';
+
+// src/storage/event-storage.ts
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// ../../node_modules/uuid/dist/esm-node/regex.js
+var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+// ../../node_modules/uuid/dist/esm-node/validate.js
+function validate(uuid) {
+  return typeof uuid === "string" && regex_default.test(uuid);
+}
+var validate_default = validate;
+
+// ../../node_modules/uuid/dist/esm-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).substr(1));
+}
+function stringify(arr, offset = 0) {
+  const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+  if (!validate_default(uuid)) {
+    throw TypeError("Stringified UUID is invalid");
+  }
+  return uuid;
+}
+var stringify_default = stringify;
+
+// ../../node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return stringify_default(rnds);
+}
+var v4_default = v4;
+function jumpConsistentHash(key, numBuckets = 65536) {
+  const hash = hashToUint32(key);
+  return hash % numBuckets;
+}
+function hashToUint32(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash = hash & 4294967295;
+  }
+  return Math.abs(hash);
+}
+function shardIdToPath(shardId) {
+  if (shardId < 0 || shardId >= 65536) {
+    throw new Error(`Invalid shard ID: ${shardId}. Must be 0-65535 for 4-hex sharding.`);
+  }
+  const shardHex = shardId.toString(16).padStart(4, "0");
+  const ab = shardHex.substring(0, 2);
+  const cd = shardHex.substring(2, 4);
+  return [ab, cd];
+}
+function getShardPath(key, numBuckets = 65536) {
+  const shardId = jumpConsistentHash(key, numBuckets);
+  return shardIdToPath(shardId);
+}
+function sha256(data) {
+  const content = typeof data === "string" ? data : JSON.stringify(data);
+  return createHash("sha256").update(content).digest("hex");
+}
+
+// src/storage/event-storage.ts
+var EventStorage = class {
+  config;
+  // Per-resource sequence tracking: resourceId -> sequence number
+  resourceSequences = /* @__PURE__ */ new Map();
+  // Per-resource last event hash: resourceId -> hash
+  resourceLastHash = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = {
+      basePath: config.basePath,
+      dataDir: config.dataDir,
+      maxEventsPerFile: config.maxEventsPerFile || 1e4,
+      enableSharding: config.enableSharding ?? true,
+      numShards: config.numShards || 65536,
+      enableCompression: config.enableCompression ?? true
+    };
+  }
+  /**
+   * Calculate shard path for a resource ID
+   * Uses jump consistent hash for uniform distribution
+   * Special case: __system__ events bypass sharding
+   */
+  getShardPath(resourceId) {
+    if (resourceId === "__system__" || !this.config.enableSharding) {
+      return "";
+    }
+    const shardIndex = jumpConsistentHash(resourceId, this.config.numShards);
+    const hex = shardIndex.toString(16).padStart(4, "0");
+    const [ab, cd] = [hex.substring(0, 2), hex.substring(2, 4)];
+    return path.join(ab, cd);
+  }
+  /**
+   * Get full path to resource's event directory
+   */
+  getResourcePath(resourceId) {
+    const shardPath = this.getShardPath(resourceId);
+    return path.join(this.config.dataDir, "events", shardPath, resourceId);
+  }
+  /**
+   * Initialize directory structure for a resource's event stream
+   * Also loads sequence number and last hash if stream exists
+   */
+  async initializeResourceStream(resourceId) {
+    const docPath = this.getResourcePath(resourceId);
+    let exists = false;
+    try {
+      await promises.access(docPath);
+      exists = true;
+    } catch {
+    }
+    if (!exists) {
+      await promises.mkdir(docPath, { recursive: true });
+      const filename = this.createEventFilename(1);
+      const filePath = path.join(docPath, filename);
+      await promises.writeFile(filePath, "", "utf-8");
+      this.resourceSequences.set(resourceId, 0);
+      console.log(`[EventStorage] Initialized event stream for ${resourceId} at ${docPath}`);
+    } else {
+      const files = await this.getEventFiles(resourceId);
+      if (files.length > 0) {
+        const lastFile = files[files.length - 1];
+        if (lastFile) {
+          const lastEvent = await this.getLastEvent(resourceId, lastFile);
+          if (lastEvent) {
+            this.resourceSequences.set(resourceId, lastEvent.metadata.sequenceNumber);
+            if (lastEvent.metadata.checksum) {
+              this.resourceLastHash.set(resourceId, lastEvent.metadata.checksum);
+            }
+          }
+        }
+      } else {
+        this.resourceSequences.set(resourceId, 0);
+      }
+    }
+  }
+  /**
+   * Append an event - handles EVERYTHING for event creation
+   * Creates ID, timestamp, metadata, checksum, sequence tracking, and writes to disk
+   */
+  async appendEvent(event, resourceId) {
+    if (this.getSequenceNumber(resourceId) === 0) {
+      await this.initializeResourceStream(resourceId);
+    }
+    const completeEvent = {
+      ...event,
+      id: v4_default(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const sequenceNumber = this.getNextSequenceNumber(resourceId);
+    const prevEventHash = this.getLastEventHash(resourceId);
+    const metadata = {
+      sequenceNumber,
+      streamPosition: 0,
+      // Will be set during write
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      prevEventHash: prevEventHash || void 0,
+      checksum: sha256(completeEvent)
+    };
+    const storedEvent = {
+      event: completeEvent,
+      metadata
+    };
+    await this.writeEvent(storedEvent, resourceId);
+    this.setLastEventHash(resourceId, metadata.checksum);
+    return storedEvent;
+  }
+  /**
+   * Write an event to storage (append to JSONL)
+   * Internal method - use appendEvent() instead
+   */
+  async writeEvent(event, resourceId) {
+    const docPath = this.getResourcePath(resourceId);
+    const files = await this.getEventFiles(resourceId);
+    let targetFile;
+    if (files.length === 0) {
+      targetFile = await this.createNewEventFile(resourceId);
+    } else {
+      const currentFile = files[files.length - 1];
+      if (!currentFile) {
+        targetFile = await this.createNewEventFile(resourceId);
+      } else {
+        const eventCount = await this.countEventsInFile(resourceId, currentFile);
+        if (eventCount >= this.config.maxEventsPerFile) {
+          targetFile = await this.createNewEventFile(resourceId);
+        } else {
+          targetFile = currentFile;
+        }
+      }
+    }
+    const targetPath = path.join(docPath, targetFile);
+    const eventLine = JSON.stringify(event) + "\n";
+    await promises.appendFile(targetPath, eventLine, "utf-8");
+  }
+  /**
+   * Count events in a specific file
+   */
+  async countEventsInFile(resourceId, filename) {
+    const docPath = this.getResourcePath(resourceId);
+    const filePath = path.join(docPath, filename);
+    try {
+      const content = await promises.readFile(filePath, "utf-8");
+      const lines = content.trim().split("\n").filter((line) => line.trim() !== "");
+      return lines.length;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return 0;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Read all events from a specific file
+   */
+  async readEventsFromFile(resourceId, filename) {
+    const docPath = this.getResourcePath(resourceId);
+    const filePath = path.join(docPath, filename);
+    const events = [];
+    try {
+      const fileStream = createReadStream(filePath, { encoding: "utf-8" });
+      const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity
+      });
+      for await (const line of rl) {
+        const trimmed = line.trim();
+        if (trimmed === "") continue;
+        try {
+          const event = JSON.parse(trimmed);
+          events.push(event);
+        } catch (parseError) {
+          console.error(`[EventStorage] Failed to parse event in ${filePath}:`, parseError);
+        }
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+    return events;
+  }
+  /**
+   * Get list of event files for a resource (sorted by sequence)
+   */
+  async getEventFiles(resourceId$1) {
+    const docPath = this.getResourcePath(resourceId(resourceId$1));
+    try {
+      const files = await promises.readdir(docPath);
+      const eventFiles = files.filter((f) => f.startsWith("events-") && f.endsWith(".jsonl")).sort((a, b) => {
+        const seqA = parseInt(a.match(/events-(\d+)\.jsonl/)?.[1] || "0");
+        const seqB = parseInt(b.match(/events-(\d+)\.jsonl/)?.[1] || "0");
+        return seqA - seqB;
+      });
+      return eventFiles;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Create a new event file for rotation
+   */
+  async createNewEventFile(resourceId) {
+    const files = await this.getEventFiles(resourceId);
+    const lastFile = files[files.length - 1];
+    const lastSeq = lastFile ? parseInt(lastFile.match(/events-(\d+)\.jsonl/)?.[1] || "1") : 1;
+    const newSeq = lastSeq + 1;
+    const filename = this.createEventFilename(newSeq);
+    const docPath = this.getResourcePath(resourceId);
+    const filePath = path.join(docPath, filename);
+    await promises.writeFile(filePath, "", "utf-8");
+    console.log(`[EventStorage] Created new event file: ${filename} for ${resourceId}`);
+    return filename;
+  }
+  /**
+   * Get the last event from a specific file
+   */
+  async getLastEvent(resourceId, filename) {
+    const events = await this.readEventsFromFile(resourceId, filename);
+    const lastEvent = events.length > 0 ? events[events.length - 1] : void 0;
+    return lastEvent ?? null;
+  }
+  /**
+   * Get all events for a resource across all files
+   */
+  async getAllEvents(resourceId) {
+    const files = await this.getEventFiles(resourceId);
+    const allEvents = [];
+    for (const file of files) {
+      const events = await this.readEventsFromFile(resourceId, file);
+      allEvents.push(...events);
+    }
+    return allEvents;
+  }
+  /**
+   * Get all resource IDs by scanning shard directories
+   */
+  async getAllResourceIds() {
+    const eventsDir = path.join(this.config.dataDir, "events");
+    const resourceIds = [];
+    try {
+      await promises.access(eventsDir);
+    } catch {
+      return [];
+    }
+    const scanDir = async (dir) => {
+      const entries = await promises.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name.length > 2) {
+            resourceIds.push(resourceId(entry.name));
+          } else {
+            await scanDir(fullPath);
+          }
+        }
+      }
+    };
+    await scanDir(eventsDir);
+    return resourceIds;
+  }
+  /**
+   * Create filename for event file
+   */
+  createEventFilename(sequenceNumber) {
+    return `events-${sequenceNumber.toString().padStart(6, "0")}.jsonl`;
+  }
+  // ============================================================
+  // Sequence/Hash Tracking
+  // ============================================================
+  /**
+   * Get current sequence number for a resource
+   */
+  getSequenceNumber(resourceId) {
+    return this.resourceSequences.get(resourceId) || 0;
+  }
+  /**
+   * Increment and return next sequence number for a resource
+   */
+  getNextSequenceNumber(resourceId) {
+    const current = this.getSequenceNumber(resourceId);
+    const next = current + 1;
+    this.resourceSequences.set(resourceId, next);
+    return next;
+  }
+  /**
+   * Get last event hash for a resource
+   */
+  getLastEventHash(resourceId) {
+    return this.resourceLastHash.get(resourceId) || null;
+  }
+  /**
+   * Set last event hash for a resource
+   */
+  setLastEventHash(resourceId, hash) {
+    this.resourceLastHash.set(resourceId, hash);
+  }
+};
+
+// src/event-log.ts
+var EventLog = class {
+  // Expose storage for EventQuery (read operations)
+  storage;
+  constructor(config) {
+    this.storage = new EventStorage({
+      basePath: config.basePath,
+      dataDir: config.dataDir,
+      enableSharding: config.enableSharding ?? true,
+      maxEventsPerFile: config.maxEventsPerFile ?? 1e4
+    });
+  }
+  /**
+   * Append event to log
+   * @param event - Resource event (from @semiont/core)
+   * @param resourceId - Branded ResourceId (from @semiont/core)
+   * @returns Stored event with metadata (sequence number, timestamp, checksum)
+   */
+  async append(event, resourceId) {
+    return this.storage.appendEvent(event, resourceId);
+  }
+  /**
+   * Get all events for a resource
+   * @param resourceId - Branded ResourceId (from @semiont/core)
+   */
+  async getEvents(resourceId) {
+    return this.storage.getAllEvents(resourceId);
+  }
+  /**
+   * Get all resource IDs
+   * @returns Array of branded ResourceId types
+   */
+  async getAllResourceIds() {
+    return this.storage.getAllResourceIds();
+  }
+  /**
+   * Query events with filter
+   * @param resourceId - Branded ResourceId (from @semiont/core)
+   * @param filter - Optional event filter
+   */
+  async queryEvents(resourceId, filter) {
+    const events = await this.storage.getAllEvents(resourceId);
+    if (!filter) return events;
+    return events.filter((e) => {
+      if (filter.eventTypes && !filter.eventTypes.includes(e.event.type)) return false;
+      if (filter.fromSequence && e.metadata.sequenceNumber < filter.fromSequence) return false;
+      if (filter.fromTimestamp && e.event.timestamp < filter.fromTimestamp) return false;
+      if (filter.toTimestamp && e.event.timestamp > filter.toTimestamp) return false;
+      if (filter.userId && e.event.userId !== filter.userId) return false;
+      return true;
+    });
+  }
+};
+function toResourceUri(config, id) {
+  if (!config.baseUrl) {
+    throw new Error("baseUrl is required");
+  }
+  return resourceUri(`${config.baseUrl}/resources/${id}`);
+}
+function toAnnotationUri(config, id) {
+  if (!config.baseUrl) {
+    throw new Error("baseUrl is required");
+  }
+  return annotationUri(`${config.baseUrl}/annotations/${id}`);
+}
+
+// src/subscriptions/event-subscriptions.ts
+var EventSubscriptions = class {
+  // Per-resource subscriptions: ResourceUri -> Set of callbacks
+  subscriptions = /* @__PURE__ */ new Map();
+  // Global subscriptions for system-level events (no resourceId)
+  globalSubscriptions = /* @__PURE__ */ new Set();
+  /**
+   * Subscribe to events for a specific resource using full URI
+   * Returns an EventSubscription with unsubscribe function
+   */
+  subscribe(resourceUri2, callback) {
+    if (!this.subscriptions.has(resourceUri2)) {
+      this.subscriptions.set(resourceUri2, /* @__PURE__ */ new Set());
+    }
+    const callbacks = this.subscriptions.get(resourceUri2);
+    callbacks.add(callback);
+    console.log(`[EventSubscriptions] Subscription added for resource ${resourceUri2} (total: ${callbacks.size} subscribers)`);
+    return {
+      resourceUri: resourceUri2,
+      callback,
+      unsubscribe: () => {
+        callbacks.delete(callback);
+        console.log(`[EventSubscriptions] Subscription removed for resource ${resourceUri2} (remaining: ${callbacks.size} subscribers)`);
+        if (callbacks.size === 0) {
+          this.subscriptions.delete(resourceUri2);
+          console.log(`[EventSubscriptions] No more subscribers for resource ${resourceUri2}, removed from subscriptions map`);
+        }
+      }
+    };
+  }
+  /**
+   * Subscribe to all system-level events (no resourceId)
+   * Returns an EventSubscription with unsubscribe function
+   *
+   * Use this for consumers that need to react to global events like:
+   * - entitytype.added (global entity type collection changes)
+   * - Future system-level events (user.created, workspace.created, etc.)
+   */
+  subscribeGlobal(callback) {
+    this.globalSubscriptions.add(callback);
+    console.log(`[EventSubscriptions] Global subscription added (total: ${this.globalSubscriptions.size} subscribers)`);
+    return {
+      resourceUri: "__global__",
+      // Special marker for global subscriptions
+      callback,
+      unsubscribe: () => {
+        this.globalSubscriptions.delete(callback);
+        console.log(`[EventSubscriptions] Global subscription removed (remaining: ${this.globalSubscriptions.size} subscribers)`);
+      }
+    };
+  }
+  /**
+   * Notify all subscribers for a resource when a new event is appended
+   * @param resourceUri - Full resource URI (e.g., http://localhost:4000/resources/abc123)
+   */
+  async notifySubscribers(resourceUri2, event) {
+    const callbacks = this.subscriptions.get(resourceUri2);
+    if (!callbacks || callbacks.size === 0) {
+      console.log(`[EventSubscriptions] Event ${event.event.type} for resource ${resourceUri2} - no subscribers to notify`);
+      return;
+    }
+    console.log(`[EventSubscriptions] Notifying ${callbacks.size} subscriber(s) of event ${event.event.type} for resource ${resourceUri2}`);
+    Array.from(callbacks).forEach((callback, index) => {
+      Promise.resolve(callback(event)).then(() => {
+        console.log(`[EventSubscriptions] Subscriber #${index + 1} successfully notified of ${event.event.type}`);
+      }).catch((error) => {
+        console.error(`[EventSubscriptions] Error in subscriber #${index + 1} for resource ${resourceUri2}, event ${event.event.type}:`, error);
+      });
+    });
+  }
+  /**
+   * Notify all global subscribers when a system-level event is appended
+   */
+  async notifyGlobalSubscribers(event) {
+    if (this.globalSubscriptions.size === 0) {
+      console.log(`[EventSubscriptions] System event ${event.event.type} - no global subscribers to notify`);
+      return;
+    }
+    console.log(`[EventSubscriptions] Notifying ${this.globalSubscriptions.size} global subscriber(s) of system event ${event.event.type}`);
+    Array.from(this.globalSubscriptions).forEach((callback, index) => {
+      Promise.resolve(callback(event)).then(() => {
+        console.log(`[EventSubscriptions] Global subscriber #${index + 1} successfully notified of ${event.event.type}`);
+      }).catch((error) => {
+        console.error(`[EventSubscriptions] Error in global subscriber #${index + 1} for system event ${event.event.type}:`, error);
+      });
+    });
+  }
+  /**
+   * Get subscription count for a resource (useful for debugging)
+   */
+  getSubscriptionCount(resourceUri2) {
+    return this.subscriptions.get(resourceUri2)?.size || 0;
+  }
+  /**
+   * Get total number of active subscriptions across all resources
+   */
+  getTotalSubscriptions() {
+    let total = 0;
+    for (const callbacks of this.subscriptions.values()) {
+      total += callbacks.size;
+    }
+    return total;
+  }
+  /**
+   * Get total number of global subscriptions
+   */
+  getGlobalSubscriptionCount() {
+    return this.globalSubscriptions.size;
+  }
+};
+var globalEventSubscriptions = null;
+function getEventSubscriptions() {
+  if (!globalEventSubscriptions) {
+    globalEventSubscriptions = new EventSubscriptions();
+    console.log("[EventSubscriptions] Created global singleton instance");
+  }
+  return globalEventSubscriptions;
+}
+
+// src/event-bus.ts
+var EventBus = class {
+  // Expose subscriptions for direct access (legacy compatibility)
+  subscriptions;
+  identifierConfig;
+  constructor(config) {
+    this.identifierConfig = config.identifierConfig;
+    this.subscriptions = getEventSubscriptions();
+  }
+  /**
+   * Publish event to subscribers
+   * - Resource events: notifies resource-scoped subscribers
+   * - System events: notifies global subscribers
+   * @param event - Stored event (from @semiont/core)
+   */
+  async publish(event) {
+    if (isSystemEvent(event.event)) {
+      await this.subscriptions.notifyGlobalSubscribers(event);
+    } else if (isResourceEvent(event.event)) {
+      const resourceId = event.event.resourceId;
+      const resourceUri2 = toResourceUri(this.identifierConfig, resourceId);
+      await this.subscriptions.notifySubscribers(resourceUri2, event);
+    } else {
+      console.warn("[EventBus] Event is neither resource nor system event:", event.event.type);
+    }
+  }
+  /**
+   * Subscribe to events for a specific resource
+   * @param resourceId - Branded ResourceId (from @semiont/core)
+   * @param callback - Event callback function
+   * @returns EventSubscription with unsubscribe function
+   */
+  subscribe(resourceId, callback) {
+    const resourceUri2 = toResourceUri(this.identifierConfig, resourceId);
+    return this.subscriptions.subscribe(resourceUri2, callback);
+  }
+  /**
+   * Subscribe to all system-level events
+   * @param callback - Event callback function
+   * @returns EventSubscription with unsubscribe function
+   */
+  subscribeGlobal(callback) {
+    return this.subscriptions.subscribeGlobal(callback);
+  }
+  /**
+   * Unsubscribe from resource events
+   * @param resourceId - Branded ResourceId (from @semiont/core)
+   * @param callback - Event callback function to remove
+   */
+  unsubscribe(resourceId, callback) {
+    const resourceUri2 = toResourceUri(this.identifierConfig, resourceId);
+    const callbacks = this.subscriptions.subscriptions.get(resourceUri2);
+    if (callbacks) {
+      callbacks.delete(callback);
+      if (callbacks.size === 0) {
+        this.subscriptions.subscriptions.delete(resourceUri2);
+      }
+    }
+  }
+  /**
+   * Unsubscribe from global events
+   * @param callback - Event callback function to remove
+   */
+  unsubscribeGlobal(callback) {
+    this.subscriptions.globalSubscriptions.delete(callback);
+  }
+  /**
+   * Get subscriber count for a resource
+   * @param resourceId - Branded ResourceId (from @semiont/core)
+   * @returns Number of active subscribers
+   */
+  getSubscriberCount(resourceId) {
+    const resourceUri2 = toResourceUri(this.identifierConfig, resourceId);
+    return this.subscriptions.getSubscriptionCount(resourceUri2);
+  }
+  /**
+   * Get total number of active subscriptions across all resources
+   */
+  getTotalSubscriptions() {
+    return this.subscriptions.getTotalSubscriptions();
+  }
+  /**
+   * Get total number of global subscriptions
+   */
+  getGlobalSubscriptionCount() {
+    return this.subscriptions.getGlobalSubscriptionCount();
+  }
+};
+var ViewMaterializer = class {
+  constructor(viewStorage, config) {
+    this.viewStorage = viewStorage;
+    this.config = config;
+  }
+  /**
+   * Materialize resource view from events
+   * Loads existing view if cached, otherwise rebuilds from events
+   */
+  async materialize(events, resourceId) {
+    const existing = await this.viewStorage.get(resourceId);
+    if (existing) {
+      return existing;
+    }
+    if (events.length === 0) return null;
+    const view = this.materializeFromEvents(events, resourceId);
+    await this.viewStorage.save(resourceId, view);
+    return view;
+  }
+  /**
+   * Materialize view incrementally with a single event
+   * Falls back to full rebuild if view doesn't exist
+   */
+  async materializeIncremental(resourceId, event, getAllEvents) {
+    console.log(`[ViewMaterializer] Updating view for ${resourceId} with event ${event.type}`);
+    let view = await this.viewStorage.get(resourceId);
+    if (!view) {
+      console.log(`[ViewMaterializer] No view found, rebuilding from scratch`);
+      const events = await getAllEvents();
+      view = this.materializeFromEvents(events, resourceId);
+    } else {
+      console.log(`[ViewMaterializer] Applying event incrementally to existing view (version ${view.annotations.version})`);
+      this.applyEventToResource(view.resource, event);
+      this.applyEventToAnnotations(view.annotations, event);
+      view.annotations.version++;
+      view.annotations.updatedAt = event.timestamp;
+    }
+    await this.viewStorage.save(resourceId, view);
+    console.log(`[ViewMaterializer] View saved (version ${view.annotations.version}, ${view.annotations.annotations.length} annotations)`);
+  }
+  /**
+   * Materialize view from event list (full rebuild)
+   */
+  materializeFromEvents(events, resourceId) {
+    const backendUrl = this.config.backendUrl;
+    const normalizedBase = backendUrl.endsWith("/") ? backendUrl.slice(0, -1) : backendUrl;
+    const resource = {
+      "@context": "https://schema.org/",
+      "@id": `${normalizedBase}/resources/${resourceId}`,
+      name: "",
+      representations: [],
+      archived: false,
+      entityTypes: [],
+      creationMethod: "api"
+    };
+    const annotations = {
+      resourceId,
+      annotations: [],
+      version: 0,
+      updatedAt: ""
+    };
+    events.sort((a, b) => a.metadata.sequenceNumber - b.metadata.sequenceNumber);
+    for (const storedEvent of events) {
+      this.applyEventToResource(resource, storedEvent.event);
+      this.applyEventToAnnotations(annotations, storedEvent.event);
+      annotations.version++;
+      annotations.updatedAt = storedEvent.event.timestamp;
+    }
+    return { resource, annotations };
+  }
+  /**
+   * Apply an event to ResourceDescriptor state (metadata only)
+   */
+  applyEventToResource(resource, event) {
+    switch (event.type) {
+      case "resource.created":
+        resource.name = event.payload.name;
+        resource.entityTypes = event.payload.entityTypes || [];
+        resource.dateCreated = event.timestamp;
+        resource.creationMethod = event.payload.creationMethod || "api";
+        resource.wasAttributedTo = didToAgent(event.userId);
+        if (!resource.representations) resource.representations = [];
+        const reps = Array.isArray(resource.representations) ? resource.representations : [resource.representations];
+        reps.push({
+          mediaType: event.payload.format,
+          checksum: event.payload.contentChecksum,
+          byteSize: event.payload.contentByteSize,
+          rel: "original",
+          language: event.payload.language
+        });
+        resource.representations = reps;
+        resource.isDraft = event.payload.isDraft;
+        resource.wasDerivedFrom = event.payload.generatedFrom;
+        break;
+      case "resource.cloned":
+        resource.name = event.payload.name;
+        resource.entityTypes = event.payload.entityTypes || [];
+        resource.dateCreated = event.timestamp;
+        resource.creationMethod = "clone";
+        resource.sourceResourceId = event.payload.parentResourceId;
+        resource.wasAttributedTo = didToAgent(event.userId);
+        if (!resource.representations) resource.representations = [];
+        const reps2 = Array.isArray(resource.representations) ? resource.representations : [resource.representations];
+        reps2.push({
+          mediaType: event.payload.format,
+          checksum: event.payload.contentChecksum,
+          byteSize: event.payload.contentByteSize,
+          rel: "original",
+          language: event.payload.language
+        });
+        resource.representations = reps2;
+        break;
+      case "resource.archived":
+        resource.archived = true;
+        break;
+      case "resource.unarchived":
+        resource.archived = false;
+        break;
+      case "entitytag.added":
+        if (!resource.entityTypes) resource.entityTypes = [];
+        if (!resource.entityTypes.includes(event.payload.entityType)) {
+          resource.entityTypes.push(event.payload.entityType);
+        }
+        break;
+      case "entitytag.removed":
+        if (resource.entityTypes) {
+          resource.entityTypes = resource.entityTypes.filter(
+            (t) => t !== event.payload.entityType
+          );
+        }
+        break;
+    }
+  }
+  /**
+   * Apply an event to ResourceAnnotations (annotation collections only)
+   */
+  applyEventToAnnotations(annotations, event) {
+    switch (event.type) {
+      case "annotation.added":
+        annotations.annotations.push({
+          ...event.payload.annotation,
+          creator: didToAgent(event.userId),
+          created: new Date(event.timestamp).toISOString()
+        });
+        break;
+      case "annotation.removed":
+        annotations.annotations = annotations.annotations.filter(
+          (a) => a.id !== event.payload.annotationId && !a.id.endsWith(`/annotations/${event.payload.annotationId}`)
+        );
+        break;
+      case "annotation.body.updated":
+        const annotation = annotations.annotations.find(
+          (a) => a.id === event.payload.annotationId || a.id.endsWith(`/annotations/${event.payload.annotationId}`)
+        );
+        if (annotation) {
+          if (!Array.isArray(annotation.body)) {
+            annotation.body = annotation.body ? [annotation.body] : [];
+          }
+          for (const op of event.payload.operations) {
+            if (op.op === "add") {
+              const exists = findBodyItem(annotation.body, op.item) !== -1;
+              if (!exists) {
+                annotation.body.push(op.item);
+              }
+            } else if (op.op === "remove") {
+              const index = findBodyItem(annotation.body, op.item);
+              if (index !== -1) {
+                annotation.body.splice(index, 1);
+              }
+            } else if (op.op === "replace") {
+              const index = findBodyItem(annotation.body, op.oldItem);
+              if (index !== -1) {
+                annotation.body[index] = op.newItem;
+              }
+            }
+          }
+          annotation.modified = new Date(event.timestamp).toISOString();
+        }
+        break;
+    }
+  }
+  /**
+   * Materialize entity types view - System-level view
+   */
+  async materializeEntityTypes(entityType) {
+    const entityTypesPath = path.join(
+      this.config.basePath,
+      "projections",
+      "entity-types",
+      "entity-types.json"
+    );
+    let view = { entityTypes: [] };
+    try {
+      const content = await promises.readFile(entityTypesPath, "utf-8");
+      view = JSON.parse(content);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const entityTypeSet = new Set(view.entityTypes);
+    entityTypeSet.add(entityType);
+    view.entityTypes = Array.from(entityTypeSet).sort();
+    await promises.mkdir(path.dirname(entityTypesPath), { recursive: true });
+    await promises.writeFile(entityTypesPath, JSON.stringify(view, null, 2));
+  }
+};
+
+// src/view-manager.ts
+var ViewManager = class {
+  // Expose materializer for direct access to view methods
+  materializer;
+  constructor(viewStorage, config) {
+    const materializerConfig = {
+      basePath: config.basePath,
+      backendUrl: config.backendUrl
+    };
+    this.materializer = new ViewMaterializer(viewStorage, materializerConfig);
+  }
+  /**
+   * Update resource view with a new event
+   * Falls back to full rebuild if view doesn't exist
+   * @param resourceId - Branded ResourceId (from @semiont/core)
+   * @param event - Resource event (from @semiont/core)
+   * @param getAllEvents - Function to retrieve all events for rebuild if needed
+   */
+  async materializeResource(resourceId, event, getAllEvents) {
+    await this.materializer.materializeIncremental(resourceId, event, getAllEvents);
+  }
+  /**
+   * Update system-level view (currently only entity types)
+   * @param eventType - Type of system event
+   * @param payload - Event payload
+   */
+  async materializeSystem(eventType, payload) {
+    if (eventType === "entitytype.added") {
+      await this.materializer.materializeEntityTypes(payload.entityType);
+    }
+  }
+  /**
+   * Get resource view (builds from events if needed)
+   * @param resourceId - Branded ResourceId (from @semiont/core)
+   * @param events - Stored events for the resource (from @semiont/core)
+   * @returns Resource view or null if no events
+   */
+  async getOrMaterialize(resourceId, events) {
+    return this.materializer.materialize(events, resourceId);
+  }
+};
+
+// src/event-store.ts
+var EventStore = class {
+  // Focused components - each with single responsibility
+  log;
+  bus;
+  views;
+  constructor(config, viewStorage, identifierConfig) {
+    const logConfig = {
+      basePath: config.basePath,
+      dataDir: config.dataDir,
+      enableSharding: config.enableSharding,
+      maxEventsPerFile: config.maxEventsPerFile
+    };
+    this.log = new EventLog(logConfig);
+    const busConfig = {
+      identifierConfig
+    };
+    this.bus = new EventBus(busConfig);
+    const viewConfig = {
+      basePath: config.basePath,
+      backendUrl: identifierConfig.baseUrl
+    };
+    this.views = new ViewManager(viewStorage, viewConfig);
+  }
+  /**
+   * Append an event to the store
+   * Coordinates: persistence → view → notification
+   */
+  async appendEvent(event) {
+    const resourceId = event.resourceId || "__system__";
+    const storedEvent = await this.log.append(event, resourceId);
+    if (resourceId === "__system__") {
+      await this.views.materializeSystem(
+        storedEvent.event.type,
+        storedEvent.event.payload
+      );
+    } else {
+      await this.views.materializeResource(
+        resourceId,
+        storedEvent.event,
+        () => this.log.getEvents(resourceId)
+      );
+    }
+    await this.bus.publish(storedEvent);
+    return storedEvent;
+  }
+};
+var FilesystemViewStorage = class {
+  basePath;
+  constructor(basePath, projectRoot) {
+    if (path.isAbsolute(basePath)) {
+      this.basePath = basePath;
+    } else if (projectRoot) {
+      this.basePath = path.resolve(projectRoot, basePath);
+    } else {
+      this.basePath = path.resolve(basePath);
+    }
+  }
+  getProjectionPath(resourceId) {
+    const [ab, cd] = getShardPath(resourceId);
+    return path.join(this.basePath, "projections", "resources", ab, cd, `${resourceId}.json`);
+  }
+  async save(resourceId, projection) {
+    const projPath = this.getProjectionPath(resourceId);
+    const projDir = path.dirname(projPath);
+    await promises.mkdir(projDir, { recursive: true });
+    await promises.writeFile(projPath, JSON.stringify(projection, null, 2), "utf-8");
+  }
+  async get(resourceId) {
+    const projPath = this.getProjectionPath(resourceId);
+    try {
+      const content = await promises.readFile(projPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async delete(resourceId) {
+    const projPath = this.getProjectionPath(resourceId);
+    try {
+      await promises.unlink(projPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  async exists(resourceId) {
+    const projPath = this.getProjectionPath(resourceId);
+    try {
+      await promises.access(projPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getAll() {
+    const views = [];
+    const annotationsPath = path.join(this.basePath, "projections", "resources");
+    try {
+      const walkDir = async (dir) => {
+        const entries = await promises.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            await walkDir(fullPath);
+          } else if (entry.isFile() && entry.name.endsWith(".json")) {
+            try {
+              const content = await promises.readFile(fullPath, "utf-8");
+              const view = JSON.parse(content);
+              views.push(view);
+            } catch (error) {
+              console.error(`[ViewStorage] Failed to read view ${fullPath}:`, error);
+            }
+          }
+        }
+      };
+      await walkDir(annotationsPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+    return views;
+  }
+};
+
+// src/query/event-query.ts
+var EventQuery = class {
+  constructor(eventStorage) {
+    this.eventStorage = eventStorage;
+  }
+  /**
+   * Query events with filters
+   * Supports filtering by: userId, eventTypes, timestamps, sequence number, limit
+   */
+  async queryEvents(query) {
+    if (!query.resourceId) {
+      throw new Error("resourceId is required for event queries");
+    }
+    const allEvents = await this.eventStorage.getAllEvents(query.resourceId);
+    let results = allEvents;
+    if (query.userId) {
+      results = results.filter((e) => e.event.userId === query.userId);
+    }
+    if (query.eventTypes && query.eventTypes.length > 0) {
+      results = results.filter((e) => query.eventTypes.includes(e.event.type));
+    }
+    if (query.fromTimestamp) {
+      results = results.filter((e) => e.event.timestamp >= query.fromTimestamp);
+    }
+    if (query.toTimestamp) {
+      results = results.filter((e) => e.event.timestamp <= query.toTimestamp);
+    }
+    if (query.fromSequence) {
+      results = results.filter((e) => e.metadata.sequenceNumber >= query.fromSequence);
+    }
+    if (query.limit && query.limit > 0) {
+      results = results.slice(0, query.limit);
+    }
+    return results;
+  }
+  /**
+   * Get all events for a specific resource (no filters)
+   */
+  async getResourceEvents(resourceId) {
+    return this.eventStorage.getAllEvents(resourceId);
+  }
+  /**
+   * Get the last event from a specific file
+   * Useful for initializing sequence numbers and last hashes
+   */
+  async getLastEvent(resourceId, filename) {
+    return this.eventStorage.getLastEvent(resourceId, filename);
+  }
+  /**
+   * Get the latest event for a resource across all files
+   */
+  async getLatestEvent(resourceId) {
+    const files = await this.eventStorage.getEventFiles(resourceId);
+    if (files.length === 0) return null;
+    for (let i = files.length - 1; i >= 0; i--) {
+      const file = files[i];
+      if (!file) continue;
+      const lastEvent = await this.eventStorage.getLastEvent(resourceId, file);
+      if (lastEvent) return lastEvent;
+    }
+    return null;
+  }
+  /**
+   * Get event count for a resource
+   */
+  async getEventCount(resourceId) {
+    const events = await this.getResourceEvents(resourceId);
+    return events.length;
+  }
+  /**
+   * Check if a resource has any events
+   */
+  async hasEvents(resourceId) {
+    const files = await this.eventStorage.getEventFiles(resourceId);
+    return files.length > 0;
+  }
+};
+
+// src/validation/event-validator.ts
+var EventValidator = class {
+  /**
+   * Validate event chain integrity for a resource's events
+   * Checks that each event properly links to the previous event
+   */
+  validateEventChain(events) {
+    const errors = [];
+    for (let i = 1; i < events.length; i++) {
+      const prev = events[i - 1];
+      const curr = events[i];
+      if (!prev || !curr) continue;
+      if (curr.metadata.prevEventHash !== prev.metadata.checksum) {
+        errors.push(
+          `Event chain broken at sequence ${curr.metadata.sequenceNumber}: prevEventHash=${curr.metadata.prevEventHash} but previous checksum=${prev.metadata.checksum}`
+        );
+      }
+      const calculated = sha256(curr.event);
+      if (calculated !== curr.metadata.checksum) {
+        errors.push(
+          `Checksum mismatch at sequence ${curr.metadata.sequenceNumber}: calculated=${calculated} but stored=${curr.metadata.checksum}`
+        );
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Validate a single event's checksum
+   * Useful for validating events before writing them
+   */
+  validateEventChecksum(event) {
+    const calculated = sha256(event.event);
+    return calculated === event.metadata.checksum;
+  }
+  /**
+   * Validate that an event properly links to a previous event
+   * Returns true if the link is valid or if this is the first event
+   */
+  validateEventLink(currentEvent, previousEvent) {
+    if (!previousEvent) {
+      return !currentEvent.metadata.prevEventHash;
+    }
+    return currentEvent.metadata.prevEventHash === previousEvent.metadata.checksum;
+  }
+};
+
+export { EventBus, EventLog, EventQuery, EventStorage, EventStore, EventSubscriptions, EventValidator, FilesystemViewStorage, ViewManager, ViewMaterializer, getEventSubscriptions, getShardPath, jumpConsistentHash, sha256, toAnnotationUri, toResourceUri };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map