@vicin/phantom 1.0.1

package/dist/assertors/assertors.d.ts

@@ -0,0 +1,86 @@
+export declare namespace assertors {
+    /**
+     * Creates a typed caster that assigns a {@link Brand} to a value.
+     *
+     * This is a zero-cost runtime assertion helper — it simply returns the value
+     * with the brand's nominal type applied. Use it for simple branded primitives
+     * where you know the value is valid.
+     *
+     * @template B - The brand declaration to assign.
+     * @returns A function that casts any value to the branded type.
+     */
+    const asBrand: <B extends import("..").Brand.Any>() => <T>(value: T) => import("..").Brand.Assign<B, T>;
+    /**
+     * Creates a typed caster that assigns an {@link Identity} to a value.
+     *
+     * This is a zero-cost runtime assertion helper — it simply returns the value
+     * with the identity's nominal type applied. Use it when you know a value
+     * conforms to an identity but need to assert it for the type system.
+     *
+     * @template I - The identity declaration to assign.
+     * @returns A function that casts any value to the assigned identity type.
+     */
+    const asIdentity: <I extends import("..").Identity.Any>() => <V>(value: V) => import("..").Identity.Assign<I, V>;
+    /**
+     * Creates a typed caster that adds a single {@link Trait} to a value.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - The trait declaration to add.
+     * @returns A function that adds the trait to any value.
+     */
+    const addTrait: <Tr extends import("..").Trait.Any>() => <V>(value: V) => import("..").Trait.Add<Tr, V>;
+    /**
+     * Creates a typed caster that adds multiple {@link Trait}s to a value.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - Tuple of trait declarations to add.
+     * @returns A function that adds all traits to any value.
+     */
+    const addTraits: <Tr extends import("..").Trait.Any[]>() => <V>(value: V) => import("..").Trait.AddMulti<Tr, V>;
+    /**
+     * Creates a typed caster that removes a single {@link Trait} from a value.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - The trait declaration to remove.
+     * @returns A function that drops the trait from any value.
+     */
+    const dropTrait: <Tr extends import("..").Trait.Any>() => <V>(value: V) => import("..").Trait.Drop<Tr, V>;
+    /**
+     * Creates a typed caster that removes multiple {@link Trait}s from a value.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - Tuple of trait declarations to remove.
+     * @returns A function that drops all specified traits from any value.
+     */
+    const dropTraits: <Tr extends import("..").Trait.Any[]>() => <V>(value: V) => import("..").Trait.DropMulti<Tr, V>;
+    /**
+     * Creates a typed applicator for a {@link Transformation}.
+     *
+     * Use this for "forward" operations (e.g., encrypt, encode, wrap).
+     * The `input` parameter is only used for type inference — it is not used at runtime.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - The transformation declaration.
+     * @returns A function that applies the transformation while preserving the input type for later revert.
+     */
+    const applyTransformation: <Tr extends import("..").Transformation.Any>() => <I, T>(input: I, transformed: T) => import("..").Transformation.Apply<Tr, I, T>;
+    /**
+     * Creates a typed reverter for a {@link Transformation}.
+     *
+     * Use this for "reverse" operations (e.g., decrypt, decode, unwrap).
+     * The `transformed` parameter is used for type inference of the expected input,
+     * and `input` is the computed result that must match the stored input type.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - The transformation declaration.
+     * @returns A function that reverts the transformation, stripping phantom metadata.
+     */
+    const revertTransformation: <Tr extends import("..").Transformation.Any>() => <T, I>(transformed: T, input: I) => import("..").Transformation.Revert<Tr, T, I>;
+}
+//# sourceMappingURL=assertors.d.ts.map

