@inhuman.tools/scheme-program 0.0.0-stage → 0.1.0

package/src/file-path.ts

@@ -0,0 +1,27 @@
+/**
+ * Path stamp on a `read_file` string. Identity-keyed: substring/append mint a
+ * new `AString` and drop it. `withProvenance` clones the same box — copy the
+ * stamp onto the clone. Not provenance.
+ */
+import { AString } from "@here.build/arrival/reflect-internals";
+
+const paths = new WeakMap<AString, string>();
+
+const originalWithProvenance = AString.prototype.withProvenance;
+Object.defineProperty(AString.prototype, "withProvenance", {
+  value(this: AString, p: ReadonlySet<number>) {
+    const next = originalWithProvenance.call(this, p);
+    const path = paths.get(this);
+    if (path !== undefined && next instanceof AString) paths.set(next, path);
+    return next;
+  },
+});
+
+export function stampFilePath(value: AString, path: string): AString {
+  paths.set(value, path);
+  return value;
+}
+
+export function filePathOf(value: unknown): string | undefined {
+  return value instanceof AString ? paths.get(value) : undefined;
+}

package/src/host.ts

@@ -0,0 +1,57 @@
+import type { EnvCapability } from "@here.build/arrival";
+import type { EvalTrace } from "@here.build/arrival/provenance";
+import type { AgentCallNotification, ApprovableJob, ProgrammaticJob } from "@inhuman.tools/harness-model";
+import type { BoundTool } from "@inhuman.tools/substrate/bound-tool";
+import type { DoorSession } from "@inhuman.tools/substrate/doors";
+
+export type PreparedProgram = {
+  readonly capabilities: readonly EnvCapability[];
+  readonly config: object;
+};
+
+/**
+ * What the interpreter needs from an engine. Catalog, secrets, and tool bodies
+ * stay in the capabilities `prepare` returns. This package does not look them up.
+ */
+export type ProgramHost = {
+  /** Stable across wrappers. The runtime map keys on this, not on the wrapper. */
+  readonly identity: object;
+  readonly signal?: AbortSignal;
+  readonly doors: DoorSession;
+  readonly root: string;
+  readonly abort?: (leaf: ApprovableJob, reason?: unknown) => void;
+  readonly notify?: (note: AgentCallNotification) => void;
+  readonly evalProgram?: boolean;
+  readonly moduleRoot?: string;
+  /**
+   * Wraps one run of the program (the whole one-shot, or one period tick) so the host owns its trace.
+   * The host mints the trace, arms what it reads, and reads it as the run goes; when `run` settles, the run is over.
+   */
+  readonly observe?: <T>(run: (trace: EvalTrace) => Promise<T>) => Promise<T>;
+  /** Unbound-variable door. Called per evaluation; `prepare` snapshots tools onto config separately. */
+  readonly tools: () => ReadonlyMap<string, BoundTool>;
+  /** Engine vocabulary. The interpreter appends display. The watchdog wraps this to append meta-reactivity. */
+  readonly prepare: (opts: {
+    readonly moduleRoot: string | undefined;
+    readonly job: ProgrammaticJob;
+  }) => PreparedProgram;
+  /** Read recorded children. Do not mint, do not append notes, do not seal the job. */
+  readonly replayOnly?: boolean;
+};
+
+export type ProgramRuntime = {
+  arm(opts: {
+    readonly moduleRoot: string | undefined;
+    /** Accepted so existing arm calls typecheck. The watchdog roots meta-reactivity by wrapping prepare. */
+    readonly watching?: boolean;
+  }): void;
+  beginTick(tick: {
+    readonly signal: AbortSignal;
+    readonly origin: number;
+    readonly maxInternalCalls: number | undefined;
+  }): void;
+  clearFailure(): void;
+  failureCode(): string | undefined;
+  readonly capabilities: readonly EnvCapability[];
+  readonly config: object;
+};

package/src/index.ts

@@ -0,0 +1,8 @@
+export { appendNotify, failureCodeOf, SchemeReplToolFailure } from "./failure.js";
+export { filePathOf, stampFilePath } from "./file-path.js";
+export { type ProgramHost, type ProgramRuntime } from "./host.js";
+export { SCHEME_REPL_DISPLAY_NOTE } from "./notes.js";
+export { replayEvaluation } from "./replay-eval.js";
+export { runProgram } from "./run.js";
+export { detachedRuntime, programRuntimeOf } from "./runtime.js";
+export { recordedModuleLoader } from "./source.js";

