@oxog/vld 2.0.2 → 2.1.0

package/dist/validators/string-bool.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Configuration for string boolean validation
  */
@@ -16,6 +16,11 @@ export interface StringBoolOptions {
  */
 export declare class VldStringBool extends VldBase<unknown, boolean> {
     private readonly options;
+    private readonly truthyValues;
+    private readonly falsyValues;
+    private readonly normalizedTruthySet;
+    private readonly normalizedFalsySet;
+    private readonly validValuesText;
     private constructor();
     /**
      * Create a new string boolean validator
@@ -25,14 +30,7 @@ export declare class VldStringBool extends VldBase<unknown, boolean> {
      * Normalize a string value based on case sensitivity setting
      */
     private normalizeValue;
-    /**
-     * Get the effective truthy values (custom or default)
-     */
-    private getTruthyValues;
-    /**
-     * Get the effective falsy values (custom or default)
-     */
-    private getFalsyValues;
+    private normalizeValues;
     /**
      * Parse and validate a string boolean value
      */
@@ -58,4 +56,3 @@ export declare class VldStringBool extends VldBase<unknown, boolean> {
      */
     caseInsensitive(): VldStringBool;
 }
-//# sourceMappingURL=string-bool.d.ts.map

package/dist/validators/string-bool.js

@@ -0,0 +1,120 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { getMessages } from '../locales/runtime.js';
+
+/**
+ * Default truthy and falsy value sets
+ */
+const DEFAULT_TRUTHY = ['true', '1', 'yes', 'on', 'y', 'enabled'];
+const DEFAULT_FALSY = ['false', '0', 'no', 'off', 'n', 'disabled'];
+/**
+ * Immutable string boolean validator for flexible boolean parsing
+ * Supports string representations like "true", "yes", "on", "1", etc.
+ */
+class VldStringBool extends VldBase {
+    constructor(options) {
+        super(VLD_VALIDATOR_TYPES.STRING_BOOL);
+        this.options = options;
+        this.truthyValues = options.truthy ?? DEFAULT_TRUTHY;
+        this.falsyValues = options.falsy ?? DEFAULT_FALSY;
+        const normalizedTruthy = this.normalizeValues(this.truthyValues);
+        const normalizedFalsy = this.normalizeValues(this.falsyValues);
+        this.normalizedTruthySet = new Set(normalizedTruthy);
+        this.normalizedFalsySet = new Set(normalizedFalsy);
+        this.validValuesText = [...normalizedTruthy, ...normalizedFalsy].join(', ');
+    }
+    /**
+     * Create a new string boolean validator
+     */
+    static create(options = {}) {
+        return new VldStringBool(options);
+    }
+    /**
+     * Normalize a string value based on case sensitivity setting
+     */
+    normalizeValue(value) {
+        return this.options.caseSensitive ? value : value.toLowerCase();
+    }
+    normalizeValues(values) {
+        if (this.options.caseSensitive) {
+            return values;
+        }
+        return values.map(value => value.toLowerCase());
+    }
+    /**
+     * Parse and validate a string boolean value
+     */
+    parse(value) {
+        // First, ensure we have a string
+        if (typeof value !== 'string') {
+            // Also accept actual boolean values for convenience
+            if (typeof value === 'boolean') {
+                return value;
+            }
+            throw new Error(getMessages().stringExpected(typeof value, 'string'));
+        }
+        const normalized = this.normalizeValue(value);
+        // Check if value is in truthy set
+        if (this.normalizedTruthySet.has(normalized)) {
+            return true;
+        }
+        // Check if value is in falsy set
+        if (this.normalizedFalsySet.has(normalized)) {
+            return false;
+        }
+        // Value is not recognized
+        throw new Error(getMessages().stringBoolExpected(this.validValuesText, value));
+    }
+    /**
+     * Safely parse and validate a string boolean value
+     */
+    safeParse(value) {
+        try {
+            const result = this.parse(value);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error
+            };
+        }
+    }
+    /**
+     * Create a new validator with custom truthy values
+     */
+    withTruthy(values) {
+        return new VldStringBool({
+            ...this.options,
+            truthy: values
+        });
+    }
+    /**
+     * Create a new validator with custom falsy values
+     */
+    withFalsy(values) {
+        return new VldStringBool({
+            ...this.options,
+            falsy: values
+        });
+    }
+    /**
+     * Create a new validator with case-sensitive matching
+     */
+    caseSensitive() {
+        return new VldStringBool({
+            ...this.options,
+            caseSensitive: true
+        });
+    }
+    /**
+     * Create a new validator with case-insensitive matching (default)
+     */
+    caseInsensitive() {
+        return new VldStringBool({
+            ...this.options,
+            caseSensitive: false
+        });
+    }
+}
+
+export { VldStringBool };

package/dist/validators/string-formats.d.ts

@@ -3,8 +3,8 @@
  * Part of Zod 4 API parity implementation
  * Provides convenient validators for common string formats
  */
-import { VldBase } from './base';
-import type { ParseResult } from './base';
+import { VldBase } from './base.js';
+import type { ParseResult } from './base.js';
 /**
  * Pre-compiled regex patterns for performance
  */
@@ -38,11 +38,15 @@ declare const REGEXES: {
     readonly sha256: RegExp;
     readonly sha384: RegExp;
     readonly sha512: RegExp;
+    readonly xid: RegExp;
+    readonly guid: RegExp;
+    readonly httpUrl: RegExp;
+    readonly ksuid: RegExp;
 };
 /**
  * Generic string format validator
  */
-declare class VldStringFormat extends VldBase<unknown, string> {
+export declare class VldStringFormat extends VldBase<unknown, string> {
     readonly _format: string;
     readonly _validator: (val: string) => boolean;
     readonly _errorMessage?: string | undefined;
@@ -61,6 +65,8 @@ export declare const uuid: (options?: {
     version?: "v4" | "v6" | "v7";
 }) => VldStringFormat;
 export declare const uuidv4: () => VldStringFormat;
+export declare const uuidv6: () => VldStringFormat;
+export declare const uuidv7: () => VldStringFormat;
 export declare const hostname: () => VldStringFormat;
 export declare const emoji: () => VldStringFormat;
 export declare const base64: () => VldStringFormat;
@@ -77,6 +83,10 @@ export declare const mac: () => VldStringFormat;
 export declare const cidrv4: () => VldStringFormat;
 export declare const cidrv6: () => VldStringFormat;
 export declare const e164: () => VldStringFormat;
+export declare const xid: () => VldStringFormat;
+export declare const guid: () => VldStringFormat;
+export declare const httpUrl: () => VldStringFormat;
+export declare const ksuid: () => VldStringFormat;
 export declare const hash: (algorithm: "md5" | "sha1" | "sha256" | "sha384" | "sha512") => VldStringFormat;
 /**
  * ISO date/time validators
@@ -94,4 +104,3 @@ export declare const iso: {
  */
 export declare const stringFormat: (name: string, validator: ((val: string) => boolean) | RegExp) => VldStringFormat;
 export { REGEXES as regexes };
-//# sourceMappingURL=string-formats.d.ts.map

package/dist/validators/string-formats.js

@@ -0,0 +1,135 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { getMessages } from '../locales/runtime.js';
+
+/**
+ * Top-level string format validators
+ * Part of Zod 4 API parity implementation
+ * Provides convenient validators for common string formats
+ */
+/**
+ * Pre-compiled regex patterns for performance
+ */
+const REGEXES = {
+    email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+    uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+    uuidv4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    uuidv6: /^[0-9a-f]{8}-[0-9a-f]{4}-6[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    uuidv7: /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    hostname: /^(?=.{1,253}$)(?:(?!-)[a-zA-Z0-9-]{1,63}(?<!-)\.)+[a-zA-Z]{2,63}$/,
+    emoji: /^(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F)(?:\u200D(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F))*$/u,
+    base64: /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/,
+    base64url: /^[A-Za-z0-9_-]*$/,
+    hex: /^[0-9a-fA-F]*$/,
+    jwt: /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$/,
+    nanoid: /^[A-Za-z0-9_-]{21}$/,
+    cuid: /^c[^\s-]{8,}$/i,
+    cuid2: /^[0-9a-z]+$/,
+    ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+    ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
+    ipv6: /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/,
+    mac: /^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$/,
+    cidrv4: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\/(?:3[0-2]|[12]?[0-9])$/,
+    cidrv6: /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$|^(?:[0-9a-fA-F]{1,4}:){1,7}:\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+    e164: /^\+[1-9]\d{1,14}$/,
+    isoDate: /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/,
+    isoTime: /^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?$/,
+    isoDateTime: /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?Z?$/,
+    md5: /^[a-f0-9]{32}$/i,
+    sha1: /^[a-f0-9]{40}$/i,
+    sha256: /^[a-f0-9]{64}$/i,
+    sha384: /^[a-f0-9]{96}$/i,
+    sha512: /^[a-f0-9]{128}$/i,
+    // Additional formats (Zod v4 parity)
+    xid: /^[A-HJKMNP-TV-Z0-9]{20}$/, // ksort's XID format
+    guid: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i, // Alias for UUID
+    httpUrl: /^https?:\/\/[^\s/$.?#].[^\s]*$/, // HTTP/HTTPS URL
+    ksuid: /^[0-9A-Za-z]{27}$/,
+};
+/**
+ * Generic string format validator
+ */
+class VldStringFormat extends VldBase {
+    constructor(_format, _validator, _errorMessage) {
+        super(VLD_VALIDATOR_TYPES.STRING_FORMAT);
+        this._format = _format;
+        this._validator = _validator;
+        this._errorMessage = _errorMessage;
+    }
+    static create(format, validator, errorMessage) {
+        return new VldStringFormat(format, validator, errorMessage);
+    }
+    parse(value) {
+        if (typeof value !== 'string') {
+            throw new Error(getMessages().invalidString);
+        }
+        if (!this._validator(value)) {
+            throw new Error(this._errorMessage || `Invalid ${this._format} format`);
+        }
+        return value;
+    }
+    safeParse(value) {
+        if (typeof value !== 'string') {
+            return {
+                success: false,
+                error: new Error(getMessages().invalidString)
+            };
+        }
+        if (!this._validator(value)) {
+            return {
+                success: false,
+                error: new Error(this._errorMessage || `Invalid ${this._format} format`)
+            };
+        }
+        return { success: true, data: value };
+    }
+}
+/**
+ * Top-level string format validators
+ */
+const email = (options) => VldStringFormat.create('email', (val) => (options?.pattern ?? REGEXES.email).test(val));
+const uuid = (options) => {
+    const pattern = options?.version ? REGEXES[`uuid${options.version}`] : REGEXES.uuid;
+    return VldStringFormat.create('uuid', (val) => pattern.test(val));
+};
+const uuidv4 = () => VldStringFormat.create('uuid', (val) => REGEXES.uuidv4.test(val));
+const uuidv6 = () => VldStringFormat.create('uuid', (val) => REGEXES.uuidv6.test(val));
+const uuidv7 = () => VldStringFormat.create('uuid', (val) => REGEXES.uuidv7.test(val));
+const hostname = () => VldStringFormat.create('hostname', (val) => REGEXES.hostname.test(val));
+const emoji = () => VldStringFormat.create('emoji', (val) => REGEXES.emoji.test(val));
+const base64 = () => VldStringFormat.create('base64', (val) => REGEXES.base64.test(val));
+const base64url = () => VldStringFormat.create('base64url', (val) => REGEXES.base64url.test(val));
+const hex = () => VldStringFormat.create('hex', (val) => REGEXES.hex.test(val));
+const jwt = () => VldStringFormat.create('jwt', (val) => REGEXES.jwt.test(val));
+const nanoid = () => VldStringFormat.create('nanoid', (val) => REGEXES.nanoid.test(val));
+const cuid = () => VldStringFormat.create('cuid', (val) => REGEXES.cuid.test(val));
+const cuid2 = () => VldStringFormat.create('cuid2', (val) => REGEXES.cuid2.test(val));
+const ulid = () => VldStringFormat.create('ulid', (val) => REGEXES.ulid.test(val));
+const ipv4 = () => VldStringFormat.create('ipv4', (val) => REGEXES.ipv4.test(val));
+const ipv6 = () => VldStringFormat.create('ipv6', (val) => REGEXES.ipv6.test(val));
+const mac = () => VldStringFormat.create('mac', (val) => REGEXES.mac.test(val));
+const cidrv4 = () => VldStringFormat.create('cidrv4', (val) => REGEXES.cidrv4.test(val));
+const cidrv6 = () => VldStringFormat.create('cidrv6', (val) => REGEXES.cidrv6.test(val));
+const e164 = () => VldStringFormat.create('e164', (val) => REGEXES.e164.test(val));
+const xid = () => VldStringFormat.create('xid', (val) => REGEXES.xid.test(val));
+const guid = () => VldStringFormat.create('guid', (val) => REGEXES.guid.test(val));
+const httpUrl = () => VldStringFormat.create('httpUrl', (val) => REGEXES.httpUrl.test(val));
+const ksuid = () => VldStringFormat.create('ksuid', (val) => REGEXES.ksuid.test(val));
+const hash = (algorithm) => VldStringFormat.create('hash', (val) => REGEXES[algorithm]?.test(val) ?? false, `Invalid ${algorithm} hash`);
+/**
+ * ISO date/time validators
+ */
+const iso = {
+    date: () => VldStringFormat.create('date', (val) => REGEXES.isoDate.test(val)),
+    time: () => VldStringFormat.create('time', (val) => REGEXES.isoTime.test(val)),
+    dateTime: (_options) => VldStringFormat.create('datetime', (val) => REGEXES.isoDateTime.test(val)),
+    duration: () => VldStringFormat.create('duration', (val) => /^-?P(?!$)(?:\d+(?:\.\d+)?Y)?(?:\d+(?:\.\d+)?M)?(?:\d+(?:\.\d+)?W)?(?:\d+(?:\.\d+)?D)?(?:T(?=\d)(?:\d+(?:\.\d+)?H)?(?:\d+(?:\.\d+)?M)?(?:\d+(?:\.\d+)?S)?)?$/.test(val)),
+};
+/**
+ * Custom format validator
+ */
+const stringFormat = (name, validator) => {
+    const fn = validator instanceof RegExp ? (val) => validator.test(val) : validator;
+    return VldStringFormat.create(name, fn);
+};
+
+export { VldStringFormat, base64, base64url, cidrv4, cidrv6, cuid, cuid2, e164, email, emoji, guid, hash, hex, hostname, httpUrl, ipv4, ipv6, iso, jwt, ksuid, mac, nanoid, REGEXES as regexes, stringFormat, ulid, uuid, uuidv4, uuidv6, uuidv7, xid };

package/dist/validators/string.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult, ValidatorType, type ErrorParam } from './base.js';
 /**
  * Type for string validation check functions
  */
@@ -7,13 +7,22 @@ type StringCheck = (value: string) => boolean;
  * Type for string transformation functions
  */
 type StringTransform = (value: string) => string;
+interface StringJSONSchemaHints {
+    minLength?: number;
+    maxLength?: number;
+    exactLength?: number;
+    format?: string;
+    pattern?: string;
+}
 /**
  * Configuration for string validator
  */
 interface StringValidatorConfig {
     readonly checks: ReadonlyArray<StringCheck>;
     readonly transforms: ReadonlyArray<StringTransform>;
-    readonly errorMessage?: string;
+    readonly errorMessage: string | undefined;
+    readonly validatorType?: ValidatorType;
+    readonly jsonSchema: StringJSONSchemaHints | undefined;
 }
 /**
  * Immutable string validator with chainable methods
@@ -21,6 +30,9 @@ interface StringValidatorConfig {
  */
 export declare class VldString extends VldBase<string, string> {
     protected readonly config: StringValidatorConfig;
+    private readonly _checks;
+    private readonly _transforms;
+    private readonly _isSimple;
     private _compiledValidator;
     /**
      * Protected constructor to allow extension while maintaining immutability
@@ -35,14 +47,24 @@ export declare class VldString extends VldBase<string, string> {
      * Get the cached compiled validator, creating it if necessary
      */
     private _getCompiledValidator;
+    /**
+     * Returns true if this is a simple string validator with no transforms or checks
+     * Used by VldObject for optimized fast-path dispatch
+     */
+    get isSimple(): boolean;
     /**
      * Create a new string validator
      */
     static create(): VldString;
     /**
-     * Parse and validate a string value - ultra-optimized with pre-compiled validator
+     * Parse and validate a string value without allocating intermediate result objects.
      */
     parse(value: unknown): string;
+    /**
+     * Parse a value that has already passed the string type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownString(value: string): string;
     /**
      * Safely parse and validate a string value
      */
@@ -50,31 +72,31 @@ export declare class VldString extends VldBase<string, string> {
     /**
      * Create a new validator with minimum length constraint
      */
-    min(length: number, message?: string): VldString;
+    min(length: number, message?: ErrorParam): VldString;
     /**
      * Create a new validator with maximum length constraint
      */
-    max(length: number, message?: string): VldString;
+    max(length: number, message?: ErrorParam): VldString;
     /**
      * Create a new validator with exact length constraint
      */
-    length(length: number, message?: string): VldString;
+    length(length: number, message?: ErrorParam): VldString;
     /**
      * Create a new validator that checks for valid email format
      */
-    email(message?: string): VldString;
+    email(message?: ErrorParam): VldString;
     /**
      * Create a new validator that checks for valid URL format
      */
-    url(message?: string): VldString;
+    url(message?: ErrorParam): VldString;
     /**
      * Create a new validator that checks for valid UUID format
      */
-    uuid(message?: string): VldString;
+    uuid(message?: ErrorParam): VldString;
     /**
      * Create a new validator with regex pattern matching
      */
-    regex(pattern: RegExp, message?: string): VldString;
+    regex(pattern: RegExp, message?: ErrorParam): VldString;
     /**
      * Create a new validator that trims whitespace
      */
@@ -90,31 +112,30 @@ export declare class VldString extends VldBase<string, string> {
     /**
      * Create a new validator that checks if string starts with a substring
      */
-    startsWith(str: string, message?: string): VldString;
+    startsWith(str: string, message?: ErrorParam): VldString;
     /**
      * Create a new validator that checks if string ends with a substring
      */
-    endsWith(str: string, message?: string): VldString;
+    endsWith(str: string, message?: ErrorParam): VldString;
     /**
      * Create a new validator that checks if string includes a substring
      */
-    includes(str: string, message?: string): VldString;
+    includes(str: string, message?: ErrorParam): VldString;
     /**
      * Create a new validator that checks for valid IP address (v4 or v6)
      */
-    ip(message?: string): VldString;
+    ip(message?: ErrorParam): VldString;
     /**
      * Create a new validator that checks for valid IPv4 address
      */
-    ipv4(message?: string): VldString;
+    ipv4(message?: ErrorParam): VldString;
     /**
      * Create a new validator that checks for valid IPv6 address
      */
-    ipv6(message?: string): VldString;
+    ipv6(message?: ErrorParam): VldString;
     /**
      * Create a new validator that ensures string is not empty
      */
-    nonempty(message?: string): VldString;
+    nonempty(message?: ErrorParam): VldString;
 }
 export {};
-//# sourceMappingURL=string.d.ts.map

package/dist/validators/string.js

@@ -0,0 +1,4 @@
+import './base.js';
+import '../locales/runtime.js';
+export { V as VldString } from '../chunks/string-BJRQod3t.js';
+import '../chunks/errors-core-BeiFUtZM.js';

package/dist/validators/symbol.d.ts

@@ -1,9 +1,9 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Immutable symbol validator
  */
 export declare class VldSymbol extends VldBase<symbol, symbol> {
-    private readonly errorMessage?;
+    private readonly errorMessage;
     /**
      * Private constructor to enforce immutability
      */
@@ -12,13 +12,18 @@ export declare class VldSymbol extends VldBase<symbol, symbol> {
      * Create a new symbol validator
      */
     static create(): VldSymbol;
+    get isSimple(): boolean;
     /**
      * Parse and validate a symbol value
      */
     parse(value: unknown): symbol;
+    /**
+     * Parse a value that has already passed the symbol type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownSymbol(value: symbol): symbol;
     /**
      * Safely parse and validate a symbol value
      */
     safeParse(value: unknown): ParseResult<symbol>;
 }
-//# sourceMappingURL=symbol.d.ts.map

package/dist/validators/symbol.js

@@ -0,0 +1,58 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { getMessages } from '../locales/runtime.js';
+import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
+
+function createSymbolError(message) {
+    return new VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Immutable symbol validator
+ */
+class VldSymbol extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(errorMessage) {
+        super(VLD_VALIDATOR_TYPES.SYMBOL);
+        this.errorMessage = errorMessage;
+    }
+    /**
+     * Create a new symbol validator
+     */
+    static create() {
+        return new VldSymbol();
+    }
+    get isSimple() {
+        return true;
+    }
+    /**
+     * Parse and validate a symbol value
+     */
+    parse(value) {
+        if (typeof value !== 'symbol') {
+            throw new Error(this.errorMessage || getMessages().invalidSymbol);
+        }
+        return value;
+    }
+    /**
+     * Parse a value that has already passed the symbol type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownSymbol(value) {
+        return value;
+    }
+    /**
+     * Safely parse and validate a symbol value
+     */
+    safeParse(value) {
+        if (typeof value === 'symbol') {
+            return { success: true, data: value };
+        }
+        return {
+            success: false,
+            error: createSymbolError(this.errorMessage || getMessages().invalidSymbol)
+        };
+    }
+}
+
+export { VldSymbol };

package/dist/validators/template-literal.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Template literal component types
  */
@@ -29,4 +29,3 @@ export declare class VldTemplateLiteral extends VldBase<unknown, string> {
  */
 export declare function templateLiteral(...components: TLComponent[]): VldTemplateLiteral;
 export {};
-//# sourceMappingURL=template-literal.d.ts.map