@voxgig/sdkgen 4.9.0 → 4.10.0

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/secrets/plugin/Resolve.swift

@@ -0,0 +1,59 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (swift/src/Resolve.swift)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/// Dynamic resolution (section 10.2) - name to candidate module ids.
+///
+/// PURE. It returns the ids a host WOULD try, in order; it does not load
+/// anything. That separation is what lets the corpus pin resolution in every
+/// language including those with no dynamic loading at all, and it is why
+/// section 15.4 puts real module loading in per-port integration tests rather
+/// than here.
+public enum Resolve {
+
+    public static let defaultSources: Value = .list([
+        .map([
+            "kind": .str("module"),
+            "prefix": .list([
+                .str("@voxgig/plugin-"), .str("voxgig-plugin-"),
+                .str("plugin-"), .str(""),
+            ]),
+        ]),
+    ])
+
+    public static func resolveCandidates(_ name: String, _ sources: Value = .null) -> [String] {
+        // A SCOPED NAME RESOLVES VERBATIM ONLY (section 10.2). `@acme/thing` is
+        // already a package id; prefixing it produces
+        // `@voxgig/plugin-@acme/thing`, which is not a thing that can exist.
+        if name.hasPrefix("@") { return [name] }
+
+        let list = sources.items.isEmpty ? defaultSources : sources
+        var out: [String] = []
+
+        for src in list.items {
+            switch src.at("kind").asString {
+            case "module":
+                var prefixes = src.at("prefix").items
+                if prefixes.isEmpty { prefixes = [.str("")] }
+                for p in prefixes {
+                    let id = (p.asString ?? "") + name
+                    if !out.contains(id) { out.append(id) }
+                }
+            case "path":
+                var dir = src.at("dir").asString ?? ""
+                while dir.hasSuffix("/") { dir = String(dir.dropLast()) }
+                let id = "\(dir)/\(name)"
+                if !out.contains(id) { out.append(id) }
+            default:
+                continue
+            }
+        }
+        return out
+    }
+
+    /// A MODULE PATH IS NOT A NAME (section 10.2). The ref grammar starts a
+    /// name with a letter or `@`, so `./local/thing` is not a ref and never
+    /// reaches candidate generation - seneca allows a path where a plugin name
+    /// goes, and this design deliberately does not, because a ref is an ADDRESS
+    /// WITHIN A HOST and a path is a LOCATION ON A DISK.
+    public static func resolveFrom(_ from: Value) -> [Value] { return [from] }
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/secrets/plugin/Types.swift

@@ -0,0 +1,125 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (swift/src/Types.swift)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/// The error type, the sort key, and the handful of helpers every module needs.
+///
+/// EVERY FUNCTION THAT CAN FAIL IS `throws`, and that is this port's defining
+/// cost. Rust returns a `Result` and the other ports raise; swift makes the
+/// possibility part of the signature, so `try` appears at every call in the
+/// chain from `Host.ready` down to `Refs.parseRef`. It is verbose and it is
+/// honest: a reader can see from a signature alone whether a call can produce
+/// a section 12 error.
+
+/// Every error carries a section 12 code. Ports compare by CODE and never by
+/// message: wording is a port's own business, and pinning the words would make
+/// every translation a corpus change. The FORMAT, however, is pinned - a
+/// parseable message is what makes a log searchable across twenty languages.
+public struct PluginError: Error {
+    public let code: String
+    public let text: String
+    public let details: [String: Value]
+    public let message: String
+
+    public init(_ code: String, _ text: String, _ details: [String: Value]) {
+        self.code = code
+        self.text = text
+        self.details = details
+        self.message = Types.formatError(code, text, details)
+    }
+}
+
+public enum Types {
+
+    /// Section 5.1's seven statuses, and no more.
+    public static let statuses = [
+        "declared", "loaded", "pending", "live", "failed", "loading", "closing"
+    ]
+
+    /// Section 12's detail keys, in the order a message renders them. FIXED,
+    /// not the map's: a message is a searchable log line, and a line whose
+    /// fields move between runs is not.
+    public static let detailOrder = [
+        "ref", "point", "name", "key", "spec", "refs", "kind", "directive",
+        "cycle", "holders", "cause"
+    ]
+
+    /// `plugin/<code>: <text> [<key>=<value> ...]`
+    ///
+    /// Values render as COMPACT JSON, so a value containing a space or a
+    /// bracket cannot break the parse, and a list renders as a JSON array. The
+    /// bracket is absent entirely when no field applies.
+    public static func formatError(
+        _ code: String, _ text: String, _ details: [String: Value]
+    ) -> String {
+        let parts = detailOrder.compactMap { k -> String? in
+            guard let v = details[k] else { return nil }
+            return "\(k)=\(v.json)"
+        }
+        let tail = parts.isEmpty ? "" : " [" + parts.joined(separator: " ") + "]"
+        return "plugin/\(code): \(text)\(tail)"
+    }
+
+    /// Throw a section 12 error. One spelling, so every raise site reads the
+    /// same.
+    public static func fail(
+        _ code: String, _ text: String, _ details: [String: Value] = [:]
+    ) -> PluginError {
+        return PluginError(code, text, details)
+    }
+
+    /// The section 12 code of an error, or "" for one this library did not
+    /// throw. The corpus compares by code, so the driver needs one place that
+    /// knows how to read it.
+    public static func codeOf(_ e: Error) -> String {
+        return (e as? PluginError)?.code ?? ""
+    }
+
+    public static func messageOf(_ e: Error) -> String {
+        return (e as? PluginError)?.message ?? "\(e)"
+    }
+
+    /// A STABLE sort by a comparable key.
+    ///
+    /// SWIFT'S `sort` IS NOT GUARANTEED STABLE. It is a timsort today and
+    /// stable in every size this port has measured, and the documentation
+    /// declines to promise it - which makes relying on it a bet on an
+    /// implementation detail. Section 7's comparators fall through to a `pos`
+    /// or ref tie-break that javascript's stable sort resolves BY POSITION, so
+    /// the guarantee has to come from here: decorate with the original index
+    /// and break the last tie on it.
+    public static func stableSortBy<T>(_ list: [T], _ keyOf: (T) -> [SortKey]) -> [T] {
+        return list.enumerated()
+            .map { (keyOf($0.element), $0.offset, $0.element) }
+            .sorted { a, b in
+                let c = SortKey.compare(a.0, b.0)
+                return c != 0 ? c < 0 : a.1 < b.1
+            }
+            .map { $0.2 }
+    }
+}
+
+/// A sort key element. A key is a list of numbers, strings and nested lists,
+/// which is what lets `Capability.rankKey` express "absent version sorts last"
+/// as a leading flag rather than as a comparator.
+public enum SortKey {
+    case num(Double)
+    case text(String)
+    case list([SortKey])
+
+    public static func compare(_ a: [SortKey], _ b: [SortKey]) -> Int {
+        for i in 0 ..< Swift.min(a.count, b.count) {
+            let c = compareOne(a[i], b[i])
+            if c != 0 { return c }
+        }
+        return a.count == b.count ? 0 : (a.count < b.count ? -1 : 1)
+    }
+
+    static func compareOne(_ a: SortKey, _ b: SortKey) -> Int {
+        switch (a, b) {
+        case (.num(let x), .num(let y)): return x == y ? 0 : (x < y ? -1 : 1)
+        case (.text(let x), .text(let y)): return x == y ? 0 : (x < y ? -1 : 1)
+        case (.list(let x), .list(let y)): return compare(x, y)
+        default: return 0
+        }
+    }
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/secrets/plugin/Value.swift

@@ -0,0 +1,198 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (swift/src/Value.swift)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/// The JSON value, and the only parser this port has.
+///
+/// NO FOUNDATION IN THE LIBRARY, AND NO SWIFTPM DEPENDENCIES (section 16).
+/// The library is allowed exactly one runtime dependency, `voxgig/struct`,
+/// which has no swift port; everything else is the standard library.
+/// `JSONSerialization` would have cost an `import Foundation` in every file
+/// that touches a value, and it hands back `[String: Any]` with `NSNull` -
+/// which is the untyped model swift exists to avoid.
+///
+/// A `Value` IS AN ENUM, not `Any`. Swift can express the JSON model exactly,
+/// and `[String: Any]` would throw away every guarantee the language is for:
+/// `dict["k"] = nil` REMOVES the key rather than storing a null, so an
+/// authored null and an absent key - the distinction `__NULL__` and
+/// `__UNDEF__` pin - could not be told apart at all.
+///
+/// `.num` is a `Double` because JSON HAS ONE NUMBER TYPE. The canonical is
+/// javascript, `1` and `1.0` are the same value there, and a port that split
+/// them would disagree with the corpus on which of two spellings a document
+/// used.
+public enum Value {
+    case null
+    case bool(Bool)
+    case num(Double)
+    case str(String)
+    case list([Value])
+    case map([String: Value])
+
+    /// A host object published through `exports` (section 11). The design lets
+    /// a plugin export "a client" - a thing the library never inspects - and
+    /// in a statically typed port that needs an escape hatch. It is never
+    /// produced by the parser and never compared as data.
+    case opaque(AnyObject)
+}
+
+// MARK: - reading
+
+public extension Value {
+
+    /// The value at a key, or nil. `nil` is ABSENT; `.null` is a present null,
+    /// and that is the whole reason this returns an optional rather than
+    /// `.null` for both.
+    func get(_ key: String) -> Value? {
+        if case .map(let m) = self { return m[key] }
+        return nil
+    }
+
+    /// PRESENCE, which is what distinguishes an authored null from absence.
+    func has(_ key: String) -> Bool { return get(key) != nil }
+
+    /// The value at a key with an absent key flattened to `.null` - for the
+    /// many sites that treat the two alike.
+    func at(_ key: String) -> Value { return get(key) ?? .null }
+
+    /// The keys of a map, SORTED - every walk of a map goes through here. A
+    /// swift `Dictionary` has NO ORDER AT ALL, not even insertion order, so
+    /// this is not tidiness: without it a teardown order changes between two
+    /// runs of the same process.
+    var keys: [String] {
+        if case .map(let m) = self { return m.keys.sorted() }
+        return []
+    }
+
+    var items: [Value] {
+        if case .list(let l) = self { return l }
+        return []
+    }
+
+    var isNull: Bool { if case .null = self { return true }; return false }
+
+    var isMap: Bool { if case .map = self { return true }; return false }
+
+    var isList: Bool { if case .list = self { return true }; return false }
+
+    var asString: String? { if case .str(let s) = self { return s }; return nil }
+
+    var asDouble: Double? { if case .num(let n) = self { return n }; return nil }
+
+    var asBool: Bool? { if case .bool(let b) = self { return b }; return nil }
+
+    var asMap: [String: Value] { if case .map(let m) = self { return m }; return [:] }
+
+    /// An INTEGER, and only when the value is one. Section 7's band is an
+    /// integer the document wrote as one, and every number here is a `Double`,
+    /// so the test is "a whole double" - `true` and `"2"` are neither and
+    /// reach neither branch.
+    var asInt: Int? {
+        guard case .num(let n) = self, n == n.rounded(.down), n.isFinite else { return nil }
+        return Int(n)
+    }
+
+    /// JSON truthiness: null and false, and nothing else, are false. Swift has
+    /// no truthiness of its own - `if 0` does not compile - so this is where
+    /// the model's rule is written down.
+    var truthy: Bool {
+        switch self {
+        case .null: return false
+        case .bool(let b): return b
+        default: return true
+        }
+    }
+}
+
+// MARK: - writing
+
+public extension Value {
+
+    /// COMPACT JSON, map keys in sorted order. A whole double renders WITHOUT
+    /// its fraction, so `1.0` and `1` spell the same - the corpus writes both
+    /// and a message quoting one must not depend on which.
+    var json: String {
+        switch self {
+        case .null: return "null"
+        case .bool(let b): return b ? "true" : "false"
+        case .num(let n):
+            return (n == n.rounded(.down) && n.isFinite) ? String(Int(n)) : String(n)
+        case .str(let s): return Value.quote(s)
+        case .list(let l): return "[" + l.map { $0.json }.joined(separator: ",") + "]"
+        case .map:
+            let body = keys.map { Value.quote($0) + ":" + at($0).json }
+            return "{" + body.joined(separator: ",") + "}"
+        case .opaque: return "\"(opaque)\""
+        }
+    }
+
+    static func quote(_ s: String) -> String {
+        var out = "\""
+        for c in s.unicodeScalars {
+            switch c {
+            case "\"": out += "\\\""
+            case "\\": out += "\\\\"
+            case "\n": out += "\\n"
+            case "\r": out += "\\r"
+            case "\t": out += "\\t"
+            default:
+                if c.value < 0x20 {
+                    out += "\\u" + Value.hex4(c.value)
+                } else {
+                    out.unicodeScalars.append(c)
+                }
+            }
+        }
+        return out + "\""
+    }
+
+    static func hex4(_ v: UInt32) -> String {
+        let digits = "0123456789abcdef".map { $0 }
+        var out = ""
+        for shift in [12, 8, 4, 0] {
+            out.append(digits[Int((v >> UInt32(shift)) & 0xF)])
+        }
+        return out
+    }
+}
+
+// MARK: - equality
+
+extension Value: Equatable {
+
+    /// JSON equality: same type, then same value. Written out rather than
+    /// synthesized, because `.opaque` holds an `AnyObject` that is not
+    /// `Equatable` and because the rule the corpus needs is a type-strict one -
+    /// `true` does not equal `1`, which a synthesized `==` would also give but
+    /// only by accident of the enum's shape.
+    public static func == (a: Value, b: Value) -> Bool {
+        switch (a, b) {
+        case (.null, .null): return true
+        case (.bool(let x), .bool(let y)): return x == y
+        case (.num(let x), .num(let y)): return x == y
+        case (.str(let x), .str(let y)): return x == y
+        case (.list(let x), .list(let y)):
+            return x.count == y.count && zip(x, y).allSatisfy { $0 == $1 }
+        case (.map(let x), .map(let y)):
+            return x.count == y.count && x.allSatisfy { k, v in y[k].map { v == $0 } ?? false }
+        case (.opaque(let x), .opaque(let y)): return x === y
+        default: return false
+        }
+    }
+}
+
+// MARK: - building
+
+public extension Value {
+
+    static func mapOf(_ pairs: [String: Value]) -> Value { return .map(pairs) }
+
+    static func listOf(_ items: [Value]) -> Value { return .list(items) }
+
+    /// Set a key, returning the new value. A `Value` is a VALUE - the enum is
+    /// copied - so every mutation is explicit and nothing aliases.
+    func setting(_ key: String, _ value: Value) -> Value {
+        var m = asMap
+        m[key] = value
+        return .map(m)
+    }
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/secrets/plugin/Version.swift

@@ -0,0 +1,139 @@
+// VENDORED: @voxgig/plugin sdk-20260908-1556-0 (swift/src/Version.swift)
+// Source: https://github.com/voxgig/plugin @ 48392f5e2b6d1434ee9b1a4a9a11f4480aaeb46a  [tag: sdk-20260908-1556-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+/// Versions and ranges (section 11.2).
+///
+/// TWO FIELDS AND ONE PREDICATE. A capability declares `version`, a concrete
+/// version. A requirement declares `range`. A requirement is satisfied when the
+/// names match, the `match` passes, and the provider's `version` falls inside
+/// the requirement's `range`.
+///
+/// That is the whole rule. There is no third field and no second comparison -
+/// an earlier draft added a provider-side `compat` range, which left three
+/// values and no statement of how they combine, and three defensible readings
+/// of one declaration is worse than the ambiguity it was introduced to fix.
+public enum Version {
+
+    /// A COMPONENT IS BOUNDED, and the bound is the model's, not the host
+    /// language's. A swift `Int` is 64-bit and javascript stops being exact
+    /// past 2**53, so `9223372036854775808.0.0` parsed to an exact value here
+    /// and a rounded one there. 2**31-1 is the smallest bound every target
+    /// language holds exactly, which makes it the model's.
+    public static let componentMax: Double = 2147483647
+
+    /// The three dot-separated numeric parts, or nil - written as a scan for
+    /// the same reason `Refs` is: no regex, and nothing to get wrong about
+    /// anchoring.
+    static func scan(_ s: String) -> [String]? {
+        var parts: [String] = []
+        var current = ""
+        for c in s.unicodeScalars {
+            if Refs.isDigit(c) {
+                current.unicodeScalars.append(c)
+                continue
+            }
+            if c == "." {
+                if current.isEmpty { return nil }
+                parts.append(current)
+                current = ""
+                continue
+            }
+            return nil
+        }
+        if current.isEmpty { return nil }
+        parts.append(current)
+        return parts.count <= 3 ? parts : nil
+    }
+
+    /// A component parses as a `Double` so that `major + 1` at `componentMax`
+    /// is 2147483648 rather than an overflow, and so that every number in this
+    /// port is one type.
+    static func component(_ digits: String, _ whole: String, _ field: String) throws -> Double {
+        // Leading zeros and forty digits both have to survive this, so the
+        // parse is on the digit string rather than on an `Int`.
+        guard let value = Double(digits) else {
+            throw Types.fail(
+                "plugin_bad_range", "invalid \(field): \(whole)", [field: .str(whole)]
+            )
+        }
+        if componentMax < value {
+            throw Types.fail(
+                "plugin_bad_range",
+                "version component out of range in \(whole): \(digits)",
+                [field: .str(whole)]
+            )
+        }
+        return value
+    }
+
+    /// Two forms and no more (section 11.2):
+    ///
+    ///   '2.1'    >= 2.1.0 and < 3.0.0
+    ///   '~2.1'   >= 2.1.0 and < 2.2.0
+    public static func parseRange(_ range: Value) throws -> Value {
+        guard let s = range.asString, !s.isEmpty else {
+            throw Types.fail(
+                "plugin_bad_range", "invalid range: \(Refs.show(range))", ["range": range]
+            )
+        }
+        let tilde = s.hasPrefix("~")
+        let body = tilde ? String(s.dropFirst()) : s
+        guard let parts = scan(body) else {
+            throw Types.fail("plugin_bad_range", "invalid range: \(s)", ["range": range])
+        }
+        let major = try component(parts[0], s, "range")
+        let minor = parts.count > 1 ? try component(parts[1], s, "range") : 0
+        let patch = parts.count > 2 ? try component(parts[2], s, "range") : 0
+
+        return .map([
+            "lo": .list([.num(major), .num(minor), .num(patch)]),
+            "hi": tilde
+                ? .list([.num(major), .num(minor + 1), .num(0)])
+                : .list([.num(major + 1), .num(0), .num(0)]),
+        ])
+    }
+
+    public static func parseVersion(_ version: Value) throws -> [Double] {
+        guard let s = version.asString, let parts = scan(s) else {
+            throw Types.fail(
+                "plugin_bad_range", "invalid version: \(Refs.show(version))",
+                ["version": version]
+            )
+        }
+        return [
+            try component(parts[0], s, "version"),
+            parts.count > 1 ? try component(parts[1], s, "version") : 0,
+            parts.count > 2 ? try component(parts[2], s, "version") : 0,
+        ]
+    }
+
+    public static func versionCmp(_ a: [Double], _ b: [Double]) -> Int {
+        for i in 0 ..< 3 {
+            let x = i < a.count ? a[i] : 0
+            let y = i < b.count ? b[i] : 0
+            if x != y { return x < y ? -1 : 1 }
+        }
+        return 0
+    }
+
+    /// The one satisfaction predicate: lo <= version < hi.
+    public static func satisfies(_ version: Value, _ range: Value) throws -> Bool {
+        let v = try parseVersion(version)
+        let r = try parseRange(range)
+        let lo = r.at("lo").items.compactMap { $0.asDouble }
+        let hi = r.at("hi").items.compactMap { $0.asDouble }
+        return versionCmp(v, lo) >= 0 && versionCmp(v, hi) < 0
+    }
+
+    /// `satisfies` for the internal callers that treat an unparseable version
+    /// or range as "does not satisfy" - Capability and Graph, both of which run
+    /// over data the corpus has already admitted.
+    public static func satisfiesq(_ version: Value, _ range: Value) -> Bool {
+        return (try? satisfies(version, range)) ?? false
+    }
+
+    /// The numeric parts of a version, or zeros - a SORT KEY, never a check.
+    public static func versionParts(_ text: Value) -> [Double] {
+        return (try? parseVersion(text)) ?? [0, 0, 0]
+    }
+}