package/dist/assertors/assertors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertors.d.ts","sourceRoot":"","sources":["../../src/assertors/assertors.ts"],"names":[],"mappings":"AAaA,yBAAiB,SAAS,CAAC;IACzB;;;;;;;;;OASG;IACI,MAAM,OAAO,2CAPjB,CAAC,EAAE,QAAQ,oCAOiB,CAAC;IAEhC;;;;;;;;;OASG;IACI,MAAM,UAAU,8CAnBiC,CAAC,EAAG,QAAO,uCAmB9B,CAAC;IAEtC;;;;;;;OAOG;IACI,MAAM,QAAQ,4CApCa,CAAC,EAAE,QAAQ,kCAoCb,CAAC;IAEjC;;;;;;;OAOG;IACI,MAAM,SAAS,8CApCrB,CAAA,EACA,QAAI,uCAmC6B,CAAC;IAEnC;;;;;;;OAOG;IACI,MAAM,SAAS,4CApCO,CAAC,EAAE,QAAQ,mCAoCL,CAAC;IAEpC;;;;;;;OAOG;IACI,MAAM,UAAU,8CArC4C,CAAC,EACnE,QACH,wCAmCuC,CAAC;IAEtC;;;;;;;;;;OAUG;IACI,MAAM,mBAAmB,qDAxEqC,CAAC,EAAE,CAAC,EAAE,QACzE,EAAC,cAAe,gDAuEqC,CAAC;IAExD;;;;;;;;;;;OAWG;IACI,MAAM,oBAAoB,qDAtEN,CAAC,EAAE,CAAC,EAAE,cAAc,EAAC,QAC/C,iDAqEwD,CAAC;CAC3D"}

package/dist/assertors/assertors.js

@@ -0,0 +1,91 @@
+import { asBrand as _asBrand } from './brand';
+import { asIdentity as _asIdentity } from './identity';
+import { addTrait as _asTrait, addTraits as _asTraits, dropTrait as _dropTrait, dropTraits as _dropTraits, } from './trait';
+import { applyTransformation as _applyTransformation, revertTransformation as _revertTransformation, } from './transformation';
+export var assertors;
+(function (assertors) {
+    /**
+     * Creates a typed caster that assigns a {@link Brand} to a value.
+     *
+     * This is a zero-cost runtime assertion helper — it simply returns the value
+     * with the brand's nominal type applied. Use it for simple branded primitives
+     * where you know the value is valid.
+     *
+     * @template B - The brand declaration to assign.
+     * @returns A function that casts any value to the branded type.
+     */
+    assertors.asBrand = _asBrand;
+    /**
+     * Creates a typed caster that assigns an {@link Identity} to a value.
+     *
+     * This is a zero-cost runtime assertion helper — it simply returns the value
+     * with the identity's nominal type applied. Use it when you know a value
+     * conforms to an identity but need to assert it for the type system.
+     *
+     * @template I - The identity declaration to assign.
+     * @returns A function that casts any value to the assigned identity type.
+     */
+    assertors.asIdentity = _asIdentity;
+    /**
+     * Creates a typed caster that adds a single {@link Trait} to a value.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - The trait declaration to add.
+     * @returns A function that adds the trait to any value.
+     */
+    assertors.addTrait = _asTrait;
+    /**
+     * Creates a typed caster that adds multiple {@link Trait}s to a value.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - Tuple of trait declarations to add.
+     * @returns A function that adds all traits to any value.
+     */
+    assertors.addTraits = _asTraits;
+    /**
+     * Creates a typed caster that removes a single {@link Trait} from a value.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - The trait declaration to remove.
+     * @returns A function that drops the trait from any value.
+     */
+    assertors.dropTrait = _dropTrait;
+    /**
+     * Creates a typed caster that removes multiple {@link Trait}s from a value.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - Tuple of trait declarations to remove.
+     * @returns A function that drops all specified traits from any value.
+     */
+    assertors.dropTraits = _dropTraits;
+    /**
+     * Creates a typed applicator for a {@link Transformation}.
+     *
+     * Use this for "forward" operations (e.g., encrypt, encode, wrap).
+     * The `input` parameter is only used for type inference — it is not used at runtime.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - The transformation declaration.
+     * @returns A function that applies the transformation while preserving the input type for later revert.
+     */
+    assertors.applyTransformation = _applyTransformation;
+    /**
+     * Creates a typed reverter for a {@link Transformation}.
+     *
+     * Use this for "reverse" operations (e.g., decrypt, decode, unwrap).
+     * The `transformed` parameter is used for type inference of the expected input,
+     * and `input` is the computed result that must match the stored input type.
+     *
+     * Zero-runtime-cost assertion helper.
+     *
+     * @template Tr - The transformation declaration.
+     * @returns A function that reverts the transformation, stripping phantom metadata.
+     */
+    assertors.revertTransformation = _revertTransformation;
+})(assertors || (assertors = {}));
+//# sourceMappingURL=assertors.js.map