package/src/notes.ts

@@ -0,0 +1,15 @@
+import type { TopLevelSplice } from "@inhuman.tools/substrate/unwrap-begin";
+
+/** Own tool text part per spliced wrapper spelling. Not a statement value. */
+export const SCHEME_REPL_UNWRAP_NOTES = {
+  begin: ";; unwrapped (begin …): each statement is returned as its own result. Write consecutive top-level forms.",
+  list: ";; unwrapped (list …): each statement is returned as its own result. Write consecutive top-level forms.",
+  vector: ";; unwrapped []: each statement is returned as its own result. Write consecutive top-level forms.",
+} as const satisfies Record<TopLevelSplice, string>;
+
+/** Attached to a top-level statement that was a `(display X)` — the rewrite unwrapped it to X and
+ *  X's value IS the answer block, so this teaches that the display spelling was unnecessary:
+ *  scheme_repl already returns each top-level statement as its own tool response. scheme_watch is
+ *  repl-only and does not surface per-statement responses, so it does not attach this note. */
+export const SCHEME_REPL_DISPLAY_NOTE =
+  ";; you do not need to use (display ...) — each top-level statement of scheme_repl is written as a tool response";

package/src/open.ts

@@ -0,0 +1,73 @@
+import { parse, type SchemeValue } from "@here.build/arrival";
+import { ProgrammaticJob, periodMsOf, SCHEME_REPL_NAMING, SCHEME_REPL_TOOL_NAME } from "@inhuman.tools/harness-model";
+import { emptyExprDoor, isUnterminatedDictLiteral, unterminatedDictDoor } from "@inhuman.tools/substrate/doors";
+import { type TopLevelSplice, unwrapTopLevel } from "@inhuman.tools/substrate/unwrap-begin";
+
+import { errorText, fail, sealChunk } from "./evaluate.js";
+import type { ProgramHost } from "./host.js";
+import { moduleRootOf, programSourceOf, type ProgramSource } from "./source.js";
+
+export type OpenedProgram = {
+  readonly forms: readonly SchemeValue[];
+  readonly kinds: readonly TopLevelSplice[];
+  readonly timeoutMs: number | undefined;
+  readonly maxInternalCalls: number | undefined;
+  readonly periodMs: number | undefined;
+  readonly source: ProgramSource;
+  /** Jail root for a one-shot, including `sourcePath`'s directory. */
+  readonly moduleRoot: string | undefined;
+};
+
+function cappedCalls(value: number | undefined): number | undefined {
+  if (value == null) return undefined;
+  if (!Number.isFinite(value)) return 1;
+  return Math.max(1, Math.floor(value));
+}
+
+/** Schema already accepted. Seals empty expr, a source without a path, and a program that does not parse. */
+export async function openProgram(
+  chunk: ProgrammaticJob,
+  host: ProgramHost,
+  data: {
+    readonly expr: string;
+    readonly timeoutMs?: number;
+    readonly maxInternalCalls?: number;
+    readonly period?: string;
+  },
+  seal = true,
+): Promise<OpenedProgram | undefined> {
+  const refuse = (result: Parameters<typeof sealChunk>[1]): undefined => {
+    if (seal) sealChunk(chunk, result);
+    return undefined;
+  };
+  if (data.expr.trim() === "") {
+    return refuse(fail(host.doors.render(emptyExprDoor(SCHEME_REPL_NAMING), SCHEME_REPL_TOOL_NAME)));
+  }
+  const source = programSourceOf(chunk.args, host.evalProgram === true);
+  if (source.source != null && source.sourcePath == null) {
+    return refuse(fail("Error: source requires sourcePath"));
+  }
+  let forms: readonly SchemeValue[];
+  let kinds: readonly TopLevelSplice[] = [];
+  try {
+    const unwrapped = unwrapTopLevel(await parse(data.expr));
+    forms = unwrapped.forms;
+    kinds = unwrapped.kinds;
+  } catch (error) {
+    const text = errorText(error);
+    if (isUnterminatedDictLiteral(text)) {
+      return refuse(fail(host.doors.render(unterminatedDictDoor(), SCHEME_REPL_TOOL_NAME)));
+    }
+    return refuse(fail(text));
+  }
+  const periodMs = typeof data.period === "string" ? periodMsOf(data.period) : undefined;
+  return {
+    forms,
+    kinds,
+    timeoutMs: data.timeoutMs,
+    maxInternalCalls: cappedCalls(data.maxInternalCalls),
+    periodMs,
+    source,
+    moduleRoot: moduleRootOf(source.sourcePath, host.moduleRoot, host.root),
+  };
+}

