@voxgig/sdkgen 1.3.8 → 1.3.9

package/project/.sdk/tm/swift/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) $$const.year$$ Voxgig
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/project/.sdk/tm/swift/Makefile

@@ -0,0 +1,41 @@
+.PHONY: test build clean publish
+
+test:
+	swift test
+
+build:
+	swift build
+
+clean:
+	swift package clean 2>/dev/null || true
+	rm -rf .build
+
+# --- Release: tag for the SwiftPM registry ---------------------------------
+# SwiftPM has no upload step - publishing IS the git tag. Publication is
+# pending (see model/target/swift.aontu publish block); publishing a version
+# currently means pushing the tag swift/vX.Y.Z. Run headless under the aql key
+# vault, which injects the GitHub token so nothing lands on disk or argv:
+#   aql vault exec --for=github=<alias> -- make publish
+# aql `--dry-run` injects a filler token we detect to rehearse (no tag/push).
+# set -e + tag-last: a failed push never leaves a tag behind.
+VERSION := $(shell cat VERSION)
+TAG := swift/v$(VERSION)
+AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+publish: test
+	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
+	  echo "tag $(TAG) already exists - bump VERSION first"; exit 1; fi
+	@set -e; \
+	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
+	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] aql filler token detected: would tag $(TAG); nothing pushed."; \
+	  exit 0; \
+	fi; \
+	git tag -a "$(TAG)" -m "swift v$(VERSION)"; \
+	url=$$(git remote get-url origin | sed -E 's#^git@github.com:#https://github.com/#'); \
+	if [ -n "$$token" ] && printf '%s' "$$url" | grep -q '^https://github.com/'; then \
+	  hdr="AUTHORIZATION: basic $$(printf 'x-access-token:%s' "$$token" | base64 | tr -d '\n')"; \
+	  git -c http.extraheader="$$hdr" push "$$url" "$(TAG)"; \
+	else \
+	  git push origin "$(TAG)"; \
+	fi; \
+	echo "Tagged $(TAG)."

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/Struct/Constants.swift

