@vicin/phantom 1.0.8 → 1.1.0

package/README.md

@@ -5,7 +5,7 @@
 > - 🎉 First stable release — v1.0! Happy coding! 😄💻
 > - 📄 **Changelog:** [CHANGELOG.md](./CHANGELOG.md)
 
-`Phantom` is a powerful, lightweight TypeScript library for nominal typing. it uses **type-only** metadata object that can be attached to any type with clean IDE. It enables compile-time distinctions between structurally identical types (e.g., `Email` vs. `Username` as branded strings) while supporting advanced features like **constrained identities**,**state variants**, **additive traits**, and **reversible transformations**. making it ideal for domain-driven design (DDD), APIs, and type-safe primitives with minimal performance overhead.
+`Phantom` is a powerful, lightweight TypeScript library for nominal typing. it uses **type-only** metadata object that can be attached to any type with clean IDE. It enables compile-time distinctions between structurally identical types (e.g., `Email` vs. `Username` as branded strings) while supporting advanced features like **constrained identities**,**state variants**, **additive traits**, and **reversible transformations**. making it ideal for domain-driven design (DDD), APIs, and type-safe primitives with near zero performance overhead.
 
 ---
 
@@ -17,7 +17,6 @@
   - [Terminology](#terminology)
   - [\_\_Phantom object](#__phantom-object)
 - [Type constructs](#type-constructs)
-  - [Branding](#branding)
   - [Identities with constraints](#identities-with-constraints)
   - [Traits (additive capabilities)](#traits-additive-capabilities)
   - [Transformations (Type pipe-like behavior)](#transformations-type-pipe-like-behavior)
@@ -29,6 +28,7 @@
 - [Debugging](#debugging)
 - [API reference](#api-reference)
 - [Full examples](#full-examples)
+- [Deprecated API](#deprecated-api)
 - [Sigil](#sigil)
 - [Contributing](#contributing)
 - [License](#license)
@@ -101,6 +101,7 @@ type X = string & {
   __Phantom: {
     __Tag: 'X';
     __Label?: 'Label of X';
+    __Base?: string;
     __Variants: 'Variant1' | 'Variant2';
     __Traits: {
       trait1: true;
@@ -118,6 +119,8 @@ From the first glance you can spot that`Phantom` is designed to separate origina
 
 - **\_\_Label?:** Optional label describing this nominal identity.
 
+- **\_\_Base?:** Optional constraint to nominal identity, so only values that extend this type can be branded.
+
 - **\_\_Variants:** Optional states of the nominal identity.
 
 - **\_\_Traits:** Additional properties the type holds, unlike `__Tag` that tells who `__Traits` tell what this type hold or can do (e.g. `Validated`, `PII` etc...).
@@ -132,51 +135,6 @@ More details of these properties will be discussed later.
 
 ## Type constructs
 
-### Branding
-
-Use brands for simple nominal distinctions on primitives.
-
-#### Structure
-
-**`Brand.Declare<Tag, Label?>`**
-
-- **Tag:** Unique identifier which can string or symbol.
-- **Label?:** Optional label description. can be set to `never`.
-
-#### Basic example
-
-```ts
-import { Phantom } from '@vicin/phantom';
-
-// Declare a brand
-type UserId = Phantom.Brand.Declare<'UserId', 'Unique user identifier'>;
-
-// Assertor for assigning the brand
-const asUserId = Phantom.assertors.asBrand<UserId>();
-
-// Usage
-const id: string = '123';
-const userId = asUserId(id); // type: string & { __Phantom: { __Tag: "UserId"; __Label?: "Unique user identifier"; __OriginalType: string; } }
-
-// Type safety: prevents assignment
-let postId: string = 'abc';
-postId = userId; // Type error: 'UserId' is not assignable to unbranded string
-```
-
-#### Re-brand
-
-Branding already branded value is prohibited and results in Error type:
-
-```ts
-const value = '123';
-
-// Branding string as UserId
-const userId = asUserId(value);
-
-// Trying to brand userId as PostId returns type error
-const postId = asPostId(userId); // type: Flow.TypeError<{ code: "ALREADY_BRANDED"; message: "Type already branded"; context: { type: <userId type>; }; }>
-```
-
 ---
 
 ### Identities with constraints
@@ -189,7 +147,8 @@ const postId = asPostId(userId); // type: Flow.TypeError<{ code: "ALREADY_BRANDE
 
 - **Tag:** Unique identifier which can string or symbol.
 - **Label?:** Optional label description. can be set to `never`.
-- **Base?:** Optional base that constrains identity so only `string` for example can be casted as `Email`. can be set to `never`.
+- **Base?:** Optional base that constrains identity so only `string` for example can be casted as `Email`. can be set to `never` or `unknown`.
+  Type passed is also added to declared `Identity` (`<Base> & <PhantomObject>`).
 - **Variants?:** Optional variants (states) of the identity. can be set to `never`.
 
 #### Basic example
@@ -320,7 +279,8 @@ Type identity is `Transformed` and stores `Input` under special field inside `__
 - **Input:** Type input to the transformation.
 - **Tag:** Unique identifier of transformed which can string or symbol.
 - **Label?:** Optional label description of transformed. can be set to `never`.
-- **Base?:** Optional base that constrains identity of transformed so only `Uint8Array` for example can be casted as `Encoded`. can be set to `never`.
+- **Base?:** Optional base that constrains identity of transformed so only `Uint8Array` for example can be casted as `Encoded`. can be set to `never` or `unknown`.
+  Type passed is also added to declared `Transformation` (`<Base> & <PhantomObject>`).
 - **Variants?:** Optional variants (states) of the identity. can be set to `never`.
 
 #### Basic example
@@ -394,7 +354,7 @@ When passed value violate specific rule, descripted `ErrorType` is returned.
 
 **ErrorTypes:**
 
-- **ALREADY_BRANDED:** Error returned if already branded value (with either `Brand` or `Identity`) is passed to `.Assign<>` again.
+- **ALREADY_BRANDED:** Error returned if already branded value (with `Identity`) is passed to `.Assign<>` again.
 
 - **TYPE_NOT_EXTEND_BASE:** Error returned if type not extend `Base` constraint of `Identity`.
 
@@ -402,7 +362,7 @@ When passed value violate specific rule, descripted `ErrorType` is returned.
 
 - **NOT_TRANSFORMED:** Error returned if you tried to revert a non-transformed type.
 
-All the types inside `Phantom` check for `ErrorType` first before applying any change, so if you tried to pass `ErrorType` to `Brand.Assign<>` or `asBrand<B>()` for example the error will return unchanged.
+All the types inside `Phantom` check for `ErrorType` first before applying any change, so if you tried to pass `ErrorType` to `Identity.Assign<>` or `asIdentity<B>()` for example the error will return unchanged.
 
 ---
 
@@ -415,7 +375,7 @@ import { Phantom } from '@vicin/phantom';
 
 // type
 declare const __UserId: unique symbol;
-type UserId = Phantom.Brand.Declare<typeof __UserId, 'User id'>;
+type UserId = Phantom.Identity.Declare<typeof __UserId, 'User id'>;
 
 // assertor
 export const asUserId = Phantom.assertors.asBrand<UserId>();
@@ -430,11 +390,11 @@ Now `UserId` can't be re-defined anywhere else in the codebase.
 Some devs (including me) may find `Phantom` namespace everywhere repetitive and prefer using `Brand` or `assertors` directly, every namespace under `Phantom` can be imported alone:
 
 ```ts
-import { Brand, assertors } from '@vicin/phantom';
+import { Identity, assertors } from '@vicin/phantom';
 
 // type
 declare const __UserId: unique symbol; // declare type only unique symbol to be our tag
-type UserId = Brand.Declare<typeof __UserId, 'User id'>;
+type UserId = Identity.Declare<typeof __UserId, 'User id'>;
 
 // assertor
 export const asUserId = assertors.asBrand<UserId>();
@@ -447,13 +407,13 @@ import P from '@vicin/phantom';
 
 // type
 declare const __UserId: unique symbol; // declare type only unique symbol to be our tag
-type UserId = P.Brand.Declare<typeof __UserId, 'User id'>;
+type UserId = P.Identity.Declare<typeof __UserId, 'User id'>;
 
 // assertor
 export const asUserId = P.assertors.asBrand<UserId>();
 ```
 
-Also you can import single assertor function:
+Also you can import single run-time function as `assertor functions` and `stripPhantom` function:
 
 ```ts
 import { asBrand } from '@vicin/phantom';
@@ -470,9 +430,9 @@ You are free to pick whatever pattern you are comfortable with.
 If you need to call multiple assertors on a single value (e.g. mark brand and attach two traits) the code can get messy:
 
 ```ts
-import { Brand, Trait, assertors } from '@vicin/phantom';
+import { Identity, Trait, assertors } from '@vicin/phantom';
 
-type UserId = Brand.Declare<'UserId'>;
+type UserId = Identity.Declare<'UserId', 'User id', string>;
 const asUserId = assertors.asBrand<UserId>();
 
 type PII = Trait.Declare<'PII'>;
@@ -508,17 +468,6 @@ The `.with()` is order sensitive, so previous example is equivalent to `addValid
 
 In hot-path code every function call matters, and although assertor functions makes code much cleaner but you may prefer to use `as` in performance critical situations so `Phantom` lives in type system entirely and have zero run-time trace, these examples defines best practices to do so:
 
-**Brand**:
-
-```ts
-import { Brand } from '@vicin/phantom';
-
-type UserId = Brand.Declare<'UserId'>;
-type AsUserId<T> = Brand.Assign<UserId, T>;
-
-const userId = '123' as AsUserId<string>;
-```
-
 **Identity**:
 
 ```ts
@@ -568,10 +517,10 @@ function decode<E extends Encoded>(encoded: E) {
 Chaining is not supported in **type-only pattern** and nesting is the only way to reliably calculate types:
 
 ```ts
-import { Brand, Trait, assertors } from '@vicin/phantom';
+import { Identity, Trait, assertors } from '@vicin/phantom';
 
-type UserId = Brand.Declare<'UserId'>;
-type AsUserId<T> = Brand.Assign<UserId, T>;
+type UserId = Identity.Declare<'UserId', 'User id', string>;
+type AsUserId<T> = Identity.Assign<UserId, T>;
 
 type PII = Trait.Declare<'PII'>;
 type AddPII<T> = Trait.Add<PII, T>;
@@ -635,13 +584,6 @@ These handle individual metadata fields in the `__Phantom` object.
 
 These provide nominal typing and metadata operations.
 
-- **Brand:** Simple nominal branding.
-  - `Any`: Marker for branded types.
-  - `Declare<T, L>`: Declare a brand with tag `T` and optional label `L`.
-  - `Assign<B, T>`: Assign brand `B` to `T` (fails if already branded).
-  - `AssignSafe<B, T>`: Assign if possible, else return `T`.
-  - `isBrand<T, B>`: Check if `T` is branded with `B`.
-
 - **Identity**: Brands with bases and variants.
   - `Any`: Marker for identity types.
   - `Declare<T, L, B, V>`: Declare identity with tag `T`, label `L`, base `B`, variants `V`.
@@ -682,7 +624,6 @@ Aliases for core and feature extractors: `LabelOf<T>`, `HasLabel<T, L>`, `TagOf<
 
 Zero-cost casting functions.
 
-`asBrand<B>()`: Assign brand `B`.
 `asIdentity<I>()`: Assign identity `I`.
 `addTrait<Tr>()`: Add trait `Tr`.
 `addTraits<Tr[]>()`: Add multiple traits `Tr[]`.
@@ -705,10 +646,10 @@ Zero-cost casting functions.
 Defining brands and identities at our app entry points after validation:
 
 ```ts
-import { Brand, assertors } from '@vicin/phantom';
+import { Identity, assertors } from '@vicin/phantom';
 
 declare const __UserId: unique symbol;
-type UserId = Brand.Declare<typeof __UserId, 'UserId'>;
+type UserId = Identity.Declare<typeof __UserId, 'UserId', string>;
 const asUserId = assertors.asBrand<UserId>();
 
 function validateUserId(userId: string) {
@@ -859,6 +800,22 @@ function hash<V>(value: V) {
 
 ---
 
+## Deprecated API
+
+### Brand
+
+To unify Api surface `Identity` should be used instead. **marked with `deprecated` and will be removed in v2.0.0**
+
+### asBrand
+
+To unify Api surface `asIdentity` should be used instead. **marked with `deprecated` and will be removed in v2.0.0**
+
+### isBrand
+
+To unify Api surface `isIdentity` should be used instead. **marked with `deprecated` and will be removed in v2.0.0**
+
+---
+
 ## Sigil
 
 `Sigil` is another lightweight TypeScript library I created for **nominal identity on classes**, providing compile-time branding and reliable runtime type checks. It solves the unreliability of `instanceof` in monorepos, bundled/HMR environments (where classes can duplicate), and manual branding boilerplate in DDD by using `symbols`, `lineages`, and a `centralized registry` for stable identity across codebases.

package/dist/index.d.mts

@@ -6,6 +6,8 @@ declare namespace assertors {
      * with the brand's nominal type applied. Use it for simple branded primitives
      * where you know the value is valid.
      *
+     * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+     *
      * @template B - The brand declaration to assign.
      * @returns A function that casts any value to the branded type.
      */
@@ -311,6 +313,15 @@ declare namespace VariantsCore {
     } ? true : false;
 }
 
+/** Stip phantom metadata object from a type */
+type StripPhantom<T> = T extends {
+    __Phantom: {
+        __OriginalType?: infer O;
+    };
+} ? Exclude<O, undefined> : T;
+/** run-time helper for 'StringPhantom', used for debugging mainly */
+declare const stripPhantom: <T>(value: T) => StripPhantom<T>;
+type _StripPhantom<T> = StripPhantom<T>;
 /**
  * Phantom meatadata object manipulators.
  *
@@ -322,13 +333,13 @@ declare namespace PhantomCore {
         __Phantom: infer Phantom extends object;
     } ? Phantom : never;
     /** Stip phantom metadata object from a type */
-    type StripPhantom<T> = T extends {
+    type StripPhantom<T> = _StripPhantom<T>;
+    /** run-time helper for 'StringPhantom', used for debugging mainly */
+    const stripPhantom: <T>(value: T) => T extends {
         __Phantom: {
             __OriginalType?: infer O;
         };
     } ? Exclude<O, undefined> : T;
-    /** run-time helper for 'StringPhantom', used for debugging mainly */
-    const stripPhantom: <T>(value: T) => StripPhantom<T>;
 }
 
 /** Interface of 'Brand' and 'Identity' errors. */
@@ -441,6 +452,8 @@ type Merge<O1 extends object, O2 extends object> = Prettify<Omit<O1, keyof O2> &
  *
  * Brands provide nominal typing for otherwise identical values.
  * A value may only be branded once.
+ *
+ * @deprecated To unify Api surface 'Identity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
  */
 declare namespace BrandCore {
     /** Type guard for any brand. */
@@ -476,7 +489,7 @@ declare namespace IdentityCore {
     /** Type guard for any identity. */
     export type Any = TagCore.Of<string | symbol>;
     /** Declare an identity */
-    export type Declare<T extends string | symbol, L extends string = never, B extends unknown = never, V extends string = never> = Prettify<TagCore.Of<T> & LabelCore.OfIfExists<L> & BaseCore.OfIfExists<B> & VariantsCore.OfIfExists<V>>;
+    export type Declare<T extends string | symbol, L extends string = never, B extends unknown = never, V extends string = never> = IfNever<B, unknown> & Prettify<TagCore.Of<T> & LabelCore.OfIfExists<L> & BaseCore.OfIfExists<B> & VariantsCore.OfIfExists<V>>;
     /**
      * Assign an identity to a value.
      * Enforces base-type compatibility.
@@ -541,7 +554,7 @@ declare namespace TransformationCore {
     /** Type guard for any transformation. */
     export type Any = InputCore.Of<any> & TagCore.Of<string | symbol>;
     /** Declare a transformation */
-    export type Declare<I, T extends string | symbol, L extends string = never, B extends unknown = never, V extends string = never> = Prettify<InputCore.Of<I> & TagCore.Of<T> & LabelCore.OfIfExists<L> & BaseCore.OfIfExists<B> & VariantsCore.OfIfExists<V>>;
+    export type Declare<I, T extends string | symbol, L extends string = never, B extends unknown = never, V extends string = never> = IfNever<B, unknown> & Prettify<InputCore.Of<I> & TagCore.Of<T> & LabelCore.OfIfExists<L> & BaseCore.OfIfExists<B> & VariantsCore.OfIfExists<V>>;
     /**
      * Apply a transformation to a value.
      * Enforces base-type compatibility.
@@ -656,6 +669,8 @@ declare namespace Traits {
  *
  * Brands provide nominal typing for otherwise identical values.
  * A value may only be branded once.
+ *
+ * @deprecated To unify Api surface 'Identity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
  */
 declare namespace Brand {
     /** Type guard for any brand. */
@@ -767,7 +782,11 @@ declare namespace Inspect {
     type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;
     /** Check if any traits exist */
     type HasTraits<T> = TraitsCore.HasTraits<T>;
-    /** Check whether value is branded with */
+    /**
+     * Check whether value is branded with
+     *
+     * @deprecated To unify Api surface 'isIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+     */
     type isBrand<T, B extends BrandCore.Any> = BrandCore.isBrand<T, B>;
     /** Check whether value is branded with */
     type isIdentity<T, I extends IdentityCore.Any> = IdentityCore.isIdentity<T, I>;
@@ -784,6 +803,8 @@ declare namespace Inspect {
  * with the brand's nominal type applied. Use it for simple branded primitives
  * where you know the value is valid.
  *
+ * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+ *
  * @template B - The brand declaration to assign.
  * @returns A function that casts any value to the branded type.
  */
@@ -1000,6 +1021,8 @@ declare namespace Phantom {
      *
      * Brands provide nominal typing for otherwise identical values.
      * A value may only be branded once.
+     *
+     * @deprecated To unify Api surface 'Identity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
      */
     namespace Brand {
         /** Type guard for any brand. */
@@ -1089,7 +1112,11 @@ declare namespace Phantom {
         /** Stip phantom metadata object from a type */
         type StripPhantom<T> = PhantomCore.StripPhantom<T>;
         /** run-time helper for 'StringPhantom', used for debugging mainly */
-        const stripPhantom: <T>(value: T) => PhantomCore.StripPhantom<T>;
+        const stripPhantom: <T>(value: T) => T extends {
+            __Phantom: {
+                __OriginalType?: infer O;
+            };
+        } ? Exclude<O, undefined> : T;
         /** Extract the label */
         type LabelOf<T> = LabelCore.LabelOf<T>;
         /** Check whether a base constraint exists */
@@ -1116,7 +1143,11 @@ declare namespace Phantom {
         type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;
         /** Check if any traits exist */
         type HasTraits<T, Tr extends string | symbol = string | symbol> = TraitsCore.HasTraits<T, Tr>;
-        /** Check whether value is branded with */
+        /**
+         * Check whether value is branded with
+         *
+         * @deprecated To unify Api surface 'isIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+         */
         type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;
         /** Check whether value is branded with */
         type isIdentity<T, I extends Identity.Any> = IdentityCore.isIdentity<T, I>;
@@ -1136,6 +1167,8 @@ declare namespace Phantom {
          * with the brand's nominal type applied. Use it for simple branded primitives
          * where you know the value is valid.
          *
+         * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+         *
          * @template B - The brand declaration to assign.
          * @returns A function that casts any value to the branded type.
          */
@@ -1220,6 +1253,8 @@ declare namespace Phantom {
      * with the brand's nominal type applied. Use it for simple branded primitives
      * where you know the value is valid.
      *
+     * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+     *
      * @template B - The brand declaration to assign.
      * @returns A function that casts any value to the branded type.
      */
@@ -1304,7 +1339,11 @@ declare namespace Phantom {
     /** Stip phantom metadata object from a type */
     type StripPhantom<T> = PhantomCore.StripPhantom<T>;
     /** run-time helper for 'StringPhantom', used for debugging mainly */
-    const stripPhantom: <T>(value: T) => PhantomCore.StripPhantom<T>;
+    const stripPhantom: <T>(value: T) => T extends {
+        __Phantom: {
+            __OriginalType?: infer O;
+        };
+    } ? Exclude<O, undefined> : T;
     /** --------------------------------------
      * Error type
      * --------------------------------------- */
@@ -1341,4 +1380,4 @@ declare namespace Phantom {
     }
 }
 
-export { Base, Brand, type ErrorType, Identity, Input, Inspect, Label, Phantom, PhantomChain, PhantomCore, Tag, Trait, Traits, Transformation, Variants, addTrait, addTraits, applyTransformation, asBrand, asIdentity, assertors, Phantom as default, dropTrait, dropTraits, revertTransformation };
+export { Base, Brand, type ErrorType, Identity, Input, Inspect, Label, Phantom, PhantomChain, PhantomCore, Tag, Trait, Traits, Transformation, Variants, addTrait, addTraits, applyTransformation, asBrand, asIdentity, assertors, Phantom as default, dropTrait, dropTraits, revertTransformation, stripPhantom };

package/dist/index.d.ts

@@ -6,6 +6,8 @@ declare namespace assertors {
      * with the brand's nominal type applied. Use it for simple branded primitives
      * where you know the value is valid.
      *
+     * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+     *
      * @template B - The brand declaration to assign.
      * @returns A function that casts any value to the branded type.
      */
@@ -311,6 +313,15 @@ declare namespace VariantsCore {
     } ? true : false;
 }
 
+/** Stip phantom metadata object from a type */
+type StripPhantom<T> = T extends {
+    __Phantom: {
+        __OriginalType?: infer O;
+    };
+} ? Exclude<O, undefined> : T;
+/** run-time helper for 'StringPhantom', used for debugging mainly */
+declare const stripPhantom: <T>(value: T) => StripPhantom<T>;
+type _StripPhantom<T> = StripPhantom<T>;
 /**
  * Phantom meatadata object manipulators.
  *
@@ -322,13 +333,13 @@ declare namespace PhantomCore {
         __Phantom: infer Phantom extends object;
     } ? Phantom : never;
     /** Stip phantom metadata object from a type */
-    type StripPhantom<T> = T extends {
+    type StripPhantom<T> = _StripPhantom<T>;
+    /** run-time helper for 'StringPhantom', used for debugging mainly */
+    const stripPhantom: <T>(value: T) => T extends {
         __Phantom: {
             __OriginalType?: infer O;
         };
     } ? Exclude<O, undefined> : T;
-    /** run-time helper for 'StringPhantom', used for debugging mainly */
-    const stripPhantom: <T>(value: T) => StripPhantom<T>;
 }
 
 /** Interface of 'Brand' and 'Identity' errors. */
@@ -441,6 +452,8 @@ type Merge<O1 extends object, O2 extends object> = Prettify<Omit<O1, keyof O2> &
  *
  * Brands provide nominal typing for otherwise identical values.
  * A value may only be branded once.
+ *
+ * @deprecated To unify Api surface 'Identity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
  */
 declare namespace BrandCore {
     /** Type guard for any brand. */
@@ -476,7 +489,7 @@ declare namespace IdentityCore {
     /** Type guard for any identity. */
     export type Any = TagCore.Of<string | symbol>;
     /** Declare an identity */
-    export type Declare<T extends string | symbol, L extends string = never, B extends unknown = never, V extends string = never> = Prettify<TagCore.Of<T> & LabelCore.OfIfExists<L> & BaseCore.OfIfExists<B> & VariantsCore.OfIfExists<V>>;
+    export type Declare<T extends string | symbol, L extends string = never, B extends unknown = never, V extends string = never> = IfNever<B, unknown> & Prettify<TagCore.Of<T> & LabelCore.OfIfExists<L> & BaseCore.OfIfExists<B> & VariantsCore.OfIfExists<V>>;
     /**
      * Assign an identity to a value.
      * Enforces base-type compatibility.
@@ -541,7 +554,7 @@ declare namespace TransformationCore {
     /** Type guard for any transformation. */
     export type Any = InputCore.Of<any> & TagCore.Of<string | symbol>;
     /** Declare a transformation */
-    export type Declare<I, T extends string | symbol, L extends string = never, B extends unknown = never, V extends string = never> = Prettify<InputCore.Of<I> & TagCore.Of<T> & LabelCore.OfIfExists<L> & BaseCore.OfIfExists<B> & VariantsCore.OfIfExists<V>>;
+    export type Declare<I, T extends string | symbol, L extends string = never, B extends unknown = never, V extends string = never> = IfNever<B, unknown> & Prettify<InputCore.Of<I> & TagCore.Of<T> & LabelCore.OfIfExists<L> & BaseCore.OfIfExists<B> & VariantsCore.OfIfExists<V>>;
     /**
      * Apply a transformation to a value.
      * Enforces base-type compatibility.
@@ -656,6 +669,8 @@ declare namespace Traits {
  *
  * Brands provide nominal typing for otherwise identical values.
  * A value may only be branded once.
+ *
+ * @deprecated To unify Api surface 'Identity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
  */
 declare namespace Brand {
     /** Type guard for any brand. */
@@ -767,7 +782,11 @@ declare namespace Inspect {
     type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;
     /** Check if any traits exist */
     type HasTraits<T> = TraitsCore.HasTraits<T>;
-    /** Check whether value is branded with */
+    /**
+     * Check whether value is branded with
+     *
+     * @deprecated To unify Api surface 'isIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+     */
     type isBrand<T, B extends BrandCore.Any> = BrandCore.isBrand<T, B>;
     /** Check whether value is branded with */
     type isIdentity<T, I extends IdentityCore.Any> = IdentityCore.isIdentity<T, I>;
@@ -784,6 +803,8 @@ declare namespace Inspect {
  * with the brand's nominal type applied. Use it for simple branded primitives
  * where you know the value is valid.
  *
+ * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+ *
  * @template B - The brand declaration to assign.
  * @returns A function that casts any value to the branded type.
  */
@@ -1000,6 +1021,8 @@ declare namespace Phantom {
      *
      * Brands provide nominal typing for otherwise identical values.
      * A value may only be branded once.
+     *
+     * @deprecated To unify Api surface 'Identity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
      */
     namespace Brand {
         /** Type guard for any brand. */
@@ -1089,7 +1112,11 @@ declare namespace Phantom {
         /** Stip phantom metadata object from a type */
         type StripPhantom<T> = PhantomCore.StripPhantom<T>;
         /** run-time helper for 'StringPhantom', used for debugging mainly */
-        const stripPhantom: <T>(value: T) => PhantomCore.StripPhantom<T>;
+        const stripPhantom: <T>(value: T) => T extends {
+            __Phantom: {
+                __OriginalType?: infer O;
+            };
+        } ? Exclude<O, undefined> : T;
         /** Extract the label */
         type LabelOf<T> = LabelCore.LabelOf<T>;
         /** Check whether a base constraint exists */
@@ -1116,7 +1143,11 @@ declare namespace Phantom {
         type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;
         /** Check if any traits exist */
         type HasTraits<T, Tr extends string | symbol = string | symbol> = TraitsCore.HasTraits<T, Tr>;
-        /** Check whether value is branded with */
+        /**
+         * Check whether value is branded with
+         *
+         * @deprecated To unify Api surface 'isIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+         */
         type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;
         /** Check whether value is branded with */
         type isIdentity<T, I extends Identity.Any> = IdentityCore.isIdentity<T, I>;
@@ -1136,6 +1167,8 @@ declare namespace Phantom {
          * with the brand's nominal type applied. Use it for simple branded primitives
          * where you know the value is valid.
          *
+         * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+         *
          * @template B - The brand declaration to assign.
          * @returns A function that casts any value to the branded type.
          */
@@ -1220,6 +1253,8 @@ declare namespace Phantom {
      * with the brand's nominal type applied. Use it for simple branded primitives
      * where you know the value is valid.
      *
+     * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'
+     *
      * @template B - The brand declaration to assign.
      * @returns A function that casts any value to the branded type.
      */
@@ -1304,7 +1339,11 @@ declare namespace Phantom {
     /** Stip phantom metadata object from a type */
     type StripPhantom<T> = PhantomCore.StripPhantom<T>;
     /** run-time helper for 'StringPhantom', used for debugging mainly */
-    const stripPhantom: <T>(value: T) => PhantomCore.StripPhantom<T>;
+    const stripPhantom: <T>(value: T) => T extends {
+        __Phantom: {
+            __OriginalType?: infer O;
+        };
+    } ? Exclude<O, undefined> : T;
     /** --------------------------------------
      * Error type
      * --------------------------------------- */
@@ -1341,4 +1380,4 @@ declare namespace Phantom {
     }
 }
 
-export { Base, Brand, type ErrorType, Identity, Input, Inspect, Label, Phantom, PhantomChain, PhantomCore, Tag, Trait, Traits, Transformation, Variants, addTrait, addTraits, applyTransformation, asBrand, asIdentity, assertors, Phantom as default, dropTrait, dropTraits, revertTransformation };
+export { Base, Brand, type ErrorType, Identity, Input, Inspect, Label, Phantom, PhantomChain, PhantomCore, Tag, Trait, Traits, Transformation, Variants, addTrait, addTraits, applyTransformation, asBrand, asIdentity, assertors, Phantom as default, dropTrait, dropTraits, revertTransformation, stripPhantom };

package/dist/index.global.js

@@ -68,10 +68,12 @@
   };
 
   // src/core/phantom.ts
-  var PhantomCore;
+  var stripPhantom = (value) => value;
+  var _stripPhantom = stripPhantom;
+  exports.PhantomCore = void 0;
   ((PhantomCore2) => {
-    PhantomCore2.stripPhantom = (value) => value;
-  })(PhantomCore || (PhantomCore = {}));
+    PhantomCore2.stripPhantom = _stripPhantom;
+  })(exports.PhantomCore || (exports.PhantomCore = {}));
 
   // src/phantom.ts
   var _addTrait2 = addTrait;
@@ -86,7 +88,7 @@
   exports.Phantom = void 0;
   ((Phantom2) => {
     ((Inspect2) => {
-      Inspect2.stripPhantom = PhantomCore.stripPhantom;
+      Inspect2.stripPhantom = exports.PhantomCore.stripPhantom;
     })(Phantom2.Inspect || (Phantom2.Inspect = {}));
     ((assertors3) => {
       assertors3.asBrand = _asBrand2;
@@ -106,7 +108,7 @@
     Phantom2.dropTraits = _dropTraits2;
     Phantom2.applyTransformation = _applyTransformation2;
     Phantom2.revertTransformation = _revertTransformation2;
-    Phantom2.stripPhantom = PhantomCore.stripPhantom;
+    Phantom2.stripPhantom = exports.PhantomCore.stripPhantom;
     class PhantomChain2 extends _PhantomChain {
     }
     Phantom2.PhantomChain = PhantomChain2;
@@ -125,6 +127,7 @@
   exports.dropTrait = dropTrait;
   exports.dropTraits = dropTraits;
   exports.revertTransformation = revertTransformation;
+  exports.stripPhantom = stripPhantom;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 

package/dist/index.global.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/assertors/brand.ts","../src/assertors/identity.ts","../src/assertors/trait.ts","../src/assertors/transformation.ts","../src/assertors/assertors.ts","../src/chain/chain.ts","../src/core/phantom.ts","../src/phantom.ts","../src/index.ts"],"names":["assertors","_PhantomChain","PhantomCore","_addTrait","_addTraits","_applyTransformation","_asBrand","_asIdentity","_dropTrait","_dropTraits","_revertTransformation","Phantom","Inspect","PhantomChain"],"mappings":";;;;;;;;AAYO,MAAM,OAAA,GACX,MACA,CAAI,KAAA,KACF;;;ACHG,MAAM,UAAA,GACX,MACA,CAAI,KAAA,KACF;;;ACLG,MAAM,QAAA,GACX,MACA,CAAI,KAAA,KACF;AAUG,MAAM,SAAA,GACX,MACA,CAAI,KAAA,KACF;AAUG,MAAM,SAAA,GACX,MACA,CAAI,KAAA,KACF;AAUG,MAAM,UAAA,GACX,MACA,CAAI,KAAA,KACF;;;ACvCG,MAAM,mBAAA,GACX,MACA,CAAO,KAAA,EAAU,WAAA,KACf;AAcG,MAAM,oBAAA,GACX,MACA,CAAO,WAAA,EAAgB,KAAA,KACrB;;;EC5BJ,IAAM,SAAA,GAAY,QAAA;EAClB,IAAM,UAAA,GAAa,SAAA;EACnB,IAAM,oBAAA,GAAuB,mBAAA;EAC7B,IAAM,QAAA,GAAW,OAAA;EACjB,IAAM,WAAA,GAAc,UAAA;EACpB,IAAM,UAAA,GAAa,SAAA;EACnB,IAAM,WAAA,GAAc,UAAA;EACpB,IAAM,qBAAA,GAAwB,oBAAA;AAEbA;EAAA,CAAV,CAAUA,UAAAA,KAAV;EAWE,EAAMA,WAAA,OAAA,GAAU,QAAA;EAYhB,EAAMA,WAAA,UAAA,GAAa,WAAA;EAUnB,EAAMA,WAAA,QAAA,GAAW,SAAA;EAUjB,EAAMA,WAAA,SAAA,GAAY,UAAA;EAUlB,EAAMA,WAAA,SAAA,GAAY,UAAA;EAUlB,EAAMA,WAAA,UAAA,GAAa,WAAA;EAanB,EAAMA,WAAA,mBAAA,GAAsB,oBAAA;EAc5B,EAAMA,WAAA,oBAAA,GAAuB,qBAAA;EAAA,CAAA,EA1FrBA,iBAAA,KAAAA,iBAAA,GAAA,EAAA,CAAA,CAAA;;;ACUV,MAAM,YAAA,GAAN,MAAMC,cAAAA,CAAgB;EAAA,EAG3B,YAAY,KAAA,EAAU;EAFtB,IAAA,aAAA,CAAA,IAAA,EAAQ,OAAA,CAAA;EAGN,IAAA,IAAA,CAAK,KAAA,GAAQ,KAAA;EAAA,EACf;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA,EAQA,KAAQ,QAAA,EAA4C;EAClD,IAAA,OAAO,IAAIA,cAAAA,CAAa,QAAA,CAAS,IAAA,CAAK,KAAK,CAAC,CAAA;EAAA,EAC9C;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA,EAOA,GAAA,GAAS;EACP,IAAA,OAAO,IAAA,CAAK,KAAA;EAAA,EACd;EACF;;;EC5CO,IAAU,WAAA;EAAA,CAAV,CAAUC,YAAAA,KAAV;EAgBE,EAAMA,YAAAA,CAAA,YAAA,GAAe,CAAI,KAAA,KAA8B,KAAA;EAAA,CAAA,EAhB/C,WAAA,KAAA,WAAA,GAAA,EAAA,CAAA,CAAA;;;ECqBjB,IAAMC,UAAAA,GAAY,QAAA;EAClB,IAAMC,WAAAA,GAAa,SAAA;EACnB,IAAMC,qBAAAA,GAAuB,mBAAA;EAC7B,IAAMC,SAAAA,GAAW,OAAA;EACjB,IAAMC,YAAAA,GAAc,UAAA;EACpB,IAAMC,WAAAA,GAAa,SAAA;EACnB,IAAMC,YAAAA,GAAc,UAAA;EACpB,IAAMC,sBAAAA,GAAwB,oBAAA;EAC9B,IAAM,aAAA,GAAgB,YAAA;AAGLC;EAAA,CAAV,CAAUA,QAAAA,KAAV;EAwOE,EAAA,CAAA,CAAUC,QAAAA,KAAV;EAME,IAAMA,QAAAA,CAAA,eAAe,WAAA,CAAY,YAAA;EAAA,EAAA,CAAA,EANzBD,QAAAA,CAAA,OAAA,KAAAA,QAAAA,CAAA,OAAA,GAAA,EAAA,CAAA,CAAA;EA8DV,EAAA,CAAA,CAAUX,UAAAA,KAAV;EAWE,IAAMA,WAAA,OAAA,GAAUM,SAAAA;EAYhB,IAAMN,WAAA,UAAA,GAAaO,YAAAA;EAUnB,IAAMP,WAAA,QAAA,GAAWG,UAAAA;EAUjB,IAAMH,WAAA,SAAA,GAAYI,WAAAA;EAUlB,IAAMJ,WAAA,SAAA,GAAYQ,WAAAA;EAUlB,IAAMR,WAAA,UAAA,GAAaS,YAAAA;EAanB,IAAMT,WAAA,mBAAA,GAAsBK,qBAAAA;EAc5B,IAAML,WAAA,oBAAA,GAAuBU,sBAAAA;EAAA,EAAA,CAAA,EA1FrBC,QAAAA,CAAA,SAAA,KAAAA,QAAAA,CAAA,SAAA,GAAA,EAAA,CAAA,CAAA;EAuGV,EAAMA,SAAA,OAAA,GAAUL,SAAAA;EAYhB,EAAMK,SAAA,UAAA,GAAaJ,YAAAA;EAUnB,EAAMI,SAAA,QAAA,GAAWR,UAAAA;EAUjB,EAAMQ,SAAA,SAAA,GAAYP,WAAAA;EAUlB,EAAMO,SAAA,SAAA,GAAYH,WAAAA;EAUlB,EAAMG,SAAA,UAAA,GAAaF,YAAAA;EAanB,EAAME,SAAA,mBAAA,GAAsBN,qBAAAA;EAc5B,EAAMM,SAAA,oBAAA,GAAuBD,sBAAAA;EAW7B,EAAMC,QAAAA,CAAA,eAAe,WAAA,CAAY,YAAA;EAAA,EAqCjC,MAAME,sBAAwB,aAAA,CAAiB;EAAA;EAA/C,EAAAF,SAAM,YAAA,GAAAE,aAAAA;EAAA,CAAA,EA5gBEF,eAAA,KAAAA,eAAA,GAAA,EAAA,CAAA,CAAA;;;ACRjB,MAAO,aAAA,GAAQA","file":"index.global.js","sourcesContent":["import type { Brand } from '../core';\n\n/**\n * Creates a typed caster that assigns a {@link Brand} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the brand's nominal type applied. Use it for simple branded primitives\n * where you know the value is valid.\n *\n * @template B - The brand declaration to assign.\n * @returns A function that casts any value to the branded type.\n */\nexport const asBrand =\n  <B extends Brand.Any>() =>\n  <T>(value: T) =>\n    value as Brand.Assign<B, T>;\n","import type { Identity } from '../core';\n\n/**\n * Creates a typed caster that assigns an {@link Identity} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the identity's nominal type applied. Use it when you know a value\n * conforms to an identity but need to assert it for the type system.\n *\n * @template I - The identity declaration to assign.\n * @returns A function that casts any value to the assigned identity type.\n */\nexport const asIdentity =\n  <I extends Identity.Any>() =>\n  <V>(value: V): Identity.Assign<I, V> =>\n    value as any;\n","import type { Trait } from '../core';\n\n/**\n * Creates a typed caster that adds a single {@link Trait} to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to add.\n * @returns A function that adds the trait to any value.\n */\nexport const addTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Add<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that adds multiple {@link Trait}s to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to add.\n * @returns A function that adds all traits to any value.\n */\nexport const addTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.AddMulti<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes a single {@link Trait} from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to remove.\n * @returns A function that drops the trait from any value.\n */\nexport const dropTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Drop<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes multiple {@link Trait}s from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to remove.\n * @returns A function that drops all specified traits from any value.\n */\nexport const dropTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.DropMulti<Tr, V> =>\n    value as any;\n","import type { Transformation } from '../core';\n\n/**\n * Creates a typed applicator for a {@link Transformation}.\n *\n * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n * The `input` parameter is only used for type inference — it is not used at runtime.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that applies the transformation while preserving the input type for later revert.\n */\nexport const applyTransformation =\n  <Tr extends Transformation.Any>() =>\n  <I, T>(input: I, transformed: T) =>\n    transformed as Transformation.Apply<Tr, I, T>;\n\n/**\n * Creates a typed reverter for a {@link Transformation}.\n *\n * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n * The `transformed` parameter is used for type inference of the expected input,\n * and `input` is the computed result that must match the stored input type.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that reverts the transformation, stripping phantom metadata.\n */\nexport const revertTransformation =\n  <Tr extends Transformation.Any>() =>\n  <T, I>(transformed: T, input: I) =>\n    input as Transformation.Revert<Tr, T, I>;\n","import { asBrand } from './brand';\nimport { asIdentity } from './identity';\nimport { addTrait, addTraits, dropTrait, dropTraits } from './trait';\nimport { applyTransformation, revertTransformation } from './transformation';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\n\nexport namespace assertors {\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n}\n","/**\n * A fluent PhantomChain class for chaining Phantom assertors.\n *\n * This provides a better developer experience (DX) by allowing method chaining\n * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n * Call `.end()` to retrieve the final value.\n *\n * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n * (just object creation and method calls).\n *\n * Example:\n * ```ts\n * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n *\n * const result = new PhantomChain(\"value\")\n *   .with(asMyBrand)\n *   .with(asMyTrait)\n *   .with(applyMyTransform)\n *   .end();\n * ```\n */\nexport class PhantomChain<T> {\n  private value: T;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n\n  /**\n   * Apply the next assertor in the chain.\n   *\n   * @param assertor A function that takes the current value and returns the updated value (with new type).\n   * @returns A new PhantomChain instance with the updated value and type.\n   */\n  with<U>(assertor: (value: T) => U): PhantomChain<U> {\n    return new PhantomChain(assertor(this.value));\n  }\n\n  /**\n   * End the chain and return the final value.\n   *\n   * @returns The value after all transformations.\n   */\n  end(): T {\n    return this.value;\n  }\n}\n","/**\n * Phantom meatadata object manipulators.\n *\n * Phantom matadata object holds all metadata used by 'phantom'.\n */\nexport namespace PhantomCore {\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = T extends {\n    __Phantom: infer Phantom extends object;\n  }\n    ? Phantom\n    : never;\n\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = T extends {\n    __Phantom: { __OriginalType?: infer O };\n  }\n    ? Exclude<O, undefined>\n    : T;\n\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = <T>(value: T): StripPhantom<T> => value as any;\n}\n","import {\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nimport { PhantomChain } from './chain';\nimport type {\n  BaseCore,\n  InputCore,\n  LabelCore,\n  TagCore,\n  TraitsCore,\n  VariantsCore,\n  BrandCore,\n  IdentityCore,\n  TraitCore,\n  TransformationCore,\n  ErrorType,\n} from './core';\nimport { PhantomCore } from './core';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\nconst _PhantomChain = PhantomChain;\ntype _ErrorType<E> = ErrorType<E>;\n\nexport namespace Phantom {\n  /** --------------------------------------\n   * Types\n   * --------------------------------------- */\n\n  /**\n   * Optional human-readable label metadata.\n   *\n   * Labels are descriptive only and do not affect identity.\n   */\n  export namespace Label {\n    /** Marker type for labeled values */\n    export type Any = LabelCore.Any;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a label exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n  }\n\n  /**\n   * Nominal tag metadata.\n   *\n   * Tags uniquely identify a branded or identified type.\n   * A value may only have a single tag.\n   */\n  export namespace Tag {\n    /** Marker type for any tagged value */\n    export type Any = TagCore.Any;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n  }\n\n  /**\n   * Variant metadata.\n   *\n   * Variants represent mutually exclusive states of a type.\n   */\n  export namespace Variants {\n    /** Marker type for variant-bearing values */\n    export type Any = VariantsCore.Any;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n  }\n\n  /**\n   * Base-type metadata.\n   *\n   * Used to constrain which runtime types a brand, identity,\n   * or transformation may be applied to.\n   */\n  export namespace Base {\n    /** Marker type for base constraints */\n    export type Any = BaseCore.Any;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n  }\n\n  /**\n   * Input metadata.\n   *\n   * Utilities for attaching and querying input metadata in transformations.\n   */\n  export namespace Input {\n    /** Marker type for input value */\n    export type Any = InputCore.Any;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n  }\n\n  /**\n   * Trait metadata.\n   *\n   * Traits behave like a set of capabilities that can be\n   * added or removed independently.\n   */\n  export namespace Traits {\n    /** Marker type for trait-bearing values */\n    export type Any = TraitsCore.Any;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n  }\n\n  /**\n   * Branding API.\n   *\n   * Brands provide nominal typing for otherwise identical values.\n   * A value may only be branded once.\n   */\n  export namespace Brand {\n    /** Type guard for any brand. */\n    export type Any = BrandCore.Any;\n    /** Declare a brand */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n    > = BrandCore.Declare<T, L>;\n    /** Assign a brand to a value. Fails if the value is already branded */\n    export type Assign<B extends Any, T> = BrandCore.Assign<B, T>;\n    /** Assign a brand if possible, otherwise return the original type */\n    export type AssignSafe<B extends Any, T> = BrandCore.AssignSafe<B, T>;\n    /** Check whether value is branded with */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n  }\n\n  /**\n   * Identity API.\n   *\n   * Identities are brands with additional constraints:\n   * - Base type\n   * - Variants\n   */\n  export namespace Identity {\n    /** Type guard for any identity. */\n    export type Any = IdentityCore.Any;\n    /** Declare an identity */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = IdentityCore.Declare<T, L, B, V>;\n    /** Assign an identity to a value. Enforces base-type compatibility */\n    export type Assign<I extends Any, T> = IdentityCore.Assign<I, T>;\n    /** Safe identity assignment */\n    export type AssignSafe<I extends Any, T> = IdentityCore.AssignSafe<I, T>;\n    /** Set the active variant on an identity */\n    export type WithVariant<\n      I extends Any,\n      V extends Variants.VariantsOf<I>,\n    > = IdentityCore.WithVariant<I, V>;\n    /** Set the active variant on a value */\n    export type WithTypeVariant<\n      T,\n      V extends Variants.VariantsOf<T>,\n    > = IdentityCore.WithTypeVariant<T, V>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Any> = IdentityCore.isIdentity<T, I>;\n  }\n\n  /**\n   * Trait API.\n   *\n   * Traits are additive capabilities that can be attached\n   * or removed independently.\n   */\n  export namespace Trait {\n    /** Type guard for any trait. */\n    export type Any = TraitCore.Any;\n    /** Declare a trait */\n    export type Declare<Tr extends string | symbol> = TraitCore.Declare<Tr>;\n    /** Add a trait */\n    export type Add<Tr extends Any, T> = TraitCore.Add<Tr, T>;\n    /** Add multiple traits */\n    export type AddMulti<Tr extends readonly Any[], T> = TraitCore.AddMulti<\n      Tr,\n      T\n    >;\n    /** Remove a trait */\n    export type Drop<Tr extends Any, T> = TraitCore.Drop<Tr, T>;\n    /** Remove multiple traits */\n    export type DropMulti<Tr extends readonly Any[], T> = TraitCore.DropMulti<\n      Tr,\n      T\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Any> = TraitCore.HasTrait<T, Tr>;\n  }\n\n  /**\n   * Transformation API.\n   *\n   * Transformations represent reversible operations that\n   * change the shape of a value while preserving its origin.\n   */\n  export namespace Transformation {\n    /** Type guard for any transformation. */\n    export type Any = TransformationCore.Any;\n    /** Declare a transformation */\n    export type Declare<\n      I,\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = TransformationCore.Declare<I, T, L, B, V>;\n    /** Apply a transformation to a value. Enforces base-type compatibility */\n    export type Apply<Tr extends Any, I, T> = TransformationCore.Apply<\n      Tr,\n      I,\n      T\n    >;\n    /** Revert a transformation */\n    export type Revert<Tr extends Any, T, I> = TransformationCore.Revert<\n      Tr,\n      T,\n      I\n    >;\n    /** Revert a transformation whatever transformation was */\n    export type RevertAny<T, I> = TransformationCore.RevertAny<T, I>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /**\n   * Inspect API.\n   *\n   * Inspection helpers of phantom types.\n   */\n  export namespace Inspect {\n    /** Get phantom metadata object from a type */\n    export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n    /** Stip phantom metadata object from a type */\n    export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n    /** run-time helper for 'StringPhantom', used for debugging mainly */\n    export const stripPhantom = PhantomCore.stripPhantom;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n    /** Check whether value is branded with */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Identity.Any> = IdentityCore.isIdentity<\n      T,\n      I\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Trait.Any> = TraitCore.HasTrait<T, Tr>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Transformation.Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /** --------------------------------------\n   * assertors\n   * --------------------------------------- */\n\n  export namespace assertors {\n    /**\n     * Creates a typed caster that assigns a {@link Brand} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the brand's nominal type applied. Use it for simple branded primitives\n     * where you know the value is valid.\n     *\n     * @template B - The brand declaration to assign.\n     * @returns A function that casts any value to the branded type.\n     */\n    export const asBrand = _asBrand;\n\n    /**\n     * Creates a typed caster that assigns an {@link Identity} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the identity's nominal type applied. Use it when you know a value\n     * conforms to an identity but need to assert it for the type system.\n     *\n     * @template I - The identity declaration to assign.\n     * @returns A function that casts any value to the assigned identity type.\n     */\n    export const asIdentity = _asIdentity;\n\n    /**\n     * Creates a typed caster that adds a single {@link Trait} to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to add.\n     * @returns A function that adds the trait to any value.\n     */\n    export const addTrait = _addTrait;\n\n    /**\n     * Creates a typed caster that adds multiple {@link Trait}s to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to add.\n     * @returns A function that adds all traits to any value.\n     */\n    export const addTraits = _addTraits;\n\n    /**\n     * Creates a typed caster that removes a single {@link Trait} from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to remove.\n     * @returns A function that drops the trait from any value.\n     */\n    export const dropTrait = _dropTrait;\n\n    /**\n     * Creates a typed caster that removes multiple {@link Trait}s from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to remove.\n     * @returns A function that drops all specified traits from any value.\n     */\n    export const dropTraits = _dropTraits;\n\n    /**\n     * Creates a typed applicator for a {@link Transformation}.\n     *\n     * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n     * The `input` parameter is only used for type inference — it is not used at runtime.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that applies the transformation while preserving the input type for later revert.\n     */\n    export const applyTransformation = _applyTransformation;\n\n    /**\n     * Creates a typed reverter for a {@link Transformation}.\n     *\n     * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n     * The `transformed` parameter is used for type inference of the expected input,\n     * and `input` is the computed result that must match the stored input type.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that reverts the transformation, stripping phantom metadata.\n     */\n    export const revertTransformation = _revertTransformation;\n  }\n\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n\n  /** --------------------------------------\n   * Phantom object manipulators\n   * --------------------------------------- */\n\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = PhantomCore.stripPhantom;\n\n  /** --------------------------------------\n   * Error type\n   * --------------------------------------- */\n\n  /** Unique Error type for rules validation in phantom. */\n  export type ErrorType<E> = _ErrorType<E>;\n\n  /** --------------------------------------\n   * Chain class\n   * --------------------------------------- */\n\n  /**\n   * A fluent PhantomChain class for chaining Phantom assertors.\n   *\n   * This provides a better developer experience (DX) by allowing method chaining\n   * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n   * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n   * Call `.end()` to retrieve the final value.\n   *\n   * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n   * (just object creation and method calls).\n   *\n   * Example:\n   * ```ts\n   * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n   * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n   * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n   *\n   * const result = new PhantomChain(\"value\")\n   *   .with(asMyBrand)\n   *   .with(asMyTrait)\n   *   .with(applyMyTransform)\n   *   .end();\n   * ```\n   */\n  export class PhantomChain<T> extends _PhantomChain<T> {}\n}\n","export {\n  assertors,\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nexport { PhantomChain } from './chain';\nexport { Phantom } from './phantom';\nexport type {\n  Base,\n  Brand,\n  ErrorType,\n  Identity,\n  Input,\n  Inspect,\n  Label,\n  PhantomCore,\n  Tag,\n  Trait,\n  Traits,\n  Transformation,\n  Variants,\n} from './core';\nimport { Phantom } from './phantom';\nexport default Phantom;\n"]}
+{"version":3,"sources":["../src/assertors/brand.ts","../src/assertors/identity.ts","../src/assertors/trait.ts","../src/assertors/transformation.ts","../src/assertors/assertors.ts","../src/chain/chain.ts","../src/core/phantom.ts","../src/phantom.ts","../src/index.ts"],"names":["assertors","_PhantomChain","PhantomCore","_addTrait","_addTraits","_applyTransformation","_asBrand","_asIdentity","_dropTrait","_dropTraits","_revertTransformation","Phantom","Inspect","PhantomChain"],"mappings":"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","file":"index.global.js","sourcesContent":["import type { Brand } from '../core';\n\n/**\n * Creates a typed caster that assigns a {@link Brand} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the brand's nominal type applied. Use it for simple branded primitives\n * where you know the value is valid.\n *\n * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n *\n * @template B - The brand declaration to assign.\n * @returns A function that casts any value to the branded type.\n */\nexport const asBrand =\n  <B extends Brand.Any>() =>\n  <T>(value: T) =>\n    value as Brand.Assign<B, T>;\n","import type { Identity } from '../core';\n\n/**\n * Creates a typed caster that assigns an {@link Identity} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the identity's nominal type applied. Use it when you know a value\n * conforms to an identity but need to assert it for the type system.\n *\n * @template I - The identity declaration to assign.\n * @returns A function that casts any value to the assigned identity type.\n */\nexport const asIdentity =\n  <I extends Identity.Any>() =>\n  <V>(value: V): Identity.Assign<I, V> =>\n    value as any;\n","import type { Trait } from '../core';\n\n/**\n * Creates a typed caster that adds a single {@link Trait} to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to add.\n * @returns A function that adds the trait to any value.\n */\nexport const addTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Add<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that adds multiple {@link Trait}s to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to add.\n * @returns A function that adds all traits to any value.\n */\nexport const addTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.AddMulti<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes a single {@link Trait} from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to remove.\n * @returns A function that drops the trait from any value.\n */\nexport const dropTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Drop<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes multiple {@link Trait}s from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to remove.\n * @returns A function that drops all specified traits from any value.\n */\nexport const dropTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.DropMulti<Tr, V> =>\n    value as any;\n","import type { Transformation } from '../core';\n\n/**\n * Creates a typed applicator for a {@link Transformation}.\n *\n * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n * The `input` parameter is only used for type inference — it is not used at runtime.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that applies the transformation while preserving the input type for later revert.\n */\nexport const applyTransformation =\n  <Tr extends Transformation.Any>() =>\n  <I, T>(input: I, transformed: T) =>\n    transformed as Transformation.Apply<Tr, I, T>;\n\n/**\n * Creates a typed reverter for a {@link Transformation}.\n *\n * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n * The `transformed` parameter is used for type inference of the expected input,\n * and `input` is the computed result that must match the stored input type.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that reverts the transformation, stripping phantom metadata.\n */\nexport const revertTransformation =\n  <Tr extends Transformation.Any>() =>\n  <T, I>(transformed: T, input: I) =>\n    input as Transformation.Revert<Tr, T, I>;\n","import { asBrand } from './brand';\nimport { asIdentity } from './identity';\nimport { addTrait, addTraits, dropTrait, dropTraits } from './trait';\nimport { applyTransformation, revertTransformation } from './transformation';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\n\nexport namespace assertors {\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n}\n","/**\n * A fluent PhantomChain class for chaining Phantom assertors.\n *\n * This provides a better developer experience (DX) by allowing method chaining\n * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n * Call `.end()` to retrieve the final value.\n *\n * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n * (just object creation and method calls).\n *\n * Example:\n * ```ts\n * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n *\n * const result = new PhantomChain(\"value\")\n *   .with(asMyBrand)\n *   .with(asMyTrait)\n *   .with(applyMyTransform)\n *   .end();\n * ```\n */\nexport class PhantomChain<T> {\n  private value: T;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n\n  /**\n   * Apply the next assertor in the chain.\n   *\n   * @param assertor A function that takes the current value and returns the updated value (with new type).\n   * @returns A new PhantomChain instance with the updated value and type.\n   */\n  with<U>(assertor: (value: T) => U): PhantomChain<U> {\n    return new PhantomChain(assertor(this.value));\n  }\n\n  /**\n   * End the chain and return the final value.\n   *\n   * @returns The value after all transformations.\n   */\n  end(): T {\n    return this.value;\n  }\n}\n","/** Stip phantom metadata object from a type */\ntype StripPhantom<T> = T extends {\n  __Phantom: { __OriginalType?: infer O };\n}\n  ? Exclude<O, undefined>\n  : T;\n\n/** run-time helper for 'StringPhantom', used for debugging mainly */\nexport const stripPhantom = <T>(value: T): StripPhantom<T> => value as any;\n\n// Avoid bundler bugs\ntype _StripPhantom<T> = StripPhantom<T>;\nconst _stripPhantom = stripPhantom;\n\n/**\n * Phantom meatadata object manipulators.\n *\n * Phantom matadata object holds all metadata used by 'phantom'.\n */\nexport namespace PhantomCore {\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = T extends {\n    __Phantom: infer Phantom extends object;\n  }\n    ? Phantom\n    : never;\n\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = _StripPhantom<T>;\n\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = _stripPhantom;\n}\n","import {\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nimport { PhantomChain } from './chain';\nimport type {\n  BaseCore,\n  InputCore,\n  LabelCore,\n  TagCore,\n  TraitsCore,\n  VariantsCore,\n  BrandCore,\n  IdentityCore,\n  TraitCore,\n  TransformationCore,\n  ErrorType,\n} from './core';\nimport { PhantomCore } from './core';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\nconst _PhantomChain = PhantomChain;\ntype _ErrorType<E> = ErrorType<E>;\n\nexport namespace Phantom {\n  /** --------------------------------------\n   * Types\n   * --------------------------------------- */\n\n  /**\n   * Optional human-readable label metadata.\n   *\n   * Labels are descriptive only and do not affect identity.\n   */\n  export namespace Label {\n    /** Marker type for labeled values */\n    export type Any = LabelCore.Any;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a label exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n  }\n\n  /**\n   * Nominal tag metadata.\n   *\n   * Tags uniquely identify a branded or identified type.\n   * A value may only have a single tag.\n   */\n  export namespace Tag {\n    /** Marker type for any tagged value */\n    export type Any = TagCore.Any;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n  }\n\n  /**\n   * Variant metadata.\n   *\n   * Variants represent mutually exclusive states of a type.\n   */\n  export namespace Variants {\n    /** Marker type for variant-bearing values */\n    export type Any = VariantsCore.Any;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n  }\n\n  /**\n   * Base-type metadata.\n   *\n   * Used to constrain which runtime types a brand, identity,\n   * or transformation may be applied to.\n   */\n  export namespace Base {\n    /** Marker type for base constraints */\n    export type Any = BaseCore.Any;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n  }\n\n  /**\n   * Input metadata.\n   *\n   * Utilities for attaching and querying input metadata in transformations.\n   */\n  export namespace Input {\n    /** Marker type for input value */\n    export type Any = InputCore.Any;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n  }\n\n  /**\n   * Trait metadata.\n   *\n   * Traits behave like a set of capabilities that can be\n   * added or removed independently.\n   */\n  export namespace Traits {\n    /** Marker type for trait-bearing values */\n    export type Any = TraitsCore.Any;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n  }\n\n  /**\n   * Branding API.\n   *\n   * Brands provide nominal typing for otherwise identical values.\n   * A value may only be branded once.\n   *\n   * @deprecated To unify Api surface 'Identity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n   */\n  export namespace Brand {\n    /** Type guard for any brand. */\n    export type Any = BrandCore.Any;\n    /** Declare a brand */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n    > = BrandCore.Declare<T, L>;\n    /** Assign a brand to a value. Fails if the value is already branded */\n    export type Assign<B extends Any, T> = BrandCore.Assign<B, T>;\n    /** Assign a brand if possible, otherwise return the original type */\n    export type AssignSafe<B extends Any, T> = BrandCore.AssignSafe<B, T>;\n    /** Check whether value is branded with */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n  }\n\n  /**\n   * Identity API.\n   *\n   * Identities are brands with additional constraints:\n   * - Base type\n   * - Variants\n   */\n  export namespace Identity {\n    /** Type guard for any identity. */\n    export type Any = IdentityCore.Any;\n    /** Declare an identity */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = IdentityCore.Declare<T, L, B, V>;\n    /** Assign an identity to a value. Enforces base-type compatibility */\n    export type Assign<I extends Any, T> = IdentityCore.Assign<I, T>;\n    /** Safe identity assignment */\n    export type AssignSafe<I extends Any, T> = IdentityCore.AssignSafe<I, T>;\n    /** Set the active variant on an identity */\n    export type WithVariant<\n      I extends Any,\n      V extends Variants.VariantsOf<I>,\n    > = IdentityCore.WithVariant<I, V>;\n    /** Set the active variant on a value */\n    export type WithTypeVariant<\n      T,\n      V extends Variants.VariantsOf<T>,\n    > = IdentityCore.WithTypeVariant<T, V>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Any> = IdentityCore.isIdentity<T, I>;\n  }\n\n  /**\n   * Trait API.\n   *\n   * Traits are additive capabilities that can be attached\n   * or removed independently.\n   */\n  export namespace Trait {\n    /** Type guard for any trait. */\n    export type Any = TraitCore.Any;\n    /** Declare a trait */\n    export type Declare<Tr extends string | symbol> = TraitCore.Declare<Tr>;\n    /** Add a trait */\n    export type Add<Tr extends Any, T> = TraitCore.Add<Tr, T>;\n    /** Add multiple traits */\n    export type AddMulti<Tr extends readonly Any[], T> = TraitCore.AddMulti<\n      Tr,\n      T\n    >;\n    /** Remove a trait */\n    export type Drop<Tr extends Any, T> = TraitCore.Drop<Tr, T>;\n    /** Remove multiple traits */\n    export type DropMulti<Tr extends readonly Any[], T> = TraitCore.DropMulti<\n      Tr,\n      T\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Any> = TraitCore.HasTrait<T, Tr>;\n  }\n\n  /**\n   * Transformation API.\n   *\n   * Transformations represent reversible operations that\n   * change the shape of a value while preserving its origin.\n   */\n  export namespace Transformation {\n    /** Type guard for any transformation. */\n    export type Any = TransformationCore.Any;\n    /** Declare a transformation */\n    export type Declare<\n      I,\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = TransformationCore.Declare<I, T, L, B, V>;\n    /** Apply a transformation to a value. Enforces base-type compatibility */\n    export type Apply<Tr extends Any, I, T> = TransformationCore.Apply<\n      Tr,\n      I,\n      T\n    >;\n    /** Revert a transformation */\n    export type Revert<Tr extends Any, T, I> = TransformationCore.Revert<\n      Tr,\n      T,\n      I\n    >;\n    /** Revert a transformation whatever transformation was */\n    export type RevertAny<T, I> = TransformationCore.RevertAny<T, I>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /**\n   * Inspect API.\n   *\n   * Inspection helpers of phantom types.\n   */\n  export namespace Inspect {\n    /** Get phantom metadata object from a type */\n    export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n    /** Stip phantom metadata object from a type */\n    export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n    /** run-time helper for 'StringPhantom', used for debugging mainly */\n    export const stripPhantom = PhantomCore.stripPhantom;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n    /**\n     * Check whether value is branded with\n     *\n     * @deprecated To unify Api surface 'isIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n     */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Identity.Any> = IdentityCore.isIdentity<\n      T,\n      I\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Trait.Any> = TraitCore.HasTrait<T, Tr>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Transformation.Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /** --------------------------------------\n   * assertors\n   * --------------------------------------- */\n\n  export namespace assertors {\n    /**\n     * Creates a typed caster that assigns a {@link Brand} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the brand's nominal type applied. Use it for simple branded primitives\n     * where you know the value is valid.\n     *\n     * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n     *\n     * @template B - The brand declaration to assign.\n     * @returns A function that casts any value to the branded type.\n     */\n    export const asBrand = _asBrand;\n\n    /**\n     * Creates a typed caster that assigns an {@link Identity} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the identity's nominal type applied. Use it when you know a value\n     * conforms to an identity but need to assert it for the type system.\n     *\n     * @template I - The identity declaration to assign.\n     * @returns A function that casts any value to the assigned identity type.\n     */\n    export const asIdentity = _asIdentity;\n\n    /**\n     * Creates a typed caster that adds a single {@link Trait} to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to add.\n     * @returns A function that adds the trait to any value.\n     */\n    export const addTrait = _addTrait;\n\n    /**\n     * Creates a typed caster that adds multiple {@link Trait}s to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to add.\n     * @returns A function that adds all traits to any value.\n     */\n    export const addTraits = _addTraits;\n\n    /**\n     * Creates a typed caster that removes a single {@link Trait} from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to remove.\n     * @returns A function that drops the trait from any value.\n     */\n    export const dropTrait = _dropTrait;\n\n    /**\n     * Creates a typed caster that removes multiple {@link Trait}s from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to remove.\n     * @returns A function that drops all specified traits from any value.\n     */\n    export const dropTraits = _dropTraits;\n\n    /**\n     * Creates a typed applicator for a {@link Transformation}.\n     *\n     * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n     * The `input` parameter is only used for type inference — it is not used at runtime.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that applies the transformation while preserving the input type for later revert.\n     */\n    export const applyTransformation = _applyTransformation;\n\n    /**\n     * Creates a typed reverter for a {@link Transformation}.\n     *\n     * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n     * The `transformed` parameter is used for type inference of the expected input,\n     * and `input` is the computed result that must match the stored input type.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that reverts the transformation, stripping phantom metadata.\n     */\n    export const revertTransformation = _revertTransformation;\n  }\n\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n\n  /** --------------------------------------\n   * Phantom object manipulators\n   * --------------------------------------- */\n\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = PhantomCore.stripPhantom;\n\n  /** --------------------------------------\n   * Error type\n   * --------------------------------------- */\n\n  /** Unique Error type for rules validation in phantom. */\n  export type ErrorType<E> = _ErrorType<E>;\n\n  /** --------------------------------------\n   * Chain class\n   * --------------------------------------- */\n\n  /**\n   * A fluent PhantomChain class for chaining Phantom assertors.\n   *\n   * This provides a better developer experience (DX) by allowing method chaining\n   * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n   * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n   * Call `.end()` to retrieve the final value.\n   *\n   * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n   * (just object creation and method calls).\n   *\n   * Example:\n   * ```ts\n   * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n   * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n   * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n   *\n   * const result = new PhantomChain(\"value\")\n   *   .with(asMyBrand)\n   *   .with(asMyTrait)\n   *   .with(applyMyTransform)\n   *   .end();\n   * ```\n   */\n  export class PhantomChain<T> extends _PhantomChain<T> {}\n}\n","export {\n  assertors,\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nexport { PhantomChain } from './chain';\nexport { Phantom } from './phantom';\nexport type {\n  Base,\n  Brand,\n  ErrorType,\n  Identity,\n  Input,\n  Inspect,\n  Label,\n  Tag,\n  Trait,\n  Traits,\n  Transformation,\n  Variants,\n} from './core';\nexport { PhantomCore, stripPhantom } from './core';\nimport { Phantom } from './phantom';\nexport default Phantom;\n"]}

package/dist/index.js

@@ -69,10 +69,12 @@ var PhantomChain = class _PhantomChain2 {
 };
 
 // src/core/phantom.ts
-var PhantomCore;
+var stripPhantom = (value) => value;
+var _stripPhantom = stripPhantom;
+exports.PhantomCore = void 0;
 ((PhantomCore2) => {
-  PhantomCore2.stripPhantom = (value) => value;
-})(PhantomCore || (PhantomCore = {}));
+  PhantomCore2.stripPhantom = _stripPhantom;
+})(exports.PhantomCore || (exports.PhantomCore = {}));
 
 // src/phantom.ts
 var _addTrait2 = addTrait;
@@ -87,7 +89,7 @@ var _PhantomChain = PhantomChain;
 exports.Phantom = void 0;
 ((Phantom2) => {
   ((Inspect2) => {
-    Inspect2.stripPhantom = PhantomCore.stripPhantom;
+    Inspect2.stripPhantom = exports.PhantomCore.stripPhantom;
   })(Phantom2.Inspect || (Phantom2.Inspect = {}));
   ((assertors3) => {
     assertors3.asBrand = _asBrand2;
@@ -107,7 +109,7 @@ exports.Phantom = void 0;
   Phantom2.dropTraits = _dropTraits2;
   Phantom2.applyTransformation = _applyTransformation2;
   Phantom2.revertTransformation = _revertTransformation2;
-  Phantom2.stripPhantom = PhantomCore.stripPhantom;
+  Phantom2.stripPhantom = exports.PhantomCore.stripPhantom;
   class PhantomChain2 extends _PhantomChain {
   }
   Phantom2.PhantomChain = PhantomChain2;
@@ -126,5 +128,6 @@ exports.default = index_default;
 exports.dropTrait = dropTrait;
 exports.dropTraits = dropTraits;
 exports.revertTransformation = revertTransformation;
+exports.stripPhantom = stripPhantom;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/assertors/brand.ts","../src/assertors/identity.ts","../src/assertors/trait.ts","../src/assertors/transformation.ts","../src/assertors/assertors.ts","../src/chain/chain.ts","../src/core/phantom.ts","../src/phantom.ts","../src/index.ts"],"names":["assertors","_PhantomChain","PhantomCore","_addTrait","_addTraits","_applyTransformation","_asBrand","_asIdentity","_dropTrait","_dropTraits","_revertTransformation","Phantom","Inspect","PhantomChain"],"mappings":"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","file":"index.js","sourcesContent":["import type { Brand } from '../core';\n\n/**\n * Creates a typed caster that assigns a {@link Brand} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the brand's nominal type applied. Use it for simple branded primitives\n * where you know the value is valid.\n *\n * @template B - The brand declaration to assign.\n * @returns A function that casts any value to the branded type.\n */\nexport const asBrand =\n  <B extends Brand.Any>() =>\n  <T>(value: T) =>\n    value as Brand.Assign<B, T>;\n","import type { Identity } from '../core';\n\n/**\n * Creates a typed caster that assigns an {@link Identity} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the identity's nominal type applied. Use it when you know a value\n * conforms to an identity but need to assert it for the type system.\n *\n * @template I - The identity declaration to assign.\n * @returns A function that casts any value to the assigned identity type.\n */\nexport const asIdentity =\n  <I extends Identity.Any>() =>\n  <V>(value: V): Identity.Assign<I, V> =>\n    value as any;\n","import type { Trait } from '../core';\n\n/**\n * Creates a typed caster that adds a single {@link Trait} to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to add.\n * @returns A function that adds the trait to any value.\n */\nexport const addTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Add<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that adds multiple {@link Trait}s to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to add.\n * @returns A function that adds all traits to any value.\n */\nexport const addTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.AddMulti<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes a single {@link Trait} from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to remove.\n * @returns A function that drops the trait from any value.\n */\nexport const dropTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Drop<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes multiple {@link Trait}s from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to remove.\n * @returns A function that drops all specified traits from any value.\n */\nexport const dropTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.DropMulti<Tr, V> =>\n    value as any;\n","import type { Transformation } from '../core';\n\n/**\n * Creates a typed applicator for a {@link Transformation}.\n *\n * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n * The `input` parameter is only used for type inference — it is not used at runtime.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that applies the transformation while preserving the input type for later revert.\n */\nexport const applyTransformation =\n  <Tr extends Transformation.Any>() =>\n  <I, T>(input: I, transformed: T) =>\n    transformed as Transformation.Apply<Tr, I, T>;\n\n/**\n * Creates a typed reverter for a {@link Transformation}.\n *\n * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n * The `transformed` parameter is used for type inference of the expected input,\n * and `input` is the computed result that must match the stored input type.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that reverts the transformation, stripping phantom metadata.\n */\nexport const revertTransformation =\n  <Tr extends Transformation.Any>() =>\n  <T, I>(transformed: T, input: I) =>\n    input as Transformation.Revert<Tr, T, I>;\n","import { asBrand } from './brand';\nimport { asIdentity } from './identity';\nimport { addTrait, addTraits, dropTrait, dropTraits } from './trait';\nimport { applyTransformation, revertTransformation } from './transformation';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\n\nexport namespace assertors {\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n}\n","/**\n * A fluent PhantomChain class for chaining Phantom assertors.\n *\n * This provides a better developer experience (DX) by allowing method chaining\n * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n * Call `.end()` to retrieve the final value.\n *\n * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n * (just object creation and method calls).\n *\n * Example:\n * ```ts\n * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n *\n * const result = new PhantomChain(\"value\")\n *   .with(asMyBrand)\n *   .with(asMyTrait)\n *   .with(applyMyTransform)\n *   .end();\n * ```\n */\nexport class PhantomChain<T> {\n  private value: T;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n\n  /**\n   * Apply the next assertor in the chain.\n   *\n   * @param assertor A function that takes the current value and returns the updated value (with new type).\n   * @returns A new PhantomChain instance with the updated value and type.\n   */\n  with<U>(assertor: (value: T) => U): PhantomChain<U> {\n    return new PhantomChain(assertor(this.value));\n  }\n\n  /**\n   * End the chain and return the final value.\n   *\n   * @returns The value after all transformations.\n   */\n  end(): T {\n    return this.value;\n  }\n}\n","/**\n * Phantom meatadata object manipulators.\n *\n * Phantom matadata object holds all metadata used by 'phantom'.\n */\nexport namespace PhantomCore {\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = T extends {\n    __Phantom: infer Phantom extends object;\n  }\n    ? Phantom\n    : never;\n\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = T extends {\n    __Phantom: { __OriginalType?: infer O };\n  }\n    ? Exclude<O, undefined>\n    : T;\n\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = <T>(value: T): StripPhantom<T> => value as any;\n}\n","import {\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nimport { PhantomChain } from './chain';\nimport type {\n  BaseCore,\n  InputCore,\n  LabelCore,\n  TagCore,\n  TraitsCore,\n  VariantsCore,\n  BrandCore,\n  IdentityCore,\n  TraitCore,\n  TransformationCore,\n  ErrorType,\n} from './core';\nimport { PhantomCore } from './core';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\nconst _PhantomChain = PhantomChain;\ntype _ErrorType<E> = ErrorType<E>;\n\nexport namespace Phantom {\n  /** --------------------------------------\n   * Types\n   * --------------------------------------- */\n\n  /**\n   * Optional human-readable label metadata.\n   *\n   * Labels are descriptive only and do not affect identity.\n   */\n  export namespace Label {\n    /** Marker type for labeled values */\n    export type Any = LabelCore.Any;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a label exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n  }\n\n  /**\n   * Nominal tag metadata.\n   *\n   * Tags uniquely identify a branded or identified type.\n   * A value may only have a single tag.\n   */\n  export namespace Tag {\n    /** Marker type for any tagged value */\n    export type Any = TagCore.Any;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n  }\n\n  /**\n   * Variant metadata.\n   *\n   * Variants represent mutually exclusive states of a type.\n   */\n  export namespace Variants {\n    /** Marker type for variant-bearing values */\n    export type Any = VariantsCore.Any;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n  }\n\n  /**\n   * Base-type metadata.\n   *\n   * Used to constrain which runtime types a brand, identity,\n   * or transformation may be applied to.\n   */\n  export namespace Base {\n    /** Marker type for base constraints */\n    export type Any = BaseCore.Any;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n  }\n\n  /**\n   * Input metadata.\n   *\n   * Utilities for attaching and querying input metadata in transformations.\n   */\n  export namespace Input {\n    /** Marker type for input value */\n    export type Any = InputCore.Any;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n  }\n\n  /**\n   * Trait metadata.\n   *\n   * Traits behave like a set of capabilities that can be\n   * added or removed independently.\n   */\n  export namespace Traits {\n    /** Marker type for trait-bearing values */\n    export type Any = TraitsCore.Any;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n  }\n\n  /**\n   * Branding API.\n   *\n   * Brands provide nominal typing for otherwise identical values.\n   * A value may only be branded once.\n   */\n  export namespace Brand {\n    /** Type guard for any brand. */\n    export type Any = BrandCore.Any;\n    /** Declare a brand */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n    > = BrandCore.Declare<T, L>;\n    /** Assign a brand to a value. Fails if the value is already branded */\n    export type Assign<B extends Any, T> = BrandCore.Assign<B, T>;\n    /** Assign a brand if possible, otherwise return the original type */\n    export type AssignSafe<B extends Any, T> = BrandCore.AssignSafe<B, T>;\n    /** Check whether value is branded with */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n  }\n\n  /**\n   * Identity API.\n   *\n   * Identities are brands with additional constraints:\n   * - Base type\n   * - Variants\n   */\n  export namespace Identity {\n    /** Type guard for any identity. */\n    export type Any = IdentityCore.Any;\n    /** Declare an identity */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = IdentityCore.Declare<T, L, B, V>;\n    /** Assign an identity to a value. Enforces base-type compatibility */\n    export type Assign<I extends Any, T> = IdentityCore.Assign<I, T>;\n    /** Safe identity assignment */\n    export type AssignSafe<I extends Any, T> = IdentityCore.AssignSafe<I, T>;\n    /** Set the active variant on an identity */\n    export type WithVariant<\n      I extends Any,\n      V extends Variants.VariantsOf<I>,\n    > = IdentityCore.WithVariant<I, V>;\n    /** Set the active variant on a value */\n    export type WithTypeVariant<\n      T,\n      V extends Variants.VariantsOf<T>,\n    > = IdentityCore.WithTypeVariant<T, V>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Any> = IdentityCore.isIdentity<T, I>;\n  }\n\n  /**\n   * Trait API.\n   *\n   * Traits are additive capabilities that can be attached\n   * or removed independently.\n   */\n  export namespace Trait {\n    /** Type guard for any trait. */\n    export type Any = TraitCore.Any;\n    /** Declare a trait */\n    export type Declare<Tr extends string | symbol> = TraitCore.Declare<Tr>;\n    /** Add a trait */\n    export type Add<Tr extends Any, T> = TraitCore.Add<Tr, T>;\n    /** Add multiple traits */\n    export type AddMulti<Tr extends readonly Any[], T> = TraitCore.AddMulti<\n      Tr,\n      T\n    >;\n    /** Remove a trait */\n    export type Drop<Tr extends Any, T> = TraitCore.Drop<Tr, T>;\n    /** Remove multiple traits */\n    export type DropMulti<Tr extends readonly Any[], T> = TraitCore.DropMulti<\n      Tr,\n      T\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Any> = TraitCore.HasTrait<T, Tr>;\n  }\n\n  /**\n   * Transformation API.\n   *\n   * Transformations represent reversible operations that\n   * change the shape of a value while preserving its origin.\n   */\n  export namespace Transformation {\n    /** Type guard for any transformation. */\n    export type Any = TransformationCore.Any;\n    /** Declare a transformation */\n    export type Declare<\n      I,\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = TransformationCore.Declare<I, T, L, B, V>;\n    /** Apply a transformation to a value. Enforces base-type compatibility */\n    export type Apply<Tr extends Any, I, T> = TransformationCore.Apply<\n      Tr,\n      I,\n      T\n    >;\n    /** Revert a transformation */\n    export type Revert<Tr extends Any, T, I> = TransformationCore.Revert<\n      Tr,\n      T,\n      I\n    >;\n    /** Revert a transformation whatever transformation was */\n    export type RevertAny<T, I> = TransformationCore.RevertAny<T, I>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /**\n   * Inspect API.\n   *\n   * Inspection helpers of phantom types.\n   */\n  export namespace Inspect {\n    /** Get phantom metadata object from a type */\n    export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n    /** Stip phantom metadata object from a type */\n    export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n    /** run-time helper for 'StringPhantom', used for debugging mainly */\n    export const stripPhantom = PhantomCore.stripPhantom;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n    /** Check whether value is branded with */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Identity.Any> = IdentityCore.isIdentity<\n      T,\n      I\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Trait.Any> = TraitCore.HasTrait<T, Tr>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Transformation.Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /** --------------------------------------\n   * assertors\n   * --------------------------------------- */\n\n  export namespace assertors {\n    /**\n     * Creates a typed caster that assigns a {@link Brand} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the brand's nominal type applied. Use it for simple branded primitives\n     * where you know the value is valid.\n     *\n     * @template B - The brand declaration to assign.\n     * @returns A function that casts any value to the branded type.\n     */\n    export const asBrand = _asBrand;\n\n    /**\n     * Creates a typed caster that assigns an {@link Identity} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the identity's nominal type applied. Use it when you know a value\n     * conforms to an identity but need to assert it for the type system.\n     *\n     * @template I - The identity declaration to assign.\n     * @returns A function that casts any value to the assigned identity type.\n     */\n    export const asIdentity = _asIdentity;\n\n    /**\n     * Creates a typed caster that adds a single {@link Trait} to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to add.\n     * @returns A function that adds the trait to any value.\n     */\n    export const addTrait = _addTrait;\n\n    /**\n     * Creates a typed caster that adds multiple {@link Trait}s to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to add.\n     * @returns A function that adds all traits to any value.\n     */\n    export const addTraits = _addTraits;\n\n    /**\n     * Creates a typed caster that removes a single {@link Trait} from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to remove.\n     * @returns A function that drops the trait from any value.\n     */\n    export const dropTrait = _dropTrait;\n\n    /**\n     * Creates a typed caster that removes multiple {@link Trait}s from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to remove.\n     * @returns A function that drops all specified traits from any value.\n     */\n    export const dropTraits = _dropTraits;\n\n    /**\n     * Creates a typed applicator for a {@link Transformation}.\n     *\n     * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n     * The `input` parameter is only used for type inference — it is not used at runtime.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that applies the transformation while preserving the input type for later revert.\n     */\n    export const applyTransformation = _applyTransformation;\n\n    /**\n     * Creates a typed reverter for a {@link Transformation}.\n     *\n     * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n     * The `transformed` parameter is used for type inference of the expected input,\n     * and `input` is the computed result that must match the stored input type.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that reverts the transformation, stripping phantom metadata.\n     */\n    export const revertTransformation = _revertTransformation;\n  }\n\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n\n  /** --------------------------------------\n   * Phantom object manipulators\n   * --------------------------------------- */\n\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = PhantomCore.stripPhantom;\n\n  /** --------------------------------------\n   * Error type\n   * --------------------------------------- */\n\n  /** Unique Error type for rules validation in phantom. */\n  export type ErrorType<E> = _ErrorType<E>;\n\n  /** --------------------------------------\n   * Chain class\n   * --------------------------------------- */\n\n  /**\n   * A fluent PhantomChain class for chaining Phantom assertors.\n   *\n   * This provides a better developer experience (DX) by allowing method chaining\n   * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n   * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n   * Call `.end()` to retrieve the final value.\n   *\n   * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n   * (just object creation and method calls).\n   *\n   * Example:\n   * ```ts\n   * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n   * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n   * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n   *\n   * const result = new PhantomChain(\"value\")\n   *   .with(asMyBrand)\n   *   .with(asMyTrait)\n   *   .with(applyMyTransform)\n   *   .end();\n   * ```\n   */\n  export class PhantomChain<T> extends _PhantomChain<T> {}\n}\n","export {\n  assertors,\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nexport { PhantomChain } from './chain';\nexport { Phantom } from './phantom';\nexport type {\n  Base,\n  Brand,\n  ErrorType,\n  Identity,\n  Input,\n  Inspect,\n  Label,\n  PhantomCore,\n  Tag,\n  Trait,\n  Traits,\n  Transformation,\n  Variants,\n} from './core';\nimport { Phantom } from './phantom';\nexport default Phantom;\n"]}
+{"version":3,"sources":["../src/assertors/brand.ts","../src/assertors/identity.ts","../src/assertors/trait.ts","../src/assertors/transformation.ts","../src/assertors/assertors.ts","../src/chain/chain.ts","../src/core/phantom.ts","../src/phantom.ts","../src/index.ts"],"names":["assertors","_PhantomChain","PhantomCore","_addTrait","_addTraits","_applyTransformation","_asBrand","_asIdentity","_dropTrait","_dropTraits","_revertTransformation","Phantom","Inspect","PhantomChain"],"mappings":"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","file":"index.js","sourcesContent":["import type { Brand } from '../core';\n\n/**\n * Creates a typed caster that assigns a {@link Brand} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the brand's nominal type applied. Use it for simple branded primitives\n * where you know the value is valid.\n *\n * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n *\n * @template B - The brand declaration to assign.\n * @returns A function that casts any value to the branded type.\n */\nexport const asBrand =\n  <B extends Brand.Any>() =>\n  <T>(value: T) =>\n    value as Brand.Assign<B, T>;\n","import type { Identity } from '../core';\n\n/**\n * Creates a typed caster that assigns an {@link Identity} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the identity's nominal type applied. Use it when you know a value\n * conforms to an identity but need to assert it for the type system.\n *\n * @template I - The identity declaration to assign.\n * @returns A function that casts any value to the assigned identity type.\n */\nexport const asIdentity =\n  <I extends Identity.Any>() =>\n  <V>(value: V): Identity.Assign<I, V> =>\n    value as any;\n","import type { Trait } from '../core';\n\n/**\n * Creates a typed caster that adds a single {@link Trait} to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to add.\n * @returns A function that adds the trait to any value.\n */\nexport const addTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Add<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that adds multiple {@link Trait}s to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to add.\n * @returns A function that adds all traits to any value.\n */\nexport const addTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.AddMulti<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes a single {@link Trait} from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to remove.\n * @returns A function that drops the trait from any value.\n */\nexport const dropTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Drop<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes multiple {@link Trait}s from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to remove.\n * @returns A function that drops all specified traits from any value.\n */\nexport const dropTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.DropMulti<Tr, V> =>\n    value as any;\n","import type { Transformation } from '../core';\n\n/**\n * Creates a typed applicator for a {@link Transformation}.\n *\n * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n * The `input` parameter is only used for type inference — it is not used at runtime.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that applies the transformation while preserving the input type for later revert.\n */\nexport const applyTransformation =\n  <Tr extends Transformation.Any>() =>\n  <I, T>(input: I, transformed: T) =>\n    transformed as Transformation.Apply<Tr, I, T>;\n\n/**\n * Creates a typed reverter for a {@link Transformation}.\n *\n * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n * The `transformed` parameter is used for type inference of the expected input,\n * and `input` is the computed result that must match the stored input type.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that reverts the transformation, stripping phantom metadata.\n */\nexport const revertTransformation =\n  <Tr extends Transformation.Any>() =>\n  <T, I>(transformed: T, input: I) =>\n    input as Transformation.Revert<Tr, T, I>;\n","import { asBrand } from './brand';\nimport { asIdentity } from './identity';\nimport { addTrait, addTraits, dropTrait, dropTraits } from './trait';\nimport { applyTransformation, revertTransformation } from './transformation';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\n\nexport namespace assertors {\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n}\n","/**\n * A fluent PhantomChain class for chaining Phantom assertors.\n *\n * This provides a better developer experience (DX) by allowing method chaining\n * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n * Call `.end()` to retrieve the final value.\n *\n * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n * (just object creation and method calls).\n *\n * Example:\n * ```ts\n * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n *\n * const result = new PhantomChain(\"value\")\n *   .with(asMyBrand)\n *   .with(asMyTrait)\n *   .with(applyMyTransform)\n *   .end();\n * ```\n */\nexport class PhantomChain<T> {\n  private value: T;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n\n  /**\n   * Apply the next assertor in the chain.\n   *\n   * @param assertor A function that takes the current value and returns the updated value (with new type).\n   * @returns A new PhantomChain instance with the updated value and type.\n   */\n  with<U>(assertor: (value: T) => U): PhantomChain<U> {\n    return new PhantomChain(assertor(this.value));\n  }\n\n  /**\n   * End the chain and return the final value.\n   *\n   * @returns The value after all transformations.\n   */\n  end(): T {\n    return this.value;\n  }\n}\n","/** Stip phantom metadata object from a type */\ntype StripPhantom<T> = T extends {\n  __Phantom: { __OriginalType?: infer O };\n}\n  ? Exclude<O, undefined>\n  : T;\n\n/** run-time helper for 'StringPhantom', used for debugging mainly */\nexport const stripPhantom = <T>(value: T): StripPhantom<T> => value as any;\n\n// Avoid bundler bugs\ntype _StripPhantom<T> = StripPhantom<T>;\nconst _stripPhantom = stripPhantom;\n\n/**\n * Phantom meatadata object manipulators.\n *\n * Phantom matadata object holds all metadata used by 'phantom'.\n */\nexport namespace PhantomCore {\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = T extends {\n    __Phantom: infer Phantom extends object;\n  }\n    ? Phantom\n    : never;\n\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = _StripPhantom<T>;\n\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = _stripPhantom;\n}\n","import {\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nimport { PhantomChain } from './chain';\nimport type {\n  BaseCore,\n  InputCore,\n  LabelCore,\n  TagCore,\n  TraitsCore,\n  VariantsCore,\n  BrandCore,\n  IdentityCore,\n  TraitCore,\n  TransformationCore,\n  ErrorType,\n} from './core';\nimport { PhantomCore } from './core';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\nconst _PhantomChain = PhantomChain;\ntype _ErrorType<E> = ErrorType<E>;\n\nexport namespace Phantom {\n  /** --------------------------------------\n   * Types\n   * --------------------------------------- */\n\n  /**\n   * Optional human-readable label metadata.\n   *\n   * Labels are descriptive only and do not affect identity.\n   */\n  export namespace Label {\n    /** Marker type for labeled values */\n    export type Any = LabelCore.Any;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a label exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n  }\n\n  /**\n   * Nominal tag metadata.\n   *\n   * Tags uniquely identify a branded or identified type.\n   * A value may only have a single tag.\n   */\n  export namespace Tag {\n    /** Marker type for any tagged value */\n    export type Any = TagCore.Any;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n  }\n\n  /**\n   * Variant metadata.\n   *\n   * Variants represent mutually exclusive states of a type.\n   */\n  export namespace Variants {\n    /** Marker type for variant-bearing values */\n    export type Any = VariantsCore.Any;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n  }\n\n  /**\n   * Base-type metadata.\n   *\n   * Used to constrain which runtime types a brand, identity,\n   * or transformation may be applied to.\n   */\n  export namespace Base {\n    /** Marker type for base constraints */\n    export type Any = BaseCore.Any;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n  }\n\n  /**\n   * Input metadata.\n   *\n   * Utilities for attaching and querying input metadata in transformations.\n   */\n  export namespace Input {\n    /** Marker type for input value */\n    export type Any = InputCore.Any;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n  }\n\n  /**\n   * Trait metadata.\n   *\n   * Traits behave like a set of capabilities that can be\n   * added or removed independently.\n   */\n  export namespace Traits {\n    /** Marker type for trait-bearing values */\n    export type Any = TraitsCore.Any;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n  }\n\n  /**\n   * Branding API.\n   *\n   * Brands provide nominal typing for otherwise identical values.\n   * A value may only be branded once.\n   *\n   * @deprecated To unify Api surface 'Identity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n   */\n  export namespace Brand {\n    /** Type guard for any brand. */\n    export type Any = BrandCore.Any;\n    /** Declare a brand */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n    > = BrandCore.Declare<T, L>;\n    /** Assign a brand to a value. Fails if the value is already branded */\n    export type Assign<B extends Any, T> = BrandCore.Assign<B, T>;\n    /** Assign a brand if possible, otherwise return the original type */\n    export type AssignSafe<B extends Any, T> = BrandCore.AssignSafe<B, T>;\n    /** Check whether value is branded with */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n  }\n\n  /**\n   * Identity API.\n   *\n   * Identities are brands with additional constraints:\n   * - Base type\n   * - Variants\n   */\n  export namespace Identity {\n    /** Type guard for any identity. */\n    export type Any = IdentityCore.Any;\n    /** Declare an identity */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = IdentityCore.Declare<T, L, B, V>;\n    /** Assign an identity to a value. Enforces base-type compatibility */\n    export type Assign<I extends Any, T> = IdentityCore.Assign<I, T>;\n    /** Safe identity assignment */\n    export type AssignSafe<I extends Any, T> = IdentityCore.AssignSafe<I, T>;\n    /** Set the active variant on an identity */\n    export type WithVariant<\n      I extends Any,\n      V extends Variants.VariantsOf<I>,\n    > = IdentityCore.WithVariant<I, V>;\n    /** Set the active variant on a value */\n    export type WithTypeVariant<\n      T,\n      V extends Variants.VariantsOf<T>,\n    > = IdentityCore.WithTypeVariant<T, V>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Any> = IdentityCore.isIdentity<T, I>;\n  }\n\n  /**\n   * Trait API.\n   *\n   * Traits are additive capabilities that can be attached\n   * or removed independently.\n   */\n  export namespace Trait {\n    /** Type guard for any trait. */\n    export type Any = TraitCore.Any;\n    /** Declare a trait */\n    export type Declare<Tr extends string | symbol> = TraitCore.Declare<Tr>;\n    /** Add a trait */\n    export type Add<Tr extends Any, T> = TraitCore.Add<Tr, T>;\n    /** Add multiple traits */\n    export type AddMulti<Tr extends readonly Any[], T> = TraitCore.AddMulti<\n      Tr,\n      T\n    >;\n    /** Remove a trait */\n    export type Drop<Tr extends Any, T> = TraitCore.Drop<Tr, T>;\n    /** Remove multiple traits */\n    export type DropMulti<Tr extends readonly Any[], T> = TraitCore.DropMulti<\n      Tr,\n      T\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Any> = TraitCore.HasTrait<T, Tr>;\n  }\n\n  /**\n   * Transformation API.\n   *\n   * Transformations represent reversible operations that\n   * change the shape of a value while preserving its origin.\n   */\n  export namespace Transformation {\n    /** Type guard for any transformation. */\n    export type Any = TransformationCore.Any;\n    /** Declare a transformation */\n    export type Declare<\n      I,\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = TransformationCore.Declare<I, T, L, B, V>;\n    /** Apply a transformation to a value. Enforces base-type compatibility */\n    export type Apply<Tr extends Any, I, T> = TransformationCore.Apply<\n      Tr,\n      I,\n      T\n    >;\n    /** Revert a transformation */\n    export type Revert<Tr extends Any, T, I> = TransformationCore.Revert<\n      Tr,\n      T,\n      I\n    >;\n    /** Revert a transformation whatever transformation was */\n    export type RevertAny<T, I> = TransformationCore.RevertAny<T, I>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /**\n   * Inspect API.\n   *\n   * Inspection helpers of phantom types.\n   */\n  export namespace Inspect {\n    /** Get phantom metadata object from a type */\n    export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n    /** Stip phantom metadata object from a type */\n    export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n    /** run-time helper for 'StringPhantom', used for debugging mainly */\n    export const stripPhantom = PhantomCore.stripPhantom;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n    /**\n     * Check whether value is branded with\n     *\n     * @deprecated To unify Api surface 'isIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n     */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Identity.Any> = IdentityCore.isIdentity<\n      T,\n      I\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Trait.Any> = TraitCore.HasTrait<T, Tr>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Transformation.Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /** --------------------------------------\n   * assertors\n   * --------------------------------------- */\n\n  export namespace assertors {\n    /**\n     * Creates a typed caster that assigns a {@link Brand} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the brand's nominal type applied. Use it for simple branded primitives\n     * where you know the value is valid.\n     *\n     * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n     *\n     * @template B - The brand declaration to assign.\n     * @returns A function that casts any value to the branded type.\n     */\n    export const asBrand = _asBrand;\n\n    /**\n     * Creates a typed caster that assigns an {@link Identity} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the identity's nominal type applied. Use it when you know a value\n     * conforms to an identity but need to assert it for the type system.\n     *\n     * @template I - The identity declaration to assign.\n     * @returns A function that casts any value to the assigned identity type.\n     */\n    export const asIdentity = _asIdentity;\n\n    /**\n     * Creates a typed caster that adds a single {@link Trait} to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to add.\n     * @returns A function that adds the trait to any value.\n     */\n    export const addTrait = _addTrait;\n\n    /**\n     * Creates a typed caster that adds multiple {@link Trait}s to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to add.\n     * @returns A function that adds all traits to any value.\n     */\n    export const addTraits = _addTraits;\n\n    /**\n     * Creates a typed caster that removes a single {@link Trait} from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to remove.\n     * @returns A function that drops the trait from any value.\n     */\n    export const dropTrait = _dropTrait;\n\n    /**\n     * Creates a typed caster that removes multiple {@link Trait}s from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to remove.\n     * @returns A function that drops all specified traits from any value.\n     */\n    export const dropTraits = _dropTraits;\n\n    /**\n     * Creates a typed applicator for a {@link Transformation}.\n     *\n     * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n     * The `input` parameter is only used for type inference — it is not used at runtime.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that applies the transformation while preserving the input type for later revert.\n     */\n    export const applyTransformation = _applyTransformation;\n\n    /**\n     * Creates a typed reverter for a {@link Transformation}.\n     *\n     * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n     * The `transformed` parameter is used for type inference of the expected input,\n     * and `input` is the computed result that must match the stored input type.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that reverts the transformation, stripping phantom metadata.\n     */\n    export const revertTransformation = _revertTransformation;\n  }\n\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n\n  /** --------------------------------------\n   * Phantom object manipulators\n   * --------------------------------------- */\n\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = PhantomCore.stripPhantom;\n\n  /** --------------------------------------\n   * Error type\n   * --------------------------------------- */\n\n  /** Unique Error type for rules validation in phantom. */\n  export type ErrorType<E> = _ErrorType<E>;\n\n  /** --------------------------------------\n   * Chain class\n   * --------------------------------------- */\n\n  /**\n   * A fluent PhantomChain class for chaining Phantom assertors.\n   *\n   * This provides a better developer experience (DX) by allowing method chaining\n   * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n   * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n   * Call `.end()` to retrieve the final value.\n   *\n   * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n   * (just object creation and method calls).\n   *\n   * Example:\n   * ```ts\n   * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n   * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n   * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n   *\n   * const result = new PhantomChain(\"value\")\n   *   .with(asMyBrand)\n   *   .with(asMyTrait)\n   *   .with(applyMyTransform)\n   *   .end();\n   * ```\n   */\n  export class PhantomChain<T> extends _PhantomChain<T> {}\n}\n","export {\n  assertors,\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nexport { PhantomChain } from './chain';\nexport { Phantom } from './phantom';\nexport type {\n  Base,\n  Brand,\n  ErrorType,\n  Identity,\n  Input,\n  Inspect,\n  Label,\n  Tag,\n  Trait,\n  Traits,\n  Transformation,\n  Variants,\n} from './core';\nexport { PhantomCore, stripPhantom } from './core';\nimport { Phantom } from './phantom';\nexport default Phantom;\n"]}

package/dist/index.mjs

@@ -65,9 +65,11 @@ var PhantomChain = class _PhantomChain2 {
 };
 
 // src/core/phantom.ts
+var stripPhantom = (value) => value;
+var _stripPhantom = stripPhantom;
 var PhantomCore;
 ((PhantomCore2) => {
-  PhantomCore2.stripPhantom = (value) => value;
+  PhantomCore2.stripPhantom = _stripPhantom;
 })(PhantomCore || (PhantomCore = {}));
 
 // src/phantom.ts
@@ -112,6 +114,6 @@ var Phantom;
 // src/index.ts
 var index_default = Phantom;
 
-export { Phantom, PhantomChain, addTrait, addTraits, applyTransformation, asBrand, asIdentity, assertors, index_default as default, dropTrait, dropTraits, revertTransformation };
+export { Phantom, PhantomChain, PhantomCore, addTrait, addTraits, applyTransformation, asBrand, asIdentity, assertors, index_default as default, dropTrait, dropTraits, revertTransformation, stripPhantom };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/assertors/brand.ts","../src/assertors/identity.ts","../src/assertors/trait.ts","../src/assertors/transformation.ts","../src/assertors/assertors.ts","../src/chain/chain.ts","../src/core/phantom.ts","../src/phantom.ts","../src/index.ts"],"names":["assertors","_PhantomChain","PhantomCore","_addTrait","_addTraits","_applyTransformation","_asBrand","_asIdentity","_dropTrait","_dropTraits","_revertTransformation","Phantom","Inspect","PhantomChain"],"mappings":"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","file":"index.mjs","sourcesContent":["import type { Brand } from '../core';\n\n/**\n * Creates a typed caster that assigns a {@link Brand} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the brand's nominal type applied. Use it for simple branded primitives\n * where you know the value is valid.\n *\n * @template B - The brand declaration to assign.\n * @returns A function that casts any value to the branded type.\n */\nexport const asBrand =\n  <B extends Brand.Any>() =>\n  <T>(value: T) =>\n    value as Brand.Assign<B, T>;\n","import type { Identity } from '../core';\n\n/**\n * Creates a typed caster that assigns an {@link Identity} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the identity's nominal type applied. Use it when you know a value\n * conforms to an identity but need to assert it for the type system.\n *\n * @template I - The identity declaration to assign.\n * @returns A function that casts any value to the assigned identity type.\n */\nexport const asIdentity =\n  <I extends Identity.Any>() =>\n  <V>(value: V): Identity.Assign<I, V> =>\n    value as any;\n","import type { Trait } from '../core';\n\n/**\n * Creates a typed caster that adds a single {@link Trait} to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to add.\n * @returns A function that adds the trait to any value.\n */\nexport const addTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Add<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that adds multiple {@link Trait}s to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to add.\n * @returns A function that adds all traits to any value.\n */\nexport const addTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.AddMulti<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes a single {@link Trait} from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to remove.\n * @returns A function that drops the trait from any value.\n */\nexport const dropTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Drop<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes multiple {@link Trait}s from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to remove.\n * @returns A function that drops all specified traits from any value.\n */\nexport const dropTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.DropMulti<Tr, V> =>\n    value as any;\n","import type { Transformation } from '../core';\n\n/**\n * Creates a typed applicator for a {@link Transformation}.\n *\n * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n * The `input` parameter is only used for type inference — it is not used at runtime.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that applies the transformation while preserving the input type for later revert.\n */\nexport const applyTransformation =\n  <Tr extends Transformation.Any>() =>\n  <I, T>(input: I, transformed: T) =>\n    transformed as Transformation.Apply<Tr, I, T>;\n\n/**\n * Creates a typed reverter for a {@link Transformation}.\n *\n * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n * The `transformed` parameter is used for type inference of the expected input,\n * and `input` is the computed result that must match the stored input type.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that reverts the transformation, stripping phantom metadata.\n */\nexport const revertTransformation =\n  <Tr extends Transformation.Any>() =>\n  <T, I>(transformed: T, input: I) =>\n    input as Transformation.Revert<Tr, T, I>;\n","import { asBrand } from './brand';\nimport { asIdentity } from './identity';\nimport { addTrait, addTraits, dropTrait, dropTraits } from './trait';\nimport { applyTransformation, revertTransformation } from './transformation';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\n\nexport namespace assertors {\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n}\n","/**\n * A fluent PhantomChain class for chaining Phantom assertors.\n *\n * This provides a better developer experience (DX) by allowing method chaining\n * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n * Call `.end()` to retrieve the final value.\n *\n * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n * (just object creation and method calls).\n *\n * Example:\n * ```ts\n * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n *\n * const result = new PhantomChain(\"value\")\n *   .with(asMyBrand)\n *   .with(asMyTrait)\n *   .with(applyMyTransform)\n *   .end();\n * ```\n */\nexport class PhantomChain<T> {\n  private value: T;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n\n  /**\n   * Apply the next assertor in the chain.\n   *\n   * @param assertor A function that takes the current value and returns the updated value (with new type).\n   * @returns A new PhantomChain instance with the updated value and type.\n   */\n  with<U>(assertor: (value: T) => U): PhantomChain<U> {\n    return new PhantomChain(assertor(this.value));\n  }\n\n  /**\n   * End the chain and return the final value.\n   *\n   * @returns The value after all transformations.\n   */\n  end(): T {\n    return this.value;\n  }\n}\n","/**\n * Phantom meatadata object manipulators.\n *\n * Phantom matadata object holds all metadata used by 'phantom'.\n */\nexport namespace PhantomCore {\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = T extends {\n    __Phantom: infer Phantom extends object;\n  }\n    ? Phantom\n    : never;\n\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = T extends {\n    __Phantom: { __OriginalType?: infer O };\n  }\n    ? Exclude<O, undefined>\n    : T;\n\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = <T>(value: T): StripPhantom<T> => value as any;\n}\n","import {\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nimport { PhantomChain } from './chain';\nimport type {\n  BaseCore,\n  InputCore,\n  LabelCore,\n  TagCore,\n  TraitsCore,\n  VariantsCore,\n  BrandCore,\n  IdentityCore,\n  TraitCore,\n  TransformationCore,\n  ErrorType,\n} from './core';\nimport { PhantomCore } from './core';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\nconst _PhantomChain = PhantomChain;\ntype _ErrorType<E> = ErrorType<E>;\n\nexport namespace Phantom {\n  /** --------------------------------------\n   * Types\n   * --------------------------------------- */\n\n  /**\n   * Optional human-readable label metadata.\n   *\n   * Labels are descriptive only and do not affect identity.\n   */\n  export namespace Label {\n    /** Marker type for labeled values */\n    export type Any = LabelCore.Any;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a label exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n  }\n\n  /**\n   * Nominal tag metadata.\n   *\n   * Tags uniquely identify a branded or identified type.\n   * A value may only have a single tag.\n   */\n  export namespace Tag {\n    /** Marker type for any tagged value */\n    export type Any = TagCore.Any;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n  }\n\n  /**\n   * Variant metadata.\n   *\n   * Variants represent mutually exclusive states of a type.\n   */\n  export namespace Variants {\n    /** Marker type for variant-bearing values */\n    export type Any = VariantsCore.Any;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n  }\n\n  /**\n   * Base-type metadata.\n   *\n   * Used to constrain which runtime types a brand, identity,\n   * or transformation may be applied to.\n   */\n  export namespace Base {\n    /** Marker type for base constraints */\n    export type Any = BaseCore.Any;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n  }\n\n  /**\n   * Input metadata.\n   *\n   * Utilities for attaching and querying input metadata in transformations.\n   */\n  export namespace Input {\n    /** Marker type for input value */\n    export type Any = InputCore.Any;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n  }\n\n  /**\n   * Trait metadata.\n   *\n   * Traits behave like a set of capabilities that can be\n   * added or removed independently.\n   */\n  export namespace Traits {\n    /** Marker type for trait-bearing values */\n    export type Any = TraitsCore.Any;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n  }\n\n  /**\n   * Branding API.\n   *\n   * Brands provide nominal typing for otherwise identical values.\n   * A value may only be branded once.\n   */\n  export namespace Brand {\n    /** Type guard for any brand. */\n    export type Any = BrandCore.Any;\n    /** Declare a brand */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n    > = BrandCore.Declare<T, L>;\n    /** Assign a brand to a value. Fails if the value is already branded */\n    export type Assign<B extends Any, T> = BrandCore.Assign<B, T>;\n    /** Assign a brand if possible, otherwise return the original type */\n    export type AssignSafe<B extends Any, T> = BrandCore.AssignSafe<B, T>;\n    /** Check whether value is branded with */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n  }\n\n  /**\n   * Identity API.\n   *\n   * Identities are brands with additional constraints:\n   * - Base type\n   * - Variants\n   */\n  export namespace Identity {\n    /** Type guard for any identity. */\n    export type Any = IdentityCore.Any;\n    /** Declare an identity */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = IdentityCore.Declare<T, L, B, V>;\n    /** Assign an identity to a value. Enforces base-type compatibility */\n    export type Assign<I extends Any, T> = IdentityCore.Assign<I, T>;\n    /** Safe identity assignment */\n    export type AssignSafe<I extends Any, T> = IdentityCore.AssignSafe<I, T>;\n    /** Set the active variant on an identity */\n    export type WithVariant<\n      I extends Any,\n      V extends Variants.VariantsOf<I>,\n    > = IdentityCore.WithVariant<I, V>;\n    /** Set the active variant on a value */\n    export type WithTypeVariant<\n      T,\n      V extends Variants.VariantsOf<T>,\n    > = IdentityCore.WithTypeVariant<T, V>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Any> = IdentityCore.isIdentity<T, I>;\n  }\n\n  /**\n   * Trait API.\n   *\n   * Traits are additive capabilities that can be attached\n   * or removed independently.\n   */\n  export namespace Trait {\n    /** Type guard for any trait. */\n    export type Any = TraitCore.Any;\n    /** Declare a trait */\n    export type Declare<Tr extends string | symbol> = TraitCore.Declare<Tr>;\n    /** Add a trait */\n    export type Add<Tr extends Any, T> = TraitCore.Add<Tr, T>;\n    /** Add multiple traits */\n    export type AddMulti<Tr extends readonly Any[], T> = TraitCore.AddMulti<\n      Tr,\n      T\n    >;\n    /** Remove a trait */\n    export type Drop<Tr extends Any, T> = TraitCore.Drop<Tr, T>;\n    /** Remove multiple traits */\n    export type DropMulti<Tr extends readonly Any[], T> = TraitCore.DropMulti<\n      Tr,\n      T\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Any> = TraitCore.HasTrait<T, Tr>;\n  }\n\n  /**\n   * Transformation API.\n   *\n   * Transformations represent reversible operations that\n   * change the shape of a value while preserving its origin.\n   */\n  export namespace Transformation {\n    /** Type guard for any transformation. */\n    export type Any = TransformationCore.Any;\n    /** Declare a transformation */\n    export type Declare<\n      I,\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = TransformationCore.Declare<I, T, L, B, V>;\n    /** Apply a transformation to a value. Enforces base-type compatibility */\n    export type Apply<Tr extends Any, I, T> = TransformationCore.Apply<\n      Tr,\n      I,\n      T\n    >;\n    /** Revert a transformation */\n    export type Revert<Tr extends Any, T, I> = TransformationCore.Revert<\n      Tr,\n      T,\n      I\n    >;\n    /** Revert a transformation whatever transformation was */\n    export type RevertAny<T, I> = TransformationCore.RevertAny<T, I>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /**\n   * Inspect API.\n   *\n   * Inspection helpers of phantom types.\n   */\n  export namespace Inspect {\n    /** Get phantom metadata object from a type */\n    export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n    /** Stip phantom metadata object from a type */\n    export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n    /** run-time helper for 'StringPhantom', used for debugging mainly */\n    export const stripPhantom = PhantomCore.stripPhantom;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n    /** Check whether value is branded with */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Identity.Any> = IdentityCore.isIdentity<\n      T,\n      I\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Trait.Any> = TraitCore.HasTrait<T, Tr>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Transformation.Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /** --------------------------------------\n   * assertors\n   * --------------------------------------- */\n\n  export namespace assertors {\n    /**\n     * Creates a typed caster that assigns a {@link Brand} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the brand's nominal type applied. Use it for simple branded primitives\n     * where you know the value is valid.\n     *\n     * @template B - The brand declaration to assign.\n     * @returns A function that casts any value to the branded type.\n     */\n    export const asBrand = _asBrand;\n\n    /**\n     * Creates a typed caster that assigns an {@link Identity} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the identity's nominal type applied. Use it when you know a value\n     * conforms to an identity but need to assert it for the type system.\n     *\n     * @template I - The identity declaration to assign.\n     * @returns A function that casts any value to the assigned identity type.\n     */\n    export const asIdentity = _asIdentity;\n\n    /**\n     * Creates a typed caster that adds a single {@link Trait} to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to add.\n     * @returns A function that adds the trait to any value.\n     */\n    export const addTrait = _addTrait;\n\n    /**\n     * Creates a typed caster that adds multiple {@link Trait}s to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to add.\n     * @returns A function that adds all traits to any value.\n     */\n    export const addTraits = _addTraits;\n\n    /**\n     * Creates a typed caster that removes a single {@link Trait} from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to remove.\n     * @returns A function that drops the trait from any value.\n     */\n    export const dropTrait = _dropTrait;\n\n    /**\n     * Creates a typed caster that removes multiple {@link Trait}s from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to remove.\n     * @returns A function that drops all specified traits from any value.\n     */\n    export const dropTraits = _dropTraits;\n\n    /**\n     * Creates a typed applicator for a {@link Transformation}.\n     *\n     * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n     * The `input` parameter is only used for type inference — it is not used at runtime.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that applies the transformation while preserving the input type for later revert.\n     */\n    export const applyTransformation = _applyTransformation;\n\n    /**\n     * Creates a typed reverter for a {@link Transformation}.\n     *\n     * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n     * The `transformed` parameter is used for type inference of the expected input,\n     * and `input` is the computed result that must match the stored input type.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that reverts the transformation, stripping phantom metadata.\n     */\n    export const revertTransformation = _revertTransformation;\n  }\n\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n\n  /** --------------------------------------\n   * Phantom object manipulators\n   * --------------------------------------- */\n\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = PhantomCore.stripPhantom;\n\n  /** --------------------------------------\n   * Error type\n   * --------------------------------------- */\n\n  /** Unique Error type for rules validation in phantom. */\n  export type ErrorType<E> = _ErrorType<E>;\n\n  /** --------------------------------------\n   * Chain class\n   * --------------------------------------- */\n\n  /**\n   * A fluent PhantomChain class for chaining Phantom assertors.\n   *\n   * This provides a better developer experience (DX) by allowing method chaining\n   * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n   * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n   * Call `.end()` to retrieve the final value.\n   *\n   * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n   * (just object creation and method calls).\n   *\n   * Example:\n   * ```ts\n   * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n   * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n   * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n   *\n   * const result = new PhantomChain(\"value\")\n   *   .with(asMyBrand)\n   *   .with(asMyTrait)\n   *   .with(applyMyTransform)\n   *   .end();\n   * ```\n   */\n  export class PhantomChain<T> extends _PhantomChain<T> {}\n}\n","export {\n  assertors,\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nexport { PhantomChain } from './chain';\nexport { Phantom } from './phantom';\nexport type {\n  Base,\n  Brand,\n  ErrorType,\n  Identity,\n  Input,\n  Inspect,\n  Label,\n  PhantomCore,\n  Tag,\n  Trait,\n  Traits,\n  Transformation,\n  Variants,\n} from './core';\nimport { Phantom } from './phantom';\nexport default Phantom;\n"]}
+{"version":3,"sources":["../src/assertors/brand.ts","../src/assertors/identity.ts","../src/assertors/trait.ts","../src/assertors/transformation.ts","../src/assertors/assertors.ts","../src/chain/chain.ts","../src/core/phantom.ts","../src/phantom.ts","../src/index.ts"],"names":["assertors","_PhantomChain","PhantomCore","_addTrait","_addTraits","_applyTransformation","_asBrand","_asIdentity","_dropTrait","_dropTraits","_revertTransformation","Phantom","Inspect","PhantomChain"],"mappings":"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","file":"index.mjs","sourcesContent":["import type { Brand } from '../core';\n\n/**\n * Creates a typed caster that assigns a {@link Brand} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the brand's nominal type applied. Use it for simple branded primitives\n * where you know the value is valid.\n *\n * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n *\n * @template B - The brand declaration to assign.\n * @returns A function that casts any value to the branded type.\n */\nexport const asBrand =\n  <B extends Brand.Any>() =>\n  <T>(value: T) =>\n    value as Brand.Assign<B, T>;\n","import type { Identity } from '../core';\n\n/**\n * Creates a typed caster that assigns an {@link Identity} to a value.\n *\n * This is a zero-cost runtime assertion helper — it simply returns the value\n * with the identity's nominal type applied. Use it when you know a value\n * conforms to an identity but need to assert it for the type system.\n *\n * @template I - The identity declaration to assign.\n * @returns A function that casts any value to the assigned identity type.\n */\nexport const asIdentity =\n  <I extends Identity.Any>() =>\n  <V>(value: V): Identity.Assign<I, V> =>\n    value as any;\n","import type { Trait } from '../core';\n\n/**\n * Creates a typed caster that adds a single {@link Trait} to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to add.\n * @returns A function that adds the trait to any value.\n */\nexport const addTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Add<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that adds multiple {@link Trait}s to a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to add.\n * @returns A function that adds all traits to any value.\n */\nexport const addTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.AddMulti<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes a single {@link Trait} from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The trait declaration to remove.\n * @returns A function that drops the trait from any value.\n */\nexport const dropTrait =\n  <Tr extends Trait.Any>() =>\n  <V>(value: V): Trait.Drop<Tr, V> =>\n    value as any;\n\n/**\n * Creates a typed caster that removes multiple {@link Trait}s from a value.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - Tuple of trait declarations to remove.\n * @returns A function that drops all specified traits from any value.\n */\nexport const dropTraits =\n  <Tr extends Trait.Any[]>() =>\n  <V>(value: V): Trait.DropMulti<Tr, V> =>\n    value as any;\n","import type { Transformation } from '../core';\n\n/**\n * Creates a typed applicator for a {@link Transformation}.\n *\n * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n * The `input` parameter is only used for type inference — it is not used at runtime.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that applies the transformation while preserving the input type for later revert.\n */\nexport const applyTransformation =\n  <Tr extends Transformation.Any>() =>\n  <I, T>(input: I, transformed: T) =>\n    transformed as Transformation.Apply<Tr, I, T>;\n\n/**\n * Creates a typed reverter for a {@link Transformation}.\n *\n * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n * The `transformed` parameter is used for type inference of the expected input,\n * and `input` is the computed result that must match the stored input type.\n *\n * Zero-runtime-cost assertion helper.\n *\n * @template Tr - The transformation declaration.\n * @returns A function that reverts the transformation, stripping phantom metadata.\n */\nexport const revertTransformation =\n  <Tr extends Transformation.Any>() =>\n  <T, I>(transformed: T, input: I) =>\n    input as Transformation.Revert<Tr, T, I>;\n","import { asBrand } from './brand';\nimport { asIdentity } from './identity';\nimport { addTrait, addTraits, dropTrait, dropTraits } from './trait';\nimport { applyTransformation, revertTransformation } from './transformation';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\n\nexport namespace assertors {\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n}\n","/**\n * A fluent PhantomChain class for chaining Phantom assertors.\n *\n * This provides a better developer experience (DX) by allowing method chaining\n * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n * Call `.end()` to retrieve the final value.\n *\n * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n * (just object creation and method calls).\n *\n * Example:\n * ```ts\n * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n *\n * const result = new PhantomChain(\"value\")\n *   .with(asMyBrand)\n *   .with(asMyTrait)\n *   .with(applyMyTransform)\n *   .end();\n * ```\n */\nexport class PhantomChain<T> {\n  private value: T;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n\n  /**\n   * Apply the next assertor in the chain.\n   *\n   * @param assertor A function that takes the current value and returns the updated value (with new type).\n   * @returns A new PhantomChain instance with the updated value and type.\n   */\n  with<U>(assertor: (value: T) => U): PhantomChain<U> {\n    return new PhantomChain(assertor(this.value));\n  }\n\n  /**\n   * End the chain and return the final value.\n   *\n   * @returns The value after all transformations.\n   */\n  end(): T {\n    return this.value;\n  }\n}\n","/** Stip phantom metadata object from a type */\ntype StripPhantom<T> = T extends {\n  __Phantom: { __OriginalType?: infer O };\n}\n  ? Exclude<O, undefined>\n  : T;\n\n/** run-time helper for 'StringPhantom', used for debugging mainly */\nexport const stripPhantom = <T>(value: T): StripPhantom<T> => value as any;\n\n// Avoid bundler bugs\ntype _StripPhantom<T> = StripPhantom<T>;\nconst _stripPhantom = stripPhantom;\n\n/**\n * Phantom meatadata object manipulators.\n *\n * Phantom matadata object holds all metadata used by 'phantom'.\n */\nexport namespace PhantomCore {\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = T extends {\n    __Phantom: infer Phantom extends object;\n  }\n    ? Phantom\n    : never;\n\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = _StripPhantom<T>;\n\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = _stripPhantom;\n}\n","import {\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nimport { PhantomChain } from './chain';\nimport type {\n  BaseCore,\n  InputCore,\n  LabelCore,\n  TagCore,\n  TraitsCore,\n  VariantsCore,\n  BrandCore,\n  IdentityCore,\n  TraitCore,\n  TransformationCore,\n  ErrorType,\n} from './core';\nimport { PhantomCore } from './core';\n\nconst _addTrait = addTrait;\nconst _addTraits = addTraits;\nconst _applyTransformation = applyTransformation;\nconst _asBrand = asBrand;\nconst _asIdentity = asIdentity;\nconst _dropTrait = dropTrait;\nconst _dropTraits = dropTraits;\nconst _revertTransformation = revertTransformation;\nconst _PhantomChain = PhantomChain;\ntype _ErrorType<E> = ErrorType<E>;\n\nexport namespace Phantom {\n  /** --------------------------------------\n   * Types\n   * --------------------------------------- */\n\n  /**\n   * Optional human-readable label metadata.\n   *\n   * Labels are descriptive only and do not affect identity.\n   */\n  export namespace Label {\n    /** Marker type for labeled values */\n    export type Any = LabelCore.Any;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a label exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n  }\n\n  /**\n   * Nominal tag metadata.\n   *\n   * Tags uniquely identify a branded or identified type.\n   * A value may only have a single tag.\n   */\n  export namespace Tag {\n    /** Marker type for any tagged value */\n    export type Any = TagCore.Any;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n  }\n\n  /**\n   * Variant metadata.\n   *\n   * Variants represent mutually exclusive states of a type.\n   */\n  export namespace Variants {\n    /** Marker type for variant-bearing values */\n    export type Any = VariantsCore.Any;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n  }\n\n  /**\n   * Base-type metadata.\n   *\n   * Used to constrain which runtime types a brand, identity,\n   * or transformation may be applied to.\n   */\n  export namespace Base {\n    /** Marker type for base constraints */\n    export type Any = BaseCore.Any;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n  }\n\n  /**\n   * Input metadata.\n   *\n   * Utilities for attaching and querying input metadata in transformations.\n   */\n  export namespace Input {\n    /** Marker type for input value */\n    export type Any = InputCore.Any;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n  }\n\n  /**\n   * Trait metadata.\n   *\n   * Traits behave like a set of capabilities that can be\n   * added or removed independently.\n   */\n  export namespace Traits {\n    /** Marker type for trait-bearing values */\n    export type Any = TraitsCore.Any;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n  }\n\n  /**\n   * Branding API.\n   *\n   * Brands provide nominal typing for otherwise identical values.\n   * A value may only be branded once.\n   *\n   * @deprecated To unify Api surface 'Identity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n   */\n  export namespace Brand {\n    /** Type guard for any brand. */\n    export type Any = BrandCore.Any;\n    /** Declare a brand */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n    > = BrandCore.Declare<T, L>;\n    /** Assign a brand to a value. Fails if the value is already branded */\n    export type Assign<B extends Any, T> = BrandCore.Assign<B, T>;\n    /** Assign a brand if possible, otherwise return the original type */\n    export type AssignSafe<B extends Any, T> = BrandCore.AssignSafe<B, T>;\n    /** Check whether value is branded with */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n  }\n\n  /**\n   * Identity API.\n   *\n   * Identities are brands with additional constraints:\n   * - Base type\n   * - Variants\n   */\n  export namespace Identity {\n    /** Type guard for any identity. */\n    export type Any = IdentityCore.Any;\n    /** Declare an identity */\n    export type Declare<\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = IdentityCore.Declare<T, L, B, V>;\n    /** Assign an identity to a value. Enforces base-type compatibility */\n    export type Assign<I extends Any, T> = IdentityCore.Assign<I, T>;\n    /** Safe identity assignment */\n    export type AssignSafe<I extends Any, T> = IdentityCore.AssignSafe<I, T>;\n    /** Set the active variant on an identity */\n    export type WithVariant<\n      I extends Any,\n      V extends Variants.VariantsOf<I>,\n    > = IdentityCore.WithVariant<I, V>;\n    /** Set the active variant on a value */\n    export type WithTypeVariant<\n      T,\n      V extends Variants.VariantsOf<T>,\n    > = IdentityCore.WithTypeVariant<T, V>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Any> = IdentityCore.isIdentity<T, I>;\n  }\n\n  /**\n   * Trait API.\n   *\n   * Traits are additive capabilities that can be attached\n   * or removed independently.\n   */\n  export namespace Trait {\n    /** Type guard for any trait. */\n    export type Any = TraitCore.Any;\n    /** Declare a trait */\n    export type Declare<Tr extends string | symbol> = TraitCore.Declare<Tr>;\n    /** Add a trait */\n    export type Add<Tr extends Any, T> = TraitCore.Add<Tr, T>;\n    /** Add multiple traits */\n    export type AddMulti<Tr extends readonly Any[], T> = TraitCore.AddMulti<\n      Tr,\n      T\n    >;\n    /** Remove a trait */\n    export type Drop<Tr extends Any, T> = TraitCore.Drop<Tr, T>;\n    /** Remove multiple traits */\n    export type DropMulti<Tr extends readonly Any[], T> = TraitCore.DropMulti<\n      Tr,\n      T\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Any> = TraitCore.HasTrait<T, Tr>;\n  }\n\n  /**\n   * Transformation API.\n   *\n   * Transformations represent reversible operations that\n   * change the shape of a value while preserving its origin.\n   */\n  export namespace Transformation {\n    /** Type guard for any transformation. */\n    export type Any = TransformationCore.Any;\n    /** Declare a transformation */\n    export type Declare<\n      I,\n      T extends string | symbol,\n      L extends string = never,\n      B extends unknown = never,\n      V extends string = never,\n    > = TransformationCore.Declare<I, T, L, B, V>;\n    /** Apply a transformation to a value. Enforces base-type compatibility */\n    export type Apply<Tr extends Any, I, T> = TransformationCore.Apply<\n      Tr,\n      I,\n      T\n    >;\n    /** Revert a transformation */\n    export type Revert<Tr extends Any, T, I> = TransformationCore.Revert<\n      Tr,\n      T,\n      I\n    >;\n    /** Revert a transformation whatever transformation was */\n    export type RevertAny<T, I> = TransformationCore.RevertAny<T, I>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /**\n   * Inspect API.\n   *\n   * Inspection helpers of phantom types.\n   */\n  export namespace Inspect {\n    /** Get phantom metadata object from a type */\n    export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n    /** Stip phantom metadata object from a type */\n    export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n    /** run-time helper for 'StringPhantom', used for debugging mainly */\n    export const stripPhantom = PhantomCore.stripPhantom;\n    /** Extract the label */\n    export type LabelOf<T> = LabelCore.LabelOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasLabel<T, L extends string = string> = LabelCore.HasLabel<\n      T,\n      L\n    >;\n    /** Extract the tag from a type */\n    export type TagOf<T> = TagCore.TagOf<T>;\n    /** Check whether a type is tagged */\n    export type HasTag<\n      T,\n      Ta extends string | symbol = string | symbol,\n    > = TagCore.HasTag<T, Ta>;\n    /** Extract variant union */\n    export type VariantsOf<T> = VariantsCore.VariantsOf<T>;\n    /** Check whether variants exist */\n    export type HasVariants<T> = VariantsCore.HasVariants<T>;\n    /** Extract the base type */\n    export type BaseOf<T> = BaseCore.BaseOf<T>;\n    /** Check whether a base constraint exists */\n    export type HasBase<T, B = unknown> = BaseCore.HasBase<T, B>;\n    /** Extract the input */\n    export type InputOf<T> = InputCore.InputOf<T>;\n    /** Check whether an input exists */\n    export type HasInput<T, I = unknown> = InputCore.HasInput<T, I>;\n    /** Extract the trait map */\n    export type TraitsOf<T> = TraitsCore.TraitsOf<T>;\n    /** Extract trait keys */\n    export type TraitKeysOf<T> = TraitsCore.TraitKeysOf<T>;\n    /** Check if any traits exist */\n    export type HasTraits<\n      T,\n      Tr extends string | symbol = string | symbol,\n    > = TraitsCore.HasTraits<T, Tr>;\n    /**\n     * Check whether value is branded with\n     *\n     * @deprecated To unify Api surface 'isIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n     */\n    export type isBrand<T, B extends Brand.Any> = BrandCore.isBrand<T, B>;\n    /** Check whether value is branded with */\n    export type isIdentity<T, I extends Identity.Any> = IdentityCore.isIdentity<\n      T,\n      I\n    >;\n    /** Check whether value has trait */\n    export type HasTrait<T, Tr extends Trait.Any> = TraitCore.HasTrait<T, Tr>;\n    /** Check whether value is transformed with */\n    export type isTransformed<\n      T,\n      Tr extends Transformation.Any,\n    > = TransformationCore.isTransformed<T, Tr>;\n  }\n\n  /** --------------------------------------\n   * assertors\n   * --------------------------------------- */\n\n  export namespace assertors {\n    /**\n     * Creates a typed caster that assigns a {@link Brand} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the brand's nominal type applied. Use it for simple branded primitives\n     * where you know the value is valid.\n     *\n     * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n     *\n     * @template B - The brand declaration to assign.\n     * @returns A function that casts any value to the branded type.\n     */\n    export const asBrand = _asBrand;\n\n    /**\n     * Creates a typed caster that assigns an {@link Identity} to a value.\n     *\n     * This is a zero-cost runtime assertion helper — it simply returns the value\n     * with the identity's nominal type applied. Use it when you know a value\n     * conforms to an identity but need to assert it for the type system.\n     *\n     * @template I - The identity declaration to assign.\n     * @returns A function that casts any value to the assigned identity type.\n     */\n    export const asIdentity = _asIdentity;\n\n    /**\n     * Creates a typed caster that adds a single {@link Trait} to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to add.\n     * @returns A function that adds the trait to any value.\n     */\n    export const addTrait = _addTrait;\n\n    /**\n     * Creates a typed caster that adds multiple {@link Trait}s to a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to add.\n     * @returns A function that adds all traits to any value.\n     */\n    export const addTraits = _addTraits;\n\n    /**\n     * Creates a typed caster that removes a single {@link Trait} from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The trait declaration to remove.\n     * @returns A function that drops the trait from any value.\n     */\n    export const dropTrait = _dropTrait;\n\n    /**\n     * Creates a typed caster that removes multiple {@link Trait}s from a value.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - Tuple of trait declarations to remove.\n     * @returns A function that drops all specified traits from any value.\n     */\n    export const dropTraits = _dropTraits;\n\n    /**\n     * Creates a typed applicator for a {@link Transformation}.\n     *\n     * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n     * The `input` parameter is only used for type inference — it is not used at runtime.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that applies the transformation while preserving the input type for later revert.\n     */\n    export const applyTransformation = _applyTransformation;\n\n    /**\n     * Creates a typed reverter for a {@link Transformation}.\n     *\n     * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n     * The `transformed` parameter is used for type inference of the expected input,\n     * and `input` is the computed result that must match the stored input type.\n     *\n     * Zero-runtime-cost assertion helper.\n     *\n     * @template Tr - The transformation declaration.\n     * @returns A function that reverts the transformation, stripping phantom metadata.\n     */\n    export const revertTransformation = _revertTransformation;\n  }\n\n  /**\n   * Creates a typed caster that assigns a {@link Brand} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the brand's nominal type applied. Use it for simple branded primitives\n   * where you know the value is valid.\n   *\n   * @deprecated To unify Api surface 'asIdentity' should be used instea, will be removed in v2.0.0. for more info check 'https://www.npmjs.com/package/@vicin/phantom#deprecated-api'\n   *\n   * @template B - The brand declaration to assign.\n   * @returns A function that casts any value to the branded type.\n   */\n  export const asBrand = _asBrand;\n\n  /**\n   * Creates a typed caster that assigns an {@link Identity} to a value.\n   *\n   * This is a zero-cost runtime assertion helper — it simply returns the value\n   * with the identity's nominal type applied. Use it when you know a value\n   * conforms to an identity but need to assert it for the type system.\n   *\n   * @template I - The identity declaration to assign.\n   * @returns A function that casts any value to the assigned identity type.\n   */\n  export const asIdentity = _asIdentity;\n\n  /**\n   * Creates a typed caster that adds a single {@link Trait} to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to add.\n   * @returns A function that adds the trait to any value.\n   */\n  export const addTrait = _addTrait;\n\n  /**\n   * Creates a typed caster that adds multiple {@link Trait}s to a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to add.\n   * @returns A function that adds all traits to any value.\n   */\n  export const addTraits = _addTraits;\n\n  /**\n   * Creates a typed caster that removes a single {@link Trait} from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The trait declaration to remove.\n   * @returns A function that drops the trait from any value.\n   */\n  export const dropTrait = _dropTrait;\n\n  /**\n   * Creates a typed caster that removes multiple {@link Trait}s from a value.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - Tuple of trait declarations to remove.\n   * @returns A function that drops all specified traits from any value.\n   */\n  export const dropTraits = _dropTraits;\n\n  /**\n   * Creates a typed applicator for a {@link Transformation}.\n   *\n   * Use this for \"forward\" operations (e.g., encrypt, encode, wrap).\n   * The `input` parameter is only used for type inference — it is not used at runtime.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that applies the transformation while preserving the input type for later revert.\n   */\n  export const applyTransformation = _applyTransformation;\n\n  /**\n   * Creates a typed reverter for a {@link Transformation}.\n   *\n   * Use this for \"reverse\" operations (e.g., decrypt, decode, unwrap).\n   * The `transformed` parameter is used for type inference of the expected input,\n   * and `input` is the computed result that must match the stored input type.\n   *\n   * Zero-runtime-cost assertion helper.\n   *\n   * @template Tr - The transformation declaration.\n   * @returns A function that reverts the transformation, stripping phantom metadata.\n   */\n  export const revertTransformation = _revertTransformation;\n\n  /** --------------------------------------\n   * Phantom object manipulators\n   * --------------------------------------- */\n\n  /** Get phantom metadata object from a type */\n  export type PhantomOf<T> = PhantomCore.PhantomOf<T>;\n  /** Stip phantom metadata object from a type */\n  export type StripPhantom<T> = PhantomCore.StripPhantom<T>;\n  /** run-time helper for 'StringPhantom', used for debugging mainly */\n  export const stripPhantom = PhantomCore.stripPhantom;\n\n  /** --------------------------------------\n   * Error type\n   * --------------------------------------- */\n\n  /** Unique Error type for rules validation in phantom. */\n  export type ErrorType<E> = _ErrorType<E>;\n\n  /** --------------------------------------\n   * Chain class\n   * --------------------------------------- */\n\n  /**\n   * A fluent PhantomChain class for chaining Phantom assertors.\n   *\n   * This provides a better developer experience (DX) by allowing method chaining\n   * with `.with(assertor)` instead of nesting function calls or using a variadic chain.\n   * Each `.with()` applies the assertor to the current value, updating the type incrementally.\n   * Call `.end()` to retrieve the final value.\n   *\n   * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead\n   * (just object creation and method calls).\n   *\n   * Example:\n   * ```ts\n   * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();\n   * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();\n   * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();\n   *\n   * const result = new PhantomChain(\"value\")\n   *   .with(asMyBrand)\n   *   .with(asMyTrait)\n   *   .with(applyMyTransform)\n   *   .end();\n   * ```\n   */\n  export class PhantomChain<T> extends _PhantomChain<T> {}\n}\n","export {\n  assertors,\n  addTrait,\n  addTraits,\n  applyTransformation,\n  asBrand,\n  asIdentity,\n  dropTrait,\n  dropTraits,\n  revertTransformation,\n} from './assertors';\nexport { PhantomChain } from './chain';\nexport { Phantom } from './phantom';\nexport type {\n  Base,\n  Brand,\n  ErrorType,\n  Identity,\n  Input,\n  Inspect,\n  Label,\n  Tag,\n  Trait,\n  Traits,\n  Transformation,\n  Variants,\n} from './core';\nexport { PhantomCore, stripPhantom } from './core';\nimport { Phantom } from './phantom';\nexport default Phantom;\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vicin/phantom",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "Powerful, lightweight TypeScript library for nominal typing.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,7 +38,20 @@
   "keywords": [
     "typescript",
     "nominal-typing",
-    "ddd"
+    "ddd",
+    "domain-driven-design",
+    "branding",
+    "branded-types",
+    "type-safety",
+    "metadata",
+    "type-metadata",
+    "identity",
+    "traits",
+    "type-transformations",
+    "state-variants",
+    "type-pipe",
+    "zero-runtime",
+    "type-only"
   ],
   "author": "Ziad ziadtaha62@gmail.com",
   "license": "MIT",