@webergency-utils/typechecker 0.1.7 → 0.1.9

package/README.md

@@ -327,6 +327,27 @@ Define defaults for optional fields:
 
 - `tag.Default<Value>`: Injects the specified `Value` if the property is `undefined` at validation time.
 
+### Assignability & compile-time constants
+
+Constraint tags use **optional** phantom properties (same pattern as `tag.Default`), so plain values assign to tagged types:
+
+```typescript
+const age: number & Minimum<18> = 18; // OK
+const plain: { age: number } = { age: 5 };
+const tagged: { age: number & Minimum<18> } = plain; // OK
+```
+
+When the TypeScript plugin is enabled, **compile-time constants** that violate constraints produce diagnostics:
+
+```typescript
+const tooYoung: number & Minimum<18> = 5;           // Error: does not satisfy Minimum<18>
+const short: string & MinLength<3> = 'ab';           // Error: does not satisfy MinLength<3>
+const empty: string[] & MinItems<1> = [];            // Error: does not satisfy MinItems<1>
+const dupes: number[] & UniqueItems = [1, 1];        // Error: does not satisfy UniqueItems
+```
+
+Non-constants (`number`, variables, function results) are not checked statically — use `is` / `assert` / `validate` at runtime.
+
 #### Example:
 ```typescript
 import { MinLength, Minimum, Format, UniqueItems, tag, transform, constraint } from '@webergency-utils/typechecker';

package/dist/engine/generators.js

@@ -199,23 +199,7 @@ export function createObjectCheck(props, requiredUtils, expected = 'object') {
     const tpl = `
     (v, path, ctx) => {
         if (!validators.object(v, path, ctx, __KEYS__, __EXPECTED__)) return v;
-        let data = v;
-        if (ctx.mode === 'strip') {
-            let hasAdditional = false;
-            const keys = Object.keys(v);
-            const allowed = __KEYS__;
-            if (keys.length > allowed.length) {
-                hasAdditional = true;
-            } else {
-                for (let i = 0; i < keys.length; i++) {
-                    if (!allowed.includes(keys[i])) {
-                        hasAdditional = true;
-                        break;
-                    }
-                }
-            }
-            if (hasAdditional) data = {};
-        }
+        const data = ctx.mode === 'strip' ? {} : v;
         validators.props(v, data, path, ctx, __PROPS__);
         return data;
     }

package/dist/engine/resolver.js

@@ -13,6 +13,32 @@ function getStringLiteralValue(type) {
     }
     return undefined;
 }
