pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/android/src/test/java/com/pythonnative/runtime/GestureArbiterTest.kt

@@ -0,0 +1,197 @@
+package com.pythonnative.runtime
+
+import com.pythonnative.runtime.gestures.GestureArbiter
+import com.pythonnative.runtime.gestures.GestureConfig
+import org.json.JSONArray
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class GestureArbiterTest {
+    private class Recorder {
+        val events = ArrayList<Pair<Int, Map<String, Any?>>>()
+        fun emit(index: Int, payload: Map<String, Any?>) {
+            events.add(index to payload)
+        }
+        fun states(index: Int) = events.filter { it.first == index }.map { it.second["state"] }
+    }
+
+    private fun tap(nTaps: Int = 1, sim: Set<Int>? = null, waitFor: Set<Int> = emptySet()) =
+        GestureConfig(kind = "tap", nTaps = nTaps, simultaneous = sim, waitFor = waitFor)
+
+    @Test
+    fun singleTapEmitsEnded() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(tap()), rec::emit)
+        arbiter.pointerDown(0, 10.0, 10.0, 0.0)
+        arbiter.pointerUp(0, 11.0, 10.0, 0.1)
+        assertEquals(listOf<Any?>("ended"), rec.states(0))
+        assertEquals(11.0, rec.events[0].second["x"])
+    }
+
+    @Test
+    fun tapFailsWhenPointerTravels() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(tap()), rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerMove(0, 50.0, 0.0, 0.05)
+        arbiter.pointerUp(0, 50.0, 0.0, 0.1)
+        assertTrue(rec.events.isEmpty())
+    }
+
+    @Test
+    fun doubleTapNeedsTwoTapsInsideTheWindow() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(tap(nTaps = 2)), rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerUp(0, 0.0, 0.0, 0.05)
+        assertTrue(rec.events.isEmpty())
+        arbiter.pointerDown(0, 0.0, 0.0, 0.2)
+        arbiter.pointerUp(0, 0.0, 0.0, 0.25)
+        assertEquals(listOf<Any?>("ended"), rec.states(0))
+    }
+
+    @Test
+    fun exclusiveSingleTapWaitsForDoubleTapWindow() {
+        // Exclusive(double_tap, single_tap): index 1 waits for index 0.
+        val rec = Recorder()
+        val specs = listOf(
+            tap(nTaps = 2, sim = emptySet()),
+            tap(nTaps = 1, sim = emptySet(), waitFor = setOf(0)),
+        )
+        val arbiter = GestureArbiter(specs, rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerUp(0, 0.0, 0.0, 0.05)
+        // Single tap is buffered until the double-tap gap expires.
+        assertTrue(rec.events.isEmpty())
+        val deadline = arbiter.nextDeadline()
+        assertTrue(deadline != null && deadline > 0.05)
+        arbiter.poll(deadline!! + 0.001)
+        assertEquals(listOf<Any?>("ended"), rec.states(1))
+        assertTrue(rec.states(0).isEmpty())
+    }
+
+    @Test
+    fun exclusiveDoubleTapSuppressesSingleTap() {
+        val rec = Recorder()
+        val specs = listOf(
+            tap(nTaps = 2, sim = emptySet()),
+            tap(nTaps = 1, sim = emptySet(), waitFor = setOf(0)),
+        )
+        val arbiter = GestureArbiter(specs, rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerUp(0, 0.0, 0.0, 0.05)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.15)
+        arbiter.pointerUp(0, 0.0, 0.0, 0.2)
+        assertEquals(listOf<Any?>("ended"), rec.states(0))
+        assertTrue(rec.states(1).isEmpty())
+    }
+
+    @Test
+    fun longPressActivatesOnPollAndEndsOnRelease() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(GestureConfig(kind = "long_press", minDurationMs = 500.0)), rec::emit)
+        arbiter.pointerDown(0, 5.0, 5.0, 0.0)
+        assertEquals(0.5, arbiter.nextDeadline()!!, 1e-9)
+        arbiter.poll(0.3)
+        assertTrue(rec.events.isEmpty())
+        arbiter.poll(0.5)
+        assertEquals(listOf<Any?>("began"), rec.states(0))
+        arbiter.pointerUp(0, 5.0, 5.0, 0.7)
+        assertEquals(listOf<Any?>("began", "ended"), rec.states(0))
+    }
+
+    @Test
+    fun panReportsTranslationAndVelocity() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(GestureConfig(kind = "pan", minDistance = 10.0)), rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerMove(0, 5.0, 0.0, 0.01)
+        assertTrue(rec.events.isEmpty())
+        arbiter.pointerMove(0, 20.0, 0.0, 0.02)
+        assertEquals(listOf<Any?>("began"), rec.states(0))
+        assertTrue(arbiter.hasActivePan())
+        arbiter.pointerMove(0, 30.0, 5.0, 0.03)
+        val changed = rec.events.last().second
+        assertEquals("changed", changed["state"])
+        assertEquals(10.0, changed["translation_x"] as Double, 1e-9)
+        assertEquals(5.0, changed["translation_y"] as Double, 1e-9)
+        assertTrue((changed["velocity_x"] as Double) > 0)
+        arbiter.pointerUp(0, 40.0, 5.0, 0.04)
+        val ended = rec.events.last().second
+        assertEquals("ended", ended["state"])
+        assertEquals(20.0, ended["translation_x"] as Double, 1e-9)
+        assertFalse(arbiter.hasActivePan())
+    }
+
+    @Test
+    fun raceLetsFirstActivationWin() {
+        // Pan and long press not simultaneous: the pan activates first, long press never fires.
+        val rec = Recorder()
+        val specs = listOf(
+            GestureConfig(kind = "pan", minDistance = 10.0, simultaneous = emptySet()),
+            GestureConfig(kind = "long_press", minDurationMs = 500.0, simultaneous = emptySet()),
+        )
+        val arbiter = GestureArbiter(specs, rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerMove(0, 3.0, 0.0, 0.05)
+        arbiter.pointerMove(0, 6.0, 0.0, 0.1)
+        arbiter.pointerMove(0, 20.0, 0.0, 0.15)
+        assertEquals(listOf<Any?>("began"), rec.states(0))
+        arbiter.poll(0.6)
+        assertTrue(rec.states(1).isEmpty())
+    }
+
+    @Test
+    fun simultaneousGesturesBothRun() {
+        val rec = Recorder()
+        val specs = listOf(
+            GestureConfig(kind = "pan", minDistance = 5.0, simultaneous = setOf(1)),
+            GestureConfig(kind = "pinch", simultaneous = setOf(0)),
+        )
+        val arbiter = GestureArbiter(specs, rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerDown(1, 100.0, 0.0, 0.01)
+        assertEquals(listOf<Any?>("began"), rec.states(1))
+        arbiter.pointerMove(1, 120.0, 0.0, 0.02)
+        assertEquals(listOf<Any?>("began"), rec.states(0))
+        assertEquals(listOf<Any?>("began", "changed"), rec.states(1))
+        assertEquals(1.2, rec.events.last().second["scale"] as Double, 1e-9)
+    }
+
+    @Test
+    fun swipeResolvesDirectionAndVelocity() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(GestureConfig(kind = "swipe", direction = "right", minVelocity = 300.0)), rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerMove(0, 50.0, 0.0, 0.05)
+        arbiter.pointerUp(0, 100.0, 0.0, 0.1)
+        val ended = rec.events.single().second
+        assertEquals("ended", ended["state"])
+        assertEquals("right", ended["direction"])
+        assertEquals(1000.0, ended["velocity_x"] as Double, 1e-6)
+    }
+
+    @Test
+    fun cancelAbortsActiveGestures() {
+        val rec = Recorder()
+        val arbiter = GestureArbiter(listOf(GestureConfig(kind = "pan", minDistance = 1.0)), rec::emit)
+        arbiter.pointerDown(0, 0.0, 0.0, 0.0)
+        arbiter.pointerMove(0, 10.0, 0.0, 0.01)
+        arbiter.cancel(0.02)
+        assertEquals(listOf<Any?>("began", "cancelled"), rec.states(0))
+    }
+
+    @Test
+    fun decodesSerializedSpecs() {
+        val specs = GestureArbiter.decodeSpecs(
+            JSONArray("""[{"kind":"tap","n_taps":2,"simultaneous":[1],"wait_for":[]},{"kind":"pan","min_distance":4}]"""),
+        )
+        assertEquals(2, specs.size)
+        assertEquals(2, specs[0].nTaps)
+        assertEquals(setOf(1), specs[0].simultaneous)
+        assertEquals(4.0, specs[1].minDistance, 0.0)
+        assertEquals(null, specs[1].simultaneous)
+    }
+}