package/dist/assertors/assertors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertors.js","sourceRoot":"","sources":["../../src/assertors/assertors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EACL,QAAQ,IAAI,QAAQ,EACpB,SAAS,IAAI,SAAS,EACtB,SAAS,IAAI,UAAU,EACvB,UAAU,IAAI,WAAW,GAC1B,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,mBAAmB,IAAI,oBAAoB,EAC3C,oBAAoB,IAAI,qBAAqB,GAC9C,MAAM,kBAAkB,CAAC;AAE1B,MAAM,KAAW,SAAS,CA2FzB;AA3FD,WAAiB,SAAS;IACxB;;;;;;;;;OASG;IACU,iBAAO,GAAG,QAAQ,CAAC;IAEhC;;;;;;;;;OASG;IACU,oBAAU,GAAG,WAAW,CAAC;IAEtC;;;;;;;OAOG;IACU,kBAAQ,GAAG,QAAQ,CAAC;IAEjC;;;;;;;OAOG;IACU,mBAAS,GAAG,SAAS,CAAC;IAEnC;;;;;;;OAOG;IACU,mBAAS,GAAG,UAAU,CAAC;IAEpC;;;;;;;OAOG;IACU,oBAAU,GAAG,WAAW,CAAC;IAEtC;;;;;;;;;;OAUG;IACU,6BAAmB,GAAG,oBAAoB,CAAC;IAExD;;;;;;;;;;;OAWG;IACU,8BAAoB,GAAG,qBAAqB,CAAC;AAC5D,CAAC,EA3FgB,SAAS,KAAT,SAAS,QA2FzB"}

package/dist/assertors/brand.d.ts

@@ -0,0 +1,13 @@
+import type { Brand } from '../types';
+/**
+ * Creates a typed caster that assigns a {@link Brand} to a value.
+ *
+ * This is a zero-cost runtime assertion helper — it simply returns the value
+ * with the brand's nominal type applied. Use it for simple branded primitives
+ * where you know the value is valid.
+ *
+ * @template B - The brand declaration to assign.
+ * @returns A function that casts any value to the branded type.
+ */
+export declare const asBrand: <B extends Brand.Any>() => <T>(value: T) => Brand.Assign<B, T>;
+//# sourceMappingURL=brand.d.ts.map

package/dist/assertors/brand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand.d.ts","sourceRoot":"","sources":["../../src/assertors/brand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,GACjB,CAAC,SAAS,KAAK,CAAC,GAAG,QACnB,CAAC,EAAE,OAAO,CAAC,KACD,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/assertors/brand.js

@@ -0,0 +1,12 @@
+/**
+ * Creates a typed caster that assigns a {@link Brand} to a value.
+ *
+ * This is a zero-cost runtime assertion helper — it simply returns the value
+ * with the brand's nominal type applied. Use it for simple branded primitives
+ * where you know the value is valid.
+ *
+ * @template B - The brand declaration to assign.
+ * @returns A function that casts any value to the branded type.
+ */
+export const asBrand = () => (value) => value;
+//# sourceMappingURL=brand.js.map

package/dist/assertors/brand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand.js","sourceRoot":"","sources":["../../src/assertors/brand.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,OAAO,GAClB,GAAwB,EAAE,CAC1B,CAAI,KAAQ,EAAE,EAAE,CACd,KAA2B,CAAC"}

package/dist/assertors/identity.d.ts

@@ -0,0 +1,13 @@
+import type { Identity } from '../types';
+/**
+ * Creates a typed caster that assigns an {@link Identity} to a value.
+ *
+ * This is a zero-cost runtime assertion helper — it simply returns the value
+ * with the identity's nominal type applied. Use it when you know a value
+ * conforms to an identity but need to assert it for the type system.
+ *
+ * @template I - The identity declaration to assign.
+ * @returns A function that casts any value to the assigned identity type.
+ */
+export declare const asIdentity: <I extends Identity.Any>() => <V>(value: V) => Identity.Assign<I, V>;
+//# sourceMappingURL=identity.d.ts.map

package/dist/assertors/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../src/assertors/identity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,GACpB,CAAC,SAAS,QAAQ,CAAC,GAAG,QACtB,CAAC,EAAE,OAAO,CAAC,KAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CACrB,CAAC"}

package/dist/assertors/identity.js

