@zyno-io/ts-reflection 26.913.2245 → 26.914.1839

package/dist/reflection/compact-metadata.d.ts

@@ -11,8 +11,19 @@
  * instead of being decoded with different semantics.
  */
 export declare function decodeCompactMetadataV1<T>(serialized: string, references: readonly unknown[], resolveType?: (index: number) => unknown): T;
+/**
+ * Lazily reconstruct metadata serialized by the native type compiler.
+ *
+ * V2 stores repeated object and array subtrees in a graph table. The returned
+ * proxy intentionally does not parse that table until metadata is inspected.
+ * Compiler-generated assignments such as `metadata.classType = Target` are
+ * retained as overrides and therefore do not force eager materialization.
+ */
+export declare function decodeCompactMetadataV2<T extends object>(serialized: string, references: readonly unknown[], resolveType?: (index: number) => unknown): T;
 /** Create one lazy metadata-type registry for a generated module. */
 export declare function createCompactMetadataRegistryV1(serialized: string, references: readonly unknown[]): (index: number) => unknown;
+/** Create one fully lazy V2 metadata-type registry for a generated module. */
+export declare function createCompactMetadataRegistryV2(serialized: string, references: readonly unknown[]): (index: number) => unknown;
 /** Resolve metadata published by a type-only external import at first use. */
 export declare function resolveCompactMetadataAliasV1(loadModule: (() => unknown) | ((specifier: string) => unknown), specifierOrExportName: string, exportNameOrTypeName: string, maybeTypeName?: string): unknown;
 //# sourceMappingURL=compact-metadata.d.ts.map

