@documentation-robotics/cli 0.1.0

package/dist/validators/reference-validator.js

@@ -0,0 +1,106 @@
+import { ValidationResult } from "./types.js";
+class ReferenceValidator {
+  // Layer hierarchy (lower numbers are "higher" in the architecture)
+  LAYER_HIERARCHY = {
+    motivation: 1,
+    business: 2,
+    security: 3,
+    application: 4,
+    technology: 5,
+    api: 6,
+    "data-model": 7,
+    "data-store": 8,
+    ux: 9,
+    navigation: 10,
+    apm: 11,
+    testing: 12
+  };
+  // Known layer names (including hyphenated ones)
+  KNOWN_LAYERS = [
+    "motivation",
+    "business",
+    "security",
+    "application",
+    "technology",
+    "api",
+    "data-model",
+    "data-store",
+    "ux",
+    "navigation",
+    "apm",
+    "testing"
+  ];
+  /**
+   * Validate all references in a model
+   */
+  validateModel(model) {
+    const result = new ValidationResult(), allElementIds = this.collectAllElementIds(model);
+    for (const [layerName, layer] of model.layers)
+      for (const element of layer.listElements())
+        this.validateReferences(element.id, element.references || [], layerName, allElementIds, result);
+    return result;
+  }
+  /**
+   * Collect all element IDs across the model
+   */
+  collectAllElementIds(model) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const layer of model.layers.values())
+      for (const element of layer.listElements())
+        ids.add(element.id);
+    return ids;
+  }
+  /**
+   * Validate references for an element
+   */
+  validateReferences(elementId, references, sourceLayerName, validIds, result) {
+    for (const ref of references) {
+      if (!validIds.has(ref.target)) {
+        result.addError({
+          layer: sourceLayerName,
+          elementId,
+          message: `Broken reference: target '${ref.target}' does not exist`,
+          fixSuggestion: `Remove reference or create element '${ref.target}'`
+        });
+        continue;
+      }
+      const targetLayerName = this.extractLayerFromId(ref.target), sourceLevel = this.LAYER_HIERARCHY[sourceLayerName], targetLevel = this.LAYER_HIERARCHY[targetLayerName];
+      if (sourceLevel === void 0) {
+        result.addError({
+          layer: sourceLayerName,
+          elementId,
+          message: `Unknown source layer: ${sourceLayerName}`
+        });
+        continue;
+      }
+      if (targetLevel === void 0) {
+        result.addError({
+          layer: sourceLayerName,
+          elementId,
+          message: `Target element '${ref.target}' has unknown layer: ${targetLayerName}`
+        });
+        continue;
+      }
+      sourceLevel > targetLevel && result.addError({
+        layer: sourceLayerName,
+        elementId,
+        message: `Invalid reference direction: ${sourceLayerName} (level ${sourceLevel}) cannot reference ${targetLayerName} (level ${targetLevel})`,
+        fixSuggestion: "References must go from higher layers to lower layers (motivation \u2192 testing)"
+      });
+    }
+  }
+  /**
+   * Extract layer name from element ID, handling hyphenated layer names
+   */
+  extractLayerFromId(elementId) {
+    const sortedLayers = [...this.KNOWN_LAYERS].sort((a, b) => b.length - a.length);
+    for (const layer of sortedLayers)
+      if (elementId.startsWith(layer + "-"))
+        return layer;
+    return elementId.split("-")[0] || "";
+  }
+}
+export {
+  ReferenceValidator
+};
+//# sourceMappingURL=reference-validator.js.map