@@ -0,0 +1,12 @@
+/**
+ * Creates a typed caster that assigns an {@link Identity} to a value.
+ *
+ * This is a zero-cost runtime assertion helper — it simply returns the value
+ * with the identity's nominal type applied. Use it when you know a value
+ * conforms to an identity but need to assert it for the type system.
+ *
+ * @template I - The identity declaration to assign.
+ * @returns A function that casts any value to the assigned identity type.
+ */
+export const asIdentity = () => (value) => value;
+//# sourceMappingURL=identity.js.map

package/dist/assertors/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/assertors/identity.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,UAAU,GACrB,GAA2B,EAAE,CAC7B,CAAI,KAAQ,EAAyB,EAAE,CACrC,KAAY,CAAC"}

package/dist/assertors/index.d.ts

@@ -0,0 +1,2 @@
+export { assertors } from './assertors';
+//# sourceMappingURL=index.d.ts.map

package/dist/assertors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/assertors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/dist/assertors/index.js

@@ -0,0 +1,2 @@
+export { assertors } from './assertors';
+//# sourceMappingURL=index.js.map

package/dist/assertors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/assertors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/dist/assertors/trait.d.ts

@@ -0,0 +1,38 @@
+import type { Trait } from '../types';
+/**
+ * Creates a typed caster that adds a single {@link Trait} to a value.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - The trait declaration to add.
+ * @returns A function that adds the trait to any value.
+ */
+export declare const addTrait: <Tr extends Trait.Any>() => <V>(value: V) => Trait.Add<Tr, V>;
+/**
+ * Creates a typed caster that adds multiple {@link Trait}s to a value.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - Tuple of trait declarations to add.
+ * @returns A function that adds all traits to any value.
+ */
+export declare const addTraits: <Tr extends Trait.Any[]>() => <V>(value: V) => Trait.AddMulti<Tr, V>;
+/**
+ * Creates a typed caster that removes a single {@link Trait} from a value.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - The trait declaration to remove.
+ * @returns A function that drops the trait from any value.
+ */
+export declare const dropTrait: <Tr extends Trait.Any>() => <V>(value: V) => Trait.Drop<Tr, V>;
+/**
+ * Creates a typed caster that removes multiple {@link Trait}s from a value.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - Tuple of trait declarations to remove.
+ * @returns A function that drops all specified traits from any value.
+ */
+export declare const dropTraits: <Tr extends Trait.Any[]>() => <V>(value: V) => Trait.DropMulti<Tr, V>;
+//# sourceMappingURL=trait.d.ts.map

package/dist/assertors/trait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trait.d.ts","sourceRoot":"","sources":["../../src/assertors/trait.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAClB,EAAE,SAAS,KAAK,CAAC,GAAG,QACpB,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAChB,CAAC;AAEjB;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GACnB,EAAE,SAAS,KAAK,CAAC,GAAG,EAAE,QACtB,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC,CACrB,CAAC;AAEjB;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GACnB,EAAE,SAAS,KAAK,CAAC,GAAG,QACpB,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CACjB,CAAC;AAEjB;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GACpB,EAAE,SAAS,KAAK,CAAC,GAAG,EAAE,QACtB,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,CACtB,CAAC"}

package/dist/assertors/trait.js

@@ -0,0 +1,37 @@
+/**
+ * Creates a typed caster that adds a single {@link Trait} to a value.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - The trait declaration to add.
+ * @returns A function that adds the trait to any value.
+ */
+export const addTrait = () => (value) => value;
+/**
+ * Creates a typed caster that adds multiple {@link Trait}s to a value.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - Tuple of trait declarations to add.
+ * @returns A function that adds all traits to any value.
+ */
+export const addTraits = () => (value) => value;
+/**
+ * Creates a typed caster that removes a single {@link Trait} from a value.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - The trait declaration to remove.
+ * @returns A function that drops the trait from any value.
+ */
+export const dropTrait = () => (value) => value;
+/**
+ * Creates a typed caster that removes multiple {@link Trait}s from a value.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - Tuple of trait declarations to remove.
+ * @returns A function that drops all specified traits from any value.
+ */
+export const dropTraits = () => (value) => value;
+//# sourceMappingURL=trait.js.map

