feat: add value-expression AST nodes for composing call chains (#84)

* feat: add value-expression AST nodes for composing call chains

Adds seven bindings nodes that let mutations build TypeScript value
expressions structurally instead of via string concatenation:

- IdentifierExpression: bare value-position identifier (`z`, `BaseSchema`).
- PropertyAccessExpression: `expr.name`, the building block for method
  chains like `z.string`.
- CallExpression: `expr(args...)`, composes with PropertyAccessExpression
  to build `z.string()` and chained `z.string().optional()`.
- ObjectLiteralExpression + PropertyAssignment: `{ k: v, ... }` in value
  position, distinct from TypeLiteralNode which emits a type literal.
- ArrowFunction + Parameter: `(params): retType => body` so callers can
  produce things like `(): z.ZodType => FooSchema` for cyclic references.
- TypeQuery: `typeof name`, used as a generic argument such as the
  `typeof FooSchema` inside `z.infer<typeof FooSchema>`.

Each node has a corresponding `ts.factory.create*` wrapper in
typescript-engine/src/index.ts, a goja-backed builder in bindings.go, and
dispatch through ToTypescriptNode / ToTypescriptExpressionNode.
typescript-engine/dist/main.js is rebuilt to ship the new factories.

bindings/expressions_test.go round-trips every node and several
compositions through goja, including the chained-call shape
`z.string().optional()`, an inline object literal with property-order
preservation, and the `z.lazy((): z.ZodType => Schema)` self-reference
form. These cover the surface a follow-up zod mutation needs without
binding the bindings to any zod-specific opinions.

Generated by Coder Agents on behalf of @Emyrk.

* refactor: type IdentifierExpression.Name as Identifier

Align with ReferenceType.Name, VariableDeclaration.Name, and Alias.Name so
the same qualified-name handle flows through value-position references.
Cross-package Prefix set during Go parsing now reaches the emitted name
via .Ref() instead of being silently dropped.

Doc comment on IdentifierExpression now spells out the distinction from
bindings.Identifier: Identifier is a parser-layer qualified-name handle
and is not itself a Node; IdentifierExpression is a tree-layer Node that
embeds an Identifier in expression position.

Test split into bare-name and prefix-is-applied subcases. The prefix case
pins the new behavior; without it, an IdentifierExpression carrying a
prefixed Identifier would emit "Schema" instead of "ExternalSchema" and
would not match the prefixed declaration the rest of guts emits for the
same Identifier.

Generated by Coder Agents on behalf of @Emyrk.

* refactor: review fixes for expression bindings

Three review findings, applied together:

1. TypeQuery.Name is now Identifier instead of string. Same reason as the
   IdentifierExpression refactor: `typeof FooSchema` references a declared
   TS name, and the prefix set during Go parsing must flow through .Ref()
   so the TypeQuery and a matching IdentifierExpression for the same
   prefixed Identifier emit aligned names. Without this, a prefixed
   declaration would emit `typeof Foo` while the value-position reference
   emits `ExternalFoo`. Doc updated to spell out the invariant and a
   prefix_is_applied subtest pins the new behavior.

2. Test helper zMethodCall renamed to methodCall(receiver, method, args).
   The bindings know nothing about zod; the helper shouldn't either. The
   helper had "z" hardcoded as the receiver, which leaked the zod
   motivation into general-purpose tests. The new signature reads
   methodCall("z", "string"), exactly as descriptive at the call site,
   without baking domain assumptions into the helper name.

3. ObjectLiteralExpression doc now calls out the modeled subset. TS's
   ObjectLiteralElementLike covers PropertyAssignment,
   ShorthandPropertyAssignment, SpreadAssignment, MethodDeclaration, and
   accessors. We model only PropertyAssignment; the doc says so, matching
   the existing pattern on ImportDeclaration ("Only the named-imports
   form is modeled").

Generated by Coder Agents on behalf of @Emyrk.

Author: Emyrk

bindings/bindings.go

@@ -33,6 +33,10 @@ func (b *Bindings) ToTypescriptNode(ety Node) (*goja.Object, error) {
 		siObj, err = b.PropertySignature(node)
 	case *TypeParameter:
 		siObj, err = b.TypeParameter(node)
+	case *PropertyAssignment:
+		siObj, err = b.PropertyAssignment(node)
+	case *Parameter:
+		siObj, err = b.Parameter(node)
 	case DeclarationType:
 		// Defer to the ExpressionType implementation
 		siObj, err = b.ToTypescriptDeclarationNode(node)
@@ -135,6 +139,18 @@ func (b *Bindings) ToTypescriptExpressionNode(ety ExpressionType) (*goja.Object,
 		siObj, err = b.TypeLiteralNode(ety)
 	case *TypeIntersection:
 		siObj, err = b.TypeIntersection(ety)
+	case *IdentifierExpression:
+		siObj, err = b.IdentifierExpression(ety)
+	case *PropertyAccessExpression:
+		siObj, err = b.PropertyAccessExpression(ety)
+	case *CallExpression:
+		siObj, err = b.CallExpression(ety)
+	case *ObjectLiteralExpression:
+		siObj, err = b.ObjectLiteralExpression(ety)
+	case *ArrowFunction:
+		siObj, err = b.ArrowFunction(ety)
+	case *TypeQuery:
+		siObj, err = b.TypeQuery(ety)
 	default:
 		return nil, xerrors.Errorf("unsupported type for field type: %T", ety)
 	}
@@ -864,3 +880,163 @@ func (b *Bindings) ImportDeclaration(decl *ImportDeclaration) (*goja.Object, err
 	}
 	return res.ToObject(b.vm), nil
 }
+
+// IdentifierExpression builds the goja node for a value-position identifier
+// such as `z` or `BaseSchema`.
+func (b *Bindings) IdentifierExpression(expr *IdentifierExpression) (*goja.Object, error) {
+	idF, err := b.f("identifierExpression")
+	if err != nil {
+		return nil, err
+	}
+	res, err := idF(goja.Undefined(), b.vm.ToValue(expr.Name.Ref()))
+	if err != nil {
+		return nil, xerrors.Errorf("call identifierExpression: %w", err)
+	}
+	return res.ToObject(b.vm), nil
+}
+
+// PropertyAccessExpression builds `<expression>.<name>`.
+func (b *Bindings) PropertyAccessExpression(expr *PropertyAccessExpression) (*goja.Object, error) {
+	paF, err := b.f("propertyAccessExpression")
+	if err != nil {
+		return nil, err
+	}
+	inner, err := b.ToTypescriptNode(expr.Expression)
+	if err != nil {
+		return nil, fmt.Errorf("property access expression: %w", err)
+	}
+	res, err := paF(goja.Undefined(), inner, b.vm.ToValue(expr.Name))
+	if err != nil {
+		return nil, xerrors.Errorf("call propertyAccessExpression: %w", err)
+	}
+	return res.ToObject(b.vm), nil
+}
+
+// CallExpression builds `<expression>(args...)`.
+func (b *Bindings) CallExpression(expr *CallExpression) (*goja.Object, error) {
+	callF, err := b.f("callExpression")
+	if err != nil {
+		return nil, err
+	}
+	callee, err := b.ToTypescriptNode(expr.Expression)
+	if err != nil {
+		return nil, fmt.Errorf("call expression callee: %w", err)
+	}
+	args := make([]interface{}, 0, len(expr.Arguments))
+	for i, a := range expr.Arguments {
+		v, err := b.ToTypescriptNode(a)
+		if err != nil {
+			return nil, fmt.Errorf("call expression arg %d: %w", i, err)
+		}
+		args = append(args, v)
+	}
+	res, err := callF(goja.Undefined(), callee, b.vm.NewArray(args...))
+	if err != nil {
+		return nil, xerrors.Errorf("call callExpression: %w", err)
+	}
+	return res.ToObject(b.vm), nil
+}
+
+// ObjectLiteralExpression builds `{ k: v, ... }` in expression position.
+func (b *Bindings) ObjectLiteralExpression(expr *ObjectLiteralExpression) (*goja.Object, error) {
+	objF, err := b.f("objectLiteralExpression")
+	if err != nil {
+		return nil, err
+	}
+	props := make([]interface{}, 0, len(expr.Properties))
+	for _, p := range expr.Properties {
+		v, err := b.PropertyAssignment(p)
+		if err != nil {
+			return nil, fmt.Errorf("object literal property %q: %w", p.Name, err)
+		}
+		props = append(props, v)
+	}
+	res, err := objF(goja.Undefined(), b.vm.NewArray(props...))
+	if err != nil {
+		return nil, xerrors.Errorf("call objectLiteralExpression: %w", err)
+	}
+	return res.ToObject(b.vm), nil
+}
+
+// PropertyAssignment builds `<name>: <initializer>` for an
+// ObjectLiteralExpression child.
+func (b *Bindings) PropertyAssignment(pa *PropertyAssignment) (*goja.Object, error) {
+	paF, err := b.f("propertyAssignment")
+	if err != nil {
+		return nil, err
+	}
+	init, err := b.ToTypescriptNode(pa.Initializer)
+	if err != nil {
+		return nil, fmt.Errorf("property assignment %q initializer: %w", pa.Name, err)
+	}
+	res, err := paF(goja.Undefined(), b.vm.ToValue(pa.Name), init)
+	if err != nil {
+		return nil, xerrors.Errorf("call propertyAssignment: %w", err)
+	}
+	return res.ToObject(b.vm), nil
+}
+
+// Parameter builds a single `name: type` arrow-function parameter.
+func (b *Bindings) Parameter(p *Parameter) (*goja.Object, error) {
+	pF, err := b.f("parameter")
+	if err != nil {
+		return nil, err
+	}
+	var typeNode goja.Value = goja.Undefined()
+	if p.Type != nil {
+		typeNode, err = b.ToTypescriptNode(p.Type)
+		if err != nil {
+			return nil, fmt.Errorf("parameter %q type: %w", p.Name, err)
+		}
+	}
+	res, err := pF(goja.Undefined(), b.vm.ToValue(p.Name), typeNode)
+	if err != nil {
+		return nil, xerrors.Errorf("call parameter: %w", err)
+	}
+	return res.ToObject(b.vm), nil
+}
+
+// ArrowFunction builds `(parameters): returnType => body`.
+func (b *Bindings) ArrowFunction(af *ArrowFunction) (*goja.Object, error) {
+	afF, err := b.f("arrowFunction")
+	if err != nil {
+		return nil, err
+	}
+	params := make([]interface{}, 0, len(af.Parameters))
+	for _, p := range af.Parameters {
+		v, err := b.Parameter(p)
+		if err != nil {
+			return nil, fmt.Errorf("arrow function parameter %q: %w", p.Name, err)
+		}
+		params = append(params, v)
+	}
+	var returnType goja.Value = goja.Undefined()
+	if af.ReturnType != nil {
+		returnType, err = b.ToTypescriptNode(af.ReturnType)
+		if err != nil {
+			return nil, fmt.Errorf("arrow function return type: %w", err)
+		}
+	}
+	body, err := b.ToTypescriptNode(af.Body)
+	if err != nil {
+		return nil, fmt.Errorf("arrow function body: %w", err)
+	}
+	res, err := afF(goja.Undefined(), b.vm.NewArray(params...), returnType, body)
+	if err != nil {
+		return nil, xerrors.Errorf("call arrowFunction: %w", err)
+	}
+	return res.ToObject(b.vm), nil
+}
+
+// TypeQuery builds `typeof <name>` as a TypeNode.
+func (b *Bindings) TypeQuery(tq *TypeQuery) (*goja.Object, error) {
+	tqF, err := b.f("typeQuery")
+	if err != nil {
+		return nil, err
+	}
+	res, err := tqF(goja.Undefined(), b.vm.ToValue(tq.Name.Ref()))
+	if err != nil {
+		return nil, xerrors.Errorf("call typeQuery: %w", err)
+	}
+	return res.ToObject(b.vm), nil
+}

bindings/expressions.go

@@ -197,3 +197,105 @@ type TypeIntersection struct {
 
 func (*TypeIntersection) isNode()           {}
 func (*TypeIntersection) isExpressionType() {}
+
+// IdentifierExpression is a value-position TypeScript identifier such as
+// the `z` in `z.string()` or `BaseSchema` in `BaseSchema.extend({...})`.
+//
+// It is distinct from bindings.Identifier despite the similar name.
+// Identifier is parser-layer plumbing: a qualified-name handle
+// (Name + Package + Prefix) used to resolve and disambiguate references
+// across Go packages, and it is not itself a Node. IdentifierExpression is
+// tree-layer plumbing: a Node that implements ExpressionType so callers
+// can place a value-position identifier inside expression slots like
+// CallExpression.Expression.
+//
+// The Name field is itself an Identifier so cross-package prefixing flows
+// through .Ref() the same way it does for ReferenceType.Name and
+// VariableDeclaration.Name.
+type IdentifierExpression struct {
+	Name Identifier
+}
+
+func (*IdentifierExpression) isNode()           {}
+func (*IdentifierExpression) isExpressionType() {}
+
+// PropertyAccessExpression is `<expression>.<name>`, used to chain method
+// names or member references such as `z.string` or `BaseSchema.extend`.
+type PropertyAccessExpression struct {
+	Expression ExpressionType
+	Name       string
+}
+
+func (*PropertyAccessExpression) isNode()           {}
+func (*PropertyAccessExpression) isExpressionType() {}
+
+// CallExpression is `<expression>(args...)`. It composes with
+// PropertyAccessExpression to build chained calls like
+// `z.string().optional()`.
+type CallExpression struct {
+	Expression ExpressionType
+	Arguments  []ExpressionType
+}
+
+func (*CallExpression) isNode()           {}
+func (*CallExpression) isExpressionType() {}
+
+// ObjectLiteralExpression is `{ k: v, ... }` in expression position. It is
+// distinct from TypeLiteralNode, which emits a TypeScript object type.
+//
+// Only the PropertyAssignment form is modeled. ShorthandPropertyAssignment
+// (`{ x }`), SpreadAssignment (`{ ...rest }`), MethodDeclaration, and
+// accessor properties are not yet supported; add them if you need them.
+type ObjectLiteralExpression struct {
+	Properties []*PropertyAssignment
+}
+
+func (*ObjectLiteralExpression) isNode()           {}
+func (*ObjectLiteralExpression) isExpressionType() {}
+
+// PropertyAssignment is `<name>: <initializer>` inside an
+// ObjectLiteralExpression. It is a node but not an ExpressionType or a
+// DeclarationType because it only appears as a child of
+// ObjectLiteralExpression.
+type PropertyAssignment struct {
+	Name        string
+	Initializer ExpressionType
+}
+
+func (*PropertyAssignment) isNode() {}
+
+// Parameter is a single parameter in an ArrowFunction signature. Name is
+// required; Type may be nil to omit the annotation.
+type Parameter struct {
+	Name string
+	Type ExpressionType
+}
+
+func (*Parameter) isNode() {}
+
+// ArrowFunction is `(parameters): returnType => body`. ReturnType may be
+// nil to omit the annotation. Body is currently required to be a single
+// expression; statement bodies are not yet modeled.
+type ArrowFunction struct {
+	Parameters []*Parameter
+	ReturnType ExpressionType
+	Body       ExpressionType
+}
+
+func (*ArrowFunction) isNode()           {}
+func (*ArrowFunction) isExpressionType() {}
+
+// TypeQuery is `typeof <name>`. It appears in type position, typically as
+// a generic argument such as the `typeof FooSchema` inside
+// `z.infer<typeof FooSchema>`.
+//
+// Name is an Identifier so cross-package prefixing flows through .Ref(),
+// matching the rest of the AST. Without this, a TypeQuery for a prefixed
+// declaration would emit `typeof Foo` while the matching value-position
+// IdentifierExpression emits `ExternalFoo`, and the two would not line up.
+type TypeQuery struct {
+	Name Identifier
+}
+
+func (*TypeQuery) isNode()           {}
+func (*TypeQuery) isExpressionType() {}