typia 15.1.0 → 15.2.0

package/native/cmd/ttsc-typia/distinct_programs_concurrent_emit_test.go

@@ -0,0 +1,167 @@
+package main
+
+import (
+  "crypto/sha256"
+  "fmt"
+  "os"
+  "path/filepath"
+  "regexp"
+  "strings"
+  "sync"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+  "github.com/samchon/typia/packages/typia/native/adapter"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  metadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  "github.com/samchon/typia/packages/typia/native/transform"
+)
+
+// TestDistinctProgramsConcurrentEmit verifies independent Programs retain their
+// own generated nodes during overlapping emits across programmer families.
+//
+// NodeFactory arenas are mutable. A helper dropping its emit context used to
+// reach a package-global arena even when each worker owned its own Program.
+// The serial control proves real validators were emitted before concurrency;
+// the race-enabled canonical command additionally detects shared arena access.
+//
+// 1. Load two isolated Programs over the same type graph and separate markers.
+// 2. Emit both serially and require generated assert/is helpers and own markers.
+// 3. Emit sixteen times per Program concurrently and require identical bytes.
+//
+// @evidence contracts/testing.md#behavioral-verification Calls the real transform through EmitWithPluginTransformer with each file's EmitContext. Every output must contain both generated validator helpers and its authored marker; repeated parallel outputs must equal the serial output, and the race detector rejects shared mutable arenas.
+// @evidence contracts/testing.md#independent-expectations The authored sources require string, number and array checks and distinct marker literals. The serial comparison only proves repeatability, not semantic correctness; the generated helper checks prevent untransformed stubs from passing, while existing TypeScript execution suites own runtime verdicts.
+// @evidence contracts/testing.md#distinguishing-cases Serial controls precede overlapping workers, each owning one Program. Nested arrays, optional objects, unions and validator, JSON, HTTP, protobuf, notation, plain, random and functional producers exercise shared helper paths; foreign marker output and nondeterministic bytes fail independently of race detection.
+// @evidence contracts/testing.md#execution-ownership Go's native unit population loads in-process Programs using shared immutable declarations and separate writable fixture roots. It builds no host binary and launches no JavaScript runtime; Program.Close and fixture cleanup release every test-owned resource.
+func TestDistinctProgramsConcurrentEmit(t *testing.T) {
+  programs := make([]*driver.Program, 2)
+  for index := range programs {
+    root := ttscTypiaTestFixtureDirectory(t, "concurrent-emit-")
+    source := distinctProgramsConcurrentEmitSource + fmt.Sprintf("\nexport const owner = %q;\n", fmt.Sprintf("program-%d", index))
+    for name, text := range map[string]string{
+      "index.ts":      source,
+      "tsconfig.json": `{"compilerOptions":{"target":"es2022","module":"nodenext","moduleResolution":"nodenext","strict":true,"skipLibCheck":true,"esModuleInterop":true,"outDir":"out"},"files":["index.ts"]}`,
+    } {
+      if err := os.WriteFile(filepath.Join(root, name), []byte(text), 0o644); err != nil {
+        t.Fatal(err)
+      }
+    }
+    program, diagnostics, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{ForceEmit: true})
+    if err != nil || driver.CountErrors(diagnostics) != 0 {
+      t.Fatalf("load: %v; %+v", err, diagnostics)
+    }
+    t.Cleanup(func() {
+      if err := program.Close(); err != nil {
+        t.Error(err)
+      }
+    })
+    if diagnostics := program.Diagnostics(); driver.CountErrors(diagnostics) != 0 {
+      t.Fatalf("typecheck: %+v", diagnostics)
+    }
+    programs[index] = program
+  }
+  emit := func(index int) (string, error) {
+    program := programs[index]
+    metadata.MetadataDefaultLibrary_register(program.Checker, func(source *shimast.SourceFile) bool { return source != nil && program.TSProgram.IsLibFile(source) })
+    defer metadata.MetadataDefaultLibrary_release(program.Checker)
+    options := (adapter.PluginOptions{}).TransformOptions()
+    var mu sync.Mutex
+    var transformed []*nativecontext.ITypiaDiagnostic
+    var javascript string
+    extras := nativecontext.ITypiaContext_Extras{Shared: &sync.Map{}, AddDiagnostic: func(d *nativecontext.ITypiaDiagnostic) int {
+      mu.Lock()
+      defer mu.Unlock()
+      transformed = append(transformed, d)
+      return len(transformed)
+    }}
+    diagnostics, err := program.EmitWithPluginTransformer(func(ec *shimprinter.EmitContext, source *shimast.SourceFile) *shimast.SourceFile {
+      return transform.Transform(program, &options, extras, ec)(source)
+    }, shimcompiler.WriteFile(func(name shimtspath.RootedFilePath, text string, _ *shimcompiler.WriteFileData) error {
+      mu.Lock()
+      defer mu.Unlock()
+      if filepath.Base(string(name)) == "index.js" {
+        javascript = text
+      }
+      return nil
+    }))
+    if err != nil || driver.CountErrors(diagnostics) != 0 || len(transformed) != 0 {
+      return "", fmt.Errorf("emit: %v; %+v; %+v", err, diagnostics, transformed)
+    }
+    for _, required := range []string{"const _ao0", "const _io0", "Array.isArray", fmt.Sprintf("program-%d", index)} {
+      if !strings.Contains(javascript, required) {
+        return "", fmt.Errorf("missing %q in generated output:\n%s", required, javascript)
+      }
+    }
+    if !regexp.MustCompile(`(?:"string"\s*===\s*typeof input\.name\b|typeof input\.name\s*===\s*"string")`).MatchString(javascript) {
+      return "", fmt.Errorf("missing name string guard:\n%s", javascript)
+    }
+    if strings.Contains(javascript, fmt.Sprintf("program-%d", 1-index)) {
+      return "", fmt.Errorf("output carries foreign Program marker")
+    }
+    return javascript, nil
+  }
+  controls := make([]string, len(programs))
+  for index := range programs {
+    var err error
+    controls[index], err = emit(index)
+    if err != nil {
+      t.Fatalf("serial: %v", err)
+    }
+    t.Logf("serial output %d SHA256: %x", index, sha256.Sum256([]byte(controls[index])))
+  }
+  start := make(chan struct{})
+  failures := make(chan error, len(programs))
+  var workers sync.WaitGroup
+  for index := range programs {
+    workers.Add(1)
+    go func() {
+      defer workers.Done()
+      <-start
+      for range 16 {
+        output, err := emit(index)
+        if err != nil {
+          failures <- err
+          return
+        }
+        if output != controls[index] {
+          failures <- fmt.Errorf("Program %d changed emitted bytes", index)
+          return
+        }
+      }
+    }()
+  }
+  close(start)
+  workers.Wait()
+  close(failures)
+  for err := range failures {
+    t.Error(err)
+  }
+}
+
+const distinctProgramsConcurrentEmitSource = `import typia from "typia";
+interface RecordType {
+  name: string;
+  values: { key: string; value: number; enabled: boolean }[];
+  optional?: { nested: { label: string; count: number } };
+  union: { type: "a"; text: string } | { type: "b"; count: number };
+}
+export const assertRecord = typia.createAssert<RecordType>();
+export const isRecord = typia.createIs<RecordType>();
+export const validateRecord = typia.createValidate<RecordType>();
+export const stringify = typia.json.createAssertStringify<RecordType>();
+export const parse = typia.json.createAssertParse<RecordType>();
+export const query = typia.http.createAssertQuery<{ name: string; values: number[] }>();
+export const headers = typia.http.createAssertHeaders<{ name: string }>();
+export const encode = typia.protobuf.createAssertEncode<RecordType>();
+export const decode = typia.protobuf.createAssertDecode<RecordType>();
+export const decodeMap = typia.protobuf.createDecode<{ values: Map<string, number> }>();
+export const decodeRecord = typia.protobuf.createDecode<{ values: Record<string, number> }>();
+export const camel = typia.notations.createCamel<RecordType>();
+export const clone = typia.plain.createAssertClone<RecordType>();
+export const random = typia.createRandom<RecordType>();
+export const functional = typia.functional.assertFunction((input: RecordType): RecordType => input);
+`