package/dist/validators/reference-validator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/reference-validator.ts"],
+  "sourcesContent": ["/**\n * Reference validation for cross-layer integrity\n */\n\nimport { ValidationResult } from './types.js';\nimport type { Model } from '../core/model.js';\n\n/**\n * Validator for cross-layer references\n */\nexport class ReferenceValidator {\n  // Layer hierarchy (lower numbers are \"higher\" in the architecture)\n  private readonly LAYER_HIERARCHY: Record<string, number> = {\n    motivation: 1,\n    business: 2,\n    security: 3,\n    application: 4,\n    technology: 5,\n    api: 6,\n    'data-model': 7,\n    'data-store': 8,\n    ux: 9,\n    navigation: 10,\n    apm: 11,\n    testing: 12,\n  };\n\n  // Known layer names (including hyphenated ones)\n  private readonly KNOWN_LAYERS = [\n    'motivation',\n    'business',\n    'security',\n    'application',\n    'technology',\n    'api',\n    'data-model',\n    'data-store',\n    'ux',\n    'navigation',\n    'apm',\n    'testing',\n  ];\n\n  /**\n   * Validate all references in a model\n   */\n  validateModel(model: Model): ValidationResult {\n    const result = new ValidationResult();\n    const allElementIds = this.collectAllElementIds(model);\n\n    for (const [layerName, layer] of model.layers) {\n      for (const element of layer.listElements()) {\n        this.validateReferences(\n          element.id,\n          element.references || [],\n          layerName,\n          allElementIds,\n          result\n        );\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Collect all element IDs across the model\n   */\n  private collectAllElementIds(model: Model): Set<string> {\n    const ids = new Set<string>();\n\n    for (const layer of model.layers.values()) {\n      for (const element of layer.listElements()) {\n        ids.add(element.id);\n      }\n    }\n\n    return ids;\n  }\n\n  /**\n   * Validate references for an element\n   */\n  private validateReferences(\n    elementId: string,\n    references: Array<{ target: string; type?: string }>,\n    sourceLayerName: string,\n    validIds: Set<string>,\n    result: ValidationResult\n  ): void {\n    for (const ref of references) {\n      // Check target exists\n      if (!validIds.has(ref.target)) {\n        result.addError({\n          layer: sourceLayerName,\n          elementId,\n          message: `Broken reference: target '${ref.target}' does not exist`,\n          fixSuggestion: `Remove reference or create element '${ref.target}'`,\n        });\n        continue;\n      }\n\n      // Check directional constraint (higher \u2192 lower only)\n      const targetLayerName = this.extractLayerFromId(ref.target);\n      const sourceLevel = this.LAYER_HIERARCHY[sourceLayerName];\n      const targetLevel = this.LAYER_HIERARCHY[targetLayerName];\n\n      if (sourceLevel === undefined) {\n        result.addError({\n          layer: sourceLayerName,\n          elementId,\n          message: `Unknown source layer: ${sourceLayerName}`,\n        });\n        continue;\n      }\n\n      if (targetLevel === undefined) {\n        result.addError({\n          layer: sourceLayerName,\n          elementId,\n          message: `Target element '${ref.target}' has unknown layer: ${targetLayerName}`,\n        });\n        continue;\n      }\n\n      // References must go from higher layers (lower numbers) to lower layers (higher numbers)\n      // or within the same layer\n      if (sourceLevel > targetLevel) {\n        result.addError({\n          layer: sourceLayerName,\n          elementId,\n          message: `Invalid reference direction: ${sourceLayerName} (level ${sourceLevel}) cannot reference ${targetLayerName} (level ${targetLevel})`,\n          fixSuggestion:\n            'References must go from higher layers to lower layers (motivation \u2192 testing)',\n        });\n      }\n    }\n  }\n\n  /**\n   * Extract layer name from element ID, handling hyphenated layer names\n   */\n  private extractLayerFromId(elementId: string): string {\n    // Try to match known layers in order of specificity (longest first)\n    const sortedLayers = [...this.KNOWN_LAYERS].sort((a, b) => b.length - a.length);\n\n    for (const layer of sortedLayers) {\n      if (elementId.startsWith(layer + '-')) {\n        return layer;\n      }\n    }\n\n    // Fallback: return first segment (shouldn't reach here with valid element IDs)\n    return elementId.split('-')[0] || '';\n  }\n}\n"],
+  "mappings": "AAIA,SAAS,wBAAwB;AAM3B,MAAO,mBAAkB;;EAEZ,kBAA0C;IACzD,YAAY;IACZ,UAAU;IACV,UAAU;IACV,aAAa;IACb,YAAY;IACZ,KAAK;IACL,cAAc;IACd,cAAc;IACd,IAAI;IACJ,YAAY;IACZ,KAAK;IACL,SAAS;;;EAIM,eAAe;IAC9B;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;;;;;EAMF,cAAc,OAAY;AACxB,UAAM,SAAS,IAAI,iBAAgB,GAC7B,gBAAgB,KAAK,qBAAqB,KAAK;AAErD,eAAW,CAAC,WAAW,KAAK,KAAK,MAAM;AACrC,iBAAW,WAAW,MAAM,aAAY;AACtC,aAAK,mBACH,QAAQ,IACR,QAAQ,cAAc,CAAA,GACtB,WACA,eACA,MAAM;AAKZ,WAAO;EACT;;;;EAKQ,qBAAqB,OAAY;AACvC,UAAM,MAAM,oBAAI,IAAG;AAEnB,eAAW,SAAS,MAAM,OAAO,OAAM;AACrC,iBAAW,WAAW,MAAM,aAAY;AACtC,YAAI,IAAI,QAAQ,EAAE;AAItB,WAAO;EACT;;;;EAKQ,mBACN,WACA,YACA,iBACA,UACA,QAAwB;AAExB,eAAW,OAAO,YAAY;AAE5B,UAAI,CAAC,SAAS,IAAI,IAAI,MAAM,GAAG;AAC7B,eAAO,SAAS;UACd,OAAO;UACP;UACA,SAAS,6BAA6B,IAAI,MAAM;UAChD,eAAe,uCAAuC,IAAI,MAAM;SACjE;AACD;MACF;AAGA,YAAM,kBAAkB,KAAK,mBAAmB,IAAI,MAAM,GACpD,cAAc,KAAK,gBAAgB,eAAe,GAClD,cAAc,KAAK,gBAAgB,eAAe;AAExD,UAAI,gBAAgB,QAAW;AAC7B,eAAO,SAAS;UACd,OAAO;UACP;UACA,SAAS,yBAAyB,eAAe;SAClD;AACD;MACF;AAEA,UAAI,gBAAgB,QAAW;AAC7B,eAAO,SAAS;UACd,OAAO;UACP;UACA,SAAS,mBAAmB,IAAI,MAAM,wBAAwB,eAAe;SAC9E;AACD;MACF;AAIA,MAAI,cAAc,eAChB,OAAO,SAAS;QACd,OAAO;QACP;QACA,SAAS,gCAAgC,eAAe,WAAW,WAAW,sBAAsB,eAAe,WAAW,WAAW;QACzI,eACE;OACH;IAEL;EACF;;;;EAKQ,mBAAmB,WAAiB;AAE1C,UAAM,eAAe,CAAC,GAAG,KAAK,YAAY,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,MAAM;AAE9E,eAAW,SAAS;AAClB,UAAI,UAAU,WAAW,QAAQ,GAAG;AAClC,eAAO;AAKX,WAAO,UAAU,MAAM,GAAG,EAAE,CAAC,KAAK;EACpC;;",
+  "names": []
+}

package/dist/validators/schema-validator.js