package/src/replay-eval.ts

@@ -0,0 +1,84 @@
+/**
+ * Re-run a program against the children it already minted. Does not seal the
+ * job, does not append notes, and does not move the watch cursor.
+ */
+import { parse } from "@here.build/arrival";
+import type { EvalTrace } from "@here.build/arrival/provenance";
+import { crossingEpoch, crossingOriginAfter, ProgrammaticJob } from "@inhuman.tools/harness-model";
+import { callArgsSchema } from "@inhuman.tools/harness-model/schemas";
+import { unwrapTopLevelBegins } from "@inhuman.tools/substrate/unwrap-begin";
+import { when } from "mobx";
+
+import { evaluateForms, observed, type SharedEval } from "./evaluate.js";
+import type { ProgramHost } from "./host.js";
+import { openProgram, type OpenedProgram } from "./open.js";
+import { detachedRuntime, type ProgramRuntime } from "./runtime.js";
+
+async function once(
+  job: ProgrammaticJob,
+  host: ProgramHost,
+  opened: OpenedProgram,
+  runtime: ProgramRuntime,
+  trace: EvalTrace | undefined,
+): Promise<void> {
+  const limits = { timeoutMs: undefined, maxInternalCalls: opened.maxInternalCalls, trace };
+  const sourceText = opened.source.source;
+  if (sourceText == null) {
+    await evaluateForms(job, host, opened.forms, { kind: "once", ...limits }, runtime);
+    return;
+  }
+  const sourceForms = unwrapTopLevelBegins(await parse(sourceText));
+  const shared: SharedEval = { signal: host.signal ?? new AbortController().signal };
+  const loaded = await evaluateForms(job, host, sourceForms, { kind: "source-load", ...limits, shared }, runtime);
+  if (loaded.kind !== "ok") return;
+  await evaluateForms(job, host, opened.forms, { kind: "source-body", ...limits, shared }, runtime);
+}
+
+async function periods(
+  job: ProgrammaticJob,
+  host: ProgramHost,
+  opened: OpenedProgram,
+  runtime: ProgramRuntime,
+  trace: EvalTrace | undefined,
+): Promise<void> {
+  const limits = { timeoutMs: undefined, maxInternalCalls: opened.maxInternalCalls, trace };
+  let origin = 0;
+  while (host.signal?.aborted !== true) {
+    if ((job.completed || job.cancelled) && origin >= job.toolCalls.length) return;
+    const before = job.toolCalls.length;
+    const epoch = crossingEpoch(job, origin);
+    await evaluateForms(job, host, opened.forms, { kind: "period", tick: { origin }, ...limits }, runtime);
+    const next = crossingOriginAfter(job, origin, epoch);
+    if (next > origin) {
+      origin = next;
+      continue;
+    }
+    if (job.completed || job.cancelled || before < job.toolCalls.length) return;
+    const joined = when(
+      () => host.signal?.aborted === true || job.completed || job.cancelled || job.toolCalls.length > before,
+    );
+    try {
+      await joined;
+    } finally {
+      joined.cancel();
+    }
+    if (job.toolCalls.length === before) return;
+  }
+}
+
+export async function replayEvaluation(job: ProgrammaticJob, host: ProgramHost, trace: EvalTrace): Promise<void> {
+  const parsed = callArgsSchema.safeParse(job.args);
+  if (!parsed.success) return;
+  const opened = await openProgram(job, host, parsed.data, false);
+  if (opened == null) return;
+  const runtime = detachedRuntime(job, host);
+  runtime.arm({ watching: opened.periodMs != null, moduleRoot: opened.moduleRoot });
+  await observed(host, async (live) => {
+    const tap = live ?? trace;
+    if (opened.periodMs == null) {
+      await once(job, host, opened, runtime, tap);
+      return;
+    }
+    await periods(job, host, opened, runtime, tap);
+  });
+}

