@gi-tcg/gts-transpiler 0.1.1 → 0.3.0

package/dist/index.js

@@ -1,11 +1,11 @@
-// src/parse/index.ts
+// packages/transpiler/src/parse/index.ts
 import { Parser } from "acorn";
 import { tsPlugin } from "@sveltejs/acorn-typescript";
 
-// src/parse/gts_plugin.ts
+// packages/transpiler/src/parse/gts_plugin.ts
 import { tokTypes as tokTypes2 } from "acorn";
 
-// src/keywords.ts
+// packages/transpiler/src/keywords.ts
 var specialIdentifiers = [
   "break",
   "case",
@@ -64,7 +64,7 @@ var specialIdentifiers = [
   "query"
 ];
 
-// src/parse/loose_plugin.ts
+// packages/transpiler/src/parse/loose_plugin.ts
 import { tokTypes } from "acorn";
 var DUMMY_PLACEHOLDER = "✖";
 function loosePlugin() {
@@ -77,7 +77,7 @@ function loosePlugin() {
           return super.parseIdent(liberal);
         }
       };
-      _proxiedThis = new Proxy(this, {
+      #proxiedThis = new Proxy(this, {
         get: (target, prop) => {
           if (prop === "parseIdent") {
             return this._patchedParseIdent;
@@ -96,13 +96,13 @@ function loosePlugin() {
         return this.finishNode(dummy, "Identifier");
       }
       parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
-        return super.parseSubscript.call(this._proxiedThis, base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
+        return super.parseSubscript.call(this.#proxiedThis, base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
       }
     };
   };
 }
 
-// src/parse/gts_plugin.ts
+// packages/transpiler/src/parse/gts_plugin.ts
 function gtsPlugin(options = {}) {
   return function gtsPluginTransformer(Parser) {
     const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
@@ -137,13 +137,17 @@ function gtsPlugin(options = {}) {
       }
       gts_parseNamedAttributeDefinition() {
         const node = this.startNode();
+        const start = this.start;
         let name;
         if (this.type.label === "string") {
           name = this.parseExprAtom();
+          if (typeof name.value === "string" && name.value.startsWith("~")) {
+            this.raise(start, `Attribute name starts with '~' is reserved for internal use.`);
+          }
         } else if (this.type.label === "name") {
           name = this.parseIdent();
         } else {
-          this.raise(this.start, "Expected attribute name");
+          this.raise(start, "Expected attribute name");
         }
         node.name = name;
         node.body = this.gts_parseAttributeBody();
@@ -299,7 +303,7 @@ function gtsPlugin(options = {}) {
   };
 }
 
-// src/parse/comment.js
+// packages/transpiler/src/parse/comment.js
 import { walk } from "zimmerframe";
 function getCommentHandlers(source, comments, index = 0) {
   function getNextNonWhitespaceCharacter(text, startIndex) {
@@ -546,7 +550,7 @@ function getCommentHandlers(source, comments, index = 0) {
   };
 }
 
-// src/error.ts
+// packages/transpiler/src/error.ts
 class GtsTranspilerError extends Error {
   position;
   constructor(message, position) {
@@ -556,7 +560,60 @@ class GtsTranspilerError extends Error {
   }
 }
 
-// src/parse/index.ts
+// packages/transpiler/src/parse/record_call_lparen_plugin.ts
+import { tokTypes as tokTypes3 } from "acorn";
+function recordCallLParenPlugin() {
+  return function recordCallLParenPluginTransformer(parser) {
+    return class RecordCallLParenParser extends parser {
+      parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
+        let recordedLParenLoc = null;
+        if (!noCalls && this.type === tokTypes3.parenL) {
+          recordedLParenLoc = {
+            start: this.startLoc,
+            end: this.endLoc
+          };
+        }
+        const result = super.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
+        if (recordedLParenLoc && result.type === "CallExpression") {
+          result.lParenLoc = recordedLParenLoc;
+        }
+        return result;
+      }
+      _capturedLParenLocFromNew = null;
+      _patchedEat = (type) => {
+        if (type === tokTypes3.parenL) {
+          this._capturedLParenLocFromNew = {
+            start: this.startLoc,
+            end: this.endLoc
+          };
+        }
+        return this.eat(type);
+      };
+      #proxiedThis = new Proxy(this, {
+        get: (target, prop) => {
+          if (prop === "eat") {
+            return this._patchedEat;
+          }
+          const value = Reflect.get(target, prop);
+          if (typeof value === "function") {
+            return value.bind(target);
+          }
+          return value;
+        }
+      });
+      parseNew() {
+        const result = super.parseNew.apply(this.#proxiedThis);
+        if (this._capturedLParenLocFromNew && result.type === "NewExpression") {
+          result.lParenLoc = this._capturedLParenLocFromNew;
+          this._capturedLParenLocFromNew = null;
+        }
+        return result;
+      }
+    };
+  };
+}
+
+// packages/transpiler/src/parse/index.ts
 var TsParser = Parser.extend(tsPlugin());
 function parse(input, options) {
   try {
@@ -580,10 +637,9 @@ function parse(input, options) {
 }
 function parseLoose(input, options) {
   try {
-    const GtsParser = TsParser.extend(loosePlugin(), gtsPlugin({
-      ...options,
-      allowEmptyShortcutMember: true,
-      allowEmptyPositionalAttribute: true
+    const GtsParser = TsParser.extend(loosePlugin(), ...options?.recordCallLParens ? [recordCallLParenPlugin()] : [], gtsPlugin({
+      allowEmptyShortcutMember: options?.allowEmptyPositionalAttribute || true,
+      allowEmptyPositionalAttribute: options?.allowEmptyPositionalAttribute || true
     }));
     const { onComment, addComments } = getCommentHandlers(input, []);
     const ast = GtsParser.parse(input, {
@@ -607,7 +663,7 @@ function parseLoose(input, options) {
   }
 }
 
-// src/transform/erase_ts.ts
+// packages/transpiler/src/transform/erase_ts.ts
 import { walk as walk2 } from "zimmerframe";
 var empty = {
   type: "EmptyStatement"
@@ -769,14 +825,14 @@ var eraseTs = (ast) => {
   return walk2(ast, null, eraseTsVisitor);
 };
 
-// src/transform/index.ts
+// packages/transpiler/src/transform/index.ts
 import { print as print2 } from "esrap";
 import jsPrinter from "esrap/languages/ts";
 
-// src/transform/gts.ts
+// packages/transpiler/src/transform/gts.ts
 import { walk as walk3 } from "zimmerframe";
 
-// src/transform/constants.ts
+// packages/transpiler/src/transform/constants.ts
 var DEFAULT_SHORTCUT_FUNCTION_PRELUDES = [
   "cryo",
   "hydro",
@@ -789,33 +845,33 @@ var DEFAULT_SHORTCUT_FUNCTION_PRELUDES = [
 ];
 var DEFAULT_QUERY_BINDINGS = ["my", "opp"];
 
-// src/transform/gts.ts
+// packages/transpiler/src/transform/gts.ts
 var commonGtsVisitor = {
   GTSDirectFunction(node, { visit, state }) {
     return {
-      type: "ArrowFunctionExpression",
-      params: [],
-      body: {
-        type: "ObjectExpression",
-        properties: [
-          {
-            type: "Property",
-            key: { type: "Identifier", name: "name" },
-            computed: false,
-            kind: "init",
-            method: false,
-            shorthand: false,
-            value: state.ActionId,
-            loc: node.loc
-          },
-          {
-            type: "Property",
-            key: { type: "Identifier", name: "positionals" },
-            computed: false,
-            kind: "init",
-            method: false,
-            shorthand: false,
-            value: {
+      type: "ObjectExpression",
+      properties: [
+        {
+          type: "Property",
+          key: { type: "Identifier", name: "name" },
+          computed: false,
+          kind: "init",
+          method: false,
+          shorthand: false,
+          value: state.ActionLit,
+          loc: node.loc
+        },
+        {
+          type: "Property",
+          key: { type: "Identifier", name: "positionals" },
+          computed: false,
+          kind: "init",
+          method: false,
+          shorthand: false,
+          value: {
+            type: "ArrowFunctionExpression",
+            params: [],
+            body: {
               type: "ArrayExpression",
               elements: [
                 {
@@ -828,23 +884,23 @@ var commonGtsVisitor = {
                   expression: false
                 }
               ]
-            }
-          },
-          {
-            type: "Property",
-            key: { type: "Identifier", name: "named" },
-            computed: false,
-            kind: "init",
-            method: false,
-            shorthand: false,
-            value: {
-              type: "Literal",
-              value: null
-            }
+            },
+            expression: true
           }
-        ]
-      },
-      expression: true,
+        },
+        {
+          type: "Property",
+          key: { type: "Identifier", name: "named" },
+          computed: false,
+          kind: "init",
+          method: false,
+          shorthand: false,
+          value: {
+            type: "Literal",
+            value: null
+          }
+        }
+      ],
       loc: node.loc
     };
   },
@@ -904,84 +960,14 @@ var commonGtsVisitor = {
   }
 };
 var gtsVisitor = {
-  Program(node, { state, next }) {
-    node = next() ?? node;
-    const body = [...node.body];
-    if (state.externalizedBindings.length > 0) {
-      body.unshift({
-        type: "ImportDeclaration",
-        specifiers: [
-          {
-            type: "ImportDefaultSpecifier",
-            local: state.binderFnId
-          }
-        ],
-        source: {
-          type: "Literal",
-          value: `${state.providerImportSource}/binder`
-        },
-        attributes: []
-      }, ...state.externalizedBindings.flatMap((binding) => {
-        const internalDecl = {
-          type: "VariableDeclaration",
-          kind: "const",
-          declarations: [
-            {
-              type: "VariableDeclarator",
-              id: binding.internalId,
-              init: binding.value
-            }
-          ]
-        };
-        const externalDecl = {
-          type: "VariableDeclaration",
-          kind: "const",
-          declarations: [
-            {
-              type: "VariableDeclarator",
-              id: binding.bindingName,
-              init: {
-                type: "CallExpression",
-                optional: false,
-                callee: state.binderFnId,
-                arguments: [
-                  binding.internalId,
-                  {
-                    type: "ObjectExpression",
-                    properties: [
-                      {
-                        type: "Property",
-                        key: { type: "Identifier", name: "path" },
-                        computed: false,
-                        kind: "init",
-                        method: false,
-                        shorthand: false,
-                        value: {
-                          type: "ArrayExpression",
-                          elements: binding.path.map((segment) => ({
-                            type: "Literal",
-                            value: segment
-                          }))
-                        }
-                      }
-                    ]
-                  }
-                ]
-              }
-            }
-          ]
-        };
-        return binding.export ? [
-          internalDecl,
-          {
-            type: "ExportNamedDeclaration",
-            declaration: externalDecl,
-            specifiers: [],
-            attributes: []
-          }
-        ] : [internalDecl, externalDecl];
-      }));
+  Program(node, { state, visit }) {
+    const body = [];
+    for (const stmt of node.body) {
+      const visited = visit(stmt);
+      body.push(visited);
     }
+    body.unshift(...state.bindingStatements);
+    state.bindingStatements = [];
     if (state.hasQueryExpressions) {
       body.unshift({
         type: "ImportDeclaration",
@@ -1008,17 +994,25 @@ var gtsVisitor = {
         },
         {
           type: "ImportSpecifier",
-          imported: { type: "Identifier", name: "Action" },
-          local: state.ActionId
-        },
-        {
-          type: "ImportSpecifier",
-          imported: { type: "Identifier", name: "Prelude" },
-          local: state.preludeSymbolId
+          imported: { type: "Identifier", name: "createBinding" },
+          local: state.createBindingFnId
         }
       ],
       source: { type: "Literal", value: state.runtimeImportSource },
       attributes: []
+    }, {
+      type: "ImportDeclaration",
+      specifiers: [
+        {
+          type: "ImportDefaultSpecifier",
+          local: state.rootVmId
+        }
+      ],
+      source: {
+        type: "Literal",
+        value: `${state.providerImportSource}/vm`
+      },
+      attributes: []
     });
     return {
       ...node,
@@ -1026,42 +1020,90 @@ var gtsVisitor = {
     };
   },
   GTSDefineStatement(node, { state, visit }) {
-    const body = visit(node.body);
-    const wrapper = {
-      type: "ObjectExpression",
-      properties: [
+    const defineId = state.defineIdCounter++;
+    const rootAttr = visit(node.body);
+    const nodeVarId = {
+      type: "Identifier",
+      name: `__gts_node_${defineId}`
+    };
+    const bindingsVarId = {
+      type: "Identifier",
+      name: `__gts_bindings_${defineId}`
+    };
+    const newBindings = state.externalizedBindings;
+    state.externalizedBindings = [];
+    state.bindingStatements.push({
+      type: "VariableDeclaration",
+      kind: "const",
+      declarations: [
         {
-          type: "Property",
-          key: { type: "Identifier", name: "attributes" },
-          computed: false,
-          kind: "init",
-          method: false,
-          shorthand: false,
-          value: {
-            type: "ArrayExpression",
-            elements: [body]
+          type: "VariableDeclarator",
+          id: nodeVarId,
+          init: rootAttr
+        }
+      ],
+      loc: node.loc
+    });
+    state.bindingStatements.push({
+      type: "VariableDeclaration",
+      kind: "const",
+      declarations: [
+        {
+          type: "VariableDeclarator",
+          id: bindingsVarId,
+          init: {
+            type: "CallExpression",
+            optional: false,
+            callee: state.createBindingFnId,
+            arguments: [state.rootVmId, nodeVarId]
           }
         }
-      ]
-    };
+      ],
+      loc: node.loc
+    });
+    for (let i = 0;i < newBindings.length; i++) {
+      const binding = newBindings[i];
+      const decl = {
+        type: "VariableDeclaration",
+        kind: "const",
+        declarations: [
+          {
+            type: "VariableDeclarator",
+            id: binding.bindingName,
+            init: {
+              type: "MemberExpression",
+              object: bindingsVarId,
+              property: { type: "Literal", value: i },
+              computed: true,
+              optional: false
+            }
+          }
+        ]
+      };
+      if (binding.export) {
+        state.bindingStatements.push({
+          type: "ExportNamedDeclaration",
+          declaration: decl,
+          specifiers: [],
+          attributes: []
+        });
+      } else {
+        state.bindingStatements.push(decl);
+      }
+    }
     return {
       type: "ExpressionStatement",
       expression: {
         type: "CallExpression",
         optional: false,
-        callee: {
-          ...state.createDefineFnId,
-          loc: node.loc
-        },
-        arguments: [state.rootVmId, wrapper]
+        callee: state.createDefineFnId,
+        arguments: [state.rootVmId, nodeVarId]
       },
       loc: node.loc
     };
   },
   GTSNamedAttributeDefinition(node, { visit, state }) {
-    state.attributeNames.push(node.name);
     const namedBody = visit(node.body);
-    state.attributeNames.pop();
     const properties = [...namedBody.properties];
     const nameValue = node.name.type === "Literal" ? node.name : {
       ...node.name,
@@ -1082,39 +1124,29 @@ var gtsVisitor = {
       loc: node.loc
     });
     const body = { ...namedBody, properties };
-    const arrow = {
-      type: "ArrowFunctionExpression",
-      params: [],
-      expression: true,
-      body,
-      loc: node.loc
-    };
     if (node.bindingName) {
       if (node.bindingAccessModifier === "protected") {
         throw new GtsTranspilerError("Protected bindings are not supported in this context.", node.loc ?? null);
       }
       const export_ = node.bindingAccessModifier !== "private";
-      const internalId = {
-        type: "Identifier",
-        name: `__gts_internal_binding_${state.externalizedBindings.length}`
-      };
       state.externalizedBindings.push({
         bindingName: node.bindingName,
-        export: export_,
-        internalId,
-        value: arrow,
-        path: [...state.attributeNames, node.name].map((n) => {
-          if (n.type === "Literal") {
-            return String(n.value);
-          } else {
-            return n.name;
-          }
-        })
+        export: export_
+      });
+      body.properties.push({
+        type: "Property",
+        key: { type: "Identifier", name: "binding" },
+        computed: false,
+        kind: "init",
+        method: false,
+        shorthand: false,
+        value: {
+          type: "Literal",
+          value: export_ ? "public" : "private"
+        }
       });
-      return internalId;
-    } else {
-      return arrow;
     }
+    return body;
   },
   GTSAttributeBody(node, { visit }) {
     const positionals = visit(node.positionalAttributes);
@@ -1129,7 +1161,13 @@ var gtsVisitor = {
           kind: "init",
           method: false,
           shorthand: false,
-          value: positionals,
+          value: {
+            type: "ArrowFunctionExpression",
+            params: [],
+            body: positionals,
+            expression: true,
+            loc: positionals.loc
+          },
           loc: positionals.loc
         },
         {
@@ -1194,9 +1232,9 @@ var initialTranspileState = (option = {}) => {
   const shortcutFunctionPreludes = option.shortcutFunctionPreludes ?? DEFAULT_SHORTCUT_FUNCTION_PRELUDES;
   const queryBindings = option.queryBindings ?? DEFAULT_QUERY_BINDINGS;
   const fnArgId = { type: "Identifier", name: "__gts_fnArg" };
-  const preludeSymbolId = {
-    type: "Identifier",
-    name: "__gts_Prelude"
+  const PreludeLit = {
+    type: "Literal",
+    value: "~prelude"
   };
   const shortcutFunctionParameters = [
     fnArgId,
@@ -1217,7 +1255,7 @@ var initialTranspileState = (option = {}) => {
       right: {
         type: "MemberExpression",
         object: fnArgId,
-        property: preludeSymbolId,
+        property: PreludeLit,
         computed: true,
         optional: false
       }
@@ -1239,12 +1277,12 @@ var initialTranspileState = (option = {}) => {
   ];
   return {
     createDefineFnId: { type: "Identifier", name: "__gts_createDefine" },
-    ActionId: { type: "Identifier", name: "__gts_Action" },
-    preludeSymbolId,
+    createBindingFnId: { type: "Identifier", name: "__gts_createBinding" },
+    ActionLit: { type: "Literal", value: "~action" },
+    PreludeLit,
     fnArgId,
     shortcutFunctionParameters,
     rootVmId: { type: "Identifier", name: "__gts_rootVm" },
-    binderFnId: { type: "Identifier", name: "__gts_Binder" },
     queryFnId: { type: "Identifier", name: "__gts_query" },
     queryParameters,
     runtimeImportSource: option.runtimeImportSource ?? "@gi-tcg/gts-runtime",
@@ -1261,9 +1299,10 @@ var initialTranspileState = (option = {}) => {
         value: { type: "Identifier", name }
       }))
     },
-    attributeNames: [],
     externalizedBindings: [],
-    hasQueryExpressions: false
+    hasQueryExpressions: false,
+    defineIdCounter: 0,
+    bindingStatements: []
   };
 };
 var gtsToTs = (ast, option = {}) => {
@@ -1271,12 +1310,11 @@ var gtsToTs = (ast, option = {}) => {
   return walk3(ast, state, gtsVisitor);
 };
 
-// src/transform/volar/index.ts
+// packages/transpiler/src/transform/volar/index.ts
 import { walk as walk5 } from "zimmerframe";
 import { print } from "esrap";
-import tsPrinter from "esrap/languages/ts";
 
-// src/transform/volar/replacements.ts
+// packages/transpiler/src/transform/volar/replacements.ts
 var createReplacementHolder = (state, value) => {
   const rawValue = JSON.stringify(value);
   return {
@@ -1300,38 +1338,101 @@ var createReplacementHolder = (state, value) => {
 };
 function applyReplacements(state, code) {
   const replacementRegex = new RegExp("\\b" + state.replacementTag.name + "`(.*?)`", "gm");
-  const {
-    symbolsId: { NamedDefinition, Meta }
-  } = state;
+  const { NamedDefinitionLit, MetaLit } = state;
+  const NamedDefinition = JSON.stringify(NamedDefinitionLit.value);
+  const Meta = JSON.stringify(MetaLit.value);
+  const oneLine = (strings, ...values) => strings.reduce((result, chunk, index) => result + chunk + (index < values.length ? values[index] : ""), "").replace(/\n[ \t]*/g, " ").trim();
   return code.replace(replacementRegex, (_, rawPayload) => {
     const payload = JSON.parse(rawPayload);
-    if (payload.type === "enterVMFromRoot") {
-      return `type ${payload.defType} = (typeof ${payload.vm})[${NamedDefinition.name}]; type ${payload.metaType} = ${payload.defType}[${Meta.name}];`;
+    if (payload.type === "preface") {
+      return oneLine`
+        namespace ${state.utilNsId.name} {
+          export type UniqueKeyProbSegment = "__gts_unique_prob_seg__";
+          export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+        }
+      `;
+    } else if (payload.type === "enterVMFromRoot") {
+      return oneLine`
+        type ${payload.defType} = (typeof ${payload.vm})[${NamedDefinition}];
+        type ${payload.metaType} = ${payload.defType}[${Meta}];
+      `;
     } else if (payload.type === "enterVMFromAttr") {
-      return `type ${payload.defType} = ${payload.returnType} extends { namedDefinition: infer Def } ? Def : { [${Meta.name}]: unknown }; type ${payload.metaType} = ${payload.defType}[${Meta.name}];`;
+      return oneLine`
+        type ${payload.defType} = ${payload.returnType} extends { namedDefinition: infer Def } ? Def : { ${Meta}: unknown };
+        type ${payload.metaType} = ${payload.defType}[${Meta}];
+      `;
     } else if (payload.type === "exitVM") {
       const lhs = `${payload.finalMetaType}_lhs`;
       const requiredAttrsNs = `${payload.finalMetaType}_rans`;
       const collectedAttrsExpr = `${payload.collectedAttrs.join(" | ")}`;
-      const needleString = `null! as ${requiredAttrsNs}.RequiredAttributes`;
+      const needleString = `"${requiredAttrsNs}_NeedleString" as any as "required attributes are missing"`;
       if (payload.errorLoc) {
-        state.additionalMappings.set(payload.errorLoc, needleString);
+        state.extraMappings.set(payload.errorLoc, needleString);
       }
-      return `type ${payload.finalMetaType} = ${payload.metaType}; const ${lhs}: { [${Meta.name}]: ${payload.metaType} } & Omit<${payload.defType}, ${Meta.name}> = 0 as any; type ${lhs} = typeof ${lhs}; namespace ${requiredAttrsNs} { export type CollectedAttributes = ${collectedAttrsExpr}; export type RequiredAttributes = { [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never }[keyof ${payload.defType}]; }; ((_: ${requiredAttrsNs}.CollectedAttributes) => 0)(${needleString});`;
+      return oneLine`
+        type ${payload.finalMetaType} = ${payload.metaType};
+        let ${lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${Meta}>;
+        type ${lhs} = typeof ${lhs};
+        namespace ${requiredAttrsNs} {
+          export type Collected = ${collectedAttrsExpr};
+          export type Expected = { [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never }[keyof ${payload.defType}];
+        };
+        ((_: ${requiredAttrsNs}.Expected extends ${requiredAttrsNs}.Collected ? string : ${requiredAttrsNs}.Expected) => 0)(${needleString});
+      `;
     } else if (payload.type === "enterAttr") {
-      return `const ${payload.lhs}: { [${Meta.name}]: ${payload.metaType} } & Omit<${payload.defType}, ${Meta.name}> = 0 as any;`;
+      const uniqueKeyLhs = `${payload.lhs}_uniqueKey_lhs`;
+      const uniqueKey = `${payload.lhs}_uniqueKey`;
+      const uniqueKeyForThis = `${payload.lhs}_uniqueKeyFor_${payload.lhs}`;
+      const uniqueKeyHelperIntf = `${payload.defType}_uniqueKeyProbeHelper`;
+      const omittedKeys = `${payload.lhs}_omittedKeys`;
+      return oneLine`
+        type ${uniqueKeyLhs} = {
+          ${Meta}: ${payload.metaType}; 
+          uniqueKey: ${payload.defType} extends { [${payload.attrName}]: { uniqueKey: infer UniqueKey } } ? UniqueKey : () => 0;
+        
+        let ${uniqueKeyLhs}!: ${uniqueKeyLhs};
+        let ${uniqueKey} = ${uniqueKeyLhs}.uniqueKey();
+        type ${uniqueKey} = typeof ${uniqueKey};
+        let ${uniqueKeyForThis}!: \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}${payload.lhs}\`;
+        interface ${uniqueKeyHelperIntf} {
+          [${uniqueKeyForThis}]: 1;
+        }
+        type ${omittedKeys} = ${Meta} | (
+          ${uniqueKey} extends 0
+          ? never                                                 /* no unique requirement */
+            : string extends keyof ${uniqueKeyHelperIntf}
+              ? keyof ${payload.defType}                          /* too loose, disable all */
+              : ${state.utilNsId.name}.UnionToIntersection<
+                keyof ${uniqueKeyHelperIntf} & \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}\${string}\`
+              > extends never
+                ? ${payload.attrName}                             /* have duplicate, disable this */
+                : never
+        );
+        let ${payload.lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${omittedKeys}>;
+      `;
     } else if (payload.type === "createBindingTyping") {
       const typingIdLhs = `${payload.typingId}_lhs`;
-      return `type ${typingIdLhs} = { [${Meta.name}]: ${payload.finalMetaType}; as: ${payload.defType}[${payload.attrName}] extends { as: infer As } ? As : unknown }; let ${typingIdLhs}!: ${typingIdLhs}; let ${payload.typingId} = ${typingIdLhs}.as(); type ${payload.typingId} = typeof ${payload.typingId};`;
+      return oneLine`
+        type ${typingIdLhs} = {
+          ${Meta}: ${payload.finalMetaType};
+          as: ${payload.defType} extends { [${payload.attrName}]: { as: infer As } } ? As : unknown;
+        };
+        let ${typingIdLhs}!: ${typingIdLhs};
+        let ${payload.typingId} = ${typingIdLhs}.as();
+        type ${payload.typingId} = typeof ${payload.typingId};
+      `;
     } else if (payload.type === "exitAttr") {
-      return `type ${payload.returnType} = typeof ${payload.returnType}; type ${payload.newMetaType} = ${payload.returnType} extends { rewriteMeta: infer NewMeta extends {} } ? NewMeta : ${payload.oldMetaType}`;
+      return oneLine`
+        type ${payload.returnType} = typeof ${payload.returnType};
+        type ${payload.newMetaType} = ${payload.returnType} extends { rewriteMeta: infer NewMeta extends {} } ? NewMeta : ${payload.oldMetaType}
+      `;
     } else {
       return "";
     }
   });
 }
 
-// src/transform/volar/walker.ts
+// packages/transpiler/src/transform/volar/walker.ts
 var EMPTY = { type: "EmptyStatement" };
 var ANY = {
   type: "TSAnyKeyword"
@@ -1341,59 +1442,7 @@ var ANY_INIT = {
   expression: { type: "Literal", value: 0 },
   typeAnnotation: ANY
 };
-var emitPreface = (state) => {
-  if (state.prefaceInserted) {
-    return;
-  }
-  const symbolsLhs = {
-    type: "TSQualifiedName",
-    left: { type: "Identifier", name: state.rootVmId.name },
-    right: { type: "Identifier", name: "_symbols" }
-  };
-  for (const symbolName of [
-    "Meta",
-    "Action",
-    "NamedDefinition",
-    "Prelude"
-  ]) {
-    const init = {
-      type: "TSTypeQuery",
-      exprName: {
-        type: "TSQualifiedName",
-        left: symbolsLhs,
-        right: { type: "Identifier", name: symbolName }
-      }
-    };
-    const symbolId = symbolName === "Action" ? state.ActionId : symbolName === "Prelude" ? state.preludeSymbolId : state.symbolsId[symbolName];
-    state.pendingStatements.push({
-      type: "TSTypeAliasDeclaration",
-      id: symbolId,
-      typeAnnotation: init
-    }, {
-      type: "VariableDeclaration",
-      kind: "const",
-      declarations: [
-        {
-          type: "VariableDeclarator",
-          id: {
-            ...symbolId,
-            typeAnnotation: {
-              type: "TSTypeAnnotation",
-              typeAnnotation: {
-                type: "TSTypeReference",
-                typeName: symbolId
-              }
-            }
-          },
-          init: ANY_INIT
-        }
-      ]
-    });
-  }
-  state.prefaceInserted = true;
-};
 var enterVMFromRoot = (state) => {
-  emitPreface(state);
   let defTypeId = {
     type: "Identifier",
     name: `__gts_rootVmDefType_${state.idCounter++}`
@@ -1406,7 +1455,7 @@ var enterVMFromRoot = (state) => {
     type: "Identifier",
     name: `__gts_rootVmFinalMetaType_${state.idCounter++}`
   };
-  state.pendingStatements.push(createReplacementHolder(state, {
+  state.typingPendingStatements.push(createReplacementHolder(state, {
     type: "enterVMFromRoot",
     vm: state.rootVmId.name,
     defType: defTypeId.name,
@@ -1430,7 +1479,7 @@ var enterVMFromAttr = (state, returningId) => {
     type: "Identifier",
     name: `__gts_nestedVmFinalMetaType_${state.idCounter++}`
   };
-  state.pendingStatements.push(createReplacementHolder(state, {
+  state.typingPendingStatements.push(createReplacementHolder(state, {
     type: "enterVMFromAttr",
     returnType: returningId.name,
     defType: defTypeId.name,
@@ -1446,7 +1495,7 @@ var exitVM = (state, errorLoc) => {
   const currentMetaId = state.metaTypeIdStack.pop();
   const finalMetaId = state.finalMetaTypeIdStack.pop();
   const collectedAttrNames = state.attrsOfCurrentVm.pop();
-  state.pendingStatements.push(createReplacementHolder(state, {
+  state.typingPendingStatements.push(createReplacementHolder(state, {
     type: "exitVM",
     metaType: currentMetaId.name,
     defType: currentDefTypeId.name,
@@ -1466,11 +1515,12 @@ var enterAttr = (state, attrName) => {
     type: "Identifier",
     name: `__gts_attr_obj_${state.idCounter++}`
   };
-  state.pendingStatements.push(createReplacementHolder(state, {
+  state.typingPendingStatements.push(createReplacementHolder(state, {
     type: "enterAttr",
     defType: defTypeId.name,
     metaType: metaTypeId.name,
-    lhs: lhsId.name
+    lhs: lhsId.name,
+    attrName
   }));
   return { lhsId };
 };
@@ -1480,7 +1530,7 @@ var genBindingTyping = (state, info) => {
   if (!finalMetaId || !defTypeId) {
     return;
   }
-  state.pendingStatements.push(createReplacementHolder(state, {
+  state.typingPendingStatements.push(createReplacementHolder(state, {
     type: "createBindingTyping",
     finalMetaType: finalMetaId.name,
     defType: defTypeId.name,
@@ -1498,7 +1548,7 @@ var exitAttr = (state, returningId) => {
     name: `__gts_newMeta__${state.idCounter++}`
   };
   const [oldMetaTypeId] = state.metaTypeIdStack.splice(-1, 1, newMetaTypeId);
-  state.pendingStatements.push(createReplacementHolder(state, {
+  state.typingPendingStatements.push(createReplacementHolder(state, {
     type: "exitAttr",
     defType: currentDefId.name,
     oldMetaType: oldMetaTypeId.name,
@@ -1513,113 +1563,49 @@ var gtsToTypingsWalker = {
       if (stmt.type === "GTSDefineStatement") {
         state.defineLeadingComments = stmt.leadingComments;
         visit(stmt);
-        body.push(...state.pendingStatements);
-        state.pendingStatements = [];
+        body.push(...state.typingPendingStatements);
+        state.typingPendingStatements = [];
       } else {
         body.push(visit(stmt));
       }
     }
-    if (state.externalizedBindings.length > 0) {
-      body.unshift({
-        type: "ImportDeclaration",
-        specifiers: [
+    for (const extBinding of state.externalizedBindings) {
+      const varDecl = {
+        type: "VariableDeclaration",
+        kind: "const",
+        declarations: [
           {
-            type: "ImportDefaultSpecifier",
-            local: state.binderFnId
-          }
-        ],
-        source: {
-          type: "Literal",
-          value: `${state.providerImportSource}/binder`
-        },
-        attributes: []
-      }, ...state.externalizedBindings.flatMap((binding) => {
-        const internalDecl = {
-          type: "VariableDeclaration",
-          kind: "const",
-          declarations: [
-            {
-              type: "VariableDeclarator",
-              id: binding.internalId,
-              init: binding.value
-            }
-          ]
-        };
-        const externalDecl = {
-          type: "VariableDeclaration",
-          kind: "const",
-          declarations: [
-            {
-              type: "VariableDeclarator",
-              id: binding.bindingName,
-              init: {
-                type: "CallExpression",
-                optional: false,
-                callee: state.binderFnId,
-                arguments: [
-                  binding.internalId,
-                  {
-                    type: "ObjectExpression",
-                    properties: [
-                      {
-                        type: "Property",
-                        key: { type: "Identifier", name: "path" },
-                        computed: false,
-                        kind: "init",
-                        method: false,
-                        shorthand: false,
-                        value: {
-                          type: "ArrayExpression",
-                          elements: binding.path.map((segment) => ({
-                            type: "Literal",
-                            value: segment
-                          }))
-                        }
-                      }
-                    ]
-                  }
-                ]
+            type: "VariableDeclarator",
+            id: extBinding.bindingName,
+            init: ANY_INIT,
+            typeAnnotation: {
+              type: "TSTypeAnnotation",
+              typeAnnotation: {
+                type: "TSTypeReference",
+                typeName: extBinding.typingId
               }
             }
-          ]
-        };
-        return binding.export ? [
-          internalDecl,
-          {
-            type: "ExportNamedDeclaration",
-            declaration: externalDecl,
-            specifiers: [],
-            attributes: [],
-            leadingComments: binding.leadingComments
           }
-        ] : [
-          internalDecl,
-          {
-            ...externalDecl,
-            leadingComments: binding.leadingComments
-          }
-        ];
-      }));
-    }
-    if (state.prefaceInserted) {
-      body.unshift({
-        type: "ImportDeclaration",
-        specifiers: [
-          {
-            type: "ImportDefaultSpecifier",
-            local: state.rootVmId
-          }
-        ],
-        source: {
-          type: "Literal",
-          value: `${state.providerImportSource}/rootVM`
-        },
-        attributes: []
-      });
+        ]
+      };
+      if (extBinding.export) {
+        body.unshift({
+          type: "ExportNamedDeclaration",
+          declaration: varDecl,
+          specifiers: [],
+          source: null,
+          attributes: [],
+          leadingComments: extBinding.leadingComments
+        });
+      } else {
+        varDecl.leadingComments = extBinding.leadingComments;
+        body.unshift(varDecl);
+      }
     }
     if (state.hasQueryExpressions) {
       body.unshift({
         type: "ImportDeclaration",
+        diagnosticsOnTop: true,
         specifiers: [
           {
             type: "ImportDefaultSpecifier",
@@ -1633,6 +1619,23 @@ var gtsToTypingsWalker = {
         attributes: []
       });
     }
+    body.unshift({
+      type: "ImportDeclaration",
+      diagnosticsOnTop: true,
+      specifiers: [
+        {
+          type: "ImportDefaultSpecifier",
+          local: state.rootVmId
+        }
+      ],
+      source: {
+        type: "Literal",
+        value: `${state.providerImportSource}/vm`
+      },
+      attributes: []
+    }, createReplacementHolder(state, {
+      type: "preface"
+    }));
     return {
       ...node,
       body
@@ -1647,15 +1650,18 @@ var gtsToTypingsWalker = {
   GTSNamedAttributeDefinition(node, { visit, state }) {
     const { name, body, bindingName } = node;
     const attrName = JSON.stringify(name.type === "Literal" ? String(name.value) : name.name);
+    const attributeNameToken = state.leafTokens.find((t) => t.loc === name.loc);
+    if (attributeNameToken) {
+      attributeNameToken.sourceLengthOffset = 1;
+    }
     const { lhsId } = enterAttr(state, attrName);
+    state.extraMappings.set(`${name.loc?.start.line}:${name.loc?.start.column}`, `${lhsId.name}${name.type === "Literal" ? `[` : `.`}`);
     const positionals = body.positionalAttributes.attributes.map((attr) => {
       if (attr.type === "Identifier" && /^[a-z_]/.test(attr.name)) {
         const token = state.leafTokens.find((t) => t.loc === attr.loc);
         if (token) {
-          token.locationAdjustment = {
-            startOffset: 1,
-            generatedLength: attr.name.length + 2
-          };
+          token.generatedStartOffset = 1;
+          token.generatedLength = attr.name.length + 2;
         }
         return {
           type: "Literal",
@@ -1670,7 +1676,7 @@ var gtsToTypingsWalker = {
       type: "Identifier",
       name: `__gts_attrRet_${state.idCounter++}`
     };
-    state.pendingStatements.push({
+    state.typingPendingStatements.push({
       type: "VariableDeclaration",
       kind: "const",
       declarations: [
@@ -1699,10 +1705,6 @@ var gtsToTypingsWalker = {
     }
     if (bindingName) {
       const export_ = node.bindingAccessModifier !== "private";
-      const internalId = {
-        type: "Identifier",
-        name: `__gts_internal_binding_${state.externalizedBindings.length}`
-      };
       const typingId = {
         type: "Identifier",
         name: `gts_binding_type_${state.externalizedBindings.length}`
@@ -1723,15 +1725,6 @@ var gtsToTypingsWalker = {
           }
         },
         export: export_,
-        internalId,
-        value: { type: "Literal", value: null },
-        path: [...state.attributeNames, node.name].map((n) => {
-          if (n.type === "Literal") {
-            return String(n.value);
-          } else {
-            return n.name;
-          }
-        }),
         typingId,
         leadingComments: state.defineLeadingComments
       });
@@ -1744,7 +1737,11 @@ var gtsToTypingsWalker = {
       visit(attr);
     }
     if (node.directAction) {
-      const { lhsId } = enterAttr(state, state.ActionId.name);
+      const attrName = JSON.stringify(state.ActionLit.value);
+      const { lhsId } = enterAttr(state, attrName);
+      const actionNotExistsReplacementStr = `${lhsId.name}[${attrName}]`;
+      const actionNotExistsErrorLoc = `${node.directAction.loc?.start.line}:${node.directAction.loc?.start.column}`;
+      state.extraMappings.set(actionNotExistsErrorLoc, actionNotExistsReplacementStr);
       const fn = {
         type: "ArrowFunctionExpression",
         params: state.shortcutFunctionParameters,
@@ -1758,7 +1755,7 @@ var gtsToTypingsWalker = {
         type: "Identifier",
         name: `__gts_attrRet_${state.idCounter++}`
       };
-      state.pendingStatements.push({
+      state.typingPendingStatements.push({
         type: "VariableDeclaration",
         kind: "const",
         declarations: [
@@ -1771,7 +1768,7 @@ var gtsToTypingsWalker = {
               callee: {
                 type: "MemberExpression",
                 object: lhsId,
-                property: state.ActionId,
+                property: state.ActionLit,
                 computed: true,
                 optional: false
               },
@@ -1796,7 +1793,7 @@ var gtsToTypingsWalker = {
   }
 };
 
-// src/transform/volar/mappings.ts
+// packages/transpiler/src/transform/volar/mappings.ts
 import { decode } from "@jridgewell/sourcemap-codec";
 var DEFAULT_VOLAR_MAPPING_DATA = {
   completion: true,
@@ -1870,8 +1867,7 @@ function buildSrcToGenMap(source_map, line_offsets, generated_code) {
 function getGeneratedPosition(src_line, src_column, srcToGenMap) {
   const key = `${src_line}:${src_column}`;
   const positions = srcToGenMap.get(key);
-  if (!positions || positions.length === 0) {}
-  return positions?.[0];
+  return positions || [];
 }
 function createLineOffsets(content) {
   const lines = content.split(`
@@ -1888,39 +1884,41 @@ function locToOffset(line, column, line_offsets) {
   if (line < 1 || line > line_offsets.length) {}
   return line_offsets[line - 1] + column;
 }
-function convertToVolarMappings(generated, source, sourceMap, tokens, additionalMappings) {
+function convertToVolarMappings(generated, source, sourceMap, tokens, extraMappings) {
   const sourceLineOffsets = createLineOffsets(source);
   const generatedLineOffsets = createLineOffsets(generated);
   const srcToGenMap = buildSrcToGenMap(sourceMap, generatedLineOffsets, generated);
   const mappings = [];
   for (const token of tokens) {
     let sourceStart = locToOffset(token.loc.start.line, token.loc.start.column, sourceLineOffsets);
+    sourceStart += token.sourceStartOffset ?? 0;
     const sourceEnd = locToOffset(token.loc.end.line, token.loc.end.column, sourceLineOffsets);
     let sourceLength = token.sourceLength ?? sourceEnd - sourceStart;
-    const genLineCol = getGeneratedPosition(token.loc.start.line, token.loc.start.column, srcToGenMap);
+    sourceLength += token.sourceLengthOffset ?? 0;
+    const [genLineCol] = getGeneratedPosition(token.loc.start.line, token.loc.start.column, srcToGenMap);
     if (!genLineCol) {
       continue;
     }
     let genStart = locToOffset(genLineCol.line, genLineCol.column, generatedLineOffsets);
-    if (token.locationAdjustment) {
+    if (token.isDummy) {
+      while (sourceStart > 0 && /\s/.test(source[sourceStart - 1])) {
+        sourceStart--;
+        sourceLength++;
+      }
+    }
+    const generatedLength = token.generatedLength ?? sourceLength;
+    if (typeof token.generatedStartOffset === "number" && token.generatedStartOffset > 0) {
       mappings.push({
         sourceOffsets: [sourceStart],
         generatedOffsets: [genStart],
         lengths: [0],
-        generatedLengths: [token.locationAdjustment.generatedLength],
+        generatedLengths: [generatedLength],
         data: {
           verification: true
         }
       });
-      genStart += token.locationAdjustment.startOffset;
+      genStart += token.generatedStartOffset;
     }
-    if (token.isDummy) {
-      while (sourceStart > 0 && /\s/.test(source[sourceStart - 1])) {
-        sourceStart--;
-        sourceLength++;
-      }
-    }
-    const generatedLength = token.generatedLength ?? sourceLength;
     mappings.push({
       sourceOffsets: [sourceStart],
       generatedOffsets: [genStart],
@@ -1929,7 +1927,20 @@ function convertToVolarMappings(generated, source, sourceMap, tokens, additional
       data: DEFAULT_VOLAR_MAPPING_DATA
     });
   }
-  for (const [loc, codeSnippet] of additionalMappings) {
+  const locMapsToTop = getGeneratedPosition(1, 0, srcToGenMap);
+  for (const loc of locMapsToTop) {
+    const offset = locToOffset(loc.line, loc.column, generatedLineOffsets);
+    mappings.push({
+      sourceOffsets: [0],
+      generatedOffsets: [offset],
+      lengths: [0],
+      generatedLengths: [0],
+      data: {
+        verification: true
+      }
+    });
+  }
+  for (const [loc, codeSnippet] of extraMappings) {
     const generatedStart = generated.indexOf(codeSnippet);
     if (generatedStart === -1) {
       continue;
@@ -1954,7 +1965,7 @@ function convertToVolarMappings(generated, source, sourceMap, tokens, additional
   return mappings;
 }
 
-// src/transform/volar/collect_tokens.ts
+// packages/transpiler/src/transform/volar/collect_tokens.ts
 import { walk as walk4 } from "zimmerframe";
 function isLeafNode(node) {
   for (const key in node) {
@@ -1972,60 +1983,159 @@ function isLeafNode(node) {
   return true;
 }
 function collectLeafTokens(ast) {
-  const tokens = [];
-  walk4(ast, tokens, {
-    _(node, { state, next }) {
+  const state = {
+    tokens: []
+  };
+  walk4(ast, state, {
+    _(node, { state: state2, next }) {
       if (isLeafNode(node) && node.loc) {
         const token = {
           loc: node.loc
         };
-        if (node.isDummy) {
+        if ("isDummy" in node && node.isDummy) {
           token.isDummy = true;
           token.sourceLength = 0;
           token.generatedLength = 1;
         }
-        state.push(token);
+        state2.tokens.push(token);
+      }
+      next();
+    },
+    NewExpression(node, { state: state2, next }) {
+      const lParenLoc = node.lParenLoc;
+      if (lParenLoc) {
+        state2.tokens.push({
+          loc: lParenLoc
+        });
+      }
+      next();
+    },
+    CallExpression(node, { state: state2, next }) {
+      const lParenLoc = node.lParenLoc;
+      if (lParenLoc) {
+        state2.tokens.push({
+          loc: lParenLoc
+        });
       }
       next();
     }
   });
-  return tokens;
+  return state.tokens;
 }
 
-// src/transform/volar/index.ts
+// packages/transpiler/src/transform/volar/printer.ts
+import tsPrinter from "esrap/languages/ts";
+var printer = tsPrinter({
+  getLeadingComments: (node) => node.leadingComments,
+  getTrailingComments: (node) => node.trailingComments
+});
+var prevIdentifier = printer.Identifier;
+printer.Identifier = function(node, context) {
+  if (node.isDummy) {
+    const text = Reflect.get(node, "lastArg") ? "," : "";
+    context.write(text, node);
+  } else {
+    prevIdentifier(node, context);
+  }
+};
+var prevCallNewExpression = printer.CallExpression;
+var newCallNewExpression = function(node, context) {
+  const lastArg = node.arguments.at(-1);
+  if (lastArg) {
+    Reflect.set(lastArg, "lastArg", true);
+  }
+  if (!node.lParenLoc) {
+    return prevCallNewExpression(node, context);
+  }
+  let hasDeferredWrite = false;
+  let interceptionDone = false;
+  const lParenFakeNode = {
+    loc: node.lParenLoc
+  };
+  const patchedWrite = (text, node2) => {
+    if (text === "(") {
+      hasDeferredWrite = true;
+    } else {
+      context.write(text, node2);
+    }
+  };
+  const patchedVisit = (node2) => {
+    if (hasDeferredWrite) {
+      context.write("(");
+    }
+    return context.visit(node2);
+  };
+  const patchedAppend = (subcontext) => {
+    if (hasDeferredWrite) {
+      context.write("(", lParenFakeNode);
+      interceptionDone = true;
+    }
+    return context.append(subcontext);
+  };
+  const proxiedContext = new Proxy(context, {
+    get(target, prop) {
+      if (!interceptionDone) {
+        if (prop === "write") {
+          return patchedWrite;
+        }
+        if (prop === "visit") {
+          return patchedVisit;
+        }
+        if (prop === "append") {
+          return patchedAppend;
+        }
+      }
+      const value = Reflect.get(target, prop);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  });
+  return prevCallNewExpression(node, proxiedContext);
+};
+printer.CallExpression = newCallNewExpression;
+printer.NewExpression = newCallNewExpression;
+var prevWildcard = printer._;
+printer._ = (node, context, visit) => {
+  const contextProto = Object.getPrototypeOf(context);
+  const prevContextWrite = contextProto.write;
+  if ("diagnosticsOnTop" in node && node.diagnosticsOnTop) {
+    contextProto.write = function(text, node2) {
+      node2 ??= {};
+      node2.loc ??= {
+        start: { line: 1, column: 0 },
+        end: { line: 1, column: 0 }
+      };
+      return prevContextWrite.call(this, text, node2);
+    };
+  }
+  prevWildcard(node, context, visit);
+  contextProto.write = prevContextWrite;
+};
+var patchedPrinter = printer;
+
+// packages/transpiler/src/transform/volar/index.ts
 function gtsToTypings(ast, option) {
   const state = {
     ...initialTranspileState(option),
     leafTokens: option.leafTokens,
     idCounter: 0,
-    pendingStatements: [],
-    prefaceInserted: false,
-    rootVmId: { type: "Identifier", name: "__root_vm" },
+    typingPendingStatements: [],
+    rootVmId: { type: "Identifier", name: "__gts_root_vm" },
+    utilNsId: { type: "Identifier", name: "__gts_util" },
     replacementTag: { type: "Identifier", name: "__gts_replacement_tag" },
-    symbolsId: {
-      Meta: { type: "Identifier", name: "__gts_symbols_meta" },
-      NamedDefinition: { type: "Identifier", name: "__gts_symbols_namedDef" }
-    },
+    MetaLit: { type: "Literal", value: "~meta" },
+    NamedDefinitionLit: { type: "Literal", value: "~namedDefinition" },
+    defineLeadingComments: [],
     vmDefTypeIdStack: [],
     metaTypeIdStack: [],
     finalMetaTypeIdStack: [],
     attrsOfCurrentVm: [],
-    additionalMappings: option.additionalMappings
+    extraMappings: option.extraMappings
   };
   const newAst = walk5(ast, state, gtsToTypingsWalker);
-  const printer = tsPrinter({
-    getLeadingComments: (node) => node.leadingComments,
-    getTrailingComments: (node) => node.trailingComments
-  });
-  const prevIdentifier = printer.Identifier;
-  printer.Identifier = function(node, context) {
-    if (node.isDummy) {
-      context.write("", node);
-    } else {
-      prevIdentifier(node, context);
-    }
-  };
-  const { code, map } = print(newAst, printer, {
+  const { code, map } = print(newAst, patchedPrinter, {
     indent: "  "
   });
   return {
@@ -2035,20 +2145,20 @@ function gtsToTypings(ast, option) {
 }
 function transformForVolar(ast, option, sourceInfo) {
   const tokens = collectLeafTokens(ast);
-  const additionalMappings = new Map;
+  const extraMappings = new Map;
   const { code, sourceMap } = gtsToTypings(ast, {
     ...option,
     leafTokens: tokens,
-    additionalMappings
+    extraMappings
   });
-  const volarMappings = convertToVolarMappings(code, sourceInfo.content, sourceMap, tokens, additionalMappings);
+  const volarMappings = convertToVolarMappings(code, sourceInfo.content, sourceMap, tokens, extraMappings);
   return {
     code,
     mappings: volarMappings
   };
 }
 
-// src/transform/index.ts
+// packages/transpiler/src/transform/index.ts
 function transform(ast, option = {}, sourceInfo = {}) {
   const ts = gtsToTs(ast, option);
   const js = eraseTs(ts);
@@ -2062,8 +2172,160 @@ function transform(ast, option = {}, sourceInfo = {}) {
     sourceMap: map
   };
 }
+// packages/transpiler/src/config.ts
+var path = globalThis.require ? globalThis.require("node:path") : {
+  isAbsolute(filePath) {
+    return filePath.startsWith("/");
+  },
+  dirname(filePath) {
+    if (!filePath) {
+      return ".";
+    }
+    const normalized = normalizeSlashes(filePath);
+    if (normalized === "/") {
+      return "/";
+    }
+    const trimmed = normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+    const idx = trimmed.lastIndexOf("/");
+    if (idx < 0) {
+      return ".";
+    }
+    if (idx === 0) {
+      return "/";
+    }
+    return trimmed.slice(0, idx);
+  },
+  resolve(...segments) {
+    if (segments.length === 0) {
+      return ".";
+    }
+    let resolved = "";
+    for (let i = segments.length - 1;i >= 0; i--) {
+      const segment = segments[i];
+      if (!segment) {
+        continue;
+      }
+      if (resolved) {
+        resolved = `${segment}/${resolved}`;
+      } else {
+        resolved = segment;
+      }
+      if (path.isAbsolute(segment)) {
+        break;
+      }
+    }
+    return normalizeResolvedPath(resolved || ".");
+  }
+};
+function normalizeSlashes(filePath) {
+  return filePath.replace(/\\+/g, "/");
+}
+function normalizeResolvedPath(filePath) {
+  const normalized = normalizeSlashes(filePath);
+  const isAbsolute = normalized.startsWith("/");
+  const parts = normalized.split("/");
+  const stack = [];
+  for (const part of parts) {
+    if (!part || part === ".") {
+      continue;
+    }
+    if (part === "..") {
+      if (stack.length > 0 && stack[stack.length - 1] !== "..") {
+        stack.pop();
+      } else if (!isAbsolute) {
+        stack.push("..");
+      }
+      continue;
+    }
+    stack.push(part);
+  }
+  if (isAbsolute) {
+    return `/${stack.join("/")}` || "/";
+  }
+  return stack.join("/") || ".";
+}
+var DEFAULT_GTS_CONFIG = {
+  runtimeImportSource: "@gi-tcg/gts-runtime",
+  providerImportSource: "@gi-tcg/core/gts",
+  shortcutFunctionPreludes: [
+    "cryo",
+    "hydro",
+    "pyro",
+    "electro",
+    "anemo",
+    "geo",
+    "dendro",
+    "omni"
+  ],
+  queryBindings: ["my", "opp"]
+};
+function* resolveGtsConfigImpl(filePath, inlineConfig = {}, options) {
+  const startDir = normalizeStartDir(filePath, options.cwd);
+  const stopDir = options.stopDir ? path.resolve(options.stopDir) : undefined;
+  const pkgConfig = yield* findNearestPackageConfig(options.readFileFn, startDir, stopDir);
+  return {
+    ...DEFAULT_GTS_CONFIG,
+    ...pkgConfig,
+    ...inlineConfig
+  };
+}
+async function resolveGtsConfig(filePath, inlineConfig, options) {
+  const generator = resolveGtsConfigImpl(filePath, inlineConfig, options);
+  let result = generator.next();
+  while (!result.done) {
+    const toRead = result.value;
+    const content = await toRead;
+    result = generator.next(content);
+  }
+  return result.value;
+}
+function resolveGtsConfigSync(filePath, inlineConfig, options) {
+  const generator = resolveGtsConfigImpl(filePath, inlineConfig, options);
+  let result = generator.next();
+  while (!result.done) {
+    const toRead = result.value;
+    if (toRead instanceof Promise) {
+      throw new Error("resolveGtsConfigSync received a Promise. Did you mean to use resolveGtsConfig instead?");
+    }
+    const content = toRead;
+    result = generator.next(content);
+  }
+  return result.value;
+}
+function normalizeStartDir(sourceFile, cwd) {
+  const absolute = path.isAbsolute(sourceFile) ? sourceFile : path.resolve(cwd || ".", sourceFile);
+  return path.dirname(absolute);
+}
+function* findNearestPackageConfig(readFileFn, startDir, stopDir) {
+  let currentDir = startDir;
+  while (true) {
+    const pkgPath = path.resolve(currentDir, "package.json");
+    const config = yield* readPackageConfig(readFileFn, pkgPath);
+    if (config) {
+      return config;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    if (stopDir && currentDir === stopDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return {};
+}
+function* readPackageConfig(readFileFn, pkgPath) {
+  try {
+    const content = yield readFileFn(pkgPath, "utf8");
+    const parsed = JSON.parse(content);
+    return parsed.gamingTs;
+  } catch {
+    return;
+  }
+}
 
-// src/index.ts
+// packages/transpiler/src/index.ts
 function transpile(source, filename, option) {
   const ast = parse(source);
   return transform(ast, option, {
@@ -2072,7 +2334,9 @@ function transpile(source, filename, option) {
   });
 }
 function transpileForVolar(source, filename, option) {
-  const ast = parseLoose(source);
+  const ast = parseLoose(source, {
+    recordCallLParens: true
+  });
   return transformForVolar(ast, option, {
     content: source,
     filename
@@ -2081,5 +2345,8 @@ function transpileForVolar(source, filename, option) {
 export {
   transpileForVolar,
   transpile,
+  resolveGtsConfigSync,
+  resolveGtsConfig,
+  path,
   GtsTranspilerError
 };