package/dist/reflection/compact-metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compact-metadata.d.ts","sourceRoot":"","sources":["../../src/reflection/compact-metadata.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,OAAO,EAAE,EAAE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,CAAC,CAE1I;AAED,qEAAqE;AACrE,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,OAAO,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAmB9H;AAED,8EAA8E;AAC9E,wBAAgB,6BAA6B,CACzC,UAAU,EAAE,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,EAC9D,qBAAqB,EAAE,MAAM,EAC7B,oBAAoB,EAAE,MAAM,EAC5B,aAAa,CAAC,EAAE,MAAM,GACvB,OAAO,CAqBT"}
+{"version":3,"file":"compact-metadata.d.ts","sourceRoot":"","sources":["../../src/reflection/compact-metadata.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,OAAO,EAAE,EAAE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,CAAC,CAE1I;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,EACpD,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,SAAS,OAAO,EAAE,EAC9B,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GACzC,CAAC,CAMH;AAED,qEAAqE;AACrE,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,OAAO,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAmB9H;AAED,8EAA8E;AAC9E,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,OAAO,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAyB9H;AAED,8EAA8E;AAC9E,wBAAgB,6BAA6B,CACzC,UAAU,EAAE,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,EAC9D,qBAAqB,EAAE,MAAM,EAC7B,oBAAoB,EAAE,MAAM,EAC5B,aAAa,CAAC,EAAE,MAAM,GACvB,OAAO,CAqBT"}

package/dist/type-compiler/go/compact_metadata.go

@@ -2,7 +2,9 @@ package main
 
 import (
 	"bytes"
+	"crypto/sha256"
 	"encoding/json"
+	"fmt"
 	"strconv"
 	"strings"
 
@@ -12,13 +14,15 @@ import (
 
 const (
 	compactMetadataRuntimeSpec       = "@zyno-io/ts-reflection/type-metadata-runtime"
-	compactMetadataDecoderName       = "decodeCompactMetadataV1"
-	compactMetadataRegistryName      = "createCompactMetadataRegistryV1"
+	compactMetadataDecoderName       = "decodeCompactMetadataV2"
+	compactMetadataRegistryName      = "createCompactMetadataRegistryV2"
 	compactMetadataAliasResolverName = "resolveCompactMetadataAliasV1"
 	compactMetadataReferenceKey      = "$tsf"
 	compactMetadataImportKey         = "$tsfImport"
 	compactMetadataAliasKey          = "$tsfAlias"
 	compactMetadataTypeKey           = "$tsfType"
+	compactMetadataNodeKey           = "$tsfNode"
+	compactMetadataGraphMinBytes     = 64
 )
 
 type compactMetadataEncoding struct {
@@ -32,6 +36,23 @@ type compactMetadataEncoder struct {
 	referenceIndexes map[string]int
 	referenceKey     func(*shimast.Node) (string, bool)
 	runtimeRecipe    func(*compactMetadataEncoder, *shimast.Node) bool
+	graph            *compactMetadataGraph
+	graphRoot        *shimast.Node
+}
+
+type compactMetadataGraphNode struct {
+	key       string
+	size      int
+	container bool
+	shareable bool
+}
+
+type compactMetadataGraph struct {
+	info    map[*shimast.Node]compactMetadataGraphNode
+	counts  map[string]int
+	indexes map[string]int
+	nodes   []*shimast.Node
+	roots   map[*shimast.Node]bool
 }
 
 type compactMetadataRuntimeInterner struct {
@@ -129,7 +150,47 @@ func encodeCompactMetadataWithRuntimeRecipes(
 	}
 }
 
+func encodeCompactMetadataV2WithRuntimeRecipes(
+	root *shimast.Node,
+	referenceKey func(*shimast.Node) (string, bool),
+	runtimeRecipe func(*compactMetadataEncoder, *shimast.Node) bool,
+	metadataTypeResolver string,
+	preserveArrayElements bool,
+) compactMetadataEncoding {
+	encoder := &compactMetadataEncoder{
+		referenceIndexes: map[string]int{},
+		referenceKey:     referenceKey,
+		runtimeRecipe:    runtimeRecipe,
+	}
+	encoder.graph = buildCompactMetadataGraph(root, referenceKey, metadataTypeResolver)
+	if preserveArrayElements && root != nil && root.Kind == shimast.KindArrayLiteralExpression {
+		for _, element := range root.AsArrayLiteralExpression().Elements.Nodes {
+			encoder.graph.roots[element] = true
+		}
+	}
+	encoder.buffer.WriteString("[2,")
+	encoder.writeValue(root)
+	encoder.buffer.WriteString(",[")
+	for index := 0; index < len(encoder.graph.nodes); index++ {
+		if index != 0 {
+			encoder.buffer.WriteByte(',')
+		}
+		node := encoder.graph.nodes[index]
+		encoder.graphRoot = node
+		encoder.writeValue(node)
+		encoder.graphRoot = nil
+	}
+	encoder.buffer.WriteString("]]")
+	return compactMetadataEncoding{
+		serialized: encoder.buffer.String(),
+		references: encoder.references,
+	}
+}
+
 func (encoder *compactMetadataEncoder) writeValue(node *shimast.Node) {
+	if encoder.writeGraphReference(node) {
+		return
+	}
 	start := encoder.buffer.Len()
 	referenceStart := len(encoder.references)
 	if encoder.writeJSONValue(node) {
@@ -140,6 +201,26 @@ func (encoder *compactMetadataEncoder) writeValue(node *shimast.Node) {
 	encoder.writeReference(node)
 }
 
+func (encoder *compactMetadataEncoder) writeGraphReference(node *shimast.Node) bool {
+	if encoder.graph == nil || node == nil || node == encoder.graphRoot || encoder.graph.roots[node] {
+		return false
+	}
+	info, ok := encoder.graph.info[node]
+	if !ok || !info.container || !info.shareable || info.size < compactMetadataGraphMinBytes || encoder.graph.counts[info.key] < 2 {
+		return false
+	}
+	index, ok := encoder.graph.indexes[info.key]
+	if !ok {
+		index = len(encoder.graph.nodes)
+		encoder.graph.indexes[info.key] = index
+		encoder.graph.nodes = append(encoder.graph.nodes, node)
+	}
+	encoder.buffer.WriteString(`{"` + compactMetadataNodeKey + `":`)
+	encoder.buffer.WriteString(strconv.Itoa(index))
+	encoder.buffer.WriteByte('}')
+	return true
+}
+
 func (encoder *compactMetadataEncoder) writeJSONValue(node *shimast.Node) bool {
 	if node == nil {
 		return false
@@ -215,7 +296,8 @@ func (encoder *compactMetadataEncoder) writeObject(object *shimast.ObjectLiteral
 }
 
 func isCompactMetadataReservedKey(name string) bool {
-	return name == compactMetadataReferenceKey || name == compactMetadataImportKey || name == compactMetadataAliasKey || name == compactMetadataTypeKey
+	return name == compactMetadataReferenceKey || name == compactMetadataImportKey || name == compactMetadataAliasKey ||
+		name == compactMetadataTypeKey || name == compactMetadataNodeKey
 }
 
 func compactMetadataPropertyName(property *shimast.Node) (string, bool) {
@@ -302,6 +384,164 @@ func (encoder *compactMetadataEncoder) writeReferenceMarker(index int) {
 	encoder.buffer.WriteByte('}')
 }
 
+func buildCompactMetadataGraph(
+	root *shimast.Node,
+	referenceKey func(*shimast.Node) (string, bool),
+	metadataTypeResolver string,
+) *compactMetadataGraph {
+	graph := &compactMetadataGraph{
+		info:    map[*shimast.Node]compactMetadataGraphNode{},
+		counts:  map[string]int{},
+		indexes: map[string]int{},
+		roots:   map[*shimast.Node]bool{},
+	}
+	var fingerprint func(*shimast.Node) compactMetadataGraphNode
+	fingerprint = func(node *shimast.Node) compactMetadataGraphNode {
+		if node == nil {
+			return compactMetadataGraphNode{}
+		}
+		if cached, ok := graph.info[node]; ok {
+			return cached
+		}
+		if node.Kind == shimast.KindParenthesizedExpression {
+			result := fingerprint(node.AsParenthesizedExpression().Expression)
+			graph.info[node] = result
+			return result
+		}
+		result := compactMetadataGraphNode{}
+		var signature strings.Builder
+		switch node.Kind {
+		case shimast.KindObjectLiteralExpression:
+			object := node.AsObjectLiteralExpression()
+			if object == nil || object.Properties == nil {
+				result = compactMetadataGraphNode{key: compactMetadataFingerprint("o"), size: 2, container: true, shareable: true}
+				break
+			}
+			if len(object.Properties.Nodes) == 1 {
+				if name, ok := compactMetadataPropertyName(object.Properties.Nodes[0]); ok && isCompactMetadataReservedKey(name) {
+					break
+				}
+			}
+			signature.WriteString("object:")
+			size := 2
+			shareable := true
+			for _, property := range object.Properties.Nodes {
+				name, ok := compactMetadataPropertyName(property)
+				assignment := property.AsPropertyAssignment()
+				if !ok || name == "__proto__" || assignment == nil {
+					shareable = false
+					break
+				}
+				child := fingerprint(assignment.Initializer)
+				if !child.shareable {
+					shareable = false
+					break
+				}
+				signature.WriteString(strconv.Quote(name))
+				signature.WriteByte(':')
+				signature.WriteString(child.key)
+				signature.WriteByte(';')
+				size += len(strconv.Quote(name)) + 1 + child.size + 1
+			}
+			if shareable {
+				result = compactMetadataGraphNode{key: compactMetadataFingerprint(signature.String()), size: size, container: true, shareable: true}
+			}
+		case shimast.KindArrayLiteralExpression:
+			array := node.AsArrayLiteralExpression()
+			signature.WriteString("array:")
+			size := 2
+			shareable := array != nil
+			if shareable && array.Elements != nil {
+				for _, element := range array.Elements.Nodes {
+					if element == nil || element.Kind == shimast.KindOmittedExpression || element.Kind == shimast.KindSpreadElement {
+						shareable = false
+						break
+					}
+					child := fingerprint(element)
+					if !child.shareable {
+						shareable = false
+						break
+					}
+					signature.WriteString(child.key)
+					signature.WriteByte(';')
+					size += child.size + 1
+				}
+			}
+			if shareable {
+				result = compactMetadataGraphNode{key: compactMetadataFingerprint(signature.String()), size: size, container: true, shareable: true}
+			}
+		case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+			value, _ := json.Marshal(node.Text())
+			result = compactMetadataGraphNode{key: compactMetadataFingerprint("string:" + string(value)), size: len(value), shareable: true}
+		case shimast.KindNumericLiteral:
+			if json.Valid([]byte(node.Text())) {
+				result = compactMetadataGraphNode{key: compactMetadataFingerprint("number:" + node.Text()), size: len(node.Text()), shareable: true}
+			}
+		case shimast.KindTrueKeyword:
+			result = compactMetadataGraphNode{key: compactMetadataFingerprint("true"), size: 4, shareable: true}
+		case shimast.KindFalseKeyword:
+			result = compactMetadataGraphNode{key: compactMetadataFingerprint("false"), size: 5, shareable: true}
+		case shimast.KindNullKeyword:
+			result = compactMetadataGraphNode{key: compactMetadataFingerprint("null"), size: 4, shareable: true}
+		case shimast.KindPrefixUnaryExpression:
+			unary := node.AsPrefixUnaryExpression()
+			if unary != nil && unary.Operator == shimast.KindMinusToken && unary.Operand != nil && unary.Operand.Kind == shimast.KindNumericLiteral {
+				value := "-" + unary.Operand.Text()
+				if json.Valid([]byte(value)) {
+					result = compactMetadataGraphNode{key: compactMetadataFingerprint("number:" + value), size: len(value), shareable: true}
+				}
+			}
+		default:
+			if index, ok := compactMetadataTypeRecipe(node, metadataTypeResolver); ok {
+				value := fmt.Sprintf("type:%d", index)
+				result = compactMetadataGraphNode{key: compactMetadataFingerprint(value), size: len(value) + 8, shareable: true}
+			} else if referenceKey != nil {
+				if key, ok := referenceKey(node); ok {
+					result = compactMetadataGraphNode{key: compactMetadataFingerprint("reference:" + key), size: len(key) + 8, shareable: true}
+				}
+			}
+		}
+		graph.info[node] = result
+		if result.container && result.shareable && result.size >= compactMetadataGraphMinBytes {
+			graph.counts[result.key]++
+		}
+		return result
+	}
+	fingerprint(root)
+	return graph
+}
+
+func compactMetadataFingerprint(value string) string {
+	hash := sha256.Sum256([]byte(value))
+	return string(hash[:])
+}
+
+func compactMetadataEncodingForSizeGuard(
+	metadata *shimast.Node,
+	imports *astImportRegistry,
+	runtimeReferences *compactMetadataRuntimeInterner,
+	metadataTypeResolver string,
+	preserveArrayElements bool,
+	inlinePureJSON bool,
+) compactMetadataEncoding {
+	runtimeRecipe := func(encoder *compactMetadataEncoder, expression *shimast.Node) bool {
+		return writeCompactMetadataRuntimeRecipe(encoder, expression, imports, metadataTypeResolver)
+	}
+	if inlinePureJSON {
+		encoding := encodeCompactMetadataWithRuntimeRecipes(metadata, runtimeReferences.deduplicationKey, runtimeRecipe)
+		if len(encoding.references) == 0 && !strings.Contains(encoding.serialized, `"$tsf`) {
+			return encoding
+		}
+	}
+	return encodeCompactMetadataV2WithRuntimeRecipes(
+		metadata,
+		runtimeReferences.deduplicationKey,
+		runtimeRecipe,
+		metadataTypeResolver,
+		preserveArrayElements,
+	)
+}
+
 func materializeCompactMetadataExpression(
 	ec *shimprinter.EmitContext,
 	imports *astImportRegistry,
@@ -322,9 +562,10 @@ func materializeCompactAliasMetadataExpression(
 	runtimeReferences *compactMetadataRuntimeInterner,
 	template expressionTemplate,
 	metadataTypeResolver string,
+	inlinePureJSON bool,
 ) *shimast.Node {
 	metadata := template.materialize(ec, imports)
-	return materializeCompactMetadataNode(ec, imports, runtimeReferences, metadata, metadataTypeResolver, false, true)
+	return materializeCompactMetadataNode(ec, imports, runtimeReferences, metadata, metadataTypeResolver, false, inlinePureJSON)
 }
 
 func materializeCompactMetadataRegistry(
@@ -351,12 +592,46 @@ func materializeCompactMetadataNode(
 	registry bool,
 	inlinePureJSON bool,
 ) *shimast.Node {
-	encoding := encodeCompactMetadataWithRuntimeRecipes(
+	encodeV1 := func() compactMetadataEncoding {
+		return encodeCompactMetadataWithRuntimeRecipes(
+			metadata,
+			runtimeReferences.deduplicationKey,
+			func(encoder *compactMetadataEncoder, expression *shimast.Node) bool {
+				return writeCompactMetadataRuntimeRecipe(encoder, expression, imports, metadataTypeResolver)
+			},
+		)
+	}
+	if inlinePureJSON {
+		encoding := encodeV1()
+		if len(encoding.references) == 0 && !strings.Contains(encoding.serialized, `"$tsf`) {
+			parsed := ec.Factory.NewCallExpression(
+				ec.Factory.NewPropertyAccessExpression(
+					ec.Factory.NewIdentifier("JSON"),
+					nil,
+					ec.Factory.NewIdentifier("parse"),
+					shimast.NodeFlagsNone,
+				),
+				nil,
+				nil,
+				ec.Factory.NewNodeList([]*shimast.Node{ec.Factory.NewStringLiteral(encoding.serialized, shimast.TokenFlagsNone)}),
+				shimast.NodeFlagsNone,
+			)
+			return ec.Factory.NewElementAccessExpression(
+				parsed,
+				nil,
+				ec.Factory.NewNumericLiteral("1", shimast.TokenFlagsNone),
+				shimast.NodeFlagsNone,
+			)
+		}
+	}
+	encoding := encodeCompactMetadataV2WithRuntimeRecipes(
 		metadata,
 		runtimeReferences.deduplicationKey,
 		func(encoder *compactMetadataEncoder, expression *shimast.Node) bool {
 			return writeCompactMetadataRuntimeRecipe(encoder, expression, imports, metadataTypeResolver)
 		},
+		metadataTypeResolver,
+		registry,
 	)
 	references := make([]*shimast.Node, 0, len(encoding.references))
 	for _, reference := range encoding.references {
@@ -366,26 +641,6 @@ func materializeCompactMetadataNode(
 		// its original binding.
 		references = append(references, ec.Factory.DeepCloneNode(reference))
 	}
-	if inlinePureJSON && len(references) == 0 && !strings.Contains(encoding.serialized, `"$tsf`) {
-		parsed := ec.Factory.NewCallExpression(
-			ec.Factory.NewPropertyAccessExpression(
-				ec.Factory.NewIdentifier("JSON"),
-				nil,
-				ec.Factory.NewIdentifier("parse"),
-				shimast.NodeFlagsNone,
-			),
-			nil,
-			nil,
-			ec.Factory.NewNodeList([]*shimast.Node{ec.Factory.NewStringLiteral(encoding.serialized, shimast.TokenFlagsNone)}),
-			shimast.NodeFlagsNone,
-		)
-		return ec.Factory.NewElementAccessExpression(
-			parsed,
-			nil,
-			ec.Factory.NewNumericLiteral("1", shimast.TokenFlagsNone),
-			shimast.NodeFlagsNone,
-		)
-	}
 	helperName := compactMetadataDecoderName
 	if registry {
 		helperName = compactMetadataRegistryName

package/dist/type-compiler/go/emission_plan.go

@@ -6,18 +6,22 @@ import (
 	"strings"
 
 	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimprinter "github.com/microsoft/typescript-go/shim/printer"
 	"github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
+const maxCompactMetadataPayloadBytes = 1024 * 1024
+
 type emissionPlans map[string]*fileEmissionPlan
 
 type fileEmissionPlan struct {
-	calls                map[int]callEmissionPlan
-	classes              map[int]classEmissionPlan
-	aliases              *expressionTemplate
-	metadataTypes        []expressionTemplate
-	metadataTypeResolver string
-	commonJS             bool
+	calls                 map[int]callEmissionPlan
+	classes               map[int]classEmissionPlan
+	aliases               *expressionTemplate
+	metadataTypes         []expressionTemplate
+	metadataTypeResolver  string
+	decodePureJSONAliases bool
+	commonJS              bool
 }
 
 type callEmissionPlan struct {
@@ -95,8 +99,9 @@ func buildEmissionPlans(reg *registry, program *driver.Program, emitTypeAliases
 			continue
 		}
 		plan := &fileEmissionPlan{
-			calls:   map[int]callEmissionPlan{},
-			classes: map[int]classEmissionPlan{},
+			calls:                 map[int]callEmissionPlan{},
+			classes:               map[int]classEmissionPlan{},
+			decodePureJSONAliases: emitMetadataRuntimeImport,
 		}
 		metadataTypes := newMetadataTypeInterner(info.file.Text())
 		if program != nil && program.TSProgram != nil {
@@ -145,6 +150,9 @@ func buildEmissionPlans(reg *registry, program *driver.Program, emitTypeAliases
 				plan.aliases = &template
 			}
 		}
+		if err := validateCompactMetadataSizes(info, plan); err != nil {
+			return nil, err
+		}
 		if !emitMetadataRuntimeImport {
 			if requirement := metadataRuntimeRequirement(plan); requirement != "" {
 				return nil, fmt.Errorf(
@@ -162,6 +170,88 @@ func buildEmissionPlans(reg *registry, program *driver.Program, emitTypeAliases
 	return plans, nil
 }
 
+func validateCompactMetadataSizes(info *fileInfo, plan *fileEmissionPlan) error {
+	if info == nil || info.file == nil || plan == nil {
+		return nil
+	}
+	ec := shimprinter.NewEmitContext()
+	imports := newAstImportRegistry(ec, info.file, plan.commonJS)
+	runtimeReferences := newCompactMetadataRuntimeInterner(ec, info.file)
+	validate := func(surface string, template expressionTemplate, preserveArrayElements bool, inlinePureJSON bool) error {
+		metadata := template.materialize(ec, imports)
+		encoding := compactMetadataEncodingForSizeGuard(
+			metadata,
+			imports,
+			runtimeReferences,
+			plan.metadataTypeResolver,
+			preserveArrayElements,
+			inlinePureJSON,
+		)
+		if len(encoding.serialized) > maxCompactMetadataPayloadBytes {
+			return fmt.Errorf(
+				"%s: compact metadata for %s is %d bytes after graph interning; limit is %d bytes",
+				info.file.FileName(),
+				surface,
+				len(encoding.serialized),
+				maxCompactMetadataPayloadBytes,
+			)
+		}
+		return nil
+	}
+
+	classPositions := make([]int, 0, len(plan.classes))
+	for position := range plan.classes {
+		classPositions = append(classPositions, position)
+	}
+	sort.Ints(classPositions)
+	for _, position := range classPositions {
+		class := plan.classes[position]
+		if err := validate("class "+class.name, class.metadata, false, false); err != nil {
+			return err
+		}
+	}
+	callPositions := make([]int, 0, len(plan.calls))
+	for position := range plan.calls {
+		callPositions = append(callPositions, position)
+	}
+	sort.Ints(callPositions)
+	for _, position := range callPositions {
+		call := plan.calls[position]
+		if err := validate("call "+call.name, call.metadata, false, false); err != nil {
+			return err
+		}
+	}
+	if plan.aliases != nil {
+		if err := validate("exported aliases", *plan.aliases, false, !plan.decodePureJSONAliases); err != nil {
+			return err
+		}
+	}
+	if len(plan.metadataTypes) != 0 {
+		elements := make([]*shimast.Node, 0, len(plan.metadataTypes))
+		for _, template := range plan.metadataTypes {
+			elements = append(elements, template.materialize(ec, imports))
+		}
+		metadata := ec.Factory.NewArrayLiteralExpression(ec.Factory.NewNodeList(elements), false)
+		encoding := compactMetadataEncodingForSizeGuard(
+			metadata,
+			imports,
+			runtimeReferences,
+			plan.metadataTypeResolver,
+			true,
+			false,
+		)
+		if len(encoding.serialized) > maxCompactMetadataPayloadBytes {
+			return fmt.Errorf(
+				"%s: compact metadata for shared type registry is %d bytes after graph interning; limit is %d bytes",
+				info.file.FileName(),
+				len(encoding.serialized),
+				maxCompactMetadataPayloadBytes,
+			)
+		}
+	}
+	return nil
+}
+
 // metadataRuntimeRequirement reports the first generated construct that cannot
 // be emitted without TSF's compact metadata runtime. Alias registries made only
 // of JSON stay self-contained; all other current metadata surfaces use runtime
@@ -170,7 +260,7 @@ func metadataRuntimeRequirement(plan *fileEmissionPlan) string {
 	if plan == nil {
 		return ""
 	}
-	if plan.aliases != nil && !compactMetadataIsPureJSON(plan.aliases.parsed) {
+	if plan.aliases != nil && (plan.decodePureJSONAliases || !compactMetadataIsPureJSON(plan.aliases.parsed)) {
 		if names := runtimeAliasMetadataNames(plan.aliases.parsed); len(names) != 0 {
 			return "reflected alias metadata for " + strings.Join(names, ", ")
 		}
@@ -236,6 +326,10 @@ func aliasMetadataExpression(info *fileInfo, reg *registry) string {
 			}
 			continue
 		}
+		if ref, ok := reexportedTypeMetadataReference(info, reg, name); ok {
+			entries = append(entries, quote(name)+": "+externalImportedTypeExpr(ref, name))
+			continue
+		}
 		if alias, owner, _, ok := resolveExportedAlias(info, reg, name, map[string]bool{}); ok {
 			if len(alias.params) == 0 {
 				if expr := cachedAliasTypeExpr(owner, reg, alias); expr != "" && !metadataExprTooLarge(expr) {
@@ -256,6 +350,56 @@ func aliasMetadataExpression(info *fileInfo, reg *registry) string {
 	return "{" + strings.Join(entries, ", ") + "}"
 }
 
+// Re-exporting a type must not copy the owner's complete structural metadata
+// into every barrel. Point at the immediate owning module when this compilation
+// emits that module's alias table; it may itself contain another recipe when the
+// export crosses more than one barrel. Declaration-only dependencies do not
+// necessarily publish runtime alias metadata, so keep their structural metadata
+// at the first emitted boundary instead of producing an unresolvable recipe.
+func reexportedTypeMetadataReference(info *fileInfo, reg *registry, name string) (importRef, bool) {
+	if info == nil || reg == nil {
+		return importRef{}, false
+	}
+	if ref, ok := info.reexports[name]; ok {
+		if target := reg.byPath[ref.source]; canPublishTypeMetadata(target) && exportedTypeMetadataExists(target, reg, ref.exportName) {
+			ref.spec = emittedMetadataOwnerSpecifier(info, target, ref.spec)
+			return ref, ref.spec != "" && ref.exportName != ""
+		}
+	}
+	for _, ref := range info.exportStar {
+		target := reg.byPath[ref.source]
+		if !canPublishTypeMetadata(target) || !exportedTypeMetadataExists(target, reg, name) {
+			continue
+		}
+		ref.exportName = name
+		ref.spec = emittedMetadataOwnerSpecifier(info, target, ref.spec)
+		return ref, ref.spec != ""
+	}
+	return importRef{}, false
+}
+
+func canPublishTypeMetadata(info *fileInfo) bool {
+	return info != nil && info.file != nil && !info.file.IsDeclarationFile
+}
+
+func emittedMetadataOwnerSpecifier(info *fileInfo, target *fileInfo, spec string) string {
+	if info == nil || info.file == nil || target == nil || target.file == nil || !strings.HasPrefix(spec, ".") {
+		return spec
+	}
+	// Use an explicit runtime file rather than syntactically appending `.js` to
+	// the source specifier. The latter turns `./directory` into a nonexistent
+	// `./directory.js` instead of the emitted `./directory/index.js`.
+	return moduleSpecifierForOutput(info.file.FileName(), target.file.FileName(), true)
+}
+
+func exportedTypeMetadataExists(info *fileInfo, reg *registry, name string) bool {
+	if _, _, _, ok := resolveExportedAlias(info, reg, name, map[string]bool{}); ok {
+		return true
+	}
+	_, _, _, ok := resolveExportedInterfaceDecl(info, reg, name, map[string]bool{})
+	return ok
+}
+
 func cachedAliasTypeExpr(info *fileInfo, reg *registry, alias aliasInfo) string {
 	if alias.metadataTooLarge {
 		return ""

package/dist/type-compiler/go/emit_ast.go

@@ -317,6 +317,7 @@ func metadataTransform(plans emissionPlans) driver.PluginTransform {
 				runtimeReferences,
 				*plan.aliases,
 				plan.metadataTypeResolver,
+				!plan.decodePureJSONAliases,
 			))
 		}
 		declarations := []*shimast.Node{}

package/dist/type-compiler/go/emit_ast_test.go

@@ -233,6 +233,10 @@ func TestMetadataRuntimeRequirementAllowsPureJSONAliases(t *testing.T) {
 	if got := metadataRuntimeRequirement(plan); got != "" {
 		t.Fatalf("pure JSON aliases require metadata runtime: %s", got)
 	}
+	plan.decodePureJSONAliases = true
+	if got := metadataRuntimeRequirement(plan); got != "reflected alias metadata" {
+		t.Fatalf("lazy pure JSON alias requirement = %q", got)
+	}
 }
 
 func TestMetadataRuntimeRequirementRejectsRuntimeAliasValues(t *testing.T) {
@@ -348,6 +352,7 @@ func TestCompactMetadataEncoderEscapesReferenceMarkerCollision(t *testing.T) {
 		`{"$tsfImport": [0, "Model"]}`,
 		`{"$tsfAlias": [0, "Alias", "Alias"]}`,
 		`{"$tsfType": 0}`,
+		`{"$tsfNode": 0}`,
 	} {
 		template, err := parseExpressionTemplate(source)
 		if err != nil {
@@ -417,6 +422,113 @@ func TestCompactMetadataEncoderDeduplicatesGeneratedRuntimeThunks(t *testing.T)
 	}
 }
 
+func TestCompactMetadataV2InternsRepeatedGraphsWithRuntimeReferences(t *testing.T) {
+	file := parseTestSourceFile(t, "/project/model.ts", `class Model {}`)
+	template, err := parseExpressionTemplate(`{
+		first: {kind: 16, classType: () => Model, properties: [{name: "value", type: {kind: 6}}]},
+		second: {kind: 16, classType: () => Model, properties: [{name: "value", type: {kind: 6}}]}
+	}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ec := shimprinter.NewEmitContext()
+	interner := newCompactMetadataRuntimeInterner(ec, file)
+	encoding := encodeCompactMetadataV2WithRuntimeRecipes(template.parsed, interner.deduplicationKey, nil, "", false)
+	if !strings.HasPrefix(encoding.serialized, `[2,`) {
+		t.Fatalf("V2 compact payload = %s", encoding.serialized)
+	}
+	if strings.Count(encoding.serialized, `{"$tsfNode":0}`) != 2 {
+		t.Fatalf("repeated graph was not interned: %s", encoding.serialized)
+	}
+	if len(encoding.references) != 1 {
+		t.Fatalf("runtime references = %d, want 1", len(encoding.references))
+	}
+}
+
+func TestAliasMetadataUsesOwnerRecipesForReexports(t *testing.T) {
+	originFile := parseTestSourceFile(t, "/project/origin/index.ts", `export type Shared = { value: string }`)
+	barrelFile := parseTestSourceFile(t, "/project/barrel.ts", `export * from "./origin"`)
+	origin := &fileInfo{
+		file:       originFile,
+		moduleKey:  moduleKey(originFile.FileName()),
+		aliases:    map[string]aliasInfo{"Shared": {body: `{ value: string }`, exported: true}},
+		interfaces: map[string][]interfaceInfo{},
+		reexports:  map[string]importRef{},
+	}
+	barrel := &fileInfo{
+		file:       barrelFile,
+		moduleKey:  moduleKey(barrelFile.FileName()),
+		aliases:    map[string]aliasInfo{},
+		interfaces: map[string][]interfaceInfo{},
+		reexports:  map[string]importRef{},
+		exportStar: []importRef{{source: origin.moduleKey, spec: "./origin"}},
+	}
+	reg := &registry{byPath: map[string]*fileInfo{origin.moduleKey: origin, barrel.moduleKey: barrel}}
+
+	got := aliasMetadataExpression(barrel, reg)
+	assertContainsAll(t, got, `"Shared": __tsf_runtime_alias__("./origin/index.js", "Shared", "Shared")`)
+	assertNotContains(t, got, `name: "value"`)
+}
+
+func TestAliasMetadataExpandsDeclarationOnlyReexportBoundary(t *testing.T) {
+	originFile := parseTestSourceFile(t, "/dependencies/origin.d.ts", `export type Shared = { value: string }`)
+	barrelFile := parseTestSourceFile(t, "/project/barrel.ts", `export * from "external-package"`)
+	origin := &fileInfo{
+		file:       originFile,
+		moduleKey:  moduleKey(originFile.FileName()),
+		aliases:    map[string]aliasInfo{"Shared": {body: `{ value: string }`, exported: true}},
+		interfaces: map[string][]interfaceInfo{},
+		reexports:  map[string]importRef{},
+	}
+	barrel := &fileInfo{
+		file:       barrelFile,
+		moduleKey:  moduleKey(barrelFile.FileName()),
+		aliases:    map[string]aliasInfo{},
+		interfaces: map[string][]interfaceInfo{},
+		reexports:  map[string]importRef{},
+		exportStar: []importRef{{source: origin.moduleKey, spec: "external-package"}},
+	}
+	reg := &registry{byPath: map[string]*fileInfo{origin.moduleKey: origin, barrel.moduleKey: barrel}}
+
+	got := aliasMetadataExpression(barrel, reg)
+	assertContainsAll(t, got, `"Shared":`, `name: "value"`)
+	assertNotContains(t, got, `__tsf_runtime_alias__`)
+}
+
+func TestCompactMetadataSizeGuardRejectsOversizedPayload(t *testing.T) {
+	file := parseTestSourceFile(t, "/project/oversized.ts", `class Oversized {}`)
+	template, err := parseExpressionTemplate(`{kind: 2, typeName: "` + strings.Repeat("x", maxCompactMetadataPayloadBytes) + `"}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan := &fileEmissionPlan{
+		calls:    map[int]callEmissionPlan{},
+		classes:  map[int]classEmissionPlan{1: {name: "Oversized", metadata: template}},
+		commonJS: true,
+	}
+	err = validateCompactMetadataSizes(&fileInfo{file: file}, plan)
+	if err == nil || !strings.Contains(err.Error(), "limit is 1048576 bytes") {
+		t.Fatalf("size guard error = %v", err)
+	}
+}
+
+func TestCompactMetadataSizeGuardMeasuresAfterGraphInterning(t *testing.T) {
+	file := parseTestSourceFile(t, "/project/compacted.ts", `class Compacted {}`)
+	repeated := strings.Repeat("x", maxCompactMetadataPayloadBytes/2+1024)
+	template, err := parseExpressionTemplate(`{first: {value: "` + repeated + `"}, second: {value: "` + repeated + `"}}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan := &fileEmissionPlan{
+		calls:    map[int]callEmissionPlan{},
+		classes:  map[int]classEmissionPlan{1: {name: "Compacted", metadata: template}},
+		commonJS: true,
+	}
+	if err := validateCompactMetadataSizes(&fileInfo{file: file}, plan); err != nil {
+		t.Fatalf("compacted metadata failed size guard: %v", err)
+	}
+}
+
 func TestMetadataTypeInternerKeepsRuntimeExpressionsAtUseSite(t *testing.T) {
 	interner := newMetadataTypeInterner("")
 	runtime := `{kind: 16, classType: () => LocalModel}`

package/dist/type-metadata-runtime.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=1,t=`$tsf`,n=`$tsfImport`,r=`$tsfAlias`,i=`$tsfType`;function a(e,t,n){return l(c(e),t,n)}function o(e,t){let n=c(e);if(!Array.isArray(n))throw Error(`Invalid TSF compact metadata registry`);let r=Array(n.length),i=new Uint8Array(n.length),a=e=>{if(!Number.isSafeInteger(e)||e<0||e>=n.length)throw Error(`Invalid TSF compact metadata type ${e}`);return i[e]||(i[e]=1,r[e]=n[e],r[e]=l(n[e],t,a)),r[e]};return a}function s(e,t,n,r){let[i,a,o]=r===void 0?[e,t,n]:[()=>e(t),n,r],s;try{let e=i();e&&typeof e==`object`&&(s=e)}catch{}let c=s?.__tsfTypeAliases?.[a];return c&&typeof c==`object`?{...c,typeName:o}:{kind:16,typeName:o,classType:()=>s?.[a]}}function c(t){let n=JSON.parse(t);if(!Array.isArray(n)||n.length!==2||n[0]!==e)throw Error(`Unsupported TSF compact metadata format`);return n[1]}function l(e,a,o){if(!e||typeof e!=`object`)return e;if(f(e))return u(a,e[t]);if(p(e)){let t=e[n],[r,i]=t.length===2?t:[t[0],t[2]],o=d(a,r,t.length===3?t[1]:void 0);return()=>o()?.[i]}if(m(e)){let t=e[r],[n,i,o]=t.length===3?t:[t[0],t[2],t[3]];return s(d(a,n,t.length===4?t[1]:void 0),i,o)}if(h(e)){if(!o)throw Error(`Missing TSF compact metadata type registry`);return o(e[i])}if(Array.isArray(e)){for(let t=0;t<e.length;t++)e[t]=l(e[t],a,o);return e}let c=e;for(let e of Object.keys(c))c[e]=l(c[e],a,o);return c}function u(e,t){if(t<0||t>=e.length)throw Error(`Invalid TSF compact metadata reference ${t}`);return e[t]}function d(e,t,n){let r=u(e,t);if(typeof r!=`function`)throw Error(`Invalid TSF compact metadata module loader ${t}`);return n===void 0?r:()=>{try{return r(n)}catch{return}}}function f(e){if(Array.isArray(e))return!1;let n=Object.keys(e);return n.length===1&&n[0]===t&&Number.isSafeInteger(e[t])}function p(e){if(Array.isArray(e))return!1;let t=Object.keys(e),r=e[n];return t.length===1&&t[0]===n&&Array.isArray(r)&&(r.length===2||r.length===3)&&Number.isSafeInteger(r[0])&&typeof r[1]==`string`&&(r.length===2||typeof r[2]==`string`)}function m(e){if(Array.isArray(e))return!1;let t=Object.keys(e),n=e[r];return t.length===1&&t[0]===r&&Array.isArray(n)&&(n.length===3||n.length===4)&&Number.isSafeInteger(n[0])&&typeof n[1]==`string`&&typeof n[2]==`string`&&(n.length===3||typeof n[3]==`string`)}function h(e){if(Array.isArray(e))return!1;let t=Object.keys(e);return t.length===1&&t[0]===i&&Number.isSafeInteger(e[i])}exports.createCompactMetadataRegistryV1=o,exports.decodeCompactMetadataV1=a,exports.resolveCompactMetadataAliasV1=s;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=1,t=`$tsf`,n=`$tsfImport`,r=`$tsfAlias`,i=`$tsfType`,a=`$tsfNode`;function o(e,t,n){return p(d(e),t,n)}function s(e,t,n){return h(()=>{let[r,i]=f(e);return p(r,t,n,m(i,t,n))})}function c(e,t){let n=d(e);if(!Array.isArray(n))throw Error(`Invalid TSF compact metadata registry`);let r=Array.from({length:n.length}),i=new Uint8Array(n.length),a=e=>{if(!Number.isSafeInteger(e)||e<0||e>=n.length)throw Error(`Invalid TSF compact metadata type ${e}`);return i[e]||(i[e]=1,r[e]=n[e],r[e]=p(n[e],t,a)),r[e]};return a}function l(e,t){let n,r,i,a,o=s=>{if(!n){let[s,c]=f(e);if(!Array.isArray(s))throw Error(`Invalid TSF compact metadata registry`);n=s,i=Array.from({length:s.length}),a=new Uint8Array(s.length),r=m(c,t,o)}if(!Number.isSafeInteger(s)||s<0||s>=n.length)throw Error(`Invalid TSF compact metadata type ${s}`);return a[s]||(a[s]=1,i[s]=n[s],i[s]=p(n[s],t,o,r)),i[s]};return o}function u(e,t,n,r){let[i,a,o]=r===void 0?[e,t,n]:[()=>e(t),n,r],s;try{let e=i();e&&typeof e==`object`&&(s=e)}catch{}let c=s?.__tsfTypeAliases?.[a];return c&&typeof c==`object`?{...c,typeName:o}:{kind:16,typeName:o,classType:()=>s?.[a]}}function d(t){let n=JSON.parse(t);if(!Array.isArray(n)||n.length!==2||n[0]!==e)throw Error(`Unsupported TSF compact metadata format`);return n[1]}function f(e){let t=JSON.parse(e);if(!Array.isArray(t)||t.length!==3||t[0]!==2||!Array.isArray(t[2]))throw Error(`Unsupported TSF compact metadata format`);return[t[1],t[2]]}function p(e,o,s,c){if(!e||typeof e!=`object`)return e;if(v(e))return g(o,e[t]);if(y(e)){let t=e[n],[r,i]=t.length===2?t:[t[0],t[2]],a=_(o,r,t.length===3?t[1]:void 0);return()=>a()?.[i]}if(b(e)){let t=e[r],[n,i,a]=t.length===3?t:[t[0],t[2],t[3]];return u(_(o,n,t.length===4?t[1]:void 0),i,a)}if(x(e)){if(!s)throw Error(`Missing TSF compact metadata type registry`);return s(e[i])}if(S(e)){if(!c)throw Error(`Missing TSF compact metadata node registry`);return c(e[a])}if(Array.isArray(e)){for(let t=0;t<e.length;t++)e[t]=p(e[t],o,s,c);return e}let l=e;for(let e of Object.keys(l))l[e]=p(l[e],o,s,c);return l}function m(e,t,n){let r=Array.from({length:e.length}),i=new Uint8Array(e.length),a=o=>{if(!Number.isSafeInteger(o)||o<0||o>=e.length)throw Error(`Invalid TSF compact metadata node ${o}`);return i[o]||(i[o]=1,r[o]=e[o],r[o]=p(e[o],t,n,a)),r[o]};return a}function h(e){let t={},n=!1,r=()=>{if(n)return;let r=e();if(!r||typeof r!=`object`)throw Error(`Invalid TSF compact metadata root`);for(let e of Reflect.ownKeys(r)){if(Object.prototype.hasOwnProperty.call(t,e))continue;let n=Object.getOwnPropertyDescriptor(r,e);n&&Object.defineProperty(t,e,n)}n=!0};return new Proxy(t,{get(e,t,n){return r(),Reflect.get(e,t,n)},set(e,t,n){return Reflect.set(e,t,n,e)},has(e,t){return r(),Reflect.has(e,t)},ownKeys(e){return r(),Reflect.ownKeys(e)},getOwnPropertyDescriptor(e,t){return r(),Reflect.getOwnPropertyDescriptor(e,t)},defineProperty(e,t,n){return Reflect.defineProperty(e,t,n)},deleteProperty(e,t){return r(),Reflect.deleteProperty(e,t)},getPrototypeOf(e){return r(),Reflect.getPrototypeOf(e)},setPrototypeOf(e,t){return r(),Reflect.setPrototypeOf(e,t)},isExtensible(e){return Reflect.isExtensible(e)},preventExtensions(e){return r(),Reflect.preventExtensions(e)}})}function g(e,t){if(t<0||t>=e.length)throw Error(`Invalid TSF compact metadata reference ${t}`);return e[t]}function _(e,t,n){let r=g(e,t);if(typeof r!=`function`)throw Error(`Invalid TSF compact metadata module loader ${t}`);return n===void 0?r:()=>{try{return r(n)}catch{return}}}function v(e){if(Array.isArray(e))return!1;let n=Object.keys(e);return n.length===1&&n[0]===t&&Number.isSafeInteger(e[t])}function y(e){if(Array.isArray(e))return!1;let t=Object.keys(e),r=e[n];return t.length===1&&t[0]===n&&Array.isArray(r)&&(r.length===2||r.length===3)&&Number.isSafeInteger(r[0])&&typeof r[1]==`string`&&(r.length===2||typeof r[2]==`string`)}function b(e){if(Array.isArray(e))return!1;let t=Object.keys(e),n=e[r];return t.length===1&&t[0]===r&&Array.isArray(n)&&(n.length===3||n.length===4)&&Number.isSafeInteger(n[0])&&typeof n[1]==`string`&&typeof n[2]==`string`&&(n.length===3||typeof n[3]==`string`)}function x(e){if(Array.isArray(e))return!1;let t=Object.keys(e);return t.length===1&&t[0]===i&&Number.isSafeInteger(e[i])}function S(e){if(Array.isArray(e))return!1;let t=Object.keys(e);return t.length===1&&t[0]===a&&Number.isSafeInteger(e[a])}exports.createCompactMetadataRegistryV1=c,exports.createCompactMetadataRegistryV2=l,exports.decodeCompactMetadataV1=o,exports.decodeCompactMetadataV2=s,exports.resolveCompactMetadataAliasV1=u;

package/dist/type-metadata-runtime.js

@@ -1,18 +1,36 @@
 //#region src/reflection/compact-metadata.ts
-var e = "$tsf", t = "$tsfImport", n = "$tsfAlias", r = "$tsfType";
-function i(e, t, n) {
-	return c(s(e), t, n);
+var e = "$tsf", t = "$tsfImport", n = "$tsfAlias", r = "$tsfType", i = "$tsfNode";
+function a(e, t, n) {
+	return f(u(e), t, n);
 }
-function a(e, t) {
-	let n = s(e);
+function o(e, t, n) {
+	return m(() => {
+		let [r, i] = d(e);
+		return f(r, t, n, p(i, t, n));
+	});
+}
+function s(e, t) {
+	let n = u(e);
 	if (!Array.isArray(n)) throw Error("Invalid TSF compact metadata registry");
-	let r = Array(n.length), i = new Uint8Array(n.length), a = (e) => {
+	let r = Array.from({ length: n.length }), i = new Uint8Array(n.length), a = (e) => {
 		if (!Number.isSafeInteger(e) || e < 0 || e >= n.length) throw Error(`Invalid TSF compact metadata type ${e}`);
-		return i[e] || (i[e] = 1, r[e] = n[e], r[e] = c(n[e], t, a)), r[e];
+		return i[e] || (i[e] = 1, r[e] = n[e], r[e] = f(n[e], t, a)), r[e];
 	};
 	return a;
 }
-function o(e, t, n, r) {
+function c(e, t) {
+	let n, r, i, a, o = (s) => {
+		if (!n) {
+			let [s, c] = d(e);
+			if (!Array.isArray(s)) throw Error("Invalid TSF compact metadata registry");
+			n = s, i = Array.from({ length: s.length }), a = new Uint8Array(s.length), r = p(c, t, o);
+		}
+		if (!Number.isSafeInteger(s) || s < 0 || s >= n.length) throw Error(`Invalid TSF compact metadata type ${s}`);
+		return a[s] || (a[s] = 1, i[s] = n[s], i[s] = f(n[s], t, o, r)), i[s];
+	};
+	return o;
+}
+function l(e, t, n, r) {
 	let [i, a, o] = r === void 0 ? [
 		e,
 		t,
@@ -36,44 +54,108 @@ function o(e, t, n, r) {
 		classType: () => s?.[a]
 	};
 }
-function s(e) {
+function u(e) {
 	let t = JSON.parse(e);
 	if (!Array.isArray(t) || t.length !== 2 || t[0] !== 1) throw Error("Unsupported TSF compact metadata format");
 	return t[1];
 }
-function c(i, a, s) {
-	if (!i || typeof i != "object") return i;
-	if (d(i)) return l(a, i[e]);
-	if (f(i)) {
-		let e = i[t], [n, r] = e.length === 2 ? e : [e[0], e[2]], o = u(a, n, e.length === 3 ? e[1] : void 0);
-		return () => o()?.[r];
+function d(e) {
+	let t = JSON.parse(e);
+	if (!Array.isArray(t) || t.length !== 3 || t[0] !== 2 || !Array.isArray(t[2])) throw Error("Unsupported TSF compact metadata format");
+	return [t[1], t[2]];
+}
+function f(a, o, s, c) {
+	if (!a || typeof a != "object") return a;
+	if (_(a)) return h(o, a[e]);
+	if (v(a)) {
+		let e = a[t], [n, r] = e.length === 2 ? e : [e[0], e[2]], i = g(o, n, e.length === 3 ? e[1] : void 0);
+		return () => i()?.[r];
 	}
-	if (p(i)) {
-		let e = i[n], [t, r, s] = e.length === 3 ? e : [
+	if (y(a)) {
+		let e = a[n], [t, r, i] = e.length === 3 ? e : [
 			e[0],
 			e[2],
 			e[3]
 		];
-		return o(u(a, t, e.length === 4 ? e[1] : void 0), r, s);
+		return l(g(o, t, e.length === 4 ? e[1] : void 0), r, i);
 	}
-	if (m(i)) {
+	if (b(a)) {
 		if (!s) throw Error("Missing TSF compact metadata type registry");
-		return s(i[r]);
+		return s(a[r]);
+	}
+	if (x(a)) {
+		if (!c) throw Error("Missing TSF compact metadata node registry");
+		return c(a[i]);
 	}
-	if (Array.isArray(i)) {
-		for (let e = 0; e < i.length; e++) i[e] = c(i[e], a, s);
-		return i;
+	if (Array.isArray(a)) {
+		for (let e = 0; e < a.length; e++) a[e] = f(a[e], o, s, c);
+		return a;
 	}
-	let h = i;
-	for (let e of Object.keys(h)) h[e] = c(h[e], a, s);
-	return h;
+	let u = a;
+	for (let e of Object.keys(u)) u[e] = f(u[e], o, s, c);
+	return u;
+}
+function p(e, t, n) {
+	let r = Array.from({ length: e.length }), i = new Uint8Array(e.length), a = (o) => {
+		if (!Number.isSafeInteger(o) || o < 0 || o >= e.length) throw Error(`Invalid TSF compact metadata node ${o}`);
+		return i[o] || (i[o] = 1, r[o] = e[o], r[o] = f(e[o], t, n, a)), r[o];
+	};
+	return a;
 }
-function l(e, t) {
+function m(e) {
+	let t = {}, n = !1, r = () => {
+		if (n) return;
+		let r = e();
+		if (!r || typeof r != "object") throw Error("Invalid TSF compact metadata root");
+		for (let e of Reflect.ownKeys(r)) {
+			if (Object.prototype.hasOwnProperty.call(t, e)) continue;
+			let n = Object.getOwnPropertyDescriptor(r, e);
+			n && Object.defineProperty(t, e, n);
+		}
+		n = !0;
+	};
+	return new Proxy(t, {
+		get(e, t, n) {
+			return r(), Reflect.get(e, t, n);
+		},
+		set(e, t, n) {
+			return Reflect.set(e, t, n, e);
+		},
+		has(e, t) {
+			return r(), Reflect.has(e, t);
+		},
+		ownKeys(e) {
+			return r(), Reflect.ownKeys(e);
+		},
+		getOwnPropertyDescriptor(e, t) {
+			return r(), Reflect.getOwnPropertyDescriptor(e, t);
+		},
+		defineProperty(e, t, n) {
+			return Reflect.defineProperty(e, t, n);
+		},
+		deleteProperty(e, t) {
+			return r(), Reflect.deleteProperty(e, t);
+		},
+		getPrototypeOf(e) {
+			return r(), Reflect.getPrototypeOf(e);
+		},
+		setPrototypeOf(e, t) {
+			return r(), Reflect.setPrototypeOf(e, t);
+		},
+		isExtensible(e) {
+			return Reflect.isExtensible(e);
+		},
+		preventExtensions(e) {
+			return r(), Reflect.preventExtensions(e);
+		}
+	});
+}
+function h(e, t) {
 	if (t < 0 || t >= e.length) throw Error(`Invalid TSF compact metadata reference ${t}`);
 	return e[t];
 }
-function u(e, t, n) {
-	let r = l(e, t);
+function g(e, t, n) {
+	let r = h(e, t);
 	if (typeof r != "function") throw Error(`Invalid TSF compact metadata module loader ${t}`);
 	return n === void 0 ? r : () => {
 		try {
@@ -83,25 +165,30 @@ function u(e, t, n) {
 		}
 	};
 }
-function d(t) {
+function _(t) {
 	if (Array.isArray(t)) return !1;
 	let n = Object.keys(t);
 	return n.length === 1 && n[0] === e && Number.isSafeInteger(t[e]);
 }
-function f(e) {
+function v(e) {
 	if (Array.isArray(e)) return !1;
 	let n = Object.keys(e), r = e[t];
 	return n.length === 1 && n[0] === t && Array.isArray(r) && (r.length === 2 || r.length === 3) && Number.isSafeInteger(r[0]) && typeof r[1] == "string" && (r.length === 2 || typeof r[2] == "string");
 }
-function p(e) {
+function y(e) {
 	if (Array.isArray(e)) return !1;
 	let t = Object.keys(e), r = e[n];
 	return t.length === 1 && t[0] === n && Array.isArray(r) && (r.length === 3 || r.length === 4) && Number.isSafeInteger(r[0]) && typeof r[1] == "string" && typeof r[2] == "string" && (r.length === 3 || typeof r[3] == "string");
 }
-function m(e) {
+function b(e) {
 	if (Array.isArray(e)) return !1;
 	let t = Object.keys(e);
 	return t.length === 1 && t[0] === r && Number.isSafeInteger(e[r]);
 }
+function x(e) {
+	if (Array.isArray(e)) return !1;
+	let t = Object.keys(e);
+	return t.length === 1 && t[0] === i && Number.isSafeInteger(e[i]);
+}
 //#endregion
-export { a as createCompactMetadataRegistryV1, i as decodeCompactMetadataV1, o as resolveCompactMetadataAliasV1 };
+export { s as createCompactMetadataRegistryV1, c as createCompactMetadataRegistryV2, a as decodeCompactMetadataV1, o as decodeCompactMetadataV2, l as resolveCompactMetadataAliasV1 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zyno-io/ts-reflection",
-    "version": "26.913.2245",
+    "version": "26.914.1839",
     "description": "Browser-neutral TypeScript reflection and runtime metadata",
     "license": "MIT",
     "files": [