package/src/run.ts

@@ -0,0 +1,103 @@
+/**
+ * One-shot Scheme program. The host passes the vocabulary. `period` is rejected
+ * here; ongoing evaluation is the watchdog.
+ */
+import { parse, type SchemeValue } from "@here.build/arrival";
+import { ProgrammaticJob } from "@inhuman.tools/harness-model";
+import { callArgsSchema, REPL_PERIOD_ERR } from "@inhuman.tools/harness-model/schemas";
+import { unwrapTopLevelBegins } from "@inhuman.tools/substrate/unwrap-begin";
+
+import {
+  createEvaluationTimeout,
+  displayPrinted,
+  errorText,
+  evaluateForms,
+  fail,
+  guardProgram,
+  observed,
+  printedValues,
+  sealChunk,
+  type EvalOutcome,
+  type SharedEval,
+} from "./evaluate.js";
+import type { ProgramHost } from "./host.js";
+import { openProgram } from "./open.js";
+import { programRuntimeOf } from "./runtime.js";
+
+function rawHasPeriod(raw: unknown): boolean {
+  return raw !== null && typeof raw === "object" && "period" in raw;
+}
+
+export async function runProgram(chunk: ProgrammaticJob, host: ProgramHost): Promise<void> {
+  await guardProgram(chunk, host, async () => {
+    const rawArgs = chunk.args;
+    if (rawHasPeriod(rawArgs)) {
+      sealChunk(chunk, fail(`Error: ${REPL_PERIOD_ERR}`));
+      return;
+    }
+    const parsed = callArgsSchema.safeParse(rawArgs);
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0]?.message ?? "invalid arguments";
+      sealChunk(chunk, fail(`Error: ${issue}`));
+      return;
+    }
+    const opened = await openProgram(chunk, host, parsed.data);
+    if (opened == null) return;
+
+    const runtime = programRuntimeOf(chunk, host);
+    runtime.arm({ watching: false, moduleRoot: opened.moduleRoot });
+    const sourceText = opened.source.source;
+    let sourceForms: readonly SchemeValue[] | undefined;
+    if (sourceText != null) {
+      try {
+        sourceForms = unwrapTopLevelBegins(await parse(sourceText));
+      } catch (error) {
+        sealChunk(chunk, fail(errorText(error)));
+        return;
+      }
+    }
+    const limits = { timeoutMs: opened.timeoutMs, maxInternalCalls: opened.maxInternalCalls };
+    const outcome: EvalOutcome = await observed(host, async (trace) => {
+      if (sourceForms === undefined) {
+        return evaluateForms(chunk, host, opened.forms, { kind: "once", ...limits, trace }, runtime);
+      }
+      const timeout = createEvaluationTimeout(host.signal, opened.timeoutMs);
+      const shared: SharedEval = { signal: timeout.signal };
+      try {
+        const loaded = await evaluateForms(
+          chunk,
+          host,
+          sourceForms,
+          { kind: "source-load", ...limits, shared, trace },
+          runtime,
+        );
+        return loaded.kind === "ok"
+          ? await evaluateForms(chunk, host, opened.forms, { kind: "source-body", ...limits, shared, trace }, runtime)
+          : loaded;
+      } finally {
+        timeout.dispose();
+      }
+    });
+    if (outcome.kind === "park") return;
+    if (outcome.kind === "halt") {
+      sealChunk(chunk, outcome.result);
+      return;
+    }
+    if (outcome.kind === "fail") {
+      sealChunk(chunk, fail(outcome.values.map(displayPrinted).join("\n\n"), outcome.code));
+      return;
+    }
+    const sealed: {
+      ok: true;
+      value: ReturnType<typeof printedValues>;
+      json?: unknown;
+      jsonError?: string;
+    } = {
+      ok: true,
+      value: printedValues(outcome.values, opened.kinds),
+    };
+    if (outcome.jsonError != null) sealed.jsonError = outcome.jsonError;
+    else if ("json" in outcome) sealed.json = outcome.json;
+    sealChunk(chunk, sealed);
+  });
+}