pythonnative/native/android/src/test/java/com/pythonnative/runtime/PNColorTest.kt

@@ -0,0 +1,47 @@
+package com.pythonnative.runtime
+
+import com.pythonnative.runtime.components.PNColor
+import org.json.JSONArray
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class PNColorTest {
+    private fun hex(v: Int?): String = if (v == null) "null" else String.format("%08X", v)
+
+    @Test
+    fun parsesHexForms() {
+        assertEquals("FFFF0000", hex(PNColor.parse("#f00")))
+        assertEquals("FF112233", hex(PNColor.parse("#112233")))
+        assertEquals("80112233", hex(PNColor.parse("#80112233")))
+        assertEquals("FF112233", hex(PNColor.parse("112233")))
+    }
+
+    @Test
+    fun parsesFunctionalForms() {
+        assertEquals("FF0A141E", hex(PNColor.parse("rgb(10, 20, 30)")))
+        assertEquals("800A141E", hex(PNColor.parse("rgba(10, 20, 30, 0.5)")))
+    }
+
+    @Test
+    fun parsesNamedColors() {
+        assertEquals("FF000000", hex(PNColor.parse("black")))
+        assertEquals("FFFFFFFF", hex(PNColor.parse("White")))
+        assertEquals("00000000", hex(PNColor.parse("transparent")))
+    }
+
+    @Test
+    fun parsesIntegersAndArrays() {
+        assertEquals("FF112233", hex(PNColor.parse(0x112233)))
+        assertEquals("80112233", hex(PNColor.parse(0x80112233L)))
+        assertEquals("FF0A141E", hex(PNColor.parse(JSONArray("[10, 20, 30]"))))
+        assertEquals("800A141E", hex(PNColor.parse(JSONArray("[10, 20, 30, 0.5]"))))
+    }
+
+    @Test
+    fun rejectsGarbage() {
+        assertNull(PNColor.parse("not a color"))
+        assertNull(PNColor.parse(null))
+        assertEquals(7, PNColor.parseOr("nope", 7))
+    }
+}

