@vorionsys/contracts 0.1.0 → 0.1.2

package/dist/car/car-string.js

@@ -0,0 +1,734 @@
+"use strict";
+/**
+ * @fileoverview CAR String Parser and Generator
+ *
+ * Provides parsing, generation, and validation for Categorical Agent
+ * Registry (CAR) strings. CAR strings follow the format:
+ *
+ *   `{registry}.{organization}.{agentClass}:{domains}-L{level}@{version}[#extensions]`
+ *
+ * Example: `a3i.acme-corp.invoice-bot:ABF-L3@1.0.0`
+ *
+ * **CRITICAL DESIGN PRINCIPLE:**
+ * The CAR is an IMMUTABLE identifier (like a certificate or passport number).
+ * Trust is NOT encoded in the CAR - it is computed at RUNTIME based on:
+ * - Attestations (stored separately)
+ * - Behavioral signals
+ * - Deployment context policies
+ *
+ * The optional extensions (section 5+) are mutable and can be defined by
+ * industry or community standards.
+ *
+ * @module @vorionsys/contracts/car/car-string
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aciValidationResultSchema = exports.carValidationResultSchema = exports.aciValidationWarningSchema = exports.carValidationWarningSchema = exports.aciValidationErrorSchema = exports.carValidationErrorSchema = exports.generateACIOptionsSchema = exports.generateCAROptionsSchema = exports.aciSchema = exports.carSchema = exports.aciStringSchema = exports.carStringSchema = exports.ACIParseError = exports.CARParseError = exports.parsedACISchema = exports.parsedCARSchema = exports.ACI_LEGACY_REGEX = exports.ACI_PARTIAL_REGEX = exports.ACI_REGEX = exports.CAR_LEGACY_REGEX = exports.CAR_PARTIAL_REGEX = exports.CAR_REGEX = void 0;
+exports.getCARIdentity = getCARIdentity;
+exports.getACIIdentity = getACIIdentity;
+exports.parseCAR = parseCAR;
+exports.parseACI = parseACI;
+exports.parseLegacyCAR = parseLegacyCAR;
+exports.parseLegacyACI = parseLegacyACI;
+exports.tryParseCAR = tryParseCAR;
+exports.tryParseACI = tryParseACI;
+exports.safeParseCAR = safeParseCAR;
+exports.safeParseACI = safeParseACI;
+exports.generateCAR = generateCAR;
+exports.generateACI = generateACI;
+exports.generateCARString = generateCARString;
+exports.generateACIString = generateACIString;
+exports.validateCAR = validateCAR;
+exports.validateACI = validateACI;
+exports.isValidCAR = isValidCAR;
+exports.isValidACI = isValidACI;
+exports.isCARString = isCARString;
+exports.isACIString = isACIString;
+exports.updateCAR = updateCAR;
+exports.updateACI = updateACI;
+exports.addCARExtensions = addCARExtensions;
+exports.addACIExtensions = addACIExtensions;
+exports.removeCARExtensions = removeCARExtensions;
+exports.removeACIExtensions = removeACIExtensions;
+exports.incrementCARVersion = incrementCARVersion;
+exports.incrementACIVersion = incrementACIVersion;
+const zod_1 = require("zod");
+const domains_js_1 = require("./domains.js");
+const levels_js_1 = require("./levels.js");
+// ============================================================================
+// CAR Regex Pattern
+// ============================================================================
+/**
+ * Regular expression for parsing CAR strings.
+ *
+ * Format: `{registry}.{organization}.{agentClass}:{domains}-L{level}@{version}[#extensions]`
+ *
+ * Groups:
+ * 1. registry - Certifying registry (e.g., 'a3i')
+ * 2. organization - Operating organization (e.g., 'acme-corp')
+ * 3. agentClass - Agent classification (e.g., 'invoice-bot')
+ * 4. domains - Capability domain codes (e.g., 'ABF')
+ * 5. level - Autonomy level (0-5)
+ * 6. version - Semantic version (e.g., '1.0.0')
+ * 7. extensions - Optional comma-separated extensions (e.g., 'gov,audit')
+ *
+ * NOTE: Trust tier is NOT part of the CAR. Trust is computed at runtime
+ * from attestations, behavioral signals, and deployment context.
+ */
+exports.CAR_REGEX = /^([a-z0-9]+)\.([a-z0-9-]+)\.([a-z0-9-]+):([A-Z]+)-L([0-5])@(\d+\.\d+\.\d+)(?:#([a-z0-9,_-]+))?$/;
+/**
+ * Looser regex for partial CAR validation.
+ */
+exports.CAR_PARTIAL_REGEX = /^([a-z0-9]+)\.([a-z0-9-]+)\.([a-z0-9-]+):([A-Z]+)-L([0-5])(@\d+\.\d+\.\d+)?(?:#([a-z0-9,_-]+))?$/;
+/**
+ * Legacy regex for parsing old-format CAR strings that include trust tier.
+ * Used for migration/compatibility only.
+ * @deprecated Use CAR_REGEX instead - trust tier should not be in the identifier
+ */
+exports.CAR_LEGACY_REGEX = /^([a-z0-9]+)\.([a-z0-9-]+)\.([a-z0-9-]+):([A-Z]+)-L([0-5])-T([0-5])@(\d+\.\d+\.\d+)$/;
+// Legacy ACI aliases for backwards compatibility
+/** @deprecated Use CAR_REGEX instead */
+exports.ACI_REGEX = exports.CAR_REGEX;
+/** @deprecated Use CAR_PARTIAL_REGEX instead */
+exports.ACI_PARTIAL_REGEX = exports.CAR_PARTIAL_REGEX;
+/** @deprecated Use CAR_LEGACY_REGEX instead */
+exports.ACI_LEGACY_REGEX = exports.CAR_LEGACY_REGEX;
+/**
+ * Extracts the identity portion from a parsed CAR.
+ */
+function getCARIdentity(parsed) {
+    return `${parsed.registry}.${parsed.organization}.${parsed.agentClass}`;
+}
+/**
+ * @deprecated Use getCARIdentity instead
+ */
+function getACIIdentity(parsed) {
+    return getCARIdentity(parsed);
+}
+/**
+ * Zod schema for ParsedCAR validation.
+ */
+exports.parsedCARSchema = zod_1.z.object({
+    car: zod_1.z.string().min(1),
+    registry: zod_1.z.string().min(1).regex(/^[a-z0-9]+$/),
+    organization: zod_1.z.string().min(1).regex(/^[a-z0-9-]+$/),
+    agentClass: zod_1.z.string().min(1).regex(/^[a-z0-9-]+$/),
+    domains: zod_1.z.array(zod_1.z.enum(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'S'])).min(1),
+    domainsBitmask: zod_1.z.number().int().min(0),
+    level: zod_1.z.nativeEnum(levels_js_1.CapabilityLevel),
+    version: zod_1.z.string().regex(/^\d+\.\d+\.\d+$/),
+    extensions: zod_1.z.array(zod_1.z.string()).default([]),
+});
+/** @deprecated Use parsedCARSchema instead */
+exports.parsedACISchema = exports.parsedCARSchema;
+// ============================================================================
+// CAR Parse Error
+// ============================================================================
+/**
+ * Error thrown when CAR parsing fails.
+ */
+class CARParseError extends Error {
+    /** The invalid CAR string that caused the error */
+    car;
+    /** Error code for programmatic handling */
+    code;
+    constructor(message, car, code = 'INVALID_FORMAT') {
+        super(message);
+        this.name = 'CARParseError';
+        this.car = car;
+        this.code = code;
+    }
+}
+exports.CARParseError = CARParseError;
+/**
+ * @deprecated Use CARParseError instead
+ */
+class ACIParseError extends CARParseError {
+    /** @deprecated Use car instead */
+    aci;
+    constructor(message, aci, code = 'INVALID_FORMAT') {
+        super(message, aci, code);
+        this.name = 'ACIParseError';
+        this.aci = aci;
+    }
+}
+exports.ACIParseError = ACIParseError;
+// ============================================================================
+// Parsing Functions
+// ============================================================================
+/**
+ * Parses a CAR string into its components.
+ *
+ * @param car - The CAR string to parse
+ * @returns Parsed CAR components
+ * @throws CARParseError if the CAR string is invalid
+ *
+ * @example
+ * ```typescript
+ * const parsed = parseCAR('a3i.acme-corp.invoice-bot:ABF-L3@1.0.0');
+ * // {
+ * //   car: 'a3i.acme-corp.invoice-bot:ABF-L3@1.0.0',
+ * //   registry: 'a3i',
+ * //   organization: 'acme-corp',
+ * //   agentClass: 'invoice-bot',
+ * //   domains: ['A', 'B', 'F'],
+ * //   domainsBitmask: 0x023,
+ * //   level: CapabilityLevel.L3_EXECUTE,
+ * //   version: '1.0.0',
+ * //   extensions: []
+ * // }
+ * ```
+ */
+function parseCAR(car) {
+    // Check for legacy format with embedded trust tier
+    if (exports.CAR_LEGACY_REGEX.test(car)) {
+        throw new CARParseError(`Legacy CAR format detected with embedded trust tier. ` +
+            `Trust should not be part of the identifier - use parseLegacyCAR() for migration.`, car, 'LEGACY_FORMAT');
+    }
+    const match = car.match(exports.CAR_REGEX);
+    if (!match) {
+        throw new CARParseError(`Invalid CAR format: ${car}`, car, 'INVALID_FORMAT');
+    }
+    const [, registry, organization, agentClass, domainsStr, levelStr, version, extensionsStr] = match;
+    // Validate and parse domains
+    const domainChars = domainsStr.split('');
+    const invalidDomains = domainChars.filter((d) => !(0, domains_js_1.isDomainCode)(d));
+    if (invalidDomains.length > 0) {
+        throw new CARParseError(`Invalid domain codes: ${invalidDomains.join(', ')}`, car, 'INVALID_DOMAINS');
+    }
+    if (domainChars.length === 0) {
+        throw new CARParseError('CAR must have at least one domain', car, 'NO_DOMAINS');
+    }
+    const domains = domainChars;
+    const domainsBitmask = (0, domains_js_1.encodeDomains)(domains);
+    // Parse level (no tier - trust is computed at runtime)
+    const level = parseInt(levelStr, 10);
+    // Parse optional extensions
+    const extensions = extensionsStr ? extensionsStr.split(',').filter((e) => e.length > 0) : [];
+    return {
+        car,
+        registry: registry,
+        organization: organization,
+        agentClass: agentClass,
+        domains,
+        domainsBitmask,
+        level,
+        version: version,
+        extensions,
+    };
+}
+/**
+ * @deprecated Use parseCAR instead
+ */
+function parseACI(aci) {
+    const parsed = parseCAR(aci);
+    return { ...parsed, aci: parsed.car };
+}
+/**
+ * Parses a legacy CAR string that includes trust tier.
+ * Returns the parsed CAR (without tier) plus the extracted tier value.
+ *
+ * @deprecated Use parseCAR() - trust should not be in the identifier
+ * @param car - Legacy CAR string with embedded tier
+ * @returns Parsed CAR plus extracted tier
+ */
+function parseLegacyCAR(car) {
+    const match = car.match(exports.CAR_LEGACY_REGEX);
+    if (!match) {
+        throw new CARParseError(`Invalid legacy CAR format: ${car}`, car, 'INVALID_FORMAT');
+    }
+    const [, registry, organization, agentClass, domainsStr, levelStr, tierStr, version] = match;
+    // Validate and parse domains
+    const domainChars = domainsStr.split('');
+    const invalidDomains = domainChars.filter((d) => !(0, domains_js_1.isDomainCode)(d));
+    if (invalidDomains.length > 0) {
+        throw new CARParseError(`Invalid domain codes: ${invalidDomains.join(', ')}`, car, 'INVALID_DOMAINS');
+    }
+    const domains = domainChars;
+    const domainsBitmask = (0, domains_js_1.encodeDomains)(domains);
+    const level = parseInt(levelStr, 10);
+    const legacyTier = parseInt(tierStr, 10);
+    // Generate the new CAR format (without tier)
+    const newCar = `${registry}.${organization}.${agentClass}:${(0, domains_js_1.formatDomainString)(domains)}-L${level}@${version}`;
+    return {
+        parsed: {
+            car: newCar,
+            registry: registry,
+            organization: organization,
+            agentClass: agentClass,
+            domains,
+            domainsBitmask,
+            level,
+            version: version,
+            extensions: [],
+        },
+        legacyTier,
+    };
+}
+/**
+ * @deprecated Use parseLegacyCAR instead
+ */
+function parseLegacyACI(aci) {
+    const result = parseLegacyCAR(aci);
+    return {
+        parsed: { ...result.parsed, aci: result.parsed.car },
+        legacyTier: result.legacyTier,
+    };
+}
+/**
+ * Safely parses a CAR string, returning null on failure.
+ *
+ * @param car - The CAR string to parse
+ * @returns Parsed CAR or null if invalid
+ */
+function tryParseCAR(car) {
+    try {
+        return parseCAR(car);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * @deprecated Use tryParseCAR instead
+ */
+function tryParseACI(aci) {
+    try {
+        return parseACI(aci);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Safely parses a CAR string, returning a result object.
+ *
+ * @param car - The CAR string to parse
+ * @returns Result object with success flag and parsed CAR or error
+ */
+function safeParseCAR(car) {
+    try {
+        return { success: true, data: parseCAR(car) };
+    }
+    catch (error) {
+        if (error instanceof CARParseError) {
+            return { success: false, error };
+        }
+        return {
+            success: false,
+            error: new CARParseError(String(error), car, 'INVALID_FORMAT'),
+        };
+    }
+}
+/**
+ * @deprecated Use safeParseCAR instead
+ */
+function safeParseACI(aci) {
+    try {
+        return { success: true, data: parseACI(aci) };
+    }
+    catch (error) {
+        if (error instanceof CARParseError) {
+            return { success: false, error };
+        }
+        return {
+            success: false,
+            error: new CARParseError(String(error), aci, 'INVALID_FORMAT'),
+        };
+    }
+}
+/**
+ * Generates a CAR string from components.
+ *
+ * @param options - CAR components
+ * @returns Generated CAR string
+ *
+ * @example
+ * ```typescript
+ * const car = generateCAR({
+ *   registry: 'a3i',
+ *   organization: 'acme-corp',
+ *   agentClass: 'invoice-bot',
+ *   domains: ['A', 'B', 'F'],
+ *   level: CapabilityLevel.L3_EXECUTE,
+ *   version: '1.0.0',
+ * });
+ * // 'a3i.acme-corp.invoice-bot:ABF-L3@1.0.0'
+ *
+ * // With extensions:
+ * const carWithExt = generateCAR({
+ *   registry: 'a3i',
+ *   organization: 'acme-corp',
+ *   agentClass: 'invoice-bot',
+ *   domains: ['A', 'B', 'F'],
+ *   level: CapabilityLevel.L3_EXECUTE,
+ *   version: '1.0.0',
+ *   extensions: ['gov', 'audit'],
+ * });
+ * // 'a3i.acme-corp.invoice-bot:ABF-L3@1.0.0#gov,audit'
+ * ```
+ */
+function generateCAR(options) {
+    const { registry, organization, agentClass, domains, level, version, extensions = [] } = options;
+    // Validate components
+    if (!/^[a-z0-9]+$/.test(registry)) {
+        throw new Error(`Invalid registry: ${registry}. Must be lowercase alphanumeric.`);
+    }
+    if (!/^[a-z0-9-]+$/.test(organization)) {
+        throw new Error(`Invalid organization: ${organization}. Must be lowercase alphanumeric with hyphens.`);
+    }
+    if (!/^[a-z0-9-]+$/.test(agentClass)) {
+        throw new Error(`Invalid agent class: ${agentClass}. Must be lowercase alphanumeric with hyphens.`);
+    }
+    if (domains.length === 0) {
+        throw new Error('At least one domain is required.');
+    }
+    const invalidDomains = domains.filter((d) => !(0, domains_js_1.isDomainCode)(d));
+    if (invalidDomains.length > 0) {
+        throw new Error(`Invalid domain codes: ${invalidDomains.join(', ')}`);
+    }
+    if (!(0, levels_js_1.isCapabilityLevel)(level)) {
+        throw new Error(`Invalid level: ${level}. Must be 0-5.`);
+    }
+    if (!/^\d+\.\d+\.\d+$/.test(version)) {
+        throw new Error(`Invalid version: ${version}. Must be semantic version (e.g., 1.0.0).`);
+    }
+    // Validate extensions if provided
+    if (extensions.length > 0) {
+        const invalidExtensions = extensions.filter((e) => !/^[a-z0-9_-]+$/.test(e));
+        if (invalidExtensions.length > 0) {
+            throw new Error(`Invalid extensions: ${invalidExtensions.join(', ')}. Must be lowercase alphanumeric with hyphens/underscores.`);
+        }
+    }
+    // Format domains (sorted, deduplicated)
+    const domainsStr = (0, domains_js_1.formatDomainString)(domains);
+    // Build CAR string
+    let car = `${registry}.${organization}.${agentClass}:${domainsStr}-L${level}@${version}`;
+    // Append extensions if present
+    if (extensions.length > 0) {
+        car += `#${extensions.join(',')}`;
+    }
+    return car;
+}
+/**
+ * @deprecated Use generateCAR instead
+ */
+function generateACI(options) {
+    return generateCAR(options);
+}
+/**
+ * Generates a CAR string from individual parameters.
+ *
+ * @param registry - Certifying registry
+ * @param organization - Operating organization
+ * @param agentClass - Agent classification
+ * @param domains - Capability domains
+ * @param level - Autonomy level
+ * @param version - Semantic version
+ * @param extensions - Optional extensions
+ * @returns Generated CAR string
+ */
+function generateCARString(registry, organization, agentClass, domains, level, version, extensions) {
+    return generateCAR({
+        registry,
+        organization,
+        agentClass,
+        domains,
+        level,
+        version,
+        extensions,
+    });
+}
+/**
+ * @deprecated Use generateCARString instead
+ */
+function generateACIString(registry, organization, agentClass, domains, level, version, extensions) {
+    return generateCARString(registry, organization, agentClass, domains, level, version, extensions);
+}
+/**
+ * Validates a CAR string.
+ *
+ * @param car - The CAR string to validate
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * const result = validateCAR('a3i.acme-corp.bot:A-L5@1.0.0');
+ * // {
+ * //   valid: true,
+ * //   errors: [],
+ * //   warnings: [],
+ * //   parsed: { ... }
+ * // }
+ * ```
+ */
+function validateCAR(car) {
+    const errors = [];
+    const warnings = [];
+    // Check for legacy format with embedded trust tier
+    if (exports.CAR_LEGACY_REGEX.test(car)) {
+        warnings.push({
+            code: 'LEGACY_FORMAT',
+            message: 'CAR contains embedded trust tier which is deprecated. ' +
+                'Trust should be computed at runtime, not encoded in the identifier.',
+        });
+    }
+    try {
+        const parsed = parseCAR(car);
+        // Validate capability level constraints
+        // Note: Trust checks are now done at RUNTIME, not in the CAR itself
+        // L7 agents operate at maximum autonomy - should be rare
+        if (parsed.level === levels_js_1.CapabilityLevel.L7_AUTONOMOUS) {
+            warnings.push({
+                code: 'L7_AUTONOMOUS_LEVEL',
+                message: 'L7 (Autonomous) level grants maximum autonomy. ' +
+                    'Ensure runtime trust policies are configured appropriately.',
+            });
+        }
+        // Security domain agents require careful runtime trust
+        if (parsed.domains.includes('S')) {
+            warnings.push({
+                code: 'SECURITY_DOMAIN',
+                message: 'Security domain agent. Runtime attestations and behavioral scoring ' +
+                    'should be configured to enforce appropriate trust levels.',
+            });
+        }
+        // Finance domain agents require careful runtime trust
+        if (parsed.domains.includes('F')) {
+            warnings.push({
+                code: 'FINANCE_DOMAIN',
+                message: 'Finance domain agent. Runtime attestations and behavioral scoring ' +
+                    'should be configured to enforce appropriate trust levels.',
+            });
+        }
+        return {
+            valid: true,
+            errors,
+            warnings,
+            parsed,
+        };
+    }
+    catch (e) {
+        if (e instanceof CARParseError) {
+            // If it's a legacy format error, try parsing with legacy parser
+            if (e.code === 'LEGACY_FORMAT') {
+                try {
+                    const { parsed } = parseLegacyCAR(car);
+                    warnings.push({
+                        code: 'LEGACY_FORMAT_MIGRATED',
+                        message: 'Legacy CAR migrated to new format. Trust tier has been removed from identifier.',
+                    });
+                    return {
+                        valid: true,
+                        errors,
+                        warnings,
+                        parsed,
+                    };
+                }
+                catch {
+                    errors.push({ code: e.code, message: e.message });
+                }
+            }
+            else {
+                errors.push({ code: e.code, message: e.message });
+            }
+        }
+        else {
+            errors.push({ code: 'UNKNOWN_ERROR', message: String(e) });
+        }
+        return { valid: false, errors, warnings };
+    }
+}
+/**
+ * @deprecated Use validateCAR instead
+ */
+function validateACI(aci) {
+    return validateCAR(aci);
+}
+/**
+ * Checks if a string is a valid CAR format.
+ *
+ * @param car - String to check
+ * @returns True if the string is a valid CAR
+ */
+function isValidCAR(car) {
+    return exports.CAR_REGEX.test(car) && validateCAR(car).valid;
+}
+/**
+ * @deprecated Use isValidCAR instead
+ */
+function isValidACI(aci) {
+    return isValidCAR(aci);
+}
+/**
+ * Type guard to check if a value is a valid CAR string.
+ *
+ * @param value - Value to check
+ * @returns True if value is a valid CAR string
+ */
+function isCARString(value) {
+    return typeof value === 'string' && isValidCAR(value);
+}
+/**
+ * @deprecated Use isCARString instead
+ */
+function isACIString(value) {
+    return isCARString(value);
+}
+// ============================================================================
+// CAR Manipulation
+// ============================================================================
+/**
+ * Updates specific fields in a CAR and returns a new CAR string.
+ *
+ * @param car - Original CAR string
+ * @param updates - Fields to update
+ * @returns New CAR string with updates applied
+ */
+function updateCAR(car, updates) {
+    const parsed = parseCAR(car);
+    return generateCAR({
+        registry: parsed.registry,
+        organization: parsed.organization,
+        agentClass: parsed.agentClass,
+        domains: updates.domains ?? parsed.domains,
+        level: updates.level ?? parsed.level,
+        version: updates.version ?? parsed.version,
+        extensions: updates.extensions ?? parsed.extensions,
+    });
+}
+/**
+ * @deprecated Use updateCAR instead
+ */
+function updateACI(aci, updates) {
+    return updateCAR(aci, updates);
+}
+/**
+ * Adds extensions to a CAR string.
+ *
+ * @param car - Original CAR string
+ * @param newExtensions - Extensions to add
+ * @returns New CAR string with extensions added
+ */
+function addCARExtensions(car, newExtensions) {
+    const parsed = parseCAR(car);
+    const allExtensions = [...new Set([...parsed.extensions, ...newExtensions])];
+    return updateCAR(car, { extensions: allExtensions });
+}
+/**
+ * @deprecated Use addCARExtensions instead
+ */
+function addACIExtensions(aci, newExtensions) {
+    return addCARExtensions(aci, newExtensions);
+}
+/**
+ * Removes extensions from a CAR string.
+ *
+ * @param car - Original CAR string
+ * @param extensionsToRemove - Extensions to remove
+ * @returns New CAR string with extensions removed
+ */
+function removeCARExtensions(car, extensionsToRemove) {
+    const parsed = parseCAR(car);
+    const remaining = parsed.extensions.filter((e) => !extensionsToRemove.includes(e));
+    return updateCAR(car, { extensions: remaining });
+}
+/**
+ * @deprecated Use removeCARExtensions instead
+ */
+function removeACIExtensions(aci, extensionsToRemove) {
+    return removeCARExtensions(aci, extensionsToRemove);
+}
+/**
+ * Increments the version in a CAR string.
+ *
+ * @param car - Original CAR string
+ * @param type - Version component to increment ('major' | 'minor' | 'patch')
+ * @returns New CAR string with incremented version
+ */
+function incrementCARVersion(car, type = 'patch') {
+    const parsed = parseCAR(car);
+    const [major, minor, patch] = parsed.version.split('.').map(Number);
+    let newVersion;
+    switch (type) {
+        case 'major':
+            newVersion = `${major + 1}.0.0`;
+            break;
+        case 'minor':
+            newVersion = `${major}.${minor + 1}.0`;
+            break;
+        case 'patch':
+        default:
+            newVersion = `${major}.${minor}.${patch + 1}`;
+            break;
+    }
+    return updateCAR(car, { version: newVersion });
+}
+/**
+ * @deprecated Use incrementCARVersion instead
+ */
+function incrementACIVersion(aci, type = 'patch') {
+    return incrementCARVersion(aci, type);
+}
+// ============================================================================
+// Zod Schemas
+// ============================================================================
+/**
+ * Zod schema for CAR string validation.
+ */
+exports.carStringSchema = zod_1.z.string().refine((val) => exports.CAR_REGEX.test(val), {
+    message: 'Invalid CAR format. Expected: registry.org.class:DOMAINS-Ln@x.y.z[#extensions]',
+});
+/** @deprecated Use carStringSchema instead */
+exports.aciStringSchema = exports.carStringSchema;
+/**
+ * Zod schema for CAR string with parsing transform.
+ */
+exports.carSchema = exports.carStringSchema.transform((car) => parseCAR(car));
+/** @deprecated Use carSchema instead */
+exports.aciSchema = exports.carStringSchema.transform((aci) => parseACI(aci));
+/**
+ * Zod schema for GenerateCAROptions.
+ */
+exports.generateCAROptionsSchema = zod_1.z.object({
+    registry: zod_1.z.string().min(1).regex(/^[a-z0-9]+$/),
+    organization: zod_1.z.string().min(1).regex(/^[a-z0-9-]+$/),
+    agentClass: zod_1.z.string().min(1).regex(/^[a-z0-9-]+$/),
+    domains: zod_1.z.array(zod_1.z.enum(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'S'])).min(1),
+    level: zod_1.z.nativeEnum(levels_js_1.CapabilityLevel),
+    version: zod_1.z.string().regex(/^\d+\.\d+\.\d+$/),
+    extensions: zod_1.z.array(zod_1.z.string().regex(/^[a-z0-9_-]+$/)).optional(),
+});
+/** @deprecated Use generateCAROptionsSchema instead */
+exports.generateACIOptionsSchema = exports.generateCAROptionsSchema;
+/**
+ * Zod schema for CARValidationError.
+ */
+exports.carValidationErrorSchema = zod_1.z.object({
+    code: zod_1.z.string(),
+    message: zod_1.z.string(),
+    path: zod_1.z.string().optional(),
+});
+/** @deprecated Use carValidationErrorSchema instead */
+exports.aciValidationErrorSchema = exports.carValidationErrorSchema;
+/**
+ * Zod schema for CARValidationWarning.
+ */
+exports.carValidationWarningSchema = zod_1.z.object({
+    code: zod_1.z.string(),
+    message: zod_1.z.string(),
+    path: zod_1.z.string().optional(),
+});
+/** @deprecated Use carValidationWarningSchema instead */
+exports.aciValidationWarningSchema = exports.carValidationWarningSchema;
+/**
+ * Zod schema for CARValidationResult.
+ */
+exports.carValidationResultSchema = zod_1.z.object({
+    valid: zod_1.z.boolean(),
+    errors: zod_1.z.array(exports.carValidationErrorSchema),
+    warnings: zod_1.z.array(exports.carValidationWarningSchema),
+    parsed: exports.parsedCARSchema.optional(),
+});
+/** @deprecated Use carValidationResultSchema instead */
+exports.aciValidationResultSchema = exports.carValidationResultSchema;
+//# sourceMappingURL=car-string.js.map