package/native/cmd/ttsc-typia/exact_optional_family_emission_contract_test.go

@@ -4,6 +4,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimparser "github.com/microsoft/typescript-go/shim/parser"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
   "os"
   "path/filepath"
   "strings"
@@ -52,7 +53,7 @@ export const randomIncluded=()=>typia.random<IExactOptionalClone>({boolean:()=>t
   if code != 0 {
     t.Fatalf("exact optional transform failed %d: %s", code, stderr)
   }
-  file := shimparser.ParseSourceFile(shimast.SourceFileParseOptions{FileName: filepath.ToSlash(filepath.Join(project, "emitted.js"))}, output, shimcore.ScriptKindJS)
+  file := shimparser.ParseSourceFile(shimast.SourceFileParseOptions{FileName: shimtspath.RootedFilePath(filepath.ToSlash(filepath.Join(project, "emitted.js")))}, output, shimcore.ScriptKindJS)
   bindings := map[string]*shimast.Node{}
   assertImports := map[string]bool{}
   var walk func(*shimast.Node) bool

package/native/cmd/ttsc-typia/project_dependencies_heritage_forms_transform_test.go

@@ -0,0 +1,84 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestProjectDependenciesHeritageFormsTransform verifies both type and value
+// heritage retain empty bases and phantom type arguments in dependency reports.
+//
+// TypeScript 7.1 represents interface extends and class implements with type
+// references, while class extends keeps an expression with type arguments.
+// Empty bases and unused generic arguments cannot be recovered from properties.
+//
+// 1. Declare aliased and qualified empty generic interfaces, classes and contracts.
+// 2. Transform validators for interface, class, implements and class-expression forms.
+// 3. Require all written heritage and argument files, excluding an unused sibling.
+//
+// @evidence contracts/testing.md#behavioral-verification Calls the real project transform and checks main.ts dependencies include each empty interface, base class, implemented contract and phantom argument file. A valid plain class without heritage is transformed in the same project and an unconsumed sibling must remain absent.
+// @evidence contracts/testing.md#independent-expectations Editing any authored empty base or phantom type argument can change the consumed type, so their written references belong to the dependency contract even before they contribute a property. The unrelated interface is never referenced and must not become a dependency.
+// @evidence contracts/testing.md#distinguishing-cases Interface extends, class extends, class implements and class-expression extends/implements combine named aliases, qualified namespace names and generic arguments. The plain-class and unused-file controls distinguish absent heritage from over-reporting; the existing empty-heritage test owns the minimal interface witness.
+// @evidence contracts/testing.md#execution-ownership The canonical native and 7.1 Go populations discover this in-process transform unit. It shares immutable declaration inputs through the existing fixture helper and starts no compiler or JavaScript subprocess.
+func TestProjectDependenciesHeritageFormsTransform(t *testing.T) {
+  project := ttscTypiaTestFixtureDirectory(t, "heritage-forms-")
+  if err := os.MkdirAll(filepath.Join(project, "src"), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  files := map[string]string{
+    "tsconfig.json":         projectDependenciesEnvelopeTSConfig,
+    "src/interface-base.ts": `export namespace Types { export interface Empty<T> {} }`,
+    "src/class-base.ts":     `export class Parent<T> {}`,
+    "src/contract.ts":       `export interface Contract<T> {}`,
+    "src/tag.ts":            `export interface Tag { id: string }`,
+    "src/unrelated.ts":      `export interface Unused { unused: string }`,
+    "src/models.ts": `import { Types } from "./interface-base";
+import { Parent as Base } from "./class-base";
+import { Contract as ContractAlias } from "./contract";
+import { Tag } from "./tag";
+export interface ViaInterface extends Types.Empty<Tag> { id: string }
+export class ViaClass extends Base<Tag> { id!: string }
+export class ViaImplements implements ContractAlias<Tag> { id!: string }
+export const Bound = class extends Base<Tag> implements ContractAlias<Tag> { id!: string };
+export class Plain { id!: string }
+`,
+    "src/main.ts": `import typia from "typia";
+import { ViaInterface, ViaClass, ViaImplements, Bound, Plain } from "./models";
+export const i = typia.createIs<ViaInterface>();
+export const c = typia.createIs<ViaClass>();
+export const m = (input: unknown) => typia.validate<ViaImplements>(input);
+export const e = typia.createIs<InstanceType<typeof Bound>>();
+export const p = typia.createIs<Plain>();
+`,
+  }
+  for name, text := range files {
+    if err := os.WriteFile(filepath.Join(project, name), []byte(text), 0o644); err != nil {
+      t.Fatal(err)
+    }
+  }
+  ttscTypiaTestTypecheck(t, project)
+  output, errors, code := ttscTypiaTestCapture(func() int { return runTransform([]string{"--cwd", project, "--output", "ts"}) })
+  if code != 0 {
+    t.Fatalf("heritage transform: %d\n%s", code, errors)
+  }
+  var envelope struct {
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(output), &envelope); err != nil {
+    t.Fatal(err)
+  }
+  found := map[string]bool{}
+  for _, name := range envelope.Dependencies["src/main.ts"] {
+    found[name] = true
+  }
+  for _, name := range []string{"models", "interface-base", "class-base", "contract", "tag"} {
+    if !found["src/"+name+".ts"] {
+      t.Errorf("missing %s heritage dependency: %v", name, found)
+    }
+  }
+  if found["src/unrelated.ts"] {
+    t.Errorf("unconsumed heritage was reported: %v", found)
+  }
+}

package/native/cmd/ttsc-typia/schema_literal_helpers_test.go

@@ -9,13 +9,14 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimparser "github.com/microsoft/typescript-go/shim/parser"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
 )
 
 // ttscTypiaTestSchemaLiteral decodes the emitted schema object's AST without
 // executing JavaScript. It rejects expressions rather than evaluating them.
 func ttscTypiaTestSchemaLiteral(t *testing.T, output string) map[string]any {
   t.Helper()
-  file := shimparser.ParseSourceFile(shimast.SourceFileParseOptions{FileName: filepath.ToSlash(filepath.Join(t.TempDir(), "emitted.ts"))}, output, shimcore.ScriptKindTS)
+  file := shimparser.ParseSourceFile(shimast.SourceFileParseOptions{FileName: shimtspath.RootedFilePath(filepath.ToSlash(filepath.Join(t.TempDir(), "emitted.ts")))}, output, shimcore.ScriptKindTS)
   var found map[string]any
   var walk func(*shimast.Node) bool
   walk = func(node *shimast.Node) bool {

package/native/cmd/ttsc-typia/transform.go

@@ -14,6 +14,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
   "github.com/samchon/ttsc/packages/ttsc/driver"
   typiaadapter "github.com/samchon/typia/packages/typia/native/adapter"
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
@@ -250,7 +251,7 @@ func runTransformProject(
     if sf.IsDeclarationFile {
       continue
     }
-    key := driver.TransformOutputKey(cwd, sf.FileName())
+    key := driver.TransformOutputKey(cwd, string(sf.FileName()))
     if filepath.IsAbs(key) || key == ".." || strings.HasPrefix(key, "../") {
       continue
     }
@@ -332,13 +333,13 @@ func transformSingleToJavaScript(
   // itself. Nothing the emit writes is then this file's artifact, so guard the
   // comparison rather than let an empty expectation match anything.
   expected := ""
-  if paths := shimcompiler.GetOutputPathsFor(target, prog.TSProgram.Options(), prog.TSProgram, false); paths != nil {
-    expected = filepath.ToSlash(paths.JsFilePath())
+  if paths := shimcompiler.OutputPathsFor(target, prog.TSProgram.Options(), prog.TSProgram); paths != nil {
+    expected = filepath.ToSlash(string(paths.JsFilePath()))
   }
   var captured string
   found := false
-  writeFile := shimcompiler.WriteFile(func(fileName, text string, _ *shimcompiler.WriteFileData) error {
-    if expected != "" && filepath.ToSlash(fileName) == expected {
+  writeFile := shimcompiler.WriteFile(func(fileName shimtspath.RootedFilePath, text string, _ *shimcompiler.WriteFileData) error {
+    if expected != "" && filepath.ToSlash(string(fileName)) == expected {
       captured = text
       found = true
     }
@@ -349,7 +350,7 @@ func transformSingleToJavaScript(
     return "", 3
   }
   if !found {
-    fmt.Fprintf(stderr, "ttsc-typia transform: no output produced for %s\n", target.FileName())
+    fmt.Fprintf(stderr, "ttsc-typia transform: no output produced for %s\n", string(target.FileName()))
     return "", 3
   }
   return captured, 0

package/native/core/context/EmitFactory.go

@@ -5,24 +5,18 @@ import (
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
 )
 
-// EmitFactory resolves the node factory a node-creating helper should use.
+// EmitFactory selects a live emit context's factory or the caller's explicit
+// standalone fallback. Returning the same instance preserves its compiler or
+// caller-installed hooks. A nil fallback remains nil when no context is supplied.
 //
-// When an emit EmitContext is present (emit stage / AST-integration mode) its
-// Factory is returned so every created node carries original-node tracking and
-// emit metadata (parent links, comments, source maps, const-enum constants,
-// namespace alias) that the tsgo emit pipeline relies on. When ec is nil (legacy
-// text emit, analysis-only or test paths) the caller's standalone fallback
-// factory is returned unchanged.
+// The caller owns the fallback and must confine its mutable arena to its own
+// construction lifetime. This selector retains no factory; callers that need a
+// fresh standalone arena can use NodeFactoryOf instead.
 //
-// This is the single-resolver form of ImportProgrammer's `if p.emit_ != nil`
-// branch: the embedded ast.NodeFactory inside printer.NodeFactory carries the
-// emit hooks, so &ec.Factory.NodeFactory produces metadata-bearing nodes while
-// printing identically to the fallback (token text/structure unchanged).
-//
-// @evidence contracts/common.md#principled-implementation A live emit context returns its embedded node factory, whose hooks give created nodes original-node links and emit metadata, and otherwise the caller's standalone factory is returned unchanged; both print the same tokens.
-// @evidence contracts/common.md#clear-and-simple-design One conditional that replaces the same branch repeated in every node-creating helper.
-// @evidence contracts/common.md#prohibited-implementation-shortcuts The fallback is the supported analysis and test path and not a workaround for a missing context.
-// @evidence contracts/common.md#meaningful-documentation The doc states both outcomes and why the emit factory is preferred.
+// @evidence contracts/common.md#principled-implementation A live context returns its embedded factory to retain compiler emit hooks. Otherwise the exact supplied fallback, including nil, is returned so caller ownership and custom hooks remain intact; the selector allocates and retains no arena.
+// @evidence contracts/common.md#clear-and-simple-design One conditional implements the explicit-fallback selection contract used by native consumers, separately from NodeFactoryOf's fresh-allocation contract.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Selection uses the public compiler factory boundary without foreign mutation, shared state or serialization. The fallback is caller-owned; typia's own context-free construction uses fresh factories through NodeFactoryOf.
+// @evidence contracts/common.md#meaningful-documentation The comment states selection priority, nil behavior, hook preservation and the caller's arena ownership responsibility.
 func EmitFactory(ec *shimprinter.EmitContext, fallback *shimast.NodeFactory) *shimast.NodeFactory {
   if ec != nil {
     return &ec.Factory.NodeFactory
@@ -30,20 +24,17 @@ func EmitFactory(ec *shimprinter.EmitContext, fallback *shimast.NodeFactory) *sh
   return fallback
 }
 
-// EmitFactoryOf is the variadic form for node-creating free helpers and shared
-// static factories that receive the emit context through an optional `emit
-// ...*EmitContext` parameter. Passing no context (or a nil one) selects the
-// standalone fallback, which is the legacy / analysis-only / test path; passing
-// a live context routes creation through ec.Factory. This lets call sites thread
-// the real context in progressively while the build stays green at every step.
+// EmitFactoryOf selects the first optional context through EmitFactory.
+// An omitted or nil first context selects the caller's fallback even when a
+// later context is live; no factory is allocated or retained by the selector.
 //
-// @evidence contracts/common.md#principled-implementation The variadic form selects the first emit context when it is present and non-nil and otherwise the fallback, so helpers can receive the context as an optional trailing argument.
-// @evidence contracts/common.md#clear-and-simple-design One conditional over a slice, used by free helpers that cannot hold a receiver.
-// @evidence contracts/common.md#prohibited-implementation-shortcuts It does not mutate its inputs.
-// @evidence contracts/common.md#meaningful-documentation The doc explains the optional parameter and the progressive threading of the context.
+// @evidence contracts/common.md#principled-implementation Only the first optional context participates, preserving the existing variadic consumer contract. EmitFactory owns the same live-context versus caller-fallback decision for both entry forms.
+// @evidence contracts/common.md#clear-and-simple-design A slice-presence check adapts optional arguments to the scalar selector without duplicating its factory selection.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The adapter changes neither the caller's factory nor its context and stores no shared mutable arena.
+// @evidence contracts/common.md#meaningful-documentation The comment explains omitted, nil-first and later-context behavior and makes the absence of allocation and retained state explicit.
 func EmitFactoryOf(fallback *shimast.NodeFactory, emit ...*shimprinter.EmitContext) *shimast.NodeFactory {
-  if len(emit) != 0 && emit[0] != nil {
-    return &emit[0].Factory.NodeFactory
+  if len(emit) == 0 {
+    return EmitFactory(nil, fallback)
   }
-  return fallback
+  return EmitFactory(emit[0], fallback)
 }

package/native/core/context/ImportProgrammer.go

@@ -130,8 +130,6 @@ type importProgrammer_asset struct {
   order     []string
 }
 
-var importProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 // NewImportProgrammer creates an importer with the first option record, or the
 // zero options.
 //
@@ -213,7 +211,7 @@ func (p *ImportProgrammer) Default(props ImportProgrammer_IDefault) *shimast.Nod
   if p.emit_ != nil {
     return p.member(asset, "default")
   }
-  return EmitFactory(p.emit_, importProgrammer_factory).NewIdentifier(asset.Default.Name)
+  return NodeFactoryOf(p.emit_).NewIdentifier(asset.Default.Name)
 }
 
 // Instance records a named import and returns its reference. The alias, or the
@@ -236,7 +234,7 @@ func (p *ImportProgrammer) Instance(props ImportProgrammer_IInstance) *shimast.N
   if p.emit_ != nil {
     return p.member(asset, props.Name)
   }
-  return EmitFactory(p.emit_, importProgrammer_factory).NewIdentifier(alias)
+  return NodeFactoryOf(p.emit_).NewIdentifier(alias)
 }
 
 // Namespace records a namespace import of the file and returns its reference. The
@@ -255,7 +253,7 @@ func (p *ImportProgrammer) Namespace(props ImportProgrammer_INamespace) *shimast
   if p.emit_ != nil {
     return p.namespaceName(asset)
   }
-  return EmitFactory(p.emit_, importProgrammer_factory).NewIdentifier(asset.namespace.Name)
+  return NodeFactoryOf(p.emit_).NewIdentifier(asset.namespace.Name)
 }
 
 // Type builds an import type node `import("file").Qualifier<Arguments>`. It
@@ -266,7 +264,7 @@ func (p *ImportProgrammer) Namespace(props ImportProgrammer_INamespace) *shimast
 // @evidence contracts/common.md#prohibited-implementation-shortcuts An unsupported qualifier type produces a node without a qualifier and does not panic.
 // @evidence contracts/common.md#meaningful-documentation The doc states that nothing is registered.
 func (p *ImportProgrammer) Type(props ImportProgrammer_TypeProps) *shimast.Node {
-  f := EmitFactory(p.emit_, importProgrammer_factory)
+  f := NodeFactoryOf(p.emit_)
   var qualifier *shimast.EntityName
   switch name := props.Name.(type) {
   case string:
@@ -343,7 +341,7 @@ func (p *ImportProgrammer) GetInternalText(name string) string {
 // @evidence contracts/common.md#prohibited-implementation-shortcuts The ranking is a fixed table and the order is deterministic.
 // @evidence contracts/common.md#meaningful-documentation The doc states the order and the two forms.
 func (p *ImportProgrammer) ToStatements() []*shimast.Node {
-  f := EmitFactory(p.emit_, importProgrammer_factory)
+  f := NodeFactoryOf(p.emit_)
   statements := []*shimast.Node{}
   order := append([]string{}, p.order_...)
   indices := map[string]int{}

package/native/core/context/NodeFactory.go

@@ -0,0 +1,25 @@
+package context
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+)
+
+// NodeFactoryOf returns the first emit context's factory, or a fresh standalone
+// factory when that context is absent or nil. Standalone callers own the factory
+// and its nodes; no mutable arena is shared between independent calls.
+//
+// An emit factory retains the compiler's original-node and parent metadata.
+// Helpers should forward their context throughout a transform. A standalone
+// factory has no emit hooks and serves analysis and context-free construction.
+//
+// @evidence contracts/common.md#principled-implementation A live first context returns its embedded node factory, whose hooks maintain emit provenance. Otherwise the supported ast constructor supplies a new arena owned by this caller, so independent Programs cannot race through a fallback factory.
+// @evidence contracts/common.md#clear-and-simple-design One resolver owns both optional-context selection and standalone allocation; node-building helpers retain no package-global factory.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The resolver uses the compiler's public factory boundary without modifying foreign state or serializing independent Programs. Missing contexts receive independent factories rather than a shared compensation.
+// @evidence contracts/common.md#meaningful-documentation The comment distinguishes per-emit provenance from standalone construction and states ownership and nil behavior.
+func NodeFactoryOf(emit ...*shimprinter.EmitContext) *shimast.NodeFactory {
+  if len(emit) != 0 && emit[0] != nil {
+    return &emit[0].Factory.NodeFactory
+  }
+  return shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+}

package/native/core/context/node_factory_ownership_test.go

@@ -0,0 +1,45 @@
+package context
+
+import (
+  "testing"
+
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+)
+
+// TestNodeFactoryOwnership verifies standalone arenas are independent while a
+// live first emit context preserves its compiler factory identity.
+//
+// A shared no-context fallback races even when all live contexts are distinct.
+// Allocating separately also prevents a later standalone caller from changing
+// nodes retained by an earlier caller.
+//
+// 1. Select factories with omitted and explicit nil contexts and compare identity.
+// 2. Select a live context twice and require its embedded factory both times.
+// 3. Allocate distinct identifiers and require the earlier identifier to survive.
+//
+// @evidence contracts/testing.md#behavioral-verification Calls NodeFactoryOf with absent, nil and live contexts, asserts independent fallback pointer identities and exact live factory identity, then checks identifier text survives allocations in the other factories.
+// @evidence contracts/testing.md#independent-expectations The ownership contract requires no arena sharing across independent standalone requests and requires live compiler factory identity to retain emit hooks. Authored identifier strings supply the content oracle.
+// @evidence contracts/testing.md#distinguishing-cases Omitted, explicit nil, repeated live and nil-first-with-live-second contexts distinguish first-argument selection and fallback independence; a different context must select a different live factory.
+// @evidence contracts/testing.md#execution-ownership Go's native unit population discovers this same-package resolver test through test:go:native and test:go:7.1. It uses real in-memory compiler factories and starts no process or installed consumer.
+func TestNodeFactoryOwnership(t *testing.T) {
+  first, second := NodeFactoryOf(), NodeFactoryOf(nil)
+  live := shimprinter.NewEmitContext()
+  third := NodeFactoryOf(nil, live)
+  if first == second || first == third || second == third {
+    t.Fatal("standalone callers share a mutable arena")
+  }
+  if NodeFactoryOf(live) != &live.Factory.NodeFactory || NodeFactoryOf(live) != NodeFactoryOf(live) {
+    t.Fatal("live emit factory identity was lost")
+  }
+  if NodeFactoryOf(live) == NodeFactoryOf(shimprinter.NewEmitContext()) {
+    t.Fatal("independent emit contexts share a factory")
+  }
+  original := first.NewIdentifier("first")
+  for range 1024 {
+    second.NewIdentifier("second")
+    third.NewIdentifier("third")
+  }
+  if original.Text() != "first" {
+    t.Fatalf("standalone allocation corrupted retained text: %s", original.Text())
+  }
+}

package/native/core/factories/ExpressionFactory.go

@@ -3,6 +3,7 @@ package factories
 import (
   "crypto/rand"
   "fmt"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
   "math"
   "os"
   "path/filepath"
@@ -153,10 +154,8 @@ type ExpressionFactory_GetEscapedTextProps struct {
   Input *shimast.Expression
 }
 
-var expressionFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (expressionFactoryNamespace) Number(value any, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   text, numeric := expressionFactory_number_text(value)
   // Go spells the non-finite floats `NaN`, `+Inf`, and `-Inf`. Only the first
   // happens to be JavaScript; `+Inf` evaluates an undeclared `Inf` and throws a
@@ -193,7 +192,7 @@ func (expressionFactoryNamespace) Number(value any, emit ...*shimprinter.EmitCon
 // `BigInt` parses the digits of a string directly, so the string form is exact
 // at any magnitude.
 func (expressionFactoryNamespace) Bigint(value any, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewCallExpression(
     f.NewIdentifier("BigInt"),
     nil,
@@ -206,7 +205,7 @@ func (expressionFactoryNamespace) Bigint(value any, emit ...*shimprinter.EmitCon
 }
 
 func (expressionFactoryNamespace) IsRequired(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewBinaryExpression(
     nil,
     f.NewIdentifier("undefined"),
@@ -217,7 +216,7 @@ func (expressionFactoryNamespace) IsRequired(input *shimast.Expression, emit ...
 }
 
 func (expressionFactoryNamespace) IsArray(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewCallExpression(
     f.NewIdentifier("Array.isArray"),
     nil,
@@ -228,7 +227,7 @@ func (expressionFactoryNamespace) IsArray(input *shimast.Expression, emit ...*sh
 }
 
 func (expressionFactoryNamespace) IsObject(props ExpressionFactory_IsObjectProps, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   conditions := []*shimast.Node{
     f.NewBinaryExpression(
       nil,
@@ -273,7 +272,7 @@ func (expressionFactoryNamespace) IsObject(props ExpressionFactory_IsObjectProps
 }
 
 func (expressionFactoryNamespace) IsInstanceOf(t string, input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewBinaryExpression(
     nil,
     input,
@@ -284,7 +283,7 @@ func (expressionFactoryNamespace) IsInstanceOf(t string, input *shimast.Expressi
 }
 
 func (expressionFactoryNamespace) Coalesce(x *shimast.Expression, y *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewBinaryExpression(
     nil,
     x,
@@ -301,7 +300,7 @@ func (expressionFactoryNamespace) Coalesce(x *shimast.Expression, y *shimast.Exp
 // removes that workaround. The node is structurally identical to the patched-up
 // form, so emitted text is unchanged.
 func (expressionFactoryNamespace) Conditional(condition *shimast.Expression, whenTrue *shimast.Expression, whenFalse *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewConditionalExpression(
     condition,
     f.NewToken(shimast.KindQuestionToken),
@@ -312,7 +311,7 @@ func (expressionFactoryNamespace) Conditional(condition *shimast.Expression, whe
 }
 
 func (expressionFactoryNamespace) Currying(props ExpressionFactory_CurryingProps, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   if len(props.Arguments) == 0 {
     return f.NewCallExpression(props.Function, nil, nil, nil, shimast.NodeFlagsNone)
   }
@@ -342,7 +341,7 @@ func (expressionFactoryNamespace) SelfCall(ec *shimprinter.EmitContext, body *sh
   if body != nil && body.Kind == shimast.KindCallExpression {
     return body
   }
-  f := nativecontext.EmitFactory(ec, expressionFactory_factory)
+  f := nativecontext.NodeFactoryOf(ec)
   var output *shimast.TypeNode
   if len(typeNode) != 0 {
     output = typeNode[0]
@@ -376,13 +375,13 @@ func (expressionFactoryNamespace) GetEscapedText(props ExpressionFactory_GetEsca
 }
 
 func (expressionFactoryNamespace) Transpile(props ExpressionFactory_TranspileProps, emit ...*shimprinter.EmitContext) func(input *shimast.Expression) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   fileName := filepath.Join(os.TempDir(), expressionFactory_random_format_uuid()+".ts")
   if absolute, err := filepath.Abs(fileName); err == nil {
     fileName = absolute
   }
   file := shimparser.ParseSourceFile(
-    shimast.SourceFileParseOptions{FileName: filepath.ToSlash(fileName)},
+    shimast.SourceFileParseOptions{FileName: shimtspath.RootedFilePath(filepath.ToSlash(fileName))},
     props.Script,
     shimcore.ScriptKindTS,
   )