@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/Runtime/JSONParser.swift

@@ -0,0 +1,443 @@
+/// RFC 8259 parser for `_JSON`. Like the serializer in JSON.swift it uses no
+/// Foundation (see Geometry.swift): it walks the UTF-8 bytes of the input with
+/// an index and builds numbers by hand.
+///
+/// Rejected on purpose: trailing garbage, trailing commas, leading zeros
+/// (`01`), control characters inside strings, unknown escapes, lone UTF-16
+/// surrogates, unterminated input, and nesting deeper than 512 levels (a
+/// recursive parser would otherwise overflow the stack on hostile input).
+
+/// Error thrown by `_JSON.parse`. `offset` is the UTF-8 byte offset into the
+/// input at which the problem was detected.
+public struct _JSONParseError: Error, CustomStringConvertible, Sendable {
+    public let message: String
+    public let offset: Int
+
+    public init(message: String, offset: Int) {
+        self.message = message
+        self.offset = offset
+    }
+
+    public var description: String { "\(message) at byte offset \(offset)" }
+}
+
+extension _JSON {
+    /// Parses one JSON text. Any number of whitespace characters may surround
+    /// the value; anything else before or after it is an error.
+    public static func parse(_ text: String) throws(_JSONParseError) -> _JSON {
+        var parser = _JSONParser(bytes: Array(text.utf8))
+        parser.skipWhitespace()
+        let value = try parser.parseValue()
+        parser.skipWhitespace()
+        if parser.index < parser.bytes.count {
+            throw parser.error("unexpected characters after the JSON value")
+        }
+        return value
+    }
+}
+
+private struct _JSONParser {
+    /// Nesting limit for arrays and objects.
+    static let maxDepth = 512
+
+    let bytes: [UInt8]
+    var index = 0
+    private var depth = 0
+
+    init(bytes: [UInt8]) {
+        self.bytes = bytes
+    }
+
+    // MARK: Helpers
+
+    private var peek: UInt8? { index < bytes.count ? bytes[index] : nil }
+
+    func error(_ message: String) -> _JSONParseError {
+        error(message, at: index)
+    }
+
+    func error(_ message: String, at offset: Int) -> _JSONParseError {
+        _JSONParseError(message: message, offset: offset)
+    }
+
+    private func endOfInput() -> _JSONParseError {
+        error("unexpected end of input", at: bytes.count)
+    }
+
+    mutating func skipWhitespace() {
+        while index < bytes.count {
+            switch bytes[index] {
+            case 0x20, 0x09, 0x0A, 0x0D: index += 1  // space, tab, LF, CR
+            default: return
+            }
+        }
+    }
+
+    private static func isDigit(_ byte: UInt8) -> Bool {
+        byte >= 0x30 && byte <= 0x39  // '0'...'9'
+    }
+
+    // MARK: Values
+
+    mutating func parseValue() throws(_JSONParseError) -> _JSON {
+        guard let byte = peek else { throw endOfInput() }
+        switch byte {
+        case 0x7B:  // {
+            return try parseObject()
+        case 0x5B:  // [
+            return try parseArray()
+        case 0x22:  // "
+            return .string(try parseString())
+        case 0x74:  // t
+            try expectLiteral("true")
+            return .bool(true)
+        case 0x66:  // f
+            try expectLiteral("false")
+            return .bool(false)
+        case 0x6E:  // n
+            try expectLiteral("null")
+            return .null
+        case 0x2D, 0x30...0x39:  // - or digit
+            return .number(try parseNumber())
+        default:
+            throw error("unexpected character")
+        }
+    }
+
+    private mutating func expectLiteral(_ literal: StaticString) throws(_JSONParseError) {
+        let start = index
+        var matched = true
+        literal.withUTF8Buffer { expected in
+            if index + expected.count > bytes.count {
+                matched = false
+                return
+            }
+            for (offset, byte) in expected.enumerated() where bytes[index + offset] != byte {
+                matched = false
+                return
+            }
+            index += expected.count
+        }
+        if !matched {
+            throw error("invalid literal; expected '\(literal)'", at: start)
+        }
+    }
+
+    // MARK: Containers
+
+    private mutating func enterContainer() throws(_JSONParseError) {
+        depth += 1
+        if depth > Self.maxDepth {
+            throw error("nesting deeper than \(Self.maxDepth) levels")
+        }
+    }
+
+    private mutating func parseArray() throws(_JSONParseError) -> _JSON {
+        try enterContainer()
+        defer { depth -= 1 }
+        index += 1  // [
+        var items: [_JSON] = []
+        skipWhitespace()
+        if peek == 0x5D {  // ]
+            index += 1
+            return .array(items)
+        }
+        while true {
+            skipWhitespace()
+            items.append(try parseValue())
+            skipWhitespace()
+            guard let byte = peek else { throw endOfInput() }
+            switch byte {
+            case 0x2C:  // ,
+                index += 1
+                skipWhitespace()
+                if peek == 0x5D { throw error("trailing comma in array") }
+            case 0x5D:  // ]
+                index += 1
+                return .array(items)
+            default:
+                throw error("expected ',' or ']' in array")
+            }
+        }
+    }
+
+    private mutating func parseObject() throws(_JSONParseError) -> _JSON {
+        try enterContainer()
+        defer { depth -= 1 }
+        index += 1  // {
+        var members: [String: _JSON] = [:]
+        skipWhitespace()
+        if peek == 0x7D {  // }
+            index += 1
+            return .object(members)
+        }
+        while true {
+            skipWhitespace()
+            guard let byte = peek else { throw endOfInput() }
+            guard byte == 0x22 else {
+                throw error(peek == 0x7D ? "trailing comma in object" : "expected string key in object")
+            }
+            let key = try parseString()
+            skipWhitespace()
+            guard let separator = peek else { throw endOfInput() }
+            guard separator == 0x3A else { throw error("expected ':' after object key") }  // :
+            index += 1
+            skipWhitespace()
+            members[key] = try parseValue()
+            skipWhitespace()
+            guard let next = peek else { throw endOfInput() }
+            switch next {
+            case 0x2C:  // ,
+                index += 1
+            case 0x7D:  // }
+                index += 1
+                return .object(members)
+            default:
+                throw error("expected ',' or '}' in object")
+            }
+        }
+    }
+
+    // MARK: Strings
+
+    /// Parses a string starting at the opening quote and returns its contents.
+    private mutating func parseString() throws(_JSONParseError) -> String {
+        let start = index
+        index += 1  // opening quote
+        var buffer: [UInt8] = []
+        while true {
+            // Copy a run of ordinary bytes in one go.
+            let runStart = index
+            while index < bytes.count {
+                let byte = bytes[index]
+                if byte == 0x22 || byte == 0x5C || byte < 0x20 { break }
+                index += 1
+            }
+            guard index < bytes.count else {
+                throw error("unterminated string", at: start)
+            }
+            let byte = bytes[index]
+            if byte == 0x22 {  // closing quote
+                index += 1
+                if buffer.isEmpty {
+                    return String(decoding: bytes[runStart..<(index - 1)], as: UTF8.self)
+                }
+                buffer.append(contentsOf: bytes[runStart..<(index - 1)])
+                return String(decoding: buffer, as: UTF8.self)
+            }
+            buffer.append(contentsOf: bytes[runStart..<index])
+            if byte == 0x5C {  // backslash
+                try parseEscape(into: &buffer)
+            } else {
+                throw error("control character in string must be escaped")
+            }
+        }
+    }
+
+    /// Parses one escape sequence starting at the backslash.
+    private mutating func parseEscape(into buffer: inout [UInt8]) throws(_JSONParseError) {
+        let start = index
+        index += 1  // backslash
+        guard let byte = peek else { throw endOfInput() }
+        index += 1
+        switch byte {
+        case 0x22: buffer.append(0x22)  // \"
+        case 0x5C: buffer.append(0x5C)  // \\
+        case 0x2F: buffer.append(0x2F)  // \/
+        case 0x62: buffer.append(0x08)  // \b
+        case 0x66: buffer.append(0x0C)  // \f
+        case 0x6E: buffer.append(0x0A)  // \n
+        case 0x72: buffer.append(0x0D)  // \r
+        case 0x74: buffer.append(0x09)  // \t
+        case 0x75:  // \u
+            var scalar = try parseHex4()
+            if scalar >= 0xD800 && scalar <= 0xDBFF {
+                // High surrogate: a low surrogate escape must follow.
+                guard index + 1 < bytes.count, bytes[index] == 0x5C, bytes[index + 1] == 0x75 else {
+                    throw error("high surrogate without a following low surrogate", at: start)
+                }
+                index += 2
+                let low = try parseHex4()
+                guard low >= 0xDC00 && low <= 0xDFFF else {
+                    throw error("invalid low surrogate in escape", at: start)
+                }
+                scalar = 0x10000 + ((scalar - 0xD800) << 10) + (low - 0xDC00)
+            } else if scalar >= 0xDC00 && scalar <= 0xDFFF {
+                throw error("lone low surrogate in escape", at: start)
+            }
+            Self.appendUTF8(scalar, to: &buffer)
+        default:
+            throw error("invalid escape sequence", at: start)
+        }
+    }
+
+    /// Reads exactly four hex digits.
+    private mutating func parseHex4() throws(_JSONParseError) -> UInt32 {
+        guard index + 4 <= bytes.count else { throw endOfInput() }
+        var value: UInt32 = 0
+        for _ in 0..<4 {
+            let byte = bytes[index]
+            let digit: UInt32
+            switch byte {
+            case 0x30...0x39: digit = UInt32(byte - 0x30)
+            case 0x41...0x46: digit = UInt32(byte - 0x41 + 10)
+            case 0x61...0x66: digit = UInt32(byte - 0x61 + 10)
+            default: throw error("invalid hex digit in \\u escape")
+            }
+            value = value << 4 | digit
+            index += 1
+        }
+        return value
+    }
+
+    private static func appendUTF8(_ scalar: UInt32, to buffer: inout [UInt8]) {
+        if scalar < 0x80 {
+            buffer.append(UInt8(scalar))
+        } else if scalar < 0x800 {
+            buffer.append(0xC0 | UInt8(scalar >> 6))
+            buffer.append(0x80 | UInt8(scalar & 0x3F))
+        } else if scalar < 0x10000 {
+            buffer.append(0xE0 | UInt8(scalar >> 12))
+            buffer.append(0x80 | UInt8((scalar >> 6) & 0x3F))
+            buffer.append(0x80 | UInt8(scalar & 0x3F))
+        } else {
+            buffer.append(0xF0 | UInt8(scalar >> 18))
+            buffer.append(0x80 | UInt8((scalar >> 12) & 0x3F))
+            buffer.append(0x80 | UInt8((scalar >> 6) & 0x3F))
+            buffer.append(0x80 | UInt8(scalar & 0x3F))
+        }
+    }
+
+    // MARK: Numbers
+
+    /// Powers of ten as correctly rounded literals. Entries 1e0...1e22 are
+    /// exactly representable, so for every realistic number (at most 15-16
+    /// significant digits, a modest exponent) the single multiplication or
+    /// division below yields the correctly rounded Double. Beyond that the
+    /// result is within an ulp, which is accurate enough for this use.
+    private static let powersOfTen: [Double] = [
+        1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10,
+        1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21,
+        1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30, 1e31, 1e32,
+        1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39, 1e40, 1e41, 1e42, 1e43,
+        1e44, 1e45, 1e46, 1e47, 1e48, 1e49, 1e50, 1e51, 1e52, 1e53, 1e54,
+        1e55, 1e56, 1e57, 1e58, 1e59, 1e60, 1e61, 1e62, 1e63, 1e64, 1e65,
+        1e66, 1e67, 1e68, 1e69, 1e70, 1e71, 1e72, 1e73, 1e74, 1e75, 1e76,
+        1e77, 1e78, 1e79, 1e80, 1e81, 1e82, 1e83, 1e84, 1e85, 1e86, 1e87,
+        1e88, 1e89, 1e90, 1e91, 1e92, 1e93, 1e94, 1e95, 1e96, 1e97, 1e98,
+        1e99, 1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109,
+        1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119, 1e120,
+        1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129, 1e130, 1e131,
+        1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139, 1e140, 1e141, 1e142,
+        1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149, 1e150, 1e151, 1e152, 1e153,
+        1e154, 1e155, 1e156, 1e157, 1e158, 1e159, 1e160, 1e161, 1e162, 1e163, 1e164,
+        1e165, 1e166, 1e167, 1e168, 1e169, 1e170, 1e171, 1e172, 1e173, 1e174, 1e175,
+        1e176, 1e177, 1e178, 1e179, 1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186,
+        1e187, 1e188, 1e189, 1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197,
+        1e198, 1e199, 1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208,
+        1e209, 1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219,
+        1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229, 1e230,
+        1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239, 1e240, 1e241,
+        1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249, 1e250, 1e251, 1e252,
+        1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259, 1e260, 1e261, 1e262, 1e263,
+        1e264, 1e265, 1e266, 1e267, 1e268, 1e269, 1e270, 1e271, 1e272, 1e273, 1e274,
+        1e275, 1e276, 1e277, 1e278, 1e279, 1e280, 1e281, 1e282, 1e283, 1e284, 1e285,
+        1e286, 1e287, 1e288, 1e289, 1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296,
+        1e297, 1e298, 1e299, 1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307,
+        1e308,
+    ]
+
+    /// Parses `-?int frac? exp?` into a Double. Up to 19 significant digits
+    /// are accumulated exactly in a UInt64; further digits only shift the
+    /// decimal exponent. The exponent is then applied with a single
+    /// multiplication or division by a power of ten from the table above.
+    private mutating func parseNumber() throws(_JSONParseError) -> Double {
+        let start = index
+        var negative = false
+        if peek == 0x2D {  // -
+            negative = true
+            index += 1
+        }
+        guard let first = peek else { throw endOfInput() }
+        guard Self.isDigit(first) else { throw error("expected a digit") }
+
+        var mantissa: UInt64 = 0
+        var exponent = 0  // decimal exponent to apply to the mantissa
+        let mantissaLimit: UInt64 = 1_000_000_000_000_000_000  // 1e18; below it, *10+9 fits
+
+        // Integer part.
+        if first == 0x30 {
+            index += 1
+            if let next = peek, Self.isDigit(next) {
+                throw error("leading zeros are not allowed", at: start)
+            }
+        } else {
+            while let byte = peek, Self.isDigit(byte) {
+                if mantissa < mantissaLimit {
+                    mantissa = mantissa * 10 + UInt64(byte - 0x30)
+                } else {
+                    exponent += 1
+                }
+                index += 1
+            }
+        }
+
+        // Fraction.
+        if peek == 0x2E {  // .
+            index += 1
+            guard let byte = peek, Self.isDigit(byte) else {
+                throw error("expected a digit after the decimal point")
+            }
+            while let byte = peek, Self.isDigit(byte) {
+                if mantissa < mantissaLimit {
+                    mantissa = mantissa * 10 + UInt64(byte - 0x30)
+                    exponent -= 1
+                }
+                index += 1
+            }
+        }
+
+        // Exponent.
+        if let byte = peek, byte == 0x65 || byte == 0x45 {  // e or E
+            index += 1
+            var exponentNegative = false
+            if peek == 0x2B {  // +
+                index += 1
+            } else if peek == 0x2D {  // -
+                exponentNegative = true
+                index += 1
+            }
+            guard let digit = peek, Self.isDigit(digit) else {
+                throw error("expected a digit in the exponent")
+            }
+            var explicitExponent = 0
+            while let byte = peek, Self.isDigit(byte) {
+                // Clamp so absurd exponents cannot overflow Int; the value
+                // saturates to infinity or zero below anyway.
+                if explicitExponent < 100_000 {
+                    explicitExponent = explicitExponent * 10 + Int(byte - 0x30)
+                }
+                index += 1
+            }
+            exponent += exponentNegative ? -explicitExponent : explicitExponent
+        }
+
+        var value = Double(mantissa)
+        if mantissa != 0 {
+            if exponent > 308 {
+                // Even a mantissa of 1 exceeds Double.greatestFiniteMagnitude.
+                value = .infinity
+            } else if exponent > 0 {
+                value *= Self.powersOfTen[exponent]  // may overflow to +infinity
+            } else if exponent < -308 {
+                // Step down in two divisions; the mantissa has at most 19
+                // digits, so anything below 1e-330 underflows to zero.
+                let remaining = -exponent - 308
+                value = remaining > 22 ? 0 : value / Self.powersOfTen[308] / Self.powersOfTen[remaining]
+            } else if exponent < 0 {
+                value /= Self.powersOfTen[-exponent]
+            }
+        }
+        return negative ? -value : value
+    }
+}

