unacy 0.1.0 → 0.1.2

package/dist/registry.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Converter registry with auto-composition via BFS
+ * @packageDocumentation
+ */
+import type { Converter, BidirectionalConverter } from './converters';
+import type { RelaxedWithUnits, UnitsFor, WithUnits } from './types';
+/**
+ * Represents a conversion edge from one unit to another
+ */
+type Edge<From extends string = string, To extends string = string> = readonly [From, To];
+/**
+ * Extract all unique 'from' units from a list of edges
+ */
+type FromUnits<Edges extends readonly Edge[]> = Edges[number][0];
+/**
+ * Extract all 'to' units for a specific 'from' unit string
+ */
+type ToUnitsFor<Edges extends readonly Edge[], FromUnit extends string> = Extract<Edges[number], readonly [FromUnit, any]>[1];
+/**
+ * Type for unit-based conversion accessors
+ * Provides the shape: registry.Celsius.to.Fahrenheit(value)
+ * Only allows conversions that have been registered
+ */
+export type ConverterMap<Edges extends readonly Edge[]> = {
+    [From in FromUnits<Edges>]: {
+        to: {
+            [To in ToUnitsFor<Edges, From>]: (value: RelaxedWithUnits<number, From>) => WithUnits<number, To>;
+        };
+    };
+};
+/**
+ * Registry for managing and composing unit converters
+ */
+export interface ConverterRegistry<Edges extends Edge[] = []> {
+    /**
+     * Register a unidirectional converter
+     *
+     * @param from - Source unit
+     * @param to - Destination unit
+     * @param converter - Converter function
+     * @returns New registry instance with the converter registered
+     */
+    register<From extends WithUnits<number, string>, To extends WithUnits<number, string>>(from: UnitsFor<From>, to: UnitsFor<To>, converter: Converter<From, To>): ConverterRegistry<[...Edges, Edge<UnitsFor<From>, UnitsFor<To>>]> & ConverterMap<[...Edges, Edge<UnitsFor<From>, UnitsFor<To>>]>;
+    /**
+     * Register a bidirectional converter (both directions)
+     *
+     * @param from - First unit
+     * @param to - Second unit
+     * @param converter - Bidirectional converter object
+     * @returns New registry instance with both converters registered
+     */
+    register<From extends WithUnits<number, string>, To extends WithUnits<number, string>>(from: UnitsFor<From>, to: UnitsFor<To>, converter: BidirectionalConverter<From, To>): ConverterRegistry<[
+        ...Edges,
+        Edge<UnitsFor<From>, UnitsFor<To>>,
+        Edge<UnitsFor<To>, UnitsFor<From>>
+    ]> & ConverterMap<[
+        ...Edges,
+        Edge<UnitsFor<From>, UnitsFor<To>>,
+        Edge<UnitsFor<To>, UnitsFor<From>>
+    ]>;
+    /**
+     * Register a bidirectional converter (both directions)
+     * @deprecated Use register() with BidirectionalConverter instead
+     *
+     * @param from - First unit
+     * @param to - Second unit
+     * @param converter - Bidirectional converter object
+     * @returns New registry instance with both converters registered
+     */
+    registerBidirectional<From extends WithUnits<number, string>, To extends WithUnits<number, string>>(from: UnitsFor<From>, to: UnitsFor<To>, converter: BidirectionalConverter<From, To>): ConverterRegistry<[
+        ...Edges,
+        Edge<UnitsFor<From>, UnitsFor<To>>,
+        Edge<UnitsFor<To>, UnitsFor<From>>
+    ]> & ConverterMap<[
+        ...Edges,
+        Edge<UnitsFor<From>, UnitsFor<To>>,
+        Edge<UnitsFor<To>, UnitsFor<From>>
+    ]>;
+    /**
+     * Explicitly allow a conversion path in the type system (for multi-hop conversions)
+     *
+     * This method verifies that a conversion path exists at runtime (via BFS) and adds it
+     * to the type system so it can be used with type-safe accessor syntax.
+     *
+     * @param from - Source unit string
+     * @param to - Destination unit string
+     * @returns New registry instance with the conversion path enabled in types
+     * @throws ConversionError if no path exists between the units
+     *
+     * @example
+     * ```typescript
+     * const registry = createRegistry()
+     *   .register('Celsius', 'Kelvin', c => (c + 273.15) as Kelvin)
+     *   .register('Kelvin', 'Fahrenheit', k => ((k - 273.15) * 9/5 + 32) as Fahrenheit)
+     *   .allow('Celsius', 'Fahrenheit'); // Enable multi-hop path in types
+     *
+     * // Now type-safe:
+     * const f = registry.Celsius.to.Fahrenheit(temp);
+     * ```
+     */
+    allow<From extends string, To extends string>(from: From, to: To): ConverterRegistry<[...Edges, Edge<From, To>]> & ConverterMap<[...Edges, Edge<From, To>]>;
+    /**
+     * Get a converter (direct or composed via BFS)
+     *
+     * @param from - Source unit
+     * @param to - Destination unit
+     * @returns Converter function, or undefined if no path exists
+     */
+    getConverter<From extends WithUnits<number, string>, To extends WithUnits<number, string>>(from: UnitsFor<From>, to: UnitsFor<To>): Converter<From, To> | undefined;
+    /**
+     * Convert a value using fluent API
+     *
+     * @param value - Value to convert
+     * @param fromUnit - Source unit
+     * @returns Object with to() method for conversion
+     */
+    convert<From extends WithUnits<number, string>>(value: From, fromUnit: UnitsFor<From>): {
+        to<To extends WithUnits<number, string>>(unit: UnitsFor<To>): To;
+    };
+}
+/**
+ * Create a new converter registry
+ *
+ * @returns Empty converter registry with unit-based accessors
+ *
+ * @example
+ * ```typescript
+ * type Celsius = WithUnits<number, 'Celsius'>;
+ * type Fahrenheit = WithUnits<number, 'Fahrenheit'>;
+ *
+ * const registry = createRegistry()
+ *   .register('Celsius', 'Fahrenheit', (c: Celsius) => ((c * 9/5) + 32) as Fahrenheit);
+ *
+ * const temp: Celsius = 25 as Celsius;
+ * const fahrenheit = registry.Celsius.to.Fahrenheit(temp);
+ * console.log(fahrenheit); // 77
+ * ```
+ */
+export declare function createRegistry(): ConverterRegistry<[]> & ConverterMap<[]>;
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAKrE;;GAEG;AACH,KAAK,IAAI,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAAE,EAAE,SAAS,MAAM,GAAG,MAAM,IAAI,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AAE1F;;GAEG;AACH,KAAK,SAAS,CAAC,KAAK,SAAS,SAAS,IAAI,EAAE,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAEjE;;GAEG;AACH,KAAK,UAAU,CAAC,KAAK,SAAS,SAAS,IAAI,EAAE,EAAE,QAAQ,SAAS,MAAM,IAAI,OAAO,CAC/E,KAAK,CAAC,MAAM,CAAC,EACb,SAAS,CAAC,QAAQ,EAAE,GAAG,CAAC,CACzB,CAAC,CAAC,CAAC,CAAC;AAEL;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,KAAK,SAAS,SAAS,IAAI,EAAE,IAAI;KACvD,IAAI,IAAI,SAAS,CAAC,KAAK,CAAC,GAAG;QAC1B,EAAE,EAAE;aACD,EAAE,IAAI,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAC/B,KAAK,EAAE,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,KACN,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC;SACvD,CAAC;KACH;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,KAAK,SAAS,IAAI,EAAE,GAAG,EAAE;IAC1D;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACnF,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,EACpB,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,EAChB,SAAS,EAAE,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC,GAC7B,iBAAiB,CAAC,CAAC,GAAG,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAClE,YAAY,CAAC,CAAC,GAAG,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/D;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACnF,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,EACpB,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,EAChB,SAAS,EAAE,sBAAsB,CAAC,IAAI,EAAE,EAAE,CAAC,GAC1C,iBAAiB,CAClB;QAAC,GAAG,KAAK;QAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;QAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;KAAC,CACnF,GACC,YAAY,CACV;QAAC,GAAG,KAAK;QAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;QAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;KAAC,CACnF,CAAC;IAEJ;;;;;;;;OAQG;IACH,qBAAqB,CACnB,IAAI,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACtC,EAAE,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAEpC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,EACpB,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,EAChB,SAAS,EAAE,sBAAsB,CAAC,IAAI,EAAE,EAAE,CAAC,GAC1C,iBAAiB,CAClB;QAAC,GAAG,KAAK;QAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;QAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;KAAC,CACnF,GACC,YAAY,CACV;QAAC,GAAG,KAAK;QAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;QAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;KAAC,CACnF,CAAC;IACJ;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAK,CAAC,IAAI,SAAS,MAAM,EAAE,EAAE,SAAS,MAAM,EAC1C,IAAI,EAAE,IAAI,EACV,EAAE,EAAE,EAAE,GACL,iBAAiB,CAAC,CAAC,GAAG,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,GAAG,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5F;;;;;;OAMG;IACH,YAAY,CAAC,IAAI,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACvF,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,EACpB,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,GACf,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,SAAS,CAAC;IACnC;;;;;;OAMG;IACH,OAAO,CAAC,IAAI,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5C,KAAK,EAAE,IAAI,EACX,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,GACvB;QACD,EAAE,CAAC,EAAE,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC;KAClE,CAAC;CACH;AAoND;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,IAAI,iBAAiB,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,EAAE,CAAC,CAEzE"}