package/src/runtime.ts

@@ -0,0 +1,99 @@
+import { EnvCapability } from "@here.build/arrival";
+import type { ProgrammaticJob } from "@inhuman.tools/harness-model";
+import { DISPLAY_INTERNAL, displaySymbol } from "@inhuman.tools/substrate";
+import invariant from "tiny-invariant";
+
+import type { PreparedProgram, ProgramHost, ProgramRuntime } from "./host.js";
+
+type ReplRig = {
+  signal: AbortSignal;
+  origin: number;
+  replayAt: number;
+  /** toolCalls length at the start of the current top-level statement. */
+  formAt: number;
+  maxInternalCalls: number | undefined;
+  failureCode: string | undefined;
+};
+
+/** `(display …)` is a host verb. Arrival has no IO; the runner rewrites the call onto this symbol. */
+const displayCapability = EnvCapability.define("harness/scheme-repl-display", {
+  symbols: () => ({
+    [DISPLAY_INTERNAL]: displaySymbol(),
+  }),
+});
+
+const runtimes = new WeakMap<
+  ProgrammaticJob,
+  { readonly identity: object; readonly signal?: AbortSignal; readonly runtime: ProgramRuntime }
+>();
+
+function runtimeFor(job: ProgrammaticJob, host: ProgramHost): ProgramRuntime {
+  const rig: ReplRig = {
+    signal: new AbortController().signal,
+    origin: 0,
+    replayAt: 0,
+    formAt: 0,
+    maxInternalCalls: undefined,
+    failureCode: undefined,
+  };
+  let armed: PreparedProgram | undefined;
+  const view = (): PreparedProgram => {
+    if (armed === undefined) throw new Error("scheme-repl: arm the runtime before evaluating");
+    return armed;
+  };
+  const runtime: ProgramRuntime = {
+    arm(opts) {
+      if (armed !== undefined) return;
+      const prepared = host.prepare({ moduleRoot: opts.moduleRoot, job });
+      armed = {
+        capabilities: [...prepared.capabilities, displayCapability],
+        config: { ...prepared.config, job, rig },
+      };
+    },
+    beginTick(tick) {
+      rig.signal = tick.signal;
+      rig.origin = tick.origin;
+      rig.replayAt = tick.origin;
+      rig.maxInternalCalls = tick.maxInternalCalls;
+      rig.failureCode = undefined;
+    },
+    clearFailure() {
+      rig.formAt = job.toolCalls.length;
+      rig.failureCode = undefined;
+    },
+    failureCode() {
+      return rig.failureCode;
+    },
+    get capabilities() {
+      return view().capabilities;
+    },
+    get config() {
+      return view().config;
+    },
+  };
+  return runtime;
+}
+
+/** One runtime per job. A new host is legal only after the previous signal parked. The first prepare wins. */
+export function programRuntimeOf(job: ProgrammaticJob, host: ProgramHost): ProgramRuntime {
+  const existing = runtimes.get(job);
+  if (existing !== undefined) {
+    if (existing.identity === host.identity) return existing.runtime;
+    const stale = existing.signal;
+    invariant(
+      stale != null && stale.aborted && stale.reason === "park",
+      "scheme-repl: ProgrammaticJob rebound to a different host",
+    );
+    runtimes.delete(job);
+  }
+  const runtime = runtimeFor(job, host);
+  runtimes.set(job, { identity: host.identity, signal: host.signal, runtime });
+  return runtime;
+}
+
+/** A second host reading the same job (the browser's replay) must not take the daemon's runtime. */
+export function detachedRuntime(job: ProgrammaticJob, host: ProgramHost): ProgramRuntime {
+  return runtimeFor(job, host);
+}
+
+export { type ProgramRuntime } from "./host.js";

package/src/source-fs.ts

