@unispechq/unispec-core 0.3.2 → 0.3.4

package/dist/normalizer/core.d.ts

@@ -1,5 +1,5 @@
-import type { UniSpecDocument } from "../types/index.js";
-import type { NormalizeOptions } from "./types.js";
+import type { UniSpecDocument } from "@/types";
+import type { NormalizeOptions } from "./types";
 /**
  * Normalize a UniSpec document into a canonical, deterministic form.
  *

package/dist/normalizer/core.js

@@ -1,7 +1,7 @@
-import { normalizeGraphqlOperations } from "./graphql-normalizer.js";
-import { normalizeRestRoutes } from "./rest-normalizer.js";
-import { normalizeValue } from "./utils.js";
-import { normalizeWebSocket } from "./websocket-normalizer.js";
+import { normalizeGraphqlOperations } from "./graphql-normalizer";
+import { normalizeRestRoutes } from "./rest-normalizer";
+import { normalizeValue } from "./utils";
+import { normalizeWebSocket } from "./websocket-normalizer";
 /**
  * Normalize a UniSpec document into a canonical, deterministic form.
  *
@@ -24,6 +24,11 @@ import { normalizeWebSocket } from "./websocket-normalizer.js";
  * @returns The normalized UniSpec document
  */
 export function normalizeUniSpec(doc, _options = {}) {
-    const normalized = normalizeValue(doc);
-    return normalizeWebSocket(normalizeGraphqlOperations(normalizeRestRoutes(normalized)));
+    // Apply protocol-specific normalizations first
+    const restNormalized = normalizeRestRoutes(doc);
+    const graphqlNormalized = normalizeGraphqlOperations(restNormalized);
+    const finalNormalized = normalizeWebSocket(graphqlNormalized);
+    // Always apply structural normalization to ensure immutability
+    // and consistent key sorting, even if no protocol changes were made
+    return normalizeValue(finalNormalized);
 }

package/dist/normalizer/graphql-normalizer.d.ts

@@ -1,4 +1,4 @@
-import type { UniSpecDocument } from "../types/index.js";
+import type { UniSpecDocument } from "@/types";
 /**
  * Normalize GraphQL operations by sorting them lexicographically by name within each operation type.
  *

package/dist/normalizer/index.d.ts

@@ -1,2 +1,2 @@
-export { normalizeUniSpec } from "./core.js";
-export type { NormalizeOptions } from "./types.js";
+export { normalizeUniSpec } from "./core";
+export type { NormalizeOptions } from "./types";

package/dist/normalizer/index.js

@@ -1,3 +1,3 @@
 // Re-export types
 // Re-export core function
-export { normalizeUniSpec } from "./core.js";
+export { normalizeUniSpec } from "./core";

package/dist/normalizer/rest-normalizer.d.ts

@@ -1,4 +1,4 @@
-import type { UniSpecDocument } from "../types/index.js";
+import type { UniSpecDocument } from "@/types";
 /**
  * Normalize REST routes by sorting them lexicographically by name or path+method.
  *

package/dist/normalizer/types.d.ts

@@ -1,4 +1,4 @@
-import type { UniSpecGraphQLProtocol, UniSpecRestProtocol, UniSpecWebSocketProtocol } from "../types/index.js";
+import type { UniSpecGraphQLProtocol, UniSpecRestProtocol, UniSpecWebSocketProtocol } from "@/types";
 export type NormalizeOptions = Record<string, never>;
 export interface UniSpecServiceProtocolsLike {
     rest?: UniSpecRestProtocol;

package/dist/normalizer/utils.d.ts

@@ -6,9 +6,12 @@
  */
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 /**
- * Recursively normalize a value by sorting object keys lexicographically.
+ * Normalize a value by sorting object keys lexicographically (recursive).
+ * Always creates new objects to ensure immutability.
+ * Handles circular references gracefully.
  *
  * @param value - The value to normalize
- * @returns The normalized value
+ * @param seen - WeakSet of already seen objects for circular reference detection
+ * @returns The normalized value (always a new object for objects/arrays)
  */
-export declare function normalizeValue(value: unknown): unknown;
+export declare function normalizeValue(value: unknown, seen?: WeakSet<object>): unknown;

