@digitaldefiance/branded-enum 0.0.1 → 0.0.2

package/dist/lib/registry.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Global registry for branded enums.
+ *
+ * Uses globalThis to ensure cross-bundle compatibility - all instances
+ * of the library share the same registry regardless of how they're bundled.
+ */
+import { BrandedEnum, BrandedEnumRegistry } from './types.js';
+/**
+ * Gets the global registry, initializing it lazily if needed.
+ * Uses globalThis for cross-bundle compatibility.
+ *
+ * The registry is shared across all instances of the library, even when
+ * bundled separately or loaded as different module formats (ESM/CJS).
+ *
+ * @returns The global branded enum registry containing all registered enums
+ *   and a value index for reverse lookups.
+ *
+ * @example
+ * const registry = getRegistry();
+ * console.log(registry.enums.size); // Number of registered enums
+ */
+export declare function getRegistry(): BrandedEnumRegistry;
+/**
+ * Registers a branded enum in the global registry.
+ * Also updates the value index for reverse lookups.
+ *
+ * @param enumObj - The branded enum to register
+ * @throws Error if an enum with the same ID is already registered
+ */
+export declare function registerEnum<T extends Record<string, string>>(enumObj: BrandedEnum<T>): void;
+/**
+ * Gets all registered enum IDs.
+ *
+ * Returns an array of all enum IDs that have been registered via
+ * `createBrandedEnum`. Useful for debugging or introspection.
+ *
+ * @returns Array of all registered enum IDs. Returns empty array if no
+ *   enums have been registered.
+ *
+ * @example
+ * createBrandedEnum('colors', { Red: 'red' } as const);
+ * createBrandedEnum('sizes', { Small: 'small' } as const);
+ *
+ * getAllEnumIds(); // ['colors', 'sizes']
+ */
+export declare function getAllEnumIds(): string[];
+/**
+ * Gets a branded enum by its ID.
+ *
+ * Retrieves a previously registered branded enum from the global registry.
+ * Useful when you need to access an enum dynamically by its ID.
+ *
+ * @param enumId - The enum ID to look up
+ * @returns The branded enum object if found, or `undefined` if no enum
+ *   with the given ID has been registered.
+ *
+ * @example
+ * const Status = createBrandedEnum('status', { Active: 'active' } as const);
+ *
+ * const retrieved = getEnumById('status');
+ * console.log(retrieved === Status); // true
+ *
+ * const notFound = getEnumById('nonexistent');
+ * console.log(notFound); // undefined
+ */
+export declare function getEnumById(enumId: string): BrandedEnum<Record<string, string>> | undefined;
+/**
+ * Finds all enum IDs that contain a given value.
+ *
+ * Performs a reverse lookup to find which enums contain a specific value.
+ * Useful for debugging value collisions or routing values to handlers.
+ *
+ * @param value - The string value to search for
+ * @returns Array of enum IDs that contain the value. Returns empty array
+ *   if no enums contain the value.
+ *
+ * @example
+ * // Single enum containing value
+ * createBrandedEnum('colors', { Red: 'red', Blue: 'blue' } as const);
+ * findEnumSources('red'); // ['colors']
+ *
+ * @example
+ * // Multiple enums with same value (collision detection)
+ * createBrandedEnum('status1', { Active: 'active' } as const);
+ * createBrandedEnum('status2', { Enabled: 'active' } as const);
+ * findEnumSources('active'); // ['status1', 'status2']
+ *
+ * @example
+ * // Value not found
+ * findEnumSources('nonexistent'); // []
+ */
+export declare function findEnumSources(value: string): string[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/lib/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/lib/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,WAAW,EACX,mBAAmB,EAKpB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,IAAI,mBAAmB,CAajD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3D,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,GACtB,IAAI,CA6BN;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,IAAI,MAAM,EAAE,CAGxC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,GACb,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAIjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAIvD"}

package/dist/lib/types.d.ts

@@ -0,0 +1,258 @@
+/**
+ * Core type definitions for branded-enum library
+ *
+ * These types enable runtime-identifiable enum-like objects in TypeScript
+ * with zero runtime overhead for value access.
+ */
+/**
+ * Symbol key for storing the enum ID metadata.
+ * Using a Symbol prevents collision with user-defined keys.
+ */
+export declare const ENUM_ID: unique symbol;
+/**
+ * Symbol key for storing the enum values Set.
+ * Using a Symbol prevents collision with user-defined keys.
+ */
+export declare const ENUM_VALUES: unique symbol;
+/**
+ * Metadata attached to branded enums via Symbol properties.
+ * These properties are non-enumerable and won't appear in
+ * Object.keys(), Object.values(), or JSON serialization.
+ */
+export interface BrandedEnumMetadata {
+    readonly [ENUM_ID]: string;
+    readonly [ENUM_VALUES]: Set<string>;
+}
+/**
+ * A branded enum object - combines the user's values object with metadata.
+ * The object is frozen (Readonly) to prevent modification after creation.
+ *
+ * @template T - The shape of the enum values object (Record<string, string>)
+ */
+export type BrandedEnum<T extends Record<string, string>> = Readonly<T> & BrandedEnumMetadata;
+/**
+ * Base constraint type for branded enums that works with both
+ * `as const` objects and regular Record<string, string> objects.
+ *
+ * This type is more permissive than `BrandedEnum<Record<string, string>>`
+ * and allows literal types from `as const` assertions.
+ */
+export type AnyBrandedEnum = {
+    readonly [ENUM_ID]: string;
+    readonly [ENUM_VALUES]: Set<string>;
+};
+/**
+ * Utility type to extract the union of all value types from a branded enum.
+ * Useful for typing variables that can hold any value from the enum.
+ *
+ * @template E - A BrandedEnum type
+ *
+ * @example
+ * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);
+ * type StatusValue = BrandedEnumValue<typeof Status>; // 'active' | 'inactive'
+ */
+export type BrandedEnumValue<E extends AnyBrandedEnum> = E extends BrandedEnum<infer T> ? T[keyof T] : never;
+/**
+ * Registry entry for tracking a single branded enum in the global registry.
+ */
+export interface RegistryEntry {
+    /** The unique identifier for this enum */
+    readonly enumId: string;
+    /** The branded enum object itself */
+    readonly enumObj: BrandedEnum<Record<string, string>>;
+    /** Set of all values in this enum for O(1) lookup */
+    readonly values: Set<string>;
+}
+/**
+ * Global registry structure stored on globalThis.
+ * Enables cross-bundle tracking of all branded enums.
+ */
+export interface BrandedEnumRegistry {
+    /** Map from enumId to registry entry */
+    readonly enums: Map<string, RegistryEntry>;
+    /** Reverse index: value -> Set of enumIds containing that value */
+    readonly valueIndex: Map<string, Set<string>>;
+}
+/**
+ * The key used to store the registry on globalThis.
+ * Namespaced to avoid collisions with other libraries.
+ */
+export declare const REGISTRY_KEY: "__brandedEnumRegistry__";
+/**
+ * The key used to store the enum consumer registry on globalThis.
+ * Tracks which classes consume which branded enums.
+ */
+export declare const CONSUMER_REGISTRY_KEY: "__brandedEnumConsumerRegistry__";
+/**
+ * Entry tracking a class that consumes branded enums.
+ */
+export interface EnumConsumerEntry {
+    /** The class constructor function */
+    readonly classRef: new (...args: any[]) => any;
+    /** The class name */
+    readonly className: string;
+    /** Set of enum IDs that this class consumes */
+    readonly enumIds: Set<string>;
+}
+/**
+ * Global registry for tracking enum consumers (classes decorated with @EnumClass).
+ * Enables debugging and introspection of enum usage across the codebase.
+ */
+export interface EnumConsumerRegistry {
+    /** Map from class name to consumer entry */
+    readonly consumers: Map<string, EnumConsumerEntry>;
+    /** Reverse index: enumId -> Set of class names consuming that enum */
+    readonly enumToConsumers: Map<string, Set<string>>;
+}
+/**
+ * Extracts the union of all keys from a branded enum.
+ *
+ * This utility type provides compile-time access to all key names of a branded enum,
+ * excluding the Symbol metadata keys (ENUM_ID and ENUM_VALUES).
+ *
+ * @template E - A BrandedEnum type
+ *
+ * @example
+ * const Status = createBrandedEnum('status', {
+ *   Active: 'active',
+ *   Inactive: 'inactive',
+ *   Pending: 'pending',
+ * } as const);
+ *
+ * type StatusKeys = EnumKeys<typeof Status>;
+ * // StatusKeys = 'Active' | 'Inactive' | 'Pending'
+ *
+ * @example
+ * // Use in function parameters
+ * function getStatusLabel<E extends AnyBrandedEnum>(
+ *   enumObj: E,
+ *   key: EnumKeys<E>
+ * ): string {
+ *   return enumObj[key] as string;
+ * }
+ */
+export type EnumKeys<E> = E extends BrandedEnum<infer T> ? keyof T & string : E extends AnyBrandedEnum ? Exclude<keyof E, typeof ENUM_ID | typeof ENUM_VALUES> & string : never;
+/**
+ * Extracts the union of all values from a branded enum.
+ *
+ * This is an alias for BrandedEnumValue that provides a more intuitive name
+ * when working with compile-time type utilities.
+ *
+ * @template E - A BrandedEnum type
+ *
+ * @example
+ * const Status = createBrandedEnum('status', {
+ *   Active: 'active',
+ *   Inactive: 'inactive',
+ *   Pending: 'pending',
+ * } as const);
+ *
+ * type StatusValues = EnumValues<typeof Status>;
+ * // StatusValues = 'active' | 'inactive' | 'pending'
+ *
+ * @example
+ * // Use for type-safe value handling
+ * function processStatus(value: EnumValues<typeof Status>) {
+ *   // value is 'active' | 'inactive' | 'pending'
+ * }
+ */
+export type EnumValues<E> = E extends BrandedEnum<infer T> ? T[keyof T] : E extends AnyBrandedEnum ? Exclude<E[Exclude<keyof E, typeof ENUM_ID | typeof ENUM_VALUES>], Set<string>> & string : never;
+/**
+ * Validates that a value type V is a valid value of branded enum E at compile time.
+ *
+ * If V is a valid value of E, this type resolves to V.
+ * If V is NOT a valid value of E, this type resolves to `never`, causing a compile error
+ * when used in contexts that expect a non-never type.
+ *
+ * This enables compile-time validation of enum values without runtime overhead.
+ *
+ * @template E - A BrandedEnum type
+ * @template V - The value type to validate
+ *
+ * @example
+ * const Status = createBrandedEnum('status', {
+ *   Active: 'active',
+ *   Inactive: 'inactive',
+ * } as const);
+ *
+ * // Valid - 'active' is in Status
+ * type Valid = ValidEnumValue<typeof Status, 'active'>; // 'active'
+ *
+ * // Invalid - 'unknown' is not in Status
+ * type Invalid = ValidEnumValue<typeof Status, 'unknown'>; // never
+ *
+ * @example
+ * // Use in function to enforce valid values at compile time
+ * function setStatus<V extends string>(
+ *   value: ValidEnumValue<typeof Status, V>
+ * ): void {
+ *   // Only compiles if value is 'active' | 'inactive'
+ * }
+ *
+ * setStatus('active'); // OK
+ * setStatus('inactive'); // OK
+ * // setStatus('unknown'); // Compile error: Argument of type 'never' is not assignable
+ *
+ * @example
+ * // Type-level assertion
+ * type AssertActive = ValidEnumValue<typeof Status, 'active'>; // 'active' - OK
+ * type AssertBad = ValidEnumValue<typeof Status, 'bad'>; // never - indicates invalid
+ */
+export type ValidEnumValue<E, V extends string> = V extends EnumValues<E> ? V : never;
+/**
+ * Creates a strict parameter type that only accepts valid values from a branded enum.
+ *
+ * This utility type is designed for function parameters where you want to enforce
+ * that only values from a specific branded enum are accepted at compile time.
+ *
+ * Unlike using `BrandedEnumValue<E>` directly, `StrictEnumParam` provides better
+ * error messages and works well with generic functions.
+ *
+ * @template E - A BrandedEnum type
+ *
+ * @example
+ * const Status = createBrandedEnum('status', {
+ *   Active: 'active',
+ *   Inactive: 'inactive',
+ *   Pending: 'pending',
+ * } as const);
+ *
+ * // Function that only accepts Status values
+ * function updateStatus(newStatus: StrictEnumParam<typeof Status>): void {
+ *   console.log(`Status updated to: ${newStatus}`);
+ * }
+ *
+ * updateStatus(Status.Active); // OK
+ * updateStatus('active'); // OK (literal type matches)
+ * // updateStatus('unknown'); // Compile error
+ *
+ * @example
+ * // Use with multiple enum parameters
+ * const Priority = createBrandedEnum('priority', {
+ *   High: 'high',
+ *   Medium: 'medium',
+ *   Low: 'low',
+ * } as const);
+ *
+ * function createTask(
+ *   status: StrictEnumParam<typeof Status>,
+ *   priority: StrictEnumParam<typeof Priority>
+ * ): void {
+ *   // Both parameters are type-safe
+ * }
+ *
+ * createTask(Status.Active, Priority.High); // OK
+ * createTask('active', 'high'); // OK
+ * // createTask('active', 'invalid'); // Compile error on second param
+ *
+ * @example
+ * // Generic function with strict enum constraint
+ * function processValue<E extends AnyBrandedEnum>(
+ *   enumObj: E,
+ *   value: StrictEnumParam<E>
+ * ): void {
+ *   // value is guaranteed to be a valid value of enumObj
+ * }
+ */
+export type StrictEnumParam<E> = EnumValues<E>;
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

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

package/dist/lib/utils.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Utility functions for branded enums.
+ *
+ * Provides additional functionality beyond standard enum operations,
+ * including reverse lookup, key validation, and iteration.
+ */
+import { AnyBrandedEnum, EnumKeys, EnumValues } from './types.js';
+/**
+ * Checks if a value exists in a branded enum (reverse lookup).
+ *
+ * Similar to `isFromEnum`, but with arguments in a different order that
+ * may be more natural for some use cases. Also provides type narrowing.
+ *
+ * @template E - The branded enum type
+ * @param enumObj - The branded enum to search in
+ * @param value - The value to check. Can be any type; non-strings return false.
+ * @returns `true` if the value exists in the enum (with type narrowing),
+ *   `false` otherwise. Returns `false` for non-string values or if
+ *   enumObj is not a branded enum.
+ *
+ * @example
+ * // Check if value exists
+ * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);
+ * hasValue(Status, 'active'); // true
+ * hasValue(Status, 'unknown'); // false
+ *
+ * @example
+ * // Returns false for non-string values
+ * hasValue(Status, 123); // false
+ * hasValue(Status, null); // false
+ */
+export declare function hasValue<E extends AnyBrandedEnum>(enumObj: E, value: unknown): value is EnumValues<E>;
+/**
+ * Gets the key name for a value in a branded enum.
+ *
+ * Performs a reverse lookup to find which key maps to a given value.
+ * If multiple keys have the same value, returns the first one found
+ * (order is not guaranteed).
+ *
+ * @template E - The branded enum type
+ * @param enumObj - The branded enum to search in
+ * @param value - The string value to look up
+ * @returns The key name that maps to the value, or `undefined` if the
+ *   value is not found or enumObj is not a branded enum.
+ *
+ * @example
+ * // Find key for value
+ * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);
+ * getKeyForValue(Status, 'active'); // 'Active'
+ * getKeyForValue(Status, 'inactive'); // 'Inactive'
+ *
+ * @example
+ * // Returns undefined for unknown values
+ * getKeyForValue(Status, 'unknown'); // undefined
+ *
+ * @example
+ * // Roundtrip: value -> key -> value
+ * const key = getKeyForValue(Status, 'active'); // 'Active'
+ * Status[key]; // 'active'
+ */
+export declare function getKeyForValue<E extends AnyBrandedEnum>(enumObj: E, value: string): EnumKeys<E> | undefined;
+/**
+ * Checks if a key exists in a branded enum.
+ *
+ * Validates whether a given key is a valid member of the enum.
+ * Returns false for Symbol keys (metadata) and non-string keys.
+ *
+ * @template E - The branded enum type
+ * @param enumObj - The branded enum to check
+ * @param key - The key to validate. Can be any type; non-strings return false.
+ * @returns `true` if the key exists in the enum (with type narrowing),
+ *   `false` otherwise. Returns `false` for metadata Symbol keys or if
+ *   enumObj is not a branded enum.
+ *
+ * @example
+ * // Check if key exists
+ * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);
+ * isValidKey(Status, 'Active'); // true
+ * isValidKey(Status, 'Inactive'); // true
+ * isValidKey(Status, 'Unknown'); // false
+ *
+ * @example
+ * // Returns false for non-string keys
+ * isValidKey(Status, 123); // false
+ * isValidKey(Status, Symbol('test')); // false
+ */
+export declare function isValidKey<E extends AnyBrandedEnum>(enumObj: E, key: unknown): key is EnumKeys<E>;
+/**
+ * Returns an iterator of [key, value] pairs for a branded enum.
+ *
+ * Provides a way to iterate over all key-value pairs in the enum using
+ * a for...of loop. Only yields user-defined entries, not metadata.
+ * Equivalent to `Object.entries(enumObj)` but with proper typing.
+ *
+ * @template E - The branded enum type
+ * @param enumObj - The branded enum to iterate over
+ * @returns An iterator yielding [key, value] tuples. Returns an empty
+ *   iterator if enumObj is not a branded enum.
+ *
+ * @example
+ * // Iterate over entries
+ * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);
+ *
+ * for (const [key, value] of enumEntries(Status)) {
+ *   console.log(`${key}: ${value}`);
+ * }
+ * // Output:
+ * // Active: active
+ * // Inactive: inactive
+ *
+ * @example
+ * // Convert to array
+ * const entries = [...enumEntries(Status)];
+ * // [['Active', 'active'], ['Inactive', 'inactive']]
+ *
+ * @example
+ * // Use with Array.from
+ * const entriesArray = Array.from(enumEntries(Status));
+ */
+export declare function enumEntries<E extends AnyBrandedEnum>(enumObj: E): IterableIterator<[EnumKeys<E>, EnumValues<E>]>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,cAAc,EAKd,QAAQ,EACR,UAAU,EACX,MAAM,YAAY,CAAC;AAmBpB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,cAAc,EAC/C,OAAO,EAAE,CAAC,EACV,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,CAQxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,cAAc,EACrD,OAAO,EAAE,CAAC,EACV,KAAK,EAAE,MAAM,GACZ,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAUzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,cAAc,EACjD,OAAO,EAAE,CAAC,EACV,GAAG,EAAE,OAAO,GACX,GAAG,IAAI,QAAQ,CAAC,CAAC,CAAC,CAQpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAiB,WAAW,CAAC,CAAC,SAAS,cAAc,EACnD,OAAO,EAAE,CAAC,GACT,gBAAgB,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAOhD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitaldefiance/branded-enum",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Runtime-identifiable enum-like types for TypeScript with zero runtime overhead",
   "license": "MIT",
   "type": "module",
@@ -69,19 +69,24 @@
     "sourceRoot": "src",
     "targets": {
       "build": {
-        "executor": "@nx/js:swc",
-        "outputs": ["{options.outputPath}"],
+        "executor": "nx:run-commands",
+        "outputs": [
+          "{projectRoot}/dist"
+        ],
         "options": {
-          "outputPath": "dist",
-          "main": "src/index.ts",
-          "tsConfig": "tsconfig.lib.json",
-          "skipTypeCheck": true,
-          "stripLeadingPaths": true
+          "commands": [
+            "swc src -d dist --config-file .swcrc --strip-leading-paths",
+            "tsc -p tsconfig.lib.json"
+          ],
+          "cwd": "{projectRoot}",
+          "parallel": false
         }
       },
       "test": {
         "executor": "@nx/jest:jest",
-        "outputs": ["{projectRoot}/test-output/jest/coverage"],
+        "outputs": [
+          "{projectRoot}/test-output/jest/coverage"
+        ],
         "options": {
           "jestConfig": "jest.config.cts",
           "passWithNoTests": true
@@ -89,18 +94,24 @@
       },
       "build-examples": {
         "executor": "nx:run-commands",
-        "outputs": ["{projectRoot}/examples/dist"],
+        "outputs": [
+          "{projectRoot}/examples/dist"
+        ],
         "options": {
           "command": "tsc -p examples/tsconfig.json"
         },
-        "dependsOn": ["build"]
+        "dependsOn": [
+          "build"
+        ]
       },
       "publish-public": {
         "executor": "nx:run-commands",
         "options": {
           "command": "npm publish --access public"
         },
-        "dependsOn": ["build"]
+        "dependsOn": [
+          "build"
+        ]
       }
     }
   },

package/dist/package.json

@@ -1,120 +0,0 @@
-{
-  "name": "@digitaldefiance/branded-enum",
-  "version": "0.0.1",
-  "description": "Runtime-identifiable enum-like types for TypeScript with zero runtime overhead",
-  "license": "MIT",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "!**/*.tsbuildinfo"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Digital-Defiance/branded-enum.git"
-  },
-  "keywords": [
-    "typescript",
-    "enum",
-    "branded",
-    "type-safe",
-    "runtime"
-  ],
-  "author": "Digital Defiance, Jessica Mulein",
-  "bugs": {
-    "url": "https://github.com/Digital-Defiance/branded-enum/issues"
-  },
-  "homepage": "https://github.com/Digital-Defiance/branded-enum#readme",
-  "scripts": {
-    "build": "nx build branded-enum",
-    "build:examples": "nx build-examples branded-enum",
-    "test": "nx test branded-enum",
-    "lint": "nx lint branded-enum",
-    "publish:public": "yarn build && npm publish --access public"
-  },
-  "devDependencies": {
-    "@nx/jest": "22.4.2",
-    "@nx/js": "22.4.2",
-    "@swc-node/register": "~1.9.1",
-    "@swc/cli": "~0.6.0",
-    "@swc/core": "~1.5.7",
-    "@swc/helpers": "~0.5.11",
-    "@swc/jest": "~0.2.38",
-    "@types/jest": "^30.0.0",
-    "@types/node": "20.19.9",
-    "fast-check": "^4.5.3",
-    "jest": "^30.0.2",
-    "jest-environment-node": "^30.0.2",
-    "jest-util": "^30.0.2",
-    "nx": "22.4.2",
-    "prettier": "~3.6.2",
-    "ts-jest": "^29.4.0",
-    "ts-node": "10.9.1",
-    "tslib": "^2.3.0",
-    "typescript": "~5.9.2"
-  },
-  "packageManager": "yarn@4.12.0",
-  "nx": {
-    "name": "branded-enum",
-    "sourceRoot": "src",
-    "targets": {
-      "build": {
-        "executor": "@nx/js:swc",
-        "outputs": [
-          "{options.outputPath}"
-        ],
-        "options": {
-          "outputPath": "dist",
-          "main": "src/index.ts",
-          "tsConfig": "tsconfig.lib.json",
-          "skipTypeCheck": true,
-          "stripLeadingPaths": true
-        }
-      },
-      "test": {
-        "executor": "@nx/jest:jest",
-        "outputs": [
-          "{projectRoot}/test-output/jest/coverage"
-        ],
-        "options": {
-          "jestConfig": "jest.config.cts",
-          "passWithNoTests": true
-        }
-      },
-      "build-examples": {
-        "executor": "nx:run-commands",
-        "outputs": [
-          "{projectRoot}/examples/dist"
-        ],
-        "options": {
-          "command": "tsc -p examples/tsconfig.json"
-        },
-        "dependsOn": [
-          "build"
-        ]
-      },
-      "publish-public": {
-        "executor": "nx:run-commands",
-        "options": {
-          "command": "npm publish --access public"
-        },
-        "dependsOn": [
-          "build"
-        ]
-      }
-    }
-  },
-  "engines": {
-    "node": ">=18"
-  }
-}