package/dist/assertors/trait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trait.js","sourceRoot":"","sources":["../../src/assertors/trait.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GACnB,GAAyB,EAAE,CAC3B,CAAI,KAAQ,EAAoB,EAAE,CAChC,KAAY,CAAC;AAEjB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,SAAS,GACpB,GAA2B,EAAE,CAC7B,CAAI,KAAQ,EAAyB,EAAE,CACrC,KAAY,CAAC;AAEjB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,SAAS,GACpB,GAAyB,EAAE,CAC3B,CAAI,KAAQ,EAAqB,EAAE,CACjC,KAAY,CAAC;AAEjB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GACrB,GAA2B,EAAE,CAC7B,CAAI,KAAQ,EAA0B,EAAE,CACtC,KAAY,CAAC"}

package/dist/assertors/transformation.d.ts

@@ -0,0 +1,27 @@
+import type { Transformation } from '../types';
+/**
+ * Creates a typed applicator for a {@link Transformation}.
+ *
+ * Use this for "forward" operations (e.g., encrypt, encode, wrap).
+ * The `input` parameter is only used for type inference — it is not used at runtime.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - The transformation declaration.
+ * @returns A function that applies the transformation while preserving the input type for later revert.
+ */
+export declare const applyTransformation: <Tr extends Transformation.Any>() => <I, T>(input: I, transformed: T) => Transformation.Apply<Tr, I, T>;
+/**
+ * Creates a typed reverter for a {@link Transformation}.
+ *
+ * Use this for "reverse" operations (e.g., decrypt, decode, unwrap).
+ * The `transformed` parameter is used for type inference of the expected input,
+ * and `input` is the computed result that must match the stored input type.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - The transformation declaration.
+ * @returns A function that reverts the transformation, stripping phantom metadata.
+ */
+export declare const revertTransformation: <Tr extends Transformation.Any>() => <T, I>(transformed: T, input: I) => Transformation.Revert<Tr, T, I>;
+//# sourceMappingURL=transformation.d.ts.map

package/dist/assertors/transformation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformation.d.ts","sourceRoot":"","sources":["../../src/assertors/transformation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAC7B,EAAE,SAAS,cAAc,CAAC,GAAG,QAC7B,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,CAAC,KACd,cAAc,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,GAC9B,EAAE,SAAS,cAAc,CAAC,GAAG,QAC7B,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,EAAE,OAAO,CAAC,KACpB,cAAc,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/assertors/transformation.js

@@ -0,0 +1,26 @@
+/**
+ * Creates a typed applicator for a {@link Transformation}.
+ *
+ * Use this for "forward" operations (e.g., encrypt, encode, wrap).
+ * The `input` parameter is only used for type inference — it is not used at runtime.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - The transformation declaration.
+ * @returns A function that applies the transformation while preserving the input type for later revert.
+ */
+export const applyTransformation = () => (input, transformed) => transformed;
+/**
+ * Creates a typed reverter for a {@link Transformation}.
+ *
+ * Use this for "reverse" operations (e.g., decrypt, decode, unwrap).
+ * The `transformed` parameter is used for type inference of the expected input,
+ * and `input` is the computed result that must match the stored input type.
+ *
+ * Zero-runtime-cost assertion helper.
+ *
+ * @template Tr - The transformation declaration.
+ * @returns A function that reverts the transformation, stripping phantom metadata.
+ */
+export const revertTransformation = () => (transformed, input) => input;
+//# sourceMappingURL=transformation.js.map

package/dist/assertors/transformation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformation.js","sourceRoot":"","sources":["../../src/assertors/transformation.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAC9B,GAAkC,EAAE,CACpC,CAAO,KAAQ,EAAE,WAAc,EAAE,EAAE,CACjC,WAA6C,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAC/B,GAAkC,EAAE,CACpC,CAAO,WAAc,EAAE,KAAQ,EAAE,EAAE,CACjC,KAAwC,CAAC"}

package/dist/chain/chain.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A fluent PhantomChain class for chaining Phantom assertors.
+ *
+ * This provides a better developer experience (DX) by allowing method chaining
+ * with `.with(assertor)` instead of nesting function calls or using a variadic chain.
+ * Each `.with()` applies the assertor to the current value, updating the type incrementally.
+ * Call `.end()` to retrieve the final value.
+ *
+ * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead
+ * (just object creation and method calls).
+ *
+ * Example:
+ * ```ts
+ * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();
+ * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();
+ * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();
+ *
+ * const result = new PhantomChain("value")
+ *   .with(asMyBrand)
+ *   .with(asMyTrait)
+ *   .with(applyMyTransform)
+ *   .end();
+ * ```
+ */
+export declare class PhantomChain<T> {
+    private value;
+    constructor(value: T);
+    /**
+     * Apply the next assertor in the chain.
+     *
+     * @param assertor A function that takes the current value and returns the updated value (with new type).
+     * @returns A new PhantomChain instance with the updated value and type.
+     */
+    with<U>(assertor: (value: T) => U): PhantomChain<U>;
+    /**
+     * End the chain and return the final value.
+     *
+     * @returns The value after all transformations.
+     */
+    end(): T;
+}
+//# sourceMappingURL=chain.d.ts.map