package/Sources/SwiftUI/Runtime/Ops.swift

@@ -0,0 +1,106 @@
+/// One instruction for a renderer. See docs/ops-protocol.md.
+public enum _Op: Equatable, Sendable {
+    case create(id: Int, kind: String, props: _JSON)
+    case update(id: Int, props: _JSON)
+    case insert(parent: Int, id: Int, index: Int)
+    case remove(id: Int)
+    /// End of a render pass, optionally animated (`withAnimation`).
+    case commit(animation: _JSON? = nil)
+    /// Headless mode only: echoes a replayed event (an object with at least
+    /// `type`) before its ops.
+    case event(_JSON)
+    /// The app's `UserDefaults`, whole, after a change; the host stores them
+    /// and hands them back at the next launch (`SB_DEFAULTS`).
+    case defaults(_JSON)
+
+    public var json: _JSON {
+        switch self {
+        case .create(let id, let kind, let props):
+            return .object(["op": .string("create"), "id": .number(Double(id)), "kind": .string(kind), "props": props])
+        case .update(let id, let props):
+            return .object(["op": .string("update"), "id": .number(Double(id)), "props": props])
+        case .insert(let parent, let id, let index):
+            return .object(["op": .string("insert"), "parent": .number(Double(parent)),
+                     "id": .number(Double(id)), "index": .number(Double(index))])
+        case .remove(let id):
+            return .object(["op": .string("remove"), "id": .number(Double(id))])
+        case .commit(let animation):
+            if let animation { return .object(["op": .string("commit"), "animation": animation]) }
+            return .object(["op": .string("commit")])
+        case .event(let event):
+            if case .object(var fields) = event {
+                fields["op"] = .string("event")
+                return .object(fields)
+            }
+            return .object(["op": .string("event")])
+        case .defaults(let values):
+            return .object(["op": .string("defaults"), "values": values])
+        }
+    }
+}
+
+/// Where ops go. The browser build buffers them for JavaScript; headless mode
+/// prints them; tests record them.
+@MainActor
+public protocol _RenderHost: AnyObject {
+    func apply(_ ops: [_Op])
+}
+
+/// Prints one op per line (JSON Lines).
+@MainActor
+final class _HeadlessHost: _RenderHost {
+    func apply(_ ops: [_Op]) {
+        for op in ops { print(op.json.serialized) }
+    }
+}
+
+/// Keeps pending ops serialized as a JSON array in a stable heap buffer that
+/// the browser reads out of linear memory via the `sb_ops_*` exports.
+@MainActor
+final class _BufferedHost: _RenderHost {
+    static let shared = _BufferedHost()
+
+    private(set) var pending: [_Op] = []
+    private var buffer: UnsafeMutableBufferPointer<UInt8> = .allocate(capacity: 2)
+
+    init() {
+        reserialize()
+    }
+
+    func apply(_ ops: [_Op]) {
+        pending.append(contentsOf: ops)
+        reserialize()
+    }
+
+    func clear() {
+        pending.removeAll()
+        reserialize()
+    }
+
+    var pointer: Int32 { Int32(Int(bitPattern: buffer.baseAddress)) }
+    var length: Int32 { Int32(buffer.count) }
+
+    private func reserialize() {
+        let bytes = Array(_JSON.array(pending.map(\.json)).serialized.utf8)
+        buffer.deallocate()
+        buffer = .allocate(capacity: bytes.count)
+        _ = buffer.initialize(from: bytes)
+    }
+}
+
+/// Holds the serialized state snapshot for the `sb_state_*` exports.
+@MainActor
+final class _StateBuffer {
+    static let shared = _StateBuffer()
+    private var buffer: UnsafeMutableBufferPointer<UInt8> = .allocate(capacity: 0)
+
+    func refresh(with json: _JSON) {
+        let bytes = Array(json.serialized.utf8)
+        buffer.deallocate()
+        buffer = .allocate(capacity: bytes.count)
+        _ = buffer.initialize(from: bytes)
+    }
+
+    var pointer: Int32 { Int32(Int(bitPattern: buffer.baseAddress)) }
+    var length: Int32 { Int32(buffer.count) }
+}