@@ -0,0 +1,113 @@
+// Constants — mirror typescript/src/StructUtility.ts. Kept in canonical
+// SCREAMING_SNAKE so cross-port grepping is easy.
+
+import Foundation
+
+// MARK: - Injection modes
+
+public let M_KEYPRE = 1
+public let M_KEYPOST = 2
+public let M_VAL = 4
+
+public let MODENAME: [Int: String] = [
+  M_KEYPRE: "key:pre",
+  M_KEYPOST: "key:post",
+  M_VAL: "val",
+]
+
+// MARK: - Backtick-quoted command names
+
+public let S_BKEY = "`$KEY`"
+public let S_BANNO = "`$ANNO`"
+public let S_BEXACT = "`$EXACT`"
+public let S_BVAL = "`$VAL`"
+public let S_BOPEN = "`$OPEN`"
+
+// MARK: - Annotation keys
+
+public let S_DKEY = "$KEY"
+public let S_DTOP = "$TOP"
+public let S_DERRS = "$ERRS"
+public let S_DSPEC = "$SPEC"
+public let S_DMETA = "$META"
+
+// MARK: - Type names (used by typename / typify)
+
+public let S_list = "list"
+public let S_base = "base"
+public let S_boolean = "boolean"
+public let S_function = "function"
+public let S_symbol = "symbol"
+public let S_instance = "instance"
+public let S_key = "key"
+public let S_any = "any"
+public let S_nil = "nil"
+public let S_null = "null"
+public let S_number = "number"
+public let S_object = "object"
+public let S_string = "string"
+public let S_decimal = "decimal"
+public let S_integer = "integer"
+public let S_map = "map"
+public let S_scalar = "scalar"
+public let S_node = "node"
+
+// MARK: - Single-character / punctuation strings
+
+public let S_BT = "`"
+public let S_CN = ":"
+public let S_CS = "]"
+public let S_DS = "$"
+public let S_DT = "."
+public let S_FS = "/"
+public let S_KEY = "KEY"
+public let S_MT = ""
+public let S_OS = "["
+public let S_SP = " "
+public let S_CM = ","
+public let S_VIZ = ": "
+
+// MARK: - Type bit-flags
+//
+// Same numeric layout as the canonical TS: T_any is all-bits-below set;
+// the others are distinct bits decreasing down the list (the order
+// matches TYPENAME below for table-driven lookup).
+
+// Type bit-flag values match the canonical TypeScript scheme exactly so that
+// typify()/typename() return the same numbers the shared corpus pins.
+public let T_any: Int = (1 << 31) - 1
+public let T_noval: Int = 1 << 30
+public let T_boolean: Int = 1 << 29
+public let T_decimal: Int = 1 << 28
+public let T_integer: Int = 1 << 27
+public let T_number: Int = 1 << 26
+public let T_string: Int = 1 << 25
+public let T_function: Int = 1 << 24
+public let T_symbol: Int = 1 << 23
+public let T_null: Int = 1 << 22
+public let T_list: Int = 1 << 14
+public let T_map: Int = 1 << 13
+public let T_instance: Int = 1 << 12
+public let T_scalar: Int = 1 << 7
+public let T_node: Int = 1 << 6
+
+// TYPENAME indexed by clz32(typebit): the human name of a type bit-field is the
+// name of its highest set bit (canonical getelem(TYPENAME, clz32(t))).
+public let TYPENAME_ARR: [String] = [
+  S_any, S_nil, S_boolean, S_decimal, S_integer, S_number, S_string,
+  S_function, S_symbol, S_null,
+  "", "", "", "", "", "", "",
+  S_list, S_map, S_instance,
+  "", "", "", "",
+  S_scalar, S_node,
+]
+
+// MARK: - Regex patterns
+
+public let R_INTEGER_KEY = try! NSRegularExpression(pattern: #"^-?[0-9]+$"#)
+public let R_META_PATH = try! NSRegularExpression(pattern: #"^([^$]+)\$([=~])(.+)$"#)
+public let R_INJECTION_FULL = try! NSRegularExpression(pattern: #"^`(\$[A-Z]+|[^`]*)[0-9]*`$"#)
+public let R_INJECTION_PARTIAL = try! NSRegularExpression(pattern: #"`([^`]+)`"#)
+public let R_TRANSFORM_NAME = try! NSRegularExpression(pattern: #"`\$([A-Z]+)`"#)
+
+public let MAXDEPTH = 32

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/Struct/Inject.swift

@@ -0,0 +1,260 @@
+// inject — recursive descent that resolves backtick references and
+// command-table injectors. The three-phase key processing
+// (M_KEYPRE → M_VAL → M_KEYPOST) is canonical: command handlers can
+// rewrite the parent map mid-iteration via `setval`, and `keyI = -1`
+// causes the outer loop to re-process the same slot with the new value.
+
+import Foundation
+
+// MARK: - Default handler
+
+public func _injecthandler(_ inj: Injection, _ val: Value, _ ref: String, _ store: Value) -> Value {
+  let isCmd: Bool = {
+    guard case .function = val else { return false }
+    return ref.isEmpty || ref.hasPrefix(S_DS)
+  }()
+  if isCmd {
+    guard case .function(let fn) = val else { return val }
+    return fn(inj, val, ref, store)
+  }
+  if inj.mode == M_VAL && inj.full {
+    inj.setval(val)
+  }
+  return val
+}
+
+// MARK: - _injectstr — full or partial backtick injection
+
+public func _injectstr(_ raw: String, _ store: Value, _ inj: Injection?) -> Value {
+  if raw.isEmpty { return .string("") }
+  let nsRaw = raw as NSString
+  // Full pattern: ^`($NAME|[^`]*)[0-9]*`$
+  let r = NSRange(location: 0, length: nsRaw.length)
+  if let m = R_INJECTION_FULL.firstMatch(in: raw, range: r), m.range == r {
+    var pathref = nsRaw.substring(with: m.range(at: 1))
+    if pathref.count > 3 {
+      pathref =
+        pathref
+        .replacingOccurrences(of: "$BT", with: "`")
+        .replacingOccurrences(of: "$DS", with: "$")
+    }
+    inj?.full = true
+    return getpath(store, .string(pathref), inj)
+  }
+  if !raw.contains("`") { return .string(raw) }
+  inj?.full = false
+  // Partial: replace each `...` segment.
+  var out = ""
+  var idx = raw.startIndex
+  while idx < raw.endIndex {
+    if raw[idx] == "`" {
+      if let close = raw.range(of: "`", range: raw.index(after: idx)..<raw.endIndex) {
+        var ref = String(raw[raw.index(after: idx)..<close.lowerBound])
+        if ref.count > 3 {
+          ref =
+            ref
+            .replacingOccurrences(of: "$BT", with: "`")
+            .replacingOccurrences(of: "$DS", with: "$")
+        }
+        inj?.full = false
+        let found = getpath(store, .string(ref), inj)
+        switch found {
+        case .noval: break
+        case .null: out += "null"
+        case .string(let s): out += s
+        case .bool(let b): out += b ? "true" : "false"
+        case .int(let n): out += String(n)
+        case .double(let d): out += JSON.formatDouble(d)
+        // A node interpolated into a string uses compact JSON (canonical TS
+        // uses JSON.stringify(found), not the pretty default jsonify).
+        case .list, .map: out += jsonify(found, indent: 0)
+        case .function, .native: out += "<function>"
+        case .sentinel(let s): out += s.marker
+        }
+        idx = raw.index(after: close.lowerBound)
+        continue
+      }
+    }
+    out.append(raw[idx])
+    idx = raw.index(after: idx)
+  }
+  // Run a final handler pass over the partial result.
+  if let inj = inj {
+    inj.full = true
+    let res = inj.handler(inj, .string(out), raw, store)
+    return res
+  }
+  return .string(out)
+}
+
+// MARK: - Top-level inject
+
+@discardableResult
+public func inject(_ val: Value, _ store: Value, _ injdef: Injection? = nil) -> Value {
+  let inj: Injection
+  let rootInit = injdef == nil || injdef!.mode == 0
+  if rootInit {
+    // Virtual parent holder.
+    let vp = VMap()
+    vp.entries[S_DTOP] = val
+    let root = Injection(val: val, parent: .map(vp))
+    root.mode = M_VAL
+    root.dparent = store
+    // Wire $ERRS from store if present.
+    if case .map(let sm) = store, let errs = sm.entries[S_DERRS], case .list(let el) = errs {
+      root.errs = el
+    }
+    root.meta.entries["__d"] = .int(0)
+    // Carry over caller-supplied options from injdef.
+    if let idef = injdef {
+      if let m = idef.modify { root.modify = m }
+      if !idef.extra.isNoval { root.extra = idef.extra }
+      if !idef.meta.entries.isEmpty { root.meta = idef.meta }
+      if !idef.errs.items.isEmpty { root.errs = idef.errs }
+      // Caller-provided meta/errs override above.
+    }
+    inj = root
+  } else {
+    inj = injdef!
+  }
+  _ = inj.descend()
+  var out = val
+  if isnode(val) {
+    var nodekeys: [String] = []
+    if case .map(let m) = val {
+      // Plain keys first, then $-prefixed in alphabetical order.
+      let allSorted = m.entries.keys.sorted()
+      let plain = allSorted.filter { !$0.contains(S_DS) }
+      let cmd = allSorted.filter { $0.contains(S_DS) }
+      nodekeys = plain + cmd
+    } else if case .list(let l) = val {
+      nodekeys = (0..<l.items.count).map { String($0) }
+    }
+    var nkI = 0
+    while nkI < nodekeys.count {
+      let childinj = inj.child(nkI, nodekeys)
+      let nodekey = childinj.key
+      childinj.mode = M_KEYPRE
+      let prekey = _injectstr(nodekey, store, childinj)
+      nkI = childinj.keyI
+      nodekeys = childinj.keys
+      if !prekey.isNoval {
+        childinj.val = getprop(val, prekey)
+        childinj.mode = M_VAL
+        inject(childinj.val, store, childinj)
+        nkI = childinj.keyI
+        nodekeys = childinj.keys
+        childinj.mode = M_KEYPOST
+        _ = _injectstr(nodekey, store, childinj)
+        nkI = childinj.keyI
+        nodekeys = childinj.keys
+      }
+      nkI += 1
+    }
+  } else if case .string(let s) = val {
+    inj.mode = M_VAL
+    out = _injectstr(s, store, inj)
+    let isSkip: Bool = {
+      if case .sentinel(let sn) = out { return sn === SKIP }
+      return false
+    }()
+    if !isSkip {
+      inj.setval(out)
+    }
+  }
+  // Modify hook (runs after injection).
+  if let mod = inj.modify {
+    let isSkip: Bool = {
+      if case .sentinel(let sn) = out { return sn === SKIP }
+      return false
+    }()
+    if !isSkip {
+      let mkey = inj.key
+      let mparent = inj.parent
+      let mval = getprop(mparent, .string(mkey))
+      mod(mval, .string(mkey), mparent, inj, store)
+    }
+  }
+  inj.val = out
+  return lookup(inj.parent, .string(S_DTOP))
+}
+
+// MARK: - Helpers for transform / validate / select commands
+
+public func checkPlacement(_ modes: Int, _ name: String, _ parentTypes: Int, _ inj: Injection)
+  -> Bool
+{
+  if (modes & inj.mode) == 0 {
+    let allowed = [M_KEYPRE, M_VAL, M_KEYPOST]
+      .filter { (modes & $0) != 0 }
+      .compactMap { MODENAME[$0] }
+      .joined(separator: ",")
+    inj.errs.items.append(
+      .string(
+        "$\(name): invalid placement as " + (MODENAME[inj.mode] ?? "?") + ", expected: " + allowed))
+    return false
+  }
+  if parentTypes != 0 {
+    let ptype = typify(inj.parent)
+    if (parentTypes & ptype) == 0 {
+      inj.errs.items.append(
+        .string("$\(name): invalid placement in parent " + typename(ptype) + "."))
+      return false
+    }
+  }
+  return true
+}
+
+public func injectorArgs(_ types: [Int], _ args: Value) -> (Value, [Value]) {
+  guard case .list(let l) = args else { return (.noval, []) }
+  var out: [Value] = []
+  for i in 0..<types.count {
+    let expected = types[i]
+    let arg = i < l.items.count ? l.items[i] : Value.noval
+    let atype = typify(arg)
+    if expected != T_any && (expected & atype) == 0 {
+      return (.string("argument \(i) not of type: " + typename(expected)), l.items)
+    }
+    out.append(arg)
+  }
+  return (.noval, out)
+}
+
+public func injectChild(_ child: Value, _ store: Value, _ inj: Injection) -> Injection {
+  var cinj = inj
+  if let prior = inj.prior {
+    if let prior2 = prior.prior {
+      cinj = prior2.child(prior.keyI, prior.keys)
+      cinj.val = child
+      setprop(cinj.parent, .string(prior.key), child)
+    } else {
+      cinj = prior.child(inj.keyI, inj.keys)
+      cinj.val = child
+      setprop(cinj.parent, .string(inj.key), child)
+    }
+  }
+  inject(child, store, cinj)
+  return cinj
+}
+
+// MARK: - Builder helpers (jm / jt)
+//
+// `jm` takes alternating key/value args (Swift variadics can't carry a
+// tuple type without ambiguity at the call site). It accepts a key, a
+// value, then any number of additional (key, value) tuples for further
+// pairs. Use `jmd` to pass a Dictionary or OrderedDictionary literal.
+
+public func jm(_ k1: String, _ v1: Value, _ pairs: (String, Value)...) -> Value {
+  let m = VMap()
+  m.entries[k1] = v1
+  for (k, v) in pairs { m.entries[k] = v }
+  return .map(m)
+}
+
+public func jmd(_ entries: OrderedDictionary<String, Value>) -> Value {
+  return .map(VMap(entries))
+}
+
+public func jt(_ items: Value...) -> Value {
+  return .list(VList(items))
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/Struct/Injection.swift

@@ -0,0 +1,111 @@
+// Injection state — passed through every recursive `inject` call as a
+// reference type so command handlers (`transform_*`, `validate_*`,
+// `select_*`) can mutate `keyI`, `keys`, `path`, `dparent`, `dpath`,
+// and the shared `errs` collector. Mirrors the canonical TS `Injection`
+// class — see typescript/src/StructUtility.ts.
+
+import Foundation
+
+public final class Injection: @unchecked Sendable {
+  // `mode == 0` is the "uninitialized" / "options-only" state — `inject`
+  // bootstraps a root Injection when it sees this. Once descent begins,
+  // the inject loop sets mode to one of M_KEYPRE / M_VAL / M_KEYPOST.
+  public var mode: Int = 0
+  public var full: Bool = false
+  public var keyI: Int = 0
+  public var keys: [String] = [S_DTOP]
+  public var key: String = S_DTOP
+  public var val: Value = .noval
+  public var parent: Value = .noval
+  public var path: [String] = [S_DTOP]
+  public var nodes: [Value] = []
+  public var handler: Injector = _injecthandler
+  public var errs: VList = VList()
+  public var meta: VMap = VMap()
+  public var dparent: Value = .noval
+  public var dpath: [String] = [S_DTOP]
+  public var base: String = S_DTOP
+  public var modify: Modify? = nil
+  public var prior: Injection? = nil
+  public var extra: Value = .noval
+
+  public init(val: Value, parent: Value) {
+    self.val = val
+    self.parent = parent
+    self.nodes = [parent]
+    self.dparent = .noval
+  }
+
+  // child(keyI, keys): build a child injection for the next descent step.
+  public func child(_ keyI: Int, _ keys: [String]) -> Injection {
+    let key = keys[keyI]
+    let cv = getprop(val, .string(key))
+    let cinj = Injection(val: cv, parent: val)
+    cinj.keyI = keyI
+    cinj.keys = keys
+    cinj.key = key
+    cinj.path = path + [key]
+    cinj.nodes = nodes + [val]
+    cinj.mode = mode
+    cinj.handler = handler
+    cinj.modify = modify
+    cinj.base = base
+    cinj.meta = meta
+    cinj.errs = errs
+    cinj.prior = self
+    cinj.dpath = dpath
+    cinj.dparent = dparent
+    return cinj
+  }
+
+  // descend(): step into the current node. dparent walks down by
+  // parentkey; dpath grows or contracts past synthetic $:KEY markers
+  // (canonical behaviour).
+  public func descend() -> Value {
+    if let d = meta.entries["__d"], case .int(let n) = d {
+      meta.entries["__d"] = .int(n + 1)
+    } else {
+      meta.entries["__d"] = .int(1)
+    }
+    let parentkey: String? = path.count >= 2 ? path[path.count - 2] : nil
+    if dparent.isNoval {
+      // No data: still grow dpath so relative paths line up with path.
+      if dpath.count > 1, let pk = parentkey {
+        dpath.append(pk)
+      }
+    } else if let pk = parentkey {
+      dparent = getprop(dparent, .string(pk))
+      let last = dpath.last ?? ""
+      if last == "$:" + pk {
+        dpath.removeLast()
+      } else {
+        dpath.append(pk)
+      }
+    }
+    return dparent
+  }
+
+  // setval(val, ancestor?): write a value into the parent (or a
+  // higher ancestor when |ancestor| >= 2). NONE deletes the slot.
+  @discardableResult
+  public func setval(_ v: Value, ancestor: Int = 0) -> Value {
+    let absAnc = abs(ancestor)
+    if absAnc < 2 {
+      if v.isNoval {
+        parent = delprop(parent, .string(key))
+      } else {
+        parent = setprop(parent, .string(key), v)
+      }
+      return parent
+    }
+    let nlen = nodes.count
+    let plen = path.count
+    guard absAnc <= nlen, absAnc <= plen else { return parent }
+    let target = nodes[nlen - absAnc]
+    let tkey = path[plen - absAnc]
+    if v.isNoval {
+      return delprop(target, .string(tkey))
+    }
+    return setprop(target, .string(tkey), v)
+  }
+}