package/dist/normalizer/utils.js

@@ -8,20 +8,36 @@ export function isPlainObject(value) {
     return Object.prototype.toString.call(value) === "[object Object]";
 }
 /**
- * Recursively normalize a value by sorting object keys lexicographically.
+ * Normalize a value by sorting object keys lexicographically (recursive).
+ * Always creates new objects to ensure immutability.
+ * Handles circular references gracefully.
  *
  * @param value - The value to normalize
- * @returns The normalized value
+ * @param seen - WeakSet of already seen objects for circular reference detection
+ * @returns The normalized value (always a new object for objects/arrays)
  */
-export function normalizeValue(value) {
+export function normalizeValue(value, seen = new WeakSet()) {
+    // Handle primitives and null/undefined
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
     if (Array.isArray(value)) {
-        return value.map((item) => normalizeValue(item));
+        // Always create new array with recursively normalized items
+        return value.map((item) => normalizeValue(item, seen));
     }
     if (isPlainObject(value)) {
-        const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+        // Check for circular references
+        if (seen.has(value)) {
+            // Return a placeholder for circular references to avoid infinite recursion
+            return "[Circular]";
+        }
+        seen.add(value);
+        const entries = Object.entries(value);
+        // Always create new object with sorted keys and recursively normalized values
+        const sortedEntries = entries.sort(([a], [b]) => a.localeCompare(b));
         const normalized = {};
-        for (const [key, val] of entries) {
-            normalized[key] = normalizeValue(val);
+        for (const [key, val] of sortedEntries) {
+            normalized[key] = normalizeValue(val, seen);
         }
         return normalized;
     }

package/dist/normalizer/websocket-normalizer.d.ts

@@ -1,4 +1,4 @@
-import type { UniSpecDocument } from "../types/index.js";
+import type { UniSpecDocument } from "@/types";
 /**
  * Normalize WebSocket channels and messages by sorting them lexicographically by name.
  *

package/dist/optimizer/core.d.ts

@@ -1,5 +1,5 @@
-import type { UniSpecDocument } from "../types/index.js";
-import type { OptimizationOptions, OptimizationReport, OptimizationResult } from "./types.js";
+import type { UniSpecDocument } from "@/types";
+import type { OptimizationOptions, OptimizationReport, OptimizationResult } from "./types";
 /**
  * Optimize a UniSpec document with various optimization strategies.
  *

package/dist/optimizer/core.js

@@ -1,4 +1,5 @@
-import { compressSchemaReferences, deduplicateSchemas, removeOrphanedSchemas, sortSchemas, } from "./optimization-functions.js";
+import { normalizeSchemaRef } from "@/schemas";
+import { compressSchemaReferences, deduplicateSchemas, removeOrphanedSchemas, sortSchemas, } from "./optimization-functions";
 /**
  * Optimize a UniSpec document with various optimization strategies.
  *
@@ -20,12 +21,6 @@ export function optimizeDocument(doc, options = {}) {
     }
     let deduplicatedCount = 0;
     // Apply optimizations in order
-    if (options.removeUnusedSchemas === true) {
-        const removed = removeOrphanedSchemas(optimizedDoc);
-        if (removed.length > 0) {
-            changes.push(`Removed ${removed.length} orphaned schemas: ${removed.join(", ")}`);
-        }
-    }
     if (options.dedupeSchemas !== false) {
         const dedupResult = deduplicateSchemas(optimizedDoc);
         if (dedupResult.removedSchemas.length > 0) {
@@ -34,6 +29,12 @@ export function optimizeDocument(doc, options = {}) {
             deduplicatedCount = dedupResult.removedSchemas.length;
         }
     }
+    if (options.removeUnusedSchemas === true) {
+        const removed = removeOrphanedSchemas(optimizedDoc);
+        if (removed.length > 0) {
+            changes.push(`Removed ${removed.length} orphaned schemas: ${removed.join(", ")}`);
+        }
+    }
     if (options.sortSchemas !== false) {
         const sortedCount = sortSchemas(optimizedDoc);
         if (sortedCount > 0) {
@@ -81,7 +82,7 @@ export function generateOptimizationReport(doc) {
             return;
         for (const [key, value] of Object.entries(obj)) {
             if (key === "schemaRef" && typeof value === "string") {
-                const schemaName = value.split("/").pop(); // Simple extraction for analysis
+                const schemaName = normalizeSchemaRef(value);
                 if (schemaName)
                     referencedSchemas.add(schemaName);
             }
@@ -101,11 +102,35 @@ export function generateOptimizationReport(doc) {
     }
     const totalSchemas = Object.keys(doc.service?.schemas || {}).length;
     const potentialReduction = orphaned.length + dedupResult.removedSchemas.length;
-    return {
+    // Calculate reference compression savings only if there are schema references
+    let referenceCompression = 0;
+    if (totalSchemas > 0) {
+        // Count actual schema references to estimate compression savings
+        let referenceCount = 0;
+        function countReferences(obj) {
+            if (!obj || typeof obj !== "object")
+                return;
+            for (const [key, value] of Object.entries(obj)) {
+                if (key === "schemaRef" && typeof value === "string") {
+                    referenceCount++;
+                }
+                else if (typeof value === "object" && value !== null) {
+                    countReferences(value);
+                }
+            }
+        }
+        countReferences(doc);
+        // Only estimate compression if there are references to compress
+        if (referenceCount > 1) {
+            referenceCompression = Math.min(referenceCount * 0.1, totalSchemas * 0.1);
+        }
+    }
+    const result = {
         recommendations,
         potentialSavings: {
             schemaReduction: potentialReduction,
-            referenceCompression: totalSchemas * 0.1, // Estimate 10% compression
+            referenceCompression,
         },
     };
+    return result;
 }

package/dist/optimizer/index.d.ts

@@ -1,4 +1,4 @@
-export { generateOptimizationReport, optimizeDocument, } from "./core.js";
-export { compressSchemaReferences, deduplicateSchemas, removeOrphanedSchemas, sortSchemas, } from "./optimization-functions.js";
-export type { DeduplicationResult, OptimizationOptions, OptimizationReport, OptimizationResult, } from "./types.js";
-export { compressReference } from "./utils.js";
+export { generateOptimizationReport, optimizeDocument, } from "./core";
+export { compressSchemaReferences, deduplicateSchemas, removeOrphanedSchemas, sortSchemas, } from "./optimization-functions";
+export type { DeduplicationResult, OptimizationOptions, OptimizationReport, OptimizationResult, } from "./types";
+export { compressReference } from "./utils";

package/dist/optimizer/index.js

@@ -1,7 +1,7 @@
 // Export types
 // Export core functions
-export { generateOptimizationReport, optimizeDocument, } from "./core.js";
+export { generateOptimizationReport, optimizeDocument, } from "./core";
 // Export optimization functions
-export { compressSchemaReferences, deduplicateSchemas, removeOrphanedSchemas, sortSchemas, } from "./optimization-functions.js";
+export { compressSchemaReferences, deduplicateSchemas, removeOrphanedSchemas, sortSchemas, } from "./optimization-functions";
 // Export utilities
-export { compressReference } from "./utils.js";
+export { compressReference } from "./utils";

package/dist/optimizer/optimization-functions.d.ts

@@ -1,5 +1,5 @@
-import type { UniSpecDocument } from "../types/index.js";
-import type { DeduplicationResult } from "./types.js";
+import type { UniSpecDocument } from "@/types";
+import type { DeduplicationResult } from "./types";
 /**
  * Remove duplicate schemas from a UniSpec document.
  * Duplicates are identified by identical JSON Schema content.

package/dist/optimizer/optimization-functions.js

@@ -1,5 +1,5 @@
-import { normalizeSchemaRef, stableStringify } from "../schemas/index.js";
-import { compressReference } from "./utils.js";
+import { normalizeSchemaRef, stableStringify } from "@/schemas";
+import { compressReference } from "./utils";
 /**
  * Remove duplicate schemas from a UniSpec document.
  * Duplicates are identified by identical JSON Schema content.

package/dist/optimizer/types.d.ts

@@ -1,4 +1,4 @@
-import type { UniSpecDocument } from "../types/index.js";
+import type { UniSpecDocument } from "@/types";
 export interface OptimizationOptions {
     dedupeSchemas?: boolean;
     sortSchemas?: boolean;

package/dist/schemas/dedupe.d.ts

@@ -1,4 +1,4 @@
-import type { UniSpecDocument } from "../types/index.js";
+import type { UniSpecDocument } from "@/types";
 /**
  * Remove duplicate schemas from a UniSpec document.
  * Duplicates are identified by identical JSON Schema content.

package/dist/schemas/dedupe.js

@@ -1,4 +1,4 @@
-import { normalizeSchemaRef, stableStringify } from "./utils.js";
+import { normalizeSchemaRef, stableStringify } from "./utils";
 function updateSchemaRefs(doc, mapping) {
     const rest = doc.service?.protocols?.rest;
     const websocket = doc.service?.protocols?.websocket;
@@ -72,26 +72,39 @@ function updateSchemaRefs(doc, mapping) {
  * @param doc - The UniSpec document to deduplicate
  */
 export function dedupeSchemas(doc) {
-    if (!doc.service?.schemas)
+    if (!doc?.service?.schemas || typeof doc.service.schemas !== "object")
         return;
-    const names = Object.keys(doc.service.schemas);
+    const schemas = doc.service.schemas;
     const hashToName = new Map();
-    const renameMap = {};
-    for (const name of names) {
-        const schema = doc.service.schemas[name];
+    const toDelete = [];
+    // Find duplicates
+    for (const name of Object.keys(schemas)) {
+        const schema = schemas[name];
         const hash = stableStringify(schema?.jsonSchema ?? null);
         const existing = hashToName.get(hash);
         if (!existing) {
             hashToName.set(hash, name);
-            continue;
         }
-        renameMap[name] = existing;
+        else {
+            // Mark for deletion - keep the first one encountered
+            toDelete.push(name);
+        }
     }
-    const duplicates = Object.keys(renameMap);
-    if (duplicates.length === 0)
-        return;
-    updateSchemaRefs(doc, renameMap);
-    for (const dup of duplicates) {
-        delete doc.service.schemas[dup];
+    // Update references before deleting
+    if (toDelete.length > 0) {
+        const renameMap = {};
+        for (const dup of toDelete) {
+            const schema = schemas[dup];
+            const hash = stableStringify(schema?.jsonSchema ?? null);
+            const existing = hashToName.get(hash);
+            if (existing) {
+                renameMap[dup] = existing;
+            }
+        }
+        updateSchemaRefs(doc, renameMap);
+        // Delete duplicates
+        for (const dup of toDelete) {
+            delete schemas[dup];
+        }
     }
 }

package/dist/schemas/index.d.ts

@@ -1,3 +1,3 @@
-export { dedupeSchemas } from "./dedupe.js";
-export { registerSchema, resolveSchemaRef } from "./resolver.js";
-export { normalizeSchemaRef, stableStringify } from "./utils.js";
+export { dedupeSchemas } from "./dedupe";
+export { registerSchema, resolveSchemaRef } from "./resolver";
+export { normalizeSchemaRef, stableStringify } from "./utils";

package/dist/schemas/index.js

@@ -1,6 +1,6 @@
 // Export utility functions
 // Export deduplication functions
-export { dedupeSchemas } from "./dedupe.js";
+export { dedupeSchemas } from "./dedupe";
 // Export resolver functions
-export { registerSchema, resolveSchemaRef } from "./resolver.js";
-export { normalizeSchemaRef, stableStringify } from "./utils.js";
+export { registerSchema, resolveSchemaRef } from "./resolver";
+export { normalizeSchemaRef, stableStringify } from "./utils";

package/dist/schemas/resolver.d.ts

@@ -1,4 +1,4 @@
-import type { UniSpecDocument, UniSpecSchemaDefinition } from "../types/index.js";
+import type { UniSpecDocument, UniSpecSchemaDefinition } from "@/types";
 /**
  * Resolve a schema reference to its definition in a UniSpec document.
  *

package/dist/schemas/resolver.js

@@ -1,4 +1,4 @@
-import { normalizeSchemaRef } from "./utils.js";
+import { normalizeSchemaRef } from "./utils";
 /**
  * Resolve a schema reference to its definition in a UniSpec document.
  *
@@ -7,6 +7,8 @@ import { normalizeSchemaRef } from "./utils.js";
  * @returns The schema definition or undefined if not found
  */
 export function resolveSchemaRef(doc, ref) {
+    if (!doc)
+        return undefined;
     const name = normalizeSchemaRef(ref);
     if (!name)
         return undefined;
@@ -29,7 +31,6 @@ export function registerSchema(doc, name, jsonSchema) {
         doc.service.schemas = {};
     }
     const definition = {
-        name,
         jsonSchema,
     };
     doc.service.schemas[name] = definition;

package/dist/types/index.d.ts

@@ -147,7 +147,8 @@ export interface UniSpecCustomValidator {
     rule: string;
     message: string;
 }
-export interface UniSpecSchemaDefinition extends UniSpecNamedItem, UniSpecDeprecatedItem {
+export interface UniSpecSchemaDefinition extends UniSpecDeprecatedItem {
+    description?: string;
     examples?: unknown[];
     jsonSchema: Record<string, unknown>;
     validation?: UniSpecSchemaValidation;

package/dist/validator/ajv-validator.d.ts

@@ -1,4 +1,4 @@
-import type { AjvValidateFn, ValidateOptions } from "./types.js";
+import type { AjvValidateFn, ValidateOptions } from "./types";
 declare let cached: {
     validateUniSpecFn: AjvValidateFn;
     validateUniSpecTestsFn?: AjvValidateFn;

package/dist/validator/ajv-validator.js

@@ -1,5 +1,5 @@
 import Ajv2020 from "ajv/dist/2020.js";
-import { GENERATED_SCHEMAS } from "../generated-schemas.js";
+import { GENERATED_SCHEMAS } from "@/generated-schemas";
 let cached = null;
 /**
  * Load default schemas from generated schemas.

package/dist/validator/config-validator-main.d.ts

@@ -1,5 +1,5 @@
-import type { UniSpecConfigDocument, ValidationResult } from "../types/index.js";
-import type { ValidateOptions } from "./types.js";
+import type { UniSpecConfigDocument, ValidationResult } from "@/types";
+import type { ValidateOptions } from "./types";
 /**
  * Validate a UniSpec Config document against the UniSpec Config JSON Schema.
  *

package/dist/validator/config-validator-main.js

@@ -1,7 +1,7 @@
-import { ErrorFactory } from "../errors/index.js";
-import { getValidator } from "./ajv-validator.js";
-import { validateConfigCustomRules } from "./config-validator.js";
-import { createValidator } from "./validator-factory.js";
+import { ErrorFactory } from "@/errors";
+import { getValidator } from "./ajv-validator";
+import { validateConfigCustomRules } from "./config-validator";
+import { createValidator } from "./validator-factory";
 /**
  * Validate a UniSpec Config document against the UniSpec Config JSON Schema.
  *

package/dist/validator/config-validator.d.ts

@@ -1,4 +1,4 @@
-import type { UniSpecConfigDocument, ValidationError } from "../types/index.js";
+import type { UniSpecConfigDocument, ValidationError } from "@/types";
 /**
  * Custom validation for UniSpec Config documents.
  */

package/dist/validator/config-validator.js

@@ -1,4 +1,4 @@
-import { ErrorFactory } from "../errors/index.js";
+import { ErrorFactory } from "@/errors";
 /**
  * Custom validation for UniSpec Config documents.
  */

package/dist/validator/index.d.ts

@@ -1,10 +1,10 @@
-export { clearValidatorCache, getValidator } from "./ajv-validator.js";
-export { validateUniSpecConfig } from "./config-validator-main.js";
-export type { ReferenceValidationOptions, ReferenceValidationResult, } from "./reference-validator.js";
-export { validateReferences } from "./reference-validator.js";
-export type { SemanticValidationOptions, SemanticValidationResult, } from "./semantic-validator.js";
-export { validateSemantic } from "./semantic-validator.js";
-export { validateUniSpecTests } from "./tests-validator.js";
-export type { Ajv2020, AjvValidateFn, ExtendedValidationResult, SchemaProvider, ValidateOptions, ValidatorSchemas, } from "./types.js";
-export { validateUniSpec } from "./unispec-validator.js";
-export { createValidator, mapAjvErrors } from "./validator-factory.js";
+export { clearValidatorCache, getValidator } from "./ajv-validator";
+export { validateUniSpecConfig } from "./config-validator-main";
+export type { ReferenceValidationOptions, ReferenceValidationResult, } from "./reference-validator";
+export { validateReferences } from "./reference-validator";
+export type { SemanticValidationOptions, SemanticValidationResult, } from "./semantic-validator";
+export { validateSemantic } from "./semantic-validator";
+export { validateUniSpecTests } from "./tests-validator";
+export type { Ajv2020, AjvValidateFn, ExtendedValidationResult, SchemaProvider, ValidateOptions, ValidatorSchemas, } from "./types";
+export { validateUniSpec } from "./unispec-validator";
+export { createValidator, mapAjvErrors } from "./validator-factory";

package/dist/validator/index.js

@@ -1,11 +1,11 @@
 // Export all validation functions and types
 // Export AJV utilities
-export { clearValidatorCache, getValidator } from "./ajv-validator.js";
-export { validateUniSpecConfig } from "./config-validator-main.js";
-export { validateReferences } from "./reference-validator.js";
+export { clearValidatorCache, getValidator } from "./ajv-validator";
+export { validateUniSpecConfig } from "./config-validator-main";
+export { validateReferences } from "./reference-validator";
 // Re-export semantic and reference validators
-export { validateSemantic } from "./semantic-validator.js";
-export { validateUniSpecTests } from "./tests-validator.js";
-export { validateUniSpec } from "./unispec-validator.js";
+export { validateSemantic } from "./semantic-validator";
+export { validateUniSpecTests } from "./tests-validator";
+export { validateUniSpec } from "./unispec-validator";
 // Export validator factory for advanced usage
-export { createValidator, mapAjvErrors } from "./validator-factory.js";
+export { createValidator, mapAjvErrors } from "./validator-factory";

package/dist/validator/reference-validator.d.ts

@@ -1,4 +1,4 @@
-import type { UniSpecDocument, ValidationError } from "../types/index.js";
+import type { UniSpecDocument, ValidationError } from "@/types";
 export interface ReferenceValidationOptions {
     checkSchemaReferences?: boolean;
     checkSecuritySchemeReferences?: boolean;

package/dist/validator/reference-validator.js

@@ -1,4 +1,4 @@
-import { extractReferences } from "./object-traversal.js";
+import { extractReferences } from "./object-traversal";
 /**
  * Extract all schema references from a UniSpec document.
  */

package/dist/validator/schema-references.d.ts

@@ -1,4 +1,4 @@
-import type { UniSpecDocument, ValidationResult } from "../types/index.js";
+import type { UniSpecDocument, ValidationResult } from "../types";
 export interface SchemaReference {
     path: string;
     schemaName: string;

package/dist/validator/semantic-validator.d.ts

@@ -1,4 +1,4 @@
-import type { UniSpecDocument, ValidationError } from "../types/index.js";
+import type { UniSpecDocument, ValidationError } from "@/types";
 export interface SemanticValidationOptions {
     strictNaming?: boolean;
     checkUrlPatterns?: boolean;

package/dist/validator/tests-validator.d.ts

@@ -1,4 +1,4 @@
-import type { ValidateOptions } from "./types.js";
+import type { ValidateOptions } from "./types";
 /**
  * Validate a UniSpec Tests document against the UniSpec Tests JSON Schema.
  *
@@ -6,4 +6,4 @@ import type { ValidateOptions } from "./types.js";
  * @param options - Validation options including custom schemas
  * @returns Validation result with success status and error details
  */
-export declare const validateUniSpecTests: (doc: unknown, options?: ValidateOptions) => Promise<import("../index.js").ValidationResult>;
+export declare const validateUniSpecTests: (doc: unknown, options?: ValidateOptions) => Promise<import("..").ValidationResult>;

package/dist/validator/tests-validator.js

@@ -1,5 +1,5 @@
-import { getValidator } from "./ajv-validator.js";
-import { createValidator } from "./validator-factory.js";
+import { getValidator } from "./ajv-validator";
+import { createValidator } from "./validator-factory";
 /**
  * Validate a UniSpec Tests document against the UniSpec Tests JSON Schema.
  *

package/dist/validator/types.d.ts

@@ -1,6 +1,6 @@
-import type { ValidationResult } from "../types/index.js";
-import type { ReferenceValidationOptions, ReferenceValidationResult } from "./reference-validator.js";
-import type { SemanticValidationOptions, SemanticValidationResult } from "./semantic-validator.js";
+import type { ValidationResult } from "@/types";
+import type { ReferenceValidationOptions, ReferenceValidationResult } from "./reference-validator";
+import type { SemanticValidationOptions, SemanticValidationResult } from "./semantic-validator";
 export interface SchemaProvider {
     getSchema: (schemaPath: string) => Promise<object>;
 }

package/dist/validator/unispec-validator.d.ts

@@ -1,5 +1,5 @@
-import type { UniSpecDocument, ValidationResult } from "../types/index.js";
-import type { ExtendedValidationResult, ValidateOptions } from "./types.js";
+import type { UniSpecDocument, ValidationResult } from "@/types";
+import type { ExtendedValidationResult, ValidateOptions } from "./types";
 /**
  * Validate a UniSpec document with optional extended validation.
  *

package/dist/validator/unispec-validator.js

@@ -1,8 +1,8 @@
-import { ErrorFactory } from "../errors/index.js";
-import { getValidator } from "./ajv-validator.js";
-import { validateReferences } from "./reference-validator.js";
-import { validateSemantic } from "./semantic-validator.js";
-import { mapAjvErrors } from "./validator-factory.js";
+import { ErrorFactory } from "@/errors";
+import { getValidator } from "./ajv-validator";
+import { validateReferences } from "./reference-validator";
+import { validateSemantic } from "./semantic-validator";
+import { mapAjvErrors } from "./validator-factory";
 /**
  * Validate a UniSpec document with optional extended validation.
  *
@@ -53,12 +53,8 @@ export async function validateUniSpec(doc, options = {}) {
 async function validateUniSpecBase(doc, options = {}) {
     try {
         const { validateUniSpecFn } = await getValidator(options);
-        // Ensure the document has required fields for validation
-        const docForValidation = {
-            unispecVersion: doc.unispecVersion || "1.0.0",
-            service: doc.service,
-        };
-        const valid = validateUniSpecFn(docForValidation);
+        // Validate the document as-is to ensure all required fields are present
+        const valid = validateUniSpecFn(doc);
         const schemaErrors = mapAjvErrors(validateUniSpecFn.errors);
         if (valid) {
             return {

package/dist/validator/validator-factory.d.ts

@@ -1,9 +1,9 @@
-import type { ValidationError } from "../types/index.js";
-import type { AjvValidateFn, ValidateOptions } from "./types.js";
+import type { ValidationError } from "@/types";
+import type { AjvValidateFn, ValidateOptions } from "./types";
 /**
  * Generic validator factory to reduce code duplication.
  */
-export declare function createValidator<T>(documentType: "unispec" | "unispecTests" | "unispecConfig", getValidatorFn: (options: ValidateOptions) => Promise<AjvValidateFn | undefined>, customValidation?: (doc: T) => ValidationError[]): (doc: T, options?: ValidateOptions) => Promise<import("../types/index.js").ValidationResult>;
+export declare function createValidator<T>(documentType: "unispec" | "unispecTests" | "unispecConfig", getValidatorFn: (options: ValidateOptions) => Promise<AjvValidateFn | undefined>, customValidation?: (doc: T) => ValidationError[]): (doc: T, options?: ValidateOptions) => Promise<import("../types").ValidationResult>;
 /**
  * Map AJV errors to specific UniSpec validation errors.
  */

package/dist/validator/validator-factory.js

@@ -1,4 +1,4 @@
-import { ErrorFactory } from "../errors/index.js";
+import { ErrorFactory } from "@/errors";
 /**
  * Generic validator factory to reduce code duplication.
  */