package/dist/registry.js

@@ -0,0 +1,212 @@
+/**
+ * Converter registry with auto-composition via BFS
+ * @packageDocumentation
+ */
+import { ConversionError } from './errors';
+import { findShortestPath, composeConverters } from './utils/graph';
+/**
+ * Internal implementation of ConverterRegistry
+ */
+class ConverterRegistryImpl {
+    graph;
+    pathCache;
+    unitAccessors;
+    constructor(graph, pathCache) {
+        this.graph = graph || new Map();
+        this.pathCache = pathCache || new Map();
+        this.unitAccessors = new Map();
+        // Build unit accessors dynamically
+        this.buildUnitAccessors();
+    }
+    /**
+     * Build dynamic unit accessors for fluent API: registry.Celsius.to.Fahrenheit(value)
+     */
+    buildUnitAccessors() {
+        // Get all unique units from the graph (both from and to)
+        const allUnits = new Set();
+        for (const from of this.graph.keys()) {
+            allUnits.add(from);
+            const toMap = this.graph.get(from);
+            if (toMap) {
+                for (const to of toMap.keys()) {
+                    allUnits.add(to);
+                }
+            }
+        }
+        // For each unit, create a `to` object with converter functions
+        for (const fromUnit of allUnits) {
+            const toAccessors = {};
+            for (const toUnit of allUnits) {
+                if (fromUnit !== toUnit) {
+                    // Create converter function that will look up the converter at call time
+                    toAccessors[toUnit] = (value) => {
+                        const converter = this.getConverter(fromUnit, toUnit);
+                        if (!converter) {
+                            throw new ConversionError(fromUnit, toUnit, 'No converter found');
+                        }
+                        return converter(value);
+                    };
+                }
+            }
+            // Wrap toAccessors in a Proxy to handle unknown units dynamically
+            const toProxy = new Proxy(toAccessors, {
+                get: (target, toProp) => {
+                    if (typeof toProp === 'symbol') {
+                        return target[toProp];
+                    }
+                    // If accessor exists, return it
+                    if (toProp in target) {
+                        return target[toProp];
+                    }
+                    // Otherwise, create a dynamic converter function
+                    return (value) => {
+                        const converter = this.getConverter(fromUnit, toProp);
+                        if (!converter) {
+                            throw new ConversionError(fromUnit, toProp, 'No converter found');
+                        }
+                        return converter(value);
+                    };
+                }
+            });
+            this.unitAccessors.set(fromUnit, { to: toProxy });
+        }
+    }
+    register(from, to, converter) {
+        // Check if it's a bidirectional converter
+        if (typeof converter === 'object' && 'to' in converter && 'from' in converter) {
+            // Handle bidirectional converter
+            const biConverter = converter;
+            return this.register(from, to, biConverter.to).register(to, from, biConverter.from);
+        }
+        // Handle unidirectional converter
+        const newGraph = new Map(this.graph);
+        if (!newGraph.has(from)) {
+            newGraph.set(from, new Map());
+        }
+        const fromMap = new Map(newGraph.get(from));
+        fromMap.set(to, converter);
+        newGraph.set(from, fromMap);
+        // Return new registry instance (immutable) with proxy
+        return createRegistryFromGraph(newGraph, new Map());
+    }
+    registerBidirectional(from, to, converter) {
+        return this.register(from, to, converter.to).register(to, from, converter.from);
+    }
+    allow(from, to) {
+        // Verify that a conversion path exists at runtime
+        const converter = this.getConverter(from, to);
+        if (!converter) {
+            throw new ConversionError(from, to, 'No conversion path exists');
+        }
+        // Return the same registry instance with updated type information
+        // The actual conversion already works via BFS, we just need to expose it in types
+        return this;
+    }
+    getConverter(from, to) {
+        // Check cache first
+        const cacheKey = `${String(from)}->${String(to)}`;
+        const cached = this.pathCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        // Try direct lookup (O(1))
+        const fromMap = this.graph.get(from);
+        if (fromMap) {
+            const direct = fromMap.get(to);
+            if (direct) {
+                this.pathCache.set(cacheKey, direct);
+                return direct;
+            }
+        }
+        // Fallback to BFS for multi-hop path
+        try {
+            const path = findShortestPath(from, to, this.graph);
+            if (!path) {
+                return undefined;
+            }
+            const composed = composeConverters(path, this.graph);
+            this.pathCache.set(cacheKey, composed);
+            return composed;
+        }
+        catch (error) {
+            // For cycle and max depth errors, we should propagate them
+            // For other errors, return undefined
+            if (error instanceof Error &&
+                (error.constructor.name === 'CycleError' || error.constructor.name === 'MaxDepthError')) {
+                throw error;
+            }
+            return undefined;
+        }
+    }
+    convert(value, fromUnit) {
+        return {
+            to: (unit) => {
+                const converter = this.getConverter(fromUnit, unit);
+                if (!converter) {
+                    throw new ConversionError(fromUnit, unit, 'No converter found');
+                }
+                return converter(value);
+            }
+        };
+    }
+}
+/**
+ * Create a new converter registry
+ *
+ * @returns Empty converter registry with unit-based accessors
+ *
+ * @example
+ * ```typescript
+ * type Celsius = WithUnits<number, 'Celsius'>;
+ * type Fahrenheit = WithUnits<number, 'Fahrenheit'>;
+ *
+ * const registry = createRegistry()
+ *   .register('Celsius', 'Fahrenheit', (c: Celsius) => ((c * 9/5) + 32) as Fahrenheit);
+ *
+ * const temp: Celsius = 25 as Celsius;
+ * const fahrenheit = registry.Celsius.to.Fahrenheit(temp);
+ * console.log(fahrenheit); // 77
+ * ```
+ */
+export function createRegistry() {
+    return createRegistryFromGraph();
+}
+/**
+ * Internal helper to create a registry with proxy from an existing graph
+ */
+function createRegistryFromGraph(graph, pathCache) {
+    const registryImpl = new ConverterRegistryImpl(graph, pathCache);
+    // Create a Proxy to intercept property access for unit accessors
+    return new Proxy(registryImpl, {
+        get(target, prop) {
+            // If the property exists on the registry implementation, return it
+            if (prop in target || typeof prop === 'symbol') {
+                return target[prop];
+            }
+            // Otherwise, check if it's a unit accessor
+            const unitAccessor = target.unitAccessors.get(prop);
+            if (unitAccessor) {
+                return unitAccessor;
+            }
+            // For unknown units, create a dynamic accessor that will throw ConversionError
+            // This handles cases where a unit is referenced but not in the registry
+            return {
+                to: new Proxy({}, {
+                    get: (_, toProp) => {
+                        if (typeof toProp === 'symbol') {
+                            return undefined;
+                        }
+                        return (value) => {
+                            const converter = target.getConverter(prop, toProp);
+                            if (!converter) {
+                                throw new ConversionError(prop, toProp, 'No converter found');
+                            }
+                            return converter(value);
+                        };
+                    }
+                })
+            };
+        }
+    });
+}
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Core type branding utilities for unit and format safety
+ * @packageDocumentation
+ */
+import type { GetTagMetadata, Tagged } from 'type-fest';
+export declare const UNITS: unique symbol;
+/**
+ * Brand a value with a unit identifier for compile-time unit safety.
+ *
+ * @template T - Base type (e.g., number, bigint)
+ * @template U - Unit identifier (e.g., 'Celsius', 'meters')
+ *
+ * @example
+ * ```typescript
+ * type Celsius = WithUnits<number, 'Celsius'>;
+ * const temp: Celsius = 25 as Celsius;
+ * ```
+ */
+export type WithUnits<T, U extends string> = Tagged<T, typeof UNITS, U>;
+export type RelaxedWithUnits<T, U extends string> = T | WithUnits<T, U>;
+export type Relax<T> = T extends WithUnits<infer U, string> ? U : T;
+/**
+ * Brand a value with a format identifier for compile-time format safety.
+ *
+ * @template T - Base type (e.g., Date, number, string)
+ * @template F - Format identifier (e.g., 'ISO8601', 'UnixTimestamp')
+ *
+ * @example
+ * ```typescript
+ * type ISO8601 = WithFormat<Date, 'ISO8601'>;
+ * const date: ISO8601 = new Date() as ISO8601;
+ * ```
+ */
+export type WithFormat<T, F extends string> = Tagged<T, typeof UNITS, F>;
+export type UnitsFor<T extends WithUnits<unknown, string>> = GetTagMetadata<T, typeof UNITS>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExD,eAAO,MAAM,KAAK,EAAE,OAAO,MAAwB,CAAC;AACpD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,MAAM,CAAC,CAAC,EAAE,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC;AAExE,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAExE,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEpE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,MAAM,CAAC,CAAC,EAAE,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC;AAEzE,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC"}

