@documentation-robotics/cli 0.1.0 → 0.1.5

package/dist/core/virtual-projection.js

@@ -0,0 +1,443 @@
+import { Layer as LayerClass } from "./layer.js";
+import { Element as ElementClass } from "./element.js";
+import { StagedChangesetStorage } from "./staged-changeset-storage.js";
+class VirtualProjectionEngine {
+  stagingAreaManager;
+  projectionCache;
+  /**
+   * Create a new projection engine.
+   *
+   * @param rootPath - Root path to the model (used by StagedChangesetStorage)
+   */
+  constructor(rootPath) {
+    this.stagingAreaManager = new StagedChangesetStorage(rootPath), this.projectionCache = {
+      cache: /* @__PURE__ */ new Map(),
+      metrics: /* @__PURE__ */ new Map(),
+      maxAge: 5 * 60 * 1e3,
+      // 5-minute TTL for cached projections
+      lastCleanup: Date.now()
+    };
+  }
+  /**
+   * Project a single element by applying staged changes to it.
+   * Merges the element's base state with staged changes to compute its projected state.
+   *
+   * @param baseModel - The base model to project from
+   * @param changesetId - ID of the changeset containing staged changes
+   * @param elementId - ID of the element to project
+   * @returns Projected element with staged changes applied, or null if element is deleted
+   * @throws Error if changeset not found
+   *
+   * @remarks
+   * If multiple changes exist for the element, the last change determines final state.
+   * For 'delete' operations, returns null.
+   * For 'add' operations without base element, creates new element from staged data.
+   * For 'update' operations, merges staged changes with base element attributes.
+   */
+  async projectElement(baseModel, changesetId, elementId) {
+    const changeset = await this.stagingAreaManager.load(changesetId);
+    if (!changeset)
+      throw new Error(`Changeset '${changesetId}' not found`);
+    const elementChanges = changeset.changes.filter((c) => c.elementId === elementId);
+    if (elementChanges.length === 0)
+      return baseModel.getElementById(elementId) || null;
+    const lastChange = elementChanges[elementChanges.length - 1];
+    if (lastChange.type === "delete")
+      return null;
+    const baseElement = baseModel.getElementById(elementId), projectedData = lastChange.after || {};
+    if (baseElement) {
+      const projectedAttributes = typeof projectedData.attributes == "object" ? projectedData.attributes : {}, mergedData = {
+        id: baseElement.id,
+        path: baseElement.path,
+        spec_node_id: baseElement.spec_node_id,
+        type: typeof projectedData.type == "string" ? projectedData.type : baseElement.type,
+        layer_id: baseElement.layer_id,
+        name: typeof projectedData.name == "string" ? projectedData.name : baseElement.name,
+        description: typeof projectedData.description == "string" ? projectedData.description : baseElement.description,
+        attributes: {
+          ...baseElement.attributes,
+          ...projectedAttributes
+        },
+        references: Array.isArray(projectedData.references) ? projectedData.references : baseElement.references,
+        relationships: Array.isArray(projectedData.relationships) ? projectedData.relationships : baseElement.relationships,
+        source_reference: baseElement.source_reference,
+        metadata: baseElement.metadata
+      };
+      return new ElementClass(mergedData);
+    } else if (lastChange.type === "add")
+      return new ElementClass({
+        id: lastChange.after?.id || elementId,
+        path: lastChange.after?.path || elementId,
+        spec_node_id: lastChange.after?.spec_node_id || "",
+        type: projectedData.type || "unknown",
+        layer_id: lastChange.layerName,
+        name: projectedData.name || elementId,
+        description: projectedData.description || "",
+        attributes: typeof projectedData.attributes == "object" ? projectedData.attributes : {},
+        references: Array.isArray(projectedData.references) ? projectedData.references : [],
+        relationships: Array.isArray(projectedData.relationships) ? projectedData.relationships : [],
+        source_reference: projectedData.source_reference,
+        metadata: projectedData.metadata,
+        layer: lastChange.layerName
+      });
+    return null;
+  }
+  /**
+   * Project a layer by applying staged changes to a clone of the base layer.
+   * Checks cache first; computes and caches result if not found or expired.
+   *
+   * @param baseModel - The base model to project from
+   * @param changesetId - ID of the changeset containing staged changes
+   * @param layerName - Name of the layer to project
+   * @returns Projected layer with staged changes applied
+   * @throws Error if changeset or base layer not found
+   *
+   * @remarks
+   * Computation process:
+   * 1. Check projection cache (returns if found and not expired)
+   * 2. Clone base layer to avoid mutations
+   * 3. Load staged changes filtered to this layer
+   * 4. Apply changes in sequence number order (add/update/delete)
+   * 5. Cache result with timestamp for TTL tracking
+   * 6. Trigger periodic cache cleanup
+   */
+  async projectLayer(baseModel, changesetId, layerName) {
+    const cacheKey = `${changesetId}:${layerName}`, cached = this.projectionCache.cache.get(cacheKey);
+    if (cached) {
+      if (Date.now() - new Date(cached.computedAt).getTime() < this.projectionCache.maxAge)
+        return this.recordCacheHit(changesetId), cached.layer;
+      this.projectionCache.cache.delete(cacheKey);
+    }
+    this.recordCacheMiss(changesetId);
+    const baseLayer = await baseModel.getBaseLayer(layerName), projectedLayer = baseLayer ? this.cloneLayer(baseLayer) : new LayerClass(layerName), changeset = await this.stagingAreaManager.load(changesetId);
+    if (!changeset)
+      throw new Error(`Changeset '${changesetId}' not found`);
+    const layerChanges = changeset.changes.filter((c) => c.layerName === layerName).sort((a, b) => a.sequenceNumber - b.sequenceNumber);
+    for (const change of layerChanges)
+      switch (change.type) {
+        case "add":
+          if (change.after) {
+            const newElement = new ElementClass({
+              id: change.after.id || change.elementId,
+              path: change.after.path || change.elementId,
+              spec_node_id: change.after.spec_node_id || "",
+              type: change.after.type || "unknown",
+              layer_id: layerName,
+              name: change.after.name || change.elementId,
+              description: change.after.description || "",
+              attributes: typeof change.after.attributes == "object" ? change.after.attributes : {},
+              references: Array.isArray(change.after.references) ? change.after.references : [],
+              relationships: Array.isArray(change.after.relationships) ? change.after.relationships : [],
+              source_reference: change.after.source_reference,
+              metadata: change.after.metadata,
+              layer: layerName
+            });
+            projectedLayer.addElement(newElement);
+          }
+          break;
+        case "update":
+          if (change.after) {
+            const existing = projectedLayer.getElement(change.elementId);
+            if (existing) {
+              const afterAttributes = typeof change.after.attributes == "object" ? change.after.attributes : {}, mergedAttributes = {
+                ...existing.attributes,
+                ...afterAttributes
+              }, updatedElement = new ElementClass({
+                id: existing.id,
+                path: existing.path,
+                spec_node_id: existing.spec_node_id,
+                layer_id: existing.layer_id,
+                type: typeof change.after.type == "string" ? change.after.type : existing.type,
+                name: typeof change.after.name == "string" ? change.after.name : existing.name,
+                description: typeof change.after.description == "string" ? change.after.description : existing.description,
+                attributes: mergedAttributes,
+                references: Array.isArray(change.after.references) ? change.after.references : existing.references,
+                relationships: Array.isArray(change.after.relationships) ? change.after.relationships : existing.relationships,
+                layer: layerName,
+                source_reference: existing.source_reference,
+                metadata: existing.metadata
+              });
+              projectedLayer.updateElement(updatedElement);
+            }
+          }
+          break;
+        case "delete":
+          const existingForDelete = projectedLayer.getElement(change.elementId);
+          existingForDelete && projectedLayer.deleteElement(existingForDelete.path || existingForDelete.id);
+          break;
+        case "relationship-add":
+        case "relationship-delete":
+          break;
+      }
+    const cacheEntry = {
+      layer: projectedLayer,
+      computedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return this.projectionCache.cache.set(cacheKey, cacheEntry), this.cleanupExpiredCache(), projectedLayer;
+  }
+  /**
+   * Project entire model by applying staged changes to all layers.
+   * Creates a complete projected model view that includes both changed and unchanged layers.
+   *
+   * @param baseModel - The base model to project from
+   * @param changesetId - ID of the changeset containing staged changes
+   * @returns ProjectedModel with isProjection=true flag (prevents accidental saves)
+   * @throws Error if changeset not found
+   *
+   * @remarks
+   * Projection includes:
+   * - All layers mentioned in changeset changes
+   * - All layers from base model (to have complete model state)
+   * - Base model's manifest (unchanged)
+   * Returned model has isProjection=true to prevent accidental persistence.
+   */
+  async projectModel(baseModel, changesetId) {
+    const changeset = await this.stagingAreaManager.load(changesetId);
+    if (!changeset)
+      throw new Error(`Changeset '${changesetId}' not found`);
+    const projectedLayers = /* @__PURE__ */ new Map(), layerNames = /* @__PURE__ */ new Set();
+    for (const change of changeset.changes)
+      layerNames.add(change.layerName);
+    for (const baseLayerName of baseModel.getLayerNames())
+      layerNames.add(baseLayerName);
+    for (const layerName of layerNames) {
+      const projectedLayer = await this.projectLayer(baseModel, changesetId, layerName);
+      projectedLayers.set(layerName, projectedLayer);
+    }
+    return {
+      manifest: baseModel.manifest,
+      layers: projectedLayers,
+      relationships: baseModel.relationships,
+      isProjection: !0
+    };
+  }
+  /**
+   * Compute diff by categorizing changeset changes by type.
+   * Extracts the staged changes and organizes them into additions, modifications, and deletions.
+   *
+   * @param _baseModel - The base model (unused; included for interface compatibility)
+   * @param changesetId - ID of the changeset to compute diff for
+   * @returns ModelDiff with changes categorized by type
+   * @throws Error if changeset not found
+   *
+   * @remarks
+   * Diff is computed directly from changeset changes; does not perform deep comparison.
+   * Each change's before/after snapshots are included for detailed display.
+   */
+  async computeDiff(_baseModel, changesetId) {
+    const changeset = await this.stagingAreaManager.load(changesetId);
+    if (!changeset)
+      throw new Error(`Changeset '${changesetId}' not found`);
+    const changes = changeset.changes;
+    return {
+      additions: changes.filter((c) => c.type === "add").map((c) => ({
+        elementId: c.elementId,
+        layerName: c.layerName,
+        data: c.after || {}
+      })),
+      modifications: changes.filter((c) => c.type === "update").map((c) => ({
+        elementId: c.elementId,
+        layerName: c.layerName,
+        before: c.before || {},
+        after: c.after || {}
+      })),
+      deletions: changes.filter((c) => c.type === "delete").map((c) => ({
+        elementId: c.elementId,
+        layerName: c.layerName,
+        data: c.before || {}
+      }))
+    };
+  }
+  /**
+   * Get affected layers for an element in a changeset.
+   * Returns all layers that have cached projections and contain changes for the element.
+   *
+   * @param changesetId - ID of the changeset
+   * @param elementId - ID of the element being unstaged
+   * @returns Set of affected layer names
+   *
+   * @remarks
+   * When unstaging an element, only the layers where that element was modified
+   * need cache invalidation. This enables granular invalidation instead of
+   * invalidating the entire changeset cache.
+   */
+  async getAffectedLayers(changesetId, elementId) {
+    const affectedLayers = /* @__PURE__ */ new Set();
+    try {
+      const changeset = await this.stagingAreaManager.load(changesetId);
+      if (!changeset)
+        return affectedLayers;
+      for (const change of changeset.changes)
+        change.elementId === elementId && affectedLayers.add(change.layerName);
+    } catch {
+    }
+    return affectedLayers;
+  }
+  /**
+   * Record a cache hit for metrics tracking.
+   *
+   * @param changesetId - ID of the changeset
+   */
+  recordCacheHit(changesetId) {
+    const metrics = this.projectionCache.metrics.get(changesetId) || {
+      hits: 0,
+      misses: 0,
+      invalidations: 0
+    };
+    metrics.hits++, this.projectionCache.metrics.set(changesetId, metrics);
+  }
+  /**
+   * Record a cache miss for metrics tracking.
+   *
+   * @param changesetId - ID of the changeset
+   */
+  recordCacheMiss(changesetId) {
+    const metrics = this.projectionCache.metrics.get(changesetId) || {
+      hits: 0,
+      misses: 0,
+      invalidations: 0
+    };
+    metrics.misses++, this.projectionCache.metrics.set(changesetId, metrics);
+  }
+  /**
+   * Record a cache invalidation for metrics tracking.
+   *
+   * @param changesetId - ID of the changeset
+   */
+  recordInvalidation(changesetId) {
+    const metrics = this.projectionCache.metrics.get(changesetId) || {
+      hits: 0,
+      misses: 0,
+      invalidations: 0
+    };
+    metrics.invalidations++, metrics.lastInvalidation = (/* @__PURE__ */ new Date()).toISOString(), this.projectionCache.metrics.set(changesetId, metrics);
+  }
+  /**
+   * Get cache metrics for a changeset (for monitoring and debugging).
+   *
+   * @param changesetId - ID of the changeset
+   * @returns Cache metrics or undefined if no metrics exist
+   */
+  getCacheMetrics(changesetId) {
+    return this.projectionCache.metrics.get(changesetId);
+  }
+  /**
+   * Invalidate projection cache when changes are staged.
+   * Removes cached projections to ensure fresh computation next time.
+   *
+   * @param changesetId - ID of the changeset being modified
+   * @param layerName - Optional: specific layer to invalidate (all if omitted)
+   *
+   * @remarks
+   * If layerName is provided, only that layer's projection is invalidated.
+   * Otherwise, all projections for the changeset are invalidated.
+   */
+  invalidateOnStage(changesetId, layerName) {
+    if (layerName) {
+      const cacheKey = `${changesetId}:${layerName}`;
+      this.projectionCache.cache.delete(cacheKey), this.recordInvalidation(changesetId);
+    } else {
+      for (const key of this.projectionCache.cache.keys())
+        key.startsWith(`${changesetId}:`) && this.projectionCache.cache.delete(key);
+      this.recordInvalidation(changesetId);
+    }
+  }
+  /**
+   * Invalidate projection cache when changes are unstaged.
+   * Uses layer-specific invalidation for the affected element's layers.
+   *
+   * @param changesetId - ID of the changeset being modified
+   * @param elementId - Optional: ID of element being unstaged (enables granular invalidation)
+   *
+   * @remarks
+   * If elementId is provided, only the layers containing that element are invalidated.
+   * This is more efficient than invalidating the entire changeset cache when
+   * unstaging elements from a multi-layer changeset.
+   * If elementId is omitted, invalidates all projections for the changeset.
+   */
+  async invalidateOnUnstage(changesetId, elementId) {
+    if (elementId) {
+      const affectedLayers = await this.getAffectedLayers(changesetId, elementId);
+      for (const layerName of affectedLayers) {
+        const cacheKey = `${changesetId}:${layerName}`;
+        this.projectionCache.cache.delete(cacheKey);
+      }
+      affectedLayers.size > 0 && this.recordInvalidation(changesetId);
+    } else {
+      for (const key of this.projectionCache.cache.keys())
+        key.startsWith(`${changesetId}:`) && this.projectionCache.cache.delete(key);
+      this.recordInvalidation(changesetId);
+    }
+  }
+  /**
+   * Invalidate all projections for a changeset when it's discarded.
+   * Clears all cached projections for this changeset to free memory.
+   *
+   * @param changesetId - ID of the changeset being discarded
+   */
+  invalidateOnDiscard(changesetId) {
+    for (const key of this.projectionCache.cache.keys())
+      key.startsWith(`${changesetId}:`) && this.projectionCache.cache.delete(key);
+  }
+  /**
+   * Clone a layer to create an independent copy.
+   * Shallow clones all elements and metadata to avoid mutations.
+   * Cloned layer is marked clean to prevent unintended saves.
+   *
+   * @param layer - The layer to clone
+   * @returns New layer with cloned elements and metadata
+   *
+   * @remarks
+   * Cloning strategy:
+   * 1. Create new Layer with same name
+   * 2. Clone each element: shallow copy attributes object and array references
+   * 3. Copy layer metadata if present
+   * 4. Mark cloned layer as clean to prevent automatic saves
+   * This ensures changes to projection don't affect base layer.
+   * Note: Shallow cloning is sufficient since attributes are read-only in projections.
+   */
+  cloneLayer(layer) {
+    const cloned = new LayerClass(layer.name);
+    for (const element of layer.listElements()) {
+      const elementClone = new ElementClass({
+        id: element.id,
+        path: element.path,
+        spec_node_id: element.spec_node_id,
+        type: element.type,
+        layer_id: element.layer_id,
+        name: element.name,
+        description: element.description,
+        attributes: { ...element.attributes },
+        references: [...element.references || []],
+        relationships: [...element.relationships || []],
+        layer: element.layer,
+        source_reference: element.source_reference,
+        metadata: element.metadata
+      });
+      cloned.addElement(elementClone);
+    }
+    return layer.metadata && (cloned.metadata = { ...layer.metadata }), cloned.markClean(), cloned;
+  }
+  /**
+   * Clean up expired cache entries periodically (every 60 seconds).
+   * Removes entries that exceed the maxAge TTL.
+   * Runs at most once per minute to limit overhead.
+   *
+   * @remarks
+   * Cleanup is triggered after each projection computation.
+   * Early exit if last cleanup was less than 60 seconds ago.
+   * Entries are marked for deletion based on age calculation from computedAt timestamp.
+   */
+  cleanupExpiredCache() {
+    const now = Date.now();
+    if (!(now - this.projectionCache.lastCleanup < 60 * 1e3)) {
+      for (const [key, entry] of this.projectionCache.cache.entries())
+        now - new Date(entry.computedAt).getTime() >= this.projectionCache.maxAge && this.projectionCache.cache.delete(key);
+      this.projectionCache.lastCleanup = now;
+    }
+  }
+}
+export {
+  VirtualProjectionEngine
+};
+//# sourceMappingURL=virtual-projection.js.map

package/dist/core/virtual-projection.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/virtual-projection.ts"],
+  "sourcesContent": ["/**\n * VirtualProjectionEngine - Computes merged model views by applying staged changes.\n *\n * Creates virtual (temporary) projections of the base model with staged changes applied,\n * without modifying or persisting the base model. Enables safe preview and validation\n * of changes before commit. Includes projection caching with TTL-based expiration.\n *\n * Staging changes are applied in sequence order to compute accurate merged views.\n */\n\nimport type { Model } from \"./model.js\";\nimport type { Layer } from \"./layer.js\";\nimport type { Element } from \"./element.js\";\nimport type { SourceReference, ElementMetadata } from \"../types/index.js\";\nimport type { Manifest } from \"./manifest.js\";\nimport type { Relationships } from \"./relationships.js\";\nimport { Layer as LayerClass } from \"./layer.js\";\nimport { Element as ElementClass } from \"./element.js\";\nimport type { StagedChange, Change } from \"./changeset.js\";\nimport { StagedChangesetStorage } from \"./staged-changeset-storage.js\";\n\n/**\n * Projected model with isProjection flag to prevent accidental saves.\n * This marker interface ensures that projected models are recognized as temporary\n * and cannot be persisted to disk without explicit commit of the underlying changeset.\n */\nexport interface ProjectedModel {\n  manifest: Manifest;\n  layers: Map<string, Layer>;\n  relationships: Relationships;\n  isProjection: true; // Always true; marks this as a temporary virtual projection\n}\n\n/**\n * Model diff categorizing changeset changes by type.\n * Separates staged changes into additions (new elements), modifications (updated attributes),\n * and deletions (removed elements). Used for preview and diff display operations.\n */\nexport interface ModelDiff {\n  additions: Array<{\n    elementId: string;\n    layerName: string;\n    data: Record<string, unknown>; // Complete element state (from change.after)\n  }>;\n  modifications: Array<{\n    elementId: string;\n    layerName: string;\n    before: Record<string, unknown>; // Previous state (from change.before)\n    after: Record<string, unknown>; // New state (from change.after)\n  }>;\n  deletions: Array<{\n    elementId: string;\n    layerName: string;\n    data: Record<string, unknown>; // Element state before deletion (from change.before)\n  }>;\n}\n\n/**\n * Single cached layer projection.\n * Stores the computed projected layer and timestamp for cache expiration.\n */\ninterface CacheEntry {\n  layer: Layer;\n  computedAt: string; // ISO timestamp for age calculation\n}\n\n/**\n * Cache hit/miss metrics for monitoring cache performance.\n * Tracks successful cache hits, misses, and invalidations per changeset.\n */\ninterface CacheMetrics {\n  hits: number; // Number of successful cache hits\n  misses: number; // Number of cache misses (required computation)\n  invalidations: number; // Number of invalidation operations\n  lastInvalidation?: string; // ISO timestamp of last invalidation\n}\n\n/**\n * Projection cache for storing computed layer projections.\n * Uses TTL-based expiration to prevent stale projections.\n * Entries are lazily removed when expired on access or during periodic cleanup.\n */\ninterface ProjectionCache {\n  cache: Map<string, CacheEntry>; // Key format: `${changesetId}:${layerName}`\n  metrics: Map<string, CacheMetrics>; // Cache metrics keyed by changesetId\n  maxAge: number; // Cache entry TTL in milliseconds (5 minutes default)\n  lastCleanup: number; // Timestamp of last cleanup to limit cleanup frequency\n}\n\n/**\n * VirtualProjectionEngine - Computes merged model views without persisting.\n * Applies staged changes to a cloned base model to compute projections.\n * Uses caching with TTL-based expiration to optimize repeated projections.\n */\nexport class VirtualProjectionEngine {\n  private stagingAreaManager: StagedChangesetStorage;\n  private projectionCache: ProjectionCache;\n\n  /**\n   * Create a new projection engine.\n   *\n   * @param rootPath - Root path to the model (used by StagedChangesetStorage)\n   */\n  constructor(rootPath: string) {\n    this.stagingAreaManager = new StagedChangesetStorage(rootPath);\n    this.projectionCache = {\n      cache: new Map(),\n      metrics: new Map(),\n      maxAge: 5 * 60 * 1000, // 5-minute TTL for cached projections\n      lastCleanup: Date.now(),\n    };\n  }\n\n  /**\n   * Project a single element by applying staged changes to it.\n   * Merges the element's base state with staged changes to compute its projected state.\n   *\n   * @param baseModel - The base model to project from\n   * @param changesetId - ID of the changeset containing staged changes\n   * @param elementId - ID of the element to project\n   * @returns Projected element with staged changes applied, or null if element is deleted\n   * @throws Error if changeset not found\n   *\n   * @remarks\n   * If multiple changes exist for the element, the last change determines final state.\n   * For 'delete' operations, returns null.\n   * For 'add' operations without base element, creates new element from staged data.\n   * For 'update' operations, merges staged changes with base element attributes.\n   */\n  async projectElement(\n    baseModel: Model,\n    changesetId: string,\n    elementId: string\n  ): Promise<Element | null> {\n    const changeset = await this.stagingAreaManager.load(changesetId);\n    if (!changeset) {\n      throw new Error(`Changeset '${changesetId}' not found`);\n    }\n\n    // Find all changes for this element across all layers\n    const elementChanges = changeset.changes.filter(\n      (c: Change) => c.elementId === elementId\n    ) as StagedChange[];\n\n    if (elementChanges.length === 0) {\n      // No changes, return base element if it exists\n      return baseModel.getElementById(elementId) || null;\n    }\n\n    // Get the last change to determine the element's final state\n    const lastChange = elementChanges[elementChanges.length - 1];\n\n    if (lastChange.type === \"delete\") {\n      return null;\n    }\n\n    // For add or update, construct the projected element\n    const baseElement = baseModel.getElementById(elementId);\n    const projectedData = lastChange.after || {};\n\n    if (baseElement) {\n      // Create a new element with projected data merged with base\n      const projectedAttributes =\n        typeof projectedData.attributes === \"object\" ? projectedData.attributes : {};\n\n      const mergedData = {\n        id: baseElement.id,\n        path: baseElement.path,\n        spec_node_id: baseElement.spec_node_id,\n        type: typeof projectedData.type === \"string\" ? projectedData.type : baseElement.type,\n        layer_id: baseElement.layer_id,\n        name: typeof projectedData.name === \"string\" ? projectedData.name : baseElement.name,\n        description:\n          typeof projectedData.description === \"string\"\n            ? projectedData.description\n            : baseElement.description,\n        attributes: {\n          ...baseElement.attributes,\n          ...projectedAttributes,\n        },\n        references: Array.isArray(projectedData.references)\n          ? projectedData.references\n          : baseElement.references,\n        relationships: Array.isArray(projectedData.relationships)\n          ? projectedData.relationships\n          : baseElement.relationships,\n        source_reference: baseElement.source_reference,\n        metadata: baseElement.metadata,\n      };\n\n      return new ElementClass(mergedData);\n    } else if (lastChange.type === \"add\") {\n      // New element being added\n      return new ElementClass({\n        id: (lastChange.after?.id as string) || elementId,\n        path: (lastChange.after?.path as string) || elementId,\n        spec_node_id: (lastChange.after?.spec_node_id as string) || \"\",\n        type: (projectedData.type as string) || \"unknown\",\n        layer_id: lastChange.layerName,\n        name: (projectedData.name as string) || elementId,\n        description: (projectedData.description as string) || \"\",\n        attributes: (typeof projectedData.attributes === \"object\"\n          ? projectedData.attributes\n          : {}) as Record<string, unknown>,\n        references: Array.isArray(projectedData.references) ? projectedData.references : [],\n        relationships: Array.isArray(projectedData.relationships)\n          ? projectedData.relationships\n          : [],\n        source_reference: projectedData.source_reference as SourceReference | undefined,\n        metadata: projectedData.metadata as ElementMetadata | undefined,\n        layer: lastChange.layerName,\n      });\n    }\n\n    return null;\n  }\n\n  /**\n   * Project a layer by applying staged changes to a clone of the base layer.\n   * Checks cache first; computes and caches result if not found or expired.\n   *\n   * @param baseModel - The base model to project from\n   * @param changesetId - ID of the changeset containing staged changes\n   * @param layerName - Name of the layer to project\n   * @returns Projected layer with staged changes applied\n   * @throws Error if changeset or base layer not found\n   *\n   * @remarks\n   * Computation process:\n   * 1. Check projection cache (returns if found and not expired)\n   * 2. Clone base layer to avoid mutations\n   * 3. Load staged changes filtered to this layer\n   * 4. Apply changes in sequence number order (add/update/delete)\n   * 5. Cache result with timestamp for TTL tracking\n   * 6. Trigger periodic cache cleanup\n   */\n  async projectLayer(baseModel: Model, changesetId: string, layerName: string): Promise<Layer> {\n    // Check cache first\n    const cacheKey = `${changesetId}:${layerName}`;\n    const cached = this.projectionCache.cache.get(cacheKey);\n\n    if (cached) {\n      const age = Date.now() - new Date(cached.computedAt).getTime();\n      if (age < this.projectionCache.maxAge) {\n        // Record cache hit\n        this.recordCacheHit(changesetId);\n        return cached.layer;\n      } else {\n        // Invalidate expired entry\n        this.projectionCache.cache.delete(cacheKey);\n      }\n    }\n\n    // Record cache miss\n    this.recordCacheMiss(changesetId);\n\n    // Load the committed base layer \u2014 must use getBaseLayer() (not getLayer()) to avoid\n    // infinite recursion: getLayer() calls projectLayer(), which would call getLayer() again.\n    const baseLayer = await baseModel.getBaseLayer(layerName);\n    const projectedLayer = baseLayer\n      ? this.cloneLayer(baseLayer)\n      : new LayerClass(layerName);\n\n    // Load staged changes for this layer\n    const changeset = await this.stagingAreaManager.load(changesetId);\n    if (!changeset) {\n      throw new Error(`Changeset '${changesetId}' not found`);\n    }\n\n    const layerChanges = (changeset.changes as StagedChange[])\n      .filter((c: StagedChange) => c.layerName === layerName)\n      .sort((a: StagedChange, b: StagedChange) => a.sequenceNumber - b.sequenceNumber);\n\n    // Apply changes in sequence order\n    for (const change of layerChanges) {\n      switch (change.type) {\n        case \"add\":\n          if (change.after) {\n            const newElement = new ElementClass({\n              id: (change.after.id as string) || change.elementId,\n              path: (change.after.path as string) || change.elementId,\n              spec_node_id: (change.after.spec_node_id as string) || \"\",\n              type: (change.after.type as string) || \"unknown\",\n              layer_id: layerName,\n              name: (change.after.name as string) || change.elementId,\n              description: (change.after.description as string) || \"\",\n              attributes: (typeof change.after.attributes === \"object\"\n                ? change.after.attributes\n                : {}) as Record<string, unknown>,\n              references: Array.isArray(change.after.references) ? change.after.references : [],\n              relationships: Array.isArray(change.after.relationships)\n                ? change.after.relationships\n                : [],\n              source_reference: change.after.source_reference as SourceReference | undefined,\n              metadata: change.after.metadata as ElementMetadata | undefined,\n              layer: layerName,\n            });\n            projectedLayer.addElement(newElement);\n          }\n          break;\n\n        case \"update\":\n          if (change.after) {\n            // Get the existing element to preserve all state\n            const existing = projectedLayer.getElement(change.elementId);\n            if (existing) {\n              // Create updated element with merged attributes\n              const afterAttributes =\n                typeof change.after.attributes === \"object\" ? change.after.attributes : {};\n\n              const mergedAttributes: Record<string, unknown> = {\n                ...existing.attributes,\n                ...afterAttributes,\n              };\n\n              const updatedElement = new ElementClass({\n                id: existing.id,\n                path: existing.path,\n                spec_node_id: existing.spec_node_id,\n                layer_id: existing.layer_id,\n                type: typeof change.after.type === \"string\" ? change.after.type : existing.type,\n                name: typeof change.after.name === \"string\" ? change.after.name : existing.name,\n                description:\n                  typeof change.after.description === \"string\"\n                    ? change.after.description\n                    : existing.description,\n                attributes: mergedAttributes,\n                references: Array.isArray(change.after.references)\n                  ? change.after.references\n                  : existing.references,\n                relationships: Array.isArray(change.after.relationships)\n                  ? change.after.relationships\n                  : existing.relationships,\n                layer: layerName,\n                source_reference: existing.source_reference,\n                metadata: existing.metadata,\n              });\n\n              projectedLayer.updateElement(updatedElement);\n            }\n          }\n          break;\n\n        case \"delete\":\n          const existingForDelete = projectedLayer.getElement(change.elementId);\n          if (existingForDelete) {\n            projectedLayer.deleteElement(existingForDelete.path || existingForDelete.id);\n          }\n          break;\n\n        case \"relationship-add\":\n        case \"relationship-delete\":\n          // Relationship changes are handled at the model level (model.relationships),\n          // not the layer level. Skip here; no layer mutation needed.\n          break;\n      }\n    }\n\n    // Cache the result\n    const cacheEntry: CacheEntry = {\n      layer: projectedLayer,\n      computedAt: new Date().toISOString(),\n    };\n    this.projectionCache.cache.set(cacheKey, cacheEntry);\n\n    // Periodic cleanup of expired entries\n    this.cleanupExpiredCache();\n\n    return projectedLayer;\n  }\n\n  /**\n   * Project entire model by applying staged changes to all layers.\n   * Creates a complete projected model view that includes both changed and unchanged layers.\n   *\n   * @param baseModel - The base model to project from\n   * @param changesetId - ID of the changeset containing staged changes\n   * @returns ProjectedModel with isProjection=true flag (prevents accidental saves)\n   * @throws Error if changeset not found\n   *\n   * @remarks\n   * Projection includes:\n   * - All layers mentioned in changeset changes\n   * - All layers from base model (to have complete model state)\n   * - Base model's manifest (unchanged)\n   * Returned model has isProjection=true to prevent accidental persistence.\n   */\n  async projectModel(baseModel: Model, changesetId: string): Promise<ProjectedModel> {\n    const changeset = await this.stagingAreaManager.load(changesetId);\n    if (!changeset) {\n      throw new Error(`Changeset '${changesetId}' not found`);\n    }\n\n    const projectedLayers = new Map<string, Layer>();\n\n    // Project all layers mentioned in the changeset\n    const layerNames = new Set<string>();\n    for (const change of changeset.changes) {\n      layerNames.add(change.layerName);\n    }\n\n    // Also include all base layers to get complete model\n    for (const baseLayerName of baseModel.getLayerNames()) {\n      layerNames.add(baseLayerName);\n    }\n\n    // Project each layer\n    for (const layerName of layerNames) {\n      const projectedLayer = await this.projectLayer(baseModel, changesetId, layerName);\n      projectedLayers.set(layerName, projectedLayer);\n    }\n\n    // Create projected model with isProjection flag\n    const projectedModel: ProjectedModel = {\n      manifest: baseModel.manifest,\n      layers: projectedLayers,\n      relationships: baseModel.relationships,\n      isProjection: true,\n    };\n\n    return projectedModel;\n  }\n\n  /**\n   * Compute diff by categorizing changeset changes by type.\n   * Extracts the staged changes and organizes them into additions, modifications, and deletions.\n   *\n   * @param _baseModel - The base model (unused; included for interface compatibility)\n   * @param changesetId - ID of the changeset to compute diff for\n   * @returns ModelDiff with changes categorized by type\n   * @throws Error if changeset not found\n   *\n   * @remarks\n   * Diff is computed directly from changeset changes; does not perform deep comparison.\n   * Each change's before/after snapshots are included for detailed display.\n   */\n  async computeDiff(_baseModel: Model, changesetId: string): Promise<ModelDiff> {\n    const changeset = await this.stagingAreaManager.load(changesetId);\n    if (!changeset) {\n      throw new Error(`Changeset '${changesetId}' not found`);\n    }\n\n    const changes = changeset.changes as StagedChange[];\n\n    return {\n      additions: changes\n        .filter((c: StagedChange) => c.type === \"add\")\n        .map((c: StagedChange) => ({\n          elementId: c.elementId,\n          layerName: c.layerName,\n          data: c.after || {},\n        })),\n\n      modifications: changes\n        .filter((c: StagedChange) => c.type === \"update\")\n        .map((c: StagedChange) => ({\n          elementId: c.elementId,\n          layerName: c.layerName,\n          before: c.before || {},\n          after: c.after || {},\n        })),\n\n      deletions: changes\n        .filter((c: StagedChange) => c.type === \"delete\")\n        .map((c: StagedChange) => ({\n          elementId: c.elementId,\n          layerName: c.layerName,\n          data: c.before || {},\n        })),\n    };\n  }\n\n  /**\n   * Get affected layers for an element in a changeset.\n   * Returns all layers that have cached projections and contain changes for the element.\n   *\n   * @param changesetId - ID of the changeset\n   * @param elementId - ID of the element being unstaged\n   * @returns Set of affected layer names\n   *\n   * @remarks\n   * When unstaging an element, only the layers where that element was modified\n   * need cache invalidation. This enables granular invalidation instead of\n   * invalidating the entire changeset cache.\n   */\n  private async getAffectedLayers(changesetId: string, elementId: string): Promise<Set<string>> {\n    const affectedLayers = new Set<string>();\n\n    try {\n      const changeset = await this.stagingAreaManager.load(changesetId);\n      if (!changeset) {\n        return affectedLayers;\n      }\n\n      // Find all layers that have changes for this element\n      for (const change of changeset.changes) {\n        if (change.elementId === elementId) {\n          affectedLayers.add(change.layerName);\n        }\n      }\n    } catch {\n      // If changeset can't be loaded, return empty set (no invalidation needed)\n      // This handles the case where changeset is deleted or corrupted\n    }\n\n    return affectedLayers;\n  }\n\n  /**\n   * Record a cache hit for metrics tracking.\n   *\n   * @param changesetId - ID of the changeset\n   */\n  private recordCacheHit(changesetId: string): void {\n    const metrics = this.projectionCache.metrics.get(changesetId) || {\n      hits: 0,\n      misses: 0,\n      invalidations: 0,\n    };\n    metrics.hits++;\n    this.projectionCache.metrics.set(changesetId, metrics);\n  }\n\n  /**\n   * Record a cache miss for metrics tracking.\n   *\n   * @param changesetId - ID of the changeset\n   */\n  private recordCacheMiss(changesetId: string): void {\n    const metrics = this.projectionCache.metrics.get(changesetId) || {\n      hits: 0,\n      misses: 0,\n      invalidations: 0,\n    };\n    metrics.misses++;\n    this.projectionCache.metrics.set(changesetId, metrics);\n  }\n\n  /**\n   * Record a cache invalidation for metrics tracking.\n   *\n   * @param changesetId - ID of the changeset\n   */\n  private recordInvalidation(changesetId: string): void {\n    const metrics = this.projectionCache.metrics.get(changesetId) || {\n      hits: 0,\n      misses: 0,\n      invalidations: 0,\n    };\n    metrics.invalidations++;\n    metrics.lastInvalidation = new Date().toISOString();\n    this.projectionCache.metrics.set(changesetId, metrics);\n  }\n\n  /**\n   * Get cache metrics for a changeset (for monitoring and debugging).\n   *\n   * @param changesetId - ID of the changeset\n   * @returns Cache metrics or undefined if no metrics exist\n   */\n  getCacheMetrics(changesetId: string): CacheMetrics | undefined {\n    return this.projectionCache.metrics.get(changesetId);\n  }\n\n  /**\n   * Invalidate projection cache when changes are staged.\n   * Removes cached projections to ensure fresh computation next time.\n   *\n   * @param changesetId - ID of the changeset being modified\n   * @param layerName - Optional: specific layer to invalidate (all if omitted)\n   *\n   * @remarks\n   * If layerName is provided, only that layer's projection is invalidated.\n   * Otherwise, all projections for the changeset are invalidated.\n   */\n  invalidateOnStage(changesetId: string, layerName?: string): void {\n    if (layerName) {\n      // Invalidate specific layer projection\n      const cacheKey = `${changesetId}:${layerName}`;\n      this.projectionCache.cache.delete(cacheKey);\n      this.recordInvalidation(changesetId);\n    } else {\n      // Invalidate all projections for this changeset\n      for (const key of this.projectionCache.cache.keys()) {\n        if (key.startsWith(`${changesetId}:`)) {\n          this.projectionCache.cache.delete(key);\n        }\n      }\n      this.recordInvalidation(changesetId);\n    }\n  }\n\n  /**\n   * Invalidate projection cache when changes are unstaged.\n   * Uses layer-specific invalidation for the affected element's layers.\n   *\n   * @param changesetId - ID of the changeset being modified\n   * @param elementId - Optional: ID of element being unstaged (enables granular invalidation)\n   *\n   * @remarks\n   * If elementId is provided, only the layers containing that element are invalidated.\n   * This is more efficient than invalidating the entire changeset cache when\n   * unstaging elements from a multi-layer changeset.\n   * If elementId is omitted, invalidates all projections for the changeset.\n   */\n  async invalidateOnUnstage(changesetId: string, elementId?: string): Promise<void> {\n    if (elementId) {\n      // Layer-specific invalidation: only invalidate affected layers\n      const affectedLayers = await this.getAffectedLayers(changesetId, elementId);\n      for (const layerName of affectedLayers) {\n        const cacheKey = `${changesetId}:${layerName}`;\n        this.projectionCache.cache.delete(cacheKey);\n      }\n      if (affectedLayers.size > 0) {\n        this.recordInvalidation(changesetId);\n      }\n    } else {\n      // Full invalidation: clear all projections for this changeset\n      for (const key of this.projectionCache.cache.keys()) {\n        if (key.startsWith(`${changesetId}:`)) {\n          this.projectionCache.cache.delete(key);\n        }\n      }\n      this.recordInvalidation(changesetId);\n    }\n  }\n\n  /**\n   * Invalidate all projections for a changeset when it's discarded.\n   * Clears all cached projections for this changeset to free memory.\n   *\n   * @param changesetId - ID of the changeset being discarded\n   */\n  invalidateOnDiscard(changesetId: string): void {\n    for (const key of this.projectionCache.cache.keys()) {\n      if (key.startsWith(`${changesetId}:`)) {\n        this.projectionCache.cache.delete(key);\n      }\n    }\n  }\n\n  /**\n   * Clone a layer to create an independent copy.\n   * Shallow clones all elements and metadata to avoid mutations.\n   * Cloned layer is marked clean to prevent unintended saves.\n   *\n   * @param layer - The layer to clone\n   * @returns New layer with cloned elements and metadata\n   *\n   * @remarks\n   * Cloning strategy:\n   * 1. Create new Layer with same name\n   * 2. Clone each element: shallow copy attributes object and array references\n   * 3. Copy layer metadata if present\n   * 4. Mark cloned layer as clean to prevent automatic saves\n   * This ensures changes to projection don't affect base layer.\n   * Note: Shallow cloning is sufficient since attributes are read-only in projections.\n   */\n  private cloneLayer(layer: Layer): Layer {\n    const cloned = new LayerClass(layer.name);\n\n    // Clone all elements (shallow copy - read-only in projection)\n    for (const element of layer.listElements()) {\n      const elementClone = new ElementClass({\n        id: element.id,\n        path: element.path,\n        spec_node_id: element.spec_node_id,\n        type: element.type,\n        layer_id: element.layer_id,\n        name: element.name,\n        description: element.description,\n        attributes: { ...element.attributes },\n        references: [...(element.references || [])],\n        relationships: [...(element.relationships || [])],\n        layer: element.layer,\n        source_reference: element.source_reference,\n        metadata: element.metadata,\n      });\n      cloned.addElement(elementClone);\n    }\n\n    // Preserve layer metadata if present\n    if (layer.metadata) {\n      cloned.metadata = { ...layer.metadata };\n    }\n\n    // Mark as clean to prevent projection from being saved\n    cloned.markClean();\n    return cloned;\n  }\n\n  /**\n   * Clean up expired cache entries periodically (every 60 seconds).\n   * Removes entries that exceed the maxAge TTL.\n   * Runs at most once per minute to limit overhead.\n   *\n   * @remarks\n   * Cleanup is triggered after each projection computation.\n   * Early exit if last cleanup was less than 60 seconds ago.\n   * Entries are marked for deletion based on age calculation from computedAt timestamp.\n   */\n  private cleanupExpiredCache(): void {\n    const now = Date.now();\n\n    // Limit cleanup frequency to at most every 60 seconds\n    if (now - this.projectionCache.lastCleanup < 60 * 1000) {\n      return;\n    }\n\n    // Remove entries that have exceeded their TTL\n    for (const [key, entry] of this.projectionCache.cache.entries()) {\n      const age = now - new Date(entry.computedAt).getTime();\n      if (age >= this.projectionCache.maxAge) {\n        this.projectionCache.cache.delete(key);\n      }\n    }\n\n    this.projectionCache.lastCleanup = now;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}