@@ -0,0 +1,148 @@
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import { ValidationResult } from "./types.js";
+import { fileURLToPath } from "url";
+import path from "path";
+import { readFile } from "../utils/file-io.js";
+import { startSpan, endSpan } from "../telemetry/index.js";
+const isTelemetryEnabled = !1;
+class SchemaValidator {
+  ajv;
+  compiledSchemas = /* @__PURE__ */ new Map();
+  schemasLoaded = !1;
+  constructor() {
+    this.ajv = new Ajv({
+      allErrors: !0,
+      strict: !1,
+      validateFormats: !0
+    }), addFormats(this.ajv);
+  }
+  /**
+   * Ensure schemas are precompiled before validation
+   */
+  async ensureSchemasLoaded() {
+    this.schemasLoaded || (await this.precompileSchemas(), this.schemasLoaded = !0);
+  }
+  /**
+   * Precompile all layer schemas for efficient validation
+   */
+  async precompileSchemas() {
+    const layerMappings = {
+      motivation: "01-motivation-layer.schema.json",
+      business: "02-business-layer.schema.json",
+      security: "03-security-layer.schema.json",
+      application: "04-application-layer.schema.json",
+      technology: "05-technology-layer.schema.json",
+      api: "06-api-layer.schema.json",
+      "data-model": "07-data-model-layer.schema.json",
+      "data-store": "08-datastore-layer.schema.json",
+      ux: "09-ux-layer.schema.json",
+      navigation: "10-navigation-layer.schema.json",
+      apm: "11-apm-observability-layer.schema.json",
+      testing: "12-testing-layer.schema.json"
+    }, __dirname = path.dirname(fileURLToPath(import.meta.url)), schemasDir = path.join(__dirname, "..", "schemas", "bundled"), commonSchemas = [
+      "common/source-references.schema.json",
+      "common/predicates.schema.json",
+      "common/relationships.schema.json",
+      "common/layer-extensions.schema.json"
+    ];
+    for (const commonSchemaFile of commonSchemas)
+      try {
+        const schemaPath = path.join(schemasDir, commonSchemaFile), schemaContent = await readFile(schemaPath), schema = JSON.parse(schemaContent);
+        this.ajv.addSchema(schema);
+      } catch (error) {
+        console.warn(`Warning: Failed to load common schema ${commonSchemaFile}:`, error);
+      }
+    for (const [layerName, schemaFileName] of Object.entries(layerMappings))
+      try {
+        let schemaPath = path.join(schemasDir, schemaFileName), schemaContent;
+        try {
+          schemaContent = await readFile(schemaPath);
+        } catch {
+          schemaPath = path.join(__dirname, "schemas", "bundled", schemaFileName), schemaContent = await readFile(schemaPath);
+        }
+        const schema = JSON.parse(schemaContent), validate = this.ajv.compile(schema);
+        this.compiledSchemas.set(layerName, validate);
+      } catch (error) {
+        console.warn(`Failed to load schema for layer ${layerName}:`, error);
+      }
+  }
+  /**
+   * Validate a layer against its schema
+   */
+  async validateLayer(layer) {
+    const span = isTelemetryEnabled ? startSpan("schema.validate", {
+      "schema.layer": layer.name
+    }) : null;
+    try {
+      const result = new ValidationResult();
+      await this.ensureSchemasLoaded();
+      const validate = this.compiledSchemas.get(layer.name);
+      if (!validate)
+        return isTelemetryEnabled && span && (span.setAttribute("schema.valid", !0), span.setAttribute("schema.skipped", !0)), result;
+      const layerData = layer.toJSON(), valid = validate(layerData);
+      if (!valid && validate.errors)
+        for (const error of validate.errors)
+          result.addError({
+            layer: layer.name,
+            message: `Schema validation failed: ${this.formatAjvError(error)}`,
+            location: error.instancePath || "/",
+            fixSuggestion: this.generateFixSuggestion(error)
+          });
+      return isTelemetryEnabled && span && (span.setAttribute("schema.valid", valid), span.setAttribute("schema.error_count", validate.errors?.length || 0)), result;
+    } finally {
+      endSpan(span);
+    }
+  }
+  /**
+   * Format AJV error message
+   */
+  formatAjvError(error) {
+    const keyword = error.keyword, dataPath = error.instancePath || "/";
+    switch (keyword) {
+      case "type":
+        return `At ${dataPath}: expected ${error.params?.type}, got ${typeof error.data}`;
+      case "required":
+        return `At ${dataPath}: missing required property '${error.params?.missingProperty}'`;
+      case "enum":
+        return `At ${dataPath}: value must be one of [${error.params?.allowedValues?.join(", ")}]`;
+      case "pattern":
+        return `At ${dataPath}: value must match pattern ${error.params?.pattern}`;
+      case "minLength":
+        return `At ${dataPath}: string must be at least ${error.params?.limit} characters`;
+      case "maxLength":
+        return `At ${dataPath}: string must be at most ${error.params?.limit} characters`;
+      case "minimum":
+        return `At ${dataPath}: value must be >= ${error.params?.limit}`;
+      case "maximum":
+        return `At ${dataPath}: value must be <= ${error.params?.limit}`;
+      case "additionalProperties":
+        return `At ${dataPath}: unexpected property '${error.params?.additionalProperty}'`;
+      default:
+        return error.message || "Validation failed";
+    }
+  }
+  /**
+   * Generate a fix suggestion based on the error
+   */
+  generateFixSuggestion(error) {
+    switch (error.keyword) {
+      case "required":
+        return `Add required field: ${error.params?.missingProperty}`;
+      case "type":
+        return `Expected type ${error.params?.type}`;
+      case "enum":
+        return `Use one of: ${error.params?.allowedValues?.join(", ")}`;
+      case "pattern":
+        return `Value must match pattern: ${error.params?.pattern}`;
+      case "additionalProperties":
+        return `Remove unexpected property: ${error.params?.additionalProperty}`;
+      default:
+        return;
+    }
+  }
+}
+export {
+  SchemaValidator
+};
+//# sourceMappingURL=schema-validator.js.map