package/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * Core type branding utilities for unit and format safety
+ * @packageDocumentation
+ */
+export const UNITS = Symbol('UNITS');
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,CAAC,MAAM,KAAK,GAAkB,MAAM,CAAC,OAAO,CAAC,CAAC"}

package/dist/utils/graph.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Graph traversal utilities for converter registry
+ * @packageDocumentation
+ */
+import type { Converter } from '../converters';
+/**
+ * Find the shortest path between two nodes using BFS.
+ *
+ * @param from - Starting node
+ * @param to - Target node
+ * @param adjacencyMap - Graph represented as adjacency list
+ * @returns Array of nodes representing the shortest path, or null if no path exists
+ * @throws {CycleError} If a cycle is detected during traversal
+ * @throws {MaxDepthError} If path depth exceeds MAX_DEPTH
+ */
+export declare function findShortestPath(from: PropertyKey, to: PropertyKey, adjacencyMap: Map<PropertyKey, Map<PropertyKey, unknown>>): PropertyKey[] | null;
+/**
+ * Compose multiple converters along a path into a single converter.
+ *
+ * @param path - Array of nodes representing the conversion path
+ * @param registry - Map of converters keyed by [from, to]
+ * @returns Composed converter function
+ * @throws {Error} If any converter in the path is missing
+ */
+export declare function composeConverters(path: PropertyKey[], registry: Map<PropertyKey, Map<PropertyKey, Converter<any, any>>>): Converter<any, any>;
+//# sourceMappingURL=graph.d.ts.map