@@ -0,0 +1,35 @@
+/**
+ * Disk `require` jail. Replay never imports this: it reads `job.modules`.
+ */
+import { readFile, realpath } from "node:fs/promises";
+import { join as posixJoin } from "node:path/posix";
+
+import { makeFsLoader, type Loader } from "@here.build/arrival-modules";
+import type { ProgrammaticJob } from "@inhuman.tools/harness-model";
+import { runInAction } from "mobx";
+
+export function programSourceLoader(root: string, job?: ProgrammaticJob): Loader {
+  return makeFsLoader({
+    async readFile(key: string) {
+      if (job !== undefined) {
+        const recorded = job.modules[key];
+        if (recorded !== undefined) return recorded;
+      }
+      const abs = posixJoin(root, key);
+      const realRoot = await realpath(root);
+      let real: string;
+      try {
+        real = await realpath(abs);
+      } catch {
+        throw new Error(`no such file: ${key}`);
+      }
+      const prefix = realRoot.endsWith("/") ? realRoot : `${realRoot}/`;
+      if (real !== realRoot && !real.startsWith(prefix)) {
+        throw new Error(`require path escapes program source root: ${key}`);
+      }
+      const text = await readFile(real, "utf8");
+      if (job !== undefined) runInAction(() => (job.modules[key] = text));
+      return text;
+    },
+  });
+}

package/src/source.ts

@@ -0,0 +1,78 @@
+/**
+ * Module `require` jail. Eval with `sourcePath` stays under the entry file's
+ * directory. Interactive `scheme_repl` / `scheme_watch` jail at the workspace
+ * (`host.root`). Skill inputs stay on licensed `read_file`.
+ */
+import { toJS, type SchemeValue } from "@here.build/arrival";
+import { makeFsLoader, type Loader } from "@here.build/arrival-modules";
+import type { ProgrammaticJob } from "@inhuman.tools/harness-model";
+
+export type ProgramSource = {
+  readonly source?: string;
+  readonly sourcePath?: string;
+};
+
+export function programSourceOf(raw: unknown, allow: boolean): ProgramSource {
+  if (!allow || raw === null || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const rec = raw as Record<string, unknown>;
+  const source = typeof rec.source === "string" && rec.source !== "" ? rec.source : undefined;
+  const sourcePath =
+    typeof rec.sourcePath === "string" && rec.sourcePath.trim() !== "" ? rec.sourcePath.trim() : undefined;
+  return { source, sourcePath };
+}
+
+function parentDir(path: string): string {
+  const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  if (slash <= 0) return slash === 0 ? path.slice(0, 1) : ".";
+  return path.slice(0, slash);
+}
+
+export function moduleRootOf(
+  sourcePath: string | undefined,
+  override?: string,
+  workspaceRoot?: string,
+): string | undefined {
+  if (override != null && override !== "") return override;
+  if (sourcePath != null && sourcePath !== "") return parentDir(sourcePath);
+  if (workspaceRoot != null && workspaceRoot !== "") return workspaceRoot;
+  return undefined;
+}
+
+/** Replay read. The live loader records the same key the first time it touches disk. */
+export function recordedModuleLoader(job: ProgrammaticJob): Loader {
+  return makeFsLoader({
+    readFile(key: string) {
+      const text = job.modules[key];
+      if (text === undefined) throw new Error(`replay: no recorded module ${key}`);
+      return text;
+    },
+  });
+}
+
+/** toJS of a dict or list is an egress proxy. structuredClone rejects proxies. */
+function plainData(value: unknown, seen = new WeakSet<object>()): unknown {
+  if (typeof value === "function") throw new Error("not json");
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) throw new Error("cycle");
+  seen.add(value);
+  if (Array.isArray(value)) return value.map((item) => plainData(item, seen));
+  const out: Record<string, unknown> = {};
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string") throw new Error("not json");
+    out[key] = plainData((value as Record<string, unknown>)[key], seen);
+  }
+  return out;
+}
+
+/** Objects/arrays become the additive `json` sibling. Scalars stay display-only. */
+export function structuredJson(value: SchemeValue): { json?: unknown; jsonError?: string } {
+  const js = toJS(value);
+  if (typeof js === "function") return { jsonError: "value is not JSON-compatible" };
+  if (js === null || typeof js !== "object") return {};
+  try {
+    const cloned: unknown = structuredClone(plainData(js));
+    return { json: cloned };
+  } catch {
+    return { jsonError: "value is not JSON-compatible" };
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.