package/dist/validators/schema-validator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/schema-validator.ts"],
+  "sourcesContent": ["/**\n * Schema validation using AJV\n */\n\nimport Ajv, { ValidateFunction, ErrorObject } from 'ajv';\nimport addFormats from 'ajv-formats';\nimport { ValidationResult } from './types.js';\nimport type { Layer } from '../core/layer.js';\nimport { fileURLToPath } from 'url';\nimport path from 'path';\nimport { readFile } from '../utils/file-io.js';\nimport { startSpan, endSpan } from '../telemetry/index.js';\n\n// Fallback for runtime environments where TELEMETRY_ENABLED is not defined by esbuild\ndeclare const TELEMETRY_ENABLED: boolean | undefined;\nconst isTelemetryEnabled = typeof TELEMETRY_ENABLED !== 'undefined' ? TELEMETRY_ENABLED : false;\n\n/**\n * Validator for JSON Schema compliance\n */\nexport class SchemaValidator {\n  private ajv: Ajv;\n  private compiledSchemas: Map<string, ValidateFunction> = new Map();\n  private schemasLoaded: boolean = false;\n\n  constructor() {\n    this.ajv = new Ajv({\n      allErrors: true,\n      strict: false,\n      validateFormats: true,\n    });\n    addFormats(this.ajv);\n    // Note: schemas are loaded lazily on first validation\n  }\n\n  /**\n   * Ensure schemas are precompiled before validation\n   */\n  private async ensureSchemasLoaded(): Promise<void> {\n    if (this.schemasLoaded) {\n      return;\n    }\n\n    await this.precompileSchemas();\n    this.schemasLoaded = true;\n  }\n\n  /**\n   * Precompile all layer schemas for efficient validation\n   */\n  private async precompileSchemas(): Promise<void> {\n    const layerMappings = {\n      motivation: '01-motivation-layer.schema.json',\n      business: '02-business-layer.schema.json',\n      security: '03-security-layer.schema.json',\n      application: '04-application-layer.schema.json',\n      technology: '05-technology-layer.schema.json',\n      api: '06-api-layer.schema.json',\n      'data-model': '07-data-model-layer.schema.json',\n      'data-store': '08-datastore-layer.schema.json',\n      ux: '09-ux-layer.schema.json',\n      navigation: '10-navigation-layer.schema.json',\n      apm: '11-apm-observability-layer.schema.json',\n      testing: '12-testing-layer.schema.json',\n    };\n\n    const __dirname = path.dirname(fileURLToPath(import.meta.url));\n    const schemasDir = path.join(__dirname, '..', 'schemas', 'bundled');\n\n    // First, register all common schemas that other schemas reference\n    const commonSchemas = [\n      'common/source-references.schema.json',\n      'common/predicates.schema.json',\n      'common/relationships.schema.json',\n      'common/layer-extensions.schema.json',\n    ];\n\n    for (const commonSchemaFile of commonSchemas) {\n      try {\n        const schemaPath = path.join(schemasDir, commonSchemaFile);\n        const schemaContent = await readFile(schemaPath);\n        const schema = JSON.parse(schemaContent);\n        this.ajv.addSchema(schema);\n      } catch (error) {\n        // Common schemas not all layers may reference - warn but continue\n        console.warn(\n          `Warning: Failed to load common schema ${commonSchemaFile}:`,\n          error\n        );\n      }\n    }\n\n    for (const [layerName, schemaFileName] of Object.entries(layerMappings)) {\n      try {\n        // Try primary schema path first (development)\n        let schemaPath = path.join(schemasDir, schemaFileName);\n\n        let schemaContent: string;\n        try {\n          schemaContent = await readFile(schemaPath);\n        } catch {\n          // Fallback to alternative path for bundled deployments\n          schemaPath = path.join(\n            __dirname,\n            'schemas',\n            'bundled',\n            schemaFileName\n          );\n          schemaContent = await readFile(schemaPath);\n        }\n\n        const schema = JSON.parse(schemaContent);\n        const validate = this.ajv.compile(schema);\n        this.compiledSchemas.set(layerName, validate);\n      } catch (error) {\n        console.warn(`Failed to load schema for layer ${layerName}:`, error);\n      }\n    }\n  }\n\n  /**\n   * Validate a layer against its schema\n   */\n  async validateLayer(layer: Layer): Promise<ValidationResult> {\n    const span = isTelemetryEnabled ? startSpan('schema.validate', {\n      'schema.layer': layer.name,\n    }) : null;\n\n    try {\n      const result = new ValidationResult();\n\n      // Ensure schemas are loaded\n      await this.ensureSchemasLoaded();\n\n      const validate = this.compiledSchemas.get(layer.name);\n\n      if (!validate) {\n        // Schema not found - skip validation silently (matching Python CLI behavior)\n        // Some layers may not have schemas yet, which is acceptable\n        // Don't add warning - just return success\n        if (isTelemetryEnabled && span) {\n          span.setAttribute('schema.valid', true);\n          span.setAttribute('schema.skipped', true);\n        }\n\n        return result;\n      }\n\n      const layerData = layer.toJSON();\n      const valid = validate(layerData);\n\n      if (!valid && validate.errors) {\n        for (const error of validate.errors) {\n          result.addError({\n            layer: layer.name,\n            message: `Schema validation failed: ${this.formatAjvError(error)}`,\n            location: error.instancePath || '/',\n            fixSuggestion: this.generateFixSuggestion(error),\n          });\n        }\n      }\n\n      if (isTelemetryEnabled && span) {\n        span.setAttribute('schema.valid', valid);\n        span.setAttribute('schema.error_count', validate.errors?.length || 0);\n      }\n\n      return result;\n    } finally {\n      endSpan(span);\n    }\n  }\n\n  /**\n   * Format AJV error message\n   */\n  private formatAjvError(error: ErrorObject): string {\n    const keyword = error.keyword;\n    const dataPath = error.instancePath || '/';\n\n    switch (keyword) {\n      case 'type':\n        return `At ${dataPath}: expected ${error.params?.type}, got ${typeof error.data}`;\n      case 'required':\n        return `At ${dataPath}: missing required property '${error.params?.missingProperty}'`;\n      case 'enum':\n        return `At ${dataPath}: value must be one of [${error.params?.allowedValues?.join(', ')}]`;\n      case 'pattern':\n        return `At ${dataPath}: value must match pattern ${error.params?.pattern}`;\n      case 'minLength':\n        return `At ${dataPath}: string must be at least ${error.params?.limit} characters`;\n      case 'maxLength':\n        return `At ${dataPath}: string must be at most ${error.params?.limit} characters`;\n      case 'minimum':\n        return `At ${dataPath}: value must be >= ${error.params?.limit}`;\n      case 'maximum':\n        return `At ${dataPath}: value must be <= ${error.params?.limit}`;\n      case 'additionalProperties':\n        return `At ${dataPath}: unexpected property '${error.params?.additionalProperty}'`;\n      default:\n        return error.message || `Validation failed`;\n    }\n  }\n\n  /**\n   * Generate a fix suggestion based on the error\n   */\n  private generateFixSuggestion(error: ErrorObject): string | undefined {\n    const keyword = error.keyword;\n\n    switch (keyword) {\n      case 'required':\n        return `Add required field: ${error.params?.missingProperty}`;\n      case 'type':\n        return `Expected type ${error.params?.type}`;\n      case 'enum':\n        return `Use one of: ${error.params?.allowedValues?.join(', ')}`;\n      case 'pattern':\n        return `Value must match pattern: ${error.params?.pattern}`;\n      case 'additionalProperties':\n        return `Remove unexpected property: ${error.params?.additionalProperty}`;\n      default:\n        return undefined;\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/validators/semantic-validator.js

@@ -0,0 +1,80 @@
+import { ValidationResult } from "./types.js";
+import { fileURLToPath } from "url";
+import path from "path";
+class SemanticValidator {
+  relationshipCatalog = null;
+  catalogLoaded = !1;
+  constructor() {
+  }
+  /**
+   * Ensure relationship catalog is loaded
+   */
+  async ensureCatalogLoaded() {
+    this.catalogLoaded || (await this.loadRelationshipCatalog(), this.catalogLoaded = !0);
+  }
+  /**
+   * Load the relationship catalog for predicate validation
+   */
+  async loadRelationshipCatalog() {
+    try {
+      const __dirname = path.dirname(fileURLToPath(import.meta.url)), catalogPath = path.join(__dirname, "..", "schemas", "bundled", "relationship-catalog.json");
+      this.relationshipCatalog = await import(catalogPath, { assert: { type: "json" } }).then((m) => m.default);
+    } catch {
+      this.relationshipCatalog = null;
+    }
+  }
+  /**
+   * Validate semantic constraints of a model
+   */
+  async validateModel(model) {
+    const result = new ValidationResult();
+    return await this.ensureCatalogLoaded(), this.validateUniqueIds(model, result), this.validateRelationshipPredicates(model, result), result;
+  }
+  /**
+   * Validate that all element IDs are unique across layers
+   */
+  validateUniqueIds(model, result) {
+    const seenIds = /* @__PURE__ */ new Map();
+    for (const [layerName, layer] of model.layers)
+      for (const element of layer.listElements())
+        seenIds.has(element.id) ? result.addError({
+          layer: layerName,
+          elementId: element.id,
+          message: `Duplicate element ID: '${element.id}' already exists in layer '${seenIds.get(element.id)}'`,
+          fixSuggestion: "Element IDs must be unique across all layers"
+        }) : seenIds.set(element.id, layerName);
+  }
+  /**
+   * Validate relationship predicates against the catalog
+   */
+  validateRelationshipPredicates(model, result) {
+    if (this.relationshipCatalog)
+      for (const [layerName, layer] of model.layers) {
+        const allowedPredicates = this.getAllowedPredicates(layerName);
+        for (const element of layer.listElements())
+          for (const rel of element.relationships || [])
+            allowedPredicates.includes(rel.predicate) || result.addWarning({
+              layer: layerName,
+              elementId: element.id,
+              message: `Unknown relationship predicate '${rel.predicate}' for layer ${layerName}`,
+              fixSuggestion: allowedPredicates.length > 0 ? `Use one of: ${allowedPredicates.join(", ")}` : "Check relationship catalog for valid predicates"
+            });
+      }
+  }
+  /**
+   * Get allowed predicates for a layer from the catalog
+   */
+  getAllowedPredicates(layerName) {
+    if (!this.relationshipCatalog)
+      return [];
+    const layerCatalog = this.relationshipCatalog.layers?.[layerName];
+    if (!layerCatalog)
+      return [];
+    const predicates = layerCatalog.predicates || layerCatalog.relationships || [];
+    return Array.isArray(predicates) ? predicates : Object.keys(predicates || {});
+  }
+}
+export {
+  SemanticValidator
+};
+//# sourceMappingURL=semantic-validator.js.map

package/dist/validators/semantic-validator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/semantic-validator.ts"],
+  "sourcesContent": ["/**\n * Semantic validation for business rules\n */\n\nimport { ValidationResult } from './types.js';\nimport type { Model } from '../core/model.js';\nimport { fileURLToPath } from 'url';\nimport path from 'path';\n\n/**\n * Validator for semantic/business rule validation\n */\nexport class SemanticValidator {\n  private relationshipCatalog: Record<string, any> | null = null;\n  private catalogLoaded: boolean = false;\n\n  constructor() {\n    // Load catalog asynchronously on first use\n  }\n\n  /**\n   * Ensure relationship catalog is loaded\n   */\n  private async ensureCatalogLoaded(): Promise<void> {\n    if (this.catalogLoaded) {\n      return;\n    }\n\n    await this.loadRelationshipCatalog();\n    this.catalogLoaded = true;\n  }\n\n  /**\n   * Load the relationship catalog for predicate validation\n   */\n  private async loadRelationshipCatalog(): Promise<void> {\n    try {\n      const __dirname = path.dirname(fileURLToPath(import.meta.url));\n      const catalogPath = path.join(__dirname, '..', 'schemas', 'bundled', 'relationship-catalog.json');\n      this.relationshipCatalog = await import(catalogPath, { assert: { type: 'json' } }).then(\n        (m) => m.default\n      );\n    } catch {\n      // Catalog load failure is gracefully handled - validation continues without predicate checking\n      this.relationshipCatalog = null;\n    }\n  }\n\n  /**\n   * Validate semantic constraints of a model\n   */\n  async validateModel(model: Model): Promise<ValidationResult> {\n    const result = new ValidationResult();\n\n    await this.ensureCatalogLoaded();\n\n    this.validateUniqueIds(model, result);\n    this.validateRelationshipPredicates(model, result);\n\n    return result;\n  }\n\n  /**\n   * Validate that all element IDs are unique across layers\n   */\n  private validateUniqueIds(model: Model, result: ValidationResult): void {\n    const seenIds = new Map<string, string>(); // id -> layer name\n\n    for (const [layerName, layer] of model.layers) {\n      for (const element of layer.listElements()) {\n        if (seenIds.has(element.id)) {\n          result.addError({\n            layer: layerName,\n            elementId: element.id,\n            message: `Duplicate element ID: '${element.id}' already exists in layer '${seenIds.get(element.id)}'`,\n            fixSuggestion: 'Element IDs must be unique across all layers',\n          });\n        } else {\n          seenIds.set(element.id, layerName);\n        }\n      }\n    }\n  }\n\n  /**\n   * Validate relationship predicates against the catalog\n   */\n  private validateRelationshipPredicates(model: Model, result: ValidationResult): void {\n    if (!this.relationshipCatalog) {\n      // If we can't load the catalog, we can't validate predicates\n      return;\n    }\n\n    for (const [layerName, layer] of model.layers) {\n      const allowedPredicates = this.getAllowedPredicates(layerName);\n\n      for (const element of layer.listElements()) {\n        for (const rel of element.relationships || []) {\n          if (!allowedPredicates.includes(rel.predicate)) {\n            result.addWarning({\n              layer: layerName,\n              elementId: element.id,\n              message: `Unknown relationship predicate '${rel.predicate}' for layer ${layerName}`,\n              fixSuggestion:\n                allowedPredicates.length > 0\n                  ? `Use one of: ${allowedPredicates.join(', ')}`\n                  : 'Check relationship catalog for valid predicates',\n            });\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Get allowed predicates for a layer from the catalog\n   */\n  private getAllowedPredicates(layerName: string): string[] {\n    if (!this.relationshipCatalog) {\n      return [];\n    }\n\n    const layerCatalog = this.relationshipCatalog.layers?.[layerName];\n    if (!layerCatalog) {\n      return [];\n    }\n\n    const predicates = layerCatalog.predicates || layerCatalog.relationships || [];\n    return Array.isArray(predicates) ? predicates : Object.keys(predicates || {});\n  }\n}\n"],
+  "mappings": "AAIA,SAAS,wBAAwB;AAEjC,SAAS,qBAAqB;AAC9B,OAAO,UAAU;AAKX,MAAO,kBAAiB;EACpB,sBAAkD;EAClD,gBAAyB;EAEjC,cAAA;EAEA;;;;EAKQ,MAAM,sBAAmB;AAC/B,IAAI,KAAK,kBAIT,MAAM,KAAK,wBAAuB,GAClC,KAAK,gBAAgB;EACvB;;;;EAKQ,MAAM,0BAAuB;AACnC,QAAI;AACF,YAAM,YAAY,KAAK,QAAQ,cAAc,YAAY,GAAG,CAAC,GACvD,cAAc,KAAK,KAAK,WAAW,MAAM,WAAW,WAAW,2BAA2B;AAChG,WAAK,sBAAsB,MAAM,OAAO,aAAa,EAAE,QAAQ,EAAE,MAAM,OAAM,EAAE,GAAI,KACjF,CAAC,MAAM,EAAE,OAAO;IAEpB,QAAQ;AAEN,WAAK,sBAAsB;IAC7B;EACF;;;;EAKA,MAAM,cAAc,OAAY;AAC9B,UAAM,SAAS,IAAI,iBAAgB;AAEnC,iBAAM,KAAK,oBAAmB,GAE9B,KAAK,kBAAkB,OAAO,MAAM,GACpC,KAAK,+BAA+B,OAAO,MAAM,GAE1C;EACT;;;;EAKQ,kBAAkB,OAAc,QAAwB;AAC9D,UAAM,UAAU,oBAAI,IAAG;AAEvB,eAAW,CAAC,WAAW,KAAK,KAAK,MAAM;AACrC,iBAAW,WAAW,MAAM,aAAY;AACtC,QAAI,QAAQ,IAAI,QAAQ,EAAE,IACxB,OAAO,SAAS;UACd,OAAO;UACP,WAAW,QAAQ;UACnB,SAAS,0BAA0B,QAAQ,EAAE,8BAA8B,QAAQ,IAAI,QAAQ,EAAE,CAAC;UAClG,eAAe;SAChB,IAED,QAAQ,IAAI,QAAQ,IAAI,SAAS;EAIzC;;;;EAKQ,+BAA+B,OAAc,QAAwB;AAC3E,QAAK,KAAK;AAKV,iBAAW,CAAC,WAAW,KAAK,KAAK,MAAM,QAAQ;AAC7C,cAAM,oBAAoB,KAAK,qBAAqB,SAAS;AAE7D,mBAAW,WAAW,MAAM,aAAY;AACtC,qBAAW,OAAO,QAAQ,iBAAiB,CAAA;AACzC,YAAK,kBAAkB,SAAS,IAAI,SAAS,KAC3C,OAAO,WAAW;cAChB,OAAO;cACP,WAAW,QAAQ;cACnB,SAAS,mCAAmC,IAAI,SAAS,eAAe,SAAS;cACjF,eACE,kBAAkB,SAAS,IACvB,eAAe,kBAAkB,KAAK,IAAI,CAAC,KAC3C;aACP;MAIT;EACF;;;;EAKQ,qBAAqB,WAAiB;AAC5C,QAAI,CAAC,KAAK;AACR,aAAO,CAAA;AAGT,UAAM,eAAe,KAAK,oBAAoB,SAAS,SAAS;AAChE,QAAI,CAAC;AACH,aAAO,CAAA;AAGT,UAAM,aAAa,aAAa,cAAc,aAAa,iBAAiB,CAAA;AAC5E,WAAO,MAAM,QAAQ,UAAU,IAAI,aAAa,OAAO,KAAK,cAAc,CAAA,CAAE;EAC9E;;",
+  "names": []
+}

