@voxgig/sdkgen 4.34.0 → 4.34.2

package/project/.sdk/tm/zig/feature/test.zig

@@ -93,6 +93,24 @@ fn fixIds(_: Allocator, key: ?[]const u8, val: Value, _: Value, path: []const []
     return val;
 }
 
+// The key a list's response transform
+// ["`$EACH`", "body", {"`$MERGE`": "`.<key>`"}] reads each item's record
+// under; null for any other transform.
+fn item_envelope_key(restf: Value) ?[]const u8 {
+    if (restf != .array) return null;
+    const spec = restf.array.data.items;
+    if (spec.len != 3) return null;
+    if (spec[0] != .string or !std.mem.eql(u8, spec[0].string, "`$EACH`")) return null;
+    if (spec[1] != .string or !std.mem.eql(u8, spec[1].string, "body")) return null;
+    const merge = h.getp(spec[2], "`$MERGE`");
+    if (merge != .string) return null;
+    const m = merge.string;
+    if (m.len < 4 or !std.mem.startsWith(u8, m, "`.") or !std.mem.endsWith(u8, m, "`")) return null;
+    const key = m[2 .. m.len - 1];
+    if (std.mem.indexOfAny(u8, key, ".`$") != null) return null;
+    return key;
+}
+
 // THE MOCK HAS TO AGREE WITH THE MODEL.
 //
 // A point carrying `transform.res: `body.item`` describes an API that answers
