@expo/expo-modules-macros-plugin 0.5.1 → 0.6.0

package/apple/Sources/ExpoModulesMacros/DecorateModuleBuilder.swift

@@ -50,12 +50,11 @@ internal struct JSFunction {
   /// The decode-call-encode statements that form the host-function body, indented with the given
   /// prefix. Receiver unwrap (shared objects only), then an arity guard (an exact check when every
   /// parameter is required, otherwise a range check) throwing `Exceptions.ArgumentsRangeMismatch`;
-  /// then the decode of the always-present required prefix (primitives via a direct typed accessor
-  /// like `asDouble()` on a zero-copy `arguments.unownedValue(at:)`, others via
-  /// `getDynamicType().cast(...)`); then the call and result encode (primitives via
-  /// `toJavaScriptValue(in:)`, others via `castToJS(...)`). When a trailing run of parameters is
-  /// omittable the call branches on `arguments.count`, decoding only the slots that branch actually
-  /// has — `arguments[i]` traps past `count`, so a slot the caller didn't pass is never indexed.
+  /// then the decode of the always-present required prefix via `JavaScriptDecodable.decode` on a
+  /// zero-copy `arguments.unownedValue(at:)`; then the call and result encode via
+  /// `JavaScriptEncodable.encode`. When a trailing run of parameters is omittable the call branches
+  /// on `arguments.count`, decoding only the slots that branch actually has — `unownedValue(at:)` is
+  /// unchecked, so a slot the caller didn't pass is never indexed.
   private func bodyStatements(receiver: Receiver, indent: String) -> String {
     let required = requiredArgumentCount
     let maximum = parameters.count
@@ -119,18 +118,14 @@ internal struct JSFunction {
       .joined(separator: "\n")
   }
 
-  /// `let arg<index> = …` decoding the slot at `index` by its static type: a primitive through a
-  /// direct typed accessor on a borrowed `JavaScriptUnownedValue` (no owning value, no `jsi::Value`
-  /// copy, no `getDynamicType()` allocation, no `Any` boxing, no force-cast — still validating and
-  /// throwing `TypeError` on a mismatch), any other type through the dynamic converter (which needs
-  /// an owning value, so it indexes the buffer directly).
+  /// `let arg<index> = …` decoding the slot at `index` by its static type through
+  /// `JavaScriptDecodable.decode` on the borrowed `JavaScriptUnownedValue` — no owning value, no
+  /// `jsi::Value` copy, no `Any` boxing, no force-cast; it returns the concrete type directly. A
+  /// primitive's `decode` is `@inlinable` and lowers to the same direct accessor a hand-rolled fast
+  /// path would use.
   private func decodeStatement(at index: Int) -> String {
-    let type = parameters[index].type.trimmedDescription
-    if let accessor = fastDecodeAccessor(for: type) {
-      return "let arg\(index) = try arguments.unownedValue(at: \(index)).\(accessor)()"
-    }
-    let exprType = expressionType(type)
-    return "let arg\(index) = try \(exprType).getDynamicType().cast(jsValue: arguments[\(index)], appContext: appContext) as! \(exprType)"
+    let exprType = expressionType(parameters[index].type.trimmedDescription)
+    return "let arg\(index) = try \(exprType).decode(arguments.unownedValue(at: \(index)), in: runtime)"
   }
 
   /// The `<callee>.<name>(...)` call for the given arity. Slots `0..<arity` are passed their decoded
@@ -178,17 +173,17 @@ internal struct JSFunction {
     return lines
   }
 
-  /// Encode the `result` local back to JS and return it: a primitive through `toJavaScriptValue(in:)`
-  /// (the typed `JavaScriptRepresentable` conversion — no `Any`, no dynamic-type allocation), any
-  /// other type through the dynamic converter. A no-return function returns `.undefined` instead.
+  /// Encode the `result` local back to JS and return it through `JavaScriptEncodable.encode`, the same
+  /// for every type. Unlike the decode side there's no primitive fast path: `encode` produces the same
+  /// value as the primitive's `toJavaScriptValue(in:)` except for `Int`/`UInt`, where it range-checks
+  /// and throws instead of silently encoding an out-of-safe-range value as a lossy number — the
+  /// catchable error is the right behavior, and matches how non-primitive integers already encode. A
+  /// no-return function returns `.undefined` instead.
   private func encodeResultLines() -> [String] {
     guard let returnType else {
       return ["return .undefined"]
     }
-    if fastDecodeAccessor(for: returnType) != nil {
-      return ["return result.toJavaScriptValue(in: runtime)"]
-    }
-    return ["return try \(expressionType(returnType)).getDynamicType().castToJS(result, appContext: appContext, in: runtime)"]
+    return ["return try \(expressionType(returnType)).encode(result, in: runtime)"]
   }
 
   /// The `setProperty` statement that installs this function on the JS object. The decode-call-encode
@@ -201,10 +196,6 @@ internal struct JSFunction {
   /// the host-function closure is what keeps the native callable alive for as long as JS can invoke
   /// it; its lifetime is bounded by the JS VM's garbage collection of the object. A shared object
   /// captures nothing of the instance: it recovers the typed receiver from the JS `this` per call.
-  /// `appContext` is captured **weak** (and guarded) so it doesn't form a real retain cycle through
-  /// the app context. When no argument or return value goes through the dynamic-type converter the
-  /// body never references `appContext`, so the capture and guard are omitted to avoid the
-  /// unused-capture warning.
   func decorateStatements(receiver: Receiver) -> String {
     // Synchronous `@JS` bindings bind through the unowned-`this` `setProperty` overload, which hands
     // `this` in as a borrowed `JavaScriptUnownedValue` instead of allocating an owning
@@ -215,42 +206,19 @@ internal struct JSFunction {
     // on a shorthand `{ [capture] name, name in }` parameter. Async functions keep the untyped
     // shorthand and the owning-`this` overload: there is no unowned-`this` async variant and the buffer
     // escapes into the task anyway.
-    let captures = receiver.captureClause(usesAppContext: usesAppContext)
+    let captures = receiver.captureClause
     let parameters =
       isAsync
       ? "this, arguments"
       : "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer)"
 
     let object = receiver.decoratedObject
-    if usesAppContext {
-      return """
-          \(object).setProperty("\(jsName)") { \(captures)\(parameters) in
-            guard let appContext else {
-              throw Exceptions.AppContextLost()
-            }
-        \(bodyStatements(receiver: receiver, indent: "    "))
-          }
-        """
-    }
     return """
         \(object).setProperty("\(jsName)") { \(captures)\(parameters) in
       \(bodyStatements(receiver: receiver, indent: "    "))
         }
       """
   }
-
-  /// True when the host-function body references `appContext` — i.e. some parameter or the return
-  /// type lacks a fast accessor and decodes/encodes through `getDynamicType()`, which threads
-  /// `appContext` in.
-  private var usesAppContext: Bool {
-    if parameters.contains(where: { fastDecodeAccessor(for: $0.type.trimmedDescription) == nil }) {
-      return true
-    }
-    if let returnType, fastDecodeAccessor(for: returnType) == nil {
-      return true
-    }
-    return false
-  }
 }
 
 /// A `@JS var` collected for **direct JSI binding**. Instead of describing the property with a
@@ -263,9 +231,8 @@ internal struct JSFunction {
 ///
 /// The receiver (see `Receiver`) is the module's `self` for a module binding, or the per-call `_self`
 /// unwrapped from the JS `this` for a shared object. The getter reads `<callee>.<name>` and the setter
-/// writes `<callee>.<name> = …`. Decode/encode of the value reuse the same static-type fast path as
-/// functions (primitives through a direct typed accessor / `toJavaScriptValue`, other types through
-/// the `getDynamicType()` converter).
+/// writes `<callee>.<name> = …`. Decode/encode of the value go through `JavaScriptDecodable.decode` /
+/// `JavaScriptEncodable.encode`, the same uniform path as functions.
 internal struct JSProperty {
   let swiftName: String
   let jsName: String
@@ -282,18 +249,11 @@ internal struct JSProperty {
   /// the closure-taking `setProperty(_:)` overload — with the read/write body inlined into each
   /// closure — and installs it with `object.defineProperty(name, descriptor:)`. Capture matches the
   /// function bindings: a module captures `self` strong, a shared object captures nothing of the
-  /// instance; `appContext` is weak + guarded — and, like functions, the `appContext` capture + guard
-  /// are omitted from an accessor whose body never references it (a primitive value, decoded/encoded
-  /// without the dynamic converter), to avoid the unused-capture warning. Getter and setter are gated
-  /// independently.
+  /// instance. Getter and setter are gated independently.
   func decorateStatements(receiver: Receiver) -> String {
     let descriptorName = "\(swiftName)Descriptor"
     let callee = receiver.callee
     let object = receiver.decoratedObject
-    // A primitive value type encodes/decodes without `getDynamicType()`, so its accessor body never
-    // references `appContext`. `nil` (untyped) goes through the dynamic-less `toJavaScriptValue`
-    // getter, which also doesn't use it.
-    let usesAppContext = valueType.map { fastDecodeAccessor(for: $0) == nil } ?? false
     // A shared object's accessors unwrap the JS `this` into `_self` before reading/writing; a module
     // reads `self` directly. The unwrap leads each accessor body.
     let unwrap = receiver.unwrapStatement.map { "\($0)\n" } ?? ""
@@ -302,39 +262,28 @@ internal struct JSProperty {
     lines.append("let \(descriptorName) = runtime.createObject()")
     lines.append("\(descriptorName).setProperty(\"enumerable\", value: true)")
 
-    // Getter: read `<callee>.<name>` and encode the result back to JS.
+    // Getter: read `<callee>.<name>` and encode the result back to JS through `encode`. When the value
+    // type couldn't be inferred (no annotation and no literal default, rare for a stored var) there's
+    // no static type to call `encode` on, so the value's own `toJavaScriptValue(in:)` is the fallback.
     let getEncode: String
-    if let valueType, fastDecodeAccessor(for: valueType) != nil {
-      getEncode = "return \(callee).\(swiftName).toJavaScriptValue(in: runtime)"
-    } else if let valueType {
-      getEncode =
-        "return try \(expressionType(valueType)).getDynamicType().castToJS(\(callee).\(swiftName), appContext: appContext, in: runtime)"
+    if let valueType {
+      getEncode = "return try \(expressionType(valueType)).encode(\(callee).\(swiftName), in: runtime)"
     } else {
-      // No known type: fall back to converting whatever `<callee>.<name>` is. This only happens when
-      // the declaration has neither an annotation nor a literal default, which is rare for a stored
-      // var.
       getEncode = "return \(callee).\(swiftName).toJavaScriptValue(in: runtime)"
     }
     lines.append(
-      accessorClosure(
-        descriptorName, "get", receiver: receiver, usesAppContext: usesAppContext, body: "\(unwrap)\(getEncode)"))
+      accessorClosure(descriptorName, "get", receiver: receiver, body: "\(unwrap)\(getEncode)"))
 
-    // Setter: decode argument 0 by the static type and write `<callee>.<name>`. A typed setter needs
-    // a known value type; when the type couldn't be inferred the property is bound getter-only (a
-    // settable var with neither an annotation nor a literal default is rare and can't be decoded).
+    // Setter: decode argument 0 by the static type through `decode` and write `<callee>.<name>`. A
+    // typed setter needs a known value type; when the type couldn't be inferred the property is bound
+    // getter-only (a settable var with neither an annotation nor a literal default is rare and can't
+    // be decoded).
     if isSettable, let valueType {
-      let setDecode: String
-      if let accessor = fastDecodeAccessor(for: valueType) {
-        setDecode = "\(callee).\(swiftName) = try arguments.unownedValue(at: 0).\(accessor)()"
-      } else {
-        let exprType = expressionType(valueType)
-        setDecode =
-          "\(callee).\(swiftName) = try \(exprType).getDynamicType().cast(jsValue: arguments[0], appContext: appContext) as! \(exprType)"
-      }
+      let exprType = expressionType(valueType)
+      let setDecode = "\(callee).\(swiftName) = try \(exprType).decode(arguments.unownedValue(at: 0), in: runtime)"
       lines.append(
         accessorClosure(
-          descriptorName, "set", receiver: receiver, usesAppContext: usesAppContext,
-          body: "\(unwrap)\(setDecode)\nreturn .undefined"))
+          descriptorName, "set", receiver: receiver, body: "\(unwrap)\(setDecode)\nreturn .undefined"))
     }
 
     lines.append("\(object).defineProperty(\"\(jsName)\", descriptor: \(descriptorName))")
@@ -346,15 +295,13 @@ internal struct JSProperty {
   }
 
   /// One `descriptor.setProperty("get"/"set") { … }` accessor entry. The capture list follows the
-  /// receiver (a module captures `self` strong; a shared object captures nothing of the instance) and,
-  /// when `usesAppContext`, adds `appContext` weak + guarded (matching the function bindings);
-  /// otherwise the guard is omitted so a primitive accessor doesn't warn on an unused capture.
+  /// receiver: a module captures `self` strong; a shared object captures nothing of the instance.
   private func accessorClosure(
-    _ descriptorName: String, _ key: String, receiver: Receiver, usesAppContext: Bool, body: String
+    _ descriptorName: String, _ key: String, receiver: Receiver, body: String
   ) -> String {
-    let captures = receiver.captureClause(usesAppContext: usesAppContext)
-    // Indent each line of a (possibly multi-line) body to sit one level inside the closure, aligned
-    // with the `guard`; a bare `\(body)` interpolation would only indent the first line.
+    let captures = receiver.captureClause
+    // Indent each line of a (possibly multi-line) body to sit one level inside the closure; a bare
+    // `\(body)` interpolation would only indent the first line.
     let indentedBody = body
       .split(separator: "\n", omittingEmptySubsequences: false)
       .map { "  \($0)" }
@@ -365,16 +312,6 @@ internal struct JSProperty {
     // `borrowing JavaScriptUnownedValue` selects the unowned-`this` overload. A module ignores `this`;
     // a shared object unwraps it in the body.
     let parameters = "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer)"
-    if usesAppContext {
-      return """
-        \(descriptorName).setProperty("\(key)") { \(captures)\(parameters) in
-          guard let appContext else {
-            throw Exceptions.AppContextLost()
-          }
-        \(indentedBody)
-        }
-        """
-    }
     return """
       \(descriptorName).setProperty("\(key)") { \(captures)\(parameters) in
       \(indentedBody)

package/apple/Sources/ExpoModulesMacros/JSConstructor.swift

@@ -12,8 +12,9 @@ internal struct JSConstructor {
     self.parameters = Array(initDecl.signature.parameterClause.parameters)
   }
 
-  /// The body statements, indented with `indent`: arity guard, per-argument decode (primitives via a
-  /// typed accessor, others via the dynamic converter), then `return <Type>(label: arg0, …)`.
+  /// The body statements, indented with `indent`: arity guard, per-argument decode through
+  /// `JavaScriptDecodable.decode` on a zero-copy `arguments.unownedValue(at:)` (the arity guard proves
+  /// each index is in bounds), then `return <Type>(label: arg0, …)`.
   private func bodyStatements(typeName: String, indent: String) -> String {
     var lines: [String] = []
 
@@ -26,15 +27,8 @@ internal struct JSConstructor {
 
     var callArguments: [String] = []
     for (index, parameter) in parameters.enumerated() {
-      let type = parameter.type.trimmedDescription
-
-      if let accessor = fastDecodeAccessor(for: type) {
-        lines.append("let arg\(index) = try arguments.unownedValue(at: \(index)).\(accessor)()")
-      } else {
-        let exprType = expressionType(type)
-        lines.append(
-          "let arg\(index) = try \(exprType).getDynamicType().cast(jsValue: arguments[\(index)], appContext: appContext) as! \(exprType)")
-      }
+      let exprType = expressionType(parameter.type.trimmedDescription)
+      lines.append("let arg\(index) = try \(exprType).decode(arguments.unownedValue(at: \(index)), in: runtime)")
 
       let label = parameter.firstName.text
       callArguments.append(label == "_" ? "arg\(index)" : "\(label): arg\(index)")

package/apple/Sources/ExpoModulesMacros/JSMacro.swift

@@ -6,11 +6,13 @@ import SwiftSyntaxMacros
 /// corresponding `Function` / `AsyncFunction` / `Property` / `Constructor` registrations; that part
 /// of the expansion lives in those macros.
 ///
-/// On its own, `@JS` emits one thing: a never-called peer that asserts every type crossing the JS
-/// boundary is JS-convertible. Because it's a **peer** of the marked member, a non-conforming type
-/// produces a compile error located on the user's own `@JS` declaration rather than on the enclosing
-/// `@ExpoModule`. The assertion mechanism itself is shared (see `typeConformanceAssertion`); `@JS`
-/// only supplies the boundary types it reads off the declaration.
+/// On its own, `@JS` emits one thing: a never-called peer that asserts each type crossing the JS
+/// boundary is convertible in the direction it travels — arguments are `JavaScriptDecodable`, return
+/// values are `JavaScriptEncodable` (a settable property's value type is both). Because it's a
+/// **peer** of the marked member, a non-conforming type produces a compile error located on the
+/// user's own `@JS` declaration rather than on the enclosing `@ExpoModule`. The assertion mechanism
+/// itself is shared (see `directionalConformanceAssertion`); `@JS` only supplies the boundary types,
+/// split by direction, that it reads off the declaration.
 ///
 /// Usage:
 ///
@@ -29,8 +31,10 @@ public struct JSMacro: PeerMacro {
     in context: some MacroExpansionContext
   ) throws -> [DeclSyntax] {
     guard let member = boundaryMember(of: declaration),
-      let assertion = typeConformanceAssertion(
-        for: ConformanceAssertion(name: member.name, types: member.types),
+      let assertion = directionalConformanceAssertion(
+        name: member.name,
+        decodableTypes: member.decodableTypes,
+        encodableType: member.encodableType,
         isStatic: member.isStatic
       ) else {
       return []
@@ -39,37 +43,54 @@ public struct JSMacro: PeerMacro {
   }
 }
 
-/// What an assertion peer needs about the `@JS` member it sits beside: a name (to keep the peer
-/// unique among siblings), the types crossing the JS boundary, and whether the member is type-level.
+/// What an assertion peer needs about the `@JS` member it sits beside: a name (to keep the peer unique
+/// among siblings), the boundary types split by conversion direction, and whether the member is
+/// type-level. Arguments (and a settable property's incoming value) are decoded; return values (and a
+/// property's outgoing value) are encoded, so each is asserted against the protocol for its direction.
 private struct BoundaryMember {
   let name: String
-  /// Boundary types as written. Composed types (`[Int]`, `String?`, …) are kept verbatim — their
-  /// conditional conformances transitively constrain the elements.
-  let types: [String]
+  /// Types decoded from JS: function/constructor arguments, and a settable property's value type.
+  let decodableTypes: [String]
+  /// The single type encoded to JS: a function's return type, or a property's value type on read;
+  /// `nil` when the member produces nothing JS-visible (a `Void` function).
+  let encodableType: String?
   /// True for `static`/`class` members, so the peer is emitted in the same metatype context.
   let isStatic: Bool
 }
 
-/// Reads the boundary member off a `@JS` declaration. A function contributes its parameter types
-/// plus the return type (when non-Void); a property contributes its declared type. Returns `nil` for
-/// declaration kinds `@JS` doesn't read types from, or a property whose type isn't spelled out (a
-/// syntactic macro can't recover it), so no assertion is emitted there.
+/// Reads the boundary member off a `@JS` declaration, splitting its types by conversion direction. A
+/// function contributes its parameter types (decodable) and its return type when non-Void (encodable);
+/// a property contributes its value type as encodable (the getter) and also as decodable when settable
+/// (the setter). Composed types (`[Int]`, `String?`, …) are kept verbatim, their conditional
+/// conformances transitively constraining the elements. Returns `nil` for declaration kinds `@JS`
+/// doesn't read types from, or a property whose type isn't spelled out (a syntactic macro can't
+/// recover it).
 private func boundaryMember(of declaration: some DeclSyntaxProtocol) -> BoundaryMember? {
   if let funcDecl = declaration.as(FunctionDeclSyntax.self) {
-    var types = funcDecl.signature.parameterClause.parameters.map { $0.type.trimmedDescription }
-    if let returnType = funcDecl.signature.returnClause?.type, !isVoidType(returnType) {
-      types.append(returnType.trimmedDescription)
-    }
-    return BoundaryMember(name: funcDecl.name.text, types: types, isStatic: isTypeLevel(funcDecl.modifiers))
+    let decodableTypes = funcDecl.signature.parameterClause.parameters.map { $0.type.trimmedDescription }
+    let returnType = funcDecl.signature.returnClause?.type
+    let encodableType = returnType.flatMap { isVoidType($0) ? nil : $0.trimmedDescription }
+    return BoundaryMember(
+      name: funcDecl.name.text,
+      decodableTypes: decodableTypes,
+      encodableType: encodableType,
+      isStatic: isTypeLevel(funcDecl.modifiers)
+    )
   }
 
   if let varDecl = declaration.as(VariableDeclSyntax.self),
     let binding = varDecl.bindings.first,
     let identifier = binding.pattern.as(IdentifierPatternSyntax.self),
     let type = binding.typeAnnotation?.type {
+    // A `let`, or a `var` with no setter, is read-only (encodable only). A settable `var` is also
+    // decoded on write, so its value type is asserted in both directions.
+    let typeText = type.trimmedDescription
+    let isVar = varDecl.bindingSpecifier.tokenKind == .keyword(.var)
+    let isSettable = isVar && bindingIsSettable(binding)
     return BoundaryMember(
       name: identifier.identifier.text,
-      types: [type.trimmedDescription],
+      decodableTypes: isSettable ? [typeText] : [],
+      encodableType: typeText,
       isStatic: isTypeLevel(varDecl.modifiers)
     )
   }

package/apple/Sources/ExpoModulesMacros/MacroHelpers.swift

@@ -246,10 +246,11 @@ extension AttributeListSyntax {
   }
 }
 
-/// A type spelled so it's valid in expression position (before `.getDynamicType()` or after `as!`).
-/// Implicitly-unwrapped optionals (`T!`) are only allowed in type-annotation position, so a trailing
-/// `!` is rewritten to `?` (`T!` and `T?` are both `Optional<T>`, which the dynamic-type / cast layer
-/// treats identically). Other type spellings pass through unchanged.
+/// A type spelled so it's valid in expression position (before `.decode`/`.encode`, before
+/// `.getDynamicType()`, or after `as!`). Implicitly-unwrapped optionals (`T!`) are only allowed in
+/// type-annotation position, so a trailing `!` is rewritten to `?` (`T!` and `T?` are both
+/// `Optional<T>`, which the conversion layer treats identically). Other type spellings pass through
+/// unchanged.
 internal func expressionType(_ type: String) -> String {
   guard type.hasSuffix("!") else {
     return type
@@ -292,7 +293,7 @@ internal func collectProperties(
 /// a computed property is settable only when it declares an explicit `set` accessor. A getter-only
 /// computed property (`{ get }` or a single getter body) stays read-only. `willSet`/`didSet`
 /// observers imply stored storage, which is also settable.
-private func bindingIsSettable(_ binding: PatternBindingSyntax) -> Bool {
+internal func bindingIsSettable(_ binding: PatternBindingSyntax) -> Bool {
   guard let accessorBlock = binding.accessorBlock else {
     return true
   }
@@ -310,22 +311,3 @@ private func bindingIsSettable(_ binding: PatternBindingSyntax) -> Bool {
     return false
   }
 }
-
-/// The throwing `JavaScriptUnownedValue` accessor that decodes the given primitive type directly
-/// (`asDouble()` for `Double`, etc.), bypassing the dynamic-type converter. Returns `nil` for types
-/// without a dedicated accessor (arrays, records, optionals, shared objects, other numeric widths),
-/// which decode through `getDynamicType().cast(...)`.
-func fastDecodeAccessor(for type: String) -> String? {
-  switch type {
-  case "Bool":
-    return "asBool"
-  case "Int":
-    return "asInt"
-  case "Double":
-    return "asDouble"
-  case "String":
-    return "asString"
-  default:
-    return nil
-  }
-}

package/apple/Sources/ExpoModulesMacros/Receiver.swift

@@ -45,14 +45,13 @@ internal enum Receiver {
   }
 
   /// The capture-clause fragment (with a trailing space, or empty when nothing is captured). A module
-  /// captures `self` strong; a shared object captures nothing of the instance. `appContext`, when used,
-  /// is captured weak in both cases.
-  func captureClause(usesAppContext: Bool) -> String {
+  /// captures `self` strong; a shared object captures nothing of the instance.
+  var captureClause: String {
     switch self {
     case .module:
-      return usesAppContext ? "[weak appContext, self] " : "[self] "
+      return "[self] "
     case .sharedObject:
-      return usesAppContext ? "[weak appContext] " : ""
+      return ""
     }
   }
 }

package/apple/Sources/ExpoModulesMacros/RecordMacro.swift

@@ -29,10 +29,13 @@ import SwiftSyntaxMacros
  an optional type makes it nullable and optional, and a non-optional property without a
  default is required (the factories throw when the source omits it).
 
- Conversions go through the **public** dynamic-type API — `T.getDynamicType()` plus
- `cast(jsValue:appContext:)` / `cast(_:appContext:)` / `convertToJS(_:appContext:)` —
- so the synthesized code compiles inside user modules without any internal core symbols.
- Every property type must therefore conform to `AnyArgument`.
+ The JS-value paths convert through `JavaScriptDecodable.decode` / `JavaScriptEncodable.encode`
+ (`from(object:)` / `toObject(appContext:)`); the native-`Any` dictionary paths still go through the
+ public dynamic-type API — `T.getDynamicType()` plus `cast(_:appContext:)` / `convertToJS(_:appContext:)`
+ (`from(dictionary:)` / `toDictionary(appContext:)`), since `JavaScriptCodable` only converts JS
+ values, not native `Any`. Both spell types as `public` symbols so the synthesized code compiles inside
+ user modules without any internal core symbols. Every property type must therefore conform to both
+ `AnyArgument` and `JavaScriptDecodable & JavaScriptEncodable`.
 
  For classes that inherit from another `@Record`-annotated class, the synthesized
  methods chain to `super` so inherited properties are handled first.
@@ -60,14 +63,15 @@ public struct RecordMacro: MemberMacro, ExtensionMacro {
 
     var members: [DeclSyntax] = []
 
-    // A single never-called member that makes the compiler verify each property type is
-    // JS-convertible (the conversions below go through its dynamic-type API). Each property keeps its
-    // own named assertion inside, so the compiler's conformance diagnostic names the offending
-    // property (see `typeConformanceAssertions`). Emitted first so that, for a non-conforming type,
-    // this clear "requires that '…' conform to '…'" error is reported ahead of the noisier
-    // "no member 'getDynamicType'" errors from the conversion code below.
+    // A single never-called member that makes the compiler verify each property type is convertible
+    // both ways (the JS-value paths call `decode`/`encode`; the native-`Any` dictionary paths call
+    // the dynamic-type API). Each property keeps its own named assertion inside, so the compiler's
+    // conformance diagnostic names the offending property (see `typeConformanceAssertions`). Emitted
+    // first so that, for a non-conforming type, this clear "requires that '…' conform to '…'" error
+    // is reported ahead of the noisier "no member 'decode'"/"getDynamicType" errors from the
+    // conversion code below.
     let assertions = properties.map { ConformanceAssertion(name: $0.name, types: [$0.type]) }
-    if let assertionMember = typeConformanceAssertions(for: assertions) {
+    if let assertionMember = typeConformanceAssertions(for: assertions, constraint: recordFieldProtocolName) {
       members.append(assertionMember)
     }
 
@@ -131,8 +135,9 @@ public struct RecordMacro: MemberMacro, ExtensionMacro {
  */
 private struct RecordProperty {
   let name: String
-  /// The property's declared type, verbatim (e.g. `String`, `Int`, `String?`). Used to build
-  /// the memberwise-init parameter and to look up the dynamic type via `T.getDynamicType()`.
+  /// The property's declared type, verbatim (e.g. `String`, `Int`, `String?`). Used to build the
+  /// memberwise-init parameter and as the receiver of the per-property `decode`/`encode` (and, on the
+  /// dictionary paths, `getDynamicType()`) conversions.
   let type: String
   /// The default-value expression verbatim (`0`, `""`, `[]`), or `nil` when the property has none.
   /// Inlined into the memberwise init and the factories' omitted-property branch so the synthesized
@@ -155,7 +160,7 @@ private struct RecordProperty {
 /**
  Discovers the record's properties: every stored `var`/`let` binding that is not `static`,
  `private`, `fileprivate`, `lazy`, or computed. Each property must declare an explicit type
- annotation, since the synthesized conversions reference `Type.getDynamicType()`.
+ annotation, since the synthesized conversions name the type (e.g. `Type.decode(…)`).
  */
 private func recordProperties(
   of declaration: some DeclGroupSyntax
@@ -271,11 +276,20 @@ private func memberwiseInit(properties: [RecordProperty]) -> DeclSyntax {
 /**
  `from(object:appContext:)` — reads each property off the `JavaScriptObject` into a local,
  then constructs the record through the memberwise init. Required properties throw when
- undefined; defaulted properties fall back to the property's declared default (read from a
- throwaway `Self()`) when undefined; optional properties become `nil` when undefined/null.
+ undefined; defaulted properties fall back to the property's declared default (inlined) when
+ undefined; optional properties become `nil` when undefined/null. Each property is decoded with
+ `JavaScriptDecodable.decode`, so the factory binds the `runtime` from the app context once and
+ threads it to every read.
  */
 private func fromJSObjectFactory(properties: [RecordProperty]) -> DeclSyntax {
-  let body = factoryBody(properties: properties, readLines: jsObjectReadLines(properties: properties))
+  var lines: [String] = []
+  // Only bind the runtime when there's a property to decode — an empty record's factory would
+  // otherwise leave it unused.
+  if !properties.isEmpty {
+    lines.append("  let runtime = try appContext.runtime")
+  }
+  lines.append(factoryBody(properties: properties, readLines: jsObjectReadLines(properties: properties)))
+  let body = lines.joined(separator: "\n")
   return """
     @JavaScriptActor
     public static func from(object: borrowing JavaScriptObject, appContext: AppContext) throws -> Self {
@@ -311,23 +325,25 @@ private func factoryBody(properties: [RecordProperty], readLines: [String]) -> S
   return lines.joined(separator: "\n")
 }
 
-/// Per-property read statements for the JS-object factory, each producing a `let <name>`.
+/// Per-property read statements for the JS-object factory, each producing a `let <name>` by decoding
+/// the JS value with `JavaScriptDecodable.decode` (recovering the app context from `runtime` itself).
 private func jsObjectReadLines(properties: [RecordProperty]) -> [String] {
   var lines: [String] = []
   for property in properties {
     let valueVar = "\(property.name)JSValue"
     let exprType = expressionType(property.type)
-    let cast = "try \(exprType).getDynamicType().cast(jsValue: \(valueVar), appContext: appContext) as! \(exprType)"
+    let decode = "try \(exprType).decode(\(valueVar), in: runtime)"
     lines.append("  let \(valueVar) = object.getProperty(\"\(property.name)\")")
     if property.isRequired {
       lines.append("  guard !\(valueVar).isUndefined() else {")
       lines.append("    throw RecordPropertyRequiredException(\"\(property.name)\")")
       lines.append("  }")
-      lines.append("  let \(property.name) = \(cast)")
+      lines.append("  let \(property.name) = \(decode)")
     } else if property.isOptional {
-      lines.append("  let \(property.name): \(property.type) = (\(valueVar).isUndefined() || \(valueVar).isNull()) ? nil : \(cast)")
+      // `Optional.decode` already maps `undefined`/`null` to `nil`, so the read is a plain decode.
+      lines.append("  let \(property.name) = \(decode)")
     } else {
-      lines.append("  let \(property.name) = \(valueVar).isUndefined() ? \(property.defaultValue!) : \(cast)")
+      lines.append("  let \(property.name) = \(valueVar).isUndefined() ? \(property.defaultValue!) : \(decode)")
     }
   }
   return lines
@@ -388,20 +404,27 @@ private func toDictionaryMethod(properties: [RecordProperty], inheritsRecord: Bo
 }
 
 /**
- `toObject(appContext:)` — builds a `JavaScriptObject` directly, converting each property via
- `convertToJS`. The fast write path mirroring `from(object:)`. Subclasses chain to `super` so
- inherited properties are written first.
+ `toObject(appContext:)` — builds a `JavaScriptObject` directly, encoding each property with
+ `JavaScriptEncodable.encode`. The fast write path mirroring `from(object:)`. The `runtime` is bound
+ from the app context once and threaded to every write. Subclasses chain to `super` so inherited
+ properties are written first.
  */
 private func toObjectMethod(properties: [RecordProperty], inheritsRecord: Bool) -> DeclSyntax {
   let overrideKeyword = inheritsRecord ? "override " : ""
   var lines: [String] = []
+  // The base case needs the runtime to create the object; the inheriting case only needs it when
+  // there's a property to encode (it chains to `super` for the object itself). Binding it when unused
+  // would warn.
+  if !inheritsRecord || !properties.isEmpty {
+    lines.append("  let runtime = try appContext.runtime")
+  }
   if inheritsRecord {
     lines.append("  let object = try super.toObject(appContext: appContext)")
   } else {
-    lines.append("  let object = try appContext.runtime.createObject()")
+    lines.append("  let object = runtime.createObject()")
   }
   for property in properties {
-    lines.append("  object.setProperty(\"\(property.name)\", value: try \(expressionType(property.type)).getDynamicType().convertToJS(self.\(property.name), appContext: appContext))")
+    lines.append("  object.setProperty(\"\(property.name)\", value: try \(expressionType(property.type)).encode(self.\(property.name), in: runtime))")
   }
   lines.append("  return object")
   let body = lines.joined(separator: "\n")