@mionjs/run-types 0.8.8 → 0.8.10

package/.dist/esm/src/nodes/collection/templateLiteral.d.ts

@@ -0,0 +1,16 @@
+import { TypeTemplateLiteral } from '@deepkit/type';
+import { JitFnCompiler, JitErrorsFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { JitCode } from '../../types.ts';
+import { CollectionRunType } from '../../lib/baseRunTypes.ts';
+export declare class TemplateLiteralRunType extends CollectionRunType<TypeTemplateLiteral> {
+    private _regexSource;
+    getRegexSource(): string;
+    private getRegexVar;
+    emitIsType(comp: JitFnCompiler): JitCode;
+    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
+    emitPrepareForJson(): JitCode;
+    emitRestoreFromJson(): JitCode;
+}
+export declare function buildAnchoredTemplateRegexSource(types: TypeTemplateLiteral['types']): string;
+export declare function spanToRegex(t: TypeTemplateLiteral['types'][number]): string;
+//# sourceMappingURL=templateLiteral.d.ts.map

package/.dist/esm/src/nodes/collection/templateLiteral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templateLiteral.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/collection/templateLiteral.ts"],"names":[],"mappings":"AAOA,OAAO,EAAiB,KAAK,mBAAmB,EAAmB,MAAM,eAAe,CAAC;AACzF,OAAO,KAAK,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AACnF,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,iBAAiB,EAAC,MAAM,2BAA2B,CAAC;AAS5D,qBAAa,sBAAuB,SAAQ,iBAAiB,CAAC,mBAAmB,CAAC;IAC9E,OAAO,CAAC,YAAY,CAAqB;IAGzC,cAAc,IAAI,MAAM;IAOxB,OAAO,CAAC,WAAW;IAQnB,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAIxC,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAQlD,kBAAkB,IAAI,OAAO;IAI7B,mBAAmB,IAAI,OAAO;CAGjC;AAGD,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,GAAG,MAAM,CAE5F;AAGD,wBAAgB,WAAW,CAAC,CAAC,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM,CAgB3E"}

package/.dist/esm/src/nodes/collection/templateLiteral.js

@@ -0,0 +1,73 @@
+import { ReflectionKind } from "@deepkit/type";
+import { CollectionRunType } from "../../lib/baseRunTypes.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+class TemplateLiteralRunType extends CollectionRunType {
+  _regexSource;
+  /** Builds the anchored regex source from src.types. Memoized. */
+  getRegexSource() {
+    if (this._regexSource !== void 0)
+      return this._regexSource;
+    this._regexSource = buildAnchoredTemplateRegexSource(this.src.types || []);
+    return this._regexSource;
+  }
+  /** Returns a context-bound variable name holding the RegExp; emits the const into the compiler context. */
+  getRegexVar(comp) {
+    const varName = comp.getLocalVarName("reTL", this);
+    if (!comp.hasContextItem(varName)) {
+      comp.setContextItem(varName, `const ${varName} = new RegExp(${JSON.stringify(this.getRegexSource())})`);
+    }
+    return varName;
+  }
+  emitIsType(comp) {
+    const re = this.getRegexVar(comp);
+    return { code: `(typeof ${comp.vλl} === 'string' && ${re}.test(${comp.vλl}))`, type: "E" };
+  }
+  emitTypeErrors(comp) {
+    const re = this.getRegexVar(comp);
+    return {
+      code: `if (typeof ${comp.vλl} !== 'string' || !${re}.test(${comp.vλl})) ${comp.callJitErr(this)}`,
+      type: "S"
+    };
+  }
+  /** value is already a JSON-safe string, no transform required */
+  emitPrepareForJson() {
+    return { code: void 0, type: "S" };
+  }
+  /** value is already a JSON-safe string, no transform required */
+  emitRestoreFromJson() {
+    return { code: void 0, type: "S" };
+  }
+  static __type = ["TypeTemplateLiteral", () => CollectionRunType, "_regexSource", "getRegexSource", "JitFnCompiler", "comp", "getRegexVar", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "TemplateLiteralRunType", `P"w!7"P&-J3#;P&0$P"w%2&&0';P"w%2&"w(0)P"w*2&"w(0+P"w(0,P"w(0-5"w!6"w.`];
+}
+function buildAnchoredTemplateRegexSource(types) {
+  return `^${types.map(__assignType((t) => spanToRegex(t), ["t", "", 'P"2!"/"'])).join("")}$`;
+}
+buildAnchoredTemplateRegexSource.__type = ["TypeTemplateLiteral", "types", "types", "buildAnchoredTemplateRegexSource", 'P"w!."f2#&/$'];
+function spanToRegex(t) {
+  switch (t.kind) {
+    case ReflectionKind.literal:
+      return escapeForRegex(String(t.literal));
+    case ReflectionKind.number:
+      return "-?(?:\\d+\\.?\\d*|\\.\\d+)";
+    case ReflectionKind.string:
+    case ReflectionKind.any:
+    case ReflectionKind.infer:
+      return "[\\s\\S]*";
+    default:
+      throw new Error(`Unsupported template literal span kind: ${t.kind}`);
+  }
+}
+spanToRegex.__type = ["TypeTemplateLiteral", "types", "t", "spanToRegex", `P"w!."f'f2#&/$`];
+function escapeForRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+escapeForRegex.__type = ["s", "escapeForRegex", 'P&2!&/"'];
+export {
+  TemplateLiteralRunType,
+  buildAnchoredTemplateRegexSource,
+  spanToRegex
+};
+//# sourceMappingURL=templateLiteral.js.map