pythonnative/native/android/src/test/java/com/pythonnative/runtime/PNTransactionTest.kt

@@ -0,0 +1,78 @@
+package com.pythonnative.runtime
+
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.Op
+import com.pythonnative.runtime.bridge.PNTransaction
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class PNTransactionTest {
+    @Test
+    fun decodesEveryOpcode() {
+        val json = """
+            [
+              ["c", 1, "View", {"background_color": "#fff"}],
+              ["u", 1, {"opacity": 0.5, "background_color": null}],
+              ["i", 1, 2, 0],
+              ["f", 2, 10, 20.5, 100, 40],
+              ["d", 2]
+            ]
+        """.trimIndent()
+        val ops = PNTransaction.decode(json)
+        assertEquals(5, ops.size)
+        val create = ops[0] as Op.Create
+        assertEquals(1L, create.tag)
+        assertEquals("View", create.typeName)
+        assertEquals("#fff", create.props.getString("background_color"))
+        val update = ops[1] as Op.Update
+        assertEquals(0.5, update.changed.getDouble("opacity"), 1e-9)
+        assertTrue(update.changed.isNull("background_color"))
+        assertEquals(Op.Insert(1, 2, 0), ops[2])
+        assertEquals(Op.Frame(2, 10.0, 20.5, 100.0, 40.0), ops[3])
+        assertEquals(Op.Destroy(2), ops[4])
+    }
+
+    @Test
+    fun infinityStringsBecomeInfinity() {
+        val ops = PNTransaction.decode("""[["f", 1, 0, 0, "inf", "-inf"]]""")
+        val frame = ops[0] as Op.Frame
+        assertEquals(Double.POSITIVE_INFINITY, frame.width, 0.0)
+        assertEquals(Double.NEGATIVE_INFINITY, frame.height, 0.0)
+        assertEquals(Double.POSITIVE_INFINITY, JsonUtil.toDouble("Infinity"), 0.0)
+    }
+
+    @Test
+    fun malformedOpsAreIsolated() {
+        val errors = ArrayList<Int>()
+        val ops = PNTransaction.decode(
+            """[["c", 1, "View", {}], ["zz", 1], "not-an-array", ["i"], ["d", 1]]""",
+        ) { index, _ -> errors.add(index) }
+        assertEquals(listOf(1, 2, 3), errors)
+        assertEquals(2, ops.size)
+        assertTrue(ops[0] is Op.Create)
+        assertEquals(Op.Destroy(1), ops[1])
+    }
+
+    @Test
+    fun mergeKeepsExplicitNulls() {
+        val target = JSONObject("""{"a": 1, "b": 2}""")
+        JsonUtil.merge(target, JSONObject("""{"b": null, "c": "x"}"""))
+        assertEquals(1, target.getInt("a"))
+        assertTrue(target.isNull("b"))
+        assertNull(target.value("b"))
+        assertEquals("x", target.getString("c"))
+    }
+
+    @Test
+    fun encodesResultsAsJson() {
+        assertNull(JsonUtil.encode(null))
+        assertEquals("\"hi\"", JsonUtil.encode("hi"))
+        assertEquals("true", JsonUtil.encode(true))
+        assertEquals("""{"x":1.5}""", JsonUtil.encode(mapOf("x" to 1.5)))
+        assertEquals("[1,2]", JsonUtil.encode(listOf(1, 2)))
+    }
+}