package/dist/utils/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/utils/graph.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAO/C;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,WAAW,EACjB,EAAE,EAAE,WAAW,EACf,YAAY,EAAE,GAAG,CAAC,WAAW,EAAE,GAAG,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,GACxD,WAAW,EAAE,GAAG,IAAI,CA8CtB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,WAAW,EAAE,EACnB,QAAQ,EAAE,GAAG,CAAC,WAAW,EAAE,GAAG,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,GAChE,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CA4BrB"}

package/dist/utils/graph.js

@@ -0,0 +1,91 @@
+/**
+ * Graph traversal utilities for converter registry
+ * @packageDocumentation
+ */
+import { CycleError, MaxDepthError } from '../errors';
+/**
+ * Maximum allowed conversion path depth to prevent infinite loops
+ */
+const MAX_DEPTH = 5;
+/**
+ * Find the shortest path between two nodes using BFS.
+ *
+ * @param from - Starting node
+ * @param to - Target node
+ * @param adjacencyMap - Graph represented as adjacency list
+ * @returns Array of nodes representing the shortest path, or null if no path exists
+ * @throws {CycleError} If a cycle is detected during traversal
+ * @throws {MaxDepthError} If path depth exceeds MAX_DEPTH
+ */
+export function findShortestPath(from, to, adjacencyMap) {
+    // Handle self-conversion (cycle detection)
+    if (from === to) {
+        throw new CycleError([from, to]);
+    }
+    // BFS queue: [currentNode, path]
+    const queue = [[from, [from]]];
+    const visited = new Set();
+    visited.add(from);
+    while (queue.length > 0) {
+        const [current, path] = queue.shift();
+        // Get neighbors
+        const neighbors = adjacencyMap.get(current);
+        if (!neighbors) {
+            continue;
+        }
+        // Explore neighbors
+        for (const neighbor of neighbors.keys()) {
+            // Check max depth before extending path
+            // path currently has N nodes (N-1 edges); adding neighbor would make N+1 nodes (N edges)
+            const numEdges = path.length; // Number of edges after adding neighbor
+            if (numEdges > MAX_DEPTH) {
+                throw new MaxDepthError(from, to, MAX_DEPTH);
+            }
+            // Found target
+            if (neighbor === to) {
+                return [...path, neighbor];
+            }
+            // Cycle detection: if we've already visited this node in this path, skip it
+            if (visited.has(neighbor)) {
+                continue;
+            }
+            visited.add(neighbor);
+            queue.push([neighbor, [...path, neighbor]]);
+        }
+    }
+    // No path found
+    return null;
+}
+/**
+ * Compose multiple converters along a path into a single converter.
+ *
+ * @param path - Array of nodes representing the conversion path
+ * @param registry - Map of converters keyed by [from, to]
+ * @returns Composed converter function
+ * @throws {Error} If any converter in the path is missing
+ */
+export function composeConverters(path, registry) {
+    if (path.length < 2) {
+        throw new Error('Path must contain at least 2 nodes');
+    }
+    // Build array of converters
+    const converters = [];
+    for (let i = 0; i < path.length - 1; i++) {
+        const from = path[i];
+        const to = path[i + 1];
+        const converterMap = registry.get(from);
+        if (!converterMap) {
+            throw new Error(`No converters registered from ${String(from)}`);
+        }
+        const converter = converterMap.get(to);
+        if (!converter) {
+            throw new Error(`No converter registered from ${String(from)} to ${String(to)}`);
+        }
+        converters.push(converter);
+    }
+    // Compose converters: apply them left-to-right
+    return (input) => {
+        return converters.reduce((value, converter) => converter(value), input);
+    };
+}
+//# sourceMappingURL=graph.js.map

