@vicin/sigil 3.1.0 → 3.1.3

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to this project will be documented in this file.
 
+## [3.1.3] - 2026-02-26
+
+### Changed
+
+- Patched type tests where `sigil` should be imported as type only
+
+## [3.1.2] - 2026-02-26
+
+### Changed
+
+- Patched README.md
+
+### Added
+
+- `GetPrototype<T>` helper to get type of class instance in `protected` or `private` classes
+
+### Removed
+
+- `isSigilified` method in `Sigil` class as it's redundant and separate check function is present
+
+## [3.1.1] - 2026-02-25
+
+### Changed
+
+- Updated README.md
+
 ## [3.1.0] - 2026-02-25
 
 ### Added

package/README.md

@@ -5,28 +5,26 @@
 > - 🎉 v3.0.0 is out! Happy coding! 😄💻
 > - 📄 **Changelog:** [CHANGELOG.md](./CHANGELOG.md)
 
-`Sigil` replaces `instanceof` across bundles, enforces nominal class identity, and makes inheritance-aware runtime type checks reliable in large TypeScript systems. It organizes class identities across your codebase and gives you the power of **nominal typing** and **safe cross-bundle class checks** where each class constructor is stored under a unique label.
+`Sigil` gives you the power of **safe cross-bundle class instances checks** and **simple class nominal typing** if needed.
 
 > **Key ideas:**
 >
-> - **Reliable Runtime Checks:** Uses labels instead of instanceof for cross-bundle reliability.
+> - **Reliable Runtime Checks:** Uses `isOfType` instead of `instanceof` for cross-bundle reliability.
 > - **Nominal Typing at Compile Time:** Distinguishes structurally similar types (e.g., UserId vs. PostId).
-> - **Inheritance Awareness:** Tracks lineages for subtype/supertype checks.
+
+## Features
+
+- ✅ **Drop-in `instanceof` replacement** that works across bundles, HMR, and monorepos, Also can check for **exact class instance**
+- ✅ **Simple nominal typing** with just one line of code for each class
+- ✅ **Tiny less than 1.5 KB minified and brotlied** measured using [size-limit](https://www.npmjs.com/package/size-limit)
+- ✅ **Performant as native instanceof** but with guaranteed checks
+- ✅ **Test coverage is 100%** to ensure that runtime remains consistent and predictable
 
 ## Important Notes Before Using
 
 - **Explicit class identity:** `Sigil` uses passed class label to identify classes, which means that the developer is responsible for uniqueness of classes by passing unique labels.
 - **Simple instanceof Fix:** If you just need runtime checks without extras, see the [minimal mode](#minimal-mode).
 
-## Features
-
-- ✅ **Drop-in `instanceof` replacement** that works across bundles, HMR, and monorepos
-- ✅ **True nominal typing** with zero runtime cost
-- ✅ **Inheritance-aware** checks (`isOfType` knows about subclasses)
-- ✅ **Tiny less than 1.5 KB minified and brotlied** measured using size-limit
-- ✅ **Performant as native instanceof** but with guaranteed checks! Also can check for **exact class instance**
-- ✅ Full TypeScript 5.0+ support + excellent JSDoc
-
 ---
 
 ## Table of contents
@@ -47,6 +45,8 @@
 - [Minimal mode](#minimal-mode)
 - [Strict mode](#strict-mode)
 - [Benchmarks](#benchmarks)
+- [Bundle Size](#bundle-size)
+- [Tests](#tests)
 - [Contributing](#contributing)
 - [License](#license)
 - [Author](#author)
@@ -154,8 +154,8 @@ Congratulations — you’ve opted into `Sigil` and you can start replacing `ins
 
 - **Label**: An identity (string) such as `@scope/pkg.ClassName`, but can be random string (e.g. `@Sigil-auto:ClassName:mm2gkdwn:0:g1sq`) if no label passed.
 - **EffectiveLabel:** A human-readable (string) such as `@scope/pkg.ClassName`, if no label is passed it inherit the last defined label.
-- **Label lineage**: Array of labels for ancestry.
-- **Label set**: Set of labels for fast checks.
+- **isOfType**: Takes object argument and check if this object is an instance of calling class or it's children. Can be called from class instances as well.
+- **isExactType**: Takes object argument and check if this object is an instance of calling class only. Can be called from class instances as well.
 - **[sigil]**: TypeScript symbol marker for nominal types.
 
 ---
@@ -188,7 +188,7 @@ type test1 = User extends Sigil ? true : false; // true
 type test2 = Sigil extends User ? true : false; // false
 ```
 
-`Sigil` abstracts these into a **centralized system**, making identity management **explicit** and **error-resistant** if defined the right way.
+`Sigil` makes identity management **explicit** and **error-resistant** if defined the right way.
 
 ### Implementation Mechanics
 
@@ -200,7 +200,7 @@ import { Sigil, WithSigil, sigil, ExtendSigil } from '@vicin/sigil';
 
 @WithSigil('@scope/package.MyClass') // <-- Run-time values update
 class MyClass extends Sigil {
-  declare [sigil]: ExtendSigil<'@scope/package.MyClass', Sigil>; // <-- compile-time type update
+  declare [sigil]: ExtendSigil<'MyClass', Sigil>; // <-- compile-time type update
 }
 ```
 
@@ -210,14 +210,14 @@ You can avoid decorators and use HOF but they are slightly more verbose:
 import { Sigil, withSigil, sigil, ExtendSigil } from '@vicin/sigil';
 
 class _MyClass extends Sigil {
-  declare [sigil]: ExtendSigil<'@scope/package.MyClass', Sigil>;
+  declare [sigil]: ExtendSigil<'MyClass', Sigil>;
 }
 
 const MyClass = withSigil(_MyClass, '@scope/package.MyClass');
 type MyClass = InstanceType<typeof MyClass>;
 ```
 
-Note that you can't use `InstanceType` on `private` or `protected` classes.
+Note that you can't use `InstanceType` on `private` or `protected` classes, however you can use `GetPrototype<T>` in such cases.
 
 ### Inheritance example
 
@@ -226,12 +226,12 @@ import { Sigil, WithSigil } from '@vicin/sigil';
 
 @WithSigil('@myorg/User')
 class User extends Sigil {
-  declare [sigil]: ExtendSigil<'@myorg/User', Sigil>;
+  declare [sigil]: ExtendSigil<'User', Sigil>;
 }
 
 @WithSigil('@myorg/Admin')
 class Admin extends User {
-  declare [sigil]: ExtendSigil<'@myorg/Admin', User>;
+  declare [sigil]: ExtendSigil<'Admin', User>;
 }
 
 const admin = new Admin();
@@ -260,8 +260,8 @@ type test2 = User extends Admin ? true : false; // false
 ### Primary Exports
 
 - **Mixins:**
-  - `Sigilify(Base, label?, opts?)`
-  - `SigilifyAbstract(Base, label?, opts?)`
+  - `Sigilify(Base, label, opts?)`
+  - `SigilifyAbstract(Base, label, opts?)`
 
 - **Classes:**
   - `Sigil`
@@ -271,15 +271,11 @@ type test2 = User extends Admin ? true : false; // false
   - `WithSigil(label, opts?)`
 
 - **HOFs:**
-  - `withSigil(Class, label?, opts?)`
+  - `withSigil(Class, label, opts?)`
 
 - **Helpers:**
   - `isSigilCtor(ctor)`
   - `isSigilInstance(inst)`
-  - `isSigilBaseCtor(ctor)`
-  - `isSigilBaseInstance(inst)`
-  - `isDecorated(ctor)`
-  - `isInheritanceChecked(ctor)`
 
 - **Options:**
   - `updateSigilOptions(opts)`
@@ -291,18 +287,20 @@ type test2 = User extends Admin ? true : false; // false
   - `ISigilInstance<Label, ParentSigil?>`
   - `SigilOf<T>`
   - `ExtendSigil<Label, Parent>`
+  - `GetPrototype<Class>`
   - `SigilOptions`
 
 ### Key helpers (runtime)
 
 - `Sigil`: a minimal sigilified base class you can extend from.
 - `SigilError`: an `Error` class decorated with a `Sigil` so it can be identified at runtime.
-- `Sigilify(Base, label?, opts?)`: mixin function that returns a new constructor with `Sigil` types and instance helpers.
-- `WithSigil(label)`: class decorator that attaches `Sigil` metadata at declaration time.
-- `withSigil(Class, label?, opts?)`: HOF that validates and decorates an existing class constructor.
+- `Sigilify(Base, label, opts?)`: mixin function that returns a new constructor with `Sigil` types and instance helpers.
+- `SigilifyAbstract(Base, label, opts?)`: Same as `Sigilify` but for abstract classes.
+- `WithSigil(label, opts?)`: class decorator that attaches `Sigil` metadata at declaration time.
+- `withSigil(Class, label, opts?)`: HOF that validates and decorates an existing class constructor.
 - `isSigilCtor(value)`: `true` if `value` is a `Sigil` constructor.
 - `isSigilInstance(value)`: `true` if `value` is an instance of a `Sigil` constructor.
-- `updateSigilOptions(opts)`: change global runtime options before `Sigil` decoration (e.g., `autofillLabels`).
+- `updateSigilOptions(opts)`: change global runtime options of `Sigil` library (e.g., `autofillLabels`).
 - `DEFAULT_LABEL_REGEX`: regex that ensures structure of `@scope/package.ClassName` to all labels, it's advised to use it as your `SigilOptions.labelValidation`
 
 ### Instance & static helpers provided by Sigilified constructors
@@ -312,8 +310,7 @@ When a constructor is decorated/sigilified it will expose the following **static
 - `SigilLabel` — the identity label string.
 - `SigilEffectiveLabel` — the human label string.
 - `SigilLabelLineage` — readonly array of labels representing parent → child for debugging.
-- `SigilLabelSet` — readonly `Set<string>` for debugging.
-- `isSigilified(obj)` — runtime predicate that delegates to `isSigilInstance`.
+- `SigilLabelSet` — readonly `Set<string>` of sigil labels for debugging.
 - `isOfType(other)` — check if other is an instance of this constructor or its children.
 - `isExactType(other) `— check if other is an instance exactly this constructor.
 
@@ -337,7 +334,6 @@ import { updateSigilOptions } from '@vicin/sigil';
 
 updateSigilOptions({
   autofillLabels: true, // Automatically label unlabeled subclasses
-  skipLabelInheritanceCheck: false, // Bypass dev inheritance checks -- ALMOST NEVER WANT TO SET THIS TO TRUE
   labelValidation: null, // Function or regex, Enforce label format
 });
 ```
@@ -369,14 +365,22 @@ import { updateSigilOptions } from '@vicin/sigil';
 updateSigilOptions({ autofillLabels: false });
 ```
 
-Now if you forgot to pass a label error is thrown.
+Now if you forgot to pass a label error is thrown at the moment you create class instance or use any of `Sigil` methods.
 
 ---
 
 ## Benchmarks
 
 Sigil is built for **real-world performance**. Below are the latest micro-benchmark results (run on **Node.js v20.12.0**).
-To run benchmarks on your machine fetch source code from [github](https://github.com/ZiadTaha62/sigil) and run `npm run bench` in your console.
+
+**Running Tests**
+
+To run benchmarks on your machine fetch source code from [github](https://github.com/ZiadTaha62/sigil) then:
+
+```bash
+npm install
+npm run bench
+```
 
 ### 1. Runtime Type Checking
 
@@ -389,8 +393,7 @@ To run benchmarks on your machine fetch source code from [github](https://github
 | 15    | 0.000058 ms           | 0.000063 ms       | **0.000051 ms**       | 0.000069 ms          | **0.000053 ms**          |
 
 > **Key takeaway**:  
-> `isOfType` has **practically the same performance as native `instanceof`**, slightly **slower** on static calls and slightly **faster** on the instance side.
-> `isExactType` adds only a tiny negligible cost and remains extremely fast even on deep hierarchies.
+> `isOfType` & `isExactType` has **practically the same performance as native `instanceof`**, slightly **slower** on static calls and slightly **faster** on the instance side.
 
 ### 2. Class Definition & Instance Creation
 
@@ -411,14 +414,59 @@ To run benchmarks on your machine fetch source code from [github](https://github
 > - Class definition is a **one-time cost** at module load time. Even at depth 10 the cost stays well under 1 ms per class.
 > - Instance creation adds a small fixed overhead of ~0.4–0.6 µs per object, which becomes completely negligible as your classes grow in size and complexity.
 
-### Bundle Size
+---
+
+## Bundle Size
+
+**Less than 1.5 KB (1.44 KB)** minified + Brotli, including all dependencies
+
+**Running Tests**
+
+To verify bundle size fetch source code from [github](https://github.com/ZiadTaha62/sigil) then:
 
-**less than 1.5 KB** (minified + Brotli, including all dependencies)
+```bash
+npm install
+npm run size
+```
 
 This makes Sigil one of the smallest full-featured solutions for nominal typing + reliable runtime identity.
 
 ---
 
+## Tests
+
+Reliability is a core pillar of `Sigil`. The library is backed by a comprehensive suite of unit tests that cover everything from basic mixins to lazy evaluation.
+
+**Coverage Status**
+
+We maintain **100%** test coverage across the entire codebase to ensure that runtime metadata remains consistent and predictable.
+
+| Metric | Score |
+| ------ | ----- |
+| Stmts  | 100%  |
+| Branch | 100%  |
+| Funcs  | 100%  |
+| Lines  | 100%  |
+
+**Key Test Areas**
+
+- **Mixins, Decorators & HOFs:** Validating `Sigilify`, `WithSigil` and `withSigil` behaviors.
+- **Sigil methods:** Ensuring `Sigil` class methods (e.g. `SigilLabel`, `getSigilLabel`) work as expected.
+- **Lazy Evaluation:** Ensuring metadata is attached before being accessed via `Sigil` methods.
+- **Lineage:** Verifying that `isOfType` and `isExactType` work across complex inheritance chains.
+- **Error Handling:** Strict validation for all errors and throws.
+
+**Running Tests**
+
+To run the test suite locally and generate a coverage report, fetch source code from [github](https://github.com/ZiadTaha62/sigil) then:
+
+```bash
+npm install
+npm run test:unit
+```
+
+---
+
 ## Contributing
 
 Any contributions you make are **greatly appreciated**.

package/dist/index.d.mts

@@ -33,14 +33,6 @@ interface ISigilStatic<L extends string = string> {
      * Useful for debugging.
      */
     readonly SigilLabelSet: Readonly<Set<string>>;
-    /**
-     * Runtime check that determines whether `obj` is an instance produced by a
-     * sigil class.
-     *
-     * @param obj - Value to test.
-     * @returns Type guard narrowing `obj` to `ISigilInstance`.
-     */
-    isSigilified(obj: unknown): obj is ISigilInstance;
     /**
      * Check whether `other` is (or inherits from) the instance represented by the
      * calling constructor.
@@ -160,7 +152,11 @@ type Prettify<T> = {
 } & {};
 /** Helper type to replace 'never' with another type */
 type IfNever<T, R = {}> = [T] extends [never] ? R : T;
-/** Helper type to get prototype of class */
+/**
+ * Helper type to get prototype of class
+ *
+ * @template T - Class constructor.
+ */
 type GetPrototype<T> = T extends {
     prototype: infer P;
 } ? P : never;
@@ -187,7 +183,6 @@ declare const Sigil: {
     get SigilEffectiveLabel(): "Sigil";
     get SigilLabelLineage(): readonly string[];
     get SigilLabelSet(): Readonly<Set<string>>;
-    isSigilified(obj: unknown): obj is ISigilInstance;
     isOfType<T extends ISigilStatic>(this: T, other: unknown): other is GetPrototype<T>;
     isExactType<T extends ISigilStatic>(this: T, other: unknown): other is GetPrototype<T>;
 } & {
@@ -218,7 +213,6 @@ declare const SigilError: {
     get SigilEffectiveLabel(): "SigilError";
     get SigilLabelLineage(): readonly string[];
     get SigilLabelSet(): Readonly<Set<string>>;
-    isSigilified(obj: unknown): obj is ISigilInstance;
     isOfType<T extends ISigilStatic>(this: T, other: unknown): other is GetPrototype<T>;
     isExactType<T extends ISigilStatic>(this: T, other: unknown): other is GetPrototype<T>;
 } & ErrorConstructor;
@@ -309,13 +303,12 @@ declare function isSigilInstance(inst: unknown): inst is ISigilInstance;
  * Mixin factory that augments an existing class with Sigil runtime metadata and helpers.
  *
  * @param Base - The base constructor to extend.
- * @param label - Optional identity label to attach to the resulting class (e.g. '@scope/pkg.ClassName').
- *                If not passed a random label is generated instead.
+ * @param label - Identity label to attach to the resulting class (e.g. '@scope/pkg.ClassName').
  * @param opts - Options object to override any global options if needed.
  * @returns A new constructor that extends `Base` and includes Sigil statics/instance methods.
  * @throws Error if `Base` is already sigilified.
  */
-declare function Sigilify<B extends Constructor, L extends string>(Base: B, label?: L, opts?: SigilOptions): {
+declare function Sigilify<B extends Constructor, L extends string>(Base: B, label: L, opts?: SigilOptions): {
     new (...args: any[]): {
         /**
          * Check whether `other` is (or inherits from) the instance represented by the
@@ -394,13 +387,6 @@ declare function Sigilify<B extends Constructor, L extends string>(Base: B, labe
      * @returns A Readonly Set of labels that represent the type lineage.
      */
     get SigilLabelSet(): Readonly<Set<string>>;
-    /**
-     * Runtime predicate indicating whether `obj` is an instance produced by a sigil class.
-     *
-     * @param obj - The value to test.
-     * @returns `true` if `obj` is a sigil instance.
-     */
-    isSigilified(obj: unknown): obj is ISigilInstance;
     /**
      * Check whether `other` is (or inherits from) the instance represented by the
      * calling constructor.
@@ -429,13 +415,12 @@ declare function Sigilify<B extends Constructor, L extends string>(Base: B, labe
  * Mixin factory that augments an existing class with Sigil runtime metadata and helpers. Accept and return 'abstract' class.
  *
  * @param Base - The base constructor to extend.
- * @param label - Optional identity label to attach to the resulting class (e.g. '@scope/pkg.ClassName').
- *                If not passed a random label is generated instead.
+ * @param label - Identity label to attach to the resulting class (e.g. '@scope/pkg.ClassName').
  * @param opts - Options object to override any global options if needed.
  * @returns A new abstract constructor that extends `Base` and includes Sigil statics/instance methods.
  * @throws Error if `Base` is already sigilified.
  */
-declare function SigilifyAbstract<B extends ConstructorAbstract, L extends string>(Base: B, label?: L, opts?: SigilOptions): ((abstract new (...args: any[]) => {
+declare function SigilifyAbstract<B extends ConstructorAbstract, L extends string>(Base: B, label: L, opts?: SigilOptions): ((abstract new (...args: any[]) => {
     /**
      * Check whether `other` is (or inherits from) the instance represented by the
      * calling constructor.
@@ -513,13 +498,6 @@ declare function SigilifyAbstract<B extends ConstructorAbstract, L extends strin
      * @returns A Readonly Set of labels that represent the type lineage.
      */
     get SigilLabelSet(): Readonly<Set<string>>;
-    /**
-     * Runtime predicate indicating whether `obj` is an instance produced by a sigil class.
-     *
-     * @param obj - The value to test.
-     * @returns `true` if `obj` is a sigil instance.
-     */
-    isSigilified(obj: unknown): obj is ISigilInstance;
     /**
      * Check whether `other` is (or inherits from) the instance represented by the
      * calling constructor.
@@ -545,4 +523,4 @@ declare function SigilifyAbstract<B extends ConstructorAbstract, L extends strin
     isExactType<T>(this: T, other: unknown): other is GetPrototype<T>;
 }) & B;
 
-export { DEFAULT_LABEL_REGEX, type ExtendSigil, type ISigil, type ISigilInstance, type ISigilStatic, Sigil, SigilError, type SigilOf, type SigilOptions, Sigilify, SigilifyAbstract, WithSigil, isSigilCtor, isSigilInstance, sigil, updateSigilOptions, withSigil };
+export { DEFAULT_LABEL_REGEX, type ExtendSigil, type GetPrototype, type ISigil, type ISigilInstance, type ISigilStatic, Sigil, SigilError, type SigilOf, type SigilOptions, Sigilify, SigilifyAbstract, WithSigil, isSigilCtor, isSigilInstance, sigil, updateSigilOptions, withSigil };

package/dist/index.d.ts

@@ -33,14 +33,6 @@ interface ISigilStatic<L extends string = string> {
      * Useful for debugging.
      */
     readonly SigilLabelSet: Readonly<Set<string>>;
-    /**
-     * Runtime check that determines whether `obj` is an instance produced by a
-     * sigil class.
-     *
-     * @param obj - Value to test.
-     * @returns Type guard narrowing `obj` to `ISigilInstance`.
-     */
-    isSigilified(obj: unknown): obj is ISigilInstance;
     /**
      * Check whether `other` is (or inherits from) the instance represented by the
      * calling constructor.
@@ -160,7 +152,11 @@ type Prettify<T> = {
 } & {};
 /** Helper type to replace 'never' with another type */
 type IfNever<T, R = {}> = [T] extends [never] ? R : T;
-/** Helper type to get prototype of class */
+/**
+ * Helper type to get prototype of class
+ *
+ * @template T - Class constructor.
+ */
 type GetPrototype<T> = T extends {
     prototype: infer P;
 } ? P : never;
@@ -187,7 +183,6 @@ declare const Sigil: {
     get SigilEffectiveLabel(): "Sigil";
     get SigilLabelLineage(): readonly string[];
     get SigilLabelSet(): Readonly<Set<string>>;
-    isSigilified(obj: unknown): obj is ISigilInstance;
     isOfType<T extends ISigilStatic>(this: T, other: unknown): other is GetPrototype<T>;
     isExactType<T extends ISigilStatic>(this: T, other: unknown): other is GetPrototype<T>;
 } & {
@@ -218,7 +213,6 @@ declare const SigilError: {
     get SigilEffectiveLabel(): "SigilError";
     get SigilLabelLineage(): readonly string[];
     get SigilLabelSet(): Readonly<Set<string>>;
-    isSigilified(obj: unknown): obj is ISigilInstance;
     isOfType<T extends ISigilStatic>(this: T, other: unknown): other is GetPrototype<T>;
     isExactType<T extends ISigilStatic>(this: T, other: unknown): other is GetPrototype<T>;
 } & ErrorConstructor;
@@ -309,13 +303,12 @@ declare function isSigilInstance(inst: unknown): inst is ISigilInstance;
  * Mixin factory that augments an existing class with Sigil runtime metadata and helpers.
  *
  * @param Base - The base constructor to extend.
- * @param label - Optional identity label to attach to the resulting class (e.g. '@scope/pkg.ClassName').
- *                If not passed a random label is generated instead.
+ * @param label - Identity label to attach to the resulting class (e.g. '@scope/pkg.ClassName').
  * @param opts - Options object to override any global options if needed.
  * @returns A new constructor that extends `Base` and includes Sigil statics/instance methods.
  * @throws Error if `Base` is already sigilified.
  */
-declare function Sigilify<B extends Constructor, L extends string>(Base: B, label?: L, opts?: SigilOptions): {
+declare function Sigilify<B extends Constructor, L extends string>(Base: B, label: L, opts?: SigilOptions): {
     new (...args: any[]): {
         /**
          * Check whether `other` is (or inherits from) the instance represented by the
@@ -394,13 +387,6 @@ declare function Sigilify<B extends Constructor, L extends string>(Base: B, labe
      * @returns A Readonly Set of labels that represent the type lineage.
      */
     get SigilLabelSet(): Readonly<Set<string>>;
-    /**
-     * Runtime predicate indicating whether `obj` is an instance produced by a sigil class.
-     *
-     * @param obj - The value to test.
-     * @returns `true` if `obj` is a sigil instance.
-     */
-    isSigilified(obj: unknown): obj is ISigilInstance;
     /**
      * Check whether `other` is (or inherits from) the instance represented by the
      * calling constructor.
@@ -429,13 +415,12 @@ declare function Sigilify<B extends Constructor, L extends string>(Base: B, labe
  * Mixin factory that augments an existing class with Sigil runtime metadata and helpers. Accept and return 'abstract' class.
  *
  * @param Base - The base constructor to extend.
- * @param label - Optional identity label to attach to the resulting class (e.g. '@scope/pkg.ClassName').
- *                If not passed a random label is generated instead.
+ * @param label - Identity label to attach to the resulting class (e.g. '@scope/pkg.ClassName').
  * @param opts - Options object to override any global options if needed.
  * @returns A new abstract constructor that extends `Base` and includes Sigil statics/instance methods.
  * @throws Error if `Base` is already sigilified.
  */
-declare function SigilifyAbstract<B extends ConstructorAbstract, L extends string>(Base: B, label?: L, opts?: SigilOptions): ((abstract new (...args: any[]) => {
+declare function SigilifyAbstract<B extends ConstructorAbstract, L extends string>(Base: B, label: L, opts?: SigilOptions): ((abstract new (...args: any[]) => {
     /**
      * Check whether `other` is (or inherits from) the instance represented by the
      * calling constructor.
@@ -513,13 +498,6 @@ declare function SigilifyAbstract<B extends ConstructorAbstract, L extends strin
      * @returns A Readonly Set of labels that represent the type lineage.
      */
     get SigilLabelSet(): Readonly<Set<string>>;
-    /**
-     * Runtime predicate indicating whether `obj` is an instance produced by a sigil class.
-     *
-     * @param obj - The value to test.
-     * @returns `true` if `obj` is a sigil instance.
-     */
-    isSigilified(obj: unknown): obj is ISigilInstance;
     /**
      * Check whether `other` is (or inherits from) the instance represented by the
      * calling constructor.
@@ -545,4 +523,4 @@ declare function SigilifyAbstract<B extends ConstructorAbstract, L extends strin
     isExactType<T>(this: T, other: unknown): other is GetPrototype<T>;
 }) & B;
 
-export { DEFAULT_LABEL_REGEX, type ExtendSigil, type ISigil, type ISigilInstance, type ISigilStatic, Sigil, SigilError, type SigilOf, type SigilOptions, Sigilify, SigilifyAbstract, WithSigil, isSigilCtor, isSigilInstance, sigil, updateSigilOptions, withSigil };
+export { DEFAULT_LABEL_REGEX, type ExtendSigil, type GetPrototype, type ISigil, type ISigilInstance, type ISigilStatic, Sigil, SigilError, type SigilOf, type SigilOptions, Sigilify, SigilifyAbstract, WithSigil, isSigilCtor, isSigilInstance, sigil, updateSigilOptions, withSigil };