package/dist/chain/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../src/chain/chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,YAAY,CAAC,CAAC;IACzB,OAAO,CAAC,KAAK,CAAI;gBAEL,KAAK,EAAE,CAAC;IAIpB;;;;;OAKG;IACH,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;IAInD;;;;OAIG;IACH,GAAG,IAAI,CAAC;CAGT"}

package/dist/chain/chain.js

@@ -0,0 +1,48 @@
+/**
+ * A fluent PhantomChain class for chaining Phantom assertors.
+ *
+ * This provides a better developer experience (DX) by allowing method chaining
+ * with `.with(assertor)` instead of nesting function calls or using a variadic chain.
+ * Each `.with()` applies the assertor to the current value, updating the type incrementally.
+ * Call `.end()` to retrieve the final value.
+ *
+ * At runtime, assertors are zero-cost casts, so the PhantomChain adds minimal overhead
+ * (just object creation and method calls).
+ *
+ * Example:
+ * ```ts
+ * const asMyBrand = Phantom.assertors.asBrand<MyBrand>();
+ * const asMyTrait = Phantom.assertors.asTrait<MyTrait>();
+ * const applyMyTransform = Phantom.assertors.applyTransformation<MyTransform>();
+ *
+ * const result = new PhantomChain("value")
+ *   .with(asMyBrand)
+ *   .with(asMyTrait)
+ *   .with(applyMyTransform)
+ *   .end();
+ * ```
+ */
+export class PhantomChain {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Apply the next assertor in the chain.
+     *
+     * @param assertor A function that takes the current value and returns the updated value (with new type).
+     * @returns A new PhantomChain instance with the updated value and type.
+     */
+    with(assertor) {
+        return new PhantomChain(assertor(this.value));
+    }
+    /**
+     * End the chain and return the final value.
+     *
+     * @returns The value after all transformations.
+     */
+    end() {
+        return this.value;
+    }
+}
+//# sourceMappingURL=chain.js.map

package/dist/chain/chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.js","sourceRoot":"","sources":["../../src/chain/chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,OAAO,YAAY;IACf,KAAK,CAAI;IAEjB,YAAY,KAAQ;QAClB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;;;;OAKG;IACH,IAAI,CAAI,QAAyB;QAC/B,OAAO,IAAI,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAChD,CAAC;IAED;;;;OAIG;IACH,GAAG;QACD,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;CACF"}

package/dist/chain/index.d.ts

@@ -0,0 +1,2 @@
+export { PhantomChain } from './chain';
+//# sourceMappingURL=index.d.ts.map

package/dist/chain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/chain/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}

package/dist/chain/index.js

@@ -0,0 +1,2 @@
+export { PhantomChain } from './chain';
+//# sourceMappingURL=index.js.map

package/dist/chain/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/chain/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { assertors } from './assertors';
+export { PhantomChain } from './chain';
+export { Phantom } from './phantom';
+export type { Base, Brand, ErrorType, Identity, Input, Inspect, Label, Phantom as PhantomCore, Tag, Trait, Traits, Transformation, Variants, } from './types';
+import { Phantom } from './phantom';
+export default Phantom;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,YAAY,EACV,IAAI,EACJ,KAAK,EACL,SAAS,EACT,QAAQ,EACR,KAAK,EACL,OAAO,EACP,KAAK,EACL,OAAO,IAAI,WAAW,EACtB,GAAG,EACH,KAAK,EACL,MAAM,EACN,cAAc,EACd,QAAQ,GACT,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,eAAe,OAAO,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { assertors } from './assertors';
+export { PhantomChain } from './chain';
+export { Phantom } from './phantom';
+import { Phantom } from './phantom';
+export default Phantom;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,eAAe,OAAO,CAAC"}