package/dist/validators/types.js

@@ -0,0 +1,48 @@
+class ValidationResult {
+  errors = [];
+  warnings = [];
+  /**
+   * Check if validation passed (no errors)
+   */
+  isValid() {
+    return this.errors.length === 0;
+  }
+  /**
+   * Add an error to the result
+   */
+  addError(issue) {
+    this.errors.push({ ...issue, severity: "error" });
+  }
+  /**
+   * Add a warning to the result
+   */
+  addWarning(issue) {
+    this.warnings.push({ ...issue, severity: "warning" });
+  }
+  /**
+   * Merge another validation result into this one
+   */
+  merge(other, prefix) {
+    const addPrefix = (issue) => ({
+      ...issue,
+      message: prefix ? `${prefix}: ${issue.message}` : issue.message
+    });
+    this.errors.push(...other.errors.map(addPrefix)), this.warnings.push(...other.warnings.map(addPrefix));
+  }
+  /**
+   * Convert to dictionary representation
+   */
+  toDict() {
+    return {
+      valid: this.isValid(),
+      errors: this.errors,
+      warnings: this.warnings,
+      errorCount: this.errors.length,
+      warningCount: this.warnings.length
+    };
+  }
+}
+export {
+  ValidationResult
+};
+//# sourceMappingURL=types.js.map