pythonnative/native/android/src/test/java/com/pythonnative/runtime/PromiseTest.kt

@@ -0,0 +1,89 @@
+package com.pythonnative.runtime
+
+import com.pythonnative.runtime.modules.ModuleEnvelope
+import com.pythonnative.runtime.modules.Promise
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class PromiseTest {
+    @Test
+    fun cancellationReleasesWorkAndIgnoresLateCompletion() {
+        val posted = ArrayList<Runnable>()
+        val promise = Promise(42, "Test") { posted.add(it) }
+        promise.markReturned()
+        var cancelled = 0
+        promise.onCancel { cancelled++ }
+        promise.cancel()
+        promise.cancel()
+        promise.resolve("late")
+        assertTrue(promise.isCancelled)
+        assertEquals(1, cancelled)
+        assertTrue(posted.isEmpty())
+    }
+    @Test
+    fun decodesCallEnvelope() {
+        val (callId, args) = ModuleEnvelope.decodeCall("""{"call_id": 7, "args": {"url": "x"}}""")
+        assertEquals(7L, callId)
+        assertEquals("x", args.getString("url"))
+        val (emptyId, emptyArgs) = ModuleEnvelope.decodeCall("")
+        assertEquals(0L, emptyId)
+        assertEquals(0, emptyArgs.length())
+    }
+
+    @Test
+    fun encodesResultEnvelopes() {
+        assertEquals("""{"ok":true,"value":3}""", ModuleEnvelope.ok(3))
+        val err = JSONObject(ModuleEnvelope.error("boom", "code_x"))
+        assertFalse(err.getBoolean("ok"))
+        assertEquals("boom", err.getString("error"))
+        assertEquals("code_x", err.getString("code"))
+        assertEquals("""{"pending":true}""", ModuleEnvelope.pending())
+        val event = JSONObject(ModuleEnvelope.event("change", mapOf("state" to "active")))
+        assertEquals("change", event.getString("event"))
+        assertEquals("active", event.getJSONObject("payload").getString("state"))
+    }
+
+    @Test
+    fun synchronousSettlementIsReturnedInline() {
+        val posted = ArrayList<Runnable>()
+        val promise = Promise(1, "Test") { posted.add(it) }
+        promise.resolve(mapOf("a" to 1))
+        assertTrue(promise.isSettled)
+        assertEquals("""{"ok":true,"value":{"a":1}}""", promise.markReturned())
+        assertTrue(posted.isEmpty())
+    }
+
+    @Test
+    fun asynchronousSettlementIsPosted() {
+        val posted = ArrayList<Runnable>()
+        val promise = Promise(9, "Test") { posted.add(it) }
+        assertEquals("""{"pending":true}""", promise.markReturned())
+        promise.resolve("later")
+        assertEquals(1, posted.size)
+        // Second settlement is ignored.
+        promise.reject("nope")
+        assertEquals(1, posted.size)
+    }
+
+    @Test
+    fun rejectionEnvelopeCarriesCode() {
+        val promise = Promise(2, "Test") { }
+        promise.reject("bad", "bad_request")
+        val obj = JSONObject(promise.markReturned())
+        assertFalse(obj.getBoolean("ok"))
+        assertEquals("bad_request", obj.getString("code"))
+    }
+
+    @Test
+    fun settledEnvelopesCarryCallId() {
+        val ok = JSONObject(ModuleEnvelope.settled(5, true))
+        assertEquals(5L, ok.getLong("call_id"))
+        assertTrue(ok.getBoolean("ok"))
+        val err = JSONObject(ModuleEnvelope.settledError(6, "x", null))
+        assertEquals(6L, err.getLong("call_id"))
+        assertFalse(err.has("code"))
+    }
+}