@@ -107,6 +125,13 @@ fn fixIds(_: Allocator, key: ?[]const u8, val: Value, _: Value, path: []const []
 fn envelope(ctx: *Context, data: Value) Value {
     if (data == .null) return data;
     const restf = h.getpath(&.{ "transform", "res" }, ctx.point);
+    if (item_envelope_key(restf)) |key| {
+        if (data == .array) {
+            const out = h.olist();
+            for (data.array.data.items) |item| out.array.append(h.jo(&.{.{ key, item }})) catch {};
+            return out;
+        }
+    }
     if (restf != .string) return data;
     const spec = restf.string;
     // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
@@ -181,17 +206,19 @@ fn pick_point(points: Value) Value {
     return point;
 }
 
+// Each name is read from its arg: this struct port's `$EACH` transform answers
+// null for every `$KEY.name`, where the other ports answer the names.
 fn reqd_names(point: Value, kind: []const u8) Value {
     const args_path = h.getpath(&.{ "args", kind }, point);
     const reqd_args = vs.select(h.A(), args_path, h.jo(&.{.{ "reqd", h.vbool(true) }})) catch return h.olist();
-    // transform reports collected injection errors beside the value; .out is
-    // the value itself, errors or not.
-    const tres = vs.transform(h.A(), reqd_args, h.ja(&.{
-        h.vstr("`$EACH`"),
-        h.vstr(""),
-        h.vstr("`$KEY.name`"),
-    })) catch return h.olist();
-    return tres.out;
+    const names = h.olist();
+    if (reqd_args == .array) {
+        for (reqd_args.array.data.items) |arg| {
+            const name = h.getp(arg, "name");
+            if (name == .string) names.array.append(name) catch {};
+        }
+    }
+    return names;
 }
 
 fn build_args(ctx: *Context, args: Value) Value {
@@ -271,7 +298,7 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
             for (found.array.data.items) |item| h.del_prop(item, h.vstr("$KEY"));
         }
         return respond(ctx, 200, h.clone(found), &.{});
-    } else if (std.mem.eql(u8, op.name, "update")) {
+    } else if (std.mem.eql(u8, op.name, "update") or std.mem.eql(u8, op.name, "patch")) {
         const reqdata = ctx.reqdata;
         var update_match = h.omap();
         if (reqdata == .object) {
@@ -292,7 +319,10 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
             return respond(ctx, 404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
         }
         if (ent == .object and reqdata == .object) {
-            ent = h.merge(h.ja(&.{ ent, reqdata }));
+            // `$body` travels on the wire alone; the record is the rest.
+            const rec = h.clone(reqdata);
+            h.del_prop(rec, h.vstr("$body"));
+            ent = h.merge(h.ja(&.{ ent, rec }));
         }
         h.del_prop(ent, h.vstr("$KEY"));
         return respond(ctx, 200, h.clone(ent), &.{});
@@ -319,6 +349,7 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
         }
         const ent = h.clone(ctx.reqdata);
         if (ent == .object) {
+            h.del_prop(ent, h.vstr("$body"));
             h.setp(ent, "id", id);
             if (id == .string) h.setp(entmap, id.string, ent);
             h.del_prop(ent, h.vstr("$KEY"));

package/project/.sdk/tm/zig/feature/validate.zig

@@ -125,6 +125,8 @@ pub const ValidateFeature = struct {
         // custom-action call would be rejected for the one key that made it
         // reachable.
         _ = out.object.fetchOrderedRemove("$action");
+        // Nor is `$body`, the raw request body.
+        _ = out.object.fetchOrderedRemove("$body");
 
         return out;
     }

package/project/.sdk/tm/zig/test/fh.zig

@@ -314,7 +314,7 @@ pub fn fh_err_code(err: ?*SdkError) []const u8 {
 
 fn fhDefaultMethod(op: []const u8) []const u8 {
     if (std.mem.eql(u8, op, "create")) return "POST";
-    if (std.mem.eql(u8, op, "update")) return "PATCH";
+    if (std.mem.eql(u8, op, "update") or std.mem.eql(u8, op, "patch")) return "PATCH";
     if (std.mem.eql(u8, op, "remove")) return "DELETE";
     return "GET";
 }

package/project/sdkgen-package.json

@@ -3,7 +3,7 @@
     "package": 1
   },
   "name": "@voxgig/sdkgen",
-  "version": "4.34.0",
+  "version": "4.34.2",
   "provides": {
     "target": [
       "c",

package/src/action/copies.ts

@@ -13,14 +13,18 @@ import { KINDS } from './kind'
 import type { Source } from './resolve'
 
 
-// What every add last wrote into `.sdk`, by fingerprint, and the version of
-// the package each item came from. It is the only record that tells a copy
-// the project changed from one its source has since moved past.
-const COPIES = 'sdkgen-copies.json'
+// What every add wrote into `.sdk`, by fingerprint, and the version of the
+// package each item came from: the only record that tells a copy the project
+// changed from one its source has since moved past. Append-only, one line per
+// add or remove that changed the record, holding just the change.
+const COPY_LOG = 'log/copies.jsonl'
 
-const ABOUT = 'Written by voxgig-sdkgen on every add: what it copied into ' +
-  '.sdk, so that doctor, generate and package update can tell an outdated ' +
-  'copy from a local edit. Commit it; do not edit it.'
+// Where 4.34.0 kept the whole record, until the next write moves it.
+const LEGACY = 'sdkgen-copies.json'
+
+const IGNORED_LOG = '.sdk/.gitignore ignores log/, so .sdk/' + COPY_LOG +
+  ' is not committed and a fresh clone has no copy record. Delete the ' +
+  'log/ line.'
 
 
 type CopyItem = {
@@ -33,9 +37,15 @@ type CopyRecord = {
   files: Record<string, string>
 }
 
+// A null forgets the item or the file.
+type CopyEntry = {
+  items?: Record<string, CopyItem | null>
+  files?: Record<string, string | null>
+}
+
 
-function copiesPath(folder: string): string {
-  return Path.join(folder, COPIES)
+function logPath(folder: string): string {
+  return Path.join(folder, ...COPY_LOG.split('/'))
 }
 
 
@@ -53,38 +63,140 @@ function fingerprint(content: any): string {
 }
 
 
-// An unreadable record is treated as absent: every copy is then unrecorded,
-// which is exactly the state of a project from before the record existed.
+// Unreadable lines are skipped. A copy can then only lose its entry, which
+// leaves it unrecorded, as in a project from before the record existed.
 function readCopies(fs: any, folder: string): CopyRecord {
-  const empty: CopyRecord = { items: {}, files: {} }
-  const path = copiesPath(folder)
+  const record: CopyRecord = { items: {}, files: {} }
+  const log = logPath(folder)
+
+  const entries = fs.existsSync(log) ?
+    String(fs.readFileSync(log, 'utf8')).split('\n').map(parseEntry) :
+    [readLegacy(fs, folder)]
+
+  for (const entry of entries) {
+    if (null != entry) {
+      apply(record, entry)
+    }
+  }
+
+  return record
+}
+
+
+function parseEntry(line: string): CopyEntry | undefined {
+  if ('' === line.trim()) {
+    return undefined
+  }
+
+  try {
+    return JSON.parse(line) ?? undefined
+  }
+  catch (err: any) {
+    return undefined
+  }
+}
+
+
+function readLegacy(fs: any, folder: string): CopyEntry | undefined {
+  const path = Path.join(folder, LEGACY)
 
   if (!fs.existsSync(path)) {
-    return empty
+    return undefined
   }
 
   try {
     const read = JSON.parse(String(fs.readFileSync(path, 'utf8')))
-    return {
-      items: { ...(read?.items ?? {}) },
-      files: { ...(read?.files ?? {}) },
-    }
+    return { items: read?.items ?? {}, files: read?.files ?? {} }
   }
   catch (err: any) {
-    return empty
+    return undefined
+  }
+}
+
+
+function apply(record: CopyRecord, entry: CopyEntry) {
+  for (const [key, item] of Object.entries(entry.items ?? {})) {
+    if (null == item) {
+      delete record.items[key]
+    }
+    else {
+      record.items[key] = item
+    }
+  }
+
+  for (const [rel, print] of Object.entries(entry.files ?? {})) {
+    if (null == print) {
+      delete record.files[rel]
+    }
+    else {
+      record.files[rel] = print
+    }
+  }
+}
+
+
+// The only writer. An entry that changes nothing is not written, so an add
+// that rewrites identical copies leaves the log, and git, as they were.
+function appendEntry(actx: ActionContext, op: string, entry: CopyEntry) {
+  const fs = actx.fs()
+  const folder = actx.folder
+  const log = logPath(folder)
+  const legacy = Path.join(folder, LEGACY)
+  const fresh = !fs.existsSync(log)
+  const lines: string[] = []
+
+  if (fresh) {
+    const imported = readLegacy(fs, folder)
+    if (null != imported && changes(imported)) {
+      lines.push(entryLine('import', imported))
+    }
   }
+
+  if (changes(entry)) {
+    lines.push(entryLine(op, entry))
+  }
+
+  if (0 < lines.length) {
+    fs.mkdirSync(Path.dirname(log), { recursive: true })
+    fs.appendFileSync(log, lines.join('\n') + '\n')
+
+    if (fresh && ignoredLog(fs, folder)) {
+      actx.log.warn({ point: 'copies-ignored', note: IGNORED_LOG })
+    }
+  }
+
+  if (fs.existsSync(legacy)) {
+    fs.unlinkSync(legacy)
+  }
+}
+
+
+// The line every create-sdkgen scaffold wrote before the record moved into
+// log/. Only git knows every rule, so this finds that one, not all of them.
+function ignoredLog(fs: any, folder: string): boolean {
+  const path = Path.join(folder, '.gitignore')
+
+  return fs.existsSync(path) && String(fs.readFileSync(path, 'utf8'))
+    .split('\n').some((line: string) => /^\/?log(\/\*?)?$/.test(line.trim()))
+}
+
+
+function changes(entry: CopyEntry): boolean {
+  return 0 < Object.keys(entry.items ?? {}).length ||
+    0 < Object.keys(entry.files ?? {}).length
 }
 
 
-function writeCopies(fs: any, folder: string, record: CopyRecord) {
-  const sorted = (obj: Record<string, any>) => Object.fromEntries(
+function entryLine(op: string, entry: CopyEntry): string {
+  const sorted = (obj: Record<string, any> = {}) => Object.fromEntries(
     Object.keys(obj).sort().map((key: string) => [key, obj[key]]))
 
-  fs.writeFileSync(copiesPath(folder), JSON.stringify({
-    about: ABOUT,
-    items: sorted(record.items),
-    files: sorted(record.files),
-  }, null, 2) + '\n')
+  return JSON.stringify({
+    at: new Date().toISOString(),
+    op,
+    items: sorted(entry.items),
+    files: sorted(entry.files),
+  })
 }
 
 
@@ -139,49 +251,69 @@ function recordCopies(
   const folder = actx.folder
   const record = readCopies(fs, folder)
 
-  const files: string[] = [
+  const items: Record<string, CopyItem> = {}
+  const files: Record<string, string | null> = gone(fs, folder, record)
+
+  for (const source of sources) {
+    const key = itemKey(kind, source.name)
+    const item = provenanceOf(source)
+    const known = record.items[key]
+
+    if (null == known ||
+      known.package !== item.package || known.version !== item.version) {
+      items[key] = item
+    }
+  }
+
+  const written: string[] = [
     ...(jres.files.written ?? []), ...(jres.files.unchanged ?? []),
   ]
 
-  for (const abs of files) {
+  for (const abs of written) {
     const rel = relativeTo(folder, abs)
 
     if (null != rel && isCopy(rel) && fs.existsSync(abs)) {
-      record.files[rel] = fingerprint(fs.readFileSync(abs))
+      const print = fingerprint(fs.readFileSync(abs))
+      if (print !== record.files[rel]) {
+        files[rel] = print
+      }
     }
   }
 
-  for (const source of sources) {
-    record.items[itemKey(kind, source.name)] = provenanceOf(source)
-  }
-
-  pruneMissing(fs, folder, record)
-  writeCopies(fs, folder, record)
+  appendEntry(actx, 'add', { items, files })
 }
 
 
 // After a remove: the item goes, with every file entry nothing holds now.
 function forgetCopies(actx: ActionContext, kind: string, name: string) {
-  const fs = actx.fs()
-  const folder = actx.folder
-
-  if (true === actx.opts?.dryrun || !fs.existsSync(copiesPath(folder))) {
+  if (true === actx.opts?.dryrun) {
     return
   }
 
+  const fs = actx.fs()
+  const folder = actx.folder
   const record = readCopies(fs, folder)
-  delete record.items[itemKey(kind, name)]
-  pruneMissing(fs, folder, record)
-  writeCopies(fs, folder, record)
+  const key = itemKey(kind, name)
+
+  appendEntry(actx, 'remove', {
+    items: null == record.items[key] ? {} : { [key]: null },
+    files: gone(fs, folder, record),
+  })
 }
 
 
-function pruneMissing(fs: any, folder: string, record: CopyRecord) {
+function gone(
+  fs: any, folder: string, record: CopyRecord,
+): Record<string, null> {
+  const missing: Record<string, null> = {}
+
   for (const rel of Object.keys(record.files)) {
     if (!fs.existsSync(Path.join(folder, ...rel.split('/')))) {
-      delete record.files[rel]
+      missing[rel] = null
     }
   }
+
+  return missing
 }
 
 
@@ -207,8 +339,9 @@ export type {
 }
 
 export {
-  COPIES,
-  copiesPath,
+  COPY_LOG,
+  IGNORED_LOG,
+  ignoredLog,
   itemKey,
   fingerprint,
   readCopies,

package/src/action/doctor.ts

@@ -37,7 +37,9 @@ import { findFeatureSources } from '../helpers/featureSource'
 
 import { isJunk } from '../helpers/junk'
 
-import { readCopies, untouched, itemKey } from './copies'
+import {
+  readCopies, untouched, itemKey, ignoredLog, IGNORED_LOG,
+} from './copies'
 import type { CopyRecord } from './copies'
 
 
@@ -111,6 +113,9 @@ type DoctorReport = {
   // Per item with findings, keyed `<kind>/<name>`.
   byItem: Record<string, ItemDrift>
 
+  // `.sdk/.gitignore` hides the copy record from git. Informational.
+  ignoredLog: boolean
+
   ok: boolean
 }
 
@@ -278,11 +283,16 @@ async function doctor(
     forked: [], edited: [], stale: [], missing: [], additive: [],
     superseded: [], unwired: [], orphanModel: [],
     resyncPending: [], aliasedDiff: [],
-    outdated: [], unrecorded: [], byItem: {}, ok: true,
+    outdated: [], unrecorded: [], byItem: {}, ignoredLog: false, ok: true,
   }
 
   const copies = readCopies(fs, root)
 
+  report.ignoredLog = ignoredLog(fs, root)
+  if (report.ignoredLog) {
+    log.warn({ point: 'doctor-copies-ignored', note: IGNORED_LOG })
+  }
+
   report.superseded = supersededFiles(actx)
 
   report.orphanModel = orphanModelFiles(actx)
@@ -1074,7 +1084,7 @@ function copyWarnings(report: DoctorReport): string[] {
     }
   }
 
-  const lines: string[] = []
+  const lines: string[] = report.ignoredLog ? [IGNORED_LOG] : []
 
   for (const [key, group] of groups) {
     const [what, command] = key.split('\n')

package/src/action/package.ts

@@ -23,13 +23,16 @@ import type { Manifest, Finding } from '../helpers/manifest'
 
 import { satisfies } from '../helpers/semver'
 
+import { npmCommand } from '../helpers/npm'
+import type { NpmCommand, NpmHost } from '../helpers/npm'
+
 import { KINDS, kindDef } from './kind'
 
 import { cmd_package_check } from './check'
 
 import { doctor } from './doctor'
 
-import { COPIES } from './copies'
+import { COPY_LOG } from './copies'
 
 import { resolveSource, registerInstalled, nameConflict } from './resolve'
 import type { Source } from './resolve'
@@ -647,7 +650,8 @@ async function preCheck(
       point: 'package-update-outdated', package: pkgname,
       files: report.outdated.length,
       note: pkgname + ': ' + report.outdated.length + ' outdated file(s) ' +
-        'will be refreshed; ' + COPIES + ' shows nothing in them was changed'
+        'will be refreshed; .sdk/' + COPY_LOG + ' shows nothing in them ' +
+        'was changed'
     })
   }
 
@@ -675,10 +679,10 @@ async function preCheck(
     'source, so updating would overwrite them:\n  ' + changed.join('\n  ') +
     (0 === edited.length ? '' :
       '\n\n  ' + edited.length + ' of them changed in this project after ' +
-      'an add wrote them (' + COPIES + ' records what it wrote), so updating ' +
-      'would discard those edits.') +
+      'an add wrote them (.sdk/' + COPY_LOG + ' records what it wrote), so ' +
+      'updating would discard those edits.') +
     (0 === unknown.length ? '' :
-      '\n\n  ' + unknown.length + ' of them predate ' + COPIES + ', so ' +
+      '\n\n  ' + unknown.length + ' of them predate .sdk/' + COPY_LOG + ', so ' +
       'nothing tells these two apart:' +
       '\n    - they are LOCAL EDITS, and `--force` will discard them;' +
       '\n    - or ' + pkgname + ' was already updated out of band (an ' +
@@ -756,10 +760,8 @@ async function npmFetch(pkgname: string, actx: ActionContext) {
   })
 
   try {
-    const out = await run(
-      'win32' === process.platform ? 'npm.cmd' : 'npm',
-      npmFetchArgs(pkgname),
-      { cwd, maxBuffer: 64 * 1024 * 1024 })
+    const npm = npmFetchCommand(pkgname)
+    const out = await run(npm.file, npm.args, { cwd, maxBuffer: 64 * 1024 * 1024 })
 
     actx.log.debug({
       point: 'package-update-fetched', package: pkgname,
@@ -784,6 +786,11 @@ function npmFetchArgs(pkgname: string): string[] {
 }
 
 
+function npmFetchCommand(pkgname: string, host?: NpmHost): NpmCommand {
+  return npmCommand('npm', npmFetchArgs(pkgname), host)
+}
+
+
 function validateFetched(
   pkgname: string, installed: Installed[], actx: ActionContext,
 ) {
@@ -968,6 +975,7 @@ export {
   package_update,
   installedFrom,
   npmFetchArgs,
+  npmFetchCommand,
   resolvePackage,
   selectItems,
   parseAliases,

package/src/action/resolve.ts

@@ -310,6 +310,44 @@ function isBare(ref: string): boolean {
 }
 
 
+// Whether an item's recorded provenance leads back to this package's own
+// scaffold, read the way resolveSource reads the ref recordedRef rebuilds: a
+// bare ref resolves to BUNDLED, any other to the folder its directory names.
+function resolvesBundled(declared: any, name: string): boolean {
+  const ref = recordedRef(declared, name) ?? name
+  return isBare(ref) ||
+    BUNDLED === normaliseBase(Path.join(Path.dirname(ref), '.sdk'))
+}
+
+
+type TargetOrigins = {
+  bundled: string[]
+  external: { name: string, from: string }[]
+}
+
+
+function targetOrigins(model: any): TargetOrigins {
+  const targets = kindCollection(model, 'target')
+  const origins: TargetOrigins = { bundled: [], external: [] }
+
+  for (const name of Object.keys(targets).sort()) {
+    const target = targets[name]
+    if (null == target || 'object' !== typeof target || false === target.active) {
+      continue
+    }
+
+    if (resolvesBundled(target, name)) {
+      origins.bundled.push(name)
+    }
+    else {
+      origins.external.push({ name, from: normaliseBase(target.base) })
+    }
+  }
+
+  return origins
+}
+
+
 function normaliseBase(base: string): string {
   return Path.normalize(String(base ?? '')).split(Path.sep).join('/')
 }
@@ -322,12 +360,15 @@ function capitalise(s: string): string {
 
 export type {
   Source,
+  TargetOrigins,
 }
 
 export {
   resolveSource,
   recordedRef,
   isBare,
+  resolvesBundled,
+  targetOrigins,
   registerInstalled,
   nameConflict,
   lastSegment,

package/src/admin/npm-trust.ts

@@ -2,6 +2,8 @@
 
 import { spawnSync } from 'node:child_process'
 
+import { npmCommand } from '../helpers/npm'
+
 
 type Mode = 'setup' | 'check' | 'dry-run'
 
@@ -282,9 +284,9 @@ function npmFailure(action: string, stderr: string): string {
 
 // An npm without the command still exits 0 from `npm trust --help`, printing
 // "Unknown command", so only the usage text tells a capable npm apart.
-function trustCapableNpm(): string[] {
-  const shell = 'win32' === process.platform
-  const probe = spawnSync('npm', ['trust', '--help'], { encoding: 'utf8', shell })
+function trustCapableNpm(): ['npm'] | ['npx', ...string[]] {
+  const npm = npmCommand('npm', ['trust', '--help'])
+  const probe = spawnSync(npm.file, npm.args, { encoding: 'utf8' })
   return /npm trust github/.test(String(probe.stdout || '') + String(probe.stderr || '')) ?
     ['npm'] : ['npx', '--yes', 'npm@latest']
 }
@@ -293,18 +295,17 @@ function trustCapableNpm(): string[] {
 // A captured call has no terminal, so npm raises EOTP instead of prompting;
 // the mutating calls keep the terminal and can prompt.
 function npmPort(otp?: string): NpmPort {
-  const npm = trustCapableNpm()
-  const shell = 'win32' === process.platform
+  const [tool, ...lead] = trustCapableNpm()
   const otpArgs = null == otp ? [] : ['--otp', otp]
 
   const call = (args: string[], capture: boolean): string => {
-    const res = spawnSync(npm[0], [...npm.slice(1), ...args, ...otpArgs], {
+    const npm = npmCommand(tool, [...lead, ...args, ...otpArgs])
+    const res = spawnSync(npm.file, npm.args, {
       encoding: 'utf8',
       stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
-      shell,
     })
     if (null != res.error) {
-      throw new Error(`could not run ${npm[0]}: ${res.error.message}`)
+      throw new Error(`could not run ${tool}: ${res.error.message}`)
     }
     if (0 !== res.status) {
       throw new Error(npmFailure(`npm ${args.slice(0, 3).join(' ')}`, String(res.stderr || '')))

package/src/cmp/AgentGuide.ts

@@ -1,7 +1,8 @@
 
-import { cmp, Content, File } from 'jostraca'
+import { Content, File } from 'jostraca'
+import { cmp } from '../helpers/component'
 
-import { requirePath } from '../utility'
+import { optionalComponent } from '../helpers/optional'
 
 import {
   activeFeatures,
@@ -108,7 +109,7 @@ the runtime under \`.sdk/tm/${lang}/feature/\` and regenerate.
     }
 
     const AgentGuide_sdk =
-      requirePath(ctx$, `./cmp/${lang}/AgentGuide_${lang}`, { ignore: true })
+      optionalComponent(ctx$, target, 'AgentGuide')
     if (AgentGuide_sdk) {
       AgentGuide_sdk['AgentGuide']({ target })
     }