@voxgig/sdkgen 1.3.8 → 1.3.10

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Context.swift

@@ -0,0 +1,161 @@
+// ProjectName SDK - operation context.
+//
+// ctxmap is a loose Swift dictionary that carries a mix of typed pipeline
+// objects (client, utility, entity, spec, ...) and loose Value maps (data,
+// match, options, ...), mirroring the C# donor's Dictionary<string,object?>.
+
+import Foundation
+
+// ctxProp reads a value from the loose ctx dictionary.
+func ctxProp(_ m: [String: Any?]?, _ key: String) -> Any? {
+  guard let m = m, let v = m[key] else { return nil }
+  return v
+}
+
+public final class Context {
+  public var id: String = ""
+  public var out: [String: Any?] = [:]
+  public var ctrl: Control = Control()
+  public var meta: VMap = VMap()
+  public var client: ProjectNameSDK?
+  public var utility: Utility?
+  public var op: Operation?
+  public var point: VMap?
+  public var config: VMap?
+  public var entopts: VMap?
+  public var options: VMap?
+  public var opmap: [String: Operation] = [:]
+  public var response: Response?
+  public var result: Result?
+  public var spec: Spec?
+  public var data: VMap = VMap()
+  public var reqdata: VMap = VMap()
+  public var match: VMap = VMap()
+  public var reqmatch: VMap = VMap()
+  public var entity: Entity?
+  public var shared: VMap?
+
+  public init(_ ctxmap: [String: Any?]?, _ basectx: Context?) {
+    id = "C" + String(Int.random(in: 10_000_000...99_999_999))
+
+    // Client
+    if let sdk = ctxProp(ctxmap, "client") as? ProjectNameSDK { client = sdk }
+    if client == nil, let b = basectx { client = b.client }
+
+    // Utility
+    if let util = ctxProp(ctxmap, "utility") as? Utility { utility = util }
+    if utility == nil, let b = basectx { utility = b.utility }
+
+    // Ctrl
+    ctrl = Control()
+    let rawctrl = ctxProp(ctxmap, "ctrl")
+    if let c = rawctrl as? Control {
+      ctrl = c
+    } else if let cm = rawctrl as? VMap {
+      if let t = cm.entries["throw"]?.asBool { ctrl.throwErr = t }
+      if let e = cm.entries["explain"]?.asMap { ctrl.explain = e }
+      if let a = cm.entries["actor"]?.asString { ctrl.actor = a }
+      if let p = cm.entries["paging"]?.asMap { ctrl.paging = p }
+    } else if let b = basectx {
+      ctrl = b.ctrl
+    }
+
+    // Meta
+    meta = VMap()
+    if let mm = ctxProp(ctxmap, "meta") as? VMap {
+      meta = mm
+    } else if let b = basectx {
+      meta = b.meta
+    }
+
+    // Config
+    if let cfg = ctxProp(ctxmap, "config") as? VMap { config = cfg }
+    if config == nil, let b = basectx { config = b.config }
+
+    // Entopts
+    if let eo = ctxProp(ctxmap, "entopts") as? VMap { entopts = eo }
+    if entopts == nil, let b = basectx { entopts = b.entopts }
+
+    // Options
+    if let om = ctxProp(ctxmap, "options") as? VMap { options = om }
+    if options == nil, let b = basectx { options = b.options }
+
+    // Entity
+    if let ent = ctxProp(ctxmap, "entity") as? Entity { entity = ent }
+    if entity == nil, let b = basectx { entity = b.entity }
+
+    // Shared
+    if let sh = ctxProp(ctxmap, "shared") as? VMap { shared = sh }
+    if shared == nil, let b = basectx { shared = b.shared }
+
+    // Opmap
+    if let opm = ctxProp(ctxmap, "opmap") as? [String: Operation] {
+      opmap = opm
+    } else if let b = basectx {
+      opmap = b.opmap
+    }
+
+    // Data maps
+    data = (ctxProp(ctxmap, "data") as? VMap) ?? VMap()
+    reqdata = (ctxProp(ctxmap, "reqdata") as? VMap) ?? VMap()
+    match = (ctxProp(ctxmap, "match") as? VMap) ?? VMap()
+    reqmatch = (ctxProp(ctxmap, "reqmatch") as? VMap) ?? VMap()
+
+    // Point
+    if let tm = ctxProp(ctxmap, "point") as? VMap { point = tm }
+    if point == nil, let b = basectx { point = b.point }
+
+    // Spec
+    if let sp = ctxProp(ctxmap, "spec") as? Spec { spec = sp }
+    if spec == nil, let b = basectx { spec = b.spec }
+
+    // Result
+    if let res = ctxProp(ctxmap, "result") as? Result { result = res }
+    if result == nil, let b = basectx { result = b.result }
+
+    // Response
+    if let resp = ctxProp(ctxmap, "response") as? Response { response = resp }
+    if response == nil, let b = basectx { response = b.response }
+
+    // Resolve operation
+    let opname = ctxProp(ctxmap, "opname") as? String ?? ""
+    op = resolveOp(opname)
+  }
+
+  private func resolveOp(_ opname: String) -> Operation {
+    // Cache key `<entity>:<opname>` so two entities with the same op get
+    // distinct cached Operations.
+    let entname = entity?.getName() ?? ""
+    let cacheKey = entname + ":" + opname
+
+    if let cached = opmap[cacheKey] { return cached }
+
+    if opname == "" {
+      return Operation(VMap())
+    }
+
+    let store: Value = config == nil ? .noval : .map(config!)
+    let opcfg = getpath(store, jtp("entity", entname, "op", opname))
+
+    let input = (opname == "update" || opname == "create") ? "data" : "match"
+
+    var points: VList = VList()
+    if let ocm = opcfg.asMap, let tl = ocm.entries["points"]?.asList {
+      points = tl
+    }
+
+    let opm = VMap()
+    opm.entries["entity"] = .string(entname)
+    opm.entries["name"] = .string(opname)
+    opm.entries["input"] = .string(input)
+    opm.entries["points"] = .list(points)
+
+    let op = Operation(opm)
+    opmap[cacheKey] = op
+    return op
+  }
+
+  public func makeError(_ code: String, _ msg: String) -> ProjectNameError {
+    return ProjectNameError(code, msg, self)
+  }
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Control.swift

@@ -0,0 +1,20 @@
+// ProjectName SDK - per-call control block.
+
+import Foundation
+
+public final class Control {
+  // `throw` is a Swift keyword; the pipeline reads `throwErr == false`.
+  public var throwErr: Bool? = nil
+  public var err: Error? = nil
+  // Explain and paging carry loose data + typed products (stored via .nat).
+  public var explain: VMap? = nil
+  public var actor: String = ""
+  public var paging: VMap? = nil
+
+  // Outbound streaming marker: the entity `stream` method sets this to the
+  // caller-supplied streamable payload so the request builder / transport can
+  // stream it as the request body.
+  public var streamOut: Value? = nil
+
+  public init() {}
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Operation.swift

@@ -0,0 +1,27 @@
+// ProjectName SDK - resolved operation definition.
+
+import Foundation
+
+public final class Operation {
+  public var entity: String = "_"
+  public var name: String = "_"
+  public var input: String = "_"
+  public var points: [VMap] = []
+  public var alias: VMap? = nil
+
+  public init(_ opmap: VMap) {
+    let m: Value = .map(opmap)
+
+    if let e = getprop(m, .string("entity")).asString, e != "" { entity = e }
+    if let n = getprop(m, .string("name")).asString, n != "" { name = n }
+    if let i = getprop(m, .string("input")).asString, i != "" { input = i }
+
+    if let tlist = getprop(m, .string("points")).asList {
+      for t in tlist.items {
+        if let tm = t.asMap { points.append(tm) }
+      }
+    }
+
+    if let am = getprop(m, .string("alias")).asMap { alias = am }
+  }
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Point.swift

@@ -0,0 +1,37 @@
+// ProjectName SDK - typed view over an endpoint (point) definition.
+
+import Foundation
+
+public final class Point {
+  public var args: VMap
+  public var rename: VMap
+  public var method: String = ""
+  public var orig: String = ""
+  public var parts: VList = VList()
+  public var params: VList? = nil
+  public var select: VMap? = nil
+  public var active: Bool = false
+  public var relations: VList? = nil
+  public var alias: VMap = VMap()
+  public var transform: VMap = VMap()
+
+  public init(_ pointmap: VMap?) {
+    args = VMap()
+    args.entries["params"] = .list([])
+    rename = VMap()
+    rename.entries["params"] = .map(VMap())
+
+    let pm: Value = pointmap == nil ? .noval : .map(pointmap!)
+    if let am = getprop(pm, .string("args")).asMap { args = am }
+    if let rm = getprop(pm, .string("rename")).asMap { rename = rm }
+    if let m = getprop(pm, .string("method")).asString { method = m }
+    if let o = getprop(pm, .string("orig")).asString { orig = o }
+    if let pl = getprop(pm, .string("parts")).asList { parts = pl }
+    if let pr = getprop(pm, .string("params")).asList { params = pr }
+    if let sm = getprop(pm, .string("select")).asMap { select = sm }
+    if let ab = getprop(pm, .string("active")).asBool { active = ab }
+    if let rl = getprop(pm, .string("relations")).asList { relations = rl }
+    if let al = getprop(pm, .string("alias")).asMap { alias = al }
+    if let tf = getprop(pm, .string("transform")).asMap { transform = tf }
+  }
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Response.swift

@@ -0,0 +1,29 @@
+// ProjectName SDK - transport response wrapper.
+
+import Foundation
+
+public final class Response {
+  public var status: Int = -1
+  public var statusText: String = ""
+  public var headers: Value = .noval
+  public var jsonFunc: NativeCall0? = nil
+  public var body: Value = .noval
+  public var err: Error? = nil
+
+  public init(_ resmap: VMap?) {
+    let m: Value = resmap == nil ? .map(VMap()) : .map(resmap!)
+
+    let st = getprop(m, .string("status"))
+    if !isNil(st) { status = toInt(st) }
+
+    if let s = getprop(m, .string("statusText")).asString { statusText = s }
+
+    headers = getprop(m, .string("headers"))
+
+    if let jf = getprop(m, .string("json")).asNative as? NativeCall0 { jsonFunc = jf }
+
+    body = getprop(m, .string("body"))
+
+    if let e = getprop(m, .string("err")).asNative as? Error { err = e }
+  }
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Result.swift

@@ -0,0 +1,41 @@
+// ProjectName SDK - operation result.
+
+import Foundation
+
+public final class Result {
+  public var ok: Bool = false
+  public var status: Int = -1
+  public var statusText: String = ""
+  public var headers: VMap = VMap()
+  public var body: Value = .noval
+  public var err: Error? = nil
+  public var resdata: Value = .noval
+  public var resmatch: VMap? = nil
+
+  // Feature extensions: pagination signals (paging feature) and the
+  // incremental item iterator (streaming feature).
+  public var paging: VMap? = nil
+  public var streaming: Bool = false
+  public var stream: (() -> [Value])? = nil
+
+  public init(_ resmap: VMap?) {
+    let m: Value = resmap == nil ? .map(VMap()) : .map(resmap!)
+
+    if let b = getprop(m, .string("ok")).asBool { ok = b }
+
+    let st = getprop(m, .string("status"))
+    if !isNil(st) { status = toInt(st) }
+
+    if let s = getprop(m, .string("statusText")).asString { statusText = s }
+
+    if let hm = getprop(m, .string("headers")).asMap { headers = hm }
+
+    body = getprop(m, .string("body"))
+
+    if let e = getprop(m, .string("err")).asNative as? Error { err = e }
+
+    resdata = getprop(m, .string("resdata"))
+
+    if let rmm = getprop(m, .string("resmatch")).asMap { resmatch = rmm }
+  }
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Spec.swift

@@ -0,0 +1,36 @@
+// ProjectName SDK - HTTP request specification.
+
+import Foundation
+
+public final class Spec {
+  public var parts: VList? = nil
+  public var headers: VMap = VMap()
+  public var alias: VMap = VMap()
+  public var base: String = ""
+  public var prefix: String = ""
+  public var suffix: String = ""
+  public var params: VMap = VMap()
+  public var query: VMap = VMap()
+  public var step: String = ""
+  public var method: String = "GET"
+  public var body: Value = .noval
+  public var url: String = ""
+  public var path: String = ""
+
+  public init(_ specmap: VMap?) {
+    guard let m = specmap else { return }
+    if let v = m.entries["parts"], let parts = v.asList { self.parts = parts }
+    if let v = m.entries["headers"], let h = v.asMap { self.headers = h }
+    if let v = m.entries["alias"], let a = v.asMap { self.alias = a }
+    if let v = m.entries["base"], let b = v.asString { self.base = b }
+    if let v = m.entries["prefix"], let p = v.asString { self.prefix = p }
+    if let v = m.entries["suffix"], let sf = v.asString { self.suffix = sf }
+    if let v = m.entries["params"], let pm = v.asMap { self.params = pm }
+    if let v = m.entries["query"], let q = v.asMap { self.query = q }
+    if let v = m.entries["step"], let st = v.asString { self.step = st }
+    if let v = m.entries["method"], let mm = v.asString { self.method = mm }
+    if let v = m.entries["body"] { self.body = v }
+    if let v = m.entries["url"], let u = v.asString { self.url = u }
+    if let v = m.entries["path"], let pa = v.asString { self.path = pa }
+  }
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Support.swift

@@ -0,0 +1,98 @@
+// ProjectName SDK - shared value helpers for the loose object model.
+//
+// The SDK, like its Voxgig-Struct data model, carries loose JSON-shaped data
+// as `Value` (see Struct/Value.swift): maps are `VMap`, lists are `VList`,
+// scalars are `.string/.int/.double/.bool`, absent/null is `.noval/.null`,
+// and language-runtime callables/objects the model must transport are
+// `.native`. Typed pipeline products (Context, Spec, Result, ...) are plain
+// classes. These helpers mirror the C# donor's Helpers + the struct accessors.
+
+import Foundation
+
+// A callable stored in the loose model (the transport `json` thunk, feature
+// callbacks, system.fetch). `.nat(closure)` wraps it; `callNative` unwraps.
+public typealias NativeCall0 = () -> Value
+
+// UnsupportedOp is thrown by entity base methods for operations the API spec
+// does not define.
+func unsupportedOp(_ opname: String, _ entityname: String) -> ProjectNameError {
+  return ProjectNameError(
+    "unsupported_op",
+    "operation '\(opname)' not supported by entity '\(entityname)'", nil)
+}
+
+// errMessage extracts a human message from any Error (SDK errors carry one).
+func errMessage(_ e: Error) -> String {
+  if let se = e as? ProjectNameError { return se.message }
+  return String(describing: e)
+}
+
+func toInt(_ v: Value) -> Int {
+  switch v {
+  case .int(let n): return Int(n)
+  case .double(let d): return Int(d)
+  default: return -1
+  }
+}
+
+func toLong(_ v: Value) -> Int64 {
+  switch v {
+  case .int(let n): return n
+  case .double(let d): return Int64(d)
+  default: return -1
+  }
+}
+
+// asVMap / asVList unwrap a Value node to its reference container.
+func asVMap(_ v: Value) -> VMap? { v.asMap }
+func asVList(_ v: Value) -> VList? { v.asList }
+
+// mapv builds a Value map (.map) from pairs, preserving insertion order.
+func mapv(_ pairs: (String, Value)...) -> Value { .map(pairs) }
+
+// vm builds a VMap from pairs.
+func vm(_ pairs: (String, Value)...) -> VMap {
+  let m = VMap()
+  for (k, v) in pairs { m.entries[k] = v }
+  return m
+}
+
+// listv builds a Value list (.list) from items.
+func listv(_ items: Value...) -> Value { .list(items) }
+
+// s/i/d/b: terse Value scalar constructors.
+func s(_ v: String) -> Value { .string(v) }
+
+// isNil: absent or JSON null (the SDK treats both as "no value").
+func isNil(_ v: Value) -> Bool { v.isNoval || v.isNull }
+
+// nativeClosure0 pulls a stored no-arg thunk (the transport `json` function).
+func nativeClosure0(_ v: Value) -> NativeCall0? { v.asNative as? NativeCall0 }
+
+// jtp is the SDK path-list constructor (C# StructUtils.Jt): a Value list of
+// string path segments for getpath/setpath.
+func jtp(_ segs: String...) -> Value { .list(segs.map { .string($0) }) }
+func jtpv(_ segs: [String]) -> Value { .list(segs.map { .string($0) }) }
+
+// gp: Group-A property read (C# StructUtils.GetProp) over an optional VMap or
+// an arbitrary Value.
+func gp(_ m: VMap?, _ key: String) -> Value { getprop(m == nil ? .noval : .map(m!), .string(key)) }
+func gp(_ v: Value, _ key: String) -> Value { getprop(v, .string(key)) }
+
+// gpath: getpath over an optional VMap store (C# StructUtils.GetPath(m, Jt(...))).
+func gpath(_ m: VMap?, _ segs: String...) -> Value {
+  getpath(m == nil ? .noval : .map(m!), jtpv(segs))
+}
+func gpath(_ v: Value, _ segs: String...) -> Value { getpath(v, jtpv(segs)) }
+
+// regexReplace replaces every match of `pattern` in `input` with the literal
+// `replacement` (template metacharacters in the replacement are escaped).
+func regexReplace(_ input: String, _ pattern: String, _ replacement: String) -> String {
+  guard let re = try? NSRegularExpression(pattern: pattern) else { return input }
+  let range = NSRange(input.startIndex..., in: input)
+  let tmpl = NSRegularExpression.escapedTemplate(for: replacement)
+  return re.stringByReplacingMatches(in: input, options: [], range: range, withTemplate: tmpl)
+}
+
+// The injectable system.fetch signature (options.system.fetch).
+public typealias SystemFetch = (String, VMap) -> Value

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Types.swift

@@ -0,0 +1,25 @@
+// ProjectName SDK - core contracts.
+
+import Foundation
+
+// The minimal entity contract the pipeline depends on (list-wrapping in
+// MakeResult, feature hooks). Concrete entity classes derive from
+// ProjectNameEntityBase which implements this.
+public protocol Entity: AnyObject {
+  func getName() -> String
+  func make() -> Entity
+  @discardableResult func data(_ newdata: Value?) -> Value
+  @discardableResult func matchv(_ newmatch: Value?) -> Value
+}
+
+public extension Entity {
+  @discardableResult func data() -> Value { data(nil) }
+  @discardableResult func matchv() -> Value { matchv(nil) }
+}
+
+// Transport function: performs the HTTP (or mock) request. Returns a
+// transport-shaped response map (Value.map):
+//   { status, statusText, headers, json: .nat(()->Value), body }
+// Throws (typically ProjectNameError) on transport-level failure. A returned
+// `.noval` mirrors the go pipeline's (nil, nil) "no response".
+public typealias FetcherFunc = (Context, String, VMap) throws -> Value

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/core/Utility.swift

@@ -0,0 +1,81 @@
+// ProjectName SDK - utility object: the pluggable set of pipeline functions.
+// Every pipeline step is a closure field so features (and custom utilities)
+// can wrap or replace behaviour per client instance.
+
+import Foundation
+
+public final class Utility {
+  public var clean: ((Context, Value) -> Value)!
+  public var done: ((Context) throws -> Value)!
+  public var makeError: ((Context, Error?) throws -> Value)!
+  public var featureAdd: ((Context, BaseFeature) -> Void)!
+  public var featureHook: ((Context, String) -> Void)!
+  public var featureInit: ((Context, BaseFeature) -> Void)!
+  public var fetcher: FetcherFunc!
+  public var makeFetchDef: ((Context) throws -> VMap)!
+  public var makeContext: (([String: Any?]?, Context?) -> Context)!
+  public var makeOptions: ((Context) -> VMap)!
+  public var makeRequest: ((Context) throws -> Response)!
+  public var makeResponse: ((Context) throws -> Response)!
+  public var makeResult: ((Context) throws -> Result)!
+  public var makePoint: ((Context) throws -> VMap?)!
+  public var makeSpec: ((Context) throws -> Spec)!
+  public var makeUrl: ((Context) throws -> String)!
+  public var param: ((Context, Value) -> Value)!
+  public var prepareAuth: ((Context) throws -> Spec)!
+  public var prepareBody: ((Context) -> Value)!
+  public var prepareHeaders: ((Context) -> VMap)!
+  public var prepareMethod: ((Context) -> String)!
+  public var prepareParams: ((Context) -> VMap)!
+  public var preparePath: ((Context) -> String)!
+  public var prepareQuery: ((Context) -> VMap)!
+  public var resultBasic: ((Context) -> Result)!
+  public var resultBody: ((Context) -> Result)!
+  public var resultHeaders: ((Context) -> Result)!
+  public var transformRequest: ((Context) -> Value)!
+  public var transformResponse: ((Context) -> Value)!
+  public var custom: [String: Any?] = [:]
+
+  public init() {
+    registerAll(self)
+  }
+
+  private init(noregister: Bool) {}
+
+  // A shallow copy sharing the same closures but with an independent Custom
+  // map, so per-entity utility views can diverge safely.
+  public static func copy(_ src: Utility) -> Utility {
+    let u = Utility(noregister: true)
+    u.clean = src.clean
+    u.done = src.done
+    u.makeError = src.makeError
+    u.featureAdd = src.featureAdd
+    u.featureHook = src.featureHook
+    u.featureInit = src.featureInit
+    u.fetcher = src.fetcher
+    u.makeFetchDef = src.makeFetchDef
+    u.makeContext = src.makeContext
+    u.makeOptions = src.makeOptions
+    u.makeRequest = src.makeRequest
+    u.makeResponse = src.makeResponse
+    u.makeResult = src.makeResult
+    u.makePoint = src.makePoint
+    u.makeSpec = src.makeSpec
+    u.makeUrl = src.makeUrl
+    u.param = src.param
+    u.prepareAuth = src.prepareAuth
+    u.prepareBody = src.prepareBody
+    u.prepareHeaders = src.prepareHeaders
+    u.prepareMethod = src.prepareMethod
+    u.prepareParams = src.prepareParams
+    u.preparePath = src.preparePath
+    u.prepareQuery = src.prepareQuery
+    u.resultBasic = src.resultBasic
+    u.resultBody = src.resultBody
+    u.resultHeaders = src.resultHeaders
+    u.transformRequest = src.transformRequest
+    u.transformResponse = src.transformResponse
+    u.custom = src.custom
+    return u
+  }
+}

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/AuditFeature.swift

@@ -0,0 +1,99 @@
+// Audit trail. Emits a structured record for every operation - who (actor),
+// what (entity + op), the outcome, and a correlation id - suitable for
+// compliance logging. Records accumulate on the feature (bounded by `max`,
+// default 1000) and, when a `sink` callback is supplied, are also pushed to
+// it (e.g. to forward to a SIEM). The actor is the per-call ctrl actor,
+// falling back to the options `actor`, then "anonymous". Each operation is
+// audited exactly once (the per-context marker in ctx.out prevents a
+// preDone + preUnexpected double-log). Timestamps use the injectable `now`
+// clock so tests stay deterministic.
+
+import Foundation
+
+public final class AuditFeature: BaseFeature {
+  private var client: ProjectNameSDK?
+  private var options: VMap?
+  private var seq = 0
+
+  // Activity tracking (mirrors the ts client._audit record).
+  public var records: [VMap] = []
+
+  private static let seenKey = "audit_seen"
+
+  public override init() {
+    super.init()
+    version = "0.0.1"
+    name = "audit"
+    active = true
+  }
+
+  public override func initFeature(_ ctx: Context, _ options: VMap) {
+    client = ctx.client
+    self.options = options
+    active = foptBool(options, "active", false)
+    seq = 0
+  }
+
+  public override func preDone(_ ctx: Context) {
+    // Outcome reflects the actual result; a non-2xx reaches preDone
+    // before the pipeline errors.
+    var outcome = "error"
+    if ctx.result != nil && ctx.result!.ok && ctx.result!.err == nil {
+      outcome = "ok"
+    }
+    emit(ctx, outcome)
+  }
+
+  public override func preUnexpected(_ ctx: Context) {
+    emit(ctx, "error")
+  }
+
+  private func emit(_ ctx: Context, _ outcome: String) {
+    if !active {
+      return
+    }
+
+    // One record per operation (preDone + a following preUnexpected on a
+    // failure must not double-log).
+    if let seen = ctx.out[AuditFeature.seenKey] as? Bool, seen {
+      return
+    }
+    ctx.out[AuditFeature.seenKey] = true
+
+    seq += 1
+
+    var actor = "anonymous"
+    let optActor = foptStr(options, "actor", "")
+    if optActor != "" {
+      actor = optActor
+    }
+    if ctx.ctrl.actor != "" {
+      actor = ctx.ctrl.actor
+    }
+
+    let entity = ctx.op?.entity ?? "_"
+    let opname = ctx.op?.name ?? "_"
+
+    let record = VMap()
+    record.entries["seq"] = .int(Int64(seq))
+    record.entries["ts"] = .int(foptNow(options)())
+    record.entries["actor"] = .string(actor)
+    record.entries["entity"] = .string(entity)
+    record.entries["op"] = .string(opname)
+    record.entries["outcome"] = .string(outcome)
+    record.entries["correlationId"] = .string(ctx.id)
+    if let result = ctx.result {
+      record.entries["status"] = .int(Int64(result.status))
+    }
+
+    records.append(record)
+    let max = foptInt(options, "max", 1000)
+    while records.count > max {
+      records.removeFirst()
+    }
+
+    if let sink = gp(options, "sink").asNative as? (VMap) -> Void {
+      sink(record)
+    }
+  }
+}