package/dist/validators/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/types.ts"],
+  "sourcesContent": ["/**\n * Validation result types and classes\n */\n\n/**\n * A single validation issue\n */\nexport interface ValidationIssue {\n  layer: string;\n  elementId?: string;\n  message: string;\n  severity: 'error' | 'warning';\n  location?: string;\n  fixSuggestion?: string;\n}\n\n/**\n * Result of a validation operation\n */\nexport class ValidationResult {\n  errors: ValidationIssue[] = [];\n  warnings: ValidationIssue[] = [];\n\n  /**\n   * Check if validation passed (no errors)\n   */\n  isValid(): boolean {\n    return this.errors.length === 0;\n  }\n\n  /**\n   * Add an error to the result\n   */\n  addError(issue: Omit<ValidationIssue, 'severity'>): void {\n    this.errors.push({ ...issue, severity: 'error' });\n  }\n\n  /**\n   * Add a warning to the result\n   */\n  addWarning(issue: Omit<ValidationIssue, 'severity'>): void {\n    this.warnings.push({ ...issue, severity: 'warning' });\n  }\n\n  /**\n   * Merge another validation result into this one\n   */\n  merge(other: ValidationResult, prefix?: string): void {\n    const addPrefix = (issue: ValidationIssue): ValidationIssue => ({\n      ...issue,\n      message: prefix ? `${prefix}: ${issue.message}` : issue.message,\n    });\n\n    this.errors.push(...other.errors.map(addPrefix));\n    this.warnings.push(...other.warnings.map(addPrefix));\n  }\n\n  /**\n   * Convert to dictionary representation\n   */\n  toDict(): Record<string, unknown> {\n    return {\n      valid: this.isValid(),\n      errors: this.errors,\n      warnings: this.warnings,\n      errorCount: this.errors.length,\n      warningCount: this.warnings.length,\n    };\n  }\n}\n"],
+  "mappings": "AAmBM,MAAO,iBAAgB;EAC3B,SAA4B,CAAA;EAC5B,WAA8B,CAAA;;;;EAK9B,UAAO;AACL,WAAO,KAAK,OAAO,WAAW;EAChC;;;;EAKA,SAAS,OAAwC;AAC/C,SAAK,OAAO,KAAK,EAAE,GAAG,OAAO,UAAU,QAAO,CAAE;EAClD;;;;EAKA,WAAW,OAAwC;AACjD,SAAK,SAAS,KAAK,EAAE,GAAG,OAAO,UAAU,UAAS,CAAE;EACtD;;;;EAKA,MAAM,OAAyB,QAAe;AAC5C,UAAM,YAAY,CAAC,WAA6C;MAC9D,GAAG;MACH,SAAS,SAAS,GAAG,MAAM,KAAK,MAAM,OAAO,KAAK,MAAM;;AAG1D,SAAK,OAAO,KAAK,GAAG,MAAM,OAAO,IAAI,SAAS,CAAC,GAC/C,KAAK,SAAS,KAAK,GAAG,MAAM,SAAS,IAAI,SAAS,CAAC;EACrD;;;;EAKA,SAAM;AACJ,WAAO;MACL,OAAO,KAAK,QAAO;MACnB,QAAQ,KAAK;MACb,UAAU,KAAK;MACf,YAAY,KAAK,OAAO;MACxB,cAAc,KAAK,SAAS;;EAEhC;;",
+  "names": []
+}

