@atscript/typescript 0.1.51 → 0.1.53

package/dist/cli.cjs

@@ -1320,13 +1320,7 @@ function forAnnotatedType(def, handlers) {
 
 //#endregion
 //#region packages/typescript/src/runtime/json-schema.ts
-/**
-* Detects a discriminator property across union items.
-*
-* Scans all items for object-typed members that share a common property
-* with distinct const/literal values. If exactly one such property exists,
-* it is returned as the discriminator.
-*/ function detectDiscriminator(items) {
+function detectDiscriminator(items) {
 	if (items.length < 2) return null;
 	for (const item of items) if (item.type.kind !== "object") return null;
 	const firstObj = items[0].type;
@@ -1500,6 +1494,132 @@ const QUERY_OP_MAP = {
 	"not exists": "$exists"
 };
 var JsRenderer = class extends BaseRenderer {
+	/**
+	* Override base `unused` to subtract symbols that the JS output references
+	* transitively through `extends`-resolved parent prop trees. Without this,
+	* cross-file `extends` strips the imports needed by inherited `.refTo()` calls.
+	*/ get unused() {
+		if (this._unusedJs) return this._unusedJs;
+		const base = new Set(this.doc.getUnusedTokens().map((t) => t.text));
+		for (const ref of this.getExtendsRefs().keys()) if (ref.id) base.delete(ref.id);
+		return this._unusedJs = base;
+	}
+	getExtendsRefs() {
+		if (this._extendsRefs) return this._extendsRefs;
+		const out = new Map();
+		const visitedInterfaces = new Set();
+		for (const node of this.doc.nodes) if ((0, __atscript_core.isInterface)(node) && node.hasExtends) this.walkExtendsParents(node, this.doc, out, visitedInterfaces);
+		return this._extendsRefs = out;
+	}
+	walkRefs(node, visited, visit) {
+		if (!node || visited.has(node)) return;
+		visited.add(node);
+		if ((0, __atscript_core.isRef)(node)) {
+			visit(node);
+			return;
+		}
+		if ((0, __atscript_core.isGroup)(node)) {
+			for (const item of node.unwrap()) this.walkRefs(item, visited, visit);
+			return;
+		}
+		if ((0, __atscript_core.isArray)(node) || (0, __atscript_core.isProp)(node)) this.walkRefs(node.getDefinition(), visited, visit);
+	}
+	walkExtendsParents(iface, doc, out, visited) {
+		if (visited.has(iface)) return;
+		visited.add(iface);
+		const visitedNodes = new Set();
+		for (const token of iface.extendsTokens) {
+			const unwound = doc.unwindType(token.text);
+			if (!unwound?.def || !(0, __atscript_core.isInterface)(unwound.def)) continue;
+			const parentInterface = unwound.def;
+			const parentDoc = unwound.doc;
+			this.walkRefs(parentInterface.getDefinition(), visitedNodes, (ref) => {
+				if (!out.has(ref)) out.set(ref, parentDoc);
+			});
+			if (parentInterface.hasExtends) this.walkExtendsParents(parentInterface, parentDoc, out, visited);
+		}
+	}
+	computeSynthesizedImports() {
+		if (this._synthComputed) return;
+		this._synthComputed = true;
+		const refToOriginDoc = this.getExtendsRefs();
+		if (refToOriginDoc.size === 0) return;
+		const taken = new Set(this.doc.registry.definitions.keys());
+		const allocated = new Map();
+		const synthPathCache = new Map();
+		for (const [refNode, originDoc] of refToOriginDoc) {
+			const refId = refNode.id;
+			if (!refId) continue;
+			const ownerInfo = this.resolveOwner(originDoc, refId);
+			if (!ownerInfo?.doc || ownerInfo.doc === this.doc) continue;
+			if (ownerInfo.node && (0, __atscript_core.isPrimitive)(ownerInfo.node)) continue;
+			const ownerDoc = ownerInfo.doc;
+			let synthPath;
+			if (synthPathCache.has(ownerDoc)) synthPath = synthPathCache.get(ownerDoc);
+else {
+				synthPath = this.computeSynthPath(ownerDoc);
+				synthPathCache.set(ownerDoc, synthPath);
+			}
+			if (!synthPath) continue;
+			const allocKey = `${synthPath}::${refId}`;
+			let info = allocated.get(allocKey);
+			if (!info) {
+				info = this.allocateSynthInfo(refId, synthPath, ownerInfo, taken);
+				allocated.set(allocKey, info);
+			}
+			this._refSynthInfo.set(refNode, info);
+		}
+	}
+	resolveOwner(fromDoc, refId) {
+		const key = `${fromDoc.id}::${refId}`;
+		let v = this._ownerCache.get(key);
+		if (v === undefined && !this._ownerCache.has(key)) {
+			v = fromDoc.getDeclarationOwnerNode(refId);
+			this._ownerCache.set(key, v);
+		}
+		return v;
+	}
+	allocateSynthInfo(refId, synthPath, ownerInfo, taken) {
+		const ownerDoc = ownerInfo.doc;
+		const ownerNode = ownerInfo.node;
+		const existing = this.doc.importedDefs.get(refId);
+		if (existing?.text === synthPath) return {
+			alias: refId,
+			ownerDoc,
+			ownerNode
+		};
+		const alias = this.allocAlias(refId, taken);
+		let group = this._synthImports.get(synthPath);
+		if (!group) {
+			group = [];
+			this._synthImports.set(synthPath, group);
+		}
+		group.push({
+			name: refId,
+			alias
+		});
+		return {
+			alias,
+			ownerDoc,
+			ownerNode
+		};
+	}
+	allocAlias(name, taken) {
+		if (!taken.has(name)) {
+			taken.add(name);
+			return name;
+		}
+		let n = 1;
+		while (taken.has(`${name}_${n}`)) n++;
+		const alias = `${name}_${n}`;
+		taken.add(alias);
+		return alias;
+	}
+	computeSynthPath(ownerDoc) {
+		if ((0, __atscript_core.isBareId)(ownerDoc.id)) return ownerDoc.id.slice("bare:".length, -".as".length);
+		if (!ownerDoc.id.startsWith("file://")) return undefined;
+		return (0, __atscript_core.getRelPath)(this.doc.id, ownerDoc.id);
+	}
 	pre() {
 		this.writeln("// prettier-ignore-start");
 		this.writeln("/* eslint-disable */");
@@ -1523,6 +1643,11 @@ else for (let i = 0; i < nodes.length; i++) this.typeIds.set(nodes[i], `${name}_
 		if (this.opts?.exampleData) imports.push("createDataFromAnnotatedType as $e");
 		if (jsonSchemaMode === false) imports.push("throwFeatureDisabled as $d");
 		this.writeln(`import { ${imports.join(", ")} } from "@atscript/typescript/utils"`);
+		this.computeSynthesizedImports();
+		for (const [synthPath, names] of this._synthImports) {
+			const list = names.map((n) => n.alias === n.name ? n.name : `${n.name} as ${n.alias}`).join(", ");
+			this.writeln(`import { ${list} } from "${this.transformFromPath(synthPath)}"`);
+		}
 	}
 	buildAdHocMap(annotateNodes) {
 		const map = new Map();
@@ -1801,7 +1926,7 @@ else handle.prop(prop.id, propHandle.$type);
 				const ref = node;
 				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
 				if ((0, __atscript_core.isPrimitive)(decl)) {
-					const ownerDecl$1 = this.doc.getDeclarationOwnerNode(ref.id);
+					const ownerDecl$1 = this.resolveOwner(this.doc, ref.id);
 					if (!ownerDecl$1?.node || ownerDecl$1.node.entity !== "type" && ownerDecl$1.node.entity !== "interface") {
 						this.annotateType(decl, name);
 						return this;
@@ -1816,9 +1941,14 @@ else handle.prop(prop.id, propHandle.$type);
 					}
 				}
 				const chain = ref.hasChain ? `, [${ref.chain.map((c) => `"${escapeQuotes(c.text)}"`).join(", ")}]` : "";
-				const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
-				const isImported = ownerDecl ? ownerDecl.doc !== this.doc : false;
-				const refExpr = isImported ? `() => ${ref.id}` : ref.id;
+				const synth = this._refSynthInfo.get(ref);
+				const ownerDecl = synth ? {
+					doc: synth.ownerDoc,
+					node: synth.ownerNode
+				} : this.resolveOwner(this.doc, ref.id);
+				const refName = synth?.alias ?? ref.id;
+				const isImported = !!synth || (ownerDecl ? ownerDecl.doc !== this.doc : false);
+				const refExpr = isImported ? `() => ${refName}` : refName;
 				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${refExpr}${chain})`);
 				if (!ref.hasChain) {
 					if (ownerDecl?.node) {
@@ -2233,7 +2363,7 @@ else {
 		return [];
 	}
 	constructor(doc, opts) {
-		super(doc), _define_property$3(this, "opts", void 0), _define_property$3(this, "postAnnotate", void 0), _define_property$3(this, "_adHocAnnotations", void 0), _define_property$3(this, "_propPath", void 0), _define_property$3(this, "typeIds", void 0), this.opts = opts, this.postAnnotate = [], this._adHocAnnotations = null, this._propPath = [], this.typeIds = new Map();
+		super(doc), _define_property$3(this, "opts", void 0), _define_property$3(this, "postAnnotate", void 0), _define_property$3(this, "_adHocAnnotations", void 0), _define_property$3(this, "_propPath", void 0), _define_property$3(this, "typeIds", void 0), _define_property$3(this, "_unusedJs", void 0), _define_property$3(this, "_extendsRefs", void 0), _define_property$3(this, "_refSynthInfo", void 0), _define_property$3(this, "_synthImports", void 0), _define_property$3(this, "_synthComputed", void 0), _define_property$3(this, "_ownerCache", void 0), this.opts = opts, this.postAnnotate = [], this._adHocAnnotations = null, this._propPath = [], this.typeIds = new Map(), this._refSynthInfo = new Map(), this._synthImports = new Map(), this._synthComputed = false, this._ownerCache = new Map();
 	}
 };
 

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
-const require_plugin = require('./plugin-cY7VLpmN.cjs');
-require('./json-schema-BgW_S2sP.cjs');
+const require_plugin = require('./plugin-C90RBCnx.cjs');
+require('./json-schema-Zi4TJzJJ.cjs');
 
 exports.default = require_plugin.tsPlugin
 exports.tsPlugin = require_plugin.tsPlugin

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { tsPlugin } from "./plugin-D96fH7Va.mjs";
-import "./json-schema-DrJMwvm1.mjs";
+import { tsPlugin } from "./plugin-PADgal82.mjs";
+import "./json-schema-D_wrIxzk.mjs";
 
 export { tsPlugin as default, tsPlugin };

package/dist/{json-schema-DrJMwvm1.mjs → json-schema-D_wrIxzk.mjs}

@@ -701,13 +701,7 @@ function forAnnotatedType(def, handlers) {
 
 //#endregion
 //#region packages/typescript/src/runtime/json-schema.ts
-/**
-* Detects a discriminator property across union items.
-*
-* Scans all items for object-typed members that share a common property
-* with distinct const/literal values. If exactly one such property exists,
-* it is returned as the discriminator.
-*/ function detectDiscriminator(items) {
+function detectDiscriminator(items) {
 	if (items.length < 2) return null;
 	for (const item of items) if (item.type.kind !== "object") return null;
 	const firstObj = items[0].type;
@@ -978,4 +972,4 @@ function mergeJsonSchemas(types) {
 }
 
 //#endregion
-export { Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, defineAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas };
+export { Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, defineAnnotatedType, detectDiscriminator, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas };

package/dist/{json-schema-BgW_S2sP.cjs → json-schema-Zi4TJzJJ.cjs}

@@ -702,13 +702,7 @@ function forAnnotatedType(def, handlers) {
 
 //#endregion
 //#region packages/typescript/src/runtime/json-schema.ts
-/**
-* Detects a discriminator property across union items.
-*
-* Scans all items for object-typed members that share a common property
-* with distinct const/literal values. If exactly one such property exists,
-* it is returned as the discriminator.
-*/ function detectDiscriminator(items) {
+function detectDiscriminator(items) {
 	if (items.length < 2) return null;
 	for (const item of items) if (item.type.kind !== "object") return null;
 	const firstObj = items[0].type;
@@ -1021,6 +1015,12 @@ Object.defineProperty(exports, 'defineAnnotatedType', {
     return defineAnnotatedType;
   }
 });
+Object.defineProperty(exports, 'detectDiscriminator', {
+  enumerable: true,
+  get: function () {
+    return detectDiscriminator;
+  }
+});
 Object.defineProperty(exports, 'forAnnotatedType', {
   enumerable: true,
   get: function () {

package/dist/{plugin-cY7VLpmN.cjs → plugin-C90RBCnx.cjs}

@@ -22,7 +22,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const require_json_schema = require('./json-schema-BgW_S2sP.cjs');
+const require_json_schema = require('./json-schema-Zi4TJzJJ.cjs');
 const path = __toESM(require("path"));
 const __atscript_core = __toESM(require("@atscript/core"));
 
@@ -695,6 +695,132 @@ const QUERY_OP_MAP = {
 	"not exists": "$exists"
 };
 var JsRenderer = class extends BaseRenderer {
+	/**
+	* Override base `unused` to subtract symbols that the JS output references
+	* transitively through `extends`-resolved parent prop trees. Without this,
+	* cross-file `extends` strips the imports needed by inherited `.refTo()` calls.
+	*/ get unused() {
+		if (this._unusedJs) return this._unusedJs;
+		const base = new Set(this.doc.getUnusedTokens().map((t) => t.text));
+		for (const ref of this.getExtendsRefs().keys()) if (ref.id) base.delete(ref.id);
+		return this._unusedJs = base;
+	}
+	getExtendsRefs() {
+		if (this._extendsRefs) return this._extendsRefs;
+		const out = new Map();
+		const visitedInterfaces = new Set();
+		for (const node of this.doc.nodes) if ((0, __atscript_core.isInterface)(node) && node.hasExtends) this.walkExtendsParents(node, this.doc, out, visitedInterfaces);
+		return this._extendsRefs = out;
+	}
+	walkRefs(node, visited, visit) {
+		if (!node || visited.has(node)) return;
+		visited.add(node);
+		if ((0, __atscript_core.isRef)(node)) {
+			visit(node);
+			return;
+		}
+		if ((0, __atscript_core.isGroup)(node)) {
+			for (const item of node.unwrap()) this.walkRefs(item, visited, visit);
+			return;
+		}
+		if ((0, __atscript_core.isArray)(node) || (0, __atscript_core.isProp)(node)) this.walkRefs(node.getDefinition(), visited, visit);
+	}
+	walkExtendsParents(iface, doc, out, visited) {
+		if (visited.has(iface)) return;
+		visited.add(iface);
+		const visitedNodes = new Set();
+		for (const token of iface.extendsTokens) {
+			const unwound = doc.unwindType(token.text);
+			if (!unwound?.def || !(0, __atscript_core.isInterface)(unwound.def)) continue;
+			const parentInterface = unwound.def;
+			const parentDoc = unwound.doc;
+			this.walkRefs(parentInterface.getDefinition(), visitedNodes, (ref) => {
+				if (!out.has(ref)) out.set(ref, parentDoc);
+			});
+			if (parentInterface.hasExtends) this.walkExtendsParents(parentInterface, parentDoc, out, visited);
+		}
+	}
+	computeSynthesizedImports() {
+		if (this._synthComputed) return;
+		this._synthComputed = true;
+		const refToOriginDoc = this.getExtendsRefs();
+		if (refToOriginDoc.size === 0) return;
+		const taken = new Set(this.doc.registry.definitions.keys());
+		const allocated = new Map();
+		const synthPathCache = new Map();
+		for (const [refNode, originDoc] of refToOriginDoc) {
+			const refId = refNode.id;
+			if (!refId) continue;
+			const ownerInfo = this.resolveOwner(originDoc, refId);
+			if (!ownerInfo?.doc || ownerInfo.doc === this.doc) continue;
+			if (ownerInfo.node && (0, __atscript_core.isPrimitive)(ownerInfo.node)) continue;
+			const ownerDoc = ownerInfo.doc;
+			let synthPath;
+			if (synthPathCache.has(ownerDoc)) synthPath = synthPathCache.get(ownerDoc);
+else {
+				synthPath = this.computeSynthPath(ownerDoc);
+				synthPathCache.set(ownerDoc, synthPath);
+			}
+			if (!synthPath) continue;
+			const allocKey = `${synthPath}::${refId}`;
+			let info = allocated.get(allocKey);
+			if (!info) {
+				info = this.allocateSynthInfo(refId, synthPath, ownerInfo, taken);
+				allocated.set(allocKey, info);
+			}
+			this._refSynthInfo.set(refNode, info);
+		}
+	}
+	resolveOwner(fromDoc, refId) {
+		const key = `${fromDoc.id}::${refId}`;
+		let v = this._ownerCache.get(key);
+		if (v === undefined && !this._ownerCache.has(key)) {
+			v = fromDoc.getDeclarationOwnerNode(refId);
+			this._ownerCache.set(key, v);
+		}
+		return v;
+	}
+	allocateSynthInfo(refId, synthPath, ownerInfo, taken) {
+		const ownerDoc = ownerInfo.doc;
+		const ownerNode = ownerInfo.node;
+		const existing = this.doc.importedDefs.get(refId);
+		if (existing?.text === synthPath) return {
+			alias: refId,
+			ownerDoc,
+			ownerNode
+		};
+		const alias = this.allocAlias(refId, taken);
+		let group = this._synthImports.get(synthPath);
+		if (!group) {
+			group = [];
+			this._synthImports.set(synthPath, group);
+		}
+		group.push({
+			name: refId,
+			alias
+		});
+		return {
+			alias,
+			ownerDoc,
+			ownerNode
+		};
+	}
+	allocAlias(name, taken) {
+		if (!taken.has(name)) {
+			taken.add(name);
+			return name;
+		}
+		let n = 1;
+		while (taken.has(`${name}_${n}`)) n++;
+		const alias = `${name}_${n}`;
+		taken.add(alias);
+		return alias;
+	}
+	computeSynthPath(ownerDoc) {
+		if ((0, __atscript_core.isBareId)(ownerDoc.id)) return ownerDoc.id.slice("bare:".length, -".as".length);
+		if (!ownerDoc.id.startsWith("file://")) return undefined;
+		return (0, __atscript_core.getRelPath)(this.doc.id, ownerDoc.id);
+	}
 	pre() {
 		this.writeln("// prettier-ignore-start");
 		this.writeln("/* eslint-disable */");
@@ -718,6 +844,11 @@ else for (let i = 0; i < nodes.length; i++) this.typeIds.set(nodes[i], `${name}_
 		if (this.opts?.exampleData) imports.push("createDataFromAnnotatedType as $e");
 		if (jsonSchemaMode === false) imports.push("throwFeatureDisabled as $d");
 		this.writeln(`import { ${imports.join(", ")} } from "@atscript/typescript/utils"`);
+		this.computeSynthesizedImports();
+		for (const [synthPath, names] of this._synthImports) {
+			const list = names.map((n) => n.alias === n.name ? n.name : `${n.name} as ${n.alias}`).join(", ");
+			this.writeln(`import { ${list} } from "${this.transformFromPath(synthPath)}"`);
+		}
 	}
 	buildAdHocMap(annotateNodes) {
 		const map = new Map();
@@ -996,7 +1127,7 @@ else handle.prop(prop.id, propHandle.$type);
 				const ref = node;
 				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
 				if ((0, __atscript_core.isPrimitive)(decl)) {
-					const ownerDecl$1 = this.doc.getDeclarationOwnerNode(ref.id);
+					const ownerDecl$1 = this.resolveOwner(this.doc, ref.id);
 					if (!ownerDecl$1?.node || ownerDecl$1.node.entity !== "type" && ownerDecl$1.node.entity !== "interface") {
 						this.annotateType(decl, name);
 						return this;
@@ -1011,9 +1142,14 @@ else handle.prop(prop.id, propHandle.$type);
 					}
 				}
 				const chain = ref.hasChain ? `, [${ref.chain.map((c) => `"${escapeQuotes(c.text)}"`).join(", ")}]` : "";
-				const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
-				const isImported = ownerDecl ? ownerDecl.doc !== this.doc : false;
-				const refExpr = isImported ? `() => ${ref.id}` : ref.id;
+				const synth = this._refSynthInfo.get(ref);
+				const ownerDecl = synth ? {
+					doc: synth.ownerDoc,
+					node: synth.ownerNode
+				} : this.resolveOwner(this.doc, ref.id);
+				const refName = synth?.alias ?? ref.id;
+				const isImported = !!synth || (ownerDecl ? ownerDecl.doc !== this.doc : false);
+				const refExpr = isImported ? `() => ${refName}` : refName;
 				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${refExpr}${chain})`);
 				if (!ref.hasChain) {
 					if (ownerDecl?.node) {
@@ -1428,7 +1564,7 @@ else {
 		return [];
 	}
 	constructor(doc, opts) {
-		super(doc), _define_property(this, "opts", void 0), _define_property(this, "postAnnotate", void 0), _define_property(this, "_adHocAnnotations", void 0), _define_property(this, "_propPath", void 0), _define_property(this, "typeIds", void 0), this.opts = opts, this.postAnnotate = [], this._adHocAnnotations = null, this._propPath = [], this.typeIds = new Map();
+		super(doc), _define_property(this, "opts", void 0), _define_property(this, "postAnnotate", void 0), _define_property(this, "_adHocAnnotations", void 0), _define_property(this, "_propPath", void 0), _define_property(this, "typeIds", void 0), _define_property(this, "_unusedJs", void 0), _define_property(this, "_extendsRefs", void 0), _define_property(this, "_refSynthInfo", void 0), _define_property(this, "_synthImports", void 0), _define_property(this, "_synthComputed", void 0), _define_property(this, "_ownerCache", void 0), this.opts = opts, this.postAnnotate = [], this._adHocAnnotations = null, this._propPath = [], this.typeIds = new Map(), this._refSynthInfo = new Map(), this._synthImports = new Map(), this._synthComputed = false, this._ownerCache = new Map();
 	}
 };
 

package/dist/{plugin-D96fH7Va.mjs → plugin-PADgal82.mjs}

@@ -1,6 +1,6 @@
-import { buildJsonSchema, defineAnnotatedType } from "./json-schema-DrJMwvm1.mjs";
+import { buildJsonSchema, defineAnnotatedType } from "./json-schema-D_wrIxzk.mjs";
 import path from "path";
-import { DEFAULT_FORMAT, flattenInterfaceNode, hasNavPropAnnotation, isArray, isConst, isGroup, isInterface, isPrimitive, isQueryLogical, isRef, isStructure } from "@atscript/core";
+import { DEFAULT_FORMAT, flattenInterfaceNode, getRelPath, hasNavPropAnnotation, isArray, isBareId, isConst, isGroup, isInterface, isPrimitive, isProp, isQueryLogical, isRef, isStructure } from "@atscript/core";
 
 //#region packages/typescript/src/codegen/code-printer.ts
 function _define_property$3(obj, key, value) {
@@ -671,6 +671,132 @@ const QUERY_OP_MAP = {
 	"not exists": "$exists"
 };
 var JsRenderer = class extends BaseRenderer {
+	/**
+	* Override base `unused` to subtract symbols that the JS output references
+	* transitively through `extends`-resolved parent prop trees. Without this,
+	* cross-file `extends` strips the imports needed by inherited `.refTo()` calls.
+	*/ get unused() {
+		if (this._unusedJs) return this._unusedJs;
+		const base = new Set(this.doc.getUnusedTokens().map((t) => t.text));
+		for (const ref of this.getExtendsRefs().keys()) if (ref.id) base.delete(ref.id);
+		return this._unusedJs = base;
+	}
+	getExtendsRefs() {
+		if (this._extendsRefs) return this._extendsRefs;
+		const out = new Map();
+		const visitedInterfaces = new Set();
+		for (const node of this.doc.nodes) if (isInterface(node) && node.hasExtends) this.walkExtendsParents(node, this.doc, out, visitedInterfaces);
+		return this._extendsRefs = out;
+	}
+	walkRefs(node, visited, visit) {
+		if (!node || visited.has(node)) return;
+		visited.add(node);
+		if (isRef(node)) {
+			visit(node);
+			return;
+		}
+		if (isGroup(node)) {
+			for (const item of node.unwrap()) this.walkRefs(item, visited, visit);
+			return;
+		}
+		if (isArray(node) || isProp(node)) this.walkRefs(node.getDefinition(), visited, visit);
+	}
+	walkExtendsParents(iface, doc, out, visited) {
+		if (visited.has(iface)) return;
+		visited.add(iface);
+		const visitedNodes = new Set();
+		for (const token of iface.extendsTokens) {
+			const unwound = doc.unwindType(token.text);
+			if (!unwound?.def || !isInterface(unwound.def)) continue;
+			const parentInterface = unwound.def;
+			const parentDoc = unwound.doc;
+			this.walkRefs(parentInterface.getDefinition(), visitedNodes, (ref) => {
+				if (!out.has(ref)) out.set(ref, parentDoc);
+			});
+			if (parentInterface.hasExtends) this.walkExtendsParents(parentInterface, parentDoc, out, visited);
+		}
+	}
+	computeSynthesizedImports() {
+		if (this._synthComputed) return;
+		this._synthComputed = true;
+		const refToOriginDoc = this.getExtendsRefs();
+		if (refToOriginDoc.size === 0) return;
+		const taken = new Set(this.doc.registry.definitions.keys());
+		const allocated = new Map();
+		const synthPathCache = new Map();
+		for (const [refNode, originDoc] of refToOriginDoc) {
+			const refId = refNode.id;
+			if (!refId) continue;
+			const ownerInfo = this.resolveOwner(originDoc, refId);
+			if (!ownerInfo?.doc || ownerInfo.doc === this.doc) continue;
+			if (ownerInfo.node && isPrimitive(ownerInfo.node)) continue;
+			const ownerDoc = ownerInfo.doc;
+			let synthPath;
+			if (synthPathCache.has(ownerDoc)) synthPath = synthPathCache.get(ownerDoc);
+else {
+				synthPath = this.computeSynthPath(ownerDoc);
+				synthPathCache.set(ownerDoc, synthPath);
+			}
+			if (!synthPath) continue;
+			const allocKey = `${synthPath}::${refId}`;
+			let info = allocated.get(allocKey);
+			if (!info) {
+				info = this.allocateSynthInfo(refId, synthPath, ownerInfo, taken);
+				allocated.set(allocKey, info);
+			}
+			this._refSynthInfo.set(refNode, info);
+		}
+	}
+	resolveOwner(fromDoc, refId) {
+		const key = `${fromDoc.id}::${refId}`;
+		let v = this._ownerCache.get(key);
+		if (v === undefined && !this._ownerCache.has(key)) {
+			v = fromDoc.getDeclarationOwnerNode(refId);
+			this._ownerCache.set(key, v);
+		}
+		return v;
+	}
+	allocateSynthInfo(refId, synthPath, ownerInfo, taken) {
+		const ownerDoc = ownerInfo.doc;
+		const ownerNode = ownerInfo.node;
+		const existing = this.doc.importedDefs.get(refId);
+		if (existing?.text === synthPath) return {
+			alias: refId,
+			ownerDoc,
+			ownerNode
+		};
+		const alias = this.allocAlias(refId, taken);
+		let group = this._synthImports.get(synthPath);
+		if (!group) {
+			group = [];
+			this._synthImports.set(synthPath, group);
+		}
+		group.push({
+			name: refId,
+			alias
+		});
+		return {
+			alias,
+			ownerDoc,
+			ownerNode
+		};
+	}
+	allocAlias(name, taken) {
+		if (!taken.has(name)) {
+			taken.add(name);
+			return name;
+		}
+		let n = 1;
+		while (taken.has(`${name}_${n}`)) n++;
+		const alias = `${name}_${n}`;
+		taken.add(alias);
+		return alias;
+	}
+	computeSynthPath(ownerDoc) {
+		if (isBareId(ownerDoc.id)) return ownerDoc.id.slice("bare:".length, -".as".length);
+		if (!ownerDoc.id.startsWith("file://")) return undefined;
+		return getRelPath(this.doc.id, ownerDoc.id);
+	}
 	pre() {
 		this.writeln("// prettier-ignore-start");
 		this.writeln("/* eslint-disable */");
@@ -694,6 +820,11 @@ else for (let i = 0; i < nodes.length; i++) this.typeIds.set(nodes[i], `${name}_
 		if (this.opts?.exampleData) imports.push("createDataFromAnnotatedType as $e");
 		if (jsonSchemaMode === false) imports.push("throwFeatureDisabled as $d");
 		this.writeln(`import { ${imports.join(", ")} } from "@atscript/typescript/utils"`);
+		this.computeSynthesizedImports();
+		for (const [synthPath, names] of this._synthImports) {
+			const list = names.map((n) => n.alias === n.name ? n.name : `${n.name} as ${n.alias}`).join(", ");
+			this.writeln(`import { ${list} } from "${this.transformFromPath(synthPath)}"`);
+		}
 	}
 	buildAdHocMap(annotateNodes) {
 		const map = new Map();
@@ -972,7 +1103,7 @@ else handle.prop(prop.id, propHandle.$type);
 				const ref = node;
 				const decl = this.doc.unwindType(ref.id, ref.chain)?.def;
 				if (isPrimitive(decl)) {
-					const ownerDecl$1 = this.doc.getDeclarationOwnerNode(ref.id);
+					const ownerDecl$1 = this.resolveOwner(this.doc, ref.id);
 					if (!ownerDecl$1?.node || ownerDecl$1.node.entity !== "type" && ownerDecl$1.node.entity !== "interface") {
 						this.annotateType(decl, name);
 						return this;
@@ -987,9 +1118,14 @@ else handle.prop(prop.id, propHandle.$type);
 					}
 				}
 				const chain = ref.hasChain ? `, [${ref.chain.map((c) => `"${escapeQuotes(c.text)}"`).join(", ")}]` : "";
-				const ownerDecl = this.doc.getDeclarationOwnerNode(ref.id);
-				const isImported = ownerDecl ? ownerDecl.doc !== this.doc : false;
-				const refExpr = isImported ? `() => ${ref.id}` : ref.id;
+				const synth = this._refSynthInfo.get(ref);
+				const ownerDecl = synth ? {
+					doc: synth.ownerDoc,
+					node: synth.ownerNode
+				} : this.resolveOwner(this.doc, ref.id);
+				const refName = synth?.alias ?? ref.id;
+				const isImported = !!synth || (ownerDecl ? ownerDecl.doc !== this.doc : false);
+				const refExpr = isImported ? `() => ${refName}` : refName;
 				this.writeln(`$(${name ? `"", ${name}` : ""})`).indent().writeln(`.refTo(${refExpr}${chain})`);
 				if (!ref.hasChain) {
 					if (ownerDecl?.node) {
@@ -1404,7 +1540,7 @@ else {
 		return [];
 	}
 	constructor(doc, opts) {
-		super(doc), _define_property(this, "opts", void 0), _define_property(this, "postAnnotate", void 0), _define_property(this, "_adHocAnnotations", void 0), _define_property(this, "_propPath", void 0), _define_property(this, "typeIds", void 0), this.opts = opts, this.postAnnotate = [], this._adHocAnnotations = null, this._propPath = [], this.typeIds = new Map();
+		super(doc), _define_property(this, "opts", void 0), _define_property(this, "postAnnotate", void 0), _define_property(this, "_adHocAnnotations", void 0), _define_property(this, "_propPath", void 0), _define_property(this, "typeIds", void 0), _define_property(this, "_unusedJs", void 0), _define_property(this, "_extendsRefs", void 0), _define_property(this, "_refSynthInfo", void 0), _define_property(this, "_synthImports", void 0), _define_property(this, "_synthComputed", void 0), _define_property(this, "_ownerCache", void 0), this.opts = opts, this.postAnnotate = [], this._adHocAnnotations = null, this._propPath = [], this.typeIds = new Map(), this._refSynthInfo = new Map(), this._synthImports = new Map(), this._synthComputed = false, this._ownerCache = new Map();
 	}
 };
 

package/dist/test-utils.cjs

@@ -1,6 +1,6 @@
 "use strict";
-const require_plugin = require('./plugin-cY7VLpmN.cjs');
-require('./json-schema-BgW_S2sP.cjs');
+const require_plugin = require('./plugin-C90RBCnx.cjs');
+require('./json-schema-Zi4TJzJJ.cjs');
 const path = require_plugin.__toESM(require("path"));
 const __atscript_core = require_plugin.__toESM(require("@atscript/core"));
 const fs = require_plugin.__toESM(require("fs"));

package/dist/test-utils.mjs

@@ -1,5 +1,5 @@
-import { tsPlugin } from "./plugin-D96fH7Va.mjs";
-import "./json-schema-DrJMwvm1.mjs";
+import { tsPlugin } from "./plugin-PADgal82.mjs";
+import "./json-schema-D_wrIxzk.mjs";
 import path from "path";
 import { build } from "@atscript/core";
 import { writeFileSync } from "fs";

package/dist/utils.cjs

@@ -1,5 +1,5 @@
 "use strict";
-const require_json_schema = require('./json-schema-BgW_S2sP.cjs');
+const require_json_schema = require('./json-schema-Zi4TJzJJ.cjs');
 
 //#region packages/typescript/src/runtime/default-value.ts
 /**
@@ -471,6 +471,7 @@ exports.createAnnotatedTypeNode = require_json_schema.createAnnotatedTypeNode
 exports.createDataFromAnnotatedType = createDataFromAnnotatedType
 exports.defineAnnotatedType = require_json_schema.defineAnnotatedType
 exports.deserializeAnnotatedType = deserializeAnnotatedType
+exports.detectDiscriminator = require_json_schema.detectDiscriminator
 exports.flattenAnnotatedType = flattenAnnotatedType
 exports.forAnnotatedType = require_json_schema.forAnnotatedType
 exports.fromJsonSchema = require_json_schema.fromJsonSchema

package/dist/utils.d.ts

@@ -292,6 +292,28 @@ declare function isAnnotatedTypeOfPrimitive(t: TAtscriptAnnotatedType): boolean;
 
 /** A JSON Schema object (draft-compatible). */
 type TJsonSchema = Record<string, any>;
+/**
+ * Describes a discriminator property shared by all variants of a union.
+ *
+ * Returned by {@link detectDiscriminator} when a union qualifies as a
+ * discriminated (a.k.a. tagged) union — every variant is an object that
+ * carries the same literal-valued property with a distinct value.
+ */
+type TUnionDiscriminator = {
+    /** Name of the discriminator property shared by all variants. */
+    propertyName: string;
+    /** Maps the literal value of `propertyName` → variant index in `items`. */
+    indexMapping: Record<string, number>;
+};
+/**
+ * Detects a discriminator property across union items.
+ *
+ * Scans all items for object-typed members that share a common property
+ * with distinct const/literal values. If exactly one such property exists,
+ * it is returned as the discriminator. Returns `null` when no qualifying
+ * property exists, or when more than one does (ambiguous).
+ */
+declare function detectDiscriminator(items: TAtscriptAnnotatedType[]): TUnionDiscriminator | null;
 /**
  * Builds a JSON Schema from an {@link TAtscriptAnnotatedType}.
  *
@@ -644,5 +666,5 @@ type NavPropsOf<T> = T extends {
     __navProps: infer N extends Record<string, unknown>;
 } ? N : Record<string, never>;
 
-export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };
-export type { AtscriptQueryComparison, AtscriptQueryFieldRef, AtscriptQueryNode, AtscriptRef, FlatOf, InferDataType, NavPropsOf, OwnPropsOf, PrimaryKeyOf, TAnnotatedTypeHandle, TAtscriptAnnotatedType, TAtscriptAnnotatedTypeConstructor, TAtscriptDataType, TAtscriptTypeArray, TAtscriptTypeComplex, TAtscriptTypeDef, TAtscriptTypeFinal, TAtscriptTypeObject, TCreateDataOptions, TFlattenOptions, TJsonSchema, TMetadataMap, TProcessAnnotationContext, TSerializeOptions, TSerializedAnnotatedType, TSerializedAnnotatedTypeInner, TSerializedTypeArray, TSerializedTypeComplex, TSerializedTypeDef, TSerializedTypeFinal, TSerializedTypeObject, TValidatorOptions, TValidatorPlugin, TValidatorPluginContext, TValueResolver };
+export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, detectDiscriminator, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };
+export type { AtscriptQueryComparison, AtscriptQueryFieldRef, AtscriptQueryNode, AtscriptRef, FlatOf, InferDataType, NavPropsOf, OwnPropsOf, PrimaryKeyOf, TAnnotatedTypeHandle, TAtscriptAnnotatedType, TAtscriptAnnotatedTypeConstructor, TAtscriptDataType, TAtscriptTypeArray, TAtscriptTypeComplex, TAtscriptTypeDef, TAtscriptTypeFinal, TAtscriptTypeObject, TCreateDataOptions, TFlattenOptions, TJsonSchema, TMetadataMap, TProcessAnnotationContext, TSerializeOptions, TSerializedAnnotatedType, TSerializedAnnotatedTypeInner, TSerializedTypeArray, TSerializedTypeComplex, TSerializedTypeDef, TSerializedTypeFinal, TSerializedTypeObject, TUnionDiscriminator, TValidatorOptions, TValidatorPlugin, TValidatorPluginContext, TValueResolver };

package/dist/utils.mjs

@@ -1,4 +1,4 @@
-import { Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, defineAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas } from "./json-schema-DrJMwvm1.mjs";
+import { Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, defineAnnotatedType, detectDiscriminator, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas } from "./json-schema-D_wrIxzk.mjs";
 
 //#region packages/typescript/src/runtime/default-value.ts
 /**
@@ -460,4 +460,4 @@ function deserializeTypeDef(t, resolved) {
 }
 
 //#endregion
-export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };
+export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, cloneRefProp, createAnnotatedTypeNode, createDataFromAnnotatedType, defineAnnotatedType, deserializeAnnotatedType, detectDiscriminator, flattenAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, mergeJsonSchemas, serializeAnnotatedType, throwFeatureDisabled };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/typescript",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "description": "Atscript: typescript-gen support.",
   "keywords": [
     "annotations",
@@ -73,7 +73,7 @@
   },
   "peerDependencies": {
     "@atscript/db": "^0.1.48",
-    "@atscript/core": "^0.1.51"
+    "@atscript/core": "^0.1.53"
   },
   "peerDependenciesMeta": {
     "@atscript/db": {