package/dist/utils/graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../src/utils/graph.ts"],"names":[],"mappings":"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"}

package/dist/utils/validation.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Runtime validation helpers for parsers
+ * @packageDocumentation
+ */
+import type { ZodSchema } from 'zod';
+import type { Parser } from '../formatters';
+import type { WithFormat } from '../types';
+/**
+ * Create a parser with Zod schema validation.
+ *
+ * @template F - Format identifier
+ * @template T - Base type
+ * @param schema - Zod schema for validation
+ * @param format - Format identifier string
+ * @returns Parser function that validates and tags values
+ *
+ * @example
+ * ```typescript
+ * const parseHex = createParserWithSchema(
+ *   z.string().regex(/^#[0-9A-Fa-f]{6}$/),
+ *   'HexColor'
+ * );
+ * ```
+ */
+export declare function createParserWithSchema<F extends string, T>(schema: ZodSchema<T>, format: F): Parser<WithFormat<T, F>>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/utils/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/utils/validation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAG3C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EACxD,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EACpB,MAAM,EAAE,CAAC,GACR,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAU1B"}

package/dist/utils/validation.js

@@ -0,0 +1,35 @@
+/**
+ * Runtime validation helpers for parsers
+ * @packageDocumentation
+ */
+import { ParseError } from '../errors';
+/**
+ * Create a parser with Zod schema validation.
+ *
+ * @template F - Format identifier
+ * @template T - Base type
+ * @param schema - Zod schema for validation
+ * @param format - Format identifier string
+ * @returns Parser function that validates and tags values
+ *
+ * @example
+ * ```typescript
+ * const parseHex = createParserWithSchema(
+ *   z.string().regex(/^#[0-9A-Fa-f]{6}$/),
+ *   'HexColor'
+ * );
+ * ```
+ */
+export function createParserWithSchema(schema, format) {
+    return (input) => {
+        try {
+            const validated = schema.parse(input);
+            return validated;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new ParseError(format, input, message);
+        }
+    };
+}
+//# sourceMappingURL=validation.js.map

package/dist/utils/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../src/utils/validation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,sBAAsB,CACpC,MAAoB,EACpB,MAAS,EACiB;IAC1B,OAAO,CAAC,KAAa,EAAoB,EAAE,CAAC;QAC1C,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACtC,OAAO,SAA6B,CAAC;QACvC,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACjE,MAAM,IAAI,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAC/C,CAAC;IAAA,CACF,CAAC;AAAA,CACH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unacy",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Type-safe unit and format conversion library",
   "type": "module",
   "private": false,
@@ -20,21 +20,21 @@
     "README.md"
   ],
   "dependencies": {
-    "type-fest": "^5.3.1",
-    "zod": "^3.24.1"
+    "type-fest": "^5.3.1"
   },
   "devDependencies": {
     "@types/node": "^25.0.3",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "@typescript/native-preview": "7.0.0-dev.20260107.1",
+    "vitest": "^4.0.16",
+    "zod": "^4.3.5"
   },
   "engines": {
     "node": ">=20.0.0"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsgo",
     "clean": "rm -rf dist",
-    "type-check": "tsc --noEmit",
+    "type-check": "tsgo --noEmit",
     "test": "vitest run",
     "test:watch": "vitest"
   }