@signalridge/pi-workflows 1.7.5 → 1.9.0

package/src/ui.ts

@@ -1,252 +1,54 @@
-import type { ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
-import { DynamicBorder } from "@earendil-works/pi-coding-agent";
-import { Container, type SelectItem, SelectList, Text } from "@earendil-works/pi-tui";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { WorkflowEngine } from "./engine.js";
-import type { ScriptRun } from "./journal.js";
 import { sanitizeDisplayText } from "./safe-text.js";
-
-/** Bounds, in code points, for untrusted strings rendered into the navigator. */
-const MAX_NAME_CHARS = 200;
-const MAX_ID_CHARS = 128;
-const MAX_RESULT_CHARS = 300;
-const MAX_RUN_ERROR_CHARS = 500;
-const MAX_DESCRIPTION_CHARS = 120;
-
-/**
- * Pure snapshot render layer shared by the navigator, the live widget, and any
- * inline render site. All child-agent output passes through sanitizeDisplayText
- * BEFORE truncation so a live escape introducer is never cut mid-sequence.
- */
-export function snapshotRunLine(run: ScriptRun): string {
-  return formatWorkflowRunLabel(run);
-}
-
-/** Live-widget lines for all non-terminal runs (A10). */
-export function liveWidgetLines(
-  runs: readonly ScriptRun[],
-  mode: "compact" | "detailed" = "compact",
-  maxAgentsShown = 6,
-): string[] {
-  const active = runs.filter((run) => !isTerminal(run.status));
-  if (active.length === 0) return [];
-  const boundedMax = Math.max(1, Math.min(32, Math.floor(maxAgentsShown)));
-  const lines = ["Workflows"];
-  for (const run of active.slice(0, boundedMax)) {
-    lines.push(`  ${snapshotRunLine(run)}`);
-    if (mode === "detailed") {
-      for (const [nodeId, status] of Object.entries(run.callStatus).slice(0, boundedMax)) {
-        lines.push(`    ${nodeId}: ${status}`);
-      }
-    }
-  }
-  return lines.slice(0, 1 + boundedMax * (mode === "detailed" ? boundedMax + 1 : 1));
-}
-
-export type RunStatus = ScriptRun["status"];
-
-function elapsed(ms: number): string {
-  const seconds = Math.floor(ms / 1_000);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  return `${minutes}m ${seconds % 60}s`;
-}
-
-function isTerminal(status: RunStatus): boolean {
-  return status === "completed" || status === "failed" || status === "stopped";
-}
-
-export function formatWorkflowRunLabel(run: ScriptRun): string {
-  const phases = run.meta.phases && run.meta.phases.length > 0 ? ` · phases ${run.meta.phases.length}` : "";
-  const calls = Object.keys(run.callResults).length;
-  const name = sanitizeDisplayText(run.meta.name, MAX_NAME_CHARS);
-  return `${name} · ${run.status}${phases} · ${calls} calls · ${elapsed(Math.max(0, (isTerminal(run.status) ? run.updatedAt : Date.now()) - run.startedAt))}`;
-}
-
-export function formatWorkflowDetail(engine: WorkflowEngine, runId: string): string {
-  const state = engine.getState(runId);
-  if (!state) return "Workflow run is no longer available.";
-  const run = state.run;
-  const tokenValues = Object.values(run.callResults)
-    .map((result) => result.tokenCount)
-    .filter((value): value is number => value !== undefined);
-  const tokenCount = tokenValues.length > 0 ? tokenValues.reduce((total, value) => total + value, 0) : undefined;
-  const lines = [
-    `${sanitizeDisplayText(run.meta.name, MAX_NAME_CHARS)} [${run.status}]`,
-    `run: ${sanitizeDisplayText(run.runId, MAX_ID_CHARS)}`,
-    `elapsed: ${elapsed(Math.max(0, (isTerminal(run.status) ? run.updatedAt : Date.now()) - run.startedAt))}`,
-    "",
-    ...(tokenCount === undefined ? [] : [`tokens: ${tokenCount}`]),
-  ];
-  for (const phase of run.meta.phases ?? []) {
-    lines.push(`Phase: ${sanitizeDisplayText(phase.title, MAX_NAME_CHARS)}`);
-  }
-  const calls = Object.entries(run.callStatus)
-    .sort(([a], [b]) => Number(a) - Number(b))
-    .map(([nodeId, status]) => {
-      const result = run.callResults[nodeId];
-      const agent = run.agentIds[nodeId] ? ` agent=${sanitizeDisplayText(run.agentIds[nodeId], MAX_ID_CHARS)}` : "";
-      const compact = run.compactions[nodeId] ? ` compactions=${run.compactions[nodeId]}` : "";
-      const parts = [`  ${status.padEnd(11)} call ${sanitizeDisplayText(nodeId, MAX_ID_CHARS)}${agent}${compact}`];
-      if (result?.error) parts.push(`    error: ${sanitizeDisplayText(result.error, MAX_RESULT_CHARS)}`);
-      if (result?.result !== undefined && result.status === "completed") {
-        parts.push(`    result: ${sanitizeDisplayText(String(result.result), MAX_RESULT_CHARS)}`);
-      }
-      return parts.join("\n");
-    });
-  if (calls.length > 0) {
-    lines.push("Calls:");
-    lines.push(...calls);
-  }
-  lines.push("", "Live agent conversations remain available through pi-subagents FleetView.");
-  if (run.error) lines.push(`Error: ${sanitizeDisplayText(run.error, MAX_RUN_ERROR_CHARS)}`);
-  return lines.join("\n");
-}
-
-/** Actions the `/workflows` detail menu can offer, in display order. */
-export type WorkflowAction = "refresh" | "pause" | "resume" | "stop" | "back";
-
-export interface WorkflowActionItem {
-  value: WorkflowAction;
-  label: string;
-}
-
-const REFRESH: WorkflowActionItem = { value: "refresh", label: "Refresh" };
-const PAUSE: WorkflowActionItem = { value: "pause", label: "Pause" };
-const RESUME: WorkflowActionItem = { value: "resume", label: "Resume" };
-const STOP: WorkflowActionItem = { value: "stop", label: "Stop" };
-const BACK: WorkflowActionItem = { value: "back", label: "Back" };
-
-/**
- * Menu actions legal for a run in `status`. Exhaustive by construction.
- */
-export function workflowActionsFor(status: RunStatus): readonly WorkflowActionItem[] {
-  switch (status) {
-    case "pending":
-    case "pausing":
-    case "stopping":
-      return [REFRESH, STOP, BACK];
-    case "running":
-      return [REFRESH, PAUSE, STOP, BACK];
-    case "paused":
-    case "interrupted":
-      return [REFRESH, RESUME, STOP, BACK];
-    case "completed":
-    case "failed":
-    case "stopped":
-      return [REFRESH, BACK];
-  }
-  const unreachable: never = status;
-  return unreachable;
-}
-
-async function selectList<T>(
-  ctx: ExtensionCommandContext,
-  title: string,
-  items: SelectItem[],
-  renderExtra: (theme: Pick<Theme, "fg">) => string,
-): Promise<T | undefined> {
-  if (ctx.mode !== "tui") return undefined;
-  return ctx.ui.custom<T | undefined>((_tui, theme, _keybindings, done) => {
-    const container = new Container();
-    container.addChild(new DynamicBorder((s: string) => theme.fg("borderAccent", s)));
-    container.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
-    container.addChild(new Text(theme.fg("dim", renderExtra(theme)), 1, 0));
-    const list = new SelectList(items, Math.min(12, Math.max(1, items.length)), {
-      selectedPrefix: (text) => theme.fg("accent", text),
-      selectedText: (text) => theme.fg("accent", text),
-      description: (text) => theme.fg("muted", text),
-      scrollInfo: (text) => theme.fg("dim", text),
-      noMatch: (text) => theme.fg("warning", text),
-    });
-    list.onSelect = (item) => done(item.value as T);
-    list.onCancel = () => done(undefined);
-    container.addChild(list);
-    container.addChild(new Text(theme.fg("dim", "↑↓ select · enter confirm · esc back"), 1, 0));
-    container.addChild(new DynamicBorder((s: string) => theme.fg("borderAccent", s)));
-    return {
-      render: (width) => container.render(width),
-      invalidate: () => container.invalidate(),
-      handleInput: (data) => list.handleInput(data),
-    };
-  });
-}
-
-/** Interactive `/workflows` navigator. TUI-only by design. */
+import { WorkflowCommandCenter, type WorkflowNavigatorOptions } from "./ui-command-center.js";
+
+export type { WorkflowNavigatorOptions } from "./ui-command-center.js";
+export {
+  formatWorkflowDetail,
+  formatWorkflowRunLabel,
+  liveWidgetLines,
+  type RunStatus,
+  snapshotRunLine,
+  type WorkflowAction,
+  type WorkflowActionItem,
+  workflowActionsFor,
+} from "./ui-presentation.js";
+
+/** Live, explicitly opened `/workflows` command center. No headless TUI mounts. */
 export async function showWorkflowNavigator(
-  ctx: ExtensionCommandContext,
+  ctx: ExtensionContext,
   engineSource: WorkflowEngine | (() => WorkflowEngine),
+  options: WorkflowNavigatorOptions = {},
 ): Promise<void> {
-  if (ctx.mode !== "tui") {
+  if (ctx.mode !== "tui" || !ctx.hasUI) {
     ctx.ui.notify("/workflows requires TUI mode; use workflow_control for machine-readable access.", "warning");
     return;
   }
-  const resolveEngine = typeof engineSource === "function" ? engineSource : () => engineSource;
-  let inactiveNotified = false;
-  const currentEngine = (): WorkflowEngine | undefined => {
-    try {
-      return resolveEngine();
-    } catch (error: unknown) {
-      if (!inactiveNotified) {
-        inactiveNotified = true;
-        ctx.ui.notify(error instanceof Error ? error.message : String(error), "warning");
-      }
-      return undefined;
-    }
-  };
-  while (true) {
-    const engine = currentEngine();
-    if (!engine) return;
-    const states = engine
-      .list()
-      .map((summary) => engine.getRun(String(summary.runId)))
-      .filter((run): run is ScriptRun => run !== undefined)
-      .sort((a, b) => b.startedAt - a.startedAt);
-    const selected = await selectList<string>(
-      ctx,
-      "Workflow runs",
-      states.map((run) => ({
-        value: run.runId,
-        label: formatWorkflowRunLabel(run),
-        description: run.error === undefined ? undefined : sanitizeDisplayText(run.error, MAX_DESCRIPTION_CHARS),
-      })),
-      (theme) =>
-        states.length > 0
-          ? theme.fg("dim", "Select a run to inspect.")
-          : theme.fg("muted", "No workflow runs in this session."),
+  const source = typeof engineSource === "function" ? engineSource : () => engineSource;
+  let component: WorkflowCommandCenter | undefined;
+  try {
+    const sessionId = ctx.sessionManager.getSessionId();
+    await ctx.ui.custom<void>(
+      (tui, theme, keys, done) => {
+        component = new WorkflowCommandCenter(
+          tui,
+          theme,
+          keys,
+          source,
+          () => ctx.sessionManager.getSessionId() === sessionId,
+          done,
+          (message) => ctx.ui.notify(message, "error"),
+          options,
+        );
+        return component;
+      },
+      { overlay: true, overlayOptions: { anchor: "center", width: "100%", maxHeight: "100%", margin: 0 } },
     );
-    if (!selected) return;
-    while (true) {
-      const latest = currentEngine();
-      if (!latest) return;
-      const run = latest.getRun(selected);
-      if (!run) break;
-      const name = sanitizeDisplayText(run.meta.name, MAX_NAME_CHARS);
-      const action = await selectList<WorkflowAction>(
-        ctx,
-        `${name} · ${run.status}`,
-        workflowActionsFor(run.status).map((item) => ({
-          value: item.value,
-          label: item.label,
-        })),
-        () => {
-          const current = currentEngine();
-          return current ? formatWorkflowDetail(current, selected) : "Workflow surface is no longer active.";
-        },
-      );
-      if (action === undefined || action === "back") break;
-      if (action === "refresh") continue;
-      if (action === "stop") {
-        const confirmed = await ctx.ui.confirm("Stop workflow", `Stop ${name}? The run will be non-resumable.`);
-        if (!confirmed) continue;
-      }
-      try {
-        const current = currentEngine();
-        if (!current) return;
-        await current.control(action, selected);
-        ctx.ui.notify(`Workflow ${action} requested.`, "info");
-      } catch (error: unknown) {
-        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-      }
-    }
+  } catch (error: unknown) {
+    ctx.ui.notify(sanitizeDisplayText(error instanceof Error ? error.message : String(error), 500), "error");
+  } finally {
+    // Also covers external cancellation or custom() rejection before TUI disposal.
+    component?.dispose();
   }
 }

package/src/vm-bootstrap.ts

@@ -0,0 +1,218 @@
+/** Plain JavaScript bootstrap: no loader, package imports or SDK in the helper. */
+export const VM_BOOTSTRAP = `
+'use strict';
+const vm = require('node:vm');
+const { AsyncLocalStorage, createHook } = require('node:async_hooks');
+const scope = new AsyncLocalStorage();
+const contexts = new Map();
+const localPromises = new Map();
+let rootReturned = false;
+// Only unresolved promises hold local continuation authority. Never retain the
+// promise object itself (GC may destroy an abandoned promise), timers, or a
+// historical async-id pool. Caps are separate from pending callback/RPC limits.
+createHook({
+  init(id,type) {
+    const context = scope.getStore();
+    if (type !== 'PROMISE' || !context || context.released) return;
+    if (localPromises.size >= 65536) throw new Error('workflow local promise limit exceeded');
+    localPromises.set(id,context); context.promises.add(id);
+  },
+  promiseResolve: settlePromise,
+  destroy: settlePromise,
+}).enable();
+function settlePromise(id) {
+  const context = localPromises.get(id);
+  if (!context) return;
+  localPromises.delete(id); context.promises.delete(id);
+  releaseScope(context);
+}
+const callbacks = new Map();
+const callbackIds = new WeakMap();
+const waiting = new Map();
+const scriptErrors = new WeakSet();
+const nativeErrors = new WeakSet();
+let realm;
+function isScriptThrow(value) { return scriptErrors.has(value) || (!(value instanceof Error) && !nativeErrors.has(value)); }
+function thrown(value) { return {value:encode(value),scriptError:isScriptThrow(value),errorText:String(value).slice(0,65536)}; }
+function invalidResult(message) { const error = new Error(message); error.name='WorkflowError'; error.code='SCRIPT_VALIDATION_ERROR'; error.recoverable=false; return error; }
+let sequence = 0, callbackSequence = 0, sent = 0, queuedBytes = 0, logBytes = 0;
+let spent = 0, total = null;
+const MAX_BYTES = 4 * 1024 * 1024;
+function send(message) {
+  const bytes = Buffer.byteLength(JSON.stringify(message));
+  if (bytes > MAX_BYTES || (message.type !== 'heartbeat' && ++sent > 100000) || queuedBytes + bytes > 8 * MAX_BYTES)
+    throw new Error('workflow helper IPC/backpressure limit exceeded');
+  queuedBytes += bytes;
+  process.send(message, error => { queuedBytes -= bytes; if (error) process.exit(1); });
+}
+function encode(value) {
+  const seen = new Map(); let nodes = 0;
+  function visit(v, depth) {
+    if (++nodes > 100000 || depth > 64) throw new Error('workflow intermediate value exceeds IPC limits');
+    if (v === undefined) return ['u'];
+    if (v === null || typeof v === 'string' || typeof v === 'boolean') return ['v', v];
+    if (typeof v === 'number') return ['n', String(v)];
+    if (typeof v === 'bigint') return ['b', String(v)];
+    if (typeof v === 'function') {
+      let id = callbackIds.get(v);
+      if (!id) { if (callbacks.size >= 8192) throw new Error('workflow callback limit exceeded');
+        id = ++callbackSequence; callbackIds.set(v, id); callbacks.set(id, v); }
+      return ['f', id];
+    }
+    if (typeof v !== 'object') throw new Error('unsupported workflow intermediate value');
+    if (seen.has(v)) return ['r', seen.get(v)];
+    const id = seen.size; seen.set(v, id);
+    const tag = Object.prototype.toString.call(v);
+    if (tag === '[object Date]') return ['d', id, v.toISOString()];
+    if (tag === '[object RegExp]') return ['x', id, v.source, v.flags];
+    if (tag === '[object Map]') return ['m', id, [...v].map(([k, x]) => [visit(k, depth + 1), visit(x, depth + 1)])];
+    if (tag === '[object Set]') return ['s', id, [...v].map(x => visit(x, depth + 1))];
+    if (Array.isArray(v)) return ['a', id, Array.from({length:v.length},(_,i)=>Object.hasOwn(v,i) ? visit(v[i],depth+1) : ['h'])];
+    if (tag.endsWith('Error]')) return ['e', id, visit({name:String(v.name), message:String(v.message), code:v.code,
+      recoverable:v.recoverable, agentLabel:v.agentLabel, resetHint:v.resetHint}, depth + 1),isScriptThrow(v)];
+    return ['o', id, Object.keys(v).map(k => [k, visit(v[k], depth + 1)])];
+  }
+  return visit(value, 0);
+}
+function decode(wire) {
+  const refs = new Map();
+  function visit(w) {
+    const [tag, id, data, flags] = w;
+    if (tag === 'u') return undefined;
+    if (tag === 'v') return id;
+    if (tag === 'n') return Number(id);
+    if (tag === 'b') return BigInt(id);
+    if (tag === 'r') return refs.get(id);
+    if (tag === 'f') { const fn = callbacks.get(id); if (!fn) throw new Error('invalid returned workflow callback identity'); return fn; }
+    let value;
+    if (tag === 'a') value = new realm.Array();
+    else if (tag === 'm') value = new realm.Map();
+    else if (tag === 's') value = new realm.Set();
+    else if (tag === 'd') value = new realm.Date(data);
+    else if (tag === 'x') value = new realm.RegExp(data, flags);
+    else if (tag === 'e') value = new realm.Error();
+    else if (tag === 'o') value = new realm.Object();
+    else throw new Error('invalid parent workflow value');
+    refs.set(id, value);
+    if (tag === 'a') for (const x of data) { if (Array.isArray(x) && x.length === 1 && x[0] === 'h') value.length++; else value.push(visit(x)); }
+    if (tag === 'm') for (const [k,x] of data) value.set(visit(k),visit(x));
+    if (tag === 's') for (const x of data) value.add(visit(x));
+    if (tag === 'o') for (const [k,x] of data) Object.defineProperty(value,k,{value:visit(x),writable:true,enumerable:true,configurable:true});
+    if (tag === 'e') {
+      const fields = visit(data);
+      const ctor = Object.hasOwn(realm.errors,fields.name) ? realm.errors[fields.name] : realm.Error;
+      Object.setPrototypeOf(value, ctor.prototype);
+      Object.assign(value, fields);
+      if (flags) scriptErrors.add(value); else nativeErrors.add(value);
+    }
+    return value;
+  }
+  return visit(wire);
+}
+function retireScope(context) {
+  if (context.released) return;
+  context.released = true;
+  contexts.delete(context.id);
+  for (const id of context.promises) localPromises.delete(id);
+  context.promises.clear();
+  send({type:'scopeReleased',id:context.id});
+}
+function releaseScope(context) {
+  if (!context || !context.settled || context.pending || context.releasing || context.released) return;
+  if (!rootReturned && context.promises.size) return;
+  context.releasing = true;
+  // Promise settlement precedes its reactions. Let those reactions post their
+  // RPCs, then recheck real credits. A local unresolved await is credited for
+  // the entire running root, not guessed to have resumed after one I/O turn.
+  setImmediate(() => {
+    context.releasing = false;
+    if (context.pending || context.released || (!rootReturned && context.promises.size)) return;
+    retireScope(context);
+  });
+}
+function closeRootAdmission() {
+  rootReturned = true;
+  // At the root boundary only accepted native work (or its unsettled callback)
+  // carries descendant authority. Ignored, purely local promises cannot keep
+  // the helper alive or mint post-root admission. Release BEFORE root result.
+  for (const context of contexts.values()) {
+    if (context.settled && !context.pending) retireScope(context);
+  }
+}
+function rpc(name, args) {
+  if (waiting.size >= 8192) throw new Error('workflow IPC request limit exceeded');
+  const id = ++sequence;
+  const context = scope.getStore();
+  const promise = new Promise((resolve,reject) => {
+    if (context) context.pending++;
+    waiting.set(id,{resolve,reject,context});
+    try { send({type:'call',id,name,args:encode(args),scope:context?.id}); }
+    catch (error) {
+      waiting.delete(id);
+      if (context) { context.pending--; releaseScope(context); }
+      reject(error);
+    }
+  });
+  // Native helpers already own ignored-call dispositions. Observe the original
+  // RPC promise without changing what author await/catch sees (strict Node).
+  void promise.catch(() => {});
+  return promise;
+}
+function notify(name,args) {
+  const context = scope.getStore();
+  send({type:'notify',name,args:encode(args),scope:context?.id});
+}
+process.on('disconnect', () => process.exit(0));
+process.on('message', message => {
+  if (message.type === 'response') {
+    spent = message.spent;
+    const waiter = waiting.get(message.id); if (!waiter) return;
+    waiting.delete(message.id);
+    try { const value = decode(message.value); if (!message.ok && message.scriptError && value && (typeof value === 'object' || typeof value === 'function')) scriptErrors.add(value); message.ok ? waiter.resolve(value) : waiter.reject(value); }
+    catch (error) { waiter.reject(error); }
+    finally {
+      if (waiter.context) { waiter.context.pending--; releaseScope(waiter.context); }
+    }
+  } else if (message.type === 'callback') {
+    const callback = callbacks.get(message.callback);
+    if (!callback) return process.exit(1);
+    if (contexts.size >= 16384) throw new Error('workflow live execution context limit exceeded');
+    const context = {id:message.id,pending:0,promises:new Set(),settled:false,releasing:false,released:false};
+    contexts.set(context.id,context);
+    scope.run(context, async () => {
+      try { send({type:'callbackResult',id:message.id,ok:true,value:encode(await callback(...decode(message.args)))}); }
+      catch (error) { send({type:'callbackResult',id:message.id,ok:false,...thrown(error)}); }
+      finally { context.settled = true; releaseScope(context); }
+    });
+  } else if (message.type === 'start') {
+    total = message.total; spent = message.spent;
+    const globals = {};
+    for (const name of message.names) globals[name] = (...args) => rpc(name,args);
+    globals.log = value => { const text = String(value); logBytes += Buffer.byteLength(text); if (text.length > 65536 || logBytes > 1024 * 1024) throw new Error('workflow log limit exceeded (64KiB per entry, 1MiB per frame)'); notify('log',[text]); };
+    globals.phase = (title,options) => {
+      if (typeof title !== 'string' || title.length > 4096) throw new TypeError('phase title must be a string of at most 4096 characters');
+      if (options !== undefined && (options === null || typeof options !== 'object' || Array.isArray(options))) throw new TypeError('phase options must be an object');
+      notify('phase',[title,options]);
+    };
+    globals.console = {log:globals.log,info:globals.log,warn:v=>globals.log('[warn] '+String(v)),error:v=>globals.log('[error] '+String(v))};
+    globals.cwd = message.cwd;
+    globals.process = Object.freeze({cwd:()=>message.cwd});
+    globals.budget = Object.freeze({total,spent:()=>spent,remaining:()=>total === null ? Infinity : Math.max(0,total-spent)});
+    const context = vm.createContext(globals);
+    realm = vm.runInContext('({Array,Object,Map,Set,Date,RegExp,Error,errors:{Error,TypeError,RangeError,SyntaxError,ReferenceError,URIError,EvalError,AggregateError}})',context);
+    globals.args = decode(message.args);
+    Promise.resolve().then(() => new vm.Script(message.script,{filename:message.filename}).runInContext(context,{timeout:1000}))
+      .then(result => {
+        try {
+          const serialized = JSON.stringify(result);
+          if (result !== undefined && serialized === undefined) throw new Error('workflow result is not JSON-serializable');
+          const value = encode(serialized === undefined ? undefined : JSON.parse(serialized));
+          closeRootAdmission();
+          send({type:'result',ok:true,value});
+        } catch (error) { throw invalidResult('workflow result is not JSON-serializable: '+error.message); }
+      }).catch(error => send({type:'result',ok:false,...thrown(error)}));
+  }
+});
+setInterval(() => send({type:'heartbeat'}),100).unref();
+send({type:'ready'});
+`;