package/dist/validators/validator.js

@@ -0,0 +1,67 @@
+import { ValidationResult } from "./types.js";
+import { SchemaValidator } from "./schema-validator.js";
+import { NamingValidator } from "./naming-validator.js";
+import { ReferenceValidator } from "./reference-validator.js";
+import { SemanticValidator } from "./semantic-validator.js";
+import { startSpan, endSpan } from "../telemetry/index.js";
+const isTelemetryEnabled = !1;
+class Validator {
+  schemaValidator;
+  namingValidator;
+  referenceValidator;
+  semanticValidator;
+  constructor() {
+    this.schemaValidator = new SchemaValidator(), this.namingValidator = new NamingValidator(), this.referenceValidator = new ReferenceValidator(), this.semanticValidator = new SemanticValidator();
+  }
+  /**
+   * Validate a complete model through all 4 stages
+   */
+  async validateModel(model) {
+    const rootSpan = isTelemetryEnabled ? startSpan("model.validate", {
+      "model.path": model.rootPath
+    }) : null, result = new ValidationResult();
+    try {
+      const schemaStageSpan = isTelemetryEnabled ? startSpan("validation.stage.schema") : null;
+      try {
+        for (const layer of model.layers.values()) {
+          const schemaResult = await this.schemaValidator.validateLayer(layer);
+          result.merge(schemaResult, `[Schema/${layer.name}]`);
+        }
+        isTelemetryEnabled && schemaStageSpan && schemaStageSpan.setAttribute("validation.error_count", result.errors.length);
+      } finally {
+        endSpan(schemaStageSpan);
+      }
+      const namingStageSpan = isTelemetryEnabled ? startSpan("validation.stage.naming") : null;
+      try {
+        for (const layer of model.layers.values()) {
+          const namingResult = this.namingValidator.validateLayer(layer);
+          result.merge(namingResult, `[Naming/${layer.name}]`);
+        }
+        isTelemetryEnabled && namingStageSpan && namingStageSpan.setAttribute("validation.error_count", result.errors.length);
+      } finally {
+        endSpan(namingStageSpan);
+      }
+      const refStageSpan = isTelemetryEnabled ? startSpan("validation.stage.reference") : null;
+      try {
+        const referenceResult = this.referenceValidator.validateModel(model);
+        result.merge(referenceResult, "[References]"), isTelemetryEnabled && refStageSpan && refStageSpan.setAttribute("validation.error_count", result.errors.length);
+      } finally {
+        endSpan(refStageSpan);
+      }
+      const semanticStageSpan = isTelemetryEnabled ? startSpan("validation.stage.semantic") : null;
+      try {
+        const semanticResult = await this.semanticValidator.validateModel(model);
+        result.merge(semanticResult, "[Semantic]"), isTelemetryEnabled && semanticStageSpan && semanticStageSpan.setAttribute("validation.error_count", result.errors.length);
+      } finally {
+        endSpan(semanticStageSpan);
+      }
+      return isTelemetryEnabled && rootSpan && (rootSpan.setAttribute("validation.valid", result.isValid()), rootSpan.setAttribute("validation.error_count", result.errors.length)), result;
+    } finally {
+      endSpan(rootSpan);
+    }
+  }
+}
+export {
+  Validator
+};
+//# sourceMappingURL=validator.js.map