pythonnative/native/ios/Package.swift

@@ -0,0 +1,23 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "PythonNativeKit",
+    platforms: [.iOS(.v13)],
+    products: [
+        .library(name: "PythonNativeKit", targets: ["PythonNativeKit"]),
+    ],
+    dependencies: [.package(path: "../yoga")],
+    targets: [
+        .target(
+            name: "PythonNativeKit",
+            dependencies: [.product(name: "YogaCore", package: "yoga")],
+            path: "Sources/PythonNativeKit"
+        ),
+        .testTarget(
+            name: "PythonNativeKitTests",
+            dependencies: ["PythonNativeKit"],
+            path: "Tests/PythonNativeKitTests"
+        ),
+    ]
+)

pythonnative/native/ios/Sources/PythonNativeKit/Animation/PNAnimationGraph.swift

@@ -0,0 +1,199 @@
+import UIKit
+
+/// UI-thread expression evaluation, input bindings, and graph animation drivers.
+enum PNAnimationGraph {
+    struct Graph { var nodes: [[String: Any]]; var bindings: [[Any]] }
+    static var graphs: [Int64: Graph] = [:]
+    static var values: [Int64: Double] = [:]
+    static var previous: [Int64: Double] = [:]
+    static var outputs: [Int64: Any] = [:]
+    static var drivers: [Int64: PNGraphDriver] = [:]
+
+    static func number(_ value: Any?) -> Double { (value as? NSNumber)?.doubleValue ?? 0 }
+    static func identity(_ value: Any?) -> Int64 { (value as? NSNumber)?.int64Value ?? 0 }
+    static func install(_ spec: [String: Any]) {
+        let id = identity(spec["id"])
+        let bindings = spec["bindings"] as? [[Any]] ?? []
+        let nodes = spec["nodes"] as? [[String: Any]] ?? []
+        let ids = Set(nodes.map { identity($0["id"]) })
+        for (key, graph) in graphs where graph.nodes.contains(where: { ids.contains(identity($0["id"])) }) { graphs.removeValue(forKey: key) }
+        if !bindings.isEmpty {
+            for node in nodes {
+                let key = identity(node["id"])
+                if values[key] == nil { values[key] = number(node["value"]) }
+                if previous[key] == nil { previous[key] = number(node["previous"]) }
+            }
+            graphs[id] = Graph(nodes: nodes, bindings: bindings)
+        }
+        collect()
+        evaluate()
+    }
+    static func set(_ id: Int64, _ value: Double) {
+        guard value.isFinite else { return }
+        values[id] = value
+        evaluate()
+    }
+    static func event(_ tag: Int64, _ name: String, _ args: [Any?]) {
+        guard let view = PNViewRegistry.shared.view(for: tag), let props = PNViewState.existing(for: view)?.props,
+              let payload = args.first as? [String: Any] else { return }
+        var fields: [String: Any]?
+        if name.hasPrefix("gesture:"), let index = Int(name.dropFirst(8)),
+           let gestures = props["gestures"] as? [[String: Any]], gestures.indices.contains(index),
+           let events = gestures[index]["animated_events"] as? [String: [String: Any]] {
+            fields = events[payload["state"] as? String ?? ""]
+        } else { fields = (props["_pn_animated_events"] as? [String: [String: Any]])?[name] }
+        guard let fields = fields else { return }
+        for (field, node) in fields { if let value = payload[field] as? NSNumber { values[identity(node)] = value.doubleValue } }
+        evaluate()
+    }
+    static func forget(_ tag: Int64) {
+        for (id, var graph) in graphs {
+            graph.bindings.removeAll { identity($0[0]) == tag }
+            if graph.bindings.isEmpty { graphs.removeValue(forKey: id) } else { graphs[id] = graph }
+        }
+        collect()
+    }
+    static func collect() {
+        let live = Set(graphs.values.flatMap { $0.nodes.map { identity($0["id"]) } })
+        values = values.filter { live.contains($0.key) }
+        previous = previous.filter { live.contains($0.key) }
+        outputs = outputs.filter { live.contains($0.key) }
+        for (id, driver) in drivers where !live.contains(driver.node) {
+            driver.stop()
+            drivers.removeValue(forKey: id)
+            PNAnimator.reportCompletion(id: id, finished: false)
+        }
+    }
+    static func input(_ value: [String: Any]) -> Double {
+        value["node"] == nil ? number(value["constant"]) : values[identity(value["node"])] ?? 0
+    }
+    static func evaluate() {
+        for graph in graphs.values {
+            for node in graph.nodes {
+                let id = identity(node["id"])
+                let inputs = (node["inputs"] as? [[String: Any]] ?? []).map(input)
+                let a = inputs.first ?? 0, b = inputs.count > 1 ? inputs[1] : 0
+                var value: Double = 0
+                switch node["kind"] as? String {
+                case "value": value = values[id] ?? 0
+                case "add": value = a + b
+                case "subtract": value = a - b
+                case "multiply": value = a * b
+                case "divide": value = b == 0 ? 0 : a / b
+                case "modulo": value = b == 0 ? 0 : a.truncatingRemainder(dividingBy: b)
+                case "negate": value = -a
+                case "diff_clamp":
+                    value = min(number(node["maximum"]), max(number(node["minimum"]), (values[id] ?? 0) + a - (previous[id] ?? a)))
+                    previous[id] = a
+                case "interpolate": value = interpolate(node, a, id)
+                default: break
+                }
+                values[id] = value.isFinite ? value : 0
+                if node["color"] as? Bool != true { outputs[id] = values[id] }
+            }
+            for binding in graph.bindings {
+                guard binding.count == 3, let record = PNViewRegistry.shared.resolve(identity(binding[0])), let prop = binding[1] as? String else { continue }
+                record.manager.setAnimatedProperty(view: record.view, prop: prop, value: outputs[identity(binding[2])])
+            }
+        }
+    }
+    private static func interpolate(_ node: [String: Any], _ incoming: Double, _ id: Int64) -> Double {
+        guard let ranges = node["ranges"] as? [Double], ranges.count >= 2,
+              let outputs = node["outputs"] as? [Any], outputs.count == ranges.count else { return 0 }
+        var x = incoming
+        let mode = x < ranges[0] ? node["left"] as? String : x > ranges.last! ? node["right"] as? String : "extend"
+        if mode == "identity" { return x }
+        if mode == "clamp" { x = min(ranges.last!, max(ranges[0], x)) }
+        var index = 0
+        while index < ranges.count - 2 && x >= ranges[index + 1] { index += 1 }
+        let span = ranges[index + 1] - ranges[index]
+        let t = span == 0 ? 0 : (x - ranges[index]) / span
+        if node["color"] as? Bool == true, let from = outputs[index] as? [Double], let to = outputs[index + 1] as? [Double] {
+            self.outputs[id] = "#" + zip(from, to).map { String(format: "%02X", Int(min(255, max(0, ($0 + ($1 - $0) * min(1, max(0, t))).rounded())))) }.joined()
+            return 0
+        }
+        return number(outputs[index]) + (number(outputs[index + 1]) - number(outputs[index])) * t
+    }
+    static func start(_ id: Int64, node: Int64, spec: [String: Any]) -> Bool {
+        guard values[node] != nil, ["timing", "spring", "decay"].contains(spec["kind"] as? String ?? "") else { return false }
+        drivers.removeValue(forKey: id)?.stop()
+        let driver = PNGraphDriver(id: id, node: node, spec: spec)
+        drivers[id] = driver
+        driver.start()
+        return true
+    }
+    static func cancel(_ id: Int64) -> Double? {
+        guard let driver = drivers.removeValue(forKey: id) else { return nil }
+        driver.stop()
+        return values[driver.node]
+    }
+}
+
+final class PNGraphDriver: NSObject {
+    let id: Int64, node: Int64
+    let spec: [String: Any]
+    var link: CADisplayLink?
+    var elapsed = 0.0, previousTime = 0.0
+    var current: Double, velocity: Double
+    init(id: Int64, node: Int64, spec: [String: Any]) {
+        self.id = id; self.node = node; self.spec = spec
+        current = PNAnimationGraph.number(spec["from"])
+        velocity = PNAnimationGraph.number(spec["velocity"] ?? spec["initial_velocity"])
+    }
+    func start() {
+        let display = CADisplayLink(target: self, selector: #selector(tick(_:)))
+        link = display
+        display.add(to: .main, forMode: .common)
+    }
+    func stop() { link?.invalidate(); link = nil }
+    @objc func tick(_ display: CADisplayLink) {
+        let dt = previousTime == 0 ? display.duration : min(0.064, display.timestamp - previousTime)
+        previousTime = display.timestamp
+        elapsed += dt
+        let delay = PNAnimationGraph.number(spec["delay_ms"]) / 1000
+        guard elapsed >= delay else { return }
+        let target = PNAnimationGraph.number(spec["to"])
+        var done = false
+        switch spec["kind"] as? String {
+        case "spring":
+            let mass = max(0.001, (spec["mass"] as? Double) ?? 1)
+            let stiffness = (spec["stiffness"] as? Double) ?? 100
+            let damping = (spec["damping"] as? Double) ?? 10
+            let steps = max(1, Int(ceil(dt / 0.004)))
+            for _ in 0..<steps {
+                let step = dt / Double(steps)
+                velocity += (-stiffness * (current - target) - damping * velocity) / mass * step
+                current += velocity * step
+            }
+            done = abs(velocity) < ((spec["rest_speed_threshold"] as? Double) ?? 0.01) && abs(current - target) < ((spec["rest_displacement_threshold"] as? Double) ?? 0.01)
+            if done { current = target }
+        case "decay":
+            velocity *= pow(min(0.999999, max(0.001, (spec["deceleration"] as? Double) ?? 0.997)), dt * 1000)
+            current += velocity * dt
+            done = abs(velocity) < ((spec["rest_threshold"] as? Double) ?? 0.1)
+        default:
+            let duration = max(0.001, ((spec["duration_ms"] as? Double) ?? 300) / 1000)
+            let t = min(1, max(0, (elapsed - delay) / duration))
+            let curve = PNAnimator.curve(for: spec["easing"]) as? UICubicTimingParameters
+            let eased = curve.map { Self.bezier(t, $0.controlPoint1, $0.controlPoint2) } ?? t
+            let from = PNAnimationGraph.number(spec["from"])
+            current = from + (target - from) * eased
+            done = t >= 1
+        }
+        if UIAccessibility.isReduceMotionEnabled { current = target; done = true }
+        PNAnimationGraph.set(node, current)
+        if done {
+            stop(); PNAnimationGraph.drivers.removeValue(forKey: id)
+            PNAnimator.reportCompletion(id: id, finished: true)
+        }
+    }
+    static func bezier(_ t: Double, _ p1: CGPoint, _ p2: CGPoint) -> Double {
+        func coordinate(_ u: Double, _ a: Double, _ b: Double) -> Double { 3 * (1-u) * (1-u) * u * a + 3 * (1-u) * u * u * b + u * u * u }
+        var low = 0.0, high = 1.0
+        for _ in 0..<18 {
+            let mid = (low + high) / 2
+            if coordinate(mid, p1.x, p2.x) < t { low = mid } else { high = mid }
+        }
+        return coordinate((low + high) / 2, p1.y, p2.y)
+    }
+}