package/.dist/esm/src/nodes/collection/templateLiteral.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templateLiteral.js","sources":["../../../../../src/nodes/collection/templateLiteral.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {ReflectionKind, type TypeTemplateLiteral, type TypeLiteral} from '@deepkit/type';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {JitCode} from '../../types.ts';\nimport {CollectionRunType} from '../../lib/baseRunTypes.ts';\n\n/**\n * RunType for TypeScript template literal types, ie: `type T = \\`api/user/${number}\\``.\n * The runtime value is a string. Validation is done by compiling the template literal type\n * to a single anchored regex at JIT-build time and then calling `regex.test(v)` at runtime.\n * Mocking walks the children directly (literal => verbatim, string/any => mockString, number => mockNumber)\n * and concatenates the spans, which guarantees the result satisfies the validation regex.\n */\nexport class TemplateLiteralRunType extends CollectionRunType<TypeTemplateLiteral> {\n    private _regexSource: string | undefined;\n\n    /** Builds the anchored regex source from src.types. Memoized. */\n    getRegexSource(): string {\n        if (this._regexSource !== undefined) return this._regexSource;\n        this._regexSource = buildAnchoredTemplateRegexSource(this.src.types || []);\n        return this._regexSource;\n    }\n\n    /** Returns a context-bound variable name holding the RegExp; emits the const into the compiler context. */\n    private getRegexVar(comp: JitFnCompiler): string {\n        const varName = comp.getLocalVarName('reTL', this);\n        if (!comp.hasContextItem(varName)) {\n            comp.setContextItem(varName, `const ${varName} = new RegExp(${JSON.stringify(this.getRegexSource())})`);\n        }\n        return varName;\n    }\n\n    emitIsType(comp: JitFnCompiler): JitCode {\n        const re = this.getRegexVar(comp);\n        return {code: `(typeof ${comp.vλl} === 'string' && ${re}.test(${comp.vλl}))`, type: 'E'};\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        const re = this.getRegexVar(comp);\n        return {\n            code: `if (typeof ${comp.vλl} !== 'string' || !${re}.test(${comp.vλl})) ${comp.callJitErr(this)}`,\n            type: 'S',\n        };\n    }\n    /** value is already a JSON-safe string, no transform required */\n    emitPrepareForJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n    /** value is already a JSON-safe string, no transform required */\n    emitRestoreFromJson(): JitCode {\n        return {code: undefined, type: 'S'};\n    }\n}\n\n/** Build the full ^...$ regex source for a template literal type's spans */\nexport function buildAnchoredTemplateRegexSource(types: TypeTemplateLiteral['types']): string {\n    return `^${types.map((t) => spanToRegex(t)).join('')}$`;\n}\n\n/** Translate a single template-literal span (TypeString | TypeAny | TypeNumber | TypeLiteral | TypeInfer) into regex source */\nexport function spanToRegex(t: TypeTemplateLiteral['types'][number]): string {\n    switch (t.kind) {\n        case ReflectionKind.literal:\n            return escapeForRegex(String((t as TypeLiteral).literal));\n        case ReflectionKind.number:\n            // matches signed integers and floats (including leading dot like '.5'), mirroring TS's `${number}` semantics\n            return '-?(?:\\\\d+\\\\.?\\\\d*|\\\\.\\\\d+)';\n        case ReflectionKind.string:\n        case ReflectionKind.any:\n        case ReflectionKind.infer:\n            // `${string}` accepts the empty string, so use * not +\n            return '[\\\\s\\\\S]*';\n        default:\n            // unreachable per deepkit's TypeTemplateLiteral.types definition\n            throw new Error(`Unsupported template literal span kind: ${(t as {kind: number}).kind}`);\n    }\n}\n\n/** Escape regex metacharacters so a literal substring is matched verbatim */\nfunction escapeForRegex(s: string): string {\n    return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n"],"names":[],"mappings":";;;;;;AAmBM,MAAO,+BAA+B,kBAAsC;AAAA,EACtE;AAAA;AAAA,EAGR,iBAAc;AACV,QAAI,KAAK,iBAAiB;AAAW,aAAO,KAAK;AACjD,SAAK,eAAe,iCAAiC,KAAK,IAAI,SAAS,EAAE;AACzE,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA,EAGQ,YAAY,MAAmB;AACnC,UAAM,UAAU,KAAK,gBAAgB,QAAQ,IAAI;AACjD,QAAI,CAAC,KAAK,eAAe,OAAO,GAAG;AAC/B,WAAK,eAAe,SAAS,SAAS,OAAO,iBAAiB,KAAK,UAAU,KAAK,eAAA,CAAgB,CAAC,GAAG;AAAA,IAC1G;AACA,WAAO;AAAA,EACX;AAAA,EAEA,WAAW,MAAmB;AAC1B,UAAM,KAAK,KAAK,YAAY,IAAI;AAChC,WAAO,EAAC,MAAM,WAAW,KAAK,GAAG,oBAAoB,EAAE,SAAS,KAAK,GAAG,MAAM,MAAM,IAAA;AAAA,EACxF;AAAA,EACA,eAAe,MAAyB;AACpC,UAAM,KAAK,KAAK,YAAY,IAAI;AAChC,WAAO;AAAA,MACH,MAAM,cAAc,KAAK,GAAG,qBAAqB,EAAE,SAAS,KAAK,GAAG,MAAM,KAAK,WAAW,IAAI,CAAC;AAAA,MAC/F,MAAM;AAAA,IAAA;AAAA,EAEd;AAAA;AAAA,EAEA,qBAAkB;AACd,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA;AAAA,EAEA,sBAAmB;AACf,WAAO,EAAC,MAAM,QAAW,MAAM,IAAA;AAAA,EACnC;AAAA;;AAIE,SAAU,iCAAiC,OAAmC;AAChF,SAAO,IAAI,MAAM,iBAAI,CAAC,MAAM,YAAY,CAAC,GAAC,CAAA,KAAA,IAAA,SAAA,CAAA,CAAA,EAAE,KAAK,EAAE,CAAC;AACxD;;AAGM,SAAU,YAAY,GAAuC;AAC/D,UAAQ,EAAE,MAAA;AAAA,IACN,KAAK,eAAe;AAChB,aAAO,eAAe,OAAQ,EAAkB,OAAO,CAAC;AAAA,IAC5D,KAAK,eAAe;AAEhB,aAAO;AAAA,IACX,KAAK,eAAe;AAAA,IACpB,KAAK,eAAe;AAAA,IACpB,KAAK,eAAe;AAEhB,aAAO;AAAA,IACX;AAEI,YAAM,IAAI,MAAM,2CAA4C,EAAqB,IAAI,EAAE;AAAA,EAAA;AAEnG;;AAGA,SAAS,eAAe,GAAS;AAC7B,SAAO,EAAE,QAAQ,uBAAuB,MAAM;AAClD;;"}

package/.dist/esm/src/nodes/member/indexProperty.d.ts

@@ -8,6 +8,7 @@ export declare class IndexSignatureRunType extends MemberRunType<TypeIndexSignat
     getChildLiteral(comp: JitFnCompiler): string;
     useArrayAccessor(): true;
     skipJit(comp: JitFnCompiler): boolean;
+    private getKeyPatternVar;
     emitIsType(comp: JitFnCompiler): JitCode;
     emitTypeErrors(comp: JitErrorsFnCompiler): JitCode;
     emitPrepareForJson(comp: JitFnCompiler): JitCode;

package/.dist/esm/src/nodes/member/indexProperty.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"indexProperty.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/member/indexProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,kBAAkB,EAAC,MAAM,eAAe,CAAC;AACjE,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAC,KAAK,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAE5C,OAAO,KAAK,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AAWnF,qBAAa,qBAAsB,SAAQ,aAAa,CAAC,kBAAkB,CAAC;IACxE,UAAU,IAAI,OAAO;IAGrB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM;IAG5C,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM;IAG5C,gBAAgB,IAAI,IAAI;IAGxB,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IASrC,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IASxC,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAMlD,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAWhD,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAWjD,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAahD,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAMxD,oBAAoB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAMlD,0BAA0B,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAMxD,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO;IAWzE,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;CAQzD"}
+{"version":3,"file":"indexProperty.d.ts","sourceRoot":"","sources":["../../../../../src/nodes/member/indexProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,kBAAkB,EAA2B,MAAM,eAAe,CAAC;AAChG,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAC,KAAK,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAE5C,OAAO,KAAK,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AAYnF,qBAAa,qBAAsB,SAAQ,aAAa,CAAC,kBAAkB,CAAC;IACxE,UAAU,IAAI,OAAO;IAGrB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM;IAG5C,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM;IAG5C,gBAAgB,IAAI,IAAI;IAGxB,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IASrC,OAAO,CAAC,gBAAgB;IAYxB,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAcxC,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAYlD,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAahD,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAajD,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAmBhD,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAWxD,oBAAoB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAWlD,0BAA0B,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAWxD,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO;IAWzE,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;CAQzD"}

package/.dist/esm/src/nodes/member/indexProperty.js

@@ -1,7 +1,8 @@
-import { ReflectionKind, __ΩTypeIndexSignature as ___TypeIndexSignature } from "@deepkit/type";
+import { ReflectionKind } from "@deepkit/type";
 import { MemberRunType } from "../../lib/baseRunTypes.js";
 import { JitFunctions } from "../../constants.functions.js";
 import { childIsExpression } from "../../lib/utils.js";
+import { buildAnchoredTemplateRegexSource } from "../collection/templateLiteral.js";
 function __assignType(fn, args) {
   fn.__type = args;
   return fn;
@@ -26,23 +27,44 @@ class IndexSignatureRunType extends MemberRunType {
     }
     return false;
   }
+  /** if the index key is a template literal type, return the JIT context var holding the compiled key-pattern regex */
+  getKeyPatternVar(comp) {
+    const idx = this.src.index;
+    if (idx?.kind !== ReflectionKind.templateLiteral)
+      return void 0;
+    const varName = comp.getLocalVarName("reIdx", this);
+    if (!comp.hasContextItem(varName)) {
+      const src = buildAnchoredTemplateRegexSource(idx.types || []);
+      comp.setContextItem(varName, `const ${varName} = new RegExp(${JSON.stringify(src)})`);
+    }
+    return varName;
+  }
   // #### jit code ####
   emitIsType(comp) {
     const child = this.getJitChild(comp);
     const childJit = comp.compileIsType(child, "E");
-    if (!childJit?.code)
+    const prop = this.getChildVarName(comp);
+    const reVar = this.getKeyPatternVar(comp);
+    const skipCode = this.getSkipCode(comp, prop);
+    const keyCheck = reVar ? `if (!${reVar}.test(${prop})) return false;` : "";
+    if (!childJit?.code && !keyCheck)
       return { code: void 0, type: "E" };
+    const valueCheck = childJit?.code ? `if (!(${childJit.code})) return false;` : "";
     return {
-      code: `for (const ${this.getChildVarName(comp)} in ${comp.vλl}){if (!(${childJit.code})) return false;} return true;`,
+      code: `for (const ${prop} in ${comp.vλl}){${skipCode} ${keyCheck} ${valueCheck}} return true;`,
       type: "RB"
     };
   }
   emitTypeErrors(comp) {
     const child = this.getJitChild(comp);
     const childJit = comp.compileTypeErrors(child, "S");
-    if (!childJit?.code)
+    const prop = this.getChildVarName(comp);
+    const reVar = this.getKeyPatternVar(comp);
+    const skipCode = this.getSkipCode(comp, prop);
+    const keyErr = reVar ? `if (!${reVar}.test(${prop})) {${comp.callJitErrWithPath(this, prop)}; continue;}` : "";
+    if (!childJit?.code && !keyErr)
       return { code: void 0, type: "S" };
-    return { code: `for (const ${this.getChildVarName(comp)} in ${comp.vλl}) {${childJit.code}}`, type: "S" };
+    return { code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${keyErr} ${childJit?.code || ""}}`, type: "S" };
   }
   emitPrepareForJson(comp) {
     const child = this.getJitChild(comp);
@@ -52,9 +74,11 @@ class IndexSignatureRunType extends MemberRunType {
     const varName = comp.vλl;
     const prop = this.getChildVarName(comp);
     const skipCode = this.getSkipCode(comp, prop);
+    const reVar = this.getKeyPatternVar(comp);
+    const patternSkip = reVar ? `if (!${reVar}.test(${prop})) continue;` : "";
     const isExpression = childIsExpression(childJit, child);
     const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || "";
-    return { code: `for (const ${prop} in ${varName}){${skipCode} ${code}}`, type: "S" };
+    return { code: `for (const ${prop} in ${varName}){${skipCode} ${patternSkip} ${code}}`, type: "S" };
   }
   emitRestoreFromJson(comp) {
     const child = this.getJitChild(comp);
@@ -64,45 +88,68 @@ class IndexSignatureRunType extends MemberRunType {
     const varName = comp.vλl;
     const prop = this.getChildVarName(comp);
     const skipCode = this.getSkipCode(comp, prop);
+    const reVar = this.getKeyPatternVar(comp);
+    const patternSkip = reVar ? `if (!${reVar}.test(${prop})) continue;` : "";
     const isExpression = childIsExpression(childJit, child);
     const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || "";
-    return { code: `for (const ${prop} in ${varName}){${skipCode} ${code}}`, type: "S" };
+    return { code: `for (const ${prop} in ${varName}){${skipCode} ${patternSkip} ${code}}`, type: "S" };
   }
   emitHasUnknownKeys(comp) {
-    if (this.getMemberType().getFamily() === "A")
-      return { code: void 0, type: "E" };
+    const reVar = this.getKeyPatternVar(comp);
     const child = this.getJitChild(comp);
     const childJit = comp.compileHasUnknownKeys(child, "E");
-    if (!childJit?.code)
-      return { code: "", type: "E" };
+    if (this.getMemberType().getFamily() === "A" && !reVar)
+      return { code: void 0, type: "E" };
     const varName = comp.vλl;
     const prop = this.getChildVarName(comp);
-    const resultVal = comp.getLocalVarName("res", this);
+    const skipCode = this.getSkipCode(comp, prop);
+    const patternCheck = reVar ? `if (!${reVar}.test(${prop})) return true;` : "";
+    const childCheck = childJit?.code ? `const ${comp.getLocalVarName("res", this)} = ${childJit.code};if (${comp.getLocalVarName("res", this)}) return true;` : "";
+    if (!patternCheck && !childCheck)
+      return { code: "", type: "E" };
     return {
-      code: `for (const ${prop} in ${varName}) {const ${resultVal} = ${childJit.code};if (${resultVal}) return true;}return false;`,
+      code: `for (const ${prop} in ${varName}) {${skipCode} ${patternCheck} ${childCheck}}return false;`,
       type: "RB"
     };
   }
   emitUnknownKeyErrors(comp) {
-    if (this.getMemberType().getFamily() === "A")
-      return { code: void 0, type: "S" };
+    const reVar = this.getKeyPatternVar(comp);
     const child = this.getJitChild(comp);
     const childJit = comp.compileUnknownKeyErrors(child, "S");
-    return this.traverseCode(comp, childJit);
+    if (this.getMemberType().getFamily() === "A" && !reVar)
+      return { code: void 0, type: "S" };
+    const prop = this.getChildVarName(comp);
+    const skipCode = this.getSkipCode(comp, prop);
+    const patternErr = reVar ? `if (!${reVar}.test(${prop})) {${comp.callJitErrWithPath("never", prop)}; continue;}` : "";
+    if (!patternErr && !childJit?.code)
+      return { code: void 0, type: "S" };
+    return { code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternErr} ${childJit?.code || ""}}`, type: "S" };
   }
   emitStripUnknownKeys(comp) {
-    if (this.getMemberType().getFamily() === "A")
-      return { code: void 0, type: "S" };
+    const reVar = this.getKeyPatternVar(comp);
     const child = this.getJitChild(comp);
     const childJit = comp.compileStripUnknownKeys(child, "S");
-    return this.traverseCode(comp, childJit);
+    if (this.getMemberType().getFamily() === "A" && !reVar)
+      return { code: void 0, type: "S" };
+    const prop = this.getChildVarName(comp);
+    const skipCode = this.getSkipCode(comp, prop);
+    const patternStrip = reVar ? `if (!${reVar}.test(${prop})) {delete ${comp.vλl}[${prop}]; continue;}` : "";
+    if (!patternStrip && !childJit?.code)
+      return { code: void 0, type: "S" };
+    return { code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternStrip} ${childJit?.code || ""}}`, type: "S" };
   }
   emitUnknownKeysToUndefined(comp) {
-    if (this.getMemberType().getFamily() === "A")
-      return { code: void 0, type: "S" };
+    const reVar = this.getKeyPatternVar(comp);
     const child = this.getJitChild(comp);
     const childJit = comp.compileUnknownKeysToUndefined(child, "S");
-    return this.traverseCode(comp, childJit);
+    if (this.getMemberType().getFamily() === "A" && !reVar)
+      return { code: void 0, type: "S" };
+    const prop = this.getChildVarName(comp);
+    const skipCode = this.getSkipCode(comp, prop);
+    const patternUndef = reVar ? `if (!${reVar}.test(${prop})) {${comp.vλl}[${prop}] = undefined; continue;}` : "";
+    if (!patternUndef && !childJit?.code)
+      return { code: void 0, type: "S" };
+    return { code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternUndef} ${childJit?.code || ""}}`, type: "S" };
   }
   traverseCode(comp, childJit) {
     if (!childJit?.code)
@@ -122,7 +169,7 @@ class IndexSignatureRunType extends MemberRunType {
     const skipNames = namedChildren.length ? namedChildren.map(__assignType((child) => `${child.getChildLiteral(comp)} === ${prop}`, ["child", "", 'P"2!"/"'])).join(" || ") : "";
     return namedChildren.length ? `if (${skipNames}) continue;` : "";
   }
-  static __type = [() => ___TypeIndexSignature, () => MemberRunType, "isOptional", "JitFnCompiler", "comp", "getChildVarName", "getChildLiteral", true, "useArrayAccessor", "skipJit", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "emitHasUnknownKeys", "emitUnknownKeyErrors", "emitStripUnknownKeys", "emitUnknownKeysToUndefined", "childJit", "traverseCode", "prop", "getSkipCode", () => ___TypeIndexSignature, "IndexSignatureRunType", `Pn!7"P)0#P"w$2%&0&P"w$2%&0'P.(0)P"w$2%)0*P"w$2%"w+0,P"w-2%"w+0.P"w$2%"w+0/P"w$2%"w+00P"w$2%"w+01P"w-2%"w+02P"w$2%"w+03P"w$2%"w+04P"w$2%P"w+-J25"w+06P"w$2%&27&085n96"w:`];
+  static __type = ["TypeIndexSignature", () => MemberRunType, "isOptional", "JitFnCompiler", "comp", "getChildVarName", "getChildLiteral", true, "useArrayAccessor", "skipJit", "getKeyPatternVar", "JitCode", "emitIsType", "JitErrorsFnCompiler", "emitTypeErrors", "emitPrepareForJson", "emitRestoreFromJson", "emitHasUnknownKeys", "emitUnknownKeyErrors", "emitStripUnknownKeys", "emitUnknownKeysToUndefined", "childJit", "traverseCode", "prop", "getSkipCode", "IndexSignatureRunType", `P"w!7"P)0#P"w$2%&0&P"w$2%&0'P.(0)P"w$2%)0*P"w$2%P&-J0+;P"w$2%"w,0-P"w.2%"w,0/P"w$2%"w,00P"w$2%"w,01P"w$2%"w,02P"w.2%"w,03P"w$2%"w,04P"w$2%"w,05P"w$2%P"w,-J26"w,07P"w$2%&28&095"w!6"w:`];
 }
 export {
   IndexSignatureRunType

package/.dist/esm/src/nodes/member/indexProperty.js.map

@@ -1 +1 @@
-{"version":3,"file":"indexProperty.js","sources":["../../../../../src/nodes/member/indexProperty.ts"],"sourcesContent":["import {ReflectionKind, TypeIndexSignature} from '@deepkit/type';\nimport {MemberRunType} from '../../lib/baseRunTypes.ts';\nimport {type JitCode} from '../../types.ts';\nimport {JitFunctions} from '../../constants.functions.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {InterfaceRunType} from '../collection/interface.ts';\nimport {childIsExpression} from '../../lib/utils.ts';\n\n/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nexport class IndexSignatureRunType extends MemberRunType<TypeIndexSignature> {\n    isOptional(): boolean {\n        return true;\n    }\n    getChildVarName(comp: JitFnCompiler): string {\n        return comp.getLocalVarName('p', this);\n    }\n    getChildLiteral(comp: JitFnCompiler): string {\n        return this.getChildVarName(comp);\n    }\n    useArrayAccessor(): true {\n        return true;\n    }\n    skipJit(comp: JitFnCompiler): boolean {\n        const index = (this.src as TypeIndexSignature).index?.kind;\n        if (index === ReflectionKind.symbol) {\n            return comp?.fnID !== JitFunctions.toJSCode.id;\n        }\n        return false;\n    }\n\n    // #### jit code ####\n    emitIsType(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileIsType(child, 'E');\n        if (!childJit?.code) return {code: undefined, type: 'E'};\n        return {\n            code: `for (const ${this.getChildVarName(comp)} in ${comp.vλl}){if (!(${childJit.code})) return false;} return true;`,\n            type: 'RB',\n        };\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileTypeErrors(child, 'S');\n        if (!childJit?.code) return {code: undefined, type: 'S'};\n        return {code: `for (const ${this.getChildVarName(comp)} in ${comp.vλl}) {${childJit.code}}`, type: 'S'};\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const childJit = comp.compilePrepareForJson(child, 'S');\n        if (!child || !childJit?.code) return {code: undefined, type: 'S'};\n        const varName = comp.vλl;\n        const prop = this.getChildVarName(comp);\n        const skipCode = this.getSkipCode(comp, prop);\n        const isExpression = childIsExpression(childJit, child);\n        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';\n        return {code: `for (const ${prop} in ${varName}){${skipCode} ${code}}`, type: 'S'};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileRestoreFromJson(child, 'S');\n        if (!child || !childJit?.code) return {code: undefined, type: 'S'};\n        const varName = comp.vλl;\n        const prop = this.getChildVarName(comp);\n        const skipCode = this.getSkipCode(comp, prop);\n        const isExpression = childIsExpression(childJit, child);\n        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';\n        return {code: `for (const ${prop} in ${varName}){${skipCode} ${code}}`, type: 'S'};\n    }\n    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'E'};\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileHasUnknownKeys(child, 'E');\n        if (!childJit?.code) return {code: '', type: 'E'};\n        const varName = comp.vλl;\n        const prop = this.getChildVarName(comp);\n        const resultVal = comp.getLocalVarName('res', this);\n        return {\n            code: `for (const ${prop} in ${varName}) {const ${resultVal} = ${childJit.code};if (${resultVal}) return true;}return false;`,\n            type: 'RB',\n        };\n    }\n    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {\n        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'S'};\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileUnknownKeyErrors(child, 'S');\n        return this.traverseCode(comp, childJit);\n    }\n    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'S'};\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileStripUnknownKeys(child, 'S');\n        return this.traverseCode(comp, childJit);\n    }\n    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n        if (this.getMemberType().getFamily() === 'A') return {code: undefined, type: 'S'};\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileUnknownKeysToUndefined(child, 'S');\n        return this.traverseCode(comp, childJit);\n    }\n    traverseCode(comp: JitFnCompiler, childJit: JitCode | undefined): JitCode {\n        if (!childJit?.code) return {code: undefined, type: 'S'};\n        const prop = this.getChildVarName(comp);\n        return {code: `for (const ${prop} in ${comp.vλl}) {${childJit.code}}`, type: 'S'};\n    }\n    /**\n     * if index property should be skipped then it output some code to skip it,\n     * this happen when an object/interface has an index property but also has named properties\n     * that might collide with the index property. ie {[key: string]: string, a: string}\n     * when executing the logic for the index property we need to skip the named properties.\n     */\n    getSkipCode(comp: JitFnCompiler, prop: string): string {\n        const parent = this.getParent() as InterfaceRunType;\n        const namedChildren = parent.getNamedChildren(comp);\n        const skipNames = namedChildren.length\n            ? namedChildren.map((child) => `${child.getChildLiteral(comp)} === ${prop}`).join(' || ')\n            : '';\n        return namedChildren.length ? `if (${skipNames}) continue;` : '';\n    }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"indexProperty.js","sources":["../../../../../src/nodes/member/indexProperty.ts"],"sourcesContent":["import {ReflectionKind, type TypeIndexSignature, type TypeTemplateLiteral} from '@deepkit/type';\nimport {MemberRunType} from '../../lib/baseRunTypes.ts';\nimport {type JitCode} from '../../types.ts';\nimport {JitFunctions} from '../../constants.functions.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {InterfaceRunType} from '../collection/interface.ts';\nimport {childIsExpression} from '../../lib/utils.ts';\nimport {buildAnchoredTemplateRegexSource} from '../collection/templateLiteral.ts';\n\n/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nexport class IndexSignatureRunType extends MemberRunType<TypeIndexSignature> {\n    isOptional(): boolean {\n        return true;\n    }\n    getChildVarName(comp: JitFnCompiler): string {\n        return comp.getLocalVarName('p', this);\n    }\n    getChildLiteral(comp: JitFnCompiler): string {\n        return this.getChildVarName(comp);\n    }\n    useArrayAccessor(): true {\n        return true;\n    }\n    skipJit(comp: JitFnCompiler): boolean {\n        const index = (this.src as TypeIndexSignature).index?.kind;\n        if (index === ReflectionKind.symbol) {\n            return comp?.fnID !== JitFunctions.toJSCode.id;\n        }\n        return false;\n    }\n\n    /** if the index key is a template literal type, return the JIT context var holding the compiled key-pattern regex */\n    private getKeyPatternVar(comp: JitFnCompiler): string | undefined {\n        const idx = this.src.index;\n        if (idx?.kind !== ReflectionKind.templateLiteral) return undefined;\n        const varName = comp.getLocalVarName('reIdx', this);\n        if (!comp.hasContextItem(varName)) {\n            const src = buildAnchoredTemplateRegexSource((idx as TypeTemplateLiteral).types || []);\n            comp.setContextItem(varName, `const ${varName} = new RegExp(${JSON.stringify(src)})`);\n        }\n        return varName;\n    }\n\n    // #### jit code ####\n    emitIsType(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileIsType(child, 'E');\n        const prop = this.getChildVarName(comp);\n        const reVar = this.getKeyPatternVar(comp);\n        const skipCode = this.getSkipCode(comp, prop);\n        const keyCheck = reVar ? `if (!${reVar}.test(${prop})) return false;` : '';\n        if (!childJit?.code && !keyCheck) return {code: undefined, type: 'E'};\n        const valueCheck = childJit?.code ? `if (!(${childJit.code})) return false;` : '';\n        return {\n            code: `for (const ${prop} in ${comp.vλl}){${skipCode} ${keyCheck} ${valueCheck}} return true;`,\n            type: 'RB',\n        };\n    }\n    emitTypeErrors(comp: JitErrorsFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileTypeErrors(child, 'S');\n        const prop = this.getChildVarName(comp);\n        const reVar = this.getKeyPatternVar(comp);\n        const skipCode = this.getSkipCode(comp, prop);\n        // when the key fails the template literal pattern, report it (with the offending key in the path)\n        // and skip the value check to avoid compounding errors on values whose key was already invalid\n        const keyErr = reVar ? `if (!${reVar}.test(${prop})) {${comp.callJitErrWithPath(this, prop)}; continue;}` : '';\n        if (!childJit?.code && !keyErr) return {code: undefined, type: 'S'};\n        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${keyErr} ${childJit?.code || ''}}`, type: 'S'};\n    }\n    emitPrepareForJson(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const childJit = comp.compilePrepareForJson(child, 'S');\n        if (!child || !childJit?.code) return {code: undefined, type: 'S'};\n        const varName = comp.vλl;\n        const prop = this.getChildVarName(comp);\n        const skipCode = this.getSkipCode(comp, prop);\n        const reVar = this.getKeyPatternVar(comp);\n        const patternSkip = reVar ? `if (!${reVar}.test(${prop})) continue;` : '';\n        const isExpression = childIsExpression(childJit, child);\n        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';\n        return {code: `for (const ${prop} in ${varName}){${skipCode} ${patternSkip} ${code}}`, type: 'S'};\n    }\n    emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileRestoreFromJson(child, 'S');\n        if (!child || !childJit?.code) return {code: undefined, type: 'S'};\n        const varName = comp.vλl;\n        const prop = this.getChildVarName(comp);\n        const skipCode = this.getSkipCode(comp, prop);\n        const reVar = this.getKeyPatternVar(comp);\n        const patternSkip = reVar ? `if (!${reVar}.test(${prop})) continue;` : '';\n        const isExpression = childIsExpression(childJit, child);\n        const code = isExpression ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code || '';\n        return {code: `for (const ${prop} in ${varName}){${skipCode} ${patternSkip} ${code}}`, type: 'S'};\n    }\n    emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n        const reVar = this.getKeyPatternVar(comp);\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileHasUnknownKeys(child, 'E');\n        // when the value is atomic and there's no key pattern, every key is \"known\" -> no check needed\n        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'E'};\n        const varName = comp.vλl;\n        const prop = this.getChildVarName(comp);\n        const skipCode = this.getSkipCode(comp, prop);\n        const patternCheck = reVar ? `if (!${reVar}.test(${prop})) return true;` : '';\n        const childCheck = childJit?.code\n            ? `const ${comp.getLocalVarName('res', this)} = ${childJit.code};if (${comp.getLocalVarName('res', this)}) return true;`\n            : '';\n        if (!patternCheck && !childCheck) return {code: '', type: 'E'};\n        return {\n            code: `for (const ${prop} in ${varName}) {${skipCode} ${patternCheck} ${childCheck}}return false;`,\n            type: 'RB',\n        };\n    }\n    emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {\n        const reVar = this.getKeyPatternVar(comp);\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileUnknownKeyErrors(child, 'S');\n        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'S'};\n        const prop = this.getChildVarName(comp);\n        const skipCode = this.getSkipCode(comp, prop);\n        const patternErr = reVar ? `if (!${reVar}.test(${prop})) {${comp.callJitErrWithPath('never', prop)}; continue;}` : '';\n        if (!patternErr && !childJit?.code) return {code: undefined, type: 'S'};\n        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternErr} ${childJit?.code || ''}}`, type: 'S'};\n    }\n    emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n        const reVar = this.getKeyPatternVar(comp);\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileStripUnknownKeys(child, 'S');\n        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'S'};\n        const prop = this.getChildVarName(comp);\n        const skipCode = this.getSkipCode(comp, prop);\n        const patternStrip = reVar ? `if (!${reVar}.test(${prop})) {delete ${comp.vλl}[${prop}]; continue;}` : '';\n        if (!patternStrip && !childJit?.code) return {code: undefined, type: 'S'};\n        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternStrip} ${childJit?.code || ''}}`, type: 'S'};\n    }\n    emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n        const reVar = this.getKeyPatternVar(comp);\n        const child = this.getJitChild(comp);\n        const childJit = comp.compileUnknownKeysToUndefined(child, 'S');\n        if (this.getMemberType().getFamily() === 'A' && !reVar) return {code: undefined, type: 'S'};\n        const prop = this.getChildVarName(comp);\n        const skipCode = this.getSkipCode(comp, prop);\n        const patternUndef = reVar ? `if (!${reVar}.test(${prop})) {${comp.vλl}[${prop}] = undefined; continue;}` : '';\n        if (!patternUndef && !childJit?.code) return {code: undefined, type: 'S'};\n        return {code: `for (const ${prop} in ${comp.vλl}) {${skipCode} ${patternUndef} ${childJit?.code || ''}}`, type: 'S'};\n    }\n    traverseCode(comp: JitFnCompiler, childJit: JitCode | undefined): JitCode {\n        if (!childJit?.code) return {code: undefined, type: 'S'};\n        const prop = this.getChildVarName(comp);\n        return {code: `for (const ${prop} in ${comp.vλl}) {${childJit.code}}`, type: 'S'};\n    }\n    /**\n     * if index property should be skipped then it output some code to skip it,\n     * this happen when an object/interface has an index property but also has named properties\n     * that might collide with the index property. ie {[key: string]: string, a: string}\n     * when executing the logic for the index property we need to skip the named properties.\n     */\n    getSkipCode(comp: JitFnCompiler, prop: string): string {\n        const parent = this.getParent() as InterfaceRunType;\n        const namedChildren = parent.getNamedChildren(comp);\n        const skipNames = namedChildren.length\n            ? namedChildren.map((child) => `${child.getChildLiteral(comp)} === ${prop}`).join(' || ')\n            : '';\n        return namedChildren.length ? `if (${skipNames}) continue;` : '';\n    }\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mionjs/run-types",
-  "version": "0.8.8",
+  "version": "0.8.10",
   "type": "module",
   "description": "Run time functionality directly from typescript types",
   "keywords": [
@@ -64,10 +64,10 @@
   "dependencies": {
     "@deepkit/core": "1.0.19",
     "@deepkit/type": "1.0.19",
-    "@mionjs/core": "0.8.8"
+    "@mionjs/core": "0.8.10"
   },
   "peerDependencies": {
     "typescript": ">=6.0.0"
   },
-  "gitHead": "a92a438011336a078d394b75054422f3a56f8468"
+  "gitHead": "3e2b3b633ceb0b054fc1f1aad914d779ddd6c8b0"
 }

package/src/createRunType.ts

@@ -52,6 +52,7 @@ import {FunctionRunType} from './nodes/function/function.ts';
 import {PromiseRunType} from './nodes/native/promise.ts';
 import {ObjectRunType} from './nodes/atomic/object.ts';
 import {IntersectionRunType} from './nodes/collection/intersection.ts';
+import {TemplateLiteralRunType} from './nodes/collection/templateLiteral.ts';
 import {ParameterRunType} from './nodes/member/param.ts';
 import {MethodRunType} from './nodes/member/method.ts';
 import {RestParamsRunType} from './nodes/member/restParams.ts';
@@ -197,12 +198,10 @@ function createRunType(deepkitType: Mutable<SrcType>): RunType {
             rt = new SymbolRunType();
             break;
         case ReflectionKind.templateLiteral:
-            // deepkit automatically resolves template literals unions to literals
-            // this is only called when you define the type of a template literal i.e: type T = `foo${string}`;
-            // this is not supported at the moment but would be useful for type safe urls etc
-            throw new Error(
-                'Template Literals are resolved by the compiler to Literals ie: const tl = `${string}World`. Template literal types are not supported. ie type TL = `${string}World`'
-            );
+            // deepkit resolves finite template literal unions to literal-string unions before reaching here.
+            // this branch handles the open form ie: type T = `api/user/${number}` (children: literal/string/number/any/infer)
+            rt = new TemplateLiteralRunType();
+            break;
         case ReflectionKind.undefined:
             rt = new UndefinedRunType();
             break;

package/src/jitCompilers/binary/fromBinary.ts

@@ -84,7 +84,8 @@ export function emitFromBinary(runType: BaseRunType, comp: BinaryCompiler): JitC
         case ReflectionKind.never:
             throw new Error('Never type cannot be deserialized from Binary');
         case ReflectionKind.templateLiteral:
-            throw new Error('Template literals are not supported in Binary deserialization');
+            // runtime value is a plain string
+            return {code: `${dεs}.desString()`, type: 'E'};
         case ReflectionKind.literal: {
             if (comp.opts.noLiterals) {
                 const lit = (runType as LiteralRunType).src.literal;

package/src/jitCompilers/binary/toBinary.ts

@@ -81,7 +81,8 @@ export function emitToBinary(runType: BaseRunType, comp: BinaryCompiler): JitCod
         case ReflectionKind.never:
             throw new Error('Never type cannot be serialized to Binary');
         case ReflectionKind.templateLiteral:
-            throw new Error('Template literals are not supported in Binary serialization');
+            // runtime value is a plain string
+            return {code: `${sεr}.serString(${comp.vλl})`, type: 'S'};
         case ReflectionKind.literal: {
             if (comp.opts.noLiterals) {
                 const lit = (runType as LiteralRunType).src.literal;

package/src/jitCompilers/json/stringifyJson.ts

@@ -108,7 +108,8 @@ export function createStringifyCompiler(fnID: Operation) {
             case ReflectionKind.symbol:
                 return {code: `JSON.stringify('Symbol:' + (${comp.vλl}.description || ''))`, type: 'E'};
             case ReflectionKind.templateLiteral:
-                throw new Error('Template Literals are not supported.');
+                // runtime value is a plain string
+                return {code: `JSON.stringify(${comp.vλl})`, type: 'E'};
             case ReflectionKind.undefined: {
                 const isRoot = comp.getNestLevel(runType) === 0;
                 if (isRoot) return {code: `undefined`, type: 'E'};

package/src/jitCompilers/serialization-suite.ts

@@ -1592,6 +1592,58 @@ export const SERIALIZATION_SPEC = {
             },
         },
     },
+    TEMPLATE_LITERALS: {
+        url_string: {
+            title: 'template literal as string type, ie: `api/users/${number}`',
+            getTestData: (dataOnly = false) => {
+                type GetUserUrl = `api/users/${number}`;
+                const rt = dataOnly ? (null as any) : runType<GetUserUrl>();
+                const values: GetUserUrl[] = [
+                    'api/users/0',
+                    'api/users/1',
+                    'api/users/42',
+                    'api/users/-7',
+                    'api/users/3.14',
+                    `api/users/${Number.MAX_SAFE_INTEGER}`,
+                ];
+                return {rt, values};
+            },
+        },
+        url_in_object: {
+            title: 'template literal as object property type',
+            getTestData: (dataOnly = false) => {
+                type ObjectWithTemplate = {
+                    url: `api/user/${number}`;
+                    method: string;
+                };
+                const rt = dataOnly ? (null as any) : runType<ObjectWithTemplate>();
+                const values: ObjectWithTemplate[] = [
+                    {url: 'api/user/1', method: 'GET'},
+                    {url: 'api/user/42', method: 'POST'},
+                    {url: 'api/user/-7', method: 'DELETE'},
+                ];
+                return {rt, values};
+            },
+        },
+        url_index_key: {
+            title: 'template literal as index signature key',
+            getTestData: (dataOnly = false) => {
+                type Routes = {[key: `api/${string}`]: number};
+                const rt = dataOnly ? (null as any) : runType<Routes>();
+                const values: Routes[] = [{}, {'api/users': 1, 'api/posts': 2}, {'api/v1/users': 7, 'api/admin': 0}];
+                return {rt, values};
+            },
+        },
+        url_index_key_with_named: {
+            title: 'template literal index key + sibling named property',
+            getTestData: (dataOnly = false) => {
+                type Routes = {meta: string; [key: `api/${string}`]: string | number};
+                const rt = dataOnly ? (null as any) : runType<Routes>();
+                const values: Routes[] = [{meta: 'a'}, {meta: 'b', 'api/users': 1}, {meta: 'c', 'api/users': 1, 'api/posts': 2}];
+                return {rt, values};
+            },
+        },
+    },
     OTHERS: {
         promise_jsonStringify_error: {
             title: 'throw error for Promise types',

package/src/jitCompilers/xyz-Template/fromXYZ.ts

@@ -69,7 +69,8 @@ function _compileFromXYZ(runType: BaseRunType, comp: JitXYZCompiler): JitCode {
             throw new Error('Never type cannot be deserialized from XYZ');
 
         case ReflectionKind.templateLiteral:
-            throw new Error('Template literals are not supported in XYZ deserialization');
+            // TODO: deserialize as string
+            break;
 
         case ReflectionKind.literal:
             return compileLiteral(runType as LiteralRunType, comp);

package/src/jitCompilers/xyz-Template/toXYZ.ts

@@ -74,7 +74,8 @@ export function _compileToXYZ(runType: BaseRunType, comp: JitXYZCompiler): JitCo
             throw new Error('Never type cannot be serialized to XYZ');
 
         case ReflectionKind.templateLiteral:
-            throw new Error('Template literals are not supported in XYZ serialization');
+            // TODO: serialize as string
+            break;
 
         case ReflectionKind.literal:
             return compileLiteral(runType as LiteralRunType, comp);

package/src/mocking/mockType.ts

@@ -269,6 +269,35 @@ function _mockType(runType: BaseRunType, comp: JitFnCompiler, stack: BaseRunType
                     case !!(rt.src.index.kind === ReflectionKind.symbol):
                         propName = Symbol.for(`key${i}`);
                         break;
+                    case !!(rt.src.index.kind === ReflectionKind.templateLiteral): {
+                        // walk the template literal spans to produce a key that matches the pattern.
+                        // retry a few times on collision since narrow patterns (eg `id-${number}`) can repeat.
+                        const tplTypes = ((rt.src.index as any).types as any[]) || [];
+                        const buildKey = () =>
+                            tplTypes
+                                .map((part: any) => {
+                                    switch (part.kind) {
+                                        case ReflectionKind.literal:
+                                            return String(part.literal);
+                                        case ReflectionKind.number:
+                                            return String(mockNumber(mOps.minNumber, mOps.maxNumber));
+                                        case ReflectionKind.string:
+                                        case ReflectionKind.any:
+                                        case ReflectionKind.infer:
+                                            return mockString(
+                                                mOps.stringLength || random(1, mOps.maxRandomStringLength),
+                                                mOps.stringCharSet || stringCharSet
+                                            );
+                                        default:
+                                            throw new Error(`Unsupported template literal span kind: ${part.kind}`);
+                                    }
+                                })
+                                .join('');
+                        let candidate = buildKey();
+                        for (let r = 0; r < 5 && candidate in parentObj; r++) candidate = buildKey();
+                        propName = candidate;
+                        break;
+                    }
                     default:
                         throw new Error('Invalid index signature type.');
                 }
@@ -277,8 +306,34 @@ function _mockType(runType: BaseRunType, comp: JitFnCompiler, stack: BaseRunType
             return parentObj;
         }
 
+        case ReflectionKind.templateLiteral: {
+            // walk the spans and emit a string for each: literal verbatim, string/any/infer => mockString,
+            // number => stringified mockNumber. The concatenated value is, by construction,
+            // accepted by the validation regex emitted by TemplateLiteralRunType.
+            const types = (src as any).types as any[];
+            return types
+                .map((part: any) => {
+                    switch (part.kind) {
+                        case ReflectionKind.literal:
+                            return String(part.literal);
+                        case ReflectionKind.number:
+                            return String(mockNumber(mOps.minNumber, mOps.maxNumber));
+                        case ReflectionKind.string:
+                        case ReflectionKind.any:
+                        case ReflectionKind.infer:
+                            return mockString(
+                                mOps.stringLength || random(1, mOps.maxRandomStringLength),
+                                mOps.stringCharSet || stringCharSet
+                            );
+                        default:
+                            throw new Error(
+                                `Unsupported template literal span kind: ${part.kind}` + printStackTrace(comp, stack)
+                            );
+                    }
+                })
+                .join('');
+        }
         case ReflectionKind.infer:
-        case ReflectionKind.templateLiteral:
         case ReflectionKind.typeParameter:
         default:
             throw new Error(`Cant mock Unsupported RunType: ${runType.getTypeName()}` + printStackTrace(comp, stack));