package/dist/validators/validator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/validator.ts"],
+  "sourcesContent": ["/**\n * Unified validator orchestrating the 4-stage validation pipeline\n */\n\nimport { ValidationResult } from './types.js';\nimport { SchemaValidator } from './schema-validator.js';\nimport { NamingValidator } from './naming-validator.js';\nimport { ReferenceValidator } from './reference-validator.js';\nimport { SemanticValidator } from './semantic-validator.js';\nimport type { Model } from '../core/model.js';\nimport { startSpan, endSpan } from '../telemetry/index.js';\n\n// Fallback for runtime environments where TELEMETRY_ENABLED is not defined by esbuild\ndeclare const TELEMETRY_ENABLED: boolean | undefined;\nconst isTelemetryEnabled = typeof TELEMETRY_ENABLED !== 'undefined' ? TELEMETRY_ENABLED : false;\n\n/**\n * Unified validator implementing the 4-stage validation pipeline:\n * 1. Schema validation (AJV)\n * 2. Naming validation (element ID format)\n * 3. Reference validation (cross-layer integrity)\n * 4. Semantic validation (business rules)\n */\nexport class Validator {\n  private schemaValidator: SchemaValidator;\n  private namingValidator: NamingValidator;\n  private referenceValidator: ReferenceValidator;\n  private semanticValidator: SemanticValidator;\n\n  constructor() {\n    this.schemaValidator = new SchemaValidator();\n    this.namingValidator = new NamingValidator();\n    this.referenceValidator = new ReferenceValidator();\n    this.semanticValidator = new SemanticValidator();\n  }\n\n  /**\n   * Validate a complete model through all 4 stages\n   */\n  async validateModel(model: Model): Promise<ValidationResult> {\n    const rootSpan = isTelemetryEnabled ? startSpan('model.validate', {\n      'model.path': model.rootPath,\n    }) : null;\n\n    const result = new ValidationResult();\n\n    try {\n      // Stage 1: Schema validation\n      const schemaStageSpan = isTelemetryEnabled ? startSpan('validation.stage.schema') : null;\n      try {\n        for (const layer of model.layers.values()) {\n          const schemaResult = await this.schemaValidator.validateLayer(layer);\n          result.merge(schemaResult, `[Schema/${layer.name}]`);\n        }\n\n        if (isTelemetryEnabled && schemaStageSpan) {\n          schemaStageSpan.setAttribute('validation.error_count', result.errors.length);\n        }\n      } finally {\n        endSpan(schemaStageSpan);\n      }\n\n      // Stage 2: Naming validation\n      const namingStageSpan = isTelemetryEnabled ? startSpan('validation.stage.naming') : null;\n      try {\n        for (const layer of model.layers.values()) {\n          const namingResult = this.namingValidator.validateLayer(layer);\n          result.merge(namingResult, `[Naming/${layer.name}]`);\n        }\n\n        if (isTelemetryEnabled && namingStageSpan) {\n          namingStageSpan.setAttribute('validation.error_count', result.errors.length);\n        }\n      } finally {\n        endSpan(namingStageSpan);\n      }\n\n      // Stage 3: Reference validation\n      const refStageSpan = isTelemetryEnabled ? startSpan('validation.stage.reference') : null;\n      try {\n        const referenceResult = this.referenceValidator.validateModel(model);\n        result.merge(referenceResult, '[References]');\n\n        if (isTelemetryEnabled && refStageSpan) {\n          refStageSpan.setAttribute('validation.error_count', result.errors.length);\n        }\n      } finally {\n        endSpan(refStageSpan);\n      }\n\n      // Stage 4: Semantic validation\n      const semanticStageSpan = isTelemetryEnabled ? startSpan('validation.stage.semantic') : null;\n      try {\n        const semanticResult = await this.semanticValidator.validateModel(model);\n        result.merge(semanticResult, '[Semantic]');\n\n        if (isTelemetryEnabled && semanticStageSpan) {\n          semanticStageSpan.setAttribute('validation.error_count', result.errors.length);\n        }\n      } finally {\n        endSpan(semanticStageSpan);\n      }\n\n      if (isTelemetryEnabled && rootSpan) {\n        rootSpan.setAttribute('validation.valid', result.isValid());\n        rootSpan.setAttribute('validation.error_count', result.errors.length);\n      }\n\n      return result;\n    } finally {\n      endSpan(rootSpan);\n    }\n  }\n}\n"],
+  "mappings": "AAIA,SAAS,wBAAwB;AACjC,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AACnC,SAAS,yBAAyB;AAElC,SAAS,WAAW,eAAe;AAInC,MAAM,qBAAgE;AAShE,MAAO,UAAS;EACZ;EACA;EACA;EACA;EAER,cAAA;AACE,SAAK,kBAAkB,IAAI,gBAAe,GAC1C,KAAK,kBAAkB,IAAI,gBAAe,GAC1C,KAAK,qBAAqB,IAAI,mBAAkB,GAChD,KAAK,oBAAoB,IAAI,kBAAiB;EAChD;;;;EAKA,MAAM,cAAc,OAAY;AAC9B,UAAM,WAAW,qBAAqB,UAAU,kBAAkB;MAChE,cAAc,MAAM;KACrB,IAAI,MAEC,SAAS,IAAI,iBAAgB;AAEnC,QAAI;AAEF,YAAM,kBAAkB,qBAAqB,UAAU,yBAAyB,IAAI;AACpF,UAAI;AACF,mBAAW,SAAS,MAAM,OAAO,OAAM,GAAI;AACzC,gBAAM,eAAe,MAAM,KAAK,gBAAgB,cAAc,KAAK;AACnE,iBAAO,MAAM,cAAc,WAAW,MAAM,IAAI,GAAG;QACrD;AAEA,QAAI,sBAAsB,mBACxB,gBAAgB,aAAa,0BAA0B,OAAO,OAAO,MAAM;MAE/E;AACE,gBAAQ,eAAe;MACzB;AAGA,YAAM,kBAAkB,qBAAqB,UAAU,yBAAyB,IAAI;AACpF,UAAI;AACF,mBAAW,SAAS,MAAM,OAAO,OAAM,GAAI;AACzC,gBAAM,eAAe,KAAK,gBAAgB,cAAc,KAAK;AAC7D,iBAAO,MAAM,cAAc,WAAW,MAAM,IAAI,GAAG;QACrD;AAEA,QAAI,sBAAsB,mBACxB,gBAAgB,aAAa,0BAA0B,OAAO,OAAO,MAAM;MAE/E;AACE,gBAAQ,eAAe;MACzB;AAGA,YAAM,eAAe,qBAAqB,UAAU,4BAA4B,IAAI;AACpF,UAAI;AACF,cAAM,kBAAkB,KAAK,mBAAmB,cAAc,KAAK;AACnE,eAAO,MAAM,iBAAiB,cAAc,GAExC,sBAAsB,gBACxB,aAAa,aAAa,0BAA0B,OAAO,OAAO,MAAM;MAE5E;AACE,gBAAQ,YAAY;MACtB;AAGA,YAAM,oBAAoB,qBAAqB,UAAU,2BAA2B,IAAI;AACxF,UAAI;AACF,cAAM,iBAAiB,MAAM,KAAK,kBAAkB,cAAc,KAAK;AACvE,eAAO,MAAM,gBAAgB,YAAY,GAErC,sBAAsB,qBACxB,kBAAkB,aAAa,0BAA0B,OAAO,OAAO,MAAM;MAEjF;AACE,gBAAQ,iBAAiB;MAC3B;AAEA,aAAI,sBAAsB,aACxB,SAAS,aAAa,oBAAoB,OAAO,QAAO,CAAE,GAC1D,SAAS,aAAa,0BAA0B,OAAO,OAAO,MAAM,IAG/D;IACT;AACE,cAAQ,QAAQ;IAClB;EACF;;",
+  "names": []
+}