@expo/expo-modules-macros-plugin 0.5.0 → 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)
@@ -411,10 +348,11 @@ internal func buildDecorateJavaScriptObject(functions: [JSFunction], properties:
 
 /// The shared-object counterpart of `_decorateModule`. Core supplies the class `prototype`; this binds
 /// every `@JS func` and `@JS var` of the given shared-object type onto it. Because a shared object has a
-/// distinct native instance behind each JS object, the bindings are **static** and recover the typed
-/// receiver from the JS `this` per call (`try SharedObject.native(from: this.asObject(in: runtime), as: <Type>.self)`)
-/// rather than capturing a singleton `self`. The first parameter is `prototype` (not `object` as on
-/// `_decorateModule`) because it's the shared class prototype, not an instance. The constructor is
+/// distinct native instance behind each JS object, the bindings recover the typed receiver from the JS
+/// `this` per call (`try SharedObject.native(from: this.asObject(in: runtime), as: <Type>.self)`)
+/// rather than capturing a singleton `self`. Overrides the base `SharedObject` class method so core can
+/// dispatch to it through the concrete type's metatype. The first parameter is `prototype` (not `object`
+/// as on `_decorateModule`) because it's the shared class prototype, not an instance. The constructor is
 /// bound separately (see `JSConstructor.buildConstructor`). Only emitted when the type has at least one
 /// `@JS func`/`var`.
 internal func buildDecorateSharedObject(
@@ -423,7 +361,7 @@ internal func buildDecorateSharedObject(
   let body = decorateBody(functions: functions, properties: properties, receiver: .sharedObject(typeName: typeName))
   return """
     @JavaScriptActor
-    public static func _decorateSharedObject(prototype: borrowing JavaScriptObject, in runtime: JavaScriptRuntime, appContext: AppContext) throws {
+    public override class func _decorateSharedObject(prototype: borrowing JavaScriptObject, in runtime: JavaScriptRuntime, appContext: AppContext) throws {
     \(raw: body)
     }
     """

package/apple/Sources/ExpoModulesMacros/JSConstructor.swift

@@ -1,9 +1,10 @@
 import SwiftSyntax
 
 /// A `@JS init` collected for direct JSI binding. A shared-object type has at most one (JS classes
-/// have a single constructor). Instead of a `Constructor { … }` DSL entry, the macro synthesizes a
-/// static `_constructSharedObject(...)` that decodes the JS arguments and returns a fresh instance;
-/// unlike the method/property bindings it produces the native instance rather than recovering one.
+/// have a single constructor). Instead of a `Constructor { … }` DSL entry, the macro synthesizes an
+/// override of `SharedObject._constructSharedObject(...)` that decodes the JS arguments and returns a
+/// fresh instance; unlike the method/property bindings it produces the native instance rather than
+/// recovering one.
 internal struct JSConstructor {
   let parameters: [FunctionParameterSyntax]
 
@@ -11,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] = []
 
@@ -25,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)")
@@ -47,12 +42,14 @@ internal struct JSConstructor {
       .joined(separator: "\n")
   }
 
-  /// The static `_constructSharedObject` entry point the runtime calls to build an instance from JS
-  /// arguments, returning the concrete type. `this`/`appContext` may go unreferenced, which is harmless.
+  /// The `_constructSharedObject` entry point the runtime calls to build an instance from JS
+  /// arguments. Overrides the base `SharedObject` class method so core can dispatch to it through the
+  /// concrete type's metatype; the body returns the concrete instance, which promotes to the base
+  /// `SharedObject?` return type. `this`/`appContext` may go unreferenced, which is harmless.
   func buildConstructor(typeName: String) -> DeclSyntax {
     return """
       @JavaScriptActor
-      public static func _constructSharedObject(this: JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime, appContext: AppContext) throws -> \(raw: typeName) {
+      public override class func _constructSharedObject(this: JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime, appContext: AppContext) throws -> SharedObject? {
       \(raw: bodyStatements(typeName: typeName, indent: "  "))
       }
       """

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 ""
     }
   }
 }