@mirascript/typed 0.1.62 → 0.1.63

package/dist/type.js.map

@@ -1 +1 @@
-{"version":3,"sources":["..\\src\\type.peggy"],"names":["Start","Type","UnionType","PostfixType","PrimaryType","RecordType","FieldList","Field","FieldName","String","Identifier","_","$initializer"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAuBgB,aAAW,G;yBAOP;AACpB;AACI,G;gCAGuD;AAC3D;AACA;AACA;AACA;AACI,G;gCAC+C;AACnD;AACA;AACA;AACA;AACI,G;iCAQmC;AACvC;AACA;AACA;AACA;AACI,G;kCAOiD;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACI,G;wBACY;AAChB;AACI,G;sBACoB;AACxB;AACI,G;qBAQW,sBAAoB,G;2BACD,0BAAwB,G;4BAGZ;AAC9C;AACI,G;kCAG0C;AAC9C;AACA;AACA;AACA;AACA;AACI,G;uBACQ;AACZ;AACA;AACA;AACI,G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAvFJA,cAAK;;;;;;;;;;;;;;;;;;WAOLC,aAAI;;;;;;;;;;;;;;WAKJC,kBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmBTC,oBAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAYXC,oBAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuBXC,mBAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIVC,kBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKTC,cAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAcLC,kBAAS;;;;;;;;;;;WAQTC,eAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAINC,mBAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGVC,UAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA9HAC;AACDA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA","file":"type.js"}
+{"version":3,"sources":["../src/type.peggy"],"names":["$top_level_initializer","Start","UnionType","PostfixType","PrimaryType","TypeParamList","TypeArgList","FunctionType","NamedFunction","FunctionBody","FunctionParamList","FunctionParam","RecordType","FieldList","Field","FieldName","HexDigit","EscapeSequence","String","DoubleQuotePart","SingleQuotePart","BacktickPart","DoubleQuoteChar","SingleQuoteChar","BacktickChar","Identifier","_","$initializer"],"mappings":";;;;;AAAEA;AACFA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAkD+C;AAC/C;AACI,G;iCAOmC;AACvC;AACA;AACA;AACA;AACI,G;kCAQuD;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACI,G;wBACY;AAChB;AACA;AACI,G;yBAoB0B,gBAAc,G;+BAGI;AAChD;AACA;AACA;AACI,G;4CAG0G;AAC9G;AACA;AACA;AACA;AACI,G;2BAGkD;AACtD;AACA;AACA;AACA;AACI,G;oCAGiD;AACrD;AACA;AACA;AACA;AACA;AACI,G;4BACoC;AACxC;AACI,G;4BAO+B,gCAA8B,G;kCAMnB;AAC9C;AACA;AACA;AACA;AACA;AACI,G;0BACW,oBAAkB,G;0BAIhB;AACjB;AACA;AACI,G;0BAU6B;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACE,G;yBAAoC;AACtC;AACA;AACA;AACA;AACE,G;yBAAiC;AACnC;AACA;AACA;AACA;AACA;AACA;AACE,G;2BAGkC,yBAAuB,G;2BACvB,yBAAuB,G;2BAC1B,yBAAuB,G;2BAI5B,mCAAiC,G;2BAIjC,mCAAiC,G;2BAIpC,mCAAiC,G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA9L1DC,cAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAWLC,kBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WASTC,oBAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAYXC,oBAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmCXC,sBAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGbC,oBAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAOXC,qBAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGZC,sBAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAObC,qBAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAQZC,0BAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAQjBC,sBAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgBbC,mBAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGVC,kBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGTC,cAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAULC,kBAAS;;;;;;;;;;;;;;;;;WAWTC,iBAAQ;;;;;;;;;;;;;;;;;;;;WAGRC,uBAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BdC,eAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKNC,wBAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIfC,wBAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIfC,qBAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIZC,wBAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIfC,wBAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIfC,qBAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIZC,mBAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAGVC,UAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AAlPAC;AACDA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA;AACAA","file":"type.js"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirascript/typed",
-  "version": "0.1.62",
+  "version": "0.1.63",
   "author": "CloudPSS",
   "license": "MIT",
   "description": "Parse MiraScript type definitions and generate TypeScript types / JSON schemas.",
@@ -23,17 +23,19 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@types/node": "^26.0.0",
+    "@types/node": "^26.0.1",
     "ava": "^8.0.1",
-    "js-yaml": "^5.1.0",
+    "c8": "^11.0.0",
+    "js-yaml": "^5.2.0",
     "peggy": "^5.1.0"
   },
   "dependencies": {
-    "@types/json-schema": "^7.0.15"
+    "@types/json-schema": "^7.0.15",
+    "@mirascript/constants": "~0.1.63"
   },
   "scripts": {
     "build": "peggy src/type.peggy --multi-output ./dist --dts --format es --source-map && tsc",
     "clean": "rimraf dist",
-    "test": "ava --no-worker-threads"
+    "test": "c8 ava --no-worker-threads"
   }
 }

package/src/json.ts

@@ -1,5 +1,6 @@
 import type { JSONSchema7 } from 'json-schema';
-import type { KnownType, LiteralType, NamedType, Type } from './parser.js';
+import { REG_NUMBER } from '@mirascript/constants';
+import type { KnownType, LiteralType, NamedType, TemplateType, Type } from './parser.js';
 
 /** Converts a KnownType or NamedType into JSON Schema */
 function string(type: KnownType | NamedType): JSONSchema7 {
@@ -29,55 +30,77 @@ function string(type: KnownType | NamedType): JSONSchema7 {
     }
 }
 
-/** Converts a Type object into JSON Schema */
-export function toJSONSchema(type: Type): JSONSchema7 {
-    if (typeof type === 'string') {
-        return string(type);
-    }
-    if (type.kind === 'array') {
-        return {
-            type: 'array',
-            items: toJSONSchema(type.element),
-        };
-    }
-    if (type.kind === 'union') {
-        const literals = type.types.filter(isLiteralType);
-        if (literals.length === type.types.length) {
-            return literalEnum(literals);
+/** Escapes a literal string for use in a regular expression */
+function escapeRegex(value: string): string {
+    return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+
+const RE_ANY = '.*?';
+const RE_NUMBER = REG_NUMBER.source;
+const RE_BOOLEAN = 'true|false';
+
+/** Converts a template interpolation part into a regex pattern fragment */
+function templatePartPattern(part: Type, grouping: boolean): string {
+    let result: string;
+    if (typeof part === 'symbol') {
+        result = RE_ANY;
+    } else if (typeof part === 'string') {
+        switch (part) {
+            case 'number':
+                result = RE_NUMBER;
+                break;
+            case 'boolean':
+                result = RE_BOOLEAN;
+                break;
+            case 'nil':
+            case 'never':
+                result = '';
+                break;
+            case 'array':
+            case 'record':
+            case 'extern':
+            case 'any':
+            case 'unknown':
+            case 'string':
+            default:
+                result = RE_ANY;
+                break;
         }
-        return {
-            anyOf: type.types.map(toJSONSchema),
-        };
-    }
-    if (type.kind === 'record') {
-        if (type.value !== undefined) {
-            return {
-                type: 'object',
-                additionalProperties: toJSONSchema(type.value),
-            };
+    } else if (part.kind === 'literal') {
+        if (typeof part.value === 'boolean') {
+            result = String(part.value);
+        } else {
+            result = escapeRegex(part.value);
         }
-        const properties: Record<string, JSONSchema7> = {};
-        const required: string[] = [];
-        for (const field of type.fields) {
-            properties[field.name] = toJSONSchema(field.type);
-            if (!field.optional) {
-                required.push(field.name);
+    } else if (part.kind === 'union') {
+        const patterns = new Set(part.types.map((p) => templatePartPattern(p, false)));
+        if (patterns.has(RE_ANY)) {
+            result = RE_ANY;
+        } else {
+            const hasEmpty = patterns.delete('');
+            result = Array.from(patterns).join('|');
+            if (hasEmpty) {
+                result = `(${result})?`;
             }
         }
-        const schema: JSONSchema7 = {
-            type: 'object',
-            properties,
-        };
-        if (required.length > 0) {
-            schema.required = required;
-        }
-        return schema;
-    }
-    if (type.kind === 'literal') {
-        return literal(type);
+    } else {
+        result = RE_ANY;
     }
-    (type) satisfies never;
-    return {};
+    if (!grouping) return result;
+    if (result.startsWith('(')) return result;
+    return `(${result})`;
+}
+
+/** Converts a TemplateType into a JSON Schema pattern */
+function templatePattern(type: TemplateType): string {
+    return `^${type.parts
+        .map((p) => {
+            if (typeof p == 'object' && p.kind === 'literal' && typeof p.value === 'string') {
+                return templatePartPattern(p, false);
+            }
+            return templatePartPattern(p, true);
+        })
+        .join('')}$`;
 }
 
 /** Converts a LiteralType into JSON Schema */
@@ -103,3 +126,115 @@ function literalEnum(types: LiteralType[]): JSONSchema7 {
 function isLiteralType(type: Type): type is LiteralType {
     return typeof type === 'object' && type.kind === 'literal';
 }
+
+/** Options for toJSONSchema */
+export interface ToJSONSchemaOptions {
+    /** When true, object schemas allow arbitrary additional properties */
+    loose?: boolean;
+}
+
+/** Converts a Type object into JSON Schema */
+export function toJSONSchema(type: Type, options?: ToJSONSchemaOptions): JSONSchema7 {
+    const loose = options?.loose ?? false;
+    if (typeof type === 'symbol') {
+        return {};
+    }
+    if (typeof type === 'string') {
+        return string(type);
+    }
+    if (type.kind === 'array') {
+        return {
+            type: 'array',
+            items: toJSONSchema(type.element, options),
+        };
+    }
+    if (type.kind === 'union') {
+        const anyOf = [];
+        const literals = [];
+        for (const t of type.types) {
+            if (isLiteralType(t)) {
+                literals.push(t);
+            } else {
+                anyOf.push(toJSONSchema(t, options));
+            }
+        }
+        if (literals.length > 0) {
+            anyOf.push(literalEnum(literals));
+        }
+        if (anyOf.length === 1) {
+            return anyOf[0]!;
+        }
+        return { anyOf };
+    }
+    if (type.kind === 'record') {
+        if ('fields' in type) {
+            const properties: Record<string, JSONSchema7> = {};
+            const required: string[] = [];
+            for (const field of type.fields) {
+                properties[field.name] = toJSONSchema(field.type, options);
+                if (!field.optional && !loose) {
+                    required.push(field.name);
+                }
+            }
+            const schema: JSONSchema7 = {
+                type: 'object',
+                properties,
+                additionalProperties: loose,
+            };
+            if (required.length > 0) {
+                schema.required = required;
+            }
+            return schema;
+        }
+
+        const valueSchema = toJSONSchema(type.value, options);
+        if (type.key == null) {
+            return {
+                type: 'object',
+                additionalProperties: valueSchema,
+            };
+        }
+        if (typeof type.key == 'object') {
+            if (isLiteralType(type.key)) {
+                const schema: JSONSchema7 = {
+                    type: 'object',
+                    properties: { [String(type.key.value)]: valueSchema },
+                    additionalProperties: loose,
+                };
+                return schema;
+            } else if (type.key.kind === 'union' && type.key.types.every(isLiteralType)) {
+                const schema: JSONSchema7 = {
+                    type: 'object',
+                    properties: Object.fromEntries(type.key.types.map((t) => [String(t.value), valueSchema])),
+                    additionalProperties: loose,
+                };
+                return schema;
+            }
+        }
+        const pattern = templatePartPattern(type.key, false);
+        if (pattern === RE_ANY) {
+            return {
+                type: 'object',
+                additionalProperties: valueSchema,
+            };
+        }
+        const schema: JSONSchema7 = {
+            type: 'object',
+            patternProperties: { [`^${pattern}$`]: valueSchema },
+            additionalProperties: loose,
+        };
+        return schema;
+    }
+    if (type.kind === 'literal') {
+        return literal(type);
+    }
+    if (type.kind === 'function') {
+        return {};
+    }
+    if (type.kind === 'template') {
+        return { type: 'string', pattern: templatePattern(type) };
+    }
+    /* c8 ignore next 3 */
+    (type) satisfies never;
+    return {};
+}

package/src/parser.ts

@@ -1,7 +1,19 @@
 import { parse as _parse } from '../dist/type.js';
 
 /** MiraScript type */
-export type Type = KnownType | NamedType | LiteralType | ArrayType | UnionType | RecordType;
+export type Type =
+    | KnownType
+    | NamedType
+    | GenericType
+    | LiteralType
+    | TemplateType
+    | ArrayType
+    | UnionType
+    | RecordType
+    | FunctionType;
+
+/** Generic type parameter reference in MiraScript */
+export type GenericType = symbol;
 
 /** Literal type in MiraScript */
 export interface LiteralType {
@@ -11,6 +23,14 @@ export interface LiteralType {
     value: string | boolean;
 }
 
+/** Template literal type in MiraScript */
+export interface TemplateType {
+    /** Tag */
+    kind: 'template';
+    /** Interpolated parts, strings are represented as {@link LiteralType} objects, other parts are nested {@link Type} objects. */
+    parts: Type[];
+}
+
 /** Known type names in MiraScript */
 export type KnownType =
     | 'string'
@@ -44,14 +64,21 @@ export interface ArrayType {
 }
 
 /** Record type in MiraScript */
-export interface RecordType {
-    /** Tag */
-    kind: 'record';
-    /** Fields in the record */
-    fields: RecordField[];
-    /** Value type for record<T> */
-    value?: Type;
-}
+export type RecordType =
+    | {
+          /** Tag */
+          kind: 'record';
+          /** Fields in the record */
+          fields: RecordField[];
+      }
+    | {
+          /** Tag */
+          kind: 'record';
+          /** Key type for record<K, V> */
+          key?: Type;
+          /** Value type for record<T> or record<K, V> */
+          value: Type;
+      };
 
 /** Record field in MiraScript */
 export interface RecordField {
@@ -63,9 +90,87 @@ export interface RecordField {
     type: Type;
 }
 
+/** Function type in MiraScript */
+export interface FunctionType {
+    /** Tag */
+    kind: 'function';
+    /** Function name (only allowed at the top level) */
+    name?: string;
+    /** Generic type parameters */
+    typeParams?: GenericType[];
+    /** Function parameters */
+    params: FunctionParameter[];
+    /** Return type */
+    returns?: Type;
+}
+
+/** Function parameter in MiraScript */
+export interface FunctionParameter {
+    /** Parameter name */
+    name: string;
+    /** Parameter type */
+    type: Type;
+    /** Whether the parameter is a rest parameter */
+    spread?: boolean;
+}
+
+/**
+ * Replaces generic type parameter names in the AST with unique symbols,
+ * scoped per function declaration.
+ */
+function resolveGenerics(type: Type, scope = new Map<string, GenericType>()): Type {
+    /* c8 ignore next 3 */
+    if (typeof type == 'symbol') {
+        return type;
+    }
+    if (typeof type == 'string') {
+        return scope.get(type) ?? type;
+    }
+    if (type.kind === 'function') {
+        const newScope = new Map(scope);
+        for (const sym of type.typeParams ?? []) {
+            newScope.set(sym.description!, sym);
+        }
+        for (const param of type.params) {
+            param.type = resolveGenerics(param.type, newScope);
+        }
+        if (type.returns != null) type.returns = resolveGenerics(type.returns, newScope);
+        return type;
+    }
+    if (type.kind === 'array') {
+        type.element = resolveGenerics(type.element, scope);
+        return type;
+    }
+    if (type.kind === 'union') {
+        type.types = type.types.map((t) => resolveGenerics(t, scope));
+        return type;
+    }
+    if (type.kind === 'record') {
+        if ('fields' in type) {
+            for (const field of type.fields) {
+                field.type = resolveGenerics(field.type, scope);
+            }
+        } else {
+            if (type.key != null) type.key = resolveGenerics(type.key, scope);
+            if (type.value != null) type.value = resolveGenerics(type.value, scope);
+        }
+        return type;
+    }
+    if (type.kind === 'literal') {
+        return type;
+    }
+    if (type.kind === 'template') {
+        type.parts = type.parts.map((part) => resolveGenerics(part, scope));
+        return type;
+    }
+    /* c8 ignore next 3 */
+    (type) satisfies never;
+    return type;
+}
+
 /**
  * Parses a type string into a Type object.
  */
 export function parse(type: string): Type {
-    return _parse(type) as Type;
+    return resolveGenerics(_parse(type) as Type);
 }