+/** Optional tag phantoms are `V | undefined` — strip undefined before reading literals/symbols. */
+function stripUndefinedFromType(type) {
+    if (!type.isUnion()) {
+        return type;
+    }
+    const nonUndefined = type.types.filter(t => !(t.getFlags() & ts.TypeFlags.Undefined));
+    if (nonUndefined.length === 1) {
+        return nonUndefined[0];
+    }
+    if (nonUndefined.length > 1) {
+        // Keep union of remaining members (e.g. string literal | other)
+        return type;
+    }
+    return type;
+}
+function getTagPropertyValue(type) {
+    const actual = stripUndefinedFromType(type);
+    let val = actual.value;
+    if (val === undefined && (actual.getFlags() & ts.TypeFlags.BooleanLiteral)) {
+        val = actual.intrinsicName === 'true';
+    }
+    if (val === undefined && (actual.getFlags() & ts.TypeFlags.Null)) {
+        val = null;
+    }
+    return val;
+}
 function minifyTypeString(str) {
     return str
         .replace(/\{\s+/g, '{')
@@ -71,13 +97,8 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
                 const pName = prop.getName();
                 if (pName.startsWith('__')) {
                     const pType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations?.[0]);
-                    let val = pType.value;
-                    if (val === undefined && (pType.getFlags() & ts.TypeFlags.BooleanLiteral)) {
-                        val = pType.intrinsicName === 'true';
-                    }
-                    if (val === undefined && (pType.getFlags() & ts.TypeFlags.Null)) {
-                        val = null;
-                    }
+                    const actualType = stripUndefinedFromType(pType);
+                    const val = getTagPropertyValue(pType);
                     if (pName === '__default') {
                         constraints.push({ type: 'default', value: val });
                     }
@@ -108,7 +129,7 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
                     else if (pName === '__transform_custom') {
                         let fnName;
                         let filePath;
-                        const symbol = pType.getSymbol() || pType.aliasSymbol;
+                        const symbol = actualType.getSymbol() || actualType.aliasSymbol || pType.getSymbol() || pType.aliasSymbol;
                         if (symbol) {
                             fnName = symbol.getName();
                             let dec = symbol.valueDeclaration || symbol.declarations?.[0];
@@ -131,7 +152,7 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
                             }
                         }
                         else {
-                            const str = checker.typeToString(pType);
+                            const str = checker.typeToString(actualType);
                             const match = str.match(/typeof\s+([a-zA-Z0-9_]+)/);
                             if (match) {
                                 fnName = match[1];
@@ -148,7 +169,7 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
                     else if (pName === '__custom') {
                         let fnName;
                         let filePath;
-                        const symbol = pType.getSymbol() || pType.aliasSymbol;
+                        const symbol = actualType.getSymbol() || actualType.aliasSymbol || pType.getSymbol() || pType.aliasSymbol;
                         if (symbol) {
                             fnName = symbol.getName();
                             let dec = symbol.valueDeclaration || symbol.declarations?.[0];
@@ -171,7 +192,7 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
                             }
                         }
                         else {
-                            const str = checker.typeToString(pType);
+                            const str = checker.typeToString(actualType);
                             const match = str.match(/typeof\s+([a-zA-Z0-9_]+)/);
                             if (match) {
                                 fnName = match[1];
@@ -237,11 +258,11 @@ export function buildValidator(type, checker, validatorsMap, requiredUtils) {
                     }
                     else if (pName === '__requires') {
                         let reqVal;
-                        if (pType.isStringLiteral()) {
-                            reqVal = pType.value;
+                        if (actualType.isStringLiteral()) {
+                            reqVal = actualType.value;
                         }
                         else {
-                            const typeArgs = pType.typeArguments || [];
+                            const typeArgs = actualType.typeArguments || [];
                             const items = [];
                             for (const arg of typeArgs) {
                                 if (arg.isStringLiteral()) {
@@ -695,13 +716,8 @@ function buildJsonSchemaInternal(type, checker, defs, visited, counts, circularH
                 const pName = prop.getName();
                 if (pName.startsWith('__')) {
                     const pType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations?.[0]);
-                    let val = pType.value;
-                    if (val === undefined && (pType.getFlags() & ts.TypeFlags.BooleanLiteral)) {
-                        val = pType.intrinsicName === 'true';
-                    }
-                    if (val === undefined && (pType.getFlags() & ts.TypeFlags.Null)) {
-                        val = null;
-                    }
+                    const actualType = stripUndefinedFromType(pType);
+                    const val = getTagPropertyValue(pType);
                     if (pName === '__default') {
                         constraints.default = val;
                     }
@@ -743,11 +759,11 @@ function buildJsonSchemaInternal(type, checker, defs, visited, counts, circularH
                     }
                     else if (pName === '__requires') {
                         let reqVal;
-                        if (pType.isStringLiteral()) {
-                            reqVal = pType.value;
+                        if (actualType.isStringLiteral()) {
+                            reqVal = actualType.value;
                         }
                         else {
-                            const typeArgs = pType.typeArguments || [];
+                            const typeArgs = actualType.typeArguments || [];
                             const items = [];
                             for (const arg of typeArgs) {
                                 if (arg.isStringLiteral()) {

package/dist/engine/staticAsserts.d.ts

@@ -0,0 +1,34 @@
+import ts from 'typescript';
+export interface IStaticConstraint {
+    type: string;
+    value: any;
+    message?: string;
+}
+/**
+ * Extract Minimum / Length / Items-style constraints from a (possibly intersected) type.
+ */
+export declare function extractStaticConstraints(type: ts.Type, checker: ts.TypeChecker): IStaticConstraint[];
+type ConstantValue = {
+    kind: 'number';
+    value: number | bigint;
+} | {
+    kind: 'string';
+    value: string;
+} | {
+    kind: 'array';
+    value: any[];
+};
+/**
+ * Resolve a compile-time constant from an expression, or undefined if not constant.
+ */
+export declare function tryGetConstantValue(expr: ts.Expression): ConstantValue | undefined;
+export declare function evaluateStaticConstraints(constant: ConstantValue, constraints: IStaticConstraint[]): string[];
+/**
+ * Walk a source file and emit diagnostics for constant values that violate tag constraints.
+ */
+export declare function collectStaticConstraintDiagnostics(sourceFile: ts.SourceFile, checker: ts.TypeChecker): ts.Diagnostic[];
+/**
+ * Analyze the program and patch getSemanticDiagnostics so constant constraint violations appear in tsc/IDE.
+ */
+export declare function installStaticConstraintDiagnostics(program: ts.Program): ts.Diagnostic[];
+export {};

package/dist/engine/staticAsserts.js

@@ -0,0 +1,317 @@
+import ts from 'typescript';
+const CONSTRAINT_KEYS = {
+    __minLength: 'minLength',
+    __maxLength: 'maxLength',
+    __minimum: 'minimum',
+    __maximum: 'maximum',
+    __exclusiveMinimum: 'exclusiveMinimum',
+    __exclusiveMaximum: 'exclusiveMaximum',
+    __multipleOf: 'multipleOf',
+    __minItems: 'minItems',
+    __maxItems: 'maxItems',
+    __uniqueItems: 'uniqueItems'
+};
+function stripUndefined(type) {
+    if (!type.isUnion()) {
+        return type;
+    }
+    const nonUndefined = type.types.filter(t => !(t.getFlags() & ts.TypeFlags.Undefined));
+    if (nonUndefined.length === 1) {
+        return nonUndefined[0];
+    }
+    return type;
+}
+function getLiteralValue(type) {
+    const actual = stripUndefined(type);
+    if (actual.value !== undefined) {
+        return actual.value;
+    }
+    if (actual.getFlags() & ts.TypeFlags.BooleanLiteral) {
+        return actual.intrinsicName === 'true';
+    }
+    return undefined;
+}
+function getStringLiteralValue(type) {
+    const actual = stripUndefined(type);
+    if (actual.isStringLiteral()) {
+        return actual.value;
+    }
+    if (actual.isUnion()) {
+        const literal = actual.types.find(t => t.isStringLiteral());
+        if (literal && literal.isStringLiteral()) {
+            return literal.value;
+        }
+    }
+    return undefined;
+}
+function getSymbolType(checker, symbol) {
+    const decl = symbol.valueDeclaration || symbol.declarations?.[0];
+    if (!decl) {
+        return undefined;
+    }
+    return checker.getTypeOfSymbolAtLocation(symbol, decl);
+}
+/**
+ * Extract Minimum / Length / Items-style constraints from a (possibly intersected) type.
+ */
+export function extractStaticConstraints(type, checker) {
+    const constraints = [];
+    const types = type.isIntersection() ? type.types : [type];
+    for (const sub of types) {
+        const props = checker.getPropertiesOfType(sub);
+        for (const prop of props) {
+            const pName = prop.getName();
+            const mapped = CONSTRAINT_KEYS[pName];
+            if (!mapped) {
+                continue;
+            }
+            const pType = getSymbolType(checker, prop);
+            if (!pType) {
+                continue;
+            }
+            let val = getLiteralValue(pType);
+            if (mapped === 'uniqueItems') {
+                val = true;
+            }
+            if (val === undefined) {
+                continue;
+            }
+            const msgProp = props.find(p => p.getName() === `${pName}_message`);
+            let message;
+            if (msgProp) {
+                const msgType = getSymbolType(checker, msgProp);
+                if (msgType) {
+                    message = getStringLiteralValue(msgType);
+                }
+            }
+            constraints.push({ type: mapped, value: val, message });
+        }
+    }
+    return constraints;
+}
+function unwrapExpression(expr) {
+    while (ts.isParenthesizedExpression(expr) ||
+        ts.isAsExpression(expr) ||
+        ts.isTypeAssertionExpression(expr) ||
+        ts.isSatisfiesExpression(expr)) {
+        expr = expr.expression;
+    }
+    return expr;
+}
+/**
+ * Resolve a compile-time constant from an expression, or undefined if not constant.
+ */
+export function tryGetConstantValue(expr) {
+    expr = unwrapExpression(expr);
+    if (ts.isNumericLiteral(expr)) {
+        return { kind: 'number', value: Number(expr.text) };
+    }
+    if (ts.isBigIntLiteral(expr)) {
+        return { kind: 'number', value: BigInt(expr.text.slice(0, -1)) };
+    }
+    if (ts.isPrefixUnaryExpression(expr) && expr.operator === ts.SyntaxKind.MinusToken) {
+        const inner = tryGetConstantValue(expr.operand);
+        if (inner?.kind === 'number') {
+            if (typeof inner.value === 'bigint') {
+                return { kind: 'number', value: -inner.value };
+            }
+            return { kind: 'number', value: -inner.value };
+        }
+    }
+    if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
+        return { kind: 'string', value: expr.text };
+    }
+    if (ts.isArrayLiteralExpression(expr)) {
+        const items = [];
+        for (const el of expr.elements) {
+            if (ts.isSpreadElement(el)) {
+                return undefined;
+            }
+            const c = tryGetConstantValue(el);
+            if (!c) {
+                return undefined;
+            }
+            if (c.kind === 'array') {
+                items.push(c.value);
+            }
+            else {
+                items.push(c.value);
+            }
+        }
+        return { kind: 'array', value: items };
+    }
+    return undefined;
+}
+export function evaluateStaticConstraints(constant, constraints) {
+    const errors = [];
+    for (const c of constraints) {
+        if (c.type === 'minimum' && constant.kind === 'number') {
+            if (constant.value < c.value) {
+                errors.push(c.message || `Value ${String(constant.value)} does not satisfy Minimum<${c.value}>`);
+            }
+        }
+        else if (c.type === 'maximum' && constant.kind === 'number') {
+            if (constant.value > c.value) {
+                errors.push(c.message || `Value ${String(constant.value)} does not satisfy Maximum<${c.value}>`);
+            }
+        }
+        else if (c.type === 'exclusiveMinimum' && constant.kind === 'number') {
+            if (constant.value <= c.value) {
+                errors.push(c.message || `Value ${String(constant.value)} does not satisfy ExclusiveMinimum<${c.value}>`);
+            }
+        }
+        else if (c.type === 'exclusiveMaximum' && constant.kind === 'number') {
+            if (constant.value >= c.value) {
+                errors.push(c.message || `Value ${String(constant.value)} does not satisfy ExclusiveMaximum<${c.value}>`);
+            }
+        }
+        else if (c.type === 'multipleOf' && constant.kind === 'number') {
+            const v = constant.value;
+            const n = c.value;
+            let ok = true;
+            if (typeof v === 'bigint' || typeof n === 'bigint') {
+                ok = BigInt(v) % BigInt(n) === 0n;
+            }
+            else {
+                ok = v % n === 0;
+            }
+            if (!ok) {
+                errors.push(c.message || `Value ${String(v)} does not satisfy MultipleOf<${n}>`);
+            }
+        }
+        else if (c.type === 'minLength' && constant.kind === 'string') {
+            if (constant.value.length < c.value) {
+                errors.push(c.message || `Value length ${constant.value.length} does not satisfy MinLength<${c.value}>`);
+            }
+        }
+        else if (c.type === 'maxLength' && constant.kind === 'string') {
+            if (constant.value.length > c.value) {
+                errors.push(c.message || `Value length ${constant.value.length} does not satisfy MaxLength<${c.value}>`);
+            }
+        }
+        else if (c.type === 'minItems' && constant.kind === 'array') {
+            if (constant.value.length < c.value) {
+                errors.push(c.message || `Array length ${constant.value.length} does not satisfy MinItems<${c.value}>`);
+            }
+        }
+        else if (c.type === 'maxItems' && constant.kind === 'array') {
+            if (constant.value.length > c.value) {
+                errors.push(c.message || `Array length ${constant.value.length} does not satisfy MaxItems<${c.value}>`);
+            }
+        }
+        else if (c.type === 'uniqueItems' && constant.kind === 'array') {
+            const seen = new Set();
+            for (const item of constant.value) {
+                const key = typeof item === 'object' && item !== null ? JSON.stringify(item) : item;
+                if (seen.has(key)) {
+                    errors.push(c.message || 'Array does not satisfy UniqueItems');
+                    break;
+                }
+                seen.add(key);
+            }
+        }
+    }
+    return errors;
+}
+function createDiagnostic(node, message) {
+    const start = node.getStart();
+    const length = node.getWidth();
+    return {
+        file: node.getSourceFile(),
+        start,
+        length,
+        messageText: message,
+        category: ts.DiagnosticCategory.Error,
+        code: 90001,
+        source: 'webergency-typechecker'
+    };
+}
+function checkExpressionAgainstType(expr, type, checker, diagnostics) {
+    const constraints = extractStaticConstraints(type, checker);
+    if (constraints.length === 0) {
+        // Still recurse into object literals for nested tagged properties
+        if (ts.isObjectLiteralExpression(unwrapExpression(expr))) {
+            checkObjectLiteral(unwrapExpression(expr), type, checker, diagnostics);
+        }
+        return;
+    }
+    const constant = tryGetConstantValue(expr);
+    if (!constant) {
+        if (ts.isObjectLiteralExpression(unwrapExpression(expr))) {
+            checkObjectLiteral(unwrapExpression(expr), type, checker, diagnostics);
+        }
+        return;
+    }
+    for (const msg of evaluateStaticConstraints(constant, constraints)) {
+        diagnostics.push(createDiagnostic(expr, msg));
+    }
+}
+function checkObjectLiteral(obj, type, checker, diagnostics) {
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop)) {
+            continue;
+        }
+        const name = prop.name;
+        if (!ts.isIdentifier(name) && !ts.isStringLiteral(name)) {
+            continue;
+        }
+        const propName = name.text;
+        const symbol = checker.getPropertyOfType(type, propName);
+        if (!symbol) {
+            continue;
+        }
+        const propType = getSymbolType(checker, symbol);
+        if (!propType) {
+            continue;
+        }
+        checkExpressionAgainstType(prop.initializer, propType, checker, diagnostics);
+    }
+}
+/**
+ * Walk a source file and emit diagnostics for constant values that violate tag constraints.
+ */
+export function collectStaticConstraintDiagnostics(sourceFile, checker) {
+    const diagnostics = [];
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) && node.type && node.initializer) {
+            const type = checker.getTypeFromTypeNode(node.type);
+            checkExpressionAgainstType(node.initializer, type, checker, diagnostics);
+        }
+        else if (ts.isPropertyDeclaration(node) && node.type && node.initializer) {
+            const type = checker.getTypeFromTypeNode(node.type);
+            checkExpressionAgainstType(node.initializer, type, checker, diagnostics);
+        }
+        else if (ts.isParameter(node) && node.type && node.initializer) {
+            const type = checker.getTypeFromTypeNode(node.type);
+            checkExpressionAgainstType(node.initializer, type, checker, diagnostics);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return diagnostics;
+}
+/**
+ * Analyze the program and patch getSemanticDiagnostics so constant constraint violations appear in tsc/IDE.
+ */
+export function installStaticConstraintDiagnostics(program) {
+    const checker = program.getTypeChecker();
+    const collected = [];
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile) {
+            continue;
+        }
+        if (sourceFile.fileName.includes('node_modules')) {
+            continue;
+        }
+        collected.push(...collectStaticConstraintDiagnostics(sourceFile, checker));
+    }
+    const previous = program.getSemanticDiagnostics.bind(program);
+    program.getSemanticDiagnostics = ((sourceFile, cancellationToken) => {
+        const base = previous(sourceFile, cancellationToken);
+        const extra = sourceFile
+            ? collected.filter(d => d.file === sourceFile)
+            : collected;
+        return [...base, ...extra];
+    });
+    return collected;
+}

package/dist/runtime/tags/constraint.d.ts

@@ -1,61 +1,61 @@
 export type MinLength<N extends number, Msg extends string = string> = {
-    readonly __minLength: N;
+    readonly __minLength?: N;
     readonly __minLength_message?: Msg;
 };
 export type MaxLength<N extends number, Msg extends string = string> = {
-    readonly __maxLength: N;
+    readonly __maxLength?: N;
     readonly __maxLength_message?: Msg;
 };
 export type Pattern<S extends string, Msg extends string = string> = {
-    readonly __pattern: S;
+    readonly __pattern?: S;
     readonly __pattern_message?: Msg;
 };
 export type Format<S extends 'email' | 'uuid' | 'url' | 'ipv4' | 'ipv6' | 'date' | 'date-time' | 'byte' | 'password' | 'regex' | 'hostname' | 'idn-email' | 'idn-hostname' | 'iri' | 'iri-reference' | 'uri' | 'uri-reference' | 'uri-template' | 'time' | 'duration' | 'objectId', Msg extends string = string> = {
-    readonly __format: S;
+    readonly __format?: S;
     readonly __format_message?: Msg;
 };
 export type Length<Min extends number, Max extends number> = MinLength<Min> & MaxLength<Max>;
 export type Minimum<N extends number | bigint, Msg extends string = string> = {
-    readonly __minimum: N;
+    readonly __minimum?: N;
     readonly __minimum_message?: Msg;
 };
 export type Maximum<N extends number | bigint, Msg extends string = string> = {
-    readonly __maximum: N;
+    readonly __maximum?: N;
     readonly __maximum_message?: Msg;
 };
 export type ExclusiveMinimum<N extends number | bigint, Msg extends string = string> = {
-    readonly __exclusiveMinimum: N;
+    readonly __exclusiveMinimum?: N;
     readonly __exclusiveMinimum_message?: Msg;
 };
 export type ExclusiveMaximum<N extends number | bigint, Msg extends string = string> = {
-    readonly __exclusiveMaximum: N;
+    readonly __exclusiveMaximum?: N;
     readonly __exclusiveMaximum_message?: Msg;
 };
 export type MultipleOf<N extends number | bigint, Msg extends string = string> = {
-    readonly __multipleOf: N;
+    readonly __multipleOf?: N;
     readonly __multipleOf_message?: Msg;
 };
 export type Range<Min extends number | bigint, Max extends number | bigint> = Minimum<Min> & Maximum<Max>;
 export type MinItems<N extends number, Msg extends string = string> = {
-    readonly __minItems: N;
+    readonly __minItems?: N;
     readonly __minItems_message?: Msg;
 };
 export type MaxItems<N extends number, Msg extends string = string> = {
-    readonly __maxItems: N;
+    readonly __maxItems?: N;
     readonly __maxItems_message?: Msg;
 };
 export type UniqueItems<Msg extends string = string> = {
-    readonly __uniqueItems: true;
+    readonly __uniqueItems?: true;
     readonly __uniqueItems_message?: Msg;
 };
 export type Custom<Fn extends (...args: any[]) => boolean, Msg extends string = string> = {
-    readonly __custom: Fn;
+    readonly __custom?: Fn;
     readonly __custom_message?: Msg;
 };
 export type Requires<Paths extends string | readonly string[], Msg extends string = string> = {
-    readonly __requires: Paths;
+    readonly __requires?: Paths;
     readonly __requires_message?: Msg;
 };
 export type Message<Msg extends string> = {
-    readonly __message: Msg;
+    readonly __message?: Msg;
 };

package/dist/runtime/tags/tag.d.ts

@@ -1,3 +1,3 @@
 export type Default<V extends string | number | boolean | null> = {
-    readonly __default: V;
+    readonly __default?: V;
 };

package/dist/runtime/tags/transform.d.ts

@@ -1,24 +1,24 @@
 export type LowerCase = {
-    readonly __transform_lowercase: true;
+    readonly __transform_lowercase?: true;
 };
 export type UpperCase = {
-    readonly __transform_uppercase: true;
+    readonly __transform_uppercase?: true;
 };
 export type Trim = {
-    readonly __transform_trim: true;
+    readonly __transform_trim?: true;
 };
 export type Capitalize = {
-    readonly __transform_capitalize: true;
+    readonly __transform_capitalize?: true;
 };
 export type ToNumber = {
-    readonly __transform_tonumber: true;
+    readonly __transform_tonumber?: true;
 };
 export type ToBoolean = {
-    readonly __transform_toboolean: true;
+    readonly __transform_toboolean?: true;
 };
 export type ToDate = {
-    readonly __transform_todate: true;
+    readonly __transform_todate?: true;
 };
 export type Custom<Fn extends (val: any) => any> = {
-    readonly __transform_custom: Fn;
+    readonly __transform_custom?: Fn;
 };

package/dist/runtime/tags.d.ts

@@ -42,18 +42,15 @@ type ApplyModifiers<T, EntriesList extends any[]> = EntriesList extends [[infer
  * Utility type to decorate nested properties of a type with validation/transform modifiers without retyping the structure.
  */
 export type WithModifiers<T, M> = ApplyModifiers<T, TuplifyUnion<Entries<M>>>;
+type IsAny<T> = 0 extends 1 & T ? true : false;
 /**
  * Recursively resolves object properties, removing the optional `?` modifier
  * from any properties that have a `tag.Default` applied.
  */
 export type ResolveDefaults<T> = T extends Date | symbol | string | number | boolean | bigint | null | undefined | Function ? T : T extends Array<infer U> ? Array<ResolveDefaults<U>> : T extends object ? {
-    [K in keyof T as NonNullable<T[K]> extends {
-        readonly __default: any;
-    } ? K : never]-?: ResolveDefaults<Exclude<T[K], undefined>>;
+    [K in keyof T as IsAny<T[K]> extends true ? never : '__default' extends keyof NonNullable<T[K]> ? K : never]-?: ResolveDefaults<Exclude<T[K], undefined>>;
 } & {
-    [K in keyof T as NonNullable<T[K]> extends {
-        readonly __default: any;
-    } ? never : K]: ResolveDefaults<T[K]>;
+    [K in keyof T as IsAny<T[K]> extends true ? K : '__default' extends keyof NonNullable<T[K]> ? never : K]: ResolveDefaults<T[K]>;
 } extends infer O ? {
     [K in keyof O]: O[K];
 } : never : T;

package/dist/transformer.js

@@ -2,9 +2,11 @@ import ts from './ts.js';
 import { buildValidator, generateHash, buildJsonSchema, objectToAst } from './engine/resolver.js';
 export { buildValidator, generateHash, buildJsonSchema } from './engine/resolver.js';
 import { hoistRegistrations } from './engine/hoister.js';
+import { installStaticConstraintDiagnostics } from './engine/staticAsserts.js';
 const RUNTIME_FUNCTIONS = ['is', 'assert', 'assertGuard', 'validate', 'jsonSchema'];
 export default function transformer(program) {
     const checker = program.getTypeChecker();
+    installStaticConstraintDiagnostics(program);
     return (context) => {
         return (sourceFile) => {
             const validatorCache = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webergency-utils/typechecker",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "description": "TypeScript compiler plugin